335 lines
8.8 KiB
C
335 lines
8.8 KiB
C
/* $NetBSD: kbd.c,v 1.1 1996/04/12 02:00:46 cgd Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 1992, 1993
|
|
* The Regents of the University of California. All rights reserved.
|
|
*
|
|
* This software was developed by the Computer Systems Engineering group
|
|
* at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
|
|
* contributed to Berkeley.
|
|
*
|
|
* All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by the University of
|
|
* California, Lawrence Berkeley Laboratory.
|
|
*
|
|
* 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. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by the University of
|
|
* California, Berkeley and its contributors.
|
|
* 4. 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.
|
|
*
|
|
* @(#)kbd.c 8.2 (Berkeley) 10/30/93
|
|
*/
|
|
|
|
/*
|
|
* Keyboard driver (/dev/kbd -- note that we do not have minor numbers
|
|
* [yet?]). Translates incoming bytes to ASCII or to `firm_events' and
|
|
* passes them up to the appropriate reader.
|
|
*/
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/conf.h>
|
|
#include <sys/device.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/proc.h>
|
|
#include <sys/syslog.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/tty.h>
|
|
|
|
#include <machine/autoconf.h>
|
|
|
|
#include <machine/vuid_event.h>
|
|
#include <machine/kbio.h> /* XXX FOR KIOCSDIRECT */
|
|
#include <machine/wsconsio.h> /* XXX for bell ioctls */
|
|
#include <alpha/wscons/event_var.h>
|
|
#include <alpha/wscons/wsconsvar.h>
|
|
|
|
struct kbd_softc {
|
|
struct device *k_idev; /* the input device */
|
|
struct wscons_idev_spec k_ispec; /* the input device information */
|
|
|
|
int k_evmode; /* set if we should produce events */
|
|
struct evvar k_events; /* event queue state */
|
|
char *k_repeatcp; /* repeated character (string) */
|
|
int k_repeating; /* we've called timeout() */
|
|
int k_repeat_start; /* how long (ms) until repeat */
|
|
int k_repeat_step; /* how long (ms) until more repeats */
|
|
|
|
struct wsconsio_bell_data k_belldata;
|
|
} kbd_softc;
|
|
|
|
void
|
|
kbdattach(idev, ispec)
|
|
struct device *idev;
|
|
struct wscons_idev_spec *ispec;
|
|
{
|
|
register struct kbd_softc *k = &kbd_softc;
|
|
|
|
/*
|
|
* It would be nice if the repeat rates were in ticks.
|
|
* However, if they were, we couldn't set them here, as
|
|
* hz might not be set up yet!
|
|
*/
|
|
k->k_repeat_start = 200;
|
|
k->k_repeat_step = 50;
|
|
|
|
k->k_belldata.wbd_pitch = 1500; /* 1500 Hz */
|
|
k->k_belldata.wbd_period = 100; /* 100 ms */
|
|
k->k_belldata.wbd_volume = 50; /* 50% volume */
|
|
|
|
k->k_idev = idev;
|
|
k->k_ispec = *ispec;
|
|
}
|
|
|
|
void
|
|
kbd_repeat(void *arg)
|
|
{
|
|
struct kbd_softc *k = (struct kbd_softc *)arg;
|
|
int s = spltty();
|
|
|
|
if (k->k_repeating && k->k_repeatcp != NULL) {
|
|
wscons_input(k->k_repeatcp);
|
|
timeout(kbd_repeat, k, (hz * k->k_repeat_step) / 1000);
|
|
}
|
|
splx(s);
|
|
}
|
|
|
|
void
|
|
kbd_input(register int c)
|
|
{
|
|
register struct kbd_softc *k = &kbd_softc;
|
|
register struct firm_event *fe;
|
|
register int put;
|
|
char *cp;
|
|
|
|
if (k->k_repeating) {
|
|
k->k_repeating = 0;
|
|
untimeout(kbd_repeat, k);
|
|
}
|
|
|
|
/*
|
|
* If /dev/kbd is not connected in event mode translate and
|
|
* send upstream.
|
|
*/
|
|
if (!k->k_evmode) {
|
|
cp = (*k->k_ispec.wi_translate)(k->k_idev, c);
|
|
if (cp != NULL) {
|
|
wscons_input(cp);
|
|
k->k_repeating = 1;
|
|
k->k_repeatcp = cp;
|
|
timeout(kbd_repeat, k, (hz * k->k_repeat_start) / 1000);
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Keyboard is generating events. Turn this keystroke into an
|
|
* event and put it in the queue. If the queue is full, the
|
|
* keystroke is lost (sorry!).
|
|
*/
|
|
put = k->k_events.ev_put;
|
|
fe = &k->k_events.ev_q[put];
|
|
put = (put + 1) % EV_QSIZE;
|
|
if (put == k->k_events.ev_get) {
|
|
log(LOG_WARNING, "keyboard event queue overflow\n"); /* ??? */
|
|
return;
|
|
}
|
|
fe->id = c & k->k_ispec.wi_keymask;
|
|
fe->value = (c & k->k_ispec.wi_keyupmask) != 0 ? VKEY_UP : VKEY_DOWN;
|
|
microtime(&fe->time);
|
|
k->k_events.ev_put = put;
|
|
EV_WAKEUP(&k->k_events);
|
|
}
|
|
|
|
int
|
|
kbdopen(dev_t dev, int flags, int mode, struct proc *p)
|
|
{
|
|
int s;
|
|
struct tty *tp;
|
|
|
|
if (kbd_softc.k_events.ev_io)
|
|
return (EBUSY);
|
|
kbd_softc.k_events.ev_io = p;
|
|
ev_init(&kbd_softc.k_events);
|
|
kbd_softc.k_evmode = 1;
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
kbdclose(dev_t dev, int flags, int mode, struct proc *p)
|
|
{
|
|
|
|
/*
|
|
* Turn off event mode, dump the queue, and close the keyboard
|
|
* unless it is supplying console input.
|
|
*/
|
|
kbd_softc.k_evmode = 0;
|
|
ev_fini(&kbd_softc.k_events);
|
|
kbd_softc.k_events.ev_io = NULL;
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
kbdread(dev_t dev, struct uio *uio, int flags)
|
|
{
|
|
|
|
return (ev_read(&kbd_softc.k_events, uio, flags));
|
|
}
|
|
|
|
/* this routine should not exist, but is convenient to write here for now */
|
|
int
|
|
kbdwrite(dev_t dev, struct uio *uio, int flags)
|
|
{
|
|
|
|
return (EOPNOTSUPP);
|
|
}
|
|
|
|
int
|
|
kbdioctl(dev_t dev, u_long cmd, register caddr_t data, int flag, struct proc *p)
|
|
{
|
|
struct kbd_softc *k = &kbd_softc;
|
|
struct wsconsio_bell_data *wbd;
|
|
int rv;
|
|
|
|
rv = ENOTTY;
|
|
switch (cmd) {
|
|
#if 0
|
|
case KIOCSDIRECT:
|
|
k->k_evmode = *(int *)data;
|
|
return (0);
|
|
#endif
|
|
|
|
case FIONBIO: /* we will remove this someday (soon???) */
|
|
return (0);
|
|
|
|
case FIOASYNC:
|
|
k->k_events.ev_async = *(int *)data != 0;
|
|
return (0);
|
|
|
|
case TIOCSPGRP:
|
|
if (*(int *)data != k->k_events.ev_io->p_pgid)
|
|
return (EPERM);
|
|
return (0);
|
|
|
|
case WSCONSIO_BELL:
|
|
if (k->k_ispec.wi_bell != NULL)
|
|
(*k->k_ispec.wi_bell)(k->k_idev, &k->k_belldata);
|
|
return (0);
|
|
|
|
case WSCONSIO_COMPLEXBELL:
|
|
if (k->k_ispec.wi_bell != NULL) {
|
|
wbd = (struct wsconsio_bell_data *)data;
|
|
if ((wbd->wbd_flags & WSCONSIO_BELLDATA_PITCH) == 0)
|
|
wbd->wbd_pitch = k->k_belldata.wbd_pitch;
|
|
if ((wbd->wbd_flags & WSCONSIO_BELLDATA_PERIOD) == 0)
|
|
wbd->wbd_period = k->k_belldata.wbd_period;
|
|
if ((wbd->wbd_flags & WSCONSIO_BELLDATA_VOLUME) == 0)
|
|
wbd->wbd_volume = k->k_belldata.wbd_volume;
|
|
|
|
(*k->k_ispec.wi_bell)(k->k_idev, wbd);
|
|
}
|
|
return (0);
|
|
|
|
case WSCONSIO_SETBELL:
|
|
wbd = (struct wsconsio_bell_data *)data;
|
|
if ((wbd->wbd_flags & WSCONSIO_BELLDATA_PITCH) != 0)
|
|
k->k_belldata.wbd_pitch = wbd->wbd_pitch;
|
|
if ((wbd->wbd_flags & WSCONSIO_BELLDATA_PERIOD) != 0)
|
|
k->k_belldata.wbd_period = wbd->wbd_period;
|
|
if ((wbd->wbd_flags & WSCONSIO_BELLDATA_VOLUME) != 0)
|
|
k->k_belldata.wbd_volume = wbd->wbd_volume;
|
|
return (0);
|
|
|
|
case WSCONSIO_GETBELL:
|
|
wbd = (struct wsconsio_bell_data *)data;
|
|
wbd->wbd_flags = WSCONSIO_BELLDATA_PITCH |
|
|
WSCONSIO_BELLDATA_PERIOD | WSCONSIO_BELLDATA_VOLUME;
|
|
wbd->wbd_pitch = k->k_belldata.wbd_pitch;
|
|
wbd->wbd_period = k->k_belldata.wbd_period;
|
|
wbd->wbd_volume = k->k_belldata.wbd_volume ;
|
|
return (0);
|
|
|
|
#if 0 /* XXX */
|
|
/* XXX KEY-REPEAT RATE SETTING */
|
|
#endif /* XXX */
|
|
|
|
default:
|
|
if (k->k_ispec.wi_ioctl != NULL)
|
|
rv = (*k->k_ispec.wi_ioctl)(k->k_idev, cmd, data,
|
|
flag, p);
|
|
}
|
|
return (rv);
|
|
}
|
|
|
|
int
|
|
kbdselect(dev_t dev, int rw, struct proc *p)
|
|
{
|
|
|
|
return (ev_select(&kbd_softc.k_events, rw, p));
|
|
}
|
|
|
|
/* Ring the console bell. (For wscons terminal emulator and other code) */
|
|
void
|
|
wscons_kbd_bell()
|
|
{
|
|
struct kbd_softc *k = &kbd_softc;
|
|
|
|
if (k->k_ispec.wi_bell != NULL)
|
|
(*k->k_ispec.wi_bell)(k->k_idev, &k->k_belldata);
|
|
}
|
|
|
|
/*
|
|
* Console handling functions.
|
|
*/
|
|
|
|
int
|
|
kbd_cngetc(dev)
|
|
dev_t dev;
|
|
{
|
|
struct kbd_softc *k = &kbd_softc;
|
|
|
|
if (kbd_softc.k_evmode) /* XXX? */
|
|
return 0;
|
|
if (k->k_ispec.wi_getc != NULL)
|
|
return (*k->k_ispec.wi_getc)(k->k_idev);
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
kbd_cnpollc(dev, on)
|
|
dev_t dev;
|
|
int on;
|
|
{
|
|
struct kbd_softc *k = &kbd_softc;
|
|
|
|
if (kbd_softc.k_evmode) /* XXX? */
|
|
return;
|
|
if (k->k_ispec.wi_pollc != NULL)
|
|
(*k->k_ispec.wi_pollc)(k->k_idev, on);
|
|
}
|