hid-samsung.c 5.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * HID driver for some samsung "special" devices
  4. *
  5. * Copyright (c) 1999 Andreas Gal
  6. * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
  7. * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
  8. * Copyright (c) 2006-2007 Jiri Kosina
  9. * Copyright (c) 2008 Jiri Slaby
  10. * Copyright (c) 2010 Don Prince <dhprince.devel@yahoo.co.uk>
  11. *
  12. * This driver supports several HID devices:
  13. *
  14. * [0419:0001] Samsung IrDA remote controller (reports as Cypress USB Mouse).
  15. * various hid report fixups for different variants.
  16. *
  17. * [0419:0600] Creative Desktop Wireless 6000 keyboard/mouse combo
  18. * several key mappings used from the consumer usage page
  19. * deviate from the USB HUT 1.12 standard.
  20. */
  21. /*
  22. */
  23. #include <linux/device.h>
  24. #include <linux/usb.h>
  25. #include <linux/hid.h>
  26. #include <linux/module.h>
  27. #include "hid-ids.h"
  28. /*
  29. * There are several variants for 0419:0001:
  30. *
  31. * 1. 184 byte report descriptor
  32. * Vendor specific report #4 has a size of 48 bit,
  33. * and therefore is not accepted when inspecting the descriptors.
  34. * As a workaround we reinterpret the report as:
  35. * Variable type, count 6, size 8 bit, log. maximum 255
  36. * The burden to reconstruct the data is moved into user space.
  37. *
  38. * 2. 203 byte report descriptor
  39. * Report #4 has an array field with logical range 0..18 instead of 1..15.
  40. *
  41. * 3. 135 byte report descriptor
  42. * Report #4 has an array field with logical range 0..17 instead of 1..14.
  43. *
  44. * 4. 171 byte report descriptor
  45. * Report #3 has an array field with logical range 0..1 instead of 1..3.
  46. */
  47. static inline void samsung_irda_dev_trace(struct hid_device *hdev,
  48. unsigned int rsize)
  49. {
  50. hid_info(hdev, "fixing up Samsung IrDA %d byte report descriptor\n",
  51. rsize);
  52. }
  53. static __u8 *samsung_irda_report_fixup(struct hid_device *hdev, __u8 *rdesc,
  54. unsigned int *rsize)
  55. {
  56. if (*rsize == 184 && rdesc[175] == 0x25 && rdesc[176] == 0x40 &&
  57. rdesc[177] == 0x75 && rdesc[178] == 0x30 &&
  58. rdesc[179] == 0x95 && rdesc[180] == 0x01 &&
  59. rdesc[182] == 0x40) {
  60. samsung_irda_dev_trace(hdev, 184);
  61. rdesc[176] = 0xff;
  62. rdesc[178] = 0x08;
  63. rdesc[180] = 0x06;
  64. rdesc[182] = 0x42;
  65. } else
  66. if (*rsize == 203 && rdesc[192] == 0x15 && rdesc[193] == 0x0 &&
  67. rdesc[194] == 0x25 && rdesc[195] == 0x12) {
  68. samsung_irda_dev_trace(hdev, 203);
  69. rdesc[193] = 0x1;
  70. rdesc[195] = 0xf;
  71. } else
  72. if (*rsize == 135 && rdesc[124] == 0x15 && rdesc[125] == 0x0 &&
  73. rdesc[126] == 0x25 && rdesc[127] == 0x11) {
  74. samsung_irda_dev_trace(hdev, 135);
  75. rdesc[125] = 0x1;
  76. rdesc[127] = 0xe;
  77. } else
  78. if (*rsize == 171 && rdesc[160] == 0x15 && rdesc[161] == 0x0 &&
  79. rdesc[162] == 0x25 && rdesc[163] == 0x01) {
  80. samsung_irda_dev_trace(hdev, 171);
  81. rdesc[161] = 0x1;
  82. rdesc[163] = 0x3;
  83. }
  84. return rdesc;
  85. }
  86. #define samsung_kbd_mouse_map_key_clear(c) \
  87. hid_map_usage_clear(hi, usage, bit, max, EV_KEY, (c))
  88. static int samsung_kbd_mouse_input_mapping(struct hid_device *hdev,
  89. struct hid_input *hi, struct hid_field *field, struct hid_usage *usage,
  90. unsigned long **bit, int *max)
  91. {
  92. struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
  93. unsigned short ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
  94. if (1 != ifnum || HID_UP_CONSUMER != (usage->hid & HID_USAGE_PAGE))
  95. return 0;
  96. dbg_hid("samsung wireless keyboard/mouse input mapping event [0x%x]\n",
  97. usage->hid & HID_USAGE);
  98. switch (usage->hid & HID_USAGE) {
  99. /* report 2 */
  100. case 0x183: samsung_kbd_mouse_map_key_clear(KEY_MEDIA); break;
  101. case 0x195: samsung_kbd_mouse_map_key_clear(KEY_EMAIL); break;
  102. case 0x196: samsung_kbd_mouse_map_key_clear(KEY_CALC); break;
  103. case 0x197: samsung_kbd_mouse_map_key_clear(KEY_COMPUTER); break;
  104. case 0x22b: samsung_kbd_mouse_map_key_clear(KEY_SEARCH); break;
  105. case 0x22c: samsung_kbd_mouse_map_key_clear(KEY_WWW); break;
  106. case 0x22d: samsung_kbd_mouse_map_key_clear(KEY_BACK); break;
  107. case 0x22e: samsung_kbd_mouse_map_key_clear(KEY_FORWARD); break;
  108. case 0x22f: samsung_kbd_mouse_map_key_clear(KEY_FAVORITES); break;
  109. case 0x230: samsung_kbd_mouse_map_key_clear(KEY_REFRESH); break;
  110. case 0x231: samsung_kbd_mouse_map_key_clear(KEY_STOP); break;
  111. default:
  112. return 0;
  113. }
  114. return 1;
  115. }
  116. static __u8 *samsung_report_fixup(struct hid_device *hdev, __u8 *rdesc,
  117. unsigned int *rsize)
  118. {
  119. if (USB_DEVICE_ID_SAMSUNG_IR_REMOTE == hdev->product)
  120. rdesc = samsung_irda_report_fixup(hdev, rdesc, rsize);
  121. return rdesc;
  122. }
  123. static int samsung_input_mapping(struct hid_device *hdev, struct hid_input *hi,
  124. struct hid_field *field, struct hid_usage *usage,
  125. unsigned long **bit, int *max)
  126. {
  127. int ret = 0;
  128. if (USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE == hdev->product)
  129. ret = samsung_kbd_mouse_input_mapping(hdev,
  130. hi, field, usage, bit, max);
  131. return ret;
  132. }
  133. static int samsung_probe(struct hid_device *hdev,
  134. const struct hid_device_id *id)
  135. {
  136. int ret;
  137. unsigned int cmask = HID_CONNECT_DEFAULT;
  138. if (!hid_is_usb(hdev))
  139. return -EINVAL;
  140. ret = hid_parse(hdev);
  141. if (ret) {
  142. hid_err(hdev, "parse failed\n");
  143. goto err_free;
  144. }
  145. if (USB_DEVICE_ID_SAMSUNG_IR_REMOTE == hdev->product) {
  146. if (hdev->rsize == 184) {
  147. /* disable hidinput, force hiddev */
  148. cmask = (cmask & ~HID_CONNECT_HIDINPUT) |
  149. HID_CONNECT_HIDDEV_FORCE;
  150. }
  151. }
  152. ret = hid_hw_start(hdev, cmask);
  153. if (ret) {
  154. hid_err(hdev, "hw start failed\n");
  155. goto err_free;
  156. }
  157. return 0;
  158. err_free:
  159. return ret;
  160. }
  161. static const struct hid_device_id samsung_devices[] = {
  162. { HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE) },
  163. { HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE) },
  164. { }
  165. };
  166. MODULE_DEVICE_TABLE(hid, samsung_devices);
  167. static struct hid_driver samsung_driver = {
  168. .name = "samsung",
  169. .id_table = samsung_devices,
  170. .report_fixup = samsung_report_fixup,
  171. .input_mapping = samsung_input_mapping,
  172. .probe = samsung_probe,
  173. };
  174. module_hid_driver(samsung_driver);
  175. MODULE_LICENSE("GPL");