haiku.git

/*
 * Copyright 2008-2011 Michael Lotz <mmlr@mlotz.ch>
 * Distributed under the terms of the MIT license.
 */


#include <new>
#include <stdlib.h>
#include <string.h>

#include <interface/InterfaceDefs.h>
#include <usb/USB_hid.h>
#include <util/AutoLock.h>

#include <debug.h>
#include <kernel.h>

#include "Driver.h"
#include "KeyboardProtocolHandler.h"

#include "HIDCollection.h"
#include "HIDDevice.h"
#include "HIDReport.h"
#include "HIDReportItem.h"

#include <keyboard_mouse_driver.h>


#define LEFT_ALT_KEY	0x04
#define RIGHT_ALT_KEY	0x40
#define ALT_KEYS		(LEFT_ALT_KEY | RIGHT_ALT_KEY)

#define KEYBOARD_HANDLER_COOKIE_FLAG_READER		0x01
#define KEYBOARD_HANDLER_COOKIE_FLAG_DEBUGGER	0x02


#ifdef KEYBOARD_SUPPORTS_KDL
static bool sDebugKeyboardFound = false;
static size_t sDebugKeyboardReportSize = 0;
static int32 sDebuggerCommandAdded = 0;

#ifdef USB_KDL
static usb_id sDebugKeyboardPipe = 0;

static int
debug_get_keyboard_config(int argc, char **argv)
{
	set_debug_variable("_usbPipeID", (uint64)sDebugKeyboardPipe);
	set_debug_variable("_usbReportSize", (uint64)sDebugKeyboardReportSize);
	return 0;
}
#endif
#endif


//	#pragma mark -


KeyboardProtocolHandler::KeyboardProtocolHandler(HIDReport &inputReport,
	HIDReport *outputReport)
	:
	ProtocolHandler(inputReport.Device(), "input/keyboard/" DEVICE_PATH_SUFFIX
		"/", 512),
	fInputReport(inputReport),
	fOutputReport(outputReport),
	fRepeatDelay(300000),
	fRepeatRate(35000),
	fCurrentRepeatDelay(B_INFINITE_TIMEOUT),
	fCurrentRepeatKey(0),
	fKeyCount(0),
	fModifierCount(0),
	fLastModifiers(0),
	fCurrentKeys(NULL),
	fLastKeys(NULL),
	fHasReader(0),
	fHasDebugReader(false)
{
	mutex_init(&fLock, DEVICE_PATH_SUFFIX " keyboard");

	// find modifiers and keys
	bool debugUsable = false;

	for (uint32 i = 0; i < inputReport.CountItems(); i++) {
		HIDReportItem *item = inputReport.ItemAt(i);
		if (!item->HasData())
			continue;

		if (item->UsagePage() == B_HID_USAGE_PAGE_KEYBOARD
			|| item->UsagePage() == B_HID_USAGE_PAGE_CONSUMER
			|| item->UsagePage() == B_HID_USAGE_PAGE_BUTTON) {
			TRACE("keyboard item with usage %" B_PRIx32 "\n",
				item->Usage());

			debugUsable = true;

			if (item->UsageID() >= B_HID_UID_KB_LEFT_CONTROL
				&& item->UsageID() <= B_HID_UID_KB_RIGHT_GUI) {
				if (fModifierCount < MAX_MODIFIERS)
					fModifiers[fModifierCount++] = item;
			} else if (fKeyCount < MAX_KEYS)
						fKeys[fKeyCount++] = item;
		}
	}

#ifdef KEYBOARD_SUPPORTS_KDL
	if (!sDebugKeyboardFound && debugUsable) {
		// It's a keyboard, not just some additional buttons, set up the kernel
		// debugger info here so that it is ready on panics or crashes that
		// don't go through the emergency keys. If we also found LEDs we assume
		// it is a full sized keyboard and discourage further setting the info.
#ifdef USB_KDL
		sDebugKeyboardPipe = fInputReport.Device()->InterruptPipe();
#endif
		sDebugKeyboardReportSize =
			fInputReport.Parser()->MaxReportSize(HID_REPORT_TYPE_INPUT);
		if (outputReport != NULL)
			sDebugKeyboardFound = true;
	}
#endif

	TRACE("keyboard device with %" B_PRIu32 " keys and %" B_PRIu32
		" modifiers\n", fKeyCount, fModifierCount);
	TRACE("input report: %u; output report: %u\n", inputReport.ID(),
		outputReport != NULL ? outputReport->ID() : 255);

	fLastKeys = (uint16 *)malloc(fKeyCount * 2 * sizeof(uint16));
	fCurrentKeys = &fLastKeys[fKeyCount];
	if (fLastKeys == NULL) {
		fStatus = B_NO_MEMORY;
		return;
	}

	memset(fLastKeys, 0, fKeyCount * 2 * sizeof(uint16));

	// find leds if we have an output report
	for (uint32 i = 0; i < MAX_LEDS; i++)
		fLEDs[i] = NULL;

	if (outputReport != NULL) {
		for (uint32 i = 0; i < outputReport->CountItems(); i++) {
			HIDReportItem *item = outputReport->ItemAt(i);
			if (!item->HasData())
				continue;

			// the led item array is identity mapped with what we get from
			// the input_server for the set-leds command
			if (item->UsagePage() == B_HID_USAGE_PAGE_LED) {
				switch (item->UsageID()) {
					case B_HID_UID_LED_NUM_LOCK:
						fLEDs[0] = item;
						break;
					case B_HID_UID_LED_CAPS_LOCK:
						fLEDs[1] = item;
						break;
					case B_HID_UID_LED_SCROLL_LOCK:
						fLEDs[2] = item;
						break;
				}
			}
		}
	}

#ifdef KEYBOARD_SUPPORTS_KDL
	if (atomic_add(&sDebuggerCommandAdded, 1) == 0) {
#ifdef USB_KDL
		add_debugger_command("get_usb_keyboard_config",
			&debug_get_keyboard_config,
			"Gets the required config of the USB keyboard");
#endif
	}
#endif
}


KeyboardProtocolHandler::~KeyboardProtocolHandler()
{
	free(fLastKeys);

#ifdef KEYBOARD_SUPPORTS_KDL
	if (atomic_add(&sDebuggerCommandAdded, -1) == 1) {
#ifdef USB_KDL
		remove_debugger_command("get_usb_keyboard_config",
			&debug_get_keyboard_config);
#endif
	}
#endif

	mutex_destroy(&fLock);
}


void
KeyboardProtocolHandler::AddHandlers(HIDDevice &device,
	HIDCollection &collection, ProtocolHandler *&handlerList)
{
	bool handled = false;
	switch (collection.UsagePage()) {
		case B_HID_USAGE_PAGE_GENERIC_DESKTOP:
		{
			switch (collection.UsageID()) {
				case B_HID_UID_GD_KEYBOARD:
				case B_HID_UID_GD_KEYPAD:
#if 0
				// This is not specific enough to deserve a keyboard device on
				// its own (some mice have one such descriptor, for example).
				// If your keyboard uses this, do a more extensive check of
				// the descriptor to make sure there actually are keys in it.
				case B_HID_UID_GD_SYSTEM_CONTROL:
#endif
					handled = true;
			}

			break;
		}

		case B_HID_USAGE_PAGE_CONSUMER:
		{
			switch (collection.UsageID()) {
				case B_HID_UID_CON_CONSUMER_CONTROL:
					handled = true;
			}

			break;
		}
	}

	if (!handled) {
		TRACE("collection not a supported keyboard subset\n");
		return;
	}

	HIDParser &parser = device.Parser();
	uint32 maxReportCount = parser.CountReports(HID_REPORT_TYPE_INPUT);
	if (maxReportCount == 0)
		return;

	uint32 inputReportCount = 0;
	HIDReport *inputReports[maxReportCount];
	collection.BuildReportList(HID_REPORT_TYPE_INPUT, inputReports,
		inputReportCount);

	TRACE("input report count: %" B_PRIu32 "\n", inputReportCount);

	for (uint32 i = 0; i < inputReportCount; i++) {
		HIDReport *inputReport = inputReports[i];

//		bool mayHaveOutput = false;
		bool foundKeyboardUsage = false;
		for (uint32 j = 0; j < inputReport->CountItems(); j++) {
			HIDReportItem *item = inputReport->ItemAt(j);
			if (!item->HasData())
				continue;

			if (item->UsagePage() == B_HID_USAGE_PAGE_KEYBOARD
				|| (item->UsagePage() == B_HID_USAGE_PAGE_CONSUMER
					&& item->Array())
				|| (item->UsagePage() == B_HID_USAGE_PAGE_BUTTON
					&& item->Array())) {
				// found at least one item with a keyboard usage or with
				// a consumer/button usage that is handled like a key
//				mayHaveOutput = item->UsagePage() == B_HID_USAGE_PAGE_KEYBOARD;
				foundKeyboardUsage = true;
				break;
			}
		}

		if (!foundKeyboardUsage)
			continue;

		bool foundOutputReport = false;
		HIDReport *outputReport = NULL;
		do {
			// try to find the led output report
			maxReportCount =  parser.CountReports(HID_REPORT_TYPE_OUTPUT);
			if (maxReportCount == 0)
				break;

			uint32 outputReportCount = 0;
			HIDReport *outputReports[maxReportCount];
			collection.BuildReportList(HID_REPORT_TYPE_OUTPUT,
				outputReports, outputReportCount);

			for (uint32  j = 0; j < outputReportCount; j++) {
				outputReport = outputReports[j];

				for (uint32 k = 0; k < outputReport->CountItems(); k++) {
					HIDReportItem *item = outputReport->ItemAt(k);
					if (item->UsagePage() == B_HID_USAGE_PAGE_LED) {
						foundOutputReport = true;
						break;
					}
				}

				if (foundOutputReport)
					break;
			}
		} while (false);

		ProtocolHandler *newHandler = new(std::nothrow) KeyboardProtocolHandler(
			*inputReport, foundOutputReport ? outputReport : NULL);
		if (newHandler == NULL) {
			TRACE("failed to allocated keyboard protocol handler\n");
			continue;
		}

		newHandler->SetNextHandler(handlerList);
		handlerList = newHandler;
	}
}


status_t
KeyboardProtocolHandler::Open(uint32 flags, uint32 *cookie)
{
	status_t status = ProtocolHandler::Open(flags, cookie);
	if (status != B_OK) {
		TRACE_ALWAYS("keyboard device failed to open: %s\n",
			strerror(status));
		return status;
	}

	if (Device()->OpenCount() == 1) {
		fCurrentRepeatDelay = B_INFINITE_TIMEOUT;
		fCurrentRepeatKey = 0;
	}

	return B_OK;
}


status_t
KeyboardProtocolHandler::Close(uint32 *cookie)
{
	if ((*cookie & KEYBOARD_HANDLER_COOKIE_FLAG_DEBUGGER) != 0)
		fHasDebugReader = false;
	if ((*cookie & KEYBOARD_HANDLER_COOKIE_FLAG_READER) != 0)
		atomic_and(&fHasReader, 0);

	return ProtocolHandler::Close(cookie);
}


status_t
KeyboardProtocolHandler::Control(uint32 *cookie, uint32 op, void *buffer,
	size_t length)
{
	switch (op) {
		case B_GET_DEVICE_NAME:
		{
			const char name[] = DEVICE_NAME" Keyboard";
			return IOGetDeviceName(name,buffer,length);
		}

		case KB_READ:
		{
			if (*cookie == 0) {
				if (atomic_or(&fHasReader, 1) != 0)
					return B_BUSY;

				// We're the first, so we become the only reader
				*cookie = KEYBOARD_HANDLER_COOKIE_FLAG_READER;
			}

			while (true) {
				MutexLocker locker(fLock);

				bigtime_t enterTime = system_time();
				while (RingBufferReadable() == 0) {
					status_t result = _ReadReport(fCurrentRepeatDelay, cookie);
					if (result != B_OK && result != B_TIMED_OUT)
						return result;

					if (!Device()->IsOpen())
						return B_ERROR;

					if (RingBufferReadable() == 0 && fCurrentRepeatKey != 0
						&& system_time() - enterTime > fCurrentRepeatDelay) {
						// this case is for handling key repeats, it means no
						// interrupt transfer has happened or it didn't produce
						// any new key events, but a repeated key down is due
						_WriteKey(fCurrentRepeatKey, true);

						// the next timeout is reduced to the repeat_rate
						fCurrentRepeatDelay = fRepeatRate;
						break;
					}
				}

				if (fHasDebugReader
					&& (*cookie & KEYBOARD_HANDLER_COOKIE_FLAG_DEBUGGER)
						== 0) {
					// Handover buffer to the debugger instead
					locker.Unlock();
					snooze(25000);
					continue;
				}

				if (!IS_USER_ADDRESS(buffer))
					return B_BAD_ADDRESS;

				// process what is in the ring_buffer, it could be written
				// there because we handled an interrupt transfer or because
				// we wrote the current repeat key
				return RingBufferRead(buffer, sizeof(raw_key_info));
			}
		}

		case KB_SET_LEDS:
		{
			uint8 ledData[4];
			if (!IS_USER_ADDRESS(buffer)
				|| user_memcpy(ledData, buffer, sizeof(ledData)) != B_OK) {
				return B_BAD_ADDRESS;
			}
			return _SetLEDs(ledData);
		}

		case KB_SET_KEY_REPEAT_RATE:
		{
			int32 repeatRate;
			if (!IS_USER_ADDRESS(buffer)
				|| user_memcpy(&repeatRate, buffer, sizeof(repeatRate))
					!= B_OK) {
				return B_BAD_ADDRESS;
			}

			if (repeatRate == 0 || repeatRate > 1000000)
				return B_BAD_VALUE;

			fRepeatRate = 10000000 / repeatRate;
			return B_OK;
		}

		case KB_GET_KEY_REPEAT_RATE:
		{
			int32 repeatRate = 10000000 / fRepeatRate;
			if (!IS_USER_ADDRESS(buffer)
				|| user_memcpy(buffer, &repeatRate, sizeof(repeatRate))
					!= B_OK) {
				return B_BAD_ADDRESS;
			}
			return B_OK;
		}

		case KB_SET_KEY_REPEAT_DELAY:
			if (!IS_USER_ADDRESS(buffer)
				|| user_memcpy(&fRepeatDelay, buffer, sizeof(fRepeatDelay))
					!= B_OK) {
				return B_BAD_ADDRESS;
			}
			return B_OK;

		case KB_GET_KEY_REPEAT_DELAY:
			if (!IS_USER_ADDRESS(buffer)
				|| user_memcpy(buffer, &fRepeatDelay, sizeof(fRepeatDelay))
					!= B_OK) {
				return B_BAD_ADDRESS;
			}
			return B_OK;

		case KB_SET_DEBUG_READER:
#ifdef KEYBOARD_SUPPORTS_KDL
			if (fHasDebugReader)
				return B_BUSY;

			*cookie |= KEYBOARD_HANDLER_COOKIE_FLAG_DEBUGGER;
			fHasDebugReader = true;
			return B_OK;
#else
			return B_NOT_SUPPORTED;
#endif
	}

	TRACE_ALWAYS("keyboard device unhandled control 0x%08" B_PRIx32 "\n", op);
	return B_ERROR;
}


void
KeyboardProtocolHandler::_WriteKey(uint32 key, bool down)
{
	raw_key_info info;
	info.keycode = key;
	info.is_keydown = down;
	info.timestamp = system_time();
	RingBufferWrite(&info, sizeof(raw_key_info));
}


status_t
KeyboardProtocolHandler::_SetLEDs(uint8 *data)
{
	if (fOutputReport == NULL || fOutputReport->Device()->IsRemoved())
		return B_ERROR;

	for (uint32 i = 0; i < MAX_LEDS; i++) {
		if (fLEDs[i] == NULL)
			continue;

		fLEDs[i]->SetData(data[i]);
	}

	return fOutputReport->SendReport();
}


status_t
KeyboardProtocolHandler::_ReadReport(bigtime_t timeout, uint32 *cookie)
{
	status_t result = fInputReport.WaitForReport(timeout);
	if (result != B_OK) {
		if (fInputReport.Device()->IsRemoved()) {
			TRACE("device has been removed\n");
			return B_ERROR;
		}

		if (result == B_INTERRUPTED)
			return result;
		if ((*cookie & PROTOCOL_HANDLER_COOKIE_FLAG_CLOSED) != 0)
			return B_FILE_ERROR;

		if (result != B_TIMED_OUT && result != B_BUSY) {
			// we expect timeouts as we do repeat key handling this way,
			// "busy" happens when other reports come in on the same endpoint
			TRACE_ALWAYS("error waiting for report: %s\n", strerror(result));
		}

		// signal that we simply want to try again
		return B_OK;
	}

	TRACE("got keyboard input report\n");

	uint8 modifiers = 0;
	for (uint32 i = 0; i < fModifierCount; i++) {
		HIDReportItem *modifier = fModifiers[i];
		if (modifier == NULL)
			break;

		if (modifier->Extract() == B_OK && modifier->Valid()) {
			modifiers |= (modifier->Data() & 1)
				<< (modifier->UsageID() - B_HID_UID_KB_LEFT_CONTROL);
		}
	}

	for (uint32 i = 0; i < fKeyCount; i++) {
		HIDReportItem *key = fKeys[i];
		if (key == NULL)
			break;

		if (key->Extract() == B_OK && key->Valid()) {
			// handle both array and bitmap based keyboard reports
			if (key->Array()) {
				fCurrentKeys[i] = key->Data() - key->Minimum();
			} else {
				if (key->Data() == 1)
					fCurrentKeys[i] = key->UsageID();
				else
					fCurrentKeys[i] = 0;
			}
		}
		else
			fCurrentKeys[i] = 0;
	}

	fInputReport.DoneProcessing();

	static const uint32 kModifierTable[] = {
		KEY_ControlL,
		KEY_ShiftL,
		KEY_AltL,
		KEY_WinL,
		KEY_ControlR,
		KEY_ShiftR,
		KEY_AltR,
		KEY_WinR
	};

	// find modifier changes and push them into the buffer
	uint8 modifierChange = fLastModifiers ^ modifiers;
	for (uint8 i = 0; modifierChange; i++, modifierChange >>= 1) {
		if (modifierChange & 1)
			_WriteKey(kModifierTable[i], (modifiers >> i) & 1);
	}

	fLastModifiers = modifiers;

	static const uint32 kKeyTable[] = {
		0x00,	// ERROR
		0x00,	// ERROR
		0x00,	// ERROR
		0x00,	// ERROR
		0x3c,	// A
		0x50,	// B
		0x4e,	// C
		0x3e,	// D
		0x29,	// E
		0x3f,	// F
		0x40,	// G
		0x41,	// H
		0x2e,	// I
		0x42,	// J
		0x43,	// K
		0x44,	// L
		0x52,	// M
		0x51,	// N
		0x2f,	// O
		0x30,	// P
		0x27,	// Q
		0x2a,	// R
		0x3d,	// S
		0x2b,	// T
		0x2d,	// U
		0x4f,	// V
		0x28,	// W
		0x4d,	// X
		0x2c,	// Y
		0x4c,	// Z
		0x12,	// 1
		0x13,	// 2
		0x14,	// 3
		0x15,	// 4
		0x16,	// 5
		0x17,	// 6
		0x18,	// 7
		0x19,	// 8
		0x1a,	// 9
		0x1b,	// 0
		0x47,	// enter
		0x01,	// Esc
		0x1e,	// Backspace
		0x26,	// Tab
		0x5e,	// Space
		0x1c,	// -
		0x1d,	// =
		0x31,	// [
		0x32,	// ]
		0x33,	// backslash
		0x33,	// backslash
		0x45,	// ;
		0x46,	// '
		0x11,	// `
		0x53,	// ,
		0x54,	// .
		0x55,	// /
		B_CAPS_LOCK_KEY,	// Caps
		0x02,	// F1
		0x03,	// F2
		0x04,	// F3
		0x05,	// F4
		0x06,	// F5
		0x07,	// F6
		0x08,	// F7
		0x09,	// F8
		0x0a,	// F9
		0x0b,	// F10
		0x0c,	// F11
		0x0d,	// F12
		0x0e,	// PrintScreen
		B_SCROLL_KEY,	// Scroll Lock
		B_PAUSE_KEY,	// Pause (0x7f with Ctrl)
		0x1f,	// Insert
		0x20,	// Home
		0x21,	// Page up
		0x34,	// Delete
		0x35,	// End
		0x36,	// Page down
		0x63,	// Right arrow
		0x61,	// Left arrow
		0x62,	// Down arrow
		0x57,	// Up arrow
		0x22,	// Num Lock
		0x23,	// Pad /
		0x24,	// Pad *
		0x25,	// Pad -
		0x3a,	// Pad +
		0x5b,	// Pad Enter
		0x58,	// Pad 1
		0x59,	// Pad 2
		0x5a,	// Pad 3
		0x48,	// Pad 4
		0x49,	// Pad 5
		0x4a,	// Pad 6
		0x37,	// Pad 7
		0x38,	// Pad 8
		0x39,	// Pad 9
		0x64,	// Pad 0
		0x65,	// Pad .
		0x69,	// <
		KEY_Menu,	// Menu
		0x00,	// Power unmapped
		B_NUMPAD_EQUAL_KEY,	// Pad =
		0x00,	// F13 unmapped
		0x00,	// F14 unmapped
		0x00,	// F15 unmapped
		0x00,	// F16 unmapped
		0x00,	// F17 unmapped
		0x00,	// F18 unmapped
		0x00,	// F19 unmapped
		0x00,	// F20 unmapped
		0x00,	// F21 unmapped
		0x00,	// F22 unmapped
		0x00,	// F23 unmapped
		0x00,	// F24 unmapped
		0x00,	// Execute unmapped
		0x00,	// Help unmapped
		0x00,	// Menu unmapped
		0x00,	// Select unmapped
		0x00,	// Stop unmapped
		0x00,	// Again unmapped
		0x00,	// Undo unmapped
		0x00,	// Cut unmapped
		0x00,	// Copy unmapped
		0x00,	// Paste unmapped
		0x00,	// Find unmapped
		0x00,	// Mute unmapped
		0x00,	// Volume up unmapped
		0x00,	// Volume down unmapped
		0x00,	// CapsLock unmapped
		0x00,	// NumLock unmapped
		0x00,	// Scroll lock unmapped
		0x70,	// Keypad . on Brazilian ABNT2
		0x00,	// = sign
		0x6b,	// Ro (\\ key, japanese)
		0x6e,	// Katakana/Hiragana, second key right to spacebar, japanese
		0x6a,	// Yen (macron key, japanese)
		0x6d,	// Henkan, first key right to spacebar, japanese
		0x6c,	// Muhenkan, key left to spacebar, japanese
		0x00,	// Keyboard International6 unmapped
		0x00,	// Keyboard International7 unmapped
		0x00,	// Keyboard International8 unmapped
		0x00,	// Keyboard International9 unmapped
		0xf0,	// Hangul, korean, Kana, Mac japanese USB
		0xf1,	// Hangul_Hanja, korean, Eisu, Mac japanese USB
	};

	static const size_t kKeyTableSize = B_COUNT_OF(kKeyTable);

	bool phantomState = true;
	for (size_t i = 0; i < fKeyCount; i++) {
		if (fCurrentKeys[i] != 1
			|| fKeys[i]->UsagePage() != B_HID_USAGE_PAGE_KEYBOARD) {
			phantomState = false;
			break;
		}
	}

	if (phantomState) {
		// no valid key information is present in this state and we don't
		// want to overwrite our last buffer as otherwise we generate
		// spurious key ups now and spurious key downs when leaving the
		// phantom state again
		return B_OK;
	}

	static bool sysReqPressed = false;

	bool keyDown = false;
	uint16 *current = fLastKeys;
	uint16 *compare = fCurrentKeys;
	for (int32 twice = 0; twice < 2; twice++) {
		for (size_t i = 0; i < fKeyCount; i++) {
			if (current[i] == 0 || (current[i] == 1
				&& fKeys[i]->UsagePage() == B_HID_USAGE_PAGE_KEYBOARD))
				continue;

			bool found = false;
			for (size_t j = 0; j < fKeyCount; j++) {
				if (compare[j] == current[i]) {
					found = true;
					break;
				}
			}

			if (found)
				continue;

			// a change occured
			uint32 key = 0;
			if (fKeys[i]->UsagePage() == B_HID_USAGE_PAGE_KEYBOARD) {
				if (current[i] < kKeyTableSize)
					key = kKeyTable[current[i]];

				if (key == B_PAUSE_KEY && (modifiers & ALT_KEYS) != 0)
					key = KEY_Break;
				else if (key == 0xe && (modifiers & ALT_KEYS) != 0) {
					key = KEY_SysRq;
					sysReqPressed = keyDown;
				} else if (sysReqPressed && keyDown
					&& current[i] >= 4 && current[i] <= 29
					&& (fLastModifiers & ALT_KEYS) != 0) {
					// Alt-SysReq+letter was pressed
#ifdef KEYBOARD_SUPPORTS_KDL
#ifdef USB_KDL
					sDebugKeyboardPipe
						= fInputReport.Device()->InterruptPipe();
#endif
					sDebugKeyboardReportSize
						= fInputReport.Parser()->MaxReportSize(HID_REPORT_TYPE_INPUT);
#endif

					char letter = current[i] - 4 + 'a';

					if (debug_emergency_key_pressed(letter)) {
						// we probably have lost some keys, so reset our key
						// state
						sysReqPressed = false;
						continue;
					}
				}
			}

			if (key == 0) {
				// unmapped normal key or consumer/button key
				key = fInputReport.Usages()[0] + current[i];
			}

			_WriteKey(key, keyDown);

			if (keyDown) {
				// repeat handling
				fCurrentRepeatKey = key;
				fCurrentRepeatDelay = fRepeatDelay;
			} else {
				// cancel the repeats if they are for this key
				if (fCurrentRepeatKey == key) {
					fCurrentRepeatDelay = B_INFINITE_TIMEOUT;
					fCurrentRepeatKey = 0;
				}
			}
		}

		current = fCurrentKeys;
		compare = fLastKeys;
		keyDown = true;
	}

	memcpy(fLastKeys, fCurrentKeys, fKeyCount * sizeof(uint16));
	return B_OK;
}