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