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
17 * Switch to grant tables together with xen-fbfront.c.
20 #include <linux/kernel.h>
21 #include <linux/errno.h>
22 #include <linux/module.h>
23 #include <linux/input.h>
25 #include <asm/xen/hypervisor.h>
28 #include <xen/events.h>
30 #include <xen/interface/io/fbif.h>
31 #include <xen/interface/io/kbdif.h>
32 #include <xen/xenbus.h>
35 struct input_dev
*kbd
;
36 struct input_dev
*ptr
;
37 struct xenkbd_page
*page
;
39 struct xenbus_device
*xbdev
;
43 static int xenkbd_remove(struct xenbus_device
*);
44 static int xenkbd_connect_backend(struct xenbus_device
*, struct xenkbd_info
*);
45 static void xenkbd_disconnect_backend(struct xenkbd_info
*);
48 * Note: if you need to send out events, see xenfb_do_update() for how
52 static irqreturn_t
input_handler(int rq
, void *dev_id
)
54 struct xenkbd_info
*info
= dev_id
;
55 struct xenkbd_page
*page
= info
->page
;
59 if (prod
== page
->in_cons
)
61 rmb(); /* ensure we see ring contents up to prod */
62 for (cons
= page
->in_cons
; cons
!= prod
; cons
++) {
63 union xenkbd_in_event
*event
;
64 struct input_dev
*dev
;
65 event
= &XENKBD_IN_RING_REF(page
, cons
);
68 switch (event
->type
) {
69 case XENKBD_TYPE_MOTION
:
70 input_report_rel(dev
, REL_X
, event
->motion
.rel_x
);
71 input_report_rel(dev
, REL_Y
, event
->motion
.rel_y
);
72 if (event
->motion
.rel_z
)
73 input_report_rel(dev
, REL_WHEEL
,
74 -event
->motion
.rel_z
);
78 if (test_bit(event
->key
.keycode
, info
->kbd
->keybit
))
80 if (test_bit(event
->key
.keycode
, info
->ptr
->keybit
))
83 input_report_key(dev
, event
->key
.keycode
,
87 "xenkbd: unhandled keycode 0x%x\n",
91 input_report_abs(dev
, ABS_X
, event
->pos
.abs_x
);
92 input_report_abs(dev
, ABS_Y
, event
->pos
.abs_y
);
94 input_report_rel(dev
, REL_WHEEL
,
101 mb(); /* ensure we got ring contents */
102 page
->in_cons
= cons
;
103 notify_remote_via_irq(info
->irq
);
108 static int __devinit
xenkbd_probe(struct xenbus_device
*dev
,
109 const struct xenbus_device_id
*id
)
112 struct xenkbd_info
*info
;
113 struct input_dev
*kbd
, *ptr
;
115 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
117 xenbus_dev_fatal(dev
, -ENOMEM
, "allocating info structure");
120 dev_set_drvdata(&dev
->dev
, info
);
123 snprintf(info
->phys
, sizeof(info
->phys
), "xenbus/%s", dev
->nodename
);
125 info
->page
= (void *)__get_free_page(GFP_KERNEL
| __GFP_ZERO
);
129 if (xenbus_scanf(XBT_NIL
, dev
->otherend
, "feature-abs-pointer", "%d", &abs
) < 0)
132 xenbus_printf(XBT_NIL
, dev
->nodename
, "request-abs-pointer", "1");
135 kbd
= input_allocate_device();
138 kbd
->name
= "Xen Virtual Keyboard";
139 kbd
->phys
= info
->phys
;
140 kbd
->id
.bustype
= BUS_PCI
;
141 kbd
->id
.vendor
= 0x5853;
142 kbd
->id
.product
= 0xffff;
144 __set_bit(EV_KEY
, kbd
->evbit
);
145 for (i
= KEY_ESC
; i
< KEY_UNKNOWN
; i
++)
146 __set_bit(i
, kbd
->keybit
);
147 for (i
= KEY_OK
; i
< KEY_MAX
; i
++)
148 __set_bit(i
, kbd
->keybit
);
150 ret
= input_register_device(kbd
);
152 input_free_device(kbd
);
153 xenbus_dev_fatal(dev
, ret
, "input_register_device(kbd)");
158 /* pointing device */
159 ptr
= input_allocate_device();
162 ptr
->name
= "Xen Virtual Pointer";
163 ptr
->phys
= info
->phys
;
164 ptr
->id
.bustype
= BUS_PCI
;
165 ptr
->id
.vendor
= 0x5853;
166 ptr
->id
.product
= 0xfffe;
169 __set_bit(EV_ABS
, ptr
->evbit
);
170 input_set_abs_params(ptr
, ABS_X
, 0, XENFB_WIDTH
, 0, 0);
171 input_set_abs_params(ptr
, ABS_Y
, 0, XENFB_HEIGHT
, 0, 0);
173 input_set_capability(ptr
, EV_REL
, REL_X
);
174 input_set_capability(ptr
, EV_REL
, REL_Y
);
176 input_set_capability(ptr
, EV_REL
, REL_WHEEL
);
178 __set_bit(EV_KEY
, ptr
->evbit
);
179 for (i
= BTN_LEFT
; i
<= BTN_TASK
; i
++)
180 __set_bit(i
, ptr
->keybit
);
182 ret
= input_register_device(ptr
);
184 input_free_device(ptr
);
185 xenbus_dev_fatal(dev
, ret
, "input_register_device(ptr)");
190 ret
= xenkbd_connect_backend(dev
, info
);
198 xenbus_dev_fatal(dev
, ret
, "allocating device memory");
204 static int xenkbd_resume(struct xenbus_device
*dev
)
206 struct xenkbd_info
*info
= dev_get_drvdata(&dev
->dev
);
208 xenkbd_disconnect_backend(info
);
209 memset(info
->page
, 0, PAGE_SIZE
);
210 return xenkbd_connect_backend(dev
, info
);
213 static int xenkbd_remove(struct xenbus_device
*dev
)
215 struct xenkbd_info
*info
= dev_get_drvdata(&dev
->dev
);
217 xenkbd_disconnect_backend(info
);
219 input_unregister_device(info
->kbd
);
221 input_unregister_device(info
->ptr
);
222 free_page((unsigned long)info
->page
);
227 static int xenkbd_connect_backend(struct xenbus_device
*dev
,
228 struct xenkbd_info
*info
)
231 struct xenbus_transaction xbt
;
233 ret
= xenbus_alloc_evtchn(dev
, &evtchn
);
236 ret
= bind_evtchn_to_irqhandler(evtchn
, input_handler
,
237 0, dev
->devicetype
, info
);
239 xenbus_free_evtchn(dev
, evtchn
);
240 xenbus_dev_fatal(dev
, ret
, "bind_evtchn_to_irqhandler");
246 ret
= xenbus_transaction_start(&xbt
);
248 xenbus_dev_fatal(dev
, ret
, "starting transaction");
251 ret
= xenbus_printf(xbt
, dev
->nodename
, "page-ref", "%lu",
252 virt_to_mfn(info
->page
));
255 ret
= xenbus_printf(xbt
, dev
->nodename
, "event-channel", "%u",
259 ret
= xenbus_transaction_end(xbt
, 0);
263 xenbus_dev_fatal(dev
, ret
, "completing transaction");
267 xenbus_switch_state(dev
, XenbusStateInitialised
);
271 xenbus_transaction_end(xbt
, 1);
272 xenbus_dev_fatal(dev
, ret
, "writing xenstore");
276 static void xenkbd_disconnect_backend(struct xenkbd_info
*info
)
279 unbind_from_irqhandler(info
->irq
, info
);
283 static void xenkbd_backend_changed(struct xenbus_device
*dev
,
284 enum xenbus_state backend_state
)
286 struct xenkbd_info
*info
= dev_get_drvdata(&dev
->dev
);
289 switch (backend_state
) {
290 case XenbusStateInitialising
:
291 case XenbusStateInitialised
:
292 case XenbusStateUnknown
:
293 case XenbusStateClosed
:
296 case XenbusStateInitWait
:
298 ret
= xenbus_scanf(XBT_NIL
, info
->xbdev
->otherend
,
299 "feature-abs-pointer", "%d", &val
);
303 ret
= xenbus_printf(XBT_NIL
, info
->xbdev
->nodename
,
304 "request-abs-pointer", "1");
306 pr_warning("can't request abs-pointer\n");
308 xenbus_switch_state(dev
, XenbusStateConnected
);
311 case XenbusStateConnected
:
313 * Work around xenbus race condition: If backend goes
314 * through InitWait to Connected fast enough, we can
315 * get Connected twice here.
317 if (dev
->state
!= XenbusStateConnected
)
318 goto InitWait
; /* no InitWait seen yet, fudge it */
320 /* Set input abs params to match backend screen res */
321 if (xenbus_scanf(XBT_NIL
, info
->xbdev
->otherend
,
322 "width", "%d", &val
) > 0)
323 input_set_abs_params(info
->ptr
, ABS_X
, 0, val
, 0, 0);
325 if (xenbus_scanf(XBT_NIL
, info
->xbdev
->otherend
,
326 "height", "%d", &val
) > 0)
327 input_set_abs_params(info
->ptr
, ABS_Y
, 0, val
, 0, 0);
331 case XenbusStateClosing
:
332 xenbus_frontend_closed(dev
);
337 static struct xenbus_device_id xenkbd_ids
[] = {
342 static struct xenbus_driver xenkbd_driver
= {
344 .owner
= THIS_MODULE
,
346 .probe
= xenkbd_probe
,
347 .remove
= xenkbd_remove
,
348 .resume
= xenkbd_resume
,
349 .otherend_changed
= xenkbd_backend_changed
,
352 static int __init
xenkbd_init(void)
357 /* Nothing to do if running in dom0. */
358 if (xen_initial_domain())
361 return xenbus_register_frontend(&xenkbd_driver
);
364 static void __exit
xenkbd_cleanup(void)
366 xenbus_unregister_driver(&xenkbd_driver
);
369 module_init(xenkbd_init
);
370 module_exit(xenkbd_cleanup
);
372 MODULE_DESCRIPTION("Xen virtual keyboard/pointer device frontend");
373 MODULE_LICENSE("GPL");
374 MODULE_ALIAS("xen:vkbd");