drivers/input/tablet/pegasus_notetaker.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Pegasus Mobile Notetaker Pen input tablet driver
   4  *
   5  * Copyright (c) 2016 Martin Kepplinger <[email protected]>
   6  */
   7
   8 /*
   9  * request packet (control endpoint):
  10  * |-------------------------------------|
  11  * | Report ID | Nr of bytes | command   |
  12  * | (1 byte)  | (1 byte)    | (n bytes) |
  13  * |-------------------------------------|
  14  * | 0x02      | n           |           |
  15  * |-------------------------------------|
  16  *
  17  * data packet after set xy mode command, 0x80 0xb5 0x02 0x01
  18  * and pen is in range:
  19  *
  20  * byte byte name               value (bits)
  21  * --------------------------------------------
  22  * 0    status                  0 1 0 0 0 0 X X
  23  * 1    color                   0 0 0 0 H 0 S T
  24  * 2    X low
  25  * 3    X high
  26  * 4    Y low
  27  * 5    Y high
  28  *
  29  * X X  battery state:
  30  *      no state reported       0x00
  31  *      battery low             0x01
  32  *      battery good            0x02
  33  *
  34  * H    Hovering
  35  * S    Switch 1 (pen button)
  36  * T    Tip
  37  */
  38
  39 #include <linux/kernel.h>
  40 #include <linux/module.h>
  41 #include <linux/input.h>
  42 #include <linux/usb/input.h>
  43 #include <linux/slab.h>
  44 #include <linux/workqueue.h>
  45 #include <linux/mutex.h>
  46
  47 /* USB HID defines */
  48 #define USB_REQ_GET_REPORT              0x01
  49 #define USB_REQ_SET_REPORT              0x09
  50
  51 #define USB_VENDOR_ID_PEGASUSTECH       0x0e20
  52 #define USB_DEVICE_ID_PEGASUS_NOTETAKER_EN100   0x0101
  53
  54 /* device specific defines */
  55 #define NOTETAKER_REPORT_ID             0x02
  56 #define NOTETAKER_SET_CMD               0x80
  57 #define NOTETAKER_SET_MODE              0xb5
  58
  59 #define NOTETAKER_LED_MOUSE             0x02
  60 #define PEN_MODE_XY                     0x01
  61
  62 #define SPECIAL_COMMAND                 0x80
  63 #define BUTTON_PRESSED                  0xb5
  64 #define COMMAND_VERSION                 0xa9
  65
  66 /* in xy data packet */
  67 #define BATTERY_NO_REPORT               0x40
  68 #define BATTERY_LOW                     0x41
  69 #define BATTERY_GOOD                    0x42
  70 #define PEN_BUTTON_PRESSED              BIT(1)
  71 #define PEN_TIP                         BIT(0)
  72
  73 struct pegasus {
  74         unsigned char *data;
  75         u8 data_len;
  76         dma_addr_t data_dma;
  77         struct input_dev *dev;
  78         struct usb_device *usbdev;
  79         struct usb_interface *intf;
  80         struct urb *irq;
  81
  82         /* serialize access to open/suspend */
  83         struct mutex pm_mutex;
  84         bool is_open;
  85
  86         char name[128];
  87         char phys[64];
  88         struct work_struct init;
  89 };
  90
  91 static int pegasus_control_msg(struct pegasus *pegasus, u8 *data, int len)
  92 {
  93         const int sizeof_buf = len + 2;
  94         int result;
  95         int error;
  96         u8 *cmd_buf;
  97
  98         cmd_buf = kmalloc(sizeof_buf, GFP_KERNEL);
  99         if (!cmd_buf)
 100                 return -ENOMEM;
 101
 102         cmd_buf[0] = NOTETAKER_REPORT_ID;
 103         cmd_buf[1] = len;
 104         memcpy(cmd_buf + 2, data, len);
 105
 106         result = usb_control_msg(pegasus->usbdev,
 107                                  usb_sndctrlpipe(pegasus->usbdev, 0),
 108                                  USB_REQ_SET_REPORT,
 109                                  USB_TYPE_VENDOR | USB_DIR_OUT,
 110                                  0, 0, cmd_buf, sizeof_buf,
 111                                  USB_CTRL_SET_TIMEOUT);
 112
 113         kfree(cmd_buf);
 114
 115         if (unlikely(result != sizeof_buf)) {
 116                 error = result < 0 ? result : -EIO;
 117                 dev_err(&pegasus->usbdev->dev, "control msg error: %d\n",
 118                         error);
 119                 return error;
 120         }
 121
 122         return 0;
 123 }
 124
 125 static int pegasus_set_mode(struct pegasus *pegasus, u8 mode, u8 led)
 126 {
 127         u8 cmd[] = { NOTETAKER_SET_CMD, NOTETAKER_SET_MODE, led, mode };
 128
 129         return pegasus_control_msg(pegasus, cmd, sizeof(cmd));
 130 }
 131
 132 static void pegasus_parse_packet(struct pegasus *pegasus)
 133 {
 134         unsigned char *data = pegasus->data;
 135         struct input_dev *dev = pegasus->dev;
 136         u16 x, y;
 137
 138         switch (data[0]) {
 139         case SPECIAL_COMMAND:
 140                 /* device button pressed */
 141                 if (data[1] == BUTTON_PRESSED)
 142                         schedule_work(&pegasus->init);
 143
 144                 break;
 145
 146         /* xy data */
 147         case BATTERY_LOW:
 148                 dev_warn_once(&dev->dev, "Pen battery low\n");
 149                 fallthrough;
 150
 151         case BATTERY_NO_REPORT:
 152         case BATTERY_GOOD:
 153                 x = le16_to_cpup((__le16 *)&data[2]);
 154                 y = le16_to_cpup((__le16 *)&data[4]);
 155
 156                 /* pen-up event */
 157                 if (x == 0 && y == 0)
 158                         break;
 159
 160                 input_report_key(dev, BTN_TOUCH, data[1] & PEN_TIP);
 161                 input_report_key(dev, BTN_RIGHT, data[1] & PEN_BUTTON_PRESSED);
 162                 input_report_key(dev, BTN_TOOL_PEN, 1);
 163                 input_report_abs(dev, ABS_X, (s16)x);
 164                 input_report_abs(dev, ABS_Y, y);
 165
 166                 input_sync(dev);
 167                 break;
 168
 169         default:
 170                 dev_warn_once(&pegasus->usbdev->dev,
 171                               "unknown answer from device\n");
 172         }
 173 }
 174
 175 static void pegasus_irq(struct urb *urb)
 176 {
 177         struct pegasus *pegasus = urb->context;
 178         struct usb_device *dev = pegasus->usbdev;
 179         int retval;
 180
 181         switch (urb->status) {
 182         case 0:
 183                 pegasus_parse_packet(pegasus);
 184                 usb_mark_last_busy(pegasus->usbdev);
 185                 break;
 186
 187         case -ECONNRESET:
 188         case -ENOENT:
 189         case -ESHUTDOWN:
 190                 dev_err(&dev->dev, "%s - urb shutting down with status: %d",
 191                         __func__, urb->status);
 192                 return;
 193
 194         default:
 195                 dev_err(&dev->dev, "%s - nonzero urb status received: %d",
 196                         __func__, urb->status);
 197                 break;
 198         }
 199
 200         retval = usb_submit_urb(urb, GFP_ATOMIC);
 201         if (retval)
 202                 dev_err(&dev->dev, "%s - usb_submit_urb failed with result %d",
 203                         __func__, retval);
 204 }
 205
 206 static void pegasus_init(struct work_struct *work)
 207 {
 208         struct pegasus *pegasus = container_of(work, struct pegasus, init);
 209         int error;
 210
 211         error = pegasus_set_mode(pegasus, PEN_MODE_XY, NOTETAKER_LED_MOUSE);
 212         if (error)
 213                 dev_err(&pegasus->usbdev->dev, "pegasus_set_mode error: %d\n",
 214                         error);
 215 }
 216
 217 static int __pegasus_open(struct pegasus *pegasus)
 218 {
 219         int error;
 220
 221         guard(mutex)(&pegasus->pm_mutex);
 222
 223         pegasus->irq->dev = pegasus->usbdev;
 224         if (usb_submit_urb(pegasus->irq, GFP_KERNEL))
 225                 return -EIO;
 226
 227         error = pegasus_set_mode(pegasus, PEN_MODE_XY, NOTETAKER_LED_MOUSE);
 228         if (error) {
 229                 usb_kill_urb(pegasus->irq);
 230                 cancel_work_sync(&pegasus->init);
 231                 return error;
 232         }
 233
 234         pegasus->is_open = true;
 235
 236         return 0;
 237 }
 238
 239 static int pegasus_open(struct input_dev *dev)
 240 {
 241         struct pegasus *pegasus = input_get_drvdata(dev);
 242         int error;
 243
 244         error = usb_autopm_get_interface(pegasus->intf);
 245         if (error)
 246                 return error;
 247
 248         error = __pegasus_open(pegasus);
 249         if (error) {
 250                 usb_autopm_put_interface(pegasus->intf);
 251                 return error;
 252         }
 253
 254         return 0;
 255 }
 256
 257 static void pegasus_close(struct input_dev *dev)
 258 {
 259         struct pegasus *pegasus = input_get_drvdata(dev);
 260
 261         scoped_guard(mutex, &pegasus->pm_mutex) {
 262                 usb_kill_urb(pegasus->irq);
 263                 cancel_work_sync(&pegasus->init);
 264
 265                 pegasus->is_open = false;
 266         }
 267
 268         usb_autopm_put_interface(pegasus->intf);
 269 }
 270
 271 static int pegasus_probe(struct usb_interface *intf,
 272                          const struct usb_device_id *id)
 273 {
 274         struct usb_device *dev = interface_to_usbdev(intf);
 275         struct usb_endpoint_descriptor *endpoint;
 276         struct pegasus *pegasus;
 277         struct input_dev *input_dev;
 278         int error;
 279         int pipe;
 280
 281         /* We control interface 0 */
 282         if (intf->cur_altsetting->desc.bInterfaceNumber >= 1)
 283                 return -ENODEV;
 284
 285         /* Sanity check that the device has an endpoint */
 286         if (intf->cur_altsetting->desc.bNumEndpoints < 1) {
 287                 dev_err(&intf->dev, "Invalid number of endpoints\n");
 288                 return -EINVAL;
 289         }
 290
 291         endpoint = &intf->cur_altsetting->endpoint[0].desc;
 292
 293         pegasus = kzalloc(sizeof(*pegasus), GFP_KERNEL);
 294         input_dev = input_allocate_device();
 295         if (!pegasus || !input_dev) {
 296                 error = -ENOMEM;
 297                 goto err_free_mem;
 298         }
 299
 300         mutex_init(&pegasus->pm_mutex);
 301
 302         pegasus->usbdev = dev;
 303         pegasus->dev = input_dev;
 304         pegasus->intf = intf;
 305
 306         pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
 307         /* Sanity check that pipe's type matches endpoint's type */
 308         if (usb_pipe_type_check(dev, pipe)) {
 309                 error = -EINVAL;
 310                 goto err_free_mem;
 311         }
 312
 313         pegasus->data_len = usb_maxpacket(dev, pipe);
 314
 315         pegasus->data = usb_alloc_coherent(dev, pegasus->data_len, GFP_KERNEL,
 316                                            &pegasus->data_dma);
 317         if (!pegasus->data) {
 318                 error = -ENOMEM;
 319                 goto err_free_mem;
 320         }
 321
 322         pegasus->irq = usb_alloc_urb(0, GFP_KERNEL);
 323         if (!pegasus->irq) {
 324                 error = -ENOMEM;
 325                 goto err_free_dma;
 326         }
 327
 328         usb_fill_int_urb(pegasus->irq, dev, pipe,
 329                          pegasus->data, pegasus->data_len,
 330                          pegasus_irq, pegasus, endpoint->bInterval);
 331
 332         pegasus->irq->transfer_dma = pegasus->data_dma;
 333         pegasus->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 334
 335         if (dev->manufacturer)
 336                 strscpy(pegasus->name, dev->manufacturer,
 337                         sizeof(pegasus->name));
 338
 339         if (dev->product) {
 340                 if (dev->manufacturer)
 341                         strlcat(pegasus->name, " ", sizeof(pegasus->name));
 342                 strlcat(pegasus->name, dev->product, sizeof(pegasus->name));
 343         }
 344
 345         if (!strlen(pegasus->name))
 346                 snprintf(pegasus->name, sizeof(pegasus->name),
 347                          "USB Pegasus Device %04x:%04x",
 348                          le16_to_cpu(dev->descriptor.idVendor),
 349                          le16_to_cpu(dev->descriptor.idProduct));
 350
 351         usb_make_path(dev, pegasus->phys, sizeof(pegasus->phys));
 352         strlcat(pegasus->phys, "/input0", sizeof(pegasus->phys));
 353
 354         INIT_WORK(&pegasus->init, pegasus_init);
 355
 356         usb_set_intfdata(intf, pegasus);
 357
 358         input_dev->name = pegasus->name;
 359         input_dev->phys = pegasus->phys;
 360         usb_to_input_id(dev, &input_dev->id);
 361         input_dev->dev.parent = &intf->dev;
 362
 363         input_set_drvdata(input_dev, pegasus);
 364
 365         input_dev->open = pegasus_open;
 366         input_dev->close = pegasus_close;
 367
 368         __set_bit(EV_ABS, input_dev->evbit);
 369         __set_bit(EV_KEY, input_dev->evbit);
 370
 371         __set_bit(ABS_X, input_dev->absbit);
 372         __set_bit(ABS_Y, input_dev->absbit);
 373
 374         __set_bit(BTN_TOUCH, input_dev->keybit);
 375         __set_bit(BTN_RIGHT, input_dev->keybit);
 376         __set_bit(BTN_TOOL_PEN, input_dev->keybit);
 377
 378         __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
 379         __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
 380
 381         input_set_abs_params(input_dev, ABS_X, -1500, 1500, 8, 0);
 382         input_set_abs_params(input_dev, ABS_Y, 1600, 3000, 8, 0);
 383
 384         error = input_register_device(pegasus->dev);
 385         if (error)
 386                 goto err_free_urb;
 387
 388         return 0;
 389
 390 err_free_urb:
 391         usb_free_urb(pegasus->irq);
 392 err_free_dma:
 393         usb_free_coherent(dev, pegasus->data_len,
 394                           pegasus->data, pegasus->data_dma);
 395 err_free_mem:
 396         input_free_device(input_dev);
 397         kfree(pegasus);
 398         usb_set_intfdata(intf, NULL);
 399
 400         return error;
 401 }
 402
 403 static void pegasus_disconnect(struct usb_interface *intf)
 404 {
 405         struct pegasus *pegasus = usb_get_intfdata(intf);
 406
 407         input_unregister_device(pegasus->dev);
 408
 409         usb_free_urb(pegasus->irq);
 410         usb_free_coherent(interface_to_usbdev(intf),
 411                           pegasus->data_len, pegasus->data,
 412                           pegasus->data_dma);
 413
 414         kfree(pegasus);
 415         usb_set_intfdata(intf, NULL);
 416 }
 417
 418 static int pegasus_suspend(struct usb_interface *intf, pm_message_t message)
 419 {
 420         struct pegasus *pegasus = usb_get_intfdata(intf);
 421
 422         guard(mutex)(&pegasus->pm_mutex);
 423
 424         usb_kill_urb(pegasus->irq);
 425         cancel_work_sync(&pegasus->init);
 426
 427         return 0;
 428 }
 429
 430 static int pegasus_resume(struct usb_interface *intf)
 431 {
 432         struct pegasus *pegasus = usb_get_intfdata(intf);
 433
 434         guard(mutex)(&pegasus->pm_mutex);
 435
 436         if (pegasus->is_open && usb_submit_urb(pegasus->irq, GFP_NOIO) < 0)
 437                 return -EIO;
 438
 439         return 0;
 440 }
 441
 442 static int pegasus_reset_resume(struct usb_interface *intf)
 443 {
 444         struct pegasus *pegasus = usb_get_intfdata(intf);
 445         int error;
 446
 447         guard(mutex)(&pegasus->pm_mutex);
 448
 449         if (pegasus->is_open) {
 450                 error = pegasus_set_mode(pegasus, PEN_MODE_XY,
 451                                           NOTETAKER_LED_MOUSE);
 452                 if (error)
 453                         return error;
 454
 455                 if (usb_submit_urb(pegasus->irq, GFP_NOIO) < 0)
 456                         return -EIO;
 457         }
 458
 459         return 0;
 460 }
 461
 462 static const struct usb_device_id pegasus_ids[] = {
 463         { USB_DEVICE(USB_VENDOR_ID_PEGASUSTECH,
 464                      USB_DEVICE_ID_PEGASUS_NOTETAKER_EN100) },
 465         { }
 466 };
 467 MODULE_DEVICE_TABLE(usb, pegasus_ids);
 468
 469 static struct usb_driver pegasus_driver = {
 470         .name           = "pegasus_notetaker",
 471         .probe          = pegasus_probe,
 472         .disconnect     = pegasus_disconnect,
 473         .suspend        = pegasus_suspend,
 474         .resume         = pegasus_resume,
 475         .reset_resume   = pegasus_reset_resume,
 476         .id_table       = pegasus_ids,
 477         .supports_autosuspend = 1,
 478 };
 479
 480 module_usb_driver(pegasus_driver);
 481
 482 MODULE_AUTHOR("Martin Kepplinger <[email protected]>");
 483 MODULE_DESCRIPTION("Pegasus Mobile Notetaker Pen tablet driver");
 484 MODULE_LICENSE("GPL");