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