244 static void pidff_set_envelope_report(struct pidff_device *pidff,  in pidff_set_envelope_report()  argument
247 	pidff->set_envelope[PID_EFFECT_BLOCK_INDEX].value[0] =  in pidff_set_envelope_report()
248 	    pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0];  in pidff_set_envelope_report()
250 	pidff->set_envelope[PID_ATTACK_LEVEL].value[0] =  in pidff_set_envelope_report()
253 			  pidff->set_envelope[PID_ATTACK_LEVEL].field);  in pidff_set_envelope_report()
254 	pidff->set_envelope[PID_FADE_LEVEL].value[0] =  in pidff_set_envelope_report()
257 			  pidff->set_envelope[PID_FADE_LEVEL].field);  in pidff_set_envelope_report()
259 	pidff->set_envelope[PID_ATTACK_TIME].value[0] = envelope->attack_length;  in pidff_set_envelope_report()
260 	pidff->set_envelope[PID_FADE_TIME].value[0] = envelope->fade_length;  in pidff_set_envelope_report()
262 	hid_dbg(pidff->hid, "attack %u => %d\n",  in pidff_set_envelope_report()
264 		pidff->set_envelope[PID_ATTACK_LEVEL].value[0]);  in pidff_set_envelope_report()
266 	hid_hw_request(pidff->hid, pidff->reports[PID_SET_ENVELOPE],  in pidff_set_envelope_report()
285 static void pidff_set_constant_force_report(struct pidff_device *pidff,  in pidff_set_constant_force_report()  argument
288 	pidff->set_constant[PID_EFFECT_BLOCK_INDEX].value[0] =  in pidff_set_constant_force_report()
289 		pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0];  in pidff_set_constant_force_report()
290 	pidff_set_signed(&pidff->set_constant[PID_MAGNITUDE],  in pidff_set_constant_force_report()
293 	hid_hw_request(pidff->hid, pidff->reports[PID_SET_CONSTANT],  in pidff_set_constant_force_report()
309 static void pidff_set_effect_report(struct pidff_device *pidff,  in pidff_set_effect_report()  argument
312 	pidff->set_effect[PID_EFFECT_BLOCK_INDEX].value[0] =  in pidff_set_effect_report()
313 		pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0];  in pidff_set_effect_report()
314 	pidff->set_effect_type->value[0] =  in pidff_set_effect_report()
315 		pidff->create_new_effect_type->value[0];  in pidff_set_effect_report()
316 	pidff->set_effect[PID_DURATION].value[0] = effect->replay.length;  in pidff_set_effect_report()
317 	pidff->set_effect[PID_TRIGGER_BUTTON].value[0] = effect->trigger.button;  in pidff_set_effect_report()
318 	pidff->set_effect[PID_TRIGGER_REPEAT_INT].value[0] =  in pidff_set_effect_report()
320 	pidff->set_effect[PID_GAIN].value[0] =  in pidff_set_effect_report()
321 		pidff->set_effect[PID_GAIN].field->logical_maximum;  in pidff_set_effect_report()
322 	pidff->set_effect[PID_DIRECTION_ENABLE].value[0] = 1;  in pidff_set_effect_report()
323 	pidff->effect_direction->value[0] =  in pidff_set_effect_report()
325 				pidff->effect_direction);  in pidff_set_effect_report()
326 	pidff->set_effect[PID_START_DELAY].value[0] = effect->replay.delay;  in pidff_set_effect_report()
328 	hid_hw_request(pidff->hid, pidff->reports[PID_SET_EFFECT],  in pidff_set_effect_report()
348 static void pidff_set_periodic_report(struct pidff_device *pidff,  in pidff_set_periodic_report()  argument
351 	pidff->set_periodic[PID_EFFECT_BLOCK_INDEX].value[0] =  in pidff_set_periodic_report()
352 		pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0];  in pidff_set_periodic_report()
353 	pidff_set_signed(&pidff->set_periodic[PID_MAGNITUDE],  in pidff_set_periodic_report()
355 	pidff_set_signed(&pidff->set_periodic[PID_OFFSET],  in pidff_set_periodic_report()
357 	pidff_set(&pidff->set_periodic[PID_PHASE], effect->u.periodic.phase);  in pidff_set_periodic_report()
358 	pidff->set_periodic[PID_PERIOD].value[0] = effect->u.periodic.period;  in pidff_set_periodic_report()
360 	hid_hw_request(pidff->hid, pidff->reports[PID_SET_PERIODIC],  in pidff_set_periodic_report()
380 static void pidff_set_condition_report(struct pidff_device *pidff,  in pidff_set_condition_report()  argument
385 	pidff->set_condition[PID_EFFECT_BLOCK_INDEX].value[0] =  in pidff_set_condition_report()
386 		pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0];  in pidff_set_condition_report()
389 		pidff->set_condition[PID_PARAM_BLOCK_OFFSET].value[0] = i;  in pidff_set_condition_report()
390 		pidff_set_signed(&pidff->set_condition[PID_CP_OFFSET],  in pidff_set_condition_report()
392 		pidff_set_signed(&pidff->set_condition[PID_POS_COEFFICIENT],  in pidff_set_condition_report()
394 		pidff_set_signed(&pidff->set_condition[PID_NEG_COEFFICIENT],  in pidff_set_condition_report()
396 		pidff_set(&pidff->set_condition[PID_POS_SATURATION],  in pidff_set_condition_report()
398 		pidff_set(&pidff->set_condition[PID_NEG_SATURATION],  in pidff_set_condition_report()
400 		pidff_set(&pidff->set_condition[PID_DEAD_BAND],  in pidff_set_condition_report()
402 		hid_hw_request(pidff->hid, pidff->reports[PID_SET_CONDITION],  in pidff_set_condition_report()
434 static void pidff_set_ramp_force_report(struct pidff_device *pidff,  in pidff_set_ramp_force_report()  argument
437 	pidff->set_ramp[PID_EFFECT_BLOCK_INDEX].value[0] =  in pidff_set_ramp_force_report()
438 		pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0];  in pidff_set_ramp_force_report()
439 	pidff_set_signed(&pidff->set_ramp[PID_RAMP_START],  in pidff_set_ramp_force_report()
441 	pidff_set_signed(&pidff->set_ramp[PID_RAMP_END],  in pidff_set_ramp_force_report()
443 	hid_hw_request(pidff->hid, pidff->reports[PID_SET_RAMP],  in pidff_set_ramp_force_report()
463 static int pidff_request_effect_upload(struct pidff_device *pidff, int efnum)  in pidff_request_effect_upload()  argument
467 	pidff->create_new_effect_type->value[0] = efnum;  in pidff_request_effect_upload()
468 	hid_hw_request(pidff->hid, pidff->reports[PID_CREATE_NEW_EFFECT],  in pidff_request_effect_upload()
470 	hid_dbg(pidff->hid, "create_new_effect sent, type: %d\n", efnum);  in pidff_request_effect_upload()
472 	pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] = 0;  in pidff_request_effect_upload()
473 	pidff->block_load_status->value[0] = 0;  in pidff_request_effect_upload()
474 	hid_hw_wait(pidff->hid);  in pidff_request_effect_upload()
477 		hid_dbg(pidff->hid, "pid_block_load requested\n");  in pidff_request_effect_upload()
478 		hid_hw_request(pidff->hid, pidff->reports[PID_BLOCK_LOAD],  in pidff_request_effect_upload()
480 		hid_hw_wait(pidff->hid);  in pidff_request_effect_upload()
481 		if (pidff->block_load_status->value[0] ==  in pidff_request_effect_upload()
482 		    pidff->status_id[PID_BLOCK_LOAD_SUCCESS]) {  in pidff_request_effect_upload()
483 			hid_dbg(pidff->hid, "device reported free memory: %d bytes\n",  in pidff_request_effect_upload()
484 				 pidff->block_load[PID_RAM_POOL_AVAILABLE].value ?  in pidff_request_effect_upload()
485 				 pidff->block_load[PID_RAM_POOL_AVAILABLE].value[0] : -1);  in pidff_request_effect_upload()
488 		if (pidff->block_load_status->value[0] ==  in pidff_request_effect_upload()
489 		    pidff->status_id[PID_BLOCK_LOAD_FULL]) {  in pidff_request_effect_upload()
490 			hid_dbg(pidff->hid, "not enough memory free: %d bytes\n",  in pidff_request_effect_upload()
491 				pidff->block_load[PID_RAM_POOL_AVAILABLE].value ?  in pidff_request_effect_upload()
492 				pidff->block_load[PID_RAM_POOL_AVAILABLE].value[0] : -1);  in pidff_request_effect_upload()
496 	hid_err(pidff->hid, "pid_block_load failed 60 times\n");  in pidff_request_effect_upload()
503 static void pidff_playback_pid(struct pidff_device *pidff, int pid_id, int n)  in pidff_playback_pid()  argument
505 	pidff->effect_operation[PID_EFFECT_BLOCK_INDEX].value[0] = pid_id;  in pidff_playback_pid()
508 		pidff->effect_operation_status->value[0] =  in pidff_playback_pid()
509 			pidff->operation_id[PID_EFFECT_STOP];  in pidff_playback_pid()
511 		pidff->effect_operation_status->value[0] =  in pidff_playback_pid()
512 			pidff->operation_id[PID_EFFECT_START];  in pidff_playback_pid()
513 		pidff->effect_operation[PID_LOOP_COUNT].value[0] = n;  in pidff_playback_pid()
516 	hid_hw_request(pidff->hid, pidff->reports[PID_EFFECT_OPERATION],  in pidff_playback_pid()
525 	struct pidff_device *pidff = dev->ff->private;  in pidff_playback()  local
527 	pidff_playback_pid(pidff, pidff->pid_id[effect_id], value);  in pidff_playback()
535 static void pidff_erase_pid(struct pidff_device *pidff, int pid_id)  in pidff_erase_pid()  argument
537 	pidff->block_free[PID_EFFECT_BLOCK_INDEX].value[0] = pid_id;  in pidff_erase_pid()
538 	hid_hw_request(pidff->hid, pidff->reports[PID_BLOCK_FREE],  in pidff_erase_pid()
547 	struct pidff_device *pidff = dev->ff->private;  in pidff_erase_effect()  local
548 	int pid_id = pidff->pid_id[effect_id];  in pidff_erase_effect()
550 	hid_dbg(pidff->hid, "starting to erase %d/%d\n",  in pidff_erase_effect()
551 		effect_id, pidff->pid_id[effect_id]);  in pidff_erase_effect()
554 	hid_hw_wait(pidff->hid);  in pidff_erase_effect()
555 	pidff_playback_pid(pidff, pid_id, 0);  in pidff_erase_effect()
556 	pidff_erase_pid(pidff, pid_id);  in pidff_erase_effect()
567 	struct pidff_device *pidff = dev->ff->private;  in pidff_upload_effect()  local
571 	pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] = 0;  in pidff_upload_effect()
573 		pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] =  in pidff_upload_effect()
574 			pidff->pid_id[effect->id];  in pidff_upload_effect()
580 			error = pidff_request_effect_upload(pidff,  in pidff_upload_effect()
581 					pidff->type_id[PID_CONSTANT]);  in pidff_upload_effect()
586 			pidff_set_effect_report(pidff, effect);  in pidff_upload_effect()
588 			pidff_set_constant_force_report(pidff, effect);  in pidff_upload_effect()
592 			pidff_set_envelope_report(pidff,  in pidff_upload_effect()
615 				hid_err(pidff->hid, "invalid waveform\n");  in pidff_upload_effect()
619 			error = pidff_request_effect_upload(pidff,  in pidff_upload_effect()
620 					pidff->type_id[type_id]);  in pidff_upload_effect()
625 			pidff_set_effect_report(pidff, effect);  in pidff_upload_effect()
627 			pidff_set_periodic_report(pidff, effect);  in pidff_upload_effect()
631 			pidff_set_envelope_report(pidff,  in pidff_upload_effect()
637 			error = pidff_request_effect_upload(pidff,  in pidff_upload_effect()
638 					pidff->type_id[PID_RAMP]);  in pidff_upload_effect()
643 			pidff_set_effect_report(pidff, effect);  in pidff_upload_effect()
645 			pidff_set_ramp_force_report(pidff, effect);  in pidff_upload_effect()
649 			pidff_set_envelope_report(pidff,  in pidff_upload_effect()
655 			error = pidff_request_effect_upload(pidff,  in pidff_upload_effect()
656 					pidff->type_id[PID_SPRING]);  in pidff_upload_effect()
661 			pidff_set_effect_report(pidff, effect);  in pidff_upload_effect()
663 			pidff_set_condition_report(pidff, effect);  in pidff_upload_effect()
668 			error = pidff_request_effect_upload(pidff,  in pidff_upload_effect()
669 					pidff->type_id[PID_FRICTION]);  in pidff_upload_effect()
674 			pidff_set_effect_report(pidff, effect);  in pidff_upload_effect()
676 			pidff_set_condition_report(pidff, effect);  in pidff_upload_effect()
681 			error = pidff_request_effect_upload(pidff,  in pidff_upload_effect()
682 					pidff->type_id[PID_DAMPER]);  in pidff_upload_effect()
687 			pidff_set_effect_report(pidff, effect);  in pidff_upload_effect()
689 			pidff_set_condition_report(pidff, effect);  in pidff_upload_effect()
694 			error = pidff_request_effect_upload(pidff,  in pidff_upload_effect()
695 					pidff->type_id[PID_INERTIA]);  in pidff_upload_effect()
700 			pidff_set_effect_report(pidff, effect);  in pidff_upload_effect()
702 			pidff_set_condition_report(pidff, effect);  in pidff_upload_effect()
706 		hid_err(pidff->hid, "invalid type\n");  in pidff_upload_effect()
711 		pidff->pid_id[effect->id] =  in pidff_upload_effect()
712 		    pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0];  in pidff_upload_effect()
714 	hid_dbg(pidff->hid, "uploaded\n");  in pidff_upload_effect()
724 	struct pidff_device *pidff = dev->ff->private;  in pidff_set_gain()  local
726 	pidff_set(&pidff->device_gain[PID_DEVICE_GAIN_FIELD], gain);  in pidff_set_gain()
727 	hid_hw_request(pidff->hid, pidff->reports[PID_DEVICE_GAIN],  in pidff_set_gain()
731 static void pidff_autocenter(struct pidff_device *pidff, u16 magnitude)  in pidff_autocenter()  argument
734 		pidff->block_load[PID_EFFECT_BLOCK_INDEX].field;  in pidff_autocenter()
737 		pidff_playback_pid(pidff, field->logical_minimum, 0);  in pidff_autocenter()
741 	pidff_playback_pid(pidff, field->logical_minimum, 1);  in pidff_autocenter()
743 	pidff->set_effect[PID_EFFECT_BLOCK_INDEX].value[0] =  in pidff_autocenter()
744 		pidff->block_load[PID_EFFECT_BLOCK_INDEX].field->logical_minimum;  in pidff_autocenter()
745 	pidff->set_effect_type->value[0] = pidff->type_id[PID_SPRING];  in pidff_autocenter()
746 	pidff->set_effect[PID_DURATION].value[0] = 0;  in pidff_autocenter()
747 	pidff->set_effect[PID_TRIGGER_BUTTON].value[0] = 0;  in pidff_autocenter()
748 	pidff->set_effect[PID_TRIGGER_REPEAT_INT].value[0] = 0;  in pidff_autocenter()
749 	pidff_set(&pidff->set_effect[PID_GAIN], magnitude);  in pidff_autocenter()
750 	pidff->set_effect[PID_DIRECTION_ENABLE].value[0] = 1;  in pidff_autocenter()
751 	pidff->set_effect[PID_START_DELAY].value[0] = 0;  in pidff_autocenter()
753 	hid_hw_request(pidff->hid, pidff->reports[PID_SET_EFFECT],  in pidff_autocenter()
762 	struct pidff_device *pidff = dev->ff->private;  in pidff_set_autocenter()  local
764 	pidff_autocenter(pidff, magnitude);  in pidff_set_autocenter()
825 			       struct pidff_device *pidff)  in pidff_find_reports()  argument
838 			pidff->reports[ret] = report;  in pidff_find_reports()
854 		if (ret != -1 && !pidff->reports[ret]) {  in pidff_find_reports()
858 			pidff->reports[ret] = report;  in pidff_find_reports()
866 static int pidff_reports_ok(struct pidff_device *pidff)  in pidff_reports_ok()  argument
871 		if (!pidff->reports[i]) {  in pidff_reports_ok()
872 			hid_dbg(pidff->hid, "%d missing\n", i);  in pidff_reports_ok()
926 	pidff_find_special_keys(pidff->keys, pidff->field, pidff_ ## name, \
932 static int pidff_find_special_fields(struct pidff_device *pidff)  in pidff_find_special_fields()  argument
934 	hid_dbg(pidff->hid, "finding special fields\n");  in pidff_find_special_fields()
936 	pidff->create_new_effect_type =  in pidff_find_special_fields()
937 		pidff_find_special_field(pidff->reports[PID_CREATE_NEW_EFFECT],  in pidff_find_special_fields()
939 	pidff->set_effect_type =  in pidff_find_special_fields()
940 		pidff_find_special_field(pidff->reports[PID_SET_EFFECT],  in pidff_find_special_fields()
942 	pidff->effect_direction =  in pidff_find_special_fields()
943 		pidff_find_special_field(pidff->reports[PID_SET_EFFECT],  in pidff_find_special_fields()
945 	pidff->device_control =  in pidff_find_special_fields()
946 		pidff_find_special_field(pidff->reports[PID_DEVICE_CONTROL],  in pidff_find_special_fields()
948 	pidff->block_load_status =  in pidff_find_special_fields()
949 		pidff_find_special_field(pidff->reports[PID_BLOCK_LOAD],  in pidff_find_special_fields()
951 	pidff->effect_operation_status =  in pidff_find_special_fields()
952 		pidff_find_special_field(pidff->reports[PID_EFFECT_OPERATION],  in pidff_find_special_fields()
955 	hid_dbg(pidff->hid, "search done\n");  in pidff_find_special_fields()
957 	if (!pidff->create_new_effect_type || !pidff->set_effect_type) {  in pidff_find_special_fields()
958 		hid_err(pidff->hid, "effect lists not found\n");  in pidff_find_special_fields()
962 	if (!pidff->effect_direction) {  in pidff_find_special_fields()
963 		hid_err(pidff->hid, "direction field not found\n");  in pidff_find_special_fields()
967 	if (!pidff->device_control) {  in pidff_find_special_fields()
968 		hid_err(pidff->hid, "device control field not found\n");  in pidff_find_special_fields()
972 	if (!pidff->block_load_status) {  in pidff_find_special_fields()
973 		hid_err(pidff->hid, "block load status field not found\n");  in pidff_find_special_fields()
977 	if (!pidff->effect_operation_status) {  in pidff_find_special_fields()
978 		hid_err(pidff->hid, "effect operation field not found\n");  in pidff_find_special_fields()
982 	pidff_find_special_keys(pidff->control_id, pidff->device_control,  in pidff_find_special_fields()
990 		hid_err(pidff->hid, "no effect types found\n");  in pidff_find_special_fields()
997 		hid_err(pidff->hid,  in pidff_find_special_fields()
1005 		hid_err(pidff->hid, "effect operation identifiers not found\n");  in pidff_find_special_fields()
1015 static int pidff_find_effects(struct pidff_device *pidff,  in pidff_find_effects()  argument
1021 		int pidff_type = pidff->type_id[i];  in pidff_find_effects()
1022 		if (pidff->set_effect_type->usage[pidff_type].hid !=  in pidff_find_effects()
1023 		    pidff->create_new_effect_type->usage[pidff_type].hid) {  in pidff_find_effects()
1024 			hid_err(pidff->hid,  in pidff_find_effects()
1030 	if (pidff->type_id[PID_CONSTANT])  in pidff_find_effects()
1032 	if (pidff->type_id[PID_RAMP])  in pidff_find_effects()
1034 	if (pidff->type_id[PID_SQUARE]) {  in pidff_find_effects()
1038 	if (pidff->type_id[PID_SINE]) {  in pidff_find_effects()
1042 	if (pidff->type_id[PID_TRIANGLE]) {  in pidff_find_effects()
1046 	if (pidff->type_id[PID_SAW_UP]) {  in pidff_find_effects()
1050 	if (pidff->type_id[PID_SAW_DOWN]) {  in pidff_find_effects()
1054 	if (pidff->type_id[PID_SPRING])  in pidff_find_effects()
1056 	if (pidff->type_id[PID_DAMPER])  in pidff_find_effects()
1058 	if (pidff->type_id[PID_INERTIA])  in pidff_find_effects()
1060 	if (pidff->type_id[PID_FRICTION])  in pidff_find_effects()
1068 	pidff_find_fields(pidff->name, pidff_ ## name, \
1069 		pidff->reports[report], \
1075 static int pidff_init_fields(struct pidff_device *pidff, struct input_dev *dev)  in pidff_init_fields()  argument
1080 		hid_err(pidff->hid, "unknown set_effect report layout\n");  in pidff_init_fields()
1085 	if (!pidff->block_load[PID_EFFECT_BLOCK_INDEX].value) {  in pidff_init_fields()
1086 		hid_err(pidff->hid, "unknown pid_block_load report layout\n");  in pidff_init_fields()
1091 		hid_err(pidff->hid, "unknown effect_operation report layout\n");  in pidff_init_fields()
1096 		hid_err(pidff->hid, "unknown pid_block_free report layout\n");  in pidff_init_fields()
1103 	if (pidff_find_special_fields(pidff) || pidff_find_effects(pidff, dev))  in pidff_init_fields()
1108 			hid_warn(pidff->hid,  in pidff_init_fields()
1111 			hid_warn(pidff->hid,  in pidff_init_fields()
1115 			hid_warn(pidff->hid,  in pidff_init_fields()
1121 		hid_warn(pidff->hid, "unknown constant effect layout\n");  in pidff_init_fields()
1127 		hid_warn(pidff->hid, "unknown ramp effect layout\n");  in pidff_init_fields()
1136 		hid_warn(pidff->hid, "unknown condition effect layout\n");  in pidff_init_fields()
1145 		hid_warn(pidff->hid, "unknown periodic effect layout\n");  in pidff_init_fields()
1160 static void pidff_reset(struct pidff_device *pidff)  in pidff_reset()  argument
1162 	struct hid_device *hid = pidff->hid;  in pidff_reset()
1165 	pidff->device_control->value[0] = pidff->control_id[PID_RESET];  in pidff_reset()
1167 	hid_hw_request(hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT);  in pidff_reset()
1169 	hid_hw_request(hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT);  in pidff_reset()
1172 	pidff->device_control->value[0] =  in pidff_reset()
1173 		pidff->control_id[PID_ENABLE_ACTUATORS];  in pidff_reset()
1174 	hid_hw_request(hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT);  in pidff_reset()
1178 	hid_hw_request(hid, pidff->reports[PID_POOL], HID_REQ_GET_REPORT);  in pidff_reset()
1181 	if (pidff->pool[PID_SIMULTANEOUS_MAX].value) {  in pidff_reset()
1182 		while (pidff->pool[PID_SIMULTANEOUS_MAX].value[0] < 2) {  in pidff_reset()
1184 				hid_warn(pidff->hid,  in pidff_reset()
1186 					 pidff->pool[PID_SIMULTANEOUS_MAX].value[0]);  in pidff_reset()
1189 			hid_dbg(pidff->hid, "pid_pool requested again\n");  in pidff_reset()
1190 			hid_hw_request(hid, pidff->reports[PID_POOL],  in pidff_reset()
1200 static int pidff_check_autocenter(struct pidff_device *pidff,  in pidff_check_autocenter()  argument
1213 	error = pidff_request_effect_upload(pidff, 1);  in pidff_check_autocenter()
1215 		hid_err(pidff->hid, "upload request failed\n");  in pidff_check_autocenter()
1219 	if (pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] ==  in pidff_check_autocenter()
1220 	    pidff->block_load[PID_EFFECT_BLOCK_INDEX].field->logical_minimum + 1) {  in pidff_check_autocenter()
1221 		pidff_autocenter(pidff, 0xffff);  in pidff_check_autocenter()
1224 		hid_notice(pidff->hid,  in pidff_check_autocenter()
1228 	pidff_erase_pid(pidff,  in pidff_check_autocenter()
1229 			pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0]);  in pidff_check_autocenter()
1240 	struct pidff_device *pidff;  in hid_pidff_init()  local
1255 	pidff = kzalloc(sizeof(*pidff), GFP_KERNEL);  in hid_pidff_init()
1256 	if (!pidff)  in hid_pidff_init()
1259 	pidff->hid = hid;  in hid_pidff_init()
1263 	pidff_find_reports(hid, HID_OUTPUT_REPORT, pidff);  in hid_pidff_init()
1264 	pidff_find_reports(hid, HID_FEATURE_REPORT, pidff);  in hid_pidff_init()
1266 	if (!pidff_reports_ok(pidff)) {  in hid_pidff_init()
1272 	error = pidff_init_fields(pidff, dev);  in hid_pidff_init()
1276 	pidff_reset(pidff);  in hid_pidff_init()
1279 		pidff_set(&pidff->device_gain[PID_DEVICE_GAIN_FIELD], 0xffff);  in hid_pidff_init()
1280 		hid_hw_request(hid, pidff->reports[PID_DEVICE_GAIN],  in hid_pidff_init()
1284 	error = pidff_check_autocenter(pidff, dev);  in hid_pidff_init()
1289 	    pidff->block_load[PID_EFFECT_BLOCK_INDEX].field->logical_maximum -  in hid_pidff_init()
1290 	    pidff->block_load[PID_EFFECT_BLOCK_INDEX].field->logical_minimum +  in hid_pidff_init()
1297 	if (pidff->pool[PID_SIMULTANEOUS_MAX].value)  in hid_pidff_init()
1299 			pidff->pool[PID_SIMULTANEOUS_MAX].value[0]);  in hid_pidff_init()
1301 	if (pidff->pool[PID_RAM_POOL_SIZE].value)  in hid_pidff_init()
1303 			pidff->pool[PID_RAM_POOL_SIZE].value[0]);  in hid_pidff_init()
1305 	if (pidff->pool[PID_DEVICE_MANAGED_POOL].value &&  in hid_pidff_init()
1306 	    pidff->pool[PID_DEVICE_MANAGED_POOL].value[0] == 0) {  in hid_pidff_init()
1317 	ff->private = pidff;  in hid_pidff_init()
1333 	kfree(pidff);  in hid_pidff_init()