xref: /src/sys/dev/sun/kbdsun.c

/*	$NetBSD: kbdsun.c,v 1.1 2002/10/03 16:13:26 uwe Exp $	*/
/*	NetBSD: kbd.c,v 1.29 2001/11/13 06:54:32 lukem 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
 */

/*
 * /dev/kbd middle layer for sun keyboard off a serial line
 * This code is used by kbd_zs and sunkbd drivers (lower layer).
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: kbdsun.c,v 1.1 2002/10/03 16:13:26 uwe Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/conf.h>
#include <sys/device.h>
#include <sys/ioctl.h>
#include <sys/kernel.h>
#include <sys/proc.h>
#include <sys/signal.h>
#include <sys/signalvar.h>
#include <sys/time.h>
#include <sys/syslog.h>
#include <sys/select.h>
#include <sys/poll.h>
#include <sys/file.h>

#include <machine/vuid_event.h>
#include <machine/kbd.h>
#include <machine/kbio.h>
#include <dev/sun/event_var.h>
#include <dev/sun/kbd_xlate.h>

#include <dev/sun/kbdvar.h>
#include <dev/sun/kbdsunvar.h>


/* callbacks for the upper /dev/kbd layer */
static int	kbd_sun_open(struct kbd_softc *);
static int	kbd_sun_close(struct kbd_softc *);
static int	kbd_sun_do_cmd(struct kbd_softc *, int, int);
static int	kbd_sun_set_leds(struct kbd_softc *, int, int);

static void	kbd_sun_set_leds1(struct kbd_softc *, int); /* aux */

struct kbd_ops kbd_ops_sun = {
	kbd_sun_open,
	kbd_sun_close,
	kbd_sun_do_cmd,
	kbd_sun_set_leds
};

/* in user context, wait for keyboard output to finish */
static int 	kbd_sun_drain_tx(struct kbd_sun_softc *);

/* helper functions for kbd_sun_input */
static void	kbd_sun_was_reset(struct kbd_sun_softc *);
static void	kbd_sun_new_layout(struct kbd_sun_softc *);
static void	kbd_sun_repeat(void *);


/***********************************************************************
 *		      Callbacks for upper layer.
 */

/*
 * Initialization to be done at first open.
 * This is called from kbdopen() or kd_cc_open()
 * Called with user context.
 */
static int
kbd_sun_open(kbd)
	struct kbd_softc *kbd;
{
	struct kbd_sun_softc *k = (struct kbd_sun_softc *)kbd;
	struct kbd_state *ks;
	int error, s;

	if (kbd == NULL)
		return (ENXIO);

	ks = &kbd->k_state;

	/* tolerate extra calls. */
	if (k->k_isopen)
		return (0);

	/* stop pending autorepeat */
	if (k->k_repeating) {
		k->k_repeating = 0;
		callout_stop(&k->k_repeat_ch);
	}

	/* open internal device */
	if (k->k_deviopen)
		(*k->k_deviopen)((struct device *)k, FREAD|FWRITE);

	s = spltty();

	/* reset the keyboard and find out its type */
	kbd_sun_output(k, KBD_CMD_RESET);
	kbd_sun_start_tx(k);
	kbd_sun_drain_tx(k);

	/* the wakeup for this is in kbd_was_reset(). */
	error = tsleep((caddr_t)&ks->kbd_id, PZERO | PCATCH, devopn, hz);
	if (error == EWOULDBLOCK) { /* no response */
		log(LOG_ERR, "%s: reset failed\n", kbd->k_dev.dv_xname);

		/*
		 * Allow the open anyway (to keep getty happy)
		 * but assume the "least common denominator".
		 */
		error = 0;
		ks->kbd_id = KB_SUN2;
	}

	/* initialize the table pointers for this type */
	kbd_xlate_init(ks);

	/* earlier than type 4 does not know "layout" */
	if (ks->kbd_id < KB_SUN4)
		goto done;

	/* ask for the layout */
	kbd_sun_output(k, KBD_CMD_GETLAYOUT);
	kbd_sun_start_tx(k);
	kbd_sun_drain_tx(k);

	/* the wakeup for this is in kbd_new_layout() */
	error = tsleep((caddr_t)&ks->kbd_layout, PZERO | PCATCH, devopn, hz);
	if (error == EWOULDBLOCK) { 	/* no response */
		log(LOG_ERR, "%s: no response to get_layout\n",
		    kbd->k_dev.dv_xname);
		error = 0;
		ks->kbd_layout = 0; /* US layout */
	}
  done:
	splx(s);

	if (error == 0)
		k->k_isopen = 1;

	return (error);
}


static int
kbd_sun_close(kbd)
	struct kbd_softc *kbd;
{

	return (0);		/* nothing to do so far */
}


/*
 * keyboard command ioctl
 * ``unimplemented commands are ignored'' (blech)
 * XXX: This is also exported to the fb driver (for bell).
 */
static int
kbd_sun_do_cmd(kbd, cmd, isioctl)
	struct kbd_softc *kbd;
	int cmd;
	int isioctl;
{
	struct kbd_sun_softc *k = (struct kbd_sun_softc *)kbd;
	struct kbd_state *ks;
	int error, s;

	error = 0;
	ks = &kbd->k_state;

	switch (cmd) {

	case KBD_CMD_BELL:
	case KBD_CMD_NOBELL:
		/* Supported by type 2, 3, and 4 keyboards */
		break;

	case KBD_CMD_CLICK:
	case KBD_CMD_NOCLICK:
		/* Unsupported by type 2 keyboards */
		if (ks->kbd_id <= KB_SUN2)
			return (0);
		ks->kbd_click = (cmd == KBD_CMD_CLICK);
		break;

	default:
		return (0);
	}

	s = spltty();

	if (isioctl)
		error = kbd_sun_drain_tx(k);

	if (error == 0) {
		kbd_sun_output(k, cmd);
		kbd_sun_start_tx(k);
	}

	splx(s);

	return (error);
}


/*
 * KIOCSLED.  Has user context.
 * Take care about spl and call kbd_sun_set_leds.
 */
static int
kbd_sun_set_leds(kbd, leds, isioctl)
	struct kbd_softc *kbd;
	int leds;
	int isioctl;
{
	struct kbd_sun_softc *k = (struct kbd_sun_softc *)kbd;

	if (isioctl) {
		int error, s;
		s = spltty();
		error = kbd_sun_drain_tx(k);
		if (error == 0) {
			kbd_sun_set_leds1(kbd, leds);
		}
		splx(s);
		return (error);
	}
	else {
		kbd_sun_set_leds1(kbd, leds);
		return (0);
	}
}


/*
 * Safe to call from intterupt handler.  Called at spltty()
 * by kbd_sun_iocsled and kbd_sun_input (via kbd_update_leds).
 */
static void
kbd_sun_set_leds1(kbd, new_leds)
	struct kbd_softc *kbd;
	int new_leds;
{
	struct kbd_sun_softc *k = (struct kbd_sun_softc *)kbd;
	struct kbd_state *ks = &kbd->k_state;

	/* Don't send unless state changes. */
	if (ks->kbd_leds == new_leds)
		return;

	ks->kbd_leds = new_leds;

	/* Only type 4 and later has LEDs anyway. */
	if (ks->kbd_id < KB_SUN4)
		return;

	kbd_sun_output(k, KBD_CMD_SETLED);
	kbd_sun_output(k, new_leds);
	kbd_sun_start_tx(k);
}



/***********************************************************************
 *	Methods for lower layer to call and related functions.
 */

/*
 * Enqueue some output for the keyboard
 * Called at spltty().
 */
void
kbd_sun_output(k, c)
	struct kbd_sun_softc *k;
	int c;	/* the data */
{
	int put;

	put = k->k_tbput;
	k->k_tbuf[put] = (u_char)c;
	put = (put + 1) & KBD_TX_RING_MASK;

	/* Would overrun if increment makes (put == get) */
	if (put == k->k_tbget) {
		log(LOG_WARNING, "%s: output overrun\n",
		    k->k_kbd.k_dev.dv_xname);
	} else {
		/* OK, really increment. */
		k->k_tbput = put;
	}
}


/*
 * In user context.  Called at spltty().
 * Wait for output to keyboard to finish.
 */
static int
kbd_sun_drain_tx(k)
	struct kbd_sun_softc *k;
{
	int error = 0;

	while (k->k_txflags & K_TXBUSY && !error) {
		k->k_txflags |= K_TXWANT;
		error = tsleep((caddr_t)&k->k_txflags,
			       PZERO | PCATCH, "kbdout", 0);
	}

	return (error);
}

/*
 * Start the sending data from the output queue
 * Called at spltty().
 */
void
kbd_sun_start_tx(k)
	struct kbd_sun_softc *k;
{
	int get;
	u_char c;

	if (k->k_txflags & K_TXBUSY)
		return;

	/* Is there anything to send? */
	get = k->k_tbget;
	if (get == k->k_tbput) {
		/* Nothing to send.  Wake drain waiters. */
		if (k->k_txflags & K_TXWANT) {
			k->k_txflags &= ~K_TXWANT;
			wakeup((caddr_t)&k->k_txflags);
		}
		return;
	}

	/* Have something to send. */
	c = k->k_tbuf[get];
	get = (get + 1) & KBD_TX_RING_MASK;
	k->k_tbget = get;
	k->k_txflags |= K_TXBUSY;

	/* Pass data down to the underlying device. */
	(*k->k_write_data)(k, c);
}


/*
 * Called by underlying driver's softint() routine on input,
 * which passes us the raw hardware scan codes.
 * Called at spltty()
 */
void
kbd_sun_input(k, c)
	struct kbd_sun_softc *k;
	int c;
{
	struct kbd_softc *kbd = (struct kbd_softc *)k;
	struct kbd_state *ks = &kbd->k_state;
	int keysym;

	/* XXX - Input errors already handled. */

	/* Are we expecting special input? */
	if (k->k_expect) {
		if (k->k_expect & KBD_EXPECT_IDCODE) {
			/* We read a KBD_RESET last time. */
			ks->kbd_id = c;
			kbd_sun_was_reset(k);
		}
		if (k->k_expect & KBD_EXPECT_LAYOUT) {
			/* We read a KBD_LAYOUT last time. */
			ks->kbd_layout = c;
			kbd_sun_new_layout(k);
		}
		k->k_expect = 0;
		return;
	}

	/* Is this one of the "special" input codes? */
	if (KBD_SPECIAL(c)) {
		switch (c) {
		case KBD_RESET:
			k->k_expect |= KBD_EXPECT_IDCODE;
			/* Fake an "all-up" to resync. translation. */
			c = KBD_IDLE;
			break;

		case KBD_LAYOUT:
			k->k_expect |= KBD_EXPECT_LAYOUT;
			return;

		case KBD_ERROR:
			log(LOG_WARNING, "%s: received error indicator\n",
			    kbd->k_dev.dv_xname);
			return;

		case KBD_IDLE:
			/* Let this go to the translator. */
			break;
		}
	}

	/*
	 * If /dev/kbd is not connected in event mode,
	 * translate and send upstream (to console).
	 */
	if (!kbd->k_evmode) {

		/* Any input stops auto-repeat (i.e. key release). */
		if (k->k_repeating) {
			k->k_repeating = 0;
			callout_stop(&k->k_repeat_ch);
		}

		/* Translate this code to a keysym */
		keysym = kbd_code_to_keysym(ks, c);

		/* Pass up to the next layer. */
		if (kbd_input_keysym(kbd, keysym)) {
			log(LOG_WARNING, "%s: code=0x%x with mod=0x%x"
					 " produced unexpected keysym 0x%x\n",
			    kbd->k_dev.dv_xname,
			    c, ks->kbd_modbits, keysym);
			/* No point in auto-repeat here. */
			return;
		}

		/* Does this symbol get auto-repeat? */
		if (KEYSYM_NOREPEAT(keysym))
			return;

		/* Setup for auto-repeat after initial delay. */
		k->k_repeating = 1;
		k->k_repeatsym = keysym;
		callout_reset(&k->k_repeat_ch, k->k_repeat_start,
			      kbd_sun_repeat, k);
		return;
	}

	/*
	 * IDLEs confuse the MIT X11R4 server badly, so we must drop them.
	 * This is bad as it means the server will not automatically resync
	 * on all-up IDLEs, but I did not drop them before, and the server
	 * goes crazy when it comes time to blank the screen....
	 */
	if (c == KBD_IDLE)
		return;

	/*
	 * Keyboard is generating events.  Turn this keystroke into an
	 * event and put it in the queue.
	 */
	kbd_input_event(kbd, c);
}


/*
 * Called by kbd_sun_input to handle keyboard's response to reset.
 * Called at spltty().
 */
static void
kbd_sun_was_reset(k)
	struct kbd_sun_softc *k;
{
	struct kbd_state *ks = &k->k_kbd.k_state;

	/*
	 * On first identification, wake up anyone waiting for type
	 * and set up the table pointers.
	 */
	wakeup((caddr_t)&ks->kbd_id);

	/* Restore keyclick, if necessary */
	switch (ks->kbd_id) {

	case KB_SUN2:
		/* Type 2 keyboards don't support keyclick */
		break;

	case KB_SUN3:
		/* Type 3 keyboards come up with keyclick on */
		if (!ks->kbd_click) {
			/* turn off the click */
			kbd_sun_output(k, KBD_CMD_NOCLICK);
			kbd_sun_start_tx(k);
		}
		break;

	case KB_SUN4:
		/* Type 4 keyboards come up with keyclick off */
		if (ks->kbd_click) {
			/* turn on the click */
			kbd_sun_output(k, KBD_CMD_CLICK);
			kbd_sun_start_tx(k);
		}
		break;
	}

	/* LEDs are off after reset. */
	ks->kbd_leds = 0;
}

/*
 * Called by kbd_sun_input to handle response to layout request.
 * Called at spltty().
 */
static void
kbd_sun_new_layout(k)
	struct kbd_sun_softc *k;
{
	struct kbd_state *ks = &k->k_kbd.k_state;

	/*
	 * On first identification, wake up anyone waiting for type
	 * and set up the table pointers.
	 */
	wakeup((caddr_t)&ks->kbd_layout);

	/* XXX: switch decoding tables? */
}


/*
 * This is the autorepeat callout function.
 * Autorepeat is scheduled by kbd_sun_input.
 * Called at splsoftclock().
 */
static void
kbd_sun_repeat(arg)
	void *arg;
{
	struct kbd_sun_softc *k = (struct kbd_sun_softc *)arg;
	int s;

	s = spltty();
	if (k->k_repeating && k->k_repeatsym >= 0) {

		/* feed typematic keysym to the upper layer */
		(void)kbd_input_keysym(&k->k_kbd, k->k_repeatsym);

		/* reschedule next repeat */
		callout_reset(&k->k_repeat_ch, k->k_repeat_step,
			      kbd_sun_repeat, k);
	}
	splx(s);
}