sys/dev/usb/input/ukbd.c

   1 #include <sys/cdefs.h>
   2 __FBSDID("$FreeBSD$");
   3
   4
   5 /*-
   6  * Copyright (c) 1998 The NetBSD Foundation, Inc.
   7  * All rights reserved.
   8  *
   9  * This code is derived from software contributed to The NetBSD Foundation
  10  * by Lennart Augustsson (lennart@augustsson.net) at
  11  * Carlstedt Research & Technology.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  23  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  24  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  25  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  26  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  27  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  28  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  29  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  30  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  31  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  32  * POSSIBILITY OF SUCH DAMAGE.
  33  *
  34  */
  35
  36 /*
  37  * HID spec: http://www.usb.org/developers/devclass_docs/HID1_11.pdf
  38  */
  39
  40 #include "opt_compat.h"
  41 #include "opt_kbd.h"
  42 #include "opt_ukbd.h"
  43
  44 #include <sys/stdint.h>
  45 #include <sys/stddef.h>
  46 #include <sys/param.h>
  47 #include <sys/queue.h>
  48 #include <sys/types.h>
  49 #include <sys/systm.h>
  50 #include <sys/kernel.h>
  51 #include <sys/bus.h>
  52 #include <sys/module.h>
  53 #include <sys/lock.h>
  54 #include <sys/mutex.h>
  55 #include <sys/condvar.h>
  56 #include <sys/sysctl.h>
  57 #include <sys/sx.h>
  58 #include <sys/unistd.h>
  59 #include <sys/callout.h>
  60 #include <sys/malloc.h>
  61 #include <sys/priv.h>
  62 #include <sys/proc.h>
  63 #include <sys/sched.h>
  64 #include <sys/kdb.h>
  65
  66 #include <dev/usb/usb.h>
  67 #include <dev/usb/usbdi.h>
  68 #include <dev/usb/usbdi_util.h>
  69 #include <dev/usb/usbhid.h>
  70
  71 #define USB_DEBUG_VAR ukbd_debug
  72 #include <dev/usb/usb_debug.h>
  73
  74 #include <dev/usb/quirk/usb_quirk.h>
  75
  76 #include <sys/ioccom.h>
  77 #include <sys/filio.h>
  78 #include <sys/tty.h>
  79 #include <sys/kbio.h>
  80
  81 #include <dev/kbd/kbdreg.h>
  82
  83 /* the initial key map, accent map and fkey strings */
  84 #if defined(UKBD_DFLT_KEYMAP) && !defined(KLD_MODULE)
  85 #define KBD_DFLT_KEYMAP
  86 #include "ukbdmap.h"
  87 #endif
  88
  89 /* the following file must be included after "ukbdmap.h" */
  90 #include <dev/kbd/kbdtables.h>
  91
  92 #ifdef USB_DEBUG
  93 static int ukbd_debug = 0;
  94 static int ukbd_no_leds = 0;
  95 static int ukbd_pollrate = 0;
  96
  97 static SYSCTL_NODE(_hw_usb, OID_AUTO, ukbd, CTLFLAG_RW, 0, "USB keyboard");
  98 SYSCTL_INT(_hw_usb_ukbd, OID_AUTO, debug, CTLFLAG_RW | CTLFLAG_TUN,
  99     &ukbd_debug, 0, "Debug level");
 100 TUNABLE_INT("hw.usb.ukbd.debug", &ukbd_debug);
 101 SYSCTL_INT(_hw_usb_ukbd, OID_AUTO, no_leds, CTLFLAG_RW | CTLFLAG_TUN,
 102     &ukbd_no_leds, 0, "Disables setting of keyboard leds");
 103 TUNABLE_INT("hw.usb.ukbd.no_leds", &ukbd_no_leds);
 104 SYSCTL_INT(_hw_usb_ukbd, OID_AUTO, pollrate, CTLFLAG_RW | CTLFLAG_TUN,
 105     &ukbd_pollrate, 0, "Force this polling rate, 1-1000Hz");
 106 TUNABLE_INT("hw.usb.ukbd.pollrate", &ukbd_pollrate);
 107 #endif
 108
 109 #define UKBD_EMULATE_ATSCANCODE        1
 110 #define UKBD_DRIVER_NAME          "ukbd"
 111 #define UKBD_NMOD                     8 /* units */
 112 #define UKBD_NKEYCODE                 6 /* units */
 113 #define UKBD_IN_BUF_SIZE  (2*(UKBD_NMOD + (2*UKBD_NKEYCODE)))   /* bytes */
 114 #define UKBD_IN_BUF_FULL  (UKBD_IN_BUF_SIZE / 2)        /* bytes */
 115 #define UKBD_NFKEY        (sizeof(fkey_tab)/sizeof(fkey_tab[0]))        /* units */
 116 #define UKBD_BUFFER_SIZE              64        /* bytes */
 117
 118 struct ukbd_data {
 119         uint16_t        modifiers;
 120 #define MOD_CONTROL_L   0x01
 121 #define MOD_CONTROL_R   0x10
 122 #define MOD_SHIFT_L     0x02
 123 #define MOD_SHIFT_R     0x20
 124 #define MOD_ALT_L       0x04
 125 #define MOD_ALT_R       0x40
 126 #define MOD_WIN_L       0x08
 127 #define MOD_WIN_R       0x80
 128 /* internal */
 129 #define MOD_EJECT       0x0100
 130 #define MOD_FN          0x0200
 131         uint8_t keycode[UKBD_NKEYCODE];
 132 };
 133
 134 enum {
 135         UKBD_INTR_DT,
 136         UKBD_CTRL_LED,
 137         UKBD_N_TRANSFER,
 138 };
 139
 140 struct ukbd_softc {
 141         keyboard_t sc_kbd;
 142         keymap_t sc_keymap;
 143         accentmap_t sc_accmap;
 144         fkeytab_t sc_fkeymap[UKBD_NFKEY];
 145         struct hid_location sc_loc_apple_eject;
 146         struct hid_location sc_loc_apple_fn;
 147         struct hid_location sc_loc_ctrl_l;
 148         struct hid_location sc_loc_ctrl_r;
 149         struct hid_location sc_loc_shift_l;
 150         struct hid_location sc_loc_shift_r;
 151         struct hid_location sc_loc_alt_l;
 152         struct hid_location sc_loc_alt_r;
 153         struct hid_location sc_loc_win_l;
 154         struct hid_location sc_loc_win_r;
 155         struct hid_location sc_loc_events;
 156         struct hid_location sc_loc_numlock;
 157         struct hid_location sc_loc_capslock;
 158         struct hid_location sc_loc_scrolllock;
 159         struct usb_callout sc_callout;
 160         struct ukbd_data sc_ndata;
 161         struct ukbd_data sc_odata;
 162
 163         struct thread *sc_poll_thread;
 164         struct usb_device *sc_udev;
 165         struct usb_interface *sc_iface;
 166         struct usb_xfer *sc_xfer[UKBD_N_TRANSFER];
 167
 168         uint32_t sc_ntime[UKBD_NKEYCODE];
 169         uint32_t sc_otime[UKBD_NKEYCODE];
 170         uint32_t sc_input[UKBD_IN_BUF_SIZE];    /* input buffer */
 171         uint32_t sc_time_ms;
 172         uint32_t sc_composed_char;      /* composed char code, if non-zero */
 173 #ifdef UKBD_EMULATE_ATSCANCODE
 174         uint32_t sc_buffered_char[2];
 175 #endif
 176         uint32_t sc_flags;              /* flags */
 177 #define UKBD_FLAG_COMPOSE       0x00000001
 178 #define UKBD_FLAG_POLLING       0x00000002
 179 #define UKBD_FLAG_SET_LEDS      0x00000004
 180 #define UKBD_FLAG_ATTACHED      0x00000010
 181 #define UKBD_FLAG_GONE          0x00000020
 182
 183 #define UKBD_FLAG_HID_MASK      0x003fffc0
 184 #define UKBD_FLAG_APPLE_EJECT   0x00000040
 185 #define UKBD_FLAG_APPLE_FN      0x00000080
 186 #define UKBD_FLAG_APPLE_SWAP    0x00000100
 187 #define UKBD_FLAG_TIMER_RUNNING 0x00000200
 188 #define UKBD_FLAG_CTRL_L        0x00000400
 189 #define UKBD_FLAG_CTRL_R        0x00000800
 190 #define UKBD_FLAG_SHIFT_L       0x00001000
 191 #define UKBD_FLAG_SHIFT_R       0x00002000
 192 #define UKBD_FLAG_ALT_L         0x00004000
 193 #define UKBD_FLAG_ALT_R         0x00008000
 194 #define UKBD_FLAG_WIN_L         0x00010000
 195 #define UKBD_FLAG_WIN_R         0x00020000
 196 #define UKBD_FLAG_EVENTS        0x00040000
 197 #define UKBD_FLAG_NUMLOCK       0x00080000
 198 #define UKBD_FLAG_CAPSLOCK      0x00100000
 199 #define UKBD_FLAG_SCROLLLOCK    0x00200000
 200 #define UKBD_FLAG_VALID_KEYS    0x00400000
 201
 202         int     sc_mode;                /* input mode (K_XLATE,K_RAW,K_CODE) */
 203         int     sc_state;               /* shift/lock key state */
 204         int     sc_accents;             /* accent key index (> 0) */
 205         int     sc_led_size;
 206         int     sc_kbd_size;
 207
 208         uint16_t sc_inputs;
 209         uint16_t sc_inputhead;
 210         uint16_t sc_inputtail;
 211         uint16_t sc_modifiers;
 212
 213         uint8_t sc_leds;                /* store for async led requests */
 214         uint8_t sc_iface_index;
 215         uint8_t sc_iface_no;
 216         uint8_t sc_id_apple_eject;
 217         uint8_t sc_id_apple_fn;
 218         uint8_t sc_id_ctrl_l;
 219         uint8_t sc_id_ctrl_r;
 220         uint8_t sc_id_shift_l;
 221         uint8_t sc_id_shift_r;
 222         uint8_t sc_id_alt_l;
 223         uint8_t sc_id_alt_r;
 224         uint8_t sc_id_win_l;
 225         uint8_t sc_id_win_r;
 226         uint8_t sc_id_event;
 227         uint8_t sc_id_numlock;
 228         uint8_t sc_id_capslock;
 229         uint8_t sc_id_scrolllock;
 230         uint8_t sc_id_events;
 231         uint8_t sc_kbd_id;
 232
 233         uint8_t sc_buffer[UKBD_BUFFER_SIZE];
 234 };
 235
 236 #define KEY_ERROR         0x01
 237
 238 #define KEY_PRESS         0
 239 #define KEY_RELEASE       0x400
 240 #define KEY_INDEX(c)      ((c) & 0xFF)
 241
 242 #define SCAN_PRESS        0
 243 #define SCAN_RELEASE      0x80
 244 #define SCAN_PREFIX_E0    0x100
 245 #define SCAN_PREFIX_E1    0x200
 246 #define SCAN_PREFIX_CTL   0x400
 247 #define SCAN_PREFIX_SHIFT 0x800
 248 #define SCAN_PREFIX     (SCAN_PREFIX_E0  | SCAN_PREFIX_E1 | \
 249                          SCAN_PREFIX_CTL | SCAN_PREFIX_SHIFT)
 250 #define SCAN_CHAR(c)    ((c) & 0x7f)
 251
 252 #define UKBD_LOCK()     mtx_lock(&Giant)
 253 #define UKBD_UNLOCK()   mtx_unlock(&Giant)
 254
 255 #ifdef  INVARIANTS
 256
 257 /*
 258  * Assert that the lock is held in all contexts
 259  * where the code can be executed.
 260  */
 261 #define UKBD_LOCK_ASSERT()      mtx_assert(&Giant, MA_OWNED)
 262
 263 /*
 264  * Assert that the lock is held in the contexts
 265  * where it really has to be so.
 266  */
 267 #define UKBD_CTX_LOCK_ASSERT()                          \
 268         do {                                            \
 269                 if (!kdb_active && panicstr == NULL)    \
 270                         mtx_assert(&Giant, MA_OWNED);   \
 271         } while (0)
 272 #else
 273
 274 #define UKBD_LOCK_ASSERT()      (void)0
 275 #define UKBD_CTX_LOCK_ASSERT()  (void)0
 276
 277 #endif
 278
 279 struct ukbd_mods {
 280         uint32_t mask, key;
 281 };
 282
 283 static const struct ukbd_mods ukbd_mods[UKBD_NMOD] = {
 284         {MOD_CONTROL_L, 0xe0},
 285         {MOD_CONTROL_R, 0xe4},
 286         {MOD_SHIFT_L, 0xe1},
 287         {MOD_SHIFT_R, 0xe5},
 288         {MOD_ALT_L, 0xe2},
 289         {MOD_ALT_R, 0xe6},
 290         {MOD_WIN_L, 0xe3},
 291         {MOD_WIN_R, 0xe7},
 292 };
 293
 294 #define NN 0                            /* no translation */
 295 /*
 296  * Translate USB keycodes to AT keyboard scancodes.
 297  */
 298 /*
 299  * FIXME: Mac USB keyboard generates:
 300  * 0x53: keypad NumLock/Clear
 301  * 0x66: Power
 302  * 0x67: keypad =
 303  * 0x68: F13
 304  * 0x69: F14
 305  * 0x6a: F15
 306  */
 307 static const uint8_t ukbd_trtab[256] = {
 308         0, 0, 0, 0, 30, 48, 46, 32,     /* 00 - 07 */
 309         18, 33, 34, 35, 23, 36, 37, 38, /* 08 - 0F */
 310         50, 49, 24, 25, 16, 19, 31, 20, /* 10 - 17 */
 311         22, 47, 17, 45, 21, 44, 2, 3,   /* 18 - 1F */
 312         4, 5, 6, 7, 8, 9, 10, 11,       /* 20 - 27 */
 313         28, 1, 14, 15, 57, 12, 13, 26,  /* 28 - 2F */
 314         27, 43, 43, 39, 40, 41, 51, 52, /* 30 - 37 */
 315         53, 58, 59, 60, 61, 62, 63, 64, /* 38 - 3F */
 316         65, 66, 67, 68, 87, 88, 92, 70, /* 40 - 47 */
 317         104, 102, 94, 96, 103, 99, 101, 98,     /* 48 - 4F */
 318         97, 100, 95, 69, 91, 55, 74, 78,/* 50 - 57 */
 319         89, 79, 80, 81, 75, 76, 77, 71, /* 58 - 5F */
 320         72, 73, 82, 83, 86, 107, 122, NN,       /* 60 - 67 */
 321         NN, NN, NN, NN, NN, NN, NN, NN, /* 68 - 6F */
 322         NN, NN, NN, NN, 115, 108, 111, 113,     /* 70 - 77 */
 323         109, 110, 112, 118, 114, 116, 117, 119, /* 78 - 7F */
 324         121, 120, NN, NN, NN, NN, NN, 123,      /* 80 - 87 */
 325         124, 125, 126, 127, 128, NN, NN, NN,    /* 88 - 8F */
 326         NN, NN, NN, NN, NN, NN, NN, NN, /* 90 - 97 */
 327         NN, NN, NN, NN, NN, NN, NN, NN, /* 98 - 9F */
 328         NN, NN, NN, NN, NN, NN, NN, NN, /* A0 - A7 */
 329         NN, NN, NN, NN, NN, NN, NN, NN, /* A8 - AF */
 330         NN, NN, NN, NN, NN, NN, NN, NN, /* B0 - B7 */
 331         NN, NN, NN, NN, NN, NN, NN, NN, /* B8 - BF */
 332         NN, NN, NN, NN, NN, NN, NN, NN, /* C0 - C7 */
 333         NN, NN, NN, NN, NN, NN, NN, NN, /* C8 - CF */
 334         NN, NN, NN, NN, NN, NN, NN, NN, /* D0 - D7 */
 335         NN, NN, NN, NN, NN, NN, NN, NN, /* D8 - DF */
 336         29, 42, 56, 105, 90, 54, 93, 106,       /* E0 - E7 */
 337         NN, NN, NN, NN, NN, NN, NN, NN, /* E8 - EF */
 338         NN, NN, NN, NN, NN, NN, NN, NN, /* F0 - F7 */
 339         NN, NN, NN, NN, NN, NN, NN, NN, /* F8 - FF */
 340 };
 341
 342 static const uint8_t ukbd_boot_desc[] = {
 343         0x05, 0x01, 0x09, 0x06, 0xa1,
 344         0x01, 0x05, 0x07, 0x19, 0xe0,
 345         0x29, 0xe7, 0x15, 0x00, 0x25,
 346         0x01, 0x75, 0x01, 0x95, 0x08,
 347         0x81, 0x02, 0x95, 0x01, 0x75,
 348         0x08, 0x81, 0x01, 0x95, 0x03,
 349         0x75, 0x01, 0x05, 0x08, 0x19,
 350         0x01, 0x29, 0x03, 0x91, 0x02,
 351         0x95, 0x05, 0x75, 0x01, 0x91,
 352         0x01, 0x95, 0x06, 0x75, 0x08,
 353         0x15, 0x00, 0x26, 0xff, 0x00,
 354         0x05, 0x07, 0x19, 0x00, 0x2a,
 355         0xff, 0x00, 0x81, 0x00, 0xc0
 356 };
 357
 358 /* prototypes */
 359 static void     ukbd_timeout(void *);
 360 static void     ukbd_set_leds(struct ukbd_softc *, uint8_t);
 361 static int      ukbd_set_typematic(keyboard_t *, int);
 362 #ifdef UKBD_EMULATE_ATSCANCODE
 363 static int      ukbd_key2scan(struct ukbd_softc *, int, int, int);
 364 #endif
 365 static uint32_t ukbd_read_char(keyboard_t *, int);
 366 static void     ukbd_clear_state(keyboard_t *);
 367 static int      ukbd_ioctl(keyboard_t *, u_long, caddr_t);
 368 static int      ukbd_enable(keyboard_t *);
 369 static int      ukbd_disable(keyboard_t *);
 370 static void     ukbd_interrupt(struct ukbd_softc *);
 371 static void     ukbd_event_keyinput(struct ukbd_softc *);
 372
 373 static device_probe_t ukbd_probe;
 374 static device_attach_t ukbd_attach;
 375 static device_detach_t ukbd_detach;
 376 static device_resume_t ukbd_resume;
 377
 378 static uint8_t
 379 ukbd_any_key_pressed(struct ukbd_softc *sc)
 380 {
 381         uint8_t i;
 382         uint8_t j;
 383
 384         for (j = i = 0; i < UKBD_NKEYCODE; i++)
 385                 j |= sc->sc_odata.keycode[i];
 386
 387         return (j ? 1 : 0);
 388 }
 389
 390 static void
 391 ukbd_start_timer(struct ukbd_softc *sc)
 392 {
 393         sc->sc_flags |= UKBD_FLAG_TIMER_RUNNING;
 394         usb_callout_reset(&sc->sc_callout, hz / 40, &ukbd_timeout, sc);
 395 }
 396
 397 static void
 398 ukbd_put_key(struct ukbd_softc *sc, uint32_t key)
 399 {
 400
 401         UKBD_CTX_LOCK_ASSERT();
 402
 403         DPRINTF("0x%02x (%d) %s\n", key, key,
 404             (key & KEY_RELEASE) ? "released" : "pressed");
 405
 406         if (sc->sc_inputs < UKBD_IN_BUF_SIZE) {
 407                 sc->sc_input[sc->sc_inputtail] = key;
 408                 ++(sc->sc_inputs);
 409                 ++(sc->sc_inputtail);
 410                 if (sc->sc_inputtail >= UKBD_IN_BUF_SIZE) {
 411                         sc->sc_inputtail = 0;
 412                 }
 413         } else {
 414                 DPRINTF("input buffer is full\n");
 415         }
 416 }
 417
 418 static void
 419 ukbd_do_poll(struct ukbd_softc *sc, uint8_t wait)
 420 {
 421
 422         UKBD_CTX_LOCK_ASSERT();
 423         KASSERT((sc->sc_flags & UKBD_FLAG_POLLING) != 0,
 424             ("ukbd_do_poll called when not polling\n"));
 425         DPRINTFN(2, "polling\n");
 426
 427         if (!kdb_active && !SCHEDULER_STOPPED()) {
 428                 /*
 429                  * In this context the kernel is polling for input,
 430                  * but the USB subsystem works in normal interrupt-driven
 431                  * mode, so we just wait on the USB threads to do the job.
 432                  * Note that we currently hold the Giant, but it's also used
 433                  * as the transfer mtx, so we must release it while waiting.
 434                  */
 435                 while (sc->sc_inputs == 0) {
 436                         /*
 437                          * Give USB threads a chance to run.  Note that
 438                          * kern_yield performs DROP_GIANT + PICKUP_GIANT.
 439                          */
 440                         kern_yield(PRI_UNCHANGED);
 441                         if (!wait)
 442                                 break;
 443                 }
 444                 return;
 445         }
 446
 447         while (sc->sc_inputs == 0) {
 448
 449                 usbd_transfer_poll(sc->sc_xfer, UKBD_N_TRANSFER);
 450
 451                 /* Delay-optimised support for repetition of keys */
 452                 if (ukbd_any_key_pressed(sc)) {
 453                         /* a key is pressed - need timekeeping */
 454                         DELAY(1000);
 455
 456                         /* 1 millisecond has passed */
 457                         sc->sc_time_ms += 1;
 458                 }
 459
 460                 ukbd_interrupt(sc);
 461
 462                 if (!wait)
 463                         break;
 464         }
 465 }
 466
 467 static int32_t
 468 ukbd_get_key(struct ukbd_softc *sc, uint8_t wait)
 469 {
 470         int32_t c;
 471
 472         UKBD_CTX_LOCK_ASSERT();
 473         KASSERT((!kdb_active && !SCHEDULER_STOPPED())
 474             || (sc->sc_flags & UKBD_FLAG_POLLING) != 0,
 475             ("not polling in kdb or panic\n"));
 476
 477         if (sc->sc_inputs == 0) {
 478                 /* start transfer, if not already started */
 479                 usbd_transfer_start(sc->sc_xfer[UKBD_INTR_DT]);
 480         }
 481
 482         if (sc->sc_flags & UKBD_FLAG_POLLING)
 483                 ukbd_do_poll(sc, wait);
 484
 485         if (sc->sc_inputs == 0) {
 486                 c = -1;
 487         } else {
 488                 c = sc->sc_input[sc->sc_inputhead];
 489                 --(sc->sc_inputs);
 490                 ++(sc->sc_inputhead);
 491                 if (sc->sc_inputhead >= UKBD_IN_BUF_SIZE) {
 492                         sc->sc_inputhead = 0;
 493                 }
 494         }
 495         return (c);
 496 }
 497
 498 static void
 499 ukbd_interrupt(struct ukbd_softc *sc)
 500 {
 501         uint32_t n_mod;
 502         uint32_t o_mod;
 503         uint32_t now = sc->sc_time_ms;
 504         uint32_t dtime;
 505         uint8_t key;
 506         uint8_t i;
 507         uint8_t j;
 508
 509         UKBD_CTX_LOCK_ASSERT();
 510
 511         if (sc->sc_ndata.keycode[0] == KEY_ERROR)
 512                 return;
 513
 514         n_mod = sc->sc_ndata.modifiers;
 515         o_mod = sc->sc_odata.modifiers;
 516
 517         /*
 518          * Don't output any modifier keys before we see a valid
 519          * non-modifier key press. This prevents so-called "ghost
 520          * keyboards" keeping modifier keys pressed while not actually
 521          * seen as a real keyboard.
 522          */
 523         if (sc->sc_flags & UKBD_FLAG_VALID_KEYS)
 524                 goto kfound;
 525
 526         for (i = 0; i != UKBD_NKEYCODE; i++) {
 527                 key = sc->sc_ndata.keycode[i];
 528                 switch (key) {
 529                 case 0xe0:
 530                 case 0xe4:
 531                 case 0xe1:
 532                 case 0xe5:
 533                 case 0xe2:
 534                 case 0xe6:
 535                 case 0xe3:
 536                 case 0xe7:
 537                 case 0x00:
 538                 case KEY_ERROR:
 539                         break;
 540                 default:
 541                         sc->sc_flags |= UKBD_FLAG_VALID_KEYS;
 542                         goto kfound;
 543                 }
 544         }
 545         DPRINTF("Keeping modifiers buffered\n");
 546
 547         /* keep modifiers in buffer */
 548         sc->sc_ndata.modifiers = n_mod = 0;
 549
 550 kfound:
 551         if (n_mod != o_mod) {
 552                 for (i = 0; i < UKBD_NMOD; i++) {
 553                         if ((n_mod & ukbd_mods[i].mask) !=
 554                             (o_mod & ukbd_mods[i].mask)) {
 555                                 ukbd_put_key(sc, ukbd_mods[i].key |
 556                                     ((n_mod & ukbd_mods[i].mask) ?
 557                                     KEY_PRESS : KEY_RELEASE));
 558                         }
 559                 }
 560         }
 561         /* Check for released keys. */
 562         for (i = 0; i < UKBD_NKEYCODE; i++) {
 563                 key = sc->sc_odata.keycode[i];
 564                 if (key == 0) {
 565                         continue;
 566                 }
 567                 for (j = 0; j < UKBD_NKEYCODE; j++) {
 568                         if (sc->sc_ndata.keycode[j] == 0) {
 569                                 continue;
 570                         }
 571                         if (key == sc->sc_ndata.keycode[j]) {
 572                                 goto rfound;
 573                         }
 574                 }
 575                 ukbd_put_key(sc, key | KEY_RELEASE);
 576 rfound: ;
 577         }
 578
 579         /* Check for pressed keys. */
 580         for (i = 0; i < UKBD_NKEYCODE; i++) {
 581                 key = sc->sc_ndata.keycode[i];
 582                 if (key == 0) {
 583                         continue;
 584                 }
 585                 sc->sc_ntime[i] = now + sc->sc_kbd.kb_delay1;
 586                 for (j = 0; j < UKBD_NKEYCODE; j++) {
 587                         if (sc->sc_odata.keycode[j] == 0) {
 588                                 continue;
 589                         }
 590                         if (key == sc->sc_odata.keycode[j]) {
 591
 592                                 /* key is still pressed */
 593
 594                                 sc->sc_ntime[i] = sc->sc_otime[j];
 595                                 dtime = (sc->sc_otime[j] - now);
 596
 597                                 if (!(dtime & 0x80000000)) {
 598                                         /* time has not elapsed */
 599                                         goto pfound;
 600                                 }
 601                                 sc->sc_ntime[i] = now + sc->sc_kbd.kb_delay2;
 602                                 break;
 603                         }
 604                 }
 605                 ukbd_put_key(sc, key | KEY_PRESS);
 606
 607                 /*
 608                  * If any other key is presently down, force its repeat to be
 609                  * well in the future (100s).  This makes the last key to be
 610                  * pressed do the autorepeat.
 611                  */
 612                 for (j = 0; j != UKBD_NKEYCODE; j++) {
 613                         if (j != i)
 614                                 sc->sc_ntime[j] = now + (100 * 1000);
 615                 }
 616 pfound: ;
 617         }
 618
 619         sc->sc_odata = sc->sc_ndata;
 620
 621         memcpy(sc->sc_otime, sc->sc_ntime, sizeof(sc->sc_otime));
 622
 623         ukbd_event_keyinput(sc);
 624 }
 625
 626 static void
 627 ukbd_event_keyinput(struct ukbd_softc *sc)
 628 {
 629         int c;
 630
 631         UKBD_CTX_LOCK_ASSERT();
 632
 633         if ((sc->sc_flags & UKBD_FLAG_POLLING) != 0)
 634                 return;
 635
 636         if (sc->sc_inputs == 0)
 637                 return;
 638
 639         if (KBD_IS_ACTIVE(&sc->sc_kbd) &&
 640             KBD_IS_BUSY(&sc->sc_kbd)) {
 641                 /* let the callback function process the input */
 642                 (sc->sc_kbd.kb_callback.kc_func) (&sc->sc_kbd, KBDIO_KEYINPUT,
 643                     sc->sc_kbd.kb_callback.kc_arg);
 644         } else {
 645                 /* read and discard the input, no one is waiting for it */
 646                 do {
 647                         c = ukbd_read_char(&sc->sc_kbd, 0);
 648                 } while (c != NOKEY);
 649         }
 650 }
 651
 652 static void
 653 ukbd_timeout(void *arg)
 654 {
 655         struct ukbd_softc *sc = arg;
 656
 657         UKBD_LOCK_ASSERT();
 658
 659         sc->sc_time_ms += 25;   /* milliseconds */
 660
 661         ukbd_interrupt(sc);
 662
 663         /* Make sure any leftover key events gets read out */
 664         ukbd_event_keyinput(sc);
 665
 666         if (ukbd_any_key_pressed(sc) || (sc->sc_inputs != 0)) {
 667                 ukbd_start_timer(sc);
 668         } else {
 669                 sc->sc_flags &= ~UKBD_FLAG_TIMER_RUNNING;
 670         }
 671 }
 672
 673 static uint8_t
 674 ukbd_apple_fn(uint8_t keycode) {
 675         switch (keycode) {
 676         case 0x28: return 0x49; /* RETURN -> INSERT */
 677         case 0x2a: return 0x4c; /* BACKSPACE -> DEL */
 678         case 0x50: return 0x4a; /* LEFT ARROW -> HOME */
 679         case 0x4f: return 0x4d; /* RIGHT ARROW -> END */
 680         case 0x52: return 0x4b; /* UP ARROW -> PGUP */
 681         case 0x51: return 0x4e; /* DOWN ARROW -> PGDN */
 682         default: return keycode;
 683         }
 684 }
 685
 686 static uint8_t
 687 ukbd_apple_swap(uint8_t keycode) {
 688         switch (keycode) {
 689         case 0x35: return 0x64;
 690         case 0x64: return 0x35;
 691         default: return keycode;
 692         }
 693 }
 694
 695 static void
 696 ukbd_intr_callback(struct usb_xfer *xfer, usb_error_t error)
 697 {
 698         struct ukbd_softc *sc = usbd_xfer_softc(xfer);
 699         struct usb_page_cache *pc;
 700         uint8_t i;
 701         uint8_t offset;
 702         uint8_t id;
 703         int len;
 704
 705         UKBD_LOCK_ASSERT();
 706
 707         usbd_xfer_status(xfer, &len, NULL, NULL, NULL);
 708         pc = usbd_xfer_get_frame(xfer, 0);
 709
 710         switch (USB_GET_STATE(xfer)) {
 711         case USB_ST_TRANSFERRED:
 712                 DPRINTF("actlen=%d bytes\n", len);
 713
 714                 if (len == 0) {
 715                         DPRINTF("zero length data\n");
 716                         goto tr_setup;
 717                 }
 718
 719                 if (sc->sc_kbd_id != 0) {
 720                         /* check and remove HID ID byte */
 721                         usbd_copy_out(pc, 0, &id, 1);
 722                         offset = 1;
 723                         len--;
 724                         if (len == 0) {
 725                                 DPRINTF("zero length data\n");
 726                                 goto tr_setup;
 727                         }
 728                 } else {
 729                         offset = 0;
 730                         id = 0;
 731                 }
 732
 733                 if (len > UKBD_BUFFER_SIZE)
 734                         len = UKBD_BUFFER_SIZE;
 735
 736                 /* get data */
 737                 usbd_copy_out(pc, offset, sc->sc_buffer, len);
 738
 739                 /* clear temporary storage */
 740                 memset(&sc->sc_ndata, 0, sizeof(sc->sc_ndata));
 741
 742                 /* scan through HID data */
 743                 if ((sc->sc_flags & UKBD_FLAG_APPLE_EJECT) &&
 744                     (id == sc->sc_id_apple_eject)) {
 745                         if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_apple_eject))
 746                                 sc->sc_modifiers |= MOD_EJECT;
 747                         else
 748                                 sc->sc_modifiers &= ~MOD_EJECT;
 749                 }
 750                 if ((sc->sc_flags & UKBD_FLAG_APPLE_FN) &&
 751                     (id == sc->sc_id_apple_fn)) {
 752                         if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_apple_fn))
 753                                 sc->sc_modifiers |= MOD_FN;
 754                         else
 755                                 sc->sc_modifiers &= ~MOD_FN;
 756                 }
 757                 if ((sc->sc_flags & UKBD_FLAG_CTRL_L) &&
 758                     (id == sc->sc_id_ctrl_l)) {
 759                         if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_ctrl_l))
 760                           sc->  sc_modifiers |= MOD_CONTROL_L;
 761                         else
 762                           sc->  sc_modifiers &= ~MOD_CONTROL_L;
 763                 }
 764                 if ((sc->sc_flags & UKBD_FLAG_CTRL_R) &&
 765                     (id == sc->sc_id_ctrl_r)) {
 766                         if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_ctrl_r))
 767                                 sc->sc_modifiers |= MOD_CONTROL_R;
 768                         else
 769                                 sc->sc_modifiers &= ~MOD_CONTROL_R;
 770                 }
 771                 if ((sc->sc_flags & UKBD_FLAG_SHIFT_L) &&
 772                     (id == sc->sc_id_shift_l)) {
 773                         if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_shift_l))
 774                                 sc->sc_modifiers |= MOD_SHIFT_L;
 775                         else
 776                                 sc->sc_modifiers &= ~MOD_SHIFT_L;
 777                 }
 778                 if ((sc->sc_flags & UKBD_FLAG_SHIFT_R) &&
 779                     (id == sc->sc_id_shift_r)) {
 780                         if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_shift_r))
 781                                 sc->sc_modifiers |= MOD_SHIFT_R;
 782                         else
 783                                 sc->sc_modifiers &= ~MOD_SHIFT_R;
 784                 }
 785                 if ((sc->sc_flags & UKBD_FLAG_ALT_L) &&
 786                     (id == sc->sc_id_alt_l)) {
 787                         if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_alt_l))
 788                                 sc->sc_modifiers |= MOD_ALT_L;
 789                         else
 790                                 sc->sc_modifiers &= ~MOD_ALT_L;
 791                 }
 792                 if ((sc->sc_flags & UKBD_FLAG_ALT_R) &&
 793                     (id == sc->sc_id_alt_r)) {
 794                         if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_alt_r))
 795                                 sc->sc_modifiers |= MOD_ALT_R;
 796                         else
 797                                 sc->sc_modifiers &= ~MOD_ALT_R;
 798                 }
 799                 if ((sc->sc_flags & UKBD_FLAG_WIN_L) &&
 800                     (id == sc->sc_id_win_l)) {
 801                         if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_win_l))
 802                                 sc->sc_modifiers |= MOD_WIN_L;
 803                         else
 804                                 sc->sc_modifiers &= ~MOD_WIN_L;
 805                 }
 806                 if ((sc->sc_flags & UKBD_FLAG_WIN_R) &&
 807                     (id == sc->sc_id_win_r)) {
 808                         if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_win_r))
 809                                 sc->sc_modifiers |= MOD_WIN_R;
 810                         else
 811                                 sc->sc_modifiers &= ~MOD_WIN_R;
 812                 }
 813
 814                 sc->sc_ndata.modifiers = sc->sc_modifiers;
 815
 816                 if ((sc->sc_flags & UKBD_FLAG_EVENTS) &&
 817                     (id == sc->sc_id_events)) {
 818                         i = sc->sc_loc_events.count;
 819                         if (i > UKBD_NKEYCODE)
 820                                 i = UKBD_NKEYCODE;
 821                         if (i > len)
 822                                 i = len;
 823                         while (i--) {
 824                                 sc->sc_ndata.keycode[i] =
 825                                     hid_get_data(sc->sc_buffer + i, len - i,
 826                                     &sc->sc_loc_events);
 827                         }
 828                 }
 829
 830 #ifdef USB_DEBUG
 831                 DPRINTF("modifiers = 0x%04x\n", (int)sc->sc_modifiers);
 832                 for (i = 0; i < UKBD_NKEYCODE; i++) {
 833                         if (sc->sc_ndata.keycode[i]) {
 834                                 DPRINTF("[%d] = 0x%02x\n",
 835                                     (int)i, (int)sc->sc_ndata.keycode[i]);
 836                         }
 837                 }
 838 #endif
 839                 if (sc->sc_modifiers & MOD_FN) {
 840                         for (i = 0; i < UKBD_NKEYCODE; i++) {
 841                                 sc->sc_ndata.keycode[i] =
 842                                     ukbd_apple_fn(sc->sc_ndata.keycode[i]);
 843                         }
 844                 }
 845
 846                 if (sc->sc_flags & UKBD_FLAG_APPLE_SWAP) {
 847                         for (i = 0; i < UKBD_NKEYCODE; i++) {
 848                                 sc->sc_ndata.keycode[i] =
 849                                     ukbd_apple_swap(sc->sc_ndata.keycode[i]);
 850                         }
 851                 }
 852
 853                 ukbd_interrupt(sc);
 854
 855                 if (!(sc->sc_flags & UKBD_FLAG_TIMER_RUNNING)) {
 856                         if (ukbd_any_key_pressed(sc)) {
 857                                 ukbd_start_timer(sc);
 858                         }
 859                 }
 860
 861         case USB_ST_SETUP:
 862 tr_setup:
 863                 if (sc->sc_inputs < UKBD_IN_BUF_FULL) {
 864                         usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
 865                         usbd_transfer_submit(xfer);
 866                 } else {
 867                         DPRINTF("input queue is full!\n");
 868                 }
 869                 break;
 870
 871         default:                        /* Error */
 872                 DPRINTF("error=%s\n", usbd_errstr(error));
 873
 874                 if (error != USB_ERR_CANCELLED) {
 875                         /* try to clear stall first */
 876                         usbd_xfer_set_stall(xfer);
 877                         goto tr_setup;
 878                 }
 879                 break;
 880         }
 881 }
 882
 883 static void
 884 ukbd_set_leds_callback(struct usb_xfer *xfer, usb_error_t error)
 885 {
 886         struct ukbd_softc *sc = usbd_xfer_softc(xfer);
 887         struct usb_device_request req;
 888         struct usb_page_cache *pc;
 889         uint8_t id;
 890         uint8_t any;
 891         int len;
 892
 893         UKBD_LOCK_ASSERT();
 894
 895 #ifdef USB_DEBUG
 896         if (ukbd_no_leds)
 897                 return;
 898 #endif
 899
 900         switch (USB_GET_STATE(xfer)) {
 901         case USB_ST_TRANSFERRED:
 902         case USB_ST_SETUP:
 903                 if (!(sc->sc_flags & UKBD_FLAG_SET_LEDS))
 904                         break;
 905                 sc->sc_flags &= ~UKBD_FLAG_SET_LEDS;
 906
 907                 req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
 908                 req.bRequest = UR_SET_REPORT;
 909                 USETW2(req.wValue, UHID_OUTPUT_REPORT, 0);
 910                 req.wIndex[0] = sc->sc_iface_no;
 911                 req.wIndex[1] = 0;
 912                 req.wLength[1] = 0;
 913
 914                 memset(sc->sc_buffer, 0, UKBD_BUFFER_SIZE);
 915
 916                 id = 0;
 917                 any = 0;
 918
 919                 /* Assumption: All led bits must be in the same ID. */
 920
 921                 if (sc->sc_flags & UKBD_FLAG_NUMLOCK) {
 922                         if (sc->sc_leds & NLKED) {
 923                                 hid_put_data_unsigned(sc->sc_buffer + 1, UKBD_BUFFER_SIZE - 1,
 924                                     &sc->sc_loc_numlock, 1);
 925                         }
 926                         id = sc->sc_id_numlock;
 927                         any = 1;
 928                 }
 929
 930                 if (sc->sc_flags & UKBD_FLAG_SCROLLLOCK) {
 931                         if (sc->sc_leds & SLKED) {
 932                                 hid_put_data_unsigned(sc->sc_buffer + 1, UKBD_BUFFER_SIZE - 1,
 933                                     &sc->sc_loc_scrolllock, 1);
 934                         }
 935                         id = sc->sc_id_scrolllock;
 936                         any = 1;
 937                 }
 938
 939                 if (sc->sc_flags & UKBD_FLAG_CAPSLOCK) {
 940                         if (sc->sc_leds & CLKED) {
 941                                 hid_put_data_unsigned(sc->sc_buffer + 1, UKBD_BUFFER_SIZE - 1,
 942                                     &sc->sc_loc_capslock, 1);
 943                         }
 944                         id = sc->sc_id_capslock;
 945                         any = 1;
 946                 }
 947
 948                 /* if no leds, nothing to do */
 949                 if (!any)
 950                         break;
 951
 952                 /* range check output report length */
 953                 len = sc->sc_led_size;
 954                 if (len > (UKBD_BUFFER_SIZE - 1))
 955                         len = (UKBD_BUFFER_SIZE - 1);
 956
 957                 /* check if we need to prefix an ID byte */
 958                 sc->sc_buffer[0] = id;
 959
 960                 pc = usbd_xfer_get_frame(xfer, 1);
 961                 if (id != 0) {
 962                         len++;
 963                         usbd_copy_in(pc, 0, sc->sc_buffer, len);
 964                 } else {
 965                         usbd_copy_in(pc, 0, sc->sc_buffer + 1, len);
 966                 }
 967                 req.wLength[0] = len;
 968                 usbd_xfer_set_frame_len(xfer, 1, len);
 969
 970                 DPRINTF("len=%d, id=%d\n", len, id);
 971
 972                 /* setup control request last */
 973                 pc = usbd_xfer_get_frame(xfer, 0);
 974                 usbd_copy_in(pc, 0, &req, sizeof(req));
 975                 usbd_xfer_set_frame_len(xfer, 0, sizeof(req));
 976
 977                 /* start data transfer */
 978                 usbd_xfer_set_frames(xfer, 2);
 979                 usbd_transfer_submit(xfer);
 980                 break;
 981
 982         default:                        /* Error */
 983                 DPRINTFN(1, "error=%s\n", usbd_errstr(error));
 984                 break;
 985         }
 986 }
 987
 988 static const struct usb_config ukbd_config[UKBD_N_TRANSFER] = {
 989
 990         [UKBD_INTR_DT] = {
 991                 .type = UE_INTERRUPT,
 992                 .endpoint = UE_ADDR_ANY,
 993                 .direction = UE_DIR_IN,
 994                 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
 995                 .bufsize = 0,   /* use wMaxPacketSize */
 996                 .callback = &ukbd_intr_callback,
 997         },
 998
 999         [UKBD_CTRL_LED] = {
1000                 .type = UE_CONTROL,
1001                 .endpoint = 0x00,       /* Control pipe */
1002                 .direction = UE_DIR_ANY,
1003                 .bufsize = sizeof(struct usb_device_request) + UKBD_BUFFER_SIZE,
1004                 .callback = &ukbd_set_leds_callback,
1005                 .timeout = 1000,        /* 1 second */
1006         },
1007 };
1008
1009 /* A match on these entries will load ukbd */
1010 static const STRUCT_USB_HOST_ID __used ukbd_devs[] = {
1011         {USB_IFACE_CLASS(UICLASS_HID),
1012          USB_IFACE_SUBCLASS(UISUBCLASS_BOOT),
1013          USB_IFACE_PROTOCOL(UIPROTO_BOOT_KEYBOARD),},
1014 };
1015
1016 static int
1017 ukbd_probe(device_t dev)
1018 {
1019         keyboard_switch_t *sw = kbd_get_switch(UKBD_DRIVER_NAME);
1020         struct usb_attach_arg *uaa = device_get_ivars(dev);
1021         void *d_ptr;
1022         int error;
1023         uint16_t d_len;
1024
1025         UKBD_LOCK_ASSERT();
1026         DPRINTFN(11, "\n");
1027
1028         if (sw == NULL) {
1029                 return (ENXIO);
1030         }
1031         if (uaa->usb_mode != USB_MODE_HOST) {
1032                 return (ENXIO);
1033         }
1034
1035         if (uaa->info.bInterfaceClass != UICLASS_HID)
1036                 return (ENXIO);
1037
1038         if (usb_test_quirk(uaa, UQ_KBD_IGNORE))
1039                 return (ENXIO);
1040
1041         if ((uaa->info.bInterfaceSubClass == UISUBCLASS_BOOT) &&
1042             (uaa->info.bInterfaceProtocol == UIPROTO_BOOT_KEYBOARD))
1043                 return (BUS_PROBE_DEFAULT);
1044
1045         error = usbd_req_get_hid_desc(uaa->device, NULL,
1046             &d_ptr, &d_len, M_TEMP, uaa->info.bIfaceIndex);
1047
1048         if (error)
1049                 return (ENXIO);
1050
1051         if (hid_is_keyboard(d_ptr, d_len)) {
1052                 if (hid_is_mouse(d_ptr, d_len)) {
1053                         /*
1054                          * NOTE: We currently don't support USB mouse
1055                          * and USB keyboard on the same USB endpoint.
1056                          * Let "ums" driver win.
1057                          */
1058                         error = ENXIO;
1059                 } else {
1060                         error = BUS_PROBE_DEFAULT;
1061                 }
1062         } else {
1063                 error = ENXIO;
1064         }
1065         free(d_ptr, M_TEMP);
1066         return (error);
1067 }
1068
1069 static void
1070 ukbd_parse_hid(struct ukbd_softc *sc, const uint8_t *ptr, uint32_t len)
1071 {
1072         uint32_t flags;
1073
1074         /* reset detected bits */
1075         sc->sc_flags &= ~UKBD_FLAG_HID_MASK;
1076
1077         /* check if there is an ID byte */
1078         sc->sc_kbd_size = hid_report_size(ptr, len,
1079             hid_input, &sc->sc_kbd_id);
1080
1081         /* investigate if this is an Apple Keyboard */
1082         if (hid_locate(ptr, len,
1083             HID_USAGE2(HUP_CONSUMER, HUG_APPLE_EJECT),
1084             hid_input, 0, &sc->sc_loc_apple_eject, &flags,
1085             &sc->sc_id_apple_eject)) {
1086                 if (flags & HIO_VARIABLE)
1087                         sc->sc_flags |= UKBD_FLAG_APPLE_EJECT |
1088                             UKBD_FLAG_APPLE_SWAP;
1089                 DPRINTFN(1, "Found Apple eject-key\n");
1090         }
1091         if (hid_locate(ptr, len,
1092             HID_USAGE2(0xFFFF, 0x0003),
1093             hid_input, 0, &sc->sc_loc_apple_fn, &flags,
1094             &sc->sc_id_apple_fn)) {
1095                 if (flags & HIO_VARIABLE)
1096                         sc->sc_flags |= UKBD_FLAG_APPLE_FN;
1097                 DPRINTFN(1, "Found Apple FN-key\n");
1098         }
1099         /* figure out some keys */
1100         if (hid_locate(ptr, len,
1101             HID_USAGE2(HUP_KEYBOARD, 0xE0),
1102             hid_input, 0, &sc->sc_loc_ctrl_l, &flags,
1103             &sc->sc_id_ctrl_l)) {
1104                 if (flags & HIO_VARIABLE)
1105                         sc->sc_flags |= UKBD_FLAG_CTRL_L;
1106                 DPRINTFN(1, "Found left control\n");
1107         }
1108         if (hid_locate(ptr, len,
1109             HID_USAGE2(HUP_KEYBOARD, 0xE4),
1110             hid_input, 0, &sc->sc_loc_ctrl_r, &flags,
1111             &sc->sc_id_ctrl_r)) {
1112                 if (flags & HIO_VARIABLE)
1113                         sc->sc_flags |= UKBD_FLAG_CTRL_R;
1114                 DPRINTFN(1, "Found right control\n");
1115         }
1116         if (hid_locate(ptr, len,
1117             HID_USAGE2(HUP_KEYBOARD, 0xE1),
1118             hid_input, 0, &sc->sc_loc_shift_l, &flags,
1119             &sc->sc_id_shift_l)) {
1120                 if (flags & HIO_VARIABLE)
1121                         sc->sc_flags |= UKBD_FLAG_SHIFT_L;
1122                 DPRINTFN(1, "Found left shift\n");
1123         }
1124         if (hid_locate(ptr, len,
1125             HID_USAGE2(HUP_KEYBOARD, 0xE5),
1126             hid_input, 0, &sc->sc_loc_shift_r, &flags,
1127             &sc->sc_id_shift_r)) {
1128                 if (flags & HIO_VARIABLE)
1129                         sc->sc_flags |= UKBD_FLAG_SHIFT_R;
1130                 DPRINTFN(1, "Found right shift\n");
1131         }
1132         if (hid_locate(ptr, len,
1133             HID_USAGE2(HUP_KEYBOARD, 0xE2),
1134             hid_input, 0, &sc->sc_loc_alt_l, &flags,
1135             &sc->sc_id_alt_l)) {
1136                 if (flags & HIO_VARIABLE)
1137                         sc->sc_flags |= UKBD_FLAG_ALT_L;
1138                 DPRINTFN(1, "Found left alt\n");
1139         }
1140         if (hid_locate(ptr, len,
1141             HID_USAGE2(HUP_KEYBOARD, 0xE6),
1142             hid_input, 0, &sc->sc_loc_alt_r, &flags,
1143             &sc->sc_id_alt_r)) {
1144                 if (flags & HIO_VARIABLE)
1145                         sc->sc_flags |= UKBD_FLAG_ALT_R;
1146                 DPRINTFN(1, "Found right alt\n");
1147         }
1148         if (hid_locate(ptr, len,
1149             HID_USAGE2(HUP_KEYBOARD, 0xE3),
1150             hid_input, 0, &sc->sc_loc_win_l, &flags,
1151             &sc->sc_id_win_l)) {
1152                 if (flags & HIO_VARIABLE)
1153                         sc->sc_flags |= UKBD_FLAG_WIN_L;
1154                 DPRINTFN(1, "Found left GUI\n");
1155         }
1156         if (hid_locate(ptr, len,
1157             HID_USAGE2(HUP_KEYBOARD, 0xE7),
1158             hid_input, 0, &sc->sc_loc_win_r, &flags,
1159             &sc->sc_id_win_r)) {
1160                 if (flags & HIO_VARIABLE)
1161                         sc->sc_flags |= UKBD_FLAG_WIN_R;
1162                 DPRINTFN(1, "Found right GUI\n");
1163         }
1164         /* figure out event buffer */
1165         if (hid_locate(ptr, len,
1166             HID_USAGE2(HUP_KEYBOARD, 0x00),
1167             hid_input, 0, &sc->sc_loc_events, &flags,
1168             &sc->sc_id_events)) {
1169                 if (flags & HIO_VARIABLE) {
1170                         DPRINTFN(1, "Ignoring keyboard event control\n");
1171                 } else {
1172                         sc->sc_flags |= UKBD_FLAG_EVENTS;
1173                         DPRINTFN(1, "Found keyboard event array\n");
1174                 }
1175         }
1176
1177         /* figure out leds on keyboard */
1178         sc->sc_led_size = hid_report_size(ptr, len,
1179             hid_output, NULL);
1180
1181         if (hid_locate(ptr, len,
1182             HID_USAGE2(HUP_LEDS, 0x01),
1183             hid_output, 0, &sc->sc_loc_numlock, &flags,
1184             &sc->sc_id_numlock)) {
1185                 if (flags & HIO_VARIABLE)
1186                         sc->sc_flags |= UKBD_FLAG_NUMLOCK;
1187                 DPRINTFN(1, "Found keyboard numlock\n");
1188         }
1189         if (hid_locate(ptr, len,
1190             HID_USAGE2(HUP_LEDS, 0x02),
1191             hid_output, 0, &sc->sc_loc_capslock, &flags,
1192             &sc->sc_id_capslock)) {
1193                 if (flags & HIO_VARIABLE)
1194                         sc->sc_flags |= UKBD_FLAG_CAPSLOCK;
1195                 DPRINTFN(1, "Found keyboard capslock\n");
1196         }
1197         if (hid_locate(ptr, len,
1198             HID_USAGE2(HUP_LEDS, 0x03),
1199             hid_output, 0, &sc->sc_loc_scrolllock, &flags,
1200             &sc->sc_id_scrolllock)) {
1201                 if (flags & HIO_VARIABLE)
1202                         sc->sc_flags |= UKBD_FLAG_SCROLLLOCK;
1203                 DPRINTFN(1, "Found keyboard scrolllock\n");
1204         }
1205 }
1206
1207 static int
1208 ukbd_attach(device_t dev)
1209 {
1210         struct ukbd_softc *sc = device_get_softc(dev);
1211         struct usb_attach_arg *uaa = device_get_ivars(dev);
1212         int unit = device_get_unit(dev);
1213         keyboard_t *kbd = &sc->sc_kbd;
1214         void *hid_ptr = NULL;
1215         usb_error_t err;
1216         uint16_t n;
1217         uint16_t hid_len;
1218 #ifdef USB_DEBUG
1219         int rate;
1220 #endif
1221         UKBD_LOCK_ASSERT();
1222
1223         kbd_init_struct(kbd, UKBD_DRIVER_NAME, KB_OTHER, unit, 0, 0, 0);
1224
1225         kbd->kb_data = (void *)sc;
1226
1227         device_set_usb_desc(dev);
1228
1229         sc->sc_udev = uaa->device;
1230         sc->sc_iface = uaa->iface;
1231         sc->sc_iface_index = uaa->info.bIfaceIndex;
1232         sc->sc_iface_no = uaa->info.bIfaceNum;
1233         sc->sc_mode = K_XLATE;
1234
1235         usb_callout_init_mtx(&sc->sc_callout, &Giant, 0);
1236
1237         err = usbd_transfer_setup(uaa->device,
1238             &uaa->info.bIfaceIndex, sc->sc_xfer, ukbd_config,
1239             UKBD_N_TRANSFER, sc, &Giant);
1240
1241         if (err) {
1242                 DPRINTF("error=%s\n", usbd_errstr(err));
1243                 goto detach;
1244         }
1245         /* setup default keyboard maps */
1246
1247         sc->sc_keymap = key_map;
1248         sc->sc_accmap = accent_map;
1249         for (n = 0; n < UKBD_NFKEY; n++) {
1250                 sc->sc_fkeymap[n] = fkey_tab[n];
1251         }
1252
1253         kbd_set_maps(kbd, &sc->sc_keymap, &sc->sc_accmap,
1254             sc->sc_fkeymap, UKBD_NFKEY);
1255
1256         KBD_FOUND_DEVICE(kbd);
1257
1258         ukbd_clear_state(kbd);
1259
1260         /*
1261          * FIXME: set the initial value for lock keys in "sc_state"
1262          * according to the BIOS data?
1263          */
1264         KBD_PROBE_DONE(kbd);
1265
1266         /* get HID descriptor */
1267         err = usbd_req_get_hid_desc(uaa->device, NULL, &hid_ptr,
1268             &hid_len, M_TEMP, uaa->info.bIfaceIndex);
1269
1270         if (err == 0) {
1271                 DPRINTF("Parsing HID descriptor of %d bytes\n",
1272                     (int)hid_len);
1273
1274                 ukbd_parse_hid(sc, hid_ptr, hid_len);
1275
1276                 free(hid_ptr, M_TEMP);
1277         }
1278
1279         /* check if we should use the boot protocol */
1280         if (usb_test_quirk(uaa, UQ_KBD_BOOTPROTO) ||
1281             (err != 0) || (!(sc->sc_flags & UKBD_FLAG_EVENTS))) {
1282
1283                 DPRINTF("Forcing boot protocol\n");
1284
1285                 err = usbd_req_set_protocol(sc->sc_udev, NULL,
1286                         sc->sc_iface_index, 0);
1287
1288                 if (err != 0) {
1289                         DPRINTF("Set protocol error=%s (ignored)\n",
1290                             usbd_errstr(err));
1291                 }
1292
1293                 ukbd_parse_hid(sc, ukbd_boot_desc, sizeof(ukbd_boot_desc));
1294         }
1295
1296         /* ignore if SETIDLE fails, hence it is not crucial */
1297         usbd_req_set_idle(sc->sc_udev, NULL, sc->sc_iface_index, 0, 0);
1298
1299         ukbd_ioctl(kbd, KDSETLED, (caddr_t)&sc->sc_state);
1300
1301         KBD_INIT_DONE(kbd);
1302
1303         if (kbd_register(kbd) < 0) {
1304                 goto detach;
1305         }
1306         KBD_CONFIG_DONE(kbd);
1307
1308         ukbd_enable(kbd);
1309
1310 #ifdef KBD_INSTALL_CDEV
1311         if (kbd_attach(kbd)) {
1312                 goto detach;
1313         }
1314 #endif
1315         sc->sc_flags |= UKBD_FLAG_ATTACHED;
1316
1317         if (bootverbose) {
1318                 genkbd_diag(kbd, bootverbose);
1319         }
1320
1321 #ifdef USB_DEBUG
1322         /* check for polling rate override */
1323         rate = ukbd_pollrate;
1324         if (rate > 0) {
1325                 if (rate > 1000)
1326                         rate = 1;
1327                 else
1328                         rate = 1000 / rate;
1329
1330                 /* set new polling interval in ms */
1331                 usbd_xfer_set_interval(sc->sc_xfer[UKBD_INTR_DT], rate);
1332         }
1333 #endif
1334         /* start the keyboard */
1335         usbd_transfer_start(sc->sc_xfer[UKBD_INTR_DT]);
1336
1337         return (0);                     /* success */
1338
1339 detach:
1340         ukbd_detach(dev);
1341         return (ENXIO);                 /* error */
1342 }
1343
1344 static int
1345 ukbd_detach(device_t dev)
1346 {
1347         struct ukbd_softc *sc = device_get_softc(dev);
1348         int error;
1349
1350         UKBD_LOCK_ASSERT();
1351
1352         DPRINTF("\n");
1353
1354         sc->sc_flags |= UKBD_FLAG_GONE;
1355
1356         usb_callout_stop(&sc->sc_callout);
1357
1358         ukbd_disable(&sc->sc_kbd);
1359
1360 #ifdef KBD_INSTALL_CDEV
1361         if (sc->sc_flags & UKBD_FLAG_ATTACHED) {
1362                 error = kbd_detach(&sc->sc_kbd);
1363                 if (error) {
1364                         /* usb attach cannot return an error */
1365                         device_printf(dev, "WARNING: kbd_detach() "
1366                             "returned non-zero! (ignored)\n");
1367                 }
1368         }
1369 #endif
1370         if (KBD_IS_CONFIGURED(&sc->sc_kbd)) {
1371                 error = kbd_unregister(&sc->sc_kbd);
1372                 if (error) {
1373                         /* usb attach cannot return an error */
1374                         device_printf(dev, "WARNING: kbd_unregister() "
1375                             "returned non-zero! (ignored)\n");
1376                 }
1377         }
1378         sc->sc_kbd.kb_flags = 0;
1379
1380         usbd_transfer_unsetup(sc->sc_xfer, UKBD_N_TRANSFER);
1381
1382         usb_callout_drain(&sc->sc_callout);
1383
1384         DPRINTF("%s: disconnected\n",
1385             device_get_nameunit(dev));
1386
1387         return (0);
1388 }
1389
1390 static int
1391 ukbd_resume(device_t dev)
1392 {
1393         struct ukbd_softc *sc = device_get_softc(dev);
1394
1395         UKBD_LOCK_ASSERT();
1396
1397         ukbd_clear_state(&sc->sc_kbd);
1398
1399         return (0);
1400 }
1401
1402 /* early keyboard probe, not supported */
1403 static int
1404 ukbd_configure(int flags)
1405 {
1406         return (0);
1407 }
1408
1409 /* detect a keyboard, not used */
1410 static int
1411 ukbd__probe(int unit, void *arg, int flags)
1412 {
1413         return (ENXIO);
1414 }
1415
1416 /* reset and initialize the device, not used */
1417 static int
1418 ukbd_init(int unit, keyboard_t **kbdp, void *arg, int flags)
1419 {
1420         return (ENXIO);
1421 }
1422
1423 /* test the interface to the device, not used */
1424 static int
1425 ukbd_test_if(keyboard_t *kbd)
1426 {
1427         return (0);
1428 }
1429
1430 /* finish using this keyboard, not used */
1431 static int
1432 ukbd_term(keyboard_t *kbd)
1433 {
1434         return (ENXIO);
1435 }
1436
1437 /* keyboard interrupt routine, not used */
1438 static int
1439 ukbd_intr(keyboard_t *kbd, void *arg)
1440 {
1441         return (0);
1442 }
1443
1444 /* lock the access to the keyboard, not used */
1445 static int
1446 ukbd_lock(keyboard_t *kbd, int lock)
1447 {
1448         return (1);
1449 }
1450
1451 /*
1452  * Enable the access to the device; until this function is called,
1453  * the client cannot read from the keyboard.
1454  */
1455 static int
1456 ukbd_enable(keyboard_t *kbd)
1457 {
1458
1459         UKBD_LOCK();
1460         KBD_ACTIVATE(kbd);
1461         UKBD_UNLOCK();
1462
1463         return (0);
1464 }
1465
1466 /* disallow the access to the device */
1467 static int
1468 ukbd_disable(keyboard_t *kbd)
1469 {
1470
1471         UKBD_LOCK();
1472         KBD_DEACTIVATE(kbd);
1473         UKBD_UNLOCK();
1474
1475         return (0);
1476 }
1477
1478 /* check if data is waiting */
1479 /* Currently unused. */
1480 static int
1481 ukbd_check(keyboard_t *kbd)
1482 {
1483         struct ukbd_softc *sc = kbd->kb_data;
1484
1485         UKBD_CTX_LOCK_ASSERT();
1486
1487         if (!KBD_IS_ACTIVE(kbd))
1488                 return (0);
1489
1490         if (sc->sc_flags & UKBD_FLAG_POLLING)
1491                 ukbd_do_poll(sc, 0);
1492
1493 #ifdef UKBD_EMULATE_ATSCANCODE
1494         if (sc->sc_buffered_char[0]) {
1495                 return (1);
1496         }
1497 #endif
1498         if (sc->sc_inputs > 0) {
1499                 return (1);
1500         }
1501         return (0);
1502 }
1503
1504 /* check if char is waiting */
1505 static int
1506 ukbd_check_char_locked(keyboard_t *kbd)
1507 {
1508         struct ukbd_softc *sc = kbd->kb_data;
1509
1510         UKBD_CTX_LOCK_ASSERT();
1511
1512         if (!KBD_IS_ACTIVE(kbd))
1513                 return (0);
1514
1515         if ((sc->sc_composed_char > 0) &&
1516             (!(sc->sc_flags & UKBD_FLAG_COMPOSE))) {
1517                 return (1);
1518         }
1519         return (ukbd_check(kbd));
1520 }
1521
1522 static int
1523 ukbd_check_char(keyboard_t *kbd)
1524 {
1525         int result;
1526
1527         UKBD_LOCK();
1528         result = ukbd_check_char_locked(kbd);
1529         UKBD_UNLOCK();
1530
1531         return (result);
1532 }
1533
1534 /* read one byte from the keyboard if it's allowed */
1535 /* Currently unused. */
1536 static int
1537 ukbd_read(keyboard_t *kbd, int wait)
1538 {
1539         struct ukbd_softc *sc = kbd->kb_data;
1540         int32_t usbcode;
1541 #ifdef UKBD_EMULATE_ATSCANCODE
1542         uint32_t keycode;
1543         uint32_t scancode;
1544
1545 #endif
1546
1547         UKBD_CTX_LOCK_ASSERT();
1548
1549         if (!KBD_IS_ACTIVE(kbd))
1550                 return (-1);
1551
1552 #ifdef UKBD_EMULATE_ATSCANCODE
1553         if (sc->sc_buffered_char[0]) {
1554                 scancode = sc->sc_buffered_char[0];
1555                 if (scancode & SCAN_PREFIX) {
1556                         sc->sc_buffered_char[0] &= ~SCAN_PREFIX;
1557                         return ((scancode & SCAN_PREFIX_E0) ? 0xe0 : 0xe1);
1558                 }
1559                 sc->sc_buffered_char[0] = sc->sc_buffered_char[1];
1560                 sc->sc_buffered_char[1] = 0;
1561                 return (scancode);
1562         }
1563 #endif                                  /* UKBD_EMULATE_ATSCANCODE */
1564
1565         /* XXX */
1566         usbcode = ukbd_get_key(sc, (wait == FALSE) ? 0 : 1);
1567         if (!KBD_IS_ACTIVE(kbd) || (usbcode == -1))
1568                 return (-1);
1569
1570         ++(kbd->kb_count);
1571
1572 #ifdef UKBD_EMULATE_ATSCANCODE
1573         keycode = ukbd_trtab[KEY_INDEX(usbcode)];
1574         if (keycode == NN) {
1575                 return -1;
1576         }
1577         return (ukbd_key2scan(sc, keycode, sc->sc_ndata.modifiers,
1578             (usbcode & KEY_RELEASE)));
1579 #else                                   /* !UKBD_EMULATE_ATSCANCODE */
1580         return (usbcode);
1581 #endif                                  /* UKBD_EMULATE_ATSCANCODE */
1582 }
1583
1584 /* read char from the keyboard */
1585 static uint32_t
1586 ukbd_read_char_locked(keyboard_t *kbd, int wait)
1587 {
1588         struct ukbd_softc *sc = kbd->kb_data;
1589         uint32_t action;
1590         uint32_t keycode;
1591         int32_t usbcode;
1592 #ifdef UKBD_EMULATE_ATSCANCODE
1593         uint32_t scancode;
1594 #endif
1595
1596         UKBD_CTX_LOCK_ASSERT();
1597
1598         if (!KBD_IS_ACTIVE(kbd))
1599                 return (NOKEY);
1600
1601 next_code:
1602
1603         /* do we have a composed char to return ? */
1604
1605         if ((sc->sc_composed_char > 0) &&
1606             (!(sc->sc_flags & UKBD_FLAG_COMPOSE))) {
1607
1608                 action = sc->sc_composed_char;
1609                 sc->sc_composed_char = 0;
1610
1611                 if (action > 0xFF) {
1612                         goto errkey;
1613                 }
1614                 goto done;
1615         }
1616 #ifdef UKBD_EMULATE_ATSCANCODE
1617
1618         /* do we have a pending raw scan code? */
1619
1620         if (sc->sc_mode == K_RAW) {
1621                 scancode = sc->sc_buffered_char[0];
1622                 if (scancode) {
1623                         if (scancode & SCAN_PREFIX) {
1624                                 sc->sc_buffered_char[0] = (scancode & ~SCAN_PREFIX);
1625                                 return ((scancode & SCAN_PREFIX_E0) ? 0xe0 : 0xe1);
1626                         }
1627                         sc->sc_buffered_char[0] = sc->sc_buffered_char[1];
1628                         sc->sc_buffered_char[1] = 0;
1629                         return (scancode);
1630                 }
1631         }
1632 #endif                                  /* UKBD_EMULATE_ATSCANCODE */
1633
1634         /* see if there is something in the keyboard port */
1635         /* XXX */
1636         usbcode = ukbd_get_key(sc, (wait == FALSE) ? 0 : 1);
1637         if (usbcode == -1) {
1638                 return (NOKEY);
1639         }
1640         ++kbd->kb_count;
1641
1642 #ifdef UKBD_EMULATE_ATSCANCODE
1643         /* USB key index -> key code -> AT scan code */
1644         keycode = ukbd_trtab[KEY_INDEX(usbcode)];
1645         if (keycode == NN) {
1646                 return (NOKEY);
1647         }
1648         /* return an AT scan code for the K_RAW mode */
1649         if (sc->sc_mode == K_RAW) {
1650                 return (ukbd_key2scan(sc, keycode, sc->sc_ndata.modifiers,
1651                     (usbcode & KEY_RELEASE)));
1652         }
1653 #else                                   /* !UKBD_EMULATE_ATSCANCODE */
1654
1655         /* return the byte as is for the K_RAW mode */
1656         if (sc->sc_mode == K_RAW) {
1657                 return (usbcode);
1658         }
1659         /* USB key index -> key code */
1660         keycode = ukbd_trtab[KEY_INDEX(usbcode)];
1661         if (keycode == NN) {
1662                 return (NOKEY);
1663         }
1664 #endif                                  /* UKBD_EMULATE_ATSCANCODE */
1665
1666         switch (keycode) {
1667         case 0x38:                      /* left alt (compose key) */
1668                 if (usbcode & KEY_RELEASE) {
1669                         if (sc->sc_flags & UKBD_FLAG_COMPOSE) {
1670                                 sc->sc_flags &= ~UKBD_FLAG_COMPOSE;
1671
1672                                 if (sc->sc_composed_char > 0xFF) {
1673                                         sc->sc_composed_char = 0;
1674                                 }
1675                         }
1676                 } else {
1677                         if (!(sc->sc_flags & UKBD_FLAG_COMPOSE)) {
1678                                 sc->sc_flags |= UKBD_FLAG_COMPOSE;
1679                                 sc->sc_composed_char = 0;
1680                         }
1681                 }
1682                 break;
1683                 /* XXX: I don't like these... */
1684         case 0x5c:                      /* print screen */
1685                 if (sc->sc_flags & ALTS) {
1686                         keycode = 0x54; /* sysrq */
1687                 }
1688                 break;
1689         case 0x68:                      /* pause/break */
1690                 if (sc->sc_flags & CTLS) {
1691                         keycode = 0x6c; /* break */
1692                 }
1693                 break;
1694         }
1695
1696         /* return the key code in the K_CODE mode */
1697         if (usbcode & KEY_RELEASE) {
1698                 keycode |= SCAN_RELEASE;
1699         }
1700         if (sc->sc_mode == K_CODE) {
1701                 return (keycode);
1702         }
1703         /* compose a character code */
1704         if (sc->sc_flags & UKBD_FLAG_COMPOSE) {
1705                 switch (keycode) {
1706                         /* key pressed, process it */
1707                 case 0x47:
1708                 case 0x48:
1709                 case 0x49:              /* keypad 7,8,9 */
1710                         sc->sc_composed_char *= 10;
1711                         sc->sc_composed_char += keycode - 0x40;
1712                         goto check_composed;
1713
1714                 case 0x4B:
1715                 case 0x4C:
1716                 case 0x4D:              /* keypad 4,5,6 */
1717                         sc->sc_composed_char *= 10;
1718                         sc->sc_composed_char += keycode - 0x47;
1719                         goto check_composed;
1720
1721                 case 0x4F:
1722                 case 0x50:
1723                 case 0x51:              /* keypad 1,2,3 */
1724                         sc->sc_composed_char *= 10;
1725                         sc->sc_composed_char += keycode - 0x4E;
1726                         goto check_composed;
1727
1728                 case 0x52:              /* keypad 0 */
1729                         sc->sc_composed_char *= 10;
1730                         goto check_composed;
1731
1732                         /* key released, no interest here */
1733                 case SCAN_RELEASE | 0x47:
1734                 case SCAN_RELEASE | 0x48:
1735                 case SCAN_RELEASE | 0x49:       /* keypad 7,8,9 */
1736                 case SCAN_RELEASE | 0x4B:
1737                 case SCAN_RELEASE | 0x4C:
1738                 case SCAN_RELEASE | 0x4D:       /* keypad 4,5,6 */
1739                 case SCAN_RELEASE | 0x4F:
1740                 case SCAN_RELEASE | 0x50:
1741                 case SCAN_RELEASE | 0x51:       /* keypad 1,2,3 */
1742                 case SCAN_RELEASE | 0x52:       /* keypad 0 */
1743                         goto next_code;
1744
1745                 case 0x38:              /* left alt key */
1746                         break;
1747
1748                 default:
1749                         if (sc->sc_composed_char > 0) {
1750                                 sc->sc_flags &= ~UKBD_FLAG_COMPOSE;
1751                                 sc->sc_composed_char = 0;
1752                                 goto errkey;
1753                         }
1754                         break;
1755                 }
1756         }
1757         /* keycode to key action */
1758         action = genkbd_keyaction(kbd, SCAN_CHAR(keycode),
1759             (keycode & SCAN_RELEASE),
1760             &sc->sc_state, &sc->sc_accents);
1761         if (action == NOKEY) {
1762                 goto next_code;
1763         }
1764 done:
1765         return (action);
1766
1767 check_composed:
1768         if (sc->sc_composed_char <= 0xFF) {
1769                 goto next_code;
1770         }
1771 errkey:
1772         return (ERRKEY);
1773 }
1774
1775 /* Currently wait is always false. */
1776 static uint32_t
1777 ukbd_read_char(keyboard_t *kbd, int wait)
1778 {
1779         uint32_t keycode;
1780
1781         UKBD_LOCK();
1782         keycode = ukbd_read_char_locked(kbd, wait);
1783         UKBD_UNLOCK();
1784
1785         return (keycode);
1786 }
1787
1788 /* some useful control functions */
1789 static int
1790 ukbd_ioctl_locked(keyboard_t *kbd, u_long cmd, caddr_t arg)
1791 {
1792         struct ukbd_softc *sc = kbd->kb_data;
1793         int i;
1794 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
1795     defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
1796         int ival;
1797
1798 #endif
1799
1800         UKBD_LOCK_ASSERT();
1801
1802         switch (cmd) {
1803         case KDGKBMODE:         /* get keyboard mode */
1804                 *(int *)arg = sc->sc_mode;
1805                 break;
1806 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
1807     defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
1808         case _IO('K', 7):
1809                 ival = IOCPARM_IVAL(arg);
1810                 arg = (caddr_t)&ival;
1811                 /* FALLTHROUGH */
1812 #endif
1813         case KDSKBMODE:         /* set keyboard mode */
1814                 switch (*(int *)arg) {
1815                 case K_XLATE:
1816                         if (sc->sc_mode != K_XLATE) {
1817                                 /* make lock key state and LED state match */
1818                                 sc->sc_state &= ~LOCK_MASK;
1819                                 sc->sc_state |= KBD_LED_VAL(kbd);
1820                         }
1821                         /* FALLTHROUGH */
1822                 case K_RAW:
1823                 case K_CODE:
1824                         if (sc->sc_mode != *(int *)arg) {
1825                                 if ((sc->sc_flags & UKBD_FLAG_POLLING) == 0)
1826                                         ukbd_clear_state(kbd);
1827                                 sc->sc_mode = *(int *)arg;
1828                         }
1829                         break;
1830                 default:
1831                         return (EINVAL);
1832                 }
1833                 break;
1834
1835         case KDGETLED:                  /* get keyboard LED */
1836                 *(int *)arg = KBD_LED_VAL(kbd);
1837                 break;
1838 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
1839     defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
1840         case _IO('K', 66):
1841                 ival = IOCPARM_IVAL(arg);
1842                 arg = (caddr_t)&ival;
1843                 /* FALLTHROUGH */
1844 #endif
1845         case KDSETLED:                  /* set keyboard LED */
1846                 /* NOTE: lock key state in "sc_state" won't be changed */
1847                 if (*(int *)arg & ~LOCK_MASK)
1848                         return (EINVAL);
1849
1850                 i = *(int *)arg;
1851
1852                 /* replace CAPS LED with ALTGR LED for ALTGR keyboards */
1853                 if (sc->sc_mode == K_XLATE &&
1854                     kbd->kb_keymap->n_keys > ALTGR_OFFSET) {
1855                         if (i & ALKED)
1856                                 i |= CLKED;
1857                         else
1858                                 i &= ~CLKED;
1859                 }
1860                 if (KBD_HAS_DEVICE(kbd))
1861                         ukbd_set_leds(sc, i);
1862
1863                 KBD_LED_VAL(kbd) = *(int *)arg;
1864                 break;
1865         case KDGKBSTATE:                /* get lock key state */
1866                 *(int *)arg = sc->sc_state & LOCK_MASK;
1867                 break;
1868 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
1869     defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
1870         case _IO('K', 20):
1871                 ival = IOCPARM_IVAL(arg);
1872                 arg = (caddr_t)&ival;
1873                 /* FALLTHROUGH */
1874 #endif
1875         case KDSKBSTATE:                /* set lock key state */
1876                 if (*(int *)arg & ~LOCK_MASK) {
1877                         return (EINVAL);
1878                 }
1879                 sc->sc_state &= ~LOCK_MASK;
1880                 sc->sc_state |= *(int *)arg;
1881
1882                 /* set LEDs and quit */
1883                 return (ukbd_ioctl(kbd, KDSETLED, arg));
1884
1885         case KDSETREPEAT:               /* set keyboard repeat rate (new
1886                                          * interface) */
1887                 if (!KBD_HAS_DEVICE(kbd)) {
1888                         return (0);
1889                 }
1890                 if (((int *)arg)[1] < 0) {
1891                         return (EINVAL);
1892                 }
1893                 if (((int *)arg)[0] < 0) {
1894                         return (EINVAL);
1895                 }
1896                 if (((int *)arg)[0] < 200)      /* fastest possible value */
1897                         kbd->kb_delay1 = 200;
1898                 else
1899                         kbd->kb_delay1 = ((int *)arg)[0];
1900                 kbd->kb_delay2 = ((int *)arg)[1];
1901                 return (0);
1902
1903 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
1904     defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
1905         case _IO('K', 67):
1906                 ival = IOCPARM_IVAL(arg);
1907                 arg = (caddr_t)&ival;
1908                 /* FALLTHROUGH */
1909 #endif
1910         case KDSETRAD:                  /* set keyboard repeat rate (old
1911                                          * interface) */
1912                 return (ukbd_set_typematic(kbd, *(int *)arg));
1913
1914         case PIO_KEYMAP:                /* set keyboard translation table */
1915         case OPIO_KEYMAP:               /* set keyboard translation table
1916                                          * (compat) */
1917         case PIO_KEYMAPENT:             /* set keyboard translation table
1918                                          * entry */
1919         case PIO_DEADKEYMAP:            /* set accent key translation table */
1920                 sc->sc_accents = 0;
1921                 /* FALLTHROUGH */
1922         default:
1923                 return (genkbd_commonioctl(kbd, cmd, arg));
1924         }
1925
1926         return (0);
1927 }
1928
1929 static int
1930 ukbd_ioctl(keyboard_t *kbd, u_long cmd, caddr_t arg)
1931 {
1932         int result;
1933
1934         /*
1935          * XXX KDGKBSTATE, KDSKBSTATE and KDSETLED can be called from any
1936          * context where printf(9) can be called, which among other things
1937          * includes interrupt filters and threads with any kinds of locks
1938          * already held.  For this reason it would be dangerous to acquire
1939          * the Giant here unconditionally.  On the other hand we have to
1940          * have it to handle the ioctl.
1941          * So we make our best effort to auto-detect whether we can grab
1942          * the Giant or not.  Blame syscons(4) for this.
1943          */
1944         switch (cmd) {
1945         case KDGKBSTATE:
1946         case KDSKBSTATE:
1947         case KDSETLED:
1948                 if (!mtx_owned(&Giant) && !SCHEDULER_STOPPED())
1949                         return (EDEADLK);       /* best I could come up with */
1950                 /* FALLTHROUGH */
1951         default:
1952                 UKBD_LOCK();
1953                 result = ukbd_ioctl_locked(kbd, cmd, arg);
1954                 UKBD_UNLOCK();
1955                 return (result);
1956         }
1957 }
1958
1959
1960 /* clear the internal state of the keyboard */
1961 static void
1962 ukbd_clear_state(keyboard_t *kbd)
1963 {
1964         struct ukbd_softc *sc = kbd->kb_data;
1965
1966         UKBD_CTX_LOCK_ASSERT();
1967
1968         sc->sc_flags &= ~(UKBD_FLAG_COMPOSE | UKBD_FLAG_POLLING);
1969         sc->sc_state &= LOCK_MASK;      /* preserve locking key state */
1970         sc->sc_accents = 0;
1971         sc->sc_composed_char = 0;
1972 #ifdef UKBD_EMULATE_ATSCANCODE
1973         sc->sc_buffered_char[0] = 0;
1974         sc->sc_buffered_char[1] = 0;
1975 #endif
1976         memset(&sc->sc_ndata, 0, sizeof(sc->sc_ndata));
1977         memset(&sc->sc_odata, 0, sizeof(sc->sc_odata));
1978         memset(&sc->sc_ntime, 0, sizeof(sc->sc_ntime));
1979         memset(&sc->sc_otime, 0, sizeof(sc->sc_otime));
1980 }
1981
1982 /* save the internal state, not used */
1983 static int
1984 ukbd_get_state(keyboard_t *kbd, void *buf, size_t len)
1985 {
1986         return (len == 0) ? 1 : -1;
1987 }
1988
1989 /* set the internal state, not used */
1990 static int
1991 ukbd_set_state(keyboard_t *kbd, void *buf, size_t len)
1992 {
1993         return (EINVAL);
1994 }
1995
1996 static int
1997 ukbd_poll(keyboard_t *kbd, int on)
1998 {
1999         struct ukbd_softc *sc = kbd->kb_data;
2000
2001         UKBD_LOCK();
2002         if (on) {
2003                 sc->sc_flags |= UKBD_FLAG_POLLING;
2004                 sc->sc_poll_thread = curthread;
2005         } else {
2006                 sc->sc_flags &= ~UKBD_FLAG_POLLING;
2007                 ukbd_start_timer(sc);   /* start timer */
2008         }
2009         UKBD_UNLOCK();
2010
2011         return (0);
2012 }
2013
2014 /* local functions */
2015
2016 static void
2017 ukbd_set_leds(struct ukbd_softc *sc, uint8_t leds)
2018 {
2019
2020         UKBD_LOCK_ASSERT();
2021         DPRINTF("leds=0x%02x\n", leds);
2022
2023         sc->sc_leds = leds;
2024         sc->sc_flags |= UKBD_FLAG_SET_LEDS;
2025
2026         /* start transfer, if not already started */
2027
2028         usbd_transfer_start(sc->sc_xfer[UKBD_CTRL_LED]);
2029 }
2030
2031 static int
2032 ukbd_set_typematic(keyboard_t *kbd, int code)
2033 {
2034         static const int delays[] = {250, 500, 750, 1000};
2035         static const int rates[] = {34, 38, 42, 46, 50, 55, 59, 63,
2036                 68, 76, 84, 92, 100, 110, 118, 126,
2037                 136, 152, 168, 184, 200, 220, 236, 252,
2038         272, 304, 336, 368, 400, 440, 472, 504};
2039
2040         if (code & ~0x7f) {
2041                 return (EINVAL);
2042         }
2043         kbd->kb_delay1 = delays[(code >> 5) & 3];
2044         kbd->kb_delay2 = rates[code & 0x1f];
2045         return (0);
2046 }
2047
2048 #ifdef UKBD_EMULATE_ATSCANCODE
2049 static int
2050 ukbd_key2scan(struct ukbd_softc *sc, int code, int shift, int up)
2051 {
2052         static const int scan[] = {
2053                 /* 89 */
2054                 0x11c,  /* Enter */
2055                 /* 90-99 */
2056                 0x11d,  /* Ctrl-R */
2057                 0x135,  /* Divide */
2058                 0x137 | SCAN_PREFIX_SHIFT,      /* PrintScreen */
2059                 0x138,  /* Alt-R */
2060                 0x147,  /* Home */
2061                 0x148,  /* Up */
2062                 0x149,  /* PageUp */
2063                 0x14b,  /* Left */
2064                 0x14d,  /* Right */
2065                 0x14f,  /* End */
2066                 /* 100-109 */
2067                 0x150,  /* Down */
2068                 0x151,  /* PageDown */
2069                 0x152,  /* Insert */
2070                 0x153,  /* Delete */
2071                 0x146,  /* XXX Pause/Break */
2072                 0x15b,  /* Win_L(Super_L) */
2073                 0x15c,  /* Win_R(Super_R) */
2074                 0x15d,  /* Application(Menu) */
2075
2076                 /* SUN TYPE 6 USB KEYBOARD */
2077                 0x168,  /* Sun Type 6 Help */
2078                 0x15e,  /* Sun Type 6 Stop */
2079                 /* 110 - 119 */
2080                 0x15f,  /* Sun Type 6 Again */
2081                 0x160,  /* Sun Type 6 Props */
2082                 0x161,  /* Sun Type 6 Undo */
2083                 0x162,  /* Sun Type 6 Front */
2084                 0x163,  /* Sun Type 6 Copy */
2085                 0x164,  /* Sun Type 6 Open */
2086                 0x165,  /* Sun Type 6 Paste */
2087                 0x166,  /* Sun Type 6 Find */
2088                 0x167,  /* Sun Type 6 Cut */
2089                 0x125,  /* Sun Type 6 Mute */
2090                 /* 120 - 128 */
2091                 0x11f,  /* Sun Type 6 VolumeDown */
2092                 0x11e,  /* Sun Type 6 VolumeUp */
2093                 0x120,  /* Sun Type 6 PowerDown */
2094
2095                 /* Japanese 106/109 keyboard */
2096                 0x73,   /* Keyboard Intl' 1 (backslash / underscore) */
2097                 0x70,   /* Keyboard Intl' 2 (Katakana / Hiragana) */
2098                 0x7d,   /* Keyboard Intl' 3 (Yen sign) (Not using in jp106/109) */
2099                 0x79,   /* Keyboard Intl' 4 (Henkan) */
2100                 0x7b,   /* Keyboard Intl' 5 (Muhenkan) */
2101                 0x5c,   /* Keyboard Intl' 6 (Keypad ,) (For PC-9821 layout) */
2102         };
2103
2104         if ((code >= 89) && (code < (int)(89 + (sizeof(scan) / sizeof(scan[0]))))) {
2105                 code = scan[code - 89];
2106         }
2107         /* Pause/Break */
2108         if ((code == 104) && (!(shift & (MOD_CONTROL_L | MOD_CONTROL_R)))) {
2109                 code = (0x45 | SCAN_PREFIX_E1 | SCAN_PREFIX_CTL);
2110         }
2111         if (shift & (MOD_SHIFT_L | MOD_SHIFT_R)) {
2112                 code &= ~SCAN_PREFIX_SHIFT;
2113         }
2114         code |= (up ? SCAN_RELEASE : SCAN_PRESS);
2115
2116         if (code & SCAN_PREFIX) {
2117                 if (code & SCAN_PREFIX_CTL) {
2118                         /* Ctrl */
2119                         sc->sc_buffered_char[0] = (0x1d | (code & SCAN_RELEASE));
2120                         sc->sc_buffered_char[1] = (code & ~SCAN_PREFIX);
2121                 } else if (code & SCAN_PREFIX_SHIFT) {
2122                         /* Shift */
2123                         sc->sc_buffered_char[0] = (0x2a | (code & SCAN_RELEASE));
2124                         sc->sc_buffered_char[1] = (code & ~SCAN_PREFIX_SHIFT);
2125                 } else {
2126                         sc->sc_buffered_char[0] = (code & ~SCAN_PREFIX);
2127                         sc->sc_buffered_char[1] = 0;
2128                 }
2129                 return ((code & SCAN_PREFIX_E0) ? 0xe0 : 0xe1);
2130         }
2131         return (code);
2132
2133 }
2134
2135 #endif                                  /* UKBD_EMULATE_ATSCANCODE */
2136
2137 static keyboard_switch_t ukbdsw = {
2138         .probe = &ukbd__probe,
2139         .init = &ukbd_init,
2140         .term = &ukbd_term,
2141         .intr = &ukbd_intr,
2142         .test_if = &ukbd_test_if,
2143         .enable = &ukbd_enable,
2144         .disable = &ukbd_disable,
2145         .read = &ukbd_read,
2146         .check = &ukbd_check,
2147         .read_char = &ukbd_read_char,
2148         .check_char = &ukbd_check_char,
2149         .ioctl = &ukbd_ioctl,
2150         .lock = &ukbd_lock,
2151         .clear_state = &ukbd_clear_state,
2152         .get_state = &ukbd_get_state,
2153         .set_state = &ukbd_set_state,
2154         .get_fkeystr = &genkbd_get_fkeystr,
2155         .poll = &ukbd_poll,
2156         .diag = &genkbd_diag,
2157 };
2158
2159 KEYBOARD_DRIVER(ukbd, ukbdsw, ukbd_configure);
2160
2161 static int
2162 ukbd_driver_load(module_t mod, int what, void *arg)
2163 {
2164         switch (what) {
2165         case MOD_LOAD:
2166                 kbd_add_driver(&ukbd_kbd_driver);
2167                 break;
2168         case MOD_UNLOAD:
2169                 kbd_delete_driver(&ukbd_kbd_driver);
2170                 break;
2171         }
2172         return (0);
2173 }
2174
2175 static devclass_t ukbd_devclass;
2176
2177 static device_method_t ukbd_methods[] = {
2178         DEVMETHOD(device_probe, ukbd_probe),
2179         DEVMETHOD(device_attach, ukbd_attach),
2180         DEVMETHOD(device_detach, ukbd_detach),
2181         DEVMETHOD(device_resume, ukbd_resume),
2182
2183         DEVMETHOD_END
2184 };
2185
2186 static driver_t ukbd_driver = {
2187         .name = "ukbd",
2188         .methods = ukbd_methods,
2189         .size = sizeof(struct ukbd_softc),
2190 };
2191
2192 DRIVER_MODULE(ukbd, uhub, ukbd_driver, ukbd_devclass, ukbd_driver_load, 0);
2193 MODULE_DEPEND(ukbd, usb, 1, 1, 1);
2194 MODULE_VERSION(ukbd, 1);