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