1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Force feedback driver for USB HID PID compliant devices 4 * 5 * Copyright (c) 2005, 2006 Anssi Hannula <anssi.hannula@gmail.com> 6 * Upgraded 2025 by Oleg Makarenko and Tomasz Pakuła 7 */ 8 9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 10 11 #include "hid-pidff.h" 12 #include <linux/input.h> 13 #include <linux/slab.h> 14 #include <linux/usb.h> 15 #include <linux/hid.h> 16 #include <linux/minmax.h> 17 18 19 #define PID_EFFECTS_MAX 64 20 #define PID_INFINITE U16_MAX 21 22 /* Linux Force Feedback API uses miliseconds as time unit */ 23 #define FF_TIME_EXPONENT -3 24 #define FF_INFINITE 0 25 26 /* Report usage table used to put reports into an array */ 27 #define PID_SET_EFFECT 0 28 #define PID_EFFECT_OPERATION 1 29 #define PID_DEVICE_GAIN 2 30 #define PID_POOL 3 31 #define PID_BLOCK_LOAD 4 32 #define PID_BLOCK_FREE 5 33 #define PID_DEVICE_CONTROL 6 34 #define PID_CREATE_NEW_EFFECT 7 35 36 #define PID_REQUIRED_REPORTS 7 37 38 #define PID_SET_ENVELOPE 8 39 #define PID_SET_CONDITION 9 40 #define PID_SET_PERIODIC 10 41 #define PID_SET_CONSTANT 11 42 #define PID_SET_RAMP 12 43 static const u8 pidff_reports[] = { 44 0x21, 0x77, 0x7d, 0x7f, 0x89, 0x90, 0x96, 0xab, 45 0x5a, 0x5f, 0x6e, 0x73, 0x74 46 }; 47 /* 48 * device_control is really 0x95, but 0x96 specified 49 * as it is the usage of the only field in that report. 50 */ 51 52 /* PID special fields */ 53 #define PID_EFFECT_TYPE 0x25 54 #define PID_DIRECTION 0x57 55 #define PID_EFFECT_OPERATION_ARRAY 0x78 56 #define PID_BLOCK_LOAD_STATUS 0x8b 57 #define PID_DEVICE_CONTROL_ARRAY 0x96 58 59 /* Value usage tables used to put fields and values into arrays */ 60 #define PID_EFFECT_BLOCK_INDEX 0 61 62 #define PID_DURATION 1 63 #define PID_GAIN 2 64 #define PID_TRIGGER_BUTTON 3 65 #define PID_TRIGGER_REPEAT_INT 4 66 #define PID_DIRECTION_ENABLE 5 67 #define PID_START_DELAY 6 68 static const u8 pidff_set_effect[] = { 69 0x22, 0x50, 0x52, 0x53, 0x54, 0x56, 0xa7 70 }; 71 72 #define PID_ATTACK_LEVEL 1 73 #define PID_ATTACK_TIME 2 74 #define PID_FADE_LEVEL 3 75 #define PID_FADE_TIME 4 76 static const u8 pidff_set_envelope[] = { 0x22, 0x5b, 0x5c, 0x5d, 0x5e }; 77 78 #define PID_PARAM_BLOCK_OFFSET 1 79 #define PID_CP_OFFSET 2 80 #define PID_POS_COEFFICIENT 3 81 #define PID_NEG_COEFFICIENT 4 82 #define PID_POS_SATURATION 5 83 #define PID_NEG_SATURATION 6 84 #define PID_DEAD_BAND 7 85 static const u8 pidff_set_condition[] = { 86 0x22, 0x23, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65 87 }; 88 89 #define PID_MAGNITUDE 1 90 #define PID_OFFSET 2 91 #define PID_PHASE 3 92 #define PID_PERIOD 4 93 static const u8 pidff_set_periodic[] = { 0x22, 0x70, 0x6f, 0x71, 0x72 }; 94 static const u8 pidff_set_constant[] = { 0x22, 0x70 }; 95 96 #define PID_RAMP_START 1 97 #define PID_RAMP_END 2 98 static const u8 pidff_set_ramp[] = { 0x22, 0x75, 0x76 }; 99 100 #define PID_RAM_POOL_AVAILABLE 1 101 static const u8 pidff_block_load[] = { 0x22, 0xac }; 102 103 #define PID_LOOP_COUNT 1 104 static const u8 pidff_effect_operation[] = { 0x22, 0x7c }; 105 106 static const u8 pidff_block_free[] = { 0x22 }; 107 108 #define PID_DEVICE_GAIN_FIELD 0 109 static const u8 pidff_device_gain[] = { 0x7e }; 110 111 #define PID_RAM_POOL_SIZE 0 112 #define PID_SIMULTANEOUS_MAX 1 113 #define PID_DEVICE_MANAGED_POOL 2 114 static const u8 pidff_pool[] = { 0x80, 0x83, 0xa9 }; 115 116 /* Special field key tables used to put special field keys into arrays */ 117 #define PID_ENABLE_ACTUATORS 0 118 #define PID_DISABLE_ACTUATORS 1 119 #define PID_STOP_ALL_EFFECTS 2 120 #define PID_RESET 3 121 #define PID_PAUSE 4 122 #define PID_CONTINUE 5 123 static const u8 pidff_device_control[] = { 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c }; 124 125 #define PID_CONSTANT 0 126 #define PID_RAMP 1 127 #define PID_SQUARE 2 128 #define PID_SINE 3 129 #define PID_TRIANGLE 4 130 #define PID_SAW_UP 5 131 #define PID_SAW_DOWN 6 132 #define PID_SPRING 7 133 #define PID_DAMPER 8 134 #define PID_INERTIA 9 135 #define PID_FRICTION 10 136 static const u8 pidff_effect_types[] = { 137 0x26, 0x27, 0x30, 0x31, 0x32, 0x33, 0x34, 138 0x40, 0x41, 0x42, 0x43 139 }; 140 141 #define PID_BLOCK_LOAD_SUCCESS 0 142 #define PID_BLOCK_LOAD_FULL 1 143 #define PID_BLOCK_LOAD_ERROR 2 144 static const u8 pidff_block_load_status[] = { 0x8c, 0x8d, 0x8e}; 145 146 #define PID_EFFECT_START 0 147 #define PID_EFFECT_STOP 1 148 static const u8 pidff_effect_operation_status[] = { 0x79, 0x7b }; 149 150 /* Polar direction 90 degrees (East) */ 151 #define PIDFF_FIXED_WHEEL_DIRECTION 0x4000 152 153 struct pidff_usage { 154 struct hid_field *field; 155 s32 *value; 156 }; 157 158 struct pidff_device { 159 struct hid_device *hid; 160 161 struct hid_report *reports[sizeof(pidff_reports)]; 162 163 struct pidff_usage set_effect[sizeof(pidff_set_effect)]; 164 struct pidff_usage set_envelope[sizeof(pidff_set_envelope)]; 165 struct pidff_usage set_condition[sizeof(pidff_set_condition)]; 166 struct pidff_usage set_periodic[sizeof(pidff_set_periodic)]; 167 struct pidff_usage set_constant[sizeof(pidff_set_constant)]; 168 struct pidff_usage set_ramp[sizeof(pidff_set_ramp)]; 169 170 struct pidff_usage device_gain[sizeof(pidff_device_gain)]; 171 struct pidff_usage block_load[sizeof(pidff_block_load)]; 172 struct pidff_usage pool[sizeof(pidff_pool)]; 173 struct pidff_usage effect_operation[sizeof(pidff_effect_operation)]; 174 struct pidff_usage block_free[sizeof(pidff_block_free)]; 175 176 /* 177 * Special field is a field that is not composed of 178 * usage<->value pairs that pidff_usage values are 179 */ 180 181 /* Special field in create_new_effect */ 182 struct hid_field *create_new_effect_type; 183 184 /* Special fields in set_effect */ 185 struct hid_field *set_effect_type; 186 struct hid_field *effect_direction; 187 188 /* Special field in device_control */ 189 struct hid_field *device_control; 190 191 /* Special field in block_load */ 192 struct hid_field *block_load_status; 193 194 /* Special field in effect_operation */ 195 struct hid_field *effect_operation_status; 196 197 int control_id[sizeof(pidff_device_control)]; 198 int type_id[sizeof(pidff_effect_types)]; 199 int status_id[sizeof(pidff_block_load_status)]; 200 int operation_id[sizeof(pidff_effect_operation_status)]; 201 202 int pid_id[PID_EFFECTS_MAX]; 203 204 u32 quirks; 205 u8 effect_count; 206 }; 207 208 /* 209 * Clamp value for a given field 210 */ 211 static s32 pidff_clamp(s32 i, struct hid_field *field) 212 { 213 return (s32)clamp(i, field->logical_minimum, field->logical_maximum); 214 } 215 216 /* 217 * Scale an unsigned value with range 0..max for the given field 218 */ 219 static int pidff_rescale(int i, int max, struct hid_field *field) 220 { 221 return i * (field->logical_maximum - field->logical_minimum) / max + 222 field->logical_minimum; 223 } 224 225 /* 226 * Scale a signed value in range S16_MIN..S16_MAX for the given field 227 */ 228 static int pidff_rescale_signed(int i, struct hid_field *field) 229 { 230 if (i > 0) return i * field->logical_maximum / S16_MAX; 231 if (i < 0) return i * field->logical_minimum / S16_MIN; 232 return 0; 233 } 234 235 /* 236 * Scale time value from Linux default (ms) to field units 237 */ 238 static u32 pidff_rescale_time(u16 time, struct hid_field *field) 239 { 240 u32 scaled_time = time; 241 int exponent = field->unit_exponent; 242 243 pr_debug("time field exponent: %d\n", exponent); 244 for (;exponent < FF_TIME_EXPONENT; exponent++) 245 scaled_time *= 10; 246 for (;exponent > FF_TIME_EXPONENT; exponent--) 247 scaled_time /= 10; 248 249 pr_debug("time calculated from %d to %d\n", time, scaled_time); 250 return scaled_time; 251 } 252 253 static void pidff_set(struct pidff_usage *usage, u16 value) 254 { 255 usage->value[0] = pidff_rescale(value, U16_MAX, usage->field); 256 pr_debug("calculated from %d to %d\n", value, usage->value[0]); 257 } 258 259 static void pidff_set_signed(struct pidff_usage *usage, s16 value) 260 { 261 if (usage->field->logical_minimum < 0) 262 usage->value[0] = pidff_rescale_signed(value, usage->field); 263 else { 264 if (value < 0) 265 usage->value[0] = 266 pidff_rescale(-value, -S16_MIN, usage->field); 267 else 268 usage->value[0] = 269 pidff_rescale(value, S16_MAX, usage->field); 270 } 271 pr_debug("calculated from %d to %d\n", value, usage->value[0]); 272 } 273 274 static void pidff_set_time(struct pidff_usage *usage, u16 time) 275 { 276 usage->value[0] = pidff_clamp( 277 pidff_rescale_time(time, usage->field), usage->field); 278 } 279 280 static void pidff_set_duration(struct pidff_usage *usage, u16 duration) 281 { 282 /* Infinite value conversion from Linux API -> PID */ 283 if (duration == FF_INFINITE) 284 duration = PID_INFINITE; 285 286 /* PID defines INFINITE as the max possible value for duration field */ 287 if (duration == PID_INFINITE) { 288 usage->value[0] = (1U << usage->field->report_size) - 1; 289 return; 290 } 291 292 pidff_set_time(usage, duration); 293 } 294 295 /* 296 * Send envelope report to the device 297 */ 298 static void pidff_set_envelope_report(struct pidff_device *pidff, 299 struct ff_envelope *envelope) 300 { 301 pidff->set_envelope[PID_EFFECT_BLOCK_INDEX].value[0] = 302 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0]; 303 304 pidff->set_envelope[PID_ATTACK_LEVEL].value[0] = 305 pidff_rescale(envelope->attack_level > 306 S16_MAX ? S16_MAX : envelope->attack_level, S16_MAX, 307 pidff->set_envelope[PID_ATTACK_LEVEL].field); 308 pidff->set_envelope[PID_FADE_LEVEL].value[0] = 309 pidff_rescale(envelope->fade_level > 310 S16_MAX ? S16_MAX : envelope->fade_level, S16_MAX, 311 pidff->set_envelope[PID_FADE_LEVEL].field); 312 313 pidff_set_time(&pidff->set_envelope[PID_ATTACK_TIME], 314 envelope->attack_length); 315 pidff_set_time(&pidff->set_envelope[PID_FADE_TIME], 316 envelope->fade_length); 317 318 hid_dbg(pidff->hid, "attack %u => %d\n", 319 envelope->attack_level, 320 pidff->set_envelope[PID_ATTACK_LEVEL].value[0]); 321 322 hid_hw_request(pidff->hid, pidff->reports[PID_SET_ENVELOPE], 323 HID_REQ_SET_REPORT); 324 } 325 326 /* 327 * Test if the new envelope differs from old one 328 */ 329 static int pidff_needs_set_envelope(struct ff_envelope *envelope, 330 struct ff_envelope *old) 331 { 332 bool needs_new_envelope; 333 334 needs_new_envelope = envelope->attack_level != 0 || 335 envelope->fade_level != 0 || 336 envelope->attack_length != 0 || 337 envelope->fade_length != 0; 338 339 if (!needs_new_envelope) 340 return false; 341 342 if (!old) 343 return needs_new_envelope; 344 345 return envelope->attack_level != old->attack_level || 346 envelope->fade_level != old->fade_level || 347 envelope->attack_length != old->attack_length || 348 envelope->fade_length != old->fade_length; 349 } 350 351 /* 352 * Send constant force report to the device 353 */ 354 static void pidff_set_constant_force_report(struct pidff_device *pidff, 355 struct ff_effect *effect) 356 { 357 pidff->set_constant[PID_EFFECT_BLOCK_INDEX].value[0] = 358 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0]; 359 pidff_set_signed(&pidff->set_constant[PID_MAGNITUDE], 360 effect->u.constant.level); 361 362 hid_hw_request(pidff->hid, pidff->reports[PID_SET_CONSTANT], 363 HID_REQ_SET_REPORT); 364 } 365 366 /* 367 * Test if the constant parameters have changed between effects 368 */ 369 static int pidff_needs_set_constant(struct ff_effect *effect, 370 struct ff_effect *old) 371 { 372 return effect->u.constant.level != old->u.constant.level; 373 } 374 375 /* 376 * Send set effect report to the device 377 */ 378 static void pidff_set_effect_report(struct pidff_device *pidff, 379 struct ff_effect *effect) 380 { 381 pidff->set_effect[PID_EFFECT_BLOCK_INDEX].value[0] = 382 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0]; 383 pidff->set_effect_type->value[0] = 384 pidff->create_new_effect_type->value[0]; 385 386 pidff_set_duration(&pidff->set_effect[PID_DURATION], 387 effect->replay.length); 388 389 pidff->set_effect[PID_TRIGGER_BUTTON].value[0] = effect->trigger.button; 390 pidff_set_time(&pidff->set_effect[PID_TRIGGER_REPEAT_INT], 391 effect->trigger.interval); 392 pidff->set_effect[PID_GAIN].value[0] = 393 pidff->set_effect[PID_GAIN].field->logical_maximum; 394 pidff->set_effect[PID_DIRECTION_ENABLE].value[0] = 1; 395 396 /* Use fixed direction if needed */ 397 pidff->effect_direction->value[0] = pidff_rescale( 398 pidff->quirks & HID_PIDFF_QUIRK_FIX_WHEEL_DIRECTION ? 399 PIDFF_FIXED_WHEEL_DIRECTION : effect->direction, 400 U16_MAX, pidff->effect_direction); 401 402 /* Omit setting delay field if it's missing */ 403 if (!(pidff->quirks & HID_PIDFF_QUIRK_MISSING_DELAY)) 404 pidff_set_time(&pidff->set_effect[PID_START_DELAY], 405 effect->replay.delay); 406 407 hid_hw_request(pidff->hid, pidff->reports[PID_SET_EFFECT], 408 HID_REQ_SET_REPORT); 409 } 410 411 /* 412 * Test if the values used in set_effect have changed 413 */ 414 static int pidff_needs_set_effect(struct ff_effect *effect, 415 struct ff_effect *old) 416 { 417 return effect->replay.length != old->replay.length || 418 effect->trigger.interval != old->trigger.interval || 419 effect->trigger.button != old->trigger.button || 420 effect->direction != old->direction || 421 effect->replay.delay != old->replay.delay; 422 } 423 424 /* 425 * Send periodic effect report to the device 426 */ 427 static void pidff_set_periodic_report(struct pidff_device *pidff, 428 struct ff_effect *effect) 429 { 430 pidff->set_periodic[PID_EFFECT_BLOCK_INDEX].value[0] = 431 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0]; 432 pidff_set_signed(&pidff->set_periodic[PID_MAGNITUDE], 433 effect->u.periodic.magnitude); 434 pidff_set_signed(&pidff->set_periodic[PID_OFFSET], 435 effect->u.periodic.offset); 436 pidff_set(&pidff->set_periodic[PID_PHASE], effect->u.periodic.phase); 437 pidff_set_time(&pidff->set_periodic[PID_PERIOD], 438 effect->u.periodic.period); 439 440 hid_hw_request(pidff->hid, pidff->reports[PID_SET_PERIODIC], 441 HID_REQ_SET_REPORT); 442 } 443 444 /* 445 * Test if periodic effect parameters have changed 446 */ 447 static int pidff_needs_set_periodic(struct ff_effect *effect, 448 struct ff_effect *old) 449 { 450 return effect->u.periodic.magnitude != old->u.periodic.magnitude || 451 effect->u.periodic.offset != old->u.periodic.offset || 452 effect->u.periodic.phase != old->u.periodic.phase || 453 effect->u.periodic.period != old->u.periodic.period; 454 } 455 456 /* 457 * Send condition effect reports to the device 458 */ 459 static void pidff_set_condition_report(struct pidff_device *pidff, 460 struct ff_effect *effect) 461 { 462 int i, max_axis; 463 464 /* Devices missing Parameter Block Offset can only have one axis */ 465 max_axis = pidff->quirks & HID_PIDFF_QUIRK_MISSING_PBO ? 1 : 2; 466 467 pidff->set_condition[PID_EFFECT_BLOCK_INDEX].value[0] = 468 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0]; 469 470 for (i = 0; i < max_axis; i++) { 471 /* Omit Parameter Block Offset if missing */ 472 if (!(pidff->quirks & HID_PIDFF_QUIRK_MISSING_PBO)) 473 pidff->set_condition[PID_PARAM_BLOCK_OFFSET].value[0] = i; 474 475 pidff_set_signed(&pidff->set_condition[PID_CP_OFFSET], 476 effect->u.condition[i].center); 477 pidff_set_signed(&pidff->set_condition[PID_POS_COEFFICIENT], 478 effect->u.condition[i].right_coeff); 479 pidff_set_signed(&pidff->set_condition[PID_NEG_COEFFICIENT], 480 effect->u.condition[i].left_coeff); 481 pidff_set(&pidff->set_condition[PID_POS_SATURATION], 482 effect->u.condition[i].right_saturation); 483 pidff_set(&pidff->set_condition[PID_NEG_SATURATION], 484 effect->u.condition[i].left_saturation); 485 pidff_set(&pidff->set_condition[PID_DEAD_BAND], 486 effect->u.condition[i].deadband); 487 hid_hw_request(pidff->hid, pidff->reports[PID_SET_CONDITION], 488 HID_REQ_SET_REPORT); 489 } 490 } 491 492 /* 493 * Test if condition effect parameters have changed 494 */ 495 static int pidff_needs_set_condition(struct ff_effect *effect, 496 struct ff_effect *old) 497 { 498 int i; 499 int ret = 0; 500 501 for (i = 0; i < 2; i++) { 502 struct ff_condition_effect *cond = &effect->u.condition[i]; 503 struct ff_condition_effect *old_cond = &old->u.condition[i]; 504 505 ret |= cond->center != old_cond->center || 506 cond->right_coeff != old_cond->right_coeff || 507 cond->left_coeff != old_cond->left_coeff || 508 cond->right_saturation != old_cond->right_saturation || 509 cond->left_saturation != old_cond->left_saturation || 510 cond->deadband != old_cond->deadband; 511 } 512 513 return ret; 514 } 515 516 /* 517 * Send ramp force report to the device 518 */ 519 static void pidff_set_ramp_force_report(struct pidff_device *pidff, 520 struct ff_effect *effect) 521 { 522 pidff->set_ramp[PID_EFFECT_BLOCK_INDEX].value[0] = 523 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0]; 524 pidff_set_signed(&pidff->set_ramp[PID_RAMP_START], 525 effect->u.ramp.start_level); 526 pidff_set_signed(&pidff->set_ramp[PID_RAMP_END], 527 effect->u.ramp.end_level); 528 hid_hw_request(pidff->hid, pidff->reports[PID_SET_RAMP], 529 HID_REQ_SET_REPORT); 530 } 531 532 /* 533 * Test if ramp force parameters have changed 534 */ 535 static int pidff_needs_set_ramp(struct ff_effect *effect, struct ff_effect *old) 536 { 537 return effect->u.ramp.start_level != old->u.ramp.start_level || 538 effect->u.ramp.end_level != old->u.ramp.end_level; 539 } 540 541 /* 542 * Set device gain 543 */ 544 static void pidff_set_gain_report(struct pidff_device *pidff, u16 gain) 545 { 546 if (!pidff->device_gain[PID_DEVICE_GAIN_FIELD].field) 547 return; 548 549 pidff_set(&pidff->device_gain[PID_DEVICE_GAIN_FIELD], gain); 550 hid_hw_request(pidff->hid, pidff->reports[PID_DEVICE_GAIN], 551 HID_REQ_SET_REPORT); 552 } 553 554 /* 555 * Send device control report to the device 556 */ 557 static void pidff_set_device_control(struct pidff_device *pidff, int field) 558 { 559 int i, index; 560 int field_index = pidff->control_id[field]; 561 562 if (field_index < 1) 563 return; 564 565 /* Detect if the field is a bitmask variable or an array */ 566 if (pidff->device_control->flags & HID_MAIN_ITEM_VARIABLE) { 567 hid_dbg(pidff->hid, "DEVICE_CONTROL is a bitmask\n"); 568 569 /* Clear current bitmask */ 570 for(i = 0; i < sizeof(pidff_device_control); i++) { 571 index = pidff->control_id[i]; 572 if (index < 1) 573 continue; 574 575 pidff->device_control->value[index - 1] = 0; 576 } 577 578 pidff->device_control->value[field_index - 1] = 1; 579 } else { 580 hid_dbg(pidff->hid, "DEVICE_CONTROL is an array\n"); 581 pidff->device_control->value[0] = field_index; 582 } 583 584 hid_hw_request(pidff->hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT); 585 hid_hw_wait(pidff->hid); 586 } 587 588 /* 589 * Modify actuators state 590 */ 591 static void pidff_set_actuators(struct pidff_device *pidff, bool enable) 592 { 593 hid_dbg(pidff->hid, "%s actuators\n", enable ? "Enable" : "Disable"); 594 pidff_set_device_control(pidff, 595 enable ? PID_ENABLE_ACTUATORS : PID_DISABLE_ACTUATORS); 596 } 597 598 /* 599 * Reset the device, stop all effects, enable actuators 600 */ 601 static void pidff_reset(struct pidff_device *pidff) 602 { 603 /* We reset twice as sometimes hid_wait_io isn't waiting long enough */ 604 pidff_set_device_control(pidff, PID_RESET); 605 pidff_set_device_control(pidff, PID_RESET); 606 pidff->effect_count = 0; 607 608 pidff_set_device_control(pidff, PID_STOP_ALL_EFFECTS); 609 pidff_set_actuators(pidff, 1); 610 } 611 612 /* 613 * Fetch pool report 614 */ 615 static void pidff_fetch_pool(struct pidff_device *pidff) 616 { 617 int i; 618 struct hid_device *hid = pidff->hid; 619 620 /* Repeat if PID_SIMULTANEOUS_MAX < 2 to make sure it's correct */ 621 for(i = 0; i < 20; i++) { 622 hid_hw_request(hid, pidff->reports[PID_POOL], HID_REQ_GET_REPORT); 623 hid_hw_wait(hid); 624 625 if (!pidff->pool[PID_SIMULTANEOUS_MAX].value) 626 return; 627 if (pidff->pool[PID_SIMULTANEOUS_MAX].value[0] >= 2) 628 return; 629 } 630 hid_warn(hid, "device reports %d simultaneous effects\n", 631 pidff->pool[PID_SIMULTANEOUS_MAX].value[0]); 632 } 633 634 /* 635 * Send a request for effect upload to the device 636 * 637 * Reset and enable actuators if no effects were present on the device 638 * 639 * Returns 0 if device reported success, -ENOSPC if the device reported memory 640 * is full. Upon unknown response the function will retry for 60 times, if 641 * still unsuccessful -EIO is returned. 642 */ 643 static int pidff_request_effect_upload(struct pidff_device *pidff, int efnum) 644 { 645 int j; 646 647 if (!pidff->effect_count) 648 pidff_reset(pidff); 649 650 pidff->create_new_effect_type->value[0] = efnum; 651 hid_hw_request(pidff->hid, pidff->reports[PID_CREATE_NEW_EFFECT], 652 HID_REQ_SET_REPORT); 653 hid_dbg(pidff->hid, "create_new_effect sent, type: %d\n", efnum); 654 655 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] = 0; 656 pidff->block_load_status->value[0] = 0; 657 hid_hw_wait(pidff->hid); 658 659 for (j = 0; j < 60; j++) { 660 hid_dbg(pidff->hid, "pid_block_load requested\n"); 661 hid_hw_request(pidff->hid, pidff->reports[PID_BLOCK_LOAD], 662 HID_REQ_GET_REPORT); 663 hid_hw_wait(pidff->hid); 664 if (pidff->block_load_status->value[0] == 665 pidff->status_id[PID_BLOCK_LOAD_SUCCESS]) { 666 hid_dbg(pidff->hid, "device reported free memory: %d bytes\n", 667 pidff->block_load[PID_RAM_POOL_AVAILABLE].value ? 668 pidff->block_load[PID_RAM_POOL_AVAILABLE].value[0] : -1); 669 670 pidff->effect_count++; 671 return 0; 672 } 673 if (pidff->block_load_status->value[0] == 674 pidff->status_id[PID_BLOCK_LOAD_FULL]) { 675 hid_dbg(pidff->hid, "not enough memory free: %d bytes\n", 676 pidff->block_load[PID_RAM_POOL_AVAILABLE].value ? 677 pidff->block_load[PID_RAM_POOL_AVAILABLE].value[0] : -1); 678 return -ENOSPC; 679 } 680 if (pidff->block_load_status->value[0] == 681 pidff->status_id[PID_BLOCK_LOAD_ERROR]) { 682 hid_dbg(pidff->hid, "device error during effect creation\n"); 683 return -EREMOTEIO; 684 } 685 } 686 hid_err(pidff->hid, "pid_block_load failed 60 times\n"); 687 return -EIO; 688 } 689 690 /* 691 * Play the effect with PID id n times 692 */ 693 static void pidff_playback_pid(struct pidff_device *pidff, int pid_id, int n) 694 { 695 pidff->effect_operation[PID_EFFECT_BLOCK_INDEX].value[0] = pid_id; 696 697 if (n == 0) { 698 pidff->effect_operation_status->value[0] = 699 pidff->operation_id[PID_EFFECT_STOP]; 700 } else { 701 pidff->effect_operation_status->value[0] = 702 pidff->operation_id[PID_EFFECT_START]; 703 pidff->effect_operation[PID_LOOP_COUNT].value[0] = 704 pidff_clamp(n, pidff->effect_operation[PID_LOOP_COUNT].field); 705 } 706 707 hid_hw_request(pidff->hid, pidff->reports[PID_EFFECT_OPERATION], 708 HID_REQ_SET_REPORT); 709 } 710 711 /* 712 * Play the effect with effect id @effect_id for @value times 713 */ 714 static int pidff_playback(struct input_dev *dev, int effect_id, int value) 715 { 716 struct pidff_device *pidff = dev->ff->private; 717 718 pidff_playback_pid(pidff, pidff->pid_id[effect_id], value); 719 return 0; 720 } 721 722 /* 723 * Erase effect with PID id 724 * Decrease the device effect counter 725 */ 726 static void pidff_erase_pid(struct pidff_device *pidff, int pid_id) 727 { 728 pidff->block_free[PID_EFFECT_BLOCK_INDEX].value[0] = pid_id; 729 hid_hw_request(pidff->hid, pidff->reports[PID_BLOCK_FREE], 730 HID_REQ_SET_REPORT); 731 732 if (pidff->effect_count > 0) 733 pidff->effect_count--; 734 } 735 736 /* 737 * Stop and erase effect with effect_id 738 */ 739 static int pidff_erase_effect(struct input_dev *dev, int effect_id) 740 { 741 struct pidff_device *pidff = dev->ff->private; 742 int pid_id = pidff->pid_id[effect_id]; 743 744 hid_dbg(pidff->hid, "starting to erase %d/%d\n", 745 effect_id, pidff->pid_id[effect_id]); 746 747 /* 748 * Wait for the queue to clear. We do not want 749 * a full fifo to prevent the effect removal. 750 */ 751 hid_hw_wait(pidff->hid); 752 pidff_playback_pid(pidff, pid_id, 0); 753 pidff_erase_pid(pidff, pid_id); 754 755 return 0; 756 } 757 758 /* 759 * Effect upload handler 760 */ 761 static int pidff_upload_effect(struct input_dev *dev, struct ff_effect *effect, 762 struct ff_effect *old) 763 { 764 struct pidff_device *pidff = dev->ff->private; 765 int type_id; 766 int error; 767 768 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] = 0; 769 if (old) { 770 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] = 771 pidff->pid_id[effect->id]; 772 } 773 774 switch (effect->type) { 775 case FF_CONSTANT: 776 if (!old) { 777 error = pidff_request_effect_upload(pidff, 778 pidff->type_id[PID_CONSTANT]); 779 if (error) 780 return error; 781 } 782 if (!old || pidff_needs_set_effect(effect, old)) 783 pidff_set_effect_report(pidff, effect); 784 if (!old || pidff_needs_set_constant(effect, old)) 785 pidff_set_constant_force_report(pidff, effect); 786 if (pidff_needs_set_envelope(&effect->u.constant.envelope, 787 old ? &old->u.constant.envelope : NULL)) 788 pidff_set_envelope_report(pidff, &effect->u.constant.envelope); 789 break; 790 791 case FF_PERIODIC: 792 if (!old) { 793 switch (effect->u.periodic.waveform) { 794 case FF_SQUARE: 795 type_id = PID_SQUARE; 796 break; 797 case FF_TRIANGLE: 798 type_id = PID_TRIANGLE; 799 break; 800 case FF_SINE: 801 type_id = PID_SINE; 802 break; 803 case FF_SAW_UP: 804 type_id = PID_SAW_UP; 805 break; 806 case FF_SAW_DOWN: 807 type_id = PID_SAW_DOWN; 808 break; 809 default: 810 hid_err(pidff->hid, "invalid waveform\n"); 811 return -EINVAL; 812 } 813 814 if (pidff->quirks & HID_PIDFF_QUIRK_PERIODIC_SINE_ONLY) 815 type_id = PID_SINE; 816 817 error = pidff_request_effect_upload(pidff, 818 pidff->type_id[type_id]); 819 if (error) 820 return error; 821 } 822 if (!old || pidff_needs_set_effect(effect, old)) 823 pidff_set_effect_report(pidff, effect); 824 if (!old || pidff_needs_set_periodic(effect, old)) 825 pidff_set_periodic_report(pidff, effect); 826 if (pidff_needs_set_envelope(&effect->u.periodic.envelope, 827 old ? &old->u.periodic.envelope : NULL)) 828 pidff_set_envelope_report(pidff, &effect->u.periodic.envelope); 829 break; 830 831 case FF_RAMP: 832 if (!old) { 833 error = pidff_request_effect_upload(pidff, 834 pidff->type_id[PID_RAMP]); 835 if (error) 836 return error; 837 } 838 if (!old || pidff_needs_set_effect(effect, old)) 839 pidff_set_effect_report(pidff, effect); 840 if (!old || pidff_needs_set_ramp(effect, old)) 841 pidff_set_ramp_force_report(pidff, effect); 842 if (pidff_needs_set_envelope(&effect->u.ramp.envelope, 843 old ? &old->u.ramp.envelope : NULL)) 844 pidff_set_envelope_report(pidff, &effect->u.ramp.envelope); 845 break; 846 847 case FF_SPRING: 848 case FF_DAMPER: 849 case FF_INERTIA: 850 case FF_FRICTION: 851 if (!old) { 852 switch(effect->type) { 853 case FF_SPRING: 854 type_id = PID_SPRING; 855 break; 856 case FF_DAMPER: 857 type_id = PID_DAMPER; 858 break; 859 case FF_INERTIA: 860 type_id = PID_INERTIA; 861 break; 862 case FF_FRICTION: 863 type_id = PID_FRICTION; 864 break; 865 } 866 error = pidff_request_effect_upload(pidff, 867 pidff->type_id[type_id]); 868 if (error) 869 return error; 870 } 871 if (!old || pidff_needs_set_effect(effect, old)) 872 pidff_set_effect_report(pidff, effect); 873 if (!old || pidff_needs_set_condition(effect, old)) 874 pidff_set_condition_report(pidff, effect); 875 break; 876 877 default: 878 hid_err(pidff->hid, "invalid type\n"); 879 return -EINVAL; 880 } 881 882 if (!old) 883 pidff->pid_id[effect->id] = 884 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0]; 885 886 hid_dbg(pidff->hid, "uploaded\n"); 887 888 return 0; 889 } 890 891 /* 892 * set_gain() handler 893 */ 894 static void pidff_set_gain(struct input_dev *dev, u16 gain) 895 { 896 pidff_set_gain_report(dev->ff->private, gain); 897 } 898 899 static void pidff_autocenter(struct pidff_device *pidff, u16 magnitude) 900 { 901 struct hid_field *field = 902 pidff->block_load[PID_EFFECT_BLOCK_INDEX].field; 903 904 if (!magnitude) { 905 pidff_playback_pid(pidff, field->logical_minimum, 0); 906 return; 907 } 908 909 pidff_playback_pid(pidff, field->logical_minimum, 1); 910 911 pidff->set_effect[PID_EFFECT_BLOCK_INDEX].value[0] = 912 pidff->block_load[PID_EFFECT_BLOCK_INDEX].field->logical_minimum; 913 pidff->set_effect_type->value[0] = pidff->type_id[PID_SPRING]; 914 pidff->set_effect[PID_DURATION].value[0] = 0; 915 pidff->set_effect[PID_TRIGGER_BUTTON].value[0] = 0; 916 pidff->set_effect[PID_TRIGGER_REPEAT_INT].value[0] = 0; 917 pidff_set(&pidff->set_effect[PID_GAIN], magnitude); 918 pidff->set_effect[PID_DIRECTION_ENABLE].value[0] = 1; 919 920 /* Omit setting delay field if it's missing */ 921 if (!(pidff->quirks & HID_PIDFF_QUIRK_MISSING_DELAY)) 922 pidff->set_effect[PID_START_DELAY].value[0] = 0; 923 924 hid_hw_request(pidff->hid, pidff->reports[PID_SET_EFFECT], 925 HID_REQ_SET_REPORT); 926 } 927 928 /* 929 * pidff_set_autocenter() handler 930 */ 931 static void pidff_set_autocenter(struct input_dev *dev, u16 magnitude) 932 { 933 pidff_autocenter(dev->ff->private, magnitude); 934 } 935 936 /* 937 * Find fields from a report and fill a pidff_usage 938 */ 939 static int pidff_find_fields(struct pidff_usage *usage, const u8 *table, 940 struct hid_report *report, int count, int strict) 941 { 942 if (!report) { 943 pr_debug("pidff_find_fields, null report\n"); 944 return -1; 945 } 946 947 int i, j, k, found; 948 int return_value = 0; 949 950 for (k = 0; k < count; k++) { 951 found = 0; 952 for (i = 0; i < report->maxfield; i++) { 953 if (report->field[i]->maxusage != 954 report->field[i]->report_count) { 955 pr_debug("maxusage and report_count do not match, skipping\n"); 956 continue; 957 } 958 for (j = 0; j < report->field[i]->maxusage; j++) { 959 if (report->field[i]->usage[j].hid == 960 (HID_UP_PID | table[k])) { 961 pr_debug("found %d at %d->%d\n", 962 k, i, j); 963 usage[k].field = report->field[i]; 964 usage[k].value = 965 &report->field[i]->value[j]; 966 found = 1; 967 break; 968 } 969 } 970 if (found) 971 break; 972 } 973 if (!found && table[k] == pidff_set_effect[PID_START_DELAY]) { 974 pr_debug("Delay field not found, but that's OK\n"); 975 pr_debug("Setting MISSING_DELAY quirk\n"); 976 return_value |= HID_PIDFF_QUIRK_MISSING_DELAY; 977 } 978 else if (!found && table[k] == pidff_set_condition[PID_PARAM_BLOCK_OFFSET]) { 979 pr_debug("PBO field not found, but that's OK\n"); 980 pr_debug("Setting MISSING_PBO quirk\n"); 981 return_value |= HID_PIDFF_QUIRK_MISSING_PBO; 982 } 983 else if (!found && strict) { 984 pr_debug("failed to locate %d\n", k); 985 return -1; 986 } 987 } 988 return return_value; 989 } 990 991 /* 992 * Return index into pidff_reports for the given usage 993 */ 994 static int pidff_check_usage(int usage) 995 { 996 int i; 997 998 for (i = 0; i < sizeof(pidff_reports); i++) 999 if (usage == (HID_UP_PID | pidff_reports[i])) 1000 return i; 1001 1002 return -1; 1003 } 1004 1005 /* 1006 * Find the reports and fill pidff->reports[] 1007 * report_type specifies either OUTPUT or FEATURE reports 1008 */ 1009 static void pidff_find_reports(struct hid_device *hid, int report_type, 1010 struct pidff_device *pidff) 1011 { 1012 struct hid_report *report; 1013 int i, ret; 1014 1015 list_for_each_entry(report, 1016 &hid->report_enum[report_type].report_list, list) { 1017 if (report->maxfield < 1) 1018 continue; 1019 ret = pidff_check_usage(report->field[0]->logical); 1020 if (ret != -1) { 1021 hid_dbg(hid, "found usage 0x%02x from field->logical\n", 1022 pidff_reports[ret]); 1023 pidff->reports[ret] = report; 1024 continue; 1025 } 1026 1027 /* 1028 * Sometimes logical collections are stacked to indicate 1029 * different usages for the report and the field, in which 1030 * case we want the usage of the parent. However, Linux HID 1031 * implementation hides this fact, so we have to dig it up 1032 * ourselves 1033 */ 1034 i = report->field[0]->usage[0].collection_index; 1035 if (i <= 0 || 1036 hid->collection[i - 1].type != HID_COLLECTION_LOGICAL) 1037 continue; 1038 ret = pidff_check_usage(hid->collection[i - 1].usage); 1039 if (ret != -1 && !pidff->reports[ret]) { 1040 hid_dbg(hid, 1041 "found usage 0x%02x from collection array\n", 1042 pidff_reports[ret]); 1043 pidff->reports[ret] = report; 1044 } 1045 } 1046 } 1047 1048 /* 1049 * Test if the required reports have been found 1050 */ 1051 static int pidff_reports_ok(struct pidff_device *pidff) 1052 { 1053 int i; 1054 1055 for (i = 0; i <= PID_REQUIRED_REPORTS; i++) { 1056 if (!pidff->reports[i]) { 1057 hid_dbg(pidff->hid, "%d missing\n", i); 1058 return 0; 1059 } 1060 } 1061 1062 return 1; 1063 } 1064 1065 /* 1066 * Find a field with a specific usage within a report 1067 */ 1068 static struct hid_field *pidff_find_special_field(struct hid_report *report, 1069 int usage, int enforce_min) 1070 { 1071 if (!report) { 1072 pr_debug("pidff_find_special_field, null report\n"); 1073 return NULL; 1074 } 1075 1076 int i; 1077 1078 for (i = 0; i < report->maxfield; i++) { 1079 if (report->field[i]->logical == (HID_UP_PID | usage) && 1080 report->field[i]->report_count > 0) { 1081 if (!enforce_min || 1082 report->field[i]->logical_minimum == 1) 1083 return report->field[i]; 1084 else { 1085 pr_err("logical_minimum is not 1 as it should be\n"); 1086 return NULL; 1087 } 1088 } 1089 } 1090 return NULL; 1091 } 1092 1093 /* 1094 * Fill a pidff->*_id struct table 1095 */ 1096 static int pidff_find_special_keys(int *keys, struct hid_field *fld, 1097 const u8 *usagetable, int count) 1098 { 1099 1100 int i, j; 1101 int found = 0; 1102 1103 for (i = 0; i < count; i++) { 1104 for (j = 0; j < fld->maxusage; j++) { 1105 if (fld->usage[j].hid == (HID_UP_PID | usagetable[i])) { 1106 keys[i] = j + 1; 1107 found++; 1108 break; 1109 } 1110 } 1111 } 1112 return found; 1113 } 1114 1115 #define PIDFF_FIND_SPECIAL_KEYS(keys, field, name) \ 1116 pidff_find_special_keys(pidff->keys, pidff->field, pidff_ ## name, \ 1117 sizeof(pidff_ ## name)) 1118 1119 /* 1120 * Find and check the special fields 1121 */ 1122 static int pidff_find_special_fields(struct pidff_device *pidff) 1123 { 1124 hid_dbg(pidff->hid, "finding special fields\n"); 1125 1126 pidff->create_new_effect_type = 1127 pidff_find_special_field(pidff->reports[PID_CREATE_NEW_EFFECT], 1128 PID_EFFECT_TYPE, 1); 1129 pidff->set_effect_type = 1130 pidff_find_special_field(pidff->reports[PID_SET_EFFECT], 1131 PID_EFFECT_TYPE, 1); 1132 pidff->effect_direction = 1133 pidff_find_special_field(pidff->reports[PID_SET_EFFECT], 1134 PID_DIRECTION, 0); 1135 pidff->device_control = 1136 pidff_find_special_field(pidff->reports[PID_DEVICE_CONTROL], 1137 PID_DEVICE_CONTROL_ARRAY, 1138 !(pidff->quirks & HID_PIDFF_QUIRK_PERMISSIVE_CONTROL)); 1139 1140 pidff->block_load_status = 1141 pidff_find_special_field(pidff->reports[PID_BLOCK_LOAD], 1142 PID_BLOCK_LOAD_STATUS, 1); 1143 pidff->effect_operation_status = 1144 pidff_find_special_field(pidff->reports[PID_EFFECT_OPERATION], 1145 PID_EFFECT_OPERATION_ARRAY, 1); 1146 1147 hid_dbg(pidff->hid, "search done\n"); 1148 1149 if (!pidff->create_new_effect_type || !pidff->set_effect_type) { 1150 hid_err(pidff->hid, "effect lists not found\n"); 1151 return -1; 1152 } 1153 1154 if (!pidff->effect_direction) { 1155 hid_err(pidff->hid, "direction field not found\n"); 1156 return -1; 1157 } 1158 1159 if (!pidff->device_control) { 1160 hid_err(pidff->hid, "device control field not found\n"); 1161 return -1; 1162 } 1163 1164 if (!pidff->block_load_status) { 1165 hid_err(pidff->hid, "block load status field not found\n"); 1166 return -1; 1167 } 1168 1169 if (!pidff->effect_operation_status) { 1170 hid_err(pidff->hid, "effect operation field not found\n"); 1171 return -1; 1172 } 1173 1174 PIDFF_FIND_SPECIAL_KEYS(control_id, device_control, device_control); 1175 1176 if (!PIDFF_FIND_SPECIAL_KEYS(type_id, create_new_effect_type, 1177 effect_types)) { 1178 hid_err(pidff->hid, "no effect types found\n"); 1179 return -1; 1180 } 1181 1182 if (PIDFF_FIND_SPECIAL_KEYS(status_id, block_load_status, 1183 block_load_status) != 1184 sizeof(pidff_block_load_status)) { 1185 hid_err(pidff->hid, 1186 "block load status identifiers not found\n"); 1187 return -1; 1188 } 1189 1190 if (PIDFF_FIND_SPECIAL_KEYS(operation_id, effect_operation_status, 1191 effect_operation_status) != 1192 sizeof(pidff_effect_operation_status)) { 1193 hid_err(pidff->hid, "effect operation identifiers not found\n"); 1194 return -1; 1195 } 1196 1197 return 0; 1198 } 1199 1200 /* 1201 * Find the implemented effect types 1202 */ 1203 static int pidff_find_effects(struct pidff_device *pidff, 1204 struct input_dev *dev) 1205 { 1206 int i; 1207 1208 for (i = 0; i < sizeof(pidff_effect_types); i++) { 1209 int pidff_type = pidff->type_id[i]; 1210 1211 if (pidff->set_effect_type->usage[pidff_type].hid != 1212 pidff->create_new_effect_type->usage[pidff_type].hid) { 1213 hid_err(pidff->hid, 1214 "effect type number %d is invalid\n", i); 1215 return -1; 1216 } 1217 } 1218 1219 if (pidff->type_id[PID_CONSTANT]) 1220 set_bit(FF_CONSTANT, dev->ffbit); 1221 if (pidff->type_id[PID_RAMP]) 1222 set_bit(FF_RAMP, dev->ffbit); 1223 if (pidff->type_id[PID_SQUARE]) { 1224 set_bit(FF_SQUARE, dev->ffbit); 1225 set_bit(FF_PERIODIC, dev->ffbit); 1226 } 1227 if (pidff->type_id[PID_SINE]) { 1228 set_bit(FF_SINE, dev->ffbit); 1229 set_bit(FF_PERIODIC, dev->ffbit); 1230 } 1231 if (pidff->type_id[PID_TRIANGLE]) { 1232 set_bit(FF_TRIANGLE, dev->ffbit); 1233 set_bit(FF_PERIODIC, dev->ffbit); 1234 } 1235 if (pidff->type_id[PID_SAW_UP]) { 1236 set_bit(FF_SAW_UP, dev->ffbit); 1237 set_bit(FF_PERIODIC, dev->ffbit); 1238 } 1239 if (pidff->type_id[PID_SAW_DOWN]) { 1240 set_bit(FF_SAW_DOWN, dev->ffbit); 1241 set_bit(FF_PERIODIC, dev->ffbit); 1242 } 1243 if (pidff->type_id[PID_SPRING]) 1244 set_bit(FF_SPRING, dev->ffbit); 1245 if (pidff->type_id[PID_DAMPER]) 1246 set_bit(FF_DAMPER, dev->ffbit); 1247 if (pidff->type_id[PID_INERTIA]) 1248 set_bit(FF_INERTIA, dev->ffbit); 1249 if (pidff->type_id[PID_FRICTION]) 1250 set_bit(FF_FRICTION, dev->ffbit); 1251 1252 return 0; 1253 } 1254 1255 #define PIDFF_FIND_FIELDS(name, report, strict) \ 1256 pidff_find_fields(pidff->name, pidff_ ## name, \ 1257 pidff->reports[report], \ 1258 sizeof(pidff_ ## name), strict) 1259 1260 /* 1261 * Fill and check the pidff_usages 1262 */ 1263 static int pidff_init_fields(struct pidff_device *pidff, struct input_dev *dev) 1264 { 1265 int status = 0; 1266 1267 /* Save info about the device not having the DELAY ffb field. */ 1268 status = PIDFF_FIND_FIELDS(set_effect, PID_SET_EFFECT, 1); 1269 if (status == -1) { 1270 hid_err(pidff->hid, "unknown set_effect report layout\n"); 1271 return -ENODEV; 1272 } 1273 pidff->quirks |= status; 1274 1275 if (status & HID_PIDFF_QUIRK_MISSING_DELAY) 1276 hid_dbg(pidff->hid, "Adding MISSING_DELAY quirk\n"); 1277 1278 1279 PIDFF_FIND_FIELDS(block_load, PID_BLOCK_LOAD, 0); 1280 if (!pidff->block_load[PID_EFFECT_BLOCK_INDEX].value) { 1281 hid_err(pidff->hid, "unknown pid_block_load report layout\n"); 1282 return -ENODEV; 1283 } 1284 1285 if (PIDFF_FIND_FIELDS(effect_operation, PID_EFFECT_OPERATION, 1)) { 1286 hid_err(pidff->hid, "unknown effect_operation report layout\n"); 1287 return -ENODEV; 1288 } 1289 1290 if (PIDFF_FIND_FIELDS(block_free, PID_BLOCK_FREE, 1)) { 1291 hid_err(pidff->hid, "unknown pid_block_free report layout\n"); 1292 return -ENODEV; 1293 } 1294 1295 if (pidff_find_special_fields(pidff) || pidff_find_effects(pidff, dev)) 1296 return -ENODEV; 1297 1298 if (PIDFF_FIND_FIELDS(set_envelope, PID_SET_ENVELOPE, 1)) { 1299 if (test_and_clear_bit(FF_CONSTANT, dev->ffbit)) 1300 hid_warn(pidff->hid, 1301 "has constant effect but no envelope\n"); 1302 if (test_and_clear_bit(FF_RAMP, dev->ffbit)) 1303 hid_warn(pidff->hid, 1304 "has ramp effect but no envelope\n"); 1305 1306 if (test_and_clear_bit(FF_PERIODIC, dev->ffbit)) 1307 hid_warn(pidff->hid, 1308 "has periodic effect but no envelope\n"); 1309 } 1310 1311 if (test_bit(FF_CONSTANT, dev->ffbit) && 1312 PIDFF_FIND_FIELDS(set_constant, PID_SET_CONSTANT, 1)) { 1313 hid_warn(pidff->hid, "unknown constant effect layout\n"); 1314 clear_bit(FF_CONSTANT, dev->ffbit); 1315 } 1316 1317 if (test_bit(FF_RAMP, dev->ffbit) && 1318 PIDFF_FIND_FIELDS(set_ramp, PID_SET_RAMP, 1)) { 1319 hid_warn(pidff->hid, "unknown ramp effect layout\n"); 1320 clear_bit(FF_RAMP, dev->ffbit); 1321 } 1322 1323 if (test_bit(FF_SPRING, dev->ffbit) || 1324 test_bit(FF_DAMPER, dev->ffbit) || 1325 test_bit(FF_FRICTION, dev->ffbit) || 1326 test_bit(FF_INERTIA, dev->ffbit)) { 1327 status = PIDFF_FIND_FIELDS(set_condition, PID_SET_CONDITION, 1); 1328 1329 if (status < 0) { 1330 hid_warn(pidff->hid, "unknown condition effect layout\n"); 1331 clear_bit(FF_SPRING, dev->ffbit); 1332 clear_bit(FF_DAMPER, dev->ffbit); 1333 clear_bit(FF_FRICTION, dev->ffbit); 1334 clear_bit(FF_INERTIA, dev->ffbit); 1335 } 1336 pidff->quirks |= status; 1337 } 1338 1339 if (test_bit(FF_PERIODIC, dev->ffbit) && 1340 PIDFF_FIND_FIELDS(set_periodic, PID_SET_PERIODIC, 1)) { 1341 hid_warn(pidff->hid, "unknown periodic effect layout\n"); 1342 clear_bit(FF_PERIODIC, dev->ffbit); 1343 } 1344 1345 PIDFF_FIND_FIELDS(pool, PID_POOL, 0); 1346 1347 if (!PIDFF_FIND_FIELDS(device_gain, PID_DEVICE_GAIN, 1)) 1348 set_bit(FF_GAIN, dev->ffbit); 1349 1350 return 0; 1351 } 1352 1353 /* 1354 * Test if autocenter modification is using the supported method 1355 */ 1356 static int pidff_check_autocenter(struct pidff_device *pidff, 1357 struct input_dev *dev) 1358 { 1359 int error; 1360 1361 /* 1362 * Let's find out if autocenter modification is supported 1363 * Specification doesn't specify anything, so we request an 1364 * effect upload and cancel it immediately. If the approved 1365 * effect id was one above the minimum, then we assume the first 1366 * effect id is a built-in spring type effect used for autocenter 1367 */ 1368 1369 error = pidff_request_effect_upload(pidff, 1); 1370 if (error) { 1371 hid_err(pidff->hid, "upload request failed\n"); 1372 return error; 1373 } 1374 1375 if (pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] == 1376 pidff->block_load[PID_EFFECT_BLOCK_INDEX].field->logical_minimum + 1) { 1377 pidff_autocenter(pidff, U16_MAX); 1378 set_bit(FF_AUTOCENTER, dev->ffbit); 1379 } else { 1380 hid_notice(pidff->hid, 1381 "device has unknown autocenter control method\n"); 1382 } 1383 pidff_erase_pid(pidff, 1384 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0]); 1385 1386 return 0; 1387 } 1388 1389 /* 1390 * Check if the device is PID and initialize it 1391 * Set initial quirks 1392 */ 1393 int hid_pidff_init_with_quirks(struct hid_device *hid, u32 initial_quirks) 1394 { 1395 struct pidff_device *pidff; 1396 struct hid_input *hidinput = list_entry(hid->inputs.next, 1397 struct hid_input, list); 1398 struct input_dev *dev = hidinput->input; 1399 struct ff_device *ff; 1400 int max_effects; 1401 int error; 1402 1403 hid_dbg(hid, "starting pid init\n"); 1404 1405 if (list_empty(&hid->report_enum[HID_OUTPUT_REPORT].report_list)) { 1406 hid_dbg(hid, "not a PID device, no output report\n"); 1407 return -ENODEV; 1408 } 1409 1410 pidff = kzalloc(sizeof(*pidff), GFP_KERNEL); 1411 if (!pidff) 1412 return -ENOMEM; 1413 1414 pidff->hid = hid; 1415 pidff->quirks = initial_quirks; 1416 pidff->effect_count = 0; 1417 1418 hid_device_io_start(hid); 1419 1420 pidff_find_reports(hid, HID_OUTPUT_REPORT, pidff); 1421 pidff_find_reports(hid, HID_FEATURE_REPORT, pidff); 1422 1423 if (!pidff_reports_ok(pidff)) { 1424 hid_dbg(hid, "reports not ok, aborting\n"); 1425 error = -ENODEV; 1426 goto fail; 1427 } 1428 1429 error = pidff_init_fields(pidff, dev); 1430 if (error) 1431 goto fail; 1432 1433 /* pool report is sometimes messed up, refetch it */ 1434 pidff_fetch_pool(pidff); 1435 pidff_set_gain_report(pidff, U16_MAX); 1436 error = pidff_check_autocenter(pidff, dev); 1437 if (error) 1438 goto fail; 1439 1440 max_effects = 1441 pidff->block_load[PID_EFFECT_BLOCK_INDEX].field->logical_maximum - 1442 pidff->block_load[PID_EFFECT_BLOCK_INDEX].field->logical_minimum + 1443 1; 1444 hid_dbg(hid, "max effects is %d\n", max_effects); 1445 1446 if (max_effects > PID_EFFECTS_MAX) 1447 max_effects = PID_EFFECTS_MAX; 1448 1449 if (pidff->pool[PID_SIMULTANEOUS_MAX].value) 1450 hid_dbg(hid, "max simultaneous effects is %d\n", 1451 pidff->pool[PID_SIMULTANEOUS_MAX].value[0]); 1452 1453 if (pidff->pool[PID_RAM_POOL_SIZE].value) 1454 hid_dbg(hid, "device memory size is %d bytes\n", 1455 pidff->pool[PID_RAM_POOL_SIZE].value[0]); 1456 1457 if (pidff->pool[PID_DEVICE_MANAGED_POOL].value && 1458 pidff->pool[PID_DEVICE_MANAGED_POOL].value[0] == 0) { 1459 error = -EPERM; 1460 hid_notice(hid, 1461 "device does not support device managed pool\n"); 1462 goto fail; 1463 } 1464 1465 error = input_ff_create(dev, max_effects); 1466 if (error) 1467 goto fail; 1468 1469 ff = dev->ff; 1470 ff->private = pidff; 1471 ff->upload = pidff_upload_effect; 1472 ff->erase = pidff_erase_effect; 1473 ff->set_gain = pidff_set_gain; 1474 ff->set_autocenter = pidff_set_autocenter; 1475 ff->playback = pidff_playback; 1476 1477 hid_info(dev, "Force feedback for USB HID PID devices by Anssi Hannula <anssi.hannula@gmail.com>\n"); 1478 hid_dbg(dev, "Active quirks mask: 0x%x\n", pidff->quirks); 1479 1480 hid_device_io_stop(hid); 1481 1482 return 0; 1483 1484 fail: 1485 hid_device_io_stop(hid); 1486 1487 kfree(pidff); 1488 return error; 1489 } 1490 EXPORT_SYMBOL_GPL(hid_pidff_init_with_quirks); 1491 1492 /* 1493 * Check if the device is PID and initialize it 1494 * Wrapper made to keep the compatibility with old 1495 * init function 1496 */ 1497 int hid_pidff_init(struct hid_device *hid) 1498 { 1499 return hid_pidff_init_with_quirks(hid, 0); 1500 } 1501