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/slab.h> 21 22 #include <asm/xen/hypervisor.h> 23 24 #include <xen/xen.h> 25 #include <xen/events.h> 26 #include <xen/page.h> 27 #include <xen/grant_table.h> 28 #include <xen/interface/grant_table.h> 29 #include <xen/interface/io/fbif.h> 30 #include <xen/interface/io/kbdif.h> 31 #include <xen/xenbus.h> 32 #include <xen/platform_pci.h> 33 34 struct xenkbd_info { 35 struct input_dev *kbd; 36 struct input_dev *ptr; 37 struct xenkbd_page *page; 38 int gref; 39 int irq; 40 struct xenbus_device *xbdev; 41 char phys[32]; 42 }; 43 44 enum { KPARAM_X, KPARAM_Y, KPARAM_CNT }; 45 static int ptr_size[KPARAM_CNT] = { XENFB_WIDTH, XENFB_HEIGHT }; 46 module_param_array(ptr_size, int, NULL, 0444); 47 MODULE_PARM_DESC(ptr_size, 48 "Pointing device width, height in pixels (default 800,600)"); 49 50 static int xenkbd_remove(struct xenbus_device *); 51 static int xenkbd_connect_backend(struct xenbus_device *, struct xenkbd_info *); 52 static void xenkbd_disconnect_backend(struct xenkbd_info *); 53 54 /* 55 * Note: if you need to send out events, see xenfb_do_update() for how 56 * to do that. 57 */ 58 59 static irqreturn_t input_handler(int rq, void *dev_id) 60 { 61 struct xenkbd_info *info = dev_id; 62 struct xenkbd_page *page = info->page; 63 __u32 cons, prod; 64 65 prod = page->in_prod; 66 if (prod == page->in_cons) 67 return IRQ_HANDLED; 68 rmb(); /* ensure we see ring contents up to prod */ 69 for (cons = page->in_cons; cons != prod; cons++) { 70 union xenkbd_in_event *event; 71 struct input_dev *dev; 72 event = &XENKBD_IN_RING_REF(page, cons); 73 74 dev = info->ptr; 75 switch (event->type) { 76 case XENKBD_TYPE_MOTION: 77 input_report_rel(dev, REL_X, event->motion.rel_x); 78 input_report_rel(dev, REL_Y, event->motion.rel_y); 79 if (event->motion.rel_z) 80 input_report_rel(dev, REL_WHEEL, 81 -event->motion.rel_z); 82 break; 83 case XENKBD_TYPE_KEY: 84 dev = NULL; 85 if (test_bit(event->key.keycode, info->kbd->keybit)) 86 dev = info->kbd; 87 if (test_bit(event->key.keycode, info->ptr->keybit)) 88 dev = info->ptr; 89 if (dev) 90 input_report_key(dev, event->key.keycode, 91 event->key.pressed); 92 else 93 pr_warn("unhandled keycode 0x%x\n", 94 event->key.keycode); 95 break; 96 case XENKBD_TYPE_POS: 97 input_report_abs(dev, ABS_X, event->pos.abs_x); 98 input_report_abs(dev, ABS_Y, event->pos.abs_y); 99 if (event->pos.rel_z) 100 input_report_rel(dev, REL_WHEEL, 101 -event->pos.rel_z); 102 break; 103 } 104 if (dev) 105 input_sync(dev); 106 } 107 mb(); /* ensure we got ring contents */ 108 page->in_cons = cons; 109 notify_remote_via_irq(info->irq); 110 111 return IRQ_HANDLED; 112 } 113 114 static int xenkbd_probe(struct xenbus_device *dev, 115 const struct xenbus_device_id *id) 116 { 117 int ret, i; 118 unsigned int abs; 119 struct xenkbd_info *info; 120 struct input_dev *kbd, *ptr; 121 122 info = kzalloc(sizeof(*info), GFP_KERNEL); 123 if (!info) { 124 xenbus_dev_fatal(dev, -ENOMEM, "allocating info structure"); 125 return -ENOMEM; 126 } 127 dev_set_drvdata(&dev->dev, info); 128 info->xbdev = dev; 129 info->irq = -1; 130 info->gref = -1; 131 snprintf(info->phys, sizeof(info->phys), "xenbus/%s", dev->nodename); 132 133 info->page = (void *)__get_free_page(GFP_KERNEL | __GFP_ZERO); 134 if (!info->page) 135 goto error_nomem; 136 137 /* Set input abs params to match backend screen res */ 138 abs = xenbus_read_unsigned(dev->otherend, 139 XENKBD_FIELD_FEAT_ABS_POINTER, 0); 140 ptr_size[KPARAM_X] = xenbus_read_unsigned(dev->otherend, 141 XENKBD_FIELD_WIDTH, 142 ptr_size[KPARAM_X]); 143 ptr_size[KPARAM_Y] = xenbus_read_unsigned(dev->otherend, 144 XENKBD_FIELD_HEIGHT, 145 ptr_size[KPARAM_Y]); 146 if (abs) { 147 ret = xenbus_write(XBT_NIL, dev->nodename, 148 XENKBD_FIELD_REQ_ABS_POINTER, "1"); 149 if (ret) { 150 pr_warn("xenkbd: can't request abs-pointer\n"); 151 abs = 0; 152 } 153 } 154 155 /* keyboard */ 156 kbd = input_allocate_device(); 157 if (!kbd) 158 goto error_nomem; 159 kbd->name = "Xen Virtual Keyboard"; 160 kbd->phys = info->phys; 161 kbd->id.bustype = BUS_PCI; 162 kbd->id.vendor = 0x5853; 163 kbd->id.product = 0xffff; 164 165 __set_bit(EV_KEY, kbd->evbit); 166 for (i = KEY_ESC; i < KEY_UNKNOWN; i++) 167 __set_bit(i, kbd->keybit); 168 for (i = KEY_OK; i < KEY_MAX; i++) 169 __set_bit(i, kbd->keybit); 170 171 ret = input_register_device(kbd); 172 if (ret) { 173 input_free_device(kbd); 174 xenbus_dev_fatal(dev, ret, "input_register_device(kbd)"); 175 goto error; 176 } 177 info->kbd = kbd; 178 179 /* pointing device */ 180 ptr = input_allocate_device(); 181 if (!ptr) 182 goto error_nomem; 183 ptr->name = "Xen Virtual Pointer"; 184 ptr->phys = info->phys; 185 ptr->id.bustype = BUS_PCI; 186 ptr->id.vendor = 0x5853; 187 ptr->id.product = 0xfffe; 188 189 if (abs) { 190 __set_bit(EV_ABS, ptr->evbit); 191 input_set_abs_params(ptr, ABS_X, 0, ptr_size[KPARAM_X], 0, 0); 192 input_set_abs_params(ptr, ABS_Y, 0, ptr_size[KPARAM_Y], 0, 0); 193 } else { 194 input_set_capability(ptr, EV_REL, REL_X); 195 input_set_capability(ptr, EV_REL, REL_Y); 196 } 197 input_set_capability(ptr, EV_REL, REL_WHEEL); 198 199 __set_bit(EV_KEY, ptr->evbit); 200 for (i = BTN_LEFT; i <= BTN_TASK; i++) 201 __set_bit(i, ptr->keybit); 202 203 ret = input_register_device(ptr); 204 if (ret) { 205 input_free_device(ptr); 206 xenbus_dev_fatal(dev, ret, "input_register_device(ptr)"); 207 goto error; 208 } 209 info->ptr = ptr; 210 211 ret = xenkbd_connect_backend(dev, info); 212 if (ret < 0) 213 goto error; 214 215 return 0; 216 217 error_nomem: 218 ret = -ENOMEM; 219 xenbus_dev_fatal(dev, ret, "allocating device memory"); 220 error: 221 xenkbd_remove(dev); 222 return ret; 223 } 224 225 static int xenkbd_resume(struct xenbus_device *dev) 226 { 227 struct xenkbd_info *info = dev_get_drvdata(&dev->dev); 228 229 xenkbd_disconnect_backend(info); 230 memset(info->page, 0, PAGE_SIZE); 231 return xenkbd_connect_backend(dev, info); 232 } 233 234 static int xenkbd_remove(struct xenbus_device *dev) 235 { 236 struct xenkbd_info *info = dev_get_drvdata(&dev->dev); 237 238 xenkbd_disconnect_backend(info); 239 if (info->kbd) 240 input_unregister_device(info->kbd); 241 if (info->ptr) 242 input_unregister_device(info->ptr); 243 free_page((unsigned long)info->page); 244 kfree(info); 245 return 0; 246 } 247 248 static int xenkbd_connect_backend(struct xenbus_device *dev, 249 struct xenkbd_info *info) 250 { 251 int ret, evtchn; 252 struct xenbus_transaction xbt; 253 254 ret = gnttab_grant_foreign_access(dev->otherend_id, 255 virt_to_gfn(info->page), 0); 256 if (ret < 0) 257 return ret; 258 info->gref = ret; 259 260 ret = xenbus_alloc_evtchn(dev, &evtchn); 261 if (ret) 262 goto error_grant; 263 ret = bind_evtchn_to_irqhandler(evtchn, input_handler, 264 0, dev->devicetype, info); 265 if (ret < 0) { 266 xenbus_dev_fatal(dev, ret, "bind_evtchn_to_irqhandler"); 267 goto error_evtchan; 268 } 269 info->irq = ret; 270 271 again: 272 ret = xenbus_transaction_start(&xbt); 273 if (ret) { 274 xenbus_dev_fatal(dev, ret, "starting transaction"); 275 goto error_irqh; 276 } 277 ret = xenbus_printf(xbt, dev->nodename, XENKBD_FIELD_RING_REF, "%lu", 278 virt_to_gfn(info->page)); 279 if (ret) 280 goto error_xenbus; 281 ret = xenbus_printf(xbt, dev->nodename, XENKBD_FIELD_RING_GREF, 282 "%u", info->gref); 283 if (ret) 284 goto error_xenbus; 285 ret = xenbus_printf(xbt, dev->nodename, XENKBD_FIELD_EVT_CHANNEL, "%u", 286 evtchn); 287 if (ret) 288 goto error_xenbus; 289 ret = xenbus_transaction_end(xbt, 0); 290 if (ret) { 291 if (ret == -EAGAIN) 292 goto again; 293 xenbus_dev_fatal(dev, ret, "completing transaction"); 294 goto error_irqh; 295 } 296 297 xenbus_switch_state(dev, XenbusStateInitialised); 298 return 0; 299 300 error_xenbus: 301 xenbus_transaction_end(xbt, 1); 302 xenbus_dev_fatal(dev, ret, "writing xenstore"); 303 error_irqh: 304 unbind_from_irqhandler(info->irq, info); 305 info->irq = -1; 306 error_evtchan: 307 xenbus_free_evtchn(dev, evtchn); 308 error_grant: 309 gnttab_end_foreign_access(info->gref, 0, 0UL); 310 info->gref = -1; 311 return ret; 312 } 313 314 static void xenkbd_disconnect_backend(struct xenkbd_info *info) 315 { 316 if (info->irq >= 0) 317 unbind_from_irqhandler(info->irq, info); 318 info->irq = -1; 319 if (info->gref >= 0) 320 gnttab_end_foreign_access(info->gref, 0, 0UL); 321 info->gref = -1; 322 } 323 324 static void xenkbd_backend_changed(struct xenbus_device *dev, 325 enum xenbus_state backend_state) 326 { 327 switch (backend_state) { 328 case XenbusStateInitialising: 329 case XenbusStateInitialised: 330 case XenbusStateReconfiguring: 331 case XenbusStateReconfigured: 332 case XenbusStateUnknown: 333 break; 334 335 case XenbusStateInitWait: 336 xenbus_switch_state(dev, XenbusStateConnected); 337 break; 338 339 case XenbusStateConnected: 340 /* 341 * Work around xenbus race condition: If backend goes 342 * through InitWait to Connected fast enough, we can 343 * get Connected twice here. 344 */ 345 if (dev->state != XenbusStateConnected) 346 xenbus_switch_state(dev, XenbusStateConnected); 347 break; 348 349 case XenbusStateClosed: 350 if (dev->state == XenbusStateClosed) 351 break; 352 /* Missed the backend's CLOSING state -- fallthrough */ 353 case XenbusStateClosing: 354 xenbus_frontend_closed(dev); 355 break; 356 } 357 } 358 359 static const struct xenbus_device_id xenkbd_ids[] = { 360 { XENKBD_DRIVER_NAME }, 361 { "" } 362 }; 363 364 static struct xenbus_driver xenkbd_driver = { 365 .ids = xenkbd_ids, 366 .probe = xenkbd_probe, 367 .remove = xenkbd_remove, 368 .resume = xenkbd_resume, 369 .otherend_changed = xenkbd_backend_changed, 370 }; 371 372 static int __init xenkbd_init(void) 373 { 374 if (!xen_domain()) 375 return -ENODEV; 376 377 /* Nothing to do if running in dom0. */ 378 if (xen_initial_domain()) 379 return -ENODEV; 380 381 if (!xen_has_pv_devices()) 382 return -ENODEV; 383 384 return xenbus_register_frontend(&xenkbd_driver); 385 } 386 387 static void __exit xenkbd_cleanup(void) 388 { 389 xenbus_unregister_driver(&xenkbd_driver); 390 } 391 392 module_init(xenkbd_init); 393 module_exit(xenkbd_cleanup); 394 395 MODULE_DESCRIPTION("Xen virtual keyboard/pointer device frontend"); 396 MODULE_LICENSE("GPL"); 397 MODULE_ALIAS("xen:" XENKBD_DRIVER_NAME); 398