1617b9080SKazutaka YOKOTA /*- 2617b9080SKazutaka YOKOTA * Copyright (c) 1999 Kazutaka YOKOTA <yokota@zodiac.mech.utsunomiya-u.ac.jp> 3617b9080SKazutaka YOKOTA * All rights reserved. 4617b9080SKazutaka YOKOTA * 5617b9080SKazutaka YOKOTA * Redistribution and use in source and binary forms, with or without 6617b9080SKazutaka YOKOTA * modification, are permitted provided that the following conditions 7617b9080SKazutaka YOKOTA * are met: 8617b9080SKazutaka YOKOTA * 1. Redistributions of source code must retain the above copyright 9617b9080SKazutaka YOKOTA * notice, this list of conditions and the following disclaimer as 10617b9080SKazutaka YOKOTA * the first lines of this file unmodified. 11617b9080SKazutaka YOKOTA * 2. Redistributions in binary form must reproduce the above copyright 12617b9080SKazutaka YOKOTA * notice, this list of conditions and the following disclaimer in the 13617b9080SKazutaka YOKOTA * documentation and/or other materials provided with the distribution. 14617b9080SKazutaka YOKOTA * 15617b9080SKazutaka YOKOTA * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR 16617b9080SKazutaka YOKOTA * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17617b9080SKazutaka YOKOTA * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18617b9080SKazutaka YOKOTA * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, 19617b9080SKazutaka YOKOTA * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20617b9080SKazutaka YOKOTA * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21617b9080SKazutaka YOKOTA * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22617b9080SKazutaka YOKOTA * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23617b9080SKazutaka YOKOTA * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24617b9080SKazutaka YOKOTA * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25617b9080SKazutaka YOKOTA * 26617b9080SKazutaka YOKOTA */ 27617b9080SKazutaka YOKOTA 28aad970f1SDavid E. O'Brien #include <sys/cdefs.h> 29aad970f1SDavid E. O'Brien __FBSDID("$FreeBSD$"); 30aad970f1SDavid E. O'Brien 319fddcc66SRuslan Ermilov #include "opt_compat.h" 32617b9080SKazutaka YOKOTA #include "opt_kbd.h" 33e9deda23SKazutaka YOKOTA #include "opt_atkbd.h" 34617b9080SKazutaka YOKOTA 35617b9080SKazutaka YOKOTA #include <sys/param.h> 36617b9080SKazutaka YOKOTA #include <sys/systm.h> 37617b9080SKazutaka YOKOTA #include <sys/kernel.h> 38d3c87b85SKazutaka YOKOTA #include <sys/bus.h> 39520b6353SMarius Strobl #include <sys/eventhandler.h> 40617b9080SKazutaka YOKOTA #include <sys/proc.h> 41104a9b7eSAlexander Kabaev #include <sys/limits.h> 42617b9080SKazutaka YOKOTA #include <sys/malloc.h> 43617b9080SKazutaka YOKOTA 44db3e34cbSKazutaka YOKOTA #include <machine/bus.h> 45db3e34cbSKazutaka YOKOTA #include <machine/resource.h> 46db3e34cbSKazutaka YOKOTA 47ee8cbcb4SJung-uk Kim #if defined(__i386__) || defined(__amd64__) 4856f5e27cSKazutaka YOKOTA #include <machine/md_var.h> 4956f5e27cSKazutaka YOKOTA #include <machine/psl.h> 5056f5e27cSKazutaka YOKOTA 5156f5e27cSKazutaka YOKOTA #include <vm/vm.h> 5256f5e27cSKazutaka YOKOTA #include <vm/pmap.h> 53092a5c45SJohn Baldwin #include <vm/vm_param.h> 54520b6353SMarius Strobl 55520b6353SMarius Strobl #include <isa/isareg.h> 568b1620e0SXin LI #endif /* __i386__ || __amd64__ */ 5756f5e27cSKazutaka YOKOTA 5876495257SKazutaka YOKOTA #include <sys/kbio.h> 59617b9080SKazutaka YOKOTA #include <dev/kbd/kbdreg.h> 60520b6353SMarius Strobl #include <dev/atkbdc/atkbdreg.h> 61520b6353SMarius Strobl #include <dev/atkbdc/atkbdcreg.h> 62f359876fSKazutaka YOKOTA 63fadf3fb9SJohn Baldwin typedef struct atkbd_state { 64fadf3fb9SJohn Baldwin KBDC kbdc; /* keyboard controller */ 65fadf3fb9SJohn Baldwin int ks_mode; /* input mode (K_XLATE,K_RAW,K_CODE) */ 66fadf3fb9SJohn Baldwin int ks_flags; /* flags */ 67fadf3fb9SJohn Baldwin #define COMPOSE (1 << 0) 68fadf3fb9SJohn Baldwin int ks_polling; 69fadf3fb9SJohn Baldwin int ks_state; /* shift/lock key state */ 70fadf3fb9SJohn Baldwin int ks_accents; /* accent key index (> 0) */ 71fadf3fb9SJohn Baldwin u_int ks_composed_char; /* composed char code (> 0) */ 72fadf3fb9SJohn Baldwin u_char ks_prefix; /* AT scan code prefix */ 73fadf3fb9SJohn Baldwin struct callout ks_timer; 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é 86617b9080SKazutaka YOKOTA int 870897438aSWarner Losh atkbd_probe_unit(device_t dev, int irq, int flags) 88617b9080SKazutaka YOKOTA { 89617b9080SKazutaka YOKOTA keyboard_switch_t *sw; 90617b9080SKazutaka YOKOTA int args[2]; 91e9deda23SKazutaka YOKOTA int error; 92617b9080SKazutaka YOKOTA 93617b9080SKazutaka YOKOTA sw = kbd_get_switch(ATKBD_DRIVER_NAME); 94617b9080SKazutaka YOKOTA if (sw == NULL) 95617b9080SKazutaka YOKOTA return ENXIO; 96617b9080SKazutaka YOKOTA 970897438aSWarner Losh args[0] = device_get_unit(device_get_parent(dev)); 98617b9080SKazutaka YOKOTA args[1] = irq; 990897438aSWarner Losh error = (*sw->probe)(device_get_unit(dev), args, flags); 100e9deda23SKazutaka YOKOTA if (error) 101e9deda23SKazutaka YOKOTA return error; 102e9deda23SKazutaka YOKOTA return 0; 103617b9080SKazutaka YOKOTA } 104617b9080SKazutaka YOKOTA 105617b9080SKazutaka YOKOTA int 1060897438aSWarner Losh atkbd_attach_unit(device_t dev, keyboard_t **kbd, int irq, int flags) 107617b9080SKazutaka YOKOTA { 108617b9080SKazutaka YOKOTA keyboard_switch_t *sw; 109fadf3fb9SJohn Baldwin atkbd_state_t *state; 110e9deda23SKazutaka YOKOTA int args[2]; 111617b9080SKazutaka YOKOTA int error; 1120897438aSWarner Losh int unit; 113617b9080SKazutaka YOKOTA 114617b9080SKazutaka YOKOTA sw = kbd_get_switch(ATKBD_DRIVER_NAME); 115617b9080SKazutaka YOKOTA if (sw == NULL) 116617b9080SKazutaka YOKOTA return ENXIO; 117617b9080SKazutaka YOKOTA 118617b9080SKazutaka YOKOTA /* reset, initialize and enable the device */ 1190897438aSWarner Losh unit = device_get_unit(dev); 1200897438aSWarner Losh args[0] = device_get_unit(device_get_parent(dev)); 121e9deda23SKazutaka YOKOTA args[1] = irq; 122800da3b2SKazutaka YOKOTA *kbd = NULL; 123e9deda23SKazutaka YOKOTA error = (*sw->probe)(unit, args, flags); 124617b9080SKazutaka YOKOTA if (error) 125e9deda23SKazutaka YOKOTA return error; 126800da3b2SKazutaka YOKOTA error = (*sw->init)(unit, kbd, args, flags); 127e9deda23SKazutaka YOKOTA if (error) 128e9deda23SKazutaka YOKOTA return error; 129800da3b2SKazutaka YOKOTA (*sw->enable)(*kbd); 130617b9080SKazutaka YOKOTA 131617b9080SKazutaka YOKOTA #ifdef KBD_INSTALL_CDEV 132617b9080SKazutaka YOKOTA /* attach a virtual keyboard cdev */ 133800da3b2SKazutaka YOKOTA error = kbd_attach(*kbd); 134617b9080SKazutaka YOKOTA if (error) 135617b9080SKazutaka YOKOTA return error; 136617b9080SKazutaka YOKOTA #endif 137617b9080SKazutaka YOKOTA 138617b9080SKazutaka YOKOTA /* 139617b9080SKazutaka YOKOTA * This is a kludge to compensate for lost keyboard interrupts. 140617b9080SKazutaka YOKOTA * A similar code used to be in syscons. See below. XXX 141617b9080SKazutaka YOKOTA */ 142fadf3fb9SJohn Baldwin state = (atkbd_state_t *)(*kbd)->kb_data; 143fadf3fb9SJohn Baldwin callout_init(&state->ks_timer, 0); 144800da3b2SKazutaka YOKOTA atkbd_timeout(*kbd); 145617b9080SKazutaka YOKOTA 146617b9080SKazutaka YOKOTA if (bootverbose) 147800da3b2SKazutaka YOKOTA (*sw->diag)(*kbd, bootverbose); 148520b6353SMarius Strobl 149520b6353SMarius Strobl EVENTHANDLER_REGISTER(shutdown_final, atkbd_shutdown_final, *kbd, 150520b6353SMarius Strobl SHUTDOWN_PRI_DEFAULT); 151520b6353SMarius Strobl 152617b9080SKazutaka YOKOTA return 0; 153617b9080SKazutaka YOKOTA } 154617b9080SKazutaka YOKOTA 155617b9080SKazutaka YOKOTA static void 156617b9080SKazutaka YOKOTA atkbd_timeout(void *arg) 157617b9080SKazutaka YOKOTA { 158fadf3fb9SJohn Baldwin atkbd_state_t *state; 159617b9080SKazutaka YOKOTA keyboard_t *kbd; 160617b9080SKazutaka YOKOTA int s; 161617b9080SKazutaka YOKOTA 162617b9080SKazutaka YOKOTA /* 1637c6f57a3SKazutaka YOKOTA * The original text of the following comments are extracted 1647c6f57a3SKazutaka YOKOTA * from syscons.c (1.287) 1657c6f57a3SKazutaka YOKOTA * 166617b9080SKazutaka YOKOTA * With release 2.1 of the Xaccel server, the keyboard is left 167617b9080SKazutaka YOKOTA * hanging pretty often. Apparently an interrupt from the 168617b9080SKazutaka YOKOTA * keyboard is lost, and I don't know why (yet). 1697c6f57a3SKazutaka YOKOTA * This ugly hack calls the low-level interrupt routine if input 1707c6f57a3SKazutaka YOKOTA * is ready for the keyboard and conveniently hides the problem. XXX 1717c6f57a3SKazutaka YOKOTA * 1727c6f57a3SKazutaka YOKOTA * Try removing anything stuck in the keyboard controller; whether 1737c6f57a3SKazutaka YOKOTA * it's a keyboard scan code or mouse data. The low-level 1747c6f57a3SKazutaka YOKOTA * interrupt routine doesn't read the mouse data directly, 1757c6f57a3SKazutaka YOKOTA * but the keyboard controller driver will, as a side effect. 176617b9080SKazutaka YOKOTA */ 177617b9080SKazutaka YOKOTA /* 1787c6f57a3SKazutaka YOKOTA * And here is bde's original comment about this: 1797c6f57a3SKazutaka YOKOTA * 1807c6f57a3SKazutaka YOKOTA * This is necessary to handle edge triggered interrupts - if we 1817c6f57a3SKazutaka YOKOTA * returned when our IRQ is high due to unserviced input, then there 1827c6f57a3SKazutaka YOKOTA * would be no more keyboard IRQs until the keyboard is reset by 1837c6f57a3SKazutaka YOKOTA * external powers. 1847c6f57a3SKazutaka YOKOTA * 1857c6f57a3SKazutaka YOKOTA * The keyboard apparently unwedges the irq in most cases. 186617b9080SKazutaka YOKOTA */ 187617b9080SKazutaka YOKOTA s = spltty(); 188617b9080SKazutaka YOKOTA kbd = (keyboard_t *)arg; 189259699b2SWojciech A. Koszek if (kbdd_lock(kbd, TRUE)) { 190617b9080SKazutaka YOKOTA /* 191617b9080SKazutaka YOKOTA * We have seen the lock flag is not set. Let's reset 192617b9080SKazutaka YOKOTA * the flag early, otherwise the LED update routine fails 193617b9080SKazutaka YOKOTA * which may want the lock during the interrupt routine. 194617b9080SKazutaka YOKOTA */ 195259699b2SWojciech A. Koszek kbdd_lock(kbd, FALSE); 196259699b2SWojciech A. Koszek if (kbdd_check_char(kbd)) 197259699b2SWojciech A. Koszek kbdd_intr(kbd, NULL); 198617b9080SKazutaka YOKOTA } 199617b9080SKazutaka YOKOTA splx(s); 200fadf3fb9SJohn Baldwin state = (atkbd_state_t *)kbd->kb_data; 201fadf3fb9SJohn Baldwin callout_reset(&state->ks_timer, hz / 10, atkbd_timeout, arg); 202617b9080SKazutaka YOKOTA } 203617b9080SKazutaka YOKOTA 204617b9080SKazutaka YOKOTA /* LOW-LEVEL */ 205617b9080SKazutaka YOKOTA 206617b9080SKazutaka YOKOTA #define ATKBD_DEFAULT 0 207617b9080SKazutaka YOKOTA 208617b9080SKazutaka YOKOTA /* keyboard driver declaration */ 209617b9080SKazutaka YOKOTA static int atkbd_configure(int flags); 210617b9080SKazutaka YOKOTA static kbd_probe_t atkbd_probe; 211617b9080SKazutaka YOKOTA static kbd_init_t atkbd_init; 212617b9080SKazutaka YOKOTA static kbd_term_t atkbd_term; 213617b9080SKazutaka YOKOTA static kbd_intr_t atkbd_intr; 214617b9080SKazutaka YOKOTA static kbd_test_if_t atkbd_test_if; 215617b9080SKazutaka YOKOTA static kbd_enable_t atkbd_enable; 216617b9080SKazutaka YOKOTA static kbd_disable_t atkbd_disable; 217617b9080SKazutaka YOKOTA static kbd_read_t atkbd_read; 218617b9080SKazutaka YOKOTA static kbd_check_t atkbd_check; 219617b9080SKazutaka YOKOTA static kbd_read_char_t atkbd_read_char; 220617b9080SKazutaka YOKOTA static kbd_check_char_t atkbd_check_char; 221617b9080SKazutaka YOKOTA static kbd_ioctl_t atkbd_ioctl; 222617b9080SKazutaka YOKOTA static kbd_lock_t atkbd_lock; 223617b9080SKazutaka YOKOTA static kbd_clear_state_t atkbd_clear_state; 224617b9080SKazutaka YOKOTA static kbd_get_state_t atkbd_get_state; 225617b9080SKazutaka YOKOTA static kbd_set_state_t atkbd_set_state; 226e9deda23SKazutaka YOKOTA static kbd_poll_mode_t atkbd_poll; 227617b9080SKazutaka YOKOTA 22851da11a2SMark Murray static keyboard_switch_t atkbdsw = { 229617b9080SKazutaka YOKOTA atkbd_probe, 230617b9080SKazutaka YOKOTA atkbd_init, 231617b9080SKazutaka YOKOTA atkbd_term, 232617b9080SKazutaka YOKOTA atkbd_intr, 233617b9080SKazutaka YOKOTA atkbd_test_if, 234617b9080SKazutaka YOKOTA atkbd_enable, 235617b9080SKazutaka YOKOTA atkbd_disable, 236617b9080SKazutaka YOKOTA atkbd_read, 237617b9080SKazutaka YOKOTA atkbd_check, 238617b9080SKazutaka YOKOTA atkbd_read_char, 239617b9080SKazutaka YOKOTA atkbd_check_char, 240617b9080SKazutaka YOKOTA atkbd_ioctl, 241617b9080SKazutaka YOKOTA atkbd_lock, 242617b9080SKazutaka YOKOTA atkbd_clear_state, 243617b9080SKazutaka YOKOTA atkbd_get_state, 244617b9080SKazutaka YOKOTA atkbd_set_state, 245617b9080SKazutaka YOKOTA genkbd_get_fkeystr, 246e9deda23SKazutaka YOKOTA atkbd_poll, 247617b9080SKazutaka YOKOTA genkbd_diag, 248617b9080SKazutaka YOKOTA }; 249617b9080SKazutaka YOKOTA 250617b9080SKazutaka YOKOTA KEYBOARD_DRIVER(atkbd, atkbdsw, atkbd_configure); 251617b9080SKazutaka YOKOTA 252617b9080SKazutaka YOKOTA /* local functions */ 253b19f7eecSRoger Pau Monné static int set_typematic(keyboard_t *kbd); 254617b9080SKazutaka YOKOTA static int setup_kbd_port(KBDC kbdc, int port, int intr); 255617b9080SKazutaka YOKOTA static int get_kbd_echo(KBDC kbdc); 256617b9080SKazutaka YOKOTA static int probe_keyboard(KBDC kbdc, int flags); 257617b9080SKazutaka YOKOTA static int init_keyboard(KBDC kbdc, int *type, int flags); 258617b9080SKazutaka YOKOTA static int write_kbd(KBDC kbdc, int command, int data); 259617b9080SKazutaka YOKOTA static int get_kbd_id(KBDC kbdc); 260e9deda23SKazutaka YOKOTA static int typematic(int delay, int rate); 26157995893SKazutaka YOKOTA static int typematic_delay(int delay); 26257995893SKazutaka YOKOTA static int typematic_rate(int rate); 263617b9080SKazutaka YOKOTA 264617b9080SKazutaka YOKOTA /* local variables */ 265617b9080SKazutaka YOKOTA 266617b9080SKazutaka YOKOTA /* the initial key map, accent map and fkey strings */ 267e9deda23SKazutaka YOKOTA #ifdef ATKBD_DFLT_KEYMAP 268e9deda23SKazutaka YOKOTA #define KBD_DFLT_KEYMAP 269e9deda23SKazutaka YOKOTA #include "atkbdmap.h" 270e9deda23SKazutaka YOKOTA #endif 271f359876fSKazutaka YOKOTA #include <dev/kbd/kbdtables.h> 272617b9080SKazutaka YOKOTA 273617b9080SKazutaka YOKOTA /* structures for the default keyboard */ 274617b9080SKazutaka YOKOTA static keyboard_t default_kbd; 275617b9080SKazutaka YOKOTA static atkbd_state_t default_kbd_state; 276617b9080SKazutaka YOKOTA static keymap_t default_keymap; 277617b9080SKazutaka YOKOTA static accentmap_t default_accentmap; 278617b9080SKazutaka YOKOTA static fkeytab_t default_fkeytab[NUM_FKEYS]; 279617b9080SKazutaka YOKOTA 280617b9080SKazutaka YOKOTA /* 281617b9080SKazutaka YOKOTA * The back door to the keyboard driver! 282617b9080SKazutaka YOKOTA * This function is called by the console driver, via the kbdio module, 283617b9080SKazutaka YOKOTA * to tickle keyboard drivers when the low-level console is being initialized. 284617b9080SKazutaka YOKOTA * Almost nothing in the kernel has been initialied yet. Try to probe 285617b9080SKazutaka YOKOTA * keyboards if possible. 2862bb113d0SJeroen Ruigrok van der Werven * NOTE: because of the way the low-level console is initialized, this routine 287617b9080SKazutaka YOKOTA * may be called more than once!! 288617b9080SKazutaka YOKOTA */ 289617b9080SKazutaka YOKOTA static int 290617b9080SKazutaka YOKOTA atkbd_configure(int flags) 291617b9080SKazutaka YOKOTA { 292617b9080SKazutaka YOKOTA keyboard_t *kbd; 293617b9080SKazutaka YOKOTA int arg[2]; 294e9deda23SKazutaka YOKOTA int i; 295617b9080SKazutaka YOKOTA 2966621aa5cSMaxim Sobolev /* 2976621aa5cSMaxim Sobolev * Probe the keyboard controller, if not present or if the driver 2986621aa5cSMaxim Sobolev * is disabled, unregister the keyboard if any. 2996621aa5cSMaxim Sobolev */ 3006621aa5cSMaxim Sobolev if (atkbdc_configure() != 0 || 3016621aa5cSMaxim Sobolev resource_disabled("atkbd", ATKBD_DEFAULT)) { 302e9deda23SKazutaka YOKOTA i = kbd_find_keyboard(ATKBD_DRIVER_NAME, ATKBD_DEFAULT); 303e9deda23SKazutaka YOKOTA if (i >= 0) { 304e9deda23SKazutaka YOKOTA kbd = kbd_get_keyboard(i); 305e9deda23SKazutaka YOKOTA kbd_unregister(kbd); 306e9deda23SKazutaka YOKOTA kbd->kb_flags &= ~KB_REGISTERED; 307e9deda23SKazutaka YOKOTA } 30829e59d7dSKazutaka YOKOTA return 0; 309e9deda23SKazutaka YOKOTA } 31057600c23SKazutaka YOKOTA 31157600c23SKazutaka YOKOTA /* XXX: a kludge to obtain the device configuration flags */ 31257600c23SKazutaka YOKOTA if (resource_int_value("atkbd", ATKBD_DEFAULT, "flags", &i) == 0) 31357600c23SKazutaka YOKOTA flags |= i; 314617b9080SKazutaka YOKOTA 315617b9080SKazutaka YOKOTA /* probe the default keyboard */ 316617b9080SKazutaka YOKOTA arg[0] = -1; 317617b9080SKazutaka YOKOTA arg[1] = -1; 318e9deda23SKazutaka YOKOTA kbd = NULL; 319e9deda23SKazutaka YOKOTA if (atkbd_probe(ATKBD_DEFAULT, arg, flags)) 320e9deda23SKazutaka YOKOTA return 0; 321e9deda23SKazutaka YOKOTA if (atkbd_init(ATKBD_DEFAULT, &kbd, arg, flags)) 322617b9080SKazutaka YOKOTA return 0; 323617b9080SKazutaka YOKOTA 324e9deda23SKazutaka YOKOTA /* return the number of found keyboards */ 325e9deda23SKazutaka YOKOTA return 1; 326617b9080SKazutaka YOKOTA } 327617b9080SKazutaka YOKOTA 328617b9080SKazutaka YOKOTA /* low-level functions */ 329617b9080SKazutaka YOKOTA 330e9deda23SKazutaka YOKOTA /* detect a keyboard */ 331617b9080SKazutaka YOKOTA static int 332e9deda23SKazutaka YOKOTA atkbd_probe(int unit, void *arg, int flags) 333e9deda23SKazutaka YOKOTA { 334e9deda23SKazutaka YOKOTA KBDC kbdc; 335db3e34cbSKazutaka YOKOTA int *data = (int *)arg; /* data[0]: controller, data[1]: irq */ 336e9deda23SKazutaka YOKOTA 337e9deda23SKazutaka YOKOTA /* XXX */ 338e9deda23SKazutaka YOKOTA if (unit == ATKBD_DEFAULT) { 339e9deda23SKazutaka YOKOTA if (KBD_IS_PROBED(&default_kbd)) 340e9deda23SKazutaka YOKOTA return 0; 341e9deda23SKazutaka YOKOTA } 342e9deda23SKazutaka YOKOTA 343db3e34cbSKazutaka YOKOTA kbdc = atkbdc_open(data[0]); 344e9deda23SKazutaka YOKOTA if (kbdc == NULL) 345e9deda23SKazutaka YOKOTA return ENXIO; 346e9deda23SKazutaka YOKOTA if (probe_keyboard(kbdc, flags)) { 347e9deda23SKazutaka YOKOTA if (flags & KB_CONF_FAIL_IF_NO_KBD) 348e9deda23SKazutaka YOKOTA return ENXIO; 349e9deda23SKazutaka YOKOTA } 350e9deda23SKazutaka YOKOTA return 0; 351e9deda23SKazutaka YOKOTA } 352e9deda23SKazutaka YOKOTA 353e9deda23SKazutaka YOKOTA /* reset and initialize the device */ 354e9deda23SKazutaka YOKOTA static int 355e9deda23SKazutaka YOKOTA atkbd_init(int unit, keyboard_t **kbdp, void *arg, int flags) 356617b9080SKazutaka YOKOTA { 357617b9080SKazutaka YOKOTA keyboard_t *kbd; 358617b9080SKazutaka YOKOTA atkbd_state_t *state; 359617b9080SKazutaka YOKOTA keymap_t *keymap; 360617b9080SKazutaka YOKOTA accentmap_t *accmap; 361617b9080SKazutaka YOKOTA fkeytab_t *fkeymap; 362617b9080SKazutaka YOKOTA int fkeymap_size; 36356f5e27cSKazutaka YOKOTA int delay[2]; 364db3e34cbSKazutaka YOKOTA int *data = (int *)arg; /* data[0]: controller, data[1]: irq */ 365ff690962SSam Leffler int error, needfree; 366617b9080SKazutaka YOKOTA 367617b9080SKazutaka YOKOTA /* XXX */ 368617b9080SKazutaka YOKOTA if (unit == ATKBD_DEFAULT) { 369617b9080SKazutaka YOKOTA *kbdp = kbd = &default_kbd; 370e9deda23SKazutaka YOKOTA if (KBD_IS_INITIALIZED(kbd) && KBD_IS_CONFIGURED(kbd)) 371617b9080SKazutaka YOKOTA return 0; 372617b9080SKazutaka YOKOTA state = &default_kbd_state; 373617b9080SKazutaka YOKOTA keymap = &default_keymap; 374617b9080SKazutaka YOKOTA accmap = &default_accentmap; 375617b9080SKazutaka YOKOTA fkeymap = default_fkeytab; 376617b9080SKazutaka YOKOTA fkeymap_size = 377617b9080SKazutaka YOKOTA sizeof(default_fkeytab)/sizeof(default_fkeytab[0]); 378ff690962SSam Leffler needfree = 0; 379617b9080SKazutaka YOKOTA } else if (*kbdp == NULL) { 3807cc0979fSDavid Malone *kbdp = kbd = malloc(sizeof(*kbd), M_DEVBUF, M_NOWAIT | M_ZERO); 3817cc0979fSDavid Malone state = malloc(sizeof(*state), M_DEVBUF, M_NOWAIT | M_ZERO); 382ff690962SSam Leffler /* NB: these will always be initialized 'cuz !KBD_IS_PROBED */ 383617b9080SKazutaka YOKOTA keymap = malloc(sizeof(key_map), M_DEVBUF, M_NOWAIT); 384617b9080SKazutaka YOKOTA accmap = malloc(sizeof(accent_map), M_DEVBUF, M_NOWAIT); 385617b9080SKazutaka YOKOTA fkeymap = malloc(sizeof(fkey_tab), M_DEVBUF, M_NOWAIT); 386617b9080SKazutaka YOKOTA fkeymap_size = sizeof(fkey_tab)/sizeof(fkey_tab[0]); 387ff690962SSam Leffler needfree = 1; 3887cc0979fSDavid Malone if ((kbd == NULL) || (state == NULL) || (keymap == NULL) 3897cc0979fSDavid Malone || (accmap == NULL) || (fkeymap == NULL)) { 390ff690962SSam Leffler error = ENOMEM; 391ff690962SSam Leffler goto bad; 392617b9080SKazutaka YOKOTA } 393e9deda23SKazutaka YOKOTA } else if (KBD_IS_INITIALIZED(*kbdp) && KBD_IS_CONFIGURED(*kbdp)) { 394617b9080SKazutaka YOKOTA return 0; 395617b9080SKazutaka YOKOTA } else { 396617b9080SKazutaka YOKOTA kbd = *kbdp; 397617b9080SKazutaka YOKOTA state = (atkbd_state_t *)kbd->kb_data; 398617b9080SKazutaka YOKOTA bzero(state, sizeof(*state)); 399617b9080SKazutaka YOKOTA keymap = kbd->kb_keymap; 400617b9080SKazutaka YOKOTA accmap = kbd->kb_accentmap; 401617b9080SKazutaka YOKOTA fkeymap = kbd->kb_fkeytab; 402617b9080SKazutaka YOKOTA fkeymap_size = kbd->kb_fkeytab_size; 403ff690962SSam Leffler needfree = 0; 404617b9080SKazutaka YOKOTA } 405617b9080SKazutaka YOKOTA 406e9deda23SKazutaka YOKOTA if (!KBD_IS_PROBED(kbd)) { 407db3e34cbSKazutaka YOKOTA state->kbdc = atkbdc_open(data[0]); 408ff690962SSam Leffler if (state->kbdc == NULL) { 409ff690962SSam Leffler error = ENXIO; 410ff690962SSam Leffler goto bad; 411ff690962SSam Leffler } 412e9deda23SKazutaka YOKOTA kbd_init_struct(kbd, ATKBD_DRIVER_NAME, KB_OTHER, unit, flags, 413db3e34cbSKazutaka YOKOTA 0, 0); 414617b9080SKazutaka YOKOTA bcopy(&key_map, keymap, sizeof(key_map)); 415617b9080SKazutaka YOKOTA bcopy(&accent_map, accmap, sizeof(accent_map)); 416617b9080SKazutaka YOKOTA bcopy(fkey_tab, fkeymap, 417617b9080SKazutaka YOKOTA imin(fkeymap_size * sizeof(fkeymap[0]), sizeof(fkey_tab))); 418617b9080SKazutaka YOKOTA kbd_set_maps(kbd, keymap, accmap, fkeymap, fkeymap_size); 419617b9080SKazutaka YOKOTA kbd->kb_data = (void *)state; 420617b9080SKazutaka YOKOTA 421e9deda23SKazutaka YOKOTA if (probe_keyboard(state->kbdc, flags)) { /* shouldn't happen */ 422ff690962SSam Leffler if (flags & KB_CONF_FAIL_IF_NO_KBD) { 423ff690962SSam Leffler error = ENXIO; 424ff690962SSam Leffler goto bad; 425ff690962SSam Leffler } 426617b9080SKazutaka YOKOTA } else { 427617b9080SKazutaka YOKOTA KBD_FOUND_DEVICE(kbd); 428617b9080SKazutaka YOKOTA } 429617b9080SKazutaka YOKOTA atkbd_clear_state(kbd); 430617b9080SKazutaka YOKOTA state->ks_mode = K_XLATE; 431617b9080SKazutaka YOKOTA /* 432617b9080SKazutaka YOKOTA * FIXME: set the initial value for lock keys in ks_state 433617b9080SKazutaka YOKOTA * according to the BIOS data? 434617b9080SKazutaka YOKOTA */ 435617b9080SKazutaka YOKOTA KBD_PROBE_DONE(kbd); 436617b9080SKazutaka YOKOTA } 437e9deda23SKazutaka YOKOTA if (!KBD_IS_INITIALIZED(kbd) && !(flags & KB_CONF_PROBE_ONLY)) { 4386c6028ffSKazutaka YOKOTA kbd->kb_config = flags & ~KB_CONF_PROBE_ONLY; 439617b9080SKazutaka YOKOTA if (KBD_HAS_DEVICE(kbd) 440e9deda23SKazutaka YOKOTA && init_keyboard(state->kbdc, &kbd->kb_type, kbd->kb_config) 4418ce4e518SHidetoshi Shimokawa && (kbd->kb_config & KB_CONF_FAIL_IF_NO_KBD)) { 4428ce4e518SHidetoshi Shimokawa kbd_unregister(kbd); 443ff690962SSam Leffler error = ENXIO; 444ff690962SSam Leffler goto bad; 4458ce4e518SHidetoshi Shimokawa } 446e9deda23SKazutaka YOKOTA atkbd_ioctl(kbd, KDSETLED, (caddr_t)&state->ks_state); 447b19f7eecSRoger Pau Monné set_typematic(kbd); 44856f5e27cSKazutaka YOKOTA delay[0] = kbd->kb_delay1; 44956f5e27cSKazutaka YOKOTA delay[1] = kbd->kb_delay2; 45056f5e27cSKazutaka YOKOTA atkbd_ioctl(kbd, KDSETREPEAT, (caddr_t)delay); 451617b9080SKazutaka YOKOTA KBD_INIT_DONE(kbd); 452617b9080SKazutaka YOKOTA } 453617b9080SKazutaka YOKOTA if (!KBD_IS_CONFIGURED(kbd)) { 454ff690962SSam Leffler if (kbd_register(kbd) < 0) { 455ff690962SSam Leffler error = ENXIO; 456ff690962SSam Leffler goto bad; 457ff690962SSam Leffler } 458617b9080SKazutaka YOKOTA KBD_CONFIG_DONE(kbd); 459617b9080SKazutaka YOKOTA } 460617b9080SKazutaka YOKOTA 461617b9080SKazutaka YOKOTA return 0; 462ff690962SSam Leffler bad: 463ff690962SSam Leffler if (needfree) { 464ff690962SSam Leffler if (state != NULL) 465ff690962SSam Leffler free(state, M_DEVBUF); 466ff690962SSam Leffler if (keymap != NULL) 467ff690962SSam Leffler free(keymap, M_DEVBUF); 468ff690962SSam Leffler if (accmap != NULL) 469ff690962SSam Leffler free(accmap, M_DEVBUF); 470ff690962SSam Leffler if (fkeymap != NULL) 471ff690962SSam Leffler free(fkeymap, M_DEVBUF); 472ff690962SSam Leffler if (kbd != NULL) { 473ff690962SSam Leffler free(kbd, M_DEVBUF); 474ff690962SSam Leffler *kbdp = NULL; /* insure ref doesn't leak to caller */ 475ff690962SSam Leffler } 476ff690962SSam Leffler } 477ff690962SSam Leffler return error; 478617b9080SKazutaka YOKOTA } 479617b9080SKazutaka YOKOTA 480617b9080SKazutaka YOKOTA /* finish using this keyboard */ 481617b9080SKazutaka YOKOTA static int 482617b9080SKazutaka YOKOTA atkbd_term(keyboard_t *kbd) 483617b9080SKazutaka YOKOTA { 484fadf3fb9SJohn Baldwin atkbd_state_t *state = (atkbd_state_t *)kbd->kb_data; 485fadf3fb9SJohn Baldwin 486617b9080SKazutaka YOKOTA kbd_unregister(kbd); 487fadf3fb9SJohn Baldwin callout_drain(&state->ks_timer); 488617b9080SKazutaka YOKOTA return 0; 489617b9080SKazutaka YOKOTA } 490617b9080SKazutaka YOKOTA 491617b9080SKazutaka YOKOTA /* keyboard interrupt routine */ 492617b9080SKazutaka YOKOTA static int 493e9deda23SKazutaka YOKOTA atkbd_intr(keyboard_t *kbd, void *arg) 494617b9080SKazutaka YOKOTA { 495018cd707SMaksim Yevmenkin atkbd_state_t *state = (atkbd_state_t *)kbd->kb_data; 49656f5e27cSKazutaka YOKOTA int delay[2]; 497617b9080SKazutaka YOKOTA int c; 498617b9080SKazutaka YOKOTA 499ac3912b0SRuslan Ermilov if (!KBD_HAS_DEVICE(kbd)) { 500ac3912b0SRuslan Ermilov /* 501ac3912b0SRuslan Ermilov * The keyboard was not detected before; 502ac3912b0SRuslan Ermilov * it must have been reconnected! 503ac3912b0SRuslan Ermilov */ 504f0143dacSWarner Losh init_keyboard(state->kbdc, &kbd->kb_type, kbd->kb_config); 505ac3912b0SRuslan Ermilov KBD_FOUND_DEVICE(kbd); 506ac3912b0SRuslan Ermilov atkbd_ioctl(kbd, KDSETLED, (caddr_t)&state->ks_state); 507b19f7eecSRoger Pau Monné set_typematic(kbd); 508ac3912b0SRuslan Ermilov delay[0] = kbd->kb_delay1; 509ac3912b0SRuslan Ermilov delay[1] = kbd->kb_delay2; 510ac3912b0SRuslan Ermilov atkbd_ioctl(kbd, KDSETREPEAT, (caddr_t)delay); 511ac3912b0SRuslan Ermilov } 512ac3912b0SRuslan Ermilov 513018cd707SMaksim Yevmenkin if (state->ks_polling) 514018cd707SMaksim Yevmenkin return 0; 515018cd707SMaksim Yevmenkin 516617b9080SKazutaka YOKOTA if (KBD_IS_ACTIVE(kbd) && KBD_IS_BUSY(kbd)) { 517617b9080SKazutaka YOKOTA /* let the callback function to process the input */ 518617b9080SKazutaka YOKOTA (*kbd->kb_callback.kc_func)(kbd, KBDIO_KEYINPUT, 519617b9080SKazutaka YOKOTA kbd->kb_callback.kc_arg); 520617b9080SKazutaka YOKOTA } else { 521617b9080SKazutaka YOKOTA /* read and discard the input; no one is waiting for input */ 522617b9080SKazutaka YOKOTA do { 523617b9080SKazutaka YOKOTA c = atkbd_read_char(kbd, FALSE); 524617b9080SKazutaka YOKOTA } while (c != NOKEY); 525617b9080SKazutaka YOKOTA } 526617b9080SKazutaka YOKOTA return 0; 527617b9080SKazutaka YOKOTA } 528617b9080SKazutaka YOKOTA 529617b9080SKazutaka YOKOTA /* test the interface to the device */ 530617b9080SKazutaka YOKOTA static int 531617b9080SKazutaka YOKOTA atkbd_test_if(keyboard_t *kbd) 532617b9080SKazutaka YOKOTA { 533617b9080SKazutaka YOKOTA int error; 534617b9080SKazutaka YOKOTA int s; 535617b9080SKazutaka YOKOTA 536617b9080SKazutaka YOKOTA error = 0; 537617b9080SKazutaka YOKOTA empty_both_buffers(((atkbd_state_t *)kbd->kb_data)->kbdc, 10); 538617b9080SKazutaka YOKOTA s = spltty(); 539617b9080SKazutaka YOKOTA if (!test_controller(((atkbd_state_t *)kbd->kb_data)->kbdc)) 540617b9080SKazutaka YOKOTA error = EIO; 541617b9080SKazutaka YOKOTA else if (test_kbd_port(((atkbd_state_t *)kbd->kb_data)->kbdc) != 0) 542617b9080SKazutaka YOKOTA error = EIO; 543617b9080SKazutaka YOKOTA splx(s); 544617b9080SKazutaka YOKOTA 545617b9080SKazutaka YOKOTA return error; 546617b9080SKazutaka YOKOTA } 547617b9080SKazutaka YOKOTA 548617b9080SKazutaka YOKOTA /* 549617b9080SKazutaka YOKOTA * Enable the access to the device; until this function is called, 550617b9080SKazutaka YOKOTA * the client cannot read from the keyboard. 551617b9080SKazutaka YOKOTA */ 552617b9080SKazutaka YOKOTA static int 553617b9080SKazutaka YOKOTA atkbd_enable(keyboard_t *kbd) 554617b9080SKazutaka YOKOTA { 555617b9080SKazutaka YOKOTA int s; 556617b9080SKazutaka YOKOTA 557617b9080SKazutaka YOKOTA s = spltty(); 558617b9080SKazutaka YOKOTA KBD_ACTIVATE(kbd); 559617b9080SKazutaka YOKOTA splx(s); 560617b9080SKazutaka YOKOTA return 0; 561617b9080SKazutaka YOKOTA } 562617b9080SKazutaka YOKOTA 563617b9080SKazutaka YOKOTA /* disallow the access to the device */ 564617b9080SKazutaka YOKOTA static int 565617b9080SKazutaka YOKOTA atkbd_disable(keyboard_t *kbd) 566617b9080SKazutaka YOKOTA { 567617b9080SKazutaka YOKOTA int s; 568617b9080SKazutaka YOKOTA 569617b9080SKazutaka YOKOTA s = spltty(); 570617b9080SKazutaka YOKOTA KBD_DEACTIVATE(kbd); 571617b9080SKazutaka YOKOTA splx(s); 572617b9080SKazutaka YOKOTA return 0; 573617b9080SKazutaka YOKOTA } 574617b9080SKazutaka YOKOTA 575617b9080SKazutaka YOKOTA /* read one byte from the keyboard if it's allowed */ 576617b9080SKazutaka YOKOTA static int 577617b9080SKazutaka YOKOTA atkbd_read(keyboard_t *kbd, int wait) 578617b9080SKazutaka YOKOTA { 579617b9080SKazutaka YOKOTA int c; 580617b9080SKazutaka YOKOTA 581617b9080SKazutaka YOKOTA if (wait) 582617b9080SKazutaka YOKOTA c = read_kbd_data(((atkbd_state_t *)kbd->kb_data)->kbdc); 583617b9080SKazutaka YOKOTA else 584617b9080SKazutaka YOKOTA c = read_kbd_data_no_wait(((atkbd_state_t *)kbd->kb_data)->kbdc); 58582d654e8SKazutaka YOKOTA if (c != -1) 58682d654e8SKazutaka YOKOTA ++kbd->kb_count; 587617b9080SKazutaka YOKOTA return (KBD_IS_ACTIVE(kbd) ? c : -1); 588617b9080SKazutaka YOKOTA } 589617b9080SKazutaka YOKOTA 590617b9080SKazutaka YOKOTA /* check if data is waiting */ 591617b9080SKazutaka YOKOTA static int 592617b9080SKazutaka YOKOTA atkbd_check(keyboard_t *kbd) 593617b9080SKazutaka YOKOTA { 594617b9080SKazutaka YOKOTA if (!KBD_IS_ACTIVE(kbd)) 595617b9080SKazutaka YOKOTA return FALSE; 596617b9080SKazutaka YOKOTA return kbdc_data_ready(((atkbd_state_t *)kbd->kb_data)->kbdc); 597617b9080SKazutaka YOKOTA } 598617b9080SKazutaka YOKOTA 599617b9080SKazutaka YOKOTA /* read char from the keyboard */ 600617b9080SKazutaka YOKOTA static u_int 601617b9080SKazutaka YOKOTA atkbd_read_char(keyboard_t *kbd, int wait) 602617b9080SKazutaka YOKOTA { 603617b9080SKazutaka YOKOTA atkbd_state_t *state; 604617b9080SKazutaka YOKOTA u_int action; 605617b9080SKazutaka YOKOTA int scancode; 606617b9080SKazutaka YOKOTA int keycode; 607617b9080SKazutaka YOKOTA 608617b9080SKazutaka YOKOTA state = (atkbd_state_t *)kbd->kb_data; 609617b9080SKazutaka YOKOTA next_code: 610617b9080SKazutaka YOKOTA /* do we have a composed char to return? */ 611617b9080SKazutaka YOKOTA if (!(state->ks_flags & COMPOSE) && (state->ks_composed_char > 0)) { 612617b9080SKazutaka YOKOTA action = state->ks_composed_char; 613617b9080SKazutaka YOKOTA state->ks_composed_char = 0; 614617b9080SKazutaka YOKOTA if (action > UCHAR_MAX) 615617b9080SKazutaka YOKOTA return ERRKEY; 616617b9080SKazutaka YOKOTA return action; 617617b9080SKazutaka YOKOTA } 618617b9080SKazutaka YOKOTA 619617b9080SKazutaka YOKOTA /* see if there is something in the keyboard port */ 620617b9080SKazutaka YOKOTA if (wait) { 621617b9080SKazutaka YOKOTA do { 622617b9080SKazutaka YOKOTA scancode = read_kbd_data(state->kbdc); 623617b9080SKazutaka YOKOTA } while (scancode == -1); 624617b9080SKazutaka YOKOTA } else { 625617b9080SKazutaka YOKOTA scancode = read_kbd_data_no_wait(state->kbdc); 626617b9080SKazutaka YOKOTA if (scancode == -1) 627617b9080SKazutaka YOKOTA return NOKEY; 628617b9080SKazutaka YOKOTA } 62982d654e8SKazutaka YOKOTA ++kbd->kb_count; 63082d654e8SKazutaka YOKOTA 63182d654e8SKazutaka YOKOTA #if KBDIO_DEBUG >= 10 63282d654e8SKazutaka YOKOTA printf("atkbd_read_char(): scancode:0x%x\n", scancode); 63382d654e8SKazutaka YOKOTA #endif 634617b9080SKazutaka YOKOTA 635617b9080SKazutaka YOKOTA /* return the byte as is for the K_RAW mode */ 636617b9080SKazutaka YOKOTA if (state->ks_mode == K_RAW) 637617b9080SKazutaka YOKOTA return scancode; 638617b9080SKazutaka YOKOTA 639617b9080SKazutaka YOKOTA /* translate the scan code into a keycode */ 640617b9080SKazutaka YOKOTA keycode = scancode & 0x7F; 641617b9080SKazutaka YOKOTA switch (state->ks_prefix) { 642617b9080SKazutaka YOKOTA case 0x00: /* normal scancode */ 643617b9080SKazutaka YOKOTA switch(scancode) { 644617b9080SKazutaka YOKOTA case 0xB8: /* left alt (compose key) released */ 645617b9080SKazutaka YOKOTA if (state->ks_flags & COMPOSE) { 646617b9080SKazutaka YOKOTA state->ks_flags &= ~COMPOSE; 647617b9080SKazutaka YOKOTA if (state->ks_composed_char > UCHAR_MAX) 648617b9080SKazutaka YOKOTA state->ks_composed_char = 0; 649617b9080SKazutaka YOKOTA } 650617b9080SKazutaka YOKOTA break; 651617b9080SKazutaka YOKOTA case 0x38: /* left alt (compose key) pressed */ 652617b9080SKazutaka YOKOTA if (!(state->ks_flags & COMPOSE)) { 653617b9080SKazutaka YOKOTA state->ks_flags |= COMPOSE; 654617b9080SKazutaka YOKOTA state->ks_composed_char = 0; 655617b9080SKazutaka YOKOTA } 656617b9080SKazutaka YOKOTA break; 657617b9080SKazutaka YOKOTA case 0xE0: 658617b9080SKazutaka YOKOTA case 0xE1: 659617b9080SKazutaka YOKOTA state->ks_prefix = scancode; 660617b9080SKazutaka YOKOTA goto next_code; 661617b9080SKazutaka YOKOTA } 662617b9080SKazutaka YOKOTA break; 663617b9080SKazutaka YOKOTA case 0xE0: /* 0xE0 prefix */ 664617b9080SKazutaka YOKOTA state->ks_prefix = 0; 665617b9080SKazutaka YOKOTA switch (keycode) { 666617b9080SKazutaka YOKOTA case 0x1C: /* right enter key */ 667617b9080SKazutaka YOKOTA keycode = 0x59; 668617b9080SKazutaka YOKOTA break; 669617b9080SKazutaka YOKOTA case 0x1D: /* right ctrl key */ 670617b9080SKazutaka YOKOTA keycode = 0x5A; 671617b9080SKazutaka YOKOTA break; 672617b9080SKazutaka YOKOTA case 0x35: /* keypad divide key */ 673617b9080SKazutaka YOKOTA keycode = 0x5B; 674617b9080SKazutaka YOKOTA break; 675617b9080SKazutaka YOKOTA case 0x37: /* print scrn key */ 676617b9080SKazutaka YOKOTA keycode = 0x5C; 677617b9080SKazutaka YOKOTA break; 678617b9080SKazutaka YOKOTA case 0x38: /* right alt key (alt gr) */ 679617b9080SKazutaka YOKOTA keycode = 0x5D; 680617b9080SKazutaka YOKOTA break; 681ffba82a9SKazutaka YOKOTA case 0x46: /* ctrl-pause/break on AT 101 (see below) */ 682ffba82a9SKazutaka YOKOTA keycode = 0x68; 683ffba82a9SKazutaka YOKOTA break; 684617b9080SKazutaka YOKOTA case 0x47: /* grey home key */ 685617b9080SKazutaka YOKOTA keycode = 0x5E; 686617b9080SKazutaka YOKOTA break; 687617b9080SKazutaka YOKOTA case 0x48: /* grey up arrow key */ 688617b9080SKazutaka YOKOTA keycode = 0x5F; 689617b9080SKazutaka YOKOTA break; 690617b9080SKazutaka YOKOTA case 0x49: /* grey page up key */ 691617b9080SKazutaka YOKOTA keycode = 0x60; 692617b9080SKazutaka YOKOTA break; 693617b9080SKazutaka YOKOTA case 0x4B: /* grey left arrow key */ 694617b9080SKazutaka YOKOTA keycode = 0x61; 695617b9080SKazutaka YOKOTA break; 696617b9080SKazutaka YOKOTA case 0x4D: /* grey right arrow key */ 697617b9080SKazutaka YOKOTA keycode = 0x62; 698617b9080SKazutaka YOKOTA break; 699617b9080SKazutaka YOKOTA case 0x4F: /* grey end key */ 700617b9080SKazutaka YOKOTA keycode = 0x63; 701617b9080SKazutaka YOKOTA break; 702617b9080SKazutaka YOKOTA case 0x50: /* grey down arrow key */ 703617b9080SKazutaka YOKOTA keycode = 0x64; 704617b9080SKazutaka YOKOTA break; 705617b9080SKazutaka YOKOTA case 0x51: /* grey page down key */ 706617b9080SKazutaka YOKOTA keycode = 0x65; 707617b9080SKazutaka YOKOTA break; 708617b9080SKazutaka YOKOTA case 0x52: /* grey insert key */ 709617b9080SKazutaka YOKOTA keycode = 0x66; 710617b9080SKazutaka YOKOTA break; 711617b9080SKazutaka YOKOTA case 0x53: /* grey delete key */ 712617b9080SKazutaka YOKOTA keycode = 0x67; 713617b9080SKazutaka YOKOTA break; 714617b9080SKazutaka YOKOTA /* the following 3 are only used on the MS "Natural" keyboard */ 715617b9080SKazutaka YOKOTA case 0x5b: /* left Window key */ 716617b9080SKazutaka YOKOTA keycode = 0x69; 717617b9080SKazutaka YOKOTA break; 718617b9080SKazutaka YOKOTA case 0x5c: /* right Window key */ 719617b9080SKazutaka YOKOTA keycode = 0x6a; 720617b9080SKazutaka YOKOTA break; 721617b9080SKazutaka YOKOTA case 0x5d: /* menu key */ 722617b9080SKazutaka YOKOTA keycode = 0x6b; 723617b9080SKazutaka YOKOTA break; 7247ea199a7SMax Khon case 0x5e: /* power key */ 7257ea199a7SMax Khon keycode = 0x6d; 7267ea199a7SMax Khon break; 7277ea199a7SMax Khon case 0x5f: /* sleep key */ 7287ea199a7SMax Khon keycode = 0x6e; 7297ea199a7SMax Khon break; 7307ea199a7SMax Khon case 0x63: /* wake key */ 7317ea199a7SMax Khon keycode = 0x6f; 7327ea199a7SMax Khon break; 733617b9080SKazutaka YOKOTA default: /* ignore everything else */ 734617b9080SKazutaka YOKOTA goto next_code; 735617b9080SKazutaka YOKOTA } 736617b9080SKazutaka YOKOTA break; 737617b9080SKazutaka YOKOTA case 0xE1: /* 0xE1 prefix */ 738ffba82a9SKazutaka YOKOTA /* 739ffba82a9SKazutaka YOKOTA * The pause/break key on the 101 keyboard produces: 740ffba82a9SKazutaka YOKOTA * E1-1D-45 E1-9D-C5 741ffba82a9SKazutaka YOKOTA * Ctrl-pause/break produces: 742ffba82a9SKazutaka YOKOTA * E0-46 E0-C6 (See above.) 743ffba82a9SKazutaka YOKOTA */ 744617b9080SKazutaka YOKOTA state->ks_prefix = 0; 745617b9080SKazutaka YOKOTA if (keycode == 0x1D) 746617b9080SKazutaka YOKOTA state->ks_prefix = 0x1D; 747617b9080SKazutaka YOKOTA goto next_code; 748617b9080SKazutaka YOKOTA /* NOT REACHED */ 749617b9080SKazutaka YOKOTA case 0x1D: /* pause / break */ 750617b9080SKazutaka YOKOTA state->ks_prefix = 0; 751617b9080SKazutaka YOKOTA if (keycode != 0x45) 752617b9080SKazutaka YOKOTA goto next_code; 753617b9080SKazutaka YOKOTA keycode = 0x68; 754617b9080SKazutaka YOKOTA break; 755617b9080SKazutaka YOKOTA } 756617b9080SKazutaka YOKOTA 757ffba82a9SKazutaka YOKOTA if (kbd->kb_type == KB_84) { 758ffba82a9SKazutaka YOKOTA switch (keycode) { 759ffba82a9SKazutaka YOKOTA case 0x37: /* *(numpad)/print screen */ 760ffba82a9SKazutaka YOKOTA if (state->ks_flags & SHIFTS) 761ffba82a9SKazutaka YOKOTA keycode = 0x5c; /* print screen */ 762ffba82a9SKazutaka YOKOTA break; 763ffba82a9SKazutaka YOKOTA case 0x45: /* num lock/pause */ 764ffba82a9SKazutaka YOKOTA if (state->ks_flags & CTLS) 765ffba82a9SKazutaka YOKOTA keycode = 0x68; /* pause */ 766ffba82a9SKazutaka YOKOTA break; 767ffba82a9SKazutaka YOKOTA case 0x46: /* scroll lock/break */ 768ffba82a9SKazutaka YOKOTA if (state->ks_flags & CTLS) 769ffba82a9SKazutaka YOKOTA keycode = 0x6c; /* break */ 770ffba82a9SKazutaka YOKOTA break; 771ffba82a9SKazutaka YOKOTA } 772ffba82a9SKazutaka YOKOTA } else if (kbd->kb_type == KB_101) { 773ffba82a9SKazutaka YOKOTA switch (keycode) { 774ffba82a9SKazutaka YOKOTA case 0x5c: /* print screen */ 775ffba82a9SKazutaka YOKOTA if (state->ks_flags & ALTS) 776ffba82a9SKazutaka YOKOTA keycode = 0x54; /* sysrq */ 777ffba82a9SKazutaka YOKOTA break; 778ffba82a9SKazutaka YOKOTA case 0x68: /* pause/break */ 779ffba82a9SKazutaka YOKOTA if (state->ks_flags & CTLS) 780ffba82a9SKazutaka YOKOTA keycode = 0x6c; /* break */ 781ffba82a9SKazutaka YOKOTA break; 782ffba82a9SKazutaka YOKOTA } 783ffba82a9SKazutaka YOKOTA } 784ffba82a9SKazutaka YOKOTA 785617b9080SKazutaka YOKOTA /* return the key code in the K_CODE mode */ 786617b9080SKazutaka YOKOTA if (state->ks_mode == K_CODE) 787617b9080SKazutaka YOKOTA return (keycode | (scancode & 0x80)); 788617b9080SKazutaka YOKOTA 789617b9080SKazutaka YOKOTA /* compose a character code */ 790617b9080SKazutaka YOKOTA if (state->ks_flags & COMPOSE) { 79183fc7c6cSKazutaka YOKOTA switch (keycode | (scancode & 0x80)) { 792617b9080SKazutaka YOKOTA /* key pressed, process it */ 793617b9080SKazutaka YOKOTA case 0x47: case 0x48: case 0x49: /* keypad 7,8,9 */ 794617b9080SKazutaka YOKOTA state->ks_composed_char *= 10; 795194da42dSKazutaka YOKOTA state->ks_composed_char += keycode - 0x40; 796617b9080SKazutaka YOKOTA if (state->ks_composed_char > UCHAR_MAX) 797617b9080SKazutaka YOKOTA return ERRKEY; 798617b9080SKazutaka YOKOTA goto next_code; 799617b9080SKazutaka YOKOTA case 0x4B: case 0x4C: case 0x4D: /* keypad 4,5,6 */ 800617b9080SKazutaka YOKOTA state->ks_composed_char *= 10; 801194da42dSKazutaka YOKOTA state->ks_composed_char += keycode - 0x47; 802617b9080SKazutaka YOKOTA if (state->ks_composed_char > UCHAR_MAX) 803617b9080SKazutaka YOKOTA return ERRKEY; 804617b9080SKazutaka YOKOTA goto next_code; 805617b9080SKazutaka YOKOTA case 0x4F: case 0x50: case 0x51: /* keypad 1,2,3 */ 806617b9080SKazutaka YOKOTA state->ks_composed_char *= 10; 807194da42dSKazutaka YOKOTA state->ks_composed_char += keycode - 0x4E; 808617b9080SKazutaka YOKOTA if (state->ks_composed_char > UCHAR_MAX) 809617b9080SKazutaka YOKOTA return ERRKEY; 810617b9080SKazutaka YOKOTA goto next_code; 811617b9080SKazutaka YOKOTA case 0x52: /* keypad 0 */ 812617b9080SKazutaka YOKOTA state->ks_composed_char *= 10; 813617b9080SKazutaka YOKOTA if (state->ks_composed_char > UCHAR_MAX) 814617b9080SKazutaka YOKOTA return ERRKEY; 815617b9080SKazutaka YOKOTA goto next_code; 816617b9080SKazutaka YOKOTA 817617b9080SKazutaka YOKOTA /* key released, no interest here */ 818617b9080SKazutaka YOKOTA case 0xC7: case 0xC8: case 0xC9: /* keypad 7,8,9 */ 819617b9080SKazutaka YOKOTA case 0xCB: case 0xCC: case 0xCD: /* keypad 4,5,6 */ 820617b9080SKazutaka YOKOTA case 0xCF: case 0xD0: case 0xD1: /* keypad 1,2,3 */ 821617b9080SKazutaka YOKOTA case 0xD2: /* keypad 0 */ 822617b9080SKazutaka YOKOTA goto next_code; 823617b9080SKazutaka YOKOTA 824617b9080SKazutaka YOKOTA case 0x38: /* left alt key */ 825617b9080SKazutaka YOKOTA break; 826617b9080SKazutaka YOKOTA 827617b9080SKazutaka YOKOTA default: 828617b9080SKazutaka YOKOTA if (state->ks_composed_char > 0) { 829617b9080SKazutaka YOKOTA state->ks_flags &= ~COMPOSE; 830617b9080SKazutaka YOKOTA state->ks_composed_char = 0; 831617b9080SKazutaka YOKOTA return ERRKEY; 832617b9080SKazutaka YOKOTA } 833617b9080SKazutaka YOKOTA break; 834617b9080SKazutaka YOKOTA } 835617b9080SKazutaka YOKOTA } 836617b9080SKazutaka YOKOTA 837617b9080SKazutaka YOKOTA /* keycode to key action */ 838617b9080SKazutaka YOKOTA action = genkbd_keyaction(kbd, keycode, scancode & 0x80, 839617b9080SKazutaka YOKOTA &state->ks_state, &state->ks_accents); 840617b9080SKazutaka YOKOTA if (action == NOKEY) 841617b9080SKazutaka YOKOTA goto next_code; 842617b9080SKazutaka YOKOTA else 843617b9080SKazutaka YOKOTA return action; 844617b9080SKazutaka YOKOTA } 845617b9080SKazutaka YOKOTA 846617b9080SKazutaka YOKOTA /* check if char is waiting */ 847617b9080SKazutaka YOKOTA static int 848617b9080SKazutaka YOKOTA atkbd_check_char(keyboard_t *kbd) 849617b9080SKazutaka YOKOTA { 850617b9080SKazutaka YOKOTA atkbd_state_t *state; 851617b9080SKazutaka YOKOTA 852617b9080SKazutaka YOKOTA if (!KBD_IS_ACTIVE(kbd)) 853617b9080SKazutaka YOKOTA return FALSE; 854617b9080SKazutaka YOKOTA state = (atkbd_state_t *)kbd->kb_data; 855617b9080SKazutaka YOKOTA if (!(state->ks_flags & COMPOSE) && (state->ks_composed_char > 0)) 856617b9080SKazutaka YOKOTA return TRUE; 857617b9080SKazutaka YOKOTA return kbdc_data_ready(state->kbdc); 858617b9080SKazutaka YOKOTA } 859617b9080SKazutaka YOKOTA 860617b9080SKazutaka YOKOTA /* some useful control functions */ 861617b9080SKazutaka YOKOTA static int 862617b9080SKazutaka YOKOTA atkbd_ioctl(keyboard_t *kbd, u_long cmd, caddr_t arg) 863617b9080SKazutaka YOKOTA { 864520b6353SMarius Strobl /* translate LED_XXX bits into the device specific bits */ 865617b9080SKazutaka YOKOTA static u_char ledmap[8] = { 866617b9080SKazutaka YOKOTA 0, 4, 2, 6, 1, 5, 3, 7, 867617b9080SKazutaka YOKOTA }; 868617b9080SKazutaka YOKOTA atkbd_state_t *state = kbd->kb_data; 869617b9080SKazutaka YOKOTA int error; 870617b9080SKazutaka YOKOTA int s; 871617b9080SKazutaka YOKOTA int i; 8729fddcc66SRuslan Ermilov #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 8739fddcc66SRuslan Ermilov defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 8749fddcc66SRuslan Ermilov int ival; 8759fddcc66SRuslan Ermilov #endif 876617b9080SKazutaka YOKOTA 877617b9080SKazutaka YOKOTA s = spltty(); 878617b9080SKazutaka YOKOTA switch (cmd) { 879617b9080SKazutaka YOKOTA 880617b9080SKazutaka YOKOTA case KDGKBMODE: /* get keyboard mode */ 881617b9080SKazutaka YOKOTA *(int *)arg = state->ks_mode; 882617b9080SKazutaka YOKOTA break; 8839fddcc66SRuslan Ermilov #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 8849fddcc66SRuslan Ermilov defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 8859fddcc66SRuslan Ermilov case _IO('K', 7): 8869fddcc66SRuslan Ermilov ival = IOCPARM_IVAL(arg); 8879fddcc66SRuslan Ermilov arg = (caddr_t)&ival; 8889fddcc66SRuslan Ermilov /* FALLTHROUGH */ 8899fddcc66SRuslan Ermilov #endif 890617b9080SKazutaka YOKOTA case KDSKBMODE: /* set keyboard mode */ 891617b9080SKazutaka YOKOTA switch (*(int *)arg) { 892617b9080SKazutaka YOKOTA case K_XLATE: 893617b9080SKazutaka YOKOTA if (state->ks_mode != K_XLATE) { 894617b9080SKazutaka YOKOTA /* make lock key state and LED state match */ 895617b9080SKazutaka YOKOTA state->ks_state &= ~LOCK_MASK; 896617b9080SKazutaka YOKOTA state->ks_state |= KBD_LED_VAL(kbd); 897617b9080SKazutaka YOKOTA } 898617b9080SKazutaka YOKOTA /* FALLTHROUGH */ 899617b9080SKazutaka YOKOTA case K_RAW: 900617b9080SKazutaka YOKOTA case K_CODE: 901617b9080SKazutaka YOKOTA if (state->ks_mode != *(int *)arg) { 902617b9080SKazutaka YOKOTA atkbd_clear_state(kbd); 903617b9080SKazutaka YOKOTA state->ks_mode = *(int *)arg; 904617b9080SKazutaka YOKOTA } 905617b9080SKazutaka YOKOTA break; 906617b9080SKazutaka YOKOTA default: 907617b9080SKazutaka YOKOTA splx(s); 908617b9080SKazutaka YOKOTA return EINVAL; 909617b9080SKazutaka YOKOTA } 910617b9080SKazutaka YOKOTA break; 911617b9080SKazutaka YOKOTA 912617b9080SKazutaka YOKOTA case KDGETLED: /* get keyboard LED */ 913617b9080SKazutaka YOKOTA *(int *)arg = KBD_LED_VAL(kbd); 914617b9080SKazutaka YOKOTA break; 9159fddcc66SRuslan Ermilov #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 9169fddcc66SRuslan Ermilov defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 9179fddcc66SRuslan Ermilov case _IO('K', 66): 9189fddcc66SRuslan Ermilov ival = IOCPARM_IVAL(arg); 9199fddcc66SRuslan Ermilov arg = (caddr_t)&ival; 9209fddcc66SRuslan Ermilov /* FALLTHROUGH */ 9219fddcc66SRuslan Ermilov #endif 922617b9080SKazutaka YOKOTA case KDSETLED: /* set keyboard LED */ 923617b9080SKazutaka YOKOTA /* NOTE: lock key state in ks_state won't be changed */ 924617b9080SKazutaka YOKOTA if (*(int *)arg & ~LOCK_MASK) { 925617b9080SKazutaka YOKOTA splx(s); 926617b9080SKazutaka YOKOTA return EINVAL; 927617b9080SKazutaka YOKOTA } 928617b9080SKazutaka YOKOTA i = *(int *)arg; 929617b9080SKazutaka YOKOTA /* replace CAPS LED with ALTGR LED for ALTGR keyboards */ 9302073104fSAndrey A. Chernov if (state->ks_mode == K_XLATE && 9312073104fSAndrey A. Chernov kbd->kb_keymap->n_keys > ALTGR_OFFSET) { 932617b9080SKazutaka YOKOTA if (i & ALKED) 933617b9080SKazutaka YOKOTA i |= CLKED; 934617b9080SKazutaka YOKOTA else 935617b9080SKazutaka YOKOTA i &= ~CLKED; 936617b9080SKazutaka YOKOTA } 937617b9080SKazutaka YOKOTA if (KBD_HAS_DEVICE(kbd)) { 938617b9080SKazutaka YOKOTA error = write_kbd(state->kbdc, KBDC_SET_LEDS, 939617b9080SKazutaka YOKOTA ledmap[i & LED_MASK]); 940617b9080SKazutaka YOKOTA if (error) { 941617b9080SKazutaka YOKOTA splx(s); 942617b9080SKazutaka YOKOTA return error; 943617b9080SKazutaka YOKOTA } 944617b9080SKazutaka YOKOTA } 945617b9080SKazutaka YOKOTA KBD_LED_VAL(kbd) = *(int *)arg; 946617b9080SKazutaka YOKOTA break; 947617b9080SKazutaka YOKOTA 948617b9080SKazutaka YOKOTA case KDGKBSTATE: /* get lock key state */ 949617b9080SKazutaka YOKOTA *(int *)arg = state->ks_state & LOCK_MASK; 950617b9080SKazutaka YOKOTA break; 9519fddcc66SRuslan Ermilov #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 9529fddcc66SRuslan Ermilov defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 9539fddcc66SRuslan Ermilov case _IO('K', 20): 9549fddcc66SRuslan Ermilov ival = IOCPARM_IVAL(arg); 9559fddcc66SRuslan Ermilov arg = (caddr_t)&ival; 9569fddcc66SRuslan Ermilov /* FALLTHROUGH */ 9579fddcc66SRuslan Ermilov #endif 958617b9080SKazutaka YOKOTA case KDSKBSTATE: /* set lock key state */ 959617b9080SKazutaka YOKOTA if (*(int *)arg & ~LOCK_MASK) { 960617b9080SKazutaka YOKOTA splx(s); 961617b9080SKazutaka YOKOTA return EINVAL; 962617b9080SKazutaka YOKOTA } 963617b9080SKazutaka YOKOTA state->ks_state &= ~LOCK_MASK; 964617b9080SKazutaka YOKOTA state->ks_state |= *(int *)arg; 965617b9080SKazutaka YOKOTA splx(s); 966617b9080SKazutaka YOKOTA /* set LEDs and quit */ 967617b9080SKazutaka YOKOTA return atkbd_ioctl(kbd, KDSETLED, arg); 968617b9080SKazutaka YOKOTA 969e9deda23SKazutaka YOKOTA case KDSETREPEAT: /* set keyboard repeat rate (new interface) */ 970617b9080SKazutaka YOKOTA splx(s); 971617b9080SKazutaka YOKOTA if (!KBD_HAS_DEVICE(kbd)) 972617b9080SKazutaka YOKOTA return 0; 973e9deda23SKazutaka YOKOTA i = typematic(((int *)arg)[0], ((int *)arg)[1]); 97457995893SKazutaka YOKOTA error = write_kbd(state->kbdc, KBDC_SET_TYPEMATIC, i); 97557995893SKazutaka YOKOTA if (error == 0) { 97657995893SKazutaka YOKOTA kbd->kb_delay1 = typematic_delay(i); 97757995893SKazutaka YOKOTA kbd->kb_delay2 = typematic_rate(i); 97857995893SKazutaka YOKOTA } 97957995893SKazutaka YOKOTA return error; 980e9deda23SKazutaka YOKOTA 9819fddcc66SRuslan Ermilov #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 9829fddcc66SRuslan Ermilov defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 9839fddcc66SRuslan Ermilov case _IO('K', 67): 9849fddcc66SRuslan Ermilov ival = IOCPARM_IVAL(arg); 9859fddcc66SRuslan Ermilov arg = (caddr_t)&ival; 9869fddcc66SRuslan Ermilov /* FALLTHROUGH */ 9879fddcc66SRuslan Ermilov #endif 988e9deda23SKazutaka YOKOTA case KDSETRAD: /* set keyboard repeat rate (old interface) */ 989e9deda23SKazutaka YOKOTA splx(s); 990e9deda23SKazutaka YOKOTA if (!KBD_HAS_DEVICE(kbd)) 991e9deda23SKazutaka YOKOTA return 0; 99257995893SKazutaka YOKOTA error = write_kbd(state->kbdc, KBDC_SET_TYPEMATIC, *(int *)arg); 99357995893SKazutaka YOKOTA if (error == 0) { 99457995893SKazutaka YOKOTA kbd->kb_delay1 = typematic_delay(*(int *)arg); 99557995893SKazutaka YOKOTA kbd->kb_delay2 = typematic_rate(*(int *)arg); 99657995893SKazutaka YOKOTA } 99757995893SKazutaka YOKOTA return error; 998617b9080SKazutaka YOKOTA 999617b9080SKazutaka YOKOTA case PIO_KEYMAP: /* set keyboard translation table */ 100078d4d8eeSEd Schouten case OPIO_KEYMAP: /* set keyboard translation table (compat) */ 1001617b9080SKazutaka YOKOTA case PIO_KEYMAPENT: /* set keyboard translation table entry */ 1002617b9080SKazutaka YOKOTA case PIO_DEADKEYMAP: /* set accent key translation table */ 1003617b9080SKazutaka YOKOTA state->ks_accents = 0; 1004617b9080SKazutaka YOKOTA /* FALLTHROUGH */ 1005617b9080SKazutaka YOKOTA default: 1006617b9080SKazutaka YOKOTA splx(s); 1007617b9080SKazutaka YOKOTA return genkbd_commonioctl(kbd, cmd, arg); 1008617b9080SKazutaka YOKOTA } 1009617b9080SKazutaka YOKOTA 1010617b9080SKazutaka YOKOTA splx(s); 1011617b9080SKazutaka YOKOTA return 0; 1012617b9080SKazutaka YOKOTA } 1013617b9080SKazutaka YOKOTA 1014617b9080SKazutaka YOKOTA /* lock the access to the keyboard */ 1015617b9080SKazutaka YOKOTA static int 1016617b9080SKazutaka YOKOTA atkbd_lock(keyboard_t *kbd, int lock) 1017617b9080SKazutaka YOKOTA { 1018617b9080SKazutaka YOKOTA return kbdc_lock(((atkbd_state_t *)kbd->kb_data)->kbdc, lock); 1019617b9080SKazutaka YOKOTA } 1020617b9080SKazutaka YOKOTA 1021617b9080SKazutaka YOKOTA /* clear the internal state of the keyboard */ 1022617b9080SKazutaka YOKOTA static void 1023617b9080SKazutaka YOKOTA atkbd_clear_state(keyboard_t *kbd) 1024617b9080SKazutaka YOKOTA { 1025617b9080SKazutaka YOKOTA atkbd_state_t *state; 1026617b9080SKazutaka YOKOTA 1027617b9080SKazutaka YOKOTA state = (atkbd_state_t *)kbd->kb_data; 1028617b9080SKazutaka YOKOTA state->ks_flags = 0; 1029e9deda23SKazutaka YOKOTA state->ks_polling = 0; 1030617b9080SKazutaka YOKOTA state->ks_state &= LOCK_MASK; /* preserve locking key state */ 1031617b9080SKazutaka YOKOTA state->ks_accents = 0; 1032617b9080SKazutaka YOKOTA state->ks_composed_char = 0; 1033617b9080SKazutaka YOKOTA #if 0 1034617b9080SKazutaka YOKOTA state->ks_prefix = 0; /* XXX */ 1035617b9080SKazutaka YOKOTA #endif 1036617b9080SKazutaka YOKOTA } 1037617b9080SKazutaka YOKOTA 1038617b9080SKazutaka YOKOTA /* save the internal state */ 1039617b9080SKazutaka YOKOTA static int 1040617b9080SKazutaka YOKOTA atkbd_get_state(keyboard_t *kbd, void *buf, size_t len) 1041617b9080SKazutaka YOKOTA { 1042617b9080SKazutaka YOKOTA if (len == 0) 1043617b9080SKazutaka YOKOTA return sizeof(atkbd_state_t); 1044617b9080SKazutaka YOKOTA if (len < sizeof(atkbd_state_t)) 1045617b9080SKazutaka YOKOTA return -1; 1046617b9080SKazutaka YOKOTA bcopy(kbd->kb_data, buf, sizeof(atkbd_state_t)); 1047617b9080SKazutaka YOKOTA return 0; 1048617b9080SKazutaka YOKOTA } 1049617b9080SKazutaka YOKOTA 1050617b9080SKazutaka YOKOTA /* set the internal state */ 1051617b9080SKazutaka YOKOTA static int 1052617b9080SKazutaka YOKOTA atkbd_set_state(keyboard_t *kbd, void *buf, size_t len) 1053617b9080SKazutaka YOKOTA { 1054617b9080SKazutaka YOKOTA if (len < sizeof(atkbd_state_t)) 1055617b9080SKazutaka YOKOTA return ENOMEM; 1056617b9080SKazutaka YOKOTA if (((atkbd_state_t *)kbd->kb_data)->kbdc 1057617b9080SKazutaka YOKOTA != ((atkbd_state_t *)buf)->kbdc) 1058617b9080SKazutaka YOKOTA return ENOMEM; 1059617b9080SKazutaka YOKOTA bcopy(buf, kbd->kb_data, sizeof(atkbd_state_t)); 1060617b9080SKazutaka YOKOTA return 0; 1061617b9080SKazutaka YOKOTA } 1062617b9080SKazutaka YOKOTA 1063e9deda23SKazutaka YOKOTA static int 1064e9deda23SKazutaka YOKOTA atkbd_poll(keyboard_t *kbd, int on) 1065e9deda23SKazutaka YOKOTA { 1066e9deda23SKazutaka YOKOTA atkbd_state_t *state; 1067e9deda23SKazutaka YOKOTA int s; 1068e9deda23SKazutaka YOKOTA 1069e9deda23SKazutaka YOKOTA state = (atkbd_state_t *)kbd->kb_data; 1070e9deda23SKazutaka YOKOTA s = spltty(); 1071e9deda23SKazutaka YOKOTA if (on) 1072e9deda23SKazutaka YOKOTA ++state->ks_polling; 1073e9deda23SKazutaka YOKOTA else 1074e9deda23SKazutaka YOKOTA --state->ks_polling; 1075e9deda23SKazutaka YOKOTA splx(s); 1076e9deda23SKazutaka YOKOTA return 0; 1077e9deda23SKazutaka YOKOTA } 1078e9deda23SKazutaka YOKOTA 1079520b6353SMarius Strobl static void 1080520b6353SMarius Strobl atkbd_shutdown_final(void *v) 1081520b6353SMarius Strobl { 1082520b6353SMarius Strobl #ifdef __sparc64__ 1083520b6353SMarius Strobl keyboard_t *kbd = v; 1084520b6353SMarius Strobl KBDC kbdc = ((atkbd_state_t *)kbd->kb_data)->kbdc; 1085520b6353SMarius Strobl 1086520b6353SMarius Strobl /* 1087520b6353SMarius Strobl * Turn off the translation in preparation for handing the keyboard 1088520b6353SMarius Strobl * over to the OFW as the OBP driver doesn't use translation and 1089520b6353SMarius Strobl * also doesn't disable it itself resulting in a broken keymap at 1090520b6353SMarius Strobl * the boot prompt. Also disable the aux port and the interrupts as 1091520b6353SMarius Strobl * the OBP driver doesn't use them, i.e. polls the keyboard. Not 1092520b6353SMarius Strobl * disabling the interrupts doesn't cause real problems but the 1093520b6353SMarius Strobl * responsiveness is a bit better when they are turned off. 1094520b6353SMarius Strobl */ 1095520b6353SMarius Strobl send_kbd_command(kbdc, KBDC_DISABLE_KBD); 1096520b6353SMarius Strobl set_controller_command_byte(kbdc, 1097520b6353SMarius Strobl KBD_AUX_CONTROL_BITS | KBD_KBD_CONTROL_BITS | KBD_TRANSLATION, 1098520b6353SMarius Strobl KBD_DISABLE_AUX_PORT | KBD_DISABLE_KBD_INT | KBD_ENABLE_KBD_PORT); 1099520b6353SMarius Strobl send_kbd_command(kbdc, KBDC_ENABLE_KBD); 1100520b6353SMarius Strobl #endif 1101520b6353SMarius Strobl } 1102520b6353SMarius Strobl 11036c176113SMichael Gmelin static int 11046c176113SMichael Gmelin atkbd_reset(KBDC kbdc, int flags, int c) 11056c176113SMichael Gmelin { 11066c176113SMichael Gmelin /* reset keyboard hardware */ 11076c176113SMichael Gmelin if (!(flags & KB_CONF_NO_RESET) && !reset_kbd(kbdc)) { 11086c176113SMichael Gmelin /* 11096c176113SMichael Gmelin * KEYBOARD ERROR 11106c176113SMichael Gmelin * Keyboard reset may fail either because the keyboard 11116c176113SMichael Gmelin * doen't exist, or because the keyboard doesn't pass 11126c176113SMichael Gmelin * the self-test, or the keyboard controller on the 11136c176113SMichael Gmelin * motherboard and the keyboard somehow fail to shake hands. 11146c176113SMichael Gmelin * It is just possible, particularly in the last case, 11156c176113SMichael Gmelin * that the keyboard controller may be left in a hung state. 11166c176113SMichael Gmelin * test_controller() and test_kbd_port() appear to bring 11176c176113SMichael Gmelin * the keyboard controller back (I don't know why and how, 11186c176113SMichael Gmelin * though.) 11196c176113SMichael Gmelin */ 11206c176113SMichael Gmelin empty_both_buffers(kbdc, 10); 11216c176113SMichael Gmelin test_controller(kbdc); 11226c176113SMichael Gmelin test_kbd_port(kbdc); 11236c176113SMichael Gmelin /* 11246c176113SMichael Gmelin * We could disable the keyboard port and interrupt... but, 11256c176113SMichael Gmelin * the keyboard may still exist (see above). 11266c176113SMichael Gmelin */ 11276c176113SMichael Gmelin set_controller_command_byte(kbdc, 11286c176113SMichael Gmelin ALLOW_DISABLE_KBD(kbdc) ? 0xff : KBD_KBD_CONTROL_BITS, c); 11296c176113SMichael Gmelin if (bootverbose) 11306c176113SMichael Gmelin printf("atkbd: failed to reset the keyboard.\n"); 11316c176113SMichael Gmelin return (EIO); 11326c176113SMichael Gmelin } 11336c176113SMichael Gmelin return (0); 11346c176113SMichael Gmelin } 11356c176113SMichael Gmelin 1136617b9080SKazutaka YOKOTA /* local functions */ 1137617b9080SKazutaka YOKOTA 1138617b9080SKazutaka YOKOTA static int 1139b19f7eecSRoger Pau Monné set_typematic(keyboard_t *kbd) 114056f5e27cSKazutaka YOKOTA { 1141b19f7eecSRoger Pau Monné int val, error; 1142b19f7eecSRoger Pau Monné atkbd_state_t *state = kbd->kb_data; 114356f5e27cSKazutaka YOKOTA 1144b19f7eecSRoger Pau Monné val = typematic(DEFAULT_DELAY, DEFAULT_RATE); 1145b19f7eecSRoger Pau Monné error = write_kbd(state->kbdc, KBDC_SET_TYPEMATIC, val); 1146b19f7eecSRoger Pau Monné if (error == 0) { 1147b19f7eecSRoger Pau Monné kbd->kb_delay1 = typematic_delay(val); 1148b19f7eecSRoger Pau Monné kbd->kb_delay2 = typematic_rate(val); 1149b19f7eecSRoger Pau Monné } 11503219f535SJung-uk Kim 1151b19f7eecSRoger Pau Monné return (error); 115256f5e27cSKazutaka YOKOTA } 115356f5e27cSKazutaka YOKOTA 115456f5e27cSKazutaka YOKOTA static int 1155617b9080SKazutaka YOKOTA setup_kbd_port(KBDC kbdc, int port, int intr) 1156617b9080SKazutaka YOKOTA { 1157617b9080SKazutaka YOKOTA if (!set_controller_command_byte(kbdc, 1158617b9080SKazutaka YOKOTA KBD_KBD_CONTROL_BITS, 1159617b9080SKazutaka YOKOTA ((port) ? KBD_ENABLE_KBD_PORT : KBD_DISABLE_KBD_PORT) 1160617b9080SKazutaka YOKOTA | ((intr) ? KBD_ENABLE_KBD_INT : KBD_DISABLE_KBD_INT))) 1161617b9080SKazutaka YOKOTA return 1; 1162617b9080SKazutaka YOKOTA return 0; 1163617b9080SKazutaka YOKOTA } 1164617b9080SKazutaka YOKOTA 1165617b9080SKazutaka YOKOTA static int 1166617b9080SKazutaka YOKOTA get_kbd_echo(KBDC kbdc) 1167617b9080SKazutaka YOKOTA { 1168617b9080SKazutaka YOKOTA /* enable the keyboard port, but disable the keyboard intr. */ 1169617b9080SKazutaka YOKOTA if (setup_kbd_port(kbdc, TRUE, FALSE)) 1170617b9080SKazutaka YOKOTA /* CONTROLLER ERROR: there is very little we can do... */ 1171617b9080SKazutaka YOKOTA return ENXIO; 1172617b9080SKazutaka YOKOTA 1173617b9080SKazutaka YOKOTA /* see if something is present */ 1174617b9080SKazutaka YOKOTA write_kbd_command(kbdc, KBDC_ECHO); 1175617b9080SKazutaka YOKOTA if (read_kbd_data(kbdc) != KBD_ECHO) { 1176617b9080SKazutaka YOKOTA empty_both_buffers(kbdc, 10); 1177617b9080SKazutaka YOKOTA test_controller(kbdc); 1178617b9080SKazutaka YOKOTA test_kbd_port(kbdc); 1179617b9080SKazutaka YOKOTA return ENXIO; 1180617b9080SKazutaka YOKOTA } 1181617b9080SKazutaka YOKOTA 1182617b9080SKazutaka YOKOTA /* enable the keyboard port and intr. */ 1183617b9080SKazutaka YOKOTA if (setup_kbd_port(kbdc, TRUE, TRUE)) { 1184617b9080SKazutaka YOKOTA /* 1185617b9080SKazutaka YOKOTA * CONTROLLER ERROR 1186617b9080SKazutaka YOKOTA * This is serious; the keyboard intr is left disabled! 1187617b9080SKazutaka YOKOTA */ 1188617b9080SKazutaka YOKOTA return ENXIO; 1189617b9080SKazutaka YOKOTA } 1190617b9080SKazutaka YOKOTA 1191617b9080SKazutaka YOKOTA return 0; 1192617b9080SKazutaka YOKOTA } 1193617b9080SKazutaka YOKOTA 1194617b9080SKazutaka YOKOTA static int 1195617b9080SKazutaka YOKOTA probe_keyboard(KBDC kbdc, int flags) 1196617b9080SKazutaka YOKOTA { 1197617b9080SKazutaka YOKOTA /* 1198617b9080SKazutaka YOKOTA * Don't try to print anything in this function. The low-level 1199617b9080SKazutaka YOKOTA * console may not have been initialized yet... 1200617b9080SKazutaka YOKOTA */ 1201617b9080SKazutaka YOKOTA int err; 1202617b9080SKazutaka YOKOTA int c; 1203617b9080SKazutaka YOKOTA int m; 1204617b9080SKazutaka YOKOTA 1205617b9080SKazutaka YOKOTA if (!kbdc_lock(kbdc, TRUE)) { 1206617b9080SKazutaka YOKOTA /* driver error? */ 1207617b9080SKazutaka YOKOTA return ENXIO; 1208617b9080SKazutaka YOKOTA } 1209617b9080SKazutaka YOKOTA 1210aec1fa1cSKazutaka YOKOTA /* temporarily block data transmission from the keyboard */ 1211aec1fa1cSKazutaka YOKOTA write_controller_command(kbdc, KBDC_DISABLE_KBD_PORT); 1212aec1fa1cSKazutaka YOKOTA 1213617b9080SKazutaka YOKOTA /* flush any noise in the buffer */ 1214aec1fa1cSKazutaka YOKOTA empty_both_buffers(kbdc, 100); 1215617b9080SKazutaka YOKOTA 1216617b9080SKazutaka YOKOTA /* save the current keyboard controller command byte */ 1217617b9080SKazutaka YOKOTA m = kbdc_get_device_mask(kbdc) & ~KBD_KBD_CONTROL_BITS; 1218617b9080SKazutaka YOKOTA c = get_controller_command_byte(kbdc); 1219617b9080SKazutaka YOKOTA if (c == -1) { 1220617b9080SKazutaka YOKOTA /* CONTROLLER ERROR */ 1221617b9080SKazutaka YOKOTA kbdc_set_device_mask(kbdc, m); 1222617b9080SKazutaka YOKOTA kbdc_lock(kbdc, FALSE); 1223617b9080SKazutaka YOKOTA return ENXIO; 1224617b9080SKazutaka YOKOTA } 1225617b9080SKazutaka YOKOTA 1226617b9080SKazutaka YOKOTA /* 1227617b9080SKazutaka YOKOTA * The keyboard may have been screwed up by the boot block. 1228617b9080SKazutaka YOKOTA * We may just be able to recover from error by testing the controller 1229617b9080SKazutaka YOKOTA * and the keyboard port. The controller command byte needs to be 1230617b9080SKazutaka YOKOTA * saved before this recovery operation, as some controllers seem 1231617b9080SKazutaka YOKOTA * to set the command byte to particular values. 1232617b9080SKazutaka YOKOTA */ 1233617b9080SKazutaka YOKOTA test_controller(kbdc); 1234f5517dc8SJohn Baldwin if (!(flags & KB_CONF_NO_PROBE_TEST)) 1235617b9080SKazutaka YOKOTA test_kbd_port(kbdc); 1236617b9080SKazutaka YOKOTA 1237617b9080SKazutaka YOKOTA err = get_kbd_echo(kbdc); 1238a68d00e3SKazutaka YOKOTA 1239a68d00e3SKazutaka YOKOTA /* 1240a68d00e3SKazutaka YOKOTA * Even if the keyboard doesn't seem to be present (err != 0), 1241a68d00e3SKazutaka YOKOTA * we shall enable the keyboard port and interrupt so that 1242a68d00e3SKazutaka YOKOTA * the driver will be operable when the keyboard is attached 1243a68d00e3SKazutaka YOKOTA * to the system later. It is NOT recommended to hot-plug 1244a68d00e3SKazutaka YOKOTA * the AT keyboard, but many people do so... 1245a68d00e3SKazutaka YOKOTA */ 1246a68d00e3SKazutaka YOKOTA kbdc_set_device_mask(kbdc, m | KBD_KBD_CONTROL_BITS); 1247a68d00e3SKazutaka YOKOTA setup_kbd_port(kbdc, TRUE, TRUE); 1248a68d00e3SKazutaka YOKOTA #if 0 1249617b9080SKazutaka YOKOTA if (err == 0) { 1250617b9080SKazutaka YOKOTA kbdc_set_device_mask(kbdc, m | KBD_KBD_CONTROL_BITS); 1251617b9080SKazutaka YOKOTA } else { 1252617b9080SKazutaka YOKOTA /* try to restore the command byte as before */ 12536c176113SMichael Gmelin set_controller_command_byte(kbdc, 12546c176113SMichael Gmelin ALLOW_DISABLE_KBD(kbdc) ? 0xff : KBD_KBD_CONTROL_BITS, c); 1255617b9080SKazutaka YOKOTA kbdc_set_device_mask(kbdc, m); 1256617b9080SKazutaka YOKOTA } 1257a68d00e3SKazutaka YOKOTA #endif 1258617b9080SKazutaka YOKOTA 1259617b9080SKazutaka YOKOTA kbdc_lock(kbdc, FALSE); 12606c176113SMichael Gmelin return (HAS_QUIRK(kbdc, KBDC_QUIRK_IGNORE_PROBE_RESULT) ? 0 : err); 1261617b9080SKazutaka YOKOTA } 1262617b9080SKazutaka YOKOTA 1263617b9080SKazutaka YOKOTA static int 1264617b9080SKazutaka YOKOTA init_keyboard(KBDC kbdc, int *type, int flags) 1265617b9080SKazutaka YOKOTA { 1266617b9080SKazutaka YOKOTA int codeset; 1267617b9080SKazutaka YOKOTA int id; 1268617b9080SKazutaka YOKOTA int c; 1269617b9080SKazutaka YOKOTA 1270617b9080SKazutaka YOKOTA if (!kbdc_lock(kbdc, TRUE)) { 1271617b9080SKazutaka YOKOTA /* driver error? */ 1272617b9080SKazutaka YOKOTA return EIO; 1273617b9080SKazutaka YOKOTA } 1274617b9080SKazutaka YOKOTA 1275aec1fa1cSKazutaka YOKOTA /* temporarily block data transmission from the keyboard */ 1276aec1fa1cSKazutaka YOKOTA write_controller_command(kbdc, KBDC_DISABLE_KBD_PORT); 1277aec1fa1cSKazutaka YOKOTA 1278617b9080SKazutaka YOKOTA /* save the current controller command byte */ 127982d654e8SKazutaka YOKOTA empty_both_buffers(kbdc, 200); 1280617b9080SKazutaka YOKOTA c = get_controller_command_byte(kbdc); 1281617b9080SKazutaka YOKOTA if (c == -1) { 1282617b9080SKazutaka YOKOTA /* CONTROLLER ERROR */ 1283617b9080SKazutaka YOKOTA kbdc_lock(kbdc, FALSE); 1284617b9080SKazutaka YOKOTA printf("atkbd: unable to get the current command byte value.\n"); 1285617b9080SKazutaka YOKOTA return EIO; 1286617b9080SKazutaka YOKOTA } 1287617b9080SKazutaka YOKOTA if (bootverbose) 1288617b9080SKazutaka YOKOTA printf("atkbd: the current kbd controller command byte %04x\n", 1289617b9080SKazutaka YOKOTA c); 1290617b9080SKazutaka YOKOTA #if 0 1291617b9080SKazutaka YOKOTA /* override the keyboard lock switch */ 1292617b9080SKazutaka YOKOTA c |= KBD_OVERRIDE_KBD_LOCK; 1293617b9080SKazutaka YOKOTA #endif 1294617b9080SKazutaka YOKOTA 1295617b9080SKazutaka YOKOTA /* enable the keyboard port, but disable the keyboard intr. */ 1296617b9080SKazutaka YOKOTA if (setup_kbd_port(kbdc, TRUE, FALSE)) { 1297617b9080SKazutaka YOKOTA /* CONTROLLER ERROR: there is very little we can do... */ 1298617b9080SKazutaka YOKOTA printf("atkbd: unable to set the command byte.\n"); 1299617b9080SKazutaka YOKOTA kbdc_lock(kbdc, FALSE); 1300617b9080SKazutaka YOKOTA return EIO; 1301617b9080SKazutaka YOKOTA } 1302617b9080SKazutaka YOKOTA 13036c176113SMichael Gmelin if (HAS_QUIRK(kbdc, KBDC_QUIRK_RESET_AFTER_PROBE) && 13046c176113SMichael Gmelin atkbd_reset(kbdc, flags, c)) { 13056c176113SMichael Gmelin kbdc_lock(kbdc, FALSE); 13066c176113SMichael Gmelin return EIO; 13076c176113SMichael Gmelin } 13086c176113SMichael Gmelin 1309617b9080SKazutaka YOKOTA /* 1310617b9080SKazutaka YOKOTA * Check if we have an XT keyboard before we attempt to reset it. 1311617b9080SKazutaka YOKOTA * The procedure assumes that the keyboard and the controller have 1312617b9080SKazutaka YOKOTA * been set up properly by BIOS and have not been messed up 1313617b9080SKazutaka YOKOTA * during the boot process. 1314617b9080SKazutaka YOKOTA */ 1315617b9080SKazutaka YOKOTA codeset = -1; 1316617b9080SKazutaka YOKOTA if (flags & KB_CONF_ALT_SCANCODESET) 1317617b9080SKazutaka YOKOTA /* the user says there is a XT keyboard */ 1318617b9080SKazutaka YOKOTA codeset = 1; 1319617b9080SKazutaka YOKOTA #ifdef KBD_DETECT_XT_KEYBOARD 1320617b9080SKazutaka YOKOTA else if ((c & KBD_TRANSLATION) == 0) { 1321617b9080SKazutaka YOKOTA /* SET_SCANCODE_SET is not always supported; ignore error */ 1322617b9080SKazutaka YOKOTA if (send_kbd_command_and_data(kbdc, KBDC_SET_SCANCODE_SET, 0) 1323617b9080SKazutaka YOKOTA == KBD_ACK) 1324617b9080SKazutaka YOKOTA codeset = read_kbd_data(kbdc); 1325617b9080SKazutaka YOKOTA } 1326617b9080SKazutaka YOKOTA if (bootverbose) 1327617b9080SKazutaka YOKOTA printf("atkbd: scancode set %d\n", codeset); 1328617b9080SKazutaka YOKOTA #endif /* KBD_DETECT_XT_KEYBOARD */ 1329617b9080SKazutaka YOKOTA 1330617b9080SKazutaka YOKOTA *type = KB_OTHER; 1331617b9080SKazutaka YOKOTA id = get_kbd_id(kbdc); 1332617b9080SKazutaka YOKOTA switch(id) { 1333934d11e3SKazutaka YOKOTA case 0x41ab: /* 101/102/... Enhanced */ 1334934d11e3SKazutaka YOKOTA case 0x83ab: /* ditto */ 1335934d11e3SKazutaka YOKOTA case 0x54ab: /* SpaceSaver */ 1336934d11e3SKazutaka YOKOTA case 0x84ab: /* ditto */ 1337934d11e3SKazutaka YOKOTA #if 0 1338934d11e3SKazutaka YOKOTA case 0x90ab: /* 'G' */ 1339934d11e3SKazutaka YOKOTA case 0x91ab: /* 'P' */ 1340934d11e3SKazutaka YOKOTA case 0x92ab: /* 'A' */ 1341934d11e3SKazutaka YOKOTA #endif 1342617b9080SKazutaka YOKOTA *type = KB_101; 1343617b9080SKazutaka YOKOTA break; 1344617b9080SKazutaka YOKOTA case -1: /* AT 84 keyboard doesn't return ID */ 1345617b9080SKazutaka YOKOTA *type = KB_84; 1346617b9080SKazutaka YOKOTA break; 1347617b9080SKazutaka YOKOTA default: 1348617b9080SKazutaka YOKOTA break; 1349617b9080SKazutaka YOKOTA } 1350617b9080SKazutaka YOKOTA if (bootverbose) 1351617b9080SKazutaka YOKOTA printf("atkbd: keyboard ID 0x%x (%d)\n", id, *type); 1352617b9080SKazutaka YOKOTA 13536c176113SMichael Gmelin if (!HAS_QUIRK(kbdc, KBDC_QUIRK_RESET_AFTER_PROBE) && 13546c176113SMichael Gmelin atkbd_reset(kbdc, flags, c)) { 1355617b9080SKazutaka YOKOTA kbdc_lock(kbdc, FALSE); 1356617b9080SKazutaka YOKOTA return EIO; 1357617b9080SKazutaka YOKOTA } 1358617b9080SKazutaka YOKOTA 1359617b9080SKazutaka YOKOTA /* 13602ce7d7a0SPoul-Henning Kamp * Allow us to set the XT_KEYBD flag so that keyboards 1361617b9080SKazutaka YOKOTA * such as those on the IBM ThinkPad laptop computers can be used 1362617b9080SKazutaka YOKOTA * with the standard console driver. 1363617b9080SKazutaka YOKOTA */ 1364617b9080SKazutaka YOKOTA if (codeset == 1) { 1365617b9080SKazutaka YOKOTA if (send_kbd_command_and_data(kbdc, 1366617b9080SKazutaka YOKOTA KBDC_SET_SCANCODE_SET, codeset) == KBD_ACK) { 1367617b9080SKazutaka YOKOTA /* XT kbd doesn't need scan code translation */ 1368617b9080SKazutaka YOKOTA c &= ~KBD_TRANSLATION; 1369617b9080SKazutaka YOKOTA } else { 1370617b9080SKazutaka YOKOTA /* 1371617b9080SKazutaka YOKOTA * KEYBOARD ERROR 1372617b9080SKazutaka YOKOTA * The XT kbd isn't usable unless the proper scan 1373617b9080SKazutaka YOKOTA * code set is selected. 1374617b9080SKazutaka YOKOTA */ 13756c176113SMichael Gmelin set_controller_command_byte(kbdc, ALLOW_DISABLE_KBD(kbdc) 13766c176113SMichael Gmelin ? 0xff : KBD_KBD_CONTROL_BITS, c); 1377617b9080SKazutaka YOKOTA kbdc_lock(kbdc, FALSE); 1378617b9080SKazutaka YOKOTA printf("atkbd: unable to set the XT keyboard mode.\n"); 1379617b9080SKazutaka YOKOTA return EIO; 1380617b9080SKazutaka YOKOTA } 1381617b9080SKazutaka YOKOTA } 1382617b9080SKazutaka YOKOTA 138373dbd3daSJohn Baldwin #if defined(__sparc64__) 1384f359876fSKazutaka YOKOTA if (send_kbd_command_and_data( 1385f359876fSKazutaka YOKOTA kbdc, KBDC_SET_SCANCODE_SET, 2) != KBD_ACK) { 1386f359876fSKazutaka YOKOTA printf("atkbd: can't set translation.\n"); 1387f359876fSKazutaka YOKOTA } 1388f359876fSKazutaka YOKOTA c |= KBD_TRANSLATION; 1389f359876fSKazutaka YOKOTA #endif 1390f359876fSKazutaka YOKOTA 13916c176113SMichael Gmelin /* 13926c176113SMichael Gmelin * Some keyboards require a SETLEDS command to be sent after 13936c176113SMichael Gmelin * the reset command before they will send keystrokes to us 13946c176113SMichael Gmelin */ 13956c176113SMichael Gmelin if (HAS_QUIRK(kbdc, KBDC_QUIRK_SETLEDS_ON_INIT) && 13966c176113SMichael Gmelin send_kbd_command_and_data(kbdc, KBDC_SET_LEDS, 0) != KBD_ACK) { 13976c176113SMichael Gmelin printf("atkbd: setleds failed\n"); 13986c176113SMichael Gmelin } 13996c176113SMichael Gmelin if (!ALLOW_DISABLE_KBD(kbdc)) 14006c176113SMichael Gmelin send_kbd_command(kbdc, KBDC_ENABLE_KBD); 14016c176113SMichael Gmelin 1402617b9080SKazutaka YOKOTA /* enable the keyboard port and intr. */ 1403617b9080SKazutaka YOKOTA if (!set_controller_command_byte(kbdc, 1404617b9080SKazutaka YOKOTA KBD_KBD_CONTROL_BITS | KBD_TRANSLATION | KBD_OVERRIDE_KBD_LOCK, 1405617b9080SKazutaka YOKOTA (c & (KBD_TRANSLATION | KBD_OVERRIDE_KBD_LOCK)) 1406617b9080SKazutaka YOKOTA | KBD_ENABLE_KBD_PORT | KBD_ENABLE_KBD_INT)) { 1407617b9080SKazutaka YOKOTA /* 1408617b9080SKazutaka YOKOTA * CONTROLLER ERROR 1409617b9080SKazutaka YOKOTA * This is serious; we are left with the disabled 1410617b9080SKazutaka YOKOTA * keyboard intr. 1411617b9080SKazutaka YOKOTA */ 14126c176113SMichael Gmelin set_controller_command_byte(kbdc, ALLOW_DISABLE_KBD(kbdc) 14136c176113SMichael Gmelin ? 0xff : (KBD_KBD_CONTROL_BITS | KBD_TRANSLATION | 14146c176113SMichael Gmelin KBD_OVERRIDE_KBD_LOCK), c); 1415617b9080SKazutaka YOKOTA kbdc_lock(kbdc, FALSE); 1416617b9080SKazutaka YOKOTA printf("atkbd: unable to enable the keyboard port and intr.\n"); 1417617b9080SKazutaka YOKOTA return EIO; 1418617b9080SKazutaka YOKOTA } 1419617b9080SKazutaka YOKOTA 1420617b9080SKazutaka YOKOTA kbdc_lock(kbdc, FALSE); 1421617b9080SKazutaka YOKOTA return 0; 1422617b9080SKazutaka YOKOTA } 1423617b9080SKazutaka YOKOTA 1424617b9080SKazutaka YOKOTA static int 1425617b9080SKazutaka YOKOTA write_kbd(KBDC kbdc, int command, int data) 1426617b9080SKazutaka YOKOTA { 1427617b9080SKazutaka YOKOTA int s; 1428617b9080SKazutaka YOKOTA 1429617b9080SKazutaka YOKOTA /* prevent the timeout routine from polling the keyboard */ 1430617b9080SKazutaka YOKOTA if (!kbdc_lock(kbdc, TRUE)) 1431617b9080SKazutaka YOKOTA return EBUSY; 1432617b9080SKazutaka YOKOTA 1433617b9080SKazutaka YOKOTA /* disable the keyboard and mouse interrupt */ 1434617b9080SKazutaka YOKOTA s = spltty(); 1435617b9080SKazutaka YOKOTA #if 0 1436617b9080SKazutaka YOKOTA c = get_controller_command_byte(kbdc); 1437617b9080SKazutaka YOKOTA if ((c == -1) 1438617b9080SKazutaka YOKOTA || !set_controller_command_byte(kbdc, 1439617b9080SKazutaka YOKOTA kbdc_get_device_mask(kbdc), 1440617b9080SKazutaka YOKOTA KBD_DISABLE_KBD_PORT | KBD_DISABLE_KBD_INT 1441617b9080SKazutaka YOKOTA | KBD_DISABLE_AUX_PORT | KBD_DISABLE_AUX_INT)) { 1442617b9080SKazutaka YOKOTA /* CONTROLLER ERROR */ 1443617b9080SKazutaka YOKOTA kbdc_lock(kbdc, FALSE); 1444617b9080SKazutaka YOKOTA splx(s); 1445617b9080SKazutaka YOKOTA return EIO; 1446617b9080SKazutaka YOKOTA } 1447617b9080SKazutaka YOKOTA /* 1448617b9080SKazutaka YOKOTA * Now that the keyboard controller is told not to generate 1449617b9080SKazutaka YOKOTA * the keyboard and mouse interrupts, call `splx()' to allow 1450617b9080SKazutaka YOKOTA * the other tty interrupts. The clock interrupt may also occur, 1451617b9080SKazutaka YOKOTA * but the timeout routine (`scrn_timer()') will be blocked 1452617b9080SKazutaka YOKOTA * by the lock flag set via `kbdc_lock()' 1453617b9080SKazutaka YOKOTA */ 1454617b9080SKazutaka YOKOTA splx(s); 1455617b9080SKazutaka YOKOTA #endif 1456617b9080SKazutaka YOKOTA if (send_kbd_command_and_data(kbdc, command, data) != KBD_ACK) 1457617b9080SKazutaka YOKOTA send_kbd_command(kbdc, KBDC_ENABLE_KBD); 1458617b9080SKazutaka YOKOTA #if 0 1459617b9080SKazutaka YOKOTA /* restore the interrupts */ 1460f0143dacSWarner Losh if (!set_controller_command_byte(kbdc, kbdc_get_device_mask(kbdc), 1461617b9080SKazutaka YOKOTA c & (KBD_KBD_CONTROL_BITS | KBD_AUX_CONTROL_BITS))) { 1462617b9080SKazutaka YOKOTA /* CONTROLLER ERROR */ 1463617b9080SKazutaka YOKOTA } 1464617b9080SKazutaka YOKOTA #else 1465617b9080SKazutaka YOKOTA splx(s); 1466617b9080SKazutaka YOKOTA #endif 1467617b9080SKazutaka YOKOTA kbdc_lock(kbdc, FALSE); 1468617b9080SKazutaka YOKOTA 1469617b9080SKazutaka YOKOTA return 0; 1470617b9080SKazutaka YOKOTA } 1471617b9080SKazutaka YOKOTA 1472617b9080SKazutaka YOKOTA static int 1473617b9080SKazutaka YOKOTA get_kbd_id(KBDC kbdc) 1474617b9080SKazutaka YOKOTA { 1475617b9080SKazutaka YOKOTA int id1, id2; 1476617b9080SKazutaka YOKOTA 1477617b9080SKazutaka YOKOTA empty_both_buffers(kbdc, 10); 1478617b9080SKazutaka YOKOTA id1 = id2 = -1; 1479617b9080SKazutaka YOKOTA if (send_kbd_command(kbdc, KBDC_SEND_DEV_ID) != KBD_ACK) 1480617b9080SKazutaka YOKOTA return -1; 1481617b9080SKazutaka YOKOTA 1482617b9080SKazutaka YOKOTA DELAY(10000); /* 10 msec delay */ 1483617b9080SKazutaka YOKOTA id1 = read_kbd_data(kbdc); 1484617b9080SKazutaka YOKOTA if (id1 != -1) 1485617b9080SKazutaka YOKOTA id2 = read_kbd_data(kbdc); 1486617b9080SKazutaka YOKOTA 1487617b9080SKazutaka YOKOTA if ((id1 == -1) || (id2 == -1)) { 1488617b9080SKazutaka YOKOTA empty_both_buffers(kbdc, 10); 1489617b9080SKazutaka YOKOTA test_controller(kbdc); 1490617b9080SKazutaka YOKOTA test_kbd_port(kbdc); 1491617b9080SKazutaka YOKOTA return -1; 1492617b9080SKazutaka YOKOTA } 1493617b9080SKazutaka YOKOTA return ((id2 << 8) | id1); 1494617b9080SKazutaka YOKOTA } 1495617b9080SKazutaka YOKOTA 1496e9deda23SKazutaka YOKOTA static int delays[] = { 250, 500, 750, 1000 }; 1497e9deda23SKazutaka YOKOTA static int rates[] = { 34, 38, 42, 46, 50, 55, 59, 63, 1498e9deda23SKazutaka YOKOTA 68, 76, 84, 92, 100, 110, 118, 126, 1499e9deda23SKazutaka YOKOTA 136, 152, 168, 184, 200, 220, 236, 252, 1500e9deda23SKazutaka YOKOTA 272, 304, 336, 368, 400, 440, 472, 504 }; 150157995893SKazutaka YOKOTA 150257995893SKazutaka YOKOTA static int 150357995893SKazutaka YOKOTA typematic_delay(int i) 150457995893SKazutaka YOKOTA { 150557995893SKazutaka YOKOTA return delays[(i >> 5) & 3]; 150657995893SKazutaka YOKOTA } 150757995893SKazutaka YOKOTA 150857995893SKazutaka YOKOTA static int 150957995893SKazutaka YOKOTA typematic_rate(int i) 151057995893SKazutaka YOKOTA { 151157995893SKazutaka YOKOTA return rates[i & 0x1f]; 151257995893SKazutaka YOKOTA } 151357995893SKazutaka YOKOTA 151457995893SKazutaka YOKOTA static int 151557995893SKazutaka YOKOTA typematic(int delay, int rate) 151657995893SKazutaka YOKOTA { 1517e9deda23SKazutaka YOKOTA int value; 1518e9deda23SKazutaka YOKOTA int i; 1519e9deda23SKazutaka YOKOTA 1520e9deda23SKazutaka YOKOTA for (i = sizeof(delays)/sizeof(delays[0]) - 1; i > 0; --i) { 1521e9deda23SKazutaka YOKOTA if (delay >= delays[i]) 1522e9deda23SKazutaka YOKOTA break; 1523e9deda23SKazutaka YOKOTA } 1524e9deda23SKazutaka YOKOTA value = i << 5; 1525e9deda23SKazutaka YOKOTA for (i = sizeof(rates)/sizeof(rates[0]) - 1; i > 0; --i) { 1526e9deda23SKazutaka YOKOTA if (rate >= rates[i]) 1527e9deda23SKazutaka YOKOTA break; 1528e9deda23SKazutaka YOKOTA } 1529e9deda23SKazutaka YOKOTA value |= i; 1530e9deda23SKazutaka YOKOTA return value; 1531e9deda23SKazutaka YOKOTA } 1532