44#include <sys/sysctl.h>
45#include <sys/uio.h>
46
47#include <sys/kbio.h>
48
49#include <dev/kbd/kbdreg.h>
50
51#define KBD_INDEX(dev) minor(dev)
52
53typedef struct genkbd_softc {
54 int gkb_flags; /* flag/status bits */
55#define KB_ASLEEP (1 << 0)
56 struct clist gkb_q; /* input queue */
57 struct selinfo gkb_rsel;
58} genkbd_softc_t;
59
60static SLIST_HEAD(, keyboard_driver) keyboard_drivers =
61 SLIST_HEAD_INITIALIZER(keyboard_drivers);
62
63SET_DECLARE(kbddriver_set, const keyboard_driver_t);
64
65/* local arrays */
66
67/*
68 * We need at least one entry each in order to initialize a keyboard
69 * for the kernel console. The arrays will be increased dynamically
70 * when necessary.
71 */
72
73static int keyboards = 1;
74static keyboard_t *kbd_ini;
75static keyboard_t **keyboard = &kbd_ini;
76static keyboard_switch_t *kbdsw_ini;
77 keyboard_switch_t **kbdsw = &kbdsw_ini;
78
79static int keymap_restrict_change;
80SYSCTL_NODE(_hw, OID_AUTO, kbd, CTLFLAG_RD, 0, "kbd");
81SYSCTL_INT(_hw_kbd, OID_AUTO, keymap_restrict_change, CTLFLAG_RW,
82 &keymap_restrict_change, 0, "restrict ability to change keymap");
83
84#define ARRAY_DELTA 4
85
86static int
87kbd_realloc_array(void)
88{
89 keyboard_t **new_kbd;
90 keyboard_switch_t **new_kbdsw;
91 int newsize;
92 int s;
93
94 s = spltty();
95 newsize = ((keyboards + ARRAY_DELTA)/ARRAY_DELTA)*ARRAY_DELTA;
96 new_kbd = malloc(sizeof(*new_kbd)*newsize, M_DEVBUF, M_NOWAIT|M_ZERO);
97 if (new_kbd == NULL) {
98 splx(s);
99 return (ENOMEM);
100 }
101 new_kbdsw = malloc(sizeof(*new_kbdsw)*newsize, M_DEVBUF,
102 M_NOWAIT|M_ZERO);
103 if (new_kbdsw == NULL) {
104 free(new_kbd, M_DEVBUF);
105 splx(s);
106 return (ENOMEM);
107 }
108 bcopy(keyboard, new_kbd, sizeof(*keyboard)*keyboards);
109 bcopy(kbdsw, new_kbdsw, sizeof(*kbdsw)*keyboards);
110 if (keyboards > 1) {
111 free(keyboard, M_DEVBUF);
112 free(kbdsw, M_DEVBUF);
113 }
114 keyboard = new_kbd;
115 kbdsw = new_kbdsw;
116 keyboards = newsize;
117 splx(s);
118
119 if (bootverbose)
120 printf("kbd: new array size %d\n", keyboards);
121
122 return (0);
123}
124
125/*
126 * Low-level keyboard driver functions
127 * Keyboard subdrivers, such as the AT keyboard driver and the USB keyboard
128 * driver, call these functions to initialize the keyboard_t structure
129 * and register it to the virtual keyboard driver `kbd'.
130 */
131
132/* initialize the keyboard_t structure */
133void
134kbd_init_struct(keyboard_t *kbd, char *name, int type, int unit, int config,
135 int port, int port_size)
136{
137 kbd->kb_flags = KB_NO_DEVICE; /* device has not been found */
138 kbd->kb_name = name;
139 kbd->kb_type = type;
140 kbd->kb_unit = unit;
141 kbd->kb_config = config & ~KB_CONF_PROBE_ONLY;
142 kbd->kb_led = 0; /* unknown */
143 kbd->kb_io_base = port;
144 kbd->kb_io_size = port_size;
145 kbd->kb_data = NULL;
146 kbd->kb_keymap = NULL;
147 kbd->kb_accentmap = NULL;
148 kbd->kb_fkeytab = NULL;
149 kbd->kb_fkeytab_size = 0;
150 kbd->kb_delay1 = KB_DELAY1; /* these values are advisory only */
151 kbd->kb_delay2 = KB_DELAY2;
152 kbd->kb_count = 0L;
153 bzero(kbd->kb_lastact, sizeof(kbd->kb_lastact));
154}
155
156void
157kbd_set_maps(keyboard_t *kbd, keymap_t *keymap, accentmap_t *accmap,
158 fkeytab_t *fkeymap, int fkeymap_size)
159{
160 kbd->kb_keymap = keymap;
161 kbd->kb_accentmap = accmap;
162 kbd->kb_fkeytab = fkeymap;
163 kbd->kb_fkeytab_size = fkeymap_size;
164}
165
166/* declare a new keyboard driver */
167int
168kbd_add_driver(keyboard_driver_t *driver)
169{
170 if (SLIST_NEXT(driver, link))
171 return (EINVAL);
172 SLIST_INSERT_HEAD(&keyboard_drivers, driver, link);
173 return (0);
174}
175
176int
177kbd_delete_driver(keyboard_driver_t *driver)
178{
179 SLIST_REMOVE(&keyboard_drivers, driver, keyboard_driver, link);
180 SLIST_NEXT(driver, link) = NULL;
181 return (0);
182}
183
184/* register a keyboard and associate it with a function table */
185int
186kbd_register(keyboard_t *kbd)
187{
188 const keyboard_driver_t **list;
189 const keyboard_driver_t *p;
190 keyboard_t *mux;
191 keyboard_info_t ki;
192 int index;
193
194 mux = kbd_get_keyboard(kbd_find_keyboard("kbdmux", -1));
195
196 for (index = 0; index < keyboards; ++index) {
197 if (keyboard[index] == NULL)
198 break;
199 }
200 if (index >= keyboards) {
201 if (kbd_realloc_array())
202 return (-1);
203 }
204
205 kbd->kb_index = index;
206 KBD_UNBUSY(kbd);
207 KBD_VALID(kbd);
208 kbd->kb_active = 0; /* disabled until someone calls kbd_enable() */
209 kbd->kb_token = NULL;
210 kbd->kb_callback.kc_func = NULL;
211 kbd->kb_callback.kc_arg = NULL;
212
213 SLIST_FOREACH(p, &keyboard_drivers, link) {
214 if (strcmp(p->name, kbd->kb_name) == 0) {
215 keyboard[index] = kbd;
216 kbdsw[index] = p->kbdsw;
217
218 if (mux != NULL) {
219 bzero(&ki, sizeof(ki));
220 strcpy(ki.kb_name, kbd->kb_name);
221 ki.kb_unit = kbd->kb_unit;
222
223 kbdd_ioctl(mux, KBADDKBD, (caddr_t) &ki);
224 }
225
226 return (index);
227 }
228 }
229 SET_FOREACH(list, kbddriver_set) {
230 p = *list;
231 if (strcmp(p->name, kbd->kb_name) == 0) {
232 keyboard[index] = kbd;
233 kbdsw[index] = p->kbdsw;
234
235 if (mux != NULL) {
236 bzero(&ki, sizeof(ki));
237 strcpy(ki.kb_name, kbd->kb_name);
238 ki.kb_unit = kbd->kb_unit;
239
240 kbdd_ioctl(mux, KBADDKBD, (caddr_t) &ki);
241 }
242
243 return (index);
244 }
245 }
246
247 return (-1);
248}
249
250int
251kbd_unregister(keyboard_t *kbd)
252{
253 int error;
254 int s;
255
256 if ((kbd->kb_index < 0) || (kbd->kb_index >= keyboards))
257 return (ENOENT);
258 if (keyboard[kbd->kb_index] != kbd)
259 return (ENOENT);
260
261 s = spltty();
262 if (KBD_IS_BUSY(kbd)) {
263 error = (*kbd->kb_callback.kc_func)(kbd, KBDIO_UNLOADING,
264 kbd->kb_callback.kc_arg);
265 if (error) {
266 splx(s);
267 return (error);
268 }
269 if (KBD_IS_BUSY(kbd)) {
270 splx(s);
271 return (EBUSY);
272 }
273 }
274 KBD_INVALID(kbd);
275 keyboard[kbd->kb_index] = NULL;
276 kbdsw[kbd->kb_index] = NULL;
277
278 splx(s);
279 return (0);
280}
281
282/* find a funciton table by the driver name */
283keyboard_switch_t
284*kbd_get_switch(char *driver)
285{
286 const keyboard_driver_t **list;
287 const keyboard_driver_t *p;
288
289 SLIST_FOREACH(p, &keyboard_drivers, link) {
290 if (strcmp(p->name, driver) == 0)
291 return (p->kbdsw);
292 }
293 SET_FOREACH(list, kbddriver_set) {
294 p = *list;
295 if (strcmp(p->name, driver) == 0)
296 return (p->kbdsw);
297 }
298
299 return (NULL);
300}
301
302/*
303 * Keyboard client functions
304 * Keyboard clients, such as the console driver `syscons' and the keyboard
305 * cdev driver, use these functions to claim and release a keyboard for
306 * exclusive use.
307 */
308
309/*
310 * find the keyboard specified by a driver name and a unit number
311 * starting at given index
312 */
313int
314kbd_find_keyboard2(char *driver, int unit, int index)
315{
316 int i;
317
318 if ((index < 0) || (index >= keyboards))
319 return (-1);
320
321 for (i = index; i < keyboards; ++i) {
322 if (keyboard[i] == NULL)
323 continue;
324 if (!KBD_IS_VALID(keyboard[i]))
325 continue;
326 if (strcmp("*", driver) && strcmp(keyboard[i]->kb_name, driver))
327 continue;
328 if ((unit != -1) && (keyboard[i]->kb_unit != unit))
329 continue;
330 return (i);
331 }
332
333 return (-1);
334}
335
336/* find the keyboard specified by a driver name and a unit number */
337int
338kbd_find_keyboard(char *driver, int unit)
339{
340 return (kbd_find_keyboard2(driver, unit, 0));
341}
342
343/* allocate a keyboard */
344int
345kbd_allocate(char *driver, int unit, void *id, kbd_callback_func_t *func,
346 void *arg)
347{
348 int index;
349 int s;
350
351 if (func == NULL)
352 return (-1);
353
354 s = spltty();
355 index = kbd_find_keyboard(driver, unit);
356 if (index >= 0) {
357 if (KBD_IS_BUSY(keyboard[index])) {
358 splx(s);
359 return (-1);
360 }
361 keyboard[index]->kb_token = id;
362 KBD_BUSY(keyboard[index]);
363 keyboard[index]->kb_callback.kc_func = func;
364 keyboard[index]->kb_callback.kc_arg = arg;
365 kbdd_clear_state(keyboard[index]);
366 }
367 splx(s);
368 return (index);
369}
370
371int
372kbd_release(keyboard_t *kbd, void *id)
373{
374 int error;
375 int s;
376
377 s = spltty();
378 if (!KBD_IS_VALID(kbd) || !KBD_IS_BUSY(kbd)) {
379 error = EINVAL;
380 } else if (kbd->kb_token != id) {
381 error = EPERM;
382 } else {
383 kbd->kb_token = NULL;
384 KBD_UNBUSY(kbd);
385 kbd->kb_callback.kc_func = NULL;
386 kbd->kb_callback.kc_arg = NULL;
387 kbdd_clear_state(kbd);
388 error = 0;
389 }
390 splx(s);
391 return (error);
392}
393
394int
395kbd_change_callback(keyboard_t *kbd, void *id, kbd_callback_func_t *func,
396 void *arg)
397{
398 int error;
399 int s;
400
401 s = spltty();
402 if (!KBD_IS_VALID(kbd) || !KBD_IS_BUSY(kbd)) {
403 error = EINVAL;
404 } else if (kbd->kb_token != id) {
405 error = EPERM;
406 } else if (func == NULL) {
407 error = EINVAL;
408 } else {
409 kbd->kb_callback.kc_func = func;
410 kbd->kb_callback.kc_arg = arg;
411 error = 0;
412 }
413 splx(s);
414 return (error);
415}
416
417/* get a keyboard structure */
418keyboard_t
419*kbd_get_keyboard(int index)
420{
421 if ((index < 0) || (index >= keyboards))
422 return (NULL);
423 if (keyboard[index] == NULL)
424 return (NULL);
425 if (!KBD_IS_VALID(keyboard[index]))
426 return (NULL);
427 return (keyboard[index]);
428}
429
430/*
431 * The back door for the console driver; configure keyboards
432 * This function is for the kernel console to initialize keyboards
433 * at very early stage.
434 */
435
436int
437kbd_configure(int flags)
438{
439 const keyboard_driver_t **list;
440 const keyboard_driver_t *p;
441
442 SLIST_FOREACH(p, &keyboard_drivers, link) {
443 if (p->configure != NULL)
444 (*p->configure)(flags);
445 }
446 SET_FOREACH(list, kbddriver_set) {
447 p = *list;
448 if (p->configure != NULL)
449 (*p->configure)(flags);
450 }
451
452 return (0);
453}
454
455#ifdef KBD_INSTALL_CDEV
456
457/*
458 * Virtual keyboard cdev driver functions
459 * The virtual keyboard driver dispatches driver functions to
460 * appropriate subdrivers.
461 */
462
463#define KBD_UNIT(dev) minor(dev)
464
465static d_open_t genkbdopen;
466static d_close_t genkbdclose;
467static d_read_t genkbdread;
468static d_write_t genkbdwrite;
469static d_ioctl_t genkbdioctl;
470static d_poll_t genkbdpoll;
471
472
473static struct cdevsw kbd_cdevsw = {
474 .d_version = D_VERSION,
475 .d_flags = D_NEEDGIANT,
476 .d_open = genkbdopen,
477 .d_close = genkbdclose,
478 .d_read = genkbdread,
479 .d_write = genkbdwrite,
480 .d_ioctl = genkbdioctl,
481 .d_poll = genkbdpoll,
482 .d_name = "kbd",
483};
484
485int
486kbd_attach(keyboard_t *kbd)
487{
488
489 if (kbd->kb_index >= keyboards)
490 return (EINVAL);
491 if (keyboard[kbd->kb_index] != kbd)
492 return (EINVAL);
493
494 kbd->kb_dev = make_dev(&kbd_cdevsw, kbd->kb_index, UID_ROOT, GID_WHEEL,
495 0600, "%s%r", kbd->kb_name, kbd->kb_unit);
496 make_dev_alias(kbd->kb_dev, "kbd%r", kbd->kb_index);
497 kbd->kb_dev->si_drv1 = malloc(sizeof(genkbd_softc_t), M_DEVBUF,
498 M_WAITOK | M_ZERO);
499 printf("kbd%d at %s%d\n", kbd->kb_index, kbd->kb_name, kbd->kb_unit);
500 return (0);
501}
502
503int
504kbd_detach(keyboard_t *kbd)
505{
506
507 if (kbd->kb_index >= keyboards)
508 return (EINVAL);
509 if (keyboard[kbd->kb_index] != kbd)
510 return (EINVAL);
511
512 free(kbd->kb_dev->si_drv1, M_DEVBUF);
513 destroy_dev(kbd->kb_dev);
514
515 return (0);
516}
517
518/*
519 * Generic keyboard cdev driver functions
520 * Keyboard subdrivers may call these functions to implement common
521 * driver functions.
522 */
523
524#define KB_QSIZE 512
525#define KB_BUFSIZE 64
526
527static kbd_callback_func_t genkbd_event;
528
529static int
530genkbdopen(struct cdev *dev, int mode, int flag, struct thread *td)
531{
532 keyboard_t *kbd;
533 genkbd_softc_t *sc;
534 int s;
535 int i;
536
537 s = spltty();
538 sc = dev->si_drv1;
539 kbd = kbd_get_keyboard(KBD_INDEX(dev));
540 if ((sc == NULL) || (kbd == NULL) || !KBD_IS_VALID(kbd)) {
541 splx(s);
542 return (ENXIO);
543 }
544 i = kbd_allocate(kbd->kb_name, kbd->kb_unit, sc,
545 genkbd_event, (void *)sc);
546 if (i < 0) {
547 splx(s);
548 return (EBUSY);
549 }
550 /* assert(i == kbd->kb_index) */
551 /* assert(kbd == kbd_get_keyboard(i)) */
552
553 /*
554 * NOTE: even when we have successfully claimed a keyboard,
555 * the device may still be missing (!KBD_HAS_DEVICE(kbd)).
556 */
557
558#if 0
559 bzero(&sc->gkb_q, sizeof(sc->gkb_q));
560#endif
561 clist_alloc_cblocks(&sc->gkb_q, KB_QSIZE, KB_QSIZE/2); /* XXX */
562 splx(s);
563
564 return (0);
565}
566
567static int
568genkbdclose(struct cdev *dev, int mode, int flag, struct thread *td)
569{
570 keyboard_t *kbd;
571 genkbd_softc_t *sc;
572 int s;
573
574 /*
575 * NOTE: the device may have already become invalid.
576 * kbd == NULL || !KBD_IS_VALID(kbd)
577 */
578 s = spltty();
579 sc = dev->si_drv1;
580 kbd = kbd_get_keyboard(KBD_INDEX(dev));
581 if ((sc == NULL) || (kbd == NULL) || !KBD_IS_VALID(kbd)) {
582 /* XXX: we shall be forgiving and don't report error... */
583 } else {
584 kbd_release(kbd, (void *)sc);
585#if 0
586 clist_free_cblocks(&sc->gkb_q);
587#endif
588 }
589 splx(s);
590 return (0);
591}
592
593static int
594genkbdread(struct cdev *dev, struct uio *uio, int flag)
595{
596 keyboard_t *kbd;
597 genkbd_softc_t *sc;
598 u_char buffer[KB_BUFSIZE];
599 int len;
600 int error;
601 int s;
602
603 /* wait for input */
604 s = spltty();
605 sc = dev->si_drv1;
606 kbd = kbd_get_keyboard(KBD_INDEX(dev));
607 if ((sc == NULL) || (kbd == NULL) || !KBD_IS_VALID(kbd)) {
608 splx(s);
609 return (ENXIO);
610 }
611 while (sc->gkb_q.c_cc == 0) {
612 if (flag & O_NONBLOCK) {
613 splx(s);
614 return (EWOULDBLOCK);
615 }
616 sc->gkb_flags |= KB_ASLEEP;
617 error = tsleep(sc, PZERO | PCATCH, "kbdrea", 0);
618 kbd = kbd_get_keyboard(KBD_INDEX(dev));
619 if ((kbd == NULL) || !KBD_IS_VALID(kbd)) {
620 splx(s);
621 return (ENXIO); /* our keyboard has gone... */
622 }
623 if (error) {
624 sc->gkb_flags &= ~KB_ASLEEP;
625 splx(s);
626 return (error);
627 }
628 }
629 splx(s);
630
631 /* copy as much input as possible */
632 error = 0;
633 while (uio->uio_resid > 0) {
634 len = imin(uio->uio_resid, sizeof(buffer));
635 len = q_to_b(&sc->gkb_q, buffer, len);
636 if (len <= 0)
637 break;
638 error = uiomove(buffer, len, uio);
639 if (error)
640 break;
641 }
642
643 return (error);
644}
645
646static int
647genkbdwrite(struct cdev *dev, struct uio *uio, int flag)
648{
649 keyboard_t *kbd;
650
651 kbd = kbd_get_keyboard(KBD_INDEX(dev));
652 if ((kbd == NULL) || !KBD_IS_VALID(kbd))
653 return (ENXIO);
654 return (ENODEV);
655}
656
657static int
658genkbdioctl(struct cdev *dev, u_long cmd, caddr_t arg, int flag, struct thread *td)
659{
660 keyboard_t *kbd;
661 int error;
662
663 kbd = kbd_get_keyboard(KBD_INDEX(dev));
664 if ((kbd == NULL) || !KBD_IS_VALID(kbd))
665 return (ENXIO);
666 error = kbdd_ioctl(kbd, cmd, arg);
667 if (error == ENOIOCTL)
668 error = ENODEV;
669 return (error);
670}
671
672static int
673genkbdpoll(struct cdev *dev, int events, struct thread *td)
674{
675 keyboard_t *kbd;
676 genkbd_softc_t *sc;
677 int revents;
678 int s;
679
680 revents = 0;
681 s = spltty();
682 sc = dev->si_drv1;
683 kbd = kbd_get_keyboard(KBD_INDEX(dev));
684 if ((sc == NULL) || (kbd == NULL) || !KBD_IS_VALID(kbd)) {
685 revents = POLLHUP; /* the keyboard has gone */
686 } else if (events & (POLLIN | POLLRDNORM)) {
687 if (sc->gkb_q.c_cc > 0)
688 revents = events & (POLLIN | POLLRDNORM);
689 else
690 selrecord(td, &sc->gkb_rsel);
691 }
692 splx(s);
693 return (revents);
694}
695
696static int
697genkbd_event(keyboard_t *kbd, int event, void *arg)
698{
699 genkbd_softc_t *sc;
700 size_t len;
701 u_char *cp;
702 int mode;
703 int c;
704
705 /* assert(KBD_IS_VALID(kbd)) */
706 sc = (genkbd_softc_t *)arg;
707
708 switch (event) {
709 case KBDIO_KEYINPUT:
710 break;
711 case KBDIO_UNLOADING:
712 /* the keyboard is going... */
713 kbd_release(kbd, (void *)sc);
714 if (sc->gkb_flags & KB_ASLEEP) {
715 sc->gkb_flags &= ~KB_ASLEEP;
716 wakeup(sc);
717 }
718 selwakeuppri(&sc->gkb_rsel, PZERO);
719 return (0);
720 default:
721 return (EINVAL);
722 }
723
724 /* obtain the current key input mode */
725 if (kbdd_ioctl(kbd, KDGKBMODE, (caddr_t)&mode))
726 mode = K_XLATE;
727
728 /* read all pending input */
729 while (kbdd_check_char(kbd)) {
730 c = kbdd_read_char(kbd, FALSE);
731 if (c == NOKEY)
732 continue;
733 if (c == ERRKEY) /* XXX: ring bell? */
734 continue;
735 if (!KBD_IS_BUSY(kbd))
736 /* the device is not open, discard the input */
737 continue;
738
739 /* store the byte as is for K_RAW and K_CODE modes */
740 if (mode != K_XLATE) {
741 putc(KEYCHAR(c), &sc->gkb_q);
742 continue;
743 }
744
745 /* K_XLATE */
746 if (c & RELKEY) /* key release is ignored */
747 continue;
748
749 /* process special keys; most of them are just ignored... */
750 if (c & SPCLKEY) {
751 switch (KEYCHAR(c)) {
752 default:
753 /* ignore them... */
754 continue;
755 case BTAB: /* a backtab: ESC [ Z */
756 putc(0x1b, &sc->gkb_q);
757 putc('[', &sc->gkb_q);
758 putc('Z', &sc->gkb_q);
759 continue;
760 }
761 }
762
763 /* normal chars, normal chars with the META, function keys */
764 switch (KEYFLAGS(c)) {
765 case 0: /* a normal char */
766 putc(KEYCHAR(c), &sc->gkb_q);
767 break;
768 case MKEY: /* the META flag: prepend ESC */
769 putc(0x1b, &sc->gkb_q);
770 putc(KEYCHAR(c), &sc->gkb_q);
771 break;
772 case FKEY | SPCLKEY: /* a function key, return string */
773 cp = kbdd_get_fkeystr(kbd, KEYCHAR(c), &len);
774 if (cp != NULL) {
775 while (len-- > 0)
776 putc(*cp++, &sc->gkb_q);
777 }
778 break;
779 }
780 }
781
782 /* wake up sleeping/polling processes */
783 if (sc->gkb_q.c_cc > 0) {
784 if (sc->gkb_flags & KB_ASLEEP) {
785 sc->gkb_flags &= ~KB_ASLEEP;
786 wakeup(sc);
787 }
788 selwakeuppri(&sc->gkb_rsel, PZERO);
789 }
790
791 return (0);
792}
793
794#endif /* KBD_INSTALL_CDEV */
795
796/*
797 * Generic low-level keyboard functions
798 * The low-level functions in the keyboard subdriver may use these
799 * functions.
800 */
801
802#ifndef KBD_DISABLE_KEYMAP_LOAD
803static int key_change_ok(struct keyent_t *, struct keyent_t *, struct thread *);
804static int keymap_change_ok(keymap_t *, keymap_t *, struct thread *);
805static int accent_change_ok(accentmap_t *, accentmap_t *, struct thread *);
806static int fkey_change_ok(fkeytab_t *, fkeyarg_t *, struct thread *);
807#endif
808
809int
810genkbd_commonioctl(keyboard_t *kbd, u_long cmd, caddr_t arg)
811{
812 keyarg_t *keyp;
813 fkeyarg_t *fkeyp;
814 int s;
815 int i;
816#ifndef KBD_DISABLE_KEYMAP_LOAD
817 int error;
818#endif
819
820 s = spltty();
821 switch (cmd) {
822
823 case KDGKBINFO: /* get keyboard information */
824 ((keyboard_info_t *)arg)->kb_index = kbd->kb_index;
825 i = imin(strlen(kbd->kb_name) + 1,
826 sizeof(((keyboard_info_t *)arg)->kb_name));
827 bcopy(kbd->kb_name, ((keyboard_info_t *)arg)->kb_name, i);
828 ((keyboard_info_t *)arg)->kb_unit = kbd->kb_unit;
829 ((keyboard_info_t *)arg)->kb_type = kbd->kb_type;
830 ((keyboard_info_t *)arg)->kb_config = kbd->kb_config;
831 ((keyboard_info_t *)arg)->kb_flags = kbd->kb_flags;
832 break;
833
834 case KDGKBTYPE: /* get keyboard type */
835 *(int *)arg = kbd->kb_type;
836 break;
837
838 case KDGETREPEAT: /* get keyboard repeat rate */
839 ((int *)arg)[0] = kbd->kb_delay1;
840 ((int *)arg)[1] = kbd->kb_delay2;
841 break;
842
843 case GIO_KEYMAP: /* get keyboard translation table */
844 bcopy(kbd->kb_keymap, arg, sizeof(*kbd->kb_keymap));
845 break;
846 case PIO_KEYMAP: /* set keyboard translation table */
847#ifndef KBD_DISABLE_KEYMAP_LOAD
848 error = keymap_change_ok(kbd->kb_keymap, (keymap_t *)arg,
849 curthread);
850 if (error != 0) {
851 splx(s);
852 return (error);
853 }
854 bzero(kbd->kb_accentmap, sizeof(*kbd->kb_accentmap));
855 bcopy(arg, kbd->kb_keymap, sizeof(*kbd->kb_keymap));
856 break;
857#else
858 splx(s);
859 return (ENODEV);
860#endif
861
862 case GIO_KEYMAPENT: /* get keyboard translation table entry */
863 keyp = (keyarg_t *)arg;
864 if (keyp->keynum >= sizeof(kbd->kb_keymap->key) /
865 sizeof(kbd->kb_keymap->key[0])) {
866 splx(s);
867 return (EINVAL);
868 }
869 bcopy(&kbd->kb_keymap->key[keyp->keynum], &keyp->key,
870 sizeof(keyp->key));
871 break;
872 case PIO_KEYMAPENT: /* set keyboard translation table entry */
873#ifndef KBD_DISABLE_KEYMAP_LOAD
874 keyp = (keyarg_t *)arg;
875 if (keyp->keynum >= sizeof(kbd->kb_keymap->key) /
876 sizeof(kbd->kb_keymap->key[0])) {
877 splx(s);
878 return (EINVAL);
879 }
880 error = key_change_ok(&kbd->kb_keymap->key[keyp->keynum],
881 &keyp->key, curthread);
882 if (error != 0) {
883 splx(s);
884 return (error);
885 }
886 bcopy(&keyp->key, &kbd->kb_keymap->key[keyp->keynum],
887 sizeof(keyp->key));
888 break;
889#else
890 splx(s);
891 return (ENODEV);
892#endif
893
894 case GIO_DEADKEYMAP: /* get accent key translation table */
895 bcopy(kbd->kb_accentmap, arg, sizeof(*kbd->kb_accentmap));
896 break;
897 case PIO_DEADKEYMAP: /* set accent key translation table */
898#ifndef KBD_DISABLE_KEYMAP_LOAD
899 error = accent_change_ok(kbd->kb_accentmap,
900 (accentmap_t *)arg, curthread);
901 if (error != 0) {
902 splx(s);
903 return (error);
904 }
905 bcopy(arg, kbd->kb_accentmap, sizeof(*kbd->kb_accentmap));
906 break;
907#else
908 splx(s);
909 return (ENODEV);
910#endif
911
912 case GETFKEY: /* get functionkey string */
913 fkeyp = (fkeyarg_t *)arg;
914 if (fkeyp->keynum >= kbd->kb_fkeytab_size) {
915 splx(s);
916 return (EINVAL);
917 }
918 bcopy(kbd->kb_fkeytab[fkeyp->keynum].str, fkeyp->keydef,
919 kbd->kb_fkeytab[fkeyp->keynum].len);
920 fkeyp->flen = kbd->kb_fkeytab[fkeyp->keynum].len;
921 break;
922 case SETFKEY: /* set functionkey string */
923#ifndef KBD_DISABLE_KEYMAP_LOAD
924 fkeyp = (fkeyarg_t *)arg;
925 if (fkeyp->keynum >= kbd->kb_fkeytab_size) {
926 splx(s);
927 return (EINVAL);
928 }
929 error = fkey_change_ok(&kbd->kb_fkeytab[fkeyp->keynum],
930 fkeyp, curthread);
931 if (error != 0) {
932 splx(s);
933 return (error);
934 }
935 kbd->kb_fkeytab[fkeyp->keynum].len = imin(fkeyp->flen, MAXFK);
936 bcopy(fkeyp->keydef, kbd->kb_fkeytab[fkeyp->keynum].str,
937 kbd->kb_fkeytab[fkeyp->keynum].len);
938 break;
939#else
940 splx(s);
941 return (ENODEV);
942#endif
943
944 default:
945 splx(s);
946 return (ENOIOCTL);
947 }
948
949 splx(s);
950 return (0);
951}
952
953#ifndef KBD_DISABLE_KEYMAP_LOAD
954#define RESTRICTED_KEY(key, i) \
955 ((key->spcl & (0x80 >> i)) && \
956 (key->map[i] == RBT || key->map[i] == SUSP || \
957 key->map[i] == STBY || key->map[i] == DBG || \
958 key->map[i] == PNC || key->map[i] == HALT || \
959 key->map[i] == PDWN))
960
961static int
962key_change_ok(struct keyent_t *oldkey, struct keyent_t *newkey, struct thread *td)
963{
964 int i;
965
966 /* Low keymap_restrict_change means any changes are OK. */
967 if (keymap_restrict_change <= 0)
968 return (0);
969
970 /* High keymap_restrict_change means only root can change the keymap. */
971 if (keymap_restrict_change >= 2) {
972 for (i = 0; i < NUM_STATES; i++)
973 if (oldkey->map[i] != newkey->map[i])
974 return priv_check(td, PRIV_KEYBOARD);
975 if (oldkey->spcl != newkey->spcl)
976 return priv_check(td, PRIV_KEYBOARD);
977 if (oldkey->flgs != newkey->flgs)
978 return priv_check(td, PRIV_KEYBOARD);
979 return (0);
980 }
981
982 /* Otherwise we have to see if any special keys are being changed. */
983 for (i = 0; i < NUM_STATES; i++) {
984 /*
985 * If either the oldkey or the newkey action is restricted
986 * then we must make sure that the action doesn't change.
987 */
988 if (!RESTRICTED_KEY(oldkey, i) && !RESTRICTED_KEY(newkey, i))
989 continue;
990 if ((oldkey->spcl & (0x80 >> i)) == (newkey->spcl & (0x80 >> i))
991 && oldkey->map[i] == newkey->map[i])
992 continue;
993 return priv_check(td, PRIV_KEYBOARD);
994 }
995
996 return (0);
997}
998
999static int
1000keymap_change_ok(keymap_t *oldmap, keymap_t *newmap, struct thread *td)
1001{
1002 int keycode, error;
1003
1004 for (keycode = 0; keycode < NUM_KEYS; keycode++) {
1005 if ((error = key_change_ok(&oldmap->key[keycode],
1006 &newmap->key[keycode], td)) != 0)
1007 return (error);
1008 }
1009 return (0);
1010}
1011
1012static int
1013accent_change_ok(accentmap_t *oldmap, accentmap_t *newmap, struct thread *td)
1014{
1015 struct acc_t *oldacc, *newacc;
1016 int accent, i;
1017
1018 if (keymap_restrict_change <= 2)
1019 return (0);
1020
1021 if (oldmap->n_accs != newmap->n_accs)
1022 return priv_check(td, PRIV_KEYBOARD);
1023
1024 for (accent = 0; accent < oldmap->n_accs; accent++) {
1025 oldacc = &oldmap->acc[accent];
1026 newacc = &newmap->acc[accent];
1027 if (oldacc->accchar != newacc->accchar)
1028 return priv_check(td, PRIV_KEYBOARD);
1029 for (i = 0; i < NUM_ACCENTCHARS; ++i) {
1030 if (oldacc->map[i][0] != newacc->map[i][0])
1031 return priv_check(td, PRIV_KEYBOARD);
1032 if (oldacc->map[i][0] == 0) /* end of table */
1033 break;
1034 if (oldacc->map[i][1] != newacc->map[i][1])
1035 return priv_check(td, PRIV_KEYBOARD);
1036 }
1037 }
1038
1039 return (0);
1040}
1041
1042static int
1043fkey_change_ok(fkeytab_t *oldkey, fkeyarg_t *newkey, struct thread *td)
1044{
1045 if (keymap_restrict_change <= 3)
1046 return (0);
1047
1048 if (oldkey->len != newkey->flen ||
1049 bcmp(oldkey->str, newkey->keydef, oldkey->len) != 0)
1050 return priv_check(td, PRIV_KEYBOARD);
1051
1052 return (0);
1053}
1054#endif
1055
1056/* get a pointer to the string associated with the given function key */
1057u_char
1058*genkbd_get_fkeystr(keyboard_t *kbd, int fkey, size_t *len)
1059{
1060 if (kbd == NULL)
1061 return (NULL);
1062 fkey -= F_FN;
1063 if (fkey > kbd->kb_fkeytab_size)
1064 return (NULL);
1065 *len = kbd->kb_fkeytab[fkey].len;
1066 return (kbd->kb_fkeytab[fkey].str);
1067}
1068
1069/* diagnostic dump */
1070static char
1071*get_kbd_type_name(int type)
1072{
1073 static struct {
1074 int type;
1075 char *name;
1076 } name_table[] = {
1077 { KB_84, "AT 84" },
1078 { KB_101, "AT 101/102" },
1079 { KB_OTHER, "generic" },
1080 };
1081 int i;
1082
1083 for (i = 0; i < sizeof(name_table)/sizeof(name_table[0]); ++i) {
1084 if (type == name_table[i].type)
1085 return (name_table[i].name);
1086 }
1087 return ("unknown");
1088}
1089
1090void
1091genkbd_diag(keyboard_t *kbd, int level)
1092{
1093 if (level > 0) {
1094 printf("kbd%d: %s%d, %s (%d), config:0x%x, flags:0x%x",
1095 kbd->kb_index, kbd->kb_name, kbd->kb_unit,
1096 get_kbd_type_name(kbd->kb_type), kbd->kb_type,
1097 kbd->kb_config, kbd->kb_flags);
1098 if (kbd->kb_io_base > 0)
1099 printf(", port:0x%x-0x%x", kbd->kb_io_base,
1100 kbd->kb_io_base + kbd->kb_io_size - 1);
1101 printf("\n");
1102 }
1103}
1104
1105#define set_lockkey_state(k, s, l) \
1106 if (!((s) & l ## DOWN)) { \
1107 int i; \
1108 (s) |= l ## DOWN; \
1109 (s) ^= l ## ED; \
1110 i = (s) & LOCK_MASK; \
1111 kbdd_ioctl((k), KDSETLED, (caddr_t)&i); \
1112 }
1113
1114static u_int
1115save_accent_key(keyboard_t *kbd, u_int key, int *accents)
1116{
1117 int i;
1118
1119 /* make an index into the accent map */
1120 i = key - F_ACC + 1;
1121 if ((i > kbd->kb_accentmap->n_accs)
1122 || (kbd->kb_accentmap->acc[i - 1].accchar == 0)) {
1123 /* the index is out of range or pointing to an empty entry */
1124 *accents = 0;
1125 return (ERRKEY);
1126 }
1127
1128 /*
1129 * If the same accent key has been hit twice, produce the accent
1130 * char itself.
1131 */
1132 if (i == *accents) {
1133 key = kbd->kb_accentmap->acc[i - 1].accchar;
1134 *accents = 0;
1135 return (key);
1136 }
1137
1138 /* remember the index and wait for the next key */
1139 *accents = i;
1140 return (NOKEY);
1141}
1142
1143static u_int
1144make_accent_char(keyboard_t *kbd, u_int ch, int *accents)
1145{
1146 struct acc_t *acc;
1147 int i;
1148
1149 acc = &kbd->kb_accentmap->acc[*accents - 1];
1150 *accents = 0;
1151
1152 /*
1153 * If the accent key is followed by the space key,
1154 * produce the accent char itself.
1155 */
1156 if (ch == ' ')
1157 return (acc->accchar);
1158
1159 /* scan the accent map */
1160 for (i = 0; i < NUM_ACCENTCHARS; ++i) {
1161 if (acc->map[i][0] == 0) /* end of table */
1162 break;
1163 if (acc->map[i][0] == ch)
1164 return (acc->map[i][1]);
1165 }
1166 /* this char cannot be accented... */
1167 return (ERRKEY);
1168}
1169
1170int
1171genkbd_keyaction(keyboard_t *kbd, int keycode, int up, int *shiftstate,
1172 int *accents)
1173{
1174 struct keyent_t *key;
1175 int state = *shiftstate;
1176 int action;
1177 int f;
1178 int i;
1179
1180 i = keycode;
1181 f = state & (AGRS | ALKED);
1182 if ((f == AGRS1) || (f == AGRS2) || (f == ALKED))
1183 i += ALTGR_OFFSET;
1184 key = &kbd->kb_keymap->key[i];
1185 i = ((state & SHIFTS) ? 1 : 0)
1186 | ((state & CTLS) ? 2 : 0)
1187 | ((state & ALTS) ? 4 : 0);
1188 if (((key->flgs & FLAG_LOCK_C) && (state & CLKED))
1189 || ((key->flgs & FLAG_LOCK_N) && (state & NLKED)) )
1190 i ^= 1;
1191
1192 if (up) { /* break: key released */
1193 action = kbd->kb_lastact[keycode];
1194 kbd->kb_lastact[keycode] = NOP;
1195 switch (action) {
1196 case LSHA:
1197 if (state & SHIFTAON) {
1198 set_lockkey_state(kbd, state, ALK);
1199 state &= ~ALKDOWN;
1200 }
1201 action = LSH;
1202 /* FALL THROUGH */
1203 case LSH:
1204 state &= ~SHIFTS1;
1205 break;
1206 case RSHA:
1207 if (state & SHIFTAON) {
1208 set_lockkey_state(kbd, state, ALK);
1209 state &= ~ALKDOWN;
1210 }
1211 action = RSH;
1212 /* FALL THROUGH */
1213 case RSH:
1214 state &= ~SHIFTS2;
1215 break;
1216 case LCTRA:
1217 if (state & SHIFTAON) {
1218 set_lockkey_state(kbd, state, ALK);
1219 state &= ~ALKDOWN;
1220 }
1221 action = LCTR;
1222 /* FALL THROUGH */
1223 case LCTR:
1224 state &= ~CTLS1;
1225 break;
1226 case RCTRA:
1227 if (state & SHIFTAON) {
1228 set_lockkey_state(kbd, state, ALK);
1229 state &= ~ALKDOWN;
1230 }
1231 action = RCTR;
1232 /* FALL THROUGH */
1233 case RCTR:
1234 state &= ~CTLS2;
1235 break;
1236 case LALTA:
1237 if (state & SHIFTAON) {
1238 set_lockkey_state(kbd, state, ALK);
1239 state &= ~ALKDOWN;
1240 }
1241 action = LALT;
1242 /* FALL THROUGH */
1243 case LALT:
1244 state &= ~ALTS1;
1245 break;
1246 case RALTA:
1247 if (state & SHIFTAON) {
1248 set_lockkey_state(kbd, state, ALK);
1249 state &= ~ALKDOWN;
1250 }
1251 action = RALT;
1252 /* FALL THROUGH */
1253 case RALT:
1254 state &= ~ALTS2;
1255 break;
1256 case ASH:
1257 state &= ~AGRS1;
1258 break;
1259 case META:
1260 state &= ~METAS1;
1261 break;
1262 case NLK:
1263 state &= ~NLKDOWN;
1264 break;
1265 case CLK:
1266#ifndef PC98
1267 state &= ~CLKDOWN;
1268#else
1269 state &= ~CLKED;
1270 i = state & LOCK_MASK;
1271 kbdd_ioctl(kbd, KDSETLED, (caddr_t)&i);
1272#endif
1273 break;
1274 case SLK:
1275 state &= ~SLKDOWN;
1276 break;
1277 case ALK:
1278 state &= ~ALKDOWN;
1279 break;
1280 case NOP:
1281 /* release events of regular keys are not reported */
1282 *shiftstate &= ~SHIFTAON;
1283 return (NOKEY);
1284 }
1285 *shiftstate = state & ~SHIFTAON;
1286 return (SPCLKEY | RELKEY | action);
1287 } else { /* make: key pressed */
1288 action = key->map[i];
1289 state &= ~SHIFTAON;
1290 if (key->spcl & (0x80 >> i)) {
1291 /* special keys */
1292 if (kbd->kb_lastact[keycode] == NOP)
1293 kbd->kb_lastact[keycode] = action;
1294 if (kbd->kb_lastact[keycode] != action)
1295 action = NOP;
1296 switch (action) {
1297 /* LOCKING KEYS */
1298 case NLK:
1299 set_lockkey_state(kbd, state, NLK);
1300 break;
1301 case CLK:
1302#ifndef PC98
1303 set_lockkey_state(kbd, state, CLK);
1304#else
1305 state |= CLKED;
1306 i = state & LOCK_MASK;
1307 kbdd_ioctl(kbd, KDSETLED, (caddr_t)&i);
1308#endif
1309 break;
1310 case SLK:
1311 set_lockkey_state(kbd, state, SLK);
1312 break;
1313 case ALK:
1314 set_lockkey_state(kbd, state, ALK);
1315 break;
1316 /* NON-LOCKING KEYS */
1317 case SPSC: case RBT: case SUSP: case STBY:
1318 case DBG: case NEXT: case PREV: case PNC:
1319 case HALT: case PDWN:
1320 *accents = 0;
1321 break;
1322 case BTAB:
1323 *accents = 0;
1324 action |= BKEY;
1325 break;
1326 case LSHA:
1327 state |= SHIFTAON;
1328 action = LSH;
1329 /* FALL THROUGH */
1330 case LSH:
1331 state |= SHIFTS1;
1332 break;
1333 case RSHA:
1334 state |= SHIFTAON;
1335 action = RSH;
1336 /* FALL THROUGH */
1337 case RSH:
1338 state |= SHIFTS2;
1339 break;
1340 case LCTRA:
1341 state |= SHIFTAON;
1342 action = LCTR;
1343 /* FALL THROUGH */
1344 case LCTR:
1345 state |= CTLS1;
1346 break;
1347 case RCTRA:
1348 state |= SHIFTAON;
1349 action = RCTR;
1350 /* FALL THROUGH */
1351 case RCTR:
1352 state |= CTLS2;
1353 break;
1354 case LALTA:
1355 state |= SHIFTAON;
1356 action = LALT;
1357 /* FALL THROUGH */
1358 case LALT:
1359 state |= ALTS1;
1360 break;
1361 case RALTA:
1362 state |= SHIFTAON;
1363 action = RALT;
1364 /* FALL THROUGH */
1365 case RALT:
1366 state |= ALTS2;
1367 break;
1368 case ASH:
1369 state |= AGRS1;
1370 break;
1371 case META:
1372 state |= METAS1;
1373 break;
1374 case NOP:
1375 *shiftstate = state;
1376 return (NOKEY);
1377 default:
1378 /* is this an accent (dead) key? */
1379 *shiftstate = state;
1380 if (action >= F_ACC && action <= L_ACC) {
1381 action = save_accent_key(kbd, action,
1382 accents);
1383 switch (action) {
1384 case NOKEY:
1385 case ERRKEY:
1386 return (action);
1387 default:
1388 if (state & METAS)
1389 return (action | MKEY);
1390 else
1391 return (action);
1392 }
1393 /* NOT REACHED */
1394 }
1395 /* other special keys */
1396 if (*accents > 0) {
1397 *accents = 0;
1398 return (ERRKEY);
1399 }
1400 if (action >= F_FN && action <= L_FN)
1401 action |= FKEY;
1402 /* XXX: return fkey string for the FKEY? */
1403 return (SPCLKEY | action);
1404 }
1405 *shiftstate = state;
1406 return (SPCLKEY | action);
1407 } else {
1408 /* regular keys */
1409 kbd->kb_lastact[keycode] = NOP;
1410 *shiftstate = state;
1411 if (*accents > 0) {
1412 /* make an accented char */
1413 action = make_accent_char(kbd, action, accents);
1414 if (action == ERRKEY)
1415 return (action);
1416 }
1417 if (state & METAS)
1418 action |= MKEY;
1419 return (action);
1420 }
1421 }
1422 /* NOT REACHED */
1423}
|