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
35struct 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
48enum { KPARAM_X, KPARAM_Y, KPARAM_CNT };
49static int ptr_size[KPARAM_CNT] = { XENFB_WIDTH, XENFB_HEIGHT };
50module_param_array(ptr_size, int, NULL, 0444);
51MODULE_PARM_DESC(ptr_size,
52	"Pointing device width, height in pixels (default 800,600)");
53
54static void xenkbd_remove(struct xenbus_device *);
55static int xenkbd_connect_backend(struct xenbus_device *, struct xenkbd_info *);
56static 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
63static 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
76static 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
89static 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
113static 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
159static 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
181static 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
200static 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
398static 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
407static 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
422static 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
488static 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
498static 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
533static const struct xenbus_device_id xenkbd_ids[] = {
534	{ XENKBD_DRIVER_NAME },
535	{ "" }
536};
537
538static 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
547static 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
562static void __exit xenkbd_cleanup(void)
563{
564	xenbus_unregister_driver(&xenkbd_driver);
565}
566
567module_init(xenkbd_init);
568module_exit(xenkbd_cleanup);
569
570MODULE_DESCRIPTION("Xen virtual keyboard/pointer device frontend");
571MODULE_LICENSE("GPL");
572MODULE_ALIAS("xen:" XENKBD_DRIVER_NAME);
573