1 /* 2 * HID driver for some logitech "special" devices 3 * 4 * Copyright (c) 1999 Andreas Gal 5 * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz> 6 * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc 7 * Copyright (c) 2006-2007 Jiri Kosina 8 * Copyright (c) 2008 Jiri Slaby 9 * Copyright (c) 2010 Hendrik Iben 10 */ 11 12 /* 13 * This program is free software; you can redistribute it and/or modify it 14 * under the terms of the GNU General Public License as published by the Free 15 * Software Foundation; either version 2 of the License, or (at your option) 16 * any later version. 17 */ 18 19 #include <linux/device.h> 20 #include <linux/hid.h> 21 #include <linux/module.h> 22 #include <linux/random.h> 23 #include <linux/sched.h> 24 #include <linux/usb.h> 25 #include <linux/wait.h> 26 27 #include "usbhid/usbhid.h" 28 #include "hid-ids.h" 29 #include "hid-lg.h" 30 #include "hid-lg4ff.h" 31 32 #define LG_RDESC 0x001 33 #define LG_BAD_RELATIVE_KEYS 0x002 34 #define LG_DUPLICATE_USAGES 0x004 35 #define LG_EXPANDED_KEYMAP 0x010 36 #define LG_IGNORE_DOUBLED_WHEEL 0x020 37 #define LG_WIRELESS 0x040 38 #define LG_INVERT_HWHEEL 0x080 39 #define LG_NOGET 0x100 40 #define LG_FF 0x200 41 #define LG_FF2 0x400 42 #define LG_RDESC_REL_ABS 0x800 43 #define LG_FF3 0x1000 44 #define LG_FF4 0x2000 45 46 /* Size of the original descriptors of the Driving Force (and Pro) wheels */ 47 #define DF_RDESC_ORIG_SIZE 130 48 #define DFP_RDESC_ORIG_SIZE 97 49 #define FV_RDESC_ORIG_SIZE 130 50 #define MOMO_RDESC_ORIG_SIZE 87 51 #define MOMO2_RDESC_ORIG_SIZE 87 52 53 /* Fixed report descriptors for Logitech Driving Force (and Pro) 54 * wheel controllers 55 * 56 * The original descriptors hide the separate throttle and brake axes in 57 * a custom vendor usage page, providing only a combined value as 58 * GenericDesktop.Y. 59 * These descriptors remove the combined Y axis and instead report 60 * separate throttle (Y) and brake (RZ). 61 */ 62 static __u8 df_rdesc_fixed[] = { 63 0x05, 0x01, /* Usage Page (Desktop), */ 64 0x09, 0x04, /* Usage (Joystick), */ 65 0xA1, 0x01, /* Collection (Application), */ 66 0xA1, 0x02, /* Collection (Logical), */ 67 0x95, 0x01, /* Report Count (1), */ 68 0x75, 0x0A, /* Report Size (10), */ 69 0x14, /* Logical Minimum (0), */ 70 0x26, 0xFF, 0x03, /* Logical Maximum (1023), */ 71 0x34, /* Physical Minimum (0), */ 72 0x46, 0xFF, 0x03, /* Physical Maximum (1023), */ 73 0x09, 0x30, /* Usage (X), */ 74 0x81, 0x02, /* Input (Variable), */ 75 0x95, 0x0C, /* Report Count (12), */ 76 0x75, 0x01, /* Report Size (1), */ 77 0x25, 0x01, /* Logical Maximum (1), */ 78 0x45, 0x01, /* Physical Maximum (1), */ 79 0x05, 0x09, /* Usage (Buttons), */ 80 0x19, 0x01, /* Usage Minimum (1), */ 81 0x29, 0x0c, /* Usage Maximum (12), */ 82 0x81, 0x02, /* Input (Variable), */ 83 0x95, 0x02, /* Report Count (2), */ 84 0x06, 0x00, 0xFF, /* Usage Page (Vendor: 65280), */ 85 0x09, 0x01, /* Usage (?: 1), */ 86 0x81, 0x02, /* Input (Variable), */ 87 0x05, 0x01, /* Usage Page (Desktop), */ 88 0x26, 0xFF, 0x00, /* Logical Maximum (255), */ 89 0x46, 0xFF, 0x00, /* Physical Maximum (255), */ 90 0x95, 0x01, /* Report Count (1), */ 91 0x75, 0x08, /* Report Size (8), */ 92 0x81, 0x02, /* Input (Variable), */ 93 0x25, 0x07, /* Logical Maximum (7), */ 94 0x46, 0x3B, 0x01, /* Physical Maximum (315), */ 95 0x75, 0x04, /* Report Size (4), */ 96 0x65, 0x14, /* Unit (Degrees), */ 97 0x09, 0x39, /* Usage (Hat Switch), */ 98 0x81, 0x42, /* Input (Variable, Null State), */ 99 0x75, 0x01, /* Report Size (1), */ 100 0x95, 0x04, /* Report Count (4), */ 101 0x65, 0x00, /* Unit (none), */ 102 0x06, 0x00, 0xFF, /* Usage Page (Vendor: 65280), */ 103 0x09, 0x01, /* Usage (?: 1), */ 104 0x25, 0x01, /* Logical Maximum (1), */ 105 0x45, 0x01, /* Physical Maximum (1), */ 106 0x81, 0x02, /* Input (Variable), */ 107 0x05, 0x01, /* Usage Page (Desktop), */ 108 0x95, 0x01, /* Report Count (1), */ 109 0x75, 0x08, /* Report Size (8), */ 110 0x26, 0xFF, 0x00, /* Logical Maximum (255), */ 111 0x46, 0xFF, 0x00, /* Physical Maximum (255), */ 112 0x09, 0x31, /* Usage (Y), */ 113 0x81, 0x02, /* Input (Variable), */ 114 0x09, 0x35, /* Usage (Rz), */ 115 0x81, 0x02, /* Input (Variable), */ 116 0xC0, /* End Collection, */ 117 0xA1, 0x02, /* Collection (Logical), */ 118 0x26, 0xFF, 0x00, /* Logical Maximum (255), */ 119 0x46, 0xFF, 0x00, /* Physical Maximum (255), */ 120 0x95, 0x07, /* Report Count (7), */ 121 0x75, 0x08, /* Report Size (8), */ 122 0x09, 0x03, /* Usage (?: 3), */ 123 0x91, 0x02, /* Output (Variable), */ 124 0xC0, /* End Collection, */ 125 0xC0 /* End Collection */ 126 }; 127 128 static __u8 dfp_rdesc_fixed[] = { 129 0x05, 0x01, /* Usage Page (Desktop), */ 130 0x09, 0x04, /* Usage (Joystick), */ 131 0xA1, 0x01, /* Collection (Application), */ 132 0xA1, 0x02, /* Collection (Logical), */ 133 0x95, 0x01, /* Report Count (1), */ 134 0x75, 0x0E, /* Report Size (14), */ 135 0x14, /* Logical Minimum (0), */ 136 0x26, 0xFF, 0x3F, /* Logical Maximum (16383), */ 137 0x34, /* Physical Minimum (0), */ 138 0x46, 0xFF, 0x3F, /* Physical Maximum (16383), */ 139 0x09, 0x30, /* Usage (X), */ 140 0x81, 0x02, /* Input (Variable), */ 141 0x95, 0x0E, /* Report Count (14), */ 142 0x75, 0x01, /* Report Size (1), */ 143 0x25, 0x01, /* Logical Maximum (1), */ 144 0x45, 0x01, /* Physical Maximum (1), */ 145 0x05, 0x09, /* Usage Page (Button), */ 146 0x19, 0x01, /* Usage Minimum (01h), */ 147 0x29, 0x0E, /* Usage Maximum (0Eh), */ 148 0x81, 0x02, /* Input (Variable), */ 149 0x05, 0x01, /* Usage Page (Desktop), */ 150 0x95, 0x01, /* Report Count (1), */ 151 0x75, 0x04, /* Report Size (4), */ 152 0x25, 0x07, /* Logical Maximum (7), */ 153 0x46, 0x3B, 0x01, /* Physical Maximum (315), */ 154 0x65, 0x14, /* Unit (Degrees), */ 155 0x09, 0x39, /* Usage (Hat Switch), */ 156 0x81, 0x42, /* Input (Variable, Nullstate), */ 157 0x65, 0x00, /* Unit, */ 158 0x26, 0xFF, 0x00, /* Logical Maximum (255), */ 159 0x46, 0xFF, 0x00, /* Physical Maximum (255), */ 160 0x75, 0x08, /* Report Size (8), */ 161 0x81, 0x01, /* Input (Constant), */ 162 0x09, 0x31, /* Usage (Y), */ 163 0x81, 0x02, /* Input (Variable), */ 164 0x09, 0x35, /* Usage (Rz), */ 165 0x81, 0x02, /* Input (Variable), */ 166 0x81, 0x01, /* Input (Constant), */ 167 0xC0, /* End Collection, */ 168 0xA1, 0x02, /* Collection (Logical), */ 169 0x09, 0x02, /* Usage (02h), */ 170 0x95, 0x07, /* Report Count (7), */ 171 0x91, 0x02, /* Output (Variable), */ 172 0xC0, /* End Collection, */ 173 0xC0 /* End Collection */ 174 }; 175 176 static __u8 fv_rdesc_fixed[] = { 177 0x05, 0x01, /* Usage Page (Desktop), */ 178 0x09, 0x04, /* Usage (Joystick), */ 179 0xA1, 0x01, /* Collection (Application), */ 180 0xA1, 0x02, /* Collection (Logical), */ 181 0x95, 0x01, /* Report Count (1), */ 182 0x75, 0x0A, /* Report Size (10), */ 183 0x15, 0x00, /* Logical Minimum (0), */ 184 0x26, 0xFF, 0x03, /* Logical Maximum (1023), */ 185 0x35, 0x00, /* Physical Minimum (0), */ 186 0x46, 0xFF, 0x03, /* Physical Maximum (1023), */ 187 0x09, 0x30, /* Usage (X), */ 188 0x81, 0x02, /* Input (Variable), */ 189 0x95, 0x0C, /* Report Count (12), */ 190 0x75, 0x01, /* Report Size (1), */ 191 0x25, 0x01, /* Logical Maximum (1), */ 192 0x45, 0x01, /* Physical Maximum (1), */ 193 0x05, 0x09, /* Usage Page (Button), */ 194 0x19, 0x01, /* Usage Minimum (01h), */ 195 0x29, 0x0C, /* Usage Maximum (0Ch), */ 196 0x81, 0x02, /* Input (Variable), */ 197 0x95, 0x02, /* Report Count (2), */ 198 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */ 199 0x09, 0x01, /* Usage (01h), */ 200 0x81, 0x02, /* Input (Variable), */ 201 0x09, 0x02, /* Usage (02h), */ 202 0x26, 0xFF, 0x00, /* Logical Maximum (255), */ 203 0x46, 0xFF, 0x00, /* Physical Maximum (255), */ 204 0x95, 0x01, /* Report Count (1), */ 205 0x75, 0x08, /* Report Size (8), */ 206 0x81, 0x02, /* Input (Variable), */ 207 0x05, 0x01, /* Usage Page (Desktop), */ 208 0x25, 0x07, /* Logical Maximum (7), */ 209 0x46, 0x3B, 0x01, /* Physical Maximum (315), */ 210 0x75, 0x04, /* Report Size (4), */ 211 0x65, 0x14, /* Unit (Degrees), */ 212 0x09, 0x39, /* Usage (Hat Switch), */ 213 0x81, 0x42, /* Input (Variable, Null State), */ 214 0x75, 0x01, /* Report Size (1), */ 215 0x95, 0x04, /* Report Count (4), */ 216 0x65, 0x00, /* Unit, */ 217 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */ 218 0x09, 0x01, /* Usage (01h), */ 219 0x25, 0x01, /* Logical Maximum (1), */ 220 0x45, 0x01, /* Physical Maximum (1), */ 221 0x81, 0x02, /* Input (Variable), */ 222 0x05, 0x01, /* Usage Page (Desktop), */ 223 0x95, 0x01, /* Report Count (1), */ 224 0x75, 0x08, /* Report Size (8), */ 225 0x26, 0xFF, 0x00, /* Logical Maximum (255), */ 226 0x46, 0xFF, 0x00, /* Physical Maximum (255), */ 227 0x09, 0x31, /* Usage (Y), */ 228 0x81, 0x02, /* Input (Variable), */ 229 0x09, 0x32, /* Usage (Z), */ 230 0x81, 0x02, /* Input (Variable), */ 231 0xC0, /* End Collection, */ 232 0xA1, 0x02, /* Collection (Logical), */ 233 0x26, 0xFF, 0x00, /* Logical Maximum (255), */ 234 0x46, 0xFF, 0x00, /* Physical Maximum (255), */ 235 0x95, 0x07, /* Report Count (7), */ 236 0x75, 0x08, /* Report Size (8), */ 237 0x09, 0x03, /* Usage (03h), */ 238 0x91, 0x02, /* Output (Variable), */ 239 0xC0, /* End Collection, */ 240 0xC0 /* End Collection */ 241 }; 242 243 static __u8 momo_rdesc_fixed[] = { 244 0x05, 0x01, /* Usage Page (Desktop), */ 245 0x09, 0x04, /* Usage (Joystick), */ 246 0xA1, 0x01, /* Collection (Application), */ 247 0xA1, 0x02, /* Collection (Logical), */ 248 0x95, 0x01, /* Report Count (1), */ 249 0x75, 0x0A, /* Report Size (10), */ 250 0x15, 0x00, /* Logical Minimum (0), */ 251 0x26, 0xFF, 0x03, /* Logical Maximum (1023), */ 252 0x35, 0x00, /* Physical Minimum (0), */ 253 0x46, 0xFF, 0x03, /* Physical Maximum (1023), */ 254 0x09, 0x30, /* Usage (X), */ 255 0x81, 0x02, /* Input (Variable), */ 256 0x95, 0x08, /* Report Count (8), */ 257 0x75, 0x01, /* Report Size (1), */ 258 0x25, 0x01, /* Logical Maximum (1), */ 259 0x45, 0x01, /* Physical Maximum (1), */ 260 0x05, 0x09, /* Usage Page (Button), */ 261 0x19, 0x01, /* Usage Minimum (01h), */ 262 0x29, 0x08, /* Usage Maximum (08h), */ 263 0x81, 0x02, /* Input (Variable), */ 264 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */ 265 0x75, 0x0E, /* Report Size (14), */ 266 0x95, 0x01, /* Report Count (1), */ 267 0x26, 0xFF, 0x00, /* Logical Maximum (255), */ 268 0x46, 0xFF, 0x00, /* Physical Maximum (255), */ 269 0x09, 0x00, /* Usage (00h), */ 270 0x81, 0x02, /* Input (Variable), */ 271 0x05, 0x01, /* Usage Page (Desktop), */ 272 0x75, 0x08, /* Report Size (8), */ 273 0x09, 0x31, /* Usage (Y), */ 274 0x81, 0x02, /* Input (Variable), */ 275 0x09, 0x32, /* Usage (Z), */ 276 0x81, 0x02, /* Input (Variable), */ 277 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */ 278 0x09, 0x01, /* Usage (01h), */ 279 0x81, 0x02, /* Input (Variable), */ 280 0xC0, /* End Collection, */ 281 0xA1, 0x02, /* Collection (Logical), */ 282 0x09, 0x02, /* Usage (02h), */ 283 0x95, 0x07, /* Report Count (7), */ 284 0x91, 0x02, /* Output (Variable), */ 285 0xC0, /* End Collection, */ 286 0xC0 /* End Collection */ 287 }; 288 289 static __u8 momo2_rdesc_fixed[] = { 290 0x05, 0x01, /* Usage Page (Desktop), */ 291 0x09, 0x04, /* Usage (Joystick), */ 292 0xA1, 0x01, /* Collection (Application), */ 293 0xA1, 0x02, /* Collection (Logical), */ 294 0x95, 0x01, /* Report Count (1), */ 295 0x75, 0x0A, /* Report Size (10), */ 296 0x15, 0x00, /* Logical Minimum (0), */ 297 0x26, 0xFF, 0x03, /* Logical Maximum (1023), */ 298 0x35, 0x00, /* Physical Minimum (0), */ 299 0x46, 0xFF, 0x03, /* Physical Maximum (1023), */ 300 0x09, 0x30, /* Usage (X), */ 301 0x81, 0x02, /* Input (Variable), */ 302 0x95, 0x0A, /* Report Count (10), */ 303 0x75, 0x01, /* Report Size (1), */ 304 0x25, 0x01, /* Logical Maximum (1), */ 305 0x45, 0x01, /* Physical Maximum (1), */ 306 0x05, 0x09, /* Usage Page (Button), */ 307 0x19, 0x01, /* Usage Minimum (01h), */ 308 0x29, 0x0A, /* Usage Maximum (0Ah), */ 309 0x81, 0x02, /* Input (Variable), */ 310 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */ 311 0x09, 0x00, /* Usage (00h), */ 312 0x95, 0x04, /* Report Count (4), */ 313 0x81, 0x02, /* Input (Variable), */ 314 0x95, 0x01, /* Report Count (1), */ 315 0x75, 0x08, /* Report Size (8), */ 316 0x26, 0xFF, 0x00, /* Logical Maximum (255), */ 317 0x46, 0xFF, 0x00, /* Physical Maximum (255), */ 318 0x09, 0x01, /* Usage (01h), */ 319 0x81, 0x02, /* Input (Variable), */ 320 0x05, 0x01, /* Usage Page (Desktop), */ 321 0x09, 0x31, /* Usage (Y), */ 322 0x81, 0x02, /* Input (Variable), */ 323 0x09, 0x32, /* Usage (Z), */ 324 0x81, 0x02, /* Input (Variable), */ 325 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */ 326 0x09, 0x00, /* Usage (00h), */ 327 0x81, 0x02, /* Input (Variable), */ 328 0xC0, /* End Collection, */ 329 0xA1, 0x02, /* Collection (Logical), */ 330 0x09, 0x02, /* Usage (02h), */ 331 0x95, 0x07, /* Report Count (7), */ 332 0x91, 0x02, /* Output (Variable), */ 333 0xC0, /* End Collection, */ 334 0xC0 /* End Collection */ 335 }; 336 337 /* 338 * Certain Logitech keyboards send in report #3 keys which are far 339 * above the logical maximum described in descriptor. This extends 340 * the original value of 0x28c of logical maximum to 0x104d 341 */ 342 static __u8 *lg_report_fixup(struct hid_device *hdev, __u8 *rdesc, 343 unsigned int *rsize) 344 { 345 struct lg_drv_data *drv_data = hid_get_drvdata(hdev); 346 347 if ((drv_data->quirks & LG_RDESC) && *rsize >= 91 && rdesc[83] == 0x26 && 348 rdesc[84] == 0x8c && rdesc[85] == 0x02) { 349 hid_info(hdev, 350 "fixing up Logitech keyboard report descriptor\n"); 351 rdesc[84] = rdesc[89] = 0x4d; 352 rdesc[85] = rdesc[90] = 0x10; 353 } 354 if ((drv_data->quirks & LG_RDESC_REL_ABS) && *rsize >= 51 && 355 rdesc[32] == 0x81 && rdesc[33] == 0x06 && 356 rdesc[49] == 0x81 && rdesc[50] == 0x06) { 357 hid_info(hdev, 358 "fixing up rel/abs in Logitech report descriptor\n"); 359 rdesc[33] = rdesc[50] = 0x02; 360 } 361 362 switch (hdev->product) { 363 364 /* Several wheels report as this id when operating in emulation mode. */ 365 case USB_DEVICE_ID_LOGITECH_WHEEL: 366 if (*rsize == DF_RDESC_ORIG_SIZE) { 367 hid_info(hdev, 368 "fixing up Logitech Driving Force report descriptor\n"); 369 rdesc = df_rdesc_fixed; 370 *rsize = sizeof(df_rdesc_fixed); 371 } 372 break; 373 374 case USB_DEVICE_ID_LOGITECH_MOMO_WHEEL: 375 if (*rsize == MOMO_RDESC_ORIG_SIZE) { 376 hid_info(hdev, 377 "fixing up Logitech Momo Force (Red) report descriptor\n"); 378 rdesc = momo_rdesc_fixed; 379 *rsize = sizeof(momo_rdesc_fixed); 380 } 381 break; 382 383 case USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2: 384 if (*rsize == MOMO2_RDESC_ORIG_SIZE) { 385 hid_info(hdev, 386 "fixing up Logitech Momo Racing Force (Black) report descriptor\n"); 387 rdesc = momo2_rdesc_fixed; 388 *rsize = sizeof(momo2_rdesc_fixed); 389 } 390 break; 391 392 case USB_DEVICE_ID_LOGITECH_VIBRATION_WHEEL: 393 if (*rsize == FV_RDESC_ORIG_SIZE) { 394 hid_info(hdev, 395 "fixing up Logitech Formula Vibration report descriptor\n"); 396 rdesc = fv_rdesc_fixed; 397 *rsize = sizeof(fv_rdesc_fixed); 398 } 399 break; 400 401 case USB_DEVICE_ID_LOGITECH_DFP_WHEEL: 402 if (*rsize == DFP_RDESC_ORIG_SIZE) { 403 hid_info(hdev, 404 "fixing up Logitech Driving Force Pro report descriptor\n"); 405 rdesc = dfp_rdesc_fixed; 406 *rsize = sizeof(dfp_rdesc_fixed); 407 } 408 break; 409 410 case USB_DEVICE_ID_LOGITECH_WII_WHEEL: 411 if (*rsize >= 101 && rdesc[41] == 0x95 && rdesc[42] == 0x0B && 412 rdesc[47] == 0x05 && rdesc[48] == 0x09) { 413 hid_info(hdev, "fixing up Logitech Speed Force Wireless report descriptor\n"); 414 rdesc[41] = 0x05; 415 rdesc[42] = 0x09; 416 rdesc[47] = 0x95; 417 rdesc[48] = 0x0B; 418 } 419 break; 420 } 421 422 return rdesc; 423 } 424 425 #define lg_map_key_clear(c) hid_map_usage_clear(hi, usage, bit, max, \ 426 EV_KEY, (c)) 427 428 static int lg_ultrax_remote_mapping(struct hid_input *hi, 429 struct hid_usage *usage, unsigned long **bit, int *max) 430 { 431 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR) 432 return 0; 433 434 set_bit(EV_REP, hi->input->evbit); 435 switch (usage->hid & HID_USAGE) { 436 /* Reported on Logitech Ultra X Media Remote */ 437 case 0x004: lg_map_key_clear(KEY_AGAIN); break; 438 case 0x00d: lg_map_key_clear(KEY_HOME); break; 439 case 0x024: lg_map_key_clear(KEY_SHUFFLE); break; 440 case 0x025: lg_map_key_clear(KEY_TV); break; 441 case 0x026: lg_map_key_clear(KEY_MENU); break; 442 case 0x031: lg_map_key_clear(KEY_AUDIO); break; 443 case 0x032: lg_map_key_clear(KEY_TEXT); break; 444 case 0x033: lg_map_key_clear(KEY_LAST); break; 445 case 0x047: lg_map_key_clear(KEY_MP3); break; 446 case 0x048: lg_map_key_clear(KEY_DVD); break; 447 case 0x049: lg_map_key_clear(KEY_MEDIA); break; 448 case 0x04a: lg_map_key_clear(KEY_VIDEO); break; 449 case 0x04b: lg_map_key_clear(KEY_ANGLE); break; 450 case 0x04c: lg_map_key_clear(KEY_LANGUAGE); break; 451 case 0x04d: lg_map_key_clear(KEY_SUBTITLE); break; 452 case 0x051: lg_map_key_clear(KEY_RED); break; 453 case 0x052: lg_map_key_clear(KEY_CLOSE); break; 454 455 default: 456 return 0; 457 } 458 return 1; 459 } 460 461 static int lg_dinovo_mapping(struct hid_input *hi, struct hid_usage *usage, 462 unsigned long **bit, int *max) 463 { 464 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR) 465 return 0; 466 467 switch (usage->hid & HID_USAGE) { 468 469 case 0x00d: lg_map_key_clear(KEY_MEDIA); break; 470 default: 471 return 0; 472 473 } 474 return 1; 475 } 476 477 static int lg_wireless_mapping(struct hid_input *hi, struct hid_usage *usage, 478 unsigned long **bit, int *max) 479 { 480 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER) 481 return 0; 482 483 switch (usage->hid & HID_USAGE) { 484 case 0x1001: lg_map_key_clear(KEY_MESSENGER); break; 485 case 0x1003: lg_map_key_clear(KEY_SOUND); break; 486 case 0x1004: lg_map_key_clear(KEY_VIDEO); break; 487 case 0x1005: lg_map_key_clear(KEY_AUDIO); break; 488 case 0x100a: lg_map_key_clear(KEY_DOCUMENTS); break; 489 /* The following two entries are Playlist 1 and 2 on the MX3200 */ 490 case 0x100f: lg_map_key_clear(KEY_FN_1); break; 491 case 0x1010: lg_map_key_clear(KEY_FN_2); break; 492 case 0x1011: lg_map_key_clear(KEY_PREVIOUSSONG); break; 493 case 0x1012: lg_map_key_clear(KEY_NEXTSONG); break; 494 case 0x1013: lg_map_key_clear(KEY_CAMERA); break; 495 case 0x1014: lg_map_key_clear(KEY_MESSENGER); break; 496 case 0x1015: lg_map_key_clear(KEY_RECORD); break; 497 case 0x1016: lg_map_key_clear(KEY_PLAYER); break; 498 case 0x1017: lg_map_key_clear(KEY_EJECTCD); break; 499 case 0x1018: lg_map_key_clear(KEY_MEDIA); break; 500 case 0x1019: lg_map_key_clear(KEY_PROG1); break; 501 case 0x101a: lg_map_key_clear(KEY_PROG2); break; 502 case 0x101b: lg_map_key_clear(KEY_PROG3); break; 503 case 0x101c: lg_map_key_clear(KEY_CYCLEWINDOWS); break; 504 case 0x101f: lg_map_key_clear(KEY_ZOOMIN); break; 505 case 0x1020: lg_map_key_clear(KEY_ZOOMOUT); break; 506 case 0x1021: lg_map_key_clear(KEY_ZOOMRESET); break; 507 case 0x1023: lg_map_key_clear(KEY_CLOSE); break; 508 case 0x1027: lg_map_key_clear(KEY_MENU); break; 509 /* this one is marked as 'Rotate' */ 510 case 0x1028: lg_map_key_clear(KEY_ANGLE); break; 511 case 0x1029: lg_map_key_clear(KEY_SHUFFLE); break; 512 case 0x102a: lg_map_key_clear(KEY_BACK); break; 513 case 0x102b: lg_map_key_clear(KEY_CYCLEWINDOWS); break; 514 case 0x102d: lg_map_key_clear(KEY_WWW); break; 515 /* The following two are 'Start/answer call' and 'End/reject call' 516 on the MX3200 */ 517 case 0x1031: lg_map_key_clear(KEY_OK); break; 518 case 0x1032: lg_map_key_clear(KEY_CANCEL); break; 519 case 0x1041: lg_map_key_clear(KEY_BATTERY); break; 520 case 0x1042: lg_map_key_clear(KEY_WORDPROCESSOR); break; 521 case 0x1043: lg_map_key_clear(KEY_SPREADSHEET); break; 522 case 0x1044: lg_map_key_clear(KEY_PRESENTATION); break; 523 case 0x1045: lg_map_key_clear(KEY_UNDO); break; 524 case 0x1046: lg_map_key_clear(KEY_REDO); break; 525 case 0x1047: lg_map_key_clear(KEY_PRINT); break; 526 case 0x1048: lg_map_key_clear(KEY_SAVE); break; 527 case 0x1049: lg_map_key_clear(KEY_PROG1); break; 528 case 0x104a: lg_map_key_clear(KEY_PROG2); break; 529 case 0x104b: lg_map_key_clear(KEY_PROG3); break; 530 case 0x104c: lg_map_key_clear(KEY_PROG4); break; 531 532 default: 533 return 0; 534 } 535 return 1; 536 } 537 538 static int lg_input_mapping(struct hid_device *hdev, struct hid_input *hi, 539 struct hid_field *field, struct hid_usage *usage, 540 unsigned long **bit, int *max) 541 { 542 /* extended mapping for certain Logitech hardware (Logitech cordless 543 desktop LX500) */ 544 static const u8 e_keymap[] = { 545 0,216, 0,213,175,156, 0, 0, 0, 0, 546 144, 0, 0, 0, 0, 0, 0, 0, 0,212, 547 174,167,152,161,112, 0, 0, 0,154, 0, 548 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 549 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 550 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 551 0, 0, 0, 0, 0,183,184,185,186,187, 552 188,189,190,191,192,193,194, 0, 0, 0 553 }; 554 struct lg_drv_data *drv_data = hid_get_drvdata(hdev); 555 unsigned int hid = usage->hid; 556 557 if (hdev->product == USB_DEVICE_ID_LOGITECH_RECEIVER && 558 lg_ultrax_remote_mapping(hi, usage, bit, max)) 559 return 1; 560 561 if (hdev->product == USB_DEVICE_ID_DINOVO_MINI && 562 lg_dinovo_mapping(hi, usage, bit, max)) 563 return 1; 564 565 if ((drv_data->quirks & LG_WIRELESS) && lg_wireless_mapping(hi, usage, bit, max)) 566 return 1; 567 568 if ((hid & HID_USAGE_PAGE) != HID_UP_BUTTON) 569 return 0; 570 571 hid &= HID_USAGE; 572 573 /* Special handling for Logitech Cordless Desktop */ 574 if (field->application == HID_GD_MOUSE) { 575 if ((drv_data->quirks & LG_IGNORE_DOUBLED_WHEEL) && 576 (hid == 7 || hid == 8)) 577 return -1; 578 } else { 579 if ((drv_data->quirks & LG_EXPANDED_KEYMAP) && 580 hid < ARRAY_SIZE(e_keymap) && 581 e_keymap[hid] != 0) { 582 hid_map_usage(hi, usage, bit, max, EV_KEY, 583 e_keymap[hid]); 584 return 1; 585 } 586 } 587 588 return 0; 589 } 590 591 static int lg_input_mapped(struct hid_device *hdev, struct hid_input *hi, 592 struct hid_field *field, struct hid_usage *usage, 593 unsigned long **bit, int *max) 594 { 595 struct lg_drv_data *drv_data = hid_get_drvdata(hdev); 596 597 if ((drv_data->quirks & LG_BAD_RELATIVE_KEYS) && usage->type == EV_KEY && 598 (field->flags & HID_MAIN_ITEM_RELATIVE)) 599 field->flags &= ~HID_MAIN_ITEM_RELATIVE; 600 601 if ((drv_data->quirks & LG_DUPLICATE_USAGES) && (usage->type == EV_KEY || 602 usage->type == EV_REL || usage->type == EV_ABS)) 603 clear_bit(usage->code, *bit); 604 605 /* Ensure that Logitech wheels are not given a default fuzz/flat value */ 606 if (usage->type == EV_ABS && (usage->code == ABS_X || 607 usage->code == ABS_Y || usage->code == ABS_Z || 608 usage->code == ABS_RZ)) { 609 switch (hdev->product) { 610 case USB_DEVICE_ID_LOGITECH_G29_WHEEL: 611 case USB_DEVICE_ID_LOGITECH_WHEEL: 612 case USB_DEVICE_ID_LOGITECH_MOMO_WHEEL: 613 case USB_DEVICE_ID_LOGITECH_DFP_WHEEL: 614 case USB_DEVICE_ID_LOGITECH_G25_WHEEL: 615 case USB_DEVICE_ID_LOGITECH_DFGT_WHEEL: 616 case USB_DEVICE_ID_LOGITECH_G27_WHEEL: 617 case USB_DEVICE_ID_LOGITECH_WII_WHEEL: 618 case USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2: 619 case USB_DEVICE_ID_LOGITECH_VIBRATION_WHEEL: 620 field->application = HID_GD_MULTIAXIS; 621 break; 622 default: 623 break; 624 } 625 } 626 627 return 0; 628 } 629 630 static int lg_event(struct hid_device *hdev, struct hid_field *field, 631 struct hid_usage *usage, __s32 value) 632 { 633 struct lg_drv_data *drv_data = hid_get_drvdata(hdev); 634 635 if ((drv_data->quirks & LG_INVERT_HWHEEL) && usage->code == REL_HWHEEL) { 636 input_event(field->hidinput->input, usage->type, usage->code, 637 -value); 638 return 1; 639 } 640 if (drv_data->quirks & LG_FF4) { 641 return lg4ff_adjust_input_event(hdev, field, usage, value, drv_data); 642 } 643 644 return 0; 645 } 646 647 static int lg_raw_event(struct hid_device *hdev, struct hid_report *report, 648 u8 *rd, int size) 649 { 650 struct lg_drv_data *drv_data = hid_get_drvdata(hdev); 651 652 if (drv_data->quirks & LG_FF4) 653 return lg4ff_raw_event(hdev, report, rd, size, drv_data); 654 655 return 0; 656 } 657 658 static int lg_probe(struct hid_device *hdev, const struct hid_device_id *id) 659 { 660 struct usb_interface *iface = to_usb_interface(hdev->dev.parent); 661 __u8 iface_num = iface->cur_altsetting->desc.bInterfaceNumber; 662 unsigned int connect_mask = HID_CONNECT_DEFAULT; 663 struct lg_drv_data *drv_data; 664 int ret; 665 666 /* G29 only work with the 1st interface */ 667 if ((hdev->product == USB_DEVICE_ID_LOGITECH_G29_WHEEL) && 668 (iface_num != 0)) { 669 dbg_hid("%s: ignoring ifnum %d\n", __func__, iface_num); 670 return -ENODEV; 671 } 672 673 drv_data = kzalloc(sizeof(struct lg_drv_data), GFP_KERNEL); 674 if (!drv_data) { 675 hid_err(hdev, "Insufficient memory, cannot allocate driver data\n"); 676 return -ENOMEM; 677 } 678 drv_data->quirks = id->driver_data; 679 680 hid_set_drvdata(hdev, (void *)drv_data); 681 682 if (drv_data->quirks & LG_NOGET) 683 hdev->quirks |= HID_QUIRK_NOGET; 684 685 ret = hid_parse(hdev); 686 if (ret) { 687 hid_err(hdev, "parse failed\n"); 688 goto err_free; 689 } 690 691 if (drv_data->quirks & (LG_FF | LG_FF2 | LG_FF3 | LG_FF4)) 692 connect_mask &= ~HID_CONNECT_FF; 693 694 ret = hid_hw_start(hdev, connect_mask); 695 if (ret) { 696 hid_err(hdev, "hw start failed\n"); 697 goto err_free; 698 } 699 700 /* Setup wireless link with Logitech Wii wheel */ 701 if (hdev->product == USB_DEVICE_ID_LOGITECH_WII_WHEEL) { 702 unsigned char buf[] = { 0x00, 0xAF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 703 704 ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(buf), 705 HID_FEATURE_REPORT, HID_REQ_SET_REPORT); 706 707 if (ret >= 0) { 708 /* insert a little delay of 10 jiffies ~ 40ms */ 709 wait_queue_head_t wait; 710 init_waitqueue_head (&wait); 711 wait_event_interruptible_timeout(wait, 0, 712 msecs_to_jiffies(40)); 713 714 /* Select random Address */ 715 buf[1] = 0xB2; 716 get_random_bytes(&buf[2], 2); 717 718 ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(buf), 719 HID_FEATURE_REPORT, HID_REQ_SET_REPORT); 720 } 721 } 722 723 if (drv_data->quirks & LG_FF) 724 ret = lgff_init(hdev); 725 else if (drv_data->quirks & LG_FF2) 726 ret = lg2ff_init(hdev); 727 else if (drv_data->quirks & LG_FF3) 728 ret = lg3ff_init(hdev); 729 else if (drv_data->quirks & LG_FF4) 730 ret = lg4ff_init(hdev); 731 732 if (ret) 733 goto err_free; 734 735 return 0; 736 err_free: 737 kfree(drv_data); 738 return ret; 739 } 740 741 static void lg_remove(struct hid_device *hdev) 742 { 743 struct lg_drv_data *drv_data = hid_get_drvdata(hdev); 744 if (drv_data->quirks & LG_FF4) 745 lg4ff_deinit(hdev); 746 else 747 hid_hw_stop(hdev); 748 kfree(drv_data); 749 } 750 751 static const struct hid_device_id lg_devices[] = { 752 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER), 753 .driver_data = LG_RDESC | LG_WIRELESS }, 754 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER), 755 .driver_data = LG_RDESC | LG_WIRELESS }, 756 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2), 757 .driver_data = LG_RDESC | LG_WIRELESS }, 758 759 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RECEIVER), 760 .driver_data = LG_BAD_RELATIVE_KEYS }, 761 762 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_DESKTOP), 763 .driver_data = LG_DUPLICATE_USAGES }, 764 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_EDGE), 765 .driver_data = LG_DUPLICATE_USAGES }, 766 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_MINI), 767 .driver_data = LG_DUPLICATE_USAGES }, 768 769 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_ELITE_KBD), 770 .driver_data = LG_IGNORE_DOUBLED_WHEEL | LG_EXPANDED_KEYMAP }, 771 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500), 772 .driver_data = LG_IGNORE_DOUBLED_WHEEL | LG_EXPANDED_KEYMAP }, 773 774 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_EXTREME_3D), 775 .driver_data = LG_NOGET }, 776 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DUAL_ACTION), 777 .driver_data = LG_NOGET }, 778 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WHEEL), 779 .driver_data = LG_NOGET | LG_FF4 }, 780 781 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD_CORD), 782 .driver_data = LG_FF2 }, 783 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD), 784 .driver_data = LG_FF }, 785 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2), 786 .driver_data = LG_FF }, 787 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G29_WHEEL), 788 .driver_data = LG_FF4 }, 789 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_F3D), 790 .driver_data = LG_FF }, 791 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FORCE3D_PRO), 792 .driver_data = LG_FF }, 793 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL), 794 .driver_data = LG_NOGET | LG_FF4 }, 795 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2), 796 .driver_data = LG_FF4 }, 797 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_VIBRATION_WHEEL), 798 .driver_data = LG_FF2 }, 799 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G25_WHEEL), 800 .driver_data = LG_FF4 }, 801 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFGT_WHEEL), 802 .driver_data = LG_FF4 }, 803 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G27_WHEEL), 804 .driver_data = LG_FF4 }, 805 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFP_WHEEL), 806 .driver_data = LG_NOGET | LG_FF4 }, 807 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WII_WHEEL), 808 .driver_data = LG_FF4 }, 809 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_FFG), 810 .driver_data = LG_FF }, 811 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2), 812 .driver_data = LG_FF2 }, 813 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FLIGHT_SYSTEM_G940), 814 .driver_data = LG_FF3 }, 815 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACENAVIGATOR), 816 .driver_data = LG_RDESC_REL_ABS }, 817 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACETRAVELLER), 818 .driver_data = LG_RDESC_REL_ABS }, 819 { } 820 }; 821 822 MODULE_DEVICE_TABLE(hid, lg_devices); 823 824 static struct hid_driver lg_driver = { 825 .name = "logitech", 826 .id_table = lg_devices, 827 .report_fixup = lg_report_fixup, 828 .input_mapping = lg_input_mapping, 829 .input_mapped = lg_input_mapped, 830 .event = lg_event, 831 .raw_event = lg_raw_event, 832 .probe = lg_probe, 833 .remove = lg_remove, 834 }; 835 module_hid_driver(lg_driver); 836 837 #ifdef CONFIG_LOGIWHEELS_FF 838 int lg4ff_no_autoswitch = 0; 839 module_param_named(lg4ff_no_autoswitch, lg4ff_no_autoswitch, int, S_IRUGO); 840 MODULE_PARM_DESC(lg4ff_no_autoswitch, "Do not switch multimode wheels to their native mode automatically"); 841 #endif 842 843 MODULE_LICENSE("GPL"); 844