2 * Xen para-virtual input device
4 * Copyright (C) 2005 Anthony Liguori <aliguori@us.ibm.com>
5 * Copyright (C) 2006-2008 Red Hat, Inc., Markus Armbruster <armbru@redhat.com>
7 * Based on linux/drivers/input/mouse/sermouse.c
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
14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
23 #include <asm/xen/hypervisor.h>
26 #include <xen/events.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>
36 struct input_dev *kbd;
37 struct input_dev *ptr;
38 struct input_dev *mtouch;
39 struct xenkbd_page *page;
42 struct xenbus_device *xbdev;
44 /* current MT slot/contact ID we are injecting events in */
45 int mtouch_cur_contact_id;
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)");
54 static int 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 *);
59 * Note: if you need to send out events, see xenfb_do_update() for how
63 static void xenkbd_handle_motion_event(struct xenkbd_info *info,
64 struct xenkbd_motion *motion)
66 input_report_rel(info->ptr, REL_X, motion->rel_x);
67 input_report_rel(info->ptr, REL_Y, motion->rel_y);
69 input_report_rel(info->ptr, REL_WHEEL, -motion->rel_z);
70 input_sync(info->ptr);
73 static void xenkbd_handle_position_event(struct xenkbd_info *info,
74 struct xenkbd_position *pos)
76 input_report_abs(info->ptr, ABS_X, pos->abs_x);
77 input_report_abs(info->ptr, ABS_Y, pos->abs_y);
79 input_report_rel(info->ptr, REL_WHEEL, -pos->rel_z);
80 input_sync(info->ptr);
83 static void xenkbd_handle_key_event(struct xenkbd_info *info,
84 struct xenkbd_key *key)
86 struct input_dev *dev;
88 if (test_bit(key->keycode, info->ptr->keybit)) {
90 } else if (test_bit(key->keycode, info->kbd->keybit)) {
93 pr_warn("unhandled keycode 0x%x\n", key->keycode);
97 input_report_key(dev, key->keycode, key->pressed);
101 static void xenkbd_handle_mt_event(struct xenkbd_info *info,
102 struct xenkbd_mtouch *mtouch)
104 if (unlikely(!info->mtouch))
107 if (mtouch->contact_id != info->mtouch_cur_contact_id) {
108 info->mtouch_cur_contact_id = mtouch->contact_id;
109 input_mt_slot(info->mtouch, mtouch->contact_id);
112 switch (mtouch->event_type) {
113 case XENKBD_MT_EV_DOWN:
114 input_mt_report_slot_state(info->mtouch, MT_TOOL_FINGER, true);
117 case XENKBD_MT_EV_MOTION:
118 input_report_abs(info->mtouch, ABS_MT_POSITION_X,
119 mtouch->u.pos.abs_x);
120 input_report_abs(info->mtouch, ABS_MT_POSITION_Y,
121 mtouch->u.pos.abs_y);
124 case XENKBD_MT_EV_SHAPE:
125 input_report_abs(info->mtouch, ABS_MT_TOUCH_MAJOR,
126 mtouch->u.shape.major);
127 input_report_abs(info->mtouch, ABS_MT_TOUCH_MINOR,
128 mtouch->u.shape.minor);
131 case XENKBD_MT_EV_ORIENT:
132 input_report_abs(info->mtouch, ABS_MT_ORIENTATION,
133 mtouch->u.orientation);
136 case XENKBD_MT_EV_UP:
137 input_mt_report_slot_state(info->mtouch, MT_TOOL_FINGER, false);
140 case XENKBD_MT_EV_SYN:
141 input_mt_sync_frame(info->mtouch);
142 input_sync(info->mtouch);
147 static void xenkbd_handle_event(struct xenkbd_info *info,
148 union xenkbd_in_event *event)
150 switch (event->type) {
151 case XENKBD_TYPE_MOTION:
152 xenkbd_handle_motion_event(info, &event->motion);
155 case XENKBD_TYPE_KEY:
156 xenkbd_handle_key_event(info, &event->key);
159 case XENKBD_TYPE_POS:
160 xenkbd_handle_position_event(info, &event->pos);
163 case XENKBD_TYPE_MTOUCH:
164 xenkbd_handle_mt_event(info, &event->mtouch);
169 static irqreturn_t input_handler(int rq, void *dev_id)
171 struct xenkbd_info *info = dev_id;
172 struct xenkbd_page *page = info->page;
175 prod = page->in_prod;
176 if (prod == page->in_cons)
178 rmb(); /* ensure we see ring contents up to prod */
179 for (cons = page->in_cons; cons != prod; cons++)
180 xenkbd_handle_event(info, &XENKBD_IN_RING_REF(page, cons));
181 mb(); /* ensure we got ring contents */
182 page->in_cons = cons;
183 notify_remote_via_irq(info->irq);
188 static int xenkbd_probe(struct xenbus_device *dev,
189 const struct xenbus_device_id *id)
192 unsigned int abs, touch;
193 struct xenkbd_info *info;
194 struct input_dev *kbd, *ptr, *mtouch;
196 info = kzalloc(sizeof(*info), GFP_KERNEL);
198 xenbus_dev_fatal(dev, -ENOMEM, "allocating info structure");
201 dev_set_drvdata(&dev->dev, info);
205 snprintf(info->phys, sizeof(info->phys), "xenbus/%s", dev->nodename);
207 info->page = (void *)__get_free_page(GFP_KERNEL | __GFP_ZERO);
211 /* Set input abs params to match backend screen res */
212 abs = xenbus_read_unsigned(dev->otherend,
213 XENKBD_FIELD_FEAT_ABS_POINTER, 0);
214 ptr_size[KPARAM_X] = xenbus_read_unsigned(dev->otherend,
217 ptr_size[KPARAM_Y] = xenbus_read_unsigned(dev->otherend,
221 ret = xenbus_write(XBT_NIL, dev->nodename,
222 XENKBD_FIELD_REQ_ABS_POINTER, "1");
224 pr_warn("xenkbd: can't request abs-pointer\n");
229 touch = xenbus_read_unsigned(dev->nodename,
230 XENKBD_FIELD_FEAT_MTOUCH, 0);
232 ret = xenbus_write(XBT_NIL, dev->nodename,
233 XENKBD_FIELD_REQ_MTOUCH, "1");
235 pr_warn("xenkbd: can't request multi-touch");
241 kbd = input_allocate_device();
244 kbd->name = "Xen Virtual Keyboard";
245 kbd->phys = info->phys;
246 kbd->id.bustype = BUS_PCI;
247 kbd->id.vendor = 0x5853;
248 kbd->id.product = 0xffff;
250 __set_bit(EV_KEY, kbd->evbit);
251 for (i = KEY_ESC; i < KEY_UNKNOWN; i++)
252 __set_bit(i, kbd->keybit);
253 for (i = KEY_OK; i < KEY_MAX; i++)
254 __set_bit(i, kbd->keybit);
256 ret = input_register_device(kbd);
258 input_free_device(kbd);
259 xenbus_dev_fatal(dev, ret, "input_register_device(kbd)");
264 /* pointing device */
265 ptr = input_allocate_device();
268 ptr->name = "Xen Virtual Pointer";
269 ptr->phys = info->phys;
270 ptr->id.bustype = BUS_PCI;
271 ptr->id.vendor = 0x5853;
272 ptr->id.product = 0xfffe;
275 __set_bit(EV_ABS, ptr->evbit);
276 input_set_abs_params(ptr, ABS_X, 0, ptr_size[KPARAM_X], 0, 0);
277 input_set_abs_params(ptr, ABS_Y, 0, ptr_size[KPARAM_Y], 0, 0);
279 input_set_capability(ptr, EV_REL, REL_X);
280 input_set_capability(ptr, EV_REL, REL_Y);
282 input_set_capability(ptr, EV_REL, REL_WHEEL);
284 __set_bit(EV_KEY, ptr->evbit);
285 for (i = BTN_LEFT; i <= BTN_TASK; i++)
286 __set_bit(i, ptr->keybit);
288 ret = input_register_device(ptr);
290 input_free_device(ptr);
291 xenbus_dev_fatal(dev, ret, "input_register_device(ptr)");
296 /* multi-touch device */
298 int num_cont, width, height;
300 mtouch = input_allocate_device();
304 num_cont = xenbus_read_unsigned(info->xbdev->nodename,
305 XENKBD_FIELD_MT_NUM_CONTACTS,
307 width = xenbus_read_unsigned(info->xbdev->nodename,
308 XENKBD_FIELD_MT_WIDTH,
310 height = xenbus_read_unsigned(info->xbdev->nodename,
311 XENKBD_FIELD_MT_HEIGHT,
314 mtouch->name = "Xen Virtual Multi-touch";
315 mtouch->phys = info->phys;
316 mtouch->id.bustype = BUS_PCI;
317 mtouch->id.vendor = 0x5853;
318 mtouch->id.product = 0xfffd;
320 input_set_abs_params(mtouch, ABS_MT_TOUCH_MAJOR,
322 input_set_abs_params(mtouch, ABS_MT_POSITION_X,
324 input_set_abs_params(mtouch, ABS_MT_POSITION_Y,
326 input_set_abs_params(mtouch, ABS_MT_PRESSURE,
329 ret = input_mt_init_slots(mtouch, num_cont, INPUT_MT_DIRECT);
331 input_free_device(mtouch);
332 xenbus_dev_fatal(info->xbdev, ret,
333 "input_mt_init_slots");
337 ret = input_register_device(mtouch);
339 input_free_device(mtouch);
340 xenbus_dev_fatal(info->xbdev, ret,
341 "input_register_device(mtouch)");
344 info->mtouch_cur_contact_id = -1;
345 info->mtouch = mtouch;
348 ret = xenkbd_connect_backend(dev, info);
356 xenbus_dev_fatal(dev, ret, "allocating device memory");
362 static int xenkbd_resume(struct xenbus_device *dev)
364 struct xenkbd_info *info = dev_get_drvdata(&dev->dev);
366 xenkbd_disconnect_backend(info);
367 memset(info->page, 0, PAGE_SIZE);
368 return xenkbd_connect_backend(dev, info);
371 static int xenkbd_remove(struct xenbus_device *dev)
373 struct xenkbd_info *info = dev_get_drvdata(&dev->dev);
375 xenkbd_disconnect_backend(info);
377 input_unregister_device(info->kbd);
379 input_unregister_device(info->ptr);
381 input_unregister_device(info->mtouch);
382 free_page((unsigned long)info->page);
387 static int xenkbd_connect_backend(struct xenbus_device *dev,
388 struct xenkbd_info *info)
391 struct xenbus_transaction xbt;
393 ret = gnttab_grant_foreign_access(dev->otherend_id,
394 virt_to_gfn(info->page), 0);
399 ret = xenbus_alloc_evtchn(dev, &evtchn);
402 ret = bind_evtchn_to_irqhandler(evtchn, input_handler,
403 0, dev->devicetype, info);
405 xenbus_dev_fatal(dev, ret, "bind_evtchn_to_irqhandler");
411 ret = xenbus_transaction_start(&xbt);
413 xenbus_dev_fatal(dev, ret, "starting transaction");
416 ret = xenbus_printf(xbt, dev->nodename, XENKBD_FIELD_RING_REF, "%lu",
417 virt_to_gfn(info->page));
420 ret = xenbus_printf(xbt, dev->nodename, XENKBD_FIELD_RING_GREF,
424 ret = xenbus_printf(xbt, dev->nodename, XENKBD_FIELD_EVT_CHANNEL, "%u",
428 ret = xenbus_transaction_end(xbt, 0);
432 xenbus_dev_fatal(dev, ret, "completing transaction");
436 xenbus_switch_state(dev, XenbusStateInitialised);
440 xenbus_transaction_end(xbt, 1);
441 xenbus_dev_fatal(dev, ret, "writing xenstore");
443 unbind_from_irqhandler(info->irq, info);
446 xenbus_free_evtchn(dev, evtchn);
448 gnttab_end_foreign_access(info->gref, 0, 0UL);
453 static void xenkbd_disconnect_backend(struct xenkbd_info *info)
456 unbind_from_irqhandler(info->irq, info);
459 gnttab_end_foreign_access(info->gref, 0, 0UL);
463 static void xenkbd_backend_changed(struct xenbus_device *dev,
464 enum xenbus_state backend_state)
466 switch (backend_state) {
467 case XenbusStateInitialising:
468 case XenbusStateInitialised:
469 case XenbusStateReconfiguring:
470 case XenbusStateReconfigured:
471 case XenbusStateUnknown:
474 case XenbusStateInitWait:
475 xenbus_switch_state(dev, XenbusStateConnected);
478 case XenbusStateConnected:
480 * Work around xenbus race condition: If backend goes
481 * through InitWait to Connected fast enough, we can
482 * get Connected twice here.
484 if (dev->state != XenbusStateConnected)
485 xenbus_switch_state(dev, XenbusStateConnected);
488 case XenbusStateClosed:
489 if (dev->state == XenbusStateClosed)
491 /* Missed the backend's CLOSING state -- fallthrough */
492 case XenbusStateClosing:
493 xenbus_frontend_closed(dev);
498 static const struct xenbus_device_id xenkbd_ids[] = {
499 { XENKBD_DRIVER_NAME },
503 static struct xenbus_driver xenkbd_driver = {
505 .probe = xenkbd_probe,
506 .remove = xenkbd_remove,
507 .resume = xenkbd_resume,
508 .otherend_changed = xenkbd_backend_changed,
511 static int __init xenkbd_init(void)
516 /* Nothing to do if running in dom0. */
517 if (xen_initial_domain())
520 if (!xen_has_pv_devices())
523 return xenbus_register_frontend(&xenkbd_driver);
526 static void __exit xenkbd_cleanup(void)
528 xenbus_unregister_driver(&xenkbd_driver);
531 module_init(xenkbd_init);
532 module_exit(xenkbd_cleanup);
534 MODULE_DESCRIPTION("Xen virtual keyboard/pointer device frontend");
535 MODULE_LICENSE("GPL");
536 MODULE_ALIAS("xen:" XENKBD_DRIVER_NAME);