surface_kbd.c 7.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Surface System Aggregator Module (SSAM) HID transport driver for the legacy
  4. * keyboard interface (KBD/TC=0x08 subsystem). Provides support for the
  5. * integrated HID keyboard on Surface Laptops 1 and 2.
  6. *
  7. * Copyright (C) 2019-2021 Maximilian Luz <luzmaximilian@gmail.com>
  8. */
  9. #include <asm/unaligned.h>
  10. #include <linux/hid.h>
  11. #include <linux/kernel.h>
  12. #include <linux/module.h>
  13. #include <linux/platform_device.h>
  14. #include <linux/types.h>
  15. #include <linux/surface_aggregator/controller.h>
  16. #include "surface_hid_core.h"
  17. /* -- SAM interface (KBD). -------------------------------------------------- */
  18. #define KBD_FEATURE_REPORT_SIZE 7 /* 6 + report ID */
  19. enum surface_kbd_cid {
  20. SURFACE_KBD_CID_GET_DESCRIPTOR = 0x00,
  21. SURFACE_KBD_CID_SET_CAPSLOCK_LED = 0x01,
  22. SURFACE_KBD_CID_EVT_INPUT_GENERIC = 0x03,
  23. SURFACE_KBD_CID_EVT_INPUT_HOTKEYS = 0x04,
  24. SURFACE_KBD_CID_GET_FEATURE_REPORT = 0x0b,
  25. };
  26. static int ssam_kbd_get_descriptor(struct surface_hid_device *shid, u8 entry, u8 *buf, size_t len)
  27. {
  28. struct ssam_request rqst;
  29. struct ssam_response rsp;
  30. int status;
  31. rqst.target_category = shid->uid.category;
  32. rqst.target_id = shid->uid.target;
  33. rqst.command_id = SURFACE_KBD_CID_GET_DESCRIPTOR;
  34. rqst.instance_id = shid->uid.instance;
  35. rqst.flags = SSAM_REQUEST_HAS_RESPONSE;
  36. rqst.length = sizeof(entry);
  37. rqst.payload = &entry;
  38. rsp.capacity = len;
  39. rsp.length = 0;
  40. rsp.pointer = buf;
  41. status = ssam_retry(ssam_request_sync_onstack, shid->ctrl, &rqst, &rsp, sizeof(entry));
  42. if (status)
  43. return status;
  44. if (rsp.length != len) {
  45. dev_err(shid->dev, "invalid descriptor length: got %zu, expected, %zu\n",
  46. rsp.length, len);
  47. return -EPROTO;
  48. }
  49. return 0;
  50. }
  51. static int ssam_kbd_set_caps_led(struct surface_hid_device *shid, bool value)
  52. {
  53. struct ssam_request rqst;
  54. u8 value_u8 = value;
  55. rqst.target_category = shid->uid.category;
  56. rqst.target_id = shid->uid.target;
  57. rqst.command_id = SURFACE_KBD_CID_SET_CAPSLOCK_LED;
  58. rqst.instance_id = shid->uid.instance;
  59. rqst.flags = 0;
  60. rqst.length = sizeof(value_u8);
  61. rqst.payload = &value_u8;
  62. return ssam_retry(ssam_request_sync_onstack, shid->ctrl, &rqst, NULL, sizeof(value_u8));
  63. }
  64. static int ssam_kbd_get_feature_report(struct surface_hid_device *shid, u8 *buf, size_t len)
  65. {
  66. struct ssam_request rqst;
  67. struct ssam_response rsp;
  68. u8 payload = 0;
  69. int status;
  70. rqst.target_category = shid->uid.category;
  71. rqst.target_id = shid->uid.target;
  72. rqst.command_id = SURFACE_KBD_CID_GET_FEATURE_REPORT;
  73. rqst.instance_id = shid->uid.instance;
  74. rqst.flags = SSAM_REQUEST_HAS_RESPONSE;
  75. rqst.length = sizeof(payload);
  76. rqst.payload = &payload;
  77. rsp.capacity = len;
  78. rsp.length = 0;
  79. rsp.pointer = buf;
  80. status = ssam_retry(ssam_request_sync_onstack, shid->ctrl, &rqst, &rsp, sizeof(payload));
  81. if (status)
  82. return status;
  83. if (rsp.length != len) {
  84. dev_err(shid->dev, "invalid feature report length: got %zu, expected, %zu\n",
  85. rsp.length, len);
  86. return -EPROTO;
  87. }
  88. return 0;
  89. }
  90. static bool ssam_kbd_is_input_event(const struct ssam_event *event)
  91. {
  92. if (event->command_id == SURFACE_KBD_CID_EVT_INPUT_GENERIC)
  93. return true;
  94. if (event->command_id == SURFACE_KBD_CID_EVT_INPUT_HOTKEYS)
  95. return true;
  96. return false;
  97. }
  98. static u32 ssam_kbd_event_fn(struct ssam_event_notifier *nf, const struct ssam_event *event)
  99. {
  100. struct surface_hid_device *shid = container_of(nf, struct surface_hid_device, notif);
  101. /*
  102. * Check against device UID manually, as registry and device target
  103. * category doesn't line up.
  104. */
  105. if (shid->uid.category != event->target_category)
  106. return 0;
  107. if (shid->uid.target != event->target_id)
  108. return 0;
  109. if (shid->uid.instance != event->instance_id)
  110. return 0;
  111. if (!ssam_kbd_is_input_event(event))
  112. return 0;
  113. hid_input_report(shid->hid, HID_INPUT_REPORT, (u8 *)&event->data[0], event->length, 0);
  114. return SSAM_NOTIF_HANDLED;
  115. }
  116. /* -- Transport driver (KBD). ----------------------------------------------- */
  117. static int skbd_get_caps_led_value(struct hid_device *hid, u8 rprt_id, u8 *buf, size_t len)
  118. {
  119. struct hid_field *field;
  120. unsigned int offset, size;
  121. int i;
  122. /* Get LED field. */
  123. field = hidinput_get_led_field(hid);
  124. if (!field)
  125. return -ENOENT;
  126. /* Check if we got the correct report. */
  127. if (len != hid_report_len(field->report))
  128. return -ENOENT;
  129. if (rprt_id != field->report->id)
  130. return -ENOENT;
  131. /* Get caps lock LED index. */
  132. for (i = 0; i < field->report_count; i++)
  133. if ((field->usage[i].hid & 0xffff) == 0x02)
  134. break;
  135. if (i == field->report_count)
  136. return -ENOENT;
  137. /* Extract value. */
  138. size = field->report_size;
  139. offset = field->report_offset + i * size;
  140. return !!hid_field_extract(hid, buf + 1, size, offset);
  141. }
  142. static int skbd_output_report(struct surface_hid_device *shid, u8 rprt_id, u8 *buf, size_t len)
  143. {
  144. int caps_led;
  145. int status;
  146. caps_led = skbd_get_caps_led_value(shid->hid, rprt_id, buf, len);
  147. if (caps_led < 0)
  148. return -EIO; /* Only caps LED output reports are supported. */
  149. status = ssam_kbd_set_caps_led(shid, caps_led);
  150. if (status < 0)
  151. return status;
  152. return len;
  153. }
  154. static int skbd_get_feature_report(struct surface_hid_device *shid, u8 rprt_id, u8 *buf, size_t len)
  155. {
  156. u8 report[KBD_FEATURE_REPORT_SIZE];
  157. int status;
  158. /*
  159. * The keyboard only has a single hard-coded read-only feature report
  160. * of size KBD_FEATURE_REPORT_SIZE. Try to load it and compare its
  161. * report ID against the requested one.
  162. */
  163. if (len < ARRAY_SIZE(report))
  164. return -ENOSPC;
  165. status = ssam_kbd_get_feature_report(shid, report, ARRAY_SIZE(report));
  166. if (status < 0)
  167. return status;
  168. if (rprt_id != report[0])
  169. return -ENOENT;
  170. memcpy(buf, report, ARRAY_SIZE(report));
  171. return len;
  172. }
  173. static int skbd_set_feature_report(struct surface_hid_device *shid, u8 rprt_id, u8 *buf, size_t len)
  174. {
  175. /* Not supported. See skbd_get_feature_report() for details. */
  176. return -EIO;
  177. }
  178. /* -- Driver setup. --------------------------------------------------------- */
  179. static int surface_kbd_probe(struct platform_device *pdev)
  180. {
  181. struct ssam_controller *ctrl;
  182. struct surface_hid_device *shid;
  183. /* Add device link to EC. */
  184. ctrl = ssam_client_bind(&pdev->dev);
  185. if (IS_ERR(ctrl))
  186. return PTR_ERR(ctrl) == -ENODEV ? -EPROBE_DEFER : PTR_ERR(ctrl);
  187. shid = devm_kzalloc(&pdev->dev, sizeof(*shid), GFP_KERNEL);
  188. if (!shid)
  189. return -ENOMEM;
  190. shid->dev = &pdev->dev;
  191. shid->ctrl = ctrl;
  192. shid->uid.domain = SSAM_DOMAIN_SERIALHUB;
  193. shid->uid.category = SSAM_SSH_TC_KBD;
  194. shid->uid.target = 2;
  195. shid->uid.instance = 0;
  196. shid->uid.function = 0;
  197. shid->notif.base.priority = 1;
  198. shid->notif.base.fn = ssam_kbd_event_fn;
  199. shid->notif.event.reg = SSAM_EVENT_REGISTRY_SAM;
  200. shid->notif.event.id.target_category = shid->uid.category;
  201. shid->notif.event.id.instance = shid->uid.instance;
  202. shid->notif.event.mask = SSAM_EVENT_MASK_NONE;
  203. shid->notif.event.flags = 0;
  204. shid->ops.get_descriptor = ssam_kbd_get_descriptor;
  205. shid->ops.output_report = skbd_output_report;
  206. shid->ops.get_feature_report = skbd_get_feature_report;
  207. shid->ops.set_feature_report = skbd_set_feature_report;
  208. platform_set_drvdata(pdev, shid);
  209. return surface_hid_device_add(shid);
  210. }
  211. static int surface_kbd_remove(struct platform_device *pdev)
  212. {
  213. surface_hid_device_destroy(platform_get_drvdata(pdev));
  214. return 0;
  215. }
  216. static const struct acpi_device_id surface_kbd_match[] = {
  217. { "MSHW0096" },
  218. { },
  219. };
  220. MODULE_DEVICE_TABLE(acpi, surface_kbd_match);
  221. static struct platform_driver surface_kbd_driver = {
  222. .probe = surface_kbd_probe,
  223. .remove = surface_kbd_remove,
  224. .driver = {
  225. .name = "surface_keyboard",
  226. .acpi_match_table = surface_kbd_match,
  227. .pm = &surface_hid_pm_ops,
  228. .probe_type = PROBE_PREFER_ASYNCHRONOUS,
  229. },
  230. };
  231. module_platform_driver(surface_kbd_driver);
  232. MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>");
  233. MODULE_DESCRIPTION("HID legacy transport driver for Surface System Aggregator Module");
  234. MODULE_LICENSE("GPL");