Changeset 095b2017 in mainline for uspace/drv

Timestamp:

2011-03-25T17:13:02Z (15 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

b8d453ec, fa3de85

Parents:

da88eb82 (diff), da3dafc (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Development branch changes

Location:

uspace/drv

Files:

• ohci/batch.c (modified) (1 diff)
• ohci/root_hub.c (modified) (2 diffs)
• ohci/root_hub.h (modified) (1 diff)
• usbhid/descdump.c (deleted)
• usbhid/hiddev.c (deleted)
• usbhid/hiddev.h (deleted)
• usbhid/main.c (deleted)
• usbhub/port_status.h (modified) (2 diffs)
• usbhub/usbhub.c (modified) (1 diff)
• usbkbd/Makefile (moved) (moved from uspace/drv/usbhid/Makefile ) (2 diffs)
• usbkbd/conv.c (moved) (moved from uspace/drv/usbhid/conv.c )
• usbkbd/conv.h (moved) (moved from uspace/drv/usbhid/conv.h ) (1 diff)
• usbkbd/kbd.h (moved) (moved from uspace/drv/usbhid/kbd.h )
• usbkbd/kbddev.c (moved) (moved from uspace/drv/usbhid/kbddev.c ) (33 diffs)
• usbkbd/kbddev.h (moved) (moved from uspace/drv/usbhid/kbddev.h ) (5 diffs)
• usbkbd/kbdrepeat.c (moved) (moved from uspace/drv/usbhid/kbdrepeat.c ) (8 diffs)
• usbkbd/kbdrepeat.h (moved) (moved from uspace/drv/usbhid/kbdrepeat.h ) (1 diff)
• usbkbd/layout.h (moved) (moved from uspace/drv/usbhid/layout.h ) (1 diff)
• usbkbd/main.c (added)
• usbkbd/usbkbd.ma (moved) (moved from uspace/drv/usbhid/usbhid.ma )

uspace/drv/ohci/batch.c

@@ -118 +118 @@
         instance->next_step = batch_call_in_and_dispose;
         /* TODO: implement */
-        usb_log_debug("Batch(%p) CONTROL WRITE initialized.\n", instance);
+        usb_log_debug("Batch(%p) CONTROL READ initialized.\n", instance);
 }
 /*----------------------------------------------------------------------------*/

uspace/drv/ohci/root_hub.c

@@ -39 +39 @@
 
 #include "root_hub.h"
+#include "usb/classes/classes.h"
+#include <usb/request.h>
+#include <usb/classes/hub.h>
+
 
 /** Root hub initialization
@@ -50 +54 @@
         instance->device = dev;
 
+
         usb_log_info("OHCI root hub with %d ports.\n", regs->rh_desc_a & 0xff);
 
+        //start generic usb hub driver
+        
         /* TODO: implement */
         return EOK;
 }
 /*----------------------------------------------------------------------------*/
+
+
+static int process_get_port_status_request(rh_t *instance, uint16_t port,
+                usb_transfer_batch_t * request){
+        if(port<1 || port>instance->port_count)
+                return EINVAL;
+        uint32_t * uint32_buffer = (uint32_t*)request->buffer;
+        request->transfered_size = 4;
+        uint32_buffer[0] = instance->registers->rh_port_status[port -1];
+        return EOK;
+}
+
+static int process_get_hub_status_request(rh_t *instance,
+                usb_transfer_batch_t * request){
+        uint32_t * uint32_buffer = (uint32_t*)request->buffer;
+        //bits, 0,1,16,17
+        request->transfered_size = 4;
+        uint32_t mask = 1 & (1<<1) & (1<<16) & (1<<17);
+        uint32_buffer[0] = mask & instance->registers->rh_status;
+        return EOK;
+
+}
+
+static void usb_create_serialized_hub_descriptor(rh_t *instance, uint8_t ** out_result,
+                size_t * out_size) {
+        //base size
+        size_t size = 7;
+        //variable size according to port count
+        size_t var_size = instance->port_count / 8 +
+                        ((instance->port_count % 8 > 0) ? 1 : 0);
+        size += 2 * var_size;
+        uint8_t * result = (uint8_t*) malloc(size);
+        bzero(result,size);
+        //size
+        result[0] = size;
+        //descriptor type
+        result[1] = USB_DESCTYPE_HUB;
+        result[2] = instance->port_count;
+        uint32_t hub_desc_reg = instance->registers->rh_desc_a;
+        result[3] = 
+                        ((hub_desc_reg >> 8) %2) +
+                        (((hub_desc_reg >> 9) %2) << 1) +
+                        (((hub_desc_reg >> 10) %2) << 2) +
+                        (((hub_desc_reg >> 11) %2) << 3) +
+                        (((hub_desc_reg >> 12) %2) << 4);
+        result[4] = 0;
+        result[5] = /*descriptor->pwr_on_2_good_time*/ 50;
+        result[6] = 50;
+
+        int port;
+        for (port = 1; port <= instance->port_count; ++port) {
+                result[7 + port/8] +=
+                                ((instance->registers->rh_desc_b >> port)%2) << (port%8);
+        }
+        size_t i;
+        for (i = 0; i < var_size; ++i) {
+                result[7 + var_size + i] = 255;
+        }
+        (*out_result) = result;
+        (*out_size) = size;
+}
+
+
+static int process_get_status_request(rh_t *instance,
+                usb_transfer_batch_t * request)
+{
+        size_t buffer_size = request->buffer_size;
+        usb_device_request_setup_packet_t * request_packet =
+                        (usb_device_request_setup_packet_t*)
+                        request->setup_buffer;
+
+        usb_hub_bm_request_type_t request_type = request_packet->request_type;
+        if(buffer_size<4/*request_packet->length*/){///\TODO
+                usb_log_warning("requested more data than buffer size\n");
+                return EINVAL;
+        }
+
+        if(request_type == USB_HUB_REQ_TYPE_GET_HUB_STATUS)
+                return process_get_hub_status_request(instance, request);
+        if(request_type == USB_HUB_REQ_TYPE_GET_PORT_STATUS)
+                return process_get_port_status_request(instance, request_packet->index,
+                                request);
+        return ENOTSUP;
+}
+
+static void create_interrupt_mask(rh_t *instance, void ** buffer,
+                size_t * buffer_size){
+        int bit_count = instance->port_count + 1;
+        (*buffer_size) = (bit_count / 8) + (bit_count%8==0)?0:1;
+        (*buffer) = malloc(*buffer_size);
+        uint8_t * bitmap = (uint8_t*)(*buffer);
+        uint32_t mask = (1<<16) + (1<<17);
+        bzero(bitmap,(*buffer_size));
+        if(instance->registers->rh_status & mask){
+                bitmap[0] = 1;
+        }
+        int port;
+        mask = 0;
+        int i;
+        for(i=16;i<=20;++i)
+                mask += 1<<i;
+        for(port = 1; port<=instance->port_count;++port){
+                if(mask & instance->registers->rh_port_status[port-1]){
+                        bitmap[(port+1)/8] += 1<<(port%8);
+                }
+        }
+}
+
+
+static int process_get_descriptor_request(rh_t *instance,
+                usb_transfer_batch_t *request){
+        /// \TODO
+        usb_device_request_setup_packet_t * setup_request =
+                        (usb_device_request_setup_packet_t*)request->setup_buffer;
+        size_t size;
+        void * result_descriptor;
+        uint16_t setup_request_value = setup_request->value_high;
+                        //(setup_request->value_low << 8);
+        if(setup_request_value == USB_DESCTYPE_HUB){
+                usb_log_debug("USB_DESCTYPE_HUB\n");
+                //create hub descriptor
+                uint8_t * descriptor;
+                usb_create_serialized_hub_descriptor(instance, 
+                                &descriptor, &size);
+                result_descriptor = descriptor;
+        }else if(setup_request_value == USB_DESCTYPE_DEVICE){
+                //create std device descriptor
+                usb_log_debug("USB_DESCTYPE_DEVICE\n");
+                usb_standard_device_descriptor_t * descriptor =
+                                (usb_standard_device_descriptor_t*)
+                                malloc(sizeof(usb_standard_device_descriptor_t));
+                descriptor->configuration_count = 1;
+                descriptor->descriptor_type = USB_DESCTYPE_DEVICE;
+                descriptor->device_class = USB_CLASS_HUB;
+                descriptor->device_protocol = 0;
+                descriptor->device_subclass = 0;
+                descriptor->device_version = 0;
+                descriptor->length = sizeof(usb_standard_device_descriptor_t);
+                /// \TODO this value is guessed
+                descriptor->max_packet_size = 8;
+                descriptor->product_id = 0x0001;
+                /// \TODO these values migt be different
+                descriptor->str_serial_number = 0;
+                descriptor->str_serial_number = 0;
+                descriptor->usb_spec_version = 0;
+                descriptor->vendor_id = 0x16db;
+                result_descriptor = descriptor;
+                size = sizeof(usb_standard_device_descriptor_t);
+        }else if(setup_request_value == USB_DESCTYPE_CONFIGURATION){
+                usb_log_debug("USB_DESCTYPE_CONFIGURATION\n");
+                usb_standard_configuration_descriptor_t * descriptor =
+                                (usb_standard_configuration_descriptor_t*)
+                                malloc(sizeof(usb_standard_configuration_descriptor_t));
+                /// \TODO some values are default or guessed
+                descriptor->attributes = 1<<7;
+                descriptor->configuration_number = 1;
+                descriptor->descriptor_type = USB_DESCTYPE_CONFIGURATION;
+                descriptor->interface_count = 1;
+                descriptor->length = sizeof(usb_standard_configuration_descriptor_t);
+                descriptor->max_power = 100;
+                descriptor->str_configuration = 0;
+                /// \TODO should this include device descriptor?
+                size_t hub_descriptor_size = 7 +
+                                2* (instance->port_count / 8 +
+                                ((instance->port_count % 8 > 0) ? 1 : 0));
+                descriptor->total_length =
+                                sizeof(usb_standard_configuration_descriptor_t)+
+                                sizeof(usb_standard_endpoint_descriptor_t)+
+                                sizeof(usb_standard_interface_descriptor_t)+
+                                hub_descriptor_size;
+                result_descriptor = descriptor;
+                size = sizeof(usb_standard_configuration_descriptor_t);
+
+        }else if(setup_request_value == USB_DESCTYPE_INTERFACE){
+                usb_log_debug("USB_DESCTYPE_INTERFACE\n");
+                usb_standard_interface_descriptor_t * descriptor =
+                                (usb_standard_interface_descriptor_t*)
+                                malloc(sizeof(usb_standard_interface_descriptor_t));
+                descriptor->alternate_setting = 0;
+                descriptor->descriptor_type = USB_DESCTYPE_INTERFACE;
+                descriptor->endpoint_count = 1;
+                descriptor->interface_class = USB_CLASS_HUB;
+                /// \TODO is this correct?
+                descriptor->interface_number = 1;
+                descriptor->interface_protocol = 0;
+                descriptor->interface_subclass = 0;
+                descriptor->length = sizeof(usb_standard_interface_descriptor_t);
+                descriptor->str_interface = 0;
+                result_descriptor = descriptor;
+                size = sizeof(usb_standard_interface_descriptor_t);
+        }else if(setup_request_value == USB_DESCTYPE_ENDPOINT){
+                usb_log_debug("USB_DESCTYPE_ENDPOINT\n");
+                usb_standard_endpoint_descriptor_t * descriptor =
+                                (usb_standard_endpoint_descriptor_t*)
+                                malloc(sizeof(usb_standard_endpoint_descriptor_t));
+                descriptor->attributes = USB_TRANSFER_INTERRUPT;
+                descriptor->descriptor_type = USB_DESCTYPE_ENDPOINT;
+                descriptor->endpoint_address = 1 + (1<<7);
+                descriptor->length = sizeof(usb_standard_endpoint_descriptor_t);
+                descriptor->max_packet_size = 8;
+                descriptor->poll_interval = 255;
+                result_descriptor = descriptor;
+                size = sizeof(usb_standard_endpoint_descriptor_t);
+        }else{
+                usb_log_debug("USB_DESCTYPE_EINVAL %d \n",setup_request->value);
+                usb_log_debug("\ttype %d\n\trequest %d\n\tvalue %d\n\tindex %d\n\tlen %d\n ",
+                                setup_request->request_type,
+                                setup_request->request,
+                                setup_request_value,
+                                setup_request->index,
+                                setup_request->length
+                                );
+                return EINVAL;
+        }
+        if(request->buffer_size < size){
+                size = request->buffer_size;
+        }
+        request->transfered_size = size;
+        memcpy(request->buffer,result_descriptor,size);
+        free(result_descriptor);
+        return EOK;
+}
+
+static int process_get_configuration_request(rh_t *instance, 
+                usb_transfer_batch_t *request){
+        //set and get configuration requests do not have any meaning, only dummy
+        //values are returned
+        if(request->buffer_size != 1)
+                return EINVAL;
+        request->buffer[0] = 1;
+        request->transfered_size = 1;
+        return EOK;
+}
+
+static int process_hub_feature_set_request(rh_t *instance,
+                uint16_t feature, bool enable){
+        if(feature > USB_HUB_FEATURE_C_HUB_OVER_CURRENT)
+                return EINVAL;
+        instance->registers->rh_status =
+                        enable ?
+                        (instance->registers->rh_status | (1<<feature))
+                        :
+                        (instance->registers->rh_status & (~(1<<feature)));
+        /// \TODO any error?
+        return EOK;
+}
+
+static int process_port_feature_set_request(rh_t *instance,
+                uint16_t feature, uint16_t port, bool enable){
+        if(feature > USB_HUB_FEATURE_C_PORT_RESET)
+                return EINVAL;
+        if(port<1 || port>instance->port_count)
+                return EINVAL;
+        instance->registers->rh_port_status[port - 1] =
+                        enable ?
+                        (instance->registers->rh_port_status[port - 1] | (1<<feature))
+                        :
+                        (instance->registers->rh_port_status[port - 1] & (~(1<<feature)));
+        /// \TODO any error?
+        return EOK;
+}
+
+static int process_address_set_request(rh_t *instance,
+                uint16_t address){
+        instance->address = address;
+        return EOK;
+}
+
+static int process_request_with_output(rh_t *instance,
+                usb_transfer_batch_t *request){
+        usb_device_request_setup_packet_t * setup_request =
+                        (usb_device_request_setup_packet_t*)request->setup_buffer;
+        if(setup_request->request == USB_DEVREQ_GET_STATUS){
+                usb_log_debug("USB_DEVREQ_GET_STATUS\n");
+                return process_get_status_request(instance, request);
+        }
+        if(setup_request->request == USB_DEVREQ_GET_DESCRIPTOR){
+                usb_log_debug("USB_DEVREQ_GET_DESCRIPTOR\n");
+                return process_get_descriptor_request(instance, request);
+        }
+        if(setup_request->request == USB_DEVREQ_GET_CONFIGURATION){
+                usb_log_debug("USB_DEVREQ_GET_CONFIGURATION\n");
+                return process_get_configuration_request(instance, request);
+        }
+        return ENOTSUP;
+}
+
+static int process_request_with_input(rh_t *instance,
+                usb_transfer_batch_t *request){
+        usb_device_request_setup_packet_t * setup_request =
+                        (usb_device_request_setup_packet_t*)request->setup_buffer;
+        request->transfered_size = 0;
+        if(setup_request->request == USB_DEVREQ_SET_DESCRIPTOR){
+                return ENOTSUP;
+        }
+        if(setup_request->request == USB_DEVREQ_SET_CONFIGURATION){
+                //set and get configuration requests do not have any meaning,
+                //only dummy values are returned
+                return EOK;
+        }
+        return ENOTSUP;
+}
+
+
+static int process_request_without_data(rh_t *instance,
+                usb_transfer_batch_t *request){
+        usb_device_request_setup_packet_t * setup_request =
+                        (usb_device_request_setup_packet_t*)request->setup_buffer;
+        request->transfered_size = 0;
+        if(setup_request->request == USB_DEVREQ_CLEAR_FEATURE
+                                || setup_request->request == USB_DEVREQ_SET_FEATURE){
+                if(setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE){
+                        usb_log_debug("USB_HUB_REQ_TYPE_SET_HUB_FEATURE\n");
+                        return process_hub_feature_set_request(instance, setup_request->value,
+                                        setup_request->request == USB_DEVREQ_SET_FEATURE);
+                }
+                if(setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE){
+                        usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n");
+                        return process_port_feature_set_request(instance, setup_request->value,
+                                        setup_request->index,
+                                        setup_request->request == USB_DEVREQ_SET_FEATURE);
+                }
+                usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n",setup_request->request_type);
+                return EINVAL;
+        }
+        if(setup_request->request == USB_DEVREQ_SET_ADDRESS){
+                usb_log_debug("USB_DEVREQ_SET_ADDRESS\n");
+                return process_address_set_request(instance, setup_request->value);
+        }
+        usb_log_debug("USB_DEVREQ_SET_ENOTSUP %d\n",setup_request->request_type);
+        return ENOTSUP;
+}
+
+
+/**
+ *
+ * @param instance
+ * @param request
+ * @return
+ */
 int rh_request(rh_t *instance, usb_transfer_batch_t *request)
 {
         assert(instance);
         assert(request);
-        /* TODO: implement */
-        if (request->setup_buffer) {
-                usb_log_info("Root hub got SETUP packet: %s.\n",
-                    usb_debug_str_buffer((const uint8_t *)request->setup_buffer, 8, 8));
-        }
-        usb_log_error("Root hub request processing not implemented.\n");
-        usb_transfer_batch_finish(request, ENOTSUP);
+        int opResult;
+        if(request->transfer_type == USB_TRANSFER_CONTROL){
+                if (request->setup_buffer) {
+                        usb_log_info("Root hub got CTRL packet: %s.\n",
+                                usb_debug_str_buffer((const uint8_t *)request->setup_buffer, 8, 8));
+                        if(sizeof(usb_device_request_setup_packet_t)>request->setup_size){
+                                usb_log_error("setup packet too small\n");
+                                return EINVAL;
+                        }
+                        usb_device_request_setup_packet_t * setup_request =
+                                        (usb_device_request_setup_packet_t*)request->setup_buffer;
+                        if(
+                                setup_request->request == USB_DEVREQ_GET_STATUS
+                                || setup_request->request == USB_DEVREQ_GET_DESCRIPTOR
+                                || setup_request->request == USB_DEVREQ_GET_CONFIGURATION
+                        ){
+                                usb_log_debug("processing request with output\n");
+                                opResult = process_request_with_output(instance,request);
+                        }else if(
+                                setup_request->request == USB_DEVREQ_CLEAR_FEATURE
+                                || setup_request->request == USB_DEVREQ_SET_FEATURE
+                                || setup_request->request == USB_DEVREQ_SET_ADDRESS
+                        ){
+                                usb_log_debug("processing request without additional data\n");
+                                opResult = process_request_without_data(instance,request);
+                        }else if(setup_request->request == USB_DEVREQ_SET_DESCRIPTOR
+                                        || setup_request->request == USB_DEVREQ_SET_CONFIGURATION
+                        ){
+                                usb_log_debug("processing request with input\n");
+                                opResult = process_request_with_input(instance,request);
+                        }else{
+                                usb_log_warning("received unsuported request: %d\n",
+                                                setup_request->request
+                                                );
+                                opResult = ENOTSUP;
+                        }
+                }else{
+                        usb_log_error("root hub received empty transaction?");
+                        opResult = EINVAL;
+                }
+        }else if(request->transfer_type == USB_TRANSFER_INTERRUPT){
+                usb_log_info("Root hub got INTERRUPT packet\n");
+                void * buffer;
+                create_interrupt_mask(instance, &buffer,
+                        &(request->transfered_size));
+                memcpy(request->transport_buffer,buffer, request->transfered_size);
+                opResult = EOK;
+        }else{
+                opResult = EINVAL;
+        }
+        usb_transfer_batch_finish(request, opResult);
         return EOK;
 }
 /*----------------------------------------------------------------------------*/
+
+
 void rh_interrupt(rh_t *instance)
 {

uspace/drv/ohci/root_hub.h

@@ -45 +45 @@
         usb_address_t address;
         ddf_dev_t *device;
+        int port_count;
 } rh_t;
 

uspace/drv/usbhub/port_status.h

@@ -30 +30 @@
  */
 
-#ifndef PORT_STATUS_H
-#define PORT_STATUS_H
+#ifndef HUB_PORT_STATUS_H
+#define HUB_PORT_STATUS_H
 
 #include <bool.h>
@@ -335 +335 @@
 
 
-#endif  /* PORT_STATUS_H */
+#endif  /* HUB_PORT_STATUS_H */
 
 /**

uspace/drv/usbhub/usbhub.c

@@ -162 +162 @@
             std_descriptor->configuration_count);
         if(std_descriptor->configuration_count<1){
-                usb_log_error("THERE ARE NO CONFIGURATIONS AVAILABLE\n");
-                //shouldn`t I return?
-                //definitely
+                usb_log_error("there are no configurations available\n");
                 return EINVAL;
         }

uspace/drv/usbkbd/Makefile

@@ -30 +30 @@
 LIBS = $(LIBDRV_PREFIX)/libdrv.a $(LIBUSB_PREFIX)/libusb.a
 EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -I$(LIBUSB_PREFIX)/include -I.
-BINARY = usbhid
+BINARY = usbkbd
 
 STOLEN_LAYOUT_SOURCES = \
@@ -40 +40 @@
         main.c \
         conv.c \
-        hidreq.c \
         kbddev.c \
         kbdrepeat.c \
-        hiddev.c \
         $(STOLEN_LAYOUT_SOURCES)
 

uspace/drv/usbkbd/conv.h

@@ -34 +34 @@
  */
 
-#ifndef USBHID_CONV_H_
-#define USBHID_CONV_H_
+#ifndef USB_KBD_CONV_H_
+#define USB_KBD_CONV_H_
 
 unsigned int usbhid_parse_scancode(int scancode);
 
-#endif /* USBHID_CONV_H_ */
+#endif /* USB_KBD_CONV_H_ */
 
 /**

uspace/drv/usbkbd/kbddev.c

@@ -46 +46 @@
 
 #include <usb/usb.h>
+#include <usb/dp.h>
+#include <usb/request.h>
 #include <usb/classes/hid.h>
 #include <usb/pipes.h>
@@ -52 +54 @@
 #include <usb/classes/classes.h>
 #include <usb/classes/hidut.h>
+#include <usb/classes/hidreq.h>
+#include <usb/classes/hidreport.h>
+
+#include <usb/devdrv.h>
 
 #include "kbddev.h"
-#include "hiddev.h"
-#include "hidreq.h"
+
 #include "layout.h"
 #include "conv.h"
@@ -85 +90 @@
 static const unsigned int DEFAULT_REPEAT_DELAY = 50 * 1000;
 
+/*----------------------------------------------------------------------------*/
+
 /** Keyboard polling endpoint description for boot protocol class. */
-static usb_endpoint_description_t poll_endpoint_description = {
+static usb_endpoint_description_t boot_poll_endpoint_description = {
         .transfer_type = USB_TRANSFER_INTERRUPT,
         .direction = USB_DIRECTION_IN,
@@ -95 +102 @@
 };
 
-typedef enum usbhid_kbd_flags {
-        USBHID_KBD_STATUS_UNINITIALIZED = 0,
-        USBHID_KBD_STATUS_INITIALIZED = 1,
-        USBHID_KBD_STATUS_TO_DESTROY = -1
-} usbhid_kbd_flags;
+/* Array of endpoints expected on the device, NULL terminated. */
+usb_endpoint_description_t 
+    *usb_kbd_endpoints[USB_KBD_POLL_EP_COUNT + 1] = {
+        &boot_poll_endpoint_description,
+        NULL
+};
+
+/*----------------------------------------------------------------------------*/
+
+enum {
+        BOOT_REPORT_DESCRIPTOR_SIZE = 63
+};
+
+static const uint8_t BOOT_REPORT_DESCRIPTOR[BOOT_REPORT_DESCRIPTOR_SIZE] = {
+        0x05, 0x01,  // Usage Page (Generic Desktop),
+        0x09, 0x06,  // Usage (Keyboard),
+        0xA1, 0x01,  // Collection (Application),
+        0x75, 0x01,  //   Report Size (1),
+        0x95, 0x08,  //   Report Count (8),       
+        0x05, 0x07,  //   Usage Page (Key Codes);
+        0x19, 0xE0,  //   Usage Minimum (224),
+        0x29, 0xE7,  //   Usage Maximum (231),
+        0x15, 0x00,  //   Logical Minimum (0),
+        0x25, 0x01,  //   Logical Maximum (1),
+        0x81, 0x02,  //   Input (Data, Variable, Absolute),   ; Modifier byte
+        0x95, 0x01,  //   Report Count (1),
+        0x75, 0x08,  //   Report Size (8),
+        0x81, 0x01,  //   Input (Constant),                   ; Reserved byte
+        0x95, 0x05,  //   Report Count (5),
+        0x75, 0x01,  //   Report Size (1),
+        0x05, 0x08,  //   Usage Page (Page# for LEDs),
+        0x19, 0x01,  //   Usage Minimum (1),
+        0x29, 0x05,  //   Usage Maxmimum (5),
+        0x91, 0x02,  //   Output (Data, Variable, Absolute),  ; LED report
+        0x95, 0x01,  //   Report Count (1),
+        0x75, 0x03,  //   Report Size (3),
+        0x91, 0x01,  //   Output (Constant),              ; LED report padding
+        0x95, 0x06,  //   Report Count (6),
+        0x75, 0x08,  //   Report Size (8),
+        0x15, 0x00,  //   Logical Minimum (0),
+        0x25, 0xff,  //   Logical Maximum (255),
+        0x05, 0x07,  //   Usage Page (Key Codes),
+        0x19, 0x00,  //   Usage Minimum (0),
+        0x29, 0xff,  //   Usage Maximum (255),
+        0x81, 0x00,  //   Input (Data, Array),            ; Key arrays (6 bytes)
+        0xC0           // End Collection
+
+};
+
+/*----------------------------------------------------------------------------*/
+
+typedef enum usb_kbd_flags {
+        USB_KBD_STATUS_UNINITIALIZED = 0,
+        USB_KBD_STATUS_INITIALIZED = 1,
+        USB_KBD_STATUS_TO_DESTROY = -1
+} usb_kbd_flags;
 
 /*----------------------------------------------------------------------------*/
@@ -132 +190 @@
 
 typedef enum usbhid_lock_code {
-        USBHID_LOCK_NUM = 0x53,
-        USBHID_LOCK_CAPS = 0x39,
-        USBHID_LOCK_SCROLL = 0x47,
-        USBHID_LOCK_COUNT = 3
+        USB_KBD_LOCK_NUM = 0x53,
+        USB_KBD_LOCK_CAPS = 0x39,
+        USB_KBD_LOCK_SCROLL = 0x47,
+        USB_KBD_LOCK_COUNT = 3
 } usbhid_lock_code;
 
-static const usbhid_lock_code usbhid_lock_codes[USBHID_LOCK_COUNT] = {
-        USBHID_LOCK_NUM,
-        USBHID_LOCK_CAPS,
-        USBHID_LOCK_SCROLL
+static const usbhid_lock_code usbhid_lock_codes[USB_KBD_LOCK_COUNT] = {
+        USB_KBD_LOCK_NUM,
+        USB_KBD_LOCK_CAPS,
+        USB_KBD_LOCK_SCROLL
 };
 
@@ -149 +207 @@
 
 static void default_connection_handler(ddf_fun_t *, ipc_callid_t, ipc_call_t *);
-static ddf_dev_ops_t keyboard_ops = {
+ddf_dev_ops_t keyboard_ops = {
         .default_handler = default_connection_handler
 };
@@ -169 +227 @@
         sysarg_t method = IPC_GET_IMETHOD(*icall);
         
-        usbhid_kbd_t *kbd_dev = (usbhid_kbd_t *)fun->driver_data;
+        usb_kbd_t *kbd_dev = (usb_kbd_t *)fun->driver_data;
         assert(kbd_dev != NULL);
 
@@ -203 +261 @@
  * @param kbd_dev Keyboard device structure.
  */
-static void usbhid_kbd_set_led(usbhid_kbd_t *kbd_dev) 
+static void usb_kbd_set_led(usb_kbd_t *kbd_dev) 
 {
         uint8_t buffer[BOOTP_BUFFER_OUT_SIZE];
@@ -237 +295 @@
             usb_debug_str_buffer(buffer, BOOTP_BUFFER_OUT_SIZE, 0));
         
-        assert(kbd_dev->hid_dev != NULL);
-        assert(kbd_dev->hid_dev->initialized == USBHID_KBD_STATUS_INITIALIZED);
-        usbhid_req_set_report(kbd_dev->hid_dev, USB_HID_REPORT_TYPE_OUTPUT, 
+        assert(kbd_dev->usb_dev != NULL);
+        
+        usbhid_req_set_report(&kbd_dev->usb_dev->ctrl_pipe, 
+            kbd_dev->usb_dev->interface_no, USB_HID_REPORT_TYPE_OUTPUT, 
             buffer, BOOTP_BUFFER_OUT_SIZE);
 }
@@ -260 +319 @@
  * @param key Key code of the key according to HID Usage Tables.
  */
-void usbhid_kbd_push_ev(usbhid_kbd_t *kbd_dev, int type, unsigned int key)
+void usb_kbd_push_ev(usb_kbd_t *kbd_dev, int type, unsigned int key)
 {
         console_event_t ev;
@@ -310 +369 @@
                         /* Update keyboard lock indicator lights. */
                         if (kbd_dev->lock_keys != locks_old) {
-                                usbhid_kbd_set_led(kbd_dev);
+                                usb_kbd_set_led(kbd_dev);
                         }
                 } else {
@@ -358 +417 @@
 
 /*----------------------------------------------------------------------------*/
-/**
- * Checks if modifiers were pressed or released and generates key events.
- *
- * @param kbd_dev Keyboard device structure.
- * @param modifiers Bitmap of modifiers.
- *
- * @sa usbhid_kbd_push_ev()
- */
-//static void usbhid_kbd_check_modifier_changes(usbhid_kbd_t *kbd_dev, 
-//    const uint8_t *key_codes, size_t count)
-//{
-//      /*
-//       * TODO: why the USB keyboard has NUM_, SCROLL_ and CAPS_LOCK
-//       *       both as modifiers and as keyUSB_HID_LOCK_COUNTs with their own scancodes???
-//       *
-//       * modifiers should be sent as normal keys to usbhid_parse_scancode()!!
-//       * so maybe it would be better if I received it from report parser in 
-//       * that way
-//       */
-        
-//      int i;
-//      for (i = 0; i < count; ++i) {
-//              if ((modifiers & usb_hid_modifiers_consts[i]) &&
-//                  !(kbd_dev->modifiers & usb_hid_modifiers_consts[i])) {
-//                      // modifier pressed
-//                      if (usbhid_modifiers_keycodes[i] != 0) {
-//                              usbhid_kbd_push_ev(kbd_dev, KEY_PRESS, 
-//                                  usbhid_modifiers_keycodes[i]);
-//                      }
-//              } else if (!(modifiers & usb_hid_modifiers_consts[i]) &&
-//                  (kbd_dev->modifiers & usb_hid_modifiers_consts[i])) {
-//                      // modifier released
-//                      if (usbhid_modifiers_keycodes[i] != 0) {
-//                              usbhid_kbd_push_ev(kbd_dev, KEY_RELEASE, 
-//                                  usbhid_modifiers_keycodes[i]);
-//                      }
-//              }       // no change
-//      }
-        
-//      kbd_dev->modifiers = modifiers;
-//}
-
-/*----------------------------------------------------------------------------*/
-
-static inline int usbhid_kbd_is_lock(unsigned int key_code) 
+
+static inline int usb_kbd_is_lock(unsigned int key_code) 
 {
         return (key_code == KC_NUM_LOCK
@@ -414 +430 @@
  *
  * An event is created only when key is pressed or released. Besides handling
- * the events (usbhid_kbd_push_ev()), the auto-repeat fibril is notified about
- * key presses and releases (see usbhid_kbd_repeat_start() and 
- * usbhid_kbd_repeat_stop()).
+ * the events (usb_kbd_push_ev()), the auto-repeat fibril is notified about
+ * key presses and releases (see usb_kbd_repeat_start() and 
+ * usb_kbd_repeat_stop()).
  *
  * @param kbd_dev Keyboard device structure.
@@ -423 +439 @@
  * @param count Number of key codes in report (size of the report).
  *
- * @sa usbhid_kbd_push_ev(), usbhid_kbd_repeat_start(), usbhid_kbd_repeat_stop()
- */
-static void usbhid_kbd_check_key_changes(usbhid_kbd_t *kbd_dev, 
+ * @sa usb_kbd_push_ev(), usb_kbd_repeat_start(), usb_kbd_repeat_stop()
+ */
+static void usb_kbd_check_key_changes(usb_kbd_t *kbd_dev, 
     const uint8_t *key_codes, size_t count)
 {
@@ -434 +450 @@
          * First of all, check if the kbd have reported phantom state.
          *
-         * TODO: this must be changed as we don't know which keys are modifiers
+         *  this must be changed as we don't know which keys are modifiers
          *       and which are regular keys.
          */
@@ -466 +482 @@
                         // not found, i.e. the key was released
                         key = usbhid_parse_scancode(kbd_dev->keys[j]);
-                        if (!usbhid_kbd_is_lock(key)) {
-                                usbhid_kbd_repeat_stop(kbd_dev, key);
+                        if (!usb_kbd_is_lock(key)) {
+                                usb_kbd_repeat_stop(kbd_dev, key);
                         }
-                        usbhid_kbd_push_ev(kbd_dev, KEY_RELEASE, key);
+                        usb_kbd_push_ev(kbd_dev, KEY_RELEASE, key);
                         usb_log_debug2("Key released: %d\n", key);
                 } else {
@@ -491 +507 @@
                         usb_log_debug2("Key pressed: %d (keycode: %d)\n", key,
                             key_codes[i]);
-                        usbhid_kbd_push_ev(kbd_dev, KEY_PRESS, key);
-                        if (!usbhid_kbd_is_lock(key)) {
-                                usbhid_kbd_repeat_start(kbd_dev, key);
+                        usb_kbd_push_ev(kbd_dev, KEY_PRESS, key);
+                        if (!usb_kbd_is_lock(key)) {
+                                usb_kbd_repeat_start(kbd_dev, key);
                         }
                 } else {
@@ -523 +539 @@
  *            structure representing the keyboard.
  *
- * @sa usbhid_kbd_check_key_changes(), usbhid_kbd_check_modifier_changes()
- */
-static void usbhid_kbd_process_keycodes(const uint8_t *key_codes, size_t count,
+ * @sa usb_kbd_check_key_changes(), usb_kbd_check_modifier_changes()
+ */
+static void usb_kbd_process_keycodes(const uint8_t *key_codes, size_t count,
     uint8_t modifiers, void *arg)
 {
@@ -534 +550 @@
         }
         
-        usbhid_kbd_t *kbd_dev = (usbhid_kbd_t *)arg;
+        usb_kbd_t *kbd_dev = (usb_kbd_t *)arg;
         assert(kbd_dev != NULL);
 
@@ -546 +562 @@
         }
         
-        ///usbhid_kbd_check_modifier_changes(kbd_dev, key_codes, count);
-        usbhid_kbd_check_key_changes(kbd_dev, key_codes, count);
+        ///usb_kbd_check_modifier_changes(kbd_dev, key_codes, count);
+        usb_kbd_check_key_changes(kbd_dev, key_codes, count);
 }
 
@@ -558 +574 @@
  * This function uses the HID report parser to translate the data received from
  * the device into generic USB HID key codes and into generic modifiers bitmap.
- * The parser then calls the given callback (usbhid_kbd_process_keycodes()).
+ * The parser then calls the given callback (usb_kbd_process_keycodes()).
  *
  * @note Currently, only the boot protocol is supported.
@@ -566 +582 @@
  * @param actual_size Size of the data from keyboard (report size) in bytes.
  *
- * @sa usbhid_kbd_process_keycodes(), usb_hid_boot_keyboard_input_report().
- */
-static void usbhid_kbd_process_data(usbhid_kbd_t *kbd_dev,
+ * @sa usb_kbd_process_keycodes(), usb_hid_boot_keyboard_input_report(),
+ *     usb_hid_parse_report().
+ */
+static void usb_kbd_process_data(usb_kbd_t *kbd_dev,
                                     uint8_t *buffer, size_t actual_size)
 {
-        assert(kbd_dev->initialized == USBHID_KBD_STATUS_INITIALIZED);
-        assert(kbd_dev->hid_dev->parser != NULL);
+        assert(kbd_dev->initialized == USB_KBD_STATUS_INITIALIZED);
+        assert(kbd_dev->parser != NULL);
         
         usb_hid_report_in_callbacks_t *callbacks =
@@ -578 +595 @@
                 sizeof(usb_hid_report_in_callbacks_t));
         
-        callbacks->keyboard = usbhid_kbd_process_keycodes;
+        callbacks->keyboard = usb_kbd_process_keycodes;
 
         usb_log_debug("Calling usb_hid_parse_report() with "
@@ -585 +602 @@
 //      int rc = usb_hid_boot_keyboard_input_report(buffer, actual_size,
 //          callbacks, kbd_dev);
-        int rc = usb_hid_parse_report(kbd_dev->hid_dev->parser, buffer,
-            actual_size, callbacks, kbd_dev);
+        usb_hid_report_path_t *path = usb_hid_report_path();
+        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
+        
+        int rc = usb_hid_parse_report(kbd_dev->parser, buffer,
+            actual_size, path, USB_HID_PATH_COMPARE_STRICT, callbacks, kbd_dev);
+
+        usb_hid_report_path_free (path);
         
         if (rc != EOK) {
@@ -597 +619 @@
 /* HID/KBD structure manipulation                                             */
 /*----------------------------------------------------------------------------*/
+
+static void usb_kbd_mark_unusable(usb_kbd_t *kbd_dev)
+{
+        kbd_dev->initialized = USB_KBD_STATUS_TO_DESTROY;
+}
+
+
+/*----------------------------------------------------------------------------*/
+/* API functions                                                              */
+/*----------------------------------------------------------------------------*/
 /**
  * Creates a new USB/HID keyboard structure.
  *
  * The structure returned by this function is not initialized. Use 
- * usbhid_kbd_init() to initialize it prior to polling.
+ * usb_kbd_init() to initialize it prior to polling.
  *
  * @return New uninitialized structure for representing a USB/HID keyboard or
  *         NULL if not successful (memory error).
  */
-static usbhid_kbd_t *usbhid_kbd_new(void)
-{
-        usbhid_kbd_t *kbd_dev = 
-            (usbhid_kbd_t *)malloc(sizeof(usbhid_kbd_t));
+usb_kbd_t *usb_kbd_new(void)
+{
+        usb_kbd_t *kbd_dev = 
+            (usb_kbd_t *)malloc(sizeof(usb_kbd_t));
 
         if (kbd_dev == NULL) {
@@ -616 +648 @@
         }
         
-        memset(kbd_dev, 0, sizeof(usbhid_kbd_t));
-        
-        kbd_dev->hid_dev = usbhid_dev_new();
-        if (kbd_dev->hid_dev == NULL) {
-                usb_log_fatal("Could not create HID device structure.\n");
+        memset(kbd_dev, 0, sizeof(usb_kbd_t));
+        
+        kbd_dev->parser = (usb_hid_report_parser_t *)(malloc(sizeof(
+            usb_hid_report_parser_t)));
+        if (kbd_dev->parser == NULL) {
+                usb_log_fatal("No memory!\n");
+                free(kbd_dev);
                 return NULL;
         }
         
         kbd_dev->console_phone = -1;
-        kbd_dev->initialized = USBHID_KBD_STATUS_UNINITIALIZED;
+        kbd_dev->initialized = USB_KBD_STATUS_UNINITIALIZED;
         
         return kbd_dev;
-}
-
-/*----------------------------------------------------------------------------*/
-
-static void usbhid_kbd_mark_unusable(usbhid_kbd_t *kbd_dev)
-{
-        kbd_dev->initialized = USBHID_KBD_STATUS_TO_DESTROY;
 }
 
@@ -658 +685 @@
  * @return Other value inherited from function usbhid_dev_init().
  */
-static int usbhid_kbd_init(usbhid_kbd_t *kbd_dev, ddf_dev_t *dev)
+int usb_kbd_init(usb_kbd_t *kbd_dev, usb_device_t *dev)
 {
         int rc;
@@ -671 +698 @@
         
         if (dev == NULL) {
-                usb_log_error("Failed to init keyboard structure: no device"
+                usb_log_error("Failed to init keyboard structure: no USB device"
                     " given.\n");
                 return EINVAL;
         }
         
-        if (kbd_dev->initialized == USBHID_KBD_STATUS_INITIALIZED) {
+        if (kbd_dev->initialized == USB_KBD_STATUS_INITIALIZED) {
                 usb_log_warning("Keyboard structure already initialized.\n");
                 return EINVAL;
         }
         
-        rc = usbhid_dev_init(kbd_dev->hid_dev, dev, &poll_endpoint_description);
-        
+        /* TODO: does not work! */
+        if (!dev->pipes[USB_KBD_POLL_EP_NO].present) {
+                usb_log_warning("Required endpoint not found - probably not "
+                    "a supported device.\n");
+                return ENOTSUP;
+        }
+        
+        /* The USB device should already be initialized, save it in structure */
+        kbd_dev->usb_dev = dev;
+        
+        /* Initialize the report parser. */
+        rc = usb_hid_parser_init(kbd_dev->parser);
         if (rc != EOK) {
-                usb_log_error("Failed to initialize HID device structure: %s\n",
-                   str_error(rc));
+                usb_log_error("Failed to initialize report parser.\n");
                 return rc;
         }
         
-        assert(kbd_dev->hid_dev->initialized == USBHID_KBD_STATUS_INITIALIZED);
-        
-        // save the size of the report (boot protocol report by default)
-//      kbd_dev->key_count = BOOTP_REPORT_SIZE;
-        
-        usb_hid_report_path_t path;
-        path.usage_page = USB_HIDUT_PAGE_KEYBOARD;
+        /* Get the report descriptor and parse it. */
+        rc = usb_hid_process_report_descriptor(kbd_dev->usb_dev, 
+            kbd_dev->parser);
+        if (rc != EOK) {
+                usb_log_warning("Could not process report descriptor, "
+                    "falling back to boot protocol.\n");
+                rc = usb_hid_parse_report_descriptor(kbd_dev->parser, 
+                    BOOT_REPORT_DESCRIPTOR, BOOT_REPORT_DESCRIPTOR_SIZE);
+                if (rc != EOK) {
+                        usb_log_error("Failed to parse boot report descriptor:"
+                            " %s.\n", str_error(rc));
+                        return rc;
+                }
+                
+                rc = usbhid_req_set_protocol(&kbd_dev->usb_dev->ctrl_pipe, 
+                    kbd_dev->usb_dev->interface_no, USB_HID_PROTOCOL_BOOT);
+                
+                if (rc != EOK) {
+                        usb_log_warning("Failed to set boot protocol to the "
+                            "device: %s\n", str_error(rc));
+                        return rc;
+                }
+        }
+        
+        /*
+         * TODO: make more general
+         */
+        usb_hid_report_path_t *path = usb_hid_report_path();
+        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
         kbd_dev->key_count = usb_hid_report_input_length(
-            kbd_dev->hid_dev->parser, &path);
+            kbd_dev->parser, path, USB_HID_PATH_COMPARE_STRICT);
+        usb_hid_report_path_free (path);
         
         usb_log_debug("Size of the input report: %zu\n", kbd_dev->key_count);
@@ -729 +788 @@
         
         /*
-         * Set boot protocol.
          * Set LEDs according to initial setup.
          * Set Idle rate
          */
-        assert(kbd_dev->hid_dev != NULL);
-        assert(kbd_dev->hid_dev->initialized);
-        //usbhid_req_set_protocol(kbd_dev->hid_dev, USB_HID_PROTOCOL_BOOT);
-        
-        usbhid_kbd_set_led(kbd_dev);
-        
-        usbhid_req_set_idle(kbd_dev->hid_dev, IDLE_RATE);
-        
-        kbd_dev->initialized = USBHID_KBD_STATUS_INITIALIZED;
+        usb_kbd_set_led(kbd_dev);
+        
+        usbhid_req_set_idle(&kbd_dev->usb_dev->ctrl_pipe, 
+            kbd_dev->usb_dev->interface_no, IDLE_RATE);
+        
+        kbd_dev->initialized = USB_KBD_STATUS_INITIALIZED;
         usb_log_debug("HID/KBD device structure initialized.\n");
         
@@ -748 +803 @@
 
 /*----------------------------------------------------------------------------*/
-/* HID/KBD polling                                                            */
-/*----------------------------------------------------------------------------*/
-/**
- * Main keyboard polling function.
- *
- * This function uses the Interrupt In pipe of the keyboard to poll for events.
- * The keyboard is initialized in a way that it reports only when a key is 
- * pressed or released, so there is no actual need for any sleeping between
- * polls (see usbhid_kbd_try_add_device() or usbhid_kbd_init()).
- *
- * @param kbd_dev Initialized keyboard structure representing the device to 
- *                poll.
- *
- * @sa usbhid_kbd_process_data()
- */
-static void usbhid_kbd_poll(usbhid_kbd_t *kbd_dev)
-{
-        int rc, sess_rc;
-        uint8_t buffer[BOOTP_BUFFER_SIZE];
-        size_t actual_size;
-        
-        usb_log_debug("Polling keyboard...\n");
-        
-        if (!kbd_dev->initialized) {
-                usb_log_error("HID/KBD device not initialized!\n");
-                return;
-        }
-        
-        assert(kbd_dev->hid_dev != NULL);
-        assert(kbd_dev->hid_dev->initialized);
-
-        while (true) {
-                sess_rc = usb_pipe_start_session(
-                    &kbd_dev->hid_dev->poll_pipe);
-                if (sess_rc != EOK) {
-                        usb_log_warning("Failed to start a session: %s.\n",
-                            str_error(sess_rc));
-                        break;
-                }
-
-                rc = usb_pipe_read(&kbd_dev->hid_dev->poll_pipe, 
-                    buffer, BOOTP_BUFFER_SIZE, &actual_size);
-                
-                sess_rc = usb_pipe_end_session(
-                    &kbd_dev->hid_dev->poll_pipe);
-
-                if (rc != EOK) {
-                        usb_log_warning("Error polling the keyboard: %s.\n",
-                            str_error(rc));
-                        break;
-                }
-
-                if (sess_rc != EOK) {
-                        usb_log_warning("Error closing session: %s.\n",
-                            str_error(sess_rc));
-                        break;
-                }
-
-                /*
-                 * If the keyboard answered with NAK, it returned no data.
-                 * This implies that no change happened since last query.
-                 */
-                if (actual_size == 0) {
-                        usb_log_debug("Keyboard returned NAK\n");
-                        continue;
-                }
-
-                /*
-                 * TODO: Process pressed keys.
-                 */
-                usb_log_debug("Calling usbhid_kbd_process_data()\n");
-                usbhid_kbd_process_data(kbd_dev, buffer, actual_size);
-                
-                // disabled for now, no reason to sleep
-                //async_usleep(kbd_dev->hid_dev->poll_interval);
-        }
-}
-
-/*----------------------------------------------------------------------------*/
-/**
- * Function executed by the main driver fibril.
- *
- * Just starts polling the keyboard for events.
- * 
- * @param arg Initialized keyboard device structure (of type usbhid_kbd_t) 
- *            representing the device.
- *
- * @retval EOK if the fibril finished polling the device.
- * @retval EINVAL if no device was given in the argument.
- *
- * @sa usbhid_kbd_poll()
- *
- * @todo Change return value - only case when the fibril finishes is in case
- *       of some error, so the error should probably be propagated from function
- *       usbhid_kbd_poll() to here and up.
- */
-static int usbhid_kbd_fibril(void *arg)
-{
-        if (arg == NULL) {
-                usb_log_error("No device!\n");
-                return EINVAL;
-        }
-        
-        usbhid_kbd_t *kbd_dev = (usbhid_kbd_t *)arg;
-
-        usbhid_kbd_poll(kbd_dev);
-        
-        // as there is another fibril using this device, so we must leave the
-        // structure to it, but mark it for destroying.
-        usbhid_kbd_mark_unusable(kbd_dev);
-        // at the end, properly destroy the KBD structure
-//      usbhid_kbd_free(&kbd_dev);
-//      assert(kbd_dev == NULL);
-
-        return EOK;
-}
-
-/*----------------------------------------------------------------------------*/
-/* API functions                                                              */
-/*----------------------------------------------------------------------------*/
-/**
- * Function for adding a new device of type USB/HID/keyboard.
- *
- * This functions initializes required structures from the device's descriptors
- * and starts new fibril for polling the keyboard for events and another one for
- * handling auto-repeat of keys.
- *
- * During initialization, the keyboard is switched into boot protocol, the idle
- * rate is set to 0 (infinity), resulting in the keyboard only reporting event
- * when a key is pressed or released. Finally, the LED lights are turned on 
- * according to the default setup of lock keys.
- *
- * @note By default, the keyboards is initialized with Num Lock turned on and 
- *       other locks turned off.
- * @note Currently supports only boot-protocol keyboards.
- *
- * @param dev Device to add.
- *
- * @retval EOK if successful.
- * @retval ENOMEM if there
- * @return Other error code inherited from one of functions usbhid_kbd_init(),
- *         ddf_fun_bind() and ddf_fun_add_to_class().
- *
- * @sa usbhid_kbd_fibril(), usbhid_kbd_repeat_fibril()
- */
-int usbhid_kbd_try_add_device(ddf_dev_t *dev)
-{
-        /*
-         * Create default function.
-         */
-        ddf_fun_t *kbd_fun = ddf_fun_create(dev, fun_exposed, "keyboard");
-        if (kbd_fun == NULL) {
-                usb_log_error("Could not create DDF function node.\n");
-                return ENOMEM;
-        }
-        
-        /* 
-         * Initialize device (get and process descriptors, get address, etc.)
-         */
-        usb_log_debug("Initializing USB/HID KBD device...\n");
-        
-        usbhid_kbd_t *kbd_dev = usbhid_kbd_new();
-        if (kbd_dev == NULL) {
-                usb_log_error("Error while creating USB/HID KBD device "
-                    "structure.\n");
-                ddf_fun_destroy(kbd_fun);
-                return ENOMEM;  // TODO: some other code??
-        }
-        
-        int rc = usbhid_kbd_init(kbd_dev, dev);
-        
-        if (rc != EOK) {
-                usb_log_error("Failed to initialize USB/HID KBD device.\n");
-                ddf_fun_destroy(kbd_fun);
-                usbhid_kbd_free(&kbd_dev);
-                return rc;
-        }       
-        
-        usb_log_debug("USB/HID KBD device structure initialized.\n");
-        
-        /*
-         * Store the initialized keyboard device and keyboard ops
-         * to the DDF function.
-         */
-        kbd_fun->driver_data = kbd_dev;
-        kbd_fun->ops = &keyboard_ops;
-
-        rc = ddf_fun_bind(kbd_fun);
-        if (rc != EOK) {
-                usb_log_error("Could not bind DDF function: %s.\n",
-                    str_error(rc));
-                // TODO: Can / should I destroy the DDF function?
-                ddf_fun_destroy(kbd_fun);
-                usbhid_kbd_free(&kbd_dev);
-                return rc;
-        }
-        
-        rc = ddf_fun_add_to_class(kbd_fun, "keyboard");
-        if (rc != EOK) {
-                usb_log_error(
-                    "Could not add DDF function to class 'keyboard': %s.\n",
-                    str_error(rc));
-                // TODO: Can / should I destroy the DDF function?
-                ddf_fun_destroy(kbd_fun);
-                usbhid_kbd_free(&kbd_dev);
-                return rc;
-        }
-        
-        /*
-         * Create new fibril for handling this keyboard
-         */
-        fid_t fid = fibril_create(usbhid_kbd_fibril, kbd_dev);
-        if (fid == 0) {
-                usb_log_error("Failed to start fibril for `%s' device.\n",
-                    dev->name);
-                return ENOMEM;
-        }
-        fibril_add_ready(fid);
-        
-        /*
-         * Create new fibril for auto-repeat
-         */
-        fid = fibril_create(usbhid_kbd_repeat_fibril, kbd_dev);
-        if (fid == 0) {
-                usb_log_error("Failed to start fibril for KBD auto-repeat");
-                return ENOMEM;
-        }
-        fibril_add_ready(fid);
-
-        (void)keyboard_ops;
-
-        /*
-         * Hurrah, device is initialized.
-         */
-        return EOK;
-}
-
-/*----------------------------------------------------------------------------*/
-
-int usbhid_kbd_is_usable(const usbhid_kbd_t *kbd_dev)
-{
-        return (kbd_dev->initialized == USBHID_KBD_STATUS_INITIALIZED);
+
+bool usb_kbd_polling_callback(usb_device_t *dev, uint8_t *buffer,
+     size_t buffer_size, void *arg)
+{
+        if (dev == NULL || buffer == NULL || arg == NULL) {
+                // do not continue polling (???)
+                return false;
+        }
+        
+        usb_kbd_t *kbd_dev = (usb_kbd_t *)arg;
+        
+        // TODO: add return value from this function
+        usb_kbd_process_data(kbd_dev, buffer, buffer_size);
+        
+        return true;
+}
+
+/*----------------------------------------------------------------------------*/
+
+void usb_kbd_polling_ended_callback(usb_device_t *dev, bool reason, 
+     void *arg)
+{
+        if (dev == NULL || arg == NULL) {
+                return;
+        }
+        
+        usb_kbd_t *kbd = (usb_kbd_t *)arg;
+        
+        usb_kbd_mark_unusable(kbd);
+}
+
+/*----------------------------------------------------------------------------*/
+
+int usb_kbd_is_initialized(const usb_kbd_t *kbd_dev)
+{
+        return (kbd_dev->initialized == USB_KBD_STATUS_INITIALIZED);
+}
+
+/*----------------------------------------------------------------------------*/
+
+int usb_kbd_is_ready_to_destroy(const usb_kbd_t *kbd_dev)
+{
+        return (kbd_dev->initialized == USB_KBD_STATUS_TO_DESTROY);
 }
 
@@ -998 +854 @@
  * @param kbd_dev Pointer to the structure to be destroyed.
  */
-void usbhid_kbd_free(usbhid_kbd_t **kbd_dev)
+void usb_kbd_free(usb_kbd_t **kbd_dev)
 {
         if (kbd_dev == NULL || *kbd_dev == NULL) {
@@ -1007 +863 @@
         async_hangup((*kbd_dev)->console_phone);
         
-        if ((*kbd_dev)->hid_dev != NULL) {
-                usbhid_dev_free(&(*kbd_dev)->hid_dev);
-                assert((*kbd_dev)->hid_dev == NULL);
-        }
+//      if ((*kbd_dev)->hid_dev != NULL) {
+//              usbhid_dev_free(&(*kbd_dev)->hid_dev);
+//              assert((*kbd_dev)->hid_dev == NULL);
+//      }
         
         if ((*kbd_dev)->repeat_mtx != NULL) {
@@ -1017 +873 @@
                 free((*kbd_dev)->repeat_mtx);
         }
+        
+        // destroy the parser
+        if ((*kbd_dev)->parser != NULL) {
+                usb_hid_free_report_parser((*kbd_dev)->parser);
+        }
+        
+        /* TODO: what about the USB device structure?? */
 
         free(*kbd_dev);

uspace/drv/usbkbd/kbddev.h

@@ -34 +34 @@
  */
 
-#ifndef USBHID_KBDDEV_H_
-#define USBHID_KBDDEV_H_
+#ifndef USB_KBDDEV_H_
+#define USB_KBDDEV_H_
 
 #include <stdint.h>
@@ -45 +45 @@
 #include <ddf/driver.h>
 #include <usb/pipes.h>
+#include <usb/devdrv.h>
 
-#include "hiddev.h"
+#include "kbdrepeat.h"
 
 /*----------------------------------------------------------------------------*/
-/**
- * Structure for keeping information needed for auto-repeat of keys.
- */
-typedef struct {
-        /** Last pressed key. */
-        unsigned int key_new;
-        /** Key to be repeated. */
-        unsigned int key_repeated;
-        /** Delay before first repeat in microseconds. */
-        unsigned int delay_before;
-        /** Delay between repeats in microseconds. */
-        unsigned int delay_between;
-} usbhid_kbd_repeat_t;
-
 /**
  * USB/HID keyboard device type.
@@ -75 +62 @@
  *       being device-specific.
  */
-typedef struct {
-        /** Structure holding generic USB/HID device information. */
-        usbhid_dev_t *hid_dev;
+typedef struct usb_kbd_t {
+        /** Structure holding generic USB device information. */
+        //usbhid_dev_t *hid_dev;
+        usb_device_t *usb_dev;
         
         /** Currently pressed keys (not translated to key codes). */
@@ -96 +84 @@
         
         /** Information for auto-repeat of keys. */
-        usbhid_kbd_repeat_t repeat;
+        usb_kbd_repeat_t repeat;
         
         /** Mutex for accessing the information about auto-repeat. */
         fibril_mutex_t *repeat_mtx;
+        
+        /** Report descriptor. */
+        uint8_t *report_desc;
+
+        /** Report descriptor size. */
+        size_t report_desc_size;
+
+        /** HID Report parser. */
+        usb_hid_report_parser_t *parser;
         
         /** State of the structure (for checking before use). 
@@ -108 +105 @@
          */
         int initialized;
-} usbhid_kbd_t;
+} usb_kbd_t;
 
 /*----------------------------------------------------------------------------*/
 
-int usbhid_kbd_try_add_device(ddf_dev_t *dev);
+enum {
+        USB_KBD_POLL_EP_NO = 0,
+        USB_KBD_POLL_EP_COUNT = 1
+};
 
-int usbhid_kbd_is_usable(const usbhid_kbd_t *kbd_dev);
+usb_endpoint_description_t *usb_kbd_endpoints[USB_KBD_POLL_EP_COUNT + 1];
 
-void usbhid_kbd_free(usbhid_kbd_t **kbd_dev);
+ddf_dev_ops_t keyboard_ops;
 
-void usbhid_kbd_push_ev(usbhid_kbd_t *kbd_dev, int type, unsigned int key);
+/*----------------------------------------------------------------------------*/
 
-#endif /* USBHID_KBDDEV_H_ */
+usb_kbd_t *usb_kbd_new(void);
+
+int usb_kbd_init(usb_kbd_t *kbd_dev, usb_device_t *dev);
+
+bool usb_kbd_polling_callback(usb_device_t *dev, uint8_t *buffer,
+     size_t buffer_size, void *arg);
+
+void usb_kbd_polling_ended_callback(usb_device_t *dev, bool reason, 
+     void *arg);
+
+int usb_kbd_is_initialized(const usb_kbd_t *kbd_dev);
+
+int usb_kbd_is_ready_to_destroy(const usb_kbd_t *kbd_dev);
+
+void usb_kbd_free(usb_kbd_t **kbd_dev);
+
+void usb_kbd_push_ev(usb_kbd_t *kbd_dev, int type, unsigned int key);
+
+#endif /* USB_KBDDEV_H_ */
 
 /**

uspace/drv/usbkbd/kbdrepeat.c

@@ -62 +62 @@
  * 
  * If the currently repeated key is not pressed any more (
- * usbhid_kbd_repeat_stop() was called), it stops repeating it and starts 
+ * usb_kbd_repeat_stop() was called), it stops repeating it and starts 
  * checking again.
  *
@@ -70 +70 @@
  * @param kbd Keyboard device structure.
  */
-static void usbhid_kbd_repeat_loop(usbhid_kbd_t *kbd)
+static void usb_kbd_repeat_loop(usb_kbd_t *kbd)
 {
         unsigned int delay = 0;
@@ -78 +78 @@
         while (true) {
                 // check if the kbd structure is usable
-                if (!usbhid_kbd_is_usable(kbd)) {
-                        usbhid_kbd_free(&kbd);
-                        assert(kbd == NULL);
+                if (!usb_kbd_is_initialized(kbd)) {
+                        if (usb_kbd_is_ready_to_destroy(kbd)) {
+                                usb_kbd_free(&kbd);
+                                assert(kbd == NULL);
+                        }
                         return;
                 }
@@ -90 +92 @@
                                 usb_log_debug2("Repeating key: %u.\n", 
                                     kbd->repeat.key_repeated);
-                                usbhid_kbd_push_ev(kbd, KEY_PRESS, 
+                                usb_kbd_push_ev(kbd, KEY_PRESS, 
                                     kbd->repeat.key_repeated);
                                 delay = kbd->repeat.delay_between;
@@ -125 +127 @@
  * @retval EINVAL if no argument is supplied.
  */
-int usbhid_kbd_repeat_fibril(void *arg)
+int usb_kbd_repeat_fibril(void *arg)
 {
         usb_log_debug("Autorepeat fibril spawned.\n");
@@ -134 +136 @@
         }
         
-        usbhid_kbd_t *kbd = (usbhid_kbd_t *)arg;
+        usb_kbd_t *kbd = (usb_kbd_t *)arg;
         
-        usbhid_kbd_repeat_loop(kbd);
+        usb_kbd_repeat_loop(kbd);
         
         return EOK;
@@ -152 +154 @@
  * @param key Key to start repeating.
  */
-void usbhid_kbd_repeat_start(usbhid_kbd_t *kbd, unsigned int key)
+void usb_kbd_repeat_start(usb_kbd_t *kbd, unsigned int key)
 {
         fibril_mutex_lock(kbd->repeat_mtx);
@@ -170 +172 @@
  * @param key Key to stop repeating.
  */
-void usbhid_kbd_repeat_stop(usbhid_kbd_t *kbd, unsigned int key)
+void usb_kbd_repeat_stop(usb_kbd_t *kbd, unsigned int key)
 {
         fibril_mutex_lock(kbd->repeat_mtx);

uspace/drv/usbkbd/kbdrepeat.h

@@ -34 +34 @@
  */
 
-#ifndef USBHID_KBDREPEAT_H_
-#define USBHID_KBDREPEAT_H_
+#ifndef USB_KBDREPEAT_H_
+#define USB_KBDREPEAT_H_
 
-#include "kbddev.h"
+struct usb_kbd_t;
+
+/*----------------------------------------------------------------------------*/
+/**
+ * Structure for keeping information needed for auto-repeat of keys.
+ */
+typedef struct {
+        /** Last pressed key. */
+        unsigned int key_new;
+        /** Key to be repeated. */
+        unsigned int key_repeated;
+        /** Delay before first repeat in microseconds. */
+        unsigned int delay_before;
+        /** Delay between repeats in microseconds. */
+        unsigned int delay_between;
+} usb_kbd_repeat_t;
 
 /*----------------------------------------------------------------------------*/
 
-int usbhid_kbd_repeat_fibril(void *arg);
+int usb_kbd_repeat_fibril(void *arg);
 
-void usbhid_kbd_repeat_start(usbhid_kbd_t *kbd, unsigned int key);
+void usb_kbd_repeat_start(struct usb_kbd_t *kbd, unsigned int key);
 
-void usbhid_kbd_repeat_stop(usbhid_kbd_t *kbd, unsigned int key);
+void usb_kbd_repeat_stop(struct usb_kbd_t *kbd, unsigned int key);
 
-#endif /* USBHID_KBDREPEAT_H_ */
+#endif /* USB_KBDREPEAT_H_ */
 
 /**

uspace/drv/usbkbd/layout.h

@@ -36 +36 @@
  */
 
-#ifndef USBHID_LAYOUT_H_
-#define USBHID_LAYOUT_H_
+#ifndef USB_KBD_LAYOUT_H_
+#define USB_KBD_LAYOUT_H_
 
 #include <sys/types.h>