drivers/hid/hid-waltop.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  HID driver for Waltop devices not fully compliant with HID standard
   4  *
   5  *  Copyright (c) 2010 Nikolai Kondrashov
   6  */
   7
   8 /*
   9  */
  10
  11 #include <linux/device.h>
  12 #include <linux/hid.h>
  13 #include <linux/module.h>
  14
  15 #include "hid-ids.h"
  16
  17 /*
  18  * There exists an official driver on the manufacturer's website, which
  19  * wasn't submitted to the kernel, for some reason. The official driver
  20  * doesn't seem to support extra features of some tablets, like wheels.
  21  *
  22  * It shows that the feature report ID 2 could be used to control any waltop
  23  * tablet input mode, switching it between "default", "tablet" and "ink".
  24  *
  25  * This driver only uses "default" mode for all the supported tablets. This
  26  * mode tries to be HID-compatible (not very successfully), but cripples the
  27  * resolution of some tablets.
  28  *
  29  * The "tablet" mode uses some proprietary, yet decipherable protocol, which
  30  * represents the correct resolution, but is possibly HID-incompatible (i.e.
  31  * indescribable by a report descriptor).
  32  *
  33  * The purpose of the "ink" mode is unknown.
  34  *
  35  * The feature reports needed for switching to each mode are these:
  36  *
  37  * 02 16 00     default
  38  * 02 16 01     tablet
  39  * 02 16 02     ink
  40  */
  41
  42 /* Size of the original report descriptor of Slim Tablet 5.8 inch */
  43 #define SLIM_TABLET_5_8_INCH_RDESC_ORIG_SIZE    222
  44
  45 /* Fixed Slim Tablet 5.8 inch descriptor */
  46 static __u8 slim_tablet_5_8_inch_rdesc_fixed[] = {
  47         0x05, 0x0D,         /*  Usage Page (Digitizer),             */
  48         0x09, 0x02,         /*  Usage (Pen),                        */
  49         0xA1, 0x01,         /*  Collection (Application),           */
  50         0x85, 0x10,         /*      Report ID (16),                 */
  51         0x09, 0x20,         /*      Usage (Stylus),                 */
  52         0xA0,               /*      Collection (Physical),          */
  53         0x09, 0x42,         /*          Usage (Tip Switch),         */
  54         0x09, 0x44,         /*          Usage (Barrel Switch),      */
  55         0x09, 0x46,         /*          Usage (Tablet Pick),        */
  56         0x15, 0x01,         /*          Logical Minimum (1),        */
  57         0x25, 0x03,         /*          Logical Maximum (3),        */
  58         0x75, 0x04,         /*          Report Size (4),            */
  59         0x95, 0x01,         /*          Report Count (1),           */
  60         0x80,               /*          Input,                      */
  61         0x09, 0x32,         /*          Usage (In Range),           */
  62         0x14,               /*          Logical Minimum (0),        */
  63         0x25, 0x01,         /*          Logical Maximum (1),        */
  64         0x75, 0x01,         /*          Report Size (1),            */
  65         0x95, 0x01,         /*          Report Count (1),           */
  66         0x81, 0x02,         /*          Input (Variable),           */
  67         0x95, 0x03,         /*          Report Count (3),           */
  68         0x81, 0x03,         /*          Input (Constant, Variable), */
  69         0x75, 0x10,         /*          Report Size (16),           */
  70         0x95, 0x01,         /*          Report Count (1),           */
  71         0x14,               /*          Logical Minimum (0),        */
  72         0xA4,               /*          Push,                       */
  73         0x05, 0x01,         /*          Usage Page (Desktop),       */
  74         0x65, 0x13,         /*          Unit (Inch),                */
  75         0x55, 0xFD,         /*          Unit Exponent (-3),         */
  76         0x34,               /*          Physical Minimum (0),       */
  77         0x09, 0x30,         /*          Usage (X),                  */
  78         0x46, 0x88, 0x13,   /*          Physical Maximum (5000),    */
  79         0x26, 0x10, 0x27,   /*          Logical Maximum (10000),    */
  80         0x81, 0x02,         /*          Input (Variable),           */
  81         0x09, 0x31,         /*          Usage (Y),                  */
  82         0x46, 0xB8, 0x0B,   /*          Physical Maximum (3000),    */
  83         0x26, 0x70, 0x17,   /*          Logical Maximum (6000),     */
  84         0x81, 0x02,         /*          Input (Variable),           */
  85         0xB4,               /*          Pop,                        */
  86         0x09, 0x30,         /*          Usage (Tip Pressure),       */
  87         0x26, 0xFF, 0x03,   /*          Logical Maximum (1023),     */
  88         0x81, 0x02,         /*          Input (Variable),           */
  89         0xC0,               /*      End Collection,                 */
  90         0xC0                /*  End Collection                      */
  91 };
  92
  93 /* Size of the original report descriptor of Slim Tablet 12.1 inch */
  94 #define SLIM_TABLET_12_1_INCH_RDESC_ORIG_SIZE   269
  95
  96 /* Fixed Slim Tablet 12.1 inch descriptor */
  97 static __u8 slim_tablet_12_1_inch_rdesc_fixed[] = {
  98         0x05, 0x0D,         /*  Usage Page (Digitizer),             */
  99         0x09, 0x02,         /*  Usage (Pen),                        */
 100         0xA1, 0x01,         /*  Collection (Application),           */
 101         0x85, 0x10,         /*      Report ID (16),                 */
 102         0x09, 0x20,         /*      Usage (Stylus),                 */
 103         0xA0,               /*      Collection (Physical),          */
 104         0x09, 0x42,         /*          Usage (Tip Switch),         */
 105         0x09, 0x44,         /*          Usage (Barrel Switch),      */
 106         0x09, 0x46,         /*          Usage (Tablet Pick),        */
 107         0x15, 0x01,         /*          Logical Minimum (1),        */
 108         0x25, 0x03,         /*          Logical Maximum (3),        */
 109         0x75, 0x04,         /*          Report Size (4),            */
 110         0x95, 0x01,         /*          Report Count (1),           */
 111         0x80,               /*          Input,                      */
 112         0x09, 0x32,         /*          Usage (In Range),           */
 113         0x14,               /*          Logical Minimum (0),        */
 114         0x25, 0x01,         /*          Logical Maximum (1),        */
 115         0x75, 0x01,         /*          Report Size (1),            */
 116         0x95, 0x01,         /*          Report Count (1),           */
 117         0x81, 0x02,         /*          Input (Variable),           */
 118         0x95, 0x03,         /*          Report Count (3),           */
 119         0x81, 0x03,         /*          Input (Constant, Variable), */
 120         0x75, 0x10,         /*          Report Size (16),           */
 121         0x95, 0x01,         /*          Report Count (1),           */
 122         0x14,               /*          Logical Minimum (0),        */
 123         0xA4,               /*          Push,                       */
 124         0x05, 0x01,         /*          Usage Page (Desktop),       */
 125         0x65, 0x13,         /*          Unit (Inch),                */
 126         0x55, 0xFD,         /*          Unit Exponent (-3),         */
 127         0x34,               /*          Physical Minimum (0),       */
 128         0x09, 0x30,         /*          Usage (X),                  */
 129         0x46, 0x10, 0x27,   /*          Physical Maximum (10000),   */
 130         0x26, 0x20, 0x4E,   /*          Logical Maximum (20000),    */
 131         0x81, 0x02,         /*          Input (Variable),           */
 132         0x09, 0x31,         /*          Usage (Y),                  */
 133         0x46, 0x6A, 0x18,   /*          Physical Maximum (6250),    */
 134         0x26, 0xD4, 0x30,   /*          Logical Maximum (12500),    */
 135         0x81, 0x02,         /*          Input (Variable),           */
 136         0xB4,               /*          Pop,                        */
 137         0x09, 0x30,         /*          Usage (Tip Pressure),       */
 138         0x26, 0xFF, 0x03,   /*          Logical Maximum (1023),     */
 139         0x81, 0x02,         /*          Input (Variable),           */
 140         0xC0,               /*      End Collection,                 */
 141         0xC0                /*  End Collection                      */
 142 };
 143
 144 /* Size of the original report descriptor of Q Pad */
 145 #define Q_PAD_RDESC_ORIG_SIZE   241
 146
 147 /* Fixed Q Pad descriptor */
 148 static __u8 q_pad_rdesc_fixed[] = {
 149         0x05, 0x0D,         /*  Usage Page (Digitizer),             */
 150         0x09, 0x02,         /*  Usage (Pen),                        */
 151         0xA1, 0x01,         /*  Collection (Application),           */
 152         0x85, 0x10,         /*      Report ID (16),                 */
 153         0x09, 0x20,         /*      Usage (Stylus),                 */
 154         0xA0,               /*      Collection (Physical),          */
 155         0x09, 0x42,         /*          Usage (Tip Switch),         */
 156         0x09, 0x44,         /*          Usage (Barrel Switch),      */
 157         0x09, 0x46,         /*          Usage (Tablet Pick),        */
 158         0x15, 0x01,         /*          Logical Minimum (1),        */
 159         0x25, 0x03,         /*          Logical Maximum (3),        */
 160         0x75, 0x04,         /*          Report Size (4),            */
 161         0x95, 0x01,         /*          Report Count (1),           */
 162         0x80,               /*          Input,                      */
 163         0x09, 0x32,         /*          Usage (In Range),           */
 164         0x14,               /*          Logical Minimum (0),        */
 165         0x25, 0x01,         /*          Logical Maximum (1),        */
 166         0x75, 0x01,         /*          Report Size (1),            */
 167         0x95, 0x01,         /*          Report Count (1),           */
 168         0x81, 0x02,         /*          Input (Variable),           */
 169         0x95, 0x03,         /*          Report Count (3),           */
 170         0x81, 0x03,         /*          Input (Constant, Variable), */
 171         0x75, 0x10,         /*          Report Size (16),           */
 172         0x95, 0x01,         /*          Report Count (1),           */
 173         0x14,               /*          Logical Minimum (0),        */
 174         0xA4,               /*          Push,                       */
 175         0x05, 0x01,         /*          Usage Page (Desktop),       */
 176         0x65, 0x13,         /*          Unit (Inch),                */
 177         0x55, 0xFD,         /*          Unit Exponent (-3),         */
 178         0x34,               /*          Physical Minimum (0),       */
 179         0x09, 0x30,         /*          Usage (X),                  */
 180         0x46, 0x70, 0x17,   /*          Physical Maximum (6000),    */
 181         0x26, 0x00, 0x30,   /*          Logical Maximum (12288),    */
 182         0x81, 0x02,         /*          Input (Variable),           */
 183         0x09, 0x31,         /*          Usage (Y),                  */
 184         0x46, 0x94, 0x11,   /*          Physical Maximum (4500),    */
 185         0x26, 0x00, 0x24,   /*          Logical Maximum (9216),     */
 186         0x81, 0x02,         /*          Input (Variable),           */
 187         0xB4,               /*          Pop,                        */
 188         0x09, 0x30,         /*          Usage (Tip Pressure),       */
 189         0x26, 0xFF, 0x03,   /*          Logical Maximum (1023),     */
 190         0x81, 0x02,         /*          Input (Variable),           */
 191         0xC0,               /*      End Collection,                 */
 192         0xC0                /*  End Collection                      */
 193 };
 194
 195 /* Size of the original report descriptor of tablet with PID 0038 */
 196 #define PID_0038_RDESC_ORIG_SIZE        241
 197
 198 /*
 199  * Fixed report descriptor for tablet with PID 0038.
 200  */
 201 static __u8 pid_0038_rdesc_fixed[] = {
 202         0x05, 0x0D,         /*  Usage Page (Digitizer),             */
 203         0x09, 0x02,         /*  Usage (Pen),                        */
 204         0xA1, 0x01,         /*  Collection (Application),           */
 205         0x85, 0x10,         /*      Report ID (16),                 */
 206         0x09, 0x20,         /*      Usage (Stylus),                 */
 207         0xA0,               /*      Collection (Physical),          */
 208         0x09, 0x42,         /*          Usage (Tip Switch),         */
 209         0x09, 0x44,         /*          Usage (Barrel Switch),      */
 210         0x09, 0x46,         /*          Usage (Tablet Pick),        */
 211         0x15, 0x01,         /*          Logical Minimum (1),        */
 212         0x25, 0x03,         /*          Logical Maximum (3),        */
 213         0x75, 0x04,         /*          Report Size (4),            */
 214         0x95, 0x01,         /*          Report Count (1),           */
 215         0x80,               /*          Input,                      */
 216         0x09, 0x32,         /*          Usage (In Range),           */
 217         0x14,               /*          Logical Minimum (0),        */
 218         0x25, 0x01,         /*          Logical Maximum (1),        */
 219         0x75, 0x01,         /*          Report Size (1),            */
 220         0x95, 0x01,         /*          Report Count (1),           */
 221         0x81, 0x02,         /*          Input (Variable),           */
 222         0x95, 0x03,         /*          Report Count (3),           */
 223         0x81, 0x03,         /*          Input (Constant, Variable), */
 224         0x75, 0x10,         /*          Report Size (16),           */
 225         0x95, 0x01,         /*          Report Count (1),           */
 226         0x14,               /*          Logical Minimum (0),        */
 227         0xA4,               /*          Push,                       */
 228         0x05, 0x01,         /*          Usage Page (Desktop),       */
 229         0x65, 0x13,         /*          Unit (Inch),                */
 230         0x55, 0xFD,         /*          Unit Exponent (-3),         */
 231         0x34,               /*          Physical Minimum (0),       */
 232         0x09, 0x30,         /*          Usage (X),                  */
 233         0x46, 0x2E, 0x22,   /*          Physical Maximum (8750),    */
 234         0x26, 0x00, 0x46,   /*          Logical Maximum (17920),    */
 235         0x81, 0x02,         /*          Input (Variable),           */
 236         0x09, 0x31,         /*          Usage (Y),                  */
 237         0x46, 0x82, 0x14,   /*          Physical Maximum (5250),    */
 238         0x26, 0x00, 0x2A,   /*          Logical Maximum (10752),    */
 239         0x81, 0x02,         /*          Input (Variable),           */
 240         0xB4,               /*          Pop,                        */
 241         0x09, 0x30,         /*          Usage (Tip Pressure),       */
 242         0x26, 0xFF, 0x03,   /*          Logical Maximum (1023),     */
 243         0x81, 0x02,         /*          Input (Variable),           */
 244         0xC0,               /*      End Collection,                 */
 245         0xC0                /*  End Collection                      */
 246 };
 247
 248 /* Size of the original report descriptor of Media Tablet 10.6 inch */
 249 #define MEDIA_TABLET_10_6_INCH_RDESC_ORIG_SIZE  300
 250
 251 /* Fixed Media Tablet 10.6 inch descriptor */
 252 static __u8 media_tablet_10_6_inch_rdesc_fixed[] = {
 253         0x05, 0x0D,         /*  Usage Page (Digitizer),             */
 254         0x09, 0x02,         /*  Usage (Pen),                        */
 255         0xA1, 0x01,         /*  Collection (Application),           */
 256         0x85, 0x10,         /*      Report ID (16),                 */
 257         0x09, 0x20,         /*      Usage (Stylus),                 */
 258         0xA0,               /*      Collection (Physical),          */
 259         0x09, 0x42,         /*          Usage (Tip Switch),         */
 260         0x09, 0x44,         /*          Usage (Barrel Switch),      */
 261         0x09, 0x46,         /*          Usage (Tablet Pick),        */
 262         0x15, 0x01,         /*          Logical Minimum (1),        */
 263         0x25, 0x03,         /*          Logical Maximum (3),        */
 264         0x75, 0x04,         /*          Report Size (4),            */
 265         0x95, 0x01,         /*          Report Count (1),           */
 266         0x80,               /*          Input,                      */
 267         0x75, 0x01,         /*          Report Size (1),            */
 268         0x09, 0x32,         /*          Usage (In Range),           */
 269         0x14,               /*          Logical Minimum (0),        */
 270         0x25, 0x01,         /*          Logical Maximum (1),        */
 271         0x95, 0x01,         /*          Report Count (1),           */
 272         0x81, 0x02,         /*          Input (Variable),           */
 273         0x95, 0x03,         /*          Report Count (3),           */
 274         0x81, 0x03,         /*          Input (Constant, Variable), */
 275         0x75, 0x10,         /*          Report Size (16),           */
 276         0x95, 0x01,         /*          Report Count (1),           */
 277         0x14,               /*          Logical Minimum (0),        */
 278         0xA4,               /*          Push,                       */
 279         0x05, 0x01,         /*          Usage Page (Desktop),       */
 280         0x65, 0x13,         /*          Unit (Inch),                */
 281         0x55, 0xFD,         /*          Unit Exponent (-3),         */
 282         0x34,               /*          Physical Minimum (0),       */
 283         0x09, 0x30,         /*          Usage (X),                  */
 284         0x46, 0x28, 0x23,   /*          Physical Maximum (9000),    */
 285         0x26, 0x50, 0x46,   /*          Logical Maximum (18000),    */
 286         0x81, 0x02,         /*          Input (Variable),           */
 287         0x09, 0x31,         /*          Usage (Y),                  */
 288         0x46, 0x7C, 0x15,   /*          Physical Maximum (5500),    */
 289         0x26, 0xF8, 0x2A,   /*          Logical Maximum (11000),    */
 290         0x81, 0x02,         /*          Input (Variable),           */
 291         0xB4,               /*          Pop,                        */
 292         0x09, 0x30,         /*          Usage (Tip Pressure),       */
 293         0x26, 0xFF, 0x03,   /*          Logical Maximum (1023),     */
 294         0x81, 0x02,         /*          Input (Variable),           */
 295         0xC0,               /*      End Collection,                 */
 296         0xC0,               /*  End Collection,                     */
 297         0x05, 0x01,         /*  Usage Page (Desktop),               */
 298         0x09, 0x02,         /*  Usage (Mouse),                      */
 299         0xA1, 0x01,         /*  Collection (Application),           */
 300         0x85, 0x01,         /*      Report ID (1),                  */
 301         0x09, 0x01,         /*      Usage (Pointer),                */
 302         0xA0,               /*      Collection (Physical),          */
 303         0x75, 0x08,         /*          Report Size (8),            */
 304         0x95, 0x03,         /*          Report Count (3),           */
 305         0x81, 0x03,         /*          Input (Constant, Variable), */
 306         0x95, 0x02,         /*          Report Count (2),           */
 307         0x15, 0xFF,         /*          Logical Minimum (-1),       */
 308         0x25, 0x01,         /*          Logical Maximum (1),        */
 309         0x09, 0x38,         /*          Usage (Wheel),              */
 310         0x0B, 0x38, 0x02,   /*          Usage (Consumer AC Pan),    */
 311                 0x0C, 0x00,
 312         0x81, 0x06,         /*          Input (Variable, Relative), */
 313         0x95, 0x02,         /*          Report Count (2),           */
 314         0x81, 0x03,         /*          Input (Constant, Variable), */
 315         0xC0,               /*      End Collection,                 */
 316         0xC0,               /*  End Collection,                     */
 317         0x05, 0x0C,         /*  Usage Page (Consumer),              */
 318         0x09, 0x01,         /*  Usage (Consumer Control),           */
 319         0xA1, 0x01,         /*  Collection (Application),           */
 320         0x85, 0x0D,         /*      Report ID (13),                 */
 321         0x95, 0x01,         /*      Report Count (1),               */
 322         0x75, 0x10,         /*      Report Size (16),               */
 323         0x81, 0x03,         /*      Input (Constant, Variable),     */
 324         0x0A, 0x2F, 0x02,   /*      Usage (AC Zoom),                */
 325         0x0A, 0x2E, 0x02,   /*      Usage (AC Zoom Out),            */
 326         0x0A, 0x2D, 0x02,   /*      Usage (AC Zoom In),             */
 327         0x09, 0xB6,         /*      Usage (Scan Previous Track),    */
 328         0x09, 0xB5,         /*      Usage (Scan Next Track),        */
 329         0x08,               /*      Usage (00h),                    */
 330         0x08,               /*      Usage (00h),                    */
 331         0x08,               /*      Usage (00h),                    */
 332         0x08,               /*      Usage (00h),                    */
 333         0x08,               /*      Usage (00h),                    */
 334         0x0A, 0x2E, 0x02,   /*      Usage (AC Zoom Out),            */
 335         0x0A, 0x2D, 0x02,   /*      Usage (AC Zoom In),             */
 336         0x15, 0x0C,         /*      Logical Minimum (12),           */
 337         0x25, 0x17,         /*      Logical Maximum (23),           */
 338         0x75, 0x05,         /*      Report Size (5),                */
 339         0x80,               /*      Input,                          */
 340         0x75, 0x03,         /*      Report Size (3),                */
 341         0x81, 0x03,         /*      Input (Constant, Variable),     */
 342         0x75, 0x20,         /*      Report Size (32),               */
 343         0x81, 0x03,         /*      Input (Constant, Variable),     */
 344         0xC0,               /*  End Collection,                     */
 345         0x09, 0x01,         /*  Usage (Consumer Control),           */
 346         0xA1, 0x01,         /*  Collection (Application),           */
 347         0x85, 0x0C,         /*      Report ID (12),                 */
 348         0x75, 0x01,         /*      Report Size (1),                */
 349         0x09, 0xE9,         /*      Usage (Volume Inc),             */
 350         0x09, 0xEA,         /*      Usage (Volume Dec),             */
 351         0x09, 0xE2,         /*      Usage (Mute),                   */
 352         0x14,               /*      Logical Minimum (0),            */
 353         0x25, 0x01,         /*      Logical Maximum (1),            */
 354         0x95, 0x03,         /*      Report Count (3),               */
 355         0x81, 0x06,         /*      Input (Variable, Relative),     */
 356         0x95, 0x35,         /*      Report Count (53),              */
 357         0x81, 0x03,         /*      Input (Constant, Variable),     */
 358         0xC0                /*  End Collection                      */
 359 };
 360
 361 /* Size of the original report descriptor of Media Tablet 14.1 inch */
 362 #define MEDIA_TABLET_14_1_INCH_RDESC_ORIG_SIZE  309
 363
 364 /* Fixed Media Tablet 14.1 inch descriptor */
 365 static __u8 media_tablet_14_1_inch_rdesc_fixed[] = {
 366         0x05, 0x0D,         /*  Usage Page (Digitizer),             */
 367         0x09, 0x02,         /*  Usage (Pen),                        */
 368         0xA1, 0x01,         /*  Collection (Application),           */
 369         0x85, 0x10,         /*      Report ID (16),                 */
 370         0x09, 0x20,         /*      Usage (Stylus),                 */
 371         0xA0,               /*      Collection (Physical),          */
 372         0x09, 0x42,         /*          Usage (Tip Switch),         */
 373         0x09, 0x44,         /*          Usage (Barrel Switch),      */
 374         0x09, 0x46,         /*          Usage (Tablet Pick),        */
 375         0x15, 0x01,         /*          Logical Minimum (1),        */
 376         0x25, 0x03,         /*          Logical Maximum (3),        */
 377         0x75, 0x04,         /*          Report Size (4),            */
 378         0x95, 0x01,         /*          Report Count (1),           */
 379         0x80,               /*          Input,                      */
 380         0x75, 0x01,         /*          Report Size (1),            */
 381         0x09, 0x32,         /*          Usage (In Range),           */
 382         0x14,               /*          Logical Minimum (0),        */
 383         0x25, 0x01,         /*          Logical Maximum (1),        */
 384         0x95, 0x01,         /*          Report Count (1),           */
 385         0x81, 0x02,         /*          Input (Variable),           */
 386         0x95, 0x03,         /*          Report Count (3),           */
 387         0x81, 0x03,         /*          Input (Constant, Variable), */
 388         0x75, 0x10,         /*          Report Size (16),           */
 389         0x95, 0x01,         /*          Report Count (1),           */
 390         0x14,               /*          Logical Minimum (0),        */
 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, 0xE0, 0x2E,   /*          Physical Maximum (12000),   */
 398         0x26, 0xFF, 0x3F,   /*          Logical Maximum (16383),    */
 399         0x81, 0x02,         /*          Input (Variable),           */
 400         0x09, 0x31,         /*          Usage (Y),                  */
 401         0x46, 0x52, 0x1C,   /*          Physical Maximum (7250),    */
 402         0x26, 0xFF, 0x3F,   /*          Logical Maximum (16383),    */
 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         0x05, 0x01,         /*  Usage Page (Desktop),               */
 411         0x09, 0x02,         /*  Usage (Mouse),                      */
 412         0xA1, 0x01,         /*  Collection (Application),           */
 413         0x85, 0x01,         /*      Report ID (1),                  */
 414         0x09, 0x01,         /*      Usage (Pointer),                */
 415         0xA0,               /*      Collection (Physical),          */
 416         0x75, 0x08,         /*          Report Size (8),            */
 417         0x95, 0x03,         /*          Report Count (3),           */
 418         0x81, 0x03,         /*          Input (Constant, Variable), */
 419         0x95, 0x02,         /*          Report Count (2),           */
 420         0x15, 0xFF,         /*          Logical Minimum (-1),       */
 421         0x25, 0x01,         /*          Logical Maximum (1),        */
 422         0x09, 0x38,         /*          Usage (Wheel),              */
 423         0x0B, 0x38, 0x02,   /*          Usage (Consumer AC Pan),    */
 424                 0x0C, 0x00,
 425         0x81, 0x06,         /*          Input (Variable, Relative), */
 426         0xC0,               /*      End Collection,                 */
 427         0xC0,               /*  End Collection,                     */
 428         0x05, 0x0C,         /*  Usage Page (Consumer),              */
 429         0x09, 0x01,         /*  Usage (Consumer Control),           */
 430         0xA1, 0x01,         /*  Collection (Application),           */
 431         0x85, 0x0D,         /*      Report ID (13),                 */
 432         0x95, 0x01,         /*      Report Count (1),               */
 433         0x75, 0x10,         /*      Report Size (16),               */
 434         0x81, 0x03,         /*      Input (Constant, Variable),     */
 435         0x0A, 0x2F, 0x02,   /*      Usage (AC Zoom),                */
 436         0x0A, 0x2E, 0x02,   /*      Usage (AC Zoom Out),            */
 437         0x0A, 0x2D, 0x02,   /*      Usage (AC Zoom In),             */
 438         0x09, 0xB6,         /*      Usage (Scan Previous Track),    */
 439         0x09, 0xB5,         /*      Usage (Scan Next Track),        */
 440         0x08,               /*      Usage (00h),                    */
 441         0x08,               /*      Usage (00h),                    */
 442         0x08,               /*      Usage (00h),                    */
 443         0x08,               /*      Usage (00h),                    */
 444         0x08,               /*      Usage (00h),                    */
 445         0x0A, 0x2E, 0x02,   /*      Usage (AC Zoom Out),            */
 446         0x0A, 0x2D, 0x02,   /*      Usage (AC Zoom In),             */
 447         0x15, 0x0C,         /*      Logical Minimum (12),           */
 448         0x25, 0x17,         /*      Logical Maximum (23),           */
 449         0x75, 0x05,         /*      Report Size (5),                */
 450         0x80,               /*      Input,                          */
 451         0x75, 0x03,         /*      Report Size (3),                */
 452         0x81, 0x03,         /*      Input (Constant, Variable),     */
 453         0x75, 0x20,         /*      Report Size (32),               */
 454         0x81, 0x03,         /*      Input (Constant, Variable),     */
 455         0xC0,               /*  End Collection,                     */
 456         0x09, 0x01,         /*  Usage (Consumer Control),           */
 457         0xA1, 0x01,         /*  Collection (Application),           */
 458         0x85, 0x0C,         /*      Report ID (12),                 */
 459         0x75, 0x01,         /*      Report Size (1),                */
 460         0x09, 0xE9,         /*      Usage (Volume Inc),             */
 461         0x09, 0xEA,         /*      Usage (Volume Dec),             */
 462         0x09, 0xE2,         /*      Usage (Mute),                   */
 463         0x14,               /*      Logical Minimum (0),            */
 464         0x25, 0x01,         /*      Logical Maximum (1),            */
 465         0x95, 0x03,         /*      Report Count (3),               */
 466         0x81, 0x06,         /*      Input (Variable, Relative),     */
 467         0x75, 0x05,         /*      Report Size (5),                */
 468         0x81, 0x03,         /*      Input (Constant, Variable),     */
 469         0xC0                /*  End Collection                      */
 470 };
 471
 472 /* Size of the original report descriptor of Sirius Battery Free Tablet */
 473 #define SIRIUS_BATTERY_FREE_TABLET_RDESC_ORIG_SIZE      335
 474
 475 /* Fixed Sirius Battery Free Tablet descriptor */
 476 static __u8 sirius_battery_free_tablet_rdesc_fixed[] = {
 477         0x05, 0x0D,         /*  Usage Page (Digitizer),             */
 478         0x09, 0x02,         /*  Usage (Pen),                        */
 479         0xA1, 0x01,         /*  Collection (Application),           */
 480         0x85, 0x10,         /*      Report ID (16),                 */
 481         0x09, 0x20,         /*      Usage (Stylus),                 */
 482         0xA0,               /*      Collection (Physical),          */
 483         0x95, 0x01,         /*          Report Count (1),           */
 484         0x15, 0x01,         /*          Logical Minimum (1),        */
 485         0x25, 0x03,         /*          Logical Maximum (3),        */
 486         0x75, 0x02,         /*          Report Size (2),            */
 487         0x09, 0x42,         /*          Usage (Tip Switch),         */
 488         0x09, 0x44,         /*          Usage (Barrel Switch),      */
 489         0x09, 0x46,         /*          Usage (Tablet Pick),        */
 490         0x80,               /*          Input,                      */
 491         0x14,               /*          Logical Minimum (0),        */
 492         0x25, 0x01,         /*          Logical Maximum (1),        */
 493         0x75, 0x01,         /*          Report Size (1),            */
 494         0x09, 0x3C,         /*          Usage (Invert),             */
 495         0x81, 0x02,         /*          Input (Variable),           */
 496         0x81, 0x03,         /*          Input (Constant, Variable), */
 497         0x09, 0x32,         /*          Usage (In Range),           */
 498         0x81, 0x02,         /*          Input (Variable),           */
 499         0x95, 0x03,         /*          Report Count (3),           */
 500         0x81, 0x03,         /*          Input (Constant, Variable), */
 501         0xA4,               /*          Push,                       */
 502         0x05, 0x01,         /*          Usage Page (Desktop),       */
 503         0x55, 0xFD,         /*          Unit Exponent (-3),         */
 504         0x65, 0x13,         /*          Unit (Inch),                */
 505         0x34,               /*          Physical Minimum (0),       */
 506         0x14,               /*          Logical Minimum (0),        */
 507         0x75, 0x10,         /*          Report Size (16),           */
 508         0x95, 0x01,         /*          Report Count (1),           */
 509         0x46, 0x10, 0x27,   /*          Physical Maximum (10000),   */
 510         0x26, 0x20, 0x4E,   /*          Logical Maximum (20000),    */
 511         0x09, 0x30,         /*          Usage (X),                  */
 512         0x81, 0x02,         /*          Input (Variable),           */
 513         0x46, 0x70, 0x17,   /*          Physical Maximum (6000),    */
 514         0x26, 0xE0, 0x2E,   /*          Logical Maximum (12000),    */
 515         0x09, 0x31,         /*          Usage (Y),                  */
 516         0x81, 0x02,         /*          Input (Variable),           */
 517         0xB4,               /*          Pop,                        */
 518         0x75, 0x10,         /*          Report Size (16),           */
 519         0x95, 0x01,         /*          Report Count (1),           */
 520         0x14,               /*          Logical Minimum (0),        */
 521         0x26, 0xFF, 0x03,   /*          Logical Maximum (1023),     */
 522         0x09, 0x30,         /*          Usage (Tip Pressure),       */
 523         0x81, 0x02,         /*          Input (Variable),           */
 524         0xA4,               /*          Push,                       */
 525         0x55, 0xFE,         /*          Unit Exponent (-2),         */
 526         0x65, 0x12,         /*          Unit (Radians),             */
 527         0x35, 0x97,         /*          Physical Minimum (-105),    */
 528         0x45, 0x69,         /*          Physical Maximum (105),     */
 529         0x15, 0x97,         /*          Logical Minimum (-105),     */
 530         0x25, 0x69,         /*          Logical Maximum (105),      */
 531         0x75, 0x08,         /*          Report Size (8),            */
 532         0x95, 0x02,         /*          Report Count (2),           */
 533         0x09, 0x3D,         /*          Usage (X Tilt),             */
 534         0x09, 0x3E,         /*          Usage (Y Tilt),             */
 535         0x81, 0x02,         /*          Input (Variable),           */
 536         0xB4,               /*          Pop,                        */
 537         0xC0,               /*      End Collection,                 */
 538         0xC0,               /*  End Collection,                     */
 539         0x05, 0x01,         /*  Usage Page (Desktop),               */
 540         0x09, 0x02,         /*  Usage (Mouse),                      */
 541         0xA1, 0x01,         /*  Collection (Application),           */
 542         0x85, 0x01,         /*      Report ID (1),                  */
 543         0x09, 0x01,         /*      Usage (Pointer),                */
 544         0xA0,               /*      Collection (Physical),          */
 545         0x75, 0x08,         /*          Report Size (8),            */
 546         0x95, 0x03,         /*          Report Count (3),           */
 547         0x81, 0x03,         /*          Input (Constant, Variable), */
 548         0x09, 0x38,         /*          Usage (Wheel),              */
 549         0x15, 0xFF,         /*          Logical Minimum (-1),       */
 550         0x25, 0x01,         /*          Logical Maximum (1),        */
 551         0x75, 0x08,         /*          Report Size (8),            */
 552         0x95, 0x01,         /*          Report Count (1),           */
 553         0x81, 0x06,         /*          Input (Variable, Relative), */
 554         0x75, 0x08,         /*          Report Size (8),            */
 555         0x95, 0x03,         /*          Report Count (3),           */
 556         0x81, 0x03,         /*          Input (Constant, Variable), */
 557         0xC0,               /*      End Collection,                 */
 558         0xC0,               /*  End Collection,                     */
 559         0x05, 0x01,         /*  Usage Page (Desktop),               */
 560         0x09, 0x06,         /*  Usage (Keyboard),                   */
 561         0xA1, 0x01,         /*  Collection (Application),           */
 562         0x85, 0x0D,         /*      Report ID (13),                 */
 563         0x05, 0x07,         /*      Usage Page (Keyboard),          */
 564         0x19, 0xE0,         /*      Usage Minimum (KB Leftcontrol), */
 565         0x29, 0xE7,         /*      Usage Maximum (KB Right GUI),   */
 566         0x14,               /*      Logical Minimum (0),            */
 567         0x25, 0x01,         /*      Logical Maximum (1),            */
 568         0x75, 0x01,         /*      Report Size (1),                */
 569         0x95, 0x08,         /*      Report Count (8),               */
 570         0x81, 0x02,         /*      Input (Variable),               */
 571         0x75, 0x08,         /*      Report Size (8),                */
 572         0x95, 0x01,         /*      Report Count (1),               */
 573         0x81, 0x01,         /*      Input (Constant),               */
 574         0x18,               /*      Usage Minimum (None),           */
 575         0x29, 0x65,         /*      Usage Maximum (KB Application), */
 576         0x14,               /*      Logical Minimum (0),            */
 577         0x25, 0x65,         /*      Logical Maximum (101),          */
 578         0x75, 0x08,         /*      Report Size (8),                */
 579         0x95, 0x05,         /*      Report Count (5),               */
 580         0x80,               /*      Input,                          */
 581         0xC0,               /*  End Collection,                     */
 582         0x05, 0x0C,         /*  Usage Page (Consumer),              */
 583         0x09, 0x01,         /*  Usage (Consumer Control),           */
 584         0xA1, 0x01,         /*  Collection (Application),           */
 585         0x85, 0x0C,         /*      Report ID (12),                 */
 586         0x09, 0xE9,         /*      Usage (Volume Inc),             */
 587         0x09, 0xEA,         /*      Usage (Volume Dec),             */
 588         0x14,               /*      Logical Minimum (0),            */
 589         0x25, 0x01,         /*      Logical Maximum (1),            */
 590         0x75, 0x01,         /*      Report Size (1),                */
 591         0x95, 0x02,         /*      Report Count (2),               */
 592         0x81, 0x02,         /*      Input (Variable),               */
 593         0x75, 0x06,         /*      Report Size (6),                */
 594         0x95, 0x01,         /*      Report Count (1),               */
 595         0x81, 0x03,         /*      Input (Constant, Variable),     */
 596         0x75, 0x10,         /*      Report Size (16),               */
 597         0x95, 0x03,         /*      Report Count (3),               */
 598         0x81, 0x03,         /*      Input (Constant, Variable),     */
 599         0xC0                /*  End Collection                      */
 600 };
 601
 602 static __u8 *waltop_report_fixup(struct hid_device *hdev, __u8 *rdesc,
 603                 unsigned int *rsize)
 604 {
 605         switch (hdev->product) {
 606         case USB_DEVICE_ID_WALTOP_SLIM_TABLET_5_8_INCH:
 607                 if (*rsize == SLIM_TABLET_5_8_INCH_RDESC_ORIG_SIZE) {
 608                         rdesc = slim_tablet_5_8_inch_rdesc_fixed;
 609                         *rsize = sizeof(slim_tablet_5_8_inch_rdesc_fixed);
 610                 }
 611                 break;
 612         case USB_DEVICE_ID_WALTOP_SLIM_TABLET_12_1_INCH:
 613                 if (*rsize == SLIM_TABLET_12_1_INCH_RDESC_ORIG_SIZE) {
 614                         rdesc = slim_tablet_12_1_inch_rdesc_fixed;
 615                         *rsize = sizeof(slim_tablet_12_1_inch_rdesc_fixed);
 616                 }
 617                 break;
 618         case USB_DEVICE_ID_WALTOP_Q_PAD:
 619                 if (*rsize == Q_PAD_RDESC_ORIG_SIZE) {
 620                         rdesc = q_pad_rdesc_fixed;
 621                         *rsize = sizeof(q_pad_rdesc_fixed);
 622                 }
 623                 break;
 624         case USB_DEVICE_ID_WALTOP_PID_0038:
 625                 if (*rsize == PID_0038_RDESC_ORIG_SIZE) {
 626                         rdesc = pid_0038_rdesc_fixed;
 627                         *rsize = sizeof(pid_0038_rdesc_fixed);
 628                 }
 629                 break;
 630         case USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH:
 631                 if (*rsize == MEDIA_TABLET_10_6_INCH_RDESC_ORIG_SIZE) {
 632                         rdesc = media_tablet_10_6_inch_rdesc_fixed;
 633                         *rsize = sizeof(media_tablet_10_6_inch_rdesc_fixed);
 634                 }
 635                 break;
 636         case USB_DEVICE_ID_WALTOP_MEDIA_TABLET_14_1_INCH:
 637                 if (*rsize == MEDIA_TABLET_14_1_INCH_RDESC_ORIG_SIZE) {
 638                         rdesc = media_tablet_14_1_inch_rdesc_fixed;
 639                         *rsize = sizeof(media_tablet_14_1_inch_rdesc_fixed);
 640                 }
 641                 break;
 642         case USB_DEVICE_ID_WALTOP_SIRIUS_BATTERY_FREE_TABLET:
 643                 if (*rsize == SIRIUS_BATTERY_FREE_TABLET_RDESC_ORIG_SIZE) {
 644                         rdesc = sirius_battery_free_tablet_rdesc_fixed;
 645                         *rsize = sizeof(sirius_battery_free_tablet_rdesc_fixed);
 646                 }
 647                 break;
 648         }
 649         return rdesc;
 650 }
 651
 652 static int waltop_raw_event(struct hid_device *hdev, struct hid_report *report,
 653                      u8 *data, int size)
 654 {
 655         /* If this is a pen input report */
 656         if (report->type == HID_INPUT_REPORT && report->id == 16 && size >= 8) {
 657                 /*
 658                  * Ignore reported pressure when a barrel button is pressed,
 659                  * because it is rarely correct.
 660                  */
 661
 662                 /* If a barrel button is pressed */
 663                 if ((data[1] & 0xF) > 1) {
 664                         /* Report zero pressure */
 665                         data[6] = 0;
 666                         data[7] = 0;
 667                 }
 668         }
 669
 670         /* If this is a pen input report of Sirius Battery Free Tablet */
 671         if (hdev->product == USB_DEVICE_ID_WALTOP_SIRIUS_BATTERY_FREE_TABLET &&
 672             report->type == HID_INPUT_REPORT &&
 673             report->id == 16 &&
 674             size == 10) {
 675                 /*
 676                  * The tablet reports tilt as roughly sin(a)*21 (18 means 60
 677                  * degrees).
 678                  *
 679                  * This array stores angles as radians * 100, corresponding to
 680                  * reported values up to 60 degrees, as expected by userspace.
 681                  */
 682                 static const s8 tilt_to_radians[] = {
 683                         0, 5, 10, 14, 19, 24, 29, 34, 40, 45,
 684                         50, 56, 62, 68, 74, 81, 88, 96, 105
 685                 };
 686
 687                 s8 tilt_x = (s8)data[8];
 688                 s8 tilt_y = (s8)data[9];
 689                 s8 sign_x = tilt_x >= 0 ? 1 : -1;
 690                 s8 sign_y = tilt_y >= 0 ? 1 : -1;
 691
 692                 tilt_x *= sign_x;
 693                 tilt_y *= sign_y;
 694
 695                 /*
 696                  * Reverse the Y Tilt direction to match the HID standard and
 697                  * userspace expectations. See HID Usage Tables v1.12 16.3.2
 698                  * Tilt Orientation.
 699                  */
 700                 sign_y *= -1;
 701
 702                 /*
 703                  * This effectively clamps reported tilt to 60 degrees - the
 704                  * range expected by userspace
 705                  */
 706                 if (tilt_x > ARRAY_SIZE(tilt_to_radians) - 1)
 707                         tilt_x = ARRAY_SIZE(tilt_to_radians) - 1;
 708                 if (tilt_y > ARRAY_SIZE(tilt_to_radians) - 1)
 709                         tilt_y = ARRAY_SIZE(tilt_to_radians) - 1;
 710
 711                 data[8] = tilt_to_radians[tilt_x] * sign_x;
 712                 data[9] = tilt_to_radians[tilt_y] * sign_y;
 713         }
 714
 715         return 0;
 716 }
 717
 718 static const struct hid_device_id waltop_devices[] = {
 719         { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP,
 720                                 USB_DEVICE_ID_WALTOP_SLIM_TABLET_5_8_INCH) },
 721         { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP,
 722                                 USB_DEVICE_ID_WALTOP_SLIM_TABLET_12_1_INCH) },
 723         { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP,
 724                                 USB_DEVICE_ID_WALTOP_Q_PAD) },
 725         { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP,
 726                                 USB_DEVICE_ID_WALTOP_PID_0038) },
 727         { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP,
 728                                 USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH) },
 729         { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP,
 730                                 USB_DEVICE_ID_WALTOP_MEDIA_TABLET_14_1_INCH) },
 731         { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP,
 732                          USB_DEVICE_ID_WALTOP_SIRIUS_BATTERY_FREE_TABLET) },
 733         { }
 734 };
 735 MODULE_DEVICE_TABLE(hid, waltop_devices);
 736
 737 static struct hid_driver waltop_driver = {
 738         .name = "waltop",
 739         .id_table = waltop_devices,
 740         .report_fixup = waltop_report_fixup,
 741         .raw_event = waltop_raw_event,
 742 };
 743 module_hid_driver(waltop_driver);
 744
 745 MODULE_LICENSE("GPL");