[linux.git] / kernel / debug / kdb / kdb_keyboard.c

/*
 * Kernel Debugger Architecture Dependent Console I/O handler
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.
 *
 * Copyright (c) 1999-2006 Silicon Graphics, Inc.  All Rights Reserved.
 * Copyright (c) 2009 Wind River Systems, Inc.  All Rights Reserved.
 */

#include <linux/kdb.h>
#include <linux/keyboard.h>
#include <linux/ctype.h>
#include <linux/module.h>
#include <linux/io.h>

/* Keyboard Controller Registers on normal PCs. */

#define KBD_STATUS_REG		0x64	/* Status register (R) */
#define KBD_DATA_REG		0x60	/* Keyboard data register (R/W) */

/* Status Register Bits */

#define KBD_STAT_OBF 		0x01	/* Keyboard output buffer full */
#define KBD_STAT_MOUSE_OBF	0x20	/* Mouse output buffer full */

static int kbd_exists;
static int kbd_last_ret;

/*
 * Check if the keyboard controller has a keypress for us.
 * Some parts (Enter Release, LED change) are still blocking polled here,
 * but hopefully they are all short.
 */
int kdb_get_kbd_char(void)
{
	int scancode, scanstatus;
	static int shift_lock;	/* CAPS LOCK state (0-off, 1-on) */
	static int shift_key;	/* Shift next keypress */
	static int ctrl_key;
	u_short keychar;

	if (KDB_FLAG(NO_I8042) || KDB_FLAG(NO_VT_CONSOLE) ||
	    (inb(KBD_STATUS_REG) == 0xff && inb(KBD_DATA_REG) == 0xff)) {
		kbd_exists = 0;
		return -1;
	}
	kbd_exists = 1;

	if ((inb(KBD_STATUS_REG) & KBD_STAT_OBF) == 0)
		return -1;

	/*
	 * Fetch the scancode
	 */
	scancode = inb(KBD_DATA_REG);
	scanstatus = inb(KBD_STATUS_REG);

	/*
	 * Ignore mouse events.
	 */
	if (scanstatus & KBD_STAT_MOUSE_OBF)
		return -1;

	/*
	 * Ignore release, trigger on make
	 * (except for shift keys, where we want to
	 *  keep the shift state so long as the key is
	 *  held down).
	 */

	if (((scancode&0x7f) == 0x2a) || ((scancode&0x7f) == 0x36)) {
		/*
		 * Next key may use shift table
		 */
		if ((scancode & 0x80) == 0)
			shift_key = 1;
		else
			shift_key = 0;
		return -1;
	}

	if ((scancode&0x7f) == 0x1d) {
		/*
		 * Left ctrl key
		 */
		if ((scancode & 0x80) == 0)
			ctrl_key = 1;
		else
			ctrl_key = 0;
		return -1;
	}

	if ((scancode & 0x80) != 0) {
		if (scancode == 0x9c)
			kbd_last_ret = 0;
		return -1;
	}

	scancode &= 0x7f;

	/*
	 * Translate scancode
	 */

	if (scancode == 0x3a) {
		/*
		 * Toggle caps lock
		 */
		shift_lock ^= 1;

#ifdef	KDB_BLINK_LED
		kdb_toggleled(0x4);
#endif
		return -1;
	}

	if (scancode == 0x0e) {
		/*
		 * Backspace
		 */
		return 8;
	}

	/* Special Key */
	switch (scancode) {
	case 0xF: /* Tab */
		return 9;
	case 0x53: /* Del */
		return 4;
	case 0x47: /* Home */
		return 1;
	case 0x4F: /* End */
		return 5;
	case 0x4B: /* Left */
		return 2;
	case 0x48: /* Up */
		return 16;
	case 0x50: /* Down */
		return 14;
	case 0x4D: /* Right */
		return 6;
	}

	if (scancode == 0xe0)
		return -1;

	/*
	 * For Japanese 86/106 keyboards
	 * 	See comment in drivers/char/pc_keyb.c.
	 * 	- Masahiro Adegawa
	 */
	if (scancode == 0x73)
		scancode = 0x59;
	else if (scancode == 0x7d)
		scancode = 0x7c;

	if (!shift_lock && !shift_key && !ctrl_key) {
		keychar = plain_map[scancode];
	} else if ((shift_lock || shift_key) && key_maps[1]) {
		keychar = key_maps[1][scancode];
	} else if (ctrl_key && key_maps[4]) {
		keychar = key_maps[4][scancode];
	} else {
		keychar = 0x0020;
		kdb_printf("Unknown state/scancode (%d)\n", scancode);
	}
	keychar &= 0x0fff;
	if (keychar == '\t')
		keychar = ' ';
	switch (KTYP(keychar)) {
	case KT_LETTER:
	case KT_LATIN:
		if (isprint(keychar))
			break;		/* printable characters */
		/* fall through */
	case KT_SPEC:
		if (keychar == K_ENTER)
			break;
		/* fall through */
	default:
		return -1;	/* ignore unprintables */
	}

	if (scancode == 0x1c) {
		kbd_last_ret = 1;
		return 13;
	}

	return keychar & 0xff;
}
EXPORT_SYMBOL_GPL(kdb_get_kbd_char);

/*
 * Best effort cleanup of ENTER break codes on leaving KDB. Called on
 * exiting KDB, when we know we processed an ENTER or KP ENTER scan
 * code.
 */
void kdb_kbd_cleanup_state(void)
{
	int scancode, scanstatus;

	/*
	 * Nothing to clean up, since either
	 * ENTER was never pressed, or has already
	 * gotten cleaned up.
	 */
	if (!kbd_last_ret)
		return;

	kbd_last_ret = 0;
	/*
	 * Enter key. Need to absorb the break code here, lest it gets
	 * leaked out if we exit KDB as the result of processing 'g'.
	 *
	 * This has several interesting implications:
	 * + Need to handle KP ENTER, which has break code 0xe0 0x9c.
	 * + Need to handle repeat ENTER and repeat KP ENTER. Repeats
	 *   only get a break code at the end of the repeated
	 *   sequence. This means we can't propagate the repeated key
	 *   press, and must swallow it away.
	 * + Need to handle possible PS/2 mouse input.
	 * + Need to handle mashed keys.
	 */

	while (1) {
		while ((inb(KBD_STATUS_REG) & KBD_STAT_OBF) == 0)
			cpu_relax();

		/*
		 * Fetch the scancode.
		 */
		scancode = inb(KBD_DATA_REG);
		scanstatus = inb(KBD_STATUS_REG);

		/*
		 * Skip mouse input.
		 */
		if (scanstatus & KBD_STAT_MOUSE_OBF)
			continue;

		/*
		 * If we see 0xe0, this is either a break code for KP
		 * ENTER, or a repeat make for KP ENTER. Either way,
		 * since the second byte is equivalent to an ENTER,
		 * skip the 0xe0 and try again.
		 *
		 * If we see 0x1c, this must be a repeat ENTER or KP
		 * ENTER (and we swallowed 0xe0 before). Try again.
		 *
		 * We can also see make and break codes for other keys
		 * mashed before or after pressing ENTER. Thus, if we
		 * see anything other than 0x9c, we have to try again.
		 *
		 * Note, if you held some key as ENTER was depressed,
		 * that break code would get leaked out.
		 */
		if (scancode != 0x9c)
			continue;

		return;
	}
}
Commit	Line	Data
ada64e4c JW	1	/*
	2	* Kernel Debugger Architecture Dependent Console I/O handler
	3	*
	4	* This file is subject to the terms and conditions of the GNU General Public
	5	* License.
	6	*
	7	* Copyright (c) 1999-2006 Silicon Graphics, Inc. All Rights Reserved.
	8	* Copyright (c) 2009 Wind River Systems, Inc. All Rights Reserved.
	9	*/
	10
	11	#include <linux/kdb.h>
	12	#include <linux/keyboard.h>
	13	#include <linux/ctype.h>
	14	#include <linux/module.h>
	15	#include <linux/io.h>
	16
	17	/* Keyboard Controller Registers on normal PCs. */
	18
	19	#define KBD_STATUS_REG 0x64 /* Status register (R) */
	20	#define KBD_DATA_REG 0x60 /* Keyboard data register (R/W) */
	21
	22	/* Status Register Bits */
	23
	24	#define KBD_STAT_OBF 0x01 /* Keyboard output buffer full */
	25	#define KBD_STAT_MOUSE_OBF 0x20 /* Mouse output buffer full */
	26
	27	static int kbd_exists;
8f30d411	28	static int kbd_last_ret;
ada64e4c JW	29
	30	/*
	31	* Check if the keyboard controller has a keypress for us.
	32	* Some parts (Enter Release, LED change) are still blocking polled here,
	33	* but hopefully they are all short.
	34	*/
	35	int kdb_get_kbd_char(void)
	36	{
	37	int scancode, scanstatus;
	38	static int shift_lock; /* CAPS LOCK state (0-off, 1-on) */
	39	static int shift_key; /* Shift next keypress */
	40	static int ctrl_key;
	41	u_short keychar;
	42
	43	if (KDB_FLAG(NO_I8042) \|\| KDB_FLAG(NO_VT_CONSOLE) \|\|
	44	(inb(KBD_STATUS_REG) == 0xff && inb(KBD_DATA_REG) == 0xff)) {
	45	kbd_exists = 0;
	46	return -1;
	47	}
	48	kbd_exists = 1;
	49
	50	if ((inb(KBD_STATUS_REG) & KBD_STAT_OBF) == 0)
	51	return -1;
	52
	53	/*
	54	* Fetch the scancode
	55	*/
	56	scancode = inb(KBD_DATA_REG);
	57	scanstatus = inb(KBD_STATUS_REG);
	58
	59	/*
	60	* Ignore mouse events.
	61	*/
	62	if (scanstatus & KBD_STAT_MOUSE_OBF)
	63	return -1;
	64
	65	/*
	66	* Ignore release, trigger on make
	67	* (except for shift keys, where we want to
	68	* keep the shift state so long as the key is
	69	* held down).
	70	*/
	71
	72	if (((scancode&0x7f) == 0x2a) \|\| ((scancode&0x7f) == 0x36)) {
	73	/*
	74	* Next key may use shift table
	75	*/
	76	if ((scancode & 0x80) == 0)
	77	shift_key = 1;
	78	else
	79	shift_key = 0;
	80	return -1;
	81	}
	82
	83	if ((scancode&0x7f) == 0x1d) {
	84	/*
	85	* Left ctrl key
	86	*/
	87	if ((scancode & 0x80) == 0)
	88	ctrl_key = 1;
	89	else
	90	ctrl_key = 0;
	91	return -1;
	92	}
93
8f30d411 AW	94	if ((scancode & 0x80) != 0) {
	95	if (scancode == 0x9c)
	96	kbd_last_ret = 0;
ada64e4c	97	return -1;
8f30d411	98	}
ada64e4c JW	99
	100	scancode &= 0x7f;
	101
	102	/*
	103	* Translate scancode
	104	*/
	105
	106	if (scancode == 0x3a) {
	107	/*
	108	* Toggle caps lock
	109	*/
	110	shift_lock ^= 1;
	111
	112	#ifdef KDB_BLINK_LED
	113	kdb_toggleled(0x4);
	114	#endif
	115	return -1;
	116	}
	117
	118	if (scancode == 0x0e) {
	119	/*
	120	* Backspace
	121	*/
	122	return 8;
	123	}
	124
	125	/* Special Key */
	126	switch (scancode) {
	127	case 0xF: /* Tab */
	128	return 9;
	129	case 0x53: /* Del */
	130	return 4;
	131	case 0x47: /* Home */
	132	return 1;
	133	case 0x4F: /* End */
	134	return 5;
	135	case 0x4B: /* Left */
	136	return 2;
	137	case 0x48: /* Up */
	138	return 16;
	139	case 0x50: /* Down */
	140	return 14;
	141	case 0x4D: /* Right */
	142	return 6;
	143	}
	144
	145	if (scancode == 0xe0)
	146	return -1;
	147
	148	/*
	149	* For Japanese 86/106 keyboards
	150	* See comment in drivers/char/pc_keyb.c.
	151	* - Masahiro Adegawa
	152	*/
	153	if (scancode == 0x73)
	154	scancode = 0x59;
	155	else if (scancode == 0x7d)
	156	scancode = 0x7c;
	157
	158	if (!shift_lock && !shift_key && !ctrl_key) {
	159	keychar = plain_map[scancode];
	160	} else if ((shift_lock \|\| shift_key) && key_maps[1]) {
	161	keychar = key_maps[1][scancode];
	162	} else if (ctrl_key && key_maps[4]) {
163	keychar = key_maps[4][scancode];
164	} else {
165	keychar = 0x0020;
166	kdb_printf("Unknown state/scancode (%d)\n", scancode);
167	}
168	keychar &= 0x0fff;
169	if (keychar == '\t')
170	keychar = ' ';
171	switch (KTYP(keychar)) {
172	case KT_LETTER:
173	case KT_LATIN:
174	if (isprint(keychar))
175	break; /* printable characters */
01cb3735	176	/* fall through */
ada64e4c JW	177	case KT_SPEC:
	178	if (keychar == K_ENTER)
	179	break;
01cb3735	180	/* fall through */
ada64e4c JW	181	default:
	182	return -1; /* ignore unprintables */
	183	}
	184
8f30d411 AW	185	if (scancode == 0x1c) {
	186	kbd_last_ret = 1;
	187	return 13;
	188	}
	189
	190	return keychar & 0xff;
	191	}
	192	EXPORT_SYMBOL_GPL(kdb_get_kbd_char);
	193
	194	/*
	195	* Best effort cleanup of ENTER break codes on leaving KDB. Called on
	196	* exiting KDB, when we know we processed an ENTER or KP ENTER scan
	197	* code.
	198	*/
	199	void kdb_kbd_cleanup_state(void)
	200	{
	201	int scancode, scanstatus;
	202
	203	/*
	204	* Nothing to clean up, since either
	205	* ENTER was never pressed, or has already
	206	* gotten cleaned up.
	207	*/
	208	if (!kbd_last_ret)
	209	return;
	210
	211	kbd_last_ret = 0;
	212	/*
	213	* Enter key. Need to absorb the break code here, lest it gets
	214	* leaked out if we exit KDB as the result of processing 'g'.
	215	*
	216	* This has several interesting implications:
	217	* + Need to handle KP ENTER, which has break code 0xe0 0x9c.
	218	* + Need to handle repeat ENTER and repeat KP ENTER. Repeats
	219	* only get a break code at the end of the repeated
	220	* sequence. This means we can't propagate the repeated key
	221	* press, and must swallow it away.
	222	* + Need to handle possible PS/2 mouse input.
	223	* + Need to handle mashed keys.
	224	*/
	225
	226	while (1) {
ada64e4c	227	while ((inb(KBD_STATUS_REG) & KBD_STAT_OBF) == 0)
8f30d411	228	cpu_relax();
ada64e4c JW	229
ada64e4c JW	230	/*
8f30d411	231	* Fetch the scancode.
ada64e4c JW	232	*/
	233	scancode = inb(KBD_DATA_REG);
	234	scanstatus = inb(KBD_STATUS_REG);
	235
8f30d411 AW	236	/*
	237	* Skip mouse input.
	238	*/
	239	if (scanstatus & KBD_STAT_MOUSE_OBF)
	240	continue;
ada64e4c	241
8f30d411 AW	242	/*
	243	* If we see 0xe0, this is either a break code for KP
	244	* ENTER, or a repeat make for KP ENTER. Either way,
	245	* since the second byte is equivalent to an ENTER,
	246	* skip the 0xe0 and try again.
	247	*
	248	* If we see 0x1c, this must be a repeat ENTER or KP
	249	* ENTER (and we swallowed 0xe0 before). Try again.
	250	*
	251	* We can also see make and break codes for other keys
	252	* mashed before or after pressing ENTER. Thus, if we
	253	* see anything other than 0x9c, we have to try again.
	254	*
	255	* Note, if you held some key as ENTER was depressed,
	256	* that break code would get leaked out.
	257	*/
	258	if (scancode != 0x9c)
	259	continue;
ada64e4c	260
8f30d411	261	return;
ada64e4c	262	}
ada64e4c	263	}