sys/dev/usb/input/ukbd.c

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