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