Index: uspace/drv/bus/usb/usbhid/subdrivers.c
===================================================================
--- uspace/drv/bus/usb/usbhid/subdrivers.c	(revision b803845b7f74b6b0f13292e50da92b17eb62ec2b)
+++ uspace/drv/bus/usb/usbhid/subdrivers.c	(revision 3f8f09fa79fdc4b6de8a974310c5cd47755481c3)
@@ -42,16 +42,16 @@
 #include "generic/hiddev.h"
 
-static usb_hid_subdriver_usage_t path_kbd[] = {
-	{USB_HIDUT_PAGE_GENERIC_DESKTOP, 
-	 USB_HIDUT_USAGE_GENERIC_DESKTOP_KEYBOARD}, 
+static const usb_hid_subdriver_usage_t path_kbd[] = {
+	{USB_HIDUT_PAGE_GENERIC_DESKTOP,
+	 USB_HIDUT_USAGE_GENERIC_DESKTOP_KEYBOARD},
 	{0, 0}
 };
 
-static usb_hid_subdriver_usage_t path_mouse[] = {
+static const usb_hid_subdriver_usage_t path_mouse[] = {
 	{USB_HIDUT_PAGE_GENERIC_DESKTOP, USB_HIDUT_USAGE_GENERIC_DESKTOP_MOUSE},
 	{0, 0}
 };
 
-static usb_hid_subdriver_usage_t multim_key_path[] = {
+static const usb_hid_subdriver_usage_t multim_key_path[] = {
 	{USB_HIDUT_PAGE_CONSUMER, USB_HIDUT_USAGE_CONSUMER_CONSUMER_CONTROL},
 	{0, 0}
@@ -71,5 +71,4 @@
 			.poll_end = NULL
 		},
-		
 	},
 	{
Index: uspace/drv/bus/usb/usbhid/subdrivers.h
===================================================================
--- uspace/drv/bus/usb/usbhid/subdrivers.h	(revision b803845b7f74b6b0f13292e50da92b17eb62ec2b)
+++ uspace/drv/bus/usb/usbhid/subdrivers.h	(revision 3f8f09fa79fdc4b6de8a974310c5cd47755481c3)
@@ -78,5 +78,5 @@
 
 	/** Subdriver for controlling this device. */
-	usb_hid_subdriver_t subdriver;
+	const usb_hid_subdriver_t subdriver;
 } usb_hid_subdriver_mapping_t;
 
Index: uspace/drv/bus/usb/usbhid/usbhid.c
===================================================================
--- uspace/drv/bus/usb/usbhid/usbhid.c	(revision b803845b7f74b6b0f13292e50da92b17eb62ec2b)
+++ uspace/drv/bus/usb/usbhid/usbhid.c	(revision 3f8f09fa79fdc4b6de8a974310c5cd47755481c3)
@@ -67,29 +67,14 @@
 static int usb_hid_set_boot_kbd_subdriver(usb_hid_dev_t *hid_dev)
 {
-	assert(hid_dev != NULL && hid_dev->subdriver_count == 0);
-
-	hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc(
-	    sizeof(usb_hid_subdriver_t));
+	assert(hid_dev != NULL);
+	assert(hid_dev->subdriver_count == 0);
+
+	hid_dev->subdrivers = malloc(sizeof(usb_hid_subdriver_t));
 	if (hid_dev->subdrivers == NULL) {
 		return ENOMEM;
 	}
-
-	assert(hid_dev->subdriver_count >= 0);
-
-	// set the init callback
-	hid_dev->subdrivers[hid_dev->subdriver_count].init = usb_kbd_init;
-
-	// set the polling callback
-	hid_dev->subdrivers[hid_dev->subdriver_count].poll = 
-	    usb_kbd_polling_callback;
-
-	// set the polling ended callback
-	hid_dev->subdrivers[hid_dev->subdriver_count].poll_end = NULL;
-
-	// set the deinit callback
-	hid_dev->subdrivers[hid_dev->subdriver_count].deinit = usb_kbd_deinit;
-
-	// set subdriver count
-	++hid_dev->subdriver_count;
+	hid_dev->subdriver_count = 1;
+	// TODO 0 should be keyboard, but find a better way
+	hid_dev->subdrivers[0] = usb_hid_subdrivers[0].subdriver;
 
 	return EOK;
@@ -100,29 +85,14 @@
 static int usb_hid_set_boot_mouse_subdriver(usb_hid_dev_t *hid_dev)
 {
-	assert(hid_dev != NULL && hid_dev->subdriver_count == 0);
-
-	hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc(
-	    sizeof(usb_hid_subdriver_t));
+	assert(hid_dev != NULL);
+	assert(hid_dev->subdriver_count == 0);
+
+	hid_dev->subdrivers = malloc(sizeof(usb_hid_subdriver_t));
 	if (hid_dev->subdrivers == NULL) {
 		return ENOMEM;
 	}
-
-	assert(hid_dev->subdriver_count >= 0);
-
-	// set the init callback
-	hid_dev->subdrivers[hid_dev->subdriver_count].init = usb_mouse_init;
-
-	// set the polling callback
-	hid_dev->subdrivers[hid_dev->subdriver_count].poll = 
-	    usb_mouse_polling_callback;
-
-	// set the polling ended callback
-	hid_dev->subdrivers[hid_dev->subdriver_count].poll_end = NULL;
-
-	// set the deinit callback
-	hid_dev->subdrivers[hid_dev->subdriver_count].deinit = usb_mouse_deinit;
-
-	// set subdriver count
-	++hid_dev->subdriver_count;
+	hid_dev->subdriver_count = 1;
+	// TODO 2 should be mouse, but find a better way
+	hid_dev->subdrivers[2] = usb_hid_subdrivers[0].subdriver;
 
 	return EOK;
@@ -135,29 +105,15 @@
 	assert(hid_dev != NULL && hid_dev->subdriver_count == 0);
 
-	hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc(
-	    sizeof(usb_hid_subdriver_t));
+	hid_dev->subdrivers = malloc(sizeof(usb_hid_subdriver_t));
 	if (hid_dev->subdrivers == NULL) {
 		return ENOMEM;
 	}
-
-	assert(hid_dev->subdriver_count >= 0);
-
-	// set the init callback
-	hid_dev->subdrivers[hid_dev->subdriver_count].init =
-	    usb_generic_hid_init;
-
-	// set the polling callback
-	hid_dev->subdrivers[hid_dev->subdriver_count].poll = 
-	    usb_generic_hid_polling_callback;
-
-	// set the polling ended callback
-	hid_dev->subdrivers[hid_dev->subdriver_count].poll_end = NULL;
-
-	// set the deinit callback
-	hid_dev->subdrivers[hid_dev->subdriver_count].deinit =
-	    usb_generic_hid_deinit;
-
-	// set subdriver count
-	++hid_dev->subdriver_count;
+	hid_dev->subdriver_count = 1;
+
+	/* Set generic hid subdriver routines */
+	hid_dev->subdrivers[0].init = usb_generic_hid_init;
+	hid_dev->subdrivers[0].poll = usb_generic_hid_polling_callback;
+	hid_dev->subdrivers[0].poll_end = NULL;
+	hid_dev->subdrivers[0].deinit = usb_generic_hid_deinit;
 
 	return EOK;
@@ -166,5 +122,5 @@
 /*----------------------------------------------------------------------------*/
 
-static bool usb_hid_ids_match(usb_hid_dev_t *hid_dev, 
+static bool usb_hid_ids_match(const usb_hid_dev_t *hid_dev,
     const usb_hid_subdriver_mapping_t *mapping)
 {
@@ -172,5 +128,5 @@
 	assert(hid_dev->usb_dev != NULL);
 
-	return (hid_dev->usb_dev->descriptors.device.vendor_id 
+	return (hid_dev->usb_dev->descriptors.device.vendor_id
 	    == mapping->vendor_id
 	    && hid_dev->usb_dev->descriptors.device.product_id 
@@ -180,5 +136,5 @@
 /*----------------------------------------------------------------------------*/
 
-static bool usb_hid_path_matches(usb_hid_dev_t *hid_dev, 
+static bool usb_hid_path_matches(usb_hid_dev_t *hid_dev,
     const usb_hid_subdriver_mapping_t *mapping)
 {
@@ -192,8 +148,8 @@
 	}
 	int i = 0;
-	while (mapping->usage_path[i].usage != 0 
+	while (mapping->usage_path[i].usage != 0
 	    || mapping->usage_path[i].usage_page != 0) {
-		if (usb_hid_report_path_append_item(usage_path, 
-		    mapping->usage_path[i].usage_page, 
+		if (usb_hid_report_path_append_item(usage_path,
+		    mapping->usage_path[i].usage_page,
 		    mapping->usage_path[i].usage) != EOK) {
 			usb_log_debug("Failed to append to usage path.\n");
@@ -239,5 +195,5 @@
 /*----------------------------------------------------------------------------*/
 
-static int usb_hid_save_subdrivers(usb_hid_dev_t *hid_dev, 
+static int usb_hid_save_subdrivers(usb_hid_dev_t *hid_dev,
     const usb_hid_subdriver_t **subdrivers, int count)
 {
@@ -250,8 +206,6 @@
 	}
 
-	// add one generic HID subdriver per device
-
-	hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc((count + 1) * 
-	    sizeof(usb_hid_subdriver_t));
+	/* +1 for generic hid subdriver */
+	hid_dev->subdrivers = calloc((count + 1), sizeof(usb_hid_subdriver_t));
 	if (hid_dev->subdrivers == NULL) {
 		return ENOMEM;
@@ -265,4 +219,5 @@
 	}
 
+	/* Add one generic HID subdriver per device */
 	hid_dev->subdrivers[count].init = usb_generic_hid_init;
 	hid_dev->subdrivers[count].poll = usb_generic_hid_polling_callback;
@@ -303,8 +258,8 @@
 			return EINVAL;
 		}
-		
+
 		ids_matched = false;
 		matched = false;
-		
+
 		if (mapping->vendor_id >= 0) {
 			assert(mapping->product_id >= 0);
@@ -317,5 +272,5 @@
 			}
 		}
-		
+
 		if (mapping->usage_path != NULL) {
 			usb_log_debug("Comparing device against usage path.\n");
@@ -328,14 +283,16 @@
 			matched = ids_matched;
 		}
-		
+
 		if (matched) {
 			usb_log_debug("Subdriver matched.\n");
 			subdrivers[count++] = &mapping->subdriver;
 		}
-		
+
 		mapping = &usb_hid_subdrivers[++i];
 	}
 
-	// we have all subdrivers determined, save them into the hid device
+	/* We have all subdrivers determined, save them into the hid device */
+	// TODO Dowe really need this complicated stuff if there is
+	// max_subdrivers limitation?
 	return usb_hid_save_subdrivers(hid_dev, subdrivers, count);
 }
@@ -343,9 +300,8 @@
 /*----------------------------------------------------------------------------*/
 
-static int usb_hid_check_pipes(usb_hid_dev_t *hid_dev, usb_device_t *dev)
-{
-	assert(hid_dev != NULL && dev != NULL);
-
-	int rc = EOK;
+static int usb_hid_check_pipes(usb_hid_dev_t *hid_dev, const usb_device_t *dev)
+{
+	assert(hid_dev);
+	assert(dev);
 
 	if (dev->pipes[USB_HID_KBD_POLL_EP_NO].present) {
@@ -364,8 +320,8 @@
 		usb_log_error("None of supported endpoints found - probably"
 		    " not a supported device.\n");
-		rc = ENOTSUP;
-	}
-
-	return rc;
+		return ENOTSUP;
+	}
+
+	return EOK;
 }
 
@@ -393,12 +349,11 @@
 	usb_log_debug("Max size of input report: %zu\n", max_size);
 
-	hid_dev->max_input_report_size = max_size;
 	assert(hid_dev->input_report == NULL);
 
-	hid_dev->input_report = malloc(max_size);
+	hid_dev->input_report = calloc(1, max_size);
 	if (hid_dev->input_report == NULL) {
 		return ENOMEM;
 	}
-	memset(hid_dev->input_report, 0, max_size);
+	hid_dev->max_input_report_size = max_size;
 
 	return EOK;
@@ -477,7 +432,7 @@
 			break;
 		default:
-			assert(hid_dev->poll_pipe_index 
+			assert(hid_dev->poll_pipe_index
 			    == USB_HID_GENERIC_POLL_EP_NO);
-			
+
 			usb_log_info("Falling back to generic HID driver.\n");
 			rc = usb_hid_set_generic_hid_subdriver(hid_dev);
@@ -488,13 +443,12 @@
 		usb_log_error("No subdriver for handling this device could be"
 		    " initialized: %s.\n", str_error(rc));
-		usb_log_debug("Subdriver count: %d\n", 
+		usb_log_debug("Subdriver count: %d\n",
 		    hid_dev->subdriver_count);
-		
 	} else {
 		bool ok = false;
-		
-		usb_log_debug("Subdriver count: %d\n", 
+
+		usb_log_debug("Subdriver count: %d\n",
 		    hid_dev->subdriver_count);
-		
+
 		for (i = 0; i < hid_dev->subdriver_count; ++i) {
 			if (hid_dev->subdrivers[i].init != NULL) {
@@ -527,5 +481,4 @@
 	}
 
-
 	return rc;
 }
@@ -533,17 +486,15 @@
 /*----------------------------------------------------------------------------*/
 
-bool usb_hid_polling_callback(usb_device_t *dev, uint8_t *buffer, 
+bool usb_hid_polling_callback(usb_device_t *dev, uint8_t *buffer,
     size_t buffer_size, void *arg)
 {
-	int i;
-
 	if (dev == NULL || arg == NULL || buffer == NULL) {
 		usb_log_error("Missing arguments to polling callback.\n");
 		return false;
 	}
-
-	usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)arg;
+	usb_hid_dev_t *hid_dev = arg;
 
 	assert(hid_dev->input_report != NULL);
+
 	usb_log_debug("New data [%zu/%zu]: %s\n", buffer_size,
 	    hid_dev->max_input_report_size,
@@ -557,9 +508,7 @@
 	}
 
-	// parse the input report
-
-	int rc = usb_hid_parse_report(&hid_dev->report, buffer, buffer_size,
-	    &hid_dev->report_id);
-
+	/* Parse the input report */
+	const int rc = usb_hid_parse_report(
+	    &hid_dev->report, buffer, buffer_size, &hid_dev->report_id);
 	if (rc != EOK) {
 		usb_log_warning("Error in usb_hid_parse_report():"
@@ -568,11 +517,9 @@
 
 	bool cont = false;
-
-	// continue if at least one of the subdrivers want to continue
-	for (i = 0; i < hid_dev->subdriver_count; ++i) {
-		if (hid_dev->subdrivers[i].poll != NULL
-		    && hid_dev->subdrivers[i].poll(hid_dev, 
-		        hid_dev->subdrivers[i].data)) {
-			cont = true;
+	/* Continue if at least one of the subdrivers want to continue */
+	for (int i = 0; i < hid_dev->subdriver_count; ++i) {
+		if (hid_dev->subdrivers[i].poll != NULL) {
+			cont = cont || hid_dev->subdrivers[i].poll(
+			    hid_dev, hid_dev->subdrivers[i].data);
 		}
 	}
@@ -583,19 +530,15 @@
 /*----------------------------------------------------------------------------*/
 
-void usb_hid_polling_ended_callback(usb_device_t *dev, bool reason, 
-     void *arg)
-{
-	int i; 
-
-	if (dev == NULL || arg == NULL) {
-		return;
-	}
-
-	usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)arg;
-
-	for (i = 0; i < hid_dev->subdriver_count; ++i) {
+void usb_hid_polling_ended_callback(usb_device_t *dev, bool reason, void *arg)
+{
+	assert(dev);
+	assert(arg);
+
+	usb_hid_dev_t *hid_dev = arg;
+
+	for (int i = 0; i < hid_dev->subdriver_count; ++i) {
 		if (hid_dev->subdrivers[i].poll_end != NULL) {
-			hid_dev->subdrivers[i].poll_end(hid_dev,
-			    hid_dev->subdrivers[i].data, reason);
+			hid_dev->subdrivers[i].poll_end(
+			    hid_dev, hid_dev->subdrivers[i].data, reason);
 		}
 	}
@@ -613,5 +556,5 @@
 /*----------------------------------------------------------------------------*/
 
-int usb_hid_report_number(usb_hid_dev_t *hid_dev)
+int usb_hid_report_number(const usb_hid_dev_t *hid_dev)
 {
 	return hid_dev->report_nr;
@@ -622,17 +565,12 @@
 void usb_hid_deinit(usb_hid_dev_t *hid_dev)
 {
-	int i;
-
-	if (hid_dev == NULL) {
-		return;
-	}
+	assert(hid_dev);
+	assert(hid_dev->subdrivers != NULL || hid_dev->subdriver_count == 0);
+
 
 	usb_log_debug("Subdrivers: %p, subdriver count: %d\n", 
 	    hid_dev->subdrivers, hid_dev->subdriver_count);
 
-	assert(hid_dev->subdrivers != NULL 
-	    || hid_dev->subdriver_count == 0);
-
-	for (i = 0; i < hid_dev->subdriver_count; ++i) {
+	for (int i = 0; i < hid_dev->subdriver_count; ++i) {
 		if (hid_dev->subdrivers[i].deinit != NULL) {
 			hid_dev->subdrivers[i].deinit(hid_dev,
Index: uspace/drv/bus/usb/usbhid/usbhid.h
===================================================================
--- uspace/drv/bus/usb/usbhid/usbhid.h	(revision b803845b7f74b6b0f13292e50da92b17eb62ec2b)
+++ uspace/drv/bus/usb/usbhid/usbhid.h	(revision 3f8f09fa79fdc4b6de8a974310c5cd47755481c3)
@@ -146,4 +146,5 @@
 
 int usb_hid_init(usb_hid_dev_t *hid_dev, usb_device_t *dev);
+
 void usb_hid_deinit(usb_hid_dev_t *hid_dev);
 
@@ -155,5 +156,5 @@
 void usb_hid_new_report(usb_hid_dev_t *hid_dev);
 
-int usb_hid_report_number(usb_hid_dev_t *hid_dev);
+int usb_hid_report_number(const usb_hid_dev_t *hid_dev);
 
 #endif /* USB_HID_USBHID_H_ */