1 | /* |
2 | * Xen para-virtual input device |
3 | * |
4 | * Copyright (C) 2005 Anthony Liguori <aliguori@us.ibm.com> |
5 | * Copyright (C) 2006-2008 Red Hat, Inc., Markus Armbruster <armbru@redhat.com> |
6 | * |
7 | * Based on linux/drivers/input/mouse/sermouse.c |
8 | * |
9 | * This file is subject to the terms and conditions of the GNU General Public |
10 | * License. See the file COPYING in the main directory of this archive for |
11 | * more details. |
12 | */ |
13 | |
14 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
15 | |
16 | #include <linux/kernel.h> |
17 | #include <linux/errno.h> |
18 | #include <linux/module.h> |
19 | #include <linux/input.h> |
20 | #include <linux/input/mt.h> |
21 | #include <linux/slab.h> |
22 | |
23 | #include <asm/xen/hypervisor.h> |
24 | |
25 | #include <xen/xen.h> |
26 | #include <xen/events.h> |
27 | #include <xen/page.h> |
28 | #include <xen/grant_table.h> |
29 | #include <xen/interface/grant_table.h> |
30 | #include <xen/interface/io/fbif.h> |
31 | #include <xen/interface/io/kbdif.h> |
32 | #include <xen/xenbus.h> |
33 | #include <xen/platform_pci.h> |
34 | |
35 | struct xenkbd_info { |
36 | struct input_dev *kbd; |
37 | struct input_dev *ptr; |
38 | struct input_dev *mtouch; |
39 | struct xenkbd_page *page; |
40 | int gref; |
41 | int irq; |
42 | struct xenbus_device *xbdev; |
43 | char phys[32]; |
44 | /* current MT slot/contact ID we are injecting events in */ |
45 | int mtouch_cur_contact_id; |
46 | }; |
47 | |
48 | enum { KPARAM_X, KPARAM_Y, KPARAM_CNT }; |
49 | static int ptr_size[KPARAM_CNT] = { XENFB_WIDTH, XENFB_HEIGHT }; |
50 | module_param_array(ptr_size, int, NULL, 0444); |
51 | MODULE_PARM_DESC(ptr_size, |
52 | "Pointing device width, height in pixels (default 800,600)" ); |
53 | |
54 | static void xenkbd_remove(struct xenbus_device *); |
55 | static int xenkbd_connect_backend(struct xenbus_device *, struct xenkbd_info *); |
56 | static void xenkbd_disconnect_backend(struct xenkbd_info *); |
57 | |
58 | /* |
59 | * Note: if you need to send out events, see xenfb_do_update() for how |
60 | * to do that. |
61 | */ |
62 | |
63 | static void xenkbd_handle_motion_event(struct xenkbd_info *info, |
64 | struct xenkbd_motion *motion) |
65 | { |
66 | if (unlikely(!info->ptr)) |
67 | return; |
68 | |
69 | input_report_rel(dev: info->ptr, REL_X, value: motion->rel_x); |
70 | input_report_rel(dev: info->ptr, REL_Y, value: motion->rel_y); |
71 | if (motion->rel_z) |
72 | input_report_rel(dev: info->ptr, REL_WHEEL, value: -motion->rel_z); |
73 | input_sync(dev: info->ptr); |
74 | } |
75 | |
76 | static void xenkbd_handle_position_event(struct xenkbd_info *info, |
77 | struct xenkbd_position *pos) |
78 | { |
79 | if (unlikely(!info->ptr)) |
80 | return; |
81 | |
82 | input_report_abs(dev: info->ptr, ABS_X, value: pos->abs_x); |
83 | input_report_abs(dev: info->ptr, ABS_Y, value: pos->abs_y); |
84 | if (pos->rel_z) |
85 | input_report_rel(dev: info->ptr, REL_WHEEL, value: -pos->rel_z); |
86 | input_sync(dev: info->ptr); |
87 | } |
88 | |
89 | static void xenkbd_handle_key_event(struct xenkbd_info *info, |
90 | struct xenkbd_key *key) |
91 | { |
92 | struct input_dev *dev; |
93 | int value = key->pressed; |
94 | |
95 | if (test_bit(key->keycode, info->ptr->keybit)) { |
96 | dev = info->ptr; |
97 | } else if (test_bit(key->keycode, info->kbd->keybit)) { |
98 | dev = info->kbd; |
99 | if (key->pressed && test_bit(key->keycode, info->kbd->key)) |
100 | value = 2; /* Mark as autorepeat */ |
101 | } else { |
102 | pr_warn("unhandled keycode 0x%x\n" , key->keycode); |
103 | return; |
104 | } |
105 | |
106 | if (unlikely(!dev)) |
107 | return; |
108 | |
109 | input_event(dev, EV_KEY, code: key->keycode, value); |
110 | input_sync(dev); |
111 | } |
112 | |
113 | static void xenkbd_handle_mt_event(struct xenkbd_info *info, |
114 | struct xenkbd_mtouch *mtouch) |
115 | { |
116 | if (unlikely(!info->mtouch)) |
117 | return; |
118 | |
119 | if (mtouch->contact_id != info->mtouch_cur_contact_id) { |
120 | info->mtouch_cur_contact_id = mtouch->contact_id; |
121 | input_mt_slot(dev: info->mtouch, slot: mtouch->contact_id); |
122 | } |
123 | |
124 | switch (mtouch->event_type) { |
125 | case XENKBD_MT_EV_DOWN: |
126 | input_mt_report_slot_state(dev: info->mtouch, MT_TOOL_FINGER, active: true); |
127 | fallthrough; |
128 | |
129 | case XENKBD_MT_EV_MOTION: |
130 | input_report_abs(dev: info->mtouch, ABS_MT_POSITION_X, |
131 | value: mtouch->u.pos.abs_x); |
132 | input_report_abs(dev: info->mtouch, ABS_MT_POSITION_Y, |
133 | value: mtouch->u.pos.abs_y); |
134 | break; |
135 | |
136 | case XENKBD_MT_EV_SHAPE: |
137 | input_report_abs(dev: info->mtouch, ABS_MT_TOUCH_MAJOR, |
138 | value: mtouch->u.shape.major); |
139 | input_report_abs(dev: info->mtouch, ABS_MT_TOUCH_MINOR, |
140 | value: mtouch->u.shape.minor); |
141 | break; |
142 | |
143 | case XENKBD_MT_EV_ORIENT: |
144 | input_report_abs(dev: info->mtouch, ABS_MT_ORIENTATION, |
145 | value: mtouch->u.orientation); |
146 | break; |
147 | |
148 | case XENKBD_MT_EV_UP: |
149 | input_mt_report_slot_inactive(dev: info->mtouch); |
150 | break; |
151 | |
152 | case XENKBD_MT_EV_SYN: |
153 | input_mt_sync_frame(dev: info->mtouch); |
154 | input_sync(dev: info->mtouch); |
155 | break; |
156 | } |
157 | } |
158 | |
159 | static void xenkbd_handle_event(struct xenkbd_info *info, |
160 | union xenkbd_in_event *event) |
161 | { |
162 | switch (event->type) { |
163 | case XENKBD_TYPE_MOTION: |
164 | xenkbd_handle_motion_event(info, motion: &event->motion); |
165 | break; |
166 | |
167 | case XENKBD_TYPE_KEY: |
168 | xenkbd_handle_key_event(info, key: &event->key); |
169 | break; |
170 | |
171 | case XENKBD_TYPE_POS: |
172 | xenkbd_handle_position_event(info, pos: &event->pos); |
173 | break; |
174 | |
175 | case XENKBD_TYPE_MTOUCH: |
176 | xenkbd_handle_mt_event(info, mtouch: &event->mtouch); |
177 | break; |
178 | } |
179 | } |
180 | |
181 | static irqreturn_t input_handler(int rq, void *dev_id) |
182 | { |
183 | struct xenkbd_info *info = dev_id; |
184 | struct xenkbd_page *page = info->page; |
185 | __u32 cons, prod; |
186 | |
187 | prod = page->in_prod; |
188 | if (prod == page->in_cons) |
189 | return IRQ_HANDLED; |
190 | rmb(); /* ensure we see ring contents up to prod */ |
191 | for (cons = page->in_cons; cons != prod; cons++) |
192 | xenkbd_handle_event(info, event: &XENKBD_IN_RING_REF(page, cons)); |
193 | mb(); /* ensure we got ring contents */ |
194 | page->in_cons = cons; |
195 | notify_remote_via_irq(irq: info->irq); |
196 | |
197 | return IRQ_HANDLED; |
198 | } |
199 | |
200 | static int xenkbd_probe(struct xenbus_device *dev, |
201 | const struct xenbus_device_id *id) |
202 | { |
203 | int ret, i; |
204 | bool with_mtouch, with_kbd, with_ptr; |
205 | struct xenkbd_info *info; |
206 | struct input_dev *kbd, *ptr, *mtouch; |
207 | |
208 | info = kzalloc(size: sizeof(*info), GFP_KERNEL); |
209 | if (!info) { |
210 | xenbus_dev_fatal(dev, err: -ENOMEM, fmt: "allocating info structure" ); |
211 | return -ENOMEM; |
212 | } |
213 | dev_set_drvdata(dev: &dev->dev, data: info); |
214 | info->xbdev = dev; |
215 | info->irq = -1; |
216 | info->gref = -1; |
217 | snprintf(buf: info->phys, size: sizeof(info->phys), fmt: "xenbus/%s" , dev->nodename); |
218 | |
219 | info->page = (void *)__get_free_page(GFP_KERNEL | __GFP_ZERO); |
220 | if (!info->page) |
221 | goto error_nomem; |
222 | |
223 | /* |
224 | * The below are reverse logic, e.g. if the feature is set, then |
225 | * do not expose the corresponding virtual device. |
226 | */ |
227 | with_kbd = !xenbus_read_unsigned(dir: dev->otherend, |
228 | XENKBD_FIELD_FEAT_DSBL_KEYBRD, default_val: 0); |
229 | |
230 | with_ptr = !xenbus_read_unsigned(dir: dev->otherend, |
231 | XENKBD_FIELD_FEAT_DSBL_POINTER, default_val: 0); |
232 | |
233 | /* Direct logic: if set, then create multi-touch device. */ |
234 | with_mtouch = xenbus_read_unsigned(dir: dev->otherend, |
235 | XENKBD_FIELD_FEAT_MTOUCH, default_val: 0); |
236 | if (with_mtouch) { |
237 | ret = xenbus_write(XBT_NIL, dir: dev->nodename, |
238 | XENKBD_FIELD_REQ_MTOUCH, string: "1" ); |
239 | if (ret) { |
240 | pr_warn("xenkbd: can't request multi-touch" ); |
241 | with_mtouch = 0; |
242 | } |
243 | } |
244 | |
245 | /* keyboard */ |
246 | if (with_kbd) { |
247 | kbd = input_allocate_device(); |
248 | if (!kbd) |
249 | goto error_nomem; |
250 | kbd->name = "Xen Virtual Keyboard" ; |
251 | kbd->phys = info->phys; |
252 | kbd->id.bustype = BUS_PCI; |
253 | kbd->id.vendor = 0x5853; |
254 | kbd->id.product = 0xffff; |
255 | |
256 | __set_bit(EV_KEY, kbd->evbit); |
257 | for (i = KEY_ESC; i < KEY_UNKNOWN; i++) |
258 | __set_bit(i, kbd->keybit); |
259 | for (i = KEY_OK; i < KEY_MAX; i++) |
260 | __set_bit(i, kbd->keybit); |
261 | |
262 | ret = input_register_device(kbd); |
263 | if (ret) { |
264 | input_free_device(kbd); |
265 | xenbus_dev_fatal(dev, ret, |
266 | "input_register_device(kbd)" ); |
267 | goto error; |
268 | } |
269 | info->kbd = kbd; |
270 | } |
271 | |
272 | /* pointing device */ |
273 | if (with_ptr) { |
274 | unsigned int abs; |
275 | |
276 | /* Set input abs params to match backend screen res */ |
277 | abs = xenbus_read_unsigned(dev->otherend, |
278 | XENKBD_FIELD_FEAT_ABS_POINTER, 0); |
279 | ptr_size[KPARAM_X] = xenbus_read_unsigned(dev->otherend, |
280 | XENKBD_FIELD_WIDTH, |
281 | ptr_size[KPARAM_X]); |
282 | ptr_size[KPARAM_Y] = xenbus_read_unsigned(dev->otherend, |
283 | XENKBD_FIELD_HEIGHT, |
284 | ptr_size[KPARAM_Y]); |
285 | if (abs) { |
286 | ret = xenbus_write(XBT_NIL, dev->nodename, |
287 | XENKBD_FIELD_REQ_ABS_POINTER, "1" ); |
288 | if (ret) { |
289 | pr_warn("xenkbd: can't request abs-pointer\n" ); |
290 | abs = 0; |
291 | } |
292 | } |
293 | |
294 | ptr = input_allocate_device(); |
295 | if (!ptr) |
296 | goto error_nomem; |
297 | ptr->name = "Xen Virtual Pointer" ; |
298 | ptr->phys = info->phys; |
299 | ptr->id.bustype = BUS_PCI; |
300 | ptr->id.vendor = 0x5853; |
301 | ptr->id.product = 0xfffe; |
302 | |
303 | if (abs) { |
304 | __set_bit(EV_ABS, ptr->evbit); |
305 | input_set_abs_params(ptr, ABS_X, 0, |
306 | ptr_size[KPARAM_X], 0, 0); |
307 | input_set_abs_params(ptr, ABS_Y, 0, |
308 | ptr_size[KPARAM_Y], 0, 0); |
309 | } else { |
310 | input_set_capability(ptr, EV_REL, REL_X); |
311 | input_set_capability(ptr, EV_REL, REL_Y); |
312 | } |
313 | input_set_capability(ptr, EV_REL, REL_WHEEL); |
314 | |
315 | __set_bit(EV_KEY, ptr->evbit); |
316 | for (i = BTN_LEFT; i <= BTN_TASK; i++) |
317 | __set_bit(i, ptr->keybit); |
318 | |
319 | ret = input_register_device(ptr); |
320 | if (ret) { |
321 | input_free_device(ptr); |
322 | xenbus_dev_fatal(dev, ret, |
323 | "input_register_device(ptr)" ); |
324 | goto error; |
325 | } |
326 | info->ptr = ptr; |
327 | } |
328 | |
329 | /* multi-touch device */ |
330 | if (with_mtouch) { |
331 | int num_cont, width, height; |
332 | |
333 | mtouch = input_allocate_device(); |
334 | if (!mtouch) |
335 | goto error_nomem; |
336 | |
337 | num_cont = xenbus_read_unsigned(info->xbdev->otherend, |
338 | XENKBD_FIELD_MT_NUM_CONTACTS, |
339 | 1); |
340 | width = xenbus_read_unsigned(info->xbdev->otherend, |
341 | XENKBD_FIELD_MT_WIDTH, |
342 | XENFB_WIDTH); |
343 | height = xenbus_read_unsigned(info->xbdev->otherend, |
344 | XENKBD_FIELD_MT_HEIGHT, |
345 | XENFB_HEIGHT); |
346 | |
347 | mtouch->name = "Xen Virtual Multi-touch" ; |
348 | mtouch->phys = info->phys; |
349 | mtouch->id.bustype = BUS_PCI; |
350 | mtouch->id.vendor = 0x5853; |
351 | mtouch->id.product = 0xfffd; |
352 | |
353 | input_set_abs_params(mtouch, ABS_MT_TOUCH_MAJOR, |
354 | 0, 255, 0, 0); |
355 | input_set_abs_params(mtouch, ABS_MT_POSITION_X, |
356 | 0, width, 0, 0); |
357 | input_set_abs_params(mtouch, ABS_MT_POSITION_Y, |
358 | 0, height, 0, 0); |
359 | |
360 | ret = input_mt_init_slots(mtouch, num_cont, INPUT_MT_DIRECT); |
361 | if (ret) { |
362 | input_free_device(mtouch); |
363 | xenbus_dev_fatal(info->xbdev, ret, |
364 | "input_mt_init_slots" ); |
365 | goto error; |
366 | } |
367 | |
368 | ret = input_register_device(mtouch); |
369 | if (ret) { |
370 | input_free_device(mtouch); |
371 | xenbus_dev_fatal(info->xbdev, ret, |
372 | "input_register_device(mtouch)" ); |
373 | goto error; |
374 | } |
375 | info->mtouch_cur_contact_id = -1; |
376 | info->mtouch = mtouch; |
377 | } |
378 | |
379 | if (!(with_kbd || with_ptr || with_mtouch)) { |
380 | ret = -ENXIO; |
381 | goto error; |
382 | } |
383 | |
384 | ret = xenkbd_connect_backend(dev, info); |
385 | if (ret < 0) |
386 | goto error; |
387 | |
388 | return 0; |
389 | |
390 | error_nomem: |
391 | ret = -ENOMEM; |
392 | xenbus_dev_fatal(dev, ret, "allocating device memory" ); |
393 | error: |
394 | xenkbd_remove(dev); |
395 | return ret; |
396 | } |
397 | |
398 | static int xenkbd_resume(struct xenbus_device *dev) |
399 | { |
400 | struct xenkbd_info *info = dev_get_drvdata(dev: &dev->dev); |
401 | |
402 | xenkbd_disconnect_backend(info); |
403 | memset(info->page, 0, PAGE_SIZE); |
404 | return xenkbd_connect_backend(dev, info); |
405 | } |
406 | |
407 | static void xenkbd_remove(struct xenbus_device *dev) |
408 | { |
409 | struct xenkbd_info *info = dev_get_drvdata(dev: &dev->dev); |
410 | |
411 | xenkbd_disconnect_backend(info); |
412 | if (info->kbd) |
413 | input_unregister_device(info->kbd); |
414 | if (info->ptr) |
415 | input_unregister_device(info->ptr); |
416 | if (info->mtouch) |
417 | input_unregister_device(info->mtouch); |
418 | free_page((unsigned long)info->page); |
419 | kfree(objp: info); |
420 | } |
421 | |
422 | static int xenkbd_connect_backend(struct xenbus_device *dev, |
423 | struct xenkbd_info *info) |
424 | { |
425 | int ret, evtchn; |
426 | struct xenbus_transaction xbt; |
427 | |
428 | ret = gnttab_grant_foreign_access(domid: dev->otherend_id, |
429 | virt_to_gfn(info->page), readonly: 0); |
430 | if (ret < 0) |
431 | return ret; |
432 | info->gref = ret; |
433 | |
434 | ret = xenbus_alloc_evtchn(dev, port: &evtchn); |
435 | if (ret) |
436 | goto error_grant; |
437 | ret = bind_evtchn_to_irqhandler(evtchn, handler: input_handler, |
438 | irqflags: 0, devname: dev->devicetype, dev_id: info); |
439 | if (ret < 0) { |
440 | xenbus_dev_fatal(dev, err: ret, fmt: "bind_evtchn_to_irqhandler" ); |
441 | goto error_evtchan; |
442 | } |
443 | info->irq = ret; |
444 | |
445 | again: |
446 | ret = xenbus_transaction_start(t: &xbt); |
447 | if (ret) { |
448 | xenbus_dev_fatal(dev, err: ret, fmt: "starting transaction" ); |
449 | goto error_irqh; |
450 | } |
451 | ret = xenbus_printf(t: xbt, dir: dev->nodename, XENKBD_FIELD_RING_REF, fmt: "%lu" , |
452 | virt_to_gfn(info->page)); |
453 | if (ret) |
454 | goto error_xenbus; |
455 | ret = xenbus_printf(t: xbt, dir: dev->nodename, XENKBD_FIELD_RING_GREF, |
456 | fmt: "%u" , info->gref); |
457 | if (ret) |
458 | goto error_xenbus; |
459 | ret = xenbus_printf(t: xbt, dir: dev->nodename, XENKBD_FIELD_EVT_CHANNEL, fmt: "%u" , |
460 | evtchn); |
461 | if (ret) |
462 | goto error_xenbus; |
463 | ret = xenbus_transaction_end(t: xbt, abort: 0); |
464 | if (ret) { |
465 | if (ret == -EAGAIN) |
466 | goto again; |
467 | xenbus_dev_fatal(dev, err: ret, fmt: "completing transaction" ); |
468 | goto error_irqh; |
469 | } |
470 | |
471 | xenbus_switch_state(dev, new_state: XenbusStateInitialised); |
472 | return 0; |
473 | |
474 | error_xenbus: |
475 | xenbus_transaction_end(t: xbt, abort: 1); |
476 | xenbus_dev_fatal(dev, err: ret, fmt: "writing xenstore" ); |
477 | error_irqh: |
478 | unbind_from_irqhandler(irq: info->irq, dev_id: info); |
479 | info->irq = -1; |
480 | error_evtchan: |
481 | xenbus_free_evtchn(dev, port: evtchn); |
482 | error_grant: |
483 | gnttab_end_foreign_access(ref: info->gref, NULL); |
484 | info->gref = -1; |
485 | return ret; |
486 | } |
487 | |
488 | static void xenkbd_disconnect_backend(struct xenkbd_info *info) |
489 | { |
490 | if (info->irq >= 0) |
491 | unbind_from_irqhandler(irq: info->irq, dev_id: info); |
492 | info->irq = -1; |
493 | if (info->gref >= 0) |
494 | gnttab_end_foreign_access(ref: info->gref, NULL); |
495 | info->gref = -1; |
496 | } |
497 | |
498 | static void xenkbd_backend_changed(struct xenbus_device *dev, |
499 | enum xenbus_state backend_state) |
500 | { |
501 | switch (backend_state) { |
502 | case XenbusStateInitialising: |
503 | case XenbusStateInitialised: |
504 | case XenbusStateReconfiguring: |
505 | case XenbusStateReconfigured: |
506 | case XenbusStateUnknown: |
507 | break; |
508 | |
509 | case XenbusStateInitWait: |
510 | xenbus_switch_state(dev, new_state: XenbusStateConnected); |
511 | break; |
512 | |
513 | case XenbusStateConnected: |
514 | /* |
515 | * Work around xenbus race condition: If backend goes |
516 | * through InitWait to Connected fast enough, we can |
517 | * get Connected twice here. |
518 | */ |
519 | if (dev->state != XenbusStateConnected) |
520 | xenbus_switch_state(dev, new_state: XenbusStateConnected); |
521 | break; |
522 | |
523 | case XenbusStateClosed: |
524 | if (dev->state == XenbusStateClosed) |
525 | break; |
526 | fallthrough; /* Missed the backend's CLOSING state */ |
527 | case XenbusStateClosing: |
528 | xenbus_frontend_closed(dev); |
529 | break; |
530 | } |
531 | } |
532 | |
533 | static const struct xenbus_device_id xenkbd_ids[] = { |
534 | { XENKBD_DRIVER_NAME }, |
535 | { "" } |
536 | }; |
537 | |
538 | static struct xenbus_driver xenkbd_driver = { |
539 | .ids = xenkbd_ids, |
540 | .probe = xenkbd_probe, |
541 | .remove = xenkbd_remove, |
542 | .resume = xenkbd_resume, |
543 | .otherend_changed = xenkbd_backend_changed, |
544 | .not_essential = true, |
545 | }; |
546 | |
547 | static int __init xenkbd_init(void) |
548 | { |
549 | if (!xen_domain()) |
550 | return -ENODEV; |
551 | |
552 | /* Nothing to do if running in dom0. */ |
553 | if (xen_initial_domain()) |
554 | return -ENODEV; |
555 | |
556 | if (!xen_has_pv_devices()) |
557 | return -ENODEV; |
558 | |
559 | return xenbus_register_frontend(&xenkbd_driver); |
560 | } |
561 | |
562 | static void __exit xenkbd_cleanup(void) |
563 | { |
564 | xenbus_unregister_driver(drv: &xenkbd_driver); |
565 | } |
566 | |
567 | module_init(xenkbd_init); |
568 | module_exit(xenkbd_cleanup); |
569 | |
570 | MODULE_DESCRIPTION("Xen virtual keyboard/pointer device frontend" ); |
571 | MODULE_LICENSE("GPL" ); |
572 | MODULE_ALIAS("xen:" XENKBD_DRIVER_NAME); |
573 | |