sys/bus/u4b/input/ukbd.c

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