The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/hpc/hpckbd.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*      $NetBSD: hpckbd.c,v 1.25 2008/04/28 20:23:48 martin Exp $ */
    2 
    3 /*-
    4  * Copyright (c) 1999-2001 The NetBSD Foundation, Inc.
    5  * All rights reserved.
    6  *
    7  * This code is derived from software contributed to The NetBSD Foundation
    8  * by UCHIYAMA Yasushi.
    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  *
   19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   29  * POSSIBILITY OF SUCH DAMAGE.
   30  */
   31 
   32 #include <sys/cdefs.h>
   33 __KERNEL_RCSID(0, "$NetBSD: hpckbd.c,v 1.25 2008/04/28 20:23:48 martin Exp $");
   34 
   35 #include <sys/param.h>
   36 #include <sys/systm.h>
   37 #include <sys/device.h>
   38 
   39 #include <sys/tty.h>
   40 
   41 #include <sys/bus.h>
   42 #include <sys/intr.h>
   43 
   44 #include <machine/config_hook.h>
   45 #include <machine/platid.h>
   46 #include <machine/platid_mask.h>
   47 
   48 #include "opt_wsdisplay_compat.h"
   49 #include "opt_pckbd_layout.h"
   50 #include <dev/wscons/wsksymdef.h>
   51 #include <dev/wscons/wsconsio.h>
   52 #include <dev/wscons/wskbdvar.h>
   53 #include <dev/wscons/wsksymvar.h>
   54 #include <dev/pckbport/wskbdmap_mfii.h>
   55 #ifdef WSDISPLAY_COMPAT_RAWKBD
   56 #include <dev/hpc/pckbd_encode.h>
   57 #endif
   58 
   59 #include <dev/hpc/hpckbdvar.h>
   60 #include <dev/hpc/hpckbdkeymap.h>
   61 
   62 struct hpckbd_softc;
   63 
   64 #define NEVENTQ 32
   65 struct hpckbd_eventq {
   66         u_int   hq_type;
   67         int     hq_data;
   68 };
   69 
   70 struct hpckbd_core {
   71         struct hpckbd_if        hc_if;
   72         struct hpckbd_ic_if     *hc_ic;
   73         const uint8_t           *hc_keymap;
   74         const int               *hc_special;
   75         int                     hc_polling;
   76         int                     hc_console;
   77 #define NEVENTQ 32
   78         struct hpckbd_eventq    hc_eventq[NEVENTQ];
   79         struct hpckbd_eventq    *hc_head, *hc_tail;
   80         int                     hc_nevents;
   81         int                     hc_enabled;
   82         struct device           *hc_wskbddev;
   83         struct hpckbd_softc*    hc_sc;  /* back link */
   84 #ifdef WSDISPLAY_COMPAT_RAWKBD
   85         int                     hc_rawkbd;
   86 #endif
   87 };
   88 
   89 struct hpckbd_softc {
   90         struct device           sc_dev;
   91         struct hpckbd_core      *sc_core;
   92         struct hpckbd_core      sc_coredata;
   93 };
   94 
   95 int     hpckbd_match(struct device *, struct cfdata *, void *);
   96 void    hpckbd_attach(struct device *, struct device *, void *);
   97 
   98 void    hpckbd_initcore(struct hpckbd_core *, struct hpckbd_ic_if *, int);
   99 void    hpckbd_initif(struct hpckbd_core *);
  100 int     hpckbd_getevent(struct hpckbd_core *, u_int *, int *);
  101 int     hpckbd_putevent(struct hpckbd_core *, u_int, int);
  102 void    hpckbd_keymap_lookup(struct hpckbd_core*);
  103 void    hpckbd_keymap_setup(struct hpckbd_core *, const keysym_t *, int);
  104 int     __hpckbd_input(void *, int, int);
  105 void    __hpckbd_input_hook(void *);
  106 
  107 CFATTACH_DECL(hpckbd, sizeof(struct hpckbd_softc),
  108     hpckbd_match, hpckbd_attach, NULL, NULL);
  109 
  110 /* wskbd accessopts */
  111 int     hpckbd_enable(void *, int);
  112 void    hpckbd_set_leds(void *, int);
  113 int     hpckbd_ioctl(void *, u_long, void *, int, struct lwp *);
  114 
  115 /* consopts */
  116 struct  hpckbd_core hpckbd_consdata;
  117 void    hpckbd_cngetc(void *, u_int *, int*);
  118 void    hpckbd_cnpollc(void *, int);
  119 
  120 const struct wskbd_accessops hpckbd_accessops = {
  121         hpckbd_enable,
  122         hpckbd_set_leds,
  123         hpckbd_ioctl,
  124 };
  125 
  126 const struct wskbd_consops hpckbd_consops = {
  127         hpckbd_cngetc,
  128         hpckbd_cnpollc,
  129         NULL,
  130 };
  131 
  132 struct wskbd_mapdata hpckbd_keymapdata = {
  133         pckbd_keydesctab,
  134 #ifdef PCKBD_LAYOUT
  135         PCKBD_LAYOUT
  136 #else
  137         KB_US
  138 #endif
  139 };
  140 
  141 int
  142 hpckbd_match(struct device *parent,
  143              struct cfdata *cf, void *aux)
  144 {
  145         return (1);
  146 }
  147 
  148 void
  149 hpckbd_attach(struct device *parent, struct device *self, void *aux)
  150 {
  151         struct hpckbd_attach_args *haa = aux;
  152         struct hpckbd_softc *sc = device_private(self);
  153         struct hpckbd_ic_if *ic = haa->haa_ic;
  154         struct wskbddev_attach_args wa;
  155 
  156         /*
  157          * Initialize core if it isn't console
  158          */
  159         if (hpckbd_consdata.hc_ic == ic) {
  160                 sc->sc_core = &hpckbd_consdata;
  161                 /* The core has been initialized in hpckbd_cnattach. */
  162         } else {
  163                 sc->sc_core = &sc->sc_coredata;
  164                 hpckbd_initcore(sc->sc_core, ic, 0 /* not console */);
  165         }
  166 
  167         if (sc->sc_core->hc_keymap == default_keymap)
  168                 printf(": no keymap.");
  169 
  170         printf("\n");
  171 
  172         /*
  173          * setup hpckbd public interface for parent controller.
  174          */
  175         hpckbd_initif(sc->sc_core);
  176 
  177         /*
  178          * attach wskbd
  179          */
  180         wa.console = sc->sc_core->hc_console;
  181         wa.keymap = &hpckbd_keymapdata;
  182         wa.accessops = &hpckbd_accessops;
  183         wa.accesscookie = sc->sc_core;
  184         sc->sc_core->hc_wskbddev = config_found(self, &wa, wskbddevprint);
  185 }
  186 
  187 int
  188 hpckbd_print(void *aux, const char *pnp)
  189 {
  190         return (pnp ? QUIET : UNCONF);
  191 }
  192 
  193 void
  194 hpckbd_initcore(struct hpckbd_core *hc, struct hpckbd_ic_if *ic, int console)
  195 {
  196         hc->hc_polling = 0;
  197         hc->hc_console = console;
  198         hc->hc_ic = ic;
  199 
  200         /* setup event queue */
  201         hc->hc_head = hc->hc_tail = hc->hc_eventq;
  202         hc->hc_nevents = 0;
  203 
  204         hpckbd_keymap_lookup(hc);
  205 }
  206 
  207 void
  208 hpckbd_initif(struct hpckbd_core *hc)
  209 {
  210         struct hpckbd_if *kbdif = &hc->hc_if;
  211 
  212         kbdif->hi_ctx = hc;
  213         kbdif->hi_input = __hpckbd_input;
  214         kbdif->hi_input_hook = __hpckbd_input_hook;
  215         hpckbd_ic_establish(hc->hc_ic, &hc->hc_if);
  216 }
  217 
  218 int
  219 hpckbd_putevent(struct hpckbd_core* hc, u_int type, int data)
  220 {
  221         int s = spltty();
  222 
  223         if (hc->hc_nevents == NEVENTQ) {
  224                 splx(s);
  225                 return (0); /* queue is full */
  226         }
  227 
  228         hc->hc_nevents++;
  229         hc->hc_tail->hq_type = type;
  230         hc->hc_tail->hq_data = data;
  231         if (&hc->hc_eventq[NEVENTQ] <= ++hc->hc_tail)
  232                 hc->hc_tail = hc->hc_eventq;
  233         splx(s);
  234 
  235         return (1);
  236 }
  237 
  238 int
  239 hpckbd_getevent(struct hpckbd_core* hc, u_int *type, int *data)
  240 {
  241         int s = spltty();
  242 
  243         if (hc->hc_nevents == 0) {
  244                 splx(s);
  245                 return (0); /* queue is empty */
  246         }
  247 
  248         *type = hc->hc_head->hq_type;
  249         *data = hc->hc_head->hq_data;
  250         hc->hc_nevents--;
  251         if (&hc->hc_eventq[NEVENTQ] <= ++hc->hc_head)
  252                 hc->hc_head = hc->hc_eventq;
  253         splx(s);
  254 
  255         return (1);
  256 }
  257 
  258 void
  259 hpckbd_keymap_setup(struct hpckbd_core *hc,
  260                     const keysym_t *map, int mapsize)
  261 {
  262         int i;
  263         struct wscons_keydesc *desc;
  264 
  265         /* fix keydesc table */
  266         /* 
  267          * XXX The way this is done is really wrong.  The __UNCONST()
  268          * is a hint as to what is wrong.  This actually ends up modifying
  269          * initialized data which is marked "const".
  270          * The reason we get away with it here is apparently that text
  271          * and read-only data gets mapped read/write on the platforms
  272          * using this code.
  273          */
  274         desc = (struct wscons_keydesc *)__UNCONST(hpckbd_keymapdata.keydesc);
  275         for (i = 0; desc[i].name != 0; i++) {
  276                 if ((desc[i].name & KB_MACHDEP) && desc[i].map == NULL) {
  277                         desc[i].map = map;
  278                         desc[i].map_size = mapsize;
  279                 }
  280         }
  281 
  282         return;
  283 }
  284 
  285 void
  286 hpckbd_keymap_lookup(struct hpckbd_core *hc)
  287 {
  288         const struct hpckbd_keymap_table *tab;
  289         platid_mask_t mask;
  290 
  291         for (tab = hpckbd_keymap_table; tab->ht_platform != NULL; tab++) {
  292 
  293                 mask = PLATID_DEREF(tab->ht_platform);
  294 
  295                 if (platid_match(&platid, &mask)) {
  296                         hc->hc_keymap = tab->ht_keymap;
  297                         hc->hc_special = tab->ht_special;
  298 #if !defined(PCKBD_LAYOUT)
  299                         hpckbd_keymapdata.layout = tab->ht_layout;
  300 #endif
  301                         if (tab->ht_cmdmap.map) {
  302                                 hpckbd_keymap_setup(hc, tab->ht_cmdmap.map,
  303                                     tab->ht_cmdmap.size);
  304 #if !defined(PCKBD_LAYOUT)
  305                                 hpckbd_keymapdata.layout |= KB_MACHDEP;
  306 #endif
  307                         } else {
  308                                 hpckbd_keymapdata.layout &= ~KB_MACHDEP;
  309                         }
  310                         return;
  311                 }
  312         }
  313 
  314         /* no keymap. use default. */
  315         hc->hc_keymap = default_keymap;
  316         hc->hc_special = default_special_keymap;
  317 #if !defined(PCKBD_LAYOUT)
  318         hpckbd_keymapdata.layout = KB_US;
  319 #endif
  320 }
  321 
  322 void
  323 __hpckbd_input_hook(void *arg)
  324 {
  325 #if 0
  326         struct hpckbd_core *hc = arg;
  327 
  328         if (hc->hc_polling) {
  329                 hc->hc_type = WSCONS_EVENT_ALL_KEYS_UP;
  330         }
  331 #endif
  332 }
  333 
  334 int
  335 __hpckbd_input(void *arg, int flag, int scancode)
  336 {
  337         struct hpckbd_core *hc = arg;
  338         int type, key;
  339 
  340         if (flag) {
  341                 type = WSCONS_EVENT_KEY_DOWN;
  342         } else {
  343                 type = WSCONS_EVENT_KEY_UP;
  344         }
  345 
  346         key = hc->hc_keymap[scancode];
  347         if (key == UNK) {
  348 #ifdef DEBUG
  349                 printf("hpckbd: unknown scan code %#x (%d, %d)\n",
  350                     scancode, scancode >> 3,
  351                     scancode - ((scancode >> 3) << 3));
  352 #endif /* DEBUG */
  353                 return (0);
  354         }
  355 
  356         if (key == IGN) {
  357                 return (0);
  358         }
  359 
  360         if (key == SPL) {
  361                 if (!flag)
  362                         return (0);
  363 
  364                 if (scancode == hc->hc_special[KEY_SPECIAL_OFF]) {
  365                         config_hook_call(CONFIG_HOOK_BUTTONEVENT,
  366                             CONFIG_HOOK_BUTTONEVENT_POWER, (void *)1 /* on */);
  367                 } else if (scancode == hc->hc_special[KEY_SPECIAL_LIGHT]) {
  368                         static int onoff; /* XXX -uch */
  369                         config_hook_call(CONFIG_HOOK_BUTTONEVENT,
  370                             CONFIG_HOOK_BUTTONEVENT_LIGHT,
  371                             (void *)(onoff ^= 1));
  372                 } else {
  373 #ifdef DEBUG
  374                         printf("unknown special key %d\n", scancode);
  375 #endif
  376                 }
  377 
  378                 return (0);
  379         }
  380 
  381         if (hc->hc_polling) {
  382                 if (hpckbd_putevent(hc, type, key) == 0)
  383                         printf("hpckbd: queue over flow\n");
  384         } else {
  385 #ifdef WSDISPLAY_COMPAT_RAWKBD
  386                 if (hc->hc_rawkbd) {
  387                         int n;
  388                         u_char data[16];
  389                         n = pckbd_encode(type, key, data);
  390                         wskbd_rawinput(hc->hc_wskbddev, data, n);
  391                 } else
  392 #endif
  393                         wskbd_input(hc->hc_wskbddev, type, key);
  394         }
  395 
  396         return (0);
  397 }
  398 
  399 /*
  400  * console support routines
  401  */
  402 int
  403 hpckbd_cnattach(struct hpckbd_ic_if *ic)
  404 {
  405         struct hpckbd_core *hc = &hpckbd_consdata;
  406 
  407         hpckbd_initcore(hc, ic, 1 /* console */);
  408 
  409         /* attach controller */
  410         hpckbd_initif(hc);
  411 
  412         /* attach wskbd */
  413         wskbd_cnattach(&hpckbd_consops, hc, &hpckbd_keymapdata);
  414 
  415         return (0);
  416 }
  417 
  418 void
  419 hpckbd_cngetc(void *arg, u_int *type, int *data)
  420 {
  421         struct hpckbd_core *hc = arg;
  422 
  423         if (!hc->hc_console || !hc->hc_polling || !hc->hc_ic)
  424                 return;
  425 
  426         while (hpckbd_getevent(hc, type, data) == 0) /* busy loop */
  427                 hpckbd_ic_poll(hc->hc_ic);
  428 }
  429 
  430 void
  431 hpckbd_cnpollc(void *arg, int on)
  432 {
  433         struct hpckbd_core *hc = arg;
  434 
  435         hc->hc_polling = on;
  436 }
  437 
  438 int
  439 hpckbd_enable(void *arg, int on)
  440 {
  441         struct hpckbd_core *hc = arg;
  442 
  443         if (on) {
  444                 if (hc->hc_enabled)
  445                         return (EBUSY);
  446                 hc->hc_enabled = 1;
  447         } else {
  448                 if (hc->hc_console)
  449                         return (EBUSY);
  450                 hc->hc_enabled = 0;
  451         }
  452 
  453         return (0);
  454 }
  455 
  456 void
  457 hpckbd_set_leds(void *arg, int leds)
  458 {
  459         /* Can you find any LED which tells you about keyboard? */
  460 }
  461 
  462 int
  463 hpckbd_ioctl(void *arg, u_long cmd, void *data, int flag,
  464              struct lwp *l)
  465 {
  466 #ifdef WSDISPLAY_COMPAT_RAWKBD
  467         struct hpckbd_core *hc = arg;
  468 #endif
  469         switch (cmd) {
  470         case WSKBDIO_GTYPE:
  471                 *(int *)data = WSKBD_TYPE_HPC_KBD;
  472                 return (0);
  473         case WSKBDIO_SETLEDS:
  474                 return 0;
  475         case WSKBDIO_GETLEDS:
  476                 *(int *)data = 0;       /* dummy for wsconsctl(8) */
  477                 return (0);
  478 #ifdef WSDISPLAY_COMPAT_RAWKBD
  479         case WSKBDIO_SETMODE:
  480                 hc->hc_rawkbd = (*(int *)data == WSKBD_RAW);
  481                 return (0);
  482 #endif
  483         }
  484         return (EPASSTHROUGH);
  485 }

Cache object: ebd76ba23cddd472270d62c36e8af8e8


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.