Merge branch 'fixes' of git://git.armlinux.org.uk/~rmk/linux-arm
[linux-2.6-microblaze.git] / drivers / hid / hid-uclogic.c
1 /*
2  *  HID driver for UC-Logic devices not fully compliant with HID standard
3  *
4  *  Copyright (c) 2010-2014 Nikolai Kondrashov
5  *  Copyright (c) 2013 Martin Rusko
6  */
7
8 /*
9  * This program is free software; you can redistribute it and/or modify it
10  * under the terms of the GNU General Public License as published by the Free
11  * Software Foundation; either version 2 of the License, or (at your option)
12  * any later version.
13  */
14
15 #include <linux/device.h>
16 #include <linux/hid.h>
17 #include <linux/module.h>
18 #include <linux/usb.h>
19 #include <asm/unaligned.h>
20 #include "usbhid/usbhid.h"
21
22 #include "hid-ids.h"
23
24 /* Size of the original descriptor of WPXXXXU tablets */
25 #define WPXXXXU_RDESC_ORIG_SIZE 212
26
27 /* Fixed WP4030U report descriptor */
28 static __u8 wp4030u_rdesc_fixed[] = {
29         0x05, 0x0D,         /*  Usage Page (Digitizer),             */
30         0x09, 0x02,         /*  Usage (Pen),                        */
31         0xA1, 0x01,         /*  Collection (Application),           */
32         0x85, 0x09,         /*      Report ID (9),                  */
33         0x09, 0x20,         /*      Usage (Stylus),                 */
34         0xA0,               /*      Collection (Physical),          */
35         0x75, 0x01,         /*          Report Size (1),            */
36         0x09, 0x42,         /*          Usage (Tip Switch),         */
37         0x09, 0x44,         /*          Usage (Barrel Switch),      */
38         0x09, 0x46,         /*          Usage (Tablet Pick),        */
39         0x14,               /*          Logical Minimum (0),        */
40         0x25, 0x01,         /*          Logical Maximum (1),        */
41         0x95, 0x03,         /*          Report Count (3),           */
42         0x81, 0x02,         /*          Input (Variable),           */
43         0x95, 0x05,         /*          Report Count (5),           */
44         0x81, 0x01,         /*          Input (Constant),           */
45         0x75, 0x10,         /*          Report Size (16),           */
46         0x95, 0x01,         /*          Report Count (1),           */
47         0x14,               /*          Logical Minimum (0),        */
48         0xA4,               /*          Push,                       */
49         0x05, 0x01,         /*          Usage Page (Desktop),       */
50         0x55, 0xFD,         /*          Unit Exponent (-3),         */
51         0x65, 0x13,         /*          Unit (Inch),                */
52         0x34,               /*          Physical Minimum (0),       */
53         0x09, 0x30,         /*          Usage (X),                  */
54         0x46, 0xA0, 0x0F,   /*          Physical Maximum (4000),    */
55         0x26, 0xFF, 0x7F,   /*          Logical Maximum (32767),    */
56         0x81, 0x02,         /*          Input (Variable),           */
57         0x09, 0x31,         /*          Usage (Y),                  */
58         0x46, 0xB8, 0x0B,   /*          Physical Maximum (3000),    */
59         0x26, 0xFF, 0x7F,   /*          Logical Maximum (32767),    */
60         0x81, 0x02,         /*          Input (Variable),           */
61         0xB4,               /*          Pop,                        */
62         0x09, 0x30,         /*          Usage (Tip Pressure),       */
63         0x26, 0xFF, 0x03,   /*          Logical Maximum (1023),     */
64         0x81, 0x02,         /*          Input (Variable),           */
65         0xC0,               /*      End Collection,                 */
66         0xC0                /*  End Collection                      */
67 };
68
69 /* Fixed WP5540U report descriptor */
70 static __u8 wp5540u_rdesc_fixed[] = {
71         0x05, 0x0D,         /*  Usage Page (Digitizer),             */
72         0x09, 0x02,         /*  Usage (Pen),                        */
73         0xA1, 0x01,         /*  Collection (Application),           */
74         0x85, 0x09,         /*      Report ID (9),                  */
75         0x09, 0x20,         /*      Usage (Stylus),                 */
76         0xA0,               /*      Collection (Physical),          */
77         0x75, 0x01,         /*          Report Size (1),            */
78         0x09, 0x42,         /*          Usage (Tip Switch),         */
79         0x09, 0x44,         /*          Usage (Barrel Switch),      */
80         0x09, 0x46,         /*          Usage (Tablet Pick),        */
81         0x14,               /*          Logical Minimum (0),        */
82         0x25, 0x01,         /*          Logical Maximum (1),        */
83         0x95, 0x03,         /*          Report Count (3),           */
84         0x81, 0x02,         /*          Input (Variable),           */
85         0x95, 0x05,         /*          Report Count (5),           */
86         0x81, 0x01,         /*          Input (Constant),           */
87         0x75, 0x10,         /*          Report Size (16),           */
88         0x95, 0x01,         /*          Report Count (1),           */
89         0x14,               /*          Logical Minimum (0),        */
90         0xA4,               /*          Push,                       */
91         0x05, 0x01,         /*          Usage Page (Desktop),       */
92         0x55, 0xFD,         /*          Unit Exponent (-3),         */
93         0x65, 0x13,         /*          Unit (Inch),                */
94         0x34,               /*          Physical Minimum (0),       */
95         0x09, 0x30,         /*          Usage (X),                  */
96         0x46, 0x7C, 0x15,   /*          Physical Maximum (5500),    */
97         0x26, 0xFF, 0x7F,   /*          Logical Maximum (32767),    */
98         0x81, 0x02,         /*          Input (Variable),           */
99         0x09, 0x31,         /*          Usage (Y),                  */
100         0x46, 0xA0, 0x0F,   /*          Physical Maximum (4000),    */
101         0x26, 0xFF, 0x7F,   /*          Logical Maximum (32767),    */
102         0x81, 0x02,         /*          Input (Variable),           */
103         0xB4,               /*          Pop,                        */
104         0x09, 0x30,         /*          Usage (Tip Pressure),       */
105         0x26, 0xFF, 0x03,   /*          Logical Maximum (1023),     */
106         0x81, 0x02,         /*          Input (Variable),           */
107         0xC0,               /*      End Collection,                 */
108         0xC0,               /*  End Collection,                     */
109         0x05, 0x01,         /*  Usage Page (Desktop),               */
110         0x09, 0x02,         /*  Usage (Mouse),                      */
111         0xA1, 0x01,         /*  Collection (Application),           */
112         0x85, 0x08,         /*      Report ID (8),                  */
113         0x09, 0x01,         /*      Usage (Pointer),                */
114         0xA0,               /*      Collection (Physical),          */
115         0x75, 0x01,         /*          Report Size (1),            */
116         0x05, 0x09,         /*          Usage Page (Button),        */
117         0x19, 0x01,         /*          Usage Minimum (01h),        */
118         0x29, 0x03,         /*          Usage Maximum (03h),        */
119         0x14,               /*          Logical Minimum (0),        */
120         0x25, 0x01,         /*          Logical Maximum (1),        */
121         0x95, 0x03,         /*          Report Count (3),           */
122         0x81, 0x02,         /*          Input (Variable),           */
123         0x95, 0x05,         /*          Report Count (5),           */
124         0x81, 0x01,         /*          Input (Constant),           */
125         0x05, 0x01,         /*          Usage Page (Desktop),       */
126         0x75, 0x08,         /*          Report Size (8),            */
127         0x09, 0x30,         /*          Usage (X),                  */
128         0x09, 0x31,         /*          Usage (Y),                  */
129         0x15, 0x81,         /*          Logical Minimum (-127),     */
130         0x25, 0x7F,         /*          Logical Maximum (127),      */
131         0x95, 0x02,         /*          Report Count (2),           */
132         0x81, 0x06,         /*          Input (Variable, Relative), */
133         0x09, 0x38,         /*          Usage (Wheel),              */
134         0x15, 0xFF,         /*          Logical Minimum (-1),       */
135         0x25, 0x01,         /*          Logical Maximum (1),        */
136         0x95, 0x01,         /*          Report Count (1),           */
137         0x81, 0x06,         /*          Input (Variable, Relative), */
138         0x81, 0x01,         /*          Input (Constant),           */
139         0xC0,               /*      End Collection,                 */
140         0xC0                /*  End Collection                      */
141 };
142
143 /* Fixed WP8060U report descriptor */
144 static __u8 wp8060u_rdesc_fixed[] = {
145         0x05, 0x0D,         /*  Usage Page (Digitizer),             */
146         0x09, 0x02,         /*  Usage (Pen),                        */
147         0xA1, 0x01,         /*  Collection (Application),           */
148         0x85, 0x09,         /*      Report ID (9),                  */
149         0x09, 0x20,         /*      Usage (Stylus),                 */
150         0xA0,               /*      Collection (Physical),          */
151         0x75, 0x01,         /*          Report Size (1),            */
152         0x09, 0x42,         /*          Usage (Tip Switch),         */
153         0x09, 0x44,         /*          Usage (Barrel Switch),      */
154         0x09, 0x46,         /*          Usage (Tablet Pick),        */
155         0x14,               /*          Logical Minimum (0),        */
156         0x25, 0x01,         /*          Logical Maximum (1),        */
157         0x95, 0x03,         /*          Report Count (3),           */
158         0x81, 0x02,         /*          Input (Variable),           */
159         0x95, 0x05,         /*          Report Count (5),           */
160         0x81, 0x01,         /*          Input (Constant),           */
161         0x75, 0x10,         /*          Report Size (16),           */
162         0x95, 0x01,         /*          Report Count (1),           */
163         0x14,               /*          Logical Minimum (0),        */
164         0xA4,               /*          Push,                       */
165         0x05, 0x01,         /*          Usage Page (Desktop),       */
166         0x55, 0xFD,         /*          Unit Exponent (-3),         */
167         0x65, 0x13,         /*          Unit (Inch),                */
168         0x34,               /*          Physical Minimum (0),       */
169         0x09, 0x30,         /*          Usage (X),                  */
170         0x46, 0x40, 0x1F,   /*          Physical Maximum (8000),    */
171         0x26, 0xFF, 0x7F,   /*          Logical Maximum (32767),    */
172         0x81, 0x02,         /*          Input (Variable),           */
173         0x09, 0x31,         /*          Usage (Y),                  */
174         0x46, 0x70, 0x17,   /*          Physical Maximum (6000),    */
175         0x26, 0xFF, 0x7F,   /*          Logical Maximum (32767),    */
176         0x81, 0x02,         /*          Input (Variable),           */
177         0xB4,               /*          Pop,                        */
178         0x09, 0x30,         /*          Usage (Tip Pressure),       */
179         0x26, 0xFF, 0x03,   /*          Logical Maximum (1023),     */
180         0x81, 0x02,         /*          Input (Variable),           */
181         0xC0,               /*      End Collection,                 */
182         0xC0,               /*  End Collection,                     */
183         0x05, 0x01,         /*  Usage Page (Desktop),               */
184         0x09, 0x02,         /*  Usage (Mouse),                      */
185         0xA1, 0x01,         /*  Collection (Application),           */
186         0x85, 0x08,         /*      Report ID (8),                  */
187         0x09, 0x01,         /*      Usage (Pointer),                */
188         0xA0,               /*      Collection (Physical),          */
189         0x75, 0x01,         /*          Report Size (1),            */
190         0x05, 0x09,         /*          Usage Page (Button),        */
191         0x19, 0x01,         /*          Usage Minimum (01h),        */
192         0x29, 0x03,         /*          Usage Maximum (03h),        */
193         0x14,               /*          Logical Minimum (0),        */
194         0x25, 0x01,         /*          Logical Maximum (1),        */
195         0x95, 0x03,         /*          Report Count (3),           */
196         0x81, 0x02,         /*          Input (Variable),           */
197         0x95, 0x05,         /*          Report Count (5),           */
198         0x81, 0x01,         /*          Input (Constant),           */
199         0x05, 0x01,         /*          Usage Page (Desktop),       */
200         0x75, 0x08,         /*          Report Size (8),            */
201         0x09, 0x30,         /*          Usage (X),                  */
202         0x09, 0x31,         /*          Usage (Y),                  */
203         0x15, 0x81,         /*          Logical Minimum (-127),     */
204         0x25, 0x7F,         /*          Logical Maximum (127),      */
205         0x95, 0x02,         /*          Report Count (2),           */
206         0x81, 0x06,         /*          Input (Variable, Relative), */
207         0x09, 0x38,         /*          Usage (Wheel),              */
208         0x15, 0xFF,         /*          Logical Minimum (-1),       */
209         0x25, 0x01,         /*          Logical Maximum (1),        */
210         0x95, 0x01,         /*          Report Count (1),           */
211         0x81, 0x06,         /*          Input (Variable, Relative), */
212         0x81, 0x01,         /*          Input (Constant),           */
213         0xC0,               /*      End Collection,                 */
214         0xC0                /*  End Collection                      */
215 };
216
217 /* Size of the original descriptor of WP1062 tablet */
218 #define WP1062_RDESC_ORIG_SIZE  254
219
220 /* Fixed WP1062 report descriptor */
221 static __u8 wp1062_rdesc_fixed[] = {
222         0x05, 0x0D,         /*  Usage Page (Digitizer),             */
223         0x09, 0x02,         /*  Usage (Pen),                        */
224         0xA1, 0x01,         /*  Collection (Application),           */
225         0x85, 0x09,         /*      Report ID (9),                  */
226         0x09, 0x20,         /*      Usage (Stylus),                 */
227         0xA0,               /*      Collection (Physical),          */
228         0x75, 0x01,         /*          Report Size (1),            */
229         0x09, 0x42,         /*          Usage (Tip Switch),         */
230         0x09, 0x44,         /*          Usage (Barrel Switch),      */
231         0x09, 0x46,         /*          Usage (Tablet Pick),        */
232         0x14,               /*          Logical Minimum (0),        */
233         0x25, 0x01,         /*          Logical Maximum (1),        */
234         0x95, 0x03,         /*          Report Count (3),           */
235         0x81, 0x02,         /*          Input (Variable),           */
236         0x95, 0x04,         /*          Report Count (4),           */
237         0x81, 0x01,         /*          Input (Constant),           */
238         0x09, 0x32,         /*          Usage (In Range),           */
239         0x95, 0x01,         /*          Report Count (1),           */
240         0x81, 0x02,         /*          Input (Variable),           */
241         0x75, 0x10,         /*          Report Size (16),           */
242         0x95, 0x01,         /*          Report Count (1),           */
243         0x14,               /*          Logical Minimum (0),        */
244         0xA4,               /*          Push,                       */
245         0x05, 0x01,         /*          Usage Page (Desktop),       */
246         0x55, 0xFD,         /*          Unit Exponent (-3),         */
247         0x65, 0x13,         /*          Unit (Inch),                */
248         0x34,               /*          Physical Minimum (0),       */
249         0x09, 0x30,         /*          Usage (X),                  */
250         0x46, 0x10, 0x27,   /*          Physical Maximum (10000),   */
251         0x26, 0x20, 0x4E,   /*          Logical Maximum (20000),    */
252         0x81, 0x02,         /*          Input (Variable),           */
253         0x09, 0x31,         /*          Usage (Y),                  */
254         0x46, 0xB7, 0x19,   /*          Physical Maximum (6583),    */
255         0x26, 0x6E, 0x33,   /*          Logical Maximum (13166),    */
256         0x81, 0x02,         /*          Input (Variable),           */
257         0xB4,               /*          Pop,                        */
258         0x09, 0x30,         /*          Usage (Tip Pressure),       */
259         0x26, 0xFF, 0x03,   /*          Logical Maximum (1023),     */
260         0x81, 0x02,         /*          Input (Variable),           */
261         0xC0,               /*      End Collection,                 */
262         0xC0                /*  End Collection                      */
263 };
264
265 /* Size of the original descriptor of PF1209 tablet */
266 #define PF1209_RDESC_ORIG_SIZE  234
267
268 /* Fixed PF1209 report descriptor */
269 static __u8 pf1209_rdesc_fixed[] = {
270         0x05, 0x0D,         /*  Usage Page (Digitizer),             */
271         0x09, 0x02,         /*  Usage (Pen),                        */
272         0xA1, 0x01,         /*  Collection (Application),           */
273         0x85, 0x09,         /*      Report ID (9),                  */
274         0x09, 0x20,         /*      Usage (Stylus),                 */
275         0xA0,               /*      Collection (Physical),          */
276         0x75, 0x01,         /*          Report Size (1),            */
277         0x09, 0x42,         /*          Usage (Tip Switch),         */
278         0x09, 0x44,         /*          Usage (Barrel Switch),      */
279         0x09, 0x46,         /*          Usage (Tablet Pick),        */
280         0x14,               /*          Logical Minimum (0),        */
281         0x25, 0x01,         /*          Logical Maximum (1),        */
282         0x95, 0x03,         /*          Report Count (3),           */
283         0x81, 0x02,         /*          Input (Variable),           */
284         0x95, 0x05,         /*          Report Count (5),           */
285         0x81, 0x01,         /*          Input (Constant),           */
286         0x75, 0x10,         /*          Report Size (16),           */
287         0x95, 0x01,         /*          Report Count (1),           */
288         0x14,               /*          Logical Minimum (0),        */
289         0xA4,               /*          Push,                       */
290         0x05, 0x01,         /*          Usage Page (Desktop),       */
291         0x55, 0xFD,         /*          Unit Exponent (-3),         */
292         0x65, 0x13,         /*          Unit (Inch),                */
293         0x34,               /*          Physical Minimum (0),       */
294         0x09, 0x30,         /*          Usage (X),                  */
295         0x46, 0xE0, 0x2E,   /*          Physical Maximum (12000),   */
296         0x26, 0xFF, 0x7F,   /*          Logical Maximum (32767),    */
297         0x81, 0x02,         /*          Input (Variable),           */
298         0x09, 0x31,         /*          Usage (Y),                  */
299         0x46, 0x28, 0x23,   /*          Physical Maximum (9000),    */
300         0x26, 0xFF, 0x7F,   /*          Logical Maximum (32767),    */
301         0x81, 0x02,         /*          Input (Variable),           */
302         0xB4,               /*          Pop,                        */
303         0x09, 0x30,         /*          Usage (Tip Pressure),       */
304         0x26, 0xFF, 0x03,   /*          Logical Maximum (1023),     */
305         0x81, 0x02,         /*          Input (Variable),           */
306         0xC0,               /*      End Collection,                 */
307         0xC0,               /*  End Collection,                     */
308         0x05, 0x01,         /*  Usage Page (Desktop),               */
309         0x09, 0x02,         /*  Usage (Mouse),                      */
310         0xA1, 0x01,         /*  Collection (Application),           */
311         0x85, 0x08,         /*      Report ID (8),                  */
312         0x09, 0x01,         /*      Usage (Pointer),                */
313         0xA0,               /*      Collection (Physical),          */
314         0x75, 0x01,         /*          Report Size (1),            */
315         0x05, 0x09,         /*          Usage Page (Button),        */
316         0x19, 0x01,         /*          Usage Minimum (01h),        */
317         0x29, 0x03,         /*          Usage Maximum (03h),        */
318         0x14,               /*          Logical Minimum (0),        */
319         0x25, 0x01,         /*          Logical Maximum (1),        */
320         0x95, 0x03,         /*          Report Count (3),           */
321         0x81, 0x02,         /*          Input (Variable),           */
322         0x95, 0x05,         /*          Report Count (5),           */
323         0x81, 0x01,         /*          Input (Constant),           */
324         0x05, 0x01,         /*          Usage Page (Desktop),       */
325         0x75, 0x08,         /*          Report Size (8),            */
326         0x09, 0x30,         /*          Usage (X),                  */
327         0x09, 0x31,         /*          Usage (Y),                  */
328         0x15, 0x81,         /*          Logical Minimum (-127),     */
329         0x25, 0x7F,         /*          Logical Maximum (127),      */
330         0x95, 0x02,         /*          Report Count (2),           */
331         0x81, 0x06,         /*          Input (Variable, Relative), */
332         0x09, 0x38,         /*          Usage (Wheel),              */
333         0x15, 0xFF,         /*          Logical Minimum (-1),       */
334         0x25, 0x01,         /*          Logical Maximum (1),        */
335         0x95, 0x01,         /*          Report Count (1),           */
336         0x81, 0x06,         /*          Input (Variable, Relative), */
337         0x81, 0x01,         /*          Input (Constant),           */
338         0xC0,               /*      End Collection,                 */
339         0xC0                /*  End Collection                      */
340 };
341
342 /* Size of the original descriptors of TWHL850 tablet */
343 #define TWHL850_RDESC_ORIG_SIZE0        182
344 #define TWHL850_RDESC_ORIG_SIZE1        161
345 #define TWHL850_RDESC_ORIG_SIZE2        92
346
347 /* Fixed PID 0522 tablet report descriptor, interface 0 (stylus) */
348 static __u8 twhl850_rdesc_fixed0[] = {
349         0x05, 0x0D,         /*  Usage Page (Digitizer),             */
350         0x09, 0x02,         /*  Usage (Pen),                        */
351         0xA1, 0x01,         /*  Collection (Application),           */
352         0x85, 0x09,         /*      Report ID (9),                  */
353         0x09, 0x20,         /*      Usage (Stylus),                 */
354         0xA0,               /*      Collection (Physical),          */
355         0x14,               /*          Logical Minimum (0),        */
356         0x25, 0x01,         /*          Logical Maximum (1),        */
357         0x75, 0x01,         /*          Report Size (1),            */
358         0x95, 0x03,         /*          Report Count (3),           */
359         0x09, 0x42,         /*          Usage (Tip Switch),         */
360         0x09, 0x44,         /*          Usage (Barrel Switch),      */
361         0x09, 0x46,         /*          Usage (Tablet Pick),        */
362         0x81, 0x02,         /*          Input (Variable),           */
363         0x81, 0x03,         /*          Input (Constant, Variable), */
364         0x95, 0x01,         /*          Report Count (1),           */
365         0x09, 0x32,         /*          Usage (In Range),           */
366         0x81, 0x02,         /*          Input (Variable),           */
367         0x81, 0x03,         /*          Input (Constant, Variable), */
368         0x75, 0x10,         /*          Report Size (16),           */
369         0xA4,               /*          Push,                       */
370         0x05, 0x01,         /*          Usage Page (Desktop),       */
371         0x65, 0x13,         /*          Unit (Inch),                */
372         0x55, 0xFD,         /*          Unit Exponent (-3),         */
373         0x34,               /*          Physical Minimum (0),       */
374         0x09, 0x30,         /*          Usage (X),                  */
375         0x46, 0x40, 0x1F,   /*          Physical Maximum (8000),    */
376         0x26, 0x00, 0x7D,   /*          Logical Maximum (32000),    */
377         0x81, 0x02,         /*          Input (Variable),           */
378         0x09, 0x31,         /*          Usage (Y),                  */
379         0x46, 0x88, 0x13,   /*          Physical Maximum (5000),    */
380         0x26, 0x20, 0x4E,   /*          Logical Maximum (20000),    */
381         0x81, 0x02,         /*          Input (Variable),           */
382         0xB4,               /*          Pop,                        */
383         0x09, 0x30,         /*          Usage (Tip Pressure),       */
384         0x26, 0xFF, 0x03,   /*          Logical Maximum (1023),     */
385         0x81, 0x02,         /*          Input (Variable),           */
386         0xC0,               /*      End Collection,                 */
387         0xC0                /*  End Collection                      */
388 };
389
390 /* Fixed PID 0522 tablet report descriptor, interface 1 (mouse) */
391 static __u8 twhl850_rdesc_fixed1[] = {
392         0x05, 0x01,         /*  Usage Page (Desktop),               */
393         0x09, 0x02,         /*  Usage (Mouse),                      */
394         0xA1, 0x01,         /*  Collection (Application),           */
395         0x85, 0x01,         /*      Report ID (1),                  */
396         0x09, 0x01,         /*      Usage (Pointer),                */
397         0xA0,               /*      Collection (Physical),          */
398         0x05, 0x09,         /*          Usage Page (Button),        */
399         0x75, 0x01,         /*          Report Size (1),            */
400         0x95, 0x03,         /*          Report Count (3),           */
401         0x19, 0x01,         /*          Usage Minimum (01h),        */
402         0x29, 0x03,         /*          Usage Maximum (03h),        */
403         0x14,               /*          Logical Minimum (0),        */
404         0x25, 0x01,         /*          Logical Maximum (1),        */
405         0x81, 0x02,         /*          Input (Variable),           */
406         0x95, 0x05,         /*          Report Count (5),           */
407         0x81, 0x03,         /*          Input (Constant, Variable), */
408         0x05, 0x01,         /*          Usage Page (Desktop),       */
409         0x09, 0x30,         /*          Usage (X),                  */
410         0x09, 0x31,         /*          Usage (Y),                  */
411         0x16, 0x00, 0x80,   /*          Logical Minimum (-32768),   */
412         0x26, 0xFF, 0x7F,   /*          Logical Maximum (32767),    */
413         0x75, 0x10,         /*          Report Size (16),           */
414         0x95, 0x02,         /*          Report Count (2),           */
415         0x81, 0x06,         /*          Input (Variable, Relative), */
416         0x09, 0x38,         /*          Usage (Wheel),              */
417         0x15, 0xFF,         /*          Logical Minimum (-1),       */
418         0x25, 0x01,         /*          Logical Maximum (1),        */
419         0x95, 0x01,         /*          Report Count (1),           */
420         0x75, 0x08,         /*          Report Size (8),            */
421         0x81, 0x06,         /*          Input (Variable, Relative), */
422         0x81, 0x03,         /*          Input (Constant, Variable), */
423         0xC0,               /*      End Collection,                 */
424         0xC0                /*  End Collection                      */
425 };
426
427 /* Fixed PID 0522 tablet report descriptor, interface 2 (frame buttons) */
428 static __u8 twhl850_rdesc_fixed2[] = {
429         0x05, 0x01,         /*  Usage Page (Desktop),               */
430         0x09, 0x06,         /*  Usage (Keyboard),                   */
431         0xA1, 0x01,         /*  Collection (Application),           */
432         0x85, 0x03,         /*      Report ID (3),                  */
433         0x05, 0x07,         /*      Usage Page (Keyboard),          */
434         0x14,               /*      Logical Minimum (0),            */
435         0x19, 0xE0,         /*      Usage Minimum (KB Leftcontrol), */
436         0x29, 0xE7,         /*      Usage Maximum (KB Right GUI),   */
437         0x25, 0x01,         /*      Logical Maximum (1),            */
438         0x75, 0x01,         /*      Report Size (1),                */
439         0x95, 0x08,         /*      Report Count (8),               */
440         0x81, 0x02,         /*      Input (Variable),               */
441         0x18,               /*      Usage Minimum (None),           */
442         0x29, 0xFF,         /*      Usage Maximum (FFh),            */
443         0x26, 0xFF, 0x00,   /*      Logical Maximum (255),          */
444         0x75, 0x08,         /*      Report Size (8),                */
445         0x95, 0x06,         /*      Report Count (6),               */
446         0x80,               /*      Input,                          */
447         0xC0                /*  End Collection                      */
448 };
449
450 /* Size of the original descriptors of TWHA60 tablet */
451 #define TWHA60_RDESC_ORIG_SIZE0 254
452 #define TWHA60_RDESC_ORIG_SIZE1 139
453
454 /* Fixed TWHA60 report descriptor, interface 0 (stylus) */
455 static __u8 twha60_rdesc_fixed0[] = {
456         0x05, 0x0D,         /*  Usage Page (Digitizer),             */
457         0x09, 0x02,         /*  Usage (Pen),                        */
458         0xA1, 0x01,         /*  Collection (Application),           */
459         0x85, 0x09,         /*      Report ID (9),                  */
460         0x09, 0x20,         /*      Usage (Stylus),                 */
461         0xA0,               /*      Collection (Physical),          */
462         0x75, 0x01,         /*          Report Size (1),            */
463         0x09, 0x42,         /*          Usage (Tip Switch),         */
464         0x09, 0x44,         /*          Usage (Barrel Switch),      */
465         0x09, 0x46,         /*          Usage (Tablet Pick),        */
466         0x14,               /*          Logical Minimum (0),        */
467         0x25, 0x01,         /*          Logical Maximum (1),        */
468         0x95, 0x03,         /*          Report Count (3),           */
469         0x81, 0x02,         /*          Input (Variable),           */
470         0x95, 0x04,         /*          Report Count (4),           */
471         0x81, 0x01,         /*          Input (Constant),           */
472         0x09, 0x32,         /*          Usage (In Range),           */
473         0x95, 0x01,         /*          Report Count (1),           */
474         0x81, 0x02,         /*          Input (Variable),           */
475         0x75, 0x10,         /*          Report Size (16),           */
476         0x95, 0x01,         /*          Report Count (1),           */
477         0x14,               /*          Logical Minimum (0),        */
478         0xA4,               /*          Push,                       */
479         0x05, 0x01,         /*          Usage Page (Desktop),       */
480         0x55, 0xFD,         /*          Unit Exponent (-3),         */
481         0x65, 0x13,         /*          Unit (Inch),                */
482         0x34,               /*          Physical Minimum (0),       */
483         0x09, 0x30,         /*          Usage (X),                  */
484         0x46, 0x10, 0x27,   /*          Physical Maximum (10000),   */
485         0x27, 0x3F, 0x9C,
486                 0x00, 0x00, /*          Logical Maximum (39999),    */
487         0x81, 0x02,         /*          Input (Variable),           */
488         0x09, 0x31,         /*          Usage (Y),                  */
489         0x46, 0x6A, 0x18,   /*          Physical Maximum (6250),    */
490         0x26, 0xA7, 0x61,   /*          Logical Maximum (24999),    */
491         0x81, 0x02,         /*          Input (Variable),           */
492         0xB4,               /*          Pop,                        */
493         0x09, 0x30,         /*          Usage (Tip Pressure),       */
494         0x26, 0xFF, 0x03,   /*          Logical Maximum (1023),     */
495         0x81, 0x02,         /*          Input (Variable),           */
496         0xC0,               /*      End Collection,                 */
497         0xC0                /*  End Collection                      */
498 };
499
500 /* Fixed TWHA60 report descriptor, interface 1 (frame buttons) */
501 static __u8 twha60_rdesc_fixed1[] = {
502         0x05, 0x01, /*  Usage Page (Desktop),       */
503         0x09, 0x06, /*  Usage (Keyboard),           */
504         0xA1, 0x01, /*  Collection (Application),   */
505         0x85, 0x05, /*      Report ID (5),          */
506         0x05, 0x07, /*      Usage Page (Keyboard),  */
507         0x14,       /*      Logical Minimum (0),    */
508         0x25, 0x01, /*      Logical Maximum (1),    */
509         0x75, 0x01, /*      Report Size (1),        */
510         0x95, 0x08, /*      Report Count (8),       */
511         0x81, 0x01, /*      Input (Constant),       */
512         0x95, 0x0C, /*      Report Count (12),      */
513         0x19, 0x3A, /*      Usage Minimum (KB F1),  */
514         0x29, 0x45, /*      Usage Maximum (KB F12), */
515         0x81, 0x02, /*      Input (Variable),       */
516         0x95, 0x0C, /*      Report Count (12),      */
517         0x19, 0x68, /*      Usage Minimum (KB F13), */
518         0x29, 0x73, /*      Usage Maximum (KB F24), */
519         0x81, 0x02, /*      Input (Variable),       */
520         0x95, 0x08, /*      Report Count (8),       */
521         0x81, 0x01, /*      Input (Constant),       */
522         0xC0        /*  End Collection              */
523 };
524
525 /* Report descriptor template placeholder head */
526 #define UCLOGIC_PH_HEAD 0xFE, 0xED, 0x1D
527
528 /* Report descriptor template placeholder IDs */
529 enum uclogic_ph_id {
530         UCLOGIC_PH_ID_X_LM,
531         UCLOGIC_PH_ID_X_PM,
532         UCLOGIC_PH_ID_Y_LM,
533         UCLOGIC_PH_ID_Y_PM,
534         UCLOGIC_PH_ID_PRESSURE_LM,
535         UCLOGIC_PH_ID_NUM
536 };
537
538 /* Report descriptor template placeholder */
539 #define UCLOGIC_PH(_ID) UCLOGIC_PH_HEAD, UCLOGIC_PH_ID_##_ID
540 #define UCLOGIC_PEN_REPORT_ID   0x07
541
542 /* Fixed report descriptor template */
543 static const __u8 uclogic_tablet_rdesc_template[] = {
544         0x05, 0x0D,             /*  Usage Page (Digitizer),                 */
545         0x09, 0x02,             /*  Usage (Pen),                            */
546         0xA1, 0x01,             /*  Collection (Application),               */
547         0x85, 0x07,             /*      Report ID (7),                      */
548         0x09, 0x20,             /*      Usage (Stylus),                     */
549         0xA0,                   /*      Collection (Physical),              */
550         0x14,                   /*          Logical Minimum (0),            */
551         0x25, 0x01,             /*          Logical Maximum (1),            */
552         0x75, 0x01,             /*          Report Size (1),                */
553         0x09, 0x42,             /*          Usage (Tip Switch),             */
554         0x09, 0x44,             /*          Usage (Barrel Switch),          */
555         0x09, 0x46,             /*          Usage (Tablet Pick),            */
556         0x95, 0x03,             /*          Report Count (3),               */
557         0x81, 0x02,             /*          Input (Variable),               */
558         0x95, 0x03,             /*          Report Count (3),               */
559         0x81, 0x03,             /*          Input (Constant, Variable),     */
560         0x09, 0x32,             /*          Usage (In Range),               */
561         0x95, 0x01,             /*          Report Count (1),               */
562         0x81, 0x02,             /*          Input (Variable),               */
563         0x95, 0x01,             /*          Report Count (1),               */
564         0x81, 0x03,             /*          Input (Constant, Variable),     */
565         0x75, 0x10,             /*          Report Size (16),               */
566         0x95, 0x01,             /*          Report Count (1),               */
567         0xA4,                   /*          Push,                           */
568         0x05, 0x01,             /*          Usage Page (Desktop),           */
569         0x65, 0x13,             /*          Unit (Inch),                    */
570         0x55, 0xFD,             /*          Unit Exponent (-3),             */
571         0x34,                   /*          Physical Minimum (0),           */
572         0x09, 0x30,             /*          Usage (X),                      */
573         0x27, UCLOGIC_PH(X_LM), /*          Logical Maximum (PLACEHOLDER),  */
574         0x47, UCLOGIC_PH(X_PM), /*          Physical Maximum (PLACEHOLDER), */
575         0x81, 0x02,             /*          Input (Variable),               */
576         0x09, 0x31,             /*          Usage (Y),                      */
577         0x27, UCLOGIC_PH(Y_LM), /*          Logical Maximum (PLACEHOLDER),  */
578         0x47, UCLOGIC_PH(Y_PM), /*          Physical Maximum (PLACEHOLDER), */
579         0x81, 0x02,             /*          Input (Variable),               */
580         0xB4,                   /*          Pop,                            */
581         0x09, 0x30,             /*          Usage (Tip Pressure),           */
582         0x27,
583         UCLOGIC_PH(PRESSURE_LM),/*          Logical Maximum (PLACEHOLDER),  */
584         0x81, 0x02,             /*          Input (Variable),               */
585         0xC0,                   /*      End Collection,                     */
586         0xC0                    /*  End Collection                          */
587 };
588
589 /* Fixed virtual pad report descriptor */
590 static const __u8 uclogic_buttonpad_rdesc[] = {
591         0x05, 0x01,             /*  Usage Page (Desktop),                   */
592         0x09, 0x07,             /*  Usage (Keypad),                         */
593         0xA1, 0x01,             /*  Collection (Application),               */
594         0x85, 0xF7,             /*      Report ID (247),                    */
595         0x05, 0x0D,             /*      Usage Page (Digitizers),            */
596         0x09, 0x39,             /*      Usage (Tablet Function Keys),       */
597         0xA0,                   /*      Collection (Physical),              */
598         0x05, 0x09,             /*          Usage Page (Button),            */
599         0x75, 0x01,             /*          Report Size (1),                */
600         0x95, 0x18,             /*          Report Count (24),              */
601         0x81, 0x03,             /*          Input (Constant, Variable),     */
602         0x19, 0x01,             /*          Usage Minimum (01h),            */
603         0x29, 0x08,             /*          Usage Maximum (08h),            */
604         0x95, 0x08,             /*          Report Count (8),               */
605         0x81, 0x02,             /*          Input (Variable),               */
606         0xC0,                   /*      End Collection                      */
607         0xC0                    /*  End Collection                          */
608 };
609
610 /* Parameter indices */
611 enum uclogic_prm {
612         UCLOGIC_PRM_X_LM        = 1,
613         UCLOGIC_PRM_Y_LM        = 2,
614         UCLOGIC_PRM_PRESSURE_LM = 4,
615         UCLOGIC_PRM_RESOLUTION  = 5,
616         UCLOGIC_PRM_NUM
617 };
618
619 /* Driver data */
620 struct uclogic_drvdata {
621         __u8 *rdesc;
622         unsigned int rsize;
623         bool invert_pen_inrange;
624         bool ignore_pen_usage;
625         bool has_virtual_pad_interface;
626 };
627
628 static __u8 *uclogic_report_fixup(struct hid_device *hdev, __u8 *rdesc,
629                                         unsigned int *rsize)
630 {
631         struct usb_interface *iface = to_usb_interface(hdev->dev.parent);
632         __u8 iface_num = iface->cur_altsetting->desc.bInterfaceNumber;
633         struct uclogic_drvdata *drvdata = hid_get_drvdata(hdev);
634
635         if (drvdata->rdesc != NULL) {
636                 rdesc = drvdata->rdesc;
637                 *rsize = drvdata->rsize;
638                 return rdesc;
639         }
640
641         switch (hdev->product) {
642         case USB_DEVICE_ID_UCLOGIC_TABLET_PF1209:
643                 if (*rsize == PF1209_RDESC_ORIG_SIZE) {
644                         rdesc = pf1209_rdesc_fixed;
645                         *rsize = sizeof(pf1209_rdesc_fixed);
646                 }
647                 break;
648         case USB_DEVICE_ID_UCLOGIC_TABLET_WP4030U:
649                 if (*rsize == WPXXXXU_RDESC_ORIG_SIZE) {
650                         rdesc = wp4030u_rdesc_fixed;
651                         *rsize = sizeof(wp4030u_rdesc_fixed);
652                 }
653                 break;
654         case USB_DEVICE_ID_UCLOGIC_TABLET_WP5540U:
655                 if (*rsize == WPXXXXU_RDESC_ORIG_SIZE) {
656                         rdesc = wp5540u_rdesc_fixed;
657                         *rsize = sizeof(wp5540u_rdesc_fixed);
658                 }
659                 break;
660         case USB_DEVICE_ID_UCLOGIC_TABLET_WP8060U:
661                 if (*rsize == WPXXXXU_RDESC_ORIG_SIZE) {
662                         rdesc = wp8060u_rdesc_fixed;
663                         *rsize = sizeof(wp8060u_rdesc_fixed);
664                 }
665                 break;
666         case USB_DEVICE_ID_UCLOGIC_TABLET_WP1062:
667                 if (*rsize == WP1062_RDESC_ORIG_SIZE) {
668                         rdesc = wp1062_rdesc_fixed;
669                         *rsize = sizeof(wp1062_rdesc_fixed);
670                 }
671                 break;
672         case USB_DEVICE_ID_UCLOGIC_WIRELESS_TABLET_TWHL850:
673                 switch (iface_num) {
674                 case 0:
675                         if (*rsize == TWHL850_RDESC_ORIG_SIZE0) {
676                                 rdesc = twhl850_rdesc_fixed0;
677                                 *rsize = sizeof(twhl850_rdesc_fixed0);
678                         }
679                         break;
680                 case 1:
681                         if (*rsize == TWHL850_RDESC_ORIG_SIZE1) {
682                                 rdesc = twhl850_rdesc_fixed1;
683                                 *rsize = sizeof(twhl850_rdesc_fixed1);
684                         }
685                         break;
686                 case 2:
687                         if (*rsize == TWHL850_RDESC_ORIG_SIZE2) {
688                                 rdesc = twhl850_rdesc_fixed2;
689                                 *rsize = sizeof(twhl850_rdesc_fixed2);
690                         }
691                         break;
692                 }
693                 break;
694         case USB_DEVICE_ID_UCLOGIC_TABLET_TWHA60:
695                 switch (iface_num) {
696                 case 0:
697                         if (*rsize == TWHA60_RDESC_ORIG_SIZE0) {
698                                 rdesc = twha60_rdesc_fixed0;
699                                 *rsize = sizeof(twha60_rdesc_fixed0);
700                         }
701                         break;
702                 case 1:
703                         if (*rsize == TWHA60_RDESC_ORIG_SIZE1) {
704                                 rdesc = twha60_rdesc_fixed1;
705                                 *rsize = sizeof(twha60_rdesc_fixed1);
706                         }
707                         break;
708                 }
709                 break;
710         }
711
712         return rdesc;
713 }
714
715 static int uclogic_input_mapping(struct hid_device *hdev, struct hid_input *hi,
716                 struct hid_field *field, struct hid_usage *usage,
717                 unsigned long **bit, int *max)
718 {
719         struct uclogic_drvdata *drvdata = hid_get_drvdata(hdev);
720
721         /* discard the unused pen interface */
722         if ((drvdata->ignore_pen_usage) &&
723             (field->application == HID_DG_PEN))
724                 return -1;
725
726         /* let hid-core decide what to do */
727         return 0;
728 }
729
730 static int uclogic_input_configured(struct hid_device *hdev,
731                 struct hid_input *hi)
732 {
733         char *name;
734         const char *suffix = NULL;
735         struct hid_field *field;
736         size_t len;
737
738         /* no report associated (HID_QUIRK_MULTI_INPUT not set) */
739         if (!hi->report)
740                 return 0;
741
742         field = hi->report->field[0];
743
744         switch (field->application) {
745         case HID_GD_KEYBOARD:
746                 suffix = "Keyboard";
747                 break;
748         case HID_GD_MOUSE:
749                 suffix = "Mouse";
750                 break;
751         case HID_GD_KEYPAD:
752                 suffix = "Pad";
753                 break;
754         case HID_DG_PEN:
755                 suffix = "Pen";
756                 break;
757         case HID_CP_CONSUMER_CONTROL:
758                 suffix = "Consumer Control";
759                 break;
760         case HID_GD_SYSTEM_CONTROL:
761                 suffix = "System Control";
762                 break;
763         }
764
765         if (suffix) {
766                 len = strlen(hdev->name) + 2 + strlen(suffix);
767                 name = devm_kzalloc(&hi->input->dev, len, GFP_KERNEL);
768                 if (name) {
769                         snprintf(name, len, "%s %s", hdev->name, suffix);
770                         hi->input->name = name;
771                 }
772         }
773
774         return 0;
775 }
776
777 /**
778  * Enable fully-functional tablet mode and determine device parameters.
779  *
780  * @hdev:       HID device
781  */
782 static int uclogic_tablet_enable(struct hid_device *hdev)
783 {
784         int rc;
785         struct usb_device *usb_dev = hid_to_usb_dev(hdev);
786         struct uclogic_drvdata *drvdata = hid_get_drvdata(hdev);
787         __le16 *buf = NULL;
788         size_t len;
789         s32 params[UCLOGIC_PH_ID_NUM];
790         s32 resolution;
791         __u8 *p;
792         s32 v;
793
794         /*
795          * Read string descriptor containing tablet parameters. The specific
796          * string descriptor and data were discovered by sniffing the Windows
797          * driver traffic.
798          * NOTE: This enables fully-functional tablet mode.
799          */
800         len = UCLOGIC_PRM_NUM * sizeof(*buf);
801         buf = kmalloc(len, GFP_KERNEL);
802         if (buf == NULL) {
803                 rc = -ENOMEM;
804                 goto cleanup;
805         }
806         rc = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
807                                 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
808                                 (USB_DT_STRING << 8) + 0x64,
809                                 0x0409, buf, len,
810                                 USB_CTRL_GET_TIMEOUT);
811         if (rc == -EPIPE) {
812                 hid_err(hdev, "device parameters not found\n");
813                 rc = -ENODEV;
814                 goto cleanup;
815         } else if (rc < 0) {
816                 hid_err(hdev, "failed to get device parameters: %d\n", rc);
817                 rc = -ENODEV;
818                 goto cleanup;
819         } else if (rc != len) {
820                 hid_err(hdev, "invalid device parameters\n");
821                 rc = -ENODEV;
822                 goto cleanup;
823         }
824
825         /* Extract device parameters */
826         params[UCLOGIC_PH_ID_X_LM] = le16_to_cpu(buf[UCLOGIC_PRM_X_LM]);
827         params[UCLOGIC_PH_ID_Y_LM] = le16_to_cpu(buf[UCLOGIC_PRM_Y_LM]);
828         params[UCLOGIC_PH_ID_PRESSURE_LM] =
829                 le16_to_cpu(buf[UCLOGIC_PRM_PRESSURE_LM]);
830         resolution = le16_to_cpu(buf[UCLOGIC_PRM_RESOLUTION]);
831         if (resolution == 0) {
832                 params[UCLOGIC_PH_ID_X_PM] = 0;
833                 params[UCLOGIC_PH_ID_Y_PM] = 0;
834         } else {
835                 params[UCLOGIC_PH_ID_X_PM] = params[UCLOGIC_PH_ID_X_LM] *
836                                                 1000 / resolution;
837                 params[UCLOGIC_PH_ID_Y_PM] = params[UCLOGIC_PH_ID_Y_LM] *
838                                                 1000 / resolution;
839         }
840
841         /* Allocate fixed report descriptor */
842         drvdata->rdesc = devm_kzalloc(&hdev->dev,
843                                 sizeof(uclogic_tablet_rdesc_template),
844                                 GFP_KERNEL);
845         if (drvdata->rdesc == NULL) {
846                 rc = -ENOMEM;
847                 goto cleanup;
848         }
849         drvdata->rsize = sizeof(uclogic_tablet_rdesc_template);
850
851         /* Format fixed report descriptor */
852         memcpy(drvdata->rdesc, uclogic_tablet_rdesc_template,
853                 drvdata->rsize);
854         for (p = drvdata->rdesc;
855              p <= drvdata->rdesc + drvdata->rsize - 4;) {
856                 if (p[0] == 0xFE && p[1] == 0xED && p[2] == 0x1D &&
857                     p[3] < ARRAY_SIZE(params)) {
858                         v = params[p[3]];
859                         put_unaligned(cpu_to_le32(v), (s32 *)p);
860                         p += 4;
861                 } else {
862                         p++;
863                 }
864         }
865
866         rc = 0;
867
868 cleanup:
869         kfree(buf);
870         return rc;
871 }
872
873 /**
874  * Enable actual button mode.
875  *
876  * @hdev:       HID device
877  */
878 static int uclogic_button_enable(struct hid_device *hdev)
879 {
880         int rc;
881         struct usb_device *usb_dev = hid_to_usb_dev(hdev);
882         struct uclogic_drvdata *drvdata = hid_get_drvdata(hdev);
883         char *str_buf;
884         size_t str_len = 16;
885         unsigned char *rdesc;
886         size_t rdesc_len;
887
888         str_buf = kzalloc(str_len, GFP_KERNEL);
889         if (str_buf == NULL) {
890                 rc = -ENOMEM;
891                 goto cleanup;
892         }
893
894         /* Enable abstract keyboard mode */
895         rc = usb_string(usb_dev, 0x7b, str_buf, str_len);
896         if (rc == -EPIPE) {
897                 hid_info(hdev, "button mode setting not found\n");
898                 rc = 0;
899                 goto cleanup;
900         } else if (rc < 0) {
901                 hid_err(hdev, "failed to enable abstract keyboard\n");
902                 goto cleanup;
903         } else if (strncmp(str_buf, "HK On", rc)) {
904                 hid_info(hdev, "invalid answer when requesting buttons: '%s'\n",
905                         str_buf);
906                 rc = -EINVAL;
907                 goto cleanup;
908         }
909
910         /* Re-allocate fixed report descriptor */
911         rdesc_len = drvdata->rsize + sizeof(uclogic_buttonpad_rdesc);
912         rdesc = devm_kzalloc(&hdev->dev, rdesc_len, GFP_KERNEL);
913         if (!rdesc) {
914                 rc = -ENOMEM;
915                 goto cleanup;
916         }
917
918         memcpy(rdesc, drvdata->rdesc, drvdata->rsize);
919
920         /* Append the buttonpad descriptor */
921         memcpy(rdesc + drvdata->rsize, uclogic_buttonpad_rdesc,
922                sizeof(uclogic_buttonpad_rdesc));
923
924         /* clean up old rdesc and use the new one */
925         drvdata->rsize = rdesc_len;
926         devm_kfree(&hdev->dev, drvdata->rdesc);
927         drvdata->rdesc = rdesc;
928
929         rc = 0;
930
931 cleanup:
932         kfree(str_buf);
933         return rc;
934 }
935
936 static int uclogic_probe(struct hid_device *hdev,
937                 const struct hid_device_id *id)
938 {
939         int rc;
940         struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
941         struct usb_device *udev = hid_to_usb_dev(hdev);
942         struct uclogic_drvdata *drvdata;
943
944         /*
945          * libinput requires the pad interface to be on a different node
946          * than the pen, so use QUIRK_MULTI_INPUT for all tablets.
947          */
948         hdev->quirks |= HID_QUIRK_MULTI_INPUT;
949         hdev->quirks |= HID_QUIRK_NO_EMPTY_INPUT;
950
951         /* Allocate and assign driver data */
952         drvdata = devm_kzalloc(&hdev->dev, sizeof(*drvdata), GFP_KERNEL);
953         if (drvdata == NULL)
954                 return -ENOMEM;
955
956         hid_set_drvdata(hdev, drvdata);
957
958         switch (id->product) {
959         case USB_DEVICE_ID_HUION_TABLET:
960         case USB_DEVICE_ID_YIYNOVA_TABLET:
961         case USB_DEVICE_ID_UGEE_TABLET_81:
962         case USB_DEVICE_ID_UCLOGIC_DRAWIMAGE_G3:
963         case USB_DEVICE_ID_UGEE_TABLET_45:
964                 /* If this is the pen interface */
965                 if (intf->cur_altsetting->desc.bInterfaceNumber == 0) {
966                         rc = uclogic_tablet_enable(hdev);
967                         if (rc) {
968                                 hid_err(hdev, "tablet enabling failed\n");
969                                 return rc;
970                         }
971                         drvdata->invert_pen_inrange = true;
972
973                         rc = uclogic_button_enable(hdev);
974                         drvdata->has_virtual_pad_interface = !rc;
975                 } else {
976                         drvdata->ignore_pen_usage = true;
977                 }
978                 break;
979         case USB_DEVICE_ID_UGTIZER_TABLET_GP0610:
980         case USB_DEVICE_ID_UGEE_TABLET_EX07S:
981                 /* If this is the pen interface */
982                 if (intf->cur_altsetting->desc.bInterfaceNumber == 1) {
983                         rc = uclogic_tablet_enable(hdev);
984                         if (rc) {
985                                 hid_err(hdev, "tablet enabling failed\n");
986                                 return rc;
987                         }
988                         drvdata->invert_pen_inrange = true;
989                 } else {
990                         drvdata->ignore_pen_usage = true;
991                 }
992                 break;
993         case USB_DEVICE_ID_UCLOGIC_TABLET_TWHA60:
994                 /*
995                  * If it is the three-interface version, which is known to
996                  * respond to initialization.
997                  */
998                 if (udev->config->desc.bNumInterfaces == 3) {
999                         /* If it is the pen interface */
1000                         if (intf->cur_altsetting->desc.bInterfaceNumber == 0) {
1001                                 rc = uclogic_tablet_enable(hdev);
1002                                 if (rc) {
1003                                         hid_err(hdev, "tablet enabling failed\n");
1004                                         return rc;
1005                                 }
1006                                 drvdata->invert_pen_inrange = true;
1007
1008                                 rc = uclogic_button_enable(hdev);
1009                                 drvdata->has_virtual_pad_interface = !rc;
1010                         } else {
1011                                 drvdata->ignore_pen_usage = true;
1012                         }
1013                 }
1014                 break;
1015         }
1016
1017         rc = hid_parse(hdev);
1018         if (rc) {
1019                 hid_err(hdev, "parse failed\n");
1020                 return rc;
1021         }
1022
1023         rc = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
1024         if (rc) {
1025                 hid_err(hdev, "hw start failed\n");
1026                 return rc;
1027         }
1028
1029         return 0;
1030 }
1031
1032 static int uclogic_raw_event(struct hid_device *hdev, struct hid_report *report,
1033                         u8 *data, int size)
1034 {
1035         struct uclogic_drvdata *drvdata = hid_get_drvdata(hdev);
1036
1037         if ((report->type == HID_INPUT_REPORT) &&
1038             (report->id == UCLOGIC_PEN_REPORT_ID) &&
1039             (size >= 2)) {
1040                 if (drvdata->has_virtual_pad_interface && (data[1] & 0x20))
1041                         /* Change to virtual frame button report ID */
1042                         data[0] = 0xf7;
1043                 else if (drvdata->invert_pen_inrange)
1044                         /* Invert the in-range bit */
1045                         data[1] ^= 0x40;
1046         }
1047
1048         return 0;
1049 }
1050
1051 static const struct hid_device_id uclogic_devices[] = {
1052         { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC,
1053                                 USB_DEVICE_ID_UCLOGIC_TABLET_PF1209) },
1054         { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC,
1055                                 USB_DEVICE_ID_UCLOGIC_TABLET_WP4030U) },
1056         { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC,
1057                                 USB_DEVICE_ID_UCLOGIC_TABLET_WP5540U) },
1058         { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC,
1059                                 USB_DEVICE_ID_UCLOGIC_TABLET_WP8060U) },
1060         { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC,
1061                                 USB_DEVICE_ID_UCLOGIC_TABLET_WP1062) },
1062         { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC,
1063                                 USB_DEVICE_ID_UCLOGIC_WIRELESS_TABLET_TWHL850) },
1064         { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC,
1065                                 USB_DEVICE_ID_UCLOGIC_TABLET_TWHA60) },
1066         { HID_USB_DEVICE(USB_VENDOR_ID_HUION, USB_DEVICE_ID_HUION_TABLET) },
1067         { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_HUION_TABLET) },
1068         { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_YIYNOVA_TABLET) },
1069         { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UGEE_TABLET_81) },
1070         { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UGEE_TABLET_45) },
1071         { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_DRAWIMAGE_G3) },
1072         { HID_USB_DEVICE(USB_VENDOR_ID_UGTIZER, USB_DEVICE_ID_UGTIZER_TABLET_GP0610) },
1073         { HID_USB_DEVICE(USB_VENDOR_ID_UGEE, USB_DEVICE_ID_UGEE_TABLET_EX07S) },
1074         { }
1075 };
1076 MODULE_DEVICE_TABLE(hid, uclogic_devices);
1077
1078 static struct hid_driver uclogic_driver = {
1079         .name = "uclogic",
1080         .id_table = uclogic_devices,
1081         .probe = uclogic_probe,
1082         .report_fixup = uclogic_report_fixup,
1083         .raw_event = uclogic_raw_event,
1084         .input_mapping = uclogic_input_mapping,
1085         .input_configured = uclogic_input_configured,
1086 };
1087 module_hid_driver(uclogic_driver);
1088
1089 MODULE_AUTHOR("Martin Rusko");
1090 MODULE_AUTHOR("Nikolai Kondrashov");
1091 MODULE_LICENSE("GPL");