?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tcp: gso: fix truesize tracking
[linux-2.6.git] / drivers / hid / hid-lg.c
blob6f12ecd36c8834fa9c9cb77b79d883dd4c246dc8
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
31 #define LG_RDESC 0x001
32 #define LG_BAD_RELATIVE_KEYS 0x002
33 #define LG_DUPLICATE_USAGES 0x004
34 #define LG_EXPANDED_KEYMAP 0x010
35 #define LG_IGNORE_DOUBLED_WHEEL 0x020
36 #define LG_WIRELESS 0x040
37 #define LG_INVERT_HWHEEL 0x080
38 #define LG_NOGET 0x100
39 #define LG_FF 0x200
40 #define LG_FF2 0x400
41 #define LG_RDESC_REL_ABS 0x800
42 #define LG_FF3 0x1000
43 #define LG_FF4 0x2000
44
45 /* Size of the original descriptors of the Driving Force (and Pro) wheels */
46 #define DF_RDESC_ORIG_SIZE 130
47 #define DFP_RDESC_ORIG_SIZE 97
48 #define MOMO_RDESC_ORIG_SIZE 87
49
50 /* Fixed report descriptors for Logitech Driving Force (and Pro)
51 * wheel controllers
52 *
53 * The original descriptors hide the separate throttle and brake axes in
54 * a custom vendor usage page, providing only a combined value as
55 * GenericDesktop.Y.
56 * These descriptors remove the combined Y axis and instead report
57 * separate throttle (Y) and brake (RZ).
58 */
59 static __u8 df_rdesc_fixed[] = {
60 0x05, 0x01, /* Usage Page (Desktop), */
61 0x09, 0x04, /* Usage (Joystik), */
62 0xA1, 0x01, /* Collection (Application), */
63 0xA1, 0x02, /* Collection (Logical), */
64 0x95, 0x01, /* Report Count (1), */
65 0x75, 0x0A, /* Report Size (10), */
66 0x14, /* Logical Minimum (0), */
67 0x26, 0xFF, 0x03, /* Logical Maximum (1023), */
68 0x34, /* Physical Minimum (0), */
69 0x46, 0xFF, 0x03, /* Physical Maximum (1023), */
70 0x09, 0x30, /* Usage (X), */
71 0x81, 0x02, /* Input (Variable), */
72 0x95, 0x0C, /* Report Count (12), */
73 0x75, 0x01, /* Report Size (1), */
74 0x25, 0x01, /* Logical Maximum (1), */
75 0x45, 0x01, /* Physical Maximum (1), */
76 0x05, 0x09, /* Usage (Buttons), */
77 0x19, 0x01, /* Usage Minimum (1), */
78 0x29, 0x0c, /* Usage Maximum (12), */
79 0x81, 0x02, /* Input (Variable), */
80 0x95, 0x02, /* Report Count (2), */
81 0x06, 0x00, 0xFF, /* Usage Page (Vendor: 65280), */
82 0x09, 0x01, /* Usage (?: 1), */
83 0x81, 0x02, /* Input (Variable), */
84 0x05, 0x01, /* Usage Page (Desktop), */
85 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
86 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
87 0x95, 0x01, /* Report Count (1), */
88 0x75, 0x08, /* Report Size (8), */
89 0x81, 0x02, /* Input (Variable), */
90 0x25, 0x07, /* Logical Maximum (7), */
91 0x46, 0x3B, 0x01, /* Physical Maximum (315), */
92 0x75, 0x04, /* Report Size (4), */
93 0x65, 0x14, /* Unit (Degrees), */
94 0x09, 0x39, /* Usage (Hat Switch), */
95 0x81, 0x42, /* Input (Variable, Null State), */
96 0x75, 0x01, /* Report Size (1), */
97 0x95, 0x04, /* Report Count (4), */
98 0x65, 0x00, /* Unit (none), */
99 0x06, 0x00, 0xFF, /* Usage Page (Vendor: 65280), */
100 0x09, 0x01, /* Usage (?: 1), */
101 0x25, 0x01, /* Logical Maximum (1), */
102 0x45, 0x01, /* Physical Maximum (1), */
103 0x81, 0x02, /* Input (Variable), */
104 0x05, 0x01, /* Usage Page (Desktop), */
105 0x95, 0x01, /* Report Count (1), */
106 0x75, 0x08, /* Report Size (8), */
107 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
108 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
109 0x09, 0x31, /* Usage (Y), */
110 0x81, 0x02, /* Input (Variable), */
111 0x09, 0x35, /* Usage (Rz), */
112 0x81, 0x02, /* Input (Variable), */
113 0xC0, /* End Collection, */
114 0xA1, 0x02, /* Collection (Logical), */
115 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
116 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
117 0x95, 0x07, /* Report Count (7), */
118 0x75, 0x08, /* Report Size (8), */
119 0x09, 0x03, /* Usage (?: 3), */
120 0x91, 0x02, /* Output (Variable), */
121 0xC0, /* End Collection, */
122 0xC0 /* End Collection */
123 };
124
125 static __u8 dfp_rdesc_fixed[] = {
126 0x05, 0x01, /* Usage Page (Desktop), */
127 0x09, 0x04, /* Usage (Joystik), */
128 0xA1, 0x01, /* Collection (Application), */
129 0xA1, 0x02, /* Collection (Logical), */
130 0x95, 0x01, /* Report Count (1), */
131 0x75, 0x0E, /* Report Size (14), */
132 0x14, /* Logical Minimum (0), */
133 0x26, 0xFF, 0x3F, /* Logical Maximum (16383), */
134 0x34, /* Physical Minimum (0), */
135 0x46, 0xFF, 0x3F, /* Physical Maximum (16383), */
136 0x09, 0x30, /* Usage (X), */
137 0x81, 0x02, /* Input (Variable), */
138 0x95, 0x0E, /* Report Count (14), */
139 0x75, 0x01, /* Report Size (1), */
140 0x25, 0x01, /* Logical Maximum (1), */
141 0x45, 0x01, /* Physical Maximum (1), */
142 0x05, 0x09, /* Usage Page (Button), */
143 0x19, 0x01, /* Usage Minimum (01h), */
144 0x29, 0x0E, /* Usage Maximum (0Eh), */
145 0x81, 0x02, /* Input (Variable), */
146 0x05, 0x01, /* Usage Page (Desktop), */
147 0x95, 0x01, /* Report Count (1), */
148 0x75, 0x04, /* Report Size (4), */
149 0x25, 0x07, /* Logical Maximum (7), */
150 0x46, 0x3B, 0x01, /* Physical Maximum (315), */
151 0x65, 0x14, /* Unit (Degrees), */
152 0x09, 0x39, /* Usage (Hat Switch), */
153 0x81, 0x42, /* Input (Variable, Nullstate), */
154 0x65, 0x00, /* Unit, */
155 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
156 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
157 0x75, 0x08, /* Report Size (8), */
158 0x81, 0x01, /* Input (Constant), */
159 0x09, 0x31, /* Usage (Y), */
160 0x81, 0x02, /* Input (Variable), */
161 0x09, 0x35, /* Usage (Rz), */
162 0x81, 0x02, /* Input (Variable), */
163 0x81, 0x01, /* Input (Constant), */
164 0xC0, /* End Collection, */
165 0xA1, 0x02, /* Collection (Logical), */
166 0x09, 0x02, /* Usage (02h), */
167 0x95, 0x07, /* Report Count (7), */
168 0x91, 0x02, /* Output (Variable), */
169 0xC0, /* End Collection, */
170 0xC0 /* End Collection */
171 };
172
173 static __u8 momo_rdesc_fixed[] = {
174 0x05, 0x01, /* Usage Page (Desktop), */
175 0x09, 0x04, /* Usage (Joystik), */
176 0xA1, 0x01, /* Collection (Application), */
177 0xA1, 0x02, /* Collection (Logical), */
178 0x95, 0x01, /* Report Count (1), */
179 0x75, 0x0A, /* Report Size (10), */
180 0x15, 0x00, /* Logical Minimum (0), */
181 0x26, 0xFF, 0x03, /* Logical Maximum (1023), */
182 0x35, 0x00, /* Physical Minimum (0), */
183 0x46, 0xFF, 0x03, /* Physical Maximum (1023), */
184 0x09, 0x30, /* Usage (X), */
185 0x81, 0x02, /* Input (Variable), */
186 0x95, 0x08, /* Report Count (8), */
187 0x75, 0x01, /* Report Size (1), */
188 0x25, 0x01, /* Logical Maximum (1), */
189 0x45, 0x01, /* Physical Maximum (1), */
190 0x05, 0x09, /* Usage Page (Button), */
191 0x19, 0x01, /* Usage Minimum (01h), */
192 0x29, 0x08, /* Usage Maximum (08h), */
193 0x81, 0x02, /* Input (Variable), */
194 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
195 0x75, 0x0E, /* Report Size (14), */
196 0x95, 0x01, /* Report Count (1), */
197 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
198 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
199 0x09, 0x00, /* Usage (00h), */
200 0x81, 0x02, /* Input (Variable), */
201 0x05, 0x01, /* Usage Page (Desktop), */
202 0x75, 0x08, /* Report Size (8), */
203 0x09, 0x31, /* Usage (Y), */
204 0x81, 0x02, /* Input (Variable), */
205 0x09, 0x32, /* Usage (Z), */
206 0x81, 0x02, /* Input (Variable), */
207 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
208 0x09, 0x01, /* Usage (01h), */
209 0x81, 0x02, /* Input (Variable), */
210 0xC0, /* End Collection, */
211 0xA1, 0x02, /* Collection (Logical), */
212 0x09, 0x02, /* Usage (02h), */
213 0x95, 0x07, /* Report Count (7), */
214 0x91, 0x02, /* Output (Variable), */
215 0xC0, /* End Collection, */
216 0xC0 /* End Collection */
217 };
218
219 /*
220 * Certain Logitech keyboards send in report #3 keys which are far
221 * above the logical maximum described in descriptor. This extends
222 * the original value of 0x28c of logical maximum to 0x104d
223 */
224 static __u8 *lg_report_fixup(struct hid_device *hdev, __u8 *rdesc,
225 unsigned int *rsize)
226 {
227 struct lg_drv_data *drv_data = hid_get_drvdata(hdev);
228 struct usb_device_descriptor *udesc;
229 __u16 bcdDevice, rev_maj, rev_min;
230
231 if ((drv_data->quirks & LG_RDESC) && *rsize >= 90 && rdesc[83] == 0x26 &&
232 rdesc[84] == 0x8c && rdesc[85] == 0x02) {
233 hid_info(hdev,
234 "fixing up Logitech keyboard report descriptor\n");
235 rdesc[84] = rdesc[89] = 0x4d;
236 rdesc[85] = rdesc[90] = 0x10;
237 }
238 if ((drv_data->quirks & LG_RDESC_REL_ABS) && *rsize >= 50 &&
239 rdesc[32] == 0x81 && rdesc[33] == 0x06 &&
240 rdesc[49] == 0x81 && rdesc[50] == 0x06) {
241 hid_info(hdev,
242 "fixing up rel/abs in Logitech report descriptor\n");
243 rdesc[33] = rdesc[50] = 0x02;
244 }
245
246 switch (hdev->product) {
247
248 /* Several wheels report as this id when operating in emulation mode. */
249 case USB_DEVICE_ID_LOGITECH_WHEEL:
250 udesc = &(hid_to_usb_dev(hdev)->descriptor);
251 if (!udesc) {
252 hid_err(hdev, "NULL USB device descriptor\n");
253 break;
254 }
255 bcdDevice = le16_to_cpu(udesc->bcdDevice);
256 rev_maj = bcdDevice >> 8;
257 rev_min = bcdDevice & 0xff;
258
259 /* Update the report descriptor for only the Driving Force wheel */
260 if (rev_maj == 1 && rev_min == 2 &&
261 *rsize == DF_RDESC_ORIG_SIZE) {
262 hid_info(hdev,
263 "fixing up Logitech Driving Force report descriptor\n");
264 rdesc = df_rdesc_fixed;
265 *rsize = sizeof(df_rdesc_fixed);
266 }
267 break;
268
269 case USB_DEVICE_ID_LOGITECH_MOMO_WHEEL:
270 if (*rsize == MOMO_RDESC_ORIG_SIZE) {
271 hid_info(hdev,
272 "fixing up Logitech Momo Force (Red) report descriptor\n");
273 rdesc = momo_rdesc_fixed;
274 *rsize = sizeof(momo_rdesc_fixed);
275 }
276 break;
277
278 case USB_DEVICE_ID_LOGITECH_DFP_WHEEL:
279 if (*rsize == DFP_RDESC_ORIG_SIZE) {
280 hid_info(hdev,
281 "fixing up Logitech Driving Force Pro report descriptor\n");
282 rdesc = dfp_rdesc_fixed;
283 *rsize = sizeof(dfp_rdesc_fixed);
284 }
285 break;
286
287 case USB_DEVICE_ID_LOGITECH_WII_WHEEL:
288 if (*rsize >= 101 && rdesc[41] == 0x95 && rdesc[42] == 0x0B &&
289 rdesc[47] == 0x05 && rdesc[48] == 0x09) {
290 hid_info(hdev, "fixing up Logitech Speed Force Wireless report descriptor\n");
291 rdesc[41] = 0x05;
292 rdesc[42] = 0x09;
293 rdesc[47] = 0x95;
294 rdesc[48] = 0x0B;
295 }
296 break;
297 }
298
299 return rdesc;
300 }
301
302 #define lg_map_key_clear(c) hid_map_usage_clear(hi, usage, bit, max, \
303 EV_KEY, (c))
304
305 static int lg_ultrax_remote_mapping(struct hid_input *hi,
306 struct hid_usage *usage, unsigned long **bit, int *max)
307 {
308 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
309 return 0;
310
311 set_bit(EV_REP, hi->input->evbit);
312 switch (usage->hid & HID_USAGE) {
313 /* Reported on Logitech Ultra X Media Remote */
314 case 0x004: lg_map_key_clear(KEY_AGAIN); break;
315 case 0x00d: lg_map_key_clear(KEY_HOME); break;
316 case 0x024: lg_map_key_clear(KEY_SHUFFLE); break;
317 case 0x025: lg_map_key_clear(KEY_TV); break;
318 case 0x026: lg_map_key_clear(KEY_MENU); break;
319 case 0x031: lg_map_key_clear(KEY_AUDIO); break;
320 case 0x032: lg_map_key_clear(KEY_TEXT); break;
321 case 0x033: lg_map_key_clear(KEY_LAST); break;
322 case 0x047: lg_map_key_clear(KEY_MP3); break;
323 case 0x048: lg_map_key_clear(KEY_DVD); break;
324 case 0x049: lg_map_key_clear(KEY_MEDIA); break;
325 case 0x04a: lg_map_key_clear(KEY_VIDEO); break;
326 case 0x04b: lg_map_key_clear(KEY_ANGLE); break;
327 case 0x04c: lg_map_key_clear(KEY_LANGUAGE); break;
328 case 0x04d: lg_map_key_clear(KEY_SUBTITLE); break;
329 case 0x051: lg_map_key_clear(KEY_RED); break;
330 case 0x052: lg_map_key_clear(KEY_CLOSE); break;
331
332 default:
333 return 0;
334 }
335 return 1;
336 }
337
338 static int lg_dinovo_mapping(struct hid_input *hi, struct hid_usage *usage,
339 unsigned long **bit, int *max)
340 {
341 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
342 return 0;
343
344 switch (usage->hid & HID_USAGE) {
345
346 case 0x00d: lg_map_key_clear(KEY_MEDIA); break;
347 default:
348 return 0;
349
350 }
351 return 1;
352 }
353
354 static int lg_wireless_mapping(struct hid_input *hi, struct hid_usage *usage,
355 unsigned long **bit, int *max)
356 {
357 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
358 return 0;
359
360 switch (usage->hid & HID_USAGE) {
361 case 0x1001: lg_map_key_clear(KEY_MESSENGER); break;
362 case 0x1003: lg_map_key_clear(KEY_SOUND); break;
363 case 0x1004: lg_map_key_clear(KEY_VIDEO); break;
364 case 0x1005: lg_map_key_clear(KEY_AUDIO); break;
365 case 0x100a: lg_map_key_clear(KEY_DOCUMENTS); break;
366 /* The following two entries are Playlist 1 and 2 on the MX3200 */
367 case 0x100f: lg_map_key_clear(KEY_FN_1); break;
368 case 0x1010: lg_map_key_clear(KEY_FN_2); break;
369 case 0x1011: lg_map_key_clear(KEY_PREVIOUSSONG); break;
370 case 0x1012: lg_map_key_clear(KEY_NEXTSONG); break;
371 case 0x1013: lg_map_key_clear(KEY_CAMERA); break;
372 case 0x1014: lg_map_key_clear(KEY_MESSENGER); break;
373 case 0x1015: lg_map_key_clear(KEY_RECORD); break;
374 case 0x1016: lg_map_key_clear(KEY_PLAYER); break;
375 case 0x1017: lg_map_key_clear(KEY_EJECTCD); break;
376 case 0x1018: lg_map_key_clear(KEY_MEDIA); break;
377 case 0x1019: lg_map_key_clear(KEY_PROG1); break;
378 case 0x101a: lg_map_key_clear(KEY_PROG2); break;
379 case 0x101b: lg_map_key_clear(KEY_PROG3); break;
380 case 0x101c: lg_map_key_clear(KEY_CYCLEWINDOWS); break;
381 case 0x101f: lg_map_key_clear(KEY_ZOOMIN); break;
382 case 0x1020: lg_map_key_clear(KEY_ZOOMOUT); break;
383 case 0x1021: lg_map_key_clear(KEY_ZOOMRESET); break;
384 case 0x1023: lg_map_key_clear(KEY_CLOSE); break;
385 case 0x1027: lg_map_key_clear(KEY_MENU); break;
386 /* this one is marked as 'Rotate' */
387 case 0x1028: lg_map_key_clear(KEY_ANGLE); break;
388 case 0x1029: lg_map_key_clear(KEY_SHUFFLE); break;
389 case 0x102a: lg_map_key_clear(KEY_BACK); break;
390 case 0x102b: lg_map_key_clear(KEY_CYCLEWINDOWS); break;
391 case 0x102d: lg_map_key_clear(KEY_WWW); break;
392 /* The following two are 'Start/answer call' and 'End/reject call'
393 on the MX3200 */
394 case 0x1031: lg_map_key_clear(KEY_OK); break;
395 case 0x1032: lg_map_key_clear(KEY_CANCEL); break;
396 case 0x1041: lg_map_key_clear(KEY_BATTERY); break;
397 case 0x1042: lg_map_key_clear(KEY_WORDPROCESSOR); break;
398 case 0x1043: lg_map_key_clear(KEY_SPREADSHEET); break;
399 case 0x1044: lg_map_key_clear(KEY_PRESENTATION); break;
400 case 0x1045: lg_map_key_clear(KEY_UNDO); break;
401 case 0x1046: lg_map_key_clear(KEY_REDO); break;
402 case 0x1047: lg_map_key_clear(KEY_PRINT); break;
403 case 0x1048: lg_map_key_clear(KEY_SAVE); break;
404 case 0x1049: lg_map_key_clear(KEY_PROG1); break;
405 case 0x104a: lg_map_key_clear(KEY_PROG2); break;
406 case 0x104b: lg_map_key_clear(KEY_PROG3); break;
407 case 0x104c: lg_map_key_clear(KEY_PROG4); break;
408
409 default:
410 return 0;
411 }
412 return 1;
413 }
414
415 static int lg_input_mapping(struct hid_device *hdev, struct hid_input *hi,
416 struct hid_field *field, struct hid_usage *usage,
417 unsigned long **bit, int *max)
418 {
419 /* extended mapping for certain Logitech hardware (Logitech cordless
420 desktop LX500) */
421 static const u8 e_keymap[] = {
422 0,216, 0,213,175,156, 0, 0, 0, 0,
423 144, 0, 0, 0, 0, 0, 0, 0, 0,212,
424 174,167,152,161,112, 0, 0, 0,154, 0,
425 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
426 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
427 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
428 0, 0, 0, 0, 0,183,184,185,186,187,
429 188,189,190,191,192,193,194, 0, 0, 0
430 };
431 struct lg_drv_data *drv_data = hid_get_drvdata(hdev);
432 unsigned int hid = usage->hid;
433
434 if (hdev->product == USB_DEVICE_ID_LOGITECH_RECEIVER &&
435 lg_ultrax_remote_mapping(hi, usage, bit, max))
436 return 1;
437
438 if (hdev->product == USB_DEVICE_ID_DINOVO_MINI &&
439 lg_dinovo_mapping(hi, usage, bit, max))
440 return 1;
441
442 if ((drv_data->quirks & LG_WIRELESS) && lg_wireless_mapping(hi, usage, bit, max))
443 return 1;
444
445 if ((hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
446 return 0;
447
448 hid &= HID_USAGE;
449
450 /* Special handling for Logitech Cordless Desktop */
451 if (field->application == HID_GD_MOUSE) {
452 if ((drv_data->quirks & LG_IGNORE_DOUBLED_WHEEL) &&
453 (hid == 7 || hid == 8))
454 return -1;
455 } else {
456 if ((drv_data->quirks & LG_EXPANDED_KEYMAP) &&
457 hid < ARRAY_SIZE(e_keymap) &&
458 e_keymap[hid] != 0) {
459 hid_map_usage(hi, usage, bit, max, EV_KEY,
460 e_keymap[hid]);
461 return 1;
462 }
463 }
464
465 return 0;
466 }
467
468 static int lg_input_mapped(struct hid_device *hdev, struct hid_input *hi,
469 struct hid_field *field, struct hid_usage *usage,
470 unsigned long **bit, int *max)
471 {
472 struct lg_drv_data *drv_data = hid_get_drvdata(hdev);
473
474 if ((drv_data->quirks & LG_BAD_RELATIVE_KEYS) && usage->type == EV_KEY &&
475 (field->flags & HID_MAIN_ITEM_RELATIVE))
476 field->flags &= ~HID_MAIN_ITEM_RELATIVE;
477
478 if ((drv_data->quirks & LG_DUPLICATE_USAGES) && (usage->type == EV_KEY ||
479 usage->type == EV_REL || usage->type == EV_ABS))
480 clear_bit(usage->code, *bit);
481
482 /* Ensure that Logitech wheels are not given a default fuzz/flat value */
483 if (usage->type == EV_ABS && (usage->code == ABS_X ||
484 usage->code == ABS_Y || usage->code == ABS_Z ||
485 usage->code == ABS_RZ)) {
486 switch (hdev->product) {
487 case USB_DEVICE_ID_LOGITECH_WHEEL:
488 case USB_DEVICE_ID_LOGITECH_MOMO_WHEEL:
489 case USB_DEVICE_ID_LOGITECH_DFP_WHEEL:
490 case USB_DEVICE_ID_LOGITECH_G25_WHEEL:
491 case USB_DEVICE_ID_LOGITECH_DFGT_WHEEL:
492 case USB_DEVICE_ID_LOGITECH_G27_WHEEL:
493 case USB_DEVICE_ID_LOGITECH_WII_WHEEL:
494 case USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2:
495 field->application = HID_GD_MULTIAXIS;
496 break;
497 default:
498 break;
499 }
500 }
501
502 return 0;
503 }
504
505 static int lg_event(struct hid_device *hdev, struct hid_field *field,
506 struct hid_usage *usage, __s32 value)
507 {
508 struct lg_drv_data *drv_data = hid_get_drvdata(hdev);
509
510 if ((drv_data->quirks & LG_INVERT_HWHEEL) && usage->code == REL_HWHEEL) {
511 input_event(field->hidinput->input, usage->type, usage->code,
512 -value);
513 return 1;
514 }
515 if (drv_data->quirks & LG_FF4) {
516 return lg4ff_adjust_input_event(hdev, field, usage, value, drv_data);
517 }
518
519 return 0;
520 }
521
522 static int lg_probe(struct hid_device *hdev, const struct hid_device_id *id)
523 {
524 unsigned int connect_mask = HID_CONNECT_DEFAULT;
525 struct lg_drv_data *drv_data;
526 int ret;
527
528 drv_data = kzalloc(sizeof(struct lg_drv_data), GFP_KERNEL);
529 if (!drv_data) {
530 hid_err(hdev, "Insufficient memory, cannot allocate driver data\n");
531 return -ENOMEM;
532 }
533 drv_data->quirks = id->driver_data;
534
535 hid_set_drvdata(hdev, (void *)drv_data);
536
537 if (drv_data->quirks & LG_NOGET)
538 hdev->quirks |= HID_QUIRK_NOGET;
539
540 ret = hid_parse(hdev);
541 if (ret) {
542 hid_err(hdev, "parse failed\n");
543 goto err_free;
544 }
545
546 if (drv_data->quirks & (LG_FF | LG_FF2 | LG_FF3 | LG_FF4))
547 connect_mask &= ~HID_CONNECT_FF;
548
549 ret = hid_hw_start(hdev, connect_mask);
550 if (ret) {
551 hid_err(hdev, "hw start failed\n");
552 goto err_free;
553 }
554
555 /* Setup wireless link with Logitech Wii wheel */
556 if (hdev->product == USB_DEVICE_ID_LOGITECH_WII_WHEEL) {
557 unsigned char buf[] = { 0x00, 0xAF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
558
559 ret = hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT);
560
561 if (ret >= 0) {
562 /* insert a little delay of 10 jiffies ~ 40ms */
563 wait_queue_head_t wait;
564 init_waitqueue_head (&wait);
565 wait_event_interruptible_timeout(wait, 0, 10);
566
567 /* Select random Address */
568 buf[1] = 0xB2;
569 get_random_bytes(&buf[2], 2);
570
571 ret = hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT);
572 }
573 }
574
575 if (drv_data->quirks & LG_FF)
576 lgff_init(hdev);
577 if (drv_data->quirks & LG_FF2)
578 lg2ff_init(hdev);
579 if (drv_data->quirks & LG_FF3)
580 lg3ff_init(hdev);
581 if (drv_data->quirks & LG_FF4)
582 lg4ff_init(hdev);
583
584 return 0;
585 err_free:
586 kfree(drv_data);
587 return ret;
588 }
589
590 static void lg_remove(struct hid_device *hdev)
591 {
592 struct lg_drv_data *drv_data = hid_get_drvdata(hdev);
593 if (drv_data->quirks & LG_FF4)
594 lg4ff_deinit(hdev);
595
596 hid_hw_stop(hdev);
597 kfree(drv_data);
598 }
599
600 static const struct hid_device_id lg_devices[] = {
601 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER),
602 .driver_data = LG_RDESC | LG_WIRELESS },
603 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER),
604 .driver_data = LG_RDESC | LG_WIRELESS },
605 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2),
606 .driver_data = LG_RDESC | LG_WIRELESS },
607
608 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RECEIVER),
609 .driver_data = LG_BAD_RELATIVE_KEYS },
610
611 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_DESKTOP),
612 .driver_data = LG_DUPLICATE_USAGES },
613 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_EDGE),
614 .driver_data = LG_DUPLICATE_USAGES },
615 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_MINI),
616 .driver_data = LG_DUPLICATE_USAGES },
617
618 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_ELITE_KBD),
619 .driver_data = LG_IGNORE_DOUBLED_WHEEL | LG_EXPANDED_KEYMAP },
620 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500),
621 .driver_data = LG_IGNORE_DOUBLED_WHEEL | LG_EXPANDED_KEYMAP },
622
623 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_EXTREME_3D),
624 .driver_data = LG_NOGET },
625 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WHEEL),
626 .driver_data = LG_NOGET | LG_FF4 },
627
628 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD_CORD),
629 .driver_data = LG_FF2 },
630 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD),
631 .driver_data = LG_FF },
632 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2),
633 .driver_data = LG_FF },
634 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_F3D),
635 .driver_data = LG_FF },
636 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FORCE3D_PRO),
637 .driver_data = LG_FF },
638 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL),
639 .driver_data = LG_NOGET | LG_FF4 },
640 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2),
641 .driver_data = LG_FF4 },
642 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G25_WHEEL),
643 .driver_data = LG_FF4 },
644 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFGT_WHEEL),
645 .driver_data = LG_FF4 },
646 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G27_WHEEL),
647 .driver_data = LG_FF4 },
648 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFP_WHEEL),
649 .driver_data = LG_NOGET | LG_FF4 },
650 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WII_WHEEL),
651 .driver_data = LG_FF4 },
652 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_FFG),
653 .driver_data = LG_FF },
654 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2),
655 .driver_data = LG_FF2 },
656 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FLIGHT_SYSTEM_G940),
657 .driver_data = LG_FF3 },
658 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACENAVIGATOR),
659 .driver_data = LG_RDESC_REL_ABS },
660 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACETRAVELLER),
661 .driver_data = LG_RDESC_REL_ABS },
662 { }
663 };
664
665 MODULE_DEVICE_TABLE(hid, lg_devices);
666
667 static struct hid_driver lg_driver = {
668 .name = "logitech",
669 .id_table = lg_devices,
670 .report_fixup = lg_report_fixup,
671 .input_mapping = lg_input_mapping,
672 .input_mapped = lg_input_mapped,
673 .event = lg_event,
674 .probe = lg_probe,
675 .remove = lg_remove,
676 };
677 module_hid_driver(lg_driver);
678
679 MODULE_LICENSE("GPL");
Linus' kernel tree