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