root/dev/wscons/wskbd.c

DEFINITIONS

1. wskbd_update_layout
2. wskbddevprint
3. wskbd_match
4. wskbd_attach
5. wskbd_cnattach
6. wskbd_cndetach
7. wskbd_repeat
8. wskbd_activate
9. wskbd_detach
10. wskbd_input
11. wskbd_deliver_event
12. wskbd_rawinput
13. wskbd_holdscreen
14. wskbd_enable
15. wskbd_mux_open
16. wskbdopen
17. wskbd_do_open
18. wskbdclose
19. wskbd_mux_close
20. wskbdread
21. wskbdioctl
22. wskbd_do_ioctl
23. wskbd_do_ioctl_sc
24. wskbd_displayioctl
25. wskbdpoll
26. wskbd_pickfree
27. wskbd_set_console_display
28. wskbd_set_display
29. wskbd_add_mux
30. wskbd_cngetc
31. wskbd_cnpollc
32. wskbd_cnbell
33. update_leds
34. update_modifier
35. change_displayparam
36. internal_command
37. wskbd_translate

    1 /* $OpenBSD: wskbd.c,v 1.56 2007/06/02 07:19:28 tedu Exp $ */
    2 /* $NetBSD: wskbd.c,v 1.80 2005/05/04 01:52:16 augustss Exp $ */
    4 /*
    5  * Copyright (c) 1996, 1997 Christopher G. Demetriou.  All rights reserved.
    6  *
    7  * Keysym translator:
    8  * Contributed to The NetBSD Foundation by Juergen Hannken-Illjes.
    9  *
   10  * Redistribution and use in source and binary forms, with or without
   11  * modification, are permitted provided that the following conditions
   12  * are met:
   13  * 1. Redistributions of source code must retain the above copyright
   14  *    notice, this list of conditions and the following disclaimer.
   15  * 2. Redistributions in binary form must reproduce the above copyright
   16  *    notice, this list of conditions and the following disclaimer in the
   17  *    documentation and/or other materials provided with the distribution.
   18  * 3. All advertising materials mentioning features or use of this software
   19  *    must display the following acknowledgement:
   20  *      This product includes software developed by Christopher G. Demetriou
   21  *      for the NetBSD Project.
   22  * 4. The name of the author may not be used to endorse or promote products
   23  *    derived from this software without specific prior written permission
   24  *
   25  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   26  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   27  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   28  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   29  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   30  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   31  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   32  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   33  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   34  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   35  */
   37 /*
   38  * Copyright (c) 1992, 1993
   39  *      The Regents of the University of California.  All rights reserved.
   40  *
   41  * This software was developed by the Computer Systems Engineering group
   42  * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
   43  * contributed to Berkeley.
   44  *
   45  * All advertising materials mentioning features or use of this software
   46  * must display the following acknowledgement:
   47  *      This product includes software developed by the University of
   48  *      California, Lawrence Berkeley Laboratory.
   49  *
   50  * Redistribution and use in source and binary forms, with or without
   51  * modification, are permitted provided that the following conditions
   52  * are met:
   53  * 1. Redistributions of source code must retain the above copyright
   54  *    notice, this list of conditions and the following disclaimer.
   55  * 2. Redistributions in binary form must reproduce the above copyright
   56  *    notice, this list of conditions and the following disclaimer in the
   57  *    documentation and/or other materials provided with the distribution.
   58  * 3. Neither the name of the University nor the names of its contributors
   59  *    may be used to endorse or promote products derived from this software
   60  *    without specific prior written permission.
   61  *
   62  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   63  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   64  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   65  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   66  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   67  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   68  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   69  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   70  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   71  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   72  * SUCH DAMAGE.
   73  *
   74  *      @(#)kbd.c       8.2 (Berkeley) 10/30/93
   75  */
   77 /*
   78  * Keyboard driver (/dev/wskbd*).  Translates incoming bytes to ASCII or
   79  * to `wscons_events' and passes them up to the appropriate reader.
   80  */
   82 #include <sys/param.h>
   83 #include <sys/conf.h>
   84 #include <sys/device.h>
   85 #include <sys/ioctl.h>
   86 #include <sys/kernel.h>
   87 #include <sys/proc.h>
   88 #include <sys/syslog.h>
   89 #include <sys/systm.h>
   90 #include <sys/timeout.h>
   91 #include <sys/malloc.h>
   92 #include <sys/tty.h>
   93 #include <sys/signalvar.h>
   94 #include <sys/errno.h>
   95 #include <sys/fcntl.h>
   96 #include <sys/vnode.h>
   97 #include <sys/poll.h>
   98 #include <sys/workq.h>
  100 #include <ddb/db_var.h>
  102 #include <dev/wscons/wsconsio.h>
  103 #include <dev/wscons/wskbdvar.h>
  104 #include <dev/wscons/wsksymdef.h>
  105 #include <dev/wscons/wsksymvar.h>
  106 #include <dev/wscons/wsdisplayvar.h>
  107 #include <dev/wscons/wseventvar.h>
  108 #include <dev/wscons/wscons_callbacks.h>
  110 #include "audio.h"              /* NAUDIO (mixer tuning) */
  111 #include "wsdisplay.h"
  112 #include "wskbd.h"
  113 #include "wsmux.h"
  115 #ifndef SMALL_KERNEL
  116 #define BURNER_SUPPORT
  117 #define SCROLLBACK_SUPPORT
  118 #endif
  120 #ifdef WSKBD_DEBUG
  121 #define DPRINTF(x)      if (wskbddebug) printf x
  122 int     wskbddebug = 0;
  123 #else
  124 #define DPRINTF(x)
  125 #endif
  127 #include <dev/wscons/wsmuxvar.h>
  129 struct wskbd_internal {
  130         const struct wskbd_mapdata *t_keymap;
  132         const struct wskbd_consops *t_consops;
  133         void    *t_consaccesscookie;
  135         int     t_modifiers;
  136         int     t_composelen;           /* remaining entries in t_composebuf */
keysym_t t_composebuf[2];
  139         int     t_flags;
  140 #define WSKFL_METAESC 1
  142 #define MAXKEYSYMSPERKEY 2 /* ESC <key> at max */
keysym_t t_symbols[MAXKEYSYMSPERKEY];
  145         struct wskbd_softc *t_sc;       /* back pointer */
  146 };
  148 struct wskbd_softc {
  149         struct wsevsrc  sc_base;
  151         struct wskbd_internal *id;
  153         const struct wskbd_accessops *sc_accessops;
  154         void *sc_accesscookie;
  156         int     sc_ledstate;
  158         int     sc_isconsole;
  160         struct wskbd_bell_data sc_bell_data;
  161         struct wskbd_keyrepeat_data sc_keyrepeat_data;
  163         int     sc_repeating;           /* we've called timeout() */
  164         int     sc_repkey;
  165         struct timeout sc_repeat_ch;
u_int   sc_repeat_type;
  167         int     sc_repeat_value;
  169         int     sc_translating;         /* xlate to chars for emulation */
  171         int     sc_maplen;              /* number of entries in sc_map */
  172         struct wscons_keymap *sc_map;   /* current translation map */
kbd_t   sc_layout; /* current layout */
  175         int     sc_refcnt;
u_char  sc_dying;               /* device is being detached */
  177 };
  179 #define MOD_SHIFT_L             (1 << 0)
  180 #define MOD_SHIFT_R             (1 << 1)
  181 #define MOD_SHIFTLOCK           (1 << 2)
  182 #define MOD_CAPSLOCK            (1 << 3)
  183 #define MOD_CONTROL_L           (1 << 4)
  184 #define MOD_CONTROL_R           (1 << 5)
  185 #define MOD_META_L              (1 << 6)
  186 #define MOD_META_R              (1 << 7)
  187 #define MOD_MODESHIFT           (1 << 8)
  188 #define MOD_NUMLOCK             (1 << 9)
  189 #define MOD_COMPOSE             (1 << 10)
  190 #define MOD_HOLDSCREEN          (1 << 11)
  191 #define MOD_COMMAND             (1 << 12)
  192 #define MOD_COMMAND1            (1 << 13)
  193 #define MOD_COMMAND2            (1 << 14)
  194 #define MOD_MODELOCK            (1 << 15)
  196 #define MOD_ANYSHIFT            (MOD_SHIFT_L | MOD_SHIFT_R | MOD_SHIFTLOCK)
  197 #define MOD_ANYCONTROL          (MOD_CONTROL_L | MOD_CONTROL_R)
  198 #define MOD_ANYMETA             (MOD_META_L | MOD_META_R)
  200 #define MOD_ONESET(id, mask)    (((id)->t_modifiers & (mask)) != 0)
  201 #define MOD_ALLSET(id, mask)    (((id)->t_modifiers & (mask)) == (mask))
keysym_t ksym_upcase(keysym_t);
  205 int     wskbd_match(struct device *, void *, void *);
  206 void    wskbd_attach(struct device *, struct device *, void *);
  207 int     wskbd_detach(struct device *, int);
  208 int     wskbd_activate(struct device *, enum devact);
  210 int     wskbd_displayioctl(struct device *, u_long, caddr_t, int, struct proc *);
  212 void    update_leds(struct wskbd_internal *);
  213 void    update_modifier(struct wskbd_internal *, u_int, int, int);
  214 int     internal_command(struct wskbd_softc *, u_int *, keysym_t, keysym_t);
  215 int     wskbd_translate(struct wskbd_internal *, u_int, int);
  216 int     wskbd_enable(struct wskbd_softc *, int);
  217 #if NWSDISPLAY > 0
  218 void    change_displayparam(struct wskbd_softc *, int, int, int);
  219 void    wskbd_holdscreen(struct wskbd_softc *, int);
  220 #endif
  222 int     wskbd_do_ioctl_sc(struct wskbd_softc *, u_long, caddr_t, int,
  223             struct proc *);
  224 void    wskbd_deliver_event(struct wskbd_softc *sc, u_int type, int value);
  226 #if NWSMUX > 0
  227 int     wskbd_mux_open(struct wsevsrc *, struct wseventvar *);
  228 int     wskbd_mux_close(struct wsevsrc *);
  229 #else
  230 #define wskbd_mux_open NULL
  231 #define wskbd_mux_close NULL
  232 #endif
  234 int     wskbd_do_open(struct wskbd_softc *, struct wseventvar *);
  235 int     wskbd_do_ioctl(struct device *, u_long, caddr_t, int, struct proc *);
  237 struct cfdriver wskbd_cd = {
NULL, "wskbd", DV_TTY
  239 };
  241 struct cfattach wskbd_ca = {
  242         sizeof (struct wskbd_softc), wskbd_match, wskbd_attach,
wskbd_detach, wskbd_activate
  244 };
  246 extern int kbd_reset;
  248 #ifndef WSKBD_DEFAULT_BELL_PITCH
  249 #define WSKBD_DEFAULT_BELL_PITCH        400     /* 400Hz */
  250 #endif
  251 #ifndef WSKBD_DEFAULT_BELL_PERIOD
  252 #define WSKBD_DEFAULT_BELL_PERIOD       100     /* 100ms */
  253 #endif
  254 #ifndef WSKBD_DEFAULT_BELL_VOLUME
  255 #define WSKBD_DEFAULT_BELL_VOLUME       50      /* 50% volume */
  256 #endif
  258 struct wskbd_bell_data wskbd_default_bell_data = {
WSKBD_BELL_DOALL,
WSKBD_DEFAULT_BELL_PITCH,
WSKBD_DEFAULT_BELL_PERIOD,
WSKBD_DEFAULT_BELL_VOLUME,
  263 };
  265 #ifndef WSKBD_DEFAULT_KEYREPEAT_DEL1
  266 #define WSKBD_DEFAULT_KEYREPEAT_DEL1    400     /* 400ms to start repeating */
  267 #endif
  268 #ifndef WSKBD_DEFAULT_KEYREPEAT_DELN
  269 #define WSKBD_DEFAULT_KEYREPEAT_DELN    100     /* 100ms to between repeats */
  270 #endif
  272 struct wskbd_keyrepeat_data wskbd_default_keyrepeat_data = {
WSKBD_KEYREPEAT_DOALL,
WSKBD_DEFAULT_KEYREPEAT_DEL1,
WSKBD_DEFAULT_KEYREPEAT_DELN,
  276 };
  278 #if NWSMUX > 0 || NWSDISPLAY > 0
  279 struct wssrcops wskbd_srcops = {
WSMUX_KBD,
wskbd_mux_open, wskbd_mux_close, wskbd_do_ioctl,
wskbd_displayioctl,
  283 #if NWSDISPLAY > 0
wskbd_set_display
  285 #else
NULL
  287 #endif
  288 };
  289 #endif
  291 #if NWSDISPLAY > 0
  292 void wskbd_repeat(void *v);
  293 #endif
  295 static int wskbd_console_initted;
  296 static struct wskbd_softc *wskbd_console_device;
  297 static struct wskbd_internal wskbd_console_data;
  299 void    wskbd_update_layout(struct wskbd_internal *, kbd_t);
  301 #if NAUDIO > 0
  302 extern int wskbd_set_mixervolume(long dir);
  303 #endif
  305 void
wskbd_update_layout(struct wskbd_internal *id, kbd_t enc)
  307 {
  308         if (enc & KB_METAESC)
id->t_flags |= WSKFL_METAESC;
  310         else
id->t_flags &= ~WSKFL_METAESC;
  312 }
  314 /*
  315  * Print function (for parent devices).
  316  */
  317 int
wskbddevprint(void *aux, const char *pnp)
  319 {
  320 #if 0
  321         struct wskbddev_attach_args *ap = aux;
  322 #endif
  324         if (pnp)
printf("wskbd at %s", pnp);
  326 #if 0
printf(" console %d", ap->console);
  328 #endif
  330         return (UNCONF);
  331 }
  333 int
wskbd_match(struct device *parent, void *match, void *aux)
  335 {
  336         struct cfdata *cf = match;
  337         struct wskbddev_attach_args *ap = aux;
  339         if (cf->wskbddevcf_console != WSKBDDEVCF_CONSOLE_UNK) {
  340                 /*
  341                  * If console-ness of device specified, either match
  342                  * exactly (at high priority), or fail.
  343                  */
  344                 if (cf->wskbddevcf_console != 0 && ap->console != 0)
  345                         return (10);
  346                 else
  347                         return (0);
  348         }
  350         /* If console-ness unspecified, it wins. */
  351         return (1);
  352 }
  354 void
wskbd_attach(struct device *parent, struct device *self, void *aux)
  356 {
  357         struct wskbd_softc *sc = (struct wskbd_softc *)self;
  358         struct wskbddev_attach_args *ap = aux;
  359 #if NWSMUX > 0
  360         int mux, error;
  361 #endif
sc->sc_isconsole = ap->console;
  365 #if NWSMUX > 0 || NWSDISPLAY > 0
sc->sc_base.me_ops = &wskbd_srcops;
  367 #endif
  368 #if NWSMUX > 0
mux = sc->sc_base.me_dv.dv_cfdata->wskbddevcf_mux;
  370         if (ap->console) {
  371                 /* Ignore mux for console; it always goes to the console mux. */
  372                 /* printf(" (mux %d ignored for console)", mux); */
mux = -1;
  374         }
  375         if (mux >= 0)
printf(" mux %d", mux);
  377 #else
  378 #if 0   /* not worth keeping, especially since the default value is not -1... */
  379         if (sc->sc_base.me_dv.dv_cfdata->wskbddevcf_mux >= 0)
printf(" (mux ignored)");
  381 #endif
  382 #endif  /* NWSMUX > 0 */
  384         if (ap->console) {
sc->id = &wskbd_console_data;
  386         } else {
sc->id = malloc(sizeof(struct wskbd_internal),
M_DEVBUF, M_WAITOK);
bzero(sc->id, sizeof(struct wskbd_internal));
sc->id->t_keymap = ap->keymap;
wskbd_update_layout(sc->id, ap->keymap->layout);
  392         }
  394 #if NWSDISPLAY > 0
timeout_set(&sc->sc_repeat_ch, wskbd_repeat, sc);
  396 #endif
sc->id->t_sc = sc;
sc->sc_accessops = ap->accessops;
sc->sc_accesscookie = ap->accesscookie;
sc->sc_repeating = 0;
sc->sc_translating = 1;
sc->sc_ledstate = -1; /* force update */
  406         if (wskbd_load_keymap(sc->id->t_keymap,
  407             &sc->sc_map, &sc->sc_maplen) != 0)
panic("cannot load keymap");
sc->sc_layout = sc->id->t_keymap->layout;
  412         /* set default bell and key repeat data */
sc->sc_bell_data = wskbd_default_bell_data;
sc->sc_keyrepeat_data = wskbd_default_keyrepeat_data;
  416         if (ap->console) {
KASSERT(wskbd_console_initted); 
KASSERT(wskbd_console_device == NULL);
wskbd_console_device = sc;
printf(": console keyboard");
  424 #if NWSDISPLAY > 0
wsdisplay_set_console_kbd(&sc->sc_base); /* sets me_dispdv */
  426                 if (sc->sc_displaydv != NULL)
printf(", using %s", sc->sc_displaydv->dv_xname);
  428 #endif
  429         }
printf("\n");
  432 #if NWSMUX > 0
  433         if (mux >= 0) {
error = wsmux_attach_sc(wsmux_getmux(mux), &sc->sc_base);
  435                 if (error)
printf("%s: attach error=%d\n",
sc->sc_base.me_dv.dv_xname, error);
  438         }
  439 #endif
  441 #if WSDISPLAY > 0 && NWSMUX == 0
  442         if (ap->console == 0) {
  443                 /*
  444                  * In the non-wsmux world, always connect wskbd0 and wsdisplay0
  445                  * together.
  446                  */
  447                 extern struct cfdriver wsdisplay_cd;
  449                 if (wsdisplay_cd.cd_ndevs != 0 && self->dv_unit == 0) {
  450                         if (wskbd_set_display(self,
wsdisplay_cd.cd_devs[0]) == 0)
wsdisplay_set_kbd(wsdisplay_cd.cd_devs[0],
  453                                     (struct wsevsrc *)sc);
  454                 }
  455         }
  456 #endif
  458 }
  460 void    
wskbd_cnattach(const struct wskbd_consops *consops, void *conscookie,
  462     const struct wskbd_mapdata *mapdata)
  463 {
KASSERT(!wskbd_console_initted);
wskbd_console_data.t_keymap = mapdata;
wskbd_update_layout(&wskbd_console_data, mapdata->layout);
wskbd_console_data.t_consops = consops;
wskbd_console_data.t_consaccesscookie = conscookie;
  473 #if NWSDISPLAY > 0
wsdisplay_set_cons_kbd(wskbd_cngetc, wskbd_cnpollc, wskbd_cnbell);
  475 #endif
wskbd_console_initted = 1;
  478 }
  480 void    
wskbd_cndetach()
  482 {
KASSERT(wskbd_console_initted);
wskbd_console_data.t_keymap = 0;
wskbd_console_data.t_consops = 0;
wskbd_console_data.t_consaccesscookie = 0;
  490 #if NWSDISPLAY > 0
wsdisplay_unset_cons_kbd();
  492 #endif
wskbd_console_initted = 0;
  495 }
  497 #if NWSDISPLAY > 0
  498 void
wskbd_repeat(void *v)
  500 {
  501         struct wskbd_softc *sc = (struct wskbd_softc *)v;
  502         int s = spltty();
  504         if (!sc->sc_repeating) {
  505                 /*
  506                  * race condition: a "key up" event came in when wskbd_repeat()
  507                  * was already called but not yet spltty()'d
  508                  */
splx(s);
  510                 return;
  511         }
  512         if (sc->sc_translating) {
  513                 /* deliver keys */
  514                 if (sc->sc_base.me_dispdv != NULL) {
  515                         int i;
  516                         for (i = 0; i < sc->sc_repeating; i++)
wsdisplay_kbdinput(sc->sc_base.me_dispdv,
sc->id->t_symbols[i]);
  519                 }
  520         } else {
  521                 /* queue event */
wskbd_deliver_event(sc, sc->sc_repeat_type,
sc->sc_repeat_value);
  524         }
  525         if (sc->sc_keyrepeat_data.delN != 0)
timeout_add(&sc->sc_repeat_ch,
  527                     (hz * sc->sc_keyrepeat_data.delN) / 1000);
splx(s);
  529 }
  530 #endif
  532 int
wskbd_activate(struct device *self, enum devact act)
  534 {
  535         struct wskbd_softc *sc = (struct wskbd_softc *)self;
  537         if (act == DVACT_DEACTIVATE)
sc->sc_dying = 1;
  539         return (0);
  540 }
  542 /*
  543  * Detach a keyboard.  To keep track of users of the softc we keep
  544  * a reference count that's incremented while inside, e.g., read.
  545  * If the keyboard is active and the reference count is > 0 (0 is the
  546  * normal state) we post an event and then wait for the process
  547  * that had the reference to wake us up again.  Then we blow away the
  548  * vnode and return (which will deallocate the softc).
  549  */
  550 int
wskbd_detach(struct device  *self, int flags)
  552 {
  553         struct wskbd_softc *sc = (struct wskbd_softc *)self;
  554         struct wseventvar *evar;
  555         int maj, mn;
  556         int s;
  558 #if NWSMUX > 0
  559         /* Tell parent mux we're leaving. */
  560         if (sc->sc_base.me_parent != NULL)
wsmux_detach_sc(&sc->sc_base);
  562 #endif
  564 #if NWSDISPLAY > 0
  565         if (sc->sc_repeating) {
sc->sc_repeating = 0;
timeout_del(&sc->sc_repeat_ch);
  568         }
  569 #endif
  571         if (sc->sc_isconsole) {
KASSERT(wskbd_console_device == sc);
wskbd_console_device = NULL;
  574         }
evar = sc->sc_base.me_evp;
  577         if (evar != NULL && evar->io != NULL) {
s = spltty();
  579                 if (--sc->sc_refcnt >= 0) {
  580                         /* Wake everyone by generating a dummy event. */
  581                         if (++evar->put >= WSEVENT_QSIZE)
evar->put = 0;
WSEVENT_WAKEUP(evar);
  584                         /* Wait for processes to go away. */
  585                         if (tsleep(sc, PZERO, "wskdet", hz * 60))
printf("wskbd_detach: %s didn't detach\n",
sc->sc_base.me_dv.dv_xname);
  588                 }
splx(s);
  590         }
  592         /* locate the major number */
  593         for (maj = 0; maj < nchrdev; maj++)
  594                 if (cdevsw[maj].d_open == wskbdopen)
  595                         break;
  597         /* Nuke the vnodes for any open instances. */
mn = self->dv_unit;
vdevgone(maj, mn, mn, VCHR);
  601         return (0);
  602 }
  604 void
wskbd_input(struct device *dev, u_int type, int value)
  606 {
  607         struct wskbd_softc *sc = (struct wskbd_softc *)dev; 
  608 #if NWSDISPLAY > 0
  609         int num, i;
  610 #endif
  612 #if NWSDISPLAY > 0
  613         if (sc->sc_repeating) {
sc->sc_repeating = 0;
timeout_del(&sc->sc_repeat_ch);
  616         }
  618         /*
  619          * If /dev/wskbdN is not connected in event mode translate and
  620          * send upstream.
  621          */
  622         if (sc->sc_translating) {
  623 #ifdef BURNER_SUPPORT
  624                 if (type == WSCONS_EVENT_KEY_DOWN && sc->sc_displaydv != NULL)
wsdisplay_burn(sc->sc_displaydv, WSDISPLAY_BURN_KBD);
  626 #endif
num = wskbd_translate(sc->id, type, value);
  628                 if (num > 0) {
  629                         if (sc->sc_base.me_dispdv != NULL) {
  630 #ifdef SCROLLBACK_SUPPORT
  631                                 /* XXX - Shift_R+PGUP(release) emits PrtSc */
  632                                 if (sc->id->t_symbols[0] != KS_Print_Screen) {
wsscrollback(sc->sc_base.me_dispdv,
WSDISPLAY_SCROLL_RESET);
  635                                 }
  636 #endif
  637                                 for (i = 0; i < num; i++) {
wsdisplay_kbdinput(sc->sc_base.me_dispdv,
sc->id->t_symbols[i]);
  640                                 }
  641                         }
  643                         if (sc->sc_keyrepeat_data.del1 != 0) {
sc->sc_repeating = num;
timeout_add(&sc->sc_repeat_ch,
  646                                     (hz * sc->sc_keyrepeat_data.del1) / 1000);
  647                         }
  648                 }
  649                 return;
  650         }
  651 #endif
wskbd_deliver_event(sc, type, value);
  655 #if NWSDISPLAY > 0
  656         /* Repeat key presses if enabled. */
  657         if (type == WSCONS_EVENT_KEY_DOWN && sc->sc_keyrepeat_data.del1 != 0) {
sc->sc_repeat_type = type;
sc->sc_repeat_value = value;
sc->sc_repeating = 1;
timeout_add(&sc->sc_repeat_ch,
  662                     (hz * sc->sc_keyrepeat_data.del1) / 1000);
  663         }
  664 #endif
  665 }
  667 /*
  668  * Keyboard is generating events.  Turn this keystroke into an
  669  * event and put it in the queue.  If the queue is full, the
  670  * keystroke is lost (sorry!).
  671  */
  672 void
wskbd_deliver_event(struct wskbd_softc *sc, u_int type, int value)
  674 {
  675         struct wseventvar *evar;
  676         struct wscons_event *ev;
  677         int put;
evar = sc->sc_base.me_evp;
  681         if (evar == NULL) {
DPRINTF(("wskbd_input: not open\n"));
  683                 return;
  684         }
  686 #ifdef DIAGNOSTIC
  687         if (evar->q == NULL) {
printf("wskbd_input: evar->q=NULL\n");
  689                 return;
  690         }
  691 #endif
put = evar->put;
ev = &evar->q[put];
put = (put + 1) % WSEVENT_QSIZE;
  696         if (put == evar->get) {
log(LOG_WARNING, "%s: event queue overflow\n",
sc->sc_base.me_dv.dv_xname);
  699                 return;
  700         }
ev->type = type;
ev->value = value;
nanotime(&ev->time);
evar->put = put;
WSEVENT_WAKEUP(evar);
  706 }
  708 #ifdef WSDISPLAY_COMPAT_RAWKBD
  709 void
wskbd_rawinput(struct device *dev, u_char *buf, int len)
  711 {
  712 #if NWSDISPLAY > 0
  713         struct wskbd_softc *sc = (struct wskbd_softc *)dev;
  714         int i;
  716         if (sc->sc_base.me_dispdv != NULL)
  717                 for (i = 0; i < len; i++)
wsdisplay_kbdinput(sc->sc_base.me_dispdv, buf[i]);
  719         /* this is KS_GROUP_Ascii */
  720 #endif
  721 }
  722 #endif /* WSDISPLAY_COMPAT_RAWKBD */
  724 #if NWSDISPLAY > 0
  725 void
wskbd_holdscreen(struct wskbd_softc *sc, int hold)
  727 {
  728         int new_state;
  730         if (sc->sc_base.me_dispdv != NULL) {
wsdisplay_kbdholdscreen(sc->sc_base.me_dispdv, hold);
new_state = sc->sc_ledstate;
  733                 if (hold)
new_state |= WSKBD_LED_SCROLL;
  735                 else
new_state &= ~WSKBD_LED_SCROLL;
  737                 if (new_state != sc->sc_ledstate) {
  738                         (*sc->sc_accessops->set_leds)(sc->sc_accesscookie,
new_state);
sc->sc_ledstate = new_state;
  741                 }
  742         }
  743 }
  744 #endif
  746 int
wskbd_enable(struct wskbd_softc *sc, int on)
  748 {
  749         int error;
  751 #if NWSDISPLAY > 0
  752         if (sc->sc_base.me_dispdv != NULL)
  753                 return (0);
  755         /* Always cancel auto repeat when fiddling with the kbd. */
  756         if (sc->sc_repeating) {
sc->sc_repeating = 0;
timeout_del(&sc->sc_repeat_ch);
  759         }
  760 #endif
error = (*sc->sc_accessops->enable)(sc->sc_accesscookie, on);
DPRINTF(("wskbd_enable: sc=%p on=%d res=%d\n", sc, on, error));
  764         return (error);
  765 }
  767 #if NWSMUX > 0
  768 int
wskbd_mux_open(struct wsevsrc *me, struct wseventvar *evp)
  770 {
  771         struct wskbd_softc *sc = (struct wskbd_softc *)me;
  773         if (sc->sc_dying)
  774                 return (EIO);
  776         if (sc->sc_base.me_evp != NULL)
  777                 return (EBUSY);
  779         return (wskbd_do_open(sc, evp));
  780 }
  781 #endif
  783 int
wskbdopen(dev_t dev, int flags, int mode, struct proc *p)
  785 {
  786         struct wskbd_softc *sc;
  787         struct wseventvar *evar;
  788         int unit, error;
unit = minor(dev);
  791         if (unit >= wskbd_cd.cd_ndevs ||        /* make sure it was attached */
  792             (sc = wskbd_cd.cd_devs[unit]) == NULL)
  793                 return (ENXIO);
  795 #if NWSMUX > 0
DPRINTF(("wskbdopen: %s mux=%p p=%p\n", sc->sc_base.me_dv.dv_xname,
sc->sc_base.me_parent, p));
  798 #endif
  800         if (sc->sc_dying)
  801                 return (EIO);
  803         if ((flags & (FREAD | FWRITE)) == FWRITE) {
  804                 /* Not opening for read, only ioctl is available. */
  805                 return (0);
  806         }
  808 #if NWSMUX > 0
  809         if (sc->sc_base.me_parent != NULL) {
  810                 /* Grab the keyboard out of the greedy hands of the mux. */
DPRINTF(("wskbdopen: detach\n"));
wsmux_detach_sc(&sc->sc_base);
  813         }
  814 #endif
  816         if (sc->sc_base.me_evp != NULL)
  817                 return (EBUSY);
evar = &sc->sc_base.me_evar;
wsevent_init(evar);
evar->io = p;
error = wskbd_do_open(sc, evar);
  824         if (error) {
DPRINTF(("wskbdopen: %s open failed\n",
sc->sc_base.me_dv.dv_xname));
sc->sc_base.me_evp = NULL;
wsevent_fini(evar);
  829         }
  830         return (error);
  831 }
  833 int
wskbd_do_open(struct wskbd_softc *sc, struct wseventvar *evp)
  835 {
sc->sc_base.me_evp = evp;
sc->sc_translating = 0;
  839         return (wskbd_enable(sc, 1));
  840 }
  842 int
  843 wskbdclose(dev_t dev, int flags, int mode, struct proc *p)
  844 {
  845         struct wskbd_softc *sc =
  846             (struct wskbd_softc *)wskbd_cd.cd_devs[minor(dev)];
  847         struct wseventvar *evar = sc->sc_base.me_evp;
  849         if (evar == NULL)
  850                 /* not open for read */
  851                 return (0);
sc->sc_base.me_evp = NULL;
sc->sc_translating = 1;
  855         (void)wskbd_enable(sc, 0);
wsevent_fini(evar);
  858         return (0);
  859 }
  861 #if NWSMUX > 0
  862 int
wskbd_mux_close(struct wsevsrc *me)
  864 {
  865         struct wskbd_softc *sc = (struct wskbd_softc *)me;
sc->sc_base.me_evp = NULL;
sc->sc_translating = 1;
  869         (void)wskbd_enable(sc, 0);
  871         return (0);
  872 }
  873 #endif
  875 int
  876 wskbdread(dev_t dev, struct uio *uio, int flags)
  877 {
  878         struct wskbd_softc *sc = wskbd_cd.cd_devs[minor(dev)];
  879         int error;
  881         if (sc->sc_dying)
  882                 return (EIO);
  884 #ifdef DIAGNOSTIC
  885         if (sc->sc_base.me_evp == NULL) {
printf("wskbdread: evp == NULL\n");
  887                 return (EINVAL);
  888         }
  889 #endif
sc->sc_refcnt++;
error = wsevent_read(&sc->sc_base.me_evar, uio, flags);
  893         if (--sc->sc_refcnt < 0) {
wakeup(sc);
error = EIO;
  896         }
  897         return (error);
  898 }
  900 int
  901 wskbdioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
  902 {
  903         return (wskbd_do_ioctl(wskbd_cd.cd_devs[minor(dev)], cmd, data, flag,p));
  904 }
  906 /* A wrapper around the ioctl() workhorse to make reference counting easy. */
  907 int
wskbd_do_ioctl(struct device *dv, u_long cmd, caddr_t data, int flag,
  909     struct proc *p)
  910 {
  911         struct wskbd_softc *sc = (struct wskbd_softc *)dv;
  912         int error;
sc->sc_refcnt++;
error = wskbd_do_ioctl_sc(sc, cmd, data, flag, p);
  916         if (--sc->sc_refcnt < 0)
wakeup(sc);
  918         return (error);
  919 }
  921 int
wskbd_do_ioctl_sc(struct wskbd_softc *sc, u_long cmd, caddr_t data, int flag,
  923      struct proc *p)
  924 {
  925         int error;
  927         /*      
  928          * Try the generic ioctls that the wskbd interface supports.
  929          */
  930         switch (cmd) {
  931         case FIONBIO:           /* we will remove this someday (soon???) */
  932                 return (0);
  934         case FIOASYNC:
  935                 if (sc->sc_base.me_evp == NULL)
  936                         return (EINVAL);
sc->sc_base.me_evp->async = *(int *)data != 0;
  938                 return (0);
  940         case FIOSETOWN:
  941                 if (sc->sc_base.me_evp == NULL)
  942                         return (EINVAL);
  943                 if (-*(int *)data != sc->sc_base.me_evp->io->p_pgid &&
  944                     *(int *)data != sc->sc_base.me_evp->io->p_pid)
  945                         return (EPERM);
  946                 return (0);
  948         case TIOCSPGRP:
  949                 if (sc->sc_base.me_evp == NULL)
  950                         return (EINVAL);
  951                 if (*(int *)data != sc->sc_base.me_evp->io->p_pgid)
  952                         return (EPERM);
  953                 return (0);
  954         }
  956         /*
  957          * Try the keyboard driver for WSKBDIO ioctls.  It returns -1
  958          * if it didn't recognize the request.
  959          */
error = wskbd_displayioctl(&sc->sc_base.me_dv, cmd, data, flag, p);
  961         return (error != -1 ? error : ENOTTY);
  962 }
  964 /*
  965  * WSKBDIO ioctls, handled in both emulation mode and in ``raw'' mode.
  966  * Some of these have no real effect in raw mode, however.
  967  */
  968 int
wskbd_displayioctl(struct device *dev, u_long cmd, caddr_t data, int flag,
  970     struct proc *p)
  971 {
  972         struct wskbd_softc *sc = (struct wskbd_softc *)dev;
  973         struct wskbd_bell_data *ubdp, *kbdp;
  974         struct wskbd_keyrepeat_data *ukdp, *kkdp;
  975         struct wskbd_map_data *umdp;
  976         struct wskbd_mapdata md;
kbd_t enc;
  978         void *buf;
  979         int len, error;
  981         switch (cmd) {
  982         case WSKBDIO_BELL:
  983         case WSKBDIO_COMPLEXBELL:
  984         case WSKBDIO_SETBELL:
  985         case WSKBDIO_SETKEYREPEAT:
  986         case WSKBDIO_SETDEFAULTKEYREPEAT:
  987         case WSKBDIO_SETMAP:
  988         case WSKBDIO_SETENCODING:
  989                 if ((flag & FWRITE) == 0)
  990                         return (EACCES);
  991         }
  993         switch (cmd) {
  994 #define SETBELL(dstp, srcp, dfltp)                                      \
  995     do {                                                                \
  996         (dstp)->pitch = ((srcp)->which & WSKBD_BELL_DOPITCH) ?          \
  997             (srcp)->pitch : (dfltp)->pitch;                             \
  998         (dstp)->period = ((srcp)->which & WSKBD_BELL_DOPERIOD) ?        \
  999             (srcp)->period : (dfltp)->period;                           \
 1000         (dstp)->volume = ((srcp)->which & WSKBD_BELL_DOVOLUME) ?        \
 1001             (srcp)->volume : (dfltp)->volume;                           \
 1002         (dstp)->which = WSKBD_BELL_DOALL;                               \
 1003     } while (0)
 1005         case WSKBDIO_BELL:
 1006                 return ((*sc->sc_accessops->ioctl)(sc->sc_accesscookie,
WSKBDIO_COMPLEXBELL, (caddr_t)&sc->sc_bell_data, flag, p));
 1009         case WSKBDIO_COMPLEXBELL:
ubdp = (struct wskbd_bell_data *)data;
SETBELL(ubdp, ubdp, &sc->sc_bell_data);
 1012                 return ((*sc->sc_accessops->ioctl)(sc->sc_accesscookie,
WSKBDIO_COMPLEXBELL, (caddr_t)ubdp, flag, p));
 1015         case WSKBDIO_SETBELL:
kbdp = &sc->sc_bell_data;
setbell:
ubdp = (struct wskbd_bell_data *)data;
SETBELL(kbdp, ubdp, kbdp);
 1020                 return (0);
 1022         case WSKBDIO_GETBELL:
kbdp = &sc->sc_bell_data;
getbell:
ubdp = (struct wskbd_bell_data *)data;
SETBELL(ubdp, kbdp, kbdp);
 1027                 return (0);
 1029         case WSKBDIO_SETDEFAULTBELL:
 1030                 if ((error = suser(p, 0)) != 0)
 1031                         return (error);
kbdp = &wskbd_default_bell_data;
 1033                 goto setbell;
 1036         case WSKBDIO_GETDEFAULTBELL:
kbdp = &wskbd_default_bell_data;
 1038                 goto getbell;
 1040 #undef SETBELL
 1042 #define SETKEYREPEAT(dstp, srcp, dfltp)                                 \
 1043     do {                                                                \
 1044         (dstp)->del1 = ((srcp)->which & WSKBD_KEYREPEAT_DODEL1) ?       \
 1045             (srcp)->del1 : (dfltp)->del1;                               \
 1046         (dstp)->delN = ((srcp)->which & WSKBD_KEYREPEAT_DODELN) ?       \
 1047             (srcp)->delN : (dfltp)->delN;                               \
 1048         (dstp)->which = WSKBD_KEYREPEAT_DOALL;                          \
 1049     } while (0)
 1051         case WSKBDIO_SETKEYREPEAT:
kkdp = &sc->sc_keyrepeat_data;
setkeyrepeat:
ukdp = (struct wskbd_keyrepeat_data *)data;
SETKEYREPEAT(kkdp, ukdp, kkdp);
 1056                 return (0);
 1058         case WSKBDIO_GETKEYREPEAT:
kkdp = &sc->sc_keyrepeat_data;
getkeyrepeat:
ukdp = (struct wskbd_keyrepeat_data *)data;
SETKEYREPEAT(ukdp, kkdp, kkdp);
 1063                 return (0);
 1065         case WSKBDIO_SETDEFAULTKEYREPEAT:
 1066                 if ((error = suser(p, 0)) != 0)
 1067                         return (error);
kkdp = &wskbd_default_keyrepeat_data;
 1069                 goto setkeyrepeat;
 1072         case WSKBDIO_GETDEFAULTKEYREPEAT:
kkdp = &wskbd_default_keyrepeat_data;
 1074                 goto getkeyrepeat;
 1076 #undef SETKEYREPEAT
 1078         case WSKBDIO_SETMAP:
umdp = (struct wskbd_map_data *)data;
 1080                 if (umdp->maplen > WSKBDIO_MAXMAPLEN)
 1081                         return (EINVAL);
len = umdp->maplen * sizeof(struct wscons_keymap);
buf = malloc(len, M_TEMP, M_WAITOK);
error = copyin(umdp->map, buf, len);
 1086                 if (error == 0) {
wskbd_init_keymap(umdp->maplen,
 1088                                           &sc->sc_map, &sc->sc_maplen);
memcpy(sc->sc_map, buf, len);
 1090                         /* drop the variant bits handled by the map */
sc->sc_layout = KB_USER |
 1092                               (KB_VARIANT(sc->sc_layout) & KB_HANDLEDBYWSKBD);
wskbd_update_layout(sc->id, sc->sc_layout);
 1094                 }
free(buf, M_TEMP);
 1096                 return(error);
 1098         case WSKBDIO_GETMAP:
umdp = (struct wskbd_map_data *)data;
 1100                 if (umdp->maplen > sc->sc_maplen)
umdp->maplen = sc->sc_maplen;
error = copyout(sc->sc_map, umdp->map,
umdp->maplen*sizeof(struct wscons_keymap));
 1104                 return(error);
 1106         case WSKBDIO_GETENCODING:
 1107                 *((kbd_t *) data) = sc->sc_layout;
 1108                 return(0);
 1110         case WSKBDIO_SETENCODING:
enc = *((kbd_t *)data);
 1112                 if (KB_ENCODING(enc) == KB_USER) {
 1113                         /* user map must already be loaded */
 1114                         if (KB_ENCODING(sc->sc_layout) != KB_USER)
 1115                                 return (EINVAL);
 1116                         /* map variants make no sense */
 1117                         if (KB_VARIANT(enc) & ~KB_HANDLEDBYWSKBD)
 1118                                 return (EINVAL);
 1119                 } else {
md = *(sc->id->t_keymap); /* structure assignment */
md.layout = enc;
error = wskbd_load_keymap(&md, &sc->sc_map,
 1123                                                   &sc->sc_maplen);
 1124                         if (error)
 1125                                 return(error);
 1126                 }
sc->sc_layout = enc;
wskbd_update_layout(sc->id, enc);
 1129                 return (0);
 1130         }
 1132         /*
 1133          * Try the keyboard driver for WSKBDIO ioctls.  It returns -1
 1134          * if it didn't recognize the request, and in turn we return
 1135          * -1 if we didn't recognize the request.
 1136          */
 1137 /* printf("kbdaccess\n"); */
error = (*sc->sc_accessops->ioctl)(sc->sc_accesscookie, cmd, data,
flag, p);
 1140 #ifdef WSDISPLAY_COMPAT_RAWKBD
 1141         if (!error && cmd == WSKBDIO_SETMODE && *(int *)data == WSKBD_RAW) {
 1142                 int s = spltty();
sc->id->t_modifiers &= ~(MOD_SHIFT_L | MOD_SHIFT_R
 1144                                          | MOD_CONTROL_L | MOD_CONTROL_R
 1145                                          | MOD_META_L | MOD_META_R
 1146                                          | MOD_COMMAND
 1147                                          | MOD_COMMAND1 | MOD_COMMAND2);
 1148 #if NWSDISPLAY > 0
 1149                 if (sc->sc_repeating) {
sc->sc_repeating = 0;
timeout_del(&sc->sc_repeat_ch);
 1152                 }
 1153 #endif
splx(s);
 1155         }
 1156 #endif
 1157         return (error);
 1158 }
 1160 int
 1161 wskbdpoll(dev_t dev, int events, struct proc *p)
 1162 {
 1163         struct wskbd_softc *sc = wskbd_cd.cd_devs[minor(dev)];
 1165         if (sc->sc_base.me_evp == NULL)
 1166                 return (POLLERR);
 1167         return (wsevent_poll(sc->sc_base.me_evp, events, p));
 1168 }
 1170 #if NWSDISPLAY > 0
 1172 int
wskbd_pickfree()
 1174 {
 1175         int i;
 1176         struct wskbd_softc *sc;
 1178         for (i = 0; i < wskbd_cd.cd_ndevs; i++) {
 1179                 if ((sc = wskbd_cd.cd_devs[i]) == NULL)
 1180                         continue;
 1181                 if (sc->sc_displaydv == NULL)
 1182                         return (i);
 1183         }
 1184         return (-1);
 1185 }
 1187 struct wsevsrc *
wskbd_set_console_display(struct device *displaydv, struct wsevsrc *me)
 1189 {
 1190         struct wskbd_softc *sc = wskbd_console_device;
 1192         if (sc == NULL)
 1193                 return (NULL);
sc->sc_base.me_dispdv = displaydv;
 1195 #if NWSMUX > 0
 1196         (void)wsmux_attach_sc((struct wsmux_softc *)me, &sc->sc_base);
 1197 #endif
 1198         return (&sc->sc_base);
 1199 }
 1201 int
wskbd_set_display(struct device *dv, struct device *displaydv)
 1203 {
 1204         struct wskbd_softc *sc = (struct wskbd_softc *)dv;
 1205         struct device *odisplaydv;
 1206         int error;
DPRINTF(("wskbd_set_display: %s odisp=%p disp=%p cons=%d\n",
dv->dv_xname, sc->sc_base.me_dispdv, displaydv, 
sc->sc_isconsole));
 1212         if (sc->sc_isconsole)
 1213                 return (EBUSY);
 1215         if (displaydv != NULL) {
 1216                 if (sc->sc_base.me_dispdv != NULL)
 1217                         return (EBUSY);
 1218         } else {
 1219                 if (sc->sc_base.me_dispdv == NULL)
 1220                         return (ENXIO);
 1221         }
odisplaydv = sc->sc_base.me_dispdv;
sc->sc_base.me_dispdv = NULL;
error = wskbd_enable(sc, displaydv != NULL);
sc->sc_base.me_dispdv = displaydv;
 1227         if (error) {
sc->sc_base.me_dispdv = odisplaydv;
 1229                 return (error);
 1230         }
 1232         if (displaydv)
printf("%s: connecting to %s\n",
sc->sc_base.me_dv.dv_xname, displaydv->dv_xname);
 1235         else
printf("%s: disconnecting from %s\n",
sc->sc_base.me_dv.dv_xname, odisplaydv->dv_xname);
 1239         return (0);
 1240 }
 1242 #endif  /* NWSDISPLAY > 0 */
 1244 #if NWSMUX > 0
 1245 int
wskbd_add_mux(int unit, struct wsmux_softc *muxsc)
 1247 {
 1248         struct wskbd_softc *sc;
 1250         if (unit < 0 || unit >= wskbd_cd.cd_ndevs ||
 1251             (sc = wskbd_cd.cd_devs[unit]) == NULL)
 1252                 return (ENXIO);
 1254         if (sc->sc_base.me_parent != NULL || sc->sc_base.me_evp != NULL)
 1255                 return (EBUSY);
 1257         return (wsmux_attach_sc(muxsc, &sc->sc_base));
 1258 }
 1259 #endif
 1261 /*
 1262  * Console interface.
 1263  */
 1264 int
wskbd_cngetc(dev_t dev)
 1266 {
 1267         static int num = 0;
 1268         static int pos;
u_int type;
 1270         int data;
keysym_t ks;
 1273         if (!wskbd_console_initted)
 1274                 return 0;
 1276         if (wskbd_console_device != NULL &&
 1277             !wskbd_console_device->sc_translating)
 1278                 return 0;
 1280         for(;;) {
 1281                 if (num-- > 0) {
ks = wskbd_console_data.t_symbols[pos++];
 1283                         if (KS_GROUP(ks) == KS_GROUP_Ascii)
 1284                                 return (KS_VALUE(ks));  
 1285                 } else {
 1286                         (*wskbd_console_data.t_consops->getc)
 1287                                 (wskbd_console_data.t_consaccesscookie,
 1288                                  &type, &data);
num = wskbd_translate(&wskbd_console_data, type, data);
pos = 0;
 1291                 }
 1292         }
 1293 }
 1295 void
wskbd_cnpollc(dev_t dev, int poll)
 1297 {
 1299         if (!wskbd_console_initted)
 1300                 return;
 1302         if (wskbd_console_device != NULL &&
 1303             !wskbd_console_device->sc_translating)
 1304                 return;
 1306         (*wskbd_console_data.t_consops->pollc)
 1307             (wskbd_console_data.t_consaccesscookie, poll);
 1308 }
 1310 void
wskbd_cnbell(dev_t dev, u_int pitch, u_int period, u_int volume)
 1312 {
 1313         if (!wskbd_console_initted)
 1314                 return;
 1316         if (wskbd_console_data.t_consops->bell != NULL)
 1317                 (*wskbd_console_data.t_consops->bell)
 1318                     (wskbd_console_data.t_consaccesscookie, pitch, period,
volume);
 1320 }
 1322 void
update_leds(struct wskbd_internal *id)
 1324 {
 1325         int new_state;
new_state = 0;
 1328         if (id->t_modifiers & (MOD_SHIFTLOCK | MOD_CAPSLOCK))
new_state |= WSKBD_LED_CAPS;
 1330         if (id->t_modifiers & MOD_NUMLOCK)
new_state |= WSKBD_LED_NUM;
 1332         if (id->t_modifiers & MOD_COMPOSE)
new_state |= WSKBD_LED_COMPOSE;
 1334         if (id->t_modifiers & MOD_HOLDSCREEN)
new_state |= WSKBD_LED_SCROLL;
 1337         if (id->t_sc && new_state != id->t_sc->sc_ledstate) {
 1338                 (*id->t_sc->sc_accessops->set_leds)
 1339                     (id->t_sc->sc_accesscookie, new_state);
id->t_sc->sc_ledstate = new_state;
 1341         }
 1342 }
 1344 void
update_modifier(struct wskbd_internal *id, u_int type, int toggle, int mask)
 1346 {
 1347         if (toggle) {
 1348                 if (type == WSCONS_EVENT_KEY_DOWN)
id->t_modifiers ^= mask;
 1350         } else {
 1351                 if (type == WSCONS_EVENT_KEY_DOWN)
id->t_modifiers |= mask;
 1353                 else
id->t_modifiers &= ~mask;
 1355         }
 1356 }
 1358 #if NWSDISPLAY > 0
 1359 void
change_displayparam(struct wskbd_softc *sc, int param, int updown,
 1361     int wraparound)
 1362 {
 1363         int res;
 1364         struct wsdisplay_param dp;
dp.param = param;
res = wsdisplay_param(sc->sc_base.me_dispdv, WSDISPLAYIO_GETPARAM, &dp);
 1369         if (res == EINVAL)
 1370                 return; /* no such parameter */
dp.curval += updown;
 1373         if (dp.max < dp.curval)
dp.curval = wraparound ? dp.min : dp.max;
 1375         else
 1376         if (dp.curval < dp.min)
dp.curval = wraparound ? dp.max : dp.min;
wsdisplay_param(sc->sc_base.me_dispdv, WSDISPLAYIO_SETPARAM, &dp);
 1379 }
 1380 #endif
 1382 int
internal_command(struct wskbd_softc *sc, u_int *type, keysym_t ksym,
keysym_t ksym2)
 1385 {
 1386         switch (ksym) {
 1387         case KS_Cmd:
update_modifier(sc->id, *type, 0, MOD_COMMAND);
ksym = ksym2;
 1390                 break;
 1392         case KS_Cmd1:
update_modifier(sc->id, *type, 0, MOD_COMMAND1);
 1394                 break;
 1396         case KS_Cmd2:
update_modifier(sc->id, *type, 0, MOD_COMMAND2);
 1398                 break;
 1399         }
 1401         if (*type != WSCONS_EVENT_KEY_DOWN)
 1402                 return (0);
 1404 #ifdef SCROLLBACK_SUPPORT
 1405 #if NWSDISPLAY > 0
 1406         switch (ksym) {
 1407         case KS_Cmd_ScrollBack:
 1408                 if (MOD_ONESET(sc->id, MOD_ANYSHIFT)) {
 1409                         if (sc->sc_displaydv != NULL)
wsscrollback(sc->sc_displaydv,
WSDISPLAY_SCROLL_BACKWARD);
 1412                         return (1);
 1413                 }
 1414                 break;
 1416         case KS_Cmd_ScrollFwd:
 1417                 if (MOD_ONESET(sc->id, MOD_ANYSHIFT)) {
 1418                         if (sc->sc_displaydv != NULL)
wsscrollback(sc->sc_displaydv,
WSDISPLAY_SCROLL_FORWARD);
 1421                         return (1);
 1422                 }
 1423                 break;
 1424         }
 1425 #endif
 1426 #endif
 1428         if (!MOD_ONESET(sc->id, MOD_COMMAND) &&
 1429             !MOD_ALLSET(sc->id, MOD_COMMAND1 | MOD_COMMAND2))
 1430                 return (0);
 1432 #ifdef DDB
 1433         if (ksym == KS_Cmd_Debugger) {
 1434                 if (sc->sc_isconsole && db_console)
Debugger();
 1436                 /* discard this key (ddb discarded command modifiers) */
 1437                 *type = WSCONS_EVENT_KEY_UP;
 1438                 return (1);
 1439         }
 1440 #endif
 1442 #if NWSDISPLAY > 0
 1443         if (sc->sc_base.me_dispdv == NULL)
 1444                 return (0);
 1446         switch (ksym) {
 1447         case KS_Cmd_Screen0:
 1448         case KS_Cmd_Screen1:
 1449         case KS_Cmd_Screen2:
 1450         case KS_Cmd_Screen3:
 1451         case KS_Cmd_Screen4:
 1452         case KS_Cmd_Screen5:
 1453         case KS_Cmd_Screen6:
 1454         case KS_Cmd_Screen7:
 1455         case KS_Cmd_Screen8:
 1456         case KS_Cmd_Screen9:
 1457         case KS_Cmd_Screen10:
 1458         case KS_Cmd_Screen11:
wsdisplay_switch(sc->sc_displaydv, ksym - KS_Cmd_Screen0, 0);
 1460                 return (1);
 1461         case KS_Cmd_ResetEmul:
wsdisplay_reset(sc->sc_displaydv, WSDISPLAY_RESETEMUL);
 1463                 return (1);
 1464         case KS_Cmd_ResetClose:
wsdisplay_reset(sc->sc_displaydv, WSDISPLAY_RESETCLOSE);
 1466                 return (1);
 1467 #if defined(__i386__) || defined(__amd64__)
 1468         case KS_Cmd_KbdReset:
 1469                 if (kbd_reset == 1) {
kbd_reset = 0;
psignal(initproc, SIGUSR1);
 1472                 }
 1473                 return (1);
 1474 #endif
 1475         case KS_Cmd_BacklightOn:
 1476         case KS_Cmd_BacklightOff:
 1477         case KS_Cmd_BacklightToggle:
change_displayparam(sc, WSDISPLAYIO_PARAM_BACKLIGHT,
ksym == KS_Cmd_BacklightOff ? -1 : 1,
ksym == KS_Cmd_BacklightToggle ? 1 : 0);
 1481                 return (1);
 1482         case KS_Cmd_BrightnessUp:
 1483         case KS_Cmd_BrightnessDown:
 1484         case KS_Cmd_BrightnessRotate:
change_displayparam(sc, WSDISPLAYIO_PARAM_BRIGHTNESS,
ksym == KS_Cmd_BrightnessDown ? -1 : 1,
ksym == KS_Cmd_BrightnessRotate ? 1 : 0);
 1488                 return (1);
 1489         case KS_Cmd_ContrastUp:
 1490         case KS_Cmd_ContrastDown:
 1491         case KS_Cmd_ContrastRotate:
change_displayparam(sc, WSDISPLAYIO_PARAM_CONTRAST,
ksym == KS_Cmd_ContrastDown ? -1 : 1,
ksym == KS_Cmd_ContrastRotate ? 1 : 0);
 1495                 return (1);
 1496         }
 1497 #endif
 1498         return (0);
 1499 }
 1501 int
wskbd_translate(struct wskbd_internal *id, u_int type, int value)
 1503 {
 1504         struct wskbd_softc *sc = id->t_sc;
keysym_t ksym, res, *group;
 1506         struct wscons_keymap kpbuf, *kp;
 1507         int gindex, iscommand = 0;
 1509         if (type == WSCONS_EVENT_ALL_KEYS_UP) {
 1510 #if NWSDISPLAY > 0
 1511                 if (sc != NULL && sc->sc_repeating) {
sc->sc_repeating = 0;
timeout_del(&sc->sc_repeat_ch);
 1514                 }
 1515 #endif
id->t_modifiers &= ~(MOD_SHIFT_L | MOD_SHIFT_R |
MOD_CONTROL_L | MOD_CONTROL_R |
MOD_META_L | MOD_META_R |
MOD_MODESHIFT | MOD_MODELOCK |
MOD_COMMAND | MOD_COMMAND1 | MOD_COMMAND2);
update_leds(id);
 1522                 return (0);
 1523         }
 1525         if (sc != NULL) {
 1526                 if (value < 0 || value >= sc->sc_maplen) {
 1527 #ifdef DEBUG
printf("wskbd_translate: keycode %d out of range\n",
value);
 1530 #endif
 1531                         return (0);
 1532                 }
kp = sc->sc_map + value;
 1534         } else {
kp = &kpbuf;
wskbd_get_mapentry(id->t_keymap, value, kp);
 1537         }
 1539         /* if this key has a command, process it first */
 1540         if (sc != NULL && kp->command != KS_voidSymbol)
iscommand = internal_command(sc, &type, kp->command,
kp->group1[0]);
 1544         /* Now update modifiers */
 1545         switch (kp->group1[0]) {
 1546         case KS_Shift_L:
update_modifier(id, type, 0, MOD_SHIFT_L);
 1548                 break;
 1550         case KS_Shift_R:
update_modifier(id, type, 0, MOD_SHIFT_R);
 1552                 break;
 1554         case KS_Shift_Lock:
update_modifier(id, type, 1, MOD_SHIFTLOCK);
 1556                 break;
 1558         case KS_Caps_Lock:
update_modifier(id, type, 1, MOD_CAPSLOCK);
 1560                 break;
 1562         case KS_Control_L:
update_modifier(id, type, 0, MOD_CONTROL_L);
 1564                 break;
 1566         case KS_Control_R:
update_modifier(id, type, 0, MOD_CONTROL_R);
 1568                 break;
 1570         case KS_Alt_L:
update_modifier(id, type, 0, MOD_META_L);
 1572                 break;
 1574         case KS_Alt_R:
update_modifier(id, type, 0, MOD_META_R);
 1576                 break;
 1578         case KS_Mode_switch:
update_modifier(id, type, 0, MOD_MODESHIFT);
 1580                 break;
 1582         case KS_Mode_Lock:
update_modifier(id, type, 1, MOD_MODELOCK);
 1584                 break;
 1586         case KS_Num_Lock:
update_modifier(id, type, 1, MOD_NUMLOCK);
 1588                 break;
 1590 #if NWSDISPLAY > 0
 1591         case KS_Hold_Screen:
 1592                 if (sc != NULL) {
update_modifier(id, type, 1, MOD_HOLDSCREEN);
wskbd_holdscreen(sc, id->t_modifiers & MOD_HOLDSCREEN);
 1595                 }
 1596                 break;
 1598         default:
 1599                 if (sc != NULL && sc->sc_repeating &&
 1600                     ((type == WSCONS_EVENT_KEY_UP && value != sc->sc_repkey) ||
 1601                      (type == WSCONS_EVENT_KEY_DOWN && value == sc->sc_repkey)))
 1602                         return (0);
 1603                 break;
 1604 #endif
 1605         }
 1607 #if NWSDISPLAY > 0
 1608         if (sc != NULL) {
 1609                 if (sc->sc_repeating) {
sc->sc_repeating = 0;
timeout_del(&sc->sc_repeat_ch);
 1612                 }
sc->sc_repkey = value;
 1614         }
 1615 #endif
 1617         /* If this is a key release or we are in command mode, we are done */
 1618         if (type != WSCONS_EVENT_KEY_DOWN || iscommand) {
update_leds(id);
 1620                 return (0);
 1621         }
 1623         /* Get the keysym */
 1624         if (id->t_modifiers & (MOD_MODESHIFT|MOD_MODELOCK) &&
 1625             !MOD_ONESET(id, MOD_ANYCONTROL))
group = & kp->group2[0];
 1627         else
group = & kp->group1[0];
 1630         if ((id->t_modifiers & MOD_NUMLOCK) &&
KS_GROUP(group[1]) == KS_GROUP_Keypad) {
gindex = !MOD_ONESET(id, MOD_ANYSHIFT);
ksym = group[gindex];
 1634         } else {
 1635                 /* CAPS alone should only affect letter keys */
 1636                 if ((id->t_modifiers & (MOD_CAPSLOCK | MOD_ANYSHIFT)) ==
MOD_CAPSLOCK) {
gindex = 0;
ksym = ksym_upcase(group[0]);
 1640                 } else {
gindex = MOD_ONESET(id, MOD_ANYSHIFT);
ksym = group[gindex];
 1643                 }
 1644         }
 1646         /* Submit Audio keys for hotkey processing */
 1647         if (KS_GROUP(ksym) == KS_GROUP_Function) {
 1648                 switch (ksym) {
 1649 #if NAUDIO > 0
 1650                 case KS_AudioMute:
workq_add_task(NULL, 0, (workq_fn)wskbd_set_mixervolume,
 1652                             (void *)(long)0, NULL);
 1653                         break;
 1654                 case KS_AudioLower:
workq_add_task(NULL, 0, (workq_fn)wskbd_set_mixervolume,
 1656                             (void *)(long)-1, NULL);
 1657                         break;
 1658                 case KS_AudioRaise:
workq_add_task(NULL, 0, (workq_fn)wskbd_set_mixervolume,
 1660                             (void *)(long)1, NULL);
 1661                         return (0);
 1662 #endif
 1663                 default:
 1664                         break;
 1665                 }
 1666         }
 1668         /* Process compose sequence and dead accents */
res = KS_voidSymbol;
 1671         switch (KS_GROUP(ksym)) {
 1672         case KS_GROUP_Ascii:
 1673         case KS_GROUP_Keypad:
 1674         case KS_GROUP_Function:
res = ksym;
 1676                 break;
 1678         case KS_GROUP_Mod:
 1679                 if (ksym == KS_Multi_key) {
update_modifier(id, 1, 0, MOD_COMPOSE);
id->t_composelen = 2;
 1682                 }
 1683                 break;
 1685         case KS_GROUP_Dead:
 1686                 if (id->t_composelen == 0) {
update_modifier(id, 1, 0, MOD_COMPOSE);
id->t_composelen = 1;
id->t_composebuf[0] = ksym;
 1690                 } else
res = ksym;
 1692                 break;
 1693         }
 1695         if (res == KS_voidSymbol) {
update_leds(id);
 1697                 return (0);
 1698         }
 1700         if (id->t_composelen > 0) {
 1701                 /*
 1702                  * If the compose key also serves as AltGr (i.e. set to both
 1703                  * KS_Multi_key and KS_Mode_switch), and would provide a valid,
 1704                  * distinct combination as AltGr, leave compose mode.
 1705                  */
 1706                 if (id->t_composelen == 2 && group == &kp->group2[0]) {
 1707                         if (kp->group1[gindex] != kp->group2[gindex])
id->t_composelen = 0;
 1709                 }
 1711                 if (id->t_composelen != 0) {
id->t_composebuf[2 - id->t_composelen] = res;
 1713                         if (--id->t_composelen == 0) {
res = wskbd_compose_value(id->t_composebuf);
update_modifier(id, 0, 0, MOD_COMPOSE);
 1716                         } else {
 1717                                 return (0);
 1718                         }
 1719                 }
 1720         }
update_leds(id);
 1724         /* We are done, return the symbol */
 1725         if (KS_GROUP(res) == KS_GROUP_Ascii) {
 1726                 if (MOD_ONESET(id, MOD_ANYCONTROL)) {
 1727                         if ((res >= KS_at && res <= KS_z) || res == KS_space)
res = res & 0x1f;
 1729                         else if (res == KS_2)
res = 0x00;
 1731                         else if (res >= KS_3 && res <= KS_7)
res = KS_Escape + (res - KS_3);
 1733                         else if (res == KS_8)
res = KS_Delete;
 1735                 }
 1736                 if (MOD_ONESET(id, MOD_ANYMETA)) {
 1737                         if (id->t_flags & WSKFL_METAESC) {
id->t_symbols[0] = KS_Escape;
id->t_symbols[1] = res;
 1740                                 return (2);
 1741                         } else
res |= 0x80;
 1743                 }
 1744         }
id->t_symbols[0] = res;
 1747         return (1);
 1748 }