1 /* 2 * Force feedback support for Logitech Gaming Wheels 3 * 4 * Including G27, G25, DFP, DFGT, FFEX, Momo, Momo2 & 5 * Speed Force Wireless (WiiWheel) 6 * 7 * Copyright (c) 2010 Simon Wood <simon@mungewell.org> 8 */ 9 10 /* 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License as published by 13 * the Free Software Foundation; either version 2 of the License, or 14 * (at your option) any later version. 15 * 16 * This program is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 * GNU General Public License for more details. 20 * 21 * You should have received a copy of the GNU General Public License 22 * along with this program; if not, write to the Free Software 23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 24 */ 25 26 27 #include <linux/input.h> 28 #include <linux/usb.h> 29 #include <linux/hid.h> 30 31 #include "usbhid/usbhid.h" 32 #include "hid-lg.h" 33 #include "hid-lg4ff.h" 34 #include "hid-ids.h" 35 36 #define LG4FF_MMODE_IS_MULTIMODE 0 37 #define LG4FF_MMODE_SWITCHED 1 38 #define LG4FF_MMODE_NOT_MULTIMODE 2 39 40 #define LG4FF_MODE_NATIVE_IDX 0 41 #define LG4FF_MODE_DFEX_IDX 1 42 #define LG4FF_MODE_DFP_IDX 2 43 #define LG4FF_MODE_G25_IDX 3 44 #define LG4FF_MODE_DFGT_IDX 4 45 #define LG4FF_MODE_G27_IDX 5 46 #define LG4FF_MODE_G29_IDX 6 47 #define LG4FF_MODE_MAX_IDX 7 48 49 #define LG4FF_MODE_NATIVE BIT(LG4FF_MODE_NATIVE_IDX) 50 #define LG4FF_MODE_DFEX BIT(LG4FF_MODE_DFEX_IDX) 51 #define LG4FF_MODE_DFP BIT(LG4FF_MODE_DFP_IDX) 52 #define LG4FF_MODE_G25 BIT(LG4FF_MODE_G25_IDX) 53 #define LG4FF_MODE_DFGT BIT(LG4FF_MODE_DFGT_IDX) 54 #define LG4FF_MODE_G27 BIT(LG4FF_MODE_G27_IDX) 55 #define LG4FF_MODE_G29 BIT(LG4FF_MODE_G29_IDX) 56 57 #define LG4FF_DFEX_TAG "DF-EX" 58 #define LG4FF_DFEX_NAME "Driving Force / Formula EX" 59 #define LG4FF_DFP_TAG "DFP" 60 #define LG4FF_DFP_NAME "Driving Force Pro" 61 #define LG4FF_G25_TAG "G25" 62 #define LG4FF_G25_NAME "G25 Racing Wheel" 63 #define LG4FF_G27_TAG "G27" 64 #define LG4FF_G27_NAME "G27 Racing Wheel" 65 #define LG4FF_G29_TAG "G29" 66 #define LG4FF_G29_NAME "G29 Racing Wheel" 67 #define LG4FF_DFGT_TAG "DFGT" 68 #define LG4FF_DFGT_NAME "Driving Force GT" 69 70 #define LG4FF_FFEX_REV_MAJ 0x21 71 #define LG4FF_FFEX_REV_MIN 0x00 72 73 static void lg4ff_set_range_dfp(struct hid_device *hid, u16 range); 74 static void lg4ff_set_range_g25(struct hid_device *hid, u16 range); 75 76 struct lg4ff_wheel_data { 77 const u32 product_id; 78 u16 combine; 79 u16 range; 80 const u16 min_range; 81 const u16 max_range; 82 #ifdef CONFIG_LEDS_CLASS 83 u8 led_state; 84 struct led_classdev *led[5]; 85 #endif 86 const u32 alternate_modes; 87 const char * const real_tag; 88 const char * const real_name; 89 const u16 real_product_id; 90 91 void (*set_range)(struct hid_device *hid, u16 range); 92 }; 93 94 struct lg4ff_device_entry { 95 spinlock_t report_lock; /* Protect output HID report */ 96 struct hid_report *report; 97 struct lg4ff_wheel_data wdata; 98 }; 99 100 static const signed short lg4ff_wheel_effects[] = { 101 FF_CONSTANT, 102 FF_AUTOCENTER, 103 -1 104 }; 105 106 static const signed short no_wheel_effects[] = { 107 -1 108 }; 109 110 struct lg4ff_wheel { 111 const u32 product_id; 112 const signed short *ff_effects; 113 const u16 min_range; 114 const u16 max_range; 115 void (*set_range)(struct hid_device *hid, u16 range); 116 }; 117 118 struct lg4ff_compat_mode_switch { 119 const u8 cmd_count; /* Number of commands to send */ 120 const u8 cmd[]; 121 }; 122 123 struct lg4ff_wheel_ident_info { 124 const u32 modes; 125 const u16 mask; 126 const u16 result; 127 const u16 real_product_id; 128 }; 129 130 struct lg4ff_multimode_wheel { 131 const u16 product_id; 132 const u32 alternate_modes; 133 const char *real_tag; 134 const char *real_name; 135 }; 136 137 struct lg4ff_alternate_mode { 138 const u16 product_id; 139 const char *tag; 140 const char *name; 141 }; 142 143 static const struct lg4ff_wheel lg4ff_devices[] = { 144 {USB_DEVICE_ID_LOGITECH_WINGMAN_FG, no_wheel_effects, 40, 180, NULL}, 145 {USB_DEVICE_ID_LOGITECH_WINGMAN_FFG, lg4ff_wheel_effects, 40, 180, NULL}, 146 {USB_DEVICE_ID_LOGITECH_WHEEL, lg4ff_wheel_effects, 40, 270, NULL}, 147 {USB_DEVICE_ID_LOGITECH_MOMO_WHEEL, lg4ff_wheel_effects, 40, 270, NULL}, 148 {USB_DEVICE_ID_LOGITECH_DFP_WHEEL, lg4ff_wheel_effects, 40, 900, lg4ff_set_range_dfp}, 149 {USB_DEVICE_ID_LOGITECH_G25_WHEEL, lg4ff_wheel_effects, 40, 900, lg4ff_set_range_g25}, 150 {USB_DEVICE_ID_LOGITECH_DFGT_WHEEL, lg4ff_wheel_effects, 40, 900, lg4ff_set_range_g25}, 151 {USB_DEVICE_ID_LOGITECH_G27_WHEEL, lg4ff_wheel_effects, 40, 900, lg4ff_set_range_g25}, 152 {USB_DEVICE_ID_LOGITECH_G29_WHEEL, lg4ff_wheel_effects, 40, 900, lg4ff_set_range_g25}, 153 {USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2, lg4ff_wheel_effects, 40, 270, NULL}, 154 {USB_DEVICE_ID_LOGITECH_WII_WHEEL, lg4ff_wheel_effects, 40, 270, NULL} 155 }; 156 157 static const struct lg4ff_multimode_wheel lg4ff_multimode_wheels[] = { 158 {USB_DEVICE_ID_LOGITECH_DFP_WHEEL, 159 LG4FF_MODE_NATIVE | LG4FF_MODE_DFP | LG4FF_MODE_DFEX, 160 LG4FF_DFP_TAG, LG4FF_DFP_NAME}, 161 {USB_DEVICE_ID_LOGITECH_G25_WHEEL, 162 LG4FF_MODE_NATIVE | LG4FF_MODE_G25 | LG4FF_MODE_DFP | LG4FF_MODE_DFEX, 163 LG4FF_G25_TAG, LG4FF_G25_NAME}, 164 {USB_DEVICE_ID_LOGITECH_DFGT_WHEEL, 165 LG4FF_MODE_NATIVE | LG4FF_MODE_DFGT | LG4FF_MODE_DFP | LG4FF_MODE_DFEX, 166 LG4FF_DFGT_TAG, LG4FF_DFGT_NAME}, 167 {USB_DEVICE_ID_LOGITECH_G27_WHEEL, 168 LG4FF_MODE_NATIVE | LG4FF_MODE_G27 | LG4FF_MODE_G25 | LG4FF_MODE_DFP | LG4FF_MODE_DFEX, 169 LG4FF_G27_TAG, LG4FF_G27_NAME}, 170 {USB_DEVICE_ID_LOGITECH_G29_WHEEL, 171 LG4FF_MODE_NATIVE | LG4FF_MODE_G29 | LG4FF_MODE_G27 | LG4FF_MODE_G25 | LG4FF_MODE_DFGT | LG4FF_MODE_DFP | LG4FF_MODE_DFEX, 172 LG4FF_G29_TAG, LG4FF_G29_NAME}, 173 }; 174 175 static const struct lg4ff_alternate_mode lg4ff_alternate_modes[] = { 176 [LG4FF_MODE_NATIVE_IDX] = {0, "native", ""}, 177 [LG4FF_MODE_DFEX_IDX] = {USB_DEVICE_ID_LOGITECH_WHEEL, LG4FF_DFEX_TAG, LG4FF_DFEX_NAME}, 178 [LG4FF_MODE_DFP_IDX] = {USB_DEVICE_ID_LOGITECH_DFP_WHEEL, LG4FF_DFP_TAG, LG4FF_DFP_NAME}, 179 [LG4FF_MODE_G25_IDX] = {USB_DEVICE_ID_LOGITECH_G25_WHEEL, LG4FF_G25_TAG, LG4FF_G25_NAME}, 180 [LG4FF_MODE_DFGT_IDX] = {USB_DEVICE_ID_LOGITECH_DFGT_WHEEL, LG4FF_DFGT_TAG, LG4FF_DFGT_NAME}, 181 [LG4FF_MODE_G27_IDX] = {USB_DEVICE_ID_LOGITECH_G27_WHEEL, LG4FF_G27_TAG, LG4FF_G27_NAME}, 182 [LG4FF_MODE_G29_IDX] = {USB_DEVICE_ID_LOGITECH_G29_WHEEL, LG4FF_G29_TAG, LG4FF_G29_NAME}, 183 }; 184 185 /* Multimode wheel identificators */ 186 static const struct lg4ff_wheel_ident_info lg4ff_dfp_ident_info = { 187 LG4FF_MODE_DFP | LG4FF_MODE_DFEX, 188 0xf000, 189 0x1000, 190 USB_DEVICE_ID_LOGITECH_DFP_WHEEL 191 }; 192 193 static const struct lg4ff_wheel_ident_info lg4ff_g25_ident_info = { 194 LG4FF_MODE_G25 | LG4FF_MODE_DFP | LG4FF_MODE_DFEX, 195 0xff00, 196 0x1200, 197 USB_DEVICE_ID_LOGITECH_G25_WHEEL 198 }; 199 200 static const struct lg4ff_wheel_ident_info lg4ff_g27_ident_info = { 201 LG4FF_MODE_G27 | LG4FF_MODE_G25 | LG4FF_MODE_DFP | LG4FF_MODE_DFEX, 202 0xfff0, 203 0x1230, 204 USB_DEVICE_ID_LOGITECH_G27_WHEEL 205 }; 206 207 static const struct lg4ff_wheel_ident_info lg4ff_dfgt_ident_info = { 208 LG4FF_MODE_DFGT | LG4FF_MODE_DFP | LG4FF_MODE_DFEX, 209 0xff00, 210 0x1300, 211 USB_DEVICE_ID_LOGITECH_DFGT_WHEEL 212 }; 213 214 static const struct lg4ff_wheel_ident_info lg4ff_g29_ident_info = { 215 LG4FF_MODE_G29 | LG4FF_MODE_G27 | LG4FF_MODE_G25 | LG4FF_MODE_DFGT | LG4FF_MODE_DFP | LG4FF_MODE_DFEX, 216 0xfff8, 217 0x1350, 218 USB_DEVICE_ID_LOGITECH_G29_WHEEL 219 }; 220 221 static const struct lg4ff_wheel_ident_info lg4ff_g29_ident_info2 = { 222 LG4FF_MODE_G29 | LG4FF_MODE_G27 | LG4FF_MODE_G25 | LG4FF_MODE_DFGT | LG4FF_MODE_DFP | LG4FF_MODE_DFEX, 223 0xff00, 224 0x8900, 225 USB_DEVICE_ID_LOGITECH_G29_WHEEL 226 }; 227 228 /* Multimode wheel identification checklists */ 229 static const struct lg4ff_wheel_ident_info *lg4ff_main_checklist[] = { 230 &lg4ff_g29_ident_info, 231 &lg4ff_g29_ident_info2, 232 &lg4ff_dfgt_ident_info, 233 &lg4ff_g27_ident_info, 234 &lg4ff_g25_ident_info, 235 &lg4ff_dfp_ident_info 236 }; 237 238 /* Compatibility mode switching commands */ 239 /* EXT_CMD9 - Understood by G27 and DFGT */ 240 static const struct lg4ff_compat_mode_switch lg4ff_mode_switch_ext09_dfex = { 241 2, 242 {0xf8, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, /* Revert mode upon USB reset */ 243 0xf8, 0x09, 0x00, 0x01, 0x00, 0x00, 0x00} /* Switch mode to DF-EX with detach */ 244 }; 245 246 static const struct lg4ff_compat_mode_switch lg4ff_mode_switch_ext09_dfp = { 247 2, 248 {0xf8, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, /* Revert mode upon USB reset */ 249 0xf8, 0x09, 0x01, 0x01, 0x00, 0x00, 0x00} /* Switch mode to DFP with detach */ 250 }; 251 252 static const struct lg4ff_compat_mode_switch lg4ff_mode_switch_ext09_g25 = { 253 2, 254 {0xf8, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, /* Revert mode upon USB reset */ 255 0xf8, 0x09, 0x02, 0x01, 0x00, 0x00, 0x00} /* Switch mode to G25 with detach */ 256 }; 257 258 static const struct lg4ff_compat_mode_switch lg4ff_mode_switch_ext09_dfgt = { 259 2, 260 {0xf8, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, /* Revert mode upon USB reset */ 261 0xf8, 0x09, 0x03, 0x01, 0x00, 0x00, 0x00} /* Switch mode to DFGT with detach */ 262 }; 263 264 static const struct lg4ff_compat_mode_switch lg4ff_mode_switch_ext09_g27 = { 265 2, 266 {0xf8, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, /* Revert mode upon USB reset */ 267 0xf8, 0x09, 0x04, 0x01, 0x00, 0x00, 0x00} /* Switch mode to G27 with detach */ 268 }; 269 270 static const struct lg4ff_compat_mode_switch lg4ff_mode_switch_ext09_g29 = { 271 2, 272 {0xf8, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, /* Revert mode upon USB reset */ 273 0xf8, 0x09, 0x05, 0x01, 0x01, 0x00, 0x00} /* Switch mode to G29 with detach */ 274 }; 275 276 /* EXT_CMD1 - Understood by DFP, G25, G27 and DFGT */ 277 static const struct lg4ff_compat_mode_switch lg4ff_mode_switch_ext01_dfp = { 278 1, 279 {0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00} 280 }; 281 282 /* EXT_CMD16 - Understood by G25 and G27 */ 283 static const struct lg4ff_compat_mode_switch lg4ff_mode_switch_ext16_g25 = { 284 1, 285 {0xf8, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00} 286 }; 287 288 /* Recalculates X axis value accordingly to currently selected range */ 289 static s32 lg4ff_adjust_dfp_x_axis(s32 value, u16 range) 290 { 291 u16 max_range; 292 s32 new_value; 293 294 if (range == 900) 295 return value; 296 else if (range == 200) 297 return value; 298 else if (range < 200) 299 max_range = 200; 300 else 301 max_range = 900; 302 303 new_value = 8192 + mult_frac(value - 8192, max_range, range); 304 if (new_value < 0) 305 return 0; 306 else if (new_value > 16383) 307 return 16383; 308 else 309 return new_value; 310 } 311 312 int lg4ff_adjust_input_event(struct hid_device *hid, struct hid_field *field, 313 struct hid_usage *usage, s32 value, struct lg_drv_data *drv_data) 314 { 315 struct lg4ff_device_entry *entry = drv_data->device_props; 316 s32 new_value = 0; 317 318 if (!entry) { 319 hid_err(hid, "Device properties not found"); 320 return 0; 321 } 322 323 switch (entry->wdata.product_id) { 324 case USB_DEVICE_ID_LOGITECH_DFP_WHEEL: 325 switch (usage->code) { 326 case ABS_X: 327 new_value = lg4ff_adjust_dfp_x_axis(value, entry->wdata.range); 328 input_event(field->hidinput->input, usage->type, usage->code, new_value); 329 return 1; 330 default: 331 return 0; 332 } 333 default: 334 return 0; 335 } 336 } 337 338 int lg4ff_raw_event(struct hid_device *hdev, struct hid_report *report, 339 u8 *rd, int size, struct lg_drv_data *drv_data) 340 { 341 int offset; 342 struct lg4ff_device_entry *entry = drv_data->device_props; 343 344 if (!entry) 345 return 0; 346 347 /* adjust HID report present combined pedals data */ 348 if (entry->wdata.combine) { 349 switch (entry->wdata.product_id) { 350 case USB_DEVICE_ID_LOGITECH_WHEEL: 351 rd[5] = rd[3]; 352 rd[6] = 0x7F; 353 return 1; 354 case USB_DEVICE_ID_LOGITECH_WINGMAN_FG: 355 case USB_DEVICE_ID_LOGITECH_WINGMAN_FFG: 356 case USB_DEVICE_ID_LOGITECH_MOMO_WHEEL: 357 case USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2: 358 rd[4] = rd[3]; 359 rd[5] = 0x7F; 360 return 1; 361 case USB_DEVICE_ID_LOGITECH_DFP_WHEEL: 362 rd[5] = rd[4]; 363 rd[6] = 0x7F; 364 return 1; 365 case USB_DEVICE_ID_LOGITECH_G25_WHEEL: 366 case USB_DEVICE_ID_LOGITECH_G27_WHEEL: 367 offset = 5; 368 break; 369 case USB_DEVICE_ID_LOGITECH_DFGT_WHEEL: 370 case USB_DEVICE_ID_LOGITECH_G29_WHEEL: 371 offset = 6; 372 break; 373 case USB_DEVICE_ID_LOGITECH_WII_WHEEL: 374 offset = 3; 375 break; 376 default: 377 return 0; 378 } 379 380 /* Compute a combined axis when wheel does not supply it */ 381 rd[offset] = (0xFF + rd[offset] - rd[offset+1]) >> 1; 382 rd[offset+1] = 0x7F; 383 return 1; 384 } 385 386 return 0; 387 } 388 389 static void lg4ff_init_wheel_data(struct lg4ff_wheel_data * const wdata, const struct lg4ff_wheel *wheel, 390 const struct lg4ff_multimode_wheel *mmode_wheel, 391 const u16 real_product_id) 392 { 393 u32 alternate_modes = 0; 394 const char *real_tag = NULL; 395 const char *real_name = NULL; 396 397 if (mmode_wheel) { 398 alternate_modes = mmode_wheel->alternate_modes; 399 real_tag = mmode_wheel->real_tag; 400 real_name = mmode_wheel->real_name; 401 } 402 403 { 404 struct lg4ff_wheel_data t_wdata = { .product_id = wheel->product_id, 405 .real_product_id = real_product_id, 406 .combine = 0, 407 .min_range = wheel->min_range, 408 .max_range = wheel->max_range, 409 .set_range = wheel->set_range, 410 .alternate_modes = alternate_modes, 411 .real_tag = real_tag, 412 .real_name = real_name }; 413 414 memcpy(wdata, &t_wdata, sizeof(t_wdata)); 415 } 416 } 417 418 static int lg4ff_play(struct input_dev *dev, void *data, struct ff_effect *effect) 419 { 420 struct hid_device *hid = input_get_drvdata(dev); 421 struct lg4ff_device_entry *entry; 422 struct lg_drv_data *drv_data; 423 unsigned long flags; 424 s32 *value; 425 int x; 426 427 drv_data = hid_get_drvdata(hid); 428 if (!drv_data) { 429 hid_err(hid, "Private driver data not found!\n"); 430 return -EINVAL; 431 } 432 433 entry = drv_data->device_props; 434 if (!entry) { 435 hid_err(hid, "Device properties not found!\n"); 436 return -EINVAL; 437 } 438 value = entry->report->field[0]->value; 439 440 #define CLAMP(x) do { if (x < 0) x = 0; else if (x > 0xff) x = 0xff; } while (0) 441 442 switch (effect->type) { 443 case FF_CONSTANT: 444 x = effect->u.ramp.start_level + 0x80; /* 0x80 is no force */ 445 CLAMP(x); 446 447 spin_lock_irqsave(&entry->report_lock, flags); 448 if (x == 0x80) { 449 /* De-activate force in slot-1*/ 450 value[0] = 0x13; 451 value[1] = 0x00; 452 value[2] = 0x00; 453 value[3] = 0x00; 454 value[4] = 0x00; 455 value[5] = 0x00; 456 value[6] = 0x00; 457 458 hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT); 459 spin_unlock_irqrestore(&entry->report_lock, flags); 460 return 0; 461 } 462 463 value[0] = 0x11; /* Slot 1 */ 464 value[1] = 0x08; 465 value[2] = x; 466 value[3] = 0x80; 467 value[4] = 0x00; 468 value[5] = 0x00; 469 value[6] = 0x00; 470 471 hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT); 472 spin_unlock_irqrestore(&entry->report_lock, flags); 473 break; 474 } 475 return 0; 476 } 477 478 /* Sends default autocentering command compatible with 479 * all wheels except Formula Force EX */ 480 static void lg4ff_set_autocenter_default(struct input_dev *dev, u16 magnitude) 481 { 482 struct hid_device *hid = input_get_drvdata(dev); 483 s32 *value; 484 u32 expand_a, expand_b; 485 struct lg4ff_device_entry *entry; 486 struct lg_drv_data *drv_data; 487 unsigned long flags; 488 489 drv_data = hid_get_drvdata(hid); 490 if (!drv_data) { 491 hid_err(hid, "Private driver data not found!\n"); 492 return; 493 } 494 495 entry = drv_data->device_props; 496 if (!entry) { 497 hid_err(hid, "Device properties not found!\n"); 498 return; 499 } 500 value = entry->report->field[0]->value; 501 502 /* De-activate Auto-Center */ 503 spin_lock_irqsave(&entry->report_lock, flags); 504 if (magnitude == 0) { 505 value[0] = 0xf5; 506 value[1] = 0x00; 507 value[2] = 0x00; 508 value[3] = 0x00; 509 value[4] = 0x00; 510 value[5] = 0x00; 511 value[6] = 0x00; 512 513 hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT); 514 spin_unlock_irqrestore(&entry->report_lock, flags); 515 return; 516 } 517 518 if (magnitude <= 0xaaaa) { 519 expand_a = 0x0c * magnitude; 520 expand_b = 0x80 * magnitude; 521 } else { 522 expand_a = (0x0c * 0xaaaa) + 0x06 * (magnitude - 0xaaaa); 523 expand_b = (0x80 * 0xaaaa) + 0xff * (magnitude - 0xaaaa); 524 } 525 526 /* Adjust for non-MOMO wheels */ 527 switch (entry->wdata.product_id) { 528 case USB_DEVICE_ID_LOGITECH_MOMO_WHEEL: 529 case USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2: 530 break; 531 default: 532 expand_a = expand_a >> 1; 533 break; 534 } 535 536 value[0] = 0xfe; 537 value[1] = 0x0d; 538 value[2] = expand_a / 0xaaaa; 539 value[3] = expand_a / 0xaaaa; 540 value[4] = expand_b / 0xaaaa; 541 value[5] = 0x00; 542 value[6] = 0x00; 543 544 hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT); 545 546 /* Activate Auto-Center */ 547 value[0] = 0x14; 548 value[1] = 0x00; 549 value[2] = 0x00; 550 value[3] = 0x00; 551 value[4] = 0x00; 552 value[5] = 0x00; 553 value[6] = 0x00; 554 555 hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT); 556 spin_unlock_irqrestore(&entry->report_lock, flags); 557 } 558 559 /* Sends autocentering command compatible with Formula Force EX */ 560 static void lg4ff_set_autocenter_ffex(struct input_dev *dev, u16 magnitude) 561 { 562 struct hid_device *hid = input_get_drvdata(dev); 563 struct lg4ff_device_entry *entry; 564 struct lg_drv_data *drv_data; 565 unsigned long flags; 566 s32 *value; 567 magnitude = magnitude * 90 / 65535; 568 569 drv_data = hid_get_drvdata(hid); 570 if (!drv_data) { 571 hid_err(hid, "Private driver data not found!\n"); 572 return; 573 } 574 575 entry = drv_data->device_props; 576 if (!entry) { 577 hid_err(hid, "Device properties not found!\n"); 578 return; 579 } 580 value = entry->report->field[0]->value; 581 582 spin_lock_irqsave(&entry->report_lock, flags); 583 value[0] = 0xfe; 584 value[1] = 0x03; 585 value[2] = magnitude >> 14; 586 value[3] = magnitude >> 14; 587 value[4] = magnitude; 588 value[5] = 0x00; 589 value[6] = 0x00; 590 591 hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT); 592 spin_unlock_irqrestore(&entry->report_lock, flags); 593 } 594 595 /* Sends command to set range compatible with G25/G27/Driving Force GT */ 596 static void lg4ff_set_range_g25(struct hid_device *hid, u16 range) 597 { 598 struct lg4ff_device_entry *entry; 599 struct lg_drv_data *drv_data; 600 unsigned long flags; 601 s32 *value; 602 603 drv_data = hid_get_drvdata(hid); 604 if (!drv_data) { 605 hid_err(hid, "Private driver data not found!\n"); 606 return; 607 } 608 609 entry = drv_data->device_props; 610 if (!entry) { 611 hid_err(hid, "Device properties not found!\n"); 612 return; 613 } 614 value = entry->report->field[0]->value; 615 dbg_hid("G25/G27/DFGT: setting range to %u\n", range); 616 617 spin_lock_irqsave(&entry->report_lock, flags); 618 value[0] = 0xf8; 619 value[1] = 0x81; 620 value[2] = range & 0x00ff; 621 value[3] = (range & 0xff00) >> 8; 622 value[4] = 0x00; 623 value[5] = 0x00; 624 value[6] = 0x00; 625 626 hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT); 627 spin_unlock_irqrestore(&entry->report_lock, flags); 628 } 629 630 /* Sends commands to set range compatible with Driving Force Pro wheel */ 631 static void lg4ff_set_range_dfp(struct hid_device *hid, u16 range) 632 { 633 struct lg4ff_device_entry *entry; 634 struct lg_drv_data *drv_data; 635 unsigned long flags; 636 int start_left, start_right, full_range; 637 s32 *value; 638 639 drv_data = hid_get_drvdata(hid); 640 if (!drv_data) { 641 hid_err(hid, "Private driver data not found!\n"); 642 return; 643 } 644 645 entry = drv_data->device_props; 646 if (!entry) { 647 hid_err(hid, "Device properties not found!\n"); 648 return; 649 } 650 value = entry->report->field[0]->value; 651 dbg_hid("Driving Force Pro: setting range to %u\n", range); 652 653 /* Prepare "coarse" limit command */ 654 spin_lock_irqsave(&entry->report_lock, flags); 655 value[0] = 0xf8; 656 value[1] = 0x00; /* Set later */ 657 value[2] = 0x00; 658 value[3] = 0x00; 659 value[4] = 0x00; 660 value[5] = 0x00; 661 value[6] = 0x00; 662 663 if (range > 200) { 664 value[1] = 0x03; 665 full_range = 900; 666 } else { 667 value[1] = 0x02; 668 full_range = 200; 669 } 670 hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT); 671 672 /* Prepare "fine" limit command */ 673 value[0] = 0x81; 674 value[1] = 0x0b; 675 value[2] = 0x00; 676 value[3] = 0x00; 677 value[4] = 0x00; 678 value[5] = 0x00; 679 value[6] = 0x00; 680 681 if (range == 200 || range == 900) { /* Do not apply any fine limit */ 682 hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT); 683 spin_unlock_irqrestore(&entry->report_lock, flags); 684 return; 685 } 686 687 /* Construct fine limit command */ 688 start_left = (((full_range - range + 1) * 2047) / full_range); 689 start_right = 0xfff - start_left; 690 691 value[2] = start_left >> 4; 692 value[3] = start_right >> 4; 693 value[4] = 0xff; 694 value[5] = (start_right & 0xe) << 4 | (start_left & 0xe); 695 value[6] = 0xff; 696 697 hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT); 698 spin_unlock_irqrestore(&entry->report_lock, flags); 699 } 700 701 static const struct lg4ff_compat_mode_switch *lg4ff_get_mode_switch_command(const u16 real_product_id, const u16 target_product_id) 702 { 703 switch (real_product_id) { 704 case USB_DEVICE_ID_LOGITECH_DFP_WHEEL: 705 switch (target_product_id) { 706 case USB_DEVICE_ID_LOGITECH_DFP_WHEEL: 707 return &lg4ff_mode_switch_ext01_dfp; 708 /* DFP can only be switched to its native mode */ 709 default: 710 return NULL; 711 } 712 break; 713 case USB_DEVICE_ID_LOGITECH_G25_WHEEL: 714 switch (target_product_id) { 715 case USB_DEVICE_ID_LOGITECH_DFP_WHEEL: 716 return &lg4ff_mode_switch_ext01_dfp; 717 case USB_DEVICE_ID_LOGITECH_G25_WHEEL: 718 return &lg4ff_mode_switch_ext16_g25; 719 /* G25 can only be switched to DFP mode or its native mode */ 720 default: 721 return NULL; 722 } 723 break; 724 case USB_DEVICE_ID_LOGITECH_G27_WHEEL: 725 switch (target_product_id) { 726 case USB_DEVICE_ID_LOGITECH_WHEEL: 727 return &lg4ff_mode_switch_ext09_dfex; 728 case USB_DEVICE_ID_LOGITECH_DFP_WHEEL: 729 return &lg4ff_mode_switch_ext09_dfp; 730 case USB_DEVICE_ID_LOGITECH_G25_WHEEL: 731 return &lg4ff_mode_switch_ext09_g25; 732 case USB_DEVICE_ID_LOGITECH_G27_WHEEL: 733 return &lg4ff_mode_switch_ext09_g27; 734 /* G27 can only be switched to DF-EX, DFP, G25 or its native mode */ 735 default: 736 return NULL; 737 } 738 break; 739 case USB_DEVICE_ID_LOGITECH_G29_WHEEL: 740 switch (target_product_id) { 741 case USB_DEVICE_ID_LOGITECH_DFP_WHEEL: 742 return &lg4ff_mode_switch_ext09_dfp; 743 case USB_DEVICE_ID_LOGITECH_DFGT_WHEEL: 744 return &lg4ff_mode_switch_ext09_dfgt; 745 case USB_DEVICE_ID_LOGITECH_G25_WHEEL: 746 return &lg4ff_mode_switch_ext09_g25; 747 case USB_DEVICE_ID_LOGITECH_G27_WHEEL: 748 return &lg4ff_mode_switch_ext09_g27; 749 case USB_DEVICE_ID_LOGITECH_G29_WHEEL: 750 return &lg4ff_mode_switch_ext09_g29; 751 /* G29 can only be switched to DF-EX, DFP, DFGT, G25, G27 or its native mode */ 752 default: 753 return NULL; 754 } 755 break; 756 case USB_DEVICE_ID_LOGITECH_DFGT_WHEEL: 757 switch (target_product_id) { 758 case USB_DEVICE_ID_LOGITECH_WHEEL: 759 return &lg4ff_mode_switch_ext09_dfex; 760 case USB_DEVICE_ID_LOGITECH_DFP_WHEEL: 761 return &lg4ff_mode_switch_ext09_dfp; 762 case USB_DEVICE_ID_LOGITECH_DFGT_WHEEL: 763 return &lg4ff_mode_switch_ext09_dfgt; 764 /* DFGT can only be switched to DF-EX, DFP or its native mode */ 765 default: 766 return NULL; 767 } 768 break; 769 /* No other wheels have multiple modes */ 770 default: 771 return NULL; 772 } 773 } 774 775 static int lg4ff_switch_compatibility_mode(struct hid_device *hid, const struct lg4ff_compat_mode_switch *s) 776 { 777 struct lg4ff_device_entry *entry; 778 struct lg_drv_data *drv_data; 779 unsigned long flags; 780 s32 *value; 781 u8 i; 782 783 drv_data = hid_get_drvdata(hid); 784 if (!drv_data) { 785 hid_err(hid, "Private driver data not found!\n"); 786 return -EINVAL; 787 } 788 789 entry = drv_data->device_props; 790 if (!entry) { 791 hid_err(hid, "Device properties not found!\n"); 792 return -EINVAL; 793 } 794 value = entry->report->field[0]->value; 795 796 spin_lock_irqsave(&entry->report_lock, flags); 797 for (i = 0; i < s->cmd_count; i++) { 798 u8 j; 799 800 for (j = 0; j < 7; j++) 801 value[j] = s->cmd[j + (7*i)]; 802 803 hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT); 804 } 805 spin_unlock_irqrestore(&entry->report_lock, flags); 806 hid_hw_wait(hid); 807 return 0; 808 } 809 810 static ssize_t lg4ff_alternate_modes_show(struct device *dev, struct device_attribute *attr, char *buf) 811 { 812 struct hid_device *hid = to_hid_device(dev); 813 struct lg4ff_device_entry *entry; 814 struct lg_drv_data *drv_data; 815 ssize_t count = 0; 816 int i; 817 818 drv_data = hid_get_drvdata(hid); 819 if (!drv_data) { 820 hid_err(hid, "Private driver data not found!\n"); 821 return 0; 822 } 823 824 entry = drv_data->device_props; 825 if (!entry) { 826 hid_err(hid, "Device properties not found!\n"); 827 return 0; 828 } 829 830 if (!entry->wdata.real_name) { 831 hid_err(hid, "NULL pointer to string\n"); 832 return 0; 833 } 834 835 for (i = 0; i < LG4FF_MODE_MAX_IDX; i++) { 836 if (entry->wdata.alternate_modes & BIT(i)) { 837 /* Print tag and full name */ 838 count += scnprintf(buf + count, PAGE_SIZE - count, "%s: %s", 839 lg4ff_alternate_modes[i].tag, 840 !lg4ff_alternate_modes[i].product_id ? entry->wdata.real_name : lg4ff_alternate_modes[i].name); 841 if (count >= PAGE_SIZE - 1) 842 return count; 843 844 /* Mark the currently active mode with an asterisk */ 845 if (lg4ff_alternate_modes[i].product_id == entry->wdata.product_id || 846 (lg4ff_alternate_modes[i].product_id == 0 && entry->wdata.product_id == entry->wdata.real_product_id)) 847 count += scnprintf(buf + count, PAGE_SIZE - count, " *\n"); 848 else 849 count += scnprintf(buf + count, PAGE_SIZE - count, "\n"); 850 851 if (count >= PAGE_SIZE - 1) 852 return count; 853 } 854 } 855 856 return count; 857 } 858 859 static ssize_t lg4ff_alternate_modes_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 860 { 861 struct hid_device *hid = to_hid_device(dev); 862 struct lg4ff_device_entry *entry; 863 struct lg_drv_data *drv_data; 864 const struct lg4ff_compat_mode_switch *s; 865 u16 target_product_id = 0; 866 int i, ret; 867 char *lbuf; 868 869 drv_data = hid_get_drvdata(hid); 870 if (!drv_data) { 871 hid_err(hid, "Private driver data not found!\n"); 872 return -EINVAL; 873 } 874 875 entry = drv_data->device_props; 876 if (!entry) { 877 hid_err(hid, "Device properties not found!\n"); 878 return -EINVAL; 879 } 880 881 /* Allow \n at the end of the input parameter */ 882 lbuf = kasprintf(GFP_KERNEL, "%s", buf); 883 if (!lbuf) 884 return -ENOMEM; 885 886 i = strlen(lbuf); 887 if (lbuf[i-1] == '\n') { 888 if (i == 1) { 889 kfree(lbuf); 890 return -EINVAL; 891 } 892 lbuf[i-1] = '\0'; 893 } 894 895 for (i = 0; i < LG4FF_MODE_MAX_IDX; i++) { 896 const u16 mode_product_id = lg4ff_alternate_modes[i].product_id; 897 const char *tag = lg4ff_alternate_modes[i].tag; 898 899 if (entry->wdata.alternate_modes & BIT(i)) { 900 if (!strcmp(tag, lbuf)) { 901 if (!mode_product_id) 902 target_product_id = entry->wdata.real_product_id; 903 else 904 target_product_id = mode_product_id; 905 break; 906 } 907 } 908 } 909 910 if (i == LG4FF_MODE_MAX_IDX) { 911 hid_info(hid, "Requested mode \"%s\" is not supported by the device\n", lbuf); 912 kfree(lbuf); 913 return -EINVAL; 914 } 915 kfree(lbuf); /* Not needed anymore */ 916 917 if (target_product_id == entry->wdata.product_id) /* Nothing to do */ 918 return count; 919 920 /* Automatic switching has to be disabled for the switch to DF-EX mode to work correctly */ 921 if (target_product_id == USB_DEVICE_ID_LOGITECH_WHEEL && !lg4ff_no_autoswitch) { 922 hid_info(hid, "\"%s\" cannot be switched to \"DF-EX\" mode. Load the \"hid_logitech\" module with \"lg4ff_no_autoswitch=1\" parameter set and try again\n", 923 entry->wdata.real_name); 924 return -EINVAL; 925 } 926 927 /* Take care of hardware limitations */ 928 if ((entry->wdata.real_product_id == USB_DEVICE_ID_LOGITECH_DFP_WHEEL || entry->wdata.real_product_id == USB_DEVICE_ID_LOGITECH_G25_WHEEL) && 929 entry->wdata.product_id > target_product_id) { 930 hid_info(hid, "\"%s\" cannot be switched back into \"%s\" mode\n", entry->wdata.real_name, lg4ff_alternate_modes[i].name); 931 return -EINVAL; 932 } 933 934 s = lg4ff_get_mode_switch_command(entry->wdata.real_product_id, target_product_id); 935 if (!s) { 936 hid_err(hid, "Invalid target product ID %X\n", target_product_id); 937 return -EINVAL; 938 } 939 940 ret = lg4ff_switch_compatibility_mode(hid, s); 941 return (ret == 0 ? count : ret); 942 } 943 static DEVICE_ATTR(alternate_modes, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH, lg4ff_alternate_modes_show, lg4ff_alternate_modes_store); 944 945 static ssize_t lg4ff_combine_show(struct device *dev, struct device_attribute *attr, 946 char *buf) 947 { 948 struct hid_device *hid = to_hid_device(dev); 949 struct lg4ff_device_entry *entry; 950 struct lg_drv_data *drv_data; 951 size_t count; 952 953 drv_data = hid_get_drvdata(hid); 954 if (!drv_data) { 955 hid_err(hid, "Private driver data not found!\n"); 956 return 0; 957 } 958 959 entry = drv_data->device_props; 960 if (!entry) { 961 hid_err(hid, "Device properties not found!\n"); 962 return 0; 963 } 964 965 count = scnprintf(buf, PAGE_SIZE, "%u\n", entry->wdata.combine); 966 return count; 967 } 968 969 static ssize_t lg4ff_combine_store(struct device *dev, struct device_attribute *attr, 970 const char *buf, size_t count) 971 { 972 struct hid_device *hid = to_hid_device(dev); 973 struct lg4ff_device_entry *entry; 974 struct lg_drv_data *drv_data; 975 u16 combine = simple_strtoul(buf, NULL, 10); 976 977 drv_data = hid_get_drvdata(hid); 978 if (!drv_data) { 979 hid_err(hid, "Private driver data not found!\n"); 980 return -EINVAL; 981 } 982 983 entry = drv_data->device_props; 984 if (!entry) { 985 hid_err(hid, "Device properties not found!\n"); 986 return -EINVAL; 987 } 988 989 if (combine > 1) 990 combine = 1; 991 992 entry->wdata.combine = combine; 993 return count; 994 } 995 static DEVICE_ATTR(combine_pedals, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH, lg4ff_combine_show, lg4ff_combine_store); 996 997 /* Export the currently set range of the wheel */ 998 static ssize_t lg4ff_range_show(struct device *dev, struct device_attribute *attr, 999 char *buf) 1000 { 1001 struct hid_device *hid = to_hid_device(dev); 1002 struct lg4ff_device_entry *entry; 1003 struct lg_drv_data *drv_data; 1004 size_t count; 1005 1006 drv_data = hid_get_drvdata(hid); 1007 if (!drv_data) { 1008 hid_err(hid, "Private driver data not found!\n"); 1009 return 0; 1010 } 1011 1012 entry = drv_data->device_props; 1013 if (!entry) { 1014 hid_err(hid, "Device properties not found!\n"); 1015 return 0; 1016 } 1017 1018 count = scnprintf(buf, PAGE_SIZE, "%u\n", entry->wdata.range); 1019 return count; 1020 } 1021 1022 /* Set range to user specified value, call appropriate function 1023 * according to the type of the wheel */ 1024 static ssize_t lg4ff_range_store(struct device *dev, struct device_attribute *attr, 1025 const char *buf, size_t count) 1026 { 1027 struct hid_device *hid = to_hid_device(dev); 1028 struct lg4ff_device_entry *entry; 1029 struct lg_drv_data *drv_data; 1030 u16 range = simple_strtoul(buf, NULL, 10); 1031 1032 drv_data = hid_get_drvdata(hid); 1033 if (!drv_data) { 1034 hid_err(hid, "Private driver data not found!\n"); 1035 return -EINVAL; 1036 } 1037 1038 entry = drv_data->device_props; 1039 if (!entry) { 1040 hid_err(hid, "Device properties not found!\n"); 1041 return -EINVAL; 1042 } 1043 1044 if (range == 0) 1045 range = entry->wdata.max_range; 1046 1047 /* Check if the wheel supports range setting 1048 * and that the range is within limits for the wheel */ 1049 if (entry->wdata.set_range && range >= entry->wdata.min_range && range <= entry->wdata.max_range) { 1050 entry->wdata.set_range(hid, range); 1051 entry->wdata.range = range; 1052 } 1053 1054 return count; 1055 } 1056 static DEVICE_ATTR(range, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH, lg4ff_range_show, lg4ff_range_store); 1057 1058 static ssize_t lg4ff_real_id_show(struct device *dev, struct device_attribute *attr, char *buf) 1059 { 1060 struct hid_device *hid = to_hid_device(dev); 1061 struct lg4ff_device_entry *entry; 1062 struct lg_drv_data *drv_data; 1063 size_t count; 1064 1065 drv_data = hid_get_drvdata(hid); 1066 if (!drv_data) { 1067 hid_err(hid, "Private driver data not found!\n"); 1068 return 0; 1069 } 1070 1071 entry = drv_data->device_props; 1072 if (!entry) { 1073 hid_err(hid, "Device properties not found!\n"); 1074 return 0; 1075 } 1076 1077 if (!entry->wdata.real_tag || !entry->wdata.real_name) { 1078 hid_err(hid, "NULL pointer to string\n"); 1079 return 0; 1080 } 1081 1082 count = scnprintf(buf, PAGE_SIZE, "%s: %s\n", entry->wdata.real_tag, entry->wdata.real_name); 1083 return count; 1084 } 1085 1086 static ssize_t lg4ff_real_id_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1087 { 1088 /* Real ID is a read-only value */ 1089 return -EPERM; 1090 } 1091 static DEVICE_ATTR(real_id, S_IRUGO, lg4ff_real_id_show, lg4ff_real_id_store); 1092 1093 #ifdef CONFIG_LEDS_CLASS 1094 static void lg4ff_set_leds(struct hid_device *hid, u8 leds) 1095 { 1096 struct lg_drv_data *drv_data; 1097 struct lg4ff_device_entry *entry; 1098 unsigned long flags; 1099 s32 *value; 1100 1101 drv_data = hid_get_drvdata(hid); 1102 if (!drv_data) { 1103 hid_err(hid, "Private driver data not found!\n"); 1104 return; 1105 } 1106 1107 entry = drv_data->device_props; 1108 if (!entry) { 1109 hid_err(hid, "Device properties not found!\n"); 1110 return; 1111 } 1112 value = entry->report->field[0]->value; 1113 1114 spin_lock_irqsave(&entry->report_lock, flags); 1115 value[0] = 0xf8; 1116 value[1] = 0x12; 1117 value[2] = leds; 1118 value[3] = 0x00; 1119 value[4] = 0x00; 1120 value[5] = 0x00; 1121 value[6] = 0x00; 1122 hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT); 1123 spin_unlock_irqrestore(&entry->report_lock, flags); 1124 } 1125 1126 static void lg4ff_led_set_brightness(struct led_classdev *led_cdev, 1127 enum led_brightness value) 1128 { 1129 struct device *dev = led_cdev->dev->parent; 1130 struct hid_device *hid = to_hid_device(dev); 1131 struct lg_drv_data *drv_data = hid_get_drvdata(hid); 1132 struct lg4ff_device_entry *entry; 1133 int i, state = 0; 1134 1135 if (!drv_data) { 1136 hid_err(hid, "Device data not found."); 1137 return; 1138 } 1139 1140 entry = drv_data->device_props; 1141 1142 if (!entry) { 1143 hid_err(hid, "Device properties not found."); 1144 return; 1145 } 1146 1147 for (i = 0; i < 5; i++) { 1148 if (led_cdev != entry->wdata.led[i]) 1149 continue; 1150 state = (entry->wdata.led_state >> i) & 1; 1151 if (value == LED_OFF && state) { 1152 entry->wdata.led_state &= ~(1 << i); 1153 lg4ff_set_leds(hid, entry->wdata.led_state); 1154 } else if (value != LED_OFF && !state) { 1155 entry->wdata.led_state |= 1 << i; 1156 lg4ff_set_leds(hid, entry->wdata.led_state); 1157 } 1158 break; 1159 } 1160 } 1161 1162 static enum led_brightness lg4ff_led_get_brightness(struct led_classdev *led_cdev) 1163 { 1164 struct device *dev = led_cdev->dev->parent; 1165 struct hid_device *hid = to_hid_device(dev); 1166 struct lg_drv_data *drv_data = hid_get_drvdata(hid); 1167 struct lg4ff_device_entry *entry; 1168 int i, value = 0; 1169 1170 if (!drv_data) { 1171 hid_err(hid, "Device data not found."); 1172 return LED_OFF; 1173 } 1174 1175 entry = drv_data->device_props; 1176 1177 if (!entry) { 1178 hid_err(hid, "Device properties not found."); 1179 return LED_OFF; 1180 } 1181 1182 for (i = 0; i < 5; i++) 1183 if (led_cdev == entry->wdata.led[i]) { 1184 value = (entry->wdata.led_state >> i) & 1; 1185 break; 1186 } 1187 1188 return value ? LED_FULL : LED_OFF; 1189 } 1190 #endif 1191 1192 static u16 lg4ff_identify_multimode_wheel(struct hid_device *hid, const u16 reported_product_id, const u16 bcdDevice) 1193 { 1194 u32 current_mode; 1195 int i; 1196 1197 /* identify current mode from USB PID */ 1198 for (i = 1; i < ARRAY_SIZE(lg4ff_alternate_modes); i++) { 1199 dbg_hid("Testing whether PID is %X\n", lg4ff_alternate_modes[i].product_id); 1200 if (reported_product_id == lg4ff_alternate_modes[i].product_id) 1201 break; 1202 } 1203 1204 if (i == ARRAY_SIZE(lg4ff_alternate_modes)) 1205 return 0; 1206 1207 current_mode = BIT(i); 1208 1209 for (i = 0; i < ARRAY_SIZE(lg4ff_main_checklist); i++) { 1210 const u16 mask = lg4ff_main_checklist[i]->mask; 1211 const u16 result = lg4ff_main_checklist[i]->result; 1212 const u16 real_product_id = lg4ff_main_checklist[i]->real_product_id; 1213 1214 if ((current_mode & lg4ff_main_checklist[i]->modes) && \ 1215 (bcdDevice & mask) == result) { 1216 dbg_hid("Found wheel with real PID %X whose reported PID is %X\n", real_product_id, reported_product_id); 1217 return real_product_id; 1218 } 1219 } 1220 1221 /* No match found. This is either Driving Force or an unknown 1222 * wheel model, do not touch it */ 1223 dbg_hid("Wheel with bcdDevice %X was not recognized as multimode wheel, leaving in its current mode\n", bcdDevice); 1224 return 0; 1225 } 1226 1227 static int lg4ff_handle_multimode_wheel(struct hid_device *hid, u16 *real_product_id, const u16 bcdDevice) 1228 { 1229 const u16 reported_product_id = hid->product; 1230 int ret; 1231 1232 *real_product_id = lg4ff_identify_multimode_wheel(hid, reported_product_id, bcdDevice); 1233 /* Probed wheel is not a multimode wheel */ 1234 if (!*real_product_id) { 1235 *real_product_id = reported_product_id; 1236 dbg_hid("Wheel is not a multimode wheel\n"); 1237 return LG4FF_MMODE_NOT_MULTIMODE; 1238 } 1239 1240 /* Switch from "Driving Force" mode to native mode automatically. 1241 * Otherwise keep the wheel in its current mode */ 1242 if (reported_product_id == USB_DEVICE_ID_LOGITECH_WHEEL && 1243 reported_product_id != *real_product_id && 1244 !lg4ff_no_autoswitch) { 1245 const struct lg4ff_compat_mode_switch *s = lg4ff_get_mode_switch_command(*real_product_id, *real_product_id); 1246 1247 if (!s) { 1248 hid_err(hid, "Invalid product id %X\n", *real_product_id); 1249 return LG4FF_MMODE_NOT_MULTIMODE; 1250 } 1251 1252 ret = lg4ff_switch_compatibility_mode(hid, s); 1253 if (ret) { 1254 /* Wheel could not have been switched to native mode, 1255 * leave it in "Driving Force" mode and continue */ 1256 hid_err(hid, "Unable to switch wheel mode, errno %d\n", ret); 1257 return LG4FF_MMODE_IS_MULTIMODE; 1258 } 1259 return LG4FF_MMODE_SWITCHED; 1260 } 1261 1262 return LG4FF_MMODE_IS_MULTIMODE; 1263 } 1264 1265 1266 int lg4ff_init(struct hid_device *hid) 1267 { 1268 struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list); 1269 struct input_dev *dev = hidinput->input; 1270 struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list; 1271 struct hid_report *report = list_entry(report_list->next, struct hid_report, list); 1272 const struct usb_device_descriptor *udesc = &(hid_to_usb_dev(hid)->descriptor); 1273 const u16 bcdDevice = le16_to_cpu(udesc->bcdDevice); 1274 const struct lg4ff_multimode_wheel *mmode_wheel = NULL; 1275 struct lg4ff_device_entry *entry; 1276 struct lg_drv_data *drv_data; 1277 int error, i, j; 1278 int mmode_ret, mmode_idx = -1; 1279 u16 real_product_id; 1280 1281 /* Check that the report looks ok */ 1282 if (!hid_validate_values(hid, HID_OUTPUT_REPORT, 0, 0, 7)) 1283 return -1; 1284 1285 drv_data = hid_get_drvdata(hid); 1286 if (!drv_data) { 1287 hid_err(hid, "Cannot add device, private driver data not allocated\n"); 1288 return -1; 1289 } 1290 entry = kzalloc(sizeof(*entry), GFP_KERNEL); 1291 if (!entry) 1292 return -ENOMEM; 1293 spin_lock_init(&entry->report_lock); 1294 entry->report = report; 1295 drv_data->device_props = entry; 1296 1297 /* Check if a multimode wheel has been connected and 1298 * handle it appropriately */ 1299 mmode_ret = lg4ff_handle_multimode_wheel(hid, &real_product_id, bcdDevice); 1300 1301 /* Wheel has been told to switch to native mode. There is no point in going on 1302 * with the initialization as the wheel will do a USB reset when it switches mode 1303 */ 1304 if (mmode_ret == LG4FF_MMODE_SWITCHED) 1305 return 0; 1306 else if (mmode_ret < 0) { 1307 hid_err(hid, "Unable to switch device mode during initialization, errno %d\n", mmode_ret); 1308 error = mmode_ret; 1309 goto err_init; 1310 } 1311 1312 /* Check what wheel has been connected */ 1313 for (i = 0; i < ARRAY_SIZE(lg4ff_devices); i++) { 1314 if (hid->product == lg4ff_devices[i].product_id) { 1315 dbg_hid("Found compatible device, product ID %04X\n", lg4ff_devices[i].product_id); 1316 break; 1317 } 1318 } 1319 1320 if (i == ARRAY_SIZE(lg4ff_devices)) { 1321 hid_err(hid, "This device is flagged to be handled by the lg4ff module but this module does not know how to handle it. " 1322 "Please report this as a bug to LKML, Simon Wood <simon@mungewell.org> or " 1323 "Michal Maly <madcatxster@devoid-pointer.net>\n"); 1324 error = -1; 1325 goto err_init; 1326 } 1327 1328 if (mmode_ret == LG4FF_MMODE_IS_MULTIMODE) { 1329 for (mmode_idx = 0; mmode_idx < ARRAY_SIZE(lg4ff_multimode_wheels); mmode_idx++) { 1330 if (real_product_id == lg4ff_multimode_wheels[mmode_idx].product_id) 1331 break; 1332 } 1333 1334 if (mmode_idx == ARRAY_SIZE(lg4ff_multimode_wheels)) { 1335 hid_err(hid, "Device product ID %X is not listed as a multimode wheel", real_product_id); 1336 error = -1; 1337 goto err_init; 1338 } 1339 } 1340 1341 /* Set supported force feedback capabilities */ 1342 for (j = 0; lg4ff_devices[i].ff_effects[j] >= 0; j++) 1343 set_bit(lg4ff_devices[i].ff_effects[j], dev->ffbit); 1344 1345 error = input_ff_create_memless(dev, NULL, lg4ff_play); 1346 1347 if (error) 1348 goto err_init; 1349 1350 /* Initialize device properties */ 1351 if (mmode_ret == LG4FF_MMODE_IS_MULTIMODE) { 1352 BUG_ON(mmode_idx == -1); 1353 mmode_wheel = &lg4ff_multimode_wheels[mmode_idx]; 1354 } 1355 lg4ff_init_wheel_data(&entry->wdata, &lg4ff_devices[i], mmode_wheel, real_product_id); 1356 1357 /* Check if autocentering is available and 1358 * set the centering force to zero by default */ 1359 if (test_bit(FF_AUTOCENTER, dev->ffbit)) { 1360 /* Formula Force EX expects different autocentering command */ 1361 if ((bcdDevice >> 8) == LG4FF_FFEX_REV_MAJ && 1362 (bcdDevice & 0xff) == LG4FF_FFEX_REV_MIN) 1363 dev->ff->set_autocenter = lg4ff_set_autocenter_ffex; 1364 else 1365 dev->ff->set_autocenter = lg4ff_set_autocenter_default; 1366 1367 dev->ff->set_autocenter(dev, 0); 1368 } 1369 1370 /* Create sysfs interface */ 1371 error = device_create_file(&hid->dev, &dev_attr_combine_pedals); 1372 if (error) 1373 hid_warn(hid, "Unable to create sysfs interface for \"combine\", errno %d\n", error); 1374 error = device_create_file(&hid->dev, &dev_attr_range); 1375 if (error) 1376 hid_warn(hid, "Unable to create sysfs interface for \"range\", errno %d\n", error); 1377 if (mmode_ret == LG4FF_MMODE_IS_MULTIMODE) { 1378 error = device_create_file(&hid->dev, &dev_attr_real_id); 1379 if (error) 1380 hid_warn(hid, "Unable to create sysfs interface for \"real_id\", errno %d\n", error); 1381 error = device_create_file(&hid->dev, &dev_attr_alternate_modes); 1382 if (error) 1383 hid_warn(hid, "Unable to create sysfs interface for \"alternate_modes\", errno %d\n", error); 1384 } 1385 dbg_hid("sysfs interface created\n"); 1386 1387 /* Set the maximum range to start with */ 1388 entry->wdata.range = entry->wdata.max_range; 1389 if (entry->wdata.set_range) 1390 entry->wdata.set_range(hid, entry->wdata.range); 1391 1392 #ifdef CONFIG_LEDS_CLASS 1393 /* register led subsystem - G27/G29 only */ 1394 entry->wdata.led_state = 0; 1395 for (j = 0; j < 5; j++) 1396 entry->wdata.led[j] = NULL; 1397 1398 if (lg4ff_devices[i].product_id == USB_DEVICE_ID_LOGITECH_G27_WHEEL || 1399 lg4ff_devices[i].product_id == USB_DEVICE_ID_LOGITECH_G29_WHEEL) { 1400 struct led_classdev *led; 1401 size_t name_sz; 1402 char *name; 1403 1404 lg4ff_set_leds(hid, 0); 1405 1406 name_sz = strlen(dev_name(&hid->dev)) + 8; 1407 1408 for (j = 0; j < 5; j++) { 1409 led = kzalloc(sizeof(struct led_classdev)+name_sz, GFP_KERNEL); 1410 if (!led) { 1411 hid_err(hid, "can't allocate memory for LED %d\n", j); 1412 goto err_leds; 1413 } 1414 1415 name = (void *)(&led[1]); 1416 snprintf(name, name_sz, "%s::RPM%d", dev_name(&hid->dev), j+1); 1417 led->name = name; 1418 led->brightness = 0; 1419 led->max_brightness = 1; 1420 led->brightness_get = lg4ff_led_get_brightness; 1421 led->brightness_set = lg4ff_led_set_brightness; 1422 1423 entry->wdata.led[j] = led; 1424 error = led_classdev_register(&hid->dev, led); 1425 1426 if (error) { 1427 hid_err(hid, "failed to register LED %d. Aborting.\n", j); 1428 err_leds: 1429 /* Deregister LEDs (if any) */ 1430 for (j = 0; j < 5; j++) { 1431 led = entry->wdata.led[j]; 1432 entry->wdata.led[j] = NULL; 1433 if (!led) 1434 continue; 1435 led_classdev_unregister(led); 1436 kfree(led); 1437 } 1438 goto out; /* Let the driver continue without LEDs */ 1439 } 1440 } 1441 } 1442 out: 1443 #endif 1444 hid_info(hid, "Force feedback support for Logitech Gaming Wheels\n"); 1445 return 0; 1446 1447 err_init: 1448 drv_data->device_props = NULL; 1449 kfree(entry); 1450 return error; 1451 } 1452 1453 int lg4ff_deinit(struct hid_device *hid) 1454 { 1455 struct lg4ff_device_entry *entry; 1456 struct lg_drv_data *drv_data; 1457 1458 drv_data = hid_get_drvdata(hid); 1459 if (!drv_data) { 1460 hid_err(hid, "Error while deinitializing device, no private driver data.\n"); 1461 return -1; 1462 } 1463 entry = drv_data->device_props; 1464 if (!entry) 1465 goto out; /* Nothing more to do */ 1466 1467 /* Multimode devices will have at least the "MODE_NATIVE" bit set */ 1468 if (entry->wdata.alternate_modes) { 1469 device_remove_file(&hid->dev, &dev_attr_real_id); 1470 device_remove_file(&hid->dev, &dev_attr_alternate_modes); 1471 } 1472 1473 device_remove_file(&hid->dev, &dev_attr_combine_pedals); 1474 device_remove_file(&hid->dev, &dev_attr_range); 1475 #ifdef CONFIG_LEDS_CLASS 1476 { 1477 int j; 1478 struct led_classdev *led; 1479 1480 /* Deregister LEDs (if any) */ 1481 for (j = 0; j < 5; j++) { 1482 1483 led = entry->wdata.led[j]; 1484 entry->wdata.led[j] = NULL; 1485 if (!led) 1486 continue; 1487 led_classdev_unregister(led); 1488 kfree(led); 1489 } 1490 } 1491 #endif 1492 hid_hw_stop(hid); 1493 drv_data->device_props = NULL; 1494 1495 kfree(entry); 1496 out: 1497 dbg_hid("Device successfully unregistered\n"); 1498 return 0; 1499 } 1500