1325 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * Force feedback driver for USB HID PID compliant devices4 *5 * Copyright (c) 2005, 2006 Anssi Hannula <anssi.hannula@gmail.com>6 */7 8/*9 */10 11/* #define DEBUG */12 13#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt14 15#include <linux/input.h>16#include <linux/slab.h>17#include <linux/usb.h>18 19#include <linux/hid.h>20 21#include "usbhid.h"22 23#define PID_EFFECTS_MAX 6424 25/* Report usage table used to put reports into an array */26 27#define PID_SET_EFFECT 028#define PID_EFFECT_OPERATION 129#define PID_DEVICE_GAIN 230#define PID_POOL 331#define PID_BLOCK_LOAD 432#define PID_BLOCK_FREE 533#define PID_DEVICE_CONTROL 634#define PID_CREATE_NEW_EFFECT 735 36#define PID_REQUIRED_REPORTS 737 38#define PID_SET_ENVELOPE 839#define PID_SET_CONDITION 940#define PID_SET_PERIODIC 1041#define PID_SET_CONSTANT 1142#define PID_SET_RAMP 1243static const u8 pidff_reports[] = {44 0x21, 0x77, 0x7d, 0x7f, 0x89, 0x90, 0x96, 0xab,45 0x5a, 0x5f, 0x6e, 0x73, 0x7446};47 48/* device_control is really 0x95, but 0x96 specified as it is the usage of49the only field in that report */50 51/* Value usage tables used to put fields and values into arrays */52 53#define PID_EFFECT_BLOCK_INDEX 054 55#define PID_DURATION 156#define PID_GAIN 257#define PID_TRIGGER_BUTTON 358#define PID_TRIGGER_REPEAT_INT 459#define PID_DIRECTION_ENABLE 560#define PID_START_DELAY 661static const u8 pidff_set_effect[] = {62 0x22, 0x50, 0x52, 0x53, 0x54, 0x56, 0xa763};64 65#define PID_ATTACK_LEVEL 166#define PID_ATTACK_TIME 267#define PID_FADE_LEVEL 368#define PID_FADE_TIME 469static const u8 pidff_set_envelope[] = { 0x22, 0x5b, 0x5c, 0x5d, 0x5e };70 71#define PID_PARAM_BLOCK_OFFSET 172#define PID_CP_OFFSET 273#define PID_POS_COEFFICIENT 374#define PID_NEG_COEFFICIENT 475#define PID_POS_SATURATION 576#define PID_NEG_SATURATION 677#define PID_DEAD_BAND 778static const u8 pidff_set_condition[] = {79 0x22, 0x23, 0x60, 0x61, 0x62, 0x63, 0x64, 0x6580};81 82#define PID_MAGNITUDE 183#define PID_OFFSET 284#define PID_PHASE 385#define PID_PERIOD 486static const u8 pidff_set_periodic[] = { 0x22, 0x70, 0x6f, 0x71, 0x72 };87static const u8 pidff_set_constant[] = { 0x22, 0x70 };88 89#define PID_RAMP_START 190#define PID_RAMP_END 291static const u8 pidff_set_ramp[] = { 0x22, 0x75, 0x76 };92 93#define PID_RAM_POOL_AVAILABLE 194static const u8 pidff_block_load[] = { 0x22, 0xac };95 96#define PID_LOOP_COUNT 197static const u8 pidff_effect_operation[] = { 0x22, 0x7c };98 99static const u8 pidff_block_free[] = { 0x22 };100 101#define PID_DEVICE_GAIN_FIELD 0102static const u8 pidff_device_gain[] = { 0x7e };103 104#define PID_RAM_POOL_SIZE 0105#define PID_SIMULTANEOUS_MAX 1106#define PID_DEVICE_MANAGED_POOL 2107static const u8 pidff_pool[] = { 0x80, 0x83, 0xa9 };108 109/* Special field key tables used to put special field keys into arrays */110 111#define PID_ENABLE_ACTUATORS 0112#define PID_RESET 1113static const u8 pidff_device_control[] = { 0x97, 0x9a };114 115#define PID_CONSTANT 0116#define PID_RAMP 1117#define PID_SQUARE 2118#define PID_SINE 3119#define PID_TRIANGLE 4120#define PID_SAW_UP 5121#define PID_SAW_DOWN 6122#define PID_SPRING 7123#define PID_DAMPER 8124#define PID_INERTIA 9125#define PID_FRICTION 10126static const u8 pidff_effect_types[] = {127 0x26, 0x27, 0x30, 0x31, 0x32, 0x33, 0x34,128 0x40, 0x41, 0x42, 0x43129};130 131#define PID_BLOCK_LOAD_SUCCESS 0132#define PID_BLOCK_LOAD_FULL 1133static const u8 pidff_block_load_status[] = { 0x8c, 0x8d };134 135#define PID_EFFECT_START 0136#define PID_EFFECT_STOP 1137static const u8 pidff_effect_operation_status[] = { 0x79, 0x7b };138 139struct pidff_usage {140 struct hid_field *field;141 s32 *value;142};143 144struct pidff_device {145 struct hid_device *hid;146 147 struct hid_report *reports[sizeof(pidff_reports)];148 149 struct pidff_usage set_effect[sizeof(pidff_set_effect)];150 struct pidff_usage set_envelope[sizeof(pidff_set_envelope)];151 struct pidff_usage set_condition[sizeof(pidff_set_condition)];152 struct pidff_usage set_periodic[sizeof(pidff_set_periodic)];153 struct pidff_usage set_constant[sizeof(pidff_set_constant)];154 struct pidff_usage set_ramp[sizeof(pidff_set_ramp)];155 156 struct pidff_usage device_gain[sizeof(pidff_device_gain)];157 struct pidff_usage block_load[sizeof(pidff_block_load)];158 struct pidff_usage pool[sizeof(pidff_pool)];159 struct pidff_usage effect_operation[sizeof(pidff_effect_operation)];160 struct pidff_usage block_free[sizeof(pidff_block_free)];161 162 /* Special field is a field that is not composed of163 usage<->value pairs that pidff_usage values are */164 165 /* Special field in create_new_effect */166 struct hid_field *create_new_effect_type;167 168 /* Special fields in set_effect */169 struct hid_field *set_effect_type;170 struct hid_field *effect_direction;171 172 /* Special field in device_control */173 struct hid_field *device_control;174 175 /* Special field in block_load */176 struct hid_field *block_load_status;177 178 /* Special field in effect_operation */179 struct hid_field *effect_operation_status;180 181 int control_id[sizeof(pidff_device_control)];182 int type_id[sizeof(pidff_effect_types)];183 int status_id[sizeof(pidff_block_load_status)];184 int operation_id[sizeof(pidff_effect_operation_status)];185 186 int pid_id[PID_EFFECTS_MAX];187};188 189/*190 * Scale an unsigned value with range 0..max for the given field191 */192static int pidff_rescale(int i, int max, struct hid_field *field)193{194 return i * (field->logical_maximum - field->logical_minimum) / max +195 field->logical_minimum;196}197 198/*199 * Scale a signed value in range -0x8000..0x7fff for the given field200 */201static int pidff_rescale_signed(int i, struct hid_field *field)202{203 return i == 0 ? 0 : i >204 0 ? i * field->logical_maximum / 0x7fff : i *205 field->logical_minimum / -0x8000;206}207 208static void pidff_set(struct pidff_usage *usage, u16 value)209{210 usage->value[0] = pidff_rescale(value, 0xffff, usage->field);211 pr_debug("calculated from %d to %d\n", value, usage->value[0]);212}213 214static void pidff_set_signed(struct pidff_usage *usage, s16 value)215{216 if (usage->field->logical_minimum < 0)217 usage->value[0] = pidff_rescale_signed(value, usage->field);218 else {219 if (value < 0)220 usage->value[0] =221 pidff_rescale(-value, 0x8000, usage->field);222 else223 usage->value[0] =224 pidff_rescale(value, 0x7fff, usage->field);225 }226 pr_debug("calculated from %d to %d\n", value, usage->value[0]);227}228 229/*230 * Send envelope report to the device231 */232static void pidff_set_envelope_report(struct pidff_device *pidff,233 struct ff_envelope *envelope)234{235 pidff->set_envelope[PID_EFFECT_BLOCK_INDEX].value[0] =236 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0];237 238 pidff->set_envelope[PID_ATTACK_LEVEL].value[0] =239 pidff_rescale(envelope->attack_level >240 0x7fff ? 0x7fff : envelope->attack_level, 0x7fff,241 pidff->set_envelope[PID_ATTACK_LEVEL].field);242 pidff->set_envelope[PID_FADE_LEVEL].value[0] =243 pidff_rescale(envelope->fade_level >244 0x7fff ? 0x7fff : envelope->fade_level, 0x7fff,245 pidff->set_envelope[PID_FADE_LEVEL].field);246 247 pidff->set_envelope[PID_ATTACK_TIME].value[0] = envelope->attack_length;248 pidff->set_envelope[PID_FADE_TIME].value[0] = envelope->fade_length;249 250 hid_dbg(pidff->hid, "attack %u => %d\n",251 envelope->attack_level,252 pidff->set_envelope[PID_ATTACK_LEVEL].value[0]);253 254 hid_hw_request(pidff->hid, pidff->reports[PID_SET_ENVELOPE],255 HID_REQ_SET_REPORT);256}257 258/*259 * Test if the new envelope differs from old one260 */261static int pidff_needs_set_envelope(struct ff_envelope *envelope,262 struct ff_envelope *old)263{264 return envelope->attack_level != old->attack_level ||265 envelope->fade_level != old->fade_level ||266 envelope->attack_length != old->attack_length ||267 envelope->fade_length != old->fade_length;268}269 270/*271 * Send constant force report to the device272 */273static void pidff_set_constant_force_report(struct pidff_device *pidff,274 struct ff_effect *effect)275{276 pidff->set_constant[PID_EFFECT_BLOCK_INDEX].value[0] =277 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0];278 pidff_set_signed(&pidff->set_constant[PID_MAGNITUDE],279 effect->u.constant.level);280 281 hid_hw_request(pidff->hid, pidff->reports[PID_SET_CONSTANT],282 HID_REQ_SET_REPORT);283}284 285/*286 * Test if the constant parameters have changed between effects287 */288static int pidff_needs_set_constant(struct ff_effect *effect,289 struct ff_effect *old)290{291 return effect->u.constant.level != old->u.constant.level;292}293 294/*295 * Send set effect report to the device296 */297static void pidff_set_effect_report(struct pidff_device *pidff,298 struct ff_effect *effect)299{300 pidff->set_effect[PID_EFFECT_BLOCK_INDEX].value[0] =301 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0];302 pidff->set_effect_type->value[0] =303 pidff->create_new_effect_type->value[0];304 pidff->set_effect[PID_DURATION].value[0] = effect->replay.length;305 pidff->set_effect[PID_TRIGGER_BUTTON].value[0] = effect->trigger.button;306 pidff->set_effect[PID_TRIGGER_REPEAT_INT].value[0] =307 effect->trigger.interval;308 pidff->set_effect[PID_GAIN].value[0] =309 pidff->set_effect[PID_GAIN].field->logical_maximum;310 pidff->set_effect[PID_DIRECTION_ENABLE].value[0] = 1;311 pidff->effect_direction->value[0] =312 pidff_rescale(effect->direction, 0xffff,313 pidff->effect_direction);314 pidff->set_effect[PID_START_DELAY].value[0] = effect->replay.delay;315 316 hid_hw_request(pidff->hid, pidff->reports[PID_SET_EFFECT],317 HID_REQ_SET_REPORT);318}319 320/*321 * Test if the values used in set_effect have changed322 */323static int pidff_needs_set_effect(struct ff_effect *effect,324 struct ff_effect *old)325{326 return effect->replay.length != old->replay.length ||327 effect->trigger.interval != old->trigger.interval ||328 effect->trigger.button != old->trigger.button ||329 effect->direction != old->direction ||330 effect->replay.delay != old->replay.delay;331}332 333/*334 * Send periodic effect report to the device335 */336static void pidff_set_periodic_report(struct pidff_device *pidff,337 struct ff_effect *effect)338{339 pidff->set_periodic[PID_EFFECT_BLOCK_INDEX].value[0] =340 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0];341 pidff_set_signed(&pidff->set_periodic[PID_MAGNITUDE],342 effect->u.periodic.magnitude);343 pidff_set_signed(&pidff->set_periodic[PID_OFFSET],344 effect->u.periodic.offset);345 pidff_set(&pidff->set_periodic[PID_PHASE], effect->u.periodic.phase);346 pidff->set_periodic[PID_PERIOD].value[0] = effect->u.periodic.period;347 348 hid_hw_request(pidff->hid, pidff->reports[PID_SET_PERIODIC],349 HID_REQ_SET_REPORT);350 351}352 353/*354 * Test if periodic effect parameters have changed355 */356static int pidff_needs_set_periodic(struct ff_effect *effect,357 struct ff_effect *old)358{359 return effect->u.periodic.magnitude != old->u.periodic.magnitude ||360 effect->u.periodic.offset != old->u.periodic.offset ||361 effect->u.periodic.phase != old->u.periodic.phase ||362 effect->u.periodic.period != old->u.periodic.period;363}364 365/*366 * Send condition effect reports to the device367 */368static void pidff_set_condition_report(struct pidff_device *pidff,369 struct ff_effect *effect)370{371 int i;372 373 pidff->set_condition[PID_EFFECT_BLOCK_INDEX].value[0] =374 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0];375 376 for (i = 0; i < 2; i++) {377 pidff->set_condition[PID_PARAM_BLOCK_OFFSET].value[0] = i;378 pidff_set_signed(&pidff->set_condition[PID_CP_OFFSET],379 effect->u.condition[i].center);380 pidff_set_signed(&pidff->set_condition[PID_POS_COEFFICIENT],381 effect->u.condition[i].right_coeff);382 pidff_set_signed(&pidff->set_condition[PID_NEG_COEFFICIENT],383 effect->u.condition[i].left_coeff);384 pidff_set(&pidff->set_condition[PID_POS_SATURATION],385 effect->u.condition[i].right_saturation);386 pidff_set(&pidff->set_condition[PID_NEG_SATURATION],387 effect->u.condition[i].left_saturation);388 pidff_set(&pidff->set_condition[PID_DEAD_BAND],389 effect->u.condition[i].deadband);390 hid_hw_request(pidff->hid, pidff->reports[PID_SET_CONDITION],391 HID_REQ_SET_REPORT);392 }393}394 395/*396 * Test if condition effect parameters have changed397 */398static int pidff_needs_set_condition(struct ff_effect *effect,399 struct ff_effect *old)400{401 int i;402 int ret = 0;403 404 for (i = 0; i < 2; i++) {405 struct ff_condition_effect *cond = &effect->u.condition[i];406 struct ff_condition_effect *old_cond = &old->u.condition[i];407 408 ret |= cond->center != old_cond->center ||409 cond->right_coeff != old_cond->right_coeff ||410 cond->left_coeff != old_cond->left_coeff ||411 cond->right_saturation != old_cond->right_saturation ||412 cond->left_saturation != old_cond->left_saturation ||413 cond->deadband != old_cond->deadband;414 }415 416 return ret;417}418 419/*420 * Send ramp force report to the device421 */422static void pidff_set_ramp_force_report(struct pidff_device *pidff,423 struct ff_effect *effect)424{425 pidff->set_ramp[PID_EFFECT_BLOCK_INDEX].value[0] =426 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0];427 pidff_set_signed(&pidff->set_ramp[PID_RAMP_START],428 effect->u.ramp.start_level);429 pidff_set_signed(&pidff->set_ramp[PID_RAMP_END],430 effect->u.ramp.end_level);431 hid_hw_request(pidff->hid, pidff->reports[PID_SET_RAMP],432 HID_REQ_SET_REPORT);433}434 435/*436 * Test if ramp force parameters have changed437 */438static int pidff_needs_set_ramp(struct ff_effect *effect, struct ff_effect *old)439{440 return effect->u.ramp.start_level != old->u.ramp.start_level ||441 effect->u.ramp.end_level != old->u.ramp.end_level;442}443 444/*445 * Send a request for effect upload to the device446 *447 * Returns 0 if device reported success, -ENOSPC if the device reported memory448 * is full. Upon unknown response the function will retry for 60 times, if449 * still unsuccessful -EIO is returned.450 */451static int pidff_request_effect_upload(struct pidff_device *pidff, int efnum)452{453 int j;454 455 pidff->create_new_effect_type->value[0] = efnum;456 hid_hw_request(pidff->hid, pidff->reports[PID_CREATE_NEW_EFFECT],457 HID_REQ_SET_REPORT);458 hid_dbg(pidff->hid, "create_new_effect sent, type: %d\n", efnum);459 460 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] = 0;461 pidff->block_load_status->value[0] = 0;462 hid_hw_wait(pidff->hid);463 464 for (j = 0; j < 60; j++) {465 hid_dbg(pidff->hid, "pid_block_load requested\n");466 hid_hw_request(pidff->hid, pidff->reports[PID_BLOCK_LOAD],467 HID_REQ_GET_REPORT);468 hid_hw_wait(pidff->hid);469 if (pidff->block_load_status->value[0] ==470 pidff->status_id[PID_BLOCK_LOAD_SUCCESS]) {471 hid_dbg(pidff->hid, "device reported free memory: %d bytes\n",472 pidff->block_load[PID_RAM_POOL_AVAILABLE].value ?473 pidff->block_load[PID_RAM_POOL_AVAILABLE].value[0] : -1);474 return 0;475 }476 if (pidff->block_load_status->value[0] ==477 pidff->status_id[PID_BLOCK_LOAD_FULL]) {478 hid_dbg(pidff->hid, "not enough memory free: %d bytes\n",479 pidff->block_load[PID_RAM_POOL_AVAILABLE].value ?480 pidff->block_load[PID_RAM_POOL_AVAILABLE].value[0] : -1);481 return -ENOSPC;482 }483 }484 hid_err(pidff->hid, "pid_block_load failed 60 times\n");485 return -EIO;486}487 488/*489 * Play the effect with PID id n times490 */491static void pidff_playback_pid(struct pidff_device *pidff, int pid_id, int n)492{493 pidff->effect_operation[PID_EFFECT_BLOCK_INDEX].value[0] = pid_id;494 495 if (n == 0) {496 pidff->effect_operation_status->value[0] =497 pidff->operation_id[PID_EFFECT_STOP];498 } else {499 pidff->effect_operation_status->value[0] =500 pidff->operation_id[PID_EFFECT_START];501 pidff->effect_operation[PID_LOOP_COUNT].value[0] = n;502 }503 504 hid_hw_request(pidff->hid, pidff->reports[PID_EFFECT_OPERATION],505 HID_REQ_SET_REPORT);506}507 508/*509 * Play the effect with effect id @effect_id for @value times510 */511static int pidff_playback(struct input_dev *dev, int effect_id, int value)512{513 struct pidff_device *pidff = dev->ff->private;514 515 pidff_playback_pid(pidff, pidff->pid_id[effect_id], value);516 517 return 0;518}519 520/*521 * Erase effect with PID id522 */523static void pidff_erase_pid(struct pidff_device *pidff, int pid_id)524{525 pidff->block_free[PID_EFFECT_BLOCK_INDEX].value[0] = pid_id;526 hid_hw_request(pidff->hid, pidff->reports[PID_BLOCK_FREE],527 HID_REQ_SET_REPORT);528}529 530/*531 * Stop and erase effect with effect_id532 */533static int pidff_erase_effect(struct input_dev *dev, int effect_id)534{535 struct pidff_device *pidff = dev->ff->private;536 int pid_id = pidff->pid_id[effect_id];537 538 hid_dbg(pidff->hid, "starting to erase %d/%d\n",539 effect_id, pidff->pid_id[effect_id]);540 /* Wait for the queue to clear. We do not want a full fifo to541 prevent the effect removal. */542 hid_hw_wait(pidff->hid);543 pidff_playback_pid(pidff, pid_id, 0);544 pidff_erase_pid(pidff, pid_id);545 546 return 0;547}548 549/*550 * Effect upload handler551 */552static int pidff_upload_effect(struct input_dev *dev, struct ff_effect *effect,553 struct ff_effect *old)554{555 struct pidff_device *pidff = dev->ff->private;556 int type_id;557 int error;558 559 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] = 0;560 if (old) {561 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] =562 pidff->pid_id[effect->id];563 }564 565 switch (effect->type) {566 case FF_CONSTANT:567 if (!old) {568 error = pidff_request_effect_upload(pidff,569 pidff->type_id[PID_CONSTANT]);570 if (error)571 return error;572 }573 if (!old || pidff_needs_set_effect(effect, old))574 pidff_set_effect_report(pidff, effect);575 if (!old || pidff_needs_set_constant(effect, old))576 pidff_set_constant_force_report(pidff, effect);577 if (!old ||578 pidff_needs_set_envelope(&effect->u.constant.envelope,579 &old->u.constant.envelope))580 pidff_set_envelope_report(pidff,581 &effect->u.constant.envelope);582 break;583 584 case FF_PERIODIC:585 if (!old) {586 switch (effect->u.periodic.waveform) {587 case FF_SQUARE:588 type_id = PID_SQUARE;589 break;590 case FF_TRIANGLE:591 type_id = PID_TRIANGLE;592 break;593 case FF_SINE:594 type_id = PID_SINE;595 break;596 case FF_SAW_UP:597 type_id = PID_SAW_UP;598 break;599 case FF_SAW_DOWN:600 type_id = PID_SAW_DOWN;601 break;602 default:603 hid_err(pidff->hid, "invalid waveform\n");604 return -EINVAL;605 }606 607 error = pidff_request_effect_upload(pidff,608 pidff->type_id[type_id]);609 if (error)610 return error;611 }612 if (!old || pidff_needs_set_effect(effect, old))613 pidff_set_effect_report(pidff, effect);614 if (!old || pidff_needs_set_periodic(effect, old))615 pidff_set_periodic_report(pidff, effect);616 if (!old ||617 pidff_needs_set_envelope(&effect->u.periodic.envelope,618 &old->u.periodic.envelope))619 pidff_set_envelope_report(pidff,620 &effect->u.periodic.envelope);621 break;622 623 case FF_RAMP:624 if (!old) {625 error = pidff_request_effect_upload(pidff,626 pidff->type_id[PID_RAMP]);627 if (error)628 return error;629 }630 if (!old || pidff_needs_set_effect(effect, old))631 pidff_set_effect_report(pidff, effect);632 if (!old || pidff_needs_set_ramp(effect, old))633 pidff_set_ramp_force_report(pidff, effect);634 if (!old ||635 pidff_needs_set_envelope(&effect->u.ramp.envelope,636 &old->u.ramp.envelope))637 pidff_set_envelope_report(pidff,638 &effect->u.ramp.envelope);639 break;640 641 case FF_SPRING:642 if (!old) {643 error = pidff_request_effect_upload(pidff,644 pidff->type_id[PID_SPRING]);645 if (error)646 return error;647 }648 if (!old || pidff_needs_set_effect(effect, old))649 pidff_set_effect_report(pidff, effect);650 if (!old || pidff_needs_set_condition(effect, old))651 pidff_set_condition_report(pidff, effect);652 break;653 654 case FF_FRICTION:655 if (!old) {656 error = pidff_request_effect_upload(pidff,657 pidff->type_id[PID_FRICTION]);658 if (error)659 return error;660 }661 if (!old || pidff_needs_set_effect(effect, old))662 pidff_set_effect_report(pidff, effect);663 if (!old || pidff_needs_set_condition(effect, old))664 pidff_set_condition_report(pidff, effect);665 break;666 667 case FF_DAMPER:668 if (!old) {669 error = pidff_request_effect_upload(pidff,670 pidff->type_id[PID_DAMPER]);671 if (error)672 return error;673 }674 if (!old || pidff_needs_set_effect(effect, old))675 pidff_set_effect_report(pidff, effect);676 if (!old || pidff_needs_set_condition(effect, old))677 pidff_set_condition_report(pidff, effect);678 break;679 680 case FF_INERTIA:681 if (!old) {682 error = pidff_request_effect_upload(pidff,683 pidff->type_id[PID_INERTIA]);684 if (error)685 return error;686 }687 if (!old || pidff_needs_set_effect(effect, old))688 pidff_set_effect_report(pidff, effect);689 if (!old || pidff_needs_set_condition(effect, old))690 pidff_set_condition_report(pidff, effect);691 break;692 693 default:694 hid_err(pidff->hid, "invalid type\n");695 return -EINVAL;696 }697 698 if (!old)699 pidff->pid_id[effect->id] =700 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0];701 702 hid_dbg(pidff->hid, "uploaded\n");703 704 return 0;705}706 707/*708 * set_gain() handler709 */710static void pidff_set_gain(struct input_dev *dev, u16 gain)711{712 struct pidff_device *pidff = dev->ff->private;713 714 pidff_set(&pidff->device_gain[PID_DEVICE_GAIN_FIELD], gain);715 hid_hw_request(pidff->hid, pidff->reports[PID_DEVICE_GAIN],716 HID_REQ_SET_REPORT);717}718 719static void pidff_autocenter(struct pidff_device *pidff, u16 magnitude)720{721 struct hid_field *field =722 pidff->block_load[PID_EFFECT_BLOCK_INDEX].field;723 724 if (!magnitude) {725 pidff_playback_pid(pidff, field->logical_minimum, 0);726 return;727 }728 729 pidff_playback_pid(pidff, field->logical_minimum, 1);730 731 pidff->set_effect[PID_EFFECT_BLOCK_INDEX].value[0] =732 pidff->block_load[PID_EFFECT_BLOCK_INDEX].field->logical_minimum;733 pidff->set_effect_type->value[0] = pidff->type_id[PID_SPRING];734 pidff->set_effect[PID_DURATION].value[0] = 0;735 pidff->set_effect[PID_TRIGGER_BUTTON].value[0] = 0;736 pidff->set_effect[PID_TRIGGER_REPEAT_INT].value[0] = 0;737 pidff_set(&pidff->set_effect[PID_GAIN], magnitude);738 pidff->set_effect[PID_DIRECTION_ENABLE].value[0] = 1;739 pidff->set_effect[PID_START_DELAY].value[0] = 0;740 741 hid_hw_request(pidff->hid, pidff->reports[PID_SET_EFFECT],742 HID_REQ_SET_REPORT);743}744 745/*746 * pidff_set_autocenter() handler747 */748static void pidff_set_autocenter(struct input_dev *dev, u16 magnitude)749{750 struct pidff_device *pidff = dev->ff->private;751 752 pidff_autocenter(pidff, magnitude);753}754 755/*756 * Find fields from a report and fill a pidff_usage757 */758static int pidff_find_fields(struct pidff_usage *usage, const u8 *table,759 struct hid_report *report, int count, int strict)760{761 int i, j, k, found;762 763 for (k = 0; k < count; k++) {764 found = 0;765 for (i = 0; i < report->maxfield; i++) {766 if (report->field[i]->maxusage !=767 report->field[i]->report_count) {768 pr_debug("maxusage and report_count do not match, skipping\n");769 continue;770 }771 for (j = 0; j < report->field[i]->maxusage; j++) {772 if (report->field[i]->usage[j].hid ==773 (HID_UP_PID | table[k])) {774 pr_debug("found %d at %d->%d\n",775 k, i, j);776 usage[k].field = report->field[i];777 usage[k].value =778 &report->field[i]->value[j];779 found = 1;780 break;781 }782 }783 if (found)784 break;785 }786 if (!found && strict) {787 pr_debug("failed to locate %d\n", k);788 return -1;789 }790 }791 return 0;792}793 794/*795 * Return index into pidff_reports for the given usage796 */797static int pidff_check_usage(int usage)798{799 int i;800 801 for (i = 0; i < sizeof(pidff_reports); i++)802 if (usage == (HID_UP_PID | pidff_reports[i]))803 return i;804 805 return -1;806}807 808/*809 * Find the reports and fill pidff->reports[]810 * report_type specifies either OUTPUT or FEATURE reports811 */812static void pidff_find_reports(struct hid_device *hid, int report_type,813 struct pidff_device *pidff)814{815 struct hid_report *report;816 int i, ret;817 818 list_for_each_entry(report,819 &hid->report_enum[report_type].report_list, list) {820 if (report->maxfield < 1)821 continue;822 ret = pidff_check_usage(report->field[0]->logical);823 if (ret != -1) {824 hid_dbg(hid, "found usage 0x%02x from field->logical\n",825 pidff_reports[ret]);826 pidff->reports[ret] = report;827 continue;828 }829 830 /*831 * Sometimes logical collections are stacked to indicate832 * different usages for the report and the field, in which833 * case we want the usage of the parent. However, Linux HID834 * implementation hides this fact, so we have to dig it up835 * ourselves836 */837 i = report->field[0]->usage[0].collection_index;838 if (i <= 0 ||839 hid->collection[i - 1].type != HID_COLLECTION_LOGICAL)840 continue;841 ret = pidff_check_usage(hid->collection[i - 1].usage);842 if (ret != -1 && !pidff->reports[ret]) {843 hid_dbg(hid,844 "found usage 0x%02x from collection array\n",845 pidff_reports[ret]);846 pidff->reports[ret] = report;847 }848 }849}850 851/*852 * Test if the required reports have been found853 */854static int pidff_reports_ok(struct pidff_device *pidff)855{856 int i;857 858 for (i = 0; i <= PID_REQUIRED_REPORTS; i++) {859 if (!pidff->reports[i]) {860 hid_dbg(pidff->hid, "%d missing\n", i);861 return 0;862 }863 }864 865 return 1;866}867 868/*869 * Find a field with a specific usage within a report870 */871static struct hid_field *pidff_find_special_field(struct hid_report *report,872 int usage, int enforce_min)873{874 int i;875 876 for (i = 0; i < report->maxfield; i++) {877 if (report->field[i]->logical == (HID_UP_PID | usage) &&878 report->field[i]->report_count > 0) {879 if (!enforce_min ||880 report->field[i]->logical_minimum == 1)881 return report->field[i];882 else {883 pr_err("logical_minimum is not 1 as it should be\n");884 return NULL;885 }886 }887 }888 return NULL;889}890 891/*892 * Fill a pidff->*_id struct table893 */894static int pidff_find_special_keys(int *keys, struct hid_field *fld,895 const u8 *usagetable, int count)896{897 898 int i, j;899 int found = 0;900 901 for (i = 0; i < count; i++) {902 for (j = 0; j < fld->maxusage; j++) {903 if (fld->usage[j].hid == (HID_UP_PID | usagetable[i])) {904 keys[i] = j + 1;905 found++;906 break;907 }908 }909 }910 return found;911}912 913#define PIDFF_FIND_SPECIAL_KEYS(keys, field, name) \914 pidff_find_special_keys(pidff->keys, pidff->field, pidff_ ## name, \915 sizeof(pidff_ ## name))916 917/*918 * Find and check the special fields919 */920static int pidff_find_special_fields(struct pidff_device *pidff)921{922 hid_dbg(pidff->hid, "finding special fields\n");923 924 pidff->create_new_effect_type =925 pidff_find_special_field(pidff->reports[PID_CREATE_NEW_EFFECT],926 0x25, 1);927 pidff->set_effect_type =928 pidff_find_special_field(pidff->reports[PID_SET_EFFECT],929 0x25, 1);930 pidff->effect_direction =931 pidff_find_special_field(pidff->reports[PID_SET_EFFECT],932 0x57, 0);933 pidff->device_control =934 pidff_find_special_field(pidff->reports[PID_DEVICE_CONTROL],935 0x96, 1);936 pidff->block_load_status =937 pidff_find_special_field(pidff->reports[PID_BLOCK_LOAD],938 0x8b, 1);939 pidff->effect_operation_status =940 pidff_find_special_field(pidff->reports[PID_EFFECT_OPERATION],941 0x78, 1);942 943 hid_dbg(pidff->hid, "search done\n");944 945 if (!pidff->create_new_effect_type || !pidff->set_effect_type) {946 hid_err(pidff->hid, "effect lists not found\n");947 return -1;948 }949 950 if (!pidff->effect_direction) {951 hid_err(pidff->hid, "direction field not found\n");952 return -1;953 }954 955 if (!pidff->device_control) {956 hid_err(pidff->hid, "device control field not found\n");957 return -1;958 }959 960 if (!pidff->block_load_status) {961 hid_err(pidff->hid, "block load status field not found\n");962 return -1;963 }964 965 if (!pidff->effect_operation_status) {966 hid_err(pidff->hid, "effect operation field not found\n");967 return -1;968 }969 970 pidff_find_special_keys(pidff->control_id, pidff->device_control,971 pidff_device_control,972 sizeof(pidff_device_control));973 974 PIDFF_FIND_SPECIAL_KEYS(control_id, device_control, device_control);975 976 if (!PIDFF_FIND_SPECIAL_KEYS(type_id, create_new_effect_type,977 effect_types)) {978 hid_err(pidff->hid, "no effect types found\n");979 return -1;980 }981 982 if (PIDFF_FIND_SPECIAL_KEYS(status_id, block_load_status,983 block_load_status) !=984 sizeof(pidff_block_load_status)) {985 hid_err(pidff->hid,986 "block load status identifiers not found\n");987 return -1;988 }989 990 if (PIDFF_FIND_SPECIAL_KEYS(operation_id, effect_operation_status,991 effect_operation_status) !=992 sizeof(pidff_effect_operation_status)) {993 hid_err(pidff->hid, "effect operation identifiers not found\n");994 return -1;995 }996 997 return 0;998}999 1000/*1001 * Find the implemented effect types1002 */1003static int pidff_find_effects(struct pidff_device *pidff,1004 struct input_dev *dev)1005{1006 int i;1007 1008 for (i = 0; i < sizeof(pidff_effect_types); i++) {1009 int pidff_type = pidff->type_id[i];1010 if (pidff->set_effect_type->usage[pidff_type].hid !=1011 pidff->create_new_effect_type->usage[pidff_type].hid) {1012 hid_err(pidff->hid,1013 "effect type number %d is invalid\n", i);1014 return -1;1015 }1016 }1017 1018 if (pidff->type_id[PID_CONSTANT])1019 set_bit(FF_CONSTANT, dev->ffbit);1020 if (pidff->type_id[PID_RAMP])1021 set_bit(FF_RAMP, dev->ffbit);1022 if (pidff->type_id[PID_SQUARE]) {1023 set_bit(FF_SQUARE, dev->ffbit);1024 set_bit(FF_PERIODIC, dev->ffbit);1025 }1026 if (pidff->type_id[PID_SINE]) {1027 set_bit(FF_SINE, dev->ffbit);1028 set_bit(FF_PERIODIC, dev->ffbit);1029 }1030 if (pidff->type_id[PID_TRIANGLE]) {1031 set_bit(FF_TRIANGLE, dev->ffbit);1032 set_bit(FF_PERIODIC, dev->ffbit);1033 }1034 if (pidff->type_id[PID_SAW_UP]) {1035 set_bit(FF_SAW_UP, dev->ffbit);1036 set_bit(FF_PERIODIC, dev->ffbit);1037 }1038 if (pidff->type_id[PID_SAW_DOWN]) {1039 set_bit(FF_SAW_DOWN, dev->ffbit);1040 set_bit(FF_PERIODIC, dev->ffbit);1041 }1042 if (pidff->type_id[PID_SPRING])1043 set_bit(FF_SPRING, dev->ffbit);1044 if (pidff->type_id[PID_DAMPER])1045 set_bit(FF_DAMPER, dev->ffbit);1046 if (pidff->type_id[PID_INERTIA])1047 set_bit(FF_INERTIA, dev->ffbit);1048 if (pidff->type_id[PID_FRICTION])1049 set_bit(FF_FRICTION, dev->ffbit);1050 1051 return 0;1052 1053}1054 1055#define PIDFF_FIND_FIELDS(name, report, strict) \1056 pidff_find_fields(pidff->name, pidff_ ## name, \1057 pidff->reports[report], \1058 sizeof(pidff_ ## name), strict)1059 1060/*1061 * Fill and check the pidff_usages1062 */1063static int pidff_init_fields(struct pidff_device *pidff, struct input_dev *dev)1064{1065 int envelope_ok = 0;1066 1067 if (PIDFF_FIND_FIELDS(set_effect, PID_SET_EFFECT, 1)) {1068 hid_err(pidff->hid, "unknown set_effect report layout\n");1069 return -ENODEV;1070 }1071 1072 PIDFF_FIND_FIELDS(block_load, PID_BLOCK_LOAD, 0);1073 if (!pidff->block_load[PID_EFFECT_BLOCK_INDEX].value) {1074 hid_err(pidff->hid, "unknown pid_block_load report layout\n");1075 return -ENODEV;1076 }1077 1078 if (PIDFF_FIND_FIELDS(effect_operation, PID_EFFECT_OPERATION, 1)) {1079 hid_err(pidff->hid, "unknown effect_operation report layout\n");1080 return -ENODEV;1081 }1082 1083 if (PIDFF_FIND_FIELDS(block_free, PID_BLOCK_FREE, 1)) {1084 hid_err(pidff->hid, "unknown pid_block_free report layout\n");1085 return -ENODEV;1086 }1087 1088 if (!PIDFF_FIND_FIELDS(set_envelope, PID_SET_ENVELOPE, 1))1089 envelope_ok = 1;1090 1091 if (pidff_find_special_fields(pidff) || pidff_find_effects(pidff, dev))1092 return -ENODEV;1093 1094 if (!envelope_ok) {1095 if (test_and_clear_bit(FF_CONSTANT, dev->ffbit))1096 hid_warn(pidff->hid,1097 "has constant effect but no envelope\n");1098 if (test_and_clear_bit(FF_RAMP, dev->ffbit))1099 hid_warn(pidff->hid,1100 "has ramp effect but no envelope\n");1101 1102 if (test_and_clear_bit(FF_PERIODIC, dev->ffbit))1103 hid_warn(pidff->hid,1104 "has periodic effect but no envelope\n");1105 }1106 1107 if (test_bit(FF_CONSTANT, dev->ffbit) &&1108 PIDFF_FIND_FIELDS(set_constant, PID_SET_CONSTANT, 1)) {1109 hid_warn(pidff->hid, "unknown constant effect layout\n");1110 clear_bit(FF_CONSTANT, dev->ffbit);1111 }1112 1113 if (test_bit(FF_RAMP, dev->ffbit) &&1114 PIDFF_FIND_FIELDS(set_ramp, PID_SET_RAMP, 1)) {1115 hid_warn(pidff->hid, "unknown ramp effect layout\n");1116 clear_bit(FF_RAMP, dev->ffbit);1117 }1118 1119 if ((test_bit(FF_SPRING, dev->ffbit) ||1120 test_bit(FF_DAMPER, dev->ffbit) ||1121 test_bit(FF_FRICTION, dev->ffbit) ||1122 test_bit(FF_INERTIA, dev->ffbit)) &&1123 PIDFF_FIND_FIELDS(set_condition, PID_SET_CONDITION, 1)) {1124 hid_warn(pidff->hid, "unknown condition effect layout\n");1125 clear_bit(FF_SPRING, dev->ffbit);1126 clear_bit(FF_DAMPER, dev->ffbit);1127 clear_bit(FF_FRICTION, dev->ffbit);1128 clear_bit(FF_INERTIA, dev->ffbit);1129 }1130 1131 if (test_bit(FF_PERIODIC, dev->ffbit) &&1132 PIDFF_FIND_FIELDS(set_periodic, PID_SET_PERIODIC, 1)) {1133 hid_warn(pidff->hid, "unknown periodic effect layout\n");1134 clear_bit(FF_PERIODIC, dev->ffbit);1135 }1136 1137 PIDFF_FIND_FIELDS(pool, PID_POOL, 0);1138 1139 if (!PIDFF_FIND_FIELDS(device_gain, PID_DEVICE_GAIN, 1))1140 set_bit(FF_GAIN, dev->ffbit);1141 1142 return 0;1143}1144 1145/*1146 * Reset the device1147 */1148static void pidff_reset(struct pidff_device *pidff)1149{1150 struct hid_device *hid = pidff->hid;1151 int i = 0;1152 1153 pidff->device_control->value[0] = pidff->control_id[PID_RESET];1154 /* We reset twice as sometimes hid_wait_io isn't waiting long enough */1155 hid_hw_request(hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT);1156 hid_hw_wait(hid);1157 hid_hw_request(hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT);1158 hid_hw_wait(hid);1159 1160 pidff->device_control->value[0] =1161 pidff->control_id[PID_ENABLE_ACTUATORS];1162 hid_hw_request(hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT);1163 hid_hw_wait(hid);1164 1165 /* pool report is sometimes messed up, refetch it */1166 hid_hw_request(hid, pidff->reports[PID_POOL], HID_REQ_GET_REPORT);1167 hid_hw_wait(hid);1168 1169 if (pidff->pool[PID_SIMULTANEOUS_MAX].value) {1170 while (pidff->pool[PID_SIMULTANEOUS_MAX].value[0] < 2) {1171 if (i++ > 20) {1172 hid_warn(pidff->hid,1173 "device reports %d simultaneous effects\n",1174 pidff->pool[PID_SIMULTANEOUS_MAX].value[0]);1175 break;1176 }1177 hid_dbg(pidff->hid, "pid_pool requested again\n");1178 hid_hw_request(hid, pidff->reports[PID_POOL],1179 HID_REQ_GET_REPORT);1180 hid_hw_wait(hid);1181 }1182 }1183}1184 1185/*1186 * Test if autocenter modification is using the supported method1187 */1188static int pidff_check_autocenter(struct pidff_device *pidff,1189 struct input_dev *dev)1190{1191 int error;1192 1193 /*1194 * Let's find out if autocenter modification is supported1195 * Specification doesn't specify anything, so we request an1196 * effect upload and cancel it immediately. If the approved1197 * effect id was one above the minimum, then we assume the first1198 * effect id is a built-in spring type effect used for autocenter1199 */1200 1201 error = pidff_request_effect_upload(pidff, 1);1202 if (error) {1203 hid_err(pidff->hid, "upload request failed\n");1204 return error;1205 }1206 1207 if (pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] ==1208 pidff->block_load[PID_EFFECT_BLOCK_INDEX].field->logical_minimum + 1) {1209 pidff_autocenter(pidff, 0xffff);1210 set_bit(FF_AUTOCENTER, dev->ffbit);1211 } else {1212 hid_notice(pidff->hid,1213 "device has unknown autocenter control method\n");1214 }1215 1216 pidff_erase_pid(pidff,1217 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0]);1218 1219 return 0;1220 1221}1222 1223/*1224 * Check if the device is PID and initialize it1225 */1226int hid_pidff_init(struct hid_device *hid)1227{1228 struct pidff_device *pidff;1229 struct hid_input *hidinput = list_entry(hid->inputs.next,1230 struct hid_input, list);1231 struct input_dev *dev = hidinput->input;1232 struct ff_device *ff;1233 int max_effects;1234 int error;1235 1236 hid_dbg(hid, "starting pid init\n");1237 1238 if (list_empty(&hid->report_enum[HID_OUTPUT_REPORT].report_list)) {1239 hid_dbg(hid, "not a PID device, no output report\n");1240 return -ENODEV;1241 }1242 1243 pidff = kzalloc(sizeof(*pidff), GFP_KERNEL);1244 if (!pidff)1245 return -ENOMEM;1246 1247 pidff->hid = hid;1248 1249 hid_device_io_start(hid);1250 1251 pidff_find_reports(hid, HID_OUTPUT_REPORT, pidff);1252 pidff_find_reports(hid, HID_FEATURE_REPORT, pidff);1253 1254 if (!pidff_reports_ok(pidff)) {1255 hid_dbg(hid, "reports not ok, aborting\n");1256 error = -ENODEV;1257 goto fail;1258 }1259 1260 error = pidff_init_fields(pidff, dev);1261 if (error)1262 goto fail;1263 1264 pidff_reset(pidff);1265 1266 if (test_bit(FF_GAIN, dev->ffbit)) {1267 pidff_set(&pidff->device_gain[PID_DEVICE_GAIN_FIELD], 0xffff);1268 hid_hw_request(hid, pidff->reports[PID_DEVICE_GAIN],1269 HID_REQ_SET_REPORT);1270 }1271 1272 error = pidff_check_autocenter(pidff, dev);1273 if (error)1274 goto fail;1275 1276 max_effects =1277 pidff->block_load[PID_EFFECT_BLOCK_INDEX].field->logical_maximum -1278 pidff->block_load[PID_EFFECT_BLOCK_INDEX].field->logical_minimum +1279 1;1280 hid_dbg(hid, "max effects is %d\n", max_effects);1281 1282 if (max_effects > PID_EFFECTS_MAX)1283 max_effects = PID_EFFECTS_MAX;1284 1285 if (pidff->pool[PID_SIMULTANEOUS_MAX].value)1286 hid_dbg(hid, "max simultaneous effects is %d\n",1287 pidff->pool[PID_SIMULTANEOUS_MAX].value[0]);1288 1289 if (pidff->pool[PID_RAM_POOL_SIZE].value)1290 hid_dbg(hid, "device memory size is %d bytes\n",1291 pidff->pool[PID_RAM_POOL_SIZE].value[0]);1292 1293 if (pidff->pool[PID_DEVICE_MANAGED_POOL].value &&1294 pidff->pool[PID_DEVICE_MANAGED_POOL].value[0] == 0) {1295 error = -EPERM;1296 hid_notice(hid,1297 "device does not support device managed pool\n");1298 goto fail;1299 }1300 1301 error = input_ff_create(dev, max_effects);1302 if (error)1303 goto fail;1304 1305 ff = dev->ff;1306 ff->private = pidff;1307 ff->upload = pidff_upload_effect;1308 ff->erase = pidff_erase_effect;1309 ff->set_gain = pidff_set_gain;1310 ff->set_autocenter = pidff_set_autocenter;1311 ff->playback = pidff_playback;1312 1313 hid_info(dev, "Force feedback for USB HID PID devices by Anssi Hannula <anssi.hannula@gmail.com>\n");1314 1315 hid_device_io_stop(hid);1316 1317 return 0;1318 1319 fail:1320 hid_device_io_stop(hid);1321 1322 kfree(pidff);1323 return error;1324}1325