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