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(info->ptr, REL_X, motion->rel_x); 70 input_report_rel(info->ptr, REL_Y, motion->rel_y); 71 if (motion->rel_z) 72 input_report_rel(info->ptr, REL_WHEEL, -motion->rel_z); 73 input_sync(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(info->ptr, ABS_X, pos->abs_x); 83 input_report_abs(info->ptr, ABS_Y, pos->abs_y); 84 if (pos->rel_z) 85 input_report_rel(info->ptr, REL_WHEEL, -pos->rel_z); 86 input_sync(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, 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(info->mtouch, mtouch->contact_id); 122 } 123 124 switch (mtouch->event_type) { 125 case XENKBD_MT_EV_DOWN: 126 input_mt_report_slot_state(info->mtouch, MT_TOOL_FINGER, true); 127 fallthrough; 128 129 case XENKBD_MT_EV_MOTION: 130 input_report_abs(info->mtouch, ABS_MT_POSITION_X, 131 mtouch->u.pos.abs_x); 132 input_report_abs(info->mtouch, ABS_MT_POSITION_Y, 133 mtouch->u.pos.abs_y); 134 break; 135 136 case XENKBD_MT_EV_SHAPE: 137 input_report_abs(info->mtouch, ABS_MT_TOUCH_MAJOR, 138 mtouch->u.shape.major); 139 input_report_abs(info->mtouch, ABS_MT_TOUCH_MINOR, 140 mtouch->u.shape.minor); 141 break; 142 143 case XENKBD_MT_EV_ORIENT: 144 input_report_abs(info->mtouch, ABS_MT_ORIENTATION, 145 mtouch->u.orientation); 146 break; 147 148 case XENKBD_MT_EV_UP: 149 input_mt_report_slot_inactive(info->mtouch); 150 break; 151 152 case XENKBD_MT_EV_SYN: 153 input_mt_sync_frame(info->mtouch); 154 input_sync(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, &event->motion); 165 break; 166 167 case XENKBD_TYPE_KEY: 168 xenkbd_handle_key_event(info, &event->key); 169 break; 170 171 case XENKBD_TYPE_POS: 172 xenkbd_handle_position_event(info, &event->pos); 173 break; 174 175 case XENKBD_TYPE_MTOUCH: 176 xenkbd_handle_mt_event(info, &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, &XENKBD_IN_RING_REF(page, cons)); 193 mb(); /* ensure we got ring contents */ 194 page->in_cons = cons; 195 notify_remote_via_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(sizeof(*info), GFP_KERNEL); 209 if (!info) { 210 xenbus_dev_fatal(dev, -ENOMEM, "allocating info structure"); 211 return -ENOMEM; 212 } 213 dev_set_drvdata(&dev->dev, info); 214 info->xbdev = dev; 215 info->irq = -1; 216 info->gref = -1; 217 snprintf(info->phys, sizeof(info->phys), "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(dev->otherend, 228 XENKBD_FIELD_FEAT_DSBL_KEYBRD, 0); 229 230 with_ptr = !xenbus_read_unsigned(dev->otherend, 231 XENKBD_FIELD_FEAT_DSBL_POINTER, 0); 232 233 /* Direct logic: if set, then create multi-touch device. */ 234 with_mtouch = xenbus_read_unsigned(dev->otherend, 235 XENKBD_FIELD_FEAT_MTOUCH, 0); 236 if (with_mtouch) { 237 ret = xenbus_write(XBT_NIL, dev->nodename, 238 XENKBD_FIELD_REQ_MTOUCH, "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); 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); 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(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(dev->otherend_id, 429 virt_to_gfn(info->page), 0); 430 if (ret < 0) 431 return ret; 432 info->gref = ret; 433 434 ret = xenbus_alloc_evtchn(dev, &evtchn); 435 if (ret) 436 goto error_grant; 437 ret = bind_evtchn_to_irqhandler(evtchn, input_handler, 438 0, dev->devicetype, info); 439 if (ret < 0) { 440 xenbus_dev_fatal(dev, ret, "bind_evtchn_to_irqhandler"); 441 goto error_evtchan; 442 } 443 info->irq = ret; 444 445 again: 446 ret = xenbus_transaction_start(&xbt); 447 if (ret) { 448 xenbus_dev_fatal(dev, ret, "starting transaction"); 449 goto error_irqh; 450 } 451 ret = xenbus_printf(xbt, dev->nodename, XENKBD_FIELD_RING_REF, "%lu", 452 virt_to_gfn(info->page)); 453 if (ret) 454 goto error_xenbus; 455 ret = xenbus_printf(xbt, dev->nodename, XENKBD_FIELD_RING_GREF, 456 "%u", info->gref); 457 if (ret) 458 goto error_xenbus; 459 ret = xenbus_printf(xbt, dev->nodename, XENKBD_FIELD_EVT_CHANNEL, "%u", 460 evtchn); 461 if (ret) 462 goto error_xenbus; 463 ret = xenbus_transaction_end(xbt, 0); 464 if (ret) { 465 if (ret == -EAGAIN) 466 goto again; 467 xenbus_dev_fatal(dev, ret, "completing transaction"); 468 goto error_irqh; 469 } 470 471 xenbus_switch_state(dev, XenbusStateInitialised); 472 return 0; 473 474 error_xenbus: 475 xenbus_transaction_end(xbt, 1); 476 xenbus_dev_fatal(dev, ret, "writing xenstore"); 477 error_irqh: 478 unbind_from_irqhandler(info->irq, info); 479 info->irq = -1; 480 error_evtchan: 481 xenbus_free_evtchn(dev, evtchn); 482 error_grant: 483 gnttab_end_foreign_access(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(info->irq, info); 492 info->irq = -1; 493 if (info->gref >= 0) 494 gnttab_end_foreign_access(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, 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, 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(&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