1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Surface System Aggregator Module (SSAM) HID transport driver for the
4  * generic HID interface (HID/TC=0x15 subsystem). Provides support for
5  * integrated HID devices on Surface Laptop 3, Book 3, and later.
6  *
7  * Copyright (C) 2019-2021 Blaž Hrastnik <blaz@mxxn.io>,
8  *                         Maximilian Luz <luzmaximilian@gmail.com>
9  */
10 
11 #include <asm/unaligned.h>
12 #include <linux/hid.h>
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/types.h>
16 
17 #include <linux/surface_aggregator/controller.h>
18 #include <linux/surface_aggregator/device.h>
19 
20 #include "surface_hid_core.h"
21 
22 
23 /* -- SAM interface. -------------------------------------------------------- */
24 
25 struct surface_hid_buffer_slice {
26 	__u8 entry;
27 	__le32 offset;
28 	__le32 length;
29 	__u8 end;
30 	__u8 data[];
31 } __packed;
32 
33 static_assert(sizeof(struct surface_hid_buffer_slice) == 10);
34 
35 enum surface_hid_cid {
36 	SURFACE_HID_CID_OUTPUT_REPORT      = 0x01,
37 	SURFACE_HID_CID_GET_FEATURE_REPORT = 0x02,
38 	SURFACE_HID_CID_SET_FEATURE_REPORT = 0x03,
39 	SURFACE_HID_CID_GET_DESCRIPTOR     = 0x04,
40 };
41 
42 static int ssam_hid_get_descriptor(struct surface_hid_device *shid, u8 entry, u8 *buf, size_t len)
43 {
44 	u8 buffer[sizeof(struct surface_hid_buffer_slice) + 0x76];
45 	struct surface_hid_buffer_slice *slice;
46 	struct ssam_request rqst;
47 	struct ssam_response rsp;
48 	u32 buffer_len, offset, length;
49 	int status;
50 
51 	/*
52 	 * Note: The 0x76 above has been chosen because that's what's used by
53 	 * the Windows driver. Together with the header, this leads to a 128
54 	 * byte payload in total.
55 	 */
56 
57 	buffer_len = ARRAY_SIZE(buffer) - sizeof(struct surface_hid_buffer_slice);
58 
59 	rqst.target_category = shid->uid.category;
60 	rqst.target_id = shid->uid.target;
61 	rqst.command_id = SURFACE_HID_CID_GET_DESCRIPTOR;
62 	rqst.instance_id = shid->uid.instance;
63 	rqst.flags = SSAM_REQUEST_HAS_RESPONSE;
64 	rqst.length = sizeof(struct surface_hid_buffer_slice);
65 	rqst.payload = buffer;
66 
67 	rsp.capacity = ARRAY_SIZE(buffer);
68 	rsp.pointer = buffer;
69 
70 	slice = (struct surface_hid_buffer_slice *)buffer;
71 	slice->entry = entry;
72 	slice->end = 0;
73 
74 	offset = 0;
75 	length = buffer_len;
76 
77 	while (!slice->end && offset < len) {
78 		put_unaligned_le32(offset, &slice->offset);
79 		put_unaligned_le32(length, &slice->length);
80 
81 		rsp.length = 0;
82 
83 		status = ssam_retry(ssam_request_sync_onstack, shid->ctrl, &rqst, &rsp,
84 				    sizeof(*slice));
85 		if (status)
86 			return status;
87 
88 		offset = get_unaligned_le32(&slice->offset);
89 		length = get_unaligned_le32(&slice->length);
90 
91 		/* Don't mess stuff up in case we receive garbage. */
92 		if (length > buffer_len || offset > len)
93 			return -EPROTO;
94 
95 		if (offset + length > len)
96 			length = len - offset;
97 
98 		memcpy(buf + offset, &slice->data[0], length);
99 
100 		offset += length;
101 		length = buffer_len;
102 	}
103 
104 	if (offset != len) {
105 		dev_err(shid->dev, "unexpected descriptor length: got %u, expected %zu\n",
106 			offset, len);
107 		return -EPROTO;
108 	}
109 
110 	return 0;
111 }
112 
113 static int ssam_hid_set_raw_report(struct surface_hid_device *shid, u8 rprt_id, bool feature,
114 				   u8 *buf, size_t len)
115 {
116 	struct ssam_request rqst;
117 	u8 cid;
118 
119 	if (feature)
120 		cid = SURFACE_HID_CID_SET_FEATURE_REPORT;
121 	else
122 		cid = SURFACE_HID_CID_OUTPUT_REPORT;
123 
124 	rqst.target_category = shid->uid.category;
125 	rqst.target_id = shid->uid.target;
126 	rqst.instance_id = shid->uid.instance;
127 	rqst.command_id = cid;
128 	rqst.flags = 0;
129 	rqst.length = len;
130 	rqst.payload = buf;
131 
132 	buf[0] = rprt_id;
133 
134 	return ssam_retry(ssam_request_sync, shid->ctrl, &rqst, NULL);
135 }
136 
137 static int ssam_hid_get_raw_report(struct surface_hid_device *shid, u8 rprt_id, u8 *buf, size_t len)
138 {
139 	struct ssam_request rqst;
140 	struct ssam_response rsp;
141 
142 	rqst.target_category = shid->uid.category;
143 	rqst.target_id = shid->uid.target;
144 	rqst.instance_id = shid->uid.instance;
145 	rqst.command_id = SURFACE_HID_CID_GET_FEATURE_REPORT;
146 	rqst.flags = SSAM_REQUEST_HAS_RESPONSE;
147 	rqst.length = sizeof(rprt_id);
148 	rqst.payload = &rprt_id;
149 
150 	rsp.capacity = len;
151 	rsp.length = 0;
152 	rsp.pointer = buf;
153 
154 	return ssam_retry(ssam_request_sync_onstack, shid->ctrl, &rqst, &rsp, sizeof(rprt_id));
155 }
156 
157 static u32 ssam_hid_event_fn(struct ssam_event_notifier *nf, const struct ssam_event *event)
158 {
159 	struct surface_hid_device *shid = container_of(nf, struct surface_hid_device, notif);
160 
161 	if (event->command_id != 0x00)
162 		return 0;
163 
164 	hid_input_report(shid->hid, HID_INPUT_REPORT, (u8 *)&event->data[0], event->length, 0);
165 	return SSAM_NOTIF_HANDLED;
166 }
167 
168 
169 /* -- Transport driver. ----------------------------------------------------- */
170 
171 static int shid_output_report(struct surface_hid_device *shid, u8 rprt_id, u8 *buf, size_t len)
172 {
173 	int status;
174 
175 	status = ssam_hid_set_raw_report(shid, rprt_id, false, buf, len);
176 	return status >= 0 ? len : status;
177 }
178 
179 static int shid_get_feature_report(struct surface_hid_device *shid, u8 rprt_id, u8 *buf, size_t len)
180 {
181 	int status;
182 
183 	status = ssam_hid_get_raw_report(shid, rprt_id, buf, len);
184 	return status >= 0 ? len : status;
185 }
186 
187 static int shid_set_feature_report(struct surface_hid_device *shid, u8 rprt_id, u8 *buf, size_t len)
188 {
189 	int status;
190 
191 	status = ssam_hid_set_raw_report(shid, rprt_id, true, buf, len);
192 	return status >= 0 ? len : status;
193 }
194 
195 
196 /* -- Driver setup. --------------------------------------------------------- */
197 
198 static int surface_hid_probe(struct ssam_device *sdev)
199 {
200 	struct surface_hid_device *shid;
201 
202 	shid = devm_kzalloc(&sdev->dev, sizeof(*shid), GFP_KERNEL);
203 	if (!shid)
204 		return -ENOMEM;
205 
206 	shid->dev = &sdev->dev;
207 	shid->ctrl = sdev->ctrl;
208 	shid->uid = sdev->uid;
209 
210 	shid->notif.base.priority = 1;
211 	shid->notif.base.fn = ssam_hid_event_fn;
212 	shid->notif.event.reg = SSAM_EVENT_REGISTRY_REG(sdev->uid.target);
213 	shid->notif.event.id.target_category = sdev->uid.category;
214 	shid->notif.event.id.instance = sdev->uid.instance;
215 	shid->notif.event.mask = SSAM_EVENT_MASK_STRICT;
216 	shid->notif.event.flags = 0;
217 
218 	shid->ops.get_descriptor = ssam_hid_get_descriptor;
219 	shid->ops.output_report = shid_output_report;
220 	shid->ops.get_feature_report = shid_get_feature_report;
221 	shid->ops.set_feature_report = shid_set_feature_report;
222 
223 	ssam_device_set_drvdata(sdev, shid);
224 	return surface_hid_device_add(shid);
225 }
226 
227 static void surface_hid_remove(struct ssam_device *sdev)
228 {
229 	surface_hid_device_destroy(ssam_device_get_drvdata(sdev));
230 }
231 
232 static const struct ssam_device_id surface_hid_match[] = {
233 	{ SSAM_SDEV(HID, SSAM_ANY_TID, SSAM_ANY_IID, 0x00) },
234 	{ },
235 };
236 MODULE_DEVICE_TABLE(ssam, surface_hid_match);
237 
238 static struct ssam_device_driver surface_hid_driver = {
239 	.probe = surface_hid_probe,
240 	.remove = surface_hid_remove,
241 	.match_table = surface_hid_match,
242 	.driver = {
243 		.name = "surface_hid",
244 		.pm = &surface_hid_pm_ops,
245 		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
246 	},
247 };
248 module_ssam_device_driver(surface_hid_driver);
249 
250 MODULE_AUTHOR("Blaž Hrastnik <blaz@mxxn.io>");
251 MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>");
252 MODULE_DESCRIPTION("HID transport driver for Surface System Aggregator Module");
253 MODULE_LICENSE("GPL");
254