Expand PMF_FN_* macros.

[netbsd-mini2440.git] / sys / dev / pckbport / pckbd.c

/* $NetBSD: pckbd.c,v 1.26 2009/03/08 15:06:56 ad Exp $ */

/*-
 * Copyright (c) 1998, 2009 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Charles M. Hannum.
 *
 * 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.
 */

/*-
 * Copyright (c) 1990 The Regents of the University of California.
 * All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * William Jolitz and Don Ahn.
 *
 * 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.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
 *
 *      @(#)pccons.c    5.11 (Berkeley) 5/21/91
 */

/*
 * code to work keyboard for PC-style console
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: pckbd.c,v 1.26 2009/03/08 15:06:56 ad Exp $");

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

#include <sys/bus.h>

#include <dev/pckbport/pckbportvar.h>

#include <dev/wscons/wsconsio.h>
#include <dev/wscons/wskbdvar.h>
#include <dev/wscons/wsksymdef.h>
#include <dev/wscons/wsksymvar.h>

#include <dev/pckbport/pckbdreg.h>
#include <dev/pckbport/pckbdvar.h>
#include <dev/pckbport/wskbdmap_mfii.h>

#include "locators.h"

#include "opt_pckbd_layout.h"
#include "opt_pckbd_cnattach_may_fail.h"
#include "opt_wsdisplay_compat.h"

struct pckbd_internal {
        int t_isconsole;
        pckbport_tag_t t_kbctag;
        pckbport_slot_t t_kbcslot;

        int t_lastchar;
        int t_extended0;
        int t_extended1;

        struct pckbd_softc *t_sc; /* back pointer */
};

struct pckbd_softc {
        device_t sc_dev;

        struct pckbd_internal *id;
        int sc_enabled;

        int sc_ledstate;

        device_t sc_wskbddev;
#ifdef WSDISPLAY_COMPAT_RAWKBD
        int rawkbd;
#endif
};

static int pckbd_is_console(pckbport_tag_t, pckbport_slot_t);

int pckbdprobe(device_t, cfdata_t, void *);
void pckbdattach(device_t, device_t, void *);

CFATTACH_DECL_NEW(pckbd, sizeof(struct pckbd_softc),
    pckbdprobe, pckbdattach, NULL, NULL);

int     pckbd_enable(void *, int);
void    pckbd_set_leds(void *, int);
int     pckbd_ioctl(void *, u_long, void *, int, struct lwp *);

const struct wskbd_accessops pckbd_accessops = {
        pckbd_enable,
        pckbd_set_leds,
        pckbd_ioctl,
};

void    pckbd_cngetc(void *, u_int *, int *);
void    pckbd_cnpollc(void *, int);
void    pckbd_cnbell(void *, u_int, u_int, u_int);

const struct wskbd_consops pckbd_consops = {
        pckbd_cngetc,
        pckbd_cnpollc,
        pckbd_cnbell,
};

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

/*
 * Hackish support for a bell on the PC Keyboard; when a suitable feeper
 * is found, it attaches itself into the pckbd driver here.
 */
void    (*pckbd_bell_fn)(void *, u_int, u_int, u_int, int);
void    *pckbd_bell_fn_arg;

void    pckbd_bell(u_int, u_int, u_int, int);

int     pckbd_set_xtscancode(pckbport_tag_t, pckbport_slot_t);
int     pckbd_init(struct pckbd_internal *, pckbport_tag_t, pckbport_slot_t,
                        int);
void    pckbd_input(void *, int);

static int      pckbd_decode(struct pckbd_internal *, int, u_int *, int *);
static int      pckbd_led_encode(int);
static int      pckbd_led_decode(int);

struct pckbd_internal pckbd_consdata;

int
pckbd_set_xtscancode(pckbport_tag_t kbctag, pckbport_slot_t kbcslot)
{
        int res;
        u_char cmd[2];

        /*
         * Some keyboard/8042 combinations do not seem to work if the keyboard
         * is set to table 1; in fact, it would appear that some keyboards just
         * ignore the command altogether.  So by default, we use the AT scan
         * codes and have the 8042 translate them.  Unfortunately, this is
         * known to not work on some PS/2 machines.  We try desperately to deal
         * with this by checking the (lack of a) translate bit in the 8042 and
         * attempting to set the keyboard to XT mode.  If this all fails, well,
         * tough luck.
         *
         * XXX It would perhaps be a better choice to just use AT scan codes
         * and not bother with this.
         */
        if (pckbport_xt_translation(kbctag, kbcslot, 1)) {
                /* The 8042 is translating for us; use AT codes. */
                cmd[0] = KBC_SETTABLE;
                cmd[1] = 2;
                res = pckbport_poll_cmd(kbctag, kbcslot, cmd, 2, 0, 0, 0);
                if (res) {
                        u_char cmdb[1];
                        aprint_debug("pckbd: error setting scanset 2\n");
                        /*
                         * XXX at least one keyboard is reported to lock up
                         * if a "set table" is attempted, thus the "reset".
                         * XXX ignore errors, scanset 2 should be
                         * default anyway.
                         */
                        cmdb[0] = KBC_RESET;
                        (void)pckbport_poll_cmd(kbctag, kbcslot, cmdb, 1, 1, 0, 1);
                        pckbport_flush(kbctag, kbcslot);
                        res = 0;
                }
        } else {
                /* Stupid 8042; set keyboard to XT codes. */
                cmd[0] = KBC_SETTABLE;
                cmd[1] = 1;
                res = pckbport_poll_cmd(kbctag, kbcslot, cmd, 2, 0, 0, 0);
                if (res)
                        aprint_debug("pckbd: error setting scanset 1\n");
        }
        return res;
}

static int
pckbd_is_console(pckbport_tag_t tag, pckbport_slot_t slot)
{

        return pckbd_consdata.t_isconsole &&
            tag == pckbd_consdata.t_kbctag && slot == pckbd_consdata.t_kbcslot;
}

static bool
pckbd_suspend(device_t dv PMF_FN_ARGS)
{
        struct pckbd_softc *sc = device_private(dv);
        u_char cmd[1];
        int res;

        /* XXX duped from pckbd_enable, but we want to disable
         *     it even if it's the console kbd
         */
        cmd[0] = KBC_DISABLE;
        res = pckbport_enqueue_cmd(sc->id->t_kbctag,
            sc->id->t_kbcslot, cmd, 1, 0, 1, 0);
        if (res)
                return false;

        pckbport_slot_enable(sc->id->t_kbctag,
            sc->id->t_kbcslot, 0);

        sc->sc_enabled = 0;
        return true;
}

static bool
pckbd_resume(device_t dv PMF_FN_ARGS)
{
        struct pckbd_softc *sc = device_private(dv);
        u_char cmd[1], resp[1];
        int res;

        /* XXX jmcneill reset the keyboard */
        pckbport_flush(sc->id->t_kbctag, sc->id->t_kbcslot);

        cmd[0] = KBC_RESET;
        res = pckbport_poll_cmd(sc->id->t_kbctag,
            sc->id->t_kbcslot, cmd, 1, 1, resp, 1);
        if (res)
                aprint_debug("pckbdprobe: reset error %d\n", res);
        if (resp[0] != KBR_RSTDONE)
                printf("pckbdprobe: reset response 0x%x\n",
                    resp[0]);

        pckbport_flush(sc->id->t_kbctag, sc->id->t_kbcslot);

        pckbd_enable(sc, 1);

        return true;
}

/*
 * these are both bad jokes
 */
int
pckbdprobe(device_t parent, cfdata_t cf, void *aux)
{
        struct pckbport_attach_args *pa = aux;
        int res;
        u_char cmd[1], resp[1];

        /*
         * XXX There are rumours that a keyboard can be connected
         * to the aux port as well. For me, this didn't work.
         * For further experiments, allow it if explicitly
         * wired in the config file.
         */
        if ((pa->pa_slot != PCKBPORT_KBD_SLOT) &&
            (cf->cf_loc[PCKBPORTCF_SLOT] == PCKBPORTCF_SLOT_DEFAULT))
                return 0;

        /* Flush any garbage. */
        pckbport_flush(pa->pa_tag, pa->pa_slot);

        /* Reset the keyboard. */
        cmd[0] = KBC_RESET;
        res = pckbport_poll_cmd(pa->pa_tag, pa->pa_slot, cmd, 1, 1, resp, 1);
        if (res) {
                aprint_debug("pckbdprobe: reset error %d\n", res);
                /*
                 * There is probably no keyboard connected.
                 * Let the probe succeed if the keyboard is used
                 * as console input - it can be connected later.
                 */
                return pckbd_is_console(pa->pa_tag, pa->pa_slot) ? 1 : 0;
        }
        if (resp[0] != KBR_RSTDONE) {
                printf("pckbdprobe: reset response 0x%x\n", resp[0]);
                return 0;
        }

        /*
         * Some keyboards seem to leave a second ack byte after the reset.
         * This is kind of stupid, but we account for them anyway by just
         * flushing the buffer.
         */
        pckbport_flush(pa->pa_tag, pa->pa_slot);

        if (pckbd_set_xtscancode(pa->pa_tag, pa->pa_slot))
                return 0;

        return 2;
}

void
pckbdattach(device_t parent, device_t self, void *aux)
{
        struct pckbd_softc *sc = device_private(self);
        struct pckbport_attach_args *pa = aux;
        struct wskbddev_attach_args a;
        int isconsole;
        u_char cmd[1];

        aprint_naive("\n");
        aprint_normal("\n");

        sc->sc_dev = self;
        isconsole = pckbd_is_console(pa->pa_tag, pa->pa_slot);

        if (isconsole) {
                sc->id = &pckbd_consdata;

                /*
                 * Some keyboards are not enabled after a reset,
                 * so make sure it is enabled now.
                 */
                cmd[0] = KBC_ENABLE;
                (void) pckbport_poll_cmd(sc->id->t_kbctag, sc->id->t_kbcslot,
                                      cmd, 1, 0, 0, 0);
                sc->sc_enabled = 1;
        } else {
                sc->id = malloc(sizeof(struct pckbd_internal),
                                M_DEVBUF, M_WAITOK);
                (void) pckbd_init(sc->id, pa->pa_tag, pa->pa_slot, 0);

                /* no interrupts until enabled */
                cmd[0] = KBC_DISABLE;
                (void) pckbport_poll_cmd(sc->id->t_kbctag, sc->id->t_kbcslot,
                                      cmd, 1, 0, 0, 0);
                sc->sc_enabled = 0;
        }

        sc->id->t_sc = sc;

        pckbport_set_inputhandler(sc->id->t_kbctag, sc->id->t_kbcslot,
                               pckbd_input, sc, device_xname(sc->sc_dev));

        a.console = isconsole;

        a.keymap = &pckbd_keymapdata;

        a.accessops = &pckbd_accessops;
        a.accesscookie = sc;

        if (!pmf_device_register(self, pckbd_suspend, pckbd_resume))
                aprint_error_dev(self, "couldn't establish power handler\n");

        /*
         * Attach the wskbd, saving a handle to it.
         * XXX XXX XXX
         */
        sc->sc_wskbddev = config_found_ia(self, "wskbddev", &a, wskbddevprint);
}

int
pckbd_enable(void *v, int on)
{
        struct pckbd_softc *sc = v;
        int res;
        u_char cmd[1];

        if (on) {
                if (sc->sc_enabled) {
                        aprint_debug("pckbd_enable: bad enable\n");
                        return EBUSY;
                }

                pckbport_slot_enable(sc->id->t_kbctag, sc->id->t_kbcslot, 1);

                cmd[0] = KBC_ENABLE;
                res = pckbport_poll_cmd(sc->id->t_kbctag, sc->id->t_kbcslot,
                                        cmd, 1, 0, NULL, 0);
                if (res) {
                        printf("pckbd_enable: command error\n");
                        return (res);
                }

                res = pckbd_set_xtscancode(sc->id->t_kbctag,
                                           sc->id->t_kbcslot);
                if (res)
                        return res;

                sc->sc_enabled = 1;
        } else {
                if (sc->id->t_isconsole)
                        return EBUSY;

                cmd[0] = KBC_DISABLE;
                res = pckbport_enqueue_cmd(sc->id->t_kbctag, sc->id->t_kbcslot,
                                        cmd, 1, 0, 1, 0);
                if (res) {
                        printf("pckbd_disable: command error\n");
                        return res;
                }

                pckbport_slot_enable(sc->id->t_kbctag, sc->id->t_kbcslot, 0);

                sc->sc_enabled = 0;
        }

        return 0;
}

static int
pckbd_decode(struct pckbd_internal *id, int datain, u_int *type, int *dataout)
{
        int key;

        if (datain == KBR_EXTENDED0) {
                id->t_extended0 = 1;
                return 0;
        } else if (datain == KBR_EXTENDED1) {
                id->t_extended1 = 2;
                return 0;
        }

        if (id->t_extended0 == 1) {
                switch (datain & 0x7f) {
                case 0x2a:
                case 0x36:
                        id->t_extended0 = 0;
                        return 0;
                default:
                        break;
                }
        }

        /* map extended keys to (unused) codes 128-254 */
        key = (datain & 0x7f) | (id->t_extended0 ? 0x80 : 0);
        id->t_extended0 = 0;

        /*
         * process PAUSE (also break) key (EXT1 1D 45  EXT1 9D C5):
         * map to (unused) code 7F
         */
        if (id->t_extended1 == 2 && (datain == 0x1d || datain == 0x9d)) {
                id->t_extended1 = 1;
                return 0;
        } else if (id->t_extended1 == 1 &&
                   (datain == 0x45 || datain == 0xc5)) {
                id->t_extended1 = 0;
                key = 0x7f;
        } else if (id->t_extended1 > 0) {
                id->t_extended1 = 0;
        }

        if (datain & 0x80) {
                id->t_lastchar = 0;
                *type = WSCONS_EVENT_KEY_UP;
        } else {
                /* Always ignore typematic keys */
                if (key == id->t_lastchar)
                        return 0;
                id->t_lastchar = key;
                *type = WSCONS_EVENT_KEY_DOWN;
        }

        *dataout = key;
        return 1;
}

int
pckbd_init(struct pckbd_internal *t, pckbport_tag_t kbctag,
    pckbport_slot_t kbcslot, int console)
{

        memset(t, 0, sizeof(struct pckbd_internal));

        t->t_isconsole = console;
        t->t_kbctag = kbctag;
        t->t_kbcslot = kbcslot;

        return pckbd_set_xtscancode(kbctag, kbcslot);
}

static int
pckbd_led_encode(int led)
{
        int res;

        res = 0;

        if (led & WSKBD_LED_SCROLL)
                res |= 0x01;
        if (led & WSKBD_LED_NUM)
                res |= 0x02;
        if (led & WSKBD_LED_CAPS)
                res |= 0x04;
        return res;
}

static int
pckbd_led_decode(int led)
{
        int res;

        res = 0;
        if (led & 0x01)
                res |= WSKBD_LED_SCROLL;
        if (led & 0x02)
                res |= WSKBD_LED_NUM;
        if (led & 0x04)
                res |= WSKBD_LED_CAPS;
        return res;
}

void
pckbd_set_leds(void *v, int leds)
{
        struct pckbd_softc *sc = v;
        u_char cmd[2];

        cmd[0] = KBC_MODEIND;
        cmd[1] = pckbd_led_encode(leds);
        sc->sc_ledstate = cmd[1];

        (void)pckbport_enqueue_cmd(sc->id->t_kbctag, sc->id->t_kbcslot,
                                 cmd, 2, 0, 0, 0);
}

/*
 * Got a console receive interrupt -
 * the console processor wants to give us a character.
 */
void
pckbd_input(void *vsc, int data)
{
        struct pckbd_softc *sc = vsc;
        int key;
        u_int type;

#ifdef WSDISPLAY_COMPAT_RAWKBD
        if (sc->rawkbd) {
                u_char d = data;
                wskbd_rawinput(sc->sc_wskbddev, &d, 1);
                return;
        }
#endif
        if (pckbd_decode(sc->id, data, &type, &key))
                wskbd_input(sc->sc_wskbddev, type, key);
}

int
pckbd_ioctl(void *v, u_long cmd, void *data, int flag,
    struct lwp *l)
{
        struct pckbd_softc *sc = v;

        switch (cmd) {
        case WSKBDIO_GTYPE:
                *(int *)data = WSKBD_TYPE_PC_XT;
                return 0;
        case WSKBDIO_SETLEDS:
        {
                int res;
                u_char cmdb[2];

                cmdb[0] = KBC_MODEIND;
                cmdb[1] = pckbd_led_encode(*(int *)data);
                sc->sc_ledstate = cmdb[1];
                res = pckbport_enqueue_cmd(sc->id->t_kbctag, sc->id->t_kbcslot,
                                        cmdb, 2, 0, 1, 0);
                return res;
        }
        case WSKBDIO_GETLEDS:
                *(int *)data = pckbd_led_decode(sc->sc_ledstate);
                return 0;
        case WSKBDIO_COMPLEXBELL:
#define d ((struct wskbd_bell_data *)data)
                /*
                 * Keyboard can't beep directly; we have an
                 * externally-provided global hook to do this.
                 */
                pckbd_bell(d->pitch, d->period, d->volume, 0);
#undef d
                return 0;
#ifdef WSDISPLAY_COMPAT_RAWKBD
        case WSKBDIO_SETMODE:
                sc->rawkbd = (*(int *)data == WSKBD_RAW);
                return 0;
#endif
        }
        return EPASSTHROUGH;
}

void
pckbd_bell(u_int pitch, u_int period, u_int volume, int poll)
{

        if (pckbd_bell_fn != NULL)
                (*pckbd_bell_fn)(pckbd_bell_fn_arg, pitch, period,
                    volume, poll);
}

void
pckbd_unhook_bell(void (*fn)(void *, u_int, u_int, u_int, int), void *arg)
{
        if (pckbd_bell_fn != fn && pckbd_bell_fn_arg != arg)
                return;
        pckbd_bell_fn = NULL;
        pckbd_bell_fn_arg = NULL;
}

void
pckbd_hookup_bell(void (*fn)(void *, u_int, u_int, u_int, int), void *arg)
{

        if (pckbd_bell_fn == NULL) {
                pckbd_bell_fn = fn;
                pckbd_bell_fn_arg = arg;
        }
}

int
pckbd_cnattach(pckbport_tag_t kbctag, int kbcslot)
{
        int res;
        u_char cmd[1];

        res = pckbd_init(&pckbd_consdata, kbctag, kbcslot, 1);
        /* We may allow the console to be attached if no keyboard is present */
#if defined(PCKBD_CNATTACH_MAY_FAIL)
        if (res)
                return res;
#endif

        /* Just to be sure. */
        cmd[0] = KBC_ENABLE;
        res = pckbport_poll_cmd(kbctag, kbcslot, cmd, 1, 0, 0, 0);

#if defined(PCKBD_CNATTACH_MAY_FAIL)
        if (res)
                return res;
#endif

        wskbd_cnattach(&pckbd_consops, &pckbd_consdata, &pckbd_keymapdata);

        return 0;
}

/* ARGSUSED */
void
pckbd_cngetc(void *v, u_int *type, int *data)
{
        struct pckbd_internal *t = v;
        int val;

        for (;;) {
                val = pckbport_poll_data(t->t_kbctag, t->t_kbcslot);
                if ((val != -1) && pckbd_decode(t, val, type, data))
                        return;
        }
}

void
pckbd_cnpollc(void *v, int on)
{
        struct pckbd_internal *t = v;

        pckbport_set_poll(t->t_kbctag, t->t_kbcslot, on);
}

void
pckbd_cnbell(void *v, u_int pitch, u_int period, u_int volume)
{

        pckbd_bell(pitch, period, volume, 1);
}