NetBSD-5.0.2/sys/arch/acorn26/ioc/arckbd.c
/* $NetBSD: arckbd.c,v 1.11 2007/03/04 05:59:04 christos Exp $ */
/*-
* Copyright (c) 1998, 1999, 2000 Ben Harris
* All rights reserved.
*
* 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. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*/
/*
* arckbd.c - Archimedes keyboard driver
*/
/*
* Most of the information used to write this driver came from the
* A3000 Technical Reference Manual (ISBN 1-85250-074-3).
*
* We keep a queue of one command in the softc for use by the receive
* interrupt handler in case it finds the KART is already transmitting
* a command (presumably as a consequence of a user request) when it
* wants to. I think this is safe in all cases, and it will never
* happen more than once at a time (I hope).
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: arckbd.c,v 1.11 2007/03/04 05:59:04 christos Exp $");
#include <sys/param.h>
#include <sys/device.h>
#include <sys/errno.h>
#include <sys/ioctl.h>
#include <sys/malloc.h>
#include <sys/proc.h>
#include <sys/reboot.h> /* For bootverbose */
#include <sys/syslog.h>
#include <sys/systm.h>
#include <machine/bus.h>
#include <machine/intr.h>
#include <machine/irq.h>
#include <dev/wscons/wsconsio.h>
#include <dev/wscons/wskbdvar.h>
#include <dev/wscons/wsksymdef.h>
#include <dev/wscons/wsmousevar.h>
#include <arch/acorn26/iobus/iocreg.h>
#include <arch/acorn26/iobus/iocvar.h>
#include <arch/acorn26/ioc/arckbdreg.h>
#include <arch/acorn26/ioc/arckbdvar.h>
#include "arckbd.h"
#include "locators.h"
#include "rnd.h"
#if NRND > 0
#include <sys/rnd.h>
#endif
/* #define ARCKBD_DEBUG */
enum arckbd_state {
AS_HRST, AS_RAK1, AS_RAK2, /* reset protocol */
AS_IDLE, /* idle, waiting for data */
AS_KDDA, AS_KUDA, AS_MDAT /* Receiving two-byte message */
};
static const char *arckbd_statenames[] = {
"hrst", "rak1", "rak2", "idle", "kdda", "kuda", "mdat"
};
static int arckbd_match(struct device *parent, struct cfdata *cf, void *aux);
static void arckbd_attach(struct device *parent, struct device *self,
void *aux);
#if 0 /* XXX should be used */
static kbd_t arckbd_pick_layout(int kbid);
#endif
#if NARCWSKBD > 0
static int arcwskbd_match(struct device *parent, struct cfdata *cf, void *aux);
static void arcwskbd_attach(struct device *parent, struct device *self,
void *aux);
#endif
#if NARCWSMOUSE > 0
static int arcwsmouse_match(struct device *parent, struct cfdata *cf,
void *aux);
static void arcwsmouse_attach(struct device *parent, struct device *self,
void *aux);
#endif
static int arckbd_rint(void *self);
static int arckbd_xint(void *self);
#if NARCWSMOUSE > 0
static void arckbd_mousemoved(struct device *self, int byte1, int byte2);
#endif
static void arckbd_keyupdown(struct device *self, int byte1, int byte2);
static int arckbd_send(struct device *self, int data,
enum arckbd_state newstate, int waitok);
#if NARCWSKBD > 0
static int arckbd_enable(void *cookie, int on);
static int arckbd_led_encode(int);
static int arckbd_led_decode(int);
static void arckbd_set_leds(void *cookie, int new_state);
static int arckbd_ioctl(void *cookie, u_long cmd, void *data, int flag,
struct lwp *l);
static void arckbd_getc(void *cookie, u_int *typep, int *valuep);
static void arckbd_pollc(void *cookie, int poll);
#endif
#if NARCWSMOUSE > 0
static int arcmouse_enable(void *cookie);
static int arcmouse_ioctl(void *cookie, u_long cmd, void *data, int flag,
struct lwp *l);
static void arcmouse_disable(void *cookie);
#endif
struct arckbd_softc {
struct device sc_dev;
bus_space_tag_t sc_bst;
bus_space_handle_t sc_bsh;
u_int sc_mouse_buttons;
enum arckbd_state sc_state;
u_char sc_byteone;
u_char sc_kbid;
struct device *sc_wskbddev;
struct device *sc_wsmousedev;
struct wskbd_mapdata sc_mapdata;
int sc_cmdqueue; /* Single-command queue */
enum arckbd_state sc_statequeue;
int sc_cmdqueued;
int sc_flags;
int sc_leds;
u_int sc_poll_type;
int sc_poll_value;
struct irq_handler *sc_xirq;
struct evcnt sc_xev;
struct irq_handler *sc_rirq;
struct evcnt sc_rev;
#if NRND > 0
rndsource_element_t sc_rnd_source;
#endif
};
#define AKF_WANTKBD 0x01
#define AKF_WANTMOUSE 0x02
#define AKF_SENTRQID 0x04
#define AKF_SENTLEDS 0x08
#define AKF_POLLING 0x10
CFATTACH_DECL(arckbd, sizeof(struct arckbd_softc),
arckbd_match, arckbd_attach, NULL, NULL);
/*
* Internal devices used because arckbd can't be both a wskbddev and a
* wsmousedev. I suspect the right way to do this is through an
* "attach wskbd at arckbd with wskbd_arckbd" type thing, but we can't
* as the size of a wskbd_softc isn't public. Come to think of it,
* this isn't very evil -- I just don't like having yet another line
* of configuration.
*/
#if NARCWSKBD > 0
CFATTACH_DECL(arcwskbd, sizeof(struct device),
arcwskbd_match, arcwskbd_attach, NULL, NULL);
#endif
#if NARCWSMOUSE > 0
CFATTACH_DECL(arcwsmouse, sizeof(struct device),
arcwsmouse_match, arcwsmouse_attach, NULL, NULL);
#endif
struct arckbd_attach_args {
enum { ARCKBD_KBDDEV, ARCKBD_MOUSEDEV } aka_devtype;
struct wskbddev_attach_args aka_wskbdargs;
struct wsmousedev_attach_args aka_wsmouseargs;
};
#if NARCWSKBD > 0
static struct wskbd_accessops arckbd_accessops = {
arckbd_enable, arckbd_set_leds, arckbd_ioctl
};
static struct wskbd_consops arckbd_consops = {
arckbd_getc, arckbd_pollc
};
#endif
#if NARCWSMOUSE > 0
static struct wsmouse_accessops arcmouse_accessops = {
arcmouse_enable, arcmouse_ioctl, arcmouse_disable
};
#endif
/* ARGSUSED */
static int
arckbd_match(struct device *parent, struct cfdata *cf, void *aux)
{
/* Assume presence for now */
return 1;
}
static void
arckbd_attach(struct device *parent, struct device *self, void *aux)
{
struct arckbd_softc *sc = (void *)self;
struct ioc_attach_args *ioc = aux;
bus_space_tag_t bst;
bus_space_handle_t bsh;
#if NARCWSKBD > 0 || NARCWSMOUSE > 0
struct arckbd_attach_args aka;
#endif
bst = sc->sc_bst = ioc->ioc_fast_t;
bsh = sc->sc_bsh = ioc->ioc_fast_h;
evcnt_attach_dynamic(&sc->sc_rev, EVCNT_TYPE_INTR, NULL,
sc->sc_dev.dv_xname, "rx intr");
sc->sc_rirq = irq_establish(IOC_IRQ_SRX, IPL_TTY, arckbd_rint, self,
&sc->sc_rev);
if (bootverbose)
printf("\n%s: interrupting at %s (rx)", self->dv_xname,
irq_string(sc->sc_rirq));
evcnt_attach_dynamic(&sc->sc_xev, EVCNT_TYPE_INTR, NULL,
sc->sc_dev.dv_xname, "tx intr");
sc->sc_xirq = irq_establish(IOC_IRQ_STX, IPL_TTY, arckbd_xint, self,
&sc->sc_xev);
irq_disable(sc->sc_xirq);
if (bootverbose)
printf(" and %s (tx)", irq_string(sc->sc_xirq));
/* Initialisation of IOC KART per IOC Data Sheet section 6.2.3. */
/* Set up IOC counter 3 */
/* k_BAUD = 1/((latch+1)*16) MHz */
ioc_counter_start(parent, 3, 62500 / ARCKBD_BAUD - 1);
/* Read from Rx register and discard. */
(void)bus_space_read_1(bst, bsh, 0);
/* Kick the keyboard into life */
arckbd_send(self, ARCKBD_HRST, AS_HRST, 0);
sc->sc_mapdata = arckbd_mapdata_default;
sc->sc_mapdata.layout = KB_UK; /* Reasonable default */
/* XXX set the LEDs to a known state? (or will wskbd do this?) */
#if NARCWSKBD > 0
/* Attach the wskbd console */
arckbd_cnattach(self);
#endif
printf("\n");
#if NRND > 0
rnd_attach_source(&sc->sc_rnd_source, self->dv_xname, RND_TYPE_TTY, 0);
#endif
/* Attach the dummy drivers */
#if NARCWSKBD > 0
aka.aka_wskbdargs.console = 1; /* XXX FIXME */
aka.aka_wskbdargs.keymap = &sc->sc_mapdata;
aka.aka_wskbdargs.accessops = &arckbd_accessops;
aka.aka_wskbdargs.accesscookie = self;
#endif
#if NARCWSMOUSE > 0
aka.aka_wsmouseargs.accessops = &arcmouse_accessops;
aka.aka_wsmouseargs.accesscookie = self;
#endif
#if NARCWSKBD > 0
aka.aka_devtype = ARCKBD_KBDDEV;
config_found(self, &aka, NULL);
#endif
#if NARCWSMOUSE > 0
aka.aka_devtype = ARCKBD_MOUSEDEV;
config_found(self, &aka, NULL);
#endif
}
#if 0 /* XXX should be used */
static kbd_t
arckbd_pick_layout(int kbid)
{
int i;
for (i = 0; arckbd_kbidtab[i].kbid != 0; i++) {
if (arckbd_kbidtab[i].kbid == kbid)
return arckbd_kbidtab[i].layout;
}
return KB_UK;
}
#endif
#if NARCWSKBD > 0
/* ARGSUSED */
static int
arcwskbd_match(struct device *parent, struct cfdata *cf, void *aux)
{
struct arckbd_attach_args *aka = aux;
if (aka->aka_devtype == ARCKBD_KBDDEV)
return 1;
return 0;
}
#endif
#if NARCWSMOUSE > 0
/* ARGSUSED */
static int
arcwsmouse_match(struct device *parent, struct cfdata *cf, void *aux)
{
struct arckbd_attach_args *aka = aux;
if (aka->aka_devtype == ARCKBD_MOUSEDEV)
return 1;
return 0;
}
#endif
#if NARCWSKBD > 0
static void
arcwskbd_attach(struct device *parent, struct device *self, void *aux)
{
struct arckbd_attach_args *aka = aux;
struct arckbd_softc *sc = (void *)parent;
printf("\n");
sc->sc_wskbddev = config_found(self, &(aka->aka_wskbdargs),
wskbddevprint);
}
#endif
#if NARCWSMOUSE > 0
static void
arcwsmouse_attach(struct device *parent, struct device *self, void *aux)
{
struct arckbd_attach_args *aka = aux;
struct arckbd_softc *sc = (void *)parent;
printf("\n");
sc->sc_wsmousedev = config_found(self, &(aka->aka_wsmouseargs),
wsmousedevprint);
}
#endif
#if NARCWSKBD > 0
/*
* We don't really _need_ a console keyboard before
* autoconfiguration's finished, so for now this function's written to
* be called from arckbd_attach. The console functions should still
* try not to rely on much, and perhaps one day we should make it
* happen in consinit instead.
*/
void
arckbd_cnattach(struct device *self)
{
struct arckbd_softc *sc = (void*)self;
wskbd_cnattach(&arckbd_consops, sc, &arckbd_mapdata_default);
}
static void
arckbd_getc(void *cookie, u_int *typep, int *valuep)
{
struct arckbd_softc *sc = cookie;
int s;
if (!(sc->sc_flags & AKF_POLLING))
panic("%s: arckbd_getc called with polling disabled",
sc->sc_dev.dv_xname);
while (sc->sc_poll_type == 0) {
if (ioc_irq_status(IOC_IRQ_STX))
arckbd_xint(&sc->sc_dev);
if (ioc_irq_status(IOC_IRQ_SRX))
arckbd_rint(&sc->sc_dev);
}
s = spltty();
*typep = sc->sc_poll_type;
*valuep = sc->sc_poll_value;
sc->sc_poll_type = 0;
sc->sc_poll_value = 0;
splx(s);
}
static void
arckbd_pollc(void *cookie, int poll)
{
struct arckbd_softc *sc = cookie;
int s;
s = spltty();
if (poll) {
sc->sc_flags |= AKF_POLLING;
irq_disable(sc->sc_rirq);
irq_disable(sc->sc_xirq);
} else {
sc->sc_flags &= ~AKF_POLLING;
irq_enable(sc->sc_rirq);
irq_enable(sc->sc_xirq);
}
splx(s);
}
#endif
static int
arckbd_send(struct device *self, int data, enum arckbd_state newstate,
int waitok)
{
struct arckbd_softc *sc = (void *)self;
int s, res;
bus_space_tag_t bst = sc->sc_bst;
bus_space_handle_t bsh = sc->sc_bsh;
s = spltty();
if (waitok) {
while (!ioc_irq_status(IOC_IRQ_STX))
if ((sc->sc_flags & AKF_POLLING) == 0) {
res = tsleep(arckbd_send, PWAIT, "kbdsend", 0);
if (res != 0)
return res;
}
} else if (!ioc_irq_status(IOC_IRQ_STX)) {
if (sc->sc_cmdqueued)
panic("%s: queue overflow", sc->sc_dev.dv_xname);
else {
sc->sc_cmdqueue = data;
sc->sc_statequeue = newstate;
sc->sc_cmdqueued = 1;
return 0;
}
}
bus_space_write_1(bst, bsh, 0, data);
sc->sc_state = newstate;
#ifdef ARCKBD_DEBUG
log(LOG_DEBUG, "%s: sent 0x%02x. now in state %s\n",
sc->sc_dev.dv_xname, data, arckbd_statenames[newstate]);
#endif
wakeup(&sc->sc_state);
splx(s);
if ((sc->sc_flags & AKF_POLLING) == 0)
irq_enable(sc->sc_xirq);
return 0;
}
static int
arckbd_xint(void *cookie)
{
struct arckbd_softc *sc = cookie;
irq_disable(sc->sc_xirq);
/* First, process queued commands (acks from the last receive) */
if (sc->sc_cmdqueued) {
sc->sc_cmdqueued = 0;
arckbd_send(&sc->sc_dev, sc->sc_cmdqueue, sc->sc_statequeue, 0);
} else if (sc->sc_state == AS_IDLE) {
/* Do things that need doing after a reset */
if (!(sc->sc_flags & AKF_SENTRQID)) {
arckbd_send(&sc->sc_dev, ARCKBD_RQID, AS_IDLE, 0);
sc->sc_flags |= AKF_SENTRQID;
} else if (!(sc->sc_flags & AKF_SENTLEDS)) {
arckbd_send(&sc->sc_dev, ARCKBD_LEDS | sc->sc_leds,
AS_IDLE, 0);
sc->sc_flags |= AKF_SENTLEDS;
}
} else if ((sc->sc_flags & AKF_POLLING) == 0)
wakeup(&arckbd_send);
return IRQ_HANDLED;
}
static int
arckbd_rint(void *cookie)
{
struct device *self = cookie;
struct arckbd_softc *sc = (void *)self;
bus_space_tag_t bst = sc->sc_bst;
bus_space_handle_t bsh = sc->sc_bsh;
int data;
data = bus_space_read_1(bst, bsh, 0);
#ifdef ARCKBD_DEBUG
log(LOG_DEBUG, "%s: got 0x%02x in state %s\n", self->dv_xname, data,
arckbd_statenames[sc->sc_state]);
#endif
/* Reset protocol */
if (data == ARCKBD_HRST && sc->sc_state == AS_HRST)
arckbd_send(self, ARCKBD_RAK1, AS_RAK1, 0);
else if (data == ARCKBD_RAK1 &&
(sc->sc_state == AS_RAK1 || sc->sc_state == AS_HRST))
arckbd_send(self, ARCKBD_RAK2, AS_RAK2, 0);
else if (data == ARCKBD_RAK2 && sc->sc_state == AS_RAK2)
arckbd_send(self, ARCKBD_SMAK, AS_IDLE, 0);
/*
* Note that for data messages, we acknowledge first and
* _then_ process the data. This is important because the
* processing may end up trying to use the keyboard in polled
* mode (e.g. through DDB) and we'd like its state to be
* self-consistent.
*/
/* Mouse data */
else if (ARCKBD_IS_MDAT(data) && sc->sc_state == AS_IDLE) {
arckbd_send(self, ARCKBD_BACK, AS_MDAT, 0);
sc->sc_byteone = data;
} else if (ARCKBD_IS_MDAT(data) && sc->sc_state == AS_MDAT) {
arckbd_send(self, ARCKBD_SMAK, AS_IDLE, 0);
#if NARCWSMOUSE > 0
arckbd_mousemoved(self, sc->sc_byteone, data);
#endif
}
/* Key down data */
else if (ARCKBD_IS_KDDA(data) && sc->sc_state == AS_IDLE) {
arckbd_send(self, ARCKBD_BACK, AS_KDDA, 0);
sc->sc_byteone = data;
} else if (ARCKBD_IS_KDDA(data) && sc->sc_state == AS_KDDA) {
arckbd_send(self, ARCKBD_SMAK, AS_IDLE, 0);
arckbd_keyupdown(self, sc->sc_byteone, data);
}
/* Key up data */
else if (ARCKBD_IS_KUDA(data) && sc->sc_state == AS_IDLE) {
arckbd_send(self, ARCKBD_BACK, AS_KUDA, 0);
sc->sc_byteone = data;
} else if (ARCKBD_IS_KUDA(data) && sc->sc_state == AS_KUDA) {
arckbd_send(self, ARCKBD_SMAK, AS_IDLE, 0);
arckbd_keyupdown(self, sc->sc_byteone, data);
}
/* Other cruft */
else if (ARCKBD_IS_KBID(data)) {
arckbd_send(self, ARCKBD_SMAK, AS_IDLE, 0);
if (sc->sc_kbid != data) {
printf("%s: layout %d\n",
self->dv_xname, data & ~ARCKBD_KBID);
sc->sc_kbid = data;
}
} else if (ARCKBD_IS_PDAT(data))
/* unused -- ignore it */;
else {
/* Protocol error */
log(LOG_WARNING, "%s: protocol error: got 0x%02x in state %s\n",
self->dv_xname, data, arckbd_statenames[sc->sc_state]);
arckbd_send(self, ARCKBD_HRST, AS_HRST, 0);
}
return IRQ_HANDLED;
}
#if NARCWSMOUSE > 0
static void
arckbd_mousemoved(struct device *self, int byte1, int byte2)
{
struct arckbd_softc *sc = (void *)self;
int dx, dy;
#if NRND > 0
rnd_add_uint32(&sc->sc_rnd_source, byte1);
#endif
if (sc->sc_wsmousedev != NULL) {
/* deltas are 7-bit signed */
dx = byte1 < 0x40 ? byte1 : byte1 - 0x80;
dy = byte2 < 0x40 ? byte2 : byte2 - 0x80;
wsmouse_input(sc->sc_wsmousedev,
sc->sc_mouse_buttons,
dx, dy, 0, 0,
WSMOUSE_INPUT_DELTA);
}
}
#endif
static void
arckbd_keyupdown(struct device *self, int byte1, int byte2)
{
#if NARCWSKBD > 0 || NARCWSMOUSE > 0 || NRND > 0
struct arckbd_softc *sc = (void *)self;
#endif
#if NARCWSKBD > 0
u_int type;
int value;
#endif
#if NRND > 0
rnd_add_uint32(&sc->sc_rnd_source, byte1);
#endif
if ((byte1 & 0x0f) == 7) {
#if NARCWSMOUSE > 0
/* Mouse button event */
/*
* This is all very silly, as the wsmouse driver then
* differentiates the button state to see if there's
* an event worth passing to the user.
*
* Oh well, at least NetBSD and Acorn number their
* mouse buttons the same way.
*/
if (ARCKBD_IS_KDDA(byte1))
sc->sc_mouse_buttons |= (1 << (byte2 & 0x0f));
else
sc->sc_mouse_buttons &= ~(1 << (byte2 & 0x0f));
if (sc->sc_wsmousedev != NULL)
wsmouse_input(sc->sc_wsmousedev,
sc->sc_mouse_buttons,
0, 0, 0, 0,
WSMOUSE_INPUT_DELTA);
#endif
} else {
#if NARCWSKBD > 0
type = ARCKBD_IS_KDDA(byte1) ?
WSCONS_EVENT_KEY_DOWN : WSCONS_EVENT_KEY_UP;
value = ((byte1 & 0x0f) << 4) | (byte2 & 0x0f);
if (sc->sc_flags & AKF_POLLING) {
sc->sc_poll_type = type;
sc->sc_poll_value = value;
} else if (sc->sc_wskbddev != NULL)
wskbd_input(sc->sc_wskbddev, type, value);
#endif
}
}
#if NARCWSKBD > 0
/*
* Keyboard access functions
*/
static int
arckbd_enable(void *cookie, int on)
{
struct arckbd_softc *sc = cookie;
if (on) {
sc->sc_flags |= AKF_WANTKBD;
/* XXX send RQMP? */
} else
sc->sc_flags &= ~ AKF_WANTKBD;
return 0;
}
static int
arckbd_led_encode(int wsleds)
{
int arcleds;
arcleds = 0;
if (wsleds & WSKBD_LED_CAPS)
arcleds |= ARCKBD_LEDS_CAPSLOCK;
if (wsleds & WSKBD_LED_NUM)
arcleds |= ARCKBD_LEDS_NUMLOCK;
if (wsleds & WSKBD_LED_SCROLL)
arcleds |= ARCKBD_LEDS_SCROLLLOCK;
/* No "compose" LED */
return arcleds;
}
static int
arckbd_led_decode(int arcleds)
{
int wsleds;
wsleds = 0;
if (arcleds & ARCKBD_LEDS_CAPSLOCK)
wsleds |= WSKBD_LED_CAPS;
if (arcleds & ARCKBD_LEDS_NUMLOCK)
wsleds |= WSKBD_LED_NUM;
if (arcleds & ARCKBD_LEDS_SCROLLLOCK)
wsleds |= WSKBD_LED_SCROLL;
/* No "compose" LED */
return wsleds;
}
/*
* Set the LEDs to the requested state.
*
* Be warned: This function gets called from interrupts.
*/
static void
arckbd_set_leds(void *cookie, int new_state)
{
struct arckbd_softc *sc = cookie;
int s;
s = spltty();
sc->sc_leds = arckbd_led_encode(new_state);
if (arckbd_send(cookie, ARCKBD_LEDS | sc->sc_leds, AS_IDLE, 0) == 0)
sc->sc_flags |= AKF_SENTLEDS;
splx(s);
}
/* ARGSUSED */
static int
arckbd_ioctl(void *cookie, u_long cmd, void *data, int flag, struct lwp *l)
{
struct arckbd_softc *sc = cookie;
switch (cmd) {
case WSKBDIO_GTYPE:
*(int *)data = WSKBD_TYPE_ARCHIMEDES;
return 0;
case WSKBDIO_SETLEDS:
arckbd_set_leds(sc, *(int *)data);
return 0;
case WSKBDIO_GETLEDS:
*(int *)data = arckbd_led_decode(sc->sc_leds);
return 0;
}
return EPASSTHROUGH;
}
#endif
#if NARCWSMOUSE > 0
/*
* Mouse access functions
*/
static int
arcmouse_enable(void *cookie)
{
struct arckbd_softc *sc = cookie;
sc->sc_flags |= AKF_WANTMOUSE;
/* XXX send RQMP */
return 0;
}
/* ARGSUSED */
static int
arcmouse_ioctl(void *cookie, u_long cmd, void *data, int flag,
struct lwp *l)
{
/* struct arckbd_softc *sc = cookie; */
switch (cmd) {
case WSMOUSEIO_GTYPE:
*(int *)data = WSMOUSE_TYPE_ARCHIMEDES;
return 0;
}
return EPASSTHROUGH;
}
static void
arcmouse_disable(void *cookie)
{
struct arckbd_softc *sc = cookie;
sc->sc_flags &= ~AKF_WANTMOUSE;
}
#endif