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 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 *); 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 input_report_rel(info->ptr, REL_X, motion->rel_x); 67 input_report_rel(info->ptr, REL_Y, motion->rel_y); 68 if (motion->rel_z) 69 input_report_rel(info->ptr, REL_WHEEL, -motion->rel_z); 70 input_sync(info->ptr); 71 } 72 73 static void xenkbd_handle_position_event(struct xenkbd_info *info, 74 struct xenkbd_position *pos) 75 { 76 input_report_abs(info->ptr, ABS_X, pos->abs_x); 77 input_report_abs(info->ptr, ABS_Y, pos->abs_y); 78 if (pos->rel_z) 79 input_report_rel(info->ptr, REL_WHEEL, -pos->rel_z); 80 input_sync(info->ptr); 81 } 82 83 static void xenkbd_handle_key_event(struct xenkbd_info *info, 84 struct xenkbd_key *key) 85 { 86 struct input_dev *dev; 87 int value = key->pressed; 88 89 if (test_bit(key->keycode, info->ptr->keybit)) { 90 dev = info->ptr; 91 } else if (test_bit(key->keycode, info->kbd->keybit)) { 92 dev = info->kbd; 93 if (key->pressed && test_bit(key->keycode, info->kbd->key)) 94 value = 2; /* Mark as autorepeat */ 95 } else { 96 pr_warn("unhandled keycode 0x%x\n", key->keycode); 97 return; 98 } 99 100 input_event(dev, EV_KEY, key->keycode, value); 101 input_sync(dev); 102 } 103 104 static void xenkbd_handle_mt_event(struct xenkbd_info *info, 105 struct xenkbd_mtouch *mtouch) 106 { 107 if (unlikely(!info->mtouch)) 108 return; 109 110 if (mtouch->contact_id != info->mtouch_cur_contact_id) { 111 info->mtouch_cur_contact_id = mtouch->contact_id; 112 input_mt_slot(info->mtouch, mtouch->contact_id); 113 } 114 115 switch (mtouch->event_type) { 116 case XENKBD_MT_EV_DOWN: 117 input_mt_report_slot_state(info->mtouch, MT_TOOL_FINGER, true); 118 /* fall through */ 119 120 case XENKBD_MT_EV_MOTION: 121 input_report_abs(info->mtouch, ABS_MT_POSITION_X, 122 mtouch->u.pos.abs_x); 123 input_report_abs(info->mtouch, ABS_MT_POSITION_Y, 124 mtouch->u.pos.abs_y); 125 break; 126 127 case XENKBD_MT_EV_SHAPE: 128 input_report_abs(info->mtouch, ABS_MT_TOUCH_MAJOR, 129 mtouch->u.shape.major); 130 input_report_abs(info->mtouch, ABS_MT_TOUCH_MINOR, 131 mtouch->u.shape.minor); 132 break; 133 134 case XENKBD_MT_EV_ORIENT: 135 input_report_abs(info->mtouch, ABS_MT_ORIENTATION, 136 mtouch->u.orientation); 137 break; 138 139 case XENKBD_MT_EV_UP: 140 input_mt_report_slot_state(info->mtouch, MT_TOOL_FINGER, false); 141 break; 142 143 case XENKBD_MT_EV_SYN: 144 input_mt_sync_frame(info->mtouch); 145 input_sync(info->mtouch); 146 break; 147 } 148 } 149 150 static void xenkbd_handle_event(struct xenkbd_info *info, 151 union xenkbd_in_event *event) 152 { 153 switch (event->type) { 154 case XENKBD_TYPE_MOTION: 155 xenkbd_handle_motion_event(info, &event->motion); 156 break; 157 158 case XENKBD_TYPE_KEY: 159 xenkbd_handle_key_event(info, &event->key); 160 break; 161 162 case XENKBD_TYPE_POS: 163 xenkbd_handle_position_event(info, &event->pos); 164 break; 165 166 case XENKBD_TYPE_MTOUCH: 167 xenkbd_handle_mt_event(info, &event->mtouch); 168 break; 169 } 170 } 171 172 static irqreturn_t input_handler(int rq, void *dev_id) 173 { 174 struct xenkbd_info *info = dev_id; 175 struct xenkbd_page *page = info->page; 176 __u32 cons, prod; 177 178 prod = page->in_prod; 179 if (prod == page->in_cons) 180 return IRQ_HANDLED; 181 rmb(); /* ensure we see ring contents up to prod */ 182 for (cons = page->in_cons; cons != prod; cons++) 183 xenkbd_handle_event(info, &XENKBD_IN_RING_REF(page, cons)); 184 mb(); /* ensure we got ring contents */ 185 page->in_cons = cons; 186 notify_remote_via_irq(info->irq); 187 188 return IRQ_HANDLED; 189 } 190 191 static int xenkbd_probe(struct xenbus_device *dev, 192 const struct xenbus_device_id *id) 193 { 194 int ret, i; 195 unsigned int abs, touch; 196 struct xenkbd_info *info; 197 struct input_dev *kbd, *ptr, *mtouch; 198 199 info = kzalloc(sizeof(*info), GFP_KERNEL); 200 if (!info) { 201 xenbus_dev_fatal(dev, -ENOMEM, "allocating info structure"); 202 return -ENOMEM; 203 } 204 dev_set_drvdata(&dev->dev, info); 205 info->xbdev = dev; 206 info->irq = -1; 207 info->gref = -1; 208 snprintf(info->phys, sizeof(info->phys), "xenbus/%s", dev->nodename); 209 210 info->page = (void *)__get_free_page(GFP_KERNEL | __GFP_ZERO); 211 if (!info->page) 212 goto error_nomem; 213 214 /* Set input abs params to match backend screen res */ 215 abs = xenbus_read_unsigned(dev->otherend, 216 XENKBD_FIELD_FEAT_ABS_POINTER, 0); 217 ptr_size[KPARAM_X] = xenbus_read_unsigned(dev->otherend, 218 XENKBD_FIELD_WIDTH, 219 ptr_size[KPARAM_X]); 220 ptr_size[KPARAM_Y] = xenbus_read_unsigned(dev->otherend, 221 XENKBD_FIELD_HEIGHT, 222 ptr_size[KPARAM_Y]); 223 if (abs) { 224 ret = xenbus_write(XBT_NIL, dev->nodename, 225 XENKBD_FIELD_REQ_ABS_POINTER, "1"); 226 if (ret) { 227 pr_warn("xenkbd: can't request abs-pointer\n"); 228 abs = 0; 229 } 230 } 231 232 touch = xenbus_read_unsigned(dev->nodename, 233 XENKBD_FIELD_FEAT_MTOUCH, 0); 234 if (touch) { 235 ret = xenbus_write(XBT_NIL, dev->nodename, 236 XENKBD_FIELD_REQ_MTOUCH, "1"); 237 if (ret) { 238 pr_warn("xenkbd: can't request multi-touch"); 239 touch = 0; 240 } 241 } 242 243 /* keyboard */ 244 kbd = input_allocate_device(); 245 if (!kbd) 246 goto error_nomem; 247 kbd->name = "Xen Virtual Keyboard"; 248 kbd->phys = info->phys; 249 kbd->id.bustype = BUS_PCI; 250 kbd->id.vendor = 0x5853; 251 kbd->id.product = 0xffff; 252 253 __set_bit(EV_KEY, kbd->evbit); 254 for (i = KEY_ESC; i < KEY_UNKNOWN; i++) 255 __set_bit(i, kbd->keybit); 256 for (i = KEY_OK; i < KEY_MAX; i++) 257 __set_bit(i, kbd->keybit); 258 259 ret = input_register_device(kbd); 260 if (ret) { 261 input_free_device(kbd); 262 xenbus_dev_fatal(dev, ret, "input_register_device(kbd)"); 263 goto error; 264 } 265 info->kbd = kbd; 266 267 /* pointing device */ 268 ptr = input_allocate_device(); 269 if (!ptr) 270 goto error_nomem; 271 ptr->name = "Xen Virtual Pointer"; 272 ptr->phys = info->phys; 273 ptr->id.bustype = BUS_PCI; 274 ptr->id.vendor = 0x5853; 275 ptr->id.product = 0xfffe; 276 277 if (abs) { 278 __set_bit(EV_ABS, ptr->evbit); 279 input_set_abs_params(ptr, ABS_X, 0, ptr_size[KPARAM_X], 0, 0); 280 input_set_abs_params(ptr, ABS_Y, 0, ptr_size[KPARAM_Y], 0, 0); 281 } else { 282 input_set_capability(ptr, EV_REL, REL_X); 283 input_set_capability(ptr, EV_REL, REL_Y); 284 } 285 input_set_capability(ptr, EV_REL, REL_WHEEL); 286 287 __set_bit(EV_KEY, ptr->evbit); 288 for (i = BTN_LEFT; i <= BTN_TASK; i++) 289 __set_bit(i, ptr->keybit); 290 291 ret = input_register_device(ptr); 292 if (ret) { 293 input_free_device(ptr); 294 xenbus_dev_fatal(dev, ret, "input_register_device(ptr)"); 295 goto error; 296 } 297 info->ptr = ptr; 298 299 /* multi-touch device */ 300 if (touch) { 301 int num_cont, width, height; 302 303 mtouch = input_allocate_device(); 304 if (!mtouch) 305 goto error_nomem; 306 307 num_cont = xenbus_read_unsigned(info->xbdev->nodename, 308 XENKBD_FIELD_MT_NUM_CONTACTS, 309 1); 310 width = xenbus_read_unsigned(info->xbdev->nodename, 311 XENKBD_FIELD_MT_WIDTH, 312 XENFB_WIDTH); 313 height = xenbus_read_unsigned(info->xbdev->nodename, 314 XENKBD_FIELD_MT_HEIGHT, 315 XENFB_HEIGHT); 316 317 mtouch->name = "Xen Virtual Multi-touch"; 318 mtouch->phys = info->phys; 319 mtouch->id.bustype = BUS_PCI; 320 mtouch->id.vendor = 0x5853; 321 mtouch->id.product = 0xfffd; 322 323 input_set_abs_params(mtouch, ABS_MT_TOUCH_MAJOR, 324 0, 255, 0, 0); 325 input_set_abs_params(mtouch, ABS_MT_POSITION_X, 326 0, width, 0, 0); 327 input_set_abs_params(mtouch, ABS_MT_POSITION_Y, 328 0, height, 0, 0); 329 330 ret = input_mt_init_slots(mtouch, num_cont, INPUT_MT_DIRECT); 331 if (ret) { 332 input_free_device(mtouch); 333 xenbus_dev_fatal(info->xbdev, ret, 334 "input_mt_init_slots"); 335 goto error; 336 } 337 338 ret = input_register_device(mtouch); 339 if (ret) { 340 input_free_device(mtouch); 341 xenbus_dev_fatal(info->xbdev, ret, 342 "input_register_device(mtouch)"); 343 goto error; 344 } 345 info->mtouch_cur_contact_id = -1; 346 info->mtouch = mtouch; 347 } 348 349 ret = xenkbd_connect_backend(dev, info); 350 if (ret < 0) 351 goto error; 352 353 return 0; 354 355 error_nomem: 356 ret = -ENOMEM; 357 xenbus_dev_fatal(dev, ret, "allocating device memory"); 358 error: 359 xenkbd_remove(dev); 360 return ret; 361 } 362 363 static int xenkbd_resume(struct xenbus_device *dev) 364 { 365 struct xenkbd_info *info = dev_get_drvdata(&dev->dev); 366 367 xenkbd_disconnect_backend(info); 368 memset(info->page, 0, PAGE_SIZE); 369 return xenkbd_connect_backend(dev, info); 370 } 371 372 static int xenkbd_remove(struct xenbus_device *dev) 373 { 374 struct xenkbd_info *info = dev_get_drvdata(&dev->dev); 375 376 xenkbd_disconnect_backend(info); 377 if (info->kbd) 378 input_unregister_device(info->kbd); 379 if (info->ptr) 380 input_unregister_device(info->ptr); 381 if (info->mtouch) 382 input_unregister_device(info->mtouch); 383 free_page((unsigned long)info->page); 384 kfree(info); 385 return 0; 386 } 387 388 static int xenkbd_connect_backend(struct xenbus_device *dev, 389 struct xenkbd_info *info) 390 { 391 int ret, evtchn; 392 struct xenbus_transaction xbt; 393 394 ret = gnttab_grant_foreign_access(dev->otherend_id, 395 virt_to_gfn(info->page), 0); 396 if (ret < 0) 397 return ret; 398 info->gref = ret; 399 400 ret = xenbus_alloc_evtchn(dev, &evtchn); 401 if (ret) 402 goto error_grant; 403 ret = bind_evtchn_to_irqhandler(evtchn, input_handler, 404 0, dev->devicetype, info); 405 if (ret < 0) { 406 xenbus_dev_fatal(dev, ret, "bind_evtchn_to_irqhandler"); 407 goto error_evtchan; 408 } 409 info->irq = ret; 410 411 again: 412 ret = xenbus_transaction_start(&xbt); 413 if (ret) { 414 xenbus_dev_fatal(dev, ret, "starting transaction"); 415 goto error_irqh; 416 } 417 ret = xenbus_printf(xbt, dev->nodename, XENKBD_FIELD_RING_REF, "%lu", 418 virt_to_gfn(info->page)); 419 if (ret) 420 goto error_xenbus; 421 ret = xenbus_printf(xbt, dev->nodename, XENKBD_FIELD_RING_GREF, 422 "%u", info->gref); 423 if (ret) 424 goto error_xenbus; 425 ret = xenbus_printf(xbt, dev->nodename, XENKBD_FIELD_EVT_CHANNEL, "%u", 426 evtchn); 427 if (ret) 428 goto error_xenbus; 429 ret = xenbus_transaction_end(xbt, 0); 430 if (ret) { 431 if (ret == -EAGAIN) 432 goto again; 433 xenbus_dev_fatal(dev, ret, "completing transaction"); 434 goto error_irqh; 435 } 436 437 xenbus_switch_state(dev, XenbusStateInitialised); 438 return 0; 439 440 error_xenbus: 441 xenbus_transaction_end(xbt, 1); 442 xenbus_dev_fatal(dev, ret, "writing xenstore"); 443 error_irqh: 444 unbind_from_irqhandler(info->irq, info); 445 info->irq = -1; 446 error_evtchan: 447 xenbus_free_evtchn(dev, evtchn); 448 error_grant: 449 gnttab_end_foreign_access(info->gref, 0, 0UL); 450 info->gref = -1; 451 return ret; 452 } 453 454 static void xenkbd_disconnect_backend(struct xenkbd_info *info) 455 { 456 if (info->irq >= 0) 457 unbind_from_irqhandler(info->irq, info); 458 info->irq = -1; 459 if (info->gref >= 0) 460 gnttab_end_foreign_access(info->gref, 0, 0UL); 461 info->gref = -1; 462 } 463 464 static void xenkbd_backend_changed(struct xenbus_device *dev, 465 enum xenbus_state backend_state) 466 { 467 switch (backend_state) { 468 case XenbusStateInitialising: 469 case XenbusStateInitialised: 470 case XenbusStateReconfiguring: 471 case XenbusStateReconfigured: 472 case XenbusStateUnknown: 473 break; 474 475 case XenbusStateInitWait: 476 xenbus_switch_state(dev, XenbusStateConnected); 477 break; 478 479 case XenbusStateConnected: 480 /* 481 * Work around xenbus race condition: If backend goes 482 * through InitWait to Connected fast enough, we can 483 * get Connected twice here. 484 */ 485 if (dev->state != XenbusStateConnected) 486 xenbus_switch_state(dev, XenbusStateConnected); 487 break; 488 489 case XenbusStateClosed: 490 if (dev->state == XenbusStateClosed) 491 break; 492 /* Missed the backend's CLOSING state -- fallthrough */ 493 case XenbusStateClosing: 494 xenbus_frontend_closed(dev); 495 break; 496 } 497 } 498 499 static const struct xenbus_device_id xenkbd_ids[] = { 500 { XENKBD_DRIVER_NAME }, 501 { "" } 502 }; 503 504 static struct xenbus_driver xenkbd_driver = { 505 .ids = xenkbd_ids, 506 .probe = xenkbd_probe, 507 .remove = xenkbd_remove, 508 .resume = xenkbd_resume, 509 .otherend_changed = xenkbd_backend_changed, 510 }; 511 512 static int __init xenkbd_init(void) 513 { 514 if (!xen_domain()) 515 return -ENODEV; 516 517 /* Nothing to do if running in dom0. */ 518 if (xen_initial_domain()) 519 return -ENODEV; 520 521 if (!xen_has_pv_devices()) 522 return -ENODEV; 523 524 return xenbus_register_frontend(&xenkbd_driver); 525 } 526 527 static void __exit xenkbd_cleanup(void) 528 { 529 xenbus_unregister_driver(&xenkbd_driver); 530 } 531 532 module_init(xenkbd_init); 533 module_exit(xenkbd_cleanup); 534 535 MODULE_DESCRIPTION("Xen virtual keyboard/pointer device frontend"); 536 MODULE_LICENSE("GPL"); 537 MODULE_ALIAS("xen:" XENKBD_DRIVER_NAME); 538