hid-plantronics.c 5.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Plantronics USB HID Driver
  4. *
  5. * Copyright (c) 2014 JD Cole <jd.cole@plantronics.com>
  6. * Copyright (c) 2015-2018 Terry Junge <terry.junge@plantronics.com>
  7. */
  8. /*
  9. */
  10. #include "hid-ids.h"
  11. #include <linux/hid.h>
  12. #include <linux/module.h>
  13. #include <linux/jiffies.h>
  14. #define PLT_HID_1_0_PAGE 0xffa00000
  15. #define PLT_HID_2_0_PAGE 0xffa20000
  16. #define PLT_BASIC_TELEPHONY 0x0003
  17. #define PLT_BASIC_EXCEPTION 0x0005
  18. #define PLT_VOL_UP 0x00b1
  19. #define PLT_VOL_DOWN 0x00b2
  20. #define PLT1_VOL_UP (PLT_HID_1_0_PAGE | PLT_VOL_UP)
  21. #define PLT1_VOL_DOWN (PLT_HID_1_0_PAGE | PLT_VOL_DOWN)
  22. #define PLT2_VOL_UP (PLT_HID_2_0_PAGE | PLT_VOL_UP)
  23. #define PLT2_VOL_DOWN (PLT_HID_2_0_PAGE | PLT_VOL_DOWN)
  24. #define PLT_DA60 0xda60
  25. #define PLT_BT300_MIN 0x0413
  26. #define PLT_BT300_MAX 0x0418
  27. #define PLT_ALLOW_CONSUMER (field->application == HID_CP_CONSUMERCONTROL && \
  28. (usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER)
  29. #define PLT_QUIRK_DOUBLE_VOLUME_KEYS BIT(0)
  30. #define PLT_DOUBLE_KEY_TIMEOUT 5 /* ms */
  31. struct plt_drv_data {
  32. unsigned long device_type;
  33. unsigned long last_volume_key_ts;
  34. u32 quirks;
  35. };
  36. static int plantronics_input_mapping(struct hid_device *hdev,
  37. struct hid_input *hi,
  38. struct hid_field *field,
  39. struct hid_usage *usage,
  40. unsigned long **bit, int *max)
  41. {
  42. unsigned short mapped_key;
  43. struct plt_drv_data *drv_data = hid_get_drvdata(hdev);
  44. unsigned long plt_type = drv_data->device_type;
  45. /* special case for PTT products */
  46. if (field->application == HID_GD_JOYSTICK)
  47. goto defaulted;
  48. /* handle volume up/down mapping */
  49. /* non-standard types or multi-HID interfaces - plt_type is PID */
  50. if (!(plt_type & HID_USAGE_PAGE)) {
  51. switch (plt_type) {
  52. case PLT_DA60:
  53. if (PLT_ALLOW_CONSUMER)
  54. goto defaulted;
  55. goto ignored;
  56. default:
  57. if (PLT_ALLOW_CONSUMER)
  58. goto defaulted;
  59. }
  60. }
  61. /* handle standard types - plt_type is 0xffa0uuuu or 0xffa2uuuu */
  62. /* 'basic telephony compliant' - allow default consumer page map */
  63. else if ((plt_type & HID_USAGE) >= PLT_BASIC_TELEPHONY &&
  64. (plt_type & HID_USAGE) != PLT_BASIC_EXCEPTION) {
  65. if (PLT_ALLOW_CONSUMER)
  66. goto defaulted;
  67. }
  68. /* not 'basic telephony' - apply legacy mapping */
  69. /* only map if the field is in the device's primary vendor page */
  70. else if (!((field->application ^ plt_type) & HID_USAGE_PAGE)) {
  71. switch (usage->hid) {
  72. case PLT1_VOL_UP:
  73. case PLT2_VOL_UP:
  74. mapped_key = KEY_VOLUMEUP;
  75. goto mapped;
  76. case PLT1_VOL_DOWN:
  77. case PLT2_VOL_DOWN:
  78. mapped_key = KEY_VOLUMEDOWN;
  79. goto mapped;
  80. }
  81. }
  82. /*
  83. * Future mapping of call control or other usages,
  84. * if and when keys are defined would go here
  85. * otherwise, ignore everything else that was not mapped
  86. */
  87. ignored:
  88. return -1;
  89. defaulted:
  90. hid_dbg(hdev, "usage: %08x (appl: %08x) - defaulted\n",
  91. usage->hid, field->application);
  92. return 0;
  93. mapped:
  94. hid_map_usage_clear(hi, usage, bit, max, EV_KEY, mapped_key);
  95. hid_dbg(hdev, "usage: %08x (appl: %08x) - mapped to key %d\n",
  96. usage->hid, field->application, mapped_key);
  97. return 1;
  98. }
  99. static int plantronics_event(struct hid_device *hdev, struct hid_field *field,
  100. struct hid_usage *usage, __s32 value)
  101. {
  102. struct plt_drv_data *drv_data = hid_get_drvdata(hdev);
  103. if (drv_data->quirks & PLT_QUIRK_DOUBLE_VOLUME_KEYS) {
  104. unsigned long prev_ts, cur_ts;
  105. /* Usages are filtered in plantronics_usages. */
  106. if (!value) /* Handle key presses only. */
  107. return 0;
  108. prev_ts = drv_data->last_volume_key_ts;
  109. cur_ts = jiffies;
  110. if (jiffies_to_msecs(cur_ts - prev_ts) <= PLT_DOUBLE_KEY_TIMEOUT)
  111. return 1; /* Ignore the repeated key. */
  112. drv_data->last_volume_key_ts = cur_ts;
  113. }
  114. return 0;
  115. }
  116. static unsigned long plantronics_device_type(struct hid_device *hdev)
  117. {
  118. unsigned i, col_page;
  119. unsigned long plt_type = hdev->product;
  120. /* multi-HID interfaces? - plt_type is PID */
  121. if (plt_type >= PLT_BT300_MIN && plt_type <= PLT_BT300_MAX)
  122. goto exit;
  123. /* determine primary vendor page */
  124. for (i = 0; i < hdev->maxcollection; i++) {
  125. col_page = hdev->collection[i].usage & HID_USAGE_PAGE;
  126. if (col_page == PLT_HID_2_0_PAGE) {
  127. plt_type = hdev->collection[i].usage;
  128. break;
  129. }
  130. if (col_page == PLT_HID_1_0_PAGE)
  131. plt_type = hdev->collection[i].usage;
  132. }
  133. exit:
  134. hid_dbg(hdev, "plt_type decoded as: %08lx\n", plt_type);
  135. return plt_type;
  136. }
  137. static int plantronics_probe(struct hid_device *hdev,
  138. const struct hid_device_id *id)
  139. {
  140. struct plt_drv_data *drv_data;
  141. int ret;
  142. drv_data = devm_kzalloc(&hdev->dev, sizeof(*drv_data), GFP_KERNEL);
  143. if (!drv_data)
  144. return -ENOMEM;
  145. ret = hid_parse(hdev);
  146. if (ret) {
  147. hid_err(hdev, "parse failed\n");
  148. goto err;
  149. }
  150. drv_data->device_type = plantronics_device_type(hdev);
  151. drv_data->quirks = id->driver_data;
  152. drv_data->last_volume_key_ts = jiffies - msecs_to_jiffies(PLT_DOUBLE_KEY_TIMEOUT);
  153. hid_set_drvdata(hdev, drv_data);
  154. ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT |
  155. HID_CONNECT_HIDINPUT_FORCE | HID_CONNECT_HIDDEV_FORCE);
  156. if (ret)
  157. hid_err(hdev, "hw start failed\n");
  158. err:
  159. return ret;
  160. }
  161. static const struct hid_device_id plantronics_devices[] = {
  162. { HID_USB_DEVICE(USB_VENDOR_ID_PLANTRONICS,
  163. USB_DEVICE_ID_PLANTRONICS_BLACKWIRE_3220_SERIES),
  164. .driver_data = PLT_QUIRK_DOUBLE_VOLUME_KEYS },
  165. { HID_USB_DEVICE(USB_VENDOR_ID_PLANTRONICS, HID_ANY_ID) },
  166. { }
  167. };
  168. MODULE_DEVICE_TABLE(hid, plantronics_devices);
  169. static const struct hid_usage_id plantronics_usages[] = {
  170. { HID_CP_VOLUMEUP, EV_KEY, HID_ANY_ID },
  171. { HID_CP_VOLUMEDOWN, EV_KEY, HID_ANY_ID },
  172. { HID_TERMINATOR, HID_TERMINATOR, HID_TERMINATOR }
  173. };
  174. static struct hid_driver plantronics_driver = {
  175. .name = "plantronics",
  176. .id_table = plantronics_devices,
  177. .usage_table = plantronics_usages,
  178. .input_mapping = plantronics_input_mapping,
  179. .event = plantronics_event,
  180. .probe = plantronics_probe,
  181. };
  182. module_hid_driver(plantronics_driver);
  183. MODULE_AUTHOR("JD Cole <jd.cole@plantronics.com>");
  184. MODULE_AUTHOR("Terry Junge <terry.junge@plantronics.com>");
  185. MODULE_DESCRIPTION("Plantronics USB HID Driver");
  186. MODULE_LICENSE("GPL");