xref: /linux/drivers/input/misc/xen-kbdfront.c (revision b8321ed4a40c02054f930ca59d3570caa27bc86c) 
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 	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 int 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 	return 0;
421 }
422 
423 static int xenkbd_connect_backend(struct xenbus_device *dev,
424 				  struct xenkbd_info *info)
425 {
426 	int ret, evtchn;
427 	struct xenbus_transaction xbt;
428 
429 	ret = gnttab_grant_foreign_access(dev->otherend_id,
430 	                                  virt_to_gfn(info->page), 0);
431 	if (ret < 0)
432 		return ret;
433 	info->gref = ret;
434 
435 	ret = xenbus_alloc_evtchn(dev, &evtchn);
436 	if (ret)
437 		goto error_grant;
438 	ret = bind_evtchn_to_irqhandler(evtchn, input_handler,
439 					0, dev->devicetype, info);
440 	if (ret < 0) {
441 		xenbus_dev_fatal(dev, ret, "bind_evtchn_to_irqhandler");
442 		goto error_evtchan;
443 	}
444 	info->irq = ret;
445 
446  again:
447 	ret = xenbus_transaction_start(&xbt);
448 	if (ret) {
449 		xenbus_dev_fatal(dev, ret, "starting transaction");
450 		goto error_irqh;
451 	}
452 	ret = xenbus_printf(xbt, dev->nodename, XENKBD_FIELD_RING_REF, "%lu",
453 			    virt_to_gfn(info->page));
454 	if (ret)
455 		goto error_xenbus;
456 	ret = xenbus_printf(xbt, dev->nodename, XENKBD_FIELD_RING_GREF,
457 			    "%u", info->gref);
458 	if (ret)
459 		goto error_xenbus;
460 	ret = xenbus_printf(xbt, dev->nodename, XENKBD_FIELD_EVT_CHANNEL, "%u",
461 			    evtchn);
462 	if (ret)
463 		goto error_xenbus;
464 	ret = xenbus_transaction_end(xbt, 0);
465 	if (ret) {
466 		if (ret == -EAGAIN)
467 			goto again;
468 		xenbus_dev_fatal(dev, ret, "completing transaction");
469 		goto error_irqh;
470 	}
471 
472 	xenbus_switch_state(dev, XenbusStateInitialised);
473 	return 0;
474 
475  error_xenbus:
476 	xenbus_transaction_end(xbt, 1);
477 	xenbus_dev_fatal(dev, ret, "writing xenstore");
478  error_irqh:
479 	unbind_from_irqhandler(info->irq, info);
480 	info->irq = -1;
481  error_evtchan:
482 	xenbus_free_evtchn(dev, evtchn);
483  error_grant:
484 	gnttab_end_foreign_access(info->gref, 0UL);
485 	info->gref = -1;
486 	return ret;
487 }
488 
489 static void xenkbd_disconnect_backend(struct xenkbd_info *info)
490 {
491 	if (info->irq >= 0)
492 		unbind_from_irqhandler(info->irq, info);
493 	info->irq = -1;
494 	if (info->gref >= 0)
495 		gnttab_end_foreign_access(info->gref, 0UL);
496 	info->gref = -1;
497 }
498 
499 static void xenkbd_backend_changed(struct xenbus_device *dev,
500 				   enum xenbus_state backend_state)
501 {
502 	switch (backend_state) {
503 	case XenbusStateInitialising:
504 	case XenbusStateInitialised:
505 	case XenbusStateReconfiguring:
506 	case XenbusStateReconfigured:
507 	case XenbusStateUnknown:
508 		break;
509 
510 	case XenbusStateInitWait:
511 		xenbus_switch_state(dev, XenbusStateConnected);
512 		break;
513 
514 	case XenbusStateConnected:
515 		/*
516 		 * Work around xenbus race condition: If backend goes
517 		 * through InitWait to Connected fast enough, we can
518 		 * get Connected twice here.
519 		 */
520 		if (dev->state != XenbusStateConnected)
521 			xenbus_switch_state(dev, XenbusStateConnected);
522 		break;
523 
524 	case XenbusStateClosed:
525 		if (dev->state == XenbusStateClosed)
526 			break;
527 		fallthrough;	/* Missed the backend's CLOSING state */
528 	case XenbusStateClosing:
529 		xenbus_frontend_closed(dev);
530 		break;
531 	}
532 }
533 
534 static const struct xenbus_device_id xenkbd_ids[] = {
535 	{ XENKBD_DRIVER_NAME },
536 	{ "" }
537 };
538 
539 static struct xenbus_driver xenkbd_driver = {
540 	.ids = xenkbd_ids,
541 	.probe = xenkbd_probe,
542 	.remove = xenkbd_remove,
543 	.resume = xenkbd_resume,
544 	.otherend_changed = xenkbd_backend_changed,
545 	.not_essential = true,
546 };
547 
548 static int __init xenkbd_init(void)
549 {
550 	if (!xen_domain())
551 		return -ENODEV;
552 
553 	/* Nothing to do if running in dom0. */
554 	if (xen_initial_domain())
555 		return -ENODEV;
556 
557 	if (!xen_has_pv_devices())
558 		return -ENODEV;
559 
560 	return xenbus_register_frontend(&xenkbd_driver);
561 }
562 
563 static void __exit xenkbd_cleanup(void)
564 {
565 	xenbus_unregister_driver(&xenkbd_driver);
566 }
567 
568 module_init(xenkbd_init);
569 module_exit(xenkbd_cleanup);
570 
571 MODULE_DESCRIPTION("Xen virtual keyboard/pointer device frontend");
572 MODULE_LICENSE("GPL");
573 MODULE_ALIAS("xen:" XENKBD_DRIVER_NAME);
574