/drivers/input/tablet/kbtab.c

http://github.com/mirrors/linux · C · 204 lines · 154 code · 43 blank · 7 comment · 12 complexity · f144efc01820b2eea8a906212cf73ab1 MD5 · raw file

  1. // SPDX-License-Identifier: GPL-2.0-only
  2. #include <linux/kernel.h>
  3. #include <linux/slab.h>
  4. #include <linux/module.h>
  5. #include <linux/usb/input.h>
  6. #include <asm/unaligned.h>
  7. /*
  8. * Pressure-threshold modules param code from Alex Perry <alex.perry@ieee.org>
  9. */
  10. MODULE_AUTHOR("Josh Myer <josh@joshisanerd.com>");
  11. MODULE_DESCRIPTION("USB KB Gear JamStudio Tablet driver");
  12. MODULE_LICENSE("GPL");
  13. #define USB_VENDOR_ID_KBGEAR 0x084e
  14. static int kb_pressure_click = 0x10;
  15. module_param(kb_pressure_click, int, 0);
  16. MODULE_PARM_DESC(kb_pressure_click, "pressure threshold for clicks");
  17. struct kbtab {
  18. unsigned char *data;
  19. dma_addr_t data_dma;
  20. struct input_dev *dev;
  21. struct usb_interface *intf;
  22. struct urb *irq;
  23. char phys[32];
  24. };
  25. static void kbtab_irq(struct urb *urb)
  26. {
  27. struct kbtab *kbtab = urb->context;
  28. unsigned char *data = kbtab->data;
  29. struct input_dev *dev = kbtab->dev;
  30. int pressure;
  31. int retval;
  32. switch (urb->status) {
  33. case 0:
  34. /* success */
  35. break;
  36. case -ECONNRESET:
  37. case -ENOENT:
  38. case -ESHUTDOWN:
  39. /* this urb is terminated, clean up */
  40. dev_dbg(&kbtab->intf->dev,
  41. "%s - urb shutting down with status: %d\n",
  42. __func__, urb->status);
  43. return;
  44. default:
  45. dev_dbg(&kbtab->intf->dev,
  46. "%s - nonzero urb status received: %d\n",
  47. __func__, urb->status);
  48. goto exit;
  49. }
  50. input_report_key(dev, BTN_TOOL_PEN, 1);
  51. input_report_abs(dev, ABS_X, get_unaligned_le16(&data[1]));
  52. input_report_abs(dev, ABS_Y, get_unaligned_le16(&data[3]));
  53. /*input_report_key(dev, BTN_TOUCH , data[0] & 0x01);*/
  54. input_report_key(dev, BTN_RIGHT, data[0] & 0x02);
  55. pressure = data[5];
  56. if (kb_pressure_click == -1)
  57. input_report_abs(dev, ABS_PRESSURE, pressure);
  58. else
  59. input_report_key(dev, BTN_LEFT, pressure > kb_pressure_click ? 1 : 0);
  60. input_sync(dev);
  61. exit:
  62. retval = usb_submit_urb(urb, GFP_ATOMIC);
  63. if (retval)
  64. dev_err(&kbtab->intf->dev,
  65. "%s - usb_submit_urb failed with result %d\n",
  66. __func__, retval);
  67. }
  68. static const struct usb_device_id kbtab_ids[] = {
  69. { USB_DEVICE(USB_VENDOR_ID_KBGEAR, 0x1001), .driver_info = 0 },
  70. { }
  71. };
  72. MODULE_DEVICE_TABLE(usb, kbtab_ids);
  73. static int kbtab_open(struct input_dev *dev)
  74. {
  75. struct kbtab *kbtab = input_get_drvdata(dev);
  76. struct usb_device *udev = interface_to_usbdev(kbtab->intf);
  77. kbtab->irq->dev = udev;
  78. if (usb_submit_urb(kbtab->irq, GFP_KERNEL))
  79. return -EIO;
  80. return 0;
  81. }
  82. static void kbtab_close(struct input_dev *dev)
  83. {
  84. struct kbtab *kbtab = input_get_drvdata(dev);
  85. usb_kill_urb(kbtab->irq);
  86. }
  87. static int kbtab_probe(struct usb_interface *intf, const struct usb_device_id *id)
  88. {
  89. struct usb_device *dev = interface_to_usbdev(intf);
  90. struct usb_endpoint_descriptor *endpoint;
  91. struct kbtab *kbtab;
  92. struct input_dev *input_dev;
  93. int error = -ENOMEM;
  94. if (intf->cur_altsetting->desc.bNumEndpoints < 1)
  95. return -ENODEV;
  96. endpoint = &intf->cur_altsetting->endpoint[0].desc;
  97. if (!usb_endpoint_is_int_in(endpoint))
  98. return -ENODEV;
  99. kbtab = kzalloc(sizeof(struct kbtab), GFP_KERNEL);
  100. input_dev = input_allocate_device();
  101. if (!kbtab || !input_dev)
  102. goto fail1;
  103. kbtab->data = usb_alloc_coherent(dev, 8, GFP_KERNEL, &kbtab->data_dma);
  104. if (!kbtab->data)
  105. goto fail1;
  106. kbtab->irq = usb_alloc_urb(0, GFP_KERNEL);
  107. if (!kbtab->irq)
  108. goto fail2;
  109. kbtab->intf = intf;
  110. kbtab->dev = input_dev;
  111. usb_make_path(dev, kbtab->phys, sizeof(kbtab->phys));
  112. strlcat(kbtab->phys, "/input0", sizeof(kbtab->phys));
  113. input_dev->name = "KB Gear Tablet";
  114. input_dev->phys = kbtab->phys;
  115. usb_to_input_id(dev, &input_dev->id);
  116. input_dev->dev.parent = &intf->dev;
  117. input_set_drvdata(input_dev, kbtab);
  118. input_dev->open = kbtab_open;
  119. input_dev->close = kbtab_close;
  120. input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
  121. input_dev->keybit[BIT_WORD(BTN_LEFT)] |=
  122. BIT_MASK(BTN_LEFT) | BIT_MASK(BTN_RIGHT);
  123. input_dev->keybit[BIT_WORD(BTN_DIGI)] |=
  124. BIT_MASK(BTN_TOOL_PEN) | BIT_MASK(BTN_TOUCH);
  125. input_set_abs_params(input_dev, ABS_X, 0, 0x2000, 4, 0);
  126. input_set_abs_params(input_dev, ABS_Y, 0, 0x1750, 4, 0);
  127. input_set_abs_params(input_dev, ABS_PRESSURE, 0, 0xff, 0, 0);
  128. usb_fill_int_urb(kbtab->irq, dev,
  129. usb_rcvintpipe(dev, endpoint->bEndpointAddress),
  130. kbtab->data, 8,
  131. kbtab_irq, kbtab, endpoint->bInterval);
  132. kbtab->irq->transfer_dma = kbtab->data_dma;
  133. kbtab->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
  134. error = input_register_device(kbtab->dev);
  135. if (error)
  136. goto fail3;
  137. usb_set_intfdata(intf, kbtab);
  138. return 0;
  139. fail3: usb_free_urb(kbtab->irq);
  140. fail2: usb_free_coherent(dev, 8, kbtab->data, kbtab->data_dma);
  141. fail1: input_free_device(input_dev);
  142. kfree(kbtab);
  143. return error;
  144. }
  145. static void kbtab_disconnect(struct usb_interface *intf)
  146. {
  147. struct kbtab *kbtab = usb_get_intfdata(intf);
  148. struct usb_device *udev = interface_to_usbdev(intf);
  149. usb_set_intfdata(intf, NULL);
  150. input_unregister_device(kbtab->dev);
  151. usb_free_urb(kbtab->irq);
  152. usb_free_coherent(udev, 8, kbtab->data, kbtab->data_dma);
  153. kfree(kbtab);
  154. }
  155. static struct usb_driver kbtab_driver = {
  156. .name = "kbtab",
  157. .probe = kbtab_probe,
  158. .disconnect = kbtab_disconnect,
  159. .id_table = kbtab_ids,
  160. };
  161. module_usb_driver(kbtab_driver);