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