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