2 * Copyright (C) 2008 Nathan Whitehorn
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
18 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
20 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
21 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
22 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
23 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 #include <sys/cdefs.h>
29 #include <sys/param.h>
30 #include <sys/systm.h>
31 #include <sys/module.h>
35 #include <sys/condvar.h>
36 #include <sys/callout.h>
37 #include <sys/kernel.h>
39 #include <machine/bus.h>
42 #include <dev/kbd/kbdreg.h>
43 #include <dev/kbd/kbdtables.h>
50 #define KBD_DRIVER_NAME "akbd"
52 #define AKBD_EMULATE_ATKBD 1
54 static int adb_kbd_probe(device_t dev);
55 static int adb_kbd_attach(device_t dev);
56 static int adb_kbd_detach(device_t dev);
57 static void akbd_repeat(void *xsc);
59 static u_int adb_kbd_receive_packet(device_t dev, u_char status,
60 u_char command, u_char reg, int len, u_char *data);
62 struct adb_kbd_softc {
75 #ifdef AKBD_EMULATE_ATKBD
76 uint8_t at_buffered_char[2];
80 struct callout sc_repeater;
82 int sc_repeatcontinue;
86 static device_method_t adb_kbd_methods[] = {
87 /* Device interface */
88 DEVMETHOD(device_probe, adb_kbd_probe),
89 DEVMETHOD(device_attach, adb_kbd_attach),
90 DEVMETHOD(device_detach, adb_kbd_detach),
91 DEVMETHOD(device_shutdown, bus_generic_shutdown),
92 DEVMETHOD(device_suspend, bus_generic_suspend),
93 DEVMETHOD(device_resume, bus_generic_resume),
96 DEVMETHOD(adb_receive_packet, adb_kbd_receive_packet),
101 static driver_t adb_kbd_driver = {
104 sizeof(struct adb_kbd_softc),
107 static devclass_t adb_kbd_devclass;
109 DRIVER_MODULE(akbd, adb, adb_kbd_driver, adb_kbd_devclass, 0, 0);
111 #ifdef AKBD_EMULATE_ATKBD
113 #define SCAN_PRESS 0x000
114 #define SCAN_RELEASE 0x080
115 #define SCAN_PREFIX_E0 0x100
116 #define SCAN_PREFIX_E1 0x200
117 #define SCAN_PREFIX_CTL 0x400
118 #define SCAN_PREFIX_SHIFT 0x800
119 #define SCAN_PREFIX (SCAN_PREFIX_E0 | SCAN_PREFIX_E1 | \
120 SCAN_PREFIX_CTL | SCAN_PREFIX_SHIFT)
122 static const uint8_t adb_to_at_scancode_map[128] = { 30, 31, 32, 33, 35, 34,
123 44, 45, 46, 47, 0, 48, 16, 17, 18, 19, 21, 20, 2, 3, 4, 5, 7, 6, 13,
124 10, 8, 12, 9, 11, 27, 24, 22, 26, 23, 25, 28, 38, 36, 40, 37, 39, 43,
125 51, 53, 49, 50, 52, 15, 57, 41, 14, 0, 1, 29, 0, 42, 58, 56, 97, 98,
126 100, 95, 0, 0, 83, 0, 55, 0, 78, 0, 69, 0, 0, 0, 91, 89, 0, 74, 13, 0,
127 0, 82, 79, 80, 81, 75, 76, 77, 71, 0, 72, 73, 0, 0, 0, 63, 64, 65, 61,
128 66, 67, 0, 87, 0, 105, 0, 70, 0, 68, 0, 88, 0, 107, 102, 94, 96, 103,
129 62, 99, 60, 101, 59, 54, 93, 90, 0, 0 };
132 keycode2scancode(int keycode, int shift, int up)
134 static const int scan[] = {
135 /* KP enter, right ctrl, KP divide */
138 0x37 | SCAN_PREFIX_SHIFT,
139 /* right alt, home, up, page up, left, right, end */
140 0x38, 0x47, 0x48, 0x49, 0x4b, 0x4d, 0x4f,
141 /* down, page down, insert, delete */
142 0x50, 0x51, 0x52, 0x53,
143 /* pause/break (see also below) */
146 * MS: left window, right window, menu
147 * also Sun: left meta, right meta, compose
151 /* help, stop, again, props, undo, front, copy */
152 0x68, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
153 /* open, paste, find, cut, audiomute, audiolower, audioraise */
154 0x64, 0x65, 0x66, 0x67, 0x25, 0x1f, 0x1e,
161 if ((keycode >= 89) && (keycode < 89 + sizeof(scan) / sizeof(scan[0])))
162 scancode = scan[keycode - 89] | SCAN_PREFIX_E0;
164 if ((keycode == 104) && !(shift & CTLS))
165 scancode = 0x45 | SCAN_PREFIX_E1 | SCAN_PREFIX_CTL;
167 scancode &= ~SCAN_PREFIX_SHIFT;
168 return (scancode | (up ? SCAN_RELEASE : SCAN_PRESS));
172 /* keyboard driver declaration */
173 static int akbd_configure(int flags);
174 static kbd_probe_t akbd_probe;
175 static kbd_init_t akbd_init;
176 static kbd_term_t akbd_term;
177 static kbd_intr_t akbd_interrupt;
178 static kbd_test_if_t akbd_test_if;
179 static kbd_enable_t akbd_enable;
180 static kbd_disable_t akbd_disable;
181 static kbd_read_t akbd_read;
182 static kbd_check_t akbd_check;
183 static kbd_read_char_t akbd_read_char;
184 static kbd_check_char_t akbd_check_char;
185 static kbd_ioctl_t akbd_ioctl;
186 static kbd_lock_t akbd_lock;
187 static kbd_clear_state_t akbd_clear_state;
188 static kbd_get_state_t akbd_get_state;
189 static kbd_set_state_t akbd_set_state;
190 static kbd_poll_mode_t akbd_poll;
192 keyboard_switch_t akbdsw = {
214 KEYBOARD_DRIVER(akbd, akbdsw, akbd_configure);
217 adb_kbd_probe(device_t dev)
221 type = adb_get_device_type(dev);
223 if (type != ADB_DEVICE_KEYBOARD)
226 switch(adb_get_device_handler(dev)) {
228 device_set_desc(dev,"Apple Standard Keyboard");
231 device_set_desc(dev,"Apple Extended Keyboard");
234 device_set_desc(dev,"Apple ISO Keyboard");
237 device_set_desc(dev,"Apple Extended ISO Keyboard");
240 device_set_desc(dev,"Apple Keyboard II");
243 device_set_desc(dev,"Apple ISO Keyboard II");
246 device_set_desc(dev,"PowerBook Keyboard");
249 device_set_desc(dev,"PowerBook ISO Keyboard");
252 device_set_desc(dev,"PowerBook Extended Keyboard");
255 device_set_desc(dev,"Apple Design Keyboard");
258 device_set_desc(dev,"PowerBook G3 Keyboard");
261 device_set_desc(dev,"iBook Keyboard");
264 device_set_desc(dev,"ADB Keyboard");
281 adb_kbd_attach(device_t dev)
283 struct adb_kbd_softc *sc;
284 keyboard_switch_t *sw;
286 sw = kbd_get_switch(KBD_DRIVER_NAME);
291 sc = device_get_softc(dev);
295 sc->have_led_control = 0;
298 /* Try stepping forward to the extended keyboard protocol */
299 adb_set_device_handler(dev,3);
301 mtx_init(&sc->sc_mutex,KBD_DRIVER_NAME,MTX_DEF,0);
302 cv_init(&sc->sc_cv,KBD_DRIVER_NAME);
303 callout_init(&sc->sc_repeater, 0);
305 #ifdef AKBD_EMULATE_ATKBD
306 kbd_init_struct(&sc->sc_kbd, KBD_DRIVER_NAME, KB_101, 0, 0, 0, 0);
307 kbd_set_maps(&sc->sc_kbd, &key_map, &accent_map, fkey_tab,
308 sizeof(fkey_tab) / sizeof(fkey_tab[0]));
310 #error ADB raw mode not implemented
313 KBD_FOUND_DEVICE(&sc->sc_kbd);
314 KBD_PROBE_DONE(&sc->sc_kbd);
315 KBD_INIT_DONE(&sc->sc_kbd);
316 KBD_CONFIG_DONE(&sc->sc_kbd);
318 (*sw->enable)(&sc->sc_kbd);
320 kbd_register(&sc->sc_kbd);
322 #ifdef KBD_INSTALL_CDEV
323 if (kbd_attach(&sc->sc_kbd)) {
329 /* Check if we can read out the LED state from
330 this keyboard by reading the key state register */
331 if (adb_read_register(dev, 2, NULL) == 2)
332 sc->have_led_control = 1;
334 adb_set_autopoll(dev,1);
340 adb_kbd_detach(device_t dev)
342 struct adb_kbd_softc *sc;
345 sc = device_get_softc(dev);
347 adb_set_autopoll(dev,0);
348 callout_stop(&sc->sc_repeater);
350 mtx_lock(&sc->sc_mutex);
352 kbd = kbd_get_keyboard(kbd_find_keyboard(KBD_DRIVER_NAME,
353 device_get_unit(dev)));
357 #ifdef KBD_INSTALL_CDEV
363 mtx_unlock(&sc->sc_mutex);
365 mtx_destroy(&sc->sc_mutex);
366 cv_destroy(&sc->sc_cv);
372 adb_kbd_receive_packet(device_t dev, u_char status,
373 u_char command, u_char reg, int len, u_char *data)
375 struct adb_kbd_softc *sc;
377 sc = device_get_softc(dev);
379 if (command != ADB_COMMAND_TALK)
382 if (reg != 0 || len != 2)
385 mtx_lock(&sc->sc_mutex);
386 if ((data[0] & 0x7f) == 57 && sc->buffers < 7) {
387 /* Fake the down/up cycle for caps lock */
388 sc->buffer[sc->buffers++] = data[0] & 0x7f;
389 sc->buffer[sc->buffers++] = (data[0] & 0x7f) | (1 << 7);
391 sc->buffer[sc->buffers++] = data[0];
394 if (sc->buffer[sc->buffers-1] < 0xff)
395 sc->last_press = sc->buffer[sc->buffers-1];
397 if ((data[1] & 0x7f) == 57 && sc->buffers < 7) {
398 /* Fake the down/up cycle for caps lock */
399 sc->buffer[sc->buffers++] = data[1] & 0x7f;
400 sc->buffer[sc->buffers++] = (data[1] & 0x7f) | (1 << 7);
402 sc->buffer[sc->buffers++] = data[1];
405 if (sc->buffer[sc->buffers-1] < 0xff)
406 sc->last_press = sc->buffer[sc->buffers-1];
408 /* Stop any existing key repeating */
409 callout_stop(&sc->sc_repeater);
411 /* Schedule a repeat callback on keydown */
412 if (!(sc->last_press & (1 << 7))) {
413 callout_reset(&sc->sc_repeater,
414 ms_to_ticks(sc->sc_kbd.kb_delay1), akbd_repeat, sc);
416 mtx_unlock(&sc->sc_mutex);
418 cv_broadcast(&sc->sc_cv);
420 if (KBD_IS_ACTIVE(&sc->sc_kbd) && KBD_IS_BUSY(&sc->sc_kbd)) {
421 sc->sc_kbd.kb_callback.kc_func(&sc->sc_kbd,
422 KBDIO_KEYINPUT, sc->sc_kbd.kb_callback.kc_arg);
429 akbd_repeat(void *xsc) {
430 struct adb_kbd_softc *sc = xsc;
433 /* Fake an up/down key repeat so long as we have the
435 mtx_lock(&sc->sc_mutex);
436 if (sc->buffers < 7) {
437 sc->buffer[sc->buffers++] = sc->last_press | (1 << 7);
438 sc->buffer[sc->buffers++] = sc->last_press;
442 mtx_unlock(&sc->sc_mutex);
444 if (notify_kbd && KBD_IS_ACTIVE(&sc->sc_kbd)
445 && KBD_IS_BUSY(&sc->sc_kbd)) {
446 sc->sc_kbd.kb_callback.kc_func(&sc->sc_kbd,
447 KBDIO_KEYINPUT, sc->sc_kbd.kb_callback.kc_arg);
450 /* Reschedule the callout */
451 callout_reset(&sc->sc_repeater, ms_to_ticks(sc->sc_kbd.kb_delay2),
456 akbd_configure(int flags)
462 akbd_probe(int unit, void *arg, int flags)
468 akbd_init(int unit, keyboard_t **kbdp, void *arg, int flags)
474 akbd_term(keyboard_t *kbd)
480 akbd_interrupt(keyboard_t *kbd, void *arg)
486 akbd_test_if(keyboard_t *kbd)
492 akbd_enable(keyboard_t *kbd)
499 akbd_disable(keyboard_t *kbd)
501 struct adb_kbd_softc *sc;
502 sc = (struct adb_kbd_softc *)(kbd);
504 callout_stop(&sc->sc_repeater);
510 akbd_read(keyboard_t *kbd, int wait)
516 akbd_check(keyboard_t *kbd)
518 struct adb_kbd_softc *sc;
520 if (!KBD_IS_ACTIVE(kbd))
523 sc = (struct adb_kbd_softc *)(kbd);
525 mtx_lock(&sc->sc_mutex);
526 #ifdef AKBD_EMULATE_ATKBD
527 if (sc->at_buffered_char[0]) {
528 mtx_unlock(&sc->sc_mutex);
533 if (sc->buffers > 0) {
534 mtx_unlock(&sc->sc_mutex);
537 mtx_unlock(&sc->sc_mutex);
543 akbd_read_char(keyboard_t *kbd, int wait)
545 struct adb_kbd_softc *sc;
550 sc = (struct adb_kbd_softc *)(kbd);
552 mtx_lock(&sc->sc_mutex);
554 #if defined(AKBD_EMULATE_ATKBD)
555 if (sc->sc_mode == K_RAW && sc->at_buffered_char[0]) {
556 key = sc->at_buffered_char[0];
557 if (key & SCAN_PREFIX) {
558 sc->at_buffered_char[0] = key & ~SCAN_PREFIX;
559 key = (key & SCAN_PREFIX_E0) ? 0xe0 : 0xe1;
561 sc->at_buffered_char[0] = sc->at_buffered_char[1];
562 sc->at_buffered_char[1] = 0;
565 mtx_unlock(&sc->sc_mutex);
571 if (!sc->buffers && wait)
572 cv_wait(&sc->sc_cv,&sc->sc_mutex);
575 mtx_unlock(&sc->sc_mutex);
579 adb_code = sc->buffer[0];
581 for (i = 1; i < sc->buffers; i++)
582 sc->buffer[i-1] = sc->buffer[i];
586 #ifdef AKBD_EMULATE_ATKBD
587 key = adb_to_at_scancode_map[adb_code & 0x7f];
588 if (sc->sc_mode == K_CODE) {
589 /* Add the key-release bit */
590 key |= adb_code & 0x80;
591 } else if (sc->sc_mode == K_RAW) {
593 * In the raw case, we have to emulate the gross
594 * variable-length AT keyboard thing. Since this code
595 * is copied from sunkbd, which is the same code
596 * as ukbd, it might be nice to have this centralized.
599 key = keycode2scancode(key,
602 if (key & SCAN_PREFIX) {
603 if (key & SCAN_PREFIX_CTL) {
604 sc->at_buffered_char[0] =
605 0x1d | (key & SCAN_RELEASE);
606 sc->at_buffered_char[1] =
608 } else if (key & SCAN_PREFIX_SHIFT) {
609 sc->at_buffered_char[0] =
610 0x2a | (key & SCAN_RELEASE);
611 sc->at_buffered_char[1] =
612 key & ~SCAN_PREFIX_SHIFT;
614 sc->at_buffered_char[0] =
616 sc->at_buffered_char[1] = 0;
619 key = (key & SCAN_PREFIX_E0) ? 0xe0 : 0xe1;
626 mtx_unlock(&sc->sc_mutex);
632 akbd_check_char(keyboard_t *kbd)
634 if (!KBD_IS_ACTIVE(kbd))
637 return (akbd_check(kbd));
641 set_typematic(keyboard_t *kbd, int code)
643 /* These numbers are in microseconds, so convert to ticks */
645 static int delays[] = { 250, 500, 750, 1000 };
646 static int rates[] = { 34, 38, 42, 46, 50, 55, 59, 63,
647 68, 76, 84, 92, 100, 110, 118, 126,
648 136, 152, 168, 184, 200, 220, 236, 252,
649 272, 304, 336, 368, 400, 440, 472, 504 };
653 kbd->kb_delay1 = delays[(code >> 5) & 3];
654 kbd->kb_delay2 = rates[code & 0x1f];
658 static int akbd_ioctl(keyboard_t *kbd, u_long cmd, caddr_t data)
660 struct adb_kbd_softc *sc;
664 sc = (struct adb_kbd_softc *)(kbd);
669 *(int *)data = sc->sc_mode;
672 switch (*(int *)data) {
674 if (sc->sc_mode != K_XLATE) {
675 /* make lock key state and LED state match */
676 sc->sc_state &= ~LOCK_MASK;
677 sc->sc_state |= KBD_LED_VAL(kbd);
682 if (sc->sc_mode != *(int *)data)
683 sc->sc_mode = *(int *)data;
693 *(int *)data = KBD_LED_VAL(kbd);
697 if (*(int *)data & ~LOCK_MASK) {
701 sc->sc_state &= ~LOCK_MASK;
702 sc->sc_state |= *(int *)data;
707 KBD_LED_VAL(kbd) = *(int *)data;
709 if (!sc->have_led_control)
712 r2 = (~0 & 0x04) | 3;
714 if (*(int *)data & NLKED)
716 if (*(int *)data & CLKED)
718 if (*(int *)data & SLKED)
721 adb_send_packet(sc->sc_dev,ADB_COMMAND_LISTEN,2,
722 sizeof(uint16_t),(u_char *)&r2);
727 *(int *)data = sc->sc_state & LOCK_MASK;
731 if (!KBD_HAS_DEVICE(kbd))
733 if (((int *)data)[1] < 0)
735 if (((int *)data)[0] < 0)
737 else if (((int *)data)[0] == 0) /* fastest possible value */
738 kbd->kb_delay1 = 200;
740 kbd->kb_delay1 = ((int *)data)[0];
741 kbd->kb_delay2 = ((int *)data)[1];
746 error = set_typematic(kbd, *(int *)data);
754 return (genkbd_commonioctl(kbd, cmd, data));
760 static int akbd_lock(keyboard_t *kbd, int lock)
765 static void akbd_clear_state(keyboard_t *kbd)
767 struct adb_kbd_softc *sc;
769 sc = (struct adb_kbd_softc *)(kbd);
771 mtx_lock(&sc->sc_mutex);
774 callout_stop(&sc->sc_repeater);
776 #if defined(AKBD_EMULATE_ATKBD)
777 sc->at_buffered_char[0] = 0;
778 sc->at_buffered_char[1] = 0;
780 mtx_unlock(&sc->sc_mutex);
783 static int akbd_get_state(keyboard_t *kbd, void *buf, size_t len)
788 static int akbd_set_state(keyboard_t *kbd, void *buf, size_t len)
793 static int akbd_poll(keyboard_t *kbd, int on)
799 akbd_modevent(module_t mod, int type, void *data)
803 kbd_add_driver(&akbd_kbd_driver);
807 kbd_delete_driver(&akbd_kbd_driver);
817 DEV_MODULE(akbd, akbd_modevent, NULL);