libusbdrivers/src/drivers/usbkbd.c - 3p/sel4proj/projects_libs - Git at Google

 /*
  * Copyright 2017, Data61
  * Commonwealth Scientific and Industrial Research Organisation (CSIRO)
  * ABN 41 687 119 230.
  *
  * This software may be distributed and modified according to the terms of
  * the BSD 2-Clause license. Note that NO WARRANTY is provided.
  * See "LICENSE_BSD2.txt" for details.
  *
  * @TAG(DATA61_BSD)
  */
 /**
  * @brief USB Keyboard Driver
  * @see USB HID spec, Appendix B
  */
 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>

 #include "../services.h"
 #include "hid.h"
 #include "usbkbd.h"

 #define KBD_ENABLE_IRQS

 #define KBD_REPEAT_RATE_MS   200
 #define KBD_REPEAT_DELAY_MS 1000

 /*
  * Ring buffer for key logging
  */

 struct ringbuf {
 	char b[100];
 	int head;
 	int tail;
 	int size;
 };

 static void rb_init(struct ringbuf *rb)
 {
 	rb->head = 0;
 	rb->tail = 0;
 	rb->size = 0;
 }

 static int rb_produce(struct ringbuf *rb, const char *str, int size)
 {
 	if (sizeof(rb->b) / sizeof(*rb->b) - rb->size >= size) {
 		while (size--) {
 			rb->b[rb->tail++] = *str++;
 			if (rb->tail == sizeof(rb->b) / sizeof(*rb->b)) {
 				rb->tail = 0;
 			}
 			rb->size++;
 		}
 		return 0;
 	} else {
 		return 1;
 	}
 }

 static int rb_consume(struct ringbuf *rb)
 {
 	char c;
 	if (rb->size) {
 		c = rb->b[rb->head++];
 		if (rb->head == sizeof(rb->b) / sizeof(*rb->b)) {
 			rb->head = 0;
 		}
 		rb->size--;
 		return ((int)c) & 0xff;
 	}
 	return -1;
 }

 /*
  * Keyboard driver
  */

 #define KBDRPT_RATE  ((KBD_REPEAT_RATE_MS + 3) / 4)
 #define KBDRPT_DELAY ((KBD_REPEAT_DELAY_MS + 3) / 4)
 #define KBD_PROTOCOL 1
 #define KBD_KEYS_SIZE   8

 #define KBDIND_CAPS    0x2
 #define KBDIND_NUM     0x1
 #define KBDIND_SCRL    0x4

 struct usb_kbd_device {
 	struct usb_dev *udev;
 	struct usb_hid_device *hid;
 	struct endpoint *ep_int;
 	struct xact int_xact;
 /// Indicator state. This is a pointer to our universal buffer at index 1
 	uint8_t ind;
 /// Store old keys for repeat detection
 	uint8_t old_keys[KBD_KEYS_SIZE];
 /// new keys is a pointer to our interrupt buffer
 	uint8_t *new_keys;
 /// Cache the current repeat rate to avoid USB transfers
 	int repeat_rate;
 /// ring buffer for characters waiting to be read by the application.
 	struct ringbuf rb;
 };

 #define KBDFN_CTRL   0x01
 #define KBDFN_SHIFT  0x02
 #define KBDFN_ALT    0x04
 #define KBDFN_WIN    0x08
 #define KBDFN_LEFT(FN)     ((KBDFN_##FN) << 0)
 #define KBDFN_RIGHT(FN)    ((KBDFN_##FN) << 4)
 #define KBDFN_TEST(FN, x)  !!((x) & (KBDFN_LEFT(FN) | KBDFN_RIGHT(FN)))
 static const char std_kcodes[] = {
 	/*       0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F */
 	/*0x00 */ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
 	/*0x10 */ 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2',
 	/*0x20 */ '3', '4', '5', '6', '7', '8', '9', '0', 10, 27, 8, 9, ' ', '-', '=', '[',
 	/*0x30 */ ']', 92, 0, ';', 39, '`', ',', '.', '/'
 };

 static const char stdshift_kcodes[] = {
 	/*       0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F */
 	/*0x00 */ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L',
 	/*0x10 */ 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '!', '@',
 	/*0x20 */ '#', '$', '%', '^', '&', '*', '(', ')', 10, 27, 8, 9, ' ', '_', '+', '{',
 	/*0x30 */ '}', '|', 0, ':', 39, '~', '<', '>', '?'
 };

 static const char num_kcodes[] = {
 	/*       0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F */
 	/*0x50 */ '/', '*', '-', '+', 10, '1', '2', '3', '4', '5', '6', '7',
 	/*0x60 */ '8', '9', '0', '.'
 };

 #define KBDKEY_NONE       0x00
 #define KBDKEY_MASH       0x01
 #define KBDKEY_NUMLOCK    0x53
 #define KBDKEY_CAPSLOCK   0x39
 #define KBDKEY_SCROLLLOCK 0x47

 static int kbd_update_ind(struct usb_kbd_device *kbd)
 {
 	int err;

 	err = usb_hid_set_report(kbd->hid, REPORT_OUTPUT, &kbd->ind, 1);

 	return err;
 }

 static int kbd_update_repeat_rate(struct usb_kbd_device *kbd)
 {
 	ZF_LOGD("Changing rate to %dms\n", kbd->repeat_rate * 4);

 	return usb_hid_set_idle(kbd->hid, kbd->repeat_rate);
 }

 static int
 kbd_irq_handler(void *token, enum usb_xact_status stat, int bytes_remaining)
 {
 	struct usb_kbd_device *kbd = (struct usb_kbd_device *)token;
 	uint8_t afn;
 	uint8_t key;
 	int new_rate = -1;
 	char c;
 	int len;

 	/* Check the status */
 	if (stat != XACTSTAT_SUCCESS) {
 		ZF_LOGD("Received unsuccessful IRQ\n");
 		return 1;
 	}
 	len = kbd->int_xact.len - bytes_remaining;
 	if (len < 4) {
 		ZF_LOGD("Short read on INT packet (%d)\n", len);
 		return 1;
 	}
 #if defined(KBDIRQ_DEBUG)
 	{
 		int i;
 		for (i = 0; i < len; i++) {
 			printf("[0x%02x]", kbd->new_keys[i]);
 		}
 		printf("\n");
 	}
 #endif

 	/* Multiple key press. Ignore input */
 	if (kbd->new_keys[3] != KBDKEY_NONE) {
 		kbd->new_keys[2] = kbd->old_keys[2] = KBDKEY_NONE;
 	}
 	/* Read in key parameters */
 	afn = kbd->new_keys[0];
 	key = kbd->new_keys[2];
 	/* Handle repeat delay */
 	if (key == KBDKEY_NONE) {
 		/* No key pressed or someone is being a jerk - idle */
 		new_rate = 0;
 	} else if (kbd->old_keys[2] == key) {
 		/* Someone is holding down a key */
 		new_rate = KBDRPT_RATE;
 	} else {
 		/* Someone pressed a new key! Start repeat delay */
 		new_rate = KBDRPT_DELAY;
 	}
 	/* Adjust the idle delay if required */
 	if (new_rate != kbd->repeat_rate) {
 		kbd->repeat_rate = new_rate;
 		kbd_update_repeat_rate(kbd);
 	}
 	/* Process the key */
 	memcpy(kbd->old_keys, kbd->new_keys, KBD_KEYS_SIZE);
 	if (key == KBDKEY_NONE || key == KBDKEY_MASH) {
 		/* Ignore it */
 	} else if (key < 0x04) {
 		printf("<!0x%x>", key);
 	} else if (key < 0x39) {
 		char cl;
 		/* Decode the key */
 		c = std_kcodes[key - 0x04];
 		if (KBDFN_TEST(CTRL, afn) && c >= '@' && c <= '_') {
 			c -= '@';
 		} else if (KBDFN_TEST(SHIFT, afn)) {
 			c = stdshift_kcodes[key - 0x04];
 		}
 		/* Check and update for capslock */
 		cl = c | 0x20;
 		if (cl >= 'a' && cl <= 'z' && (kbd->ind & KBDIND_CAPS)) {
 			c ^= 0x20;
 		}
 		/* Register the character */
 		if (KBDFN_TEST(ALT, afn)) {
 			char str[2] = { 0x1B, c };
 			rb_produce(&kbd->rb, str, 2);
 		} else {
 			rb_produce(&kbd->rb, &c, 1);
 		}
 	} else if (key == KBDKEY_NUMLOCK) {
 		kbd->ind ^= KBDIND_NUM;
 		kbd_update_ind(kbd);
 	} else if (key == KBDKEY_CAPSLOCK) {
 		kbd->ind ^= KBDIND_CAPS;
 		kbd_update_ind(kbd);
 	} else if (key == KBDKEY_SCROLLLOCK) {
 		kbd->ind ^= KBDIND_SCRL;
 		kbd_update_ind(kbd);
 	} else if (key < 0x54) {
 		/* TODO handle these codes (see below) */
 		printf("<!0x%x>", key);
 	} else if (key < 0x64 && (kbd->ind & KBDIND_NUM)) {
 		c = num_kcodes[key - 0x54];
 		rb_produce(&kbd->rb, &c, 1);
 	} else if (key < 0x66) {
 		/* TODO find scan codes for these keys and keypad
 		 * with no numlock */
 #if 0
 		F1 - F12 3 a - 45
 		    prntscrn / sysrq 46
 		    pause / break 48
 		    insert 49 home 4 a pgup 4 b delete 4 c end 4 d pgdwn 4e
  right 4f left 50 down 51 up 52 macro 64 dropdown 65
 #endif
 		    printf("<!0x%x>", key);
 	} else {
 		printf("<!!0x%x>", key);
 	}

 	usbdev_schedule_xact(kbd->udev, kbd->ep_int, &kbd->int_xact, 1,
 			     &kbd_irq_handler, kbd);

 	return 1;
 }

 static ssize_t
 kbd_read(ps_chardevice_t *d, void *vdata, size_t bytes,
 	 chardev_callback_t cb, void *token)
 {
 	struct usb_kbd_device *kbd;
 	char *data;
 	int i;
 	kbd = (struct usb_kbd_device *)d->vaddr;
 	data = (char *)vdata;
 	for (i = 0; i < bytes; i++) {
 		int c;
 		c = rb_consume(&kbd->rb);
 		if (c >= 0) {
 			*data++ = c;
 		} else {
 			break;
 		}
 	}
 	return i;
 }

 int usb_kbd_driver_bind(usb_dev_t *usb_dev, struct ps_chardevice *cdev)
 {
 	struct usb_kbd_device *kbd;
 	int err;

 	kbd = (struct usb_kbd_device*)usb_malloc(sizeof(struct usb_kbd_device));
 	if (!kbd) {
 		ZF_LOGF("Out of memory\n");
 	}

 	usb_dev->dev_data = (struct udev_priv*)kbd;
 	kbd->udev = usb_dev;
 	kbd->repeat_rate = 0;
 	rb_init(&kbd->rb);

 	kbd->hid = usb_hid_alloc(usb_dev);

 	if (kbd->hid->protocol != 1) {
 		ZF_LOGF("Not a keyboard: %d\n", kbd->hid->protocol);
 	}

 	/* Find endpoint */
 	kbd->ep_int = usb_dev->ep[kbd->hid->iface];
 	if (kbd->ep_int == NULL || kbd->ep_int->type != EP_INTERRUPT) {
 		ZF_LOGF("Endpoint not found\n");
 	}

 	ZF_LOGD("Configuring keyboard\n");

 	err = usb_hid_set_idle(kbd->hid, 0);
 	if (err < 0) {
 		ZF_LOGF("Keyboard initialisation error\n");
 	}

 	cdev->vaddr = kbd;
 	cdev->read = kbd_read;

 	/* Initialise LEDS */
 	kbd_update_ind(kbd);

 	/* Initialise IRQs */
 	if (kbd->ep_int->dir == EP_DIR_IN) {
 		kbd->int_xact.type = PID_IN;
 	} else {
 		kbd->int_xact.type = PID_OUT;
 	}

 	kbd->int_xact.len = kbd->ep_int->max_pkt;

 	err = usb_alloc_xact(usb_dev->dman, &kbd->int_xact, 1);
 	if (err) {
 		ZF_LOGF("Out of DMA memory\n");
 	}

 	kbd->new_keys = xact_get_vaddr(&kbd->int_xact);

 #if defined(KBD_ENABLE_IRQS)
 	ZF_LOGD("Scheduling IRQS\n");
 	usbdev_schedule_xact(usb_dev, kbd->ep_int, &kbd->int_xact, 1,
 			     &kbd_irq_handler, kbd);
 #else
 	(void)kbd_irq_handler;
 #endif
 	ZF_LOGD("Successfully initialised\n");

 	return 0;
 }
	/*
	* Copyright 2017, Data61
	* Commonwealth Scientific and Industrial Research Organisation (CSIRO)
	* ABN 41 687 119 230.
	*
	* This software may be distributed and modified according to the terms of
	* the BSD 2-Clause license. Note that NO WARRANTY is provided.
	* See "LICENSE_BSD2.txt" for details.
	*
	* @TAG(DATA61_BSD)
	*/
	/**
	* @brief USB Keyboard Driver
	* @see USB HID spec, Appendix B
	*/
	#include <string.h>
	#include <stdlib.h>
	#include <stdio.h>

	#include "../services.h"
	#include "hid.h"
	#include "usbkbd.h"

	#define KBD_ENABLE_IRQS

	#define KBD_REPEAT_RATE_MS 200
	#define KBD_REPEAT_DELAY_MS 1000

	/*
	* Ring buffer for key logging
	*/

	struct ringbuf {
	char b[100];
	int head;
	int tail;
	int size;
	};

	static void rb_init(struct ringbuf *rb)
	{
	rb->head = 0;
	rb->tail = 0;
	rb->size = 0;
	}

	static int rb_produce(struct ringbuf rb, const char str, int size)
	{
	if (sizeof(rb->b) / sizeof(*rb->b) - rb->size >= size) {
	while (size--) {
	rb->b[rb->tail++] = *str++;
	if (rb->tail == sizeof(rb->b) / sizeof(*rb->b)) {
	rb->tail = 0;
	}
	rb->size++;
	}
	return 0;
	} else {
	return 1;
	}
	}

	static int rb_consume(struct ringbuf *rb)
	{
	char c;
	if (rb->size) {
	c = rb->b[rb->head++];
	if (rb->head == sizeof(rb->b) / sizeof(*rb->b)) {
	rb->head = 0;
	}
	rb->size--;
	return ((int)c) & 0xff;
	}
	return -1;
	}

	/*
	* Keyboard driver
	*/

	#define KBDRPT_RATE ((KBD_REPEAT_RATE_MS + 3) / 4)
	#define KBDRPT_DELAY ((KBD_REPEAT_DELAY_MS + 3) / 4)
	#define KBD_PROTOCOL 1
	#define KBD_KEYS_SIZE 8

	#define KBDIND_CAPS 0x2
	#define KBDIND_NUM 0x1
	#define KBDIND_SCRL 0x4

	struct usb_kbd_device {
	struct usb_dev *udev;
	struct usb_hid_device *hid;
	struct endpoint *ep_int;
	struct xact int_xact;
	/// Indicator state. This is a pointer to our universal buffer at index 1
	uint8_t ind;
	/// Store old keys for repeat detection
	uint8_t old_keys[KBD_KEYS_SIZE];
	/// new keys is a pointer to our interrupt buffer
	uint8_t *new_keys;
	/// Cache the current repeat rate to avoid USB transfers
	int repeat_rate;
	/// ring buffer for characters waiting to be read by the application.
	struct ringbuf rb;
	};

	#define KBDFN_CTRL 0x01
	#define KBDFN_SHIFT 0x02
	#define KBDFN_ALT 0x04
	#define KBDFN_WIN 0x08
	#define KBDFN_LEFT(FN) ((KBDFN_##FN) << 0)
	#define KBDFN_RIGHT(FN) ((KBDFN_##FN) << 4)
	#define KBDFN_TEST(FN, x) !!((x) & (KBDFN_LEFT(FN) \| KBDFN_RIGHT(FN)))
	static const char std_kcodes[] = {
	/* 0 1 2 3 4 5 6 7 8 9 A B C D E F */
	/0x00 / 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
	/0x10 / 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2',
	/0x20 / '3', '4', '5', '6', '7', '8', '9', '0', 10, 27, 8, 9, ' ', '-', '=', '[',
	/0x30 / ']', 92, 0, ';', 39, '`', ',', '.', '/'
	};

	static const char stdshift_kcodes[] = {
	/* 0 1 2 3 4 5 6 7 8 9 A B C D E F */
	/0x00 / 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L',
	/0x10 / 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '!', '@',
	/0x20 / '#', '$', '%', '^', '&', '*', '(', ')', 10, 27, 8, 9, ' ', '_', '+', '{',
	/0x30 / '}', '\|', 0, ':', 39, '~', '<', '>', '?'
	};

	static const char num_kcodes[] = {
	/* 0 1 2 3 4 5 6 7 8 9 A B C D E F */
	/0x50 / '/', '*', '-', '+', 10, '1', '2', '3', '4', '5', '6', '7',
	/0x60 / '8', '9', '0', '.'
	};

	#define KBDKEY_NONE 0x00
	#define KBDKEY_MASH 0x01
	#define KBDKEY_NUMLOCK 0x53
	#define KBDKEY_CAPSLOCK 0x39
	#define KBDKEY_SCROLLLOCK 0x47

	static int kbd_update_ind(struct usb_kbd_device *kbd)
	{
	int err;

	err = usb_hid_set_report(kbd->hid, REPORT_OUTPUT, &kbd->ind, 1);

	return err;
	}

	static int kbd_update_repeat_rate(struct usb_kbd_device *kbd)
	{
	ZF_LOGD("Changing rate to %dms\n", kbd->repeat_rate * 4);

	return usb_hid_set_idle(kbd->hid, kbd->repeat_rate);
	}

	static int
	kbd_irq_handler(void *token, enum usb_xact_status stat, int bytes_remaining)
	{
	struct usb_kbd_device kbd = (struct usb_kbd_device )token;
	uint8_t afn;
	uint8_t key;
	int new_rate = -1;
	char c;
	int len;

	/* Check the status */
	if (stat != XACTSTAT_SUCCESS) {
	ZF_LOGD("Received unsuccessful IRQ\n");
	return 1;
	}
	len = kbd->int_xact.len - bytes_remaining;
	if (len < 4) {
	ZF_LOGD("Short read on INT packet (%d)\n", len);
	return 1;
	}
	#if defined(KBDIRQ_DEBUG)
	{
	int i;
	for (i = 0; i < len; i++) {
	printf("[0x%02x]", kbd->new_keys[i]);
	}
	printf("\n");
	}
	#endif

	/* Multiple key press. Ignore input */
	if (kbd->new_keys[3] != KBDKEY_NONE) {
	kbd->new_keys[2] = kbd->old_keys[2] = KBDKEY_NONE;
	}
	/* Read in key parameters */
	afn = kbd->new_keys[0];
	key = kbd->new_keys[2];
	/* Handle repeat delay */
	if (key == KBDKEY_NONE) {
	/* No key pressed or someone is being a jerk - idle */
	new_rate = 0;
	} else if (kbd->old_keys[2] == key) {
	/* Someone is holding down a key */
	new_rate = KBDRPT_RATE;
	} else {
	/* Someone pressed a new key! Start repeat delay */
	new_rate = KBDRPT_DELAY;
	}
	/* Adjust the idle delay if required */
	if (new_rate != kbd->repeat_rate) {
	kbd->repeat_rate = new_rate;
	kbd_update_repeat_rate(kbd);
	}
	/* Process the key */
	memcpy(kbd->old_keys, kbd->new_keys, KBD_KEYS_SIZE);
	if (key == KBDKEY_NONE \|\| key == KBDKEY_MASH) {
	/* Ignore it */
	} else if (key < 0x04) {
	printf("<!0x%x>", key);
	} else if (key < 0x39) {
	char cl;
	/* Decode the key */
	c = std_kcodes[key - 0x04];
	if (KBDFN_TEST(CTRL, afn) && c >= '@' && c <= '_') {
	c -= '@';
	} else if (KBDFN_TEST(SHIFT, afn)) {
	c = stdshift_kcodes[key - 0x04];
	}
	/* Check and update for capslock */
	cl = c \| 0x20;
	if (cl >= 'a' && cl <= 'z' && (kbd->ind & KBDIND_CAPS)) {
	c ^= 0x20;
	}
	/* Register the character */
	if (KBDFN_TEST(ALT, afn)) {
	char str[2] = { 0x1B, c };
	rb_produce(&kbd->rb, str, 2);
	} else {
	rb_produce(&kbd->rb, &c, 1);
	}
	} else if (key == KBDKEY_NUMLOCK) {
	kbd->ind ^= KBDIND_NUM;
	kbd_update_ind(kbd);
	} else if (key == KBDKEY_CAPSLOCK) {
	kbd->ind ^= KBDIND_CAPS;
	kbd_update_ind(kbd);
	} else if (key == KBDKEY_SCROLLLOCK) {
	kbd->ind ^= KBDIND_SCRL;
	kbd_update_ind(kbd);
	} else if (key < 0x54) {
	/* TODO handle these codes (see below) */
	printf("<!0x%x>", key);
	} else if (key < 0x64 && (kbd->ind & KBDIND_NUM)) {
	c = num_kcodes[key - 0x54];
	rb_produce(&kbd->rb, &c, 1);
	} else if (key < 0x66) {
	/* TODO find scan codes for these keys and keypad
	* with no numlock */
	#if 0
	F1 - F12 3 a - 45
	prntscrn / sysrq 46
	pause / break 48
	insert 49 home 4 a pgup 4 b delete 4 c end 4 d pgdwn 4e
	right 4f left 50 down 51 up 52 macro 64 dropdown 65
	#endif
	printf("<!0x%x>", key);
	} else {
	printf("<!!0x%x>", key);
	}

	usbdev_schedule_xact(kbd->udev, kbd->ep_int, &kbd->int_xact, 1,
	&kbd_irq_handler, kbd);

	return 1;
	}

	static ssize_t
	kbd_read(ps_chardevice_t d, void vdata, size_t bytes,
	chardev_callback_t cb, void *token)
	{
	struct usb_kbd_device *kbd;
	char *data;
	int i;
	kbd = (struct usb_kbd_device *)d->vaddr;
	data = (char *)vdata;
	for (i = 0; i < bytes; i++) {
	int c;
	c = rb_consume(&kbd->rb);
	if (c >= 0) {
	*data++ = c;
	} else {
	break;
	}
	}
	return i;
	}

	int usb_kbd_driver_bind(usb_dev_t usb_dev, struct ps_chardevice cdev)
	{
	struct usb_kbd_device *kbd;
	int err;

	kbd = (struct usb_kbd_device*)usb_malloc(sizeof(struct usb_kbd_device));
	if (!kbd) {
	ZF_LOGF("Out of memory\n");
	}

	usb_dev->dev_data = (struct udev_priv*)kbd;
	kbd->udev = usb_dev;
	kbd->repeat_rate = 0;
	rb_init(&kbd->rb);

	kbd->hid = usb_hid_alloc(usb_dev);

	if (kbd->hid->protocol != 1) {
	ZF_LOGF("Not a keyboard: %d\n", kbd->hid->protocol);
	}

	/* Find endpoint */
	kbd->ep_int = usb_dev->ep[kbd->hid->iface];
	if (kbd->ep_int == NULL \|\| kbd->ep_int->type != EP_INTERRUPT) {
	ZF_LOGF("Endpoint not found\n");
	}

	ZF_LOGD("Configuring keyboard\n");

	err = usb_hid_set_idle(kbd->hid, 0);
	if (err < 0) {
	ZF_LOGF("Keyboard initialisation error\n");
	}

	cdev->vaddr = kbd;
	cdev->read = kbd_read;

	/* Initialise LEDS */
	kbd_update_ind(kbd);

	/* Initialise IRQs */
	if (kbd->ep_int->dir == EP_DIR_IN) {
	kbd->int_xact.type = PID_IN;
	} else {
	kbd->int_xact.type = PID_OUT;
	}

	kbd->int_xact.len = kbd->ep_int->max_pkt;

	err = usb_alloc_xact(usb_dev->dman, &kbd->int_xact, 1);
	if (err) {
	ZF_LOGF("Out of DMA memory\n");
	}

	kbd->new_keys = xact_get_vaddr(&kbd->int_xact);

	#if defined(KBD_ENABLE_IRQS)
	ZF_LOGD("Scheduling IRQS\n");
	usbdev_schedule_xact(usb_dev, kbd->ep_int, &kbd->int_xact, 1,
	&kbd_irq_handler, kbd);
	#else
	(void)kbd_irq_handler;
	#endif
	ZF_LOGD("Successfully initialised\n");

	return 0;
	}