Changeset 095b2017 in mainline

Timestamp:

2011-03-25T17:13:02Z (14 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

Files:

• boot/arch/amd64/Makefile.inc (modified) (1 diff)
• uspace/Makefile (modified) (2 diffs)
• uspace/app/usbinfo/info.c (modified) (1 diff)
• uspace/app/usbinfo/main.c (modified) (3 diffs)
• uspace/app/usbinfo/usbinfo.h (modified) (1 diff)
• uspace/drv/ohci/batch.c (modified) (1 diff)
• uspace/drv/ohci/root_hub.c (modified) (2 diffs)
• uspace/drv/ohci/root_hub.h (modified) (1 diff)
• uspace/drv/usbhid/descdump.c (deleted)
• uspace/drv/usbhid/hiddev.c (deleted)
• uspace/drv/usbhid/hiddev.h (deleted)
• uspace/drv/usbhid/main.c (deleted)
• uspace/drv/usbhub/port_status.h (modified) (2 diffs)
• uspace/drv/usbhub/usbhub.c (modified) (1 diff)
• uspace/drv/usbkbd/Makefile (moved) (moved from uspace/drv/usbhid/Makefile ) (2 diffs)
• uspace/drv/usbkbd/conv.c (moved) (moved from uspace/drv/usbhid/conv.c )
• uspace/drv/usbkbd/conv.h (moved) (moved from uspace/drv/usbhid/conv.h ) (1 diff)
• uspace/drv/usbkbd/kbd.h (moved) (moved from uspace/drv/usbhid/kbd.h )
• uspace/drv/usbkbd/kbddev.c (moved) (moved from uspace/drv/usbhid/kbddev.c ) (33 diffs)
• uspace/drv/usbkbd/kbddev.h (moved) (moved from uspace/drv/usbhid/kbddev.h ) (5 diffs)
• uspace/drv/usbkbd/kbdrepeat.c (moved) (moved from uspace/drv/usbhid/kbdrepeat.c ) (8 diffs)
• uspace/drv/usbkbd/kbdrepeat.h (moved) (moved from uspace/drv/usbhid/kbdrepeat.h ) (1 diff)
• uspace/drv/usbkbd/layout.h (moved) (moved from uspace/drv/usbhid/layout.h ) (1 diff)
• uspace/drv/usbkbd/main.c (added)
• uspace/drv/usbkbd/usbkbd.ma (moved) (moved from uspace/drv/usbhid/usbhid.ma )
• uspace/lib/usb/Makefile (modified) (1 diff)
• uspace/lib/usb/include/usb/classes/hidparser.h (modified) (6 diffs)
• uspace/lib/usb/include/usb/classes/hidreport.h (moved) (moved from uspace/drv/usbhid/descdump.h ) (2 diffs)
• uspace/lib/usb/include/usb/classes/hidreq.h (moved) (moved from uspace/drv/usbhid/hidreq.h ) (2 diffs)
• uspace/lib/usb/include/usb/request.h (modified) (1 diff)
• uspace/lib/usb/src/hidparser.c (modified) (25 diffs)
• uspace/lib/usb/src/hidreport.c (added)
• uspace/lib/usb/src/hidreq.c (moved) (moved from uspace/drv/usbhid/hidreq.c ) (14 diffs)

boot/arch/amd64/Makefile.inc

@@ -49 +49 @@
         usbflbk \
         usbhub \
-        usbhid \
+        usbkbd \
         usbmid \
         usbmouse \

uspace/Makefile

@@ -122 +122 @@
                 drv/uhci-rhd \
                 drv/usbflbk \
-                drv/usbhid \
+                drv/usbkbd \
                 drv/usbhub \
                 drv/usbmid \
@@ -142 +142 @@
                 drv/uhci-rhd \
                 drv/usbflbk \
-                drv/usbhid \
+                drv/usbkbd \
                 drv/usbhub \
                 drv/usbmid \

uspace/app/usbinfo/info.c

@@ -294 +294 @@
 }
 
+
+void dump_status(usbinfo_device_t *dev)
+{
+        int rc;
+        uint16_t device_status = 0;
+        uint16_t ctrl_pipe_status = 0;
+
+        /* Device status first. */
+        rc = usb_request_get_status(&dev->ctrl_pipe,
+            USB_REQUEST_RECIPIENT_DEVICE, 0,
+            &device_status);
+        if (rc != EOK) {
+                printf("%sFailed to get device status: %s.\n",
+                    get_indent(0), str_error(rc));
+                goto try_ctrl_pipe_status;
+        }
+
+        printf("%sDevice status 0x%04x: power=%s, remote-wakeup=%s.\n",
+            get_indent(0),
+            device_status,
+            device_status & USB_DEVICE_STATUS_SELF_POWERED ? "self" : "bus",
+            device_status & USB_DEVICE_STATUS_REMOTE_WAKEUP ? "yes" : "no");
+
+        /* Interface is not interesting, skipping ;-). */
+
+        /* Control endpoint zero. */
+try_ctrl_pipe_status:
+        rc = usb_request_get_status(&dev->ctrl_pipe,
+            USB_REQUEST_RECIPIENT_ENDPOINT, 0,
+            &ctrl_pipe_status);
+        if (rc != EOK) {
+                printf("%sFailed to get control endpoint status: %s.\n",
+                    get_indent(0), str_error(rc));
+                goto leave;
+        }
+
+        printf("%sControl endpoint zero status %04X: halted=%s.\n",
+            get_indent(0),
+            ctrl_pipe_status,
+            ctrl_pipe_status & USB_ENDPOINT_STATUS_HALTED ? "yes" : "no");
+
+leave:
+        return;
+}
+
 /** @}
  */

uspace/app/usbinfo/main.c

@@ -136 +136 @@
         _OPTION("-T --descriptor-tree-full", "Print detailed descriptor tree");
         _OPTION("-s --strings", "Try to print all string descriptors.");
+        _OPTION("-S --status", "Get status of the device.");
 
         printf("\n");
@@ -152 +153 @@
         {"descriptor-tree-full", no_argument, NULL, 'T'},
         {"strings", no_argument, NULL, 's'},
+        {"status", no_argument, NULL, 'S'},
         {0, 0, NULL, 0}
 };
-static const char *short_options = "himtTs";
+static const char *short_options = "himtTsS";
 
 static usbinfo_action_t actions[] = {
@@ -180 +182 @@
                 .opt = 's',
                 .action = dump_strings,
+                .active = false
+        },
+        {
+                .opt = 'S',
+                .action = dump_status,
                 .active = false
         },

uspace/app/usbinfo/usbinfo.h

@@ -84 +84 @@
 void dump_descriptor_tree_full(usbinfo_device_t *);
 void dump_strings(usbinfo_device_t *);
+void dump_status(usbinfo_device_t *);
 
 

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>

uspace/lib/usb/Makefile

@@ -50 +50 @@
         src/usb.c \
         src/usbdevice.c \
+        src/hidreq.c \
+        src/hidreport.c \
         src/host/device_keeper.c \
         src/host/batch.c

uspace/lib/usb/include/usb/classes/hidparser.h

@@ -70 +70 @@
  * Description of path of usage pages and usages in report descriptor
  */
+#define USB_HID_PATH_COMPARE_STRICT                             0
+#define USB_HID_PATH_COMPARE_END                                1
+#define USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY    4
+
 typedef struct {
         int32_t usage_page;
+        int32_t usage;
+
+        link_t link;
+} usb_hid_report_usage_path_t;
+
+typedef struct {
+        int depth;      
+        link_t link;
 } usb_hid_report_path_t;
 
@@ -79 +91 @@
 typedef struct {
         int32_t id;
-        int32_t usage_page;
-        int32_t usage;  
         int32_t usage_minimum;
         int32_t usage_maximum;
@@ -107 +117 @@
         uint8_t item_flags;
 
+        usb_hid_report_path_t *usage_path;
         link_t link;
 } usb_hid_report_item_t;
@@ -117 +128 @@
         link_t feature;
 } usb_hid_report_parser_t;      
-
 
 
@@ -194 +204 @@
 int usb_hid_parse_report(const usb_hid_report_parser_t *parser,  
     const uint8_t *data, size_t size,
+    usb_hid_report_path_t *path, int flags,
     const usb_hid_report_in_callbacks_t *callbacks, void *arg);
 
 int usb_hid_report_input_length(const usb_hid_report_parser_t *parser,
-        const usb_hid_report_path_t *path);
+        usb_hid_report_path_t *path, int flags);
 
 
@@ -204 +215 @@
 void usb_hid_descriptor_print(usb_hid_report_parser_t *parser);
 
+/* usage path functions */
+usb_hid_report_path_t *usb_hid_report_path(void);
+void usb_hid_report_path_free(usb_hid_report_path_t *path);
+int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path, int32_t usage_page, int32_t usage);
+void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path);
+void usb_hid_report_null_last_item(usb_hid_report_path_t *usage_path);
+void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path, int32_t tag, int32_t data);
+int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path, usb_hid_report_path_t *path, int flags);
+int     usb_hid_report_path_clone(usb_hid_report_path_t *new_usage_path, usb_hid_report_path_t *usage_path);
+
+
+// output
+//      - funkce co vrati cesty poli v output reportu
+//      - funkce co pro danou cestu nastavi data
+//      - finalize
+
 #endif
 /**

uspace/lib/usb/include/usb/classes/hidreport.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2010 Lubos Slovak
+ * Copyright (c) 2011 Lubos Slovak
  * All rights reserved.
  *
@@ -27 +27 @@
  */
 
-/** @addtogroup drvusbhid
+/** @addtogroup libusb
  * @{
  */
 /** @file
- * Descriptor dumping.
+ * USB HID report parser initialization from descriptors.
  */
 
-#ifndef USBHID_DESCDUMP_H_
-#define USBHID_DESCDUMP_H_
+#ifndef LIBUSB_HIDREPORT_H_
+#define LIBUSB_HIDREPORT_H_
 
-#include <usb/descriptor.h>
-#include <usb/classes/hid.h>
+#include <usb/devdrv.h>
+#include <usb/classes/hidparser.h>
 
-void dump_standard_configuration_descriptor(
-    int index, const usb_standard_configuration_descriptor_t *d);
+/**
+ * Retrieves the Report descriptor from the USB device and initializes the
+ * report parser.
+ *
+ * \param dev USB device representing a HID device.
+ * \param parser HID Report parser.
+ *
+ * \retval EOK if successful.
+ * \retval EINVAL if one of the parameters is not given (is NULL).
+ * \retval ENOENT if there are some descriptors missing.
+ * \retval ENOMEM if an error with allocation occured.
+ * \retval EINVAL if the Report descriptor's size does not match the size 
+ *         from the interface descriptor.
+ * \return Other value inherited from function usb_pipe_start_session(),
+ *         usb_pipe_end_session() or usb_request_get_descriptor().
+ */
+int usb_hid_process_report_descriptor(usb_device_t *dev, 
+    usb_hid_report_parser_t *parser);
 
-void dump_standard_interface_descriptor(
-    const usb_standard_interface_descriptor_t *d);
-
-void dump_standard_endpoint_descriptor(
-    const usb_standard_endpoint_descriptor_t *d);
-
-void dump_standard_hid_descriptor_header(
-    const usb_standard_hid_descriptor_t *d);
-
-void dump_standard_hid_class_descriptor_info(
-    const usb_standard_hid_class_descriptor_info_t *d);
-
-void dump_hid_class_descriptor(int index, uint8_t type, 
-    const uint8_t *d, size_t size);
-
-#endif /* USBHID_DESCDUMP_H_ */
+#endif /* LIBUSB_HIDREPORT_H_ */
 
 /**

uspace/lib/usb/include/usb/classes/hidreq.h

@@ -27 +27 @@
  */
 
-/** @addtogroup drvusbhid
+/** @addtogroup libusb
  * @{
  */
@@ -34 +34 @@
  */
 
-#ifndef USBHID_HIDREQ_H_
-#define USBHID_HIDREQ_H_
+#ifndef USB_KBD_HIDREQ_H_
+#define USB_KBD_HIDREQ_H_
 
 #include <stdint.h>
 
 #include <usb/classes/hid.h>
-
-#include "hiddev.h"
+#include <usb/pipes.h>
 
 /*----------------------------------------------------------------------------*/
 
-int usbhid_req_set_report(usbhid_dev_t *hid_dev,
+int usbhid_req_set_report(usb_pipe_t *ctrl_pipe, int iface_no,
     usb_hid_report_type_t type, uint8_t *buffer, size_t buf_size);
 
-int usbhid_req_set_protocol(usbhid_dev_t *hid_dev, usb_hid_protocol_t protocol);
+int usbhid_req_set_protocol(usb_pipe_t *ctrl_pipe, int iface_no, 
+    usb_hid_protocol_t protocol);
 
-int usbhid_req_set_idle(usbhid_dev_t *hid_dev, uint8_t duration);
+int usbhid_req_set_idle(usb_pipe_t *ctrl_pipe, int iface_no, uint8_t duration);
 
-int usbhid_req_get_report(usbhid_dev_t *hid_dev, usb_hid_report_type_t type, 
-    uint8_t *buffer, size_t buf_size, size_t *actual_size);
+int usbhid_req_get_report(usb_pipe_t *ctrl_pipe, int iface_no, 
+    usb_hid_report_type_t type, uint8_t *buffer, size_t buf_size, 
+    size_t *actual_size);
 
-int usbhid_req_get_protocol(usbhid_dev_t *hid_dev, usb_hid_protocol_t *protocol);
+int usbhid_req_get_protocol(usb_pipe_t *ctrl_pipe, int iface_no, 
+    usb_hid_protocol_t *protocol);
 
-int usbhid_req_get_idle(usbhid_dev_t *hid_dev, uint8_t *duration);
+int usbhid_req_get_idle(usb_pipe_t *ctrl_pipe, int iface_no, uint8_t *duration);
 
 /*----------------------------------------------------------------------------*/
 
-#endif /* USBHID_HIDREQ_H_ */
+#endif /* USB_KBD_HIDREQ_H_ */
 
 /**

uspace/lib/usb/include/usb/request.h

@@ -41 +41 @@
 #include <usb/pipes.h>
 #include <usb/descriptor.h>
+
+/** USB device status - device is self powered (opposed to bus powered). */
+#define USB_DEVICE_STATUS_SELF_POWERED ((uint16_t)(1 << 0))
+
+/** USB device status - remote wake-up signaling is enabled. */
+#define USB_DEVICE_STATUS_REMOTE_WAKEUP ((uint16_t)(1 << 1))
+
+/** USB endpoint status - endpoint is halted (stalled). */
+#define USB_ENDPOINT_STATUS_HALTED ((uint16_t)(1 << 0))
 
 /** Standard device request. */

uspace/lib/usb/src/hidparser.c

@@ -47 +47 @@
 
 int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data, size_t item_size,
-                             usb_hid_report_item_t *report_item);
+                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
 int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, size_t item_size,
-                             usb_hid_report_item_t *report_item);
+                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
 int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, size_t item_size,
-                             usb_hid_report_item_t *report_item);
+                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
 int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data, size_t item_size,
-                             usb_hid_report_item_t *report_item);
+                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
 
 void usb_hid_descriptor_print_list(link_t *head);
@@ -63 +63 @@
 int usb_pow(int a, int b);
 
+
 int usb_pow(int a, int b)
 {
@@ -84 +85 @@
 {
    if(parser == NULL) {
-        return -1;
+        return EINVAL;
    }
 
@@ -110 +111 @@
         int ret;
         usb_hid_report_item_t *report_item=0;
-        usb_hid_report_item_t *new_report_item;
+        usb_hid_report_item_t *new_report_item; 
+        usb_hid_report_path_t *usage_path;
+        usb_hid_report_path_t *tmp_usage_path;
 
         size_t offset_input=0;
@@ -117 +120 @@
         
 
+        /* parser structure initialization*/
+        if(usb_hid_parser_init(parser) != EOK) {
+                return EINVAL;
+        }
+        
+
+        /*report item initialization*/
         if(!(report_item=malloc(sizeof(usb_hid_report_item_t)))){
                 return ENOMEM;
         }
         memset(report_item, 0, sizeof(usb_hid_report_item_t));
-        
-        link_initialize(&(report_item->link));  
-
+        list_initialize(&(report_item->link));  
+
+        /* usage path context initialization */
+        if(!(usage_path=usb_hid_report_path())){
+                return ENOMEM;
+        }
+        
         while(i<size){  
                 if(!USB_HID_ITEM_IS_LONG(data[i])){
 
                         if((i+USB_HID_ITEM_SIZE(data[i]))>= size){
-                                return -1; // TODO ERROR CODE
+                                return EINVAL; // TODO ERROR CODE
                         }
                         
@@ -141 +155 @@
                         
                         ret = usb_hid_report_parse_tag(tag,class,data+i+1,
-                                                 item_size,report_item);
+                                                       item_size,report_item, usage_path);
                         usb_log_debug2("ret: %u\n", ret);
                         switch(ret){
                                 case USB_HID_NEW_REPORT_ITEM:
                                         // store report item to report and create the new one
-                                        usb_log_debug("\nNEW REPORT ITEM: %X",tag);
+                                        usb_log_debug("\nNEW REPORT ITEM: %X",ret);
+
+                                        // store current usage path
+                                        report_item->usage_path = usage_path;
+
+                                        // new current usage path 
+                                        tmp_usage_path = usb_hid_report_path();
+                                        
+                                        // copy old path to the new one
+                                        usb_hid_report_path_clone(tmp_usage_path, usage_path);
+
+                                        // swap
+                                        usage_path = tmp_usage_path;
+                                        tmp_usage_path = NULL;
+
                                         
                                         switch(tag) {
@@ -184 +212 @@
                                         link_initialize(&(new_report_item->link));
                                         report_item = new_report_item;
-                                        
+                                                                                
                                         break;
                                 case USB_HID_REPORT_TAG_PUSH:
@@ -284 +312 @@
  */
 int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data, size_t item_size,
-                             usb_hid_report_item_t *report_item)
+                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
 {       
         int ret;
@@ -291 +319 @@
                 case USB_HID_TAG_CLASS_MAIN:
 
-                        if((ret=usb_hid_report_parse_main_tag(tag,data,item_size,report_item)) == EOK) {
+                        if((ret=usb_hid_report_parse_main_tag(tag,data,item_size,report_item, usage_path)) == EOK) {
                                 return USB_HID_NEW_REPORT_ITEM;
                         }
@@ -301 +329 @@
 
                 case USB_HID_TAG_CLASS_GLOBAL:  
-                        return usb_hid_report_parse_global_tag(tag,data,item_size,report_item);
+                        return usb_hid_report_parse_global_tag(tag,data,item_size,report_item, usage_path);
                         break;
 
                 case USB_HID_TAG_CLASS_LOCAL:                   
-                        return usb_hid_report_parse_local_tag(tag,data,item_size,report_item);
+                        return usb_hid_report_parse_local_tag(tag,data,item_size,report_item, usage_path);
                         break;
                 default:
@@ -323 +351 @@
 
 int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, size_t item_size,
-                             usb_hid_report_item_t *report_item)
-{
+                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
+{               
         switch(tag)
         {
@@ -335 +363 @@
                         
                 case USB_HID_REPORT_TAG_COLLECTION:
-                        // TODO
+                        usb_hid_report_path_append_item(usage_path, 0, 0);
+                                                
                         return USB_HID_NO_ACTION;
                         break;
                         
                 case USB_HID_REPORT_TAG_END_COLLECTION:
-                        /* should be ignored */
+                        // TODO
+                        // znici posledni uroven ve vsech usage paths
+                        // otazka jestli nema nicit dve, respektive novou posledni vynulovat?
+                        usb_hid_report_remove_last_item(usage_path);
                         return USB_HID_NO_ACTION;
                         break;
@@ -361 +393 @@
 
 int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, size_t item_size,
-                             usb_hid_report_item_t *report_item)
+                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
 {
         // TODO take care about the bit length of data
@@ -367 +399 @@
         {
                 case USB_HID_REPORT_TAG_USAGE_PAGE:
-                        report_item->usage_page = usb_hid_report_tag_data_int32(data,item_size);
+                        // zmeni to jenom v poslednim poli aktualni usage path
+                        usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_GLOBAL,
+                                usb_hid_report_tag_data_int32(data,item_size));
                         break;
                 case USB_HID_REPORT_TAG_LOGICAL_MINIMUM:
@@ -418 +452 @@
  */
 int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data, size_t item_size,
-                             usb_hid_report_item_t *report_item)
+                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
 {
         switch(tag)
         {
                 case USB_HID_REPORT_TAG_USAGE:
-                        report_item->usage = usb_hid_report_tag_data_int32(data,item_size);
+                        usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_LOCAL,
+                                usb_hid_report_tag_data_int32(data,item_size));
                         break;
                 case USB_HID_REPORT_TAG_USAGE_MINIMUM:
@@ -491 +526 @@
 {
         usb_hid_report_item_t *report_item;
+        usb_hid_report_usage_path_t *path_item;
+        link_t *path;
         link_t *item;
         
@@ -507 +544 @@
                 usb_log_debug("\tCONSTANT/VAR: %X\n", USB_HID_ITEM_FLAG_CONSTANT(report_item->item_flags));
                 usb_log_debug("\tVARIABLE/ARRAY: %X\n", USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags));
-                usb_log_debug("\tUSAGE: %X\n", report_item->usage);
-                usb_log_debug("\tUSAGE PAGE: %X\n", report_item->usage_page);
+                usb_log_debug("\tUSAGE PATH:\n");
+
+                path = report_item->usage_path->link.next;
+                while(path != &report_item->usage_path->link)   {
+                        path_item = list_get_instance(path, usb_hid_report_usage_path_t, link);
+                        usb_log_debug("\t\tUSAGE PAGE: %X, USAGE: %X\n", path_item->usage_page, path_item->usage);
+                        path = path->next;
+                }
+                
+                
+//              usb_log_debug("\tUSAGE: %X\n", report_item->usage);
+//              usb_log_debug("\tUSAGE PAGE: %X\n", report_item->usage_page);
                 usb_log_debug("\tLOGMIN: %X\n", report_item->logical_minimum);
                 usb_log_debug("\tLOGMAX: %X\n", report_item->logical_maximum);          
@@ -530 +577 @@
 void usb_hid_descriptor_print(usb_hid_report_parser_t *parser)
 {
+        if(parser == NULL) {
+                return;
+        }
+        
         usb_log_debug("INPUT:\n");
         usb_hid_descriptor_print_list(&parser->input);
@@ -561 +612 @@
         
             report_item = list_get_instance(next, usb_hid_report_item_t, link);
+
+                while(!list_empty(&report_item->usage_path->link)) {
+                        usb_hid_report_remove_last_item(report_item->usage_path);
+                }
+
+                
             next = next->next;
             
@@ -600 +657 @@
 int usb_hid_parse_report(const usb_hid_report_parser_t *parser,  
     const uint8_t *data, size_t size,
+    usb_hid_report_path_t *path, int flags,
     const usb_hid_report_in_callbacks_t *callbacks, void *arg)
 {
@@ -615 +673 @@
         size_t j=0;
 
+        if(parser == NULL) {
+                return EINVAL;
+        }
+
+        
         // get the size of result keycodes array
-        usb_hid_report_path_t path;
-        path.usage_page = BAD_HACK_USAGE_PAGE;
-        key_count = usb_hid_report_input_length(parser, &path);
+        key_count = usb_hid_report_input_length(parser, path, flags);
 
         if(!(keys = malloc(sizeof(uint8_t) * key_count))){
@@ -629 +690 @@
 
                 item = list_get_instance(list_item, usb_hid_report_item_t, link);
-                if(!USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) &&
-                   (item->usage_page == path.usage_page)) {
+                if(!USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) && 
+                   (usb_hid_report_compare_usage_path(item->usage_path, path, flags) == EOK)) {
                         for(j=0; j<(size_t)(item->count); j++) {
                                 if((USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0) ||
@@ -640 +701 @@
                                         // bitmapa
                                         if((item_value = usb_hid_translate_data(item, data, j)) != 0) {
-                                                keys[i++] = j + item->usage_minimum;
+                                                keys[i++] = (item->count - 1 - j) + item->usage_minimum;
                                         }
                                         else {
@@ -736 +797 @@
 
 int usb_hid_report_input_length(const usb_hid_report_parser_t *parser,
-        const usb_hid_report_path_t *path)
-{
+        usb_hid_report_path_t *path, int flags)
+{       
         int ret = 0;
         link_t *item;
         usb_hid_report_item_t *report_item;
 
+        if(parser == NULL) {
+                return EINVAL;
+        }
+        
         item = (&parser->input)->next;
         while(&parser->input != item) {
                 report_item = list_get_instance(item, usb_hid_report_item_t, link);
                 if(!USB_HID_ITEM_FLAG_CONSTANT(report_item->item_flags) &&
-                   (report_item->usage_page == path->usage_page)) {
+                   (usb_hid_report_compare_usage_path(report_item->usage_path, path, flags) == EOK)) {
                         ret += report_item->count;
                 }
@@ -757 +822 @@
 
 
+/**
+ * 
+ */
+int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path, 
+                                    int32_t usage_page, int32_t usage)
+{       
+        usb_hid_report_usage_path_t *item;
+
+        if(!(item=malloc(sizeof(usb_hid_report_usage_path_t)))) {
+                return ENOMEM;
+        }
+        list_initialize(&item->link);
+
+        item->usage = usage;
+        item->usage_page = usage_page;
+        
+        list_append (&usage_path->link, &item->link);
+        usage_path->depth++;
+        return EOK;
+}
+
+/**
+ *
+ */
+void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path)
+{
+        usb_hid_report_usage_path_t *item;
+        
+        if(!list_empty(&usage_path->link)){
+                item = list_get_instance(usage_path->link.prev, usb_hid_report_usage_path_t, link);             
+                list_remove(usage_path->link.prev);
+                usage_path->depth--;
+                free(item);
+        }
+}
+
+/**
+ *
+ */
+void usb_hid_report_null_last_item(usb_hid_report_path_t *usage_path)
+{
+        usb_hid_report_usage_path_t *item;
+        
+        if(!list_empty(&usage_path->link)){     
+                item = list_get_instance(usage_path->link.prev, usb_hid_report_usage_path_t, link);
+                memset(item, 0, sizeof(usb_hid_report_usage_path_t));
+        }
+}
+
+/**
+ *
+ */
+void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path, int32_t tag, int32_t data)
+{
+        usb_hid_report_usage_path_t *item;
+        
+        if(!list_empty(&usage_path->link)){     
+                item = list_get_instance(usage_path->link.prev, usb_hid_report_usage_path_t, link);
+
+                switch(tag) {
+                        case USB_HID_TAG_CLASS_GLOBAL:
+                                item->usage_page = data;
+                                break;
+                        case USB_HID_TAG_CLASS_LOCAL:
+                                item->usage = data;
+                                break;
+                }
+        }
+        
+}
+
+/**
+ *
+ */
+int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path, 
+                                      usb_hid_report_path_t *path,
+                                      int flags)
+{
+        usb_hid_report_usage_path_t *report_item;
+        usb_hid_report_usage_path_t *path_item;
+
+        link_t *report_link;
+        link_t *path_link;
+
+        int only_page;
+
+        if(path->depth == 0){
+                return EOK;
+        }
+
+
+        if((only_page = flags & USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY) != 0){
+                flags -= USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY;
+        }
+        
+        switch(flags){
+                /* path must be completly identical */
+                case USB_HID_PATH_COMPARE_STRICT:
+                                if(report_path->depth != path->depth){
+                                        return 1;
+                                }
+
+                                report_link = report_path->link.next;
+                                path_link = path->link.next;
+                        
+                                while((report_link != &report_path->link) && (path_link != &path->link)) {
+                                        report_item = list_get_instance(report_link, usb_hid_report_usage_path_t, link);
+                                        path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link);            
+
+                                        if((report_item->usage_page != path_item->usage_page) || 
+                                           ((only_page == 0) && (report_item->usage != path_item->usage))) {
+                                                   return 1;
+                                        } else {
+                                                report_link = report_link->next;
+                                                path_link = path_link->next;                    
+                                        }
+                        
+                                }
+
+                                if((report_link == &report_path->link) && (path_link == &path->link)) {
+                                        return EOK;
+                                }
+                                else {
+                                        return 1;
+                                }                                               
+                        break;
+
+                /* given path must be the end of the report one*/
+                case USB_HID_PATH_COMPARE_END:
+                                report_link = report_path->link.prev;
+                                path_link = path->link.prev;
+
+                                if(list_empty(&path->link)){
+                                        return EOK;
+                                }
+                        
+                                while((report_link != &report_path->link) && (path_link != &path->link)) {
+                                        report_item = list_get_instance(report_link, usb_hid_report_usage_path_t, link);
+                                        path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link);            
+
+                                        if((report_item->usage_page != path_item->usage_page) || 
+                                           ((only_page == 0) && (report_item->usage != path_item->usage))) {
+                                                   return 1;
+                                        } else {
+                                                report_link = report_link->prev;
+                                                path_link = path_link->prev;                    
+                                        }
+                        
+                                }
+
+                                if(path_link == &path->link) {
+                                        return EOK;
+                                }
+                                else {
+                                        return 1;
+                                }                                               
+                        
+                        break;
+
+                default:
+                        return EINVAL;
+        }
+        
+        
+        
+        
+}
+
+/**
+ *
+ */
+usb_hid_report_path_t *usb_hid_report_path(void)
+{
+        usb_hid_report_path_t *path;
+        path = malloc(sizeof(usb_hid_report_path_t));
+        if(!path){
+                return NULL;
+        }
+        else {
+                path->depth = 0;
+                list_initialize(&path->link);
+                return path;
+        }
+}
+
+/**
+ *
+ */
+void usb_hid_report_path_free(usb_hid_report_path_t *path)
+{
+        while(!list_empty(&path->link)){
+                usb_hid_report_remove_last_item(path);
+        }
+}
+
+
+/**
+ *
+ */
+int     usb_hid_report_path_clone(usb_hid_report_path_t *new_usage_path, usb_hid_report_path_t *usage_path)
+{
+        usb_hid_report_usage_path_t *path_item;
+        link_t *path_link;
+
+        
+        if(list_empty(&usage_path->link)){
+                return EOK;
+        }
+
+        path_link = usage_path->link.next;
+        while(path_link != &usage_path->link) {
+                path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link);
+                usb_hid_report_path_append_item (new_usage_path, path_item->usage_page, path_item->usage);
+
+                path_link = path_link->next;
+        }
+
+        return EOK;
+}
+
 
 /**

uspace/lib/usb/src/hidreq.c

@@ -41 +41 @@
 #include <usb/debug.h>
 #include <usb/request.h>
-
-#include "hidreq.h"
-#include "hiddev.h"
+#include <usb/pipes.h>
+
+#include <usb/classes/hidreq.h>
 
 /*----------------------------------------------------------------------------*/
@@ -60 +60 @@
  *         usb_control_request_set().
  */
-int usbhid_req_set_report(usbhid_dev_t *hid_dev,
+int usbhid_req_set_report(usb_pipe_t *ctrl_pipe, int iface_no,
     usb_hid_report_type_t type, uint8_t *buffer, size_t buf_size)
 {
-        if (hid_dev == NULL) {
-                usb_log_error("usbhid_req_set_report(): no HID device structure"
-                    " given.\n");
-                return EINVAL;
-        }
-        
-        /*
-         * No need for checking other parameters, as they are checked in
-         * the called function (usb_control_request_set()).
-         */
-        
-        int rc, sess_rc;
-        
-        sess_rc = usb_pipe_start_session(&hid_dev->ctrl_pipe);
+        if (ctrl_pipe == NULL) {
+                usb_log_warning("usbhid_req_set_report(): no pipe given.\n");
+                return EINVAL;
+        }
+        
+        if (iface_no < 0) {
+                usb_log_warning("usbhid_req_set_report(): no interface given."
+                    "\n");
+                return EINVAL;
+        }
+        
+        /*
+         * No need for checking other parameters, as they are checked in
+         * the called function (usb_control_request_set()).
+         */
+        
+        int rc, sess_rc;
+        
+        sess_rc = usb_pipe_start_session(ctrl_pipe);
         if (sess_rc != EOK) {
                 usb_log_warning("Failed to start a session: %s.\n",
@@ -88 +93 @@
         usb_log_debug("Sending Set_Report request to the device.\n");
         
-        rc = usb_control_request_set(&hid_dev->ctrl_pipe, 
-            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
-            USB_HIDREQ_SET_REPORT, value, hid_dev->iface, buffer, buf_size);
-
-        sess_rc = usb_pipe_end_session(&hid_dev->ctrl_pipe);
+        rc = usb_control_request_set(ctrl_pipe, 
+            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
+            USB_HIDREQ_SET_REPORT, value, iface_no, buffer, buf_size);
+
+        sess_rc = usb_pipe_end_session(ctrl_pipe);
 
         if (rc != EOK) {
@@ -122 +127 @@
  *         usb_control_request_set().
  */
-int usbhid_req_set_protocol(usbhid_dev_t *hid_dev, usb_hid_protocol_t protocol)
-{
-        if (hid_dev == NULL) {
-                usb_log_error("usbhid_req_set_protocol(): no HID device "
-                    "structure given.\n");
-                return EINVAL;
-        }
-        
-        /*
-         * No need for checking other parameters, as they are checked in
-         * the called function (usb_control_request_set()).
-         */
-        
-        int rc, sess_rc;
-        
-        sess_rc = usb_pipe_start_session(&hid_dev->ctrl_pipe);
+int usbhid_req_set_protocol(usb_pipe_t *ctrl_pipe, int iface_no,
+    usb_hid_protocol_t protocol)
+{
+        if (ctrl_pipe == NULL) {
+                usb_log_warning("usbhid_req_set_report(): no pipe given.\n");
+                return EINVAL;
+        }
+        
+        if (iface_no < 0) {
+                usb_log_warning("usbhid_req_set_report(): no interface given."
+                    "\n");
+                return EINVAL;
+        }
+        
+        /*
+         * No need for checking other parameters, as they are checked in
+         * the called function (usb_control_request_set()).
+         */
+        
+        int rc, sess_rc;
+        
+        sess_rc = usb_pipe_start_session(ctrl_pipe);
         if (sess_rc != EOK) {
                 usb_log_warning("Failed to start a session: %s.\n",
@@ -145 +156 @@
 
         usb_log_debug("Sending Set_Protocol request to the device ("
-            "protocol: %d, iface: %d).\n", protocol, hid_dev->iface);
-        
-        rc = usb_control_request_set(&hid_dev->ctrl_pipe, 
-            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
-            USB_HIDREQ_SET_PROTOCOL, protocol, hid_dev->iface, NULL, 0);
-
-        sess_rc = usb_pipe_end_session(&hid_dev->ctrl_pipe);
+            "protocol: %d, iface: %d).\n", protocol, iface_no);
+        
+        rc = usb_control_request_set(ctrl_pipe, 
+            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
+            USB_HIDREQ_SET_PROTOCOL, protocol, iface_no, NULL, 0);
+
+        sess_rc = usb_pipe_end_session(ctrl_pipe);
 
         if (rc != EOK) {
@@ -182 +193 @@
  *         usb_control_request_set().
  */
-int usbhid_req_set_idle(usbhid_dev_t *hid_dev, uint8_t duration)
-{
-        if (hid_dev == NULL) {
-                usb_log_error("usbhid_req_set_idle(): no HID device "
-                    "structure given.\n");
-                return EINVAL;
-        }
-        
-        /*
-         * No need for checking other parameters, as they are checked in
-         * the called function (usb_control_request_set()).
-         */
-        
-        int rc, sess_rc;
-        
-        sess_rc = usb_pipe_start_session(&hid_dev->ctrl_pipe);
+int usbhid_req_set_idle(usb_pipe_t *ctrl_pipe, int iface_no, uint8_t duration)
+{
+        if (ctrl_pipe == NULL) {
+                usb_log_warning("usbhid_req_set_report(): no pipe given.\n");
+                return EINVAL;
+        }
+        
+        if (iface_no < 0) {
+                usb_log_warning("usbhid_req_set_report(): no interface given."
+                    "\n");
+                return EINVAL;
+        }
+        
+        /*
+         * No need for checking other parameters, as they are checked in
+         * the called function (usb_control_request_set()).
+         */
+        
+        int rc, sess_rc;
+        
+        sess_rc = usb_pipe_start_session(ctrl_pipe);
         if (sess_rc != EOK) {
                 usb_log_warning("Failed to start a session: %s.\n",
@@ -205 +221 @@
 
         usb_log_debug("Sending Set_Idle request to the device ("
-            "duration: %u, iface: %d).\n", duration, hid_dev->iface);
+            "duration: %u, iface: %d).\n", duration, iface_no);
         
         uint16_t value = duration << 8;
         
-        rc = usb_control_request_set(&hid_dev->ctrl_pipe, 
-            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
-            USB_HIDREQ_SET_IDLE, value, hid_dev->iface, NULL, 0);
-
-        sess_rc = usb_pipe_end_session(&hid_dev->ctrl_pipe);
+        rc = usb_control_request_set(ctrl_pipe, 
+            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
+            USB_HIDREQ_SET_IDLE, value, iface_no, NULL, 0);
+
+        sess_rc = usb_pipe_end_session(ctrl_pipe);
 
         if (rc != EOK) {
@@ -247 +263 @@
  *         usb_control_request_set().
  */
-int usbhid_req_get_report(usbhid_dev_t *hid_dev, usb_hid_report_type_t type, 
-    uint8_t *buffer, size_t buf_size, size_t *actual_size)
-{
-        if (hid_dev == NULL) {
-                usb_log_error("usbhid_req_set_report(): no HID device structure"
-                    " given.\n");
-                return EINVAL;
-        }
-        
-        /*
-         * No need for checking other parameters, as they are checked in
-         * the called function (usb_control_request_set()).
-         */
-        
-        int rc, sess_rc;
-        
-        sess_rc = usb_pipe_start_session(&hid_dev->ctrl_pipe);
+int usbhid_req_get_report(usb_pipe_t *ctrl_pipe, int iface_no, 
+    usb_hid_report_type_t type, uint8_t *buffer, size_t buf_size, 
+    size_t *actual_size)
+{
+        if (ctrl_pipe == NULL) {
+                usb_log_warning("usbhid_req_set_report(): no pipe given.\n");
+                return EINVAL;
+        }
+        
+        if (iface_no < 0) {
+                usb_log_warning("usbhid_req_set_report(): no interface given."
+                    "\n");
+                return EINVAL;
+        }
+        
+        /*
+         * No need for checking other parameters, as they are checked in
+         * the called function (usb_control_request_set()).
+         */
+        
+        int rc, sess_rc;
+        
+        sess_rc = usb_pipe_start_session(ctrl_pipe);
         if (sess_rc != EOK) {
                 usb_log_warning("Failed to start a session: %s.\n",
@@ -275 +297 @@
         usb_log_debug("Sending Get_Report request to the device.\n");
         
-        rc = usb_control_request_get(&hid_dev->ctrl_pipe, 
-            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
-            USB_HIDREQ_GET_REPORT, value, hid_dev->iface, buffer, buf_size,
+        rc = usb_control_request_get(ctrl_pipe, 
+            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
+            USB_HIDREQ_GET_REPORT, value, iface_no, buffer, buf_size,
             actual_size);
 
-        sess_rc = usb_pipe_end_session(&hid_dev->ctrl_pipe);
+        sess_rc = usb_pipe_end_session(ctrl_pipe);
 
         if (rc != EOK) {
@@ -310 +332 @@
  *         usb_control_request_set().
  */
-int usbhid_req_get_protocol(usbhid_dev_t *hid_dev, usb_hid_protocol_t *protocol)
-{
-        if (hid_dev == NULL) {
-                usb_log_error("usbhid_req_set_protocol(): no HID device "
-                    "structure given.\n");
-                return EINVAL;
-        }
-        
-        /*
-         * No need for checking other parameters, as they are checked in
-         * the called function (usb_control_request_set()).
-         */
-        
-        int rc, sess_rc;
-        
-        sess_rc = usb_pipe_start_session(&hid_dev->ctrl_pipe);
+int usbhid_req_get_protocol(usb_pipe_t *ctrl_pipe, int iface_no, 
+    usb_hid_protocol_t *protocol)
+{
+        if (ctrl_pipe == NULL) {
+                usb_log_warning("usbhid_req_set_report(): no pipe given.\n");
+                return EINVAL;
+        }
+        
+        if (iface_no < 0) {
+                usb_log_warning("usbhid_req_set_report(): no interface given."
+                    "\n");
+                return EINVAL;
+        }
+        
+        /*
+         * No need for checking other parameters, as they are checked in
+         * the called function (usb_control_request_set()).
+         */
+        
+        int rc, sess_rc;
+        
+        sess_rc = usb_pipe_start_session(ctrl_pipe);
         if (sess_rc != EOK) {
                 usb_log_warning("Failed to start a session: %s.\n",
@@ -333 +361 @@
 
         usb_log_debug("Sending Get_Protocol request to the device ("
-            "iface: %d).\n", hid_dev->iface);
+            "iface: %d).\n", iface_no);
         
         uint8_t buffer[1];
         size_t actual_size = 0;
         
-        rc = usb_control_request_get(&hid_dev->ctrl_pipe, 
-            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
-            USB_HIDREQ_GET_PROTOCOL, 0, hid_dev->iface, buffer, 1, &actual_size);
-
-        sess_rc = usb_pipe_end_session(&hid_dev->ctrl_pipe);
+        rc = usb_control_request_get(ctrl_pipe, 
+            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
+            USB_HIDREQ_GET_PROTOCOL, 0, iface_no, buffer, 1, &actual_size);
+
+        sess_rc = usb_pipe_end_session(ctrl_pipe);
 
         if (rc != EOK) {
@@ -381 +409 @@
  *         usb_control_request_set().
  */
-int usbhid_req_get_idle(usbhid_dev_t *hid_dev, uint8_t *duration)
-{
-        if (hid_dev == NULL) {
-                usb_log_error("usbhid_req_set_idle(): no HID device "
-                    "structure given.\n");
-                return EINVAL;
-        }
-        
-        /*
-         * No need for checking other parameters, as they are checked in
-         * the called function (usb_control_request_set()).
-         */
-        
-        int rc, sess_rc;
-        
-        sess_rc = usb_pipe_start_session(&hid_dev->ctrl_pipe);
+int usbhid_req_get_idle(usb_pipe_t *ctrl_pipe, int iface_no, uint8_t *duration)
+{
+        if (ctrl_pipe == NULL) {
+                usb_log_warning("usbhid_req_set_report(): no pipe given.\n");
+                return EINVAL;
+        }
+        
+        if (iface_no < 0) {
+                usb_log_warning("usbhid_req_set_report(): no interface given."
+                    "\n");
+                return EINVAL;
+        }
+        
+        /*
+         * No need for checking other parameters, as they are checked in
+         * the called function (usb_control_request_set()).
+         */
+        
+        int rc, sess_rc;
+        
+        sess_rc = usb_pipe_start_session(ctrl_pipe);
         if (sess_rc != EOK) {
                 usb_log_warning("Failed to start a session: %s.\n",
@@ -404 +437 @@
 
         usb_log_debug("Sending Get_Idle request to the device ("
-            "iface: %d).\n", hid_dev->iface);
+            "iface: %d).\n", iface_no);
         
         uint16_t value = 0;
@@ -410 +443 @@
         size_t actual_size = 0;
         
-        rc = usb_control_request_get(&hid_dev->ctrl_pipe, 
-            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
-            USB_HIDREQ_GET_IDLE, value, hid_dev->iface, buffer, 1, 
+        rc = usb_control_request_get(ctrl_pipe, 
+            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
+            USB_HIDREQ_GET_IDLE, value, iface_no, buffer, 1, 
             &actual_size);
 
-        sess_rc = usb_pipe_end_session(&hid_dev->ctrl_pipe);
+        sess_rc = usb_pipe_end_session(ctrl_pipe);
 
         if (rc != EOK) {