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