path: root/chips/dtop_handlers.c

/* 
 * Mach Operating System
 * Copyright (c) 1992 Carnegie Mellon University
 * All Rights Reserved.
 * 
 * Permission to use, copy, modify and distribute this software and its
 * documentation is hereby granted, provided that both the copyright
 * notice and this permission notice appear in all copies of the
 * software, derivative works or modified versions, and any portions
 * thereof, and that both notices appear in supporting documentation.
 * 
 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
 * 
 * Carnegie Mellon requests users of this software to return to
 * 
 *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
 *  School of Computer Science
 *  Carnegie Mellon University
 *  Pittsburgh PA 15213-3890
 * 
 * any improvements or extensions that they make and grant Carnegie Mellon
 * the rights to redistribute these changes.
 */
/*
 *	File: dtop_handlers.c
 * 	Author: Alessandro Forin, Carnegie Mellon University
 *	Date:	1/92
 *
 *	Handler functions for devices attached to the DESKTOP bus.
 */

#include <dtop.h>
#if	NDTOP > 0

#include <mach_kdb.h>

#include <machine/machspl.h>		/* spl definitions */
#include <mach/std_types.h>
#include <device/io_req.h>
#include <device/tty.h>

#include <chips/busses.h>
#include <chips/serial_defs.h>
#include <chips/screen_defs.h>
#include <mips/PMAX/tc.h>

#include <chips/dtop.h>
#include <chips/lk201.h>

/*
 * Default handler function
 */
int
dtop_null_device_handler(
	 dtop_device_t	dev,
	 dtop_message_t	msg,
	 int		event,
	 unsigned char	outc)
{
	/* See if the message was to the default address (powerup) */

	/* Uhmm, donno how to handle this. Drop it */
	if (event == DTOP_EVENT_RECEIVE_PACKET)
		dev->unknown_report = *msg;
	return 0;
}

/*
 * Handler for locator devices (mice)
 */
int
dtop_locator_handler(
	 dtop_device_t	dev,
	 dtop_message_t	msg,
	 int		event,
	 unsigned char	outc)
{
	register unsigned short	buttons;
	register short		coord;
#if	BYTE_MSF
#	define	get_short(b0,b1)	(((b1)<<8)|(b0))
#else
#	define	get_short(b0,b1)	(((b0)<<8)|(b1))
#endif

	/*
	 * Do the position first
	 */
	{
		register int		i;
		register boolean_t	moved;
		int			delta_coords[L_COORD_MAX];

		/*
		 * Get all coords, see if it moved at all (buttons!)
		 */
		moved = FALSE;
		for (i = 0; i < dev->locator.n_coords; i++) {

			coord = get_short(msg->body[2+(i<<1)],
					  msg->body[3+(i<<1)]);

			if (dev->locator.relative) {
				/*
				 * Flame on
				 * I am getting tired of this, why do they have to
				 * keep this bug around ?  Religion ?  Damn, they
				 * design a keyboard for X11 use and forget the mouse ?
				 * Flame off
				 */
#define	BOGUS_DEC_X_AXIS
#ifdef	BOGUS_DEC_X_AXIS
				if (i == 1) coord = - coord;
#endif	/* BOGUS_DEC_X_AXIS */
				/* dev->locator.coordinate[i] += coord; */
			} else {
				register unsigned int	old_coord;

				old_coord = dev->locator.coordinate[i];
				dev->locator.coordinate[i] = coord;
				coord = old_coord - coord;
			}
			delta_coords[i] = coord;
			if (coord != 0)
				moved = TRUE;
		}
		if (moved) {
			/* scale and threshold done higher up */
			screen_motion_event( 0,
				dev->locator.type,
				delta_coords[0],
				delta_coords[1]);
		}
	}

	/*
	 * Time for the buttons now
	 */
#define	new_buttons	coord
	new_buttons = get_short(msg->body[0],msg->body[1]);
	buttons = new_buttons ^ dev->locator.prev_buttons;
	if (buttons) {
		register int	i, type;

		dev->locator.prev_buttons = new_buttons;
		for (i = 0; buttons; i++, buttons >>= 1) {

			if ((buttons & 1) == 0) continue;

			type = (new_buttons & (1<<i)) ? 
				EVT_BUTTON_DOWN : EVT_BUTTON_UP;
			screen_keypress_event(	0,
						dev->locator.type,
						dev->locator.button_code[i],
						type);
		}
	}
#undef	new_buttons
}

/*
 * Handler for keyboard devices
 * Special case: outc set for recv packet means
 * we are inside the kernel debugger
 */
int
dtop_keyboard_handler(
	 dtop_device_t	dev,
	 dtop_message_t	msg,
	 int		event,
	 unsigned char	outc)
{
	char		save[11];
	register int	msg_len, c;

	/*
	 * Well, really this code handles just an lk401 and in
	 * a very primitive way at that.  Should at least emulate
	 * an lk201 decently, and make that a pluggable module.
	 * Sigh.
	 */

	if (event != DTOP_EVENT_RECEIVE_PACKET) {
		switch (event) {
		case DTOP_EVENT_POLL:
		    {
			register unsigned int	t, t0;

			/*
			 * Note we will always have at least the
			 * end-of-list marker present (a zero)
			 * Here stop and trigger of autorepeat.
			 * Do not repeat shift keys, either.
			 */
			{
				register unsigned char	uc, i = 0;

rpt_char:
				uc = dev->keyboard.last_codes[i];

				if (uc == DTOP_KBD_EMPTY) {
					dev->keyboard.k_ar_state = K_AR_OFF;
					return 0;
				}
				if ((uc >= LK_R_SHIFT) && (uc <= LK_R_ALT)) {
					/* sometimes swapped. Grrr. */
					if (++i < dev->keyboard.last_codes_count) 
						goto rpt_char;
					dev->keyboard.k_ar_state = K_AR_OFF;
					return 0;
				}
				c = uc;
			}

			/*
			 * Got a char. See if enough time from stroke,
			 * or from last repeat.
			 */
			t0 = (dev->keyboard.k_ar_state == K_AR_TRIGGER) ? 30 : 500;
			t = approx_time_in_msec();
			if ((t - dev->keyboard.last_msec) < t0)
				return 0;

			dev->keyboard.k_ar_state = K_AR_TRIGGER;

			/*
			 * Simplest thing to do is to mimic lk201
			 */
			outc = lk201_input(0, LK_REPEAT);
			if ( ! screen_keypress_event(	0,
							DEV_KEYBD,
							c,
							EVT_BUTTON_UP)) {
				if (outc > 0) cons_input(0, outc, 0);
			} else
				screen_keypress_event(	0,
							DEV_KEYBD,
							c,
							EVT_BUTTON_DOWN);
			return 0;
		    }
		default:	gimmeabreak();/*fornow*/
		}
		return -1;
	}

	msg_len = msg->code.val.len;

	/* Check for errors */
	c = msg->body[0];
	if ((c < DTOP_KBD_KEY_MIN) && (c != DTOP_KBD_EMPTY)) {
		printf("Keyboard error: %x %x %x..\n", msg_len, c, msg->body[1]);
		if (c != DTOP_KBD_OUT_ERR) return -1;
		/* spec sez if scan list overflow still there is data */
		msg->body[0] = 0;
	}

	dev->keyboard.last_msec = approx_time_in_msec();

	switch (dev->keyboard.k_ar_state) {
	case K_AR_IDLE:
		/* if from debugger, timeouts might not be working yet */
		if (outc == 0xff)
			break;
		dtop_keyboard_autorepeat( dev );
		/* fall through */
	case K_AR_TRIGGER:
		dev->keyboard.k_ar_state = K_AR_ACTIVE;
		break;
	case K_AR_ACTIVE:
		break;
	case K_AR_OFF:	gimmeabreak();	/* ??? */
		dev->keyboard.k_ar_state = K_AR_IDLE;
	}

	/*
	 * We can only assume that pressed keys are reported in the
	 * same order (a minimum of sanity, please) across scans.
	 * To make things readable, do a first pass cancelling out
	 * all keys that are still pressed, and a second one generating
	 * events.  While generating events, do the upstrokes first
	 * from oldest to youngest, then the downstrokes from oldest
	 * to youngest.  This copes with lost packets and provides
	 * a reasonable model even if scans are too slow.
	 */

	/* make a copy of new state first */
	{
		register char	*p, *q, *e;

		p = save;
		q = (char*)msg->body;
		e = (char*)&msg->body[msg_len];

		while (q < e)
			*p++ = *q++;
	}

	/*
	 * Do the cancelling pass
	 */
	{
		register char	*ls, *le, *ns, *ne, *sync;

		ls = (char*)dev->keyboard.last_codes;
		le = (char*)&dev->keyboard.last_codes[dev->keyboard.last_codes_count];
		ns = (char*)msg->body;
		ne = (char*)&msg->body[msg_len];

		/* sync marks where to restart scanning, saving
		   time thanks to ordering constraints */
		for (sync = ns; ls < le; ls++) {
			register char	c = *ls;
			for (ns = sync; ns < ne; ns++)
				if (c == *ns) {
					*ls = *ns = 0;
					sync = ns + 1;
					break;
				}
			/* we could already tell if c is an upstroke,
			   but see the above discussion about errors */
		}
	}
	/*
	 * Now generate all upstrokes
	 */
	{
		register char	*ls, *le;
		register unsigned char	c;

		le = (char*)dev->keyboard.last_codes;
		ls = (char*)&dev->keyboard.last_codes[dev->keyboard.last_codes_count - 1];

		for ( ; ls >= le; ls--)
		    if (c = *ls) {
			/* keep kernel notion of lk201 state consistent */
			(void) lk201_input(0,c);			

			if (outc == 0)
			    screen_keypress_event(0,
						  DEV_KEYBD,
						  c,
						  EVT_BUTTON_UP);
		    }
	}
	/*
	 * And finally the downstrokes
	 */
	{
		register char	*ns, *ne, c, retc;

		ne = (char*)msg->body;
		ns = (char*)&msg->body[msg_len - 1];
		retc = 0;

		for ( ; ns >= ne; ns--)
		    if (c = *ns) {
			register unsigned char	data;

			data = c;
			c = lk201_input(0, data);

			if (c == -2) {	/* just returned from kdb */
				/* NOTE: many things have happened while
				   we were sitting on the stack, now it
				   is last_codes that holds the truth */
#if 1
				/* But the truth might not be welcome.
				   If we get out because we hit RETURN
				   on the rconsole line all is well,
				   but if we did it from the keyboard
				   we get here on the downstroke. Then
				   we will get the upstroke which we
				   would give to X11. People complained
				   about this extra keypress..  so they
				   lose everything. */

				dev->keyboard.last_codes_count = 1;
				dev->keyboard.last_codes[0] = 0;
#endif
				return -1;
			}

			/*
			 * If X11 had better code for the keyboard this
			 * would be an EVT_BUTTON_DOWN.  But that would
			 * screwup the REPEAT function. Grrr.
			 */
			/* outc non zero sez we are in the debugger */
			if (outc == 0) {
			    if (screen_keypress_event(0,
						  DEV_KEYBD,
						  data,
						  EVT_BUTTON_DOWN))
				c = -1; /* consumed by X */
			    else
				if (c > 0) cons_input(0, c, 0);
			}
			/* return the xlated keycode anyways */
			if ((c > 0) && (retc == 0))
			    retc = c;
		    }
		outc = retc;
	}
	/* install new scan state */
	{
		register char	*p, *q, *e;

		p = (char*)dev->keyboard.last_codes;
		q = (char*)save;
		e = (char*)&save[msg_len];

		while (q < e)
			*p++ = *q++;
		dev->keyboard.last_codes_count = msg_len;
	}
	return outc;
}

/*
 * Polled operations: we must do autorepeat by hand. Sigh.
 */
dtop_keyboard_autorepeat(
	dtop_device_t	dev)
{
	spl_t	s = spltty();

	if (dev->keyboard.k_ar_state != K_AR_IDLE)
		dtop_keyboard_handler( dev, 0, DTOP_EVENT_POLL, 0);

	if (dev->keyboard.k_ar_state == K_AR_OFF)
		dev->keyboard.k_ar_state = K_AR_IDLE;
	else
		timeout( dtop_keyboard_autorepeat, dev, dev->keyboard.poll_frequency);

	splx(s);
}

#endif	/*NDTOP>0*/