sys/dev/kbdmux/kbdmux.c

   1 /*
   2  * kbdmux.c
   3  */
   4
   5 /*-
   6  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   7  *
   8  * Copyright (c) 2005 Maksim Yevmenkin <m_evmenkin@yahoo.com>
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  *
  32  * $Id: kbdmux.c,v 1.4 2005/07/14 17:38:35 max Exp $
  33  * $FreeBSD$
  34  */
  35
  36 #include "opt_evdev.h"
  37 #include "opt_kbd.h"
  38 #include "opt_kbdmux.h"
  39
  40 #include <sys/param.h>
  41 #include <sys/bus.h>
  42 #include <sys/conf.h>
  43 #include <sys/consio.h>
  44 #include <sys/fcntl.h>
  45 #include <sys/kbio.h>
  46 #include <sys/kernel.h>
  47 #include <sys/limits.h>
  48 #include <sys/lock.h>
  49 #include <sys/malloc.h>
  50 #include <sys/module.h>
  51 #include <sys/mutex.h>
  52 #include <sys/poll.h>
  53 #include <sys/proc.h>
  54 #include <sys/queue.h>
  55 #include <sys/selinfo.h>
  56 #include <sys/systm.h>
  57 #include <sys/taskqueue.h>
  58 #include <sys/uio.h>
  59 #include <dev/kbd/kbdreg.h>
  60
  61 /* the initial key map, accent map and fkey strings */
  62 #ifdef KBDMUX_DFLT_KEYMAP
  63 #define KBD_DFLT_KEYMAP
  64 #include "kbdmuxmap.h"
  65 #endif
  66
  67 #include <dev/kbd/kbdtables.h>
  68
  69 #ifdef EVDEV_SUPPORT
  70 #include <dev/evdev/evdev.h>
  71 #include <dev/evdev/input.h>
  72 #endif
  73
  74 #define KEYBOARD_NAME   "kbdmux"
  75
  76 MALLOC_DECLARE(M_KBDMUX);
  77 MALLOC_DEFINE(M_KBDMUX, KEYBOARD_NAME, "Keyboard multiplexor");
  78
  79 /*****************************************************************************
  80  *****************************************************************************
  81  **                             Keyboard state
  82  *****************************************************************************
  83  *****************************************************************************/
  84
  85 #define KBDMUX_Q_SIZE   512     /* input queue size */
  86
  87 /*
  88  * XXX
  89  * For now rely on Giant mutex to protect our data structures.
  90  * Just like the rest of keyboard drivers and syscons(4) do.
  91  * Note that callout is initialized as not MP-safe to make sure
  92  * Giant is held.
  93  */
  94
  95 #if 0 /* not yet */
  96 #define KBDMUX_LOCK_DECL_GLOBAL \
  97         struct mtx ks_lock
  98 #define KBDMUX_LOCK_INIT(s) \
  99         mtx_init(&(s)->ks_lock, "kbdmux", NULL, MTX_DEF|MTX_RECURSE)
 100 #define KBDMUX_LOCK_DESTROY(s) \
 101         mtx_destroy(&(s)->ks_lock)
 102 #define KBDMUX_LOCK(s) \
 103         mtx_lock(&(s)->ks_lock)
 104 #define KBDMUX_UNLOCK(s) \
 105         mtx_unlock(&(s)->ks_lock)
 106 #define KBDMUX_LOCK_ASSERT(s, w) \
 107         mtx_assert(&(s)->ks_lock, (w))
 108 #define KBDMUX_SLEEP(s, f, d, t) \
 109         msleep(&(s)->f, &(s)->ks_lock, PCATCH | (PZERO + 1), (d), (t))
 110 #define KBDMUX_CALLOUT_INIT(s) \
 111         callout_init_mtx(&(s)->ks_timo, &(s)->ks_lock, 0)
 112 #define KBDMUX_QUEUE_INTR(s) \
 113         taskqueue_enqueue(taskqueue_swi_giant, &(s)->ks_task)
 114 #else
 115 #define KBDMUX_LOCK_DECL_GLOBAL
 116
 117 #define KBDMUX_LOCK_INIT(s)
 118
 119 #define KBDMUX_LOCK_DESTROY(s)
 120
 121 #define KBDMUX_LOCK(s)
 122
 123 #define KBDMUX_UNLOCK(s)
 124
 125 #define KBDMUX_LOCK_ASSERT(s, w)
 126
 127 #define KBDMUX_SLEEP(s, f, d, t) \
 128         tsleep(&(s)->f, PCATCH | (PZERO + 1), (d), (t))
 129 #define KBDMUX_CALLOUT_INIT(s) \
 130         callout_init(&(s)->ks_timo, 0)
 131 #define KBDMUX_QUEUE_INTR(s) \
 132         taskqueue_enqueue(taskqueue_swi_giant, &(s)->ks_task)
 133 #endif /* not yet */
 134
 135 /*
 136  * kbdmux keyboard
 137  */
 138 struct kbdmux_kbd
 139 {
 140         keyboard_t              *kbd;   /* keyboard */
 141         SLIST_ENTRY(kbdmux_kbd)  next;  /* link to next */
 142 };
 143
 144 typedef struct kbdmux_kbd       kbdmux_kbd_t;
 145
 146 /*
 147  * kbdmux state
 148  */
 149 struct kbdmux_state
 150 {
 151         char                     ks_inq[KBDMUX_Q_SIZE]; /* input chars queue */
 152         unsigned int             ks_inq_start;
 153         unsigned int             ks_inq_length;
 154         struct task              ks_task;       /* interrupt task */
 155         struct callout           ks_timo;       /* timeout handler */
 156 #define TICKS                   (hz)            /* rate */
 157
 158         int                      ks_flags;      /* flags */
 159 #define COMPOSE                 (1 << 0)        /* compose char flag */
 160 #define TASK                    (1 << 2)        /* interrupt task queued */
 161
 162         int                      ks_polling;    /* poll nesting count */
 163         int                      ks_mode;       /* K_XLATE, K_RAW, K_CODE */
 164         int                      ks_state;      /* state */
 165         int                      ks_accents;    /* accent key index (> 0) */
 166         u_int                    ks_composed_char; /* composed char code */
 167         u_char                   ks_prefix;     /* AT scan code prefix */
 168
 169 #ifdef EVDEV_SUPPORT
 170         struct evdev_dev *       ks_evdev;
 171         int                      ks_evdev_state;
 172 #endif
 173
 174         SLIST_HEAD(, kbdmux_kbd) ks_kbds;       /* keyboards */
 175
 176         KBDMUX_LOCK_DECL_GLOBAL;
 177 };
 178
 179 typedef struct kbdmux_state     kbdmux_state_t;
 180
 181 /*****************************************************************************
 182  *****************************************************************************
 183  **                             Helper functions
 184  *****************************************************************************
 185  *****************************************************************************/
 186
 187 static task_fn_t                kbdmux_kbd_intr;
 188 static timeout_t                kbdmux_kbd_intr_timo;
 189 static kbd_callback_func_t      kbdmux_kbd_event;
 190
 191 static void
 192 kbdmux_kbd_putc(kbdmux_state_t *state, char c)
 193 {
 194         unsigned int p;
 195
 196         if (state->ks_inq_length == KBDMUX_Q_SIZE)
 197                 return;
 198
 199         p = (state->ks_inq_start + state->ks_inq_length) % KBDMUX_Q_SIZE;
 200         state->ks_inq[p] = c;
 201         state->ks_inq_length++;
 202 }
 203
 204 static int
 205 kbdmux_kbd_getc(kbdmux_state_t *state)
 206 {
 207         unsigned char c;
 208
 209         if (state->ks_inq_length == 0)
 210                 return (-1);
 211
 212         c = state->ks_inq[state->ks_inq_start];
 213         state->ks_inq_start = (state->ks_inq_start + 1) % KBDMUX_Q_SIZE;
 214         state->ks_inq_length--;
 215
 216         return (c);
 217 }
 218
 219 /*
 220  * Interrupt handler task
 221  */
 222 void
 223 kbdmux_kbd_intr(void *xkbd, int pending)
 224 {
 225         keyboard_t      *kbd = (keyboard_t *) xkbd;
 226         kbdmux_state_t  *state = (kbdmux_state_t *) kbd->kb_data;
 227
 228         kbdd_intr(kbd, NULL);
 229
 230         KBDMUX_LOCK(state);
 231
 232         state->ks_flags &= ~TASK;
 233         wakeup(&state->ks_task);
 234
 235         KBDMUX_UNLOCK(state);
 236 }
 237
 238 /*
 239  * Schedule interrupt handler on timeout. Called with locked state.
 240  */
 241 void
 242 kbdmux_kbd_intr_timo(void *xstate)
 243 {
 244         kbdmux_state_t  *state = (kbdmux_state_t *) xstate;
 245
 246         KBDMUX_LOCK_ASSERT(state, MA_OWNED);
 247
 248         if (callout_pending(&state->ks_timo))
 249                 return; /* callout was reset */
 250
 251         if (!callout_active(&state->ks_timo))
 252                 return; /* callout was stopped */
 253
 254         callout_deactivate(&state->ks_timo);
 255
 256         /* queue interrupt task if needed */
 257         if (state->ks_inq_length > 0 && !(state->ks_flags & TASK) &&
 258             KBDMUX_QUEUE_INTR(state) == 0)
 259                 state->ks_flags |= TASK;
 260
 261         /* re-schedule timeout */
 262         callout_reset(&state->ks_timo, TICKS, kbdmux_kbd_intr_timo, state);
 263 }
 264
 265 /*
 266  * Process event from one of our keyboards
 267  */
 268 static int
 269 kbdmux_kbd_event(keyboard_t *kbd, int event, void *arg)
 270 {
 271         kbdmux_state_t  *state = (kbdmux_state_t *) arg;
 272
 273         switch (event) {
 274         case KBDIO_KEYINPUT: {
 275                 int     c;
 276
 277                 KBDMUX_LOCK(state);
 278
 279                 /*
 280                  * Read all chars from the keyboard
 281                  *
 282                  * Turns out that atkbd(4) check_char() method may return
 283                  * "true" while read_char() method returns NOKEY. If this
 284                  * happens we could stuck in the loop below. Avoid this
 285                  * by breaking out of the loop if read_char() method returns
 286                  * NOKEY.
 287                  */
 288
 289                 while (kbdd_check_char(kbd)) {
 290                         c = kbdd_read_char(kbd, 0);
 291                         if (c == NOKEY)
 292                                 break;
 293                         if (c == ERRKEY)
 294                                 continue; /* XXX ring bell */
 295                         if (!KBD_IS_BUSY(kbd))
 296                                 continue; /* not open - discard the input */
 297
 298                         kbdmux_kbd_putc(state, c);
 299                 }
 300
 301                 /* queue interrupt task if needed */
 302                 if (state->ks_inq_length > 0 && !(state->ks_flags & TASK) &&
 303                     KBDMUX_QUEUE_INTR(state) == 0)
 304                         state->ks_flags |= TASK;
 305
 306                 KBDMUX_UNLOCK(state);
 307                 } break;
 308
 309         case KBDIO_UNLOADING: {
 310                 kbdmux_kbd_t    *k;
 311
 312                 KBDMUX_LOCK(state);
 313
 314                 SLIST_FOREACH(k, &state->ks_kbds, next)
 315                         if (k->kbd == kbd)
 316                                 break;
 317
 318                 if (k != NULL) {
 319                         kbd_release(k->kbd, &k->kbd);
 320                         SLIST_REMOVE(&state->ks_kbds, k, kbdmux_kbd, next);
 321
 322                         k->kbd = NULL;
 323
 324                         free(k, M_KBDMUX);
 325                 }
 326
 327                 KBDMUX_UNLOCK(state);
 328                 } break;
 329
 330         default:
 331                 return (EINVAL);
 332                 /* NOT REACHED */
 333         }
 334
 335         return (0);
 336 }
 337
 338 /****************************************************************************
 339  ****************************************************************************
 340  **                              Keyboard driver
 341  ****************************************************************************
 342  ****************************************************************************/
 343
 344 static int              kbdmux_configure(int flags);
 345 static kbd_probe_t      kbdmux_probe;
 346 static kbd_init_t       kbdmux_init;
 347 static kbd_term_t       kbdmux_term;
 348 static kbd_intr_t       kbdmux_intr;
 349 static kbd_test_if_t    kbdmux_test_if;
 350 static kbd_enable_t     kbdmux_enable;
 351 static kbd_disable_t    kbdmux_disable;
 352 static kbd_read_t       kbdmux_read;
 353 static kbd_check_t      kbdmux_check;
 354 static kbd_read_char_t  kbdmux_read_char;
 355 static kbd_check_char_t kbdmux_check_char;
 356 static kbd_ioctl_t      kbdmux_ioctl;
 357 static kbd_lock_t       kbdmux_lock;
 358 static void             kbdmux_clear_state_locked(kbdmux_state_t *state);
 359 static kbd_clear_state_t kbdmux_clear_state;
 360 static kbd_get_state_t  kbdmux_get_state;
 361 static kbd_set_state_t  kbdmux_set_state;
 362 static kbd_poll_mode_t  kbdmux_poll;
 363
 364 static keyboard_switch_t kbdmuxsw = {
 365         .probe =        kbdmux_probe,
 366         .init =         kbdmux_init,
 367         .term =         kbdmux_term,
 368         .intr =         kbdmux_intr,
 369         .test_if =      kbdmux_test_if,
 370         .enable =       kbdmux_enable,
 371         .disable =      kbdmux_disable,
 372         .read =         kbdmux_read,
 373         .check =        kbdmux_check,
 374         .read_char =    kbdmux_read_char,
 375         .check_char =   kbdmux_check_char,
 376         .ioctl =        kbdmux_ioctl,
 377         .lock =         kbdmux_lock,
 378         .clear_state =  kbdmux_clear_state,
 379         .get_state =    kbdmux_get_state,
 380         .set_state =    kbdmux_set_state,
 381         .get_fkeystr =  genkbd_get_fkeystr,
 382         .poll =         kbdmux_poll,
 383         .diag =         genkbd_diag,
 384 };
 385
 386 #ifdef EVDEV_SUPPORT
 387 static evdev_event_t kbdmux_ev_event;
 388
 389 static const struct evdev_methods kbdmux_evdev_methods = {
 390         .ev_event = kbdmux_ev_event,
 391 };
 392 #endif
 393
 394 /*
 395  * Return the number of found keyboards
 396  */
 397 static int
 398 kbdmux_configure(int flags)
 399 {
 400         return (1);
 401 }
 402
 403 /*
 404  * Detect a keyboard
 405  */
 406 static int
 407 kbdmux_probe(int unit, void *arg, int flags)
 408 {
 409         if (resource_disabled(KEYBOARD_NAME, unit))
 410                 return (ENXIO);
 411
 412         return (0);
 413 }
 414
 415 /*
 416  * Reset and initialize the keyboard (stolen from atkbd.c)
 417  */
 418 static int
 419 kbdmux_init(int unit, keyboard_t **kbdp, void *arg, int flags)
 420 {
 421         keyboard_t      *kbd = NULL;
 422         kbdmux_state_t  *state = NULL;
 423         keymap_t        *keymap = NULL;
 424         accentmap_t     *accmap = NULL;
 425         fkeytab_t       *fkeymap = NULL;
 426         int              error, needfree, fkeymap_size, delay[2];
 427 #ifdef EVDEV_SUPPORT
 428         struct evdev_dev *evdev;
 429         char             phys_loc[NAMELEN];
 430 #endif
 431
 432         if (*kbdp == NULL) {
 433                 *kbdp = kbd = malloc(sizeof(*kbd), M_KBDMUX, M_NOWAIT | M_ZERO);
 434                 state = malloc(sizeof(*state), M_KBDMUX, M_NOWAIT | M_ZERO);
 435                 keymap = malloc(sizeof(key_map), M_KBDMUX, M_NOWAIT);
 436                 accmap = malloc(sizeof(accent_map), M_KBDMUX, M_NOWAIT);
 437                 fkeymap = malloc(sizeof(fkey_tab), M_KBDMUX, M_NOWAIT);
 438                 fkeymap_size = sizeof(fkey_tab)/sizeof(fkey_tab[0]);
 439                 needfree = 1;
 440
 441                 if ((kbd == NULL) || (state == NULL) || (keymap == NULL) ||
 442                     (accmap == NULL) || (fkeymap == NULL)) {
 443                         error = ENOMEM;
 444                         goto bad;
 445                 }
 446
 447                 KBDMUX_LOCK_INIT(state);
 448                 TASK_INIT(&state->ks_task, 0, kbdmux_kbd_intr, (void *) kbd);
 449                 KBDMUX_CALLOUT_INIT(state);
 450                 SLIST_INIT(&state->ks_kbds);
 451         } else if (KBD_IS_INITIALIZED(*kbdp) && KBD_IS_CONFIGURED(*kbdp)) {
 452                 return (0);
 453         } else {
 454                 kbd = *kbdp;
 455                 state = (kbdmux_state_t *) kbd->kb_data;
 456                 keymap = kbd->kb_keymap;
 457                 accmap = kbd->kb_accentmap;
 458                 fkeymap = kbd->kb_fkeytab;
 459                 fkeymap_size = kbd->kb_fkeytab_size;
 460                 needfree = 0;
 461         }
 462
 463         if (!KBD_IS_PROBED(kbd)) {
 464                 /* XXX assume 101/102 keys keyboard */
 465                 kbd_init_struct(kbd, KEYBOARD_NAME, KB_101, unit, flags, 0, 0);
 466                 bcopy(&key_map, keymap, sizeof(key_map));
 467                 bcopy(&accent_map, accmap, sizeof(accent_map));
 468                 bcopy(fkey_tab, fkeymap,
 469                         imin(fkeymap_size*sizeof(fkeymap[0]), sizeof(fkey_tab)));
 470                 kbd_set_maps(kbd, keymap, accmap, fkeymap, fkeymap_size);
 471                 kbd->kb_data = (void *)state;
 472
 473                 KBD_FOUND_DEVICE(kbd);
 474                 KBD_PROBE_DONE(kbd);
 475
 476                 KBDMUX_LOCK(state);
 477                 kbdmux_clear_state_locked(state);
 478                 state->ks_mode = K_XLATE;
 479                 KBDMUX_UNLOCK(state);
 480         }
 481
 482         if (!KBD_IS_INITIALIZED(kbd) && !(flags & KB_CONF_PROBE_ONLY)) {
 483                 kbd->kb_config = flags & ~KB_CONF_PROBE_ONLY;
 484
 485                 kbdmux_ioctl(kbd, KDSETLED, (caddr_t)&state->ks_state);
 486
 487                 delay[0] = kbd->kb_delay1;
 488                 delay[1] = kbd->kb_delay2;
 489                 kbdmux_ioctl(kbd, KDSETREPEAT, (caddr_t)delay);
 490
 491 #ifdef EVDEV_SUPPORT
 492                 /* register as evdev provider */
 493                 evdev = evdev_alloc();
 494                 evdev_set_name(evdev, "System keyboard multiplexer");
 495                 snprintf(phys_loc, NAMELEN, KEYBOARD_NAME"%d", unit);
 496                 evdev_set_phys(evdev, phys_loc);
 497                 evdev_set_id(evdev, BUS_VIRTUAL, 0, 0, 0);
 498                 evdev_set_methods(evdev, kbd, &kbdmux_evdev_methods);
 499                 evdev_support_event(evdev, EV_SYN);
 500                 evdev_support_event(evdev, EV_KEY);
 501                 evdev_support_event(evdev, EV_LED);
 502                 evdev_support_event(evdev, EV_REP);
 503                 evdev_support_all_known_keys(evdev);
 504                 evdev_support_led(evdev, LED_NUML);
 505                 evdev_support_led(evdev, LED_CAPSL);
 506                 evdev_support_led(evdev, LED_SCROLLL);
 507
 508                 if (evdev_register_mtx(evdev, &Giant))
 509                         evdev_free(evdev);
 510                 else
 511                         state->ks_evdev = evdev;
 512                 state->ks_evdev_state = 0;
 513 #endif
 514
 515                 KBD_INIT_DONE(kbd);
 516         }
 517
 518         if (!KBD_IS_CONFIGURED(kbd)) {
 519                 if (kbd_register(kbd) < 0) {
 520                         error = ENXIO;
 521                         goto bad;
 522                 }
 523
 524                 KBD_CONFIG_DONE(kbd);
 525
 526                 KBDMUX_LOCK(state);
 527                 callout_reset(&state->ks_timo, TICKS, kbdmux_kbd_intr_timo, state);
 528                 KBDMUX_UNLOCK(state);
 529         }
 530
 531         return (0);
 532 bad:
 533         if (needfree) {
 534                 if (state != NULL)
 535                         free(state, M_KBDMUX);
 536                 if (keymap != NULL)
 537                         free(keymap, M_KBDMUX);
 538                 if (accmap != NULL)
 539                         free(accmap, M_KBDMUX);
 540                 if (fkeymap != NULL)
 541                         free(fkeymap, M_KBDMUX);
 542                 if (kbd != NULL) {
 543                         free(kbd, M_KBDMUX);
 544                         *kbdp = NULL;   /* insure ref doesn't leak to caller */
 545                 }
 546         }
 547
 548         return (error);
 549 }
 550
 551 /*
 552  * Finish using this keyboard
 553  */
 554 static int
 555 kbdmux_term(keyboard_t *kbd)
 556 {
 557         kbdmux_state_t  *state = (kbdmux_state_t *) kbd->kb_data;
 558         kbdmux_kbd_t    *k;
 559
 560         KBDMUX_LOCK(state);
 561
 562         /* kill callout */
 563         callout_stop(&state->ks_timo);
 564
 565         /* wait for interrupt task */
 566         while (state->ks_flags & TASK)
 567                 KBDMUX_SLEEP(state, ks_task, "kbdmuxc", 0);
 568
 569         /* release all keyboards from the mux */
 570         while ((k = SLIST_FIRST(&state->ks_kbds)) != NULL) {
 571                 kbd_release(k->kbd, &k->kbd);
 572                 SLIST_REMOVE_HEAD(&state->ks_kbds, next);
 573
 574                 k->kbd = NULL;
 575
 576                 free(k, M_KBDMUX);
 577         }
 578
 579         KBDMUX_UNLOCK(state);
 580
 581         kbd_unregister(kbd);
 582
 583 #ifdef EVDEV_SUPPORT
 584         evdev_free(state->ks_evdev);
 585 #endif
 586
 587         KBDMUX_LOCK_DESTROY(state);
 588         bzero(state, sizeof(*state));
 589         free(state, M_KBDMUX);
 590
 591         free(kbd->kb_keymap, M_KBDMUX);
 592         free(kbd->kb_accentmap, M_KBDMUX);
 593         free(kbd->kb_fkeytab, M_KBDMUX);
 594         free(kbd, M_KBDMUX);
 595
 596         return (0);
 597 }
 598
 599 /*
 600  * Keyboard interrupt routine
 601  */
 602 static int
 603 kbdmux_intr(keyboard_t *kbd, void *arg)
 604 {
 605         int     c;
 606
 607         if (KBD_IS_ACTIVE(kbd) && KBD_IS_BUSY(kbd)) {
 608                 /* let the callback function to process the input */
 609                 (*kbd->kb_callback.kc_func)(kbd, KBDIO_KEYINPUT,
 610                                             kbd->kb_callback.kc_arg);
 611         } else {
 612                 /* read and discard the input; no one is waiting for input */
 613                 do {
 614                         c = kbdmux_read_char(kbd, FALSE);
 615                 } while (c != NOKEY);
 616         }
 617
 618         return (0);
 619 }
 620
 621 /*
 622  * Test the interface to the device
 623  */
 624 static int
 625 kbdmux_test_if(keyboard_t *kbd)
 626 {
 627         return (0);
 628 }
 629
 630 /*
 631  * Enable the access to the device; until this function is called,
 632  * the client cannot read from the keyboard.
 633  */
 634 static int
 635 kbdmux_enable(keyboard_t *kbd)
 636 {
 637         KBD_ACTIVATE(kbd);
 638         return (0);
 639 }
 640
 641 /*
 642  * Disallow the access to the device
 643  */
 644 static int
 645 kbdmux_disable(keyboard_t *kbd)
 646 {
 647         KBD_DEACTIVATE(kbd);
 648         return (0);
 649 }
 650
 651 /*
 652  * Read one byte from the keyboard if it's allowed
 653  */
 654 static int
 655 kbdmux_read(keyboard_t *kbd, int wait)
 656 {
 657         kbdmux_state_t  *state = (kbdmux_state_t *) kbd->kb_data;
 658         int              c;
 659
 660         KBDMUX_LOCK(state);
 661         c = kbdmux_kbd_getc(state);
 662         KBDMUX_UNLOCK(state);
 663
 664         if (c != -1)
 665                 kbd->kb_count ++;
 666
 667         return (KBD_IS_ACTIVE(kbd)? c : -1);
 668 }
 669
 670 /*
 671  * Check if data is waiting
 672  */
 673 static int
 674 kbdmux_check(keyboard_t *kbd)
 675 {
 676         kbdmux_state_t  *state = (kbdmux_state_t *) kbd->kb_data;
 677         int              ready;
 678
 679         if (!KBD_IS_ACTIVE(kbd))
 680                 return (FALSE);
 681
 682         KBDMUX_LOCK(state);
 683         ready = (state->ks_inq_length > 0) ? TRUE : FALSE;
 684         KBDMUX_UNLOCK(state);
 685
 686         return (ready);
 687 }
 688
 689 /*
 690  * Read char from the keyboard (stolen from atkbd.c)
 691  */
 692 static u_int
 693 kbdmux_read_char(keyboard_t *kbd, int wait)
 694 {
 695         kbdmux_state_t  *state = (kbdmux_state_t *) kbd->kb_data;
 696         u_int            action;
 697         int              scancode, keycode;
 698
 699         KBDMUX_LOCK(state);
 700
 701 next_code:
 702
 703         /* do we have a composed char to return? */
 704         if (!(state->ks_flags & COMPOSE) && (state->ks_composed_char > 0)) {
 705                 action = state->ks_composed_char;
 706                 state->ks_composed_char = 0;
 707                 if (action > UCHAR_MAX) {
 708                         KBDMUX_UNLOCK(state);
 709
 710                         return (ERRKEY);
 711                 }
 712
 713                 KBDMUX_UNLOCK(state);
 714
 715                 return (action);
 716         }
 717
 718         /* see if there is something in the keyboard queue */
 719         scancode = kbdmux_kbd_getc(state);
 720         if (scancode == -1) {
 721                 if (state->ks_polling != 0) {
 722                         kbdmux_kbd_t    *k;
 723
 724                         SLIST_FOREACH(k, &state->ks_kbds, next) {
 725                                 while (kbdd_check_char(k->kbd)) {
 726                                         scancode = kbdd_read_char(k->kbd, 0);
 727                                         if (scancode == NOKEY)
 728                                                 break;
 729                                         if (scancode == ERRKEY)
 730                                                 continue;
 731                                         if (!KBD_IS_BUSY(k->kbd))
 732                                                 continue;
 733
 734                                         kbdmux_kbd_putc(state, scancode);
 735                                 }
 736                         }
 737
 738                         if (state->ks_inq_length > 0)
 739                                 goto next_code;
 740                 }
 741
 742                 KBDMUX_UNLOCK(state);
 743                 return (NOKEY);
 744         }
 745         /* XXX FIXME: check for -1 if wait == 1! */
 746
 747         kbd->kb_count ++;
 748
 749 #ifdef EVDEV_SUPPORT
 750         /* push evdev event */
 751         if (evdev_rcpt_mask & EVDEV_RCPT_KBDMUX && state->ks_evdev != NULL) {
 752                 uint16_t key = evdev_scancode2key(&state->ks_evdev_state,
 753                     scancode);
 754
 755                 if (key != KEY_RESERVED) {
 756                         evdev_push_event(state->ks_evdev, EV_KEY,
 757                             key, scancode & 0x80 ? 0 : 1);
 758                         evdev_sync(state->ks_evdev);
 759                 }
 760         }
 761 #endif
 762
 763         /* return the byte as is for the K_RAW mode */
 764         if (state->ks_mode == K_RAW) {
 765                 KBDMUX_UNLOCK(state);
 766                 return (scancode);
 767         }
 768
 769         /* translate the scan code into a keycode */
 770         keycode = scancode & 0x7F;
 771         switch (state->ks_prefix) {
 772         case 0x00:      /* normal scancode */
 773                 switch(scancode) {
 774                 case 0xB8:      /* left alt (compose key) released */
 775                         if (state->ks_flags & COMPOSE) {
 776                                 state->ks_flags &= ~COMPOSE;
 777                                 if (state->ks_composed_char > UCHAR_MAX)
 778                                         state->ks_composed_char = 0;
 779                         }
 780                         break;
 781                 case 0x38:      /* left alt (compose key) pressed */
 782                         if (!(state->ks_flags & COMPOSE)) {
 783                                 state->ks_flags |= COMPOSE;
 784                                 state->ks_composed_char = 0;
 785                         }
 786                         break;
 787                 case 0xE0:
 788                 case 0xE1:
 789                         state->ks_prefix = scancode;
 790                         goto next_code;
 791                 }
 792                 break;
 793         case 0xE0:      /* 0xE0 prefix */
 794                 state->ks_prefix = 0;
 795                 switch (keycode) {
 796                 case 0x1C:      /* right enter key */
 797                         keycode = 0x59;
 798                         break;
 799                 case 0x1D:      /* right ctrl key */
 800                         keycode = 0x5A;
 801                         break;
 802                 case 0x35:      /* keypad divide key */
 803                         keycode = 0x5B;
 804                         break;
 805                 case 0x37:      /* print scrn key */
 806                         keycode = 0x5C;
 807                         break;
 808                 case 0x38:      /* right alt key (alt gr) */
 809                         keycode = 0x5D;
 810                         break;
 811                 case 0x46:      /* ctrl-pause/break on AT 101 (see below) */
 812                         keycode = 0x68;
 813                         break;
 814                 case 0x47:      /* grey home key */
 815                         keycode = 0x5E;
 816                         break;
 817                 case 0x48:      /* grey up arrow key */
 818                         keycode = 0x5F;
 819                         break;
 820                 case 0x49:      /* grey page up key */
 821                         keycode = 0x60;
 822                         break;
 823                 case 0x4B:      /* grey left arrow key */
 824                         keycode = 0x61;
 825                         break;
 826                 case 0x4D:      /* grey right arrow key */
 827                         keycode = 0x62;
 828                         break;
 829                 case 0x4F:      /* grey end key */
 830                         keycode = 0x63;
 831                         break;
 832                 case 0x50:      /* grey down arrow key */
 833                         keycode = 0x64;
 834                         break;
 835                 case 0x51:      /* grey page down key */
 836                         keycode = 0x65;
 837                         break;
 838                 case 0x52:      /* grey insert key */
 839                         keycode = 0x66;
 840                         break;
 841                 case 0x53:      /* grey delete key */
 842                         keycode = 0x67;
 843                         break;
 844                 /* the following 3 are only used on the MS "Natural" keyboard */
 845                 case 0x5b:      /* left Window key */
 846                         keycode = 0x69;
 847                         break;
 848                 case 0x5c:      /* right Window key */
 849                         keycode = 0x6a;
 850                         break;
 851                 case 0x5d:      /* menu key */
 852                         keycode = 0x6b;
 853                         break;
 854                 case 0x5e:      /* power key */
 855                         keycode = 0x6d;
 856                         break;
 857                 case 0x5f:      /* sleep key */
 858                         keycode = 0x6e;
 859                         break;
 860                 case 0x63:      /* wake key */
 861                         keycode = 0x6f;
 862                         break;
 863                 case 0x64:      /* [JP106USB] backslash, underscore */
 864                         keycode = 0x73;
 865                         break;
 866                 default:        /* ignore everything else */
 867                         goto next_code;
 868                 }
 869                 break;
 870         case 0xE1:      /* 0xE1 prefix */
 871                 /*
 872                  * The pause/break key on the 101 keyboard produces:
 873                  * E1-1D-45 E1-9D-C5
 874                  * Ctrl-pause/break produces:
 875                  * E0-46 E0-C6 (See above.)
 876                  */
 877                 state->ks_prefix = 0;
 878                 if (keycode == 0x1D)
 879                         state->ks_prefix = 0x1D;
 880                 goto next_code;
 881                 /* NOT REACHED */
 882         case 0x1D:      /* pause / break */
 883                 state->ks_prefix = 0;
 884                 if (keycode != 0x45)
 885                         goto next_code;
 886                 keycode = 0x68;
 887                 break;
 888         }
 889
 890         /* XXX assume 101/102 keys AT keyboard */
 891         switch (keycode) {
 892         case 0x5c:      /* print screen */
 893                 if (state->ks_flags & ALTS)
 894                         keycode = 0x54; /* sysrq */
 895                 break;
 896         case 0x68:      /* pause/break */
 897                 if (state->ks_flags & CTLS)
 898                         keycode = 0x6c; /* break */
 899                 break;
 900         }
 901
 902         /* return the key code in the K_CODE mode */
 903         if (state->ks_mode == K_CODE) {
 904                 KBDMUX_UNLOCK(state);
 905                 return (keycode | (scancode & 0x80));
 906         }
 907
 908         /* compose a character code */
 909         if (state->ks_flags & COMPOSE) {
 910                 switch (keycode | (scancode & 0x80)) {
 911                 /* key pressed, process it */
 912                 case 0x47: case 0x48: case 0x49:        /* keypad 7,8,9 */
 913                         state->ks_composed_char *= 10;
 914                         state->ks_composed_char += keycode - 0x40;
 915                         if (state->ks_composed_char > UCHAR_MAX) {
 916                                 KBDMUX_UNLOCK(state);
 917                                 return (ERRKEY);
 918                         }
 919                         goto next_code;
 920                 case 0x4B: case 0x4C: case 0x4D:        /* keypad 4,5,6 */
 921                         state->ks_composed_char *= 10;
 922                         state->ks_composed_char += keycode - 0x47;
 923                         if (state->ks_composed_char > UCHAR_MAX) {
 924                                 KBDMUX_UNLOCK(state);
 925                                 return (ERRKEY);
 926                         }
 927                         goto next_code;
 928                 case 0x4F: case 0x50: case 0x51:        /* keypad 1,2,3 */
 929                         state->ks_composed_char *= 10;
 930                         state->ks_composed_char += keycode - 0x4E;
 931                         if (state->ks_composed_char > UCHAR_MAX) {
 932                                 KBDMUX_UNLOCK(state);
 933                                 return (ERRKEY);
 934                         }
 935                         goto next_code;
 936                 case 0x52:      /* keypad 0 */
 937                         state->ks_composed_char *= 10;
 938                         if (state->ks_composed_char > UCHAR_MAX) {
 939                                 KBDMUX_UNLOCK(state);
 940                                 return (ERRKEY);
 941                         }
 942                         goto next_code;
 943
 944                 /* key released, no interest here */
 945                 case 0xC7: case 0xC8: case 0xC9:        /* keypad 7,8,9 */
 946                 case 0xCB: case 0xCC: case 0xCD:        /* keypad 4,5,6 */
 947                 case 0xCF: case 0xD0: case 0xD1:        /* keypad 1,2,3 */
 948                 case 0xD2:                              /* keypad 0 */
 949                         goto next_code;
 950
 951                 case 0x38:                              /* left alt key */
 952                         break;
 953
 954                 default:
 955                         if (state->ks_composed_char > 0) {
 956                                 state->ks_flags &= ~COMPOSE;
 957                                 state->ks_composed_char = 0;
 958                                 KBDMUX_UNLOCK(state);
 959                                 return (ERRKEY);
 960                         }
 961                         break;
 962                 }
 963         }
 964
 965         /* keycode to key action */
 966         action = genkbd_keyaction(kbd, keycode, scancode & 0x80,
 967                         &state->ks_state, &state->ks_accents);
 968         if (action == NOKEY)
 969                 goto next_code;
 970
 971         KBDMUX_UNLOCK(state);
 972
 973         return (action);
 974 }
 975
 976 /*
 977  * Check if char is waiting
 978  */
 979 static int
 980 kbdmux_check_char(keyboard_t *kbd)
 981 {
 982         kbdmux_state_t  *state = (kbdmux_state_t *) kbd->kb_data;
 983         int              ready;
 984
 985         if (!KBD_IS_ACTIVE(kbd))
 986                 return (FALSE);
 987
 988         KBDMUX_LOCK(state);
 989
 990         if (!(state->ks_flags & COMPOSE) && (state->ks_composed_char != 0))
 991                 ready = TRUE;
 992         else
 993                 ready = (state->ks_inq_length > 0) ? TRUE : FALSE;
 994
 995         KBDMUX_UNLOCK(state);
 996
 997         return (ready);
 998 }
 999
1000 /*
1001  * Keyboard ioctl's
1002  */
1003 static int
1004 kbdmux_ioctl(keyboard_t *kbd, u_long cmd, caddr_t arg)
1005 {
1006         static int       delays[] = {
1007                 250, 500, 750, 1000
1008         };
1009
1010         static int       rates[]  =  {
1011                 34,  38,  42,  46,  50,   55,  59,  63,
1012                 68,  76,  84,  92,  100, 110, 118, 126,
1013                 136, 152, 168, 184, 200, 220, 236, 252,
1014                 272, 304, 336, 368, 400, 440, 472, 504
1015         };
1016
1017         kbdmux_state_t  *state = (kbdmux_state_t *) kbd->kb_data;
1018         kbdmux_kbd_t    *k;
1019         keyboard_info_t *ki;
1020         int              error = 0, mode;
1021 #ifdef COMPAT_FREEBSD6
1022         int              ival;
1023 #endif
1024
1025         if (state == NULL)
1026                 return (ENXIO);
1027
1028         switch (cmd) {
1029         case KBADDKBD: /* add keyboard to the mux */
1030                 ki = (keyboard_info_t *) arg;
1031
1032                 if (ki == NULL || ki->kb_unit < 0 || ki->kb_name[0] == '\0' ||
1033                     strcmp(ki->kb_name, "*") == 0)
1034                         return (EINVAL); /* bad input */
1035
1036                 KBDMUX_LOCK(state);
1037
1038                 SLIST_FOREACH(k, &state->ks_kbds, next)
1039                         if (k->kbd->kb_unit == ki->kb_unit &&
1040                             strcmp(k->kbd->kb_name, ki->kb_name) == 0)
1041                                 break;
1042
1043                 if (k != NULL) {
1044                         KBDMUX_UNLOCK(state);
1045
1046                         return (0); /* keyboard already in the mux */
1047                 }
1048
1049                 k = malloc(sizeof(*k), M_KBDMUX, M_NOWAIT | M_ZERO);
1050                 if (k == NULL) {
1051                         KBDMUX_UNLOCK(state);
1052
1053                         return (ENOMEM); /* out of memory */
1054                 }
1055
1056                 k->kbd = kbd_get_keyboard(
1057                                 kbd_allocate(
1058                                         ki->kb_name,
1059                                         ki->kb_unit,
1060                                         (void *) &k->kbd,
1061                                         kbdmux_kbd_event, (void *) state));
1062                 if (k->kbd == NULL) {
1063                         KBDMUX_UNLOCK(state);
1064                         free(k, M_KBDMUX);
1065
1066                         return (EINVAL); /* bad keyboard */
1067                 }
1068
1069                 kbdd_enable(k->kbd);
1070                 kbdd_clear_state(k->kbd);
1071
1072                 /* set K_RAW mode on slave keyboard */
1073                 mode = K_RAW;
1074                 error = kbdd_ioctl(k->kbd, KDSKBMODE, (caddr_t)&mode);
1075                 if (error == 0) {
1076                         /* set lock keys state on slave keyboard */
1077                         mode = state->ks_state & LOCK_MASK;
1078                         error = kbdd_ioctl(k->kbd, KDSKBSTATE, (caddr_t)&mode);
1079                 }
1080
1081                 if (error != 0) {
1082                         KBDMUX_UNLOCK(state);
1083
1084                         kbd_release(k->kbd, &k->kbd);
1085                         k->kbd = NULL;
1086
1087                         free(k, M_KBDMUX);
1088
1089                         return (error); /* could not set mode */
1090                 }
1091
1092                 SLIST_INSERT_HEAD(&state->ks_kbds, k, next);
1093
1094                 KBDMUX_UNLOCK(state);
1095                 break;
1096
1097         case KBRELKBD: /* release keyboard from the mux */
1098                 ki = (keyboard_info_t *) arg;
1099
1100                 if (ki == NULL || ki->kb_unit < 0 || ki->kb_name[0] == '\0' ||
1101                     strcmp(ki->kb_name, "*") == 0)
1102                         return (EINVAL); /* bad input */
1103
1104                 KBDMUX_LOCK(state);
1105
1106                 SLIST_FOREACH(k, &state->ks_kbds, next)
1107                         if (k->kbd->kb_unit == ki->kb_unit &&
1108                             strcmp(k->kbd->kb_name, ki->kb_name) == 0)
1109                                 break;
1110
1111                 if (k != NULL) {
1112                         error = kbd_release(k->kbd, &k->kbd);
1113                         if (error == 0) {
1114                                 SLIST_REMOVE(&state->ks_kbds, k, kbdmux_kbd, next);
1115
1116                                 k->kbd = NULL;
1117
1118                                 free(k, M_KBDMUX);
1119                         }
1120                 } else
1121                         error = ENXIO; /* keyboard is not in the mux */
1122
1123                 KBDMUX_UNLOCK(state);
1124                 break;
1125
1126         case KDGKBMODE: /* get kyboard mode */
1127                 KBDMUX_LOCK(state);
1128                 *(int *)arg = state->ks_mode;
1129                 KBDMUX_UNLOCK(state);
1130                 break;
1131
1132 #ifdef COMPAT_FREEBSD6
1133         case _IO('K', 7):
1134                 ival = IOCPARM_IVAL(arg);
1135                 arg = (caddr_t)&ival;
1136                 /* FALLTHROUGH */
1137 #endif
1138         case KDSKBMODE: /* set keyboard mode */
1139                 KBDMUX_LOCK(state);
1140
1141                 switch (*(int *)arg) {
1142                 case K_XLATE:
1143                         if (state->ks_mode != K_XLATE) {
1144                                 /* make lock key state and LED state match */
1145                                 state->ks_state &= ~LOCK_MASK;
1146                                 state->ks_state |= KBD_LED_VAL(kbd);
1147                         }
1148                         /* FALLTHROUGH */
1149
1150                 case K_RAW:
1151                 case K_CODE:
1152                         if (state->ks_mode != *(int *)arg) {
1153                                 kbdmux_clear_state_locked(state);
1154                                 state->ks_mode = *(int *)arg;
1155                         }
1156                         break;
1157
1158                 default:
1159                         error = EINVAL;
1160                         break;
1161                 }
1162
1163                 KBDMUX_UNLOCK(state);
1164                 break;
1165
1166         case KDGETLED: /* get keyboard LED */
1167                 KBDMUX_LOCK(state);
1168                 *(int *)arg = KBD_LED_VAL(kbd);
1169                 KBDMUX_UNLOCK(state);
1170                 break;
1171
1172 #ifdef COMPAT_FREEBSD6
1173         case _IO('K', 66):
1174                 ival = IOCPARM_IVAL(arg);
1175                 arg = (caddr_t)&ival;
1176                 /* FALLTHROUGH */
1177 #endif
1178         case KDSETLED: /* set keyboard LED */
1179                 KBDMUX_LOCK(state);
1180
1181                 /* NOTE: lock key state in ks_state won't be changed */
1182                 if (*(int *)arg & ~LOCK_MASK) {
1183                         KBDMUX_UNLOCK(state);
1184
1185                         return (EINVAL);
1186                 }
1187
1188                 KBD_LED_VAL(kbd) = *(int *)arg;
1189 #ifdef EVDEV_SUPPORT
1190                 if (state->ks_evdev != NULL &&
1191                     evdev_rcpt_mask & EVDEV_RCPT_KBDMUX)
1192                         evdev_push_leds(state->ks_evdev, *(int *)arg);
1193 #endif
1194                 /* KDSETLED on all slave keyboards */
1195                 SLIST_FOREACH(k, &state->ks_kbds, next)
1196                         (void)kbdd_ioctl(k->kbd, KDSETLED, arg);
1197
1198                 KBDMUX_UNLOCK(state);
1199                 break;
1200
1201         case KDGKBSTATE: /* get lock key state */
1202                 KBDMUX_LOCK(state);
1203                 *(int *)arg = state->ks_state & LOCK_MASK;
1204                 KBDMUX_UNLOCK(state);
1205                 break;
1206
1207 #ifdef COMPAT_FREEBSD6
1208         case _IO('K', 20):
1209                 ival = IOCPARM_IVAL(arg);
1210                 arg = (caddr_t)&ival;
1211                 /* FALLTHROUGH */
1212 #endif
1213         case KDSKBSTATE: /* set lock key state */
1214                 KBDMUX_LOCK(state);
1215
1216                 if (*(int *)arg & ~LOCK_MASK) {
1217                         KBDMUX_UNLOCK(state);
1218
1219                         return (EINVAL);
1220                 }
1221
1222                 state->ks_state &= ~LOCK_MASK;
1223                 state->ks_state |= *(int *)arg;
1224
1225                 /* KDSKBSTATE on all slave keyboards */
1226                 SLIST_FOREACH(k, &state->ks_kbds, next)
1227                         (void)kbdd_ioctl(k->kbd, KDSKBSTATE, arg);
1228
1229                 KBDMUX_UNLOCK(state);
1230
1231                 return (kbdmux_ioctl(kbd, KDSETLED, arg));
1232                 /* NOT REACHED */
1233
1234 #ifdef COMPAT_FREEBSD6
1235         case _IO('K', 67):
1236                 cmd = KDSETRAD;
1237                 ival = IOCPARM_IVAL(arg);
1238                 arg = (caddr_t)&ival;
1239                 /* FALLTHROUGH */
1240 #endif
1241         case KDSETREPEAT: /* set keyboard repeat rate (new interface) */
1242         case KDSETRAD: /* set keyboard repeat rate (old interface) */
1243                 KBDMUX_LOCK(state);
1244
1245                 if (cmd == KDSETREPEAT) {
1246                         int     i;
1247
1248                         /* lookup delay */
1249                         for (i = sizeof(delays)/sizeof(delays[0]) - 1; i > 0; i --)
1250                                 if (((int *)arg)[0] >= delays[i])
1251                                         break;
1252                         mode = i << 5;
1253
1254                         /* lookup rate */
1255                         for (i = sizeof(rates)/sizeof(rates[0]) - 1; i > 0; i --)
1256                                 if (((int *)arg)[1] >= rates[i])
1257                                         break;
1258                         mode |= i;
1259                 } else
1260                         mode = *(int *)arg;
1261
1262                 if (mode & ~0x7f) {
1263                         KBDMUX_UNLOCK(state);
1264
1265                         return (EINVAL);
1266                 }
1267
1268                 kbd->kb_delay1 = delays[(mode >> 5) & 3];
1269                 kbd->kb_delay2 = rates[mode & 0x1f];
1270 #ifdef EVDEV_SUPPORT
1271                 if (state->ks_evdev != NULL &&
1272                     evdev_rcpt_mask & EVDEV_RCPT_KBDMUX)
1273                         evdev_push_repeats(state->ks_evdev, kbd);
1274 #endif
1275                 /* perform command on all slave keyboards */
1276                 SLIST_FOREACH(k, &state->ks_kbds, next)
1277                         (void)kbdd_ioctl(k->kbd, cmd, arg);
1278
1279                 KBDMUX_UNLOCK(state);
1280                 break;
1281
1282         case PIO_KEYMAP:        /* set keyboard translation table */
1283         case OPIO_KEYMAP:       /* set keyboard translation table (compat) */
1284         case PIO_KEYMAPENT:     /* set keyboard translation table entry */
1285         case PIO_DEADKEYMAP:    /* set accent key translation table */
1286                 KBDMUX_LOCK(state);
1287                 state->ks_accents = 0;
1288
1289                 /* perform command on all slave keyboards */
1290                 SLIST_FOREACH(k, &state->ks_kbds, next)
1291                         (void)kbdd_ioctl(k->kbd, cmd, arg);
1292
1293                 KBDMUX_UNLOCK(state);
1294                 /* FALLTHROUGH */
1295
1296         default:
1297                 error = genkbd_commonioctl(kbd, cmd, arg);
1298                 break;
1299         }
1300
1301         return (error);
1302 }
1303
1304 /*
1305  * Lock the access to the keyboard
1306  */
1307 static int
1308 kbdmux_lock(keyboard_t *kbd, int lock)
1309 {
1310         return (1); /* XXX */
1311 }
1312
1313 /*
1314  * Clear the internal state of the keyboard
1315  */
1316 static void
1317 kbdmux_clear_state_locked(kbdmux_state_t *state)
1318 {
1319         KBDMUX_LOCK_ASSERT(state, MA_OWNED);
1320
1321         state->ks_flags &= ~COMPOSE;
1322         state->ks_polling = 0;
1323         state->ks_state &= LOCK_MASK;   /* preserve locking key state */
1324         state->ks_accents = 0;
1325         state->ks_composed_char = 0;
1326 /*      state->ks_prefix = 0;           XXX */
1327         state->ks_inq_length = 0;
1328 }
1329
1330 static void
1331 kbdmux_clear_state(keyboard_t *kbd)
1332 {
1333         kbdmux_state_t  *state = (kbdmux_state_t *) kbd->kb_data;
1334
1335         KBDMUX_LOCK(state);
1336         kbdmux_clear_state_locked(state);
1337         KBDMUX_UNLOCK(state);
1338 }
1339
1340 /*
1341  * Save the internal state
1342  */
1343 static int
1344 kbdmux_get_state(keyboard_t *kbd, void *buf, size_t len)
1345 {
1346         if (len == 0)
1347                 return (sizeof(kbdmux_state_t));
1348         if (len < sizeof(kbdmux_state_t))
1349                 return (-1);
1350
1351         bcopy(kbd->kb_data, buf, sizeof(kbdmux_state_t)); /* XXX locking? */
1352
1353         return (0);
1354 }
1355
1356 /*
1357  * Set the internal state
1358  */
1359 static int
1360 kbdmux_set_state(keyboard_t *kbd, void *buf, size_t len)
1361 {
1362         if (len < sizeof(kbdmux_state_t))
1363                 return (ENOMEM);
1364
1365         bcopy(buf, kbd->kb_data, sizeof(kbdmux_state_t)); /* XXX locking? */
1366
1367         return (0);
1368 }
1369
1370 /*
1371  * Set polling
1372  */
1373 static int
1374 kbdmux_poll(keyboard_t *kbd, int on)
1375 {
1376         kbdmux_state_t  *state = (kbdmux_state_t *) kbd->kb_data;
1377         kbdmux_kbd_t    *k;
1378
1379         KBDMUX_LOCK(state);
1380
1381         if (on)
1382                 state->ks_polling++;
1383         else
1384                 state->ks_polling--;
1385
1386         /* set poll on slave keyboards */
1387         SLIST_FOREACH(k, &state->ks_kbds, next)
1388                 kbdd_poll(k->kbd, on);
1389
1390         KBDMUX_UNLOCK(state);
1391
1392         return (0);
1393 }
1394
1395 #ifdef EVDEV_SUPPORT
1396 static void
1397 kbdmux_ev_event(struct evdev_dev *evdev, uint16_t type, uint16_t code,
1398     int32_t value)
1399 {
1400         keyboard_t *kbd = evdev_get_softc(evdev);
1401
1402         if (evdev_rcpt_mask & EVDEV_RCPT_KBDMUX &&
1403             (type == EV_LED || type == EV_REP)) {
1404                 mtx_lock(&Giant);
1405                 kbd_ev_event(kbd, type, code, value);
1406                 mtx_unlock(&Giant);
1407         }
1408 }
1409 #endif
1410
1411 /*****************************************************************************
1412  *****************************************************************************
1413  **                                    Module
1414  *****************************************************************************
1415  *****************************************************************************/
1416
1417 KEYBOARD_DRIVER(kbdmux, kbdmuxsw, kbdmux_configure);
1418
1419 static int
1420 kbdmux_modevent(module_t mod, int type, void *data)
1421 {
1422         keyboard_switch_t       *sw;
1423         keyboard_t              *kbd;
1424         int                      error;
1425
1426         switch (type) {
1427         case MOD_LOAD:
1428                 if ((error = kbd_add_driver(&kbdmux_kbd_driver)) != 0)
1429                         break;
1430
1431                 if ((sw = kbd_get_switch(KEYBOARD_NAME)) == NULL) {
1432                         kbd_delete_driver(&kbdmux_kbd_driver);
1433                         error = ENXIO;
1434                         break;
1435                 }
1436
1437                 kbd = NULL;
1438
1439                 if ((error = (*sw->probe)(0, NULL, 0)) != 0 ||
1440                     (error = (*sw->init)(0, &kbd, NULL, 0)) != 0) {
1441                         kbd_delete_driver(&kbdmux_kbd_driver);
1442                         break;
1443                 }
1444
1445 #ifdef KBD_INSTALL_CDEV
1446                 if ((error = kbd_attach(kbd)) != 0) {
1447                         (*sw->term)(kbd);
1448                         kbd_delete_driver(&kbdmux_kbd_driver);
1449                         break;
1450                 }
1451 #endif
1452
1453                 if ((error = (*sw->enable)(kbd)) != 0) {
1454                         (*sw->disable)(kbd);
1455 #ifdef KBD_INSTALL_CDEV
1456                         kbd_detach(kbd);
1457 #endif
1458                         (*sw->term)(kbd);
1459                         kbd_delete_driver(&kbdmux_kbd_driver);
1460                         break;
1461                 }
1462                 break;
1463
1464         case MOD_UNLOAD:
1465                 if ((sw = kbd_get_switch(KEYBOARD_NAME)) == NULL)
1466                         panic("kbd_get_switch(" KEYBOARD_NAME ") == NULL");
1467
1468                 kbd = kbd_get_keyboard(kbd_find_keyboard(KEYBOARD_NAME, 0));
1469                 if (kbd != NULL) {
1470                         (*sw->disable)(kbd);
1471 #ifdef KBD_INSTALL_CDEV
1472                         kbd_detach(kbd);
1473 #endif
1474                         (*sw->term)(kbd);
1475                         kbd_delete_driver(&kbdmux_kbd_driver);
1476                 }
1477                 error = 0;
1478                 break;
1479
1480         default:
1481                 error = EOPNOTSUPP;
1482                 break;
1483         }
1484
1485         return (error);
1486 }
1487
1488 DEV_MODULE(kbdmux, kbdmux_modevent, NULL);
1489 #ifdef EVDEV_SUPPORT
1490 MODULE_DEPEND(kbdmux, evdev, 1, 1, 1);
1491 #endif