xref: /illumos-gate/usr/src/uts/common/io/kbtrans/kbtrans.c (revision adc2b73d)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Generic keyboard support: translation
 *
 * This module is project private.  Please see PSARC/1998/176 and
 * PSARC/1998/026 for references to the kbtrans module.
 *
 * It is believed that it is safe to call these functions within debugger mode
 * except kbtrans_dprintf.  Debugger mode is a single threaded mode where most
 * kernel services are not available, including memory allocation.  Debugger
 * mode is for kmdb and OBP debugging, where the debugger calls back into the
 * kernel to obtain console input.
 *
 * Please be _very_ careful about what external functions you call.
 */

#define	KEYMAP_SIZE_VARIABLE

#include <sys/types.h>
#include <sys/cred.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/kmem.h>
#include <sys/kbd.h>
#include <sys/cmn_err.h>
#include <sys/modctl.h>
#include <sys/kbio.h>
#include <sys/vuid_event.h>
#include <sys/consdev.h>
#include <sys/kbtrans.h>
#include <sys/errno.h>
#include <sys/promif.h>
#include <sys/varargs.h>
#include "kbtrans_lower.h"

/*
 * Internal Function Prototypes
 */
static boolean_t kbtrans_do_compose(struct kbtrans_lower *, keymap_entry_t,
    keymap_entry_t, keymap_entry_t *);
static void kbtrans_translate(struct kbtrans_lower *,
    struct keyboard_callback *, kbtrans_key_t, enum keystate);

/*
 * kbtrans_processkey:
 *
 * 	lower	- state information used by the calling driver
 *		  this parameter is passed back to the callback routines.
 * 	key	- scancode
 * 	state	- KEY_PRESSED / KEY_RELEASED
 *
 * This routine checks to see if there is a raw callback, and calls it
 * if it exists.  If there is no raw callback, the key is translated.
 * The raw callback allows the driver that called the translation module
 * to be passed untranslated scancodes.
 */
void
kbtrans_processkey(struct kbtrans_lower *lower,
    struct keyboard_callback *cb, kbtrans_key_t key, enum keystate state)
{
	DPRINTF(PRINT_L0, PRINT_MASK_ALL, (lower, "kbtrans_processkey: "
	    "newstate=%d key=%d", state, key));

	/*
	 * If there is a raw routine, then call it and return.
	 */
	if (cb->kc_keypressed_raw != NULL) {

		if (state == KEY_PRESSED) {

			cb->kc_keypressed_raw(lower->kbtrans_upper, key);
		} else {

			cb->kc_keyreleased_raw(lower->kbtrans_upper, key);
		}

		return;
	}

	/*
	 * translate the scancode into a key.
	 */
	kbtrans_translate(lower, cb, key, state);
}


/*
 * kbtrans_translate:
 *
 * 	lower	- state information used by the calling driver
 *		  this parameter is passed back to the callback routines.
 * 	key		- scan code
 * 	state	- KEY_PRESSED / KEY_RELEASED
 *
 * Called to process key events if we are in TR_ASCII or TR_EVENT
 * (sunview) mode.  This routine will call the appropriate translation_callback
 * for the character when it is done translating it.
 */
static void
kbtrans_translate(struct kbtrans_lower *lower, struct keyboard_callback *cb,
    kbtrans_key_t key, enum keystate newstate)
{
	unsigned		shiftmask;
	register keymap_entry_t	entry;
	register unsigned	entrytype;
	keymap_entry_t		result;
	keymap_entry_t		*ke;
	int			i;
	boolean_t		good_compose;

	DPRINTF(PRINT_L0, PRINT_MASK_ALL, (lower, "KEY TRANSLATE "
	    "newstate=0x%x key=0x%x\n", newstate, key));

	if (lower->kbtrans_keyboard == NULL) {
		/*
		 * Nobody has told us about this keyboard yet.
		 */
		return;
	}

	/*
	 * Get the current state of the shiftmask
	 */
	shiftmask = lower->kbtrans_shiftmask;

	/*
	 * If the key has been released, then or in the UPMASK flag.
	 */
	if (newstate == KEY_RELEASED)
		shiftmask |= UPMASK;

	/*
	 * Based on the shiftmask, lookup the keymap entry that we should
	 * be using for this scancode.
	 */
	ke = kbtrans_find_entry(lower, shiftmask, key);

	if (ke == NULL) {
		/*
		 * This is a gross error.  Cancel the repeat key and exit,
		 * we can not translate this scancode.
		 */
		cb->kc_cancel_repeat(lower->kbtrans_upper);

		return;
	}

	/*
	 * Get the key for this scancode.
	 */
	entry = *ke;

	if (entry == NONL) {
		/*
		 * NONL appears only in the Num Lock table, and indicates that
		 * this key is not affected by Num Lock.  This means we should
		 * ask for the table we would have gotten had Num Lock not been
		 * down, and translate using that table.
		 */
		ke = kbtrans_find_entry(lower, shiftmask & ~NUMLOCKMASK, key);

		if (ke == NULL) {
			/*
			 * This is a gross error.  Cancel the repeat key and
			 * exit, we can not translate this scancode.
			 */
			cb->kc_cancel_repeat(lower->kbtrans_upper);

			return;
		}

		/*
		 * Get the new key for this scancode.
		 */
		entry = *ke;
	}

	/*
	 * The entrytype indicates what category of key we are processing.
	 * Categories include shift keys, function keys, and numeric keypad
	 * keys.
	 */
	entrytype = KEYFLAGS(entry);

	if (entrytype == SHIFTKEYS) {
		/*
		 * Handle the state of toggle shifts specially.
		 * Ups should be ignored, and downs should be mapped to ups if
		 * that shift is currently on.
		 */
		if ((1 << (entry & 0x0F)) &
		    lower->kbtrans_keyboard->k_toggleshifts) {
			if ((1 << (entry & 0x0F)) & lower->kbtrans_togglemask) {
				newstate = KEY_RELEASED; /* toggling off */
			} else {
				newstate = KEY_PRESSED;	/* toggling on */
			}
		}
	} else {
		/*
		 * Handle Compose and floating accent key sequences
		 */
		switch (lower->kbtrans_state) {
		case COMPOSE1:
			if (newstate == KEY_RELEASED)
				return;

			if (entry < ASCII_SET_SIZE) {
				if (lower->kbtrans_compose_map[entry] >= 0) {
					lower->kbtrans_compose_key = entry;
					lower->kbtrans_state = COMPOSE2;

					return;
				}
			}
			lower->kbtrans_state = NORMAL;
			lower->kbtrans_led_state &= ~LED_COMPOSE;

			cb->kc_setled(lower->kbtrans_upper);

			return;

		case COMPOSE2:
			if (newstate == KEY_RELEASED)
				return;

			/* next state is "normal" */
			lower->kbtrans_state = NORMAL;
			lower->kbtrans_led_state &= ~LED_COMPOSE;

			cb->kc_setled(lower->kbtrans_upper);

			good_compose = kbtrans_do_compose(lower,
			    lower->kbtrans_compose_key, entry, &result);
			if (good_compose) {
				cb->kc_keypressed(lower->kbtrans_upper,
				    entrytype, key, result);
			}
			return;

		case FLTACCENT:
			if (newstate == KEY_RELEASED)
				return;

			/* next state is "normal" */
			lower->kbtrans_state = NORMAL;
			for (i = 0;
			    (lower->kbtrans_fltaccent_table[i].fa_entry !=
			    lower->kbtrans_fltaccent_entry) ||
			    (lower->kbtrans_fltaccent_table[i].ascii != entry);
			    i++) {
				if (lower->kbtrans_fltaccent_table[i].fa_entry
				    == 0) {
					/* Invalid second key: ignore key */

					return;
				}
			}

			cb->kc_keypressed(lower->kbtrans_upper, entrytype, key,
			    lower->kbtrans_fltaccent_table[i].utf8);

			return;
		}
	}

	/*
	 * If the key is going down, and it's not one of the keys that doesn't
	 * auto-repeat, set up the auto-repeat timeout.
	 *
	 * The keys that don't auto-repeat are the Compose key,
	 * the shift keys, the "bucky bit" keys, the "floating accent" keys,
	 * and the function keys when in TR_EVENT mode.
	 */
	if (newstate == KEY_PRESSED && entrytype != SHIFTKEYS &&
	    entrytype != BUCKYBITS && entrytype != FUNNY &&
	    entrytype != FA_CLASS) {

		if (lower->kbtrans_repeatkey != key) {
			cb->kc_cancel_repeat(lower->kbtrans_upper);
			cb->kc_setup_repeat(lower->kbtrans_upper, entrytype,
			    key);
		}
		/* key going up */
	} else if (key == lower->kbtrans_repeatkey) {

		cb->kc_cancel_repeat(lower->kbtrans_upper);
	}

	if (newstate == KEY_RELEASED) {
		cb->kc_keyreleased(lower->kbtrans_upper, key);
	}

	/*
	 * We assume here that keys other than shift keys and bucky keys have
	 * entries in the "up" table that cause nothing to be done, and thus we
	 * don't have to check for newstate == KEY_RELEASED.
	 */
	switch (entrytype) {

	case 0x0:		/* regular key */
		cb->kc_keypressed(lower->kbtrans_upper, entrytype, key,
		    SPECIAL(lower->kbtrans_buckybits, entry));
		break;

	case SHIFTKEYS: {
		uint_t shiftbit = 1 << (entry & 0x0F);

		/* Modify toggle state (see toggle processing above) */
		if (shiftbit & lower->kbtrans_keyboard->k_toggleshifts) {
			if (newstate == KEY_RELEASED) {
				if (shiftbit == CAPSMASK) {
					lower->kbtrans_led_state &=
					    ~LED_CAPS_LOCK;

					cb->kc_setled(lower->kbtrans_upper);

				} else if (shiftbit == NUMLOCKMASK) {
					lower->kbtrans_led_state &=
					    ~LED_NUM_LOCK;

					cb->kc_setled(lower->kbtrans_upper);
				}
				lower->kbtrans_togglemask &= ~shiftbit;
			} else {
				if (shiftbit == CAPSMASK) {
					lower->kbtrans_led_state |=
					    LED_CAPS_LOCK;

					cb->kc_setled(lower->kbtrans_upper);
				} else if (shiftbit == NUMLOCKMASK) {
					lower->kbtrans_led_state |=
					    LED_NUM_LOCK;

					cb->kc_setled(lower->kbtrans_upper);
				}
				lower->kbtrans_togglemask |= shiftbit;
			}
		}

		if (newstate == KEY_RELEASED)
			lower->kbtrans_shiftmask &= ~shiftbit;
		else
			lower->kbtrans_shiftmask |= shiftbit;

		if (newstate == KEY_PRESSED) {
			cb->kc_keypressed(lower->kbtrans_upper, entrytype, key,
			    entry);
		}

		break;
		}

	case BUCKYBITS:
		lower->kbtrans_buckybits ^= 1 << (entry & 0x0F);

		if (newstate == KEY_PRESSED) {
			cb->kc_keypressed(lower->kbtrans_upper, entrytype, key,
			    entry);
		}

		break;

	case FUNNY:
		switch (entry) {
		case NOP:
			break;

		case IDLE:
			/* Fall thru into RESET code */
			/* FALLTHRU */
		case RESET:
		case ERROR:
			lower->kbtrans_shiftmask &=
			    lower->kbtrans_keyboard->k_idleshifts;

			lower->kbtrans_shiftmask |=
			    lower->kbtrans_togglemask;

			lower->kbtrans_buckybits &=
			    lower->kbtrans_keyboard->k_idlebuckys;

			cb->kc_cancel_repeat(lower->kbtrans_upper);

			cb->kc_keypressed(lower->kbtrans_upper, entrytype, key,
			    entry);

			break;


		case COMPOSE:
			lower->kbtrans_state = COMPOSE1;
			lower->kbtrans_led_state |= LED_COMPOSE;
			cb->kc_setled(lower->kbtrans_upper);
			break;
		/*
		 * Remember when adding new entries that,
		 * if they should NOT auto-repeat,
		 * they should be put into the IF statement
		 * just above this switch block.
		 */
		default:
			/* Ignore it */
			break;
		}
		break;

	case FA_CLASS:
		if (lower->kbtrans_state == NORMAL) {
			lower->kbtrans_fltaccent_entry = entry;
			lower->kbtrans_state = FLTACCENT;
		}
		break;

	case STRING:
		cb->kc_keypressed(lower->kbtrans_upper, entrytype, key, entry);

		break;

	case FUNCKEYS:
		cb->kc_keypressed(lower->kbtrans_upper, entrytype, key, entry);

		break;

	/*
	 * Remember when adding new entries that,
	 * if they should NOT auto-repeat,
	 * they should be put into the IF statement
	 * just above this switch block.
	 */
	case PADKEYS:
		cb->kc_keypressed(lower->kbtrans_upper, entrytype, key, entry);

		break;
	}
}

/*
 * kbtrans_do_compose:
 *	Given a two key compose sequence, lookup the iso equivalent and put
 *	the result in the result_ptr.
 */
static boolean_t
kbtrans_do_compose(struct kbtrans_lower *lower, keymap_entry_t first_entry,
    keymap_entry_t second_entry, keymap_entry_t *result_ptr)
{
	struct compose_sequence_t *ptr;
	keymap_entry_t tmp;

	/*
	 * Validate the second keystroke.
	 */
	if (second_entry >= ASCII_SET_SIZE)
		return (B_FALSE);

	if (lower->kbtrans_compose_map[second_entry] < 0)
		return (B_FALSE);

	/*
	 * Get them in code order, rather than press order.
	 */
	if (first_entry > second_entry) {
		tmp = first_entry;
		first_entry = second_entry;
		second_entry = tmp;
	}

	ptr = lower->kbtrans_compose_table +
	    lower->kbtrans_compose_map[first_entry];

	while (ptr->first == first_entry) {
		if (ptr->second == second_entry) {
			*result_ptr = ptr->utf8;

			return (B_TRUE);
		}
		ptr++;
	}
	return (B_FALSE);
}


/*
 * kbtrans_find_entry:
 * 	This routine finds the entry corresponding to the current shift
 * 	state and keycode.
 */
keymap_entry_t *
kbtrans_find_entry(struct kbtrans_lower *lower, uint_t mask,
    kbtrans_key_t key_station)
{
	register struct keyboard *kp;
	keymap_entry_t *km;
	struct exception_map *ex;

	kp = lower->kbtrans_keyboard;

	if (kp == NULL)
		return (NULL);

	if (key_station < 0 || key_station >= kp->k_keymap_size)
		return (NULL);

	ex = kp->k_except;
	if (ex != NULL) {
		for (; ex->exc_care != 0; ex++) {
			if ((mask & ex->exc_care) == ex->exc_mask &&
			    key_station == ex->exc_key)
				return (&ex->exc_entry);
		}
	}

	if (mask & UPMASK)
		km = kp->k_up;
	else if (mask & NUMLOCKMASK)
		km = kp->k_numlock;
	else if (mask & CTRLMASK)
		km = kp->k_control;
	else if (mask & ALTGRAPHMASK)
		km = kp->k_altgraph;
	else if (mask & SHIFTMASK)
		km = kp->k_shifted;
	else if (mask & CAPSMASK)
		km = kp->k_caps;
	else km = kp->k_normal;

	return (&km[key_station]);
}

#ifdef DEBUG
/*ARGSUSED*/
void
kbtrans_dprintf(void *un, const char *fmt, ...)
{
	char buf[256];
	va_list ap;

	va_start(ap, fmt);
	(void) vsprintf(buf, fmt, ap);
	va_end(ap);

	cmn_err(CE_CONT, "kbtrans: %s", buf);
}
#endif