hid-microsoft.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * HID driver for some microsoft "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. */
  11. /*
  12. */
  13. #include <linux/device.h>
  14. #include <linux/input.h>
  15. #include <linux/hid.h>
  16. #include <linux/module.h>
  17. #include "hid-ids.h"
  18. #define MS_HIDINPUT BIT(0)
  19. #define MS_ERGONOMY BIT(1)
  20. #define MS_PRESENTER BIT(2)
  21. #define MS_RDESC BIT(3)
  22. #define MS_NOGET BIT(4)
  23. #define MS_DUPLICATE_USAGES BIT(5)
  24. #define MS_SURFACE_DIAL BIT(6)
  25. #define MS_QUIRK_FF BIT(7)
  26. struct ms_data {
  27. unsigned long quirks;
  28. struct hid_device *hdev;
  29. struct work_struct ff_worker;
  30. __u8 strong;
  31. __u8 weak;
  32. void *output_report_dmabuf;
  33. };
  34. #define XB1S_FF_REPORT 3
  35. #define ENABLE_WEAK BIT(0)
  36. #define ENABLE_STRONG BIT(1)
  37. enum {
  38. MAGNITUDE_STRONG = 2,
  39. MAGNITUDE_WEAK,
  40. MAGNITUDE_NUM
  41. };
  42. struct xb1s_ff_report {
  43. __u8 report_id;
  44. __u8 enable;
  45. __u8 magnitude[MAGNITUDE_NUM];
  46. __u8 duration_10ms;
  47. __u8 start_delay_10ms;
  48. __u8 loop_count;
  49. } __packed;
  50. static __u8 *ms_report_fixup(struct hid_device *hdev, __u8 *rdesc,
  51. unsigned int *rsize)
  52. {
  53. struct ms_data *ms = hid_get_drvdata(hdev);
  54. unsigned long quirks = ms->quirks;
  55. /*
  56. * Microsoft Wireless Desktop Receiver (Model 1028) has
  57. * 'Usage Min/Max' where it ought to have 'Physical Min/Max'
  58. */
  59. if ((quirks & MS_RDESC) && *rsize == 571 && rdesc[557] == 0x19 &&
  60. rdesc[559] == 0x29) {
  61. hid_info(hdev, "fixing up Microsoft Wireless Receiver Model 1028 report descriptor\n");
  62. rdesc[557] = 0x35;
  63. rdesc[559] = 0x45;
  64. }
  65. return rdesc;
  66. }
  67. #define ms_map_key_clear(c) hid_map_usage_clear(hi, usage, bit, max, \
  68. EV_KEY, (c))
  69. static int ms_ergonomy_kb_quirk(struct hid_input *hi, struct hid_usage *usage,
  70. unsigned long **bit, int *max)
  71. {
  72. struct input_dev *input = hi->input;
  73. if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER) {
  74. switch (usage->hid & HID_USAGE) {
  75. /*
  76. * Microsoft uses these 2 reserved usage ids for 2 keys on
  77. * the MS office kb labelled "Office Home" and "Task Pane".
  78. */
  79. case 0x29d:
  80. ms_map_key_clear(KEY_PROG1);
  81. return 1;
  82. case 0x29e:
  83. ms_map_key_clear(KEY_PROG2);
  84. return 1;
  85. }
  86. return 0;
  87. }
  88. if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
  89. return 0;
  90. switch (usage->hid & HID_USAGE) {
  91. case 0xfd06: ms_map_key_clear(KEY_CHAT); break;
  92. case 0xfd07: ms_map_key_clear(KEY_PHONE); break;
  93. case 0xff00:
  94. /* Special keypad keys */
  95. ms_map_key_clear(KEY_KPEQUAL);
  96. set_bit(KEY_KPLEFTPAREN, input->keybit);
  97. set_bit(KEY_KPRIGHTPAREN, input->keybit);
  98. break;
  99. case 0xff01:
  100. /* Scroll wheel */
  101. hid_map_usage_clear(hi, usage, bit, max, EV_REL, REL_WHEEL);
  102. break;
  103. case 0xff02:
  104. /*
  105. * This byte contains a copy of the modifier keys byte of a
  106. * standard hid keyboard report, as send by interface 0
  107. * (this usage is found on interface 1).
  108. *
  109. * This byte only gets send when another key in the same report
  110. * changes state, and as such is useless, ignore it.
  111. */
  112. return -1;
  113. case 0xff05:
  114. set_bit(EV_REP, input->evbit);
  115. ms_map_key_clear(KEY_F13);
  116. set_bit(KEY_F14, input->keybit);
  117. set_bit(KEY_F15, input->keybit);
  118. set_bit(KEY_F16, input->keybit);
  119. set_bit(KEY_F17, input->keybit);
  120. set_bit(KEY_F18, input->keybit);
  121. break;
  122. default:
  123. return 0;
  124. }
  125. return 1;
  126. }
  127. static int ms_presenter_8k_quirk(struct hid_input *hi, struct hid_usage *usage,
  128. unsigned long **bit, int *max)
  129. {
  130. if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
  131. return 0;
  132. set_bit(EV_REP, hi->input->evbit);
  133. switch (usage->hid & HID_USAGE) {
  134. case 0xfd08: ms_map_key_clear(KEY_FORWARD); break;
  135. case 0xfd09: ms_map_key_clear(KEY_BACK); break;
  136. case 0xfd0b: ms_map_key_clear(KEY_PLAYPAUSE); break;
  137. case 0xfd0e: ms_map_key_clear(KEY_CLOSE); break;
  138. case 0xfd0f: ms_map_key_clear(KEY_PLAY); break;
  139. default:
  140. return 0;
  141. }
  142. return 1;
  143. }
  144. static int ms_surface_dial_quirk(struct hid_input *hi, struct hid_field *field,
  145. struct hid_usage *usage, unsigned long **bit, int *max)
  146. {
  147. switch (usage->hid & HID_USAGE_PAGE) {
  148. case 0xff070000:
  149. case HID_UP_DIGITIZER:
  150. /* ignore those axis */
  151. return -1;
  152. case HID_UP_GENDESK:
  153. switch (usage->hid) {
  154. case HID_GD_X:
  155. case HID_GD_Y:
  156. case HID_GD_RFKILL_BTN:
  157. /* ignore those axis */
  158. return -1;
  159. }
  160. }
  161. return 0;
  162. }
  163. static int ms_input_mapping(struct hid_device *hdev, struct hid_input *hi,
  164. struct hid_field *field, struct hid_usage *usage,
  165. unsigned long **bit, int *max)
  166. {
  167. struct ms_data *ms = hid_get_drvdata(hdev);
  168. unsigned long quirks = ms->quirks;
  169. if (quirks & MS_ERGONOMY) {
  170. int ret = ms_ergonomy_kb_quirk(hi, usage, bit, max);
  171. if (ret)
  172. return ret;
  173. }
  174. if ((quirks & MS_PRESENTER) &&
  175. ms_presenter_8k_quirk(hi, usage, bit, max))
  176. return 1;
  177. if (quirks & MS_SURFACE_DIAL) {
  178. int ret = ms_surface_dial_quirk(hi, field, usage, bit, max);
  179. if (ret)
  180. return ret;
  181. }
  182. return 0;
  183. }
  184. static int ms_input_mapped(struct hid_device *hdev, struct hid_input *hi,
  185. struct hid_field *field, struct hid_usage *usage,
  186. unsigned long **bit, int *max)
  187. {
  188. struct ms_data *ms = hid_get_drvdata(hdev);
  189. unsigned long quirks = ms->quirks;
  190. if (quirks & MS_DUPLICATE_USAGES)
  191. clear_bit(usage->code, *bit);
  192. return 0;
  193. }
  194. static int ms_event(struct hid_device *hdev, struct hid_field *field,
  195. struct hid_usage *usage, __s32 value)
  196. {
  197. struct ms_data *ms = hid_get_drvdata(hdev);
  198. unsigned long quirks = ms->quirks;
  199. struct input_dev *input;
  200. if (!(hdev->claimed & HID_CLAIMED_INPUT) || !field->hidinput ||
  201. !usage->type)
  202. return 0;
  203. input = field->hidinput->input;
  204. /* Handling MS keyboards special buttons */
  205. if (quirks & MS_ERGONOMY && usage->hid == (HID_UP_MSVENDOR | 0xff00)) {
  206. /* Special keypad keys */
  207. input_report_key(input, KEY_KPEQUAL, value & 0x01);
  208. input_report_key(input, KEY_KPLEFTPAREN, value & 0x02);
  209. input_report_key(input, KEY_KPRIGHTPAREN, value & 0x04);
  210. return 1;
  211. }
  212. if (quirks & MS_ERGONOMY && usage->hid == (HID_UP_MSVENDOR | 0xff01)) {
  213. /* Scroll wheel */
  214. int step = ((value & 0x60) >> 5) + 1;
  215. switch (value & 0x1f) {
  216. case 0x01:
  217. input_report_rel(input, REL_WHEEL, step);
  218. break;
  219. case 0x1f:
  220. input_report_rel(input, REL_WHEEL, -step);
  221. break;
  222. }
  223. return 1;
  224. }
  225. if (quirks & MS_ERGONOMY && usage->hid == (HID_UP_MSVENDOR | 0xff05)) {
  226. static unsigned int last_key = 0;
  227. unsigned int key = 0;
  228. switch (value) {
  229. case 0x01: key = KEY_F14; break;
  230. case 0x02: key = KEY_F15; break;
  231. case 0x04: key = KEY_F16; break;
  232. case 0x08: key = KEY_F17; break;
  233. case 0x10: key = KEY_F18; break;
  234. }
  235. if (key) {
  236. input_event(input, usage->type, key, 1);
  237. last_key = key;
  238. } else
  239. input_event(input, usage->type, last_key, 0);
  240. return 1;
  241. }
  242. return 0;
  243. }
  244. static void ms_ff_worker(struct work_struct *work)
  245. {
  246. struct ms_data *ms = container_of(work, struct ms_data, ff_worker);
  247. struct hid_device *hdev = ms->hdev;
  248. struct xb1s_ff_report *r = ms->output_report_dmabuf;
  249. int ret;
  250. memset(r, 0, sizeof(*r));
  251. r->report_id = XB1S_FF_REPORT;
  252. r->enable = ENABLE_WEAK | ENABLE_STRONG;
  253. /*
  254. * Specifying maximum duration and maximum loop count should
  255. * cover maximum duration of a single effect, which is 65536
  256. * ms
  257. */
  258. r->duration_10ms = U8_MAX;
  259. r->loop_count = U8_MAX;
  260. r->magnitude[MAGNITUDE_STRONG] = ms->strong; /* left actuator */
  261. r->magnitude[MAGNITUDE_WEAK] = ms->weak; /* right actuator */
  262. ret = hid_hw_output_report(hdev, (__u8 *)r, sizeof(*r));
  263. if (ret < 0)
  264. hid_warn(hdev, "failed to send FF report\n");
  265. }
  266. static int ms_play_effect(struct input_dev *dev, void *data,
  267. struct ff_effect *effect)
  268. {
  269. struct hid_device *hid = input_get_drvdata(dev);
  270. struct ms_data *ms = hid_get_drvdata(hid);
  271. if (effect->type != FF_RUMBLE)
  272. return 0;
  273. /*
  274. * Magnitude is 0..100 so scale the 16-bit input here
  275. */
  276. ms->strong = ((u32) effect->u.rumble.strong_magnitude * 100) / U16_MAX;
  277. ms->weak = ((u32) effect->u.rumble.weak_magnitude * 100) / U16_MAX;
  278. schedule_work(&ms->ff_worker);
  279. return 0;
  280. }
  281. static int ms_init_ff(struct hid_device *hdev)
  282. {
  283. struct hid_input *hidinput;
  284. struct input_dev *input_dev;
  285. struct ms_data *ms = hid_get_drvdata(hdev);
  286. if (list_empty(&hdev->inputs)) {
  287. hid_err(hdev, "no inputs found\n");
  288. return -ENODEV;
  289. }
  290. hidinput = list_entry(hdev->inputs.next, struct hid_input, list);
  291. input_dev = hidinput->input;
  292. if (!(ms->quirks & MS_QUIRK_FF))
  293. return 0;
  294. ms->hdev = hdev;
  295. INIT_WORK(&ms->ff_worker, ms_ff_worker);
  296. ms->output_report_dmabuf = devm_kzalloc(&hdev->dev,
  297. sizeof(struct xb1s_ff_report),
  298. GFP_KERNEL);
  299. if (ms->output_report_dmabuf == NULL)
  300. return -ENOMEM;
  301. input_set_capability(input_dev, EV_FF, FF_RUMBLE);
  302. return input_ff_create_memless(input_dev, NULL, ms_play_effect);
  303. }
  304. static void ms_remove_ff(struct hid_device *hdev)
  305. {
  306. struct ms_data *ms = hid_get_drvdata(hdev);
  307. if (!(ms->quirks & MS_QUIRK_FF))
  308. return;
  309. cancel_work_sync(&ms->ff_worker);
  310. }
  311. static int ms_probe(struct hid_device *hdev, const struct hid_device_id *id)
  312. {
  313. unsigned long quirks = id->driver_data;
  314. struct ms_data *ms;
  315. int ret;
  316. ms = devm_kzalloc(&hdev->dev, sizeof(*ms), GFP_KERNEL);
  317. if (ms == NULL)
  318. return -ENOMEM;
  319. ms->quirks = quirks;
  320. hid_set_drvdata(hdev, ms);
  321. if (quirks & MS_NOGET)
  322. hdev->quirks |= HID_QUIRK_NOGET;
  323. if (quirks & MS_SURFACE_DIAL)
  324. hdev->quirks |= HID_QUIRK_INPUT_PER_APP;
  325. ret = hid_parse(hdev);
  326. if (ret) {
  327. hid_err(hdev, "parse failed\n");
  328. goto err_free;
  329. }
  330. ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT | ((quirks & MS_HIDINPUT) ?
  331. HID_CONNECT_HIDINPUT_FORCE : 0));
  332. if (ret) {
  333. hid_err(hdev, "hw start failed\n");
  334. goto err_free;
  335. }
  336. ret = ms_init_ff(hdev);
  337. if (ret)
  338. hid_err(hdev, "could not initialize ff, continuing anyway");
  339. return 0;
  340. err_free:
  341. return ret;
  342. }
  343. static void ms_remove(struct hid_device *hdev)
  344. {
  345. hid_hw_stop(hdev);
  346. ms_remove_ff(hdev);
  347. }
  348. static const struct hid_device_id ms_devices[] = {
  349. { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_SIDEWINDER_GV),
  350. .driver_data = MS_HIDINPUT },
  351. { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_OFFICE_KB),
  352. .driver_data = MS_ERGONOMY },
  353. { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K),
  354. .driver_data = MS_ERGONOMY },
  355. { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K_JP),
  356. .driver_data = MS_ERGONOMY },
  357. { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE7K),
  358. .driver_data = MS_ERGONOMY },
  359. { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_LK6K),
  360. .driver_data = MS_ERGONOMY | MS_RDESC },
  361. { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_USB),
  362. .driver_data = MS_PRESENTER },
  363. { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_3K),
  364. .driver_data = MS_ERGONOMY },
  365. { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_7K),
  366. .driver_data = MS_ERGONOMY },
  367. { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_600),
  368. .driver_data = MS_ERGONOMY },
  369. { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_3KV1),
  370. .driver_data = MS_ERGONOMY },
  371. { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0),
  372. .driver_data = MS_NOGET },
  373. { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_COMFORT_MOUSE_4500),
  374. .driver_data = MS_DUPLICATE_USAGES },
  375. { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_POWER_COVER),
  376. .driver_data = MS_HIDINPUT },
  377. { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_COMFORT_KEYBOARD),
  378. .driver_data = MS_ERGONOMY},
  379. { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_BT),
  380. .driver_data = MS_PRESENTER },
  381. { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, 0x091B),
  382. .driver_data = MS_SURFACE_DIAL },
  383. { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_XBOX_ONE_S_CONTROLLER),
  384. .driver_data = MS_QUIRK_FF },
  385. { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_8BITDO_SN30_PRO_PLUS),
  386. .driver_data = MS_QUIRK_FF },
  387. { }
  388. };
  389. MODULE_DEVICE_TABLE(hid, ms_devices);
  390. static struct hid_driver ms_driver = {
  391. .name = "microsoft",
  392. .id_table = ms_devices,
  393. .report_fixup = ms_report_fixup,
  394. .input_mapping = ms_input_mapping,
  395. .input_mapped = ms_input_mapped,
  396. .event = ms_event,
  397. .probe = ms_probe,
  398. .remove = ms_remove,
  399. };
  400. module_hid_driver(ms_driver);
  401. MODULE_LICENSE("GPL");