xref: /illumos-gate/usr/src/uts/common/sys/kbd.h (revision adc2b73d)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#ifndef _SYS_KBD_H
#define	_SYS_KBD_H

#ifdef	__cplusplus
extern "C" {
#endif

/*
 * Following #defines are related to the older keyboards which
 * are no longer supported by kb module.  The #defines ane left
 * for older programs to still compile.
 */
#define	KB_KLUNK	0x00		/* Micro Switch 103SD32-2 */
#define	KB_VT100	0x01		/* Keytronics VT100 compatible */
#define	KB_SUN2		0x02		/* Sun-2 custom keyboard */
#define	KB_VT220	0x81		/* Emulation VT220 */
#define	KB_VT220I	0x82		/* International VT220 Emulation */

#define	NOTPRESENT	0xFF		/* Keyboard is not plugged in */
#define	KBD_CMD_LED1	0x04		/* Turn on LED 1 for Sun-2 */
#define	KBD_CMD_NOLED1	0x05		/* Turn off LED 1 for Sun-2 */
#define	KBD_CMD_LED2	0x06		/* Turn on LED 2 for Sun-2 */
#define	KBD_CMD_NOLED2	0x07		/* Turn off LED 2 for Sun-2 */

#define	CTLSMASK	0x0100		/* Set if ^S was last keyed of ^S, ^Q */
					/* determines which NOSCROLL sends. */

#define	NOSCROLL	0x303	/* This key alternately sends ^S or ^Q */
#define	CTRLS		0x304	/* This sends ^S and lets NOSCROLL know */
#define	CTRLQ		0x305	/* This sends ^Q and lets NOSCROLL know */


/*
 * Following are the only keyboard types supported by kb module.
 * (Type 5, Hobo, US101A are also supported but they report
 * themselves as Type 4 keyboard with a different layout id.)
 */
#define	KB_SUN3		3		/* Type 3 Sun keyboard */
#define	KB_SUN4		4		/* Type 4 Sun keyboard */
#define	KB_USB		6		/* USB keyboard */
#define	KB_PC		101		/* Type 101 AT keyboard */

#define	KB_ASCII	0x0F		/* Ascii terminal masquerading as kbd */

/*
 * This structure is used to enumerate the supported keyboard types.
 * The array of these is terminated by an entry with a NULL table entry.
 * The first entry is used if none match.
 */
struct keyboards {
	int		id;	/* Keyboard type, per KIOCTYPE */
	struct keyboard	*table;	/* Keyboard table to use. */
};

/*
 * Various special characters that might show up on the port
 */
#define	IDLEKEY		0x7F		/* Keyboard is idle; no keys down */
#define	ERRORKEY	0x7E		/* Keyboard detected an error */
#define	RESETKEY	0xFF		/* Keyboard was just reset */
#define	LAYOUTKEY	0xFE		/* Keyboard layout byte follows */

#define	PRESSED		0x00		/* 0x80 bit off: key was pressed */
#define	RELEASED	0x80		/* 0x80 bit on : key was released */

/*
 * Commands to the Sun-3 keyboard.
 */
#define	KBD_CMD_RESET		0x01	/* Reset keyboard as if power-up */
#define	KBD_CMD_BELL		0x02	/* Turn on the bell */
#define	KBD_CMD_NOBELL		0x03	/* Turn off the bell */
#define	KBD_CMD_CLICK		0x0A	/* Turn on the click annunciator */
#define	KBD_CMD_NOCLICK		0x0B	/* Turn off the click annunciator */

/*
 * Commands to the Type 4 keyboard, in addition to those above.
 */
#define	KBD_CMD_AUTOTEST	0x0C	/* Initiate test sequence */
#define	KBD_CMD_SETLED		0x0E	/* Set keyboard LED's */
#define	KBD_CMD_GETLAYOUT	0x0F	/* Request that keyboard indicate */
					/* layout */
/*
 * Type 4 keyboard LED masks (used to set LED's)
 */
#define	LED_NUM_LOCK	0x1
#define	LED_COMPOSE	0x2
#define	LED_SCROLL_LOCK 0x4
#define	LED_CAPS_LOCK	0x8
#define	LED_KANA	0x10		/* Valid only on Japanese layout */

/*
 * Software related definitions
 */
/*
 * These are the states that the keyboard scanner can be in.
 *
 * It starts out in NORMAL state.
 */
#define	NORMAL		0		/* The usual (ho, hum) */
#define	ABORT1		1		/* Got KEYABORT1 */
#define	COMPOSE1	2		/* Got COMPOSE */
#define	COMPOSE2	3		/* Got COMPOSE plus first key */
#define	FLTACCENT	4		/* Got floating accent key */
#define	NEWABORT1	5		/* Got NEW KEYABORT1 */

/*
 * Size of ASCII set as used in compose handling.
 */
#define	ASCII_SET_SIZE	128

/*
 * These are how you can have your input translated.
 * TR_EVENT means that each keystroke is sent as a firm event.
 * TR_UNTRANS_EVENT also sends a firm event for each up / down transition,
 * but the value is untranslated: the event id is the key station; the
 * value indicates whether the transition was up or down; the value of the
 * shift-mask is undefined.
 */
#define	TR_NONE		  0
#define	TR_ASCII	  1
#define	TR_EVENT	  2
#define	TR_UNTRANS_EVENT  3

/*
 * These bits can appear in the result of TR_NONE & TR_UNTRANS_EVENT getkey()s.
 */
#define	BUILDKEY(key, state)	(key | state)
#define	STATEOF(key)	((key) & RELEASED)	/* 0 = key down, !=0 = key up */
#define	KEYOF(key)	((key) & ~RELEASED)	/* The key number that moved */
#define	NOKEY		(-1)		/* The argument was 0, and no key was */
					/* depressed.  They were all elated. */

/*
 * "Bucky" bits.  These are bits for mode keys.	 The META bit is ORed into the
 * result of TR_ASCII getkey()s, and can be ORed into the result of TR_EVENT
 * getkey()s for backwards compatibility.
 * (NOKEY can also appear if no keypress was queued up.)
 */
#define	METABIT		0		/* Meta key depressed with key */
#define	METAMASK	0x000080
#define	SYSTEMBIT	1		/* Upper left key was down w/key */
#define	SYSTEMMASK	0x000100
/* other "bucky" bits can be defined at will.  See "BUCKYBITS" below. */

/*
 * This defines the bit positions used within "shiftmask" to
 * indicate the "pressed" (1) or "released" (0) state of shift keys.
 * Both the bit numbers, and the aggregate masks, are defined.
 *
 * The "UPMASK" is a minor kludge.  Since whether the key is going
 * up or down determines the translation table (just as the shift
 * keys' positions do), we OR it with "shiftmask" to get "tempmask",
 * which is the mask which is actually used to determine the
 * translation table to use.  Don't reassign 0x0080 for anything
 * else, or we'll have to shift and such to squeeze in UPMASK,
 * since it comes in from the hardware as 0x80.
 */
#define	CAPSLOCK	0		/* Caps Lock key */
#define	CAPSMASK	0x0001
#define	SHIFTLOCK	1		/* Shift Lock key */
#define	LEFTSHIFT	2		/* Left-hand shift key */
#define	RIGHTSHIFT	3		/* Right-hand shift key */
#define	SHIFTMASK	0x000E
#define	LEFTCTRL	4		/* Left-hand (or only) control key */
#define	RIGHTCTRL	5		/* Right-hand control key */
#define	CTRLMASK	0x0030
/*	META		6		Meta keys */
/*	META_SHIFT_MASK 0x0040		reserved */
/*	TOP		7		do not use! */
/*	TOPMASK		0x0080		UPMASK in keyboard driver */
/*	CMD		8		reserved */
/*	CMDMASK		0x0100		reserved */
#define	ALTGRAPH	9		/* Alt Graph key */
#define	ALTGRAPHMASK	0x0200
#define	ALT		10		/* Left (or only) Alt key */
#define	LEFTALT		10		/* Left Alt key */
#define	ALTMASK		0x1400
#define	NUMLOCK		11		/* Num Lock key */
#define	NUMLOCKMASK	0x0800
#define	RIGHTALT	12		/* Right Alt key */
#define	UPMASK		0x0080

/*
 * This defines the format of translation tables.
 *
 * A translation table is KEYMAP_SIZE "entries", each of which is 2 bytes
 * (unsigned shorts).  The top 8 bits of each entry are decoded by
 * a case statement in getkey.c.  If the entry is less than 0x100, it
 * is sent out as an EUC character (possibly with bucky bits
 * OR-ed in).  "Special" entries are 0x100 or greater, and
 * invoke more complicated actions.
 *
 * The KEYMAP_SIZE is dependent upon the keyboard type.  For example, the
 * Sun Type 4/5 keyboards have a KEYMAP_SIZE of 128 where a USB keyboard
 * has a KEYMAP_SIZE of 255.  Instead of defining a KEYMAP_SIZE per
 * keyboard type, a keyboard specific module/driver may supply the value
 * at run time by defining the KEYMAP_SIZE_VARIABLE and filling in the
 * keyboard struct appropriately.
 */

typedef unsigned int keymap_entry_t;
#ifdef KEYMAP_SIZE_VARIABLE


#else
#define	KEYMAP_SIZE	128

struct keymap {
	keymap_entry_t	keymap[KEYMAP_SIZE];	/* maps keycodes to actions */
};

#endif

/*
 * This structure is used for "exception" cases for key sequences that
 * we want to map, that should not be handled by keymap entries (For
 * example: using Control-Shift-F1 on PC's for the compose key).
 */
struct exception_map {
	/*
	 * these are the modifier keys that we "care" about
	 */
	unsigned int exc_care;

	/*
	 * This is the mask of modifier keys that we want to match
	 */
	unsigned int exc_mask;

	/*
	 * This is the key that we want to match.
	 */
	int exc_key;

	/*
	 * This is our translated version of the matching sequence.
	 */
	keymap_entry_t exc_entry;
};

/*
 * A keyboard is defined by its keymaps and what state it resets at idle.
 *
 * The masks k_idleshifts and k_idlebuckys are AND-ed with the current
 * state of  shiftmask	and  buckybits	when a "keyboard idle" code
 * is received.	 This ensures that where we "think" the shift & bucky
 * keys are, more accurately reflects where they really are, since the
 * keyboard knows better than us.  However, some keyboards don't know
 * about shift states that should be remembered across idles.  Such
 * shifts are described by k_toggleshifts.  k_toggleshifts are used to
 * identify such shifts.  A toggle shift state is maintained separately
 * from the general shift state.  The toggle shift state is OR-ed
 * with the state general shift state when an idle is received.
 * k_toggleshifts should not appear in the k_up table.
 */
struct keyboard {
#ifdef KEYMAP_SIZE_VARIABLE
	int		k_keymap_size;	/* Number of entries in keymaps */
	keymap_entry_t	*k_normal;	/* Unshifted */
	keymap_entry_t	*k_shifted;	/* Shifted */
	keymap_entry_t	*k_caps;	/* Caps locked */
	keymap_entry_t	*k_altgraph;	/* Alt Graph down */
	keymap_entry_t	*k_numlock;	/* Num Lock down */
	keymap_entry_t	*k_control;	/* Controlled */
	keymap_entry_t	*k_up;		/* Key went up */
#else
	struct keymap	*k_normal;	/* Unshifted */
	struct keymap	*k_shifted;	/* Shifted */
	struct keymap	*k_caps;	/* Caps locked */
	struct keymap	*k_altgraph;	/* Alt Graph down */
	struct keymap	*k_numlock;	/* Num Lock down */
	struct keymap	*k_control;	/* Controlled */
	struct keymap	*k_up;		/* Key went up */
#endif
	int		k_idleshifts;	/* Shifts that keep across idle */
	int		k_idlebuckys;	/* Bucky bits that keep across idle */
	unsigned char	k_abort1;	/* 1st key of abort sequence */
	unsigned char	k_abort1a;	/* alternate 1st key */
	unsigned char	k_abort2;	/* 2nd key of abort sequence */
	int		k_toggleshifts; /* Shifts that toggle on down from */
					/* kbd and keep across idle */
	struct exception_map *k_except;	/* Oddball cases */
	unsigned char	k_newabort1;	/* 1st key of new abort sequence */
	unsigned char	k_newabort1a;	/* alternate 1st key */
	unsigned char	k_newabort2;	/* 2nd key of new abort sequence */
};

/*
 * Define the compose sequence structure.  First and second
 * ASCII chars of 0 indicate the end of the table.
 */
struct compose_sequence_t {
	unsigned char	first;	/* first ASCII char after COMPOSE key */
	unsigned char	second; /* second ASCII char after COMPOSE key */
	keymap_entry_t	utf8;	/* equivalent UTF-8 code */
};

/*
 * Define the floating accent sequence structure.
 */
struct fltaccent_sequence_t {
	keymap_entry_t	fa_entry;	/* floating accent keymap entry */
	unsigned char	ascii;		/* ASCII char after FA-type key */
	keymap_entry_t	utf8;		/* equivalent UTF-8 code */
};

/*
 * The top byte is used to store the flags, leaving 24 bits for char.
 */
#define	KEYCHAR(c)	((c) & 0x00ffffff)
#define	KEYFLAGS(c)	((c) & ~0x00ffffff)

/*
 * The "special" entries' top 4 bits are defined below.	 Generally they are
 * used with a 4-bit parameter (such as a bit number) in the low 4 bits.
 * The bytes whose top 4 bits are 0x0 thru 0x7 happen to be ascii
 * characters.	They are not special cased, but just normal cased.
 */

#define	SPECIAL(h, l)	(((h) << 24) | (l))

#define	SHIFTKEYS SPECIAL(0x1, 0)
				/* thru 0x10F.	This key helps to determine */
				/* the translation table used.	The bit */
				/* position of its bit in "shiftmask" */
				/* is added to the entry, eg */
				/* SHIFTKEYS+LEFTCTRL.	When this entry is */
				/* invoked, the bit in "shiftmask" is */
				/* toggled.  Depending which tables you put */
				/* it in, this works well for hold-down */
				/* keys or press-on, press-off keys.  */
#define	BUCKYBITS SPECIAL(0x2, 0)
				/* thru 0x20F.	This key determines the state */
				/* of one of the "bucky" bits above the */
				/* returned ASCII character.  This is */
				/* basically a way to pass mode-key-up/down */
				/* information back to the caller with each */
				/* "real" key depressed.  The concept, and */
				/* name "bucky" (derivation unknown) comes */
				/* from the MIT/SAIL "TV" system...they had */
				/* TOP, META, CTRL, and a few other bucky */
				/* bits.  The bit position of its bit in */
				/* "buckybits", minus 7, is added to the */
				/* entry; eg bit 0x00000400 is BUCKYBITS+3. */
				/* The "-7" prevents us from messing up the */
				/* ASCII char, and gives us 16 useful bucky */
				/* bits.  When this entry is invoked, */
				/* the designated bit in "buckybits" is */
				/* toggled.  Depending which tables you put */
				/* it in, this works well for hold-down */
				/* keys or press-on, press-off keys.  */
#define	FUNNY SPECIAL(0x3, 0)	/* thru 0x30F.	This key does one of 16 funny */
				/* things based on the low 4 bits: */
#define	NOP SPECIAL(0x3, 0x0)	/* This key does nothing. */
#define	OOPS SPECIAL(0x3, 0x1) /* This key exists but is undefined. */
#define	HOLE SPECIAL(0x3, 0x2) /* This key does not exist on the keyboard. */
				/* Its position code should never be */
				/* generated.  This indicates a software/ */
				/* hardware mismatch, or bugs. */
#define	RESET SPECIAL(0x3, 0x6) /* Kbd was just reset */
#define	ERROR SPECIAL(0x3, 0x7) /* Kbd just detected an internal error */
#define	IDLE SPECIAL(0x3, 0x8) /* Kbd is idle (no keys down) */
#define	COMPOSE SPECIAL(0x3, 0x9) /* This key is the Compose key. */
#define	NONL SPECIAL(0x3, 0xA) /* This key not affected by Num Lock */
/* Combinations 0x30B to 0x30F are reserved for non-parameterized functions */

#define	FA_CLASS SPECIAL(0x4, 0)
				/* thru 0x40F.	These are for "floating */
				/* accent" characters.	The low-order 4 bits */
				/* select one of those characters. */
/* Definitions for the individual floating accents: */
#define	FA_UMLAUT SPECIAL(0x4, 0x0)	/* umlaut accent */
#define	FA_CFLEX SPECIAL(0x4, 0x1)	/* circumflex accent */
#define	FA_TILDE SPECIAL(0x4, 0x2)	/* tilde accent */
#define	FA_CEDILLA SPECIAL(0x4, 0x3)	/* cedilla accent */
#define	FA_ACUTE SPECIAL(0x4, 0x4)	/* acute accent */
#define	FA_GRAVE SPECIAL(0x4, 0x5)	/* grave accent */
#define	FA_MACRON SPECIAL(0x4, 0x6)	/* macron accent */
#define	FA_BREVE SPECIAL(0x4, 0x7)	/* breve accent */
#define	FA_DOT SPECIAL(0x4, 0x8)	/* dot accent */
#define	FA_SLASH SPECIAL(0x4, 0x9)	/* slash accent */
#define	FA_RING SPECIAL(0x4, 0xa)	/* ring accent */
#define	FA_APOSTROPHE SPECIAL(0x4, 0xb)	/* apostrophe accent */
#define	FA_DACUTE SPECIAL(0x4, 0xc)	/* double acute accent */
#define	FA_OGONEK SPECIAL(0x4, 0xd)	/* ogonek accent */
#define	FA_CARON SPECIAL(0x4, 0xe)	/* caron accent */

#define	STRING SPECIAL(0x5, 0)	/* thru 0x50F.	The low-order 4 bits index */
				/* a table select a string to be returned, */
				/* char by char.  Each entry the table is */
				/* null terminated. */
#define	KTAB_STRLEN	10	/* Maximum string length (including null) */
/* Definitions for the individual string numbers: */
#define	HOMEARROW	0x00
#define	UPARROW		0x01
#define	DOWNARROW	0x02
#define	LEFTARROW	0x03
#define	RIGHTARROW	0x04
/* string numbers 5 thru F are available to users making custom entries */

/*
 * In the following function key groupings, the low-order 4 bits indicate
 * the function key number within the group, and the next 4 bits indicate
 * the group.
 */
#define	FUNCKEYS	SPECIAL(0x6, 0)
#define	LEFTFUNC SPECIAL(0x6, 0x0)	/* thru 0x60F.	The "left" group. */
#define	RIGHTFUNC SPECIAL(0x6, 0x10)	/* thru 0x61F.	The "right" group. */
#define	TOPFUNC SPECIAL(0x6, 0x20)	/* thru 0x62F.	The "top" group. */
#define	BOTTOMFUNC SPECIAL(0x6, 0x30)	/* thru 0x63F.	The "bottom" group. */
#define	LF(n)		(LEFTFUNC+(n)-1)
#define	RF(n)		(RIGHTFUNC+(n)-1)
#define	TF(n)		(TOPFUNC+(n)-1)
#define	BF(n)		(BOTTOMFUNC+(n)-1)

/*
 * The actual keyboard positions may not be on the left/right/top/bottom
 * of the physical keyboard (although they usually are).
 * What is important is that we have reserved 64 keys for function keys.
 *
 * Normally, striking a function key will cause the following escape sequence
 * to be sent through the character stream:
 *	ESC[0..9z
 * where ESC is a single escape character and 0..9 indicate some number of
 * digits needed to encode the function key as a decimal number.
 */
#define	PADKEYS		SPECIAL(0x7, 0)
#define	PADEQUAL SPECIAL(0x7, 0x00)		/* keypad = */
#define	PADSLASH SPECIAL(0x7, 0x01)		/* keypad / */
#define	PADSTAR SPECIAL(0x7, 0x02)		/* keypad * */
#define	PADMINUS SPECIAL(0x7, 0x03)		/* keypad - */
#define	PADSEP SPECIAL(0x7, 0x04)		/* keypad,  */
#define	PAD7 SPECIAL(0x7, 0x05)		/* keypad 7 */
#define	PAD8 SPECIAL(0x7, 0x06)		/* keypad 8 */
#define	PAD9 SPECIAL(0x7, 0x07)		/* keypad 9 */
#define	PADPLUS SPECIAL(0x7, 0x08)		/* keypad + */
#define	PAD4 SPECIAL(0x7, 0x09)		/* keypad 4 */
#define	PAD5 SPECIAL(0x7, 0x0A)		/* keypad 5 */
#define	PAD6 SPECIAL(0x7, 0x0B)		/* keypad 6 */
#define	PAD1 SPECIAL(0x7, 0x0C)		/* keypad 1 */
#define	PAD2 SPECIAL(0x7, 0x0D)		/* keypad 2 */
#define	PAD3 SPECIAL(0x7, 0x0E)		/* keypad 3 */
#define	PAD0 SPECIAL(0x7, 0x0F)		/* keypad 0 */
#define	PADDOT SPECIAL(0x7, 0x10)		/* keypad . */
#define	PADENTER SPECIAL(0x7, 0x11)		/* keypad Enter */

#ifdef	__cplusplus
}
#endif

#endif	/* _SYS_KBD_H */