Lines Matching +full:report +full:- +full:error
1 // SPDX-License-Identifier: GPL-2.0-or-later
25 /* Report usage table used to put reports into an array */
49 the only field in that report */
163 usage<->value pairs that pidff_usage values are */
194 return i * (field->logical_maximum - field->logical_minimum) / max + in pidff_rescale()
195 field->logical_minimum; in pidff_rescale()
199 * Scale a signed value in range -0x8000..0x7fff for the given field
204 0 ? i * field->logical_maximum / 0x7fff : i * in pidff_rescale_signed()
205 field->logical_minimum / -0x8000; in pidff_rescale_signed()
210 usage->value[0] = pidff_rescale(value, 0xffff, usage->field); in pidff_set()
211 pr_debug("calculated from %d to %d\n", value, usage->value[0]); in pidff_set()
216 if (usage->field->logical_minimum < 0) in pidff_set_signed()
217 usage->value[0] = pidff_rescale_signed(value, usage->field); in pidff_set_signed()
220 usage->value[0] = in pidff_set_signed()
221 pidff_rescale(-value, 0x8000, usage->field); in pidff_set_signed()
223 usage->value[0] = in pidff_set_signed()
224 pidff_rescale(value, 0x7fff, usage->field); in pidff_set_signed()
226 pr_debug("calculated from %d to %d\n", value, usage->value[0]); in pidff_set_signed()
230 * Send envelope report to the device
235 pidff->set_envelope[PID_EFFECT_BLOCK_INDEX].value[0] = in pidff_set_envelope_report()
236 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0]; in pidff_set_envelope_report()
238 pidff->set_envelope[PID_ATTACK_LEVEL].value[0] = in pidff_set_envelope_report()
239 pidff_rescale(envelope->attack_level > in pidff_set_envelope_report()
240 0x7fff ? 0x7fff : envelope->attack_level, 0x7fff, in pidff_set_envelope_report()
241 pidff->set_envelope[PID_ATTACK_LEVEL].field); in pidff_set_envelope_report()
242 pidff->set_envelope[PID_FADE_LEVEL].value[0] = in pidff_set_envelope_report()
243 pidff_rescale(envelope->fade_level > in pidff_set_envelope_report()
244 0x7fff ? 0x7fff : envelope->fade_level, 0x7fff, in pidff_set_envelope_report()
245 pidff->set_envelope[PID_FADE_LEVEL].field); in pidff_set_envelope_report()
247 pidff->set_envelope[PID_ATTACK_TIME].value[0] = envelope->attack_length; in pidff_set_envelope_report()
248 pidff->set_envelope[PID_FADE_TIME].value[0] = envelope->fade_length; in pidff_set_envelope_report()
250 hid_dbg(pidff->hid, "attack %u => %d\n", in pidff_set_envelope_report()
251 envelope->attack_level, in pidff_set_envelope_report()
252 pidff->set_envelope[PID_ATTACK_LEVEL].value[0]); in pidff_set_envelope_report()
254 hid_hw_request(pidff->hid, pidff->reports[PID_SET_ENVELOPE], in pidff_set_envelope_report()
264 return envelope->attack_level != old->attack_level || in pidff_needs_set_envelope()
265 envelope->fade_level != old->fade_level || in pidff_needs_set_envelope()
266 envelope->attack_length != old->attack_length || in pidff_needs_set_envelope()
267 envelope->fade_length != old->fade_length; in pidff_needs_set_envelope()
271 * Send constant force report to the device
276 pidff->set_constant[PID_EFFECT_BLOCK_INDEX].value[0] = in pidff_set_constant_force_report()
277 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0]; in pidff_set_constant_force_report()
278 pidff_set_signed(&pidff->set_constant[PID_MAGNITUDE], in pidff_set_constant_force_report()
279 effect->u.constant.level); in pidff_set_constant_force_report()
281 hid_hw_request(pidff->hid, pidff->reports[PID_SET_CONSTANT], in pidff_set_constant_force_report()
291 return effect->u.constant.level != old->u.constant.level; in pidff_needs_set_constant()
295 * Send set effect report to the device
300 pidff->set_effect[PID_EFFECT_BLOCK_INDEX].value[0] = in pidff_set_effect_report()
301 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0]; in pidff_set_effect_report()
302 pidff->set_effect_type->value[0] = in pidff_set_effect_report()
303 pidff->create_new_effect_type->value[0]; in pidff_set_effect_report()
304 pidff->set_effect[PID_DURATION].value[0] = effect->replay.length; in pidff_set_effect_report()
305 pidff->set_effect[PID_TRIGGER_BUTTON].value[0] = effect->trigger.button; in pidff_set_effect_report()
306 pidff->set_effect[PID_TRIGGER_REPEAT_INT].value[0] = in pidff_set_effect_report()
307 effect->trigger.interval; in pidff_set_effect_report()
308 pidff->set_effect[PID_GAIN].value[0] = in pidff_set_effect_report()
309 pidff->set_effect[PID_GAIN].field->logical_maximum; in pidff_set_effect_report()
310 pidff->set_effect[PID_DIRECTION_ENABLE].value[0] = 1; in pidff_set_effect_report()
311 pidff->effect_direction->value[0] = in pidff_set_effect_report()
312 pidff_rescale(effect->direction, 0xffff, in pidff_set_effect_report()
313 pidff->effect_direction); in pidff_set_effect_report()
314 pidff->set_effect[PID_START_DELAY].value[0] = effect->replay.delay; in pidff_set_effect_report()
316 hid_hw_request(pidff->hid, pidff->reports[PID_SET_EFFECT], in pidff_set_effect_report()
326 return effect->replay.length != old->replay.length || in pidff_needs_set_effect()
327 effect->trigger.interval != old->trigger.interval || in pidff_needs_set_effect()
328 effect->trigger.button != old->trigger.button || in pidff_needs_set_effect()
329 effect->direction != old->direction || in pidff_needs_set_effect()
330 effect->replay.delay != old->replay.delay; in pidff_needs_set_effect()
334 * Send periodic effect report to the device
339 pidff->set_periodic[PID_EFFECT_BLOCK_INDEX].value[0] = in pidff_set_periodic_report()
340 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0]; in pidff_set_periodic_report()
341 pidff_set_signed(&pidff->set_periodic[PID_MAGNITUDE], in pidff_set_periodic_report()
342 effect->u.periodic.magnitude); in pidff_set_periodic_report()
343 pidff_set_signed(&pidff->set_periodic[PID_OFFSET], in pidff_set_periodic_report()
344 effect->u.periodic.offset); in pidff_set_periodic_report()
345 pidff_set(&pidff->set_periodic[PID_PHASE], effect->u.periodic.phase); in pidff_set_periodic_report()
346 pidff->set_periodic[PID_PERIOD].value[0] = effect->u.periodic.period; in pidff_set_periodic_report()
348 hid_hw_request(pidff->hid, pidff->reports[PID_SET_PERIODIC], in pidff_set_periodic_report()
359 return effect->u.periodic.magnitude != old->u.periodic.magnitude || in pidff_needs_set_periodic()
360 effect->u.periodic.offset != old->u.periodic.offset || in pidff_needs_set_periodic()
361 effect->u.periodic.phase != old->u.periodic.phase || in pidff_needs_set_periodic()
362 effect->u.periodic.period != old->u.periodic.period; in pidff_needs_set_periodic()
373 pidff->set_condition[PID_EFFECT_BLOCK_INDEX].value[0] = in pidff_set_condition_report()
374 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0]; in pidff_set_condition_report()
377 pidff->set_condition[PID_PARAM_BLOCK_OFFSET].value[0] = i; in pidff_set_condition_report()
378 pidff_set_signed(&pidff->set_condition[PID_CP_OFFSET], in pidff_set_condition_report()
379 effect->u.condition[i].center); in pidff_set_condition_report()
380 pidff_set_signed(&pidff->set_condition[PID_POS_COEFFICIENT], in pidff_set_condition_report()
381 effect->u.condition[i].right_coeff); in pidff_set_condition_report()
382 pidff_set_signed(&pidff->set_condition[PID_NEG_COEFFICIENT], in pidff_set_condition_report()
383 effect->u.condition[i].left_coeff); in pidff_set_condition_report()
384 pidff_set(&pidff->set_condition[PID_POS_SATURATION], in pidff_set_condition_report()
385 effect->u.condition[i].right_saturation); in pidff_set_condition_report()
386 pidff_set(&pidff->set_condition[PID_NEG_SATURATION], in pidff_set_condition_report()
387 effect->u.condition[i].left_saturation); in pidff_set_condition_report()
388 pidff_set(&pidff->set_condition[PID_DEAD_BAND], in pidff_set_condition_report()
389 effect->u.condition[i].deadband); in pidff_set_condition_report()
390 hid_hw_request(pidff->hid, pidff->reports[PID_SET_CONDITION], in pidff_set_condition_report()
405 struct ff_condition_effect *cond = &effect->u.condition[i]; in pidff_needs_set_condition()
406 struct ff_condition_effect *old_cond = &old->u.condition[i]; in pidff_needs_set_condition()
408 ret |= cond->center != old_cond->center || in pidff_needs_set_condition()
409 cond->right_coeff != old_cond->right_coeff || in pidff_needs_set_condition()
410 cond->left_coeff != old_cond->left_coeff || in pidff_needs_set_condition()
411 cond->right_saturation != old_cond->right_saturation || in pidff_needs_set_condition()
412 cond->left_saturation != old_cond->left_saturation || in pidff_needs_set_condition()
413 cond->deadband != old_cond->deadband; in pidff_needs_set_condition()
420 * Send ramp force report to the device
425 pidff->set_ramp[PID_EFFECT_BLOCK_INDEX].value[0] = in pidff_set_ramp_force_report()
426 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0]; in pidff_set_ramp_force_report()
427 pidff_set_signed(&pidff->set_ramp[PID_RAMP_START], in pidff_set_ramp_force_report()
428 effect->u.ramp.start_level); in pidff_set_ramp_force_report()
429 pidff_set_signed(&pidff->set_ramp[PID_RAMP_END], in pidff_set_ramp_force_report()
430 effect->u.ramp.end_level); in pidff_set_ramp_force_report()
431 hid_hw_request(pidff->hid, pidff->reports[PID_SET_RAMP], in pidff_set_ramp_force_report()
440 return effect->u.ramp.start_level != old->u.ramp.start_level || in pidff_needs_set_ramp()
441 effect->u.ramp.end_level != old->u.ramp.end_level; in pidff_needs_set_ramp()
447 * Returns 0 if device reported success, -ENOSPC if the device reported memory
449 * still unsuccessful -EIO is returned.
455 pidff->create_new_effect_type->value[0] = efnum; in pidff_request_effect_upload()
456 hid_hw_request(pidff->hid, pidff->reports[PID_CREATE_NEW_EFFECT], in pidff_request_effect_upload()
458 hid_dbg(pidff->hid, "create_new_effect sent, type: %d\n", efnum); in pidff_request_effect_upload()
460 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] = 0; in pidff_request_effect_upload()
461 pidff->block_load_status->value[0] = 0; in pidff_request_effect_upload()
462 hid_hw_wait(pidff->hid); in pidff_request_effect_upload()
465 hid_dbg(pidff->hid, "pid_block_load requested\n"); in pidff_request_effect_upload()
466 hid_hw_request(pidff->hid, pidff->reports[PID_BLOCK_LOAD], in pidff_request_effect_upload()
468 hid_hw_wait(pidff->hid); in pidff_request_effect_upload()
469 if (pidff->block_load_status->value[0] == in pidff_request_effect_upload()
470 pidff->status_id[PID_BLOCK_LOAD_SUCCESS]) { in pidff_request_effect_upload()
471 hid_dbg(pidff->hid, "device reported free memory: %d bytes\n", in pidff_request_effect_upload()
472 pidff->block_load[PID_RAM_POOL_AVAILABLE].value ? in pidff_request_effect_upload()
473 pidff->block_load[PID_RAM_POOL_AVAILABLE].value[0] : -1); in pidff_request_effect_upload()
476 if (pidff->block_load_status->value[0] == in pidff_request_effect_upload()
477 pidff->status_id[PID_BLOCK_LOAD_FULL]) { in pidff_request_effect_upload()
478 hid_dbg(pidff->hid, "not enough memory free: %d bytes\n", in pidff_request_effect_upload()
479 pidff->block_load[PID_RAM_POOL_AVAILABLE].value ? in pidff_request_effect_upload()
480 pidff->block_load[PID_RAM_POOL_AVAILABLE].value[0] : -1); in pidff_request_effect_upload()
481 return -ENOSPC; in pidff_request_effect_upload()
484 hid_err(pidff->hid, "pid_block_load failed 60 times\n"); in pidff_request_effect_upload()
485 return -EIO; in pidff_request_effect_upload()
493 pidff->effect_operation[PID_EFFECT_BLOCK_INDEX].value[0] = pid_id; in pidff_playback_pid()
496 pidff->effect_operation_status->value[0] = in pidff_playback_pid()
497 pidff->operation_id[PID_EFFECT_STOP]; in pidff_playback_pid()
499 pidff->effect_operation_status->value[0] = in pidff_playback_pid()
500 pidff->operation_id[PID_EFFECT_START]; in pidff_playback_pid()
501 pidff->effect_operation[PID_LOOP_COUNT].value[0] = n; in pidff_playback_pid()
504 hid_hw_request(pidff->hid, pidff->reports[PID_EFFECT_OPERATION], in pidff_playback_pid()
513 struct pidff_device *pidff = dev->ff->private; in pidff_playback()
515 pidff_playback_pid(pidff, pidff->pid_id[effect_id], value); in pidff_playback()
525 pidff->block_free[PID_EFFECT_BLOCK_INDEX].value[0] = pid_id; in pidff_erase_pid()
526 hid_hw_request(pidff->hid, pidff->reports[PID_BLOCK_FREE], in pidff_erase_pid()
535 struct pidff_device *pidff = dev->ff->private; in pidff_erase_effect()
536 int pid_id = pidff->pid_id[effect_id]; in pidff_erase_effect()
538 hid_dbg(pidff->hid, "starting to erase %d/%d\n", in pidff_erase_effect()
539 effect_id, pidff->pid_id[effect_id]); in pidff_erase_effect()
542 hid_hw_wait(pidff->hid); in pidff_erase_effect()
555 struct pidff_device *pidff = dev->ff->private; in pidff_upload_effect()
557 int error; in pidff_upload_effect() local
559 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] = 0; in pidff_upload_effect()
561 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] = in pidff_upload_effect()
562 pidff->pid_id[effect->id]; in pidff_upload_effect()
565 switch (effect->type) { in pidff_upload_effect()
568 error = pidff_request_effect_upload(pidff, in pidff_upload_effect()
569 pidff->type_id[PID_CONSTANT]); in pidff_upload_effect()
570 if (error) in pidff_upload_effect()
571 return error; in pidff_upload_effect()
578 pidff_needs_set_envelope(&effect->u.constant.envelope, in pidff_upload_effect()
579 &old->u.constant.envelope)) in pidff_upload_effect()
581 &effect->u.constant.envelope); in pidff_upload_effect()
586 switch (effect->u.periodic.waveform) { in pidff_upload_effect()
603 hid_err(pidff->hid, "invalid waveform\n"); in pidff_upload_effect()
604 return -EINVAL; in pidff_upload_effect()
607 error = pidff_request_effect_upload(pidff, in pidff_upload_effect()
608 pidff->type_id[type_id]); in pidff_upload_effect()
609 if (error) in pidff_upload_effect()
610 return error; in pidff_upload_effect()
617 pidff_needs_set_envelope(&effect->u.periodic.envelope, in pidff_upload_effect()
618 &old->u.periodic.envelope)) in pidff_upload_effect()
620 &effect->u.periodic.envelope); in pidff_upload_effect()
625 error = pidff_request_effect_upload(pidff, in pidff_upload_effect()
626 pidff->type_id[PID_RAMP]); in pidff_upload_effect()
627 if (error) in pidff_upload_effect()
628 return error; in pidff_upload_effect()
635 pidff_needs_set_envelope(&effect->u.ramp.envelope, in pidff_upload_effect()
636 &old->u.ramp.envelope)) in pidff_upload_effect()
638 &effect->u.ramp.envelope); in pidff_upload_effect()
643 error = pidff_request_effect_upload(pidff, in pidff_upload_effect()
644 pidff->type_id[PID_SPRING]); in pidff_upload_effect()
645 if (error) in pidff_upload_effect()
646 return error; in pidff_upload_effect()
656 error = pidff_request_effect_upload(pidff, in pidff_upload_effect()
657 pidff->type_id[PID_FRICTION]); in pidff_upload_effect()
658 if (error) in pidff_upload_effect()
659 return error; in pidff_upload_effect()
669 error = pidff_request_effect_upload(pidff, in pidff_upload_effect()
670 pidff->type_id[PID_DAMPER]); in pidff_upload_effect()
671 if (error) in pidff_upload_effect()
672 return error; in pidff_upload_effect()
682 error = pidff_request_effect_upload(pidff, in pidff_upload_effect()
683 pidff->type_id[PID_INERTIA]); in pidff_upload_effect()
684 if (error) in pidff_upload_effect()
685 return error; in pidff_upload_effect()
694 hid_err(pidff->hid, "invalid type\n"); in pidff_upload_effect()
695 return -EINVAL; in pidff_upload_effect()
699 pidff->pid_id[effect->id] = in pidff_upload_effect()
700 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0]; in pidff_upload_effect()
702 hid_dbg(pidff->hid, "uploaded\n"); in pidff_upload_effect()
712 struct pidff_device *pidff = dev->ff->private; in pidff_set_gain()
714 pidff_set(&pidff->device_gain[PID_DEVICE_GAIN_FIELD], gain); in pidff_set_gain()
715 hid_hw_request(pidff->hid, pidff->reports[PID_DEVICE_GAIN], in pidff_set_gain()
722 pidff->block_load[PID_EFFECT_BLOCK_INDEX].field; in pidff_autocenter()
725 pidff_playback_pid(pidff, field->logical_minimum, 0); in pidff_autocenter()
729 pidff_playback_pid(pidff, field->logical_minimum, 1); in pidff_autocenter()
731 pidff->set_effect[PID_EFFECT_BLOCK_INDEX].value[0] = in pidff_autocenter()
732 pidff->block_load[PID_EFFECT_BLOCK_INDEX].field->logical_minimum; in pidff_autocenter()
733 pidff->set_effect_type->value[0] = pidff->type_id[PID_SPRING]; in pidff_autocenter()
734 pidff->set_effect[PID_DURATION].value[0] = 0; in pidff_autocenter()
735 pidff->set_effect[PID_TRIGGER_BUTTON].value[0] = 0; in pidff_autocenter()
736 pidff->set_effect[PID_TRIGGER_REPEAT_INT].value[0] = 0; in pidff_autocenter()
737 pidff_set(&pidff->set_effect[PID_GAIN], magnitude); in pidff_autocenter()
738 pidff->set_effect[PID_DIRECTION_ENABLE].value[0] = 1; in pidff_autocenter()
739 pidff->set_effect[PID_START_DELAY].value[0] = 0; in pidff_autocenter()
741 hid_hw_request(pidff->hid, pidff->reports[PID_SET_EFFECT], in pidff_autocenter()
750 struct pidff_device *pidff = dev->ff->private; in pidff_set_autocenter()
756 * Find fields from a report and fill a pidff_usage
759 struct hid_report *report, int count, int strict) in pidff_find_fields() argument
765 for (i = 0; i < report->maxfield; i++) { in pidff_find_fields()
766 if (report->field[i]->maxusage != in pidff_find_fields()
767 report->field[i]->report_count) { in pidff_find_fields()
771 for (j = 0; j < report->field[i]->maxusage; j++) { in pidff_find_fields()
772 if (report->field[i]->usage[j].hid == in pidff_find_fields()
774 pr_debug("found %d at %d->%d\n", in pidff_find_fields()
776 usage[k].field = report->field[i]; in pidff_find_fields()
778 &report->field[i]->value[j]; in pidff_find_fields()
788 return -1; in pidff_find_fields()
805 return -1; in pidff_check_usage()
809 * Find the reports and fill pidff->reports[]
815 struct hid_report *report; in pidff_find_reports() local
818 list_for_each_entry(report, in pidff_find_reports()
819 &hid->report_enum[report_type].report_list, list) { in pidff_find_reports()
820 if (report->maxfield < 1) in pidff_find_reports()
822 ret = pidff_check_usage(report->field[0]->logical); in pidff_find_reports()
823 if (ret != -1) { in pidff_find_reports()
824 hid_dbg(hid, "found usage 0x%02x from field->logical\n", in pidff_find_reports()
826 pidff->reports[ret] = report; in pidff_find_reports()
832 * different usages for the report and the field, in which in pidff_find_reports()
837 i = report->field[0]->usage[0].collection_index; in pidff_find_reports()
839 hid->collection[i - 1].type != HID_COLLECTION_LOGICAL) in pidff_find_reports()
841 ret = pidff_check_usage(hid->collection[i - 1].usage); in pidff_find_reports()
842 if (ret != -1 && !pidff->reports[ret]) { in pidff_find_reports()
846 pidff->reports[ret] = report; in pidff_find_reports()
859 if (!pidff->reports[i]) { in pidff_reports_ok()
860 hid_dbg(pidff->hid, "%d missing\n", i); in pidff_reports_ok()
869 * Find a field with a specific usage within a report
871 static struct hid_field *pidff_find_special_field(struct hid_report *report, in pidff_find_special_field() argument
876 for (i = 0; i < report->maxfield; i++) { in pidff_find_special_field()
877 if (report->field[i]->logical == (HID_UP_PID | usage) && in pidff_find_special_field()
878 report->field[i]->report_count > 0) { in pidff_find_special_field()
880 report->field[i]->logical_minimum == 1) in pidff_find_special_field()
881 return report->field[i]; in pidff_find_special_field()
892 * Fill a pidff->*_id struct table
902 for (j = 0; j < fld->maxusage; j++) { in pidff_find_special_keys()
903 if (fld->usage[j].hid == (HID_UP_PID | usagetable[i])) { in pidff_find_special_keys()
914 pidff_find_special_keys(pidff->keys, pidff->field, pidff_ ## name, \
922 hid_dbg(pidff->hid, "finding special fields\n"); in pidff_find_special_fields()
924 pidff->create_new_effect_type = in pidff_find_special_fields()
925 pidff_find_special_field(pidff->reports[PID_CREATE_NEW_EFFECT], in pidff_find_special_fields()
927 pidff->set_effect_type = in pidff_find_special_fields()
928 pidff_find_special_field(pidff->reports[PID_SET_EFFECT], in pidff_find_special_fields()
930 pidff->effect_direction = in pidff_find_special_fields()
931 pidff_find_special_field(pidff->reports[PID_SET_EFFECT], in pidff_find_special_fields()
933 pidff->device_control = in pidff_find_special_fields()
934 pidff_find_special_field(pidff->reports[PID_DEVICE_CONTROL], in pidff_find_special_fields()
936 pidff->block_load_status = in pidff_find_special_fields()
937 pidff_find_special_field(pidff->reports[PID_BLOCK_LOAD], in pidff_find_special_fields()
939 pidff->effect_operation_status = in pidff_find_special_fields()
940 pidff_find_special_field(pidff->reports[PID_EFFECT_OPERATION], in pidff_find_special_fields()
943 hid_dbg(pidff->hid, "search done\n"); in pidff_find_special_fields()
945 if (!pidff->create_new_effect_type || !pidff->set_effect_type) { in pidff_find_special_fields()
946 hid_err(pidff->hid, "effect lists not found\n"); in pidff_find_special_fields()
947 return -1; in pidff_find_special_fields()
950 if (!pidff->effect_direction) { in pidff_find_special_fields()
951 hid_err(pidff->hid, "direction field not found\n"); in pidff_find_special_fields()
952 return -1; in pidff_find_special_fields()
955 if (!pidff->device_control) { in pidff_find_special_fields()
956 hid_err(pidff->hid, "device control field not found\n"); in pidff_find_special_fields()
957 return -1; in pidff_find_special_fields()
960 if (!pidff->block_load_status) { in pidff_find_special_fields()
961 hid_err(pidff->hid, "block load status field not found\n"); in pidff_find_special_fields()
962 return -1; in pidff_find_special_fields()
965 if (!pidff->effect_operation_status) { in pidff_find_special_fields()
966 hid_err(pidff->hid, "effect operation field not found\n"); in pidff_find_special_fields()
967 return -1; in pidff_find_special_fields()
970 pidff_find_special_keys(pidff->control_id, pidff->device_control, in pidff_find_special_fields()
978 hid_err(pidff->hid, "no effect types found\n"); in pidff_find_special_fields()
979 return -1; in pidff_find_special_fields()
985 hid_err(pidff->hid, in pidff_find_special_fields()
987 return -1; in pidff_find_special_fields()
993 hid_err(pidff->hid, "effect operation identifiers not found\n"); in pidff_find_special_fields()
994 return -1; in pidff_find_special_fields()
1009 int pidff_type = pidff->type_id[i]; in pidff_find_effects()
1010 if (pidff->set_effect_type->usage[pidff_type].hid != in pidff_find_effects()
1011 pidff->create_new_effect_type->usage[pidff_type].hid) { in pidff_find_effects()
1012 hid_err(pidff->hid, in pidff_find_effects()
1014 return -1; in pidff_find_effects()
1018 if (pidff->type_id[PID_CONSTANT]) in pidff_find_effects()
1019 set_bit(FF_CONSTANT, dev->ffbit); in pidff_find_effects()
1020 if (pidff->type_id[PID_RAMP]) in pidff_find_effects()
1021 set_bit(FF_RAMP, dev->ffbit); in pidff_find_effects()
1022 if (pidff->type_id[PID_SQUARE]) { in pidff_find_effects()
1023 set_bit(FF_SQUARE, dev->ffbit); in pidff_find_effects()
1024 set_bit(FF_PERIODIC, dev->ffbit); in pidff_find_effects()
1026 if (pidff->type_id[PID_SINE]) { in pidff_find_effects()
1027 set_bit(FF_SINE, dev->ffbit); in pidff_find_effects()
1028 set_bit(FF_PERIODIC, dev->ffbit); in pidff_find_effects()
1030 if (pidff->type_id[PID_TRIANGLE]) { in pidff_find_effects()
1031 set_bit(FF_TRIANGLE, dev->ffbit); in pidff_find_effects()
1032 set_bit(FF_PERIODIC, dev->ffbit); in pidff_find_effects()
1034 if (pidff->type_id[PID_SAW_UP]) { in pidff_find_effects()
1035 set_bit(FF_SAW_UP, dev->ffbit); in pidff_find_effects()
1036 set_bit(FF_PERIODIC, dev->ffbit); in pidff_find_effects()
1038 if (pidff->type_id[PID_SAW_DOWN]) { in pidff_find_effects()
1039 set_bit(FF_SAW_DOWN, dev->ffbit); in pidff_find_effects()
1040 set_bit(FF_PERIODIC, dev->ffbit); in pidff_find_effects()
1042 if (pidff->type_id[PID_SPRING]) in pidff_find_effects()
1043 set_bit(FF_SPRING, dev->ffbit); in pidff_find_effects()
1044 if (pidff->type_id[PID_DAMPER]) in pidff_find_effects()
1045 set_bit(FF_DAMPER, dev->ffbit); in pidff_find_effects()
1046 if (pidff->type_id[PID_INERTIA]) in pidff_find_effects()
1047 set_bit(FF_INERTIA, dev->ffbit); in pidff_find_effects()
1048 if (pidff->type_id[PID_FRICTION]) in pidff_find_effects()
1049 set_bit(FF_FRICTION, dev->ffbit); in pidff_find_effects()
1055 #define PIDFF_FIND_FIELDS(name, report, strict) \ argument
1056 pidff_find_fields(pidff->name, pidff_ ## name, \
1057 pidff->reports[report], \
1068 hid_err(pidff->hid, "unknown set_effect report layout\n"); in pidff_init_fields()
1069 return -ENODEV; in pidff_init_fields()
1073 if (!pidff->block_load[PID_EFFECT_BLOCK_INDEX].value) { in pidff_init_fields()
1074 hid_err(pidff->hid, "unknown pid_block_load report layout\n"); in pidff_init_fields()
1075 return -ENODEV; in pidff_init_fields()
1079 hid_err(pidff->hid, "unknown effect_operation report layout\n"); in pidff_init_fields()
1080 return -ENODEV; in pidff_init_fields()
1084 hid_err(pidff->hid, "unknown pid_block_free report layout\n"); in pidff_init_fields()
1085 return -ENODEV; in pidff_init_fields()
1092 return -ENODEV; in pidff_init_fields()
1095 if (test_and_clear_bit(FF_CONSTANT, dev->ffbit)) in pidff_init_fields()
1096 hid_warn(pidff->hid, in pidff_init_fields()
1098 if (test_and_clear_bit(FF_RAMP, dev->ffbit)) in pidff_init_fields()
1099 hid_warn(pidff->hid, in pidff_init_fields()
1102 if (test_and_clear_bit(FF_PERIODIC, dev->ffbit)) in pidff_init_fields()
1103 hid_warn(pidff->hid, in pidff_init_fields()
1107 if (test_bit(FF_CONSTANT, dev->ffbit) && in pidff_init_fields()
1109 hid_warn(pidff->hid, "unknown constant effect layout\n"); in pidff_init_fields()
1110 clear_bit(FF_CONSTANT, dev->ffbit); in pidff_init_fields()
1113 if (test_bit(FF_RAMP, dev->ffbit) && in pidff_init_fields()
1115 hid_warn(pidff->hid, "unknown ramp effect layout\n"); in pidff_init_fields()
1116 clear_bit(FF_RAMP, dev->ffbit); in pidff_init_fields()
1119 if ((test_bit(FF_SPRING, dev->ffbit) || in pidff_init_fields()
1120 test_bit(FF_DAMPER, dev->ffbit) || in pidff_init_fields()
1121 test_bit(FF_FRICTION, dev->ffbit) || in pidff_init_fields()
1122 test_bit(FF_INERTIA, dev->ffbit)) && in pidff_init_fields()
1124 hid_warn(pidff->hid, "unknown condition effect layout\n"); in pidff_init_fields()
1125 clear_bit(FF_SPRING, dev->ffbit); in pidff_init_fields()
1126 clear_bit(FF_DAMPER, dev->ffbit); in pidff_init_fields()
1127 clear_bit(FF_FRICTION, dev->ffbit); in pidff_init_fields()
1128 clear_bit(FF_INERTIA, dev->ffbit); in pidff_init_fields()
1131 if (test_bit(FF_PERIODIC, dev->ffbit) && in pidff_init_fields()
1133 hid_warn(pidff->hid, "unknown periodic effect layout\n"); in pidff_init_fields()
1134 clear_bit(FF_PERIODIC, dev->ffbit); in pidff_init_fields()
1140 set_bit(FF_GAIN, dev->ffbit); in pidff_init_fields()
1150 struct hid_device *hid = pidff->hid; in pidff_reset()
1153 pidff->device_control->value[0] = pidff->control_id[PID_RESET]; in pidff_reset()
1155 hid_hw_request(hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT); in pidff_reset()
1157 hid_hw_request(hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT); in pidff_reset()
1160 pidff->device_control->value[0] = in pidff_reset()
1161 pidff->control_id[PID_ENABLE_ACTUATORS]; in pidff_reset()
1162 hid_hw_request(hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT); in pidff_reset()
1165 /* pool report is sometimes messed up, refetch it */ in pidff_reset()
1166 hid_hw_request(hid, pidff->reports[PID_POOL], HID_REQ_GET_REPORT); in pidff_reset()
1169 if (pidff->pool[PID_SIMULTANEOUS_MAX].value) { in pidff_reset()
1170 while (pidff->pool[PID_SIMULTANEOUS_MAX].value[0] < 2) { in pidff_reset()
1172 hid_warn(pidff->hid, in pidff_reset()
1174 pidff->pool[PID_SIMULTANEOUS_MAX].value[0]); in pidff_reset()
1177 hid_dbg(pidff->hid, "pid_pool requested again\n"); in pidff_reset()
1178 hid_hw_request(hid, pidff->reports[PID_POOL], in pidff_reset()
1191 int error; in pidff_check_autocenter() local
1198 * effect id is a built-in spring type effect used for autocenter in pidff_check_autocenter()
1201 error = pidff_request_effect_upload(pidff, 1); in pidff_check_autocenter()
1202 if (error) { in pidff_check_autocenter()
1203 hid_err(pidff->hid, "upload request failed\n"); in pidff_check_autocenter()
1204 return error; in pidff_check_autocenter()
1207 if (pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] == in pidff_check_autocenter()
1208 pidff->block_load[PID_EFFECT_BLOCK_INDEX].field->logical_minimum + 1) { in pidff_check_autocenter()
1210 set_bit(FF_AUTOCENTER, dev->ffbit); in pidff_check_autocenter()
1212 hid_notice(pidff->hid, in pidff_check_autocenter()
1217 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0]); in pidff_check_autocenter()
1229 struct hid_input *hidinput = list_entry(hid->inputs.next, in hid_pidff_init()
1231 struct input_dev *dev = hidinput->input; in hid_pidff_init()
1234 int error; in hid_pidff_init() local
1238 if (list_empty(&hid->report_enum[HID_OUTPUT_REPORT].report_list)) { in hid_pidff_init()
1239 hid_dbg(hid, "not a PID device, no output report\n"); in hid_pidff_init()
1240 return -ENODEV; in hid_pidff_init()
1245 return -ENOMEM; in hid_pidff_init()
1247 pidff->hid = hid; in hid_pidff_init()
1256 error = -ENODEV; in hid_pidff_init()
1260 error = pidff_init_fields(pidff, dev); in hid_pidff_init()
1261 if (error) in hid_pidff_init()
1266 if (test_bit(FF_GAIN, dev->ffbit)) { in hid_pidff_init()
1267 pidff_set(&pidff->device_gain[PID_DEVICE_GAIN_FIELD], 0xffff); in hid_pidff_init()
1268 hid_hw_request(hid, pidff->reports[PID_DEVICE_GAIN], in hid_pidff_init()
1272 error = pidff_check_autocenter(pidff, dev); in hid_pidff_init()
1273 if (error) in hid_pidff_init()
1277 pidff->block_load[PID_EFFECT_BLOCK_INDEX].field->logical_maximum - in hid_pidff_init()
1278 pidff->block_load[PID_EFFECT_BLOCK_INDEX].field->logical_minimum + in hid_pidff_init()
1285 if (pidff->pool[PID_SIMULTANEOUS_MAX].value) in hid_pidff_init()
1287 pidff->pool[PID_SIMULTANEOUS_MAX].value[0]); in hid_pidff_init()
1289 if (pidff->pool[PID_RAM_POOL_SIZE].value) in hid_pidff_init()
1291 pidff->pool[PID_RAM_POOL_SIZE].value[0]); in hid_pidff_init()
1293 if (pidff->pool[PID_DEVICE_MANAGED_POOL].value && in hid_pidff_init()
1294 pidff->pool[PID_DEVICE_MANAGED_POOL].value[0] == 0) { in hid_pidff_init()
1295 error = -EPERM; in hid_pidff_init()
1301 error = input_ff_create(dev, max_effects); in hid_pidff_init()
1302 if (error) in hid_pidff_init()
1305 ff = dev->ff; in hid_pidff_init()
1306 ff->private = pidff; in hid_pidff_init()
1307 ff->upload = pidff_upload_effect; in hid_pidff_init()
1308 ff->erase = pidff_erase_effect; in hid_pidff_init()
1309 ff->set_gain = pidff_set_gain; in hid_pidff_init()
1310 ff->set_autocenter = pidff_set_autocenter; in hid_pidff_init()
1311 ff->playback = pidff_playback; in hid_pidff_init()
1323 return error; in hid_pidff_init()