1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Copyright (c) 2009, Citrix Systems, Inc. |
4 | * Copyright (c) 2010, Microsoft Corporation. |
5 | * Copyright (c) 2011, Novell Inc. |
6 | */ |
7 | #include <linux/init.h> |
8 | #include <linux/module.h> |
9 | #include <linux/device.h> |
10 | #include <linux/completion.h> |
11 | #include <linux/input.h> |
12 | #include <linux/hid.h> |
13 | #include <linux/hiddev.h> |
14 | #include <linux/hyperv.h> |
15 | |
16 | |
17 | struct hv_input_dev_info { |
18 | unsigned int size; |
19 | unsigned short vendor; |
20 | unsigned short product; |
21 | unsigned short version; |
22 | unsigned short reserved[11]; |
23 | }; |
24 | |
25 | /* |
26 | * Current version |
27 | * |
28 | * History: |
29 | * Beta, RC < 2008/1/22 1,0 |
30 | * RC > 2008/1/22 2,0 |
31 | */ |
32 | #define SYNTHHID_INPUT_VERSION_MAJOR 2 |
33 | #define SYNTHHID_INPUT_VERSION_MINOR 0 |
34 | #define SYNTHHID_INPUT_VERSION (SYNTHHID_INPUT_VERSION_MINOR | \ |
35 | (SYNTHHID_INPUT_VERSION_MAJOR << 16)) |
36 | |
37 | |
38 | #pragma pack(push, 1) |
39 | /* |
40 | * Message types in the synthetic input protocol |
41 | */ |
42 | enum synthhid_msg_type { |
43 | SYNTH_HID_PROTOCOL_REQUEST, |
44 | SYNTH_HID_PROTOCOL_RESPONSE, |
45 | SYNTH_HID_INITIAL_DEVICE_INFO, |
46 | SYNTH_HID_INITIAL_DEVICE_INFO_ACK, |
47 | SYNTH_HID_INPUT_REPORT, |
48 | SYNTH_HID_MAX |
49 | }; |
50 | |
51 | /* |
52 | * Basic message structures. |
53 | */ |
54 | struct synthhid_msg_hdr { |
55 | enum synthhid_msg_type type; |
56 | u32 size; |
57 | }; |
58 | |
59 | union synthhid_version { |
60 | struct { |
61 | u16 minor_version; |
62 | u16 major_version; |
63 | }; |
64 | u32 version; |
65 | }; |
66 | |
67 | /* |
68 | * Protocol messages |
69 | */ |
70 | struct synthhid_protocol_request { |
71 | struct synthhid_msg_hdr ; |
72 | union synthhid_version version_requested; |
73 | }; |
74 | |
75 | struct synthhid_protocol_response { |
76 | struct synthhid_msg_hdr ; |
77 | union synthhid_version version_requested; |
78 | unsigned char approved; |
79 | }; |
80 | |
81 | struct synthhid_device_info { |
82 | struct synthhid_msg_hdr ; |
83 | struct hv_input_dev_info hid_dev_info; |
84 | struct hid_descriptor hid_descriptor; |
85 | }; |
86 | |
87 | struct synthhid_device_info_ack { |
88 | struct synthhid_msg_hdr ; |
89 | unsigned char reserved; |
90 | }; |
91 | |
92 | struct synthhid_input_report { |
93 | struct synthhid_msg_hdr ; |
94 | char buffer[]; |
95 | }; |
96 | |
97 | #pragma pack(pop) |
98 | |
99 | #define INPUTVSC_SEND_RING_BUFFER_SIZE VMBUS_RING_SIZE(36 * 1024) |
100 | #define INPUTVSC_RECV_RING_BUFFER_SIZE VMBUS_RING_SIZE(36 * 1024) |
101 | |
102 | |
103 | enum pipe_prot_msg_type { |
104 | PIPE_MESSAGE_INVALID, |
105 | PIPE_MESSAGE_DATA, |
106 | PIPE_MESSAGE_MAXIMUM |
107 | }; |
108 | |
109 | |
110 | struct pipe_prt_msg { |
111 | enum pipe_prot_msg_type type; |
112 | u32 size; |
113 | char data[]; |
114 | }; |
115 | |
116 | struct mousevsc_prt_msg { |
117 | enum pipe_prot_msg_type type; |
118 | u32 size; |
119 | union { |
120 | struct synthhid_protocol_request request; |
121 | struct synthhid_protocol_response response; |
122 | struct synthhid_device_info_ack ack; |
123 | }; |
124 | }; |
125 | |
126 | /* |
127 | * Represents an mousevsc device |
128 | */ |
129 | struct mousevsc_dev { |
130 | struct hv_device *device; |
131 | bool init_complete; |
132 | bool connected; |
133 | struct mousevsc_prt_msg protocol_req; |
134 | struct mousevsc_prt_msg protocol_resp; |
135 | /* Synchronize the request/response if needed */ |
136 | struct completion wait_event; |
137 | int dev_info_status; |
138 | |
139 | struct hid_descriptor *hid_desc; |
140 | unsigned char *report_desc; |
141 | u32 report_desc_size; |
142 | struct hv_input_dev_info hid_dev_info; |
143 | struct hid_device *hid_device; |
144 | u8 input_buf[HID_MAX_BUFFER_SIZE]; |
145 | }; |
146 | |
147 | |
148 | static struct mousevsc_dev *mousevsc_alloc_device(struct hv_device *device) |
149 | { |
150 | struct mousevsc_dev *input_dev; |
151 | |
152 | input_dev = kzalloc(size: sizeof(struct mousevsc_dev), GFP_KERNEL); |
153 | |
154 | if (!input_dev) |
155 | return NULL; |
156 | |
157 | input_dev->device = device; |
158 | hv_set_drvdata(dev: device, data: input_dev); |
159 | init_completion(x: &input_dev->wait_event); |
160 | input_dev->init_complete = false; |
161 | |
162 | return input_dev; |
163 | } |
164 | |
165 | static void mousevsc_free_device(struct mousevsc_dev *device) |
166 | { |
167 | kfree(objp: device->hid_desc); |
168 | kfree(objp: device->report_desc); |
169 | hv_set_drvdata(dev: device->device, NULL); |
170 | kfree(objp: device); |
171 | } |
172 | |
173 | static void mousevsc_on_receive_device_info(struct mousevsc_dev *input_device, |
174 | struct synthhid_device_info *device_info) |
175 | { |
176 | int ret = 0; |
177 | struct hid_descriptor *desc; |
178 | struct mousevsc_prt_msg ack; |
179 | |
180 | input_device->dev_info_status = -ENOMEM; |
181 | |
182 | input_device->hid_dev_info = device_info->hid_dev_info; |
183 | desc = &device_info->hid_descriptor; |
184 | if (desc->bLength == 0) |
185 | goto cleanup; |
186 | |
187 | /* The pointer is not NULL when we resume from hibernation */ |
188 | kfree(objp: input_device->hid_desc); |
189 | input_device->hid_desc = kmemdup(p: desc, size: desc->bLength, GFP_ATOMIC); |
190 | |
191 | if (!input_device->hid_desc) |
192 | goto cleanup; |
193 | |
194 | input_device->report_desc_size = le16_to_cpu( |
195 | desc->desc[0].wDescriptorLength); |
196 | if (input_device->report_desc_size == 0) { |
197 | input_device->dev_info_status = -EINVAL; |
198 | goto cleanup; |
199 | } |
200 | |
201 | /* The pointer is not NULL when we resume from hibernation */ |
202 | kfree(objp: input_device->report_desc); |
203 | input_device->report_desc = kzalloc(size: input_device->report_desc_size, |
204 | GFP_ATOMIC); |
205 | |
206 | if (!input_device->report_desc) { |
207 | input_device->dev_info_status = -ENOMEM; |
208 | goto cleanup; |
209 | } |
210 | |
211 | memcpy(input_device->report_desc, |
212 | ((unsigned char *)desc) + desc->bLength, |
213 | le16_to_cpu(desc->desc[0].wDescriptorLength)); |
214 | |
215 | /* Send the ack */ |
216 | memset(&ack, 0, sizeof(struct mousevsc_prt_msg)); |
217 | |
218 | ack.type = PIPE_MESSAGE_DATA; |
219 | ack.size = sizeof(struct synthhid_device_info_ack); |
220 | |
221 | ack.ack.header.type = SYNTH_HID_INITIAL_DEVICE_INFO_ACK; |
222 | ack.ack.header.size = 1; |
223 | ack.ack.reserved = 0; |
224 | |
225 | ret = vmbus_sendpacket(channel: input_device->device->channel, |
226 | buffer: &ack, |
227 | bufferLen: sizeof(struct pipe_prt_msg) + |
228 | sizeof(struct synthhid_device_info_ack), |
229 | requestid: (unsigned long)&ack, |
230 | type: VM_PKT_DATA_INBAND, |
231 | VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED); |
232 | |
233 | if (!ret) |
234 | input_device->dev_info_status = 0; |
235 | |
236 | cleanup: |
237 | complete(&input_device->wait_event); |
238 | |
239 | return; |
240 | } |
241 | |
242 | static void mousevsc_on_receive(struct hv_device *device, |
243 | struct vmpacket_descriptor *packet) |
244 | { |
245 | struct pipe_prt_msg *pipe_msg; |
246 | struct synthhid_msg_hdr *hid_msg_hdr; |
247 | struct mousevsc_dev *input_dev = hv_get_drvdata(dev: device); |
248 | struct synthhid_input_report *input_report; |
249 | size_t len; |
250 | |
251 | pipe_msg = (struct pipe_prt_msg *)((unsigned long)packet + |
252 | (packet->offset8 << 3)); |
253 | |
254 | if (pipe_msg->type != PIPE_MESSAGE_DATA) |
255 | return; |
256 | |
257 | hid_msg_hdr = (struct synthhid_msg_hdr *)pipe_msg->data; |
258 | |
259 | switch (hid_msg_hdr->type) { |
260 | case SYNTH_HID_PROTOCOL_RESPONSE: |
261 | len = struct_size(pipe_msg, data, pipe_msg->size); |
262 | |
263 | /* |
264 | * While it will be impossible for us to protect against |
265 | * malicious/buggy hypervisor/host, add a check here to |
266 | * ensure we don't corrupt memory. |
267 | */ |
268 | if (WARN_ON(len > sizeof(struct mousevsc_prt_msg))) |
269 | break; |
270 | |
271 | memcpy(&input_dev->protocol_resp, pipe_msg, len); |
272 | complete(&input_dev->wait_event); |
273 | break; |
274 | |
275 | case SYNTH_HID_INITIAL_DEVICE_INFO: |
276 | WARN_ON(pipe_msg->size < sizeof(struct hv_input_dev_info)); |
277 | |
278 | /* |
279 | * Parse out the device info into device attr, |
280 | * hid desc and report desc |
281 | */ |
282 | mousevsc_on_receive_device_info(input_device: input_dev, |
283 | device_info: (struct synthhid_device_info *)pipe_msg->data); |
284 | break; |
285 | case SYNTH_HID_INPUT_REPORT: |
286 | input_report = |
287 | (struct synthhid_input_report *)pipe_msg->data; |
288 | if (!input_dev->init_complete) |
289 | break; |
290 | |
291 | len = min(input_report->header.size, |
292 | (u32)sizeof(input_dev->input_buf)); |
293 | memcpy(input_dev->input_buf, input_report->buffer, len); |
294 | hid_input_report(hid: input_dev->hid_device, type: HID_INPUT_REPORT, |
295 | data: input_dev->input_buf, size: len, interrupt: 1); |
296 | |
297 | pm_wakeup_hard_event(dev: &input_dev->device->device); |
298 | |
299 | break; |
300 | default: |
301 | pr_err("unsupported hid msg type - type %d len %d\n" , |
302 | hid_msg_hdr->type, hid_msg_hdr->size); |
303 | break; |
304 | } |
305 | |
306 | } |
307 | |
308 | static void mousevsc_on_channel_callback(void *context) |
309 | { |
310 | struct hv_device *device = context; |
311 | struct vmpacket_descriptor *desc; |
312 | |
313 | foreach_vmbus_pkt(desc, device->channel) { |
314 | switch (desc->type) { |
315 | case VM_PKT_COMP: |
316 | break; |
317 | |
318 | case VM_PKT_DATA_INBAND: |
319 | mousevsc_on_receive(device, packet: desc); |
320 | break; |
321 | |
322 | default: |
323 | pr_err("Unhandled packet type %d, tid %llx len %d\n" , |
324 | desc->type, desc->trans_id, desc->len8 * 8); |
325 | break; |
326 | } |
327 | } |
328 | } |
329 | |
330 | static int mousevsc_connect_to_vsp(struct hv_device *device) |
331 | { |
332 | int ret = 0; |
333 | unsigned long t; |
334 | struct mousevsc_dev *input_dev = hv_get_drvdata(dev: device); |
335 | struct mousevsc_prt_msg *request; |
336 | struct mousevsc_prt_msg *response; |
337 | |
338 | reinit_completion(x: &input_dev->wait_event); |
339 | |
340 | request = &input_dev->protocol_req; |
341 | memset(request, 0, sizeof(struct mousevsc_prt_msg)); |
342 | |
343 | request->type = PIPE_MESSAGE_DATA; |
344 | request->size = sizeof(struct synthhid_protocol_request); |
345 | request->request.header.type = SYNTH_HID_PROTOCOL_REQUEST; |
346 | request->request.header.size = sizeof(unsigned int); |
347 | request->request.version_requested.version = SYNTHHID_INPUT_VERSION; |
348 | |
349 | ret = vmbus_sendpacket(channel: device->channel, buffer: request, |
350 | bufferLen: sizeof(struct pipe_prt_msg) + |
351 | sizeof(struct synthhid_protocol_request), |
352 | requestid: (unsigned long)request, |
353 | type: VM_PKT_DATA_INBAND, |
354 | VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED); |
355 | if (ret) |
356 | goto cleanup; |
357 | |
358 | t = wait_for_completion_timeout(x: &input_dev->wait_event, timeout: 5*HZ); |
359 | if (!t) { |
360 | ret = -ETIMEDOUT; |
361 | goto cleanup; |
362 | } |
363 | |
364 | response = &input_dev->protocol_resp; |
365 | |
366 | if (!response->response.approved) { |
367 | pr_err("synthhid protocol request failed (version %d)\n" , |
368 | SYNTHHID_INPUT_VERSION); |
369 | ret = -ENODEV; |
370 | goto cleanup; |
371 | } |
372 | |
373 | t = wait_for_completion_timeout(x: &input_dev->wait_event, timeout: 5*HZ); |
374 | if (!t) { |
375 | ret = -ETIMEDOUT; |
376 | goto cleanup; |
377 | } |
378 | |
379 | /* |
380 | * We should have gotten the device attr, hid desc and report |
381 | * desc at this point |
382 | */ |
383 | ret = input_dev->dev_info_status; |
384 | |
385 | cleanup: |
386 | return ret; |
387 | } |
388 | |
389 | static int mousevsc_hid_parse(struct hid_device *hid) |
390 | { |
391 | struct hv_device *dev = hid_get_drvdata(hdev: hid); |
392 | struct mousevsc_dev *input_dev = hv_get_drvdata(dev); |
393 | |
394 | return hid_parse_report(hid, start: input_dev->report_desc, |
395 | size: input_dev->report_desc_size); |
396 | } |
397 | |
398 | static int mousevsc_hid_open(struct hid_device *hid) |
399 | { |
400 | return 0; |
401 | } |
402 | |
403 | static int mousevsc_hid_start(struct hid_device *hid) |
404 | { |
405 | return 0; |
406 | } |
407 | |
408 | static void mousevsc_hid_close(struct hid_device *hid) |
409 | { |
410 | } |
411 | |
412 | static void mousevsc_hid_stop(struct hid_device *hid) |
413 | { |
414 | } |
415 | |
416 | static int mousevsc_hid_raw_request(struct hid_device *hid, |
417 | unsigned char report_num, |
418 | __u8 *buf, size_t len, |
419 | unsigned char rtype, |
420 | int reqtype) |
421 | { |
422 | return 0; |
423 | } |
424 | |
425 | static const struct hid_ll_driver mousevsc_ll_driver = { |
426 | .parse = mousevsc_hid_parse, |
427 | .open = mousevsc_hid_open, |
428 | .close = mousevsc_hid_close, |
429 | .start = mousevsc_hid_start, |
430 | .stop = mousevsc_hid_stop, |
431 | .raw_request = mousevsc_hid_raw_request, |
432 | }; |
433 | |
434 | static struct hid_driver mousevsc_hid_driver; |
435 | |
436 | static int mousevsc_probe(struct hv_device *device, |
437 | const struct hv_vmbus_device_id *dev_id) |
438 | { |
439 | int ret; |
440 | struct mousevsc_dev *input_dev; |
441 | struct hid_device *hid_dev; |
442 | |
443 | input_dev = mousevsc_alloc_device(device); |
444 | |
445 | if (!input_dev) |
446 | return -ENOMEM; |
447 | |
448 | ret = vmbus_open(channel: device->channel, |
449 | INPUTVSC_SEND_RING_BUFFER_SIZE, |
450 | INPUTVSC_RECV_RING_BUFFER_SIZE, |
451 | NULL, |
452 | userdatalen: 0, |
453 | onchannel_callback: mousevsc_on_channel_callback, |
454 | context: device |
455 | ); |
456 | |
457 | if (ret) |
458 | goto probe_err0; |
459 | |
460 | ret = mousevsc_connect_to_vsp(device); |
461 | |
462 | if (ret) |
463 | goto probe_err1; |
464 | |
465 | /* workaround SA-167 */ |
466 | if (input_dev->report_desc[14] == 0x25) |
467 | input_dev->report_desc[14] = 0x29; |
468 | |
469 | hid_dev = hid_allocate_device(); |
470 | if (IS_ERR(ptr: hid_dev)) { |
471 | ret = PTR_ERR(ptr: hid_dev); |
472 | goto probe_err1; |
473 | } |
474 | |
475 | hid_dev->ll_driver = &mousevsc_ll_driver; |
476 | hid_dev->driver = &mousevsc_hid_driver; |
477 | hid_dev->bus = BUS_VIRTUAL; |
478 | hid_dev->vendor = input_dev->hid_dev_info.vendor; |
479 | hid_dev->product = input_dev->hid_dev_info.product; |
480 | hid_dev->version = input_dev->hid_dev_info.version; |
481 | input_dev->hid_device = hid_dev; |
482 | |
483 | sprintf(buf: hid_dev->name, fmt: "%s" , "Microsoft Vmbus HID-compliant Mouse" ); |
484 | |
485 | hid_set_drvdata(hdev: hid_dev, data: device); |
486 | |
487 | ret = hid_add_device(hid_dev); |
488 | if (ret) |
489 | goto probe_err2; |
490 | |
491 | |
492 | ret = hid_parse(hdev: hid_dev); |
493 | if (ret) { |
494 | hid_err(hid_dev, "parse failed\n" ); |
495 | goto probe_err2; |
496 | } |
497 | |
498 | ret = hid_hw_start(hdev: hid_dev, HID_CONNECT_HIDINPUT | HID_CONNECT_HIDDEV); |
499 | |
500 | if (ret) { |
501 | hid_err(hid_dev, "hw start failed\n" ); |
502 | goto probe_err2; |
503 | } |
504 | |
505 | device_init_wakeup(dev: &device->device, enable: true); |
506 | |
507 | input_dev->connected = true; |
508 | input_dev->init_complete = true; |
509 | |
510 | return ret; |
511 | |
512 | probe_err2: |
513 | hid_destroy_device(hid_dev); |
514 | |
515 | probe_err1: |
516 | vmbus_close(channel: device->channel); |
517 | |
518 | probe_err0: |
519 | mousevsc_free_device(device: input_dev); |
520 | |
521 | return ret; |
522 | } |
523 | |
524 | |
525 | static void mousevsc_remove(struct hv_device *dev) |
526 | { |
527 | struct mousevsc_dev *input_dev = hv_get_drvdata(dev); |
528 | |
529 | device_init_wakeup(dev: &dev->device, enable: false); |
530 | vmbus_close(channel: dev->channel); |
531 | hid_hw_stop(hdev: input_dev->hid_device); |
532 | hid_destroy_device(input_dev->hid_device); |
533 | mousevsc_free_device(device: input_dev); |
534 | } |
535 | |
536 | static int mousevsc_suspend(struct hv_device *dev) |
537 | { |
538 | vmbus_close(channel: dev->channel); |
539 | |
540 | return 0; |
541 | } |
542 | |
543 | static int mousevsc_resume(struct hv_device *dev) |
544 | { |
545 | int ret; |
546 | |
547 | ret = vmbus_open(channel: dev->channel, |
548 | INPUTVSC_SEND_RING_BUFFER_SIZE, |
549 | INPUTVSC_RECV_RING_BUFFER_SIZE, |
550 | NULL, userdatalen: 0, |
551 | onchannel_callback: mousevsc_on_channel_callback, |
552 | context: dev); |
553 | if (ret) |
554 | return ret; |
555 | |
556 | ret = mousevsc_connect_to_vsp(device: dev); |
557 | return ret; |
558 | } |
559 | |
560 | static const struct hv_vmbus_device_id id_table[] = { |
561 | /* Mouse guid */ |
562 | { HV_MOUSE_GUID, }, |
563 | { }, |
564 | }; |
565 | |
566 | MODULE_DEVICE_TABLE(vmbus, id_table); |
567 | |
568 | static struct hv_driver mousevsc_drv = { |
569 | .name = KBUILD_MODNAME, |
570 | .id_table = id_table, |
571 | .probe = mousevsc_probe, |
572 | .remove = mousevsc_remove, |
573 | .suspend = mousevsc_suspend, |
574 | .resume = mousevsc_resume, |
575 | .driver = { |
576 | .probe_type = PROBE_PREFER_ASYNCHRONOUS, |
577 | }, |
578 | }; |
579 | |
580 | static int __init mousevsc_init(void) |
581 | { |
582 | return vmbus_driver_register(&mousevsc_drv); |
583 | } |
584 | |
585 | static void __exit mousevsc_exit(void) |
586 | { |
587 | vmbus_driver_unregister(hv_driver: &mousevsc_drv); |
588 | } |
589 | |
590 | MODULE_LICENSE("GPL" ); |
591 | MODULE_DESCRIPTION("Microsoft Hyper-V Synthetic HID Driver" ); |
592 | |
593 | module_init(mousevsc_init); |
594 | module_exit(mousevsc_exit); |
595 | |