/*      $NetBSD: hpckbd.c,v 1.38 2022/10/26 22:09:37 andvar Exp $ */

/*-
* Copyright (c) 1999-2001 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by UCHIYAMA Yasushi.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: hpckbd.c,v 1.38 2022/10/26 22:09:37 andvar Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/malloc.h>

#include <sys/tty.h>

#include <sys/bus.h>
#include <sys/intr.h>

#include <machine/config_hook.h>
#include <machine/platid.h>
#include <machine/platid_mask.h>

#include "opt_wsdisplay_compat.h"
#include "opt_pckbd_layout.h"
#include <dev/wscons/wsksymdef.h>
#include <dev/wscons/wsconsio.h>
#include <dev/wscons/wskbdvar.h>
#include <dev/wscons/wsksymvar.h>
#include <dev/pckbport/wskbdmap_mfii.h>
#ifdef WSDISPLAY_COMPAT_RAWKBD
#include <dev/hpc/pckbd_encode.h>
#endif

#include <dev/hpc/hpckbdvar.h>
#include <dev/hpc/hpckbdkeymap.h>

struct hpckbd_softc;

#define NEVENTQ 32
struct hpckbd_eventq {
       u_int   hq_type;
       int     hq_data;
};

struct hpckbd_core {
       struct hpckbd_if        hc_if;
       struct hpckbd_ic_if     *hc_ic;
       const uint8_t           *hc_keymap;
       const int               *hc_special;
       int                     hc_polling;
       int                     hc_console;
#define NEVENTQ 32
       struct hpckbd_eventq    hc_eventq[NEVENTQ];
       struct hpckbd_eventq    *hc_head, *hc_tail;
       int                     hc_nevents;
       int                     hc_enabled;
       device_t                hc_wskbddev;
       struct hpckbd_softc     *hc_sc; /* back link */
#ifdef WSDISPLAY_COMPAT_RAWKBD
       int                     hc_rawkbd;
#endif
};

struct hpckbd_softc {
       device_t                sc_dev;
       struct hpckbd_core      *sc_core;
       struct hpckbd_core      sc_coredata;
};

int     hpckbd_match(device_t, cfdata_t, void *);
void    hpckbd_attach(device_t, device_t, void *);

void    hpckbd_initcore(struct hpckbd_core *, struct hpckbd_ic_if *, int);
void    hpckbd_initif(struct hpckbd_core *);
int     hpckbd_getevent(struct hpckbd_core *, u_int *, int *);
int     hpckbd_putevent(struct hpckbd_core *, u_int, int);
void    hpckbd_keymap_lookup(struct hpckbd_core*);
void    hpckbd_keymap_setup(struct hpckbd_core *, const keysym_t *, int);
int     __hpckbd_input(void *, int, int);
void    __hpckbd_input_hook(void *);

CFATTACH_DECL_NEW(hpckbd, sizeof(struct hpckbd_softc),
   hpckbd_match, hpckbd_attach, NULL, NULL);

/* wskbd accessopts */
int     hpckbd_enable(void *, int);
void    hpckbd_set_leds(void *, int);
int     hpckbd_ioctl(void *, u_long, void *, int, struct lwp *);

/* consopts */
struct  hpckbd_core hpckbd_consdata;
void    hpckbd_cngetc(void *, u_int *, int*);
void    hpckbd_cnpollc(void *, int);

const struct wskbd_accessops hpckbd_accessops = {
       hpckbd_enable,
       hpckbd_set_leds,
       hpckbd_ioctl,
};

const struct wskbd_consops hpckbd_consops = {
       hpckbd_cngetc,
       hpckbd_cnpollc,
       NULL,
};

struct wskbd_mapdata hpckbd_keymapdata = {
       pckbd_keydesctab,
#ifdef PCKBD_LAYOUT
       PCKBD_LAYOUT
#else
       KB_US
#endif
};

int
hpckbd_match(device_t parent, cfdata_t cf, void *aux)
{
       return (1);
}

void
hpckbd_attach(device_t parent, device_t self, void *aux)
{
       struct hpckbd_attach_args *haa = aux;
       struct hpckbd_softc *sc = device_private(self);
       struct hpckbd_ic_if *ic = haa->haa_ic;
       struct wskbddev_attach_args wa;

       sc->sc_dev = self;

       /*
        * Initialize core if it isn't console
        */
       if (hpckbd_consdata.hc_ic == ic) {
               sc->sc_core = &hpckbd_consdata;
               /* The core has been initialized in hpckbd_cnattach. */
       } else {
               sc->sc_core = &sc->sc_coredata;
               hpckbd_initcore(sc->sc_core, ic, 0 /* not console */);
       }

       if (sc->sc_core->hc_keymap == default_keymap)
               printf(": no keymap.");

       printf("\n");

       /*
        * setup hpckbd public interface for parent controller.
        */
       hpckbd_initif(sc->sc_core);

       /*
        * attach wskbd
        */
       wa.console = sc->sc_core->hc_console;
       wa.keymap = &hpckbd_keymapdata;
       wa.accessops = &hpckbd_accessops;
       wa.accesscookie = sc->sc_core;
       sc->sc_core->hc_wskbddev = config_found(self, &wa, wskbddevprint,
           CFARGS_NONE);

       if (!pmf_device_register(self, NULL, NULL))
               aprint_error_dev(self, "unable to establish power handler\n");
}

int
hpckbd_print(void *aux, const char *pnp)
{
       return (pnp ? QUIET : UNCONF);
}

void
hpckbd_initcore(struct hpckbd_core *hc, struct hpckbd_ic_if *ic, int console)
{
       hc->hc_polling = 0;
       hc->hc_console = console;
       hc->hc_ic = ic;

       /* setup event queue */
       hc->hc_head = hc->hc_tail = hc->hc_eventq;
       hc->hc_nevents = 0;

       hpckbd_keymap_lookup(hc);
}

void
hpckbd_initif(struct hpckbd_core *hc)
{
       struct hpckbd_if *kbdif = &hc->hc_if;

       kbdif->hi_ctx = hc;
       kbdif->hi_input = __hpckbd_input;
       kbdif->hi_input_hook = __hpckbd_input_hook;
       hpckbd_ic_establish(hc->hc_ic, &hc->hc_if);
}

int
hpckbd_putevent(struct hpckbd_core* hc, u_int type, int data)
{
       int s = spltty();

       if (hc->hc_nevents == NEVENTQ) {
               splx(s);
               return (0); /* queue is full */
       }

       hc->hc_nevents++;
       hc->hc_tail->hq_type = type;
       hc->hc_tail->hq_data = data;
       if (&hc->hc_eventq[NEVENTQ] <= ++hc->hc_tail)
               hc->hc_tail = hc->hc_eventq;
       splx(s);

       return (1);
}

int
hpckbd_getevent(struct hpckbd_core* hc, u_int *type, int *data)
{
       int s = spltty();

       if (hc->hc_nevents == 0) {
               splx(s);
               return (0); /* queue is empty */
       }

       *type = hc->hc_head->hq_type;
       *data = hc->hc_head->hq_data;
       hc->hc_nevents--;
       if (&hc->hc_eventq[NEVENTQ] <= ++hc->hc_head)
               hc->hc_head = hc->hc_eventq;
       splx(s);

       return (1);
}


#if defined(hpcsh) || defined(hpcmips)
/*
* XXX: Use the old wrong code for now as hpcsh and hpcmips attach
* console very early when malloc(9) is not yet available.  It is
* convenient to be able to do early DDB on wscons.
*/
void
hpckbd_keymap_setup(struct hpckbd_core *hc,
                   const keysym_t *map, int mapsize)
{
       int i;
       struct wscons_keydesc *desc;

       /* fix keydesc table */
       /*
        * XXX The way this is done is really wrong.  The __UNCONST()
        * is a hint as to what is wrong.  This actually ends up modifying
        * initialized data which is marked "const".
        *
        * The reason we get away with it here is that on sh3 and mips
        * the kernel is directly mapped.
        */
       desc = (struct wscons_keydesc *)__UNCONST(hpckbd_keymapdata.keydesc);
       for (i = 0; desc[i].name != 0; i++) {
               if ((desc[i].name & KB_MACHDEP) && desc[i].map == NULL) {
                       desc[i].map = map;
                       desc[i].map_size = mapsize;
               }
       }

       return;
}

#else

void
hpckbd_keymap_setup(struct hpckbd_core *hc,
                   const keysym_t *map, int mapsize)
{
       int i;
       const struct wscons_keydesc *desc;
       static struct wscons_keydesc *ndesc = NULL;

       /*
        * fix keydesc table. Since it is const data, we must
        * copy it once before changing it.
        */

       if (ndesc == NULL) {
               size_t sz;

               for (sz = 0; hpckbd_keymapdata.keydesc[sz].name != 0; sz++);

               ndesc = malloc(sz * sizeof(*ndesc), M_DEVBUF, M_WAITOK);
               memcpy(ndesc, hpckbd_keymapdata.keydesc, sz * sizeof(*ndesc));

               hpckbd_keymapdata.keydesc = ndesc;
       }

       desc = hpckbd_keymapdata.keydesc;
       for (i = 0; desc[i].name != 0; i++) {
               if ((desc[i].name & KB_MACHDEP) && desc[i].map == NULL) {
                       ndesc[i].map = map;
                       ndesc[i].map_size = mapsize;
               }
       }

       return;
}
#endif

void
hpckbd_keymap_lookup(struct hpckbd_core *hc)
{
       const struct hpckbd_keymap_table *tab;
       platid_mask_t mask;

       for (tab = hpckbd_keymap_table; tab->ht_platform != NULL; tab++) {

               mask = PLATID_DEREF(tab->ht_platform);

               if (platid_match(&platid, &mask)) {
                       hc->hc_keymap = tab->ht_keymap;
                       hc->hc_special = tab->ht_special;
#if !defined(PCKBD_LAYOUT)
                       hpckbd_keymapdata.layout = tab->ht_layout;
#endif
                       if (tab->ht_cmdmap.map) {
                               hpckbd_keymap_setup(hc, tab->ht_cmdmap.map,
                                   tab->ht_cmdmap.size);
#if !defined(PCKBD_LAYOUT)
                               hpckbd_keymapdata.layout |= KB_MACHDEP;
#endif
                       } else {
                               hpckbd_keymapdata.layout &= ~KB_MACHDEP;
                       }
                       return;
               }
       }

       /* no keymap. use default. */
       hc->hc_keymap = default_keymap;
       hc->hc_special = default_special_keymap;
#if !defined(PCKBD_LAYOUT)
       hpckbd_keymapdata.layout = KB_US;
#endif
}

void
__hpckbd_input_hook(void *arg)
{
#if 0
       struct hpckbd_core *hc = arg;

       if (hc->hc_polling) {
               hc->hc_type = WSCONS_EVENT_ALL_KEYS_UP;
       }
#endif
}

int
__hpckbd_input(void *arg, int flag, int scancode)
{
       struct hpckbd_core *hc = arg;
       int type, key;

       if (flag) {
               type = WSCONS_EVENT_KEY_DOWN;
       } else {
               type = WSCONS_EVENT_KEY_UP;
       }

       key = hc->hc_keymap[scancode];
       if (key == UNK) {
#ifdef DEBUG
               printf("hpckbd: unknown scan code %#x (%d, %d)\n",
                   scancode, scancode >> 3,
                   scancode - ((scancode >> 3) << 3));
#endif /* DEBUG */
               return (0);
       }

       if (key == IGN) {
               return (0);
       }

       if (key == SPL) {
               if (!flag)
                       return (0);

               if (scancode == hc->hc_special[KEY_SPECIAL_OFF]) {
                       config_hook_call(CONFIG_HOOK_BUTTONEVENT,
                           CONFIG_HOOK_BUTTONEVENT_POWER, (void *)1 /* on */);
               } else if (scancode == hc->hc_special[KEY_SPECIAL_LIGHT]) {
                       static int onoff; /* XXX -uch */
                       config_hook_call(CONFIG_HOOK_BUTTONEVENT,
                           CONFIG_HOOK_BUTTONEVENT_LIGHT,
                           (void *)(onoff ^= 1));
               } else {
#ifdef DEBUG
                       printf("unknown special key %d\n", scancode);
#endif
               }

               return (0);
       }

       if (hc->hc_polling) {
               if (hpckbd_putevent(hc, type, key) == 0)
                       printf("hpckbd: queue over flow\n");
       } else {
#ifdef WSDISPLAY_COMPAT_RAWKBD
               if (hc->hc_rawkbd) {
                       int n;
                       u_char data[16];
                       n = pckbd_encode(type, key, data);
                       wskbd_rawinput(hc->hc_wskbddev, data, n);
               } else
#endif
                       wskbd_input(hc->hc_wskbddev, type, key);
       }

       return (0);
}

/*
* console support routines
*/
int
hpckbd_cnattach(struct hpckbd_ic_if *ic)
{
       struct hpckbd_core *hc = &hpckbd_consdata;

       hpckbd_initcore(hc, ic, 1 /* console */);

       /* attach controller */
       hpckbd_initif(hc);

       /* attach wskbd */
       wskbd_cnattach(&hpckbd_consops, hc, &hpckbd_keymapdata);

       return (0);
}

void
hpckbd_cngetc(void *arg, u_int *type, int *data)
{
       struct hpckbd_core *hc = arg;

       if (!hc->hc_console || !hc->hc_polling || !hc->hc_ic)
               return;

       while (hpckbd_getevent(hc, type, data) == 0) /* busy loop */
               hpckbd_ic_poll(hc->hc_ic);
}

void
hpckbd_cnpollc(void *arg, int on)
{
       struct hpckbd_core *hc = arg;

       hc->hc_polling = on;
}

int
hpckbd_enable(void *arg, int on)
{
       struct hpckbd_core *hc = arg;

       if (on) {
               if (hc->hc_enabled)
                       return (EBUSY);
               hc->hc_enabled = 1;
       } else {
               if (hc->hc_console)
                       return (EBUSY);
               hc->hc_enabled = 0;
       }

       return (0);
}

void
hpckbd_set_leds(void *arg, int leds)
{
       /* Can you find any LED which tells you about keyboard? */
}

int
hpckbd_ioctl(void *arg, u_long cmd, void *data, int flag,
            struct lwp *l)
{
#ifdef WSDISPLAY_COMPAT_RAWKBD
       struct hpckbd_core *hc = arg;
#endif
       switch (cmd) {
       case WSKBDIO_GTYPE:
               *(int *)data = WSKBD_TYPE_HPC_KBD;
               return (0);
       case WSKBDIO_SETLEDS:
               return 0;
       case WSKBDIO_GETLEDS:
               *(int *)data = 0;       /* dummy for wsconsctl(8) */
               return (0);
#ifdef WSDISPLAY_COMPAT_RAWKBD
       case WSKBDIO_SETMODE:
               hc->hc_rawkbd = (*(int *)data == WSKBD_RAW);
               return (0);
#endif
       }
       return (EPASSTHROUGH);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.