sys/dev/usb/input/ukbd.c

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