sys/dev/usb/input/ukbd.c

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