NetBSD/sys/dev/pckbc/pckbd.c

/* $NetBSD: pckbd.c,v 1.1 1998/03/22 15:41:27 drochner Exp $ */

/*-
 * Copyright (c) 1993, 1994, 1995 Charles Hannum.  All rights reserved.
 * 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. 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.
 *
 *	@(#)pccons.c	5.11 (Berkeley) 5/21/91
 */

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

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

#include <dev/isa/isareg.h>
#include <dev/isa/isavar.h>
#include <dev/isa/pckbcvar.h>

#include <dev/pckbc/pckbdreg.h>
#include <dev/pckbc/pckbdvar.h>

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

#include <dev/pckbc/pckbd_scancodes.h>

#include "locators.h"

struct pckbd_internal {
	int t_isconsole;
	pckbc_tag_t t_kbctag;
	int t_kbcslot;

	pckbd_scan_def *t_scancodes;

	int extended;
	u_char shift_state, lock_state;

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

struct pckbd_softc {
        struct  device sc_dev;

	struct pckbd_internal *id;
	int sc_lastchar;

	struct device *sc_wskbddev;
};

#ifdef __BROKEN_INDIRECT_CONFIG
int pckbdprobe __P((struct device *, void *, void *));
#else
int pckbdprobe __P((struct device *, struct cfdata *, void *));
#endif
void pckbdattach __P((struct device *, struct device *, void *));

struct cfattach pckbd_ca = {
	sizeof(struct pckbd_softc), pckbdprobe, pckbdattach,
};

int	pckbd_ioctl __P((void *, u_long, caddr_t, int, struct proc *));
const char *pckbd_translate __P((void *, u_int, int));

const struct wskbd_accessops pckbd_accessops = {
	pckbd_ioctl,
	pckbd_translate,
};

int	pckbd_cngetc __P((void *));
void	pckbd_cnpollc __P((void *, int));

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

int	pckbd_set_xtscancode __P((pckbc_tag_t, pckbc_slot_t));
void	pckbd_init __P((struct pckbd_internal *, pckbc_tag_t, pckbc_slot_t,
			int));
void	pckbd_input __P((void *, int));
void	pckbd_update_leds __P((struct pckbd_internal *));

struct pckbd_internal pckbd_consdata;

int
pckbd_set_xtscancode(kbctag, kbcslot)
	pckbc_tag_t kbctag;
	pckbc_slot_t kbcslot;
{
	u_char cmd[2];
	int res;

	/*
	 * 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 desparately 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 (pckbc_xt_translation(kbctag, kbcslot, 1)) {
		/* The 8042 is translating for us; use AT codes. */
		cmd[0] = KBC_SETTABLE;
		cmd[1] = 2;
		res = pckbc_poll_cmd(kbctag, kbcslot, cmd, 2, 0, 0, 0);
		if (res)
			printf("pckbd: error setting scanset 2\n");
	} else {
		/* Stupid 8042; set keyboard to XT codes. */
		cmd[0] = KBC_SETTABLE;
		cmd[1] = 1;
		res = pckbc_poll_cmd(kbctag, kbcslot, cmd, 2, 0, 0, 0);
		if (res)
			printf("pckbd: error setting scanset 1\n");
	}
	return (res);
}

/*
 * these are both bad jokes
 */
int
pckbdprobe(parent, match, aux)
	struct device *parent;
#ifdef __BROKEN_INDIRECT_CONFIG
	void *match;
#else
	struct cfdata *match;
#endif
	void *aux;
{
	struct cfdata *cf = match;
	struct pckbc_attach_args *pa = aux;
	u_char cmd[1], resp[1];
	int res;

	/*
	 * 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 explicitely
	 * wired in the config file.
	 */
	if ((pa->pa_slot != PCKBC_KBD_SLOT) &&
	    (cf->cf_loc[PCKBCCF_SLOT] != PCKBC_KBD_SLOT))
		return (0);

#if 1
	/* Flush any garbage. */
	pckbc_flush(pa->pa_tag, pa->pa_slot);

	/* Reset the keyboard. */
	cmd[0] = KBC_RESET;
	res = pckbc_poll_cmd(pa->pa_tag, pa->pa_slot, cmd, 1, 1, resp, 1);
	if (res) {
		printf("pcprobe: reset error %d\n", 1);
		goto lose;
	}
	if (resp[0] != KBR_RSTDONE) {
		printf("pcprobe: reset error %d\n", 2);
		goto lose;
	}

	/*
	 * 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.
	 */
	pckbc_flush(pa->pa_tag, pa->pa_slot);

	/* Just to be sure. */
	cmd[0] = KBC_ENABLE;
	res = pckbc_poll_cmd(pa->pa_tag, pa->pa_slot, cmd, 1, 0, 0, 0);
	if (res) {
		printf("pcprobe: reset error %d\n", 3);
		goto lose;
	}

	if (pckbd_set_xtscancode(pa->pa_tag, pa->pa_slot))
		goto lose;

	return (2);

lose:
	/*
	 * Technically, we should probably fail the probe.  But we'll be nice
	 * and allow keyboard-less machines to boot with the console.
	 */
#endif
	return (1);
}

void
pckbdattach(parent, self, aux)
	struct device *parent, *self;
	void *aux;
{
	struct pckbd_softc *sc = (void *)self;
	struct pckbc_attach_args *pa = aux;
	int isconsole;
	struct wskbddev_attach_args a;

	printf("\n");

	isconsole = pckbd_consdata.t_isconsole &&
	    (pckbd_consdata.t_kbctag == pa->pa_tag) &&
	    (pckbd_consdata.t_kbcslot == pa->pa_slot);

	if (isconsole) {
		sc->id = &pckbd_consdata;
	} else {
		sc->id = malloc(sizeof(struct pckbd_internal),
				M_DEVBUF, M_WAITOK);
		pckbd_init(sc->id, pa->pa_tag, pa->pa_slot, 0);
	}

	sc->id->t_sc = sc;

	(void) pckbd_set_xtscancode(sc->id->t_kbctag, sc->id->t_kbcslot);
	pckbc_set_inputhandler(sc->id->t_kbctag, sc->id->t_kbcslot,
			       pckbd_input, sc);

	a.console = isconsole;
	a.accessops = &pckbd_accessops;
	a.accesscookie = sc->id;

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

void
pckbd_init(t, kbctag, kbcslot, console)
	struct pckbd_internal *t;
	pckbc_tag_t kbctag;
	pckbc_slot_t kbcslot;
	int console;
{
	t->t_isconsole = console;
	t->t_kbctag = kbctag;
	t->t_kbcslot = kbcslot;
	t->t_scancodes = pckbd_scan_codes_us;
	t->extended = 0;
	t->shift_state = t->lock_state = 0;
}

void
pckbd_update_leds(t)
	struct pckbd_internal *t;
{
	u_char cmd[2];

	cmd[0] = KBC_MODEIND;
	cmd[1] = t->lock_state;

	(void) pckbc_enqueue_cmd(t->t_kbctag, t->t_kbcslot, cmd, 2, 0, 0, 0);
}

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

	/* Always ignore typematic keys */
	if (data == sc->sc_lastchar)
		return;
	sc->sc_lastchar = data;

	switch (data) {
	    case KBR_EXTENDED:
		type = WSCONS_EVENT_KEY_OTHER;
		break;
	    default:
		type = (data & 0x80) ? WSCONS_EVENT_KEY_UP :
		    WSCONS_EVENT_KEY_DOWN;
		data &= ~0x80;
		break;
	}
	wskbd_input(sc->sc_wskbddev, type, data);
}

int
pckbd_ioctl(v, cmd, data, flag, p)
	void *v;
	u_long cmd;
	caddr_t data;
	int flag;
	struct proc *p;
{
	struct pckbd_internal *t = v;

/* printf("pckdb_ioctl 0x%lx, 0x%lx\n", cmd, WSKBDIO_GTYPE); */
	switch (cmd) {
	    case WSKBDIO_GTYPE:
		*(int *)data = WSKBD_TYPE_PC_XT;
		return 0;
	    case WSKBDIO_SETLEDS: {
		char cmd[2];
		int res;
		cmd[0] = KBC_MODEIND;
		cmd[1] = *(int*)data;
		res = pckbc_enqueue_cmd(t->t_kbctag, t->t_kbcslot, cmd, 2, 0,
					1, 0);
		return (res);
		}
	}
	return -1;
}

/*
 * Get characters from the keyboard.  If none are present, return NULL.
 */
const char *
pckbd_translate(v, type, value)
	void *v;
	u_int type;
	int value;
{
	struct pckbd_internal *t = v;
	u_char dt = value;
	static u_char capchar[2];

	if (type == WSCONS_EVENT_KEY_OTHER && dt == KBR_EXTENDED) {
		t->extended = 1;
		return NULL;
	}

#ifdef DDB
	/*
	 * Check for cntl-alt-esc.
	 */
	if (t->t_isconsole && (type == WSCONS_EVENT_KEY_DOWN) &&
	    (dt == 1) && ((t->shift_state & (CTL | ALT)) == (CTL | ALT))
	    /* XXX && we're not already in the debugger */) {
		Debugger();
#if 0
		dt |= 0x80;	/* discard esc (ddb discarded ctl-alt) */
#else
		t->extended = 0;
		return (NULL);
#endif
	}
#endif

	/* XXX XXX temporary hack to get virtual consoles working */
	if (t->t_sc && ((t->shift_state & (CTL | ALT)) == (CTL | ALT)) &&
	    (dt >= 59 && dt <= 66)) {
		if (type == WSCONS_EVENT_KEY_DOWN)
			wskbd_ctlinput(t->t_sc->sc_wskbddev, dt - 59);
		t->extended = 0;
		return (NULL);
	}

	/*
	 * Check for make/break.
	 */
	if (type == WSCONS_EVENT_KEY_UP) {
		/*
		 * break
		 */
		switch (t->t_scancodes[dt].type) {
		case NUM:
			t->shift_state &= ~NUM;
			break;
		case CAPS:
			t->shift_state &= ~CAPS;
			break;
		case SCROLL:
			t->shift_state &= ~SCROLL;
			break;
		case SHIFT:
			t->shift_state &= ~SHIFT;
			break;
		case ALT:
			if (t->extended) 
				t->shift_state &= ~ALTGR;
			else
				t->shift_state &= ~ALT;
			break;
		case CTL:
			t->shift_state &= ~CTL;
			break;
		}
	} else if (type == WSCONS_EVENT_KEY_DOWN) {
		/*
		 * make
		 */
		/* fix numeric / on non US keyboard */
		if (t->extended && dt == 53) {
			capchar[0] = '/';
			t->extended = 0;
			return capchar;
		}

		switch (t->t_scancodes[dt].type) {
		/*
		 * locking keys
		 */
		case NUM:
			if (t->shift_state & NUM)
				break;
			t->shift_state |= NUM;
			t->lock_state ^= NUM;
			pckbd_update_leds(t);
			break;
		case CAPS:
			if (t->shift_state & CAPS)
				break;
			t->shift_state |= CAPS;
			t->lock_state ^= CAPS;
			pckbd_update_leds(t);
			break;
		case SCROLL:
			if (t->shift_state & SCROLL)
				break;
			t->shift_state |= SCROLL;
			t->lock_state ^= SCROLL;
			if (t->t_sc)
				wskbd_holdscreen(t->t_sc->sc_wskbddev,
						 t->lock_state & SCROLL);
			pckbd_update_leds(t);
			break;
		/*
		 * non-locking keys
		 */
		case SHIFT:
			t->shift_state |= SHIFT;
			break;
		case ALT:
			if (t->extended)  
				t->shift_state |= ALTGR;
			else
				t->shift_state |= ALT;
			break;
		case CTL:
			t->shift_state |= CTL;
			break;
		case ASCII:
			/* control has highest priority */
			if (t->shift_state & CTL)
				capchar[0] = t->t_scancodes[dt].ctl[0];
			else if (t->shift_state & ALTGR)
				capchar[0] = t->t_scancodes[dt].altgr[0];
			else if (t->shift_state & SHIFT)
				capchar[0] = t->t_scancodes[dt].shift[0];
			else
				capchar[0] = t->t_scancodes[dt].unshift[0];
			if ((t->lock_state & CAPS) && capchar[0] >= 'a' &&
			    capchar[0] <= 'z') {
				capchar[0] -= ('a' - 'A');
			}
			capchar[0] |= (t->shift_state & ALT);
			t->extended = 0;
			return capchar;
		case NONE:
			break;
		case FUNC: {
			char *more_chars;
			if (t->shift_state & SHIFT)
				more_chars = t->t_scancodes[dt].shift;
			else if (t->shift_state & CTL)
				more_chars = t->t_scancodes[dt].ctl;
			else
				more_chars = t->t_scancodes[dt].unshift;
			t->extended = 0;
			return more_chars;
		}
		case KP: {
			char *more_chars;
			if (t->shift_state & (SHIFT | CTL) ||
			    (t->lock_state & NUM) == 0 || t->extended)
				more_chars = t->t_scancodes[dt].shift;
			else
				more_chars = t->t_scancodes[dt].unshift;
			t->extended = 0;
			return more_chars;
		}
		}
	}

	t->extended = 0;
	return (NULL);
}

int
pckbd_cnattach(kbctag, kbcslot)
	pckbc_tag_t kbctag;
	int kbcslot;
{
	pckbd_init(&pckbd_consdata, kbctag, kbcslot, 1);

	wskbd_cnattach(&pckbd_consops, NULL);

	return (0);
}

/* ARGSUSED */
int
pckbd_cngetc(v)
	void *v;
{
        register const char *cp = NULL;
	u_int type;
	int data;
#if 0
	static u_char last;
#endif

        do {
		/* wait for byte */
		do {
			data = pckbc_poll_data(pckbd_consdata.t_kbctag,
					       pckbd_consdata.t_kbcslot);
		} while (data == -1);

#if 0
		/* Ignore typematic keys */
		if (data == last)
			continue;
		last = data;
#endif

		switch (data) { 
		case KBR_EXTENDED:
			type = WSCONS_EVENT_KEY_OTHER;
			break;
		default:
			type = (data & 0x80) ? WSCONS_EVENT_KEY_UP :
			    WSCONS_EVENT_KEY_DOWN;
			data &= ~0x80;
			break;
		}

		cp = pckbd_translate(&pckbd_consdata, type, data);
        } while (!cp);
        if (*cp == '\r')
                return ('\n');
        return (*cp);
}

void
pckbd_cnpollc(v, on)
	void *v;
        int on;
{
	pckbc_set_poll(pckbd_consdata.t_kbctag, pckbd_consdata.t_kbcslot, on);
}