haiku.git

/*
 * Copyright 2009-2011, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Michael Lotz <mmlr@mlotz.ch>
 */

#include <debug.h>
#include <debugger_keymaps.h>

static bool sUseUSBKeyboard = false;
static uint8 sUSBTransferData[64];
static uint8 sLastTransferData[64];
static size_t sUSBTransferLength = 0;
static void *sUSBPipe = NULL;

// simple ring buffer
static int sBufferedChars[32];
static uint8 sBufferSize = sizeof(sBufferedChars) / sizeof(sBufferedChars[0]);
static uint8 sBufferedCharCount = 0;
static uint8 sBufferWriteIndex = 0;
static uint8 sBufferReadIndex = 0;

#define MODIFIER_CONTROL	0x01
#define MODIFIER_SHIFT		0x02
#define MODIFIER_ALT		0x04

static uint32 sModifierTable[] = {
	MODIFIER_CONTROL,
	MODIFIER_SHIFT,
	MODIFIER_ALT,
	0,
	MODIFIER_CONTROL,
	MODIFIER_SHIFT,
	MODIFIER_ALT,
	0
};

static uint8 sKeyTable[] = {
	0,	// ERROR
	0,	// ERROR
	0,	// ERROR
	0,	// ERROR
	30,	// A
	48,	// B
	46,	// C
	32,	// D
	18,	// E
	33,	// F
	34,	// G
	35,	// H
	23,	// I
	36,	// J
	37,	// K
	38,	// L
	50,	// M
	49,	// N
	24,	// O
	25,	// P
	16,	// Q
	19,	// R
	31,	// S
	20,	// T
	22,	// U
	47,	// V
	17,	// W
	45,	// X
	21,	// Y
	44,	// Z
	2,	// 1
	3,	// 2
	4,	// 3
	5,	// 4
	6,	// 5
	7,	// 6
	8,	// 7
	9,	// 8
	10,	// 9
	11,	// 0
	28,	// enter
	1,	// Esc
	14,	// Backspace
	15,	// Tab
	57,	// Space
	12,	// -
	13,	// =
	26,	// [
	27,	// ]
	43,	// backslash
	80,	// backslash
	39,	// ;
	40,	// '
	41,	// `
	51,	// ,
	52,	// .
	53,	// /
	0,	// Caps
	0,	// F1
	0,	// F2
	0,	// F3
	0,	// F4
	0,	// F5
	0,	// F6
	0,	// F7
	0,	// F8
	0,	// F9
	0,	// F10
	0,	// F11
	0,	// F12
	0,	// PrintScreen
	0,	// Scroll Lock
	0,	// Pause (0x7f with Ctrl)
	0,	// Insert
	0x80 | 'H',	// Home
	0x80 | '5',	// Page up
	0x80 | '3',	// Delete
	0x80 | 'F',	// End
	0x80 | '6',	// Page down
	0x80 | 'C',	// Right arrow
	0x80 | 'D',	// Left arrow
	0x80 | 'B',	// Down arrow
	0x80 | 'A',	// Up arrow
	0,	// Num Lock
	53,	// Pad /
	55,	// Pad *
	12,	// Pad -
	54,	// Pad +
	28,	// Pad Enter
	2,	// Pad 1
	3,	// Pad 2
	4,	// Pad 3
	5,	// Pad 4
	6,	// Pad 5
	7,	// Pad 6
	8,	// Pad 7
	9,	// Pad 8
	10,	// Pad 9
	11,	// Pad 0
	52,	// Pad .
	86,	// <
	0,	// Menu
	0,	// Power
	13	// Pad =
};

static size_t sKeyTableSize = sizeof(sKeyTable) / sizeof(sKeyTable[0]);


static void
enter_debugger(void)
{
	if (!has_debugger_command("get_usb_keyboard_config")
		|| !has_debugger_command("get_usb_pipe_for_id")
		|| !has_debugger_command("usb_process_transfer")) {
		return;
	}

	unset_debug_variable("_usbPipe");
	unset_debug_variable("_usbReportSize");

	evaluate_debug_command("get_usb_keyboard_config");
	sUSBTransferLength = get_debug_variable("_usbReportSize", 0);
	if (sUSBTransferLength == 0 || sUSBTransferLength > sizeof(sUSBTransferData))
		return;

	evaluate_debug_command("get_usb_pipe_for_id");
	sUSBPipe = (void *)get_debug_variable("_usbPipe", 0);
	if (sUSBPipe == NULL)
		return;

	sUseUSBKeyboard = true;
}


static void
exit_debugger(void)
{
	if (sUseUSBKeyboard) {
		// make sure a possibly pending transfer is canceled
		set_debug_variable("_usbPipe", (uint64)sUSBPipe);
		evaluate_debug_command("usb_process_transfer cancel");
		sUseUSBKeyboard = false;
	}
}


static void
write_key(int key)
{
	sBufferedChars[sBufferWriteIndex++] = key;
	sBufferWriteIndex %= sBufferSize;
	sBufferedCharCount++;
}


static int
debugger_getchar(void)
{
	if (!sUseUSBKeyboard)
		return -1;

	if (sBufferedCharCount == 0) {
		set_debug_variable("_usbPipe", (uint64)sUSBPipe);
		set_debug_variable("_usbTransferData", (uint64)sUSBTransferData);
		set_debug_variable("_usbTransferLength", (uint64)sUSBTransferLength);

		status_t status = evaluate_debug_command("usb_process_transfer");
		if (status == B_DEV_PENDING)
			return -1;

		if (status != B_OK) {
			// try clearing a possibly set halt due to toggle mismatches
			evaluate_debug_command("usb_clear_stall");
			return -1;
		}

		bool phantomState = true;
		for (size_t i = 2; i < sUSBTransferLength; i++) {
			if (sUSBTransferData[i] != 0x01) {
				phantomState = false;
				break;
			}
		}

		if (phantomState)
			return -1;

		uint8 modifiers = 0;
		for (uint32 i = 0; i < 8; i++) {
			if (sUSBTransferData[0] & (1 << i))
				modifiers |= sModifierTable[i];
		}

		uint8 *current = sUSBTransferData;
		uint8 *compare = sLastTransferData;
		for (uint32 i = 2; i < sUSBTransferLength; i++) {
			if (current[i] == 0x00 || current[i] == 0x01)
				continue;

			bool found = false;
			for (uint32 j = 2; j < sUSBTransferLength; j++) {
				if (compare[j] == current[i]) {
					found = true;
					break;
				}
			}

			if (found)
				continue;

			if (current[i] >= sKeyTableSize)
				continue;

			int result = -1;
			uint8 key = sKeyTable[current[i]];
			if (key & 0x80) {
				write_key(27);
				write_key('[');

				key &= ~0x80;
				write_key(key);

				if (key == '5' || key == '6' || key == '3')
					write_key('~');

				continue;
			} else if (modifiers & MODIFIER_CONTROL) {
				char c = kShiftedKeymap[key];
				if (c >= 'A' && c <= 'Z')
					result = 0x1f & c;
			} else if (modifiers & MODIFIER_ALT)
				result = kAltedKeymap[key];
			else if (modifiers & MODIFIER_SHIFT)
				result = kShiftedKeymap[key];
			else
				result = kUnshiftedKeymap[key];

			if (result < 0)
				continue;

			write_key(result);
		}

		for (uint32 i = 0; i < sUSBTransferLength; i++)
			sLastTransferData[i] = sUSBTransferData[i];
	}

	if (sBufferedCharCount == 0)
		return -1;

	int result = sBufferedChars[sBufferReadIndex++];
	sBufferReadIndex %= sBufferSize;
	sBufferedCharCount--;
	return result;
}


static status_t
std_ops(int32 op, ...)
{
	if (op == B_MODULE_INIT || op == B_MODULE_UNINIT)
		return B_OK;

	return B_BAD_VALUE;
}


static struct debugger_module_info sModuleInfo = {
	{
		"debugger/usb_keyboard/v1",
		0,
		&std_ops
	},

	&enter_debugger,
	&exit_debugger,
	NULL,
	&debugger_getchar
};

module_info *modules[] = {
	(module_info *)&sModuleInfo,
	NULL
};