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