sys/bus/u4b/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,
  98     &ukbd_debug, 0, "Debug level");
  99 SYSCTL_INT(_hw_usb_ukbd, OID_AUTO, no_leds, CTLFLAG_RW,
 100     &ukbd_no_leds, 0, "Disables setting of keyboard leds");
 101
 102 TUNABLE_INT("hw.usb.ukbd.debug", &ukbd_debug);
 103 TUNABLE_INT("hw.usb.ukbd.no_leds", &ukbd_no_leds);
 104 #endif
 105
 106 #define UKBD_EMULATE_ATSCANCODE        1
 107 #define UKBD_DRIVER_NAME          "ukbd"
 108 #define UKBD_NMOD                     8 /* units */
 109 #define UKBD_NKEYCODE                 6 /* units */
 110 #define UKBD_IN_BUF_SIZE  (2*(UKBD_NMOD + (2*UKBD_NKEYCODE)))   /* bytes */
 111 #define UKBD_IN_BUF_FULL  (UKBD_IN_BUF_SIZE / 2)        /* bytes */
 112 #define UKBD_NFKEY        (sizeof(fkey_tab)/sizeof(fkey_tab[0]))        /* units */
 113 #define UKBD_BUFFER_SIZE              64        /* bytes */
 114
 115 struct ukbd_data {
 116         uint16_t        modifiers;
 117 #define MOD_CONTROL_L   0x01
 118 #define MOD_CONTROL_R   0x10
 119 #define MOD_SHIFT_L     0x02
 120 #define MOD_SHIFT_R     0x20
 121 #define MOD_ALT_L       0x04
 122 #define MOD_ALT_R       0x40
 123 #define MOD_WIN_L       0x08
 124 #define MOD_WIN_R       0x80
 125 /* internal */
 126 #define MOD_EJECT       0x0100
 127 #define MOD_FN          0x0200
 128         uint8_t keycode[UKBD_NKEYCODE];
 129 };
 130
 131 enum {
 132         UKBD_INTR_DT,
 133         UKBD_CTRL_LED,
 134         UKBD_N_TRANSFER,
 135 };
 136
 137 struct ukbd_softc {
 138         keyboard_t sc_kbd;
 139         keymap_t sc_keymap;
 140         accentmap_t sc_accmap;
 141         fkeytab_t sc_fkeymap[UKBD_NFKEY];
 142         struct hid_location sc_loc_apple_eject;
 143         struct hid_location sc_loc_apple_fn;
 144         struct hid_location sc_loc_ctrl_l;
 145         struct hid_location sc_loc_ctrl_r;
 146         struct hid_location sc_loc_shift_l;
 147         struct hid_location sc_loc_shift_r;
 148         struct hid_location sc_loc_alt_l;
 149         struct hid_location sc_loc_alt_r;
 150         struct hid_location sc_loc_win_l;
 151         struct hid_location sc_loc_win_r;
 152         struct hid_location sc_loc_events;
 153         struct hid_location sc_loc_numlock;
 154         struct hid_location sc_loc_capslock;
 155         struct hid_location sc_loc_scrolllock;
 156         struct usb_callout sc_callout;
 157         struct ukbd_data sc_ndata;
 158         struct ukbd_data sc_odata;
 159
 160         struct thread *sc_poll_thread;
 161         struct usb_device *sc_udev;
 162         struct usb_interface *sc_iface;
 163         struct usb_xfer *sc_xfer[UKBD_N_TRANSFER];
 164
 165         uint32_t sc_ntime[UKBD_NKEYCODE];
 166         uint32_t sc_otime[UKBD_NKEYCODE];
 167         uint32_t sc_input[UKBD_IN_BUF_SIZE];    /* input buffer */
 168         uint32_t sc_time_ms;
 169         uint32_t sc_composed_char;      /* composed char code, if non-zero */
 170 #ifdef UKBD_EMULATE_ATSCANCODE
 171         uint32_t sc_buffered_char[2];
 172 #endif
 173         uint32_t sc_flags;              /* flags */
 174 #define UKBD_FLAG_COMPOSE       0x00000001
 175 #define UKBD_FLAG_POLLING       0x00000002
 176 #define UKBD_FLAG_SET_LEDS      0x00000004
 177 #define UKBD_FLAG_ATTACHED      0x00000010
 178 #define UKBD_FLAG_GONE          0x00000020
 179
 180 #define UKBD_FLAG_HID_MASK      0x003fffc0
 181 #define UKBD_FLAG_APPLE_EJECT   0x00000040
 182 #define UKBD_FLAG_APPLE_FN      0x00000080
 183 #define UKBD_FLAG_APPLE_SWAP    0x00000100
 184 #define UKBD_FLAG_TIMER_RUNNING 0x00000200
 185 #define UKBD_FLAG_CTRL_L        0x00000400
 186 #define UKBD_FLAG_CTRL_R        0x00000800
 187 #define UKBD_FLAG_SHIFT_L       0x00001000
 188 #define UKBD_FLAG_SHIFT_R       0x00002000
 189 #define UKBD_FLAG_ALT_L         0x00004000
 190 #define UKBD_FLAG_ALT_R         0x00008000
 191 #define UKBD_FLAG_WIN_L         0x00010000
 192 #define UKBD_FLAG_WIN_R         0x00020000
 193 #define UKBD_FLAG_EVENTS        0x00040000
 194 #define UKBD_FLAG_NUMLOCK       0x00080000
 195 #define UKBD_FLAG_CAPSLOCK      0x00100000
 196 #define UKBD_FLAG_SCROLLLOCK    0x00200000
 197
 198         int     sc_mode;                /* input mode (K_XLATE,K_RAW,K_CODE) */
 199         int     sc_state;               /* shift/lock key state */
 200         int     sc_accents;             /* accent key index (> 0) */
 201         int     sc_led_size;
 202         int     sc_kbd_size;
 203
 204         uint16_t sc_inputs;
 205         uint16_t sc_inputhead;
 206         uint16_t sc_inputtail;
 207         uint16_t sc_modifiers;
 208
 209         uint8_t sc_leds;                /* store for async led requests */
 210         uint8_t sc_iface_index;
 211         uint8_t sc_iface_no;
 212         uint8_t sc_id_apple_eject;
 213         uint8_t sc_id_apple_fn;
 214         uint8_t sc_id_ctrl_l;
 215         uint8_t sc_id_ctrl_r;
 216         uint8_t sc_id_shift_l;
 217         uint8_t sc_id_shift_r;
 218         uint8_t sc_id_alt_l;
 219         uint8_t sc_id_alt_r;
 220         uint8_t sc_id_win_l;
 221         uint8_t sc_id_win_r;
 222         uint8_t sc_id_event;
 223         uint8_t sc_id_numlock;
 224         uint8_t sc_id_capslock;
 225         uint8_t sc_id_scrolllock;
 226         uint8_t sc_id_events;
 227         uint8_t sc_kbd_id;
 228
 229         uint8_t sc_buffer[UKBD_BUFFER_SIZE];
 230 };
 231
 232 #define KEY_ERROR         0x01
 233
 234 #define KEY_PRESS         0
 235 #define KEY_RELEASE       0x400
 236 #define KEY_INDEX(c)      ((c) & 0xFF)
 237
 238 #define SCAN_PRESS        0
 239 #define SCAN_RELEASE      0x80
 240 #define SCAN_PREFIX_E0    0x100
 241 #define SCAN_PREFIX_E1    0x200
 242 #define SCAN_PREFIX_CTL   0x400
 243 #define SCAN_PREFIX_SHIFT 0x800
 244 #define SCAN_PREFIX     (SCAN_PREFIX_E0  | SCAN_PREFIX_E1 | \
 245                          SCAN_PREFIX_CTL | SCAN_PREFIX_SHIFT)
 246 #define SCAN_CHAR(c)    ((c) & 0x7f)
 247
 248 #define UKBD_LOCK()     mtx_lock(&Giant)
 249 #define UKBD_UNLOCK()   mtx_unlock(&Giant)
 250
 251 #ifdef  INVARIANTS
 252
 253 /*
 254  * Assert that the lock is held in all contexts
 255  * where the code can be executed.
 256  */
 257 #define UKBD_LOCK_ASSERT()      mtx_assert(&Giant, MA_OWNED)
 258
 259 /*
 260  * Assert that the lock is held in the contexts
 261  * where it really has to be so.
 262  */
 263 #define UKBD_CTX_LOCK_ASSERT()                          \
 264         do {                                            \
 265                 if (!kdb_active && panicstr == NULL)    \
 266                         mtx_assert(&Giant, MA_OWNED);   \
 267         } while (0)
 268 #else
 269
 270 #define UKBD_LOCK_ASSERT()      (void)0
 271 #define UKBD_CTX_LOCK_ASSERT()  (void)0
 272
 273 #endif
 274
 275 struct ukbd_mods {
 276         uint32_t mask, key;
 277 };
 278
 279 static const struct ukbd_mods ukbd_mods[UKBD_NMOD] = {
 280         {MOD_CONTROL_L, 0xe0},
 281         {MOD_CONTROL_R, 0xe4},
 282         {MOD_SHIFT_L, 0xe1},
 283         {MOD_SHIFT_R, 0xe5},
 284         {MOD_ALT_L, 0xe2},
 285         {MOD_ALT_R, 0xe6},
 286         {MOD_WIN_L, 0xe3},
 287         {MOD_WIN_R, 0xe7},
 288 };
 289
 290 #define NN 0                            /* no translation */
 291 /*
 292  * Translate USB keycodes to AT keyboard scancodes.
 293  */
 294 /*
 295  * FIXME: Mac USB keyboard generates:
 296  * 0x53: keypad NumLock/Clear
 297  * 0x66: Power
 298  * 0x67: keypad =
 299  * 0x68: F13
 300  * 0x69: F14
 301  * 0x6a: F15
 302  */
 303 static const uint8_t ukbd_trtab[256] = {
 304         0, 0, 0, 0, 30, 48, 46, 32,     /* 00 - 07 */
 305         18, 33, 34, 35, 23, 36, 37, 38, /* 08 - 0F */
 306         50, 49, 24, 25, 16, 19, 31, 20, /* 10 - 17 */
 307         22, 47, 17, 45, 21, 44, 2, 3,   /* 18 - 1F */
 308         4, 5, 6, 7, 8, 9, 10, 11,       /* 20 - 27 */
 309         28, 1, 14, 15, 57, 12, 13, 26,  /* 28 - 2F */
 310         27, 43, 43, 39, 40, 41, 51, 52, /* 30 - 37 */
 311         53, 58, 59, 60, 61, 62, 63, 64, /* 38 - 3F */
 312         65, 66, 67, 68, 87, 88, 92, 70, /* 40 - 47 */
 313         104, 102, 94, 96, 103, 99, 101, 98,     /* 48 - 4F */
 314         97, 100, 95, 69, 91, 55, 74, 78,/* 50 - 57 */
 315         89, 79, 80, 81, 75, 76, 77, 71, /* 58 - 5F */
 316         72, 73, 82, 83, 86, 107, 122, NN,       /* 60 - 67 */
 317         NN, NN, NN, NN, NN, NN, NN, NN, /* 68 - 6F */
 318         NN, NN, NN, NN, 115, 108, 111, 113,     /* 70 - 77 */
 319         109, 110, 112, 118, 114, 116, 117, 119, /* 78 - 7F */
 320         121, 120, NN, NN, NN, NN, NN, 123,      /* 80 - 87 */
 321         124, 125, 126, 127, 128, NN, NN, NN,    /* 88 - 8F */
 322         NN, NN, NN, NN, NN, NN, NN, NN, /* 90 - 97 */
 323         NN, NN, NN, NN, NN, NN, NN, NN, /* 98 - 9F */
 324         NN, NN, NN, NN, NN, NN, NN, NN, /* A0 - A7 */
 325         NN, NN, NN, NN, NN, NN, NN, NN, /* A8 - AF */
 326         NN, NN, NN, NN, NN, NN, NN, NN, /* B0 - B7 */
 327         NN, NN, NN, NN, NN, NN, NN, NN, /* B8 - BF */
 328         NN, NN, NN, NN, NN, NN, NN, NN, /* C0 - C7 */
 329         NN, NN, NN, NN, NN, NN, NN, NN, /* C8 - CF */
 330         NN, NN, NN, NN, NN, NN, NN, NN, /* D0 - D7 */
 331         NN, NN, NN, NN, NN, NN, NN, NN, /* D8 - DF */
 332         29, 42, 56, 105, 90, 54, 93, 106,       /* E0 - E7 */
 333         NN, NN, NN, NN, NN, NN, NN, NN, /* E8 - EF */
 334         NN, NN, NN, NN, NN, NN, NN, NN, /* F0 - F7 */
 335         NN, NN, NN, NN, NN, NN, NN, NN, /* F8 - FF */
 336 };
 337
 338 static const uint8_t ukbd_boot_desc[] = {
 339         0x05, 0x01, 0x09, 0x06, 0xa1,
 340         0x01, 0x05, 0x07, 0x19, 0xe0,
 341         0x29, 0xe7, 0x15, 0x00, 0x25,
 342         0x01, 0x75, 0x01, 0x95, 0x08,
 343         0x81, 0x02, 0x95, 0x01, 0x75,
 344         0x08, 0x81, 0x01, 0x95, 0x03,
 345         0x75, 0x01, 0x05, 0x08, 0x19,
 346         0x01, 0x29, 0x03, 0x91, 0x02,
 347         0x95, 0x05, 0x75, 0x01, 0x91,
 348         0x01, 0x95, 0x06, 0x75, 0x08,
 349         0x15, 0x00, 0x26, 0xff, 0x00,
 350         0x05, 0x07, 0x19, 0x00, 0x2a,
 351         0xff, 0x00, 0x81, 0x00, 0xc0
 352 };
 353
 354 /* prototypes */
 355 static void     ukbd_timeout(void *);
 356 static void     ukbd_set_leds(struct ukbd_softc *, uint8_t);
 357 static int      ukbd_set_typematic(keyboard_t *, int);
 358 #ifdef UKBD_EMULATE_ATSCANCODE
 359 static int      ukbd_key2scan(struct ukbd_softc *, int, int, int);
 360 #endif
 361 static uint32_t ukbd_read_char(keyboard_t *, int);
 362 static void     ukbd_clear_state(keyboard_t *);
 363 static int      ukbd_ioctl(keyboard_t *, u_long, caddr_t);
 364 static int      ukbd_enable(keyboard_t *);
 365 static int      ukbd_disable(keyboard_t *);
 366 static void     ukbd_interrupt(struct ukbd_softc *);
 367 static void     ukbd_event_keyinput(struct ukbd_softc *);
 368
 369 static device_probe_t ukbd_probe;
 370 static device_attach_t ukbd_attach;
 371 static device_detach_t ukbd_detach;
 372 static device_resume_t ukbd_resume;
 373
 374 static uint8_t
 375 ukbd_any_key_pressed(struct ukbd_softc *sc)
 376 {
 377         uint8_t i;
 378         uint8_t j;
 379
 380         for (j = i = 0; i < UKBD_NKEYCODE; i++)
 381                 j |= sc->sc_odata.keycode[i];
 382
 383         return (j ? 1 : 0);
 384 }
 385
 386 static void
 387 ukbd_start_timer(struct ukbd_softc *sc)
 388 {
 389         sc->sc_flags |= UKBD_FLAG_TIMER_RUNNING;
 390         usb_callout_reset(&sc->sc_callout, hz / 40, &ukbd_timeout, sc);
 391 }
 392
 393 static void
 394 ukbd_put_key(struct ukbd_softc *sc, uint32_t key)
 395 {
 396
 397         UKBD_CTX_LOCK_ASSERT();
 398
 399         DPRINTF("0x%02x (%d) %s\n", key, key,
 400             (key & KEY_RELEASE) ? "released" : "pressed");
 401
 402         if (sc->sc_inputs < UKBD_IN_BUF_SIZE) {
 403                 sc->sc_input[sc->sc_inputtail] = key;
 404                 ++(sc->sc_inputs);
 405                 ++(sc->sc_inputtail);
 406                 if (sc->sc_inputtail >= UKBD_IN_BUF_SIZE) {
 407                         sc->sc_inputtail = 0;
 408                 }
 409         } else {
 410                 DPRINTF("input buffer is full\n");
 411         }
 412 }
 413
 414 static void
 415 ukbd_do_poll(struct ukbd_softc *sc, uint8_t wait)
 416 {
 417
 418         UKBD_CTX_LOCK_ASSERT();
 419         KASSERT((sc->sc_flags & UKBD_FLAG_POLLING) != 0,
 420             ("ukbd_do_poll called when not polling\n"));
 421         DPRINTFN(2, "polling\n");
 422
 423         if (!kdb_active && !SCHEDULER_STOPPED()) {
 424                 /*
 425                  * In this context the kernel is polling for input,
 426                  * but the USB subsystem works in normal interrupt-driven
 427                  * mode, so we just wait on the USB threads to do the job.
 428                  * Note that we currently hold the Giant, but it's also used
 429                  * as the transfer mtx, so we must release it while waiting.
 430                  */
 431                 while (sc->sc_inputs == 0) {
 432                         /*
 433                          * Give USB threads a chance to run.  Note that
 434                          * kern_yield performs DROP_GIANT + PICKUP_GIANT.
 435                          */
 436                         kern_yield(PRI_UNCHANGED);
 437                         if (!wait)
 438                                 break;
 439                 }
 440                 return;
 441         }
 442
 443         while (sc->sc_inputs == 0) {
 444
 445                 usbd_transfer_poll(sc->sc_xfer, UKBD_N_TRANSFER);
 446
 447                 /* Delay-optimised support for repetition of keys */
 448                 if (ukbd_any_key_pressed(sc)) {
 449                         /* a key is pressed - need timekeeping */
 450                         DELAY(1000);
 451
 452                         /* 1 millisecond has passed */
 453                         sc->sc_time_ms += 1;
 454                 }
 455
 456                 ukbd_interrupt(sc);
 457
 458                 if (!wait)
 459                         break;
 460         }
 461 }
 462
 463 static int32_t
 464 ukbd_get_key(struct ukbd_softc *sc, uint8_t wait)
 465 {
 466         int32_t c;
 467
 468         UKBD_CTX_LOCK_ASSERT();
 469         KASSERT((!kdb_active && !SCHEDULER_STOPPED())
 470             || (sc->sc_flags & UKBD_FLAG_POLLING) != 0,
 471             ("not polling in kdb or panic\n"));
 472
 473         if (sc->sc_inputs == 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 ((uaa->info.bInterfaceSubClass == UISUBCLASS_BOOT) &&
1000             (uaa->info.bInterfaceProtocol == UIPROTO_BOOT_KEYBOARD)) {
1001                 if (usb_test_quirk(uaa, UQ_KBD_IGNORE))
1002                         return (ENXIO);
1003                 else
1004                         return (BUS_PROBE_DEFAULT);
1005         }
1006
1007         error = usbd_req_get_hid_desc(uaa->device, NULL,
1008             &d_ptr, &d_len, M_TEMP, uaa->info.bIfaceIndex);
1009
1010         if (error)
1011                 return (ENXIO);
1012
1013         /*
1014          * NOTE: we currently don't support USB mouse and USB keyboard
1015          * on the same USB endpoint.
1016          */
1017         if (hid_is_collection(d_ptr, d_len,
1018             HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_MOUSE))) {
1019                 /* most likely a mouse */
1020                 error = ENXIO;
1021         } else if (hid_is_collection(d_ptr, d_len,
1022             HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_KEYBOARD))) {
1023                 if (usb_test_quirk(uaa, UQ_KBD_IGNORE))
1024                         error = ENXIO;
1025                 else
1026                         error = BUS_PROBE_DEFAULT;
1027         } else
1028                 error = ENXIO;
1029
1030         free(d_ptr, M_TEMP);
1031         return (error);
1032 }
1033
1034 static void
1035 ukbd_parse_hid(struct ukbd_softc *sc, const uint8_t *ptr, uint32_t len)
1036 {
1037         uint32_t flags;
1038
1039         /* reset detected bits */
1040         sc->sc_flags &= ~UKBD_FLAG_HID_MASK;
1041
1042         /* check if there is an ID byte */
1043         sc->sc_kbd_size = hid_report_size(ptr, len,
1044             hid_input, &sc->sc_kbd_id);
1045
1046         /* investigate if this is an Apple Keyboard */
1047         if (hid_locate(ptr, len,
1048             HID_USAGE2(HUP_CONSUMER, HUG_APPLE_EJECT),
1049             hid_input, 0, &sc->sc_loc_apple_eject, &flags,
1050             &sc->sc_id_apple_eject)) {
1051                 if (flags & HIO_VARIABLE)
1052                         sc->sc_flags |= UKBD_FLAG_APPLE_EJECT |
1053                             UKBD_FLAG_APPLE_SWAP;
1054                 DPRINTFN(1, "Found Apple eject-key\n");
1055         }
1056         if (hid_locate(ptr, len,
1057             HID_USAGE2(0xFFFF, 0x0003),
1058             hid_input, 0, &sc->sc_loc_apple_fn, &flags,
1059             &sc->sc_id_apple_fn)) {
1060                 if (flags & HIO_VARIABLE)
1061                         sc->sc_flags |= UKBD_FLAG_APPLE_FN;
1062                 DPRINTFN(1, "Found Apple FN-key\n");
1063         }
1064         /* figure out some keys */
1065         if (hid_locate(ptr, len,
1066             HID_USAGE2(HUP_KEYBOARD, 0xE0),
1067             hid_input, 0, &sc->sc_loc_ctrl_l, &flags,
1068             &sc->sc_id_ctrl_l)) {
1069                 if (flags & HIO_VARIABLE)
1070                         sc->sc_flags |= UKBD_FLAG_CTRL_L;
1071                 DPRINTFN(1, "Found left control\n");
1072         }
1073         if (hid_locate(ptr, len,
1074             HID_USAGE2(HUP_KEYBOARD, 0xE4),
1075             hid_input, 0, &sc->sc_loc_ctrl_r, &flags,
1076             &sc->sc_id_ctrl_r)) {
1077                 if (flags & HIO_VARIABLE)
1078                         sc->sc_flags |= UKBD_FLAG_CTRL_R;
1079                 DPRINTFN(1, "Found right control\n");
1080         }
1081         if (hid_locate(ptr, len,
1082             HID_USAGE2(HUP_KEYBOARD, 0xE1),
1083             hid_input, 0, &sc->sc_loc_shift_l, &flags,
1084             &sc->sc_id_shift_l)) {
1085                 if (flags & HIO_VARIABLE)
1086                         sc->sc_flags |= UKBD_FLAG_SHIFT_L;
1087                 DPRINTFN(1, "Found left shift\n");
1088         }
1089         if (hid_locate(ptr, len,
1090             HID_USAGE2(HUP_KEYBOARD, 0xE5),
1091             hid_input, 0, &sc->sc_loc_shift_r, &flags,
1092             &sc->sc_id_shift_r)) {
1093                 if (flags & HIO_VARIABLE)
1094                         sc->sc_flags |= UKBD_FLAG_SHIFT_R;
1095                 DPRINTFN(1, "Found right shift\n");
1096         }
1097         if (hid_locate(ptr, len,
1098             HID_USAGE2(HUP_KEYBOARD, 0xE2),
1099             hid_input, 0, &sc->sc_loc_alt_l, &flags,
1100             &sc->sc_id_alt_l)) {
1101                 if (flags & HIO_VARIABLE)
1102                         sc->sc_flags |= UKBD_FLAG_ALT_L;
1103                 DPRINTFN(1, "Found left alt\n");
1104         }
1105         if (hid_locate(ptr, len,
1106             HID_USAGE2(HUP_KEYBOARD, 0xE6),
1107             hid_input, 0, &sc->sc_loc_alt_r, &flags,
1108             &sc->sc_id_alt_r)) {
1109                 if (flags & HIO_VARIABLE)
1110                         sc->sc_flags |= UKBD_FLAG_ALT_R;
1111                 DPRINTFN(1, "Found right alt\n");
1112         }
1113         if (hid_locate(ptr, len,
1114             HID_USAGE2(HUP_KEYBOARD, 0xE3),
1115             hid_input, 0, &sc->sc_loc_win_l, &flags,
1116             &sc->sc_id_win_l)) {
1117                 if (flags & HIO_VARIABLE)
1118                         sc->sc_flags |= UKBD_FLAG_WIN_L;
1119                 DPRINTFN(1, "Found left GUI\n");
1120         }
1121         if (hid_locate(ptr, len,
1122             HID_USAGE2(HUP_KEYBOARD, 0xE7),
1123             hid_input, 0, &sc->sc_loc_win_r, &flags,
1124             &sc->sc_id_win_r)) {
1125                 if (flags & HIO_VARIABLE)
1126                         sc->sc_flags |= UKBD_FLAG_WIN_R;
1127                 DPRINTFN(1, "Found right GUI\n");
1128         }
1129         /* figure out event buffer */
1130         if (hid_locate(ptr, len,
1131             HID_USAGE2(HUP_KEYBOARD, 0x00),
1132             hid_input, 0, &sc->sc_loc_events, &flags,
1133             &sc->sc_id_events)) {
1134                 sc->sc_flags |= UKBD_FLAG_EVENTS;
1135                 DPRINTFN(1, "Found keyboard events\n");
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         ukbd_disable(&sc->sc_kbd);
1305
1306 #ifdef KBD_INSTALL_CDEV
1307         if (sc->sc_flags & UKBD_FLAG_ATTACHED) {
1308                 error = kbd_detach(&sc->sc_kbd);
1309                 if (error) {
1310                         /* usb attach cannot return an error */
1311                         device_printf(dev, "WARNING: kbd_detach() "
1312                             "returned non-zero! (ignored)\n");
1313                 }
1314         }
1315 #endif
1316         if (KBD_IS_CONFIGURED(&sc->sc_kbd)) {
1317                 error = kbd_unregister(&sc->sc_kbd);
1318                 if (error) {
1319                         /* usb attach cannot return an error */
1320                         device_printf(dev, "WARNING: kbd_unregister() "
1321                             "returned non-zero! (ignored)\n");
1322                 }
1323         }
1324         sc->sc_kbd.kb_flags = 0;
1325
1326         usbd_transfer_unsetup(sc->sc_xfer, UKBD_N_TRANSFER);
1327
1328         usb_callout_drain(&sc->sc_callout);
1329
1330         DPRINTF("%s: disconnected\n",
1331             device_get_nameunit(dev));
1332
1333         return (0);
1334 }
1335
1336 static int
1337 ukbd_resume(device_t dev)
1338 {
1339         struct ukbd_softc *sc = device_get_softc(dev);
1340
1341         UKBD_LOCK_ASSERT();
1342
1343         ukbd_clear_state(&sc->sc_kbd);
1344
1345         return (0);
1346 }
1347
1348 /* early keyboard probe, not supported */
1349 static int
1350 ukbd_configure(int flags)
1351 {
1352         return (0);
1353 }
1354
1355 /* detect a keyboard, not used */
1356 static int
1357 ukbd__probe(int unit, void *arg, int flags)
1358 {
1359         return (ENXIO);
1360 }
1361
1362 /* reset and initialize the device, not used */
1363 static int
1364 ukbd_init(int unit, keyboard_t **kbdp, void *arg, int flags)
1365 {
1366         return (ENXIO);
1367 }
1368
1369 /* test the interface to the device, not used */
1370 static int
1371 ukbd_test_if(keyboard_t *kbd)
1372 {
1373         return (0);
1374 }
1375
1376 /* finish using this keyboard, not used */
1377 static int
1378 ukbd_term(keyboard_t *kbd)
1379 {
1380         return (ENXIO);
1381 }
1382
1383 /* keyboard interrupt routine, not used */
1384 static int
1385 ukbd_intr(keyboard_t *kbd, void *arg)
1386 {
1387         return (0);
1388 }
1389
1390 /* lock the access to the keyboard, not used */
1391 static int
1392 ukbd_lock(keyboard_t *kbd, int lock)
1393 {
1394         return (1);
1395 }
1396
1397 /*
1398  * Enable the access to the device; until this function is called,
1399  * the client cannot read from the keyboard.
1400  */
1401 static int
1402 ukbd_enable(keyboard_t *kbd)
1403 {
1404
1405         UKBD_LOCK();
1406         KBD_ACTIVATE(kbd);
1407         UKBD_UNLOCK();
1408
1409         return (0);
1410 }
1411
1412 /* disallow the access to the device */
1413 static int
1414 ukbd_disable(keyboard_t *kbd)
1415 {
1416
1417         UKBD_LOCK();
1418         KBD_DEACTIVATE(kbd);
1419         UKBD_UNLOCK();
1420
1421         return (0);
1422 }
1423
1424 /* check if data is waiting */
1425 /* Currently unused. */
1426 static int
1427 ukbd_check(keyboard_t *kbd)
1428 {
1429         struct ukbd_softc *sc = kbd->kb_data;
1430
1431         UKBD_CTX_LOCK_ASSERT();
1432
1433         if (!KBD_IS_ACTIVE(kbd))
1434                 return (0);
1435
1436         if (sc->sc_flags & UKBD_FLAG_POLLING)
1437                 ukbd_do_poll(sc, 0);
1438
1439 #ifdef UKBD_EMULATE_ATSCANCODE
1440         if (sc->sc_buffered_char[0]) {
1441                 return (1);
1442         }
1443 #endif
1444         if (sc->sc_inputs > 0) {
1445                 return (1);
1446         }
1447         return (0);
1448 }
1449
1450 /* check if char is waiting */
1451 static int
1452 ukbd_check_char_locked(keyboard_t *kbd)
1453 {
1454         struct ukbd_softc *sc = kbd->kb_data;
1455
1456         UKBD_CTX_LOCK_ASSERT();
1457
1458         if (!KBD_IS_ACTIVE(kbd))
1459                 return (0);
1460
1461         if ((sc->sc_composed_char > 0) &&
1462             (!(sc->sc_flags & UKBD_FLAG_COMPOSE))) {
1463                 return (1);
1464         }
1465         return (ukbd_check(kbd));
1466 }
1467
1468 static int
1469 ukbd_check_char(keyboard_t *kbd)
1470 {
1471         int result;
1472
1473         UKBD_LOCK();
1474         result = ukbd_check_char_locked(kbd);
1475         UKBD_UNLOCK();
1476
1477         return (result);
1478 }
1479
1480 /* read one byte from the keyboard if it's allowed */
1481 /* Currently unused. */
1482 static int
1483 ukbd_read(keyboard_t *kbd, int wait)
1484 {
1485         struct ukbd_softc *sc = kbd->kb_data;
1486         int32_t usbcode;
1487 #ifdef UKBD_EMULATE_ATSCANCODE
1488         uint32_t keycode;
1489         uint32_t scancode;
1490
1491 #endif
1492
1493         UKBD_CTX_LOCK_ASSERT();
1494
1495         if (!KBD_IS_ACTIVE(kbd))
1496                 return (-1);
1497
1498 #ifdef UKBD_EMULATE_ATSCANCODE
1499         if (sc->sc_buffered_char[0]) {
1500                 scancode = sc->sc_buffered_char[0];
1501                 if (scancode & SCAN_PREFIX) {
1502                         sc->sc_buffered_char[0] &= ~SCAN_PREFIX;
1503                         return ((scancode & SCAN_PREFIX_E0) ? 0xe0 : 0xe1);
1504                 }
1505                 sc->sc_buffered_char[0] = sc->sc_buffered_char[1];
1506                 sc->sc_buffered_char[1] = 0;
1507                 return (scancode);
1508         }
1509 #endif                                  /* UKBD_EMULATE_ATSCANCODE */
1510
1511         /* XXX */
1512         usbcode = ukbd_get_key(sc, (wait == FALSE) ? 0 : 1);
1513         if (!KBD_IS_ACTIVE(kbd) || (usbcode == -1))
1514                 return (-1);
1515
1516         ++(kbd->kb_count);
1517
1518 #ifdef UKBD_EMULATE_ATSCANCODE
1519         keycode = ukbd_trtab[KEY_INDEX(usbcode)];
1520         if (keycode == NN) {
1521                 return -1;
1522         }
1523         return (ukbd_key2scan(sc, keycode, sc->sc_ndata.modifiers,
1524             (usbcode & KEY_RELEASE)));
1525 #else                                   /* !UKBD_EMULATE_ATSCANCODE */
1526         return (usbcode);
1527 #endif                                  /* UKBD_EMULATE_ATSCANCODE */
1528 }
1529
1530 /* read char from the keyboard */
1531 static uint32_t
1532 ukbd_read_char_locked(keyboard_t *kbd, int wait)
1533 {
1534         struct ukbd_softc *sc = kbd->kb_data;
1535         uint32_t action;
1536         uint32_t keycode;
1537         int32_t usbcode;
1538 #ifdef UKBD_EMULATE_ATSCANCODE
1539         uint32_t scancode;
1540 #endif
1541
1542         UKBD_CTX_LOCK_ASSERT();
1543
1544         if (!KBD_IS_ACTIVE(kbd))
1545                 return (NOKEY);
1546
1547 next_code:
1548
1549         /* do we have a composed char to return ? */
1550
1551         if ((sc->sc_composed_char > 0) &&
1552             (!(sc->sc_flags & UKBD_FLAG_COMPOSE))) {
1553
1554                 action = sc->sc_composed_char;
1555                 sc->sc_composed_char = 0;
1556
1557                 if (action > 0xFF) {
1558                         goto errkey;
1559                 }
1560                 goto done;
1561         }
1562 #ifdef UKBD_EMULATE_ATSCANCODE
1563
1564         /* do we have a pending raw scan code? */
1565
1566         if (sc->sc_mode == K_RAW) {
1567                 scancode = sc->sc_buffered_char[0];
1568                 if (scancode) {
1569                         if (scancode & SCAN_PREFIX) {
1570                                 sc->sc_buffered_char[0] = (scancode & ~SCAN_PREFIX);
1571                                 return ((scancode & SCAN_PREFIX_E0) ? 0xe0 : 0xe1);
1572                         }
1573                         sc->sc_buffered_char[0] = sc->sc_buffered_char[1];
1574                         sc->sc_buffered_char[1] = 0;
1575                         return (scancode);
1576                 }
1577         }
1578 #endif                                  /* UKBD_EMULATE_ATSCANCODE */
1579
1580         /* see if there is something in the keyboard port */
1581         /* XXX */
1582         usbcode = ukbd_get_key(sc, (wait == FALSE) ? 0 : 1);
1583         if (usbcode == -1) {
1584                 return (NOKEY);
1585         }
1586         ++kbd->kb_count;
1587
1588 #ifdef UKBD_EMULATE_ATSCANCODE
1589         /* USB key index -> key code -> AT scan code */
1590         keycode = ukbd_trtab[KEY_INDEX(usbcode)];
1591         if (keycode == NN) {
1592                 return (NOKEY);
1593         }
1594         /* return an AT scan code for the K_RAW mode */
1595         if (sc->sc_mode == K_RAW) {
1596                 return (ukbd_key2scan(sc, keycode, sc->sc_ndata.modifiers,
1597                     (usbcode & KEY_RELEASE)));
1598         }
1599 #else                                   /* !UKBD_EMULATE_ATSCANCODE */
1600
1601         /* return the byte as is for the K_RAW mode */
1602         if (sc->sc_mode == K_RAW) {
1603                 return (usbcode);
1604         }
1605         /* USB key index -> key code */
1606         keycode = ukbd_trtab[KEY_INDEX(usbcode)];
1607         if (keycode == NN) {
1608                 return (NOKEY);
1609         }
1610 #endif                                  /* UKBD_EMULATE_ATSCANCODE */
1611
1612         switch (keycode) {
1613         case 0x38:                      /* left alt (compose key) */
1614                 if (usbcode & KEY_RELEASE) {
1615                         if (sc->sc_flags & UKBD_FLAG_COMPOSE) {
1616                                 sc->sc_flags &= ~UKBD_FLAG_COMPOSE;
1617
1618                                 if (sc->sc_composed_char > 0xFF) {
1619                                         sc->sc_composed_char = 0;
1620                                 }
1621                         }
1622                 } else {
1623                         if (!(sc->sc_flags & UKBD_FLAG_COMPOSE)) {
1624                                 sc->sc_flags |= UKBD_FLAG_COMPOSE;
1625                                 sc->sc_composed_char = 0;
1626                         }
1627                 }
1628                 break;
1629                 /* XXX: I don't like these... */
1630         case 0x5c:                      /* print screen */
1631                 if (sc->sc_flags & ALTS) {
1632                         keycode = 0x54; /* sysrq */
1633                 }
1634                 break;
1635         case 0x68:                      /* pause/break */
1636                 if (sc->sc_flags & CTLS) {
1637                         keycode = 0x6c; /* break */
1638                 }
1639                 break;
1640         }
1641
1642         /* return the key code in the K_CODE mode */
1643         if (usbcode & KEY_RELEASE) {
1644                 keycode |= SCAN_RELEASE;
1645         }
1646         if (sc->sc_mode == K_CODE) {
1647                 return (keycode);
1648         }
1649         /* compose a character code */
1650         if (sc->sc_flags & UKBD_FLAG_COMPOSE) {
1651                 switch (keycode) {
1652                         /* key pressed, process it */
1653                 case 0x47:
1654                 case 0x48:
1655                 case 0x49:              /* keypad 7,8,9 */
1656                         sc->sc_composed_char *= 10;
1657                         sc->sc_composed_char += keycode - 0x40;
1658                         goto check_composed;
1659
1660                 case 0x4B:
1661                 case 0x4C:
1662                 case 0x4D:              /* keypad 4,5,6 */
1663                         sc->sc_composed_char *= 10;
1664                         sc->sc_composed_char += keycode - 0x47;
1665                         goto check_composed;
1666
1667                 case 0x4F:
1668                 case 0x50:
1669                 case 0x51:              /* keypad 1,2,3 */
1670                         sc->sc_composed_char *= 10;
1671                         sc->sc_composed_char += keycode - 0x4E;
1672                         goto check_composed;
1673
1674                 case 0x52:              /* keypad 0 */
1675                         sc->sc_composed_char *= 10;
1676                         goto check_composed;
1677
1678                         /* key released, no interest here */
1679                 case SCAN_RELEASE | 0x47:
1680                 case SCAN_RELEASE | 0x48:
1681                 case SCAN_RELEASE | 0x49:       /* keypad 7,8,9 */
1682                 case SCAN_RELEASE | 0x4B:
1683                 case SCAN_RELEASE | 0x4C:
1684                 case SCAN_RELEASE | 0x4D:       /* keypad 4,5,6 */
1685                 case SCAN_RELEASE | 0x4F:
1686                 case SCAN_RELEASE | 0x50:
1687                 case SCAN_RELEASE | 0x51:       /* keypad 1,2,3 */
1688                 case SCAN_RELEASE | 0x52:       /* keypad 0 */
1689                         goto next_code;
1690
1691                 case 0x38:              /* left alt key */
1692                         break;
1693
1694                 default:
1695                         if (sc->sc_composed_char > 0) {
1696                                 sc->sc_flags &= ~UKBD_FLAG_COMPOSE;
1697                                 sc->sc_composed_char = 0;
1698                                 goto errkey;
1699                         }
1700                         break;
1701                 }
1702         }
1703         /* keycode to key action */
1704         action = genkbd_keyaction(kbd, SCAN_CHAR(keycode),
1705             (keycode & SCAN_RELEASE),
1706             &sc->sc_state, &sc->sc_accents);
1707         if (action == NOKEY) {
1708                 goto next_code;
1709         }
1710 done:
1711         return (action);
1712
1713 check_composed:
1714         if (sc->sc_composed_char <= 0xFF) {
1715                 goto next_code;
1716         }
1717 errkey:
1718         return (ERRKEY);
1719 }
1720
1721 /* Currently wait is always false. */
1722 static uint32_t
1723 ukbd_read_char(keyboard_t *kbd, int wait)
1724 {
1725         uint32_t keycode;
1726
1727         UKBD_LOCK();
1728         keycode = ukbd_read_char_locked(kbd, wait);
1729         UKBD_UNLOCK();
1730
1731         return (keycode);
1732 }
1733
1734 /* some useful control functions */
1735 static int
1736 ukbd_ioctl_locked(keyboard_t *kbd, u_long cmd, caddr_t arg)
1737 {
1738         struct ukbd_softc *sc = kbd->kb_data;
1739         int i;
1740 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
1741     defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
1742         int ival;
1743
1744 #endif
1745
1746         UKBD_LOCK_ASSERT();
1747
1748         switch (cmd) {
1749         case KDGKBMODE:         /* get keyboard mode */
1750                 *(int *)arg = sc->sc_mode;
1751                 break;
1752 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
1753     defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
1754         case _IO('K', 7):
1755                 ival = IOCPARM_IVAL(arg);
1756                 arg = (caddr_t)&ival;
1757                 /* FALLTHROUGH */
1758 #endif
1759         case KDSKBMODE:         /* set keyboard mode */
1760                 switch (*(int *)arg) {
1761                 case K_XLATE:
1762                         if (sc->sc_mode != K_XLATE) {
1763                                 /* make lock key state and LED state match */
1764                                 sc->sc_state &= ~LOCK_MASK;
1765                                 sc->sc_state |= KBD_LED_VAL(kbd);
1766                         }
1767                         /* FALLTHROUGH */
1768                 case K_RAW:
1769                 case K_CODE:
1770                         if (sc->sc_mode != *(int *)arg) {
1771                                 if ((sc->sc_flags & UKBD_FLAG_POLLING) == 0)
1772                                         ukbd_clear_state(kbd);
1773                                 sc->sc_mode = *(int *)arg;
1774                         }
1775                         break;
1776                 default:
1777                         return (EINVAL);
1778                 }
1779                 break;
1780
1781         case KDGETLED:                  /* get keyboard LED */
1782                 *(int *)arg = KBD_LED_VAL(kbd);
1783                 break;
1784 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
1785     defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
1786         case _IO('K', 66):
1787                 ival = IOCPARM_IVAL(arg);
1788                 arg = (caddr_t)&ival;
1789                 /* FALLTHROUGH */
1790 #endif
1791         case KDSETLED:                  /* set keyboard LED */
1792                 /* NOTE: lock key state in "sc_state" won't be changed */
1793                 if (*(int *)arg & ~LOCK_MASK)
1794                         return (EINVAL);
1795
1796                 i = *(int *)arg;
1797
1798                 /* replace CAPS LED with ALTGR LED for ALTGR keyboards */
1799                 if (sc->sc_mode == K_XLATE &&
1800                     kbd->kb_keymap->n_keys > ALTGR_OFFSET) {
1801                         if (i & ALKED)
1802                                 i |= CLKED;
1803                         else
1804                                 i &= ~CLKED;
1805                 }
1806                 if (KBD_HAS_DEVICE(kbd))
1807                         ukbd_set_leds(sc, i);
1808
1809                 KBD_LED_VAL(kbd) = *(int *)arg;
1810                 break;
1811         case KDGKBSTATE:                /* get lock key state */
1812                 *(int *)arg = sc->sc_state & LOCK_MASK;
1813                 break;
1814 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
1815     defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
1816         case _IO('K', 20):
1817                 ival = IOCPARM_IVAL(arg);
1818                 arg = (caddr_t)&ival;
1819                 /* FALLTHROUGH */
1820 #endif
1821         case KDSKBSTATE:                /* set lock key state */
1822                 if (*(int *)arg & ~LOCK_MASK) {
1823                         return (EINVAL);
1824                 }
1825                 sc->sc_state &= ~LOCK_MASK;
1826                 sc->sc_state |= *(int *)arg;
1827
1828                 /* set LEDs and quit */
1829                 return (ukbd_ioctl(kbd, KDSETLED, arg));
1830
1831         case KDSETREPEAT:               /* set keyboard repeat rate (new
1832                                          * interface) */
1833                 if (!KBD_HAS_DEVICE(kbd)) {
1834                         return (0);
1835                 }
1836                 if (((int *)arg)[1] < 0) {
1837                         return (EINVAL);
1838                 }
1839                 if (((int *)arg)[0] < 0) {
1840                         return (EINVAL);
1841                 }
1842                 if (((int *)arg)[0] < 200)      /* fastest possible value */
1843                         kbd->kb_delay1 = 200;
1844                 else
1845                         kbd->kb_delay1 = ((int *)arg)[0];
1846                 kbd->kb_delay2 = ((int *)arg)[1];
1847                 return (0);
1848
1849 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
1850     defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
1851         case _IO('K', 67):
1852                 ival = IOCPARM_IVAL(arg);
1853                 arg = (caddr_t)&ival;
1854                 /* FALLTHROUGH */
1855 #endif
1856         case KDSETRAD:                  /* set keyboard repeat rate (old
1857                                          * interface) */
1858                 return (ukbd_set_typematic(kbd, *(int *)arg));
1859
1860         case PIO_KEYMAP:                /* set keyboard translation table */
1861         case OPIO_KEYMAP:               /* set keyboard translation table
1862                                          * (compat) */
1863         case PIO_KEYMAPENT:             /* set keyboard translation table
1864                                          * entry */
1865         case PIO_DEADKEYMAP:            /* set accent key translation table */
1866                 sc->sc_accents = 0;
1867                 /* FALLTHROUGH */
1868         default:
1869                 return (genkbd_commonioctl(kbd, cmd, arg));
1870         }
1871
1872         return (0);
1873 }
1874
1875 static int
1876 ukbd_ioctl(keyboard_t *kbd, u_long cmd, caddr_t arg)
1877 {
1878         int result;
1879
1880         /*
1881          * XXX KDGKBSTATE, KDSKBSTATE and KDSETLED can be called from any
1882          * context where printf(9) can be called, which among other things
1883          * includes interrupt filters and threads with any kinds of locks
1884          * already held.  For this reason it would be dangerous to acquire
1885          * the Giant here unconditionally.  On the other hand we have to
1886          * have it to handle the ioctl.
1887          * So we make our best effort to auto-detect whether we can grab
1888          * the Giant or not.  Blame syscons(4) for this.
1889          */
1890         switch (cmd) {
1891         case KDGKBSTATE:
1892         case KDSKBSTATE:
1893         case KDSETLED:
1894                 if (!mtx_owned(&Giant) && !SCHEDULER_STOPPED())
1895                         return (EDEADLK);       /* best I could come up with */
1896                 /* FALLTHROUGH */
1897         default:
1898                 UKBD_LOCK();
1899                 result = ukbd_ioctl_locked(kbd, cmd, arg);
1900                 UKBD_UNLOCK();
1901                 return (result);
1902         }
1903 }
1904
1905
1906 /* clear the internal state of the keyboard */
1907 static void
1908 ukbd_clear_state(keyboard_t *kbd)
1909 {
1910         struct ukbd_softc *sc = kbd->kb_data;
1911
1912         UKBD_CTX_LOCK_ASSERT();
1913
1914         sc->sc_flags &= ~(UKBD_FLAG_COMPOSE | UKBD_FLAG_POLLING);
1915         sc->sc_state &= LOCK_MASK;      /* preserve locking key state */
1916         sc->sc_accents = 0;
1917         sc->sc_composed_char = 0;
1918 #ifdef UKBD_EMULATE_ATSCANCODE
1919         sc->sc_buffered_char[0] = 0;
1920         sc->sc_buffered_char[1] = 0;
1921 #endif
1922         memset(&sc->sc_ndata, 0, sizeof(sc->sc_ndata));
1923         memset(&sc->sc_odata, 0, sizeof(sc->sc_odata));
1924         memset(&sc->sc_ntime, 0, sizeof(sc->sc_ntime));
1925         memset(&sc->sc_otime, 0, sizeof(sc->sc_otime));
1926 }
1927
1928 /* save the internal state, not used */
1929 static int
1930 ukbd_get_state(keyboard_t *kbd, void *buf, size_t len)
1931 {
1932         return (len == 0) ? 1 : -1;
1933 }
1934
1935 /* set the internal state, not used */
1936 static int
1937 ukbd_set_state(keyboard_t *kbd, void *buf, size_t len)
1938 {
1939         return (EINVAL);
1940 }
1941
1942 static int
1943 ukbd_poll(keyboard_t *kbd, int on)
1944 {
1945         struct ukbd_softc *sc = kbd->kb_data;
1946
1947         UKBD_LOCK();
1948         if (on) {
1949                 sc->sc_flags |= UKBD_FLAG_POLLING;
1950                 sc->sc_poll_thread = curthread;
1951         } else {
1952                 sc->sc_flags &= ~UKBD_FLAG_POLLING;
1953                 ukbd_start_timer(sc);   /* start timer */
1954         }
1955         UKBD_UNLOCK();
1956
1957         return (0);
1958 }
1959
1960 /* local functions */
1961
1962 static void
1963 ukbd_set_leds(struct ukbd_softc *sc, uint8_t leds)
1964 {
1965
1966         UKBD_LOCK_ASSERT();
1967         DPRINTF("leds=0x%02x\n", leds);
1968
1969         sc->sc_leds = leds;
1970         sc->sc_flags |= UKBD_FLAG_SET_LEDS;
1971
1972         /* start transfer, if not already started */
1973
1974         usbd_transfer_start(sc->sc_xfer[UKBD_CTRL_LED]);
1975 }
1976
1977 static int
1978 ukbd_set_typematic(keyboard_t *kbd, int code)
1979 {
1980         static const int delays[] = {250, 500, 750, 1000};
1981         static const int rates[] = {34, 38, 42, 46, 50, 55, 59, 63,
1982                 68, 76, 84, 92, 100, 110, 118, 126,
1983                 136, 152, 168, 184, 200, 220, 236, 252,
1984         272, 304, 336, 368, 400, 440, 472, 504};
1985
1986         if (code & ~0x7f) {
1987                 return (EINVAL);
1988         }
1989         kbd->kb_delay1 = delays[(code >> 5) & 3];
1990         kbd->kb_delay2 = rates[code & 0x1f];
1991         return (0);
1992 }
1993
1994 #ifdef UKBD_EMULATE_ATSCANCODE
1995 static int
1996 ukbd_key2scan(struct ukbd_softc *sc, int code, int shift, int up)
1997 {
1998         static const int scan[] = {
1999                 /* 89 */
2000                 0x11c,  /* Enter */
2001                 /* 90-99 */
2002                 0x11d,  /* Ctrl-R */
2003                 0x135,  /* Divide */
2004                 0x137 | SCAN_PREFIX_SHIFT,      /* PrintScreen */
2005                 0x138,  /* Alt-R */
2006                 0x147,  /* Home */
2007                 0x148,  /* Up */
2008                 0x149,  /* PageUp */
2009                 0x14b,  /* Left */
2010                 0x14d,  /* Right */
2011                 0x14f,  /* End */
2012                 /* 100-109 */
2013                 0x150,  /* Down */
2014                 0x151,  /* PageDown */
2015                 0x152,  /* Insert */
2016                 0x153,  /* Delete */
2017                 0x146,  /* XXX Pause/Break */
2018                 0x15b,  /* Win_L(Super_L) */
2019                 0x15c,  /* Win_R(Super_R) */
2020                 0x15d,  /* Application(Menu) */
2021
2022                 /* SUN TYPE 6 USB KEYBOARD */
2023                 0x168,  /* Sun Type 6 Help */
2024                 0x15e,  /* Sun Type 6 Stop */
2025                 /* 110 - 119 */
2026                 0x15f,  /* Sun Type 6 Again */
2027                 0x160,  /* Sun Type 6 Props */
2028                 0x161,  /* Sun Type 6 Undo */
2029                 0x162,  /* Sun Type 6 Front */
2030                 0x163,  /* Sun Type 6 Copy */
2031                 0x164,  /* Sun Type 6 Open */
2032                 0x165,  /* Sun Type 6 Paste */
2033                 0x166,  /* Sun Type 6 Find */
2034                 0x167,  /* Sun Type 6 Cut */
2035                 0x125,  /* Sun Type 6 Mute */
2036                 /* 120 - 128 */
2037                 0x11f,  /* Sun Type 6 VolumeDown */
2038                 0x11e,  /* Sun Type 6 VolumeUp */
2039                 0x120,  /* Sun Type 6 PowerDown */
2040
2041                 /* Japanese 106/109 keyboard */
2042                 0x73,   /* Keyboard Intl' 1 (backslash / underscore) */
2043                 0x70,   /* Keyboard Intl' 2 (Katakana / Hiragana) */
2044                 0x7d,   /* Keyboard Intl' 3 (Yen sign) (Not using in jp106/109) */
2045                 0x79,   /* Keyboard Intl' 4 (Henkan) */
2046                 0x7b,   /* Keyboard Intl' 5 (Muhenkan) */
2047                 0x5c,   /* Keyboard Intl' 6 (Keypad ,) (For PC-9821 layout) */
2048         };
2049
2050         if ((code >= 89) && (code < (89 + (sizeof(scan) / sizeof(scan[0]))))) {
2051                 code = scan[code - 89];
2052         }
2053         /* Pause/Break */
2054         if ((code == 104) && (!(shift & (MOD_CONTROL_L | MOD_CONTROL_R)))) {
2055                 code = (0x45 | SCAN_PREFIX_E1 | SCAN_PREFIX_CTL);
2056         }
2057         if (shift & (MOD_SHIFT_L | MOD_SHIFT_R)) {
2058                 code &= ~SCAN_PREFIX_SHIFT;
2059         }
2060         code |= (up ? SCAN_RELEASE : SCAN_PRESS);
2061
2062         if (code & SCAN_PREFIX) {
2063                 if (code & SCAN_PREFIX_CTL) {
2064                         /* Ctrl */
2065                         sc->sc_buffered_char[0] = (0x1d | (code & SCAN_RELEASE));
2066                         sc->sc_buffered_char[1] = (code & ~SCAN_PREFIX);
2067                 } else if (code & SCAN_PREFIX_SHIFT) {
2068                         /* Shift */
2069                         sc->sc_buffered_char[0] = (0x2a | (code & SCAN_RELEASE));
2070                         sc->sc_buffered_char[1] = (code & ~SCAN_PREFIX_SHIFT);
2071                 } else {
2072                         sc->sc_buffered_char[0] = (code & ~SCAN_PREFIX);
2073                         sc->sc_buffered_char[1] = 0;
2074                 }
2075                 return ((code & SCAN_PREFIX_E0) ? 0xe0 : 0xe1);
2076         }
2077         return (code);
2078
2079 }
2080
2081 #endif                                  /* UKBD_EMULATE_ATSCANCODE */
2082
2083 static keyboard_switch_t ukbdsw = {
2084         .probe = &ukbd__probe,
2085         .init = &ukbd_init,
2086         .term = &ukbd_term,
2087         .intr = &ukbd_intr,
2088         .test_if = &ukbd_test_if,
2089         .enable = &ukbd_enable,
2090         .disable = &ukbd_disable,
2091         .read = &ukbd_read,
2092         .check = &ukbd_check,
2093         .read_char = &ukbd_read_char,
2094         .check_char = &ukbd_check_char,
2095         .ioctl = &ukbd_ioctl,
2096         .lock = &ukbd_lock,
2097         .clear_state = &ukbd_clear_state,
2098         .get_state = &ukbd_get_state,
2099         .set_state = &ukbd_set_state,
2100         .get_fkeystr = &genkbd_get_fkeystr,
2101         .poll = &ukbd_poll,
2102         .diag = &genkbd_diag,
2103 };
2104
2105 KEYBOARD_DRIVER(ukbd, ukbdsw, ukbd_configure);
2106
2107 static int
2108 ukbd_driver_load(module_t mod, int what, void *arg)
2109 {
2110         switch (what) {
2111         case MOD_LOAD:
2112                 kbd_add_driver(&ukbd_kbd_driver);
2113                 break;
2114         case MOD_UNLOAD:
2115                 kbd_delete_driver(&ukbd_kbd_driver);
2116                 break;
2117         }
2118         return (0);
2119 }
2120
2121 static devclass_t ukbd_devclass;
2122
2123 static device_method_t ukbd_methods[] = {
2124         DEVMETHOD(device_probe, ukbd_probe),
2125         DEVMETHOD(device_attach, ukbd_attach),
2126         DEVMETHOD(device_detach, ukbd_detach),
2127         DEVMETHOD(device_resume, ukbd_resume),
2128         {0, 0}
2129 };
2130
2131 static driver_t ukbd_driver = {
2132         .name = "ukbd",
2133         .methods = ukbd_methods,
2134         .size = sizeof(struct ukbd_softc),
2135 };
2136
2137 DRIVER_MODULE(ukbd, uhub, ukbd_driver, ukbd_devclass, ukbd_driver_load, 0);
2138 MODULE_DEPEND(ukbd, usb, 1, 1, 1);
2139 MODULE_VERSION(ukbd, 1);