xref: /freebsd/sys/dev/atkbdc/atkbd.c (revision f86e7267f5fd81461dbf15ee92763403191c43b9)
1617b9080SKazutaka YOKOTA /*-
2718cf2ccSPedro F. Giffuni  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3718cf2ccSPedro F. Giffuni  *
4617b9080SKazutaka YOKOTA  * Copyright (c) 1999 Kazutaka YOKOTA <yokota@zodiac.mech.utsunomiya-u.ac.jp>
5617b9080SKazutaka YOKOTA  * All rights reserved.
6617b9080SKazutaka YOKOTA  *
7617b9080SKazutaka YOKOTA  * Redistribution and use in source and binary forms, with or without
8617b9080SKazutaka YOKOTA  * modification, are permitted provided that the following conditions
9617b9080SKazutaka YOKOTA  * are met:
10617b9080SKazutaka YOKOTA  * 1. Redistributions of source code must retain the above copyright
11617b9080SKazutaka YOKOTA  *    notice, this list of conditions and the following disclaimer as
12617b9080SKazutaka YOKOTA  *    the first lines of this file unmodified.
13617b9080SKazutaka YOKOTA  * 2. Redistributions in binary form must reproduce the above copyright
14617b9080SKazutaka YOKOTA  *    notice, this list of conditions and the following disclaimer in the
15617b9080SKazutaka YOKOTA  *    documentation and/or other materials provided with the distribution.
16617b9080SKazutaka YOKOTA  *
17617b9080SKazutaka YOKOTA  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
18617b9080SKazutaka YOKOTA  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19617b9080SKazutaka YOKOTA  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20617b9080SKazutaka YOKOTA  * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
21617b9080SKazutaka YOKOTA  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22617b9080SKazutaka YOKOTA  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23617b9080SKazutaka YOKOTA  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24617b9080SKazutaka YOKOTA  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25617b9080SKazutaka YOKOTA  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26617b9080SKazutaka YOKOTA  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27617b9080SKazutaka YOKOTA  *
28617b9080SKazutaka YOKOTA  */
29617b9080SKazutaka YOKOTA 
30aad970f1SDavid E. O'Brien #include <sys/cdefs.h>
31aad970f1SDavid E. O'Brien __FBSDID("$FreeBSD$");
32aad970f1SDavid E. O'Brien 
33617b9080SKazutaka YOKOTA #include "opt_kbd.h"
34e9deda23SKazutaka YOKOTA #include "opt_atkbd.h"
3538ae0c59SOleksandr Tymoshenko #include "opt_evdev.h"
36617b9080SKazutaka YOKOTA 
37617b9080SKazutaka YOKOTA #include <sys/param.h>
38617b9080SKazutaka YOKOTA #include <sys/systm.h>
39617b9080SKazutaka YOKOTA #include <sys/kernel.h>
40d3c87b85SKazutaka YOKOTA #include <sys/bus.h>
41520b6353SMarius Strobl #include <sys/eventhandler.h>
42617b9080SKazutaka YOKOTA #include <sys/proc.h>
43104a9b7eSAlexander Kabaev #include <sys/limits.h>
44617b9080SKazutaka YOKOTA #include <sys/malloc.h>
45617b9080SKazutaka YOKOTA 
46db3e34cbSKazutaka YOKOTA #include <machine/bus.h>
47db3e34cbSKazutaka YOKOTA #include <machine/resource.h>
48db3e34cbSKazutaka YOKOTA 
4976495257SKazutaka YOKOTA #include <sys/kbio.h>
50617b9080SKazutaka YOKOTA #include <dev/kbd/kbdreg.h>
51520b6353SMarius Strobl #include <dev/atkbdc/atkbdreg.h>
52520b6353SMarius Strobl #include <dev/atkbdc/atkbdcreg.h>
53f359876fSKazutaka YOKOTA 
5438ae0c59SOleksandr Tymoshenko #ifdef EVDEV_SUPPORT
5538ae0c59SOleksandr Tymoshenko #include <dev/evdev/evdev.h>
5638ae0c59SOleksandr Tymoshenko #include <dev/evdev/input.h>
5738ae0c59SOleksandr Tymoshenko #endif
5838ae0c59SOleksandr Tymoshenko 
59fadf3fb9SJohn Baldwin typedef struct atkbd_state {
60fadf3fb9SJohn Baldwin 	KBDC		kbdc;		/* keyboard controller */
61fadf3fb9SJohn Baldwin 	int		ks_mode;	/* input mode (K_XLATE,K_RAW,K_CODE) */
62fadf3fb9SJohn Baldwin 	int		ks_flags;	/* flags */
63fadf3fb9SJohn Baldwin #define COMPOSE		(1 << 0)
64fadf3fb9SJohn Baldwin 	int		ks_polling;
65fadf3fb9SJohn Baldwin 	int		ks_state;	/* shift/lock key state */
66fadf3fb9SJohn Baldwin 	int		ks_accents;	/* accent key index (> 0) */
67fadf3fb9SJohn Baldwin 	u_int		ks_composed_char; /* composed char code (> 0) */
68fadf3fb9SJohn Baldwin 	u_char		ks_prefix;	/* AT scan code prefix */
69fadf3fb9SJohn Baldwin 	struct callout	ks_timer;
7038ae0c59SOleksandr Tymoshenko #ifdef EVDEV_SUPPORT
7138ae0c59SOleksandr Tymoshenko 	struct evdev_dev *ks_evdev;
7238ae0c59SOleksandr Tymoshenko 	int		ks_evdev_state;
7338ae0c59SOleksandr Tymoshenko #endif
74fadf3fb9SJohn Baldwin } atkbd_state_t;
75fadf3fb9SJohn Baldwin 
76fadf3fb9SJohn Baldwin static void		atkbd_timeout(void *arg);
77520b6353SMarius Strobl static void		atkbd_shutdown_final(void *v);
786c176113SMichael Gmelin static int		atkbd_reset(KBDC kbdc, int flags, int c);
796c176113SMichael Gmelin 
806c176113SMichael Gmelin #define HAS_QUIRK(p, q)		(((atkbdc_softc_t *)(p))->quirks & q)
816c176113SMichael Gmelin #define ALLOW_DISABLE_KBD(kbdc)	!HAS_QUIRK(kbdc, KBDC_QUIRK_KEEP_ACTIVATED)
82617b9080SKazutaka YOKOTA 
83b19f7eecSRoger Pau Monné #define DEFAULT_DELAY		0x1  /* 500ms */
84b19f7eecSRoger Pau Monné #define DEFAULT_RATE		0x10 /* 14Hz */
85b19f7eecSRoger Pau Monné 
8638ae0c59SOleksandr Tymoshenko #ifdef EVDEV_SUPPORT
8738ae0c59SOleksandr Tymoshenko #define PS2_KEYBOARD_VENDOR	1
8838ae0c59SOleksandr Tymoshenko #define PS2_KEYBOARD_PRODUCT	1
8938ae0c59SOleksandr Tymoshenko #endif
9038ae0c59SOleksandr Tymoshenko 
91617b9080SKazutaka YOKOTA int
920897438aSWarner Losh atkbd_probe_unit(device_t dev, int irq, int flags)
93617b9080SKazutaka YOKOTA {
94617b9080SKazutaka YOKOTA 	keyboard_switch_t *sw;
95617b9080SKazutaka YOKOTA 	int args[2];
96e9deda23SKazutaka YOKOTA 	int error;
97617b9080SKazutaka YOKOTA 
98617b9080SKazutaka YOKOTA 	sw = kbd_get_switch(ATKBD_DRIVER_NAME);
99617b9080SKazutaka YOKOTA 	if (sw == NULL)
100617b9080SKazutaka YOKOTA 		return ENXIO;
101617b9080SKazutaka YOKOTA 
1020897438aSWarner Losh 	args[0] = device_get_unit(device_get_parent(dev));
103617b9080SKazutaka YOKOTA 	args[1] = irq;
1040897438aSWarner Losh 	error = (*sw->probe)(device_get_unit(dev), args, flags);
105e9deda23SKazutaka YOKOTA 	if (error)
106e9deda23SKazutaka YOKOTA 		return error;
107e9deda23SKazutaka YOKOTA 	return 0;
108617b9080SKazutaka YOKOTA }
109617b9080SKazutaka YOKOTA 
110617b9080SKazutaka YOKOTA int
1110897438aSWarner Losh atkbd_attach_unit(device_t dev, keyboard_t **kbd, int irq, int flags)
112617b9080SKazutaka YOKOTA {
113617b9080SKazutaka YOKOTA 	keyboard_switch_t *sw;
114fadf3fb9SJohn Baldwin 	atkbd_state_t *state;
115e9deda23SKazutaka YOKOTA 	int args[2];
116617b9080SKazutaka YOKOTA 	int error;
1170897438aSWarner Losh 	int unit;
118617b9080SKazutaka YOKOTA 
119617b9080SKazutaka YOKOTA 	sw = kbd_get_switch(ATKBD_DRIVER_NAME);
120617b9080SKazutaka YOKOTA 	if (sw == NULL)
121617b9080SKazutaka YOKOTA 		return ENXIO;
122617b9080SKazutaka YOKOTA 
123617b9080SKazutaka YOKOTA 	/* reset, initialize and enable the device */
1240897438aSWarner Losh 	unit = device_get_unit(dev);
1250897438aSWarner Losh 	args[0] = device_get_unit(device_get_parent(dev));
126e9deda23SKazutaka YOKOTA 	args[1] = irq;
127800da3b2SKazutaka YOKOTA 	*kbd = NULL;
128e9deda23SKazutaka YOKOTA 	error = (*sw->probe)(unit, args, flags);
129617b9080SKazutaka YOKOTA 	if (error)
130e9deda23SKazutaka YOKOTA 		return error;
131800da3b2SKazutaka YOKOTA 	error = (*sw->init)(unit, kbd, args, flags);
132e9deda23SKazutaka YOKOTA 	if (error)
133e9deda23SKazutaka YOKOTA 		return error;
134800da3b2SKazutaka YOKOTA 	(*sw->enable)(*kbd);
135617b9080SKazutaka YOKOTA 
136617b9080SKazutaka YOKOTA #ifdef KBD_INSTALL_CDEV
137617b9080SKazutaka YOKOTA 	/* attach a virtual keyboard cdev */
138800da3b2SKazutaka YOKOTA 	error = kbd_attach(*kbd);
139617b9080SKazutaka YOKOTA 	if (error)
140617b9080SKazutaka YOKOTA 		return error;
141617b9080SKazutaka YOKOTA #endif
142617b9080SKazutaka YOKOTA 
143617b9080SKazutaka YOKOTA 	/*
144617b9080SKazutaka YOKOTA 	 * This is a kludge to compensate for lost keyboard interrupts.
145617b9080SKazutaka YOKOTA 	 * A similar code used to be in syscons. See below. XXX
146617b9080SKazutaka YOKOTA 	 */
147fadf3fb9SJohn Baldwin 	state = (atkbd_state_t *)(*kbd)->kb_data;
148fadf3fb9SJohn Baldwin 	callout_init(&state->ks_timer, 0);
149800da3b2SKazutaka YOKOTA 	atkbd_timeout(*kbd);
150617b9080SKazutaka YOKOTA 
151617b9080SKazutaka YOKOTA 	if (bootverbose)
152800da3b2SKazutaka YOKOTA 		(*sw->diag)(*kbd, bootverbose);
153520b6353SMarius Strobl 
154520b6353SMarius Strobl 	EVENTHANDLER_REGISTER(shutdown_final, atkbd_shutdown_final, *kbd,
155520b6353SMarius Strobl 	    SHUTDOWN_PRI_DEFAULT);
156520b6353SMarius Strobl 
157617b9080SKazutaka YOKOTA 	return 0;
158617b9080SKazutaka YOKOTA }
159617b9080SKazutaka YOKOTA 
160617b9080SKazutaka YOKOTA static void
161617b9080SKazutaka YOKOTA atkbd_timeout(void *arg)
162617b9080SKazutaka YOKOTA {
163fadf3fb9SJohn Baldwin 	atkbd_state_t *state;
164617b9080SKazutaka YOKOTA 	keyboard_t *kbd;
165617b9080SKazutaka YOKOTA 	int s;
166617b9080SKazutaka YOKOTA 
167617b9080SKazutaka YOKOTA 	/*
1687c6f57a3SKazutaka YOKOTA 	 * The original text of the following comments are extracted
1697c6f57a3SKazutaka YOKOTA 	 * from syscons.c (1.287)
1707c6f57a3SKazutaka YOKOTA 	 *
171617b9080SKazutaka YOKOTA 	 * With release 2.1 of the Xaccel server, the keyboard is left
172617b9080SKazutaka YOKOTA 	 * hanging pretty often. Apparently an interrupt from the
173617b9080SKazutaka YOKOTA 	 * keyboard is lost, and I don't know why (yet).
1747c6f57a3SKazutaka YOKOTA 	 * This ugly hack calls the low-level interrupt routine if input
1757c6f57a3SKazutaka YOKOTA 	 * is ready for the keyboard and conveniently hides the problem. XXX
1767c6f57a3SKazutaka YOKOTA 	 *
1777c6f57a3SKazutaka YOKOTA 	 * Try removing anything stuck in the keyboard controller; whether
1787c6f57a3SKazutaka YOKOTA 	 * it's a keyboard scan code or mouse data. The low-level
1797c6f57a3SKazutaka YOKOTA 	 * interrupt routine doesn't read the mouse data directly,
1807c6f57a3SKazutaka YOKOTA 	 * but the keyboard controller driver will, as a side effect.
181617b9080SKazutaka YOKOTA 	 */
182617b9080SKazutaka YOKOTA 	/*
1837c6f57a3SKazutaka YOKOTA 	 * And here is bde's original comment about this:
1847c6f57a3SKazutaka YOKOTA 	 *
1857c6f57a3SKazutaka YOKOTA 	 * This is necessary to handle edge triggered interrupts - if we
1867c6f57a3SKazutaka YOKOTA 	 * returned when our IRQ is high due to unserviced input, then there
1877c6f57a3SKazutaka YOKOTA 	 * would be no more keyboard IRQs until the keyboard is reset by
1887c6f57a3SKazutaka YOKOTA 	 * external powers.
1897c6f57a3SKazutaka YOKOTA 	 *
1907c6f57a3SKazutaka YOKOTA 	 * The keyboard apparently unwedges the irq in most cases.
191617b9080SKazutaka YOKOTA 	 */
192617b9080SKazutaka YOKOTA 	s = spltty();
193617b9080SKazutaka YOKOTA 	kbd = (keyboard_t *)arg;
194259699b2SWojciech A. Koszek 	if (kbdd_lock(kbd, TRUE)) {
195617b9080SKazutaka YOKOTA 		/*
196617b9080SKazutaka YOKOTA 		 * We have seen the lock flag is not set. Let's reset
197617b9080SKazutaka YOKOTA 		 * the flag early, otherwise the LED update routine fails
198617b9080SKazutaka YOKOTA 		 * which may want the lock during the interrupt routine.
199617b9080SKazutaka YOKOTA 		 */
200259699b2SWojciech A. Koszek 		kbdd_lock(kbd, FALSE);
201259699b2SWojciech A. Koszek 		if (kbdd_check_char(kbd))
202259699b2SWojciech A. Koszek 			kbdd_intr(kbd, NULL);
203617b9080SKazutaka YOKOTA 	}
204617b9080SKazutaka YOKOTA 	splx(s);
205fadf3fb9SJohn Baldwin 	state = (atkbd_state_t *)kbd->kb_data;
206fadf3fb9SJohn Baldwin 	callout_reset(&state->ks_timer, hz / 10, atkbd_timeout, arg);
207617b9080SKazutaka YOKOTA }
208617b9080SKazutaka YOKOTA 
209617b9080SKazutaka YOKOTA /* LOW-LEVEL */
210617b9080SKazutaka YOKOTA 
211617b9080SKazutaka YOKOTA #define ATKBD_DEFAULT	0
212617b9080SKazutaka YOKOTA 
213617b9080SKazutaka YOKOTA /* keyboard driver declaration */
214617b9080SKazutaka YOKOTA static int		atkbd_configure(int flags);
215617b9080SKazutaka YOKOTA static kbd_probe_t	atkbd_probe;
216617b9080SKazutaka YOKOTA static kbd_init_t	atkbd_init;
217617b9080SKazutaka YOKOTA static kbd_term_t	atkbd_term;
218617b9080SKazutaka YOKOTA static kbd_intr_t	atkbd_intr;
219617b9080SKazutaka YOKOTA static kbd_test_if_t	atkbd_test_if;
220617b9080SKazutaka YOKOTA static kbd_enable_t	atkbd_enable;
221617b9080SKazutaka YOKOTA static kbd_disable_t	atkbd_disable;
222617b9080SKazutaka YOKOTA static kbd_read_t	atkbd_read;
223617b9080SKazutaka YOKOTA static kbd_check_t	atkbd_check;
224617b9080SKazutaka YOKOTA static kbd_read_char_t	atkbd_read_char;
225617b9080SKazutaka YOKOTA static kbd_check_char_t	atkbd_check_char;
226617b9080SKazutaka YOKOTA static kbd_ioctl_t	atkbd_ioctl;
227617b9080SKazutaka YOKOTA static kbd_lock_t	atkbd_lock;
228617b9080SKazutaka YOKOTA static kbd_clear_state_t atkbd_clear_state;
229617b9080SKazutaka YOKOTA static kbd_get_state_t	atkbd_get_state;
230617b9080SKazutaka YOKOTA static kbd_set_state_t	atkbd_set_state;
231e9deda23SKazutaka YOKOTA static kbd_poll_mode_t	atkbd_poll;
232617b9080SKazutaka YOKOTA 
23351da11a2SMark Murray static keyboard_switch_t atkbdsw = {
234617b9080SKazutaka YOKOTA 	atkbd_probe,
235617b9080SKazutaka YOKOTA 	atkbd_init,
236617b9080SKazutaka YOKOTA 	atkbd_term,
237617b9080SKazutaka YOKOTA 	atkbd_intr,
238617b9080SKazutaka YOKOTA 	atkbd_test_if,
239617b9080SKazutaka YOKOTA 	atkbd_enable,
240617b9080SKazutaka YOKOTA 	atkbd_disable,
241617b9080SKazutaka YOKOTA 	atkbd_read,
242617b9080SKazutaka YOKOTA 	atkbd_check,
243617b9080SKazutaka YOKOTA 	atkbd_read_char,
244617b9080SKazutaka YOKOTA 	atkbd_check_char,
245617b9080SKazutaka YOKOTA 	atkbd_ioctl,
246617b9080SKazutaka YOKOTA 	atkbd_lock,
247617b9080SKazutaka YOKOTA 	atkbd_clear_state,
248617b9080SKazutaka YOKOTA 	atkbd_get_state,
249617b9080SKazutaka YOKOTA 	atkbd_set_state,
250617b9080SKazutaka YOKOTA 	genkbd_get_fkeystr,
251e9deda23SKazutaka YOKOTA 	atkbd_poll,
252617b9080SKazutaka YOKOTA 	genkbd_diag,
253617b9080SKazutaka YOKOTA };
254617b9080SKazutaka YOKOTA 
255617b9080SKazutaka YOKOTA KEYBOARD_DRIVER(atkbd, atkbdsw, atkbd_configure);
256617b9080SKazutaka YOKOTA 
257617b9080SKazutaka YOKOTA /* local functions */
258b19f7eecSRoger Pau Monné static int		set_typematic(keyboard_t *kbd);
259617b9080SKazutaka YOKOTA static int		setup_kbd_port(KBDC kbdc, int port, int intr);
260617b9080SKazutaka YOKOTA static int		get_kbd_echo(KBDC kbdc);
261617b9080SKazutaka YOKOTA static int		probe_keyboard(KBDC kbdc, int flags);
262617b9080SKazutaka YOKOTA static int		init_keyboard(KBDC kbdc, int *type, int flags);
263617b9080SKazutaka YOKOTA static int		write_kbd(KBDC kbdc, int command, int data);
264617b9080SKazutaka YOKOTA static int		get_kbd_id(KBDC kbdc);
265e9deda23SKazutaka YOKOTA static int		typematic(int delay, int rate);
26657995893SKazutaka YOKOTA static int		typematic_delay(int delay);
26757995893SKazutaka YOKOTA static int		typematic_rate(int rate);
268617b9080SKazutaka YOKOTA 
26938ae0c59SOleksandr Tymoshenko #ifdef EVDEV_SUPPORT
27048f2b006SVladimir Kondratyev static evdev_event_t atkbd_ev_event;
27148f2b006SVladimir Kondratyev 
27238ae0c59SOleksandr Tymoshenko static const struct evdev_methods atkbd_evdev_methods = {
27348f2b006SVladimir Kondratyev 	.ev_event = atkbd_ev_event,
27438ae0c59SOleksandr Tymoshenko };
27538ae0c59SOleksandr Tymoshenko #endif
27638ae0c59SOleksandr Tymoshenko 
277617b9080SKazutaka YOKOTA /* local variables */
278617b9080SKazutaka YOKOTA 
279617b9080SKazutaka YOKOTA /* the initial key map, accent map and fkey strings */
280e9deda23SKazutaka YOKOTA #ifdef ATKBD_DFLT_KEYMAP
281e9deda23SKazutaka YOKOTA #define KBD_DFLT_KEYMAP
282e9deda23SKazutaka YOKOTA #include "atkbdmap.h"
283e9deda23SKazutaka YOKOTA #endif
284f359876fSKazutaka YOKOTA #include <dev/kbd/kbdtables.h>
285617b9080SKazutaka YOKOTA 
286617b9080SKazutaka YOKOTA /* structures for the default keyboard */
287617b9080SKazutaka YOKOTA static keyboard_t	default_kbd;
288617b9080SKazutaka YOKOTA static atkbd_state_t	default_kbd_state;
289617b9080SKazutaka YOKOTA static keymap_t		default_keymap;
290617b9080SKazutaka YOKOTA static accentmap_t	default_accentmap;
291617b9080SKazutaka YOKOTA static fkeytab_t	default_fkeytab[NUM_FKEYS];
292617b9080SKazutaka YOKOTA 
293617b9080SKazutaka YOKOTA /*
294617b9080SKazutaka YOKOTA  * The back door to the keyboard driver!
295617b9080SKazutaka YOKOTA  * This function is called by the console driver, via the kbdio module,
296617b9080SKazutaka YOKOTA  * to tickle keyboard drivers when the low-level console is being initialized.
297617b9080SKazutaka YOKOTA  * Almost nothing in the kernel has been initialied yet.  Try to probe
298617b9080SKazutaka YOKOTA  * keyboards if possible.
2992bb113d0SJeroen Ruigrok van der Werven  * NOTE: because of the way the low-level console is initialized, this routine
300617b9080SKazutaka YOKOTA  * may be called more than once!!
301617b9080SKazutaka YOKOTA  */
302617b9080SKazutaka YOKOTA static int
303617b9080SKazutaka YOKOTA atkbd_configure(int flags)
304617b9080SKazutaka YOKOTA {
305617b9080SKazutaka YOKOTA 	keyboard_t *kbd;
306617b9080SKazutaka YOKOTA 	int arg[2];
307e9deda23SKazutaka YOKOTA 	int i;
308617b9080SKazutaka YOKOTA 
3096621aa5cSMaxim Sobolev 	/*
3106621aa5cSMaxim Sobolev 	 * Probe the keyboard controller, if not present or if the driver
3116621aa5cSMaxim Sobolev 	 * is disabled, unregister the keyboard if any.
3126621aa5cSMaxim Sobolev 	 */
3136621aa5cSMaxim Sobolev 	if (atkbdc_configure() != 0 ||
3146621aa5cSMaxim Sobolev 	    resource_disabled("atkbd", ATKBD_DEFAULT)) {
315e9deda23SKazutaka YOKOTA 		i = kbd_find_keyboard(ATKBD_DRIVER_NAME, ATKBD_DEFAULT);
316e9deda23SKazutaka YOKOTA 		if (i >= 0) {
317e9deda23SKazutaka YOKOTA 			kbd = kbd_get_keyboard(i);
318e9deda23SKazutaka YOKOTA 			kbd_unregister(kbd);
319e9deda23SKazutaka YOKOTA 			kbd->kb_flags &= ~KB_REGISTERED;
320e9deda23SKazutaka YOKOTA 		}
32129e59d7dSKazutaka YOKOTA 		return 0;
322e9deda23SKazutaka YOKOTA 	}
32357600c23SKazutaka YOKOTA 
32457600c23SKazutaka YOKOTA 	/* XXX: a kludge to obtain the device configuration flags */
32557600c23SKazutaka YOKOTA 	if (resource_int_value("atkbd", ATKBD_DEFAULT, "flags", &i) == 0)
32657600c23SKazutaka YOKOTA 		flags |= i;
327617b9080SKazutaka YOKOTA 
328617b9080SKazutaka YOKOTA 	/* probe the default keyboard */
329617b9080SKazutaka YOKOTA 	arg[0] = -1;
330617b9080SKazutaka YOKOTA 	arg[1] = -1;
331e9deda23SKazutaka YOKOTA 	kbd = NULL;
332e9deda23SKazutaka YOKOTA 	if (atkbd_probe(ATKBD_DEFAULT, arg, flags))
333e9deda23SKazutaka YOKOTA 		return 0;
334e9deda23SKazutaka YOKOTA 	if (atkbd_init(ATKBD_DEFAULT, &kbd, arg, flags))
335617b9080SKazutaka YOKOTA 		return 0;
336617b9080SKazutaka YOKOTA 
337e9deda23SKazutaka YOKOTA 	/* return the number of found keyboards */
338e9deda23SKazutaka YOKOTA 	return 1;
339617b9080SKazutaka YOKOTA }
340617b9080SKazutaka YOKOTA 
341617b9080SKazutaka YOKOTA /* low-level functions */
342617b9080SKazutaka YOKOTA 
343e9deda23SKazutaka YOKOTA /* detect a keyboard */
344617b9080SKazutaka YOKOTA static int
345e9deda23SKazutaka YOKOTA atkbd_probe(int unit, void *arg, int flags)
346e9deda23SKazutaka YOKOTA {
347e9deda23SKazutaka YOKOTA 	KBDC kbdc;
348db3e34cbSKazutaka YOKOTA 	int *data = (int *)arg;	/* data[0]: controller, data[1]: irq */
349e9deda23SKazutaka YOKOTA 
350e9deda23SKazutaka YOKOTA 	/* XXX */
351e9deda23SKazutaka YOKOTA 	if (unit == ATKBD_DEFAULT) {
352e9deda23SKazutaka YOKOTA 		if (KBD_IS_PROBED(&default_kbd))
353e9deda23SKazutaka YOKOTA 			return 0;
354e9deda23SKazutaka YOKOTA 	}
355e9deda23SKazutaka YOKOTA 
356db3e34cbSKazutaka YOKOTA 	kbdc = atkbdc_open(data[0]);
357e9deda23SKazutaka YOKOTA 	if (kbdc == NULL)
358e9deda23SKazutaka YOKOTA 		return ENXIO;
359e9deda23SKazutaka YOKOTA 	if (probe_keyboard(kbdc, flags)) {
360e9deda23SKazutaka YOKOTA 		if (flags & KB_CONF_FAIL_IF_NO_KBD)
361e9deda23SKazutaka YOKOTA 			return ENXIO;
362e9deda23SKazutaka YOKOTA 	}
363e9deda23SKazutaka YOKOTA 	return 0;
364e9deda23SKazutaka YOKOTA }
365e9deda23SKazutaka YOKOTA 
366e9deda23SKazutaka YOKOTA /* reset and initialize the device */
367e9deda23SKazutaka YOKOTA static int
368e9deda23SKazutaka YOKOTA atkbd_init(int unit, keyboard_t **kbdp, void *arg, int flags)
369617b9080SKazutaka YOKOTA {
370617b9080SKazutaka YOKOTA 	keyboard_t *kbd;
371617b9080SKazutaka YOKOTA 	atkbd_state_t *state;
372617b9080SKazutaka YOKOTA 	keymap_t *keymap;
373617b9080SKazutaka YOKOTA 	accentmap_t *accmap;
374617b9080SKazutaka YOKOTA 	fkeytab_t *fkeymap;
375617b9080SKazutaka YOKOTA 	int fkeymap_size;
37656f5e27cSKazutaka YOKOTA 	int delay[2];
377db3e34cbSKazutaka YOKOTA 	int *data = (int *)arg;	/* data[0]: controller, data[1]: irq */
378ff690962SSam Leffler 	int error, needfree;
37938ae0c59SOleksandr Tymoshenko #ifdef EVDEV_SUPPORT
38038ae0c59SOleksandr Tymoshenko 	struct evdev_dev *evdev;
38138ae0c59SOleksandr Tymoshenko 	char phys_loc[8];
38238ae0c59SOleksandr Tymoshenko #endif
383617b9080SKazutaka YOKOTA 
384617b9080SKazutaka YOKOTA 	/* XXX */
385617b9080SKazutaka YOKOTA 	if (unit == ATKBD_DEFAULT) {
386617b9080SKazutaka YOKOTA 		*kbdp = kbd = &default_kbd;
387e9deda23SKazutaka YOKOTA 		if (KBD_IS_INITIALIZED(kbd) && KBD_IS_CONFIGURED(kbd))
388617b9080SKazutaka YOKOTA 			return 0;
389617b9080SKazutaka YOKOTA 		state = &default_kbd_state;
390617b9080SKazutaka YOKOTA 		keymap = &default_keymap;
391617b9080SKazutaka YOKOTA 		accmap = &default_accentmap;
392617b9080SKazutaka YOKOTA 		fkeymap = default_fkeytab;
39373a1170aSPedro F. Giffuni 		fkeymap_size = nitems(default_fkeytab);
394ff690962SSam Leffler 		needfree = 0;
395617b9080SKazutaka YOKOTA 	} else if (*kbdp == NULL) {
3967cc0979fSDavid Malone 		*kbdp = kbd = malloc(sizeof(*kbd), M_DEVBUF, M_NOWAIT | M_ZERO);
3977cc0979fSDavid Malone 		state = malloc(sizeof(*state), M_DEVBUF, M_NOWAIT | M_ZERO);
398ff690962SSam Leffler 		/* NB: these will always be initialized 'cuz !KBD_IS_PROBED */
399617b9080SKazutaka YOKOTA 		keymap = malloc(sizeof(key_map), M_DEVBUF, M_NOWAIT);
400617b9080SKazutaka YOKOTA 		accmap = malloc(sizeof(accent_map), M_DEVBUF, M_NOWAIT);
401617b9080SKazutaka YOKOTA 		fkeymap = malloc(sizeof(fkey_tab), M_DEVBUF, M_NOWAIT);
402617b9080SKazutaka YOKOTA 		fkeymap_size = sizeof(fkey_tab)/sizeof(fkey_tab[0]);
403ff690962SSam Leffler 		needfree = 1;
4047cc0979fSDavid Malone 		if ((kbd == NULL) || (state == NULL) || (keymap == NULL)
4057cc0979fSDavid Malone 		     || (accmap == NULL) || (fkeymap == NULL)) {
406ff690962SSam Leffler 			error = ENOMEM;
407ff690962SSam Leffler 			goto bad;
408617b9080SKazutaka YOKOTA 		}
409e9deda23SKazutaka YOKOTA 	} else if (KBD_IS_INITIALIZED(*kbdp) && KBD_IS_CONFIGURED(*kbdp)) {
410617b9080SKazutaka YOKOTA 		return 0;
411617b9080SKazutaka YOKOTA 	} else {
412617b9080SKazutaka YOKOTA 		kbd = *kbdp;
413617b9080SKazutaka YOKOTA 		state = (atkbd_state_t *)kbd->kb_data;
414617b9080SKazutaka YOKOTA 		bzero(state, sizeof(*state));
415617b9080SKazutaka YOKOTA 		keymap = kbd->kb_keymap;
416617b9080SKazutaka YOKOTA 		accmap = kbd->kb_accentmap;
417617b9080SKazutaka YOKOTA 		fkeymap = kbd->kb_fkeytab;
418617b9080SKazutaka YOKOTA 		fkeymap_size = kbd->kb_fkeytab_size;
419ff690962SSam Leffler 		needfree = 0;
420617b9080SKazutaka YOKOTA 	}
421617b9080SKazutaka YOKOTA 
422e9deda23SKazutaka YOKOTA 	if (!KBD_IS_PROBED(kbd)) {
423db3e34cbSKazutaka YOKOTA 		state->kbdc = atkbdc_open(data[0]);
424ff690962SSam Leffler 		if (state->kbdc == NULL) {
425ff690962SSam Leffler 			error = ENXIO;
426ff690962SSam Leffler 			goto bad;
427ff690962SSam Leffler 		}
428e9deda23SKazutaka YOKOTA 		kbd_init_struct(kbd, ATKBD_DRIVER_NAME, KB_OTHER, unit, flags,
429db3e34cbSKazutaka YOKOTA 				0, 0);
430617b9080SKazutaka YOKOTA 		bcopy(&key_map, keymap, sizeof(key_map));
431617b9080SKazutaka YOKOTA 		bcopy(&accent_map, accmap, sizeof(accent_map));
432617b9080SKazutaka YOKOTA 		bcopy(fkey_tab, fkeymap,
433617b9080SKazutaka YOKOTA 		    imin(fkeymap_size * sizeof(fkeymap[0]), sizeof(fkey_tab)));
434617b9080SKazutaka YOKOTA 		kbd_set_maps(kbd, keymap, accmap, fkeymap, fkeymap_size);
435617b9080SKazutaka YOKOTA 		kbd->kb_data = (void *)state;
436617b9080SKazutaka YOKOTA 
437e9deda23SKazutaka YOKOTA 		if (probe_keyboard(state->kbdc, flags)) { /* shouldn't happen */
438ff690962SSam Leffler 			if (flags & KB_CONF_FAIL_IF_NO_KBD) {
439ff690962SSam Leffler 				error = ENXIO;
440ff690962SSam Leffler 				goto bad;
441ff690962SSam Leffler 			}
442617b9080SKazutaka YOKOTA 		} else {
443617b9080SKazutaka YOKOTA 			KBD_FOUND_DEVICE(kbd);
444617b9080SKazutaka YOKOTA 		}
445617b9080SKazutaka YOKOTA 		atkbd_clear_state(kbd);
446617b9080SKazutaka YOKOTA 		state->ks_mode = K_XLATE;
447617b9080SKazutaka YOKOTA 		/*
448617b9080SKazutaka YOKOTA 		 * FIXME: set the initial value for lock keys in ks_state
449617b9080SKazutaka YOKOTA 		 * according to the BIOS data?
450617b9080SKazutaka YOKOTA 		 */
451617b9080SKazutaka YOKOTA 		KBD_PROBE_DONE(kbd);
452617b9080SKazutaka YOKOTA 	}
453e9deda23SKazutaka YOKOTA 	if (!KBD_IS_INITIALIZED(kbd) && !(flags & KB_CONF_PROBE_ONLY)) {
4546c6028ffSKazutaka YOKOTA 		kbd->kb_config = flags & ~KB_CONF_PROBE_ONLY;
455617b9080SKazutaka YOKOTA 		if (KBD_HAS_DEVICE(kbd)
456e9deda23SKazutaka YOKOTA 		    && init_keyboard(state->kbdc, &kbd->kb_type, kbd->kb_config)
4578ce4e518SHidetoshi Shimokawa 		    && (kbd->kb_config & KB_CONF_FAIL_IF_NO_KBD)) {
4588ce4e518SHidetoshi Shimokawa 			kbd_unregister(kbd);
459ff690962SSam Leffler 			error = ENXIO;
460ff690962SSam Leffler 			goto bad;
4618ce4e518SHidetoshi Shimokawa 		}
462e9deda23SKazutaka YOKOTA 		atkbd_ioctl(kbd, KDSETLED, (caddr_t)&state->ks_state);
463b19f7eecSRoger Pau Monné 		set_typematic(kbd);
46456f5e27cSKazutaka YOKOTA 		delay[0] = kbd->kb_delay1;
46556f5e27cSKazutaka YOKOTA 		delay[1] = kbd->kb_delay2;
46656f5e27cSKazutaka YOKOTA 		atkbd_ioctl(kbd, KDSETREPEAT, (caddr_t)delay);
46738ae0c59SOleksandr Tymoshenko 
46838ae0c59SOleksandr Tymoshenko #ifdef EVDEV_SUPPORT
46938ae0c59SOleksandr Tymoshenko 		/* register as evdev provider on first init */
47038ae0c59SOleksandr Tymoshenko 		if (state->ks_evdev == NULL) {
47138ae0c59SOleksandr Tymoshenko 			snprintf(phys_loc, sizeof(phys_loc), "atkbd%d", unit);
47238ae0c59SOleksandr Tymoshenko 			evdev = evdev_alloc();
47338ae0c59SOleksandr Tymoshenko 			evdev_set_name(evdev, "AT keyboard");
47438ae0c59SOleksandr Tymoshenko 			evdev_set_phys(evdev, phys_loc);
47538ae0c59SOleksandr Tymoshenko 			evdev_set_id(evdev, BUS_I8042, PS2_KEYBOARD_VENDOR,
47638ae0c59SOleksandr Tymoshenko 			    PS2_KEYBOARD_PRODUCT, 0);
47738ae0c59SOleksandr Tymoshenko 			evdev_set_methods(evdev, kbd, &atkbd_evdev_methods);
47838ae0c59SOleksandr Tymoshenko 			evdev_support_event(evdev, EV_SYN);
47938ae0c59SOleksandr Tymoshenko 			evdev_support_event(evdev, EV_KEY);
48038ae0c59SOleksandr Tymoshenko 			evdev_support_event(evdev, EV_LED);
48138ae0c59SOleksandr Tymoshenko 			evdev_support_event(evdev, EV_REP);
48238ae0c59SOleksandr Tymoshenko 			evdev_support_all_known_keys(evdev);
48338ae0c59SOleksandr Tymoshenko 			evdev_support_led(evdev, LED_NUML);
48438ae0c59SOleksandr Tymoshenko 			evdev_support_led(evdev, LED_CAPSL);
48538ae0c59SOleksandr Tymoshenko 			evdev_support_led(evdev, LED_SCROLLL);
48638ae0c59SOleksandr Tymoshenko 
487*f86e7267SVladimir Kondratyev 			if (evdev_register_mtx(evdev, &Giant))
48838ae0c59SOleksandr Tymoshenko 				evdev_free(evdev);
48938ae0c59SOleksandr Tymoshenko 			else
49038ae0c59SOleksandr Tymoshenko 				state->ks_evdev = evdev;
49138ae0c59SOleksandr Tymoshenko 			state->ks_evdev_state = 0;
49238ae0c59SOleksandr Tymoshenko 		}
49338ae0c59SOleksandr Tymoshenko #endif
49438ae0c59SOleksandr Tymoshenko 
495617b9080SKazutaka YOKOTA 		KBD_INIT_DONE(kbd);
496617b9080SKazutaka YOKOTA 	}
497617b9080SKazutaka YOKOTA 	if (!KBD_IS_CONFIGURED(kbd)) {
498ff690962SSam Leffler 		if (kbd_register(kbd) < 0) {
499ff690962SSam Leffler 			error = ENXIO;
500ff690962SSam Leffler 			goto bad;
501ff690962SSam Leffler 		}
502617b9080SKazutaka YOKOTA 		KBD_CONFIG_DONE(kbd);
503617b9080SKazutaka YOKOTA 	}
504617b9080SKazutaka YOKOTA 
505617b9080SKazutaka YOKOTA 	return 0;
506ff690962SSam Leffler bad:
507ff690962SSam Leffler 	if (needfree) {
508ff690962SSam Leffler 		if (state != NULL)
509ff690962SSam Leffler 			free(state, M_DEVBUF);
510ff690962SSam Leffler 		if (keymap != NULL)
511ff690962SSam Leffler 			free(keymap, M_DEVBUF);
512ff690962SSam Leffler 		if (accmap != NULL)
513ff690962SSam Leffler 			free(accmap, M_DEVBUF);
514ff690962SSam Leffler 		if (fkeymap != NULL)
515ff690962SSam Leffler 			free(fkeymap, M_DEVBUF);
516ff690962SSam Leffler 		if (kbd != NULL) {
517ff690962SSam Leffler 			free(kbd, M_DEVBUF);
518ff690962SSam Leffler 			*kbdp = NULL;	/* insure ref doesn't leak to caller */
519ff690962SSam Leffler 		}
520ff690962SSam Leffler 	}
521ff690962SSam Leffler 	return error;
522617b9080SKazutaka YOKOTA }
523617b9080SKazutaka YOKOTA 
524617b9080SKazutaka YOKOTA /* finish using this keyboard */
525617b9080SKazutaka YOKOTA static int
526617b9080SKazutaka YOKOTA atkbd_term(keyboard_t *kbd)
527617b9080SKazutaka YOKOTA {
528fadf3fb9SJohn Baldwin 	atkbd_state_t *state = (atkbd_state_t *)kbd->kb_data;
529fadf3fb9SJohn Baldwin 
530617b9080SKazutaka YOKOTA 	kbd_unregister(kbd);
531fadf3fb9SJohn Baldwin 	callout_drain(&state->ks_timer);
532617b9080SKazutaka YOKOTA 	return 0;
533617b9080SKazutaka YOKOTA }
534617b9080SKazutaka YOKOTA 
535617b9080SKazutaka YOKOTA /* keyboard interrupt routine */
536617b9080SKazutaka YOKOTA static int
537e9deda23SKazutaka YOKOTA atkbd_intr(keyboard_t *kbd, void *arg)
538617b9080SKazutaka YOKOTA {
539018cd707SMaksim Yevmenkin 	atkbd_state_t *state = (atkbd_state_t *)kbd->kb_data;
54056f5e27cSKazutaka YOKOTA 	int delay[2];
541617b9080SKazutaka YOKOTA 	int c;
542617b9080SKazutaka YOKOTA 
543ac3912b0SRuslan Ermilov 	if (!KBD_HAS_DEVICE(kbd)) {
544ac3912b0SRuslan Ermilov 		/*
545ac3912b0SRuslan Ermilov 		 * The keyboard was not detected before;
546ac3912b0SRuslan Ermilov 		 * it must have been reconnected!
547ac3912b0SRuslan Ermilov 		 */
548f0143dacSWarner Losh 		init_keyboard(state->kbdc, &kbd->kb_type, kbd->kb_config);
549ac3912b0SRuslan Ermilov 		KBD_FOUND_DEVICE(kbd);
550ac3912b0SRuslan Ermilov 		atkbd_ioctl(kbd, KDSETLED, (caddr_t)&state->ks_state);
551b19f7eecSRoger Pau Monné 		set_typematic(kbd);
552ac3912b0SRuslan Ermilov 		delay[0] = kbd->kb_delay1;
553ac3912b0SRuslan Ermilov 		delay[1] = kbd->kb_delay2;
554ac3912b0SRuslan Ermilov 		atkbd_ioctl(kbd, KDSETREPEAT, (caddr_t)delay);
555ac3912b0SRuslan Ermilov 	}
556ac3912b0SRuslan Ermilov 
557018cd707SMaksim Yevmenkin 	if (state->ks_polling)
558018cd707SMaksim Yevmenkin 		return 0;
559018cd707SMaksim Yevmenkin 
560617b9080SKazutaka YOKOTA 	if (KBD_IS_ACTIVE(kbd) && KBD_IS_BUSY(kbd)) {
561617b9080SKazutaka YOKOTA 		/* let the callback function to process the input */
562617b9080SKazutaka YOKOTA 		(*kbd->kb_callback.kc_func)(kbd, KBDIO_KEYINPUT,
563617b9080SKazutaka YOKOTA 					    kbd->kb_callback.kc_arg);
564617b9080SKazutaka YOKOTA 	} else {
565617b9080SKazutaka YOKOTA 		/* read and discard the input; no one is waiting for input */
566617b9080SKazutaka YOKOTA 		do {
567617b9080SKazutaka YOKOTA 			c = atkbd_read_char(kbd, FALSE);
568617b9080SKazutaka YOKOTA 		} while (c != NOKEY);
569617b9080SKazutaka YOKOTA 	}
570617b9080SKazutaka YOKOTA 	return 0;
571617b9080SKazutaka YOKOTA }
572617b9080SKazutaka YOKOTA 
573617b9080SKazutaka YOKOTA /* test the interface to the device */
574617b9080SKazutaka YOKOTA static int
575617b9080SKazutaka YOKOTA atkbd_test_if(keyboard_t *kbd)
576617b9080SKazutaka YOKOTA {
577617b9080SKazutaka YOKOTA 	int error;
578617b9080SKazutaka YOKOTA 	int s;
579617b9080SKazutaka YOKOTA 
580617b9080SKazutaka YOKOTA 	error = 0;
581617b9080SKazutaka YOKOTA 	empty_both_buffers(((atkbd_state_t *)kbd->kb_data)->kbdc, 10);
582617b9080SKazutaka YOKOTA 	s = spltty();
583617b9080SKazutaka YOKOTA 	if (!test_controller(((atkbd_state_t *)kbd->kb_data)->kbdc))
584617b9080SKazutaka YOKOTA 		error = EIO;
585617b9080SKazutaka YOKOTA 	else if (test_kbd_port(((atkbd_state_t *)kbd->kb_data)->kbdc) != 0)
586617b9080SKazutaka YOKOTA 		error = EIO;
587617b9080SKazutaka YOKOTA 	splx(s);
588617b9080SKazutaka YOKOTA 
589617b9080SKazutaka YOKOTA 	return error;
590617b9080SKazutaka YOKOTA }
591617b9080SKazutaka YOKOTA 
592617b9080SKazutaka YOKOTA /*
593617b9080SKazutaka YOKOTA  * Enable the access to the device; until this function is called,
594617b9080SKazutaka YOKOTA  * the client cannot read from the keyboard.
595617b9080SKazutaka YOKOTA  */
596617b9080SKazutaka YOKOTA static int
597617b9080SKazutaka YOKOTA atkbd_enable(keyboard_t *kbd)
598617b9080SKazutaka YOKOTA {
599617b9080SKazutaka YOKOTA 	int s;
600617b9080SKazutaka YOKOTA 
601617b9080SKazutaka YOKOTA 	s = spltty();
602617b9080SKazutaka YOKOTA 	KBD_ACTIVATE(kbd);
603617b9080SKazutaka YOKOTA 	splx(s);
604617b9080SKazutaka YOKOTA 	return 0;
605617b9080SKazutaka YOKOTA }
606617b9080SKazutaka YOKOTA 
607617b9080SKazutaka YOKOTA /* disallow the access to the device */
608617b9080SKazutaka YOKOTA static int
609617b9080SKazutaka YOKOTA atkbd_disable(keyboard_t *kbd)
610617b9080SKazutaka YOKOTA {
611617b9080SKazutaka YOKOTA 	int s;
612617b9080SKazutaka YOKOTA 
613617b9080SKazutaka YOKOTA 	s = spltty();
614617b9080SKazutaka YOKOTA 	KBD_DEACTIVATE(kbd);
615617b9080SKazutaka YOKOTA 	splx(s);
616617b9080SKazutaka YOKOTA 	return 0;
617617b9080SKazutaka YOKOTA }
618617b9080SKazutaka YOKOTA 
619617b9080SKazutaka YOKOTA /* read one byte from the keyboard if it's allowed */
620617b9080SKazutaka YOKOTA static int
621617b9080SKazutaka YOKOTA atkbd_read(keyboard_t *kbd, int wait)
622617b9080SKazutaka YOKOTA {
623617b9080SKazutaka YOKOTA 	int c;
624617b9080SKazutaka YOKOTA 
625617b9080SKazutaka YOKOTA 	if (wait)
626617b9080SKazutaka YOKOTA 		c = read_kbd_data(((atkbd_state_t *)kbd->kb_data)->kbdc);
627617b9080SKazutaka YOKOTA 	else
628617b9080SKazutaka YOKOTA 		c = read_kbd_data_no_wait(((atkbd_state_t *)kbd->kb_data)->kbdc);
62982d654e8SKazutaka YOKOTA 	if (c != -1)
63082d654e8SKazutaka YOKOTA 		++kbd->kb_count;
631617b9080SKazutaka YOKOTA 	return (KBD_IS_ACTIVE(kbd) ? c : -1);
632617b9080SKazutaka YOKOTA }
633617b9080SKazutaka YOKOTA 
634617b9080SKazutaka YOKOTA /* check if data is waiting */
635617b9080SKazutaka YOKOTA static int
636617b9080SKazutaka YOKOTA atkbd_check(keyboard_t *kbd)
637617b9080SKazutaka YOKOTA {
638617b9080SKazutaka YOKOTA 	if (!KBD_IS_ACTIVE(kbd))
639617b9080SKazutaka YOKOTA 		return FALSE;
640617b9080SKazutaka YOKOTA 	return kbdc_data_ready(((atkbd_state_t *)kbd->kb_data)->kbdc);
641617b9080SKazutaka YOKOTA }
642617b9080SKazutaka YOKOTA 
643617b9080SKazutaka YOKOTA /* read char from the keyboard */
644617b9080SKazutaka YOKOTA static u_int
645617b9080SKazutaka YOKOTA atkbd_read_char(keyboard_t *kbd, int wait)
646617b9080SKazutaka YOKOTA {
647617b9080SKazutaka YOKOTA 	atkbd_state_t *state;
648617b9080SKazutaka YOKOTA 	u_int action;
649617b9080SKazutaka YOKOTA 	int scancode;
650617b9080SKazutaka YOKOTA 	int keycode;
651617b9080SKazutaka YOKOTA 
652617b9080SKazutaka YOKOTA 	state = (atkbd_state_t *)kbd->kb_data;
653617b9080SKazutaka YOKOTA next_code:
654617b9080SKazutaka YOKOTA 	/* do we have a composed char to return? */
655617b9080SKazutaka YOKOTA 	if (!(state->ks_flags & COMPOSE) && (state->ks_composed_char > 0)) {
656617b9080SKazutaka YOKOTA 		action = state->ks_composed_char;
657617b9080SKazutaka YOKOTA 		state->ks_composed_char = 0;
658617b9080SKazutaka YOKOTA 		if (action > UCHAR_MAX)
659617b9080SKazutaka YOKOTA 			return ERRKEY;
660617b9080SKazutaka YOKOTA 		return action;
661617b9080SKazutaka YOKOTA 	}
662617b9080SKazutaka YOKOTA 
663617b9080SKazutaka YOKOTA 	/* see if there is something in the keyboard port */
664617b9080SKazutaka YOKOTA 	if (wait) {
665617b9080SKazutaka YOKOTA 		do {
666617b9080SKazutaka YOKOTA 			scancode = read_kbd_data(state->kbdc);
667617b9080SKazutaka YOKOTA 		} while (scancode == -1);
668617b9080SKazutaka YOKOTA 	} else {
669617b9080SKazutaka YOKOTA 		scancode = read_kbd_data_no_wait(state->kbdc);
670617b9080SKazutaka YOKOTA 		if (scancode == -1)
671617b9080SKazutaka YOKOTA 			return NOKEY;
672617b9080SKazutaka YOKOTA 	}
67382d654e8SKazutaka YOKOTA 	++kbd->kb_count;
67482d654e8SKazutaka YOKOTA 
67582d654e8SKazutaka YOKOTA #if KBDIO_DEBUG >= 10
67682d654e8SKazutaka YOKOTA 	printf("atkbd_read_char(): scancode:0x%x\n", scancode);
67782d654e8SKazutaka YOKOTA #endif
678617b9080SKazutaka YOKOTA 
67938ae0c59SOleksandr Tymoshenko #ifdef EVDEV_SUPPORT
68038ae0c59SOleksandr Tymoshenko 	/* push evdev event */
68138ae0c59SOleksandr Tymoshenko 	if (evdev_rcpt_mask & EVDEV_RCPT_HW_KBD && state->ks_evdev != NULL) {
68238ae0c59SOleksandr Tymoshenko 		keycode = evdev_scancode2key(&state->ks_evdev_state,
68338ae0c59SOleksandr Tymoshenko 		    scancode);
68438ae0c59SOleksandr Tymoshenko 
68538ae0c59SOleksandr Tymoshenko 		if (keycode != KEY_RESERVED) {
68638ae0c59SOleksandr Tymoshenko 			evdev_push_event(state->ks_evdev, EV_KEY,
68738ae0c59SOleksandr Tymoshenko 			    (uint16_t)keycode, scancode & 0x80 ? 0 : 1);
68838ae0c59SOleksandr Tymoshenko 			evdev_sync(state->ks_evdev);
68938ae0c59SOleksandr Tymoshenko 		}
69038ae0c59SOleksandr Tymoshenko 	}
69138ae0c59SOleksandr Tymoshenko #endif
69238ae0c59SOleksandr Tymoshenko 
693617b9080SKazutaka YOKOTA 	/* return the byte as is for the K_RAW mode */
694617b9080SKazutaka YOKOTA 	if (state->ks_mode == K_RAW)
695617b9080SKazutaka YOKOTA 		return scancode;
696617b9080SKazutaka YOKOTA 
697617b9080SKazutaka YOKOTA 	/* translate the scan code into a keycode */
698617b9080SKazutaka YOKOTA 	keycode = scancode & 0x7F;
699617b9080SKazutaka YOKOTA 	switch (state->ks_prefix) {
700617b9080SKazutaka YOKOTA 	case 0x00:	/* normal scancode */
701617b9080SKazutaka YOKOTA 		switch(scancode) {
702617b9080SKazutaka YOKOTA 		case 0xB8:	/* left alt (compose key) released */
703617b9080SKazutaka YOKOTA 			if (state->ks_flags & COMPOSE) {
704617b9080SKazutaka YOKOTA 				state->ks_flags &= ~COMPOSE;
705617b9080SKazutaka YOKOTA 				if (state->ks_composed_char > UCHAR_MAX)
706617b9080SKazutaka YOKOTA 					state->ks_composed_char = 0;
707617b9080SKazutaka YOKOTA 			}
708617b9080SKazutaka YOKOTA 			break;
709617b9080SKazutaka YOKOTA 		case 0x38:	/* left alt (compose key) pressed */
710617b9080SKazutaka YOKOTA 			if (!(state->ks_flags & COMPOSE)) {
711617b9080SKazutaka YOKOTA 				state->ks_flags |= COMPOSE;
712617b9080SKazutaka YOKOTA 				state->ks_composed_char = 0;
713617b9080SKazutaka YOKOTA 			}
714617b9080SKazutaka YOKOTA 			break;
715617b9080SKazutaka YOKOTA 		case 0xE0:
716617b9080SKazutaka YOKOTA 		case 0xE1:
717617b9080SKazutaka YOKOTA 			state->ks_prefix = scancode;
718617b9080SKazutaka YOKOTA 			goto next_code;
719617b9080SKazutaka YOKOTA 		}
720617b9080SKazutaka YOKOTA 		break;
721617b9080SKazutaka YOKOTA 	case 0xE0:		/* 0xE0 prefix */
722617b9080SKazutaka YOKOTA 		state->ks_prefix = 0;
723617b9080SKazutaka YOKOTA 		switch (keycode) {
724617b9080SKazutaka YOKOTA 		case 0x1C:	/* right enter key */
725617b9080SKazutaka YOKOTA 			keycode = 0x59;
726617b9080SKazutaka YOKOTA 			break;
727617b9080SKazutaka YOKOTA 		case 0x1D:	/* right ctrl key */
728617b9080SKazutaka YOKOTA 			keycode = 0x5A;
729617b9080SKazutaka YOKOTA 			break;
730617b9080SKazutaka YOKOTA 		case 0x35:	/* keypad divide key */
731617b9080SKazutaka YOKOTA 			keycode = 0x5B;
732617b9080SKazutaka YOKOTA 			break;
733617b9080SKazutaka YOKOTA 		case 0x37:	/* print scrn key */
734617b9080SKazutaka YOKOTA 			keycode = 0x5C;
735617b9080SKazutaka YOKOTA 			break;
736617b9080SKazutaka YOKOTA 		case 0x38:	/* right alt key (alt gr) */
737617b9080SKazutaka YOKOTA 			keycode = 0x5D;
738617b9080SKazutaka YOKOTA 			break;
739ffba82a9SKazutaka YOKOTA 		case 0x46:	/* ctrl-pause/break on AT 101 (see below) */
740ffba82a9SKazutaka YOKOTA 			keycode = 0x68;
741ffba82a9SKazutaka YOKOTA 			break;
742617b9080SKazutaka YOKOTA 		case 0x47:	/* grey home key */
743617b9080SKazutaka YOKOTA 			keycode = 0x5E;
744617b9080SKazutaka YOKOTA 			break;
745617b9080SKazutaka YOKOTA 		case 0x48:	/* grey up arrow key */
746617b9080SKazutaka YOKOTA 			keycode = 0x5F;
747617b9080SKazutaka YOKOTA 			break;
748617b9080SKazutaka YOKOTA 		case 0x49:	/* grey page up key */
749617b9080SKazutaka YOKOTA 			keycode = 0x60;
750617b9080SKazutaka YOKOTA 			break;
751617b9080SKazutaka YOKOTA 		case 0x4B:	/* grey left arrow key */
752617b9080SKazutaka YOKOTA 			keycode = 0x61;
753617b9080SKazutaka YOKOTA 			break;
754617b9080SKazutaka YOKOTA 		case 0x4D:	/* grey right arrow key */
755617b9080SKazutaka YOKOTA 			keycode = 0x62;
756617b9080SKazutaka YOKOTA 			break;
757617b9080SKazutaka YOKOTA 		case 0x4F:	/* grey end key */
758617b9080SKazutaka YOKOTA 			keycode = 0x63;
759617b9080SKazutaka YOKOTA 			break;
760617b9080SKazutaka YOKOTA 		case 0x50:	/* grey down arrow key */
761617b9080SKazutaka YOKOTA 			keycode = 0x64;
762617b9080SKazutaka YOKOTA 			break;
763617b9080SKazutaka YOKOTA 		case 0x51:	/* grey page down key */
764617b9080SKazutaka YOKOTA 			keycode = 0x65;
765617b9080SKazutaka YOKOTA 			break;
766617b9080SKazutaka YOKOTA 		case 0x52:	/* grey insert key */
767617b9080SKazutaka YOKOTA 			keycode = 0x66;
768617b9080SKazutaka YOKOTA 			break;
769617b9080SKazutaka YOKOTA 		case 0x53:	/* grey delete key */
770617b9080SKazutaka YOKOTA 			keycode = 0x67;
771617b9080SKazutaka YOKOTA 			break;
772617b9080SKazutaka YOKOTA 			/* the following 3 are only used on the MS "Natural" keyboard */
773617b9080SKazutaka YOKOTA 		case 0x5b:	/* left Window key */
774617b9080SKazutaka YOKOTA 			keycode = 0x69;
775617b9080SKazutaka YOKOTA 			break;
776617b9080SKazutaka YOKOTA 		case 0x5c:	/* right Window key */
777617b9080SKazutaka YOKOTA 			keycode = 0x6a;
778617b9080SKazutaka YOKOTA 			break;
779617b9080SKazutaka YOKOTA 		case 0x5d:	/* menu key */
780617b9080SKazutaka YOKOTA 			keycode = 0x6b;
781617b9080SKazutaka YOKOTA 			break;
7827ea199a7SMax Khon 		case 0x5e:	/* power key */
7837ea199a7SMax Khon 			keycode = 0x6d;
7847ea199a7SMax Khon 			break;
7857ea199a7SMax Khon 		case 0x5f:	/* sleep key */
7867ea199a7SMax Khon 			keycode = 0x6e;
7877ea199a7SMax Khon 			break;
7887ea199a7SMax Khon 		case 0x63:	/* wake key */
7897ea199a7SMax Khon 			keycode = 0x6f;
7907ea199a7SMax Khon 			break;
791617b9080SKazutaka YOKOTA 		default:	/* ignore everything else */
792617b9080SKazutaka YOKOTA 			goto next_code;
793617b9080SKazutaka YOKOTA 		}
794617b9080SKazutaka YOKOTA 		break;
795617b9080SKazutaka YOKOTA    	case 0xE1:	/* 0xE1 prefix */
796ffba82a9SKazutaka YOKOTA 		/*
797ffba82a9SKazutaka YOKOTA 		 * The pause/break key on the 101 keyboard produces:
798ffba82a9SKazutaka YOKOTA 		 * E1-1D-45 E1-9D-C5
799ffba82a9SKazutaka YOKOTA 		 * Ctrl-pause/break produces:
800ffba82a9SKazutaka YOKOTA 		 * E0-46 E0-C6 (See above.)
801ffba82a9SKazutaka YOKOTA 		 */
802617b9080SKazutaka YOKOTA 		state->ks_prefix = 0;
803617b9080SKazutaka YOKOTA 		if (keycode == 0x1D)
804617b9080SKazutaka YOKOTA 			state->ks_prefix = 0x1D;
805617b9080SKazutaka YOKOTA 		goto next_code;
806617b9080SKazutaka YOKOTA 		/* NOT REACHED */
807617b9080SKazutaka YOKOTA    	case 0x1D:	/* pause / break */
808617b9080SKazutaka YOKOTA 		state->ks_prefix = 0;
809617b9080SKazutaka YOKOTA 		if (keycode != 0x45)
810617b9080SKazutaka YOKOTA 			goto next_code;
811617b9080SKazutaka YOKOTA 		keycode = 0x68;
812617b9080SKazutaka YOKOTA 		break;
813617b9080SKazutaka YOKOTA 	}
814617b9080SKazutaka YOKOTA 
815ffba82a9SKazutaka YOKOTA 	if (kbd->kb_type == KB_84) {
816ffba82a9SKazutaka YOKOTA 		switch (keycode) {
817ffba82a9SKazutaka YOKOTA 		case 0x37:	/* *(numpad)/print screen */
818ffba82a9SKazutaka YOKOTA 			if (state->ks_flags & SHIFTS)
819ffba82a9SKazutaka YOKOTA 				keycode = 0x5c;	/* print screen */
820ffba82a9SKazutaka YOKOTA 			break;
821ffba82a9SKazutaka YOKOTA 		case 0x45:	/* num lock/pause */
822ffba82a9SKazutaka YOKOTA 			if (state->ks_flags & CTLS)
823ffba82a9SKazutaka YOKOTA 				keycode = 0x68;	/* pause */
824ffba82a9SKazutaka YOKOTA 			break;
825ffba82a9SKazutaka YOKOTA 		case 0x46:	/* scroll lock/break */
826ffba82a9SKazutaka YOKOTA 			if (state->ks_flags & CTLS)
827ffba82a9SKazutaka YOKOTA 				keycode = 0x6c;	/* break */
828ffba82a9SKazutaka YOKOTA 			break;
829ffba82a9SKazutaka YOKOTA 		}
830ffba82a9SKazutaka YOKOTA 	} else if (kbd->kb_type == KB_101) {
831ffba82a9SKazutaka YOKOTA 		switch (keycode) {
832ffba82a9SKazutaka YOKOTA 		case 0x5c:	/* print screen */
833ffba82a9SKazutaka YOKOTA 			if (state->ks_flags & ALTS)
834ffba82a9SKazutaka YOKOTA 				keycode = 0x54;	/* sysrq */
835ffba82a9SKazutaka YOKOTA 			break;
836ffba82a9SKazutaka YOKOTA 		case 0x68:	/* pause/break */
837ffba82a9SKazutaka YOKOTA 			if (state->ks_flags & CTLS)
838ffba82a9SKazutaka YOKOTA 				keycode = 0x6c;	/* break */
839ffba82a9SKazutaka YOKOTA 			break;
840ffba82a9SKazutaka YOKOTA 		}
841ffba82a9SKazutaka YOKOTA 	}
842ffba82a9SKazutaka YOKOTA 
843617b9080SKazutaka YOKOTA 	/* return the key code in the K_CODE mode */
844617b9080SKazutaka YOKOTA 	if (state->ks_mode == K_CODE)
845617b9080SKazutaka YOKOTA 		return (keycode | (scancode & 0x80));
846617b9080SKazutaka YOKOTA 
847617b9080SKazutaka YOKOTA 	/* compose a character code */
848617b9080SKazutaka YOKOTA 	if (state->ks_flags & COMPOSE) {
84983fc7c6cSKazutaka YOKOTA 		switch (keycode | (scancode & 0x80)) {
850617b9080SKazutaka YOKOTA 		/* key pressed, process it */
851617b9080SKazutaka YOKOTA 		case 0x47: case 0x48: case 0x49:	/* keypad 7,8,9 */
852617b9080SKazutaka YOKOTA 			state->ks_composed_char *= 10;
853194da42dSKazutaka YOKOTA 			state->ks_composed_char += keycode - 0x40;
854617b9080SKazutaka YOKOTA 			if (state->ks_composed_char > UCHAR_MAX)
855617b9080SKazutaka YOKOTA 				return ERRKEY;
856617b9080SKazutaka YOKOTA 			goto next_code;
857617b9080SKazutaka YOKOTA 		case 0x4B: case 0x4C: case 0x4D:	/* keypad 4,5,6 */
858617b9080SKazutaka YOKOTA 			state->ks_composed_char *= 10;
859194da42dSKazutaka YOKOTA 			state->ks_composed_char += keycode - 0x47;
860617b9080SKazutaka YOKOTA 			if (state->ks_composed_char > UCHAR_MAX)
861617b9080SKazutaka YOKOTA 				return ERRKEY;
862617b9080SKazutaka YOKOTA 			goto next_code;
863617b9080SKazutaka YOKOTA 		case 0x4F: case 0x50: case 0x51:	/* keypad 1,2,3 */
864617b9080SKazutaka YOKOTA 			state->ks_composed_char *= 10;
865194da42dSKazutaka YOKOTA 			state->ks_composed_char += keycode - 0x4E;
866617b9080SKazutaka YOKOTA 			if (state->ks_composed_char > UCHAR_MAX)
867617b9080SKazutaka YOKOTA 				return ERRKEY;
868617b9080SKazutaka YOKOTA 			goto next_code;
869617b9080SKazutaka YOKOTA 		case 0x52:				/* keypad 0 */
870617b9080SKazutaka YOKOTA 			state->ks_composed_char *= 10;
871617b9080SKazutaka YOKOTA 			if (state->ks_composed_char > UCHAR_MAX)
872617b9080SKazutaka YOKOTA 				return ERRKEY;
873617b9080SKazutaka YOKOTA 			goto next_code;
874617b9080SKazutaka YOKOTA 
875617b9080SKazutaka YOKOTA 		/* key released, no interest here */
876617b9080SKazutaka YOKOTA 		case 0xC7: case 0xC8: case 0xC9:	/* keypad 7,8,9 */
877617b9080SKazutaka YOKOTA 		case 0xCB: case 0xCC: case 0xCD:	/* keypad 4,5,6 */
878617b9080SKazutaka YOKOTA 		case 0xCF: case 0xD0: case 0xD1:	/* keypad 1,2,3 */
879617b9080SKazutaka YOKOTA 		case 0xD2:				/* keypad 0 */
880617b9080SKazutaka YOKOTA 			goto next_code;
881617b9080SKazutaka YOKOTA 
882617b9080SKazutaka YOKOTA 		case 0x38:				/* left alt key */
883617b9080SKazutaka YOKOTA 			break;
884617b9080SKazutaka YOKOTA 
885617b9080SKazutaka YOKOTA 		default:
886617b9080SKazutaka YOKOTA 			if (state->ks_composed_char > 0) {
887617b9080SKazutaka YOKOTA 				state->ks_flags &= ~COMPOSE;
888617b9080SKazutaka YOKOTA 				state->ks_composed_char = 0;
889617b9080SKazutaka YOKOTA 				return ERRKEY;
890617b9080SKazutaka YOKOTA 			}
891617b9080SKazutaka YOKOTA 			break;
892617b9080SKazutaka YOKOTA 		}
893617b9080SKazutaka YOKOTA 	}
894617b9080SKazutaka YOKOTA 
895617b9080SKazutaka YOKOTA 	/* keycode to key action */
896617b9080SKazutaka YOKOTA 	action = genkbd_keyaction(kbd, keycode, scancode & 0x80,
897617b9080SKazutaka YOKOTA 				  &state->ks_state, &state->ks_accents);
898617b9080SKazutaka YOKOTA 	if (action == NOKEY)
899617b9080SKazutaka YOKOTA 		goto next_code;
900617b9080SKazutaka YOKOTA 	else
901617b9080SKazutaka YOKOTA 		return action;
902617b9080SKazutaka YOKOTA }
903617b9080SKazutaka YOKOTA 
904617b9080SKazutaka YOKOTA /* check if char is waiting */
905617b9080SKazutaka YOKOTA static int
906617b9080SKazutaka YOKOTA atkbd_check_char(keyboard_t *kbd)
907617b9080SKazutaka YOKOTA {
908617b9080SKazutaka YOKOTA 	atkbd_state_t *state;
909617b9080SKazutaka YOKOTA 
910617b9080SKazutaka YOKOTA 	if (!KBD_IS_ACTIVE(kbd))
911617b9080SKazutaka YOKOTA 		return FALSE;
912617b9080SKazutaka YOKOTA 	state = (atkbd_state_t *)kbd->kb_data;
913617b9080SKazutaka YOKOTA 	if (!(state->ks_flags & COMPOSE) && (state->ks_composed_char > 0))
914617b9080SKazutaka YOKOTA 		return TRUE;
915617b9080SKazutaka YOKOTA 	return kbdc_data_ready(state->kbdc);
916617b9080SKazutaka YOKOTA }
917617b9080SKazutaka YOKOTA 
918617b9080SKazutaka YOKOTA /* some useful control functions */
919617b9080SKazutaka YOKOTA static int
920617b9080SKazutaka YOKOTA atkbd_ioctl(keyboard_t *kbd, u_long cmd, caddr_t arg)
921617b9080SKazutaka YOKOTA {
922520b6353SMarius Strobl 	/* translate LED_XXX bits into the device specific bits */
923617b9080SKazutaka YOKOTA 	static u_char ledmap[8] = {
924617b9080SKazutaka YOKOTA 		0, 4, 2, 6, 1, 5, 3, 7,
925617b9080SKazutaka YOKOTA 	};
926617b9080SKazutaka YOKOTA 	atkbd_state_t *state = kbd->kb_data;
927617b9080SKazutaka YOKOTA 	int error;
928617b9080SKazutaka YOKOTA 	int s;
929617b9080SKazutaka YOKOTA 	int i;
9309fddcc66SRuslan Ermilov #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
9319fddcc66SRuslan Ermilov     defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
9329fddcc66SRuslan Ermilov 	int ival;
9339fddcc66SRuslan Ermilov #endif
934617b9080SKazutaka YOKOTA 
935617b9080SKazutaka YOKOTA 	s = spltty();
936617b9080SKazutaka YOKOTA 	switch (cmd) {
937617b9080SKazutaka YOKOTA 
938617b9080SKazutaka YOKOTA 	case KDGKBMODE:		/* get keyboard mode */
939617b9080SKazutaka YOKOTA 		*(int *)arg = state->ks_mode;
940617b9080SKazutaka YOKOTA 		break;
9419fddcc66SRuslan Ermilov #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
9429fddcc66SRuslan Ermilov     defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
9439fddcc66SRuslan Ermilov 	case _IO('K', 7):
9449fddcc66SRuslan Ermilov 		ival = IOCPARM_IVAL(arg);
9459fddcc66SRuslan Ermilov 		arg = (caddr_t)&ival;
9469fddcc66SRuslan Ermilov 		/* FALLTHROUGH */
9479fddcc66SRuslan Ermilov #endif
948617b9080SKazutaka YOKOTA 	case KDSKBMODE:		/* set keyboard mode */
949617b9080SKazutaka YOKOTA 		switch (*(int *)arg) {
950617b9080SKazutaka YOKOTA 		case K_XLATE:
951617b9080SKazutaka YOKOTA 			if (state->ks_mode != K_XLATE) {
952617b9080SKazutaka YOKOTA 				/* make lock key state and LED state match */
953617b9080SKazutaka YOKOTA 				state->ks_state &= ~LOCK_MASK;
954617b9080SKazutaka YOKOTA 				state->ks_state |= KBD_LED_VAL(kbd);
955617b9080SKazutaka YOKOTA 			}
956617b9080SKazutaka YOKOTA 			/* FALLTHROUGH */
957617b9080SKazutaka YOKOTA 		case K_RAW:
958617b9080SKazutaka YOKOTA 		case K_CODE:
959617b9080SKazutaka YOKOTA 			if (state->ks_mode != *(int *)arg) {
960617b9080SKazutaka YOKOTA 				atkbd_clear_state(kbd);
961617b9080SKazutaka YOKOTA 				state->ks_mode = *(int *)arg;
962617b9080SKazutaka YOKOTA 			}
963617b9080SKazutaka YOKOTA 			break;
964617b9080SKazutaka YOKOTA 		default:
965617b9080SKazutaka YOKOTA 			splx(s);
966617b9080SKazutaka YOKOTA 			return EINVAL;
967617b9080SKazutaka YOKOTA 		}
968617b9080SKazutaka YOKOTA 		break;
969617b9080SKazutaka YOKOTA 
970617b9080SKazutaka YOKOTA 	case KDGETLED:		/* get keyboard LED */
971617b9080SKazutaka YOKOTA 		*(int *)arg = KBD_LED_VAL(kbd);
972617b9080SKazutaka YOKOTA 		break;
9739fddcc66SRuslan Ermilov #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
9749fddcc66SRuslan Ermilov     defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
9759fddcc66SRuslan Ermilov 	case _IO('K', 66):
9769fddcc66SRuslan Ermilov 		ival = IOCPARM_IVAL(arg);
9779fddcc66SRuslan Ermilov 		arg = (caddr_t)&ival;
9789fddcc66SRuslan Ermilov 		/* FALLTHROUGH */
9799fddcc66SRuslan Ermilov #endif
980617b9080SKazutaka YOKOTA 	case KDSETLED:		/* set keyboard LED */
981617b9080SKazutaka YOKOTA 		/* NOTE: lock key state in ks_state won't be changed */
982617b9080SKazutaka YOKOTA 		if (*(int *)arg & ~LOCK_MASK) {
983617b9080SKazutaka YOKOTA 			splx(s);
984617b9080SKazutaka YOKOTA 			return EINVAL;
985617b9080SKazutaka YOKOTA 		}
986617b9080SKazutaka YOKOTA 		i = *(int *)arg;
987617b9080SKazutaka YOKOTA 		/* replace CAPS LED with ALTGR LED for ALTGR keyboards */
9882073104fSAndrey A. Chernov 		if (state->ks_mode == K_XLATE &&
9892073104fSAndrey A. Chernov 		    kbd->kb_keymap->n_keys > ALTGR_OFFSET) {
990617b9080SKazutaka YOKOTA 			if (i & ALKED)
991617b9080SKazutaka YOKOTA 				i |= CLKED;
992617b9080SKazutaka YOKOTA 			else
993617b9080SKazutaka YOKOTA 				i &= ~CLKED;
994617b9080SKazutaka YOKOTA 		}
995617b9080SKazutaka YOKOTA 		if (KBD_HAS_DEVICE(kbd)) {
996617b9080SKazutaka YOKOTA 			error = write_kbd(state->kbdc, KBDC_SET_LEDS,
997617b9080SKazutaka YOKOTA 					  ledmap[i & LED_MASK]);
998617b9080SKazutaka YOKOTA 			if (error) {
999617b9080SKazutaka YOKOTA 				splx(s);
1000617b9080SKazutaka YOKOTA 				return error;
1001617b9080SKazutaka YOKOTA 			}
1002617b9080SKazutaka YOKOTA 		}
100338ae0c59SOleksandr Tymoshenko #ifdef EVDEV_SUPPORT
100438ae0c59SOleksandr Tymoshenko 		/* push LED states to evdev */
100538ae0c59SOleksandr Tymoshenko 		if (state->ks_evdev != NULL &&
100638ae0c59SOleksandr Tymoshenko 		    evdev_rcpt_mask & EVDEV_RCPT_HW_KBD)
100738ae0c59SOleksandr Tymoshenko 			evdev_push_leds(state->ks_evdev, *(int *)arg);
100838ae0c59SOleksandr Tymoshenko #endif
1009617b9080SKazutaka YOKOTA 		KBD_LED_VAL(kbd) = *(int *)arg;
1010617b9080SKazutaka YOKOTA 		break;
1011617b9080SKazutaka YOKOTA 
1012617b9080SKazutaka YOKOTA 	case KDGKBSTATE:	/* get lock key state */
1013617b9080SKazutaka YOKOTA 		*(int *)arg = state->ks_state & LOCK_MASK;
1014617b9080SKazutaka YOKOTA 		break;
10159fddcc66SRuslan Ermilov #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
10169fddcc66SRuslan Ermilov     defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
10179fddcc66SRuslan Ermilov 	case _IO('K', 20):
10189fddcc66SRuslan Ermilov 		ival = IOCPARM_IVAL(arg);
10199fddcc66SRuslan Ermilov 		arg = (caddr_t)&ival;
10209fddcc66SRuslan Ermilov 		/* FALLTHROUGH */
10219fddcc66SRuslan Ermilov #endif
1022617b9080SKazutaka YOKOTA 	case KDSKBSTATE:	/* set lock key state */
1023617b9080SKazutaka YOKOTA 		if (*(int *)arg & ~LOCK_MASK) {
1024617b9080SKazutaka YOKOTA 			splx(s);
1025617b9080SKazutaka YOKOTA 			return EINVAL;
1026617b9080SKazutaka YOKOTA 		}
1027617b9080SKazutaka YOKOTA 		state->ks_state &= ~LOCK_MASK;
1028617b9080SKazutaka YOKOTA 		state->ks_state |= *(int *)arg;
1029617b9080SKazutaka YOKOTA 		splx(s);
1030617b9080SKazutaka YOKOTA 		/* set LEDs and quit */
1031617b9080SKazutaka YOKOTA 		return atkbd_ioctl(kbd, KDSETLED, arg);
1032617b9080SKazutaka YOKOTA 
1033e9deda23SKazutaka YOKOTA 	case KDSETREPEAT:	/* set keyboard repeat rate (new interface) */
1034617b9080SKazutaka YOKOTA 		splx(s);
1035617b9080SKazutaka YOKOTA 		if (!KBD_HAS_DEVICE(kbd))
1036617b9080SKazutaka YOKOTA 			return 0;
1037e9deda23SKazutaka YOKOTA 		i = typematic(((int *)arg)[0], ((int *)arg)[1]);
103857995893SKazutaka YOKOTA 		error = write_kbd(state->kbdc, KBDC_SET_TYPEMATIC, i);
103957995893SKazutaka YOKOTA 		if (error == 0) {
104057995893SKazutaka YOKOTA 			kbd->kb_delay1 = typematic_delay(i);
104157995893SKazutaka YOKOTA 			kbd->kb_delay2 = typematic_rate(i);
104238ae0c59SOleksandr Tymoshenko #ifdef EVDEV_SUPPORT
104338ae0c59SOleksandr Tymoshenko 			if (state->ks_evdev != NULL &&
104438ae0c59SOleksandr Tymoshenko 			    evdev_rcpt_mask & EVDEV_RCPT_HW_KBD)
104538ae0c59SOleksandr Tymoshenko 				evdev_push_repeats(state->ks_evdev, kbd);
104638ae0c59SOleksandr Tymoshenko #endif
104757995893SKazutaka YOKOTA 		}
104857995893SKazutaka YOKOTA 		return error;
1049e9deda23SKazutaka YOKOTA 
10509fddcc66SRuslan Ermilov #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
10519fddcc66SRuslan Ermilov     defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
10529fddcc66SRuslan Ermilov 	case _IO('K', 67):
10539fddcc66SRuslan Ermilov 		ival = IOCPARM_IVAL(arg);
10549fddcc66SRuslan Ermilov 		arg = (caddr_t)&ival;
10559fddcc66SRuslan Ermilov 		/* FALLTHROUGH */
10569fddcc66SRuslan Ermilov #endif
1057e9deda23SKazutaka YOKOTA 	case KDSETRAD:		/* set keyboard repeat rate (old interface) */
1058e9deda23SKazutaka YOKOTA 		splx(s);
1059e9deda23SKazutaka YOKOTA 		if (!KBD_HAS_DEVICE(kbd))
1060e9deda23SKazutaka YOKOTA 			return 0;
106157995893SKazutaka YOKOTA 		error = write_kbd(state->kbdc, KBDC_SET_TYPEMATIC, *(int *)arg);
106257995893SKazutaka YOKOTA 		if (error == 0) {
106357995893SKazutaka YOKOTA 			kbd->kb_delay1 = typematic_delay(*(int *)arg);
106457995893SKazutaka YOKOTA 			kbd->kb_delay2 = typematic_rate(*(int *)arg);
106538ae0c59SOleksandr Tymoshenko #ifdef EVDEV_SUPPORT
106638ae0c59SOleksandr Tymoshenko 			if (state->ks_evdev != NULL &&
106738ae0c59SOleksandr Tymoshenko 			    evdev_rcpt_mask & EVDEV_RCPT_HW_KBD)
106838ae0c59SOleksandr Tymoshenko 				evdev_push_repeats(state->ks_evdev, kbd);
106938ae0c59SOleksandr Tymoshenko #endif
107057995893SKazutaka YOKOTA 		}
107157995893SKazutaka YOKOTA 		return error;
1072617b9080SKazutaka YOKOTA 
1073617b9080SKazutaka YOKOTA 	case PIO_KEYMAP:	/* set keyboard translation table */
107478d4d8eeSEd Schouten 	case OPIO_KEYMAP:	/* set keyboard translation table (compat) */
1075617b9080SKazutaka YOKOTA 	case PIO_KEYMAPENT:	/* set keyboard translation table entry */
1076617b9080SKazutaka YOKOTA 	case PIO_DEADKEYMAP:	/* set accent key translation table */
1077617b9080SKazutaka YOKOTA 		state->ks_accents = 0;
1078617b9080SKazutaka YOKOTA 		/* FALLTHROUGH */
1079617b9080SKazutaka YOKOTA 	default:
1080617b9080SKazutaka YOKOTA 		splx(s);
1081617b9080SKazutaka YOKOTA 		return genkbd_commonioctl(kbd, cmd, arg);
1082617b9080SKazutaka YOKOTA 	}
1083617b9080SKazutaka YOKOTA 
1084617b9080SKazutaka YOKOTA 	splx(s);
1085617b9080SKazutaka YOKOTA 	return 0;
1086617b9080SKazutaka YOKOTA }
1087617b9080SKazutaka YOKOTA 
1088617b9080SKazutaka YOKOTA /* lock the access to the keyboard */
1089617b9080SKazutaka YOKOTA static int
1090617b9080SKazutaka YOKOTA atkbd_lock(keyboard_t *kbd, int lock)
1091617b9080SKazutaka YOKOTA {
1092617b9080SKazutaka YOKOTA 	return kbdc_lock(((atkbd_state_t *)kbd->kb_data)->kbdc, lock);
1093617b9080SKazutaka YOKOTA }
1094617b9080SKazutaka YOKOTA 
1095617b9080SKazutaka YOKOTA /* clear the internal state of the keyboard */
1096617b9080SKazutaka YOKOTA static void
1097617b9080SKazutaka YOKOTA atkbd_clear_state(keyboard_t *kbd)
1098617b9080SKazutaka YOKOTA {
1099617b9080SKazutaka YOKOTA 	atkbd_state_t *state;
1100617b9080SKazutaka YOKOTA 
1101617b9080SKazutaka YOKOTA 	state = (atkbd_state_t *)kbd->kb_data;
1102617b9080SKazutaka YOKOTA 	state->ks_flags = 0;
1103e9deda23SKazutaka YOKOTA 	state->ks_polling = 0;
1104617b9080SKazutaka YOKOTA 	state->ks_state &= LOCK_MASK;	/* preserve locking key state */
1105617b9080SKazutaka YOKOTA 	state->ks_accents = 0;
1106617b9080SKazutaka YOKOTA 	state->ks_composed_char = 0;
1107617b9080SKazutaka YOKOTA #if 0
1108617b9080SKazutaka YOKOTA 	state->ks_prefix = 0; /* XXX */
1109617b9080SKazutaka YOKOTA #endif
1110617b9080SKazutaka YOKOTA }
1111617b9080SKazutaka YOKOTA 
1112617b9080SKazutaka YOKOTA /* save the internal state */
1113617b9080SKazutaka YOKOTA static int
1114617b9080SKazutaka YOKOTA atkbd_get_state(keyboard_t *kbd, void *buf, size_t len)
1115617b9080SKazutaka YOKOTA {
1116617b9080SKazutaka YOKOTA 	if (len == 0)
1117617b9080SKazutaka YOKOTA 		return sizeof(atkbd_state_t);
1118617b9080SKazutaka YOKOTA 	if (len < sizeof(atkbd_state_t))
1119617b9080SKazutaka YOKOTA 		return -1;
1120617b9080SKazutaka YOKOTA 	bcopy(kbd->kb_data, buf, sizeof(atkbd_state_t));
1121617b9080SKazutaka YOKOTA 	return 0;
1122617b9080SKazutaka YOKOTA }
1123617b9080SKazutaka YOKOTA 
1124617b9080SKazutaka YOKOTA /* set the internal state */
1125617b9080SKazutaka YOKOTA static int
1126617b9080SKazutaka YOKOTA atkbd_set_state(keyboard_t *kbd, void *buf, size_t len)
1127617b9080SKazutaka YOKOTA {
1128617b9080SKazutaka YOKOTA 	if (len < sizeof(atkbd_state_t))
1129617b9080SKazutaka YOKOTA 		return ENOMEM;
1130617b9080SKazutaka YOKOTA 	if (((atkbd_state_t *)kbd->kb_data)->kbdc
1131617b9080SKazutaka YOKOTA 		!= ((atkbd_state_t *)buf)->kbdc)
1132617b9080SKazutaka YOKOTA 		return ENOMEM;
1133617b9080SKazutaka YOKOTA 	bcopy(buf, kbd->kb_data, sizeof(atkbd_state_t));
1134617b9080SKazutaka YOKOTA 	return 0;
1135617b9080SKazutaka YOKOTA }
1136617b9080SKazutaka YOKOTA 
1137e9deda23SKazutaka YOKOTA static int
1138e9deda23SKazutaka YOKOTA atkbd_poll(keyboard_t *kbd, int on)
1139e9deda23SKazutaka YOKOTA {
1140e9deda23SKazutaka YOKOTA 	atkbd_state_t *state;
1141e9deda23SKazutaka YOKOTA 	int s;
1142e9deda23SKazutaka YOKOTA 
1143e9deda23SKazutaka YOKOTA 	state = (atkbd_state_t *)kbd->kb_data;
1144e9deda23SKazutaka YOKOTA 	s = spltty();
1145e9deda23SKazutaka YOKOTA 	if (on)
1146e9deda23SKazutaka YOKOTA 		++state->ks_polling;
1147e9deda23SKazutaka YOKOTA 	else
1148e9deda23SKazutaka YOKOTA 		--state->ks_polling;
1149e9deda23SKazutaka YOKOTA 	splx(s);
1150e9deda23SKazutaka YOKOTA 	return 0;
1151e9deda23SKazutaka YOKOTA }
1152e9deda23SKazutaka YOKOTA 
1153520b6353SMarius Strobl static void
1154520b6353SMarius Strobl atkbd_shutdown_final(void *v)
1155520b6353SMarius Strobl {
1156520b6353SMarius Strobl #ifdef __sparc64__
1157520b6353SMarius Strobl 	keyboard_t *kbd = v;
1158520b6353SMarius Strobl 	KBDC kbdc = ((atkbd_state_t *)kbd->kb_data)->kbdc;
1159520b6353SMarius Strobl 
1160520b6353SMarius Strobl 	/*
1161520b6353SMarius Strobl 	 * Turn off the translation in preparation for handing the keyboard
1162520b6353SMarius Strobl 	 * over to the OFW as the OBP driver doesn't use translation and
1163520b6353SMarius Strobl 	 * also doesn't disable it itself resulting in a broken keymap at
1164520b6353SMarius Strobl 	 * the boot prompt. Also disable the aux port and the interrupts as
1165520b6353SMarius Strobl 	 * the OBP driver doesn't use them, i.e. polls the keyboard. Not
1166520b6353SMarius Strobl 	 * disabling the interrupts doesn't cause real problems but the
1167520b6353SMarius Strobl 	 * responsiveness is a bit better when they are turned off.
1168520b6353SMarius Strobl 	 */
1169520b6353SMarius Strobl 	send_kbd_command(kbdc, KBDC_DISABLE_KBD);
1170520b6353SMarius Strobl 	set_controller_command_byte(kbdc,
1171520b6353SMarius Strobl 	    KBD_AUX_CONTROL_BITS | KBD_KBD_CONTROL_BITS | KBD_TRANSLATION,
1172520b6353SMarius Strobl 	    KBD_DISABLE_AUX_PORT | KBD_DISABLE_KBD_INT | KBD_ENABLE_KBD_PORT);
1173520b6353SMarius Strobl 	send_kbd_command(kbdc, KBDC_ENABLE_KBD);
1174520b6353SMarius Strobl #endif
1175520b6353SMarius Strobl }
1176520b6353SMarius Strobl 
11776c176113SMichael Gmelin static int
11786c176113SMichael Gmelin atkbd_reset(KBDC kbdc, int flags, int c)
11796c176113SMichael Gmelin {
11806c176113SMichael Gmelin 	/* reset keyboard hardware */
11816c176113SMichael Gmelin 	if (!(flags & KB_CONF_NO_RESET) && !reset_kbd(kbdc)) {
11826c176113SMichael Gmelin 		/*
11836c176113SMichael Gmelin 		 * KEYBOARD ERROR
11846c176113SMichael Gmelin 		 * Keyboard reset may fail either because the keyboard
11856c176113SMichael Gmelin 		 * doen't exist, or because the keyboard doesn't pass
11866c176113SMichael Gmelin 		 * the self-test, or the keyboard controller on the
11876c176113SMichael Gmelin 		 * motherboard and the keyboard somehow fail to shake hands.
11886c176113SMichael Gmelin 		 * It is just possible, particularly in the last case,
11896c176113SMichael Gmelin 		 * that the keyboard controller may be left in a hung state.
11906c176113SMichael Gmelin 		 * test_controller() and test_kbd_port() appear to bring
11916c176113SMichael Gmelin 		 * the keyboard controller back (I don't know why and how,
11926c176113SMichael Gmelin 		 * though.)
11936c176113SMichael Gmelin 		 */
11946c176113SMichael Gmelin 		empty_both_buffers(kbdc, 10);
11956c176113SMichael Gmelin 		test_controller(kbdc);
11966c176113SMichael Gmelin 		test_kbd_port(kbdc);
11976c176113SMichael Gmelin 		/*
11986c176113SMichael Gmelin 		 * We could disable the keyboard port and interrupt... but,
11996c176113SMichael Gmelin 		 * the keyboard may still exist (see above).
12006c176113SMichael Gmelin 		 */
12016c176113SMichael Gmelin 		set_controller_command_byte(kbdc,
12026c176113SMichael Gmelin 		    ALLOW_DISABLE_KBD(kbdc) ? 0xff : KBD_KBD_CONTROL_BITS, c);
12036c176113SMichael Gmelin 		if (bootverbose)
12046c176113SMichael Gmelin 			printf("atkbd: failed to reset the keyboard.\n");
12056c176113SMichael Gmelin 		return (EIO);
12066c176113SMichael Gmelin 	}
12076c176113SMichael Gmelin 	return (0);
12086c176113SMichael Gmelin }
12096c176113SMichael Gmelin 
121048f2b006SVladimir Kondratyev #ifdef EVDEV_SUPPORT
121148f2b006SVladimir Kondratyev static void
121248f2b006SVladimir Kondratyev atkbd_ev_event(struct evdev_dev *evdev, uint16_t type, uint16_t code,
121348f2b006SVladimir Kondratyev     int32_t value)
121448f2b006SVladimir Kondratyev {
121548f2b006SVladimir Kondratyev 	keyboard_t *kbd = evdev_get_softc(evdev);
121648f2b006SVladimir Kondratyev 
121748f2b006SVladimir Kondratyev 	if (evdev_rcpt_mask & EVDEV_RCPT_HW_KBD &&
121848f2b006SVladimir Kondratyev 	    (type == EV_LED || type == EV_REP)) {
121948f2b006SVladimir Kondratyev 		mtx_lock(&Giant);
122048f2b006SVladimir Kondratyev 		kbd_ev_event(kbd, type, code, value);
122148f2b006SVladimir Kondratyev 		mtx_unlock(&Giant);
122248f2b006SVladimir Kondratyev 	}
122348f2b006SVladimir Kondratyev }
122448f2b006SVladimir Kondratyev #endif
122548f2b006SVladimir Kondratyev 
1226617b9080SKazutaka YOKOTA /* local functions */
1227617b9080SKazutaka YOKOTA 
1228617b9080SKazutaka YOKOTA static int
1229b19f7eecSRoger Pau Monné set_typematic(keyboard_t *kbd)
123056f5e27cSKazutaka YOKOTA {
1231b19f7eecSRoger Pau Monné 	int val, error;
1232b19f7eecSRoger Pau Monné 	atkbd_state_t *state = kbd->kb_data;
123356f5e27cSKazutaka YOKOTA 
1234b19f7eecSRoger Pau Monné 	val = typematic(DEFAULT_DELAY, DEFAULT_RATE);
1235b19f7eecSRoger Pau Monné 	error = write_kbd(state->kbdc, KBDC_SET_TYPEMATIC, val);
1236b19f7eecSRoger Pau Monné 	if (error == 0) {
1237b19f7eecSRoger Pau Monné 		kbd->kb_delay1 = typematic_delay(val);
1238b19f7eecSRoger Pau Monné 		kbd->kb_delay2 = typematic_rate(val);
1239b19f7eecSRoger Pau Monné 	}
12403219f535SJung-uk Kim 
1241b19f7eecSRoger Pau Monné 	return (error);
124256f5e27cSKazutaka YOKOTA }
124356f5e27cSKazutaka YOKOTA 
124456f5e27cSKazutaka YOKOTA static int
1245617b9080SKazutaka YOKOTA setup_kbd_port(KBDC kbdc, int port, int intr)
1246617b9080SKazutaka YOKOTA {
1247617b9080SKazutaka YOKOTA 	if (!set_controller_command_byte(kbdc,
1248617b9080SKazutaka YOKOTA 		KBD_KBD_CONTROL_BITS,
1249617b9080SKazutaka YOKOTA 		((port) ? KBD_ENABLE_KBD_PORT : KBD_DISABLE_KBD_PORT)
1250617b9080SKazutaka YOKOTA 		    | ((intr) ? KBD_ENABLE_KBD_INT : KBD_DISABLE_KBD_INT)))
1251617b9080SKazutaka YOKOTA 		return 1;
1252617b9080SKazutaka YOKOTA 	return 0;
1253617b9080SKazutaka YOKOTA }
1254617b9080SKazutaka YOKOTA 
1255617b9080SKazutaka YOKOTA static int
1256617b9080SKazutaka YOKOTA get_kbd_echo(KBDC kbdc)
1257617b9080SKazutaka YOKOTA {
1258617b9080SKazutaka YOKOTA 	/* enable the keyboard port, but disable the keyboard intr. */
1259617b9080SKazutaka YOKOTA 	if (setup_kbd_port(kbdc, TRUE, FALSE))
1260617b9080SKazutaka YOKOTA 		/* CONTROLLER ERROR: there is very little we can do... */
1261617b9080SKazutaka YOKOTA 		return ENXIO;
1262617b9080SKazutaka YOKOTA 
1263617b9080SKazutaka YOKOTA 	/* see if something is present */
1264617b9080SKazutaka YOKOTA 	write_kbd_command(kbdc, KBDC_ECHO);
1265617b9080SKazutaka YOKOTA 	if (read_kbd_data(kbdc) != KBD_ECHO) {
1266617b9080SKazutaka YOKOTA 		empty_both_buffers(kbdc, 10);
1267617b9080SKazutaka YOKOTA 		test_controller(kbdc);
1268617b9080SKazutaka YOKOTA 		test_kbd_port(kbdc);
1269617b9080SKazutaka YOKOTA 		return ENXIO;
1270617b9080SKazutaka YOKOTA 	}
1271617b9080SKazutaka YOKOTA 
1272617b9080SKazutaka YOKOTA 	/* enable the keyboard port and intr. */
1273617b9080SKazutaka YOKOTA 	if (setup_kbd_port(kbdc, TRUE, TRUE)) {
1274617b9080SKazutaka YOKOTA 		/*
1275617b9080SKazutaka YOKOTA 		 * CONTROLLER ERROR
1276617b9080SKazutaka YOKOTA 		 * This is serious; the keyboard intr is left disabled!
1277617b9080SKazutaka YOKOTA 		 */
1278617b9080SKazutaka YOKOTA 		return ENXIO;
1279617b9080SKazutaka YOKOTA 	}
1280617b9080SKazutaka YOKOTA 
1281617b9080SKazutaka YOKOTA 	return 0;
1282617b9080SKazutaka YOKOTA }
1283617b9080SKazutaka YOKOTA 
1284617b9080SKazutaka YOKOTA static int
1285617b9080SKazutaka YOKOTA probe_keyboard(KBDC kbdc, int flags)
1286617b9080SKazutaka YOKOTA {
1287617b9080SKazutaka YOKOTA 	/*
1288617b9080SKazutaka YOKOTA 	 * Don't try to print anything in this function.  The low-level
1289617b9080SKazutaka YOKOTA 	 * console may not have been initialized yet...
1290617b9080SKazutaka YOKOTA 	 */
1291617b9080SKazutaka YOKOTA 	int err;
1292617b9080SKazutaka YOKOTA 	int c;
1293617b9080SKazutaka YOKOTA 	int m;
1294617b9080SKazutaka YOKOTA 
1295617b9080SKazutaka YOKOTA 	if (!kbdc_lock(kbdc, TRUE)) {
1296617b9080SKazutaka YOKOTA 		/* driver error? */
1297617b9080SKazutaka YOKOTA 		return ENXIO;
1298617b9080SKazutaka YOKOTA 	}
1299617b9080SKazutaka YOKOTA 
1300aec1fa1cSKazutaka YOKOTA 	/* temporarily block data transmission from the keyboard */
1301aec1fa1cSKazutaka YOKOTA 	write_controller_command(kbdc, KBDC_DISABLE_KBD_PORT);
1302aec1fa1cSKazutaka YOKOTA 
1303617b9080SKazutaka YOKOTA 	/* flush any noise in the buffer */
1304aec1fa1cSKazutaka YOKOTA 	empty_both_buffers(kbdc, 100);
1305617b9080SKazutaka YOKOTA 
1306617b9080SKazutaka YOKOTA 	/* save the current keyboard controller command byte */
1307617b9080SKazutaka YOKOTA 	m = kbdc_get_device_mask(kbdc) & ~KBD_KBD_CONTROL_BITS;
1308617b9080SKazutaka YOKOTA 	c = get_controller_command_byte(kbdc);
1309617b9080SKazutaka YOKOTA 	if (c == -1) {
1310617b9080SKazutaka YOKOTA 		/* CONTROLLER ERROR */
1311617b9080SKazutaka YOKOTA 		kbdc_set_device_mask(kbdc, m);
1312617b9080SKazutaka YOKOTA 		kbdc_lock(kbdc, FALSE);
1313617b9080SKazutaka YOKOTA 		return ENXIO;
1314617b9080SKazutaka YOKOTA 	}
1315617b9080SKazutaka YOKOTA 
1316617b9080SKazutaka YOKOTA 	/*
1317617b9080SKazutaka YOKOTA 	 * The keyboard may have been screwed up by the boot block.
1318617b9080SKazutaka YOKOTA 	 * We may just be able to recover from error by testing the controller
1319617b9080SKazutaka YOKOTA 	 * and the keyboard port. The controller command byte needs to be
1320617b9080SKazutaka YOKOTA 	 * saved before this recovery operation, as some controllers seem
1321617b9080SKazutaka YOKOTA 	 * to set the command byte to particular values.
1322617b9080SKazutaka YOKOTA 	 */
1323617b9080SKazutaka YOKOTA 	test_controller(kbdc);
1324f5517dc8SJohn Baldwin 	if (!(flags & KB_CONF_NO_PROBE_TEST))
1325617b9080SKazutaka YOKOTA 		test_kbd_port(kbdc);
1326617b9080SKazutaka YOKOTA 
1327617b9080SKazutaka YOKOTA 	err = get_kbd_echo(kbdc);
1328a68d00e3SKazutaka YOKOTA 
1329a68d00e3SKazutaka YOKOTA 	/*
1330a68d00e3SKazutaka YOKOTA 	 * Even if the keyboard doesn't seem to be present (err != 0),
1331a68d00e3SKazutaka YOKOTA 	 * we shall enable the keyboard port and interrupt so that
1332a68d00e3SKazutaka YOKOTA 	 * the driver will be operable when the keyboard is attached
1333a68d00e3SKazutaka YOKOTA 	 * to the system later.  It is NOT recommended to hot-plug
1334a68d00e3SKazutaka YOKOTA 	 * the AT keyboard, but many people do so...
1335a68d00e3SKazutaka YOKOTA 	 */
1336a68d00e3SKazutaka YOKOTA 	kbdc_set_device_mask(kbdc, m | KBD_KBD_CONTROL_BITS);
1337a68d00e3SKazutaka YOKOTA 	setup_kbd_port(kbdc, TRUE, TRUE);
1338a68d00e3SKazutaka YOKOTA #if 0
1339617b9080SKazutaka YOKOTA 	if (err == 0) {
1340617b9080SKazutaka YOKOTA 		kbdc_set_device_mask(kbdc, m | KBD_KBD_CONTROL_BITS);
1341617b9080SKazutaka YOKOTA 	} else {
1342617b9080SKazutaka YOKOTA 		/* try to restore the command byte as before */
13436c176113SMichael Gmelin 		set_controller_command_byte(kbdc,
13446c176113SMichael Gmelin 		    ALLOW_DISABLE_KBD(kbdc) ? 0xff : KBD_KBD_CONTROL_BITS, c);
1345617b9080SKazutaka YOKOTA 		kbdc_set_device_mask(kbdc, m);
1346617b9080SKazutaka YOKOTA 	}
1347a68d00e3SKazutaka YOKOTA #endif
1348617b9080SKazutaka YOKOTA 
1349617b9080SKazutaka YOKOTA 	kbdc_lock(kbdc, FALSE);
13506c176113SMichael Gmelin 	return (HAS_QUIRK(kbdc, KBDC_QUIRK_IGNORE_PROBE_RESULT) ? 0 : err);
1351617b9080SKazutaka YOKOTA }
1352617b9080SKazutaka YOKOTA 
1353617b9080SKazutaka YOKOTA static int
1354617b9080SKazutaka YOKOTA init_keyboard(KBDC kbdc, int *type, int flags)
1355617b9080SKazutaka YOKOTA {
1356617b9080SKazutaka YOKOTA 	int codeset;
1357617b9080SKazutaka YOKOTA 	int id;
1358617b9080SKazutaka YOKOTA 	int c;
1359617b9080SKazutaka YOKOTA 
1360617b9080SKazutaka YOKOTA 	if (!kbdc_lock(kbdc, TRUE)) {
1361617b9080SKazutaka YOKOTA 		/* driver error? */
1362617b9080SKazutaka YOKOTA 		return EIO;
1363617b9080SKazutaka YOKOTA 	}
1364617b9080SKazutaka YOKOTA 
1365aec1fa1cSKazutaka YOKOTA 	/* temporarily block data transmission from the keyboard */
1366aec1fa1cSKazutaka YOKOTA 	write_controller_command(kbdc, KBDC_DISABLE_KBD_PORT);
1367aec1fa1cSKazutaka YOKOTA 
1368617b9080SKazutaka YOKOTA 	/* save the current controller command byte */
136982d654e8SKazutaka YOKOTA 	empty_both_buffers(kbdc, 200);
1370617b9080SKazutaka YOKOTA 	c = get_controller_command_byte(kbdc);
1371617b9080SKazutaka YOKOTA 	if (c == -1) {
1372617b9080SKazutaka YOKOTA 		/* CONTROLLER ERROR */
1373617b9080SKazutaka YOKOTA 		kbdc_lock(kbdc, FALSE);
1374617b9080SKazutaka YOKOTA 		printf("atkbd: unable to get the current command byte value.\n");
1375617b9080SKazutaka YOKOTA 		return EIO;
1376617b9080SKazutaka YOKOTA 	}
1377617b9080SKazutaka YOKOTA 	if (bootverbose)
1378617b9080SKazutaka YOKOTA 		printf("atkbd: the current kbd controller command byte %04x\n",
1379617b9080SKazutaka YOKOTA 		   c);
1380617b9080SKazutaka YOKOTA #if 0
1381617b9080SKazutaka YOKOTA 	/* override the keyboard lock switch */
1382617b9080SKazutaka YOKOTA 	c |= KBD_OVERRIDE_KBD_LOCK;
1383617b9080SKazutaka YOKOTA #endif
1384617b9080SKazutaka YOKOTA 
1385617b9080SKazutaka YOKOTA 	/* enable the keyboard port, but disable the keyboard intr. */
1386617b9080SKazutaka YOKOTA 	if (setup_kbd_port(kbdc, TRUE, FALSE)) {
1387617b9080SKazutaka YOKOTA 		/* CONTROLLER ERROR: there is very little we can do... */
1388617b9080SKazutaka YOKOTA 		printf("atkbd: unable to set the command byte.\n");
1389617b9080SKazutaka YOKOTA 		kbdc_lock(kbdc, FALSE);
1390617b9080SKazutaka YOKOTA 		return EIO;
1391617b9080SKazutaka YOKOTA 	}
1392617b9080SKazutaka YOKOTA 
13936c176113SMichael Gmelin 	if (HAS_QUIRK(kbdc, KBDC_QUIRK_RESET_AFTER_PROBE) &&
13946c176113SMichael Gmelin 	    atkbd_reset(kbdc, flags, c)) {
13956c176113SMichael Gmelin 		kbdc_lock(kbdc, FALSE);
13966c176113SMichael Gmelin 		return EIO;
13976c176113SMichael Gmelin 	}
13986c176113SMichael Gmelin 
1399617b9080SKazutaka YOKOTA 	/*
1400617b9080SKazutaka YOKOTA 	 * Check if we have an XT keyboard before we attempt to reset it.
1401617b9080SKazutaka YOKOTA 	 * The procedure assumes that the keyboard and the controller have
1402617b9080SKazutaka YOKOTA 	 * been set up properly by BIOS and have not been messed up
1403617b9080SKazutaka YOKOTA 	 * during the boot process.
1404617b9080SKazutaka YOKOTA 	 */
1405617b9080SKazutaka YOKOTA 	codeset = -1;
1406617b9080SKazutaka YOKOTA 	if (flags & KB_CONF_ALT_SCANCODESET)
1407617b9080SKazutaka YOKOTA 		/* the user says there is a XT keyboard */
1408617b9080SKazutaka YOKOTA 		codeset = 1;
1409617b9080SKazutaka YOKOTA #ifdef KBD_DETECT_XT_KEYBOARD
1410617b9080SKazutaka YOKOTA 	else if ((c & KBD_TRANSLATION) == 0) {
1411617b9080SKazutaka YOKOTA 		/* SET_SCANCODE_SET is not always supported; ignore error */
1412617b9080SKazutaka YOKOTA 		if (send_kbd_command_and_data(kbdc, KBDC_SET_SCANCODE_SET, 0)
1413617b9080SKazutaka YOKOTA 			== KBD_ACK)
1414617b9080SKazutaka YOKOTA 			codeset = read_kbd_data(kbdc);
1415617b9080SKazutaka YOKOTA 	}
1416617b9080SKazutaka YOKOTA 	if (bootverbose)
1417617b9080SKazutaka YOKOTA 		printf("atkbd: scancode set %d\n", codeset);
1418617b9080SKazutaka YOKOTA #endif /* KBD_DETECT_XT_KEYBOARD */
1419617b9080SKazutaka YOKOTA 
1420617b9080SKazutaka YOKOTA 	*type = KB_OTHER;
1421617b9080SKazutaka YOKOTA 	id = get_kbd_id(kbdc);
1422617b9080SKazutaka YOKOTA 	switch(id) {
1423934d11e3SKazutaka YOKOTA 	case 0x41ab:	/* 101/102/... Enhanced */
1424934d11e3SKazutaka YOKOTA 	case 0x83ab:	/* ditto */
1425934d11e3SKazutaka YOKOTA 	case 0x54ab:	/* SpaceSaver */
1426934d11e3SKazutaka YOKOTA 	case 0x84ab:	/* ditto */
1427934d11e3SKazutaka YOKOTA #if 0
1428934d11e3SKazutaka YOKOTA 	case 0x90ab:	/* 'G' */
1429934d11e3SKazutaka YOKOTA 	case 0x91ab:	/* 'P' */
1430934d11e3SKazutaka YOKOTA 	case 0x92ab:	/* 'A' */
1431934d11e3SKazutaka YOKOTA #endif
1432617b9080SKazutaka YOKOTA 		*type = KB_101;
1433617b9080SKazutaka YOKOTA 		break;
1434617b9080SKazutaka YOKOTA 	case -1:	/* AT 84 keyboard doesn't return ID */
1435617b9080SKazutaka YOKOTA 		*type = KB_84;
1436617b9080SKazutaka YOKOTA 		break;
1437617b9080SKazutaka YOKOTA 	default:
1438617b9080SKazutaka YOKOTA 		break;
1439617b9080SKazutaka YOKOTA 	}
1440617b9080SKazutaka YOKOTA 	if (bootverbose)
1441617b9080SKazutaka YOKOTA 		printf("atkbd: keyboard ID 0x%x (%d)\n", id, *type);
1442617b9080SKazutaka YOKOTA 
14436c176113SMichael Gmelin 	if (!HAS_QUIRK(kbdc, KBDC_QUIRK_RESET_AFTER_PROBE) &&
14446c176113SMichael Gmelin 	    atkbd_reset(kbdc, flags, c)) {
1445617b9080SKazutaka YOKOTA 		kbdc_lock(kbdc, FALSE);
1446617b9080SKazutaka YOKOTA 		return EIO;
1447617b9080SKazutaka YOKOTA 	}
1448617b9080SKazutaka YOKOTA 
1449617b9080SKazutaka YOKOTA 	/*
14502ce7d7a0SPoul-Henning Kamp 	 * Allow us to set the XT_KEYBD flag so that keyboards
1451617b9080SKazutaka YOKOTA 	 * such as those on the IBM ThinkPad laptop computers can be used
1452617b9080SKazutaka YOKOTA 	 * with the standard console driver.
1453617b9080SKazutaka YOKOTA 	 */
1454617b9080SKazutaka YOKOTA 	if (codeset == 1) {
1455617b9080SKazutaka YOKOTA 		if (send_kbd_command_and_data(kbdc,
1456617b9080SKazutaka YOKOTA 			KBDC_SET_SCANCODE_SET, codeset) == KBD_ACK) {
1457617b9080SKazutaka YOKOTA 			/* XT kbd doesn't need scan code translation */
1458617b9080SKazutaka YOKOTA 			c &= ~KBD_TRANSLATION;
1459617b9080SKazutaka YOKOTA 		} else {
1460617b9080SKazutaka YOKOTA 			/*
1461617b9080SKazutaka YOKOTA 			 * KEYBOARD ERROR
1462617b9080SKazutaka YOKOTA 			 * The XT kbd isn't usable unless the proper scan
1463617b9080SKazutaka YOKOTA 			 * code set is selected.
1464617b9080SKazutaka YOKOTA 			 */
14656c176113SMichael Gmelin 			set_controller_command_byte(kbdc, ALLOW_DISABLE_KBD(kbdc)
14666c176113SMichael Gmelin 			    ? 0xff : KBD_KBD_CONTROL_BITS, c);
1467617b9080SKazutaka YOKOTA 			kbdc_lock(kbdc, FALSE);
1468617b9080SKazutaka YOKOTA 			printf("atkbd: unable to set the XT keyboard mode.\n");
1469617b9080SKazutaka YOKOTA 			return EIO;
1470617b9080SKazutaka YOKOTA 		}
1471617b9080SKazutaka YOKOTA 	}
1472617b9080SKazutaka YOKOTA 
147373dbd3daSJohn Baldwin #if defined(__sparc64__)
1474f359876fSKazutaka YOKOTA 	if (send_kbd_command_and_data(
1475f359876fSKazutaka YOKOTA 		kbdc, KBDC_SET_SCANCODE_SET, 2) != KBD_ACK) {
1476f359876fSKazutaka YOKOTA 		printf("atkbd: can't set translation.\n");
1477f359876fSKazutaka YOKOTA 	}
1478f359876fSKazutaka YOKOTA 	c |= KBD_TRANSLATION;
1479f359876fSKazutaka YOKOTA #endif
1480f359876fSKazutaka YOKOTA 
14816c176113SMichael Gmelin 	/*
14826c176113SMichael Gmelin 	 * Some keyboards require a SETLEDS command to be sent after
14836c176113SMichael Gmelin 	 * the reset command before they will send keystrokes to us
14846c176113SMichael Gmelin 	 */
14856c176113SMichael Gmelin 	if (HAS_QUIRK(kbdc, KBDC_QUIRK_SETLEDS_ON_INIT) &&
14866c176113SMichael Gmelin 	    send_kbd_command_and_data(kbdc, KBDC_SET_LEDS, 0) != KBD_ACK) {
14876c176113SMichael Gmelin 		printf("atkbd: setleds failed\n");
14886c176113SMichael Gmelin 	}
14896c176113SMichael Gmelin 	if (!ALLOW_DISABLE_KBD(kbdc))
14906c176113SMichael Gmelin 	    send_kbd_command(kbdc, KBDC_ENABLE_KBD);
14916c176113SMichael Gmelin 
1492617b9080SKazutaka YOKOTA 	/* enable the keyboard port and intr. */
1493617b9080SKazutaka YOKOTA 	if (!set_controller_command_byte(kbdc,
1494617b9080SKazutaka YOKOTA 		KBD_KBD_CONTROL_BITS | KBD_TRANSLATION | KBD_OVERRIDE_KBD_LOCK,
1495617b9080SKazutaka YOKOTA 		(c & (KBD_TRANSLATION | KBD_OVERRIDE_KBD_LOCK))
1496617b9080SKazutaka YOKOTA 		    | KBD_ENABLE_KBD_PORT | KBD_ENABLE_KBD_INT)) {
1497617b9080SKazutaka YOKOTA 		/*
1498617b9080SKazutaka YOKOTA 		 * CONTROLLER ERROR
1499617b9080SKazutaka YOKOTA 		 * This is serious; we are left with the disabled
1500617b9080SKazutaka YOKOTA 		 * keyboard intr.
1501617b9080SKazutaka YOKOTA 		 */
15026c176113SMichael Gmelin 		set_controller_command_byte(kbdc, ALLOW_DISABLE_KBD(kbdc)
15036c176113SMichael Gmelin 		    ? 0xff : (KBD_KBD_CONTROL_BITS | KBD_TRANSLATION |
15046c176113SMichael Gmelin 			KBD_OVERRIDE_KBD_LOCK), c);
1505617b9080SKazutaka YOKOTA 		kbdc_lock(kbdc, FALSE);
1506617b9080SKazutaka YOKOTA 		printf("atkbd: unable to enable the keyboard port and intr.\n");
1507617b9080SKazutaka YOKOTA 		return EIO;
1508617b9080SKazutaka YOKOTA 	}
1509617b9080SKazutaka YOKOTA 
1510617b9080SKazutaka YOKOTA 	kbdc_lock(kbdc, FALSE);
1511617b9080SKazutaka YOKOTA 	return 0;
1512617b9080SKazutaka YOKOTA }
1513617b9080SKazutaka YOKOTA 
1514617b9080SKazutaka YOKOTA static int
1515617b9080SKazutaka YOKOTA write_kbd(KBDC kbdc, int command, int data)
1516617b9080SKazutaka YOKOTA {
1517617b9080SKazutaka YOKOTA 	int s;
1518617b9080SKazutaka YOKOTA 
1519617b9080SKazutaka YOKOTA 	/* prevent the timeout routine from polling the keyboard */
1520617b9080SKazutaka YOKOTA 	if (!kbdc_lock(kbdc, TRUE))
1521617b9080SKazutaka YOKOTA 		return EBUSY;
1522617b9080SKazutaka YOKOTA 
1523617b9080SKazutaka YOKOTA 	/* disable the keyboard and mouse interrupt */
1524617b9080SKazutaka YOKOTA 	s = spltty();
1525617b9080SKazutaka YOKOTA #if 0
1526617b9080SKazutaka YOKOTA 	c = get_controller_command_byte(kbdc);
1527617b9080SKazutaka YOKOTA 	if ((c == -1)
1528617b9080SKazutaka YOKOTA 	    || !set_controller_command_byte(kbdc,
1529617b9080SKazutaka YOKOTA 		kbdc_get_device_mask(kbdc),
1530617b9080SKazutaka YOKOTA 		KBD_DISABLE_KBD_PORT | KBD_DISABLE_KBD_INT
1531617b9080SKazutaka YOKOTA 		| KBD_DISABLE_AUX_PORT | KBD_DISABLE_AUX_INT)) {
1532617b9080SKazutaka YOKOTA 		/* CONTROLLER ERROR */
1533617b9080SKazutaka YOKOTA 		kbdc_lock(kbdc, FALSE);
1534617b9080SKazutaka YOKOTA 		splx(s);
1535617b9080SKazutaka YOKOTA 		return EIO;
1536617b9080SKazutaka YOKOTA 	}
1537617b9080SKazutaka YOKOTA 	/*
1538617b9080SKazutaka YOKOTA 	 * Now that the keyboard controller is told not to generate
1539617b9080SKazutaka YOKOTA 	 * the keyboard and mouse interrupts, call `splx()' to allow
1540617b9080SKazutaka YOKOTA 	 * the other tty interrupts. The clock interrupt may also occur,
1541617b9080SKazutaka YOKOTA 	 * but the timeout routine (`scrn_timer()') will be blocked
1542617b9080SKazutaka YOKOTA 	 * by the lock flag set via `kbdc_lock()'
1543617b9080SKazutaka YOKOTA 	 */
1544617b9080SKazutaka YOKOTA 	splx(s);
1545617b9080SKazutaka YOKOTA #endif
1546617b9080SKazutaka YOKOTA 	if (send_kbd_command_and_data(kbdc, command, data) != KBD_ACK)
1547617b9080SKazutaka YOKOTA 		send_kbd_command(kbdc, KBDC_ENABLE_KBD);
1548617b9080SKazutaka YOKOTA #if 0
1549617b9080SKazutaka YOKOTA 	/* restore the interrupts */
1550f0143dacSWarner Losh 	if (!set_controller_command_byte(kbdc, kbdc_get_device_mask(kbdc),
1551617b9080SKazutaka YOKOTA 	    c & (KBD_KBD_CONTROL_BITS | KBD_AUX_CONTROL_BITS))) {
1552617b9080SKazutaka YOKOTA 		/* CONTROLLER ERROR */
1553617b9080SKazutaka YOKOTA 	}
1554617b9080SKazutaka YOKOTA #else
1555617b9080SKazutaka YOKOTA 	splx(s);
1556617b9080SKazutaka YOKOTA #endif
1557617b9080SKazutaka YOKOTA 	kbdc_lock(kbdc, FALSE);
1558617b9080SKazutaka YOKOTA 
1559617b9080SKazutaka YOKOTA 	return 0;
1560617b9080SKazutaka YOKOTA }
1561617b9080SKazutaka YOKOTA 
1562617b9080SKazutaka YOKOTA static int
1563617b9080SKazutaka YOKOTA get_kbd_id(KBDC kbdc)
1564617b9080SKazutaka YOKOTA {
1565617b9080SKazutaka YOKOTA 	int id1, id2;
1566617b9080SKazutaka YOKOTA 
1567617b9080SKazutaka YOKOTA 	empty_both_buffers(kbdc, 10);
1568617b9080SKazutaka YOKOTA 	id1 = id2 = -1;
1569617b9080SKazutaka YOKOTA 	if (send_kbd_command(kbdc, KBDC_SEND_DEV_ID) != KBD_ACK)
1570617b9080SKazutaka YOKOTA 		return -1;
1571617b9080SKazutaka YOKOTA 
1572617b9080SKazutaka YOKOTA 	DELAY(10000); 	/* 10 msec delay */
1573617b9080SKazutaka YOKOTA 	id1 = read_kbd_data(kbdc);
1574617b9080SKazutaka YOKOTA 	if (id1 != -1)
1575617b9080SKazutaka YOKOTA 		id2 = read_kbd_data(kbdc);
1576617b9080SKazutaka YOKOTA 
1577617b9080SKazutaka YOKOTA 	if ((id1 == -1) || (id2 == -1)) {
1578617b9080SKazutaka YOKOTA 		empty_both_buffers(kbdc, 10);
1579617b9080SKazutaka YOKOTA 		test_controller(kbdc);
1580617b9080SKazutaka YOKOTA 		test_kbd_port(kbdc);
1581617b9080SKazutaka YOKOTA 		return -1;
1582617b9080SKazutaka YOKOTA 	}
1583617b9080SKazutaka YOKOTA 	return ((id2 << 8) | id1);
1584617b9080SKazutaka YOKOTA }
1585617b9080SKazutaka YOKOTA 
1586e9deda23SKazutaka YOKOTA static int delays[] = { 250, 500, 750, 1000 };
1587e9deda23SKazutaka YOKOTA static int rates[] = {  34,  38,  42,  46,  50,  55,  59,  63,
1588e9deda23SKazutaka YOKOTA 			68,  76,  84,  92, 100, 110, 118, 126,
1589e9deda23SKazutaka YOKOTA 		       136, 152, 168, 184, 200, 220, 236, 252,
1590e9deda23SKazutaka YOKOTA 		       272, 304, 336, 368, 400, 440, 472, 504 };
159157995893SKazutaka YOKOTA 
159257995893SKazutaka YOKOTA static int
159357995893SKazutaka YOKOTA typematic_delay(int i)
159457995893SKazutaka YOKOTA {
159557995893SKazutaka YOKOTA 	return delays[(i >> 5) & 3];
159657995893SKazutaka YOKOTA }
159757995893SKazutaka YOKOTA 
159857995893SKazutaka YOKOTA static int
159957995893SKazutaka YOKOTA typematic_rate(int i)
160057995893SKazutaka YOKOTA {
160157995893SKazutaka YOKOTA 	return rates[i & 0x1f];
160257995893SKazutaka YOKOTA }
160357995893SKazutaka YOKOTA 
160457995893SKazutaka YOKOTA static int
160557995893SKazutaka YOKOTA typematic(int delay, int rate)
160657995893SKazutaka YOKOTA {
1607e9deda23SKazutaka YOKOTA 	int value;
1608e9deda23SKazutaka YOKOTA 	int i;
1609e9deda23SKazutaka YOKOTA 
161073a1170aSPedro F. Giffuni 	for (i = nitems(delays) - 1; i > 0; --i) {
1611e9deda23SKazutaka YOKOTA 		if (delay >= delays[i])
1612e9deda23SKazutaka YOKOTA 			break;
1613e9deda23SKazutaka YOKOTA 	}
1614e9deda23SKazutaka YOKOTA 	value = i << 5;
161573a1170aSPedro F. Giffuni 	for (i = nitems(rates) - 1; i > 0; --i) {
1616e9deda23SKazutaka YOKOTA 		if (rate >= rates[i])
1617e9deda23SKazutaka YOKOTA 			break;
1618e9deda23SKazutaka YOKOTA 	}
1619e9deda23SKazutaka YOKOTA 	value |= i;
1620e9deda23SKazutaka YOKOTA 	return value;
1621e9deda23SKazutaka YOKOTA }
1622