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