hvkbd.c revision 1.1 
1/*	$NetBSD: hvkbd.c,v 1.1 2019/05/24 14:28:48 nonaka Exp $	*/
2
3/*-
4 * Copyright (c) 2017 Microsoft Corp.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice unmodified, this list of conditions, and the following
12 *    disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 *    notice, this list of conditions and the following disclaimer in the
15 *    documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 * $FreeBSD: head/sys/dev/hyperv/input/hv_kbd.c 317821 2017-05-05 03:28:30Z sephe $
29 * $FreeBSD: head/sys/dev/hyperv/input/hv_kbdc.c 320490 2017-06-30 03:01:22Z sephe $
30 * $FreeBSD: head/sys/dev/hyperv/input/hv_kbdc.h 316515 2017-04-05 05:01:23Z sephe $
31 */
32
33#ifdef _KERNEL_OPT
34#include "opt_pckbd_layout.h"
35#include "opt_wsdisplay_compat.h"
36#endif /* _KERNEL_OPT */
37
38#include <sys/cdefs.h>
39__KERNEL_RCSID(0, "$NetBSD: hvkbd.c,v 1.1 2019/05/24 14:28:48 nonaka Exp $");
40
41#include <sys/param.h>
42#include <sys/systm.h>
43#include <sys/device.h>
44#include <sys/mutex.h>
45#include <sys/kernel.h>
46#include <sys/kmem.h>
47#include <sys/module.h>
48#include <sys/pmf.h>
49#include <sys/proc.h>
50#include <sys/queue.h>
51
52#include <dev/hyperv/vmbusvar.h>
53#include <dev/hyperv/hvkbdvar.h>
54
55#include <dev/wscons/wsconsio.h>
56#include <dev/wscons/wskbdvar.h>
57#include <dev/wscons/wsksymdef.h>
58#include <dev/wscons/wsksymvar.h>
59#include <dev/pckbport/wskbdmap_mfii.h>
60
61#define HVKBD_BUFSIZE		(4 * PAGE_SIZE)
62#define HVKBD_TX_RING_SIZE	(10 * PAGE_SIZE)
63#define HVKBD_RX_RING_SIZE	(10 * PAGE_SIZE)
64
65#define HVKBD_VER_MAJOR		(1)
66#define HVKBD_VER_MINOR		(0)
67#define HVKBD_VERSION		((HVKBD_VER_MAJOR << 16) | HVKBD_VER_MINOR)
68
69enum hvkbd_msg_type {
70	HVKBD_PROTO_REQUEST		= 1,
71	HVKBD_PROTO_RESPONSE		= 2,
72	HVKBD_PROTO_EVENT		= 3,
73	HVKBD_PROTO_LED_INDICATORS	= 4
74};
75
76struct hvkbd_msg_hdr {
77	uint32_t		type;
78} __packed;
79
80struct hvkbd_proto_req {
81	struct hvkbd_msg_hdr	hdr;
82	uint32_t		ver;
83} __packed;
84
85struct hvkbd_proto_resp {
86	struct hvkbd_msg_hdr	hdr;
87	uint32_t		status;
88#define	RESP_STATUS_ACCEPTED	__BIT(0)
89} __packed;
90
91struct keystroke {
92	uint16_t		makecode;
93	uint16_t		pad0;
94	uint32_t		info;
95#define KS_INFO_UNICODE		__BIT(0)
96#define KS_INFO_BREAK		__BIT(1)
97#define KS_INFO_E0		__BIT(2)
98#define KS_INFO_E1		__BIT(3)
99} __packed;
100
101struct hvkbd_keystroke {
102	struct hvkbd_msg_hdr	hdr;
103	struct keystroke	ks;
104} __packed;
105
106struct hvkbd_keystroke_info {
107	LIST_ENTRY(hvkbd_keystroke_info)	link;
108	STAILQ_ENTRY(hvkbd_keystroke_info)	slink;
109	struct keystroke			ks;
110};
111
112#define	HVKBD_KEYBUF_SIZE	16
113
114struct hvkbd_softc {
115	device_t				sc_dev;
116
117	struct vmbus_channel    		*sc_chan;
118	void					*sc_buf;
119
120	kmutex_t				sc_ks_lock;
121	LIST_HEAD(, hvkbd_keystroke_info)	sc_ks_free;
122	STAILQ_HEAD(, hvkbd_keystroke_info)	sc_ks_queue;
123
124	int					sc_enabled;
125	int					sc_polling;
126	int					sc_console_keyboard;
127#if defined(WSDISPLAY_COMPAT_RAWKBD)
128	int					sc_rawkbd;
129#endif
130
131	int					sc_connected;
132	uint32_t				sc_connect_status;
133
134	device_t				sc_wskbddev;
135};
136
137static int	hvkbd_match(device_t, cfdata_t, void *);
138static void	hvkbd_attach(device_t, device_t, void *);
139
140CFATTACH_DECL_NEW(hvkbd, sizeof(struct hvkbd_softc),
141    hvkbd_match, hvkbd_attach, NULL, NULL);
142
143static int	hvkbd_alloc_keybuf(struct hvkbd_softc *);
144static void	hvkbd_free_keybuf(struct hvkbd_softc *);
145
146static int	hvkbd_enable(void *, int);
147static void	hvkbd_set_leds(void *, int);
148static int	hvkbd_ioctl(void *, u_long, void *, int, struct lwp *);
149
150static const struct wskbd_accessops hvkbd_accessops = {
151	hvkbd_enable,
152	hvkbd_set_leds,
153	hvkbd_ioctl,
154};
155
156static const struct wskbd_mapdata hvkbd_keymapdata = {
157	pckbd_keydesctab,
158#if defined(PCKBD_LAYOUT)
159	PCKBD_LAYOUT,
160#else
161	KB_US,
162#endif
163};
164
165static int	hvkbd_connect(struct hvkbd_softc *);
166static void	hvkbd_intr(void *);
167
168static void	hvkbd_cngetc(void *, u_int *, int *);
169static void	hvkbd_cnpollc(void *, int);
170
171static const struct wskbd_consops hvkbd_consops = {
172	.getc =  hvkbd_cngetc,
173	.pollc = hvkbd_cnpollc,
174	.bell =  NULL,
175};
176
177static int	hvkbd_is_console;
178
179static int
180hvkbd_match(device_t parent, cfdata_t cf, void *aux)
181{
182	struct vmbus_attach_args *aa = aux;
183
184	if (memcmp(aa->aa_type, &hyperv_guid_kbd, sizeof(*aa->aa_type)) != 0)
185		return 0;
186
187	/* If hvkbd(4) is not console, we use pckbd(4) in Gen.1 VM. */
188	if (!hvkbd_is_console && hyperv_is_gen1())
189		return 0;
190
191	return 1;
192}
193
194static void
195hvkbd_attach(device_t parent, device_t self, void *aux)
196{
197	struct hvkbd_softc *sc = device_private(self);
198	struct vmbus_attach_args *aa = aux;
199	struct wskbddev_attach_args a;
200
201	sc->sc_dev = self;
202	sc->sc_chan = aa->aa_chan;
203
204	aprint_naive("\n");
205	aprint_normal(": Hyper-V Synthetic Keyboard\n");
206
207	mutex_init(&sc->sc_ks_lock, MUTEX_DEFAULT, IPL_TTY);
208	LIST_INIT(&sc->sc_ks_free);
209	STAILQ_INIT(&sc->sc_ks_queue);
210	hvkbd_alloc_keybuf(sc);
211
212	sc->sc_buf = kmem_zalloc(HVKBD_BUFSIZE, cold ? KM_NOSLEEP : KM_SLEEP);
213	if (sc->sc_buf == NULL) {
214		aprint_error_dev(self,
215		    "failed to allocate channel data buffer\n");
216		return;
217	}
218
219	if (vmbus_channel_setdeferred(sc->sc_chan, device_xname(self))) {
220		aprint_error_dev(self,
221		    "failed to create the interrupt thread\n");
222		goto free_buf;
223	}
224
225	sc->sc_chan->ch_flags &= ~CHF_BATCHED;
226	if (vmbus_channel_open(sc->sc_chan,
227	    HVKBD_TX_RING_SIZE + HVKBD_RX_RING_SIZE, NULL, 0, hvkbd_intr, sc)) {
228		aprint_error_dev(self, "failed to open channel\n");
229		goto free_buf;
230	}
231
232	if (hvkbd_connect(sc))
233		goto free_buf;
234
235	if (!pmf_device_register(self, NULL, NULL))
236		aprint_error_dev(self, "couldn't establish power handler\n");
237
238	sc->sc_console_keyboard = hvkbd_is_console;
239	if (hvkbd_is_console)
240		hvkbd_is_console = 0;
241
242	if (sc->sc_console_keyboard) {
243		wskbd_cnattach(&hvkbd_consops, sc, &hvkbd_keymapdata);
244		hvkbd_enable(sc, 1);
245	}
246
247	a.console = sc->sc_console_keyboard;
248	a.keymap = &hvkbd_keymapdata;
249	a.accessops = &hvkbd_accessops;
250	a.accesscookie = sc;
251	sc->sc_wskbddev = config_found(self, &a, wskbddevprint);
252	return;
253
254free_buf:
255	if (sc->sc_buf != NULL) {
256		kmem_free(sc->sc_buf, HVKBD_BUFSIZE);
257		sc->sc_buf = NULL;
258	}
259	hvkbd_free_keybuf(sc);
260}
261
262static int
263hvkbd_alloc_keybuf(struct hvkbd_softc *sc)
264{
265	struct hvkbd_keystroke_info *ksi;
266	int i;
267
268	for (i = 0; i < HVKBD_KEYBUF_SIZE; i++) {
269		ksi = kmem_zalloc(sizeof(*ksi), cold ? KM_NOSLEEP : KM_SLEEP);
270		if (ksi != NULL) {
271			LIST_INSERT_HEAD(&sc->sc_ks_free, ksi, link);
272			continue;
273		}
274
275		while ((ksi = LIST_FIRST(&sc->sc_ks_free)) != NULL) {
276			LIST_REMOVE(ksi, link);
277			kmem_free(ksi, sizeof(*ksi));
278		}
279		return ENOMEM;
280
281	}
282
283	return 0;
284}
285
286static void
287hvkbd_free_keybuf(struct hvkbd_softc *sc)
288{
289	struct hvkbd_keystroke_info *ksi;
290
291	while ((ksi = STAILQ_FIRST(&sc->sc_ks_queue)) != NULL) {
292		STAILQ_REMOVE(&sc->sc_ks_queue, ksi, hvkbd_keystroke_info,
293		    slink);
294		kmem_free(ksi, sizeof(*ksi));
295	}
296	while ((ksi = LIST_FIRST(&sc->sc_ks_free)) != NULL) {
297		LIST_REMOVE(ksi, link);
298		kmem_free(ksi, sizeof(*ksi));
299	}
300}
301
302int
303hvkbd_enable(void *v, int on)
304{
305	struct hvkbd_softc *sc = v;
306
307	sc->sc_enabled = on;
308
309	return 0;
310}
311
312static void
313hvkbd_set_leds(void *v, int leds)
314{
315}
316
317static int
318hvkbd_ioctl(void *v, u_long cmd, void *data, int flag, struct lwp *l)
319{
320	struct hvkbd_softc *sc = v;
321
322	switch (cmd) {
323	case WSKBDIO_GTYPE:
324		*(int *)data = WSKBD_TYPE_HYPERV;
325		return 0;
326
327	case WSKBDIO_SETLEDS:
328		hvkbd_set_leds(v, *(int *)data);
329		return 0;
330
331	case WSKBDIO_GETLEDS:
332		*(int *)data = 0;
333		return 0;
334
335#if defined(WSDISPLAY_COMPAT_RAWKBD)
336	case WSKBDIO_SETMODE:
337		sc->sc_rawkbd = (*(int *)data == WSKBD_RAW);
338		return 0;
339#endif
340	}
341
342	return EPASSTHROUGH;
343}
344
345static int
346hvkbd_connect(struct hvkbd_softc *sc)
347{
348	struct hvkbd_proto_req req;
349	int timo = 100;
350	int error, s;
351
352	sc->sc_connected = 0;
353
354	memset(&req, 0, sizeof(req));
355	req.hdr.type = HVKBD_PROTO_REQUEST;
356	req.ver = HVKBD_VERSION;
357	error = vmbus_channel_send(sc->sc_chan, &req, sizeof(req),
358	    0, VMBUS_CHANPKT_TYPE_INBAND, VMBUS_CHANPKT_FLAG_RC);
359	if (error) {
360		aprint_error_dev(sc->sc_dev, "failed to send connect: %d\n",
361		    error);
362		return error;
363	}
364
365	do {
366		if (cold)
367			delay(1000);
368		else
369			tsleep(sc, PRIBIO | PCATCH, "hvkbdcon", 1);
370		s = spltty();
371		hvkbd_intr(sc);
372		splx(s);
373	} while (--timo > 0 && sc->sc_connected == 0);
374
375	if (timo == 0 && sc->sc_connected == 0) {
376		aprint_error_dev(sc->sc_dev, "connect timed out\n");
377		return ETIMEDOUT;
378	}
379
380	if (!(sc->sc_connect_status & RESP_STATUS_ACCEPTED)) {
381		aprint_error_dev(sc->sc_dev, "protocol request failed\n");
382		return ENODEV;
383	}
384
385	return 0;
386}
387
388static int
389hvkbd_keybuf_add_keystroke(struct hvkbd_softc *sc, const struct keystroke *ks)
390{
391	struct hvkbd_keystroke_info *ksi;
392
393	mutex_enter(&sc->sc_ks_lock);
394	ksi = LIST_FIRST(&sc->sc_ks_free);
395	if (ksi != NULL) {
396		LIST_REMOVE(ksi, link);
397		ksi->ks = *ks;
398		STAILQ_INSERT_TAIL(&sc->sc_ks_queue, ksi, slink);
399	}
400	mutex_exit(&sc->sc_ks_lock);
401
402	return (ksi != NULL) ? 0 : 1;
403}
404
405static int
406hvkbd_decode(struct hvkbd_softc *sc, u_int *type, int *scancode)
407{
408	struct hvkbd_keystroke_info *ksi;
409	struct keystroke ks;
410
411	mutex_enter(&sc->sc_ks_lock);
412	ksi = STAILQ_FIRST(&sc->sc_ks_queue);
413	if (ksi != NULL) {
414		STAILQ_REMOVE_HEAD(&sc->sc_ks_queue, slink);
415		ks = ksi->ks;
416		LIST_INSERT_HEAD(&sc->sc_ks_free, ksi, link);
417	}
418	mutex_exit(&sc->sc_ks_lock);
419
420	if (ksi == NULL)
421		return 0;
422
423	/*
424	 * XXX: Hyper-V host send unicode to VM through 'Type clipboard text',
425	 * the mapping from unicode to scancode depends on the keymap.
426	 * It is so complicated that we do not plan to support it yet.
427	 */
428	if (ks.info & KS_INFO_UNICODE)
429		return 0;
430
431	*type = (ks.info & KS_INFO_BREAK) ?
432	    WSCONS_EVENT_KEY_UP : WSCONS_EVENT_KEY_DOWN;
433	*scancode = ks.makecode;
434	return 1;
435}
436
437static int
438hvkbd_encode(struct hvkbd_softc *sc, u_char *buf, int *len)
439{
440	struct hvkbd_keystroke_info *ksi;
441	struct keystroke ks;
442	int i;
443
444	mutex_enter(&sc->sc_ks_lock);
445	ksi = STAILQ_FIRST(&sc->sc_ks_queue);
446	if (ksi != NULL) {
447		STAILQ_REMOVE_HEAD(&sc->sc_ks_queue, slink);
448		ks = ksi->ks;
449		LIST_INSERT_HEAD(&sc->sc_ks_free, ksi, link);
450	}
451	mutex_exit(&sc->sc_ks_lock);
452
453	if (ksi == NULL)
454		return 0;
455
456	/*
457	 * XXX: Hyper-V host send unicode to VM through 'Type clipboard text',
458	 * the mapping from unicode to scancode depends on the keymap.
459	 * It is so complicated that we do not plan to support it yet.
460	 */
461	if (ks.info & KS_INFO_UNICODE)
462		return 0;
463
464	i = 0;
465	if (ks.info & (KS_INFO_E0|KS_INFO_E1)) {
466		if (ks.info & KS_INFO_E0)
467			buf[i++] = 0xe0;
468		else
469			buf[i++] = 0xe1;
470	}
471	if (ks.info & KS_INFO_BREAK)
472		buf[i++] = (u_char)ks.makecode & 0x80;
473	else
474		buf[i++] = (u_char)ks.makecode;
475
476	KDASSERT(i <= *len);
477	*len = i;
478
479	return 1;
480}
481
482static void
483hvkbd_intr(void *xsc)
484{
485	struct hvkbd_softc *sc = xsc;
486	struct vmbus_chanpkt_hdr *cph;
487	const struct hvkbd_msg_hdr *hdr;
488	const struct hvkbd_proto_resp *rsp;
489	const struct hvkbd_keystroke *ks;
490	uint64_t rid;
491	uint32_t rlen;
492	u_int type;
493	int key, error;
494
495	for (;;) {
496		error = vmbus_channel_recv(sc->sc_chan, sc->sc_buf,
497		    HVKBD_BUFSIZE, &rlen, &rid, 1);
498		if (error != 0 || rlen == 0) {
499			if (error != EAGAIN)
500				device_printf(sc->sc_dev,
501				    "failed to receive a reply packet\n");
502			return;
503		}
504
505		cph = (struct vmbus_chanpkt_hdr *)sc->sc_buf;
506		switch (cph->cph_type) {
507		case VMBUS_CHANPKT_TYPE_INBAND:
508			hdr = VMBUS_CHANPKT_CONST_DATA(cph);
509			if (rlen < sizeof(*hdr)) {
510				device_printf(sc->sc_dev, "Illegal packet\n");
511				continue;
512			}
513
514			switch (hdr->type) {
515			case HVKBD_PROTO_RESPONSE:
516				if (!sc->sc_connected) {
517					rsp = VMBUS_CHANPKT_CONST_DATA(cph);
518					if (rlen < sizeof(*rsp)) {
519						device_printf(sc->sc_dev,
520						    "Illegal resp packet\n");
521						break;
522					}
523					sc->sc_connect_status = rsp->status;
524					sc->sc_connected = 1;
525					wakeup(sc);
526				}
527				break;
528
529			case HVKBD_PROTO_EVENT:
530				if (sc->sc_wskbddev == NULL || !sc->sc_enabled)
531					break;
532
533				ks = VMBUS_CHANPKT_CONST_DATA(cph);
534				hvkbd_keybuf_add_keystroke(sc, &ks->ks);
535				if (sc->sc_polling)
536					break;
537
538#if defined(WSDISPLAY_COMPAT_RAWKBD)
539				if (sc->sc_rawkbd) {
540					u_char buf[2];
541					int len;
542
543					len = sizeof(buf);
544					if (hvkbd_encode(sc, buf, &len)) {
545						wskbd_rawinput(sc->sc_wskbddev,
546						    buf, len);
547					}
548					break;
549				}
550#endif
551				if (hvkbd_decode(sc, &type, &key))
552					wskbd_input(sc->sc_wskbddev, type, key);
553				break;
554
555			case HVKBD_PROTO_REQUEST:
556			case HVKBD_PROTO_LED_INDICATORS:
557				device_printf(sc->sc_dev,
558				    "unhandled message: %d\n", hdr->type);
559				break;
560
561			default:
562				device_printf(sc->sc_dev,
563				    "unknown message: %d\n", hdr->type);
564				break;
565			}
566			break;
567
568		case VMBUS_CHANPKT_TYPE_COMP:
569		case VMBUS_CHANPKT_TYPE_RXBUF:
570			device_printf(sc->sc_dev, "unhandled event: %d\n",
571			    cph->cph_type);
572			break;
573
574		default:
575			device_printf(sc->sc_dev, "unknown event: %d\n",
576			    cph->cph_type);
577			break;
578		}
579	}
580}
581
582int
583hvkbd_cnattach(void)
584{
585
586	hvkbd_is_console = 1;
587
588	return 0;
589}
590
591static void
592hvkbd_cngetc(void *v, u_int *type, int *data)
593{
594	struct hvkbd_softc *sc = v;
595
596	while (!hvkbd_decode(sc, type, data))
597		hvkbd_intr(sc);
598}
599
600static void
601hvkbd_cnpollc(void *v, int on)
602{
603	struct hvkbd_softc *sc = v;
604
605	sc->sc_polling = on;
606}
607
608MODULE(MODULE_CLASS_DRIVER, hvkbd, "vmbus");
609
610#ifdef _MODULE
611#include "ioconf.c"
612#endif
613
614static int
615hvkbd_modcmd(modcmd_t cmd, void *aux)
616{
617	int error = 0;
618
619	switch (cmd) {
620	case MODULE_CMD_INIT:
621#ifdef _MODULE
622		error = config_init_component(cfdriver_ioconf_hvkbd,
623		    cfattach_ioconf_hvkbd, cfdata_ioconf_hvkbd);
624#endif
625		break;
626
627	case MODULE_CMD_FINI:
628#ifdef _MODULE
629		error = config_fini_component(cfdriver_ioconf_hvtkbd,
630		    cfattach_ioconf_hvkbd, cfdata_ioconf_hvkbd);
631#endif
632		break;
633
634	case MODULE_CMD_AUTOUNLOAD:
635		error = EBUSY;
636		break;
637
638	default:
639		error = ENOTTY;
640		break;
641	}
642
643	return error;
644}
645