Changes in / [c6cb76d:7dfc06fa] in mainline

Files:

• boot/arch/amd64/Makefile.inc (modified) (1 diff)
• uspace/Makefile (modified) (2 diffs)
• uspace/drv/ohci/root_hub.c (modified) (32 diffs)
• uspace/drv/uhci-hcd/batch.c (modified) (4 diffs)
• uspace/drv/uhci-hcd/batch.h (modified) (1 diff)
• uspace/drv/uhci-hcd/hc.c (modified) (2 diffs)
• uspace/drv/uhci-hcd/iface.c (modified) (7 diffs)
• uspace/drv/uhci-hcd/transfer_list.c (modified) (3 diffs)
• uspace/drv/uhci-rhd/root_hub.h (modified) (1 diff)
• uspace/drv/usbhid/Makefile (deleted)
• uspace/drv/usbhid/generic/hiddev.c (deleted)
• uspace/drv/usbhid/generic/hiddev.h (deleted)
• uspace/drv/usbhid/kbd.h (deleted)
• uspace/drv/usbhid/kbd/conv.c (deleted)
• uspace/drv/usbhid/kbd/conv.h (deleted)
• uspace/drv/usbhid/kbd/kbddev.c (deleted)
• uspace/drv/usbhid/kbd/kbddev.h (deleted)
• uspace/drv/usbhid/kbd/kbdrepeat.c (deleted)
• uspace/drv/usbhid/kbd/kbdrepeat.h (deleted)
• uspace/drv/usbhid/kbd/layout.h (deleted)
• uspace/drv/usbhid/kbd/main.c (deleted)
• uspace/drv/usbhid/layout.h (deleted)
• uspace/drv/usbhid/main.c (deleted)
• uspace/drv/usbhid/usbhid.c (deleted)
• uspace/drv/usbhid/usbhid.h (deleted)
• uspace/drv/usbhid/usbhid.ma (deleted)
• uspace/drv/usbkbd/kbddev.c (modified) (9 diffs)
• uspace/drv/usbkbd/main.c (modified) (6 diffs)
• uspace/drv/usbkbd/usbkbd.ma (modified) (1 diff)
• uspace/lib/usb/include/usb/classes/hidparser.h (modified) (4 diffs)
• uspace/lib/usb/include/usb/host/batch.h (modified) (1 diff)
• uspace/lib/usb/include/usb/host/device_keeper.h (modified) (1 diff)
• uspace/lib/usb/include/usb/host/endpoint.h (modified) (3 diffs)
• uspace/lib/usb/src/devpoll.c (modified) (2 diffs)
• uspace/lib/usb/src/hidparser.c (modified) (19 diffs)
• uspace/lib/usb/src/hidreport.c (modified) (1 diff)
• uspace/lib/usb/src/host/batch.c (modified) (2 diffs)
• uspace/lib/usb/src/host/device_keeper.c (modified) (1 diff)
• uspace/lib/usb/src/host/endpoint.c (modified) (3 diffs)
• uspace/lib/usb/src/hub.c (modified) (8 diffs)

boot/arch/amd64/Makefile.inc

@@ -50 +50 @@
         usbhub \
         usbkbd \
-        usbhid \
         usbmid \
         usbmouse \

uspace/Makefile

@@ -123 +123 @@
                 drv/usbflbk \
                 drv/usbkbd \
-                drv/usbhid \
                 drv/usbhub \
                 drv/usbmid \
@@ -144 +143 @@
                 drv/usbflbk \
                 drv/usbkbd \
-                drv/usbhid \
                 drv/usbhub \
                 drv/usbmid \

uspace/drv/ohci/root_hub.c

@@ -47 +47 @@
  *      standart device descriptor for ohci root hub
  */
-static const usb_standard_device_descriptor_t ohci_rh_device_descriptor = {
-        .configuration_count = 1,
-        .descriptor_type = USB_DESCTYPE_DEVICE,
-        .device_class = USB_CLASS_HUB,
-        .device_protocol = 0,
-        .device_subclass = 0,
-        .device_version = 0,
-        .length = sizeof (usb_standard_device_descriptor_t),
-        /// \TODO this value is guessed
-        .max_packet_size = 8,
-        .vendor_id = 0x16db,
-        .product_id = 0x0001,
-        /// \TODO these values migt be different
-        .str_serial_number = 0,
-        .usb_spec_version = 0x110,
+static const usb_standard_device_descriptor_t ohci_rh_device_descriptor =
+{
+                .configuration_count = 1,
+                .descriptor_type = USB_DESCTYPE_DEVICE,
+                .device_class = USB_CLASS_HUB,
+                .device_protocol = 0,
+                .device_subclass = 0,
+                .device_version = 0,
+                .length = sizeof(usb_standard_device_descriptor_t),
+                /// \TODO this value is guessed
+                .max_packet_size = 8,
+                .vendor_id = 0x16db,
+                .product_id = 0x0001,
+                /// \TODO these values migt be different
+                .str_serial_number = 0,
+                .usb_spec_version = 0x110,
 };
 
@@ -68 +69 @@
  * for ohci root hubs
  */
-static const usb_standard_configuration_descriptor_t ohci_rh_conf_descriptor = {
+static const usb_standard_configuration_descriptor_t ohci_rh_conf_descriptor =
+{
         /// \TODO some values are default or guessed
-        .attributes = 1 << 7,
+        .attributes = 1<<7,
         .configuration_number = 1,
         .descriptor_type = USB_DESCTYPE_CONFIGURATION,
         .interface_count = 1,
-        .length = sizeof (usb_standard_configuration_descriptor_t),
+        .length = sizeof(usb_standard_configuration_descriptor_t),
         .max_power = 100,
         .str_configuration = 0,
@@ -82 +84 @@
  * standart ohci root hub interface descriptor
  */
-static const usb_standard_interface_descriptor_t ohci_rh_iface_descriptor = {
+static const usb_standard_interface_descriptor_t ohci_rh_iface_descriptor =
+{
         .alternate_setting = 0,
         .descriptor_type = USB_DESCTYPE_INTERFACE,
@@ -91 +94 @@
         .interface_protocol = 0,
         .interface_subclass = 0,
-        .length = sizeof (usb_standard_interface_descriptor_t),
+        .length = sizeof(usb_standard_interface_descriptor_t),
         .str_interface = 0,
 };
@@ -98 +101 @@
  * standart ohci root hub endpoint descriptor
  */
-static const usb_standard_endpoint_descriptor_t ohci_rh_ep_descriptor = {
+static const usb_standard_endpoint_descriptor_t ohci_rh_ep_descriptor =
+{
         .attributes = USB_TRANSFER_INTERRUPT,
         .descriptor_type = USB_DESCTYPE_ENDPOINT,
-        .endpoint_address = 1 + (1 << 7),
-        .length = sizeof (usb_standard_endpoint_descriptor_t),
+        .endpoint_address = 1 + (1<<7),
+        .length = sizeof(usb_standard_endpoint_descriptor_t),
         .max_packet_size = 8,
         .poll_interval = 255,
@@ -108 +112 @@
 
 static const uint32_t hub_clear_feature_valid_mask =
-        (1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER) |
-(1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
+        (1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER) +
+        (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
 
 static const uint32_t hub_clear_feature_by_writing_one_mask =
@@ -117 +121 @@
         (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
 
-
+        
 static const uint32_t hub_set_feature_direct_mask =
         (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
 
 static const uint32_t port_set_feature_valid_mask =
-        (1 << USB_HUB_FEATURE_PORT_ENABLE) |
-(1 << USB_HUB_FEATURE_PORT_SUSPEND) |
-(1 << USB_HUB_FEATURE_PORT_RESET) |
-(1 << USB_HUB_FEATURE_PORT_POWER);
+        (1 << USB_HUB_FEATURE_PORT_ENABLE) +
+        (1 << USB_HUB_FEATURE_PORT_SUSPEND) +
+        (1 << USB_HUB_FEATURE_PORT_RESET) +
+        (1 << USB_HUB_FEATURE_PORT_POWER);
 
 static const uint32_t port_clear_feature_valid_mask =
-        (1 << USB_HUB_FEATURE_PORT_CONNECTION) |
-(1 << USB_HUB_FEATURE_PORT_SUSPEND) |
-(1 << USB_HUB_FEATURE_PORT_OVER_CURRENT) |
-(1 << USB_HUB_FEATURE_PORT_POWER) |
-(1 << USB_HUB_FEATURE_C_PORT_CONNECTION) |
-(1 << USB_HUB_FEATURE_C_PORT_ENABLE) |
-(1 << USB_HUB_FEATURE_C_PORT_SUSPEND) |
-(1 << USB_HUB_FEATURE_C_PORT_OVER_CURRENT) |
-(1 << USB_HUB_FEATURE_C_PORT_RESET);
-//note that USB_HUB_FEATURE_PORT_POWER bit is translated into
-//USB_HUB_FEATURE_PORT_LOW_SPEED
-
-static const uint32_t port_status_change_mask =
-(1<< USB_HUB_FEATURE_C_PORT_CONNECTION) |
-(1<< USB_HUB_FEATURE_C_PORT_ENABLE) |
-(1<< USB_HUB_FEATURE_C_PORT_OVER_CURRENT) |
-(1<< USB_HUB_FEATURE_C_PORT_RESET) |
-(1<< USB_HUB_FEATURE_C_PORT_SUSPEND);
-
-
-static void usb_create_serialized_hub_descriptor(rh_t *instance,
-        uint8_t ** out_result,
-        size_t * out_size);
-
-static void rh_init_descriptors(rh_t *instance);
-
-static int process_get_port_status_request(rh_t *instance, uint16_t port,
-        usb_transfer_batch_t * request);
-
-static int process_get_hub_status_request(rh_t *instance,
-        usb_transfer_batch_t * request);
-
-static int process_get_status_request(rh_t *instance,
-        usb_transfer_batch_t * request);
-
-static void create_interrupt_mask(rh_t *instance, void ** buffer,
-        size_t * buffer_size);
-
-static int process_get_descriptor_request(rh_t *instance,
-        usb_transfer_batch_t *request);
-
-static int process_get_configuration_request(rh_t *instance,
-        usb_transfer_batch_t *request);
-
-static int process_hub_feature_set_request(rh_t *instance, uint16_t feature);
-
-static int process_hub_feature_clear_request(rh_t *instance,
-        uint16_t feature);
-
-static int process_port_feature_set_request(rh_t *instance,
-        uint16_t feature, uint16_t port);
-
-static int process_port_feature_clear_request(rh_t *instance,
-        uint16_t feature, uint16_t port);
-
-static int process_address_set_request(rh_t *instance,
-        uint16_t address);
-
-static int process_request_with_output(rh_t *instance,
-        usb_transfer_batch_t *request);
-
-static int process_request_with_input(rh_t *instance,
-        usb_transfer_batch_t *request);
-
-static int process_request_without_data(rh_t *instance,
-        usb_transfer_batch_t *request);
-
-static int process_ctrl_request(rh_t *instance, usb_transfer_batch_t *request);
-
-
-
-
-
-/** Root hub initialization
- * @return Error code.
- */
-int rh_init(rh_t *instance, ddf_dev_t *dev, ohci_regs_t *regs) {
-        assert(instance);
-        //instance->address = -1;
-        instance->registers = regs;
-        instance->device = dev;
-        instance->port_count = instance->registers->rh_desc_a & 0xff;
-        rh_init_descriptors(instance);
-        // set port power mode to no-power-switching
-        instance->registers->rh_desc_a =
-                instance->registers->rh_desc_a | (1<<9);
-
-        usb_log_info("OHCI root hub with %d ports.\n", instance->port_count);
-
-        //start generic usb hub driver
-
-        /* TODO: implement */
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
-
-/**
- * process root hub request
- *
- * @param instance root hub instance
- * @param request structure containing both request and response information
- * @return error code
- */
-int rh_request(rh_t *instance, usb_transfer_batch_t *request) {
-        assert(instance);
-        assert(request);
-        int opResult;
-        if (request->transfer_type == USB_TRANSFER_CONTROL) {
-                usb_log_info("Root hub got CONTROL packet\n");
-                opResult = process_ctrl_request(instance, request);
-        } 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_error(request, opResult);
-        return EOK;
-}
-
-/*----------------------------------------------------------------------------*/
-
-
-void rh_interrupt(rh_t *instance) {
-        usb_log_info("Whoa whoa wait, I`m not supposed to receive any "
-                "interrupts, am I?\n");
-        /* TODO: implement? */
-}
-/*----------------------------------------------------------------------------*/
+        (1 << USB_HUB_FEATURE_PORT_CONNECTION) +
+        (1 << USB_HUB_FEATURE_PORT_SUSPEND) +
+        (1 << USB_HUB_FEATURE_PORT_OVER_CURRENT) +
+        (1 << USB_HUB_FEATURE_PORT_POWER) +
+        (1 << USB_HUB_FEATURE_C_PORT_CONNECTION) +
+        (1 << USB_HUB_FEATURE_C_PORT_ENABLE) +
+        (1 << USB_HUB_FEATURE_C_PORT_SUSPEND) +
+        (1 << USB_HUB_FEATURE_C_PORT_OVER_CURRENT) +
+        (1 << USB_HUB_FEATURE_C_PORT_RESET);
+//note that USB_HUB_FEATURE_PORT_POWER bit is translated into USB_HUB_FEATURE_PORT_LOW_SPEED
+
+
+
 
 /**
@@ -274 +157 @@
  */
 static void usb_create_serialized_hub_descriptor(rh_t *instance,
-        uint8_t ** out_result,
-        size_t * out_size) {
+                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);
+                        ((instance->port_count % 8 > 0) ? 1 : 0);
         size += 2 * var_size;
         uint8_t * result = (uint8_t*) malloc(size);
-        bzero(result, size);
+        bzero(result,size);
         //size
         result[0] = size;
@@ -291 +174 @@
         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);
+                        ((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;
@@ -302 +185 @@
         int port;
         for (port = 1; port <= instance->port_count; ++port) {
-                uint8_t is_non_removable =
-                        instance->registers->rh_desc_b >> port % 2;
-                result[7 + port / 8] +=
-                        is_non_removable << (port % 8);
+                result[7 + port/8] +=
+                                ((instance->registers->rh_desc_b >> port)%2) << (port%8);
         }
         size_t i;
@@ -314 +195 @@
         (*out_size) = size;
 }
-/*----------------------------------------------------------------------------*/
+
 
 /** initialize hub descriptors
@@ -322 +203 @@
  * @instance root hub instance
  */
-static void rh_init_descriptors(rh_t *instance) {
+static void rh_init_descriptors(rh_t *instance){
         memcpy(&instance->descriptors.device, &ohci_rh_device_descriptor,
-                sizeof (ohci_rh_device_descriptor)
-                );
+                sizeof(ohci_rh_device_descriptor)
+        );
         usb_standard_configuration_descriptor_t descriptor;
-        memcpy(&descriptor, &ohci_rh_conf_descriptor,
-                sizeof (ohci_rh_conf_descriptor));
+        memcpy(&descriptor,&ohci_rh_conf_descriptor,
+                        sizeof(ohci_rh_conf_descriptor));
         uint8_t * hub_descriptor;
         size_t hub_desc_size;
         usb_create_serialized_hub_descriptor(instance, &hub_descriptor,
-                &hub_desc_size);
+                        &hub_desc_size);
 
         descriptor.total_length =
-                sizeof (usb_standard_configuration_descriptor_t) +
-                sizeof (usb_standard_endpoint_descriptor_t) +
-                sizeof (usb_standard_interface_descriptor_t) +
-                hub_desc_size;
-
+                        sizeof(usb_standard_configuration_descriptor_t)+
+                        sizeof(usb_standard_endpoint_descriptor_t)+
+                        sizeof(usb_standard_interface_descriptor_t)+
+                        hub_desc_size;
+        
         uint8_t * full_config_descriptor =
-                (uint8_t*) malloc(descriptor.total_length);
-        memcpy(full_config_descriptor, &descriptor, sizeof (descriptor));
-        memcpy(full_config_descriptor + sizeof (descriptor),
-                &ohci_rh_iface_descriptor, sizeof (ohci_rh_iface_descriptor));
-        memcpy(full_config_descriptor + sizeof (descriptor) +
-                sizeof (ohci_rh_iface_descriptor),
-                &ohci_rh_ep_descriptor, sizeof (ohci_rh_ep_descriptor));
-        memcpy(full_config_descriptor + sizeof (descriptor) +
-                sizeof (ohci_rh_iface_descriptor) +
-                sizeof (ohci_rh_ep_descriptor),
-                hub_descriptor, hub_desc_size);
-
+                        (uint8_t*) malloc(descriptor.total_length);
+        memcpy(full_config_descriptor, &descriptor, sizeof(descriptor));
+        memcpy(full_config_descriptor + sizeof(descriptor),
+                        &ohci_rh_iface_descriptor, sizeof(ohci_rh_iface_descriptor));
+        memcpy(full_config_descriptor + sizeof(descriptor) +
+                                sizeof(ohci_rh_iface_descriptor),
+                        &ohci_rh_ep_descriptor, sizeof(ohci_rh_ep_descriptor));
+        memcpy(full_config_descriptor + sizeof(descriptor) +
+                                sizeof(ohci_rh_iface_descriptor) +
+                                sizeof(ohci_rh_ep_descriptor),
+                        hub_descriptor, hub_desc_size);
+        
         instance->descriptors.configuration = full_config_descriptor;
         instance->descriptors.configuration_size = descriptor.total_length;
 }
+
+/** Root hub initialization
+ * @return Error code.
+ */
+int rh_init(rh_t *instance, ddf_dev_t *dev, ohci_regs_t *regs)
+{
+        assert(instance);
+        instance->address = -1;
+        instance->registers = regs;
+        instance->device = dev;
+        instance->port_count = instance->registers->rh_desc_a & 0xff;
+        rh_init_descriptors(instance);
+        /// \TODO set port power mode
+
+
+        usb_log_info("OHCI root hub with %d ports.\n", instance->port_count);
+
+        //start generic usb hub driver
+        
+        /* TODO: implement */
+        return EOK;
+}
 /*----------------------------------------------------------------------------*/
 
@@ -369 +272 @@
  */
 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->transport_buffer;
+                usb_transfer_batch_t * request){
+        if(port<1 || port>instance->port_count)
+                return EINVAL;
+        uint32_t * uint32_buffer = (uint32_t*)request->transport_buffer;
         request->transfered_size = 4;
-        uint32_buffer[0] = instance->registers->rh_port_status[port - 1];
-#if 0
-        int i;
-        for (i = 0; i < instance->port_count; ++i) {
-                usb_log_debug("port status %d,x%x\n",
-                        instance->registers->rh_port_status[i],
-                        instance->registers->rh_port_status[i]);
-        }
-#endif
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
+        uint32_buffer[0] = instance->registers->rh_port_status[port -1];
+        return EOK;
+}
 
 /**
@@ -397 +291 @@
  */
 static int process_get_hub_status_request(rh_t *instance,
-        usb_transfer_batch_t * request) {
-        uint32_t * uint32_buffer = (uint32_t*) request->transport_buffer;
+                usb_transfer_batch_t * request){
+        uint32_t * uint32_buffer = (uint32_t*)request->transport_buffer;
+        //bits, 0,1,16,17
         request->transfered_size = 4;
-        //bits, 0,1,16,17
-        uint32_t mask = 1 | (1 << 1) | (1 << 16) | (1 << 17);
+        uint32_t mask = 1 & (1<<1) & (1<<16) & (1<<17);
         uint32_buffer[0] = mask & instance->registers->rh_status;
         return EOK;
-}
-/*----------------------------------------------------------------------------*/
+
+}
+
+
 
 /**
@@ -417 +313 @@
  */
 static int process_get_status_request(rh_t *instance,
-        usb_transfer_batch_t * request) {
+                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_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
+        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)
+        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);
+        if(request_type == USB_HUB_REQ_TYPE_GET_PORT_STATUS)
+                return process_get_port_status_request(instance, request_packet->index,
+                                request);
         return ENOTSUP;
 }
-/*----------------------------------------------------------------------------*/
 
 /**
@@ -444 +339 @@
  * Result contains bitmap where bit 0 indicates change on hub and
  * bit i indicates change on i`th port (i>0). For more info see
- * Hub and Port status bitmap specification in USB specification
- * (chapter 11.13.4)
+ * Hub and Port status bitmap specification in USB specification.
  * @param instance root hub instance
  * @param@out buffer pointer to created interrupt mas
@@ -451 +345 @@
  */
 static void create_interrupt_mask(rh_t *instance, void ** buffer,
-        size_t * buffer_size) {
+                size_t * buffer_size){
         int bit_count = instance->port_count + 1;
-        (*buffer_size) = (bit_count / 8) + ((bit_count % 8 == 0) ? 0 : 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 << (USB_HUB_FEATURE_C_HUB_LOCAL_POWER + 16))
-                | (1 << (USB_HUB_FEATURE_C_HUB_OVER_CURRENT + 16));
-        bzero(bitmap, (*buffer_size));
-        if (instance->registers->rh_status & mask) {
+        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 = port_status_change_mask;
-        for (port = 1; port <= instance->port_count; ++port) {
-                if (mask & instance->registers->rh_port_status[port - 1]) {
-                        bitmap[(port) / 8] += 1 << (port % 8);
-                }
-        }
-}
-/*----------------------------------------------------------------------------*/
-
+        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);
+                }
+        }
+}
+ 
 /**
  * create answer to a descriptor request
@@ -483 +377 @@
  */
 static int process_get_descriptor_request(rh_t *instance,
-        usb_transfer_batch_t *request) {
+                usb_transfer_batch_t *request){
         usb_device_request_setup_packet_t * setup_request =
-                (usb_device_request_setup_packet_t*) request->setup_buffer;
+                        (usb_device_request_setup_packet_t*)request->setup_buffer;
         size_t size;
         const void * result_descriptor = NULL;
         const uint16_t setup_request_value = setup_request->value_high;
-        //(setup_request->value_low << 8);
+                        //(setup_request->value_low << 8);
         bool del = false;
-        switch (setup_request_value) {
-                case USB_DESCTYPE_HUB:
-                {
+        switch (setup_request_value)
+        {
+                case USB_DESCTYPE_HUB: {
                         uint8_t * descriptor;
                         usb_create_serialized_hub_descriptor(
                                 instance, &descriptor, &size);
                         result_descriptor = descriptor;
-                        if (result_descriptor) del = true;
+                        if(result_descriptor) del = true;
                         break;
                 }
-                case USB_DESCTYPE_DEVICE:
-                {
+                case USB_DESCTYPE_DEVICE: {
                         usb_log_debug("USB_DESCTYPE_DEVICE\n");
                         result_descriptor = &ohci_rh_device_descriptor;
-                        size = sizeof (ohci_rh_device_descriptor);
+                        size = sizeof(ohci_rh_device_descriptor);
                         break;
                 }
-                case USB_DESCTYPE_CONFIGURATION:
-                {
+                case USB_DESCTYPE_CONFIGURATION: {
                         usb_log_debug("USB_DESCTYPE_CONFIGURATION\n");
                         result_descriptor = instance->descriptors.configuration;
@@ -515 +407 @@
                         break;
                 }
-                case USB_DESCTYPE_INTERFACE:
-                {
+                case USB_DESCTYPE_INTERFACE: {
                         usb_log_debug("USB_DESCTYPE_INTERFACE\n");
                         result_descriptor = &ohci_rh_iface_descriptor;
-                        size = sizeof (ohci_rh_iface_descriptor);
+                        size = sizeof(ohci_rh_iface_descriptor);
                         break;
                 }
-                case USB_DESCTYPE_ENDPOINT:
-                {
+                case USB_DESCTYPE_ENDPOINT: {
                         usb_log_debug("USB_DESCTYPE_ENDPOINT\n");
                         result_descriptor = &ohci_rh_ep_descriptor;
-                        size = sizeof (ohci_rh_ep_descriptor);
+                        size = sizeof(ohci_rh_ep_descriptor);
                         break;
                 }
-                default:
-                {
-                        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
-                                );
+                default: {
+                        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) {
+        if(request->buffer_size < size){
                 size = request->buffer_size;
         }
         request->transfered_size = size;
-        memcpy(request->transport_buffer, result_descriptor, size);
+        memcpy(request->transport_buffer,result_descriptor,size);
+        usb_log_debug("sent desctiptor: %s\n",
+                        usb_debug_str_buffer((uint8_t*)request->transport_buffer,size,size));
         if (del)
                 free(result_descriptor);
         return EOK;
 }
-/*----------------------------------------------------------------------------*/
 
 /**
@@ -563 +451 @@
  * @return error code
  */
-static int process_get_configuration_request(rh_t *instance,
-        usb_transfer_batch_t *request) {
+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)
+        if(request->buffer_size != 1)
                 return EINVAL;
         request->transport_buffer[0] = 1;
@@ -573 +461 @@
         return EOK;
 }
-/*----------------------------------------------------------------------------*/
 
 /**
  * process feature-enabling request on hub
- *
+ * 
  * @param instance root hub instance
  * @param feature feature selector
@@ -583 +470 @@
  */
 static int process_hub_feature_set_request(rh_t *instance,
-        uint16_t feature) {
-        if (!((1 << feature) & hub_set_feature_valid_mask))
+                uint16_t feature){
+        if(! ((1<<feature) & hub_set_feature_valid_mask))
                 return EINVAL;
         instance->registers->rh_status =
-                (instance->registers->rh_status | (1 << feature))
-                & (~hub_clear_feature_by_writing_one_mask);
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
+                        (instance->registers->rh_status | (1<<feature))
+                        & (~ hub_clear_feature_by_writing_one_mask);
+        return EOK;
+}
 
 /**
@@ -601 +487 @@
  */
 static int process_hub_feature_clear_request(rh_t *instance,
-        uint16_t feature) {
-        if (!((1 << feature) & hub_clear_feature_valid_mask))
+                uint16_t feature){
+        if(! ((1<<feature) & hub_clear_feature_valid_mask))
                 return EINVAL;
         //is the feature cleared directly?
-        if ((1 << feature) & hub_set_feature_direct_mask) {
+        if ((1<<feature) & hub_set_feature_direct_mask){
                 instance->registers->rh_status =
-                        (instance->registers->rh_status & (~(1 << feature)))
-                        & (~hub_clear_feature_by_writing_one_mask);
-        } else {//the feature is cleared by writing '1'
+                        (instance->registers->rh_status & (~(1<<feature)))
+                        & (~ hub_clear_feature_by_writing_one_mask);
+        }else{//the feature is cleared by writing '1'
                 instance->registers->rh_status =
-                        (instance->registers->rh_status
-                        & (~hub_clear_feature_by_writing_one_mask))
-                        | (1 << feature);
-        }
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
+                                (instance->registers->rh_status
+                                & (~ hub_clear_feature_by_writing_one_mask))
+                                | (1<<feature);
+        }
+        return EOK;
+}
+
+
 
 /**
  * process feature-enabling request on hub
- *
+ * 
  * @param instance root hub instance
  * @param feature feature selector
@@ -629 +516 @@
  */
 static int process_port_feature_set_request(rh_t *instance,
-        uint16_t feature, uint16_t port) {
-        if (!((1 << feature) & port_set_feature_valid_mask))
-                return EINVAL;
-        if (port < 1 || port > instance->port_count)
+                uint16_t feature, uint16_t port){
+        if(!((1<<feature) & port_set_feature_valid_mask))
+                return EINVAL;
+        if(port<1 || port>instance->port_count)
                 return EINVAL;
         instance->registers->rh_port_status[port - 1] =
-                (instance->registers->rh_port_status[port - 1] | (1 << feature))
-                & (~port_clear_feature_valid_mask);
+                        (instance->registers->rh_port_status[port - 1] | (1<<feature))
+                        & (~port_clear_feature_valid_mask);
         /// \TODO any error?
         return EOK;
 }
-/*----------------------------------------------------------------------------*/
 
 /**
@@ -652 +538 @@
  */
 static int process_port_feature_clear_request(rh_t *instance,
-        uint16_t feature, uint16_t port) {
-        if (!((1 << feature) & port_clear_feature_valid_mask))
-                return EINVAL;
-        if (port < 1 || port > instance->port_count)
-                return EINVAL;
-        if (feature == USB_HUB_FEATURE_PORT_POWER)
+                uint16_t feature, uint16_t port){
+        if(!((1<<feature) & port_clear_feature_valid_mask))
+                return EINVAL;
+        if(port<1 || port>instance->port_count)
+                return EINVAL;
+        if(feature == USB_HUB_FEATURE_PORT_POWER)
                 feature = USB_HUB_FEATURE_PORT_LOW_SPEED;
-        if (feature == USB_HUB_FEATURE_PORT_SUSPEND)
+        if(feature == USB_HUB_FEATURE_PORT_SUSPEND)
                 feature = USB_HUB_FEATURE_PORT_OVER_CURRENT;
         instance->registers->rh_port_status[port - 1] =
-                (instance->registers->rh_port_status[port - 1]
-                & (~port_clear_feature_valid_mask))
-                | (1 << feature);
+                        (instance->registers->rh_port_status[port - 1] 
+                        & (~port_clear_feature_valid_mask))
+                        | (1<<feature);
         /// \TODO any error?
         return EOK;
 }
-/*----------------------------------------------------------------------------*/
+
 
 /**
  * register address to this device
- *
+ * 
  * @param instance root hub instance
  * @param address new address
@@ -678 +564 @@
  */
 static int process_address_set_request(rh_t *instance,
-        uint16_t address) {
+                uint16_t address){
         instance->address = address;
         return EOK;
 }
-/*----------------------------------------------------------------------------*/
 
 /**
@@ -694 +579 @@
  */
 static int process_request_with_output(rh_t *instance,
-        usb_transfer_batch_t *request) {
+                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_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) {
+        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) {
+        if(setup_request->request == USB_DEVREQ_GET_CONFIGURATION){
                 usb_log_debug("USB_DEVREQ_GET_CONFIGURATION\n");
                 return process_get_configuration_request(instance, request);
@@ -711 +596 @@
         return ENOTSUP;
 }
-/*----------------------------------------------------------------------------*/
 
 /**
@@ -723 +607 @@
  */
 static int process_request_with_input(rh_t *instance,
-        usb_transfer_batch_t *request) {
+                usb_transfer_batch_t *request){
         usb_device_request_setup_packet_t * setup_request =
-                (usb_device_request_setup_packet_t*) request->setup_buffer;
+                        (usb_device_request_setup_packet_t*)request->setup_buffer;
         request->transfered_size = 0;
-        if (setup_request->request == USB_DEVREQ_SET_DESCRIPTOR) {
+        if(setup_request->request == USB_DEVREQ_SET_DESCRIPTOR){
                 return ENOTSUP;
         }
-        if (setup_request->request == USB_DEVREQ_SET_CONFIGURATION) {
+        if(setup_request->request == USB_DEVREQ_SET_CONFIGURATION){
                 //set and get configuration requests do not have any meaning,
                 //only dummy values are returned
@@ -737 +621 @@
         return ENOTSUP;
 }
-/*----------------------------------------------------------------------------*/
 
 /**
@@ -749 +632 @@
  */
 static int process_request_without_data(rh_t *instance,
-        usb_transfer_batch_t *request) {
+                usb_transfer_batch_t *request){
         usb_device_request_setup_packet_t * setup_request =
-                (usb_device_request_setup_packet_t*) request->setup_buffer;
+                        (usb_device_request_setup_packet_t*)request->setup_buffer;
         request->transfered_size = 0;
-        if (setup_request->request == USB_DEVREQ_CLEAR_FEATURE) {
-                if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE) {
+        if(setup_request->request == USB_DEVREQ_CLEAR_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_clear_request(instance,
-                                setup_request->value);
-                }
-                if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE) {
+                                        setup_request->value);
+                }
+                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_clear_request(instance,
-                                setup_request->value,
-                                setup_request->index);
+                                        setup_request->value,
+                                        setup_request->index);
                 }
                 usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n",
-                        setup_request->request_type);
-                return EINVAL;
-        }
-        if (setup_request->request == USB_DEVREQ_SET_FEATURE) {
-                if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE) {
+                                setup_request->request_type);
+                return EINVAL;
+        }
+        if(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);
-                }
-                if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE) {
+                                        setup_request->value);
+                }
+                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);
-                }
-                usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n",
-                        setup_request->request_type);
-                return EINVAL;
-        }
-        if (setup_request->request == USB_DEVREQ_SET_ADDRESS) {
+                                        setup_request->value,
+                                        setup_request->index);
+                }
+                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 process_address_set_request(instance, setup_request->value);
+        }
+        usb_log_debug("USB_DEVREQ_SET_ENOTSUP %d\n",setup_request->request_type);
         return ENOTSUP;
 }
-/*----------------------------------------------------------------------------*/
 
 /**
@@ -814 +693 @@
  * @return error code
  */
-static int process_ctrl_request(rh_t *instance, usb_transfer_batch_t *request) {
-        if (!request->setup_buffer) {
+static int process_ctrl_request(rh_t *instance, usb_transfer_batch_t *request){
+        int opResult;
+        if (request->setup_buffer) {
+                if(sizeof(usb_device_request_setup_packet_t)>request->setup_size){
+                        usb_log_error("setup packet too small\n");
+                        return EINVAL;
+                }
+                usb_log_info("CTRL packet: %s.\n",
+                        usb_debug_str_buffer((const uint8_t *)request->setup_buffer, 8, 8));
+                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?");
-                return EINVAL;
-        }
+                opResult = EINVAL;
+        }
+        return opResult;
+}
+
+/**
+ * process root hub request
+ *
+ * @param instance root hub instance
+ * @param request structure containing both request and response information
+ * @return error code
+ */
+int rh_request(rh_t *instance, usb_transfer_batch_t *request)
+{
+        assert(instance);
+        assert(request);
         int opResult;
-        if (sizeof (usb_device_request_setup_packet_t) > request->setup_size) {
-                usb_log_error("setup packet too small\n");
-                return EINVAL;
-        }
-        usb_log_info("CTRL packet: %s.\n",
-                usb_debug_str_buffer(
-                (const uint8_t *) request->setup_buffer, 8, 8));
-        usb_device_request_setup_packet_t * setup_request =
-                (usb_device_request_setup_packet_t*)
-                request->setup_buffer;
-        switch (setup_request->request) {
-                case USB_DEVREQ_GET_STATUS:
-                case USB_DEVREQ_GET_DESCRIPTOR:
-                case USB_DEVREQ_GET_CONFIGURATION:
-                        usb_log_debug("processing request with output\n");
-                        opResult = process_request_with_output(
-                                instance, request);
-                        break;
-                case USB_DEVREQ_CLEAR_FEATURE:
-                case USB_DEVREQ_SET_FEATURE:
-                case USB_DEVREQ_SET_ADDRESS:
-                        usb_log_debug("processing request without "
-                                "additional data\n");
-                        opResult = process_request_without_data(
-                                instance, request);
-                        break;
-                case USB_DEVREQ_SET_DESCRIPTOR:
-                case USB_DEVREQ_SET_CONFIGURATION:
-                        usb_log_debug("processing request with "
-                                "input\n");
-                        opResult = process_request_with_input(
-                                instance, request);
-                        break;
-                default:
-                        usb_log_warning("received unsuported request: "
-                                "%d\n",
-                                setup_request->request
-                                );
-                        opResult = ENOTSUP;
-        }
-        return opResult;
-}
-
+        if(request->transfer_type == USB_TRANSFER_CONTROL){
+                usb_log_info("Root hub got CONTROL packet\n");
+                opResult = process_ctrl_request(instance,request);
+        }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)
+{
+        usb_log_info("Whoa whoa wait, I`m not supposed to receive any interrupts, am I?\n");
+        /* TODO: implement? */
+}
 /**
  * @}

uspace/drv/uhci-hcd/batch.c

@@ -80 +80 @@
  * transaction and callback.
  */
-usb_transfer_batch_t * batch_get(ddf_fun_t *fun, endpoint_t *ep,
-    char *buffer, size_t buffer_size, char* setup_buffer, size_t setup_size,
+usb_transfer_batch_t * batch_get(ddf_fun_t *fun, usb_target_t target,
+    usb_transfer_type_t transfer_type, size_t max_packet_size,
+    usb_speed_t speed, char *buffer, size_t buffer_size,
+    char* setup_buffer, size_t setup_size,
     usbhc_iface_transfer_in_callback_t func_in,
-    usbhc_iface_transfer_out_callback_t func_out, void *arg)
-{
-        assert(ep);
+    usbhc_iface_transfer_out_callback_t func_out, void *arg, endpoint_t *ep
+    )
+{
         assert(func_in == NULL || func_out == NULL);
         assert(func_in != NULL || func_out != NULL);
@@ -101 +103 @@
         CHECK_NULL_DISPOSE_RETURN(instance,
             "Failed to allocate batch instance.\n");
-        usb_target_t target =
-            { .address = ep->address, .endpoint = ep->endpoint };
         usb_transfer_batch_init(instance, target,
-            ep->transfer_type, ep->speed, ep->max_packet_size,
+            transfer_type, speed, max_packet_size,
             buffer, NULL, buffer_size, NULL, setup_size, func_in,
             func_out, arg, fun, ep, NULL);
@@ -115 +115 @@
         instance->private_data = data;
 
-        data->transfers =
-            (buffer_size + ep->max_packet_size - 1) / ep->max_packet_size;
-        if (ep->transfer_type == USB_TRANSFER_CONTROL) {
+        data->transfers = (buffer_size + max_packet_size - 1) / max_packet_size;
+        if (transfer_type == USB_TRANSFER_CONTROL) {
                 data->transfers += 2;
         }
@@ -179 +178 @@
                             instance, i, data->tds[i].status);
                         td_print_status(&data->tds[i]);
-                        assert(instance->ep != NULL);
-
-                        endpoint_toggle_set(instance->ep,
-                            td_toggle(&data->tds[i]));
+                        if (instance->ep != NULL)
+                                endpoint_toggle_set(instance->ep,
+                                    td_toggle(&data->tds[i]));
                         if (i > 0)
                                 goto substract_ret;

uspace/drv/uhci-hcd/batch.h

@@ -44 +44 @@
 
 usb_transfer_batch_t * batch_get(
-    ddf_fun_t *fun, endpoint_t *ep, char *buffer, size_t size,
-    char *setup_buffer, size_t setup_size,
+    ddf_fun_t *fun,
+                usb_target_t target,
+    usb_transfer_type_t transfer_type,
+                size_t max_packet_size,
+    usb_speed_t speed,
+                char *buffer,
+                size_t size,
+                char *setup_buffer,
+                size_t setup_size,
     usbhc_iface_transfer_in_callback_t func_in,
     usbhc_iface_transfer_out_callback_t func_out,
-    void *arg);
+                void *arg,
+                endpoint_t *ep
+                );
 
 void batch_dispose(usb_transfer_batch_t *instance);

uspace/drv/uhci-hcd/hc.c

@@ -332 +332 @@
             instance->transfers[batch->speed][batch->transfer_type];
         assert(list);
+        if (batch->transfer_type == USB_TRANSFER_CONTROL) {
+                usb_device_keeper_use_control(
+                    &instance->manager, batch->target);
+        }
         transfer_list_add_batch(list, batch);
 
@@ -369 +373 @@
                         usb_transfer_batch_t *batch =
                             list_get_instance(item, usb_transfer_batch_t, link);
-                        usb_transfer_batch_finish(batch);
+                        switch (batch->transfer_type)
+                        {
+                        case USB_TRANSFER_CONTROL:
+                                usb_device_keeper_release_control(
+                                    &instance->manager, batch->target);
+                                break;
+                        case USB_TRANSFER_INTERRUPT:
+                        case USB_TRANSFER_ISOCHRONOUS: {
+/*
+                                int ret = bandwidth_free(&instance->bandwidth,
+                                    batch->target.address,
+                                    batch->target.endpoint,
+                                    batch->direction);
+                                if (ret != EOK)
+                                        usb_log_warning("Failed(%d) to free "
+                                            "reserved bw: %s.\n", ret,
+                                            str_error(ret));
+*/
+                                }
+                        default:
+                                break;
+                        }
+                        batch->next_step(batch);
                 }
         }

uspace/drv/uhci-hcd/iface.c

@@ -41 +41 @@
 #include "hc.h"
 
-static inline int setup_batch(
-    ddf_fun_t *fun, usb_target_t target, usb_direction_t direction,
-    void *data, size_t size, void * setup_data, size_t setup_size,
-    usbhc_iface_transfer_in_callback_t in,
-    usbhc_iface_transfer_out_callback_t out, void *arg, const char* name,
-    hc_t **hc, usb_transfer_batch_t **batch)
-{
-        assert(hc);
-        assert(batch);
-        assert(fun);
-        *hc = fun_to_hc(fun);
-        assert(*hc);
-
-        size_t res_bw;
-        endpoint_t *ep = usb_endpoint_manager_get_ep(&(*hc)->ep_manager,
-            target.address, target.endpoint, direction, &res_bw);
-        if (ep == NULL) {
-                usb_log_error("Endpoint(%d:%d) not registered for %s.\n",
-                    target.address, target.endpoint, name);
-                return ENOENT;
-        }
-
-        const size_t bw = bandwidth_count_usb11(
-            ep->speed, ep->transfer_type, size, ep->max_packet_size);
-        if (res_bw < bw) {
-                usb_log_error("Endpoint(%d:%d) %s needs %zu bw "
-                    "but only %zu is reserved.\n",
-                    name, target.address, target.endpoint, bw, res_bw);
-                return ENOSPC;
-        }
-        usb_log_debug("%s %d:%d %zu(%zu).\n",
-            name, target.address, target.endpoint, size, ep->max_packet_size);
-
-        assert(ep->speed ==
-            usb_device_keeper_get_speed(&(*hc)->manager, target.address));
-//      assert(ep->max_packet_size == max_packet_size);
-//      assert(ep->transfer_type == USB_TRANSFER_CONTROL);
-
-        *batch =
-            batch_get(fun, ep, data, size, setup_data, setup_size,
-                in, out, arg);
-        if (!batch)
-                return ENOMEM;
-        return EOK;
-}
-
-
 /** Reserve default address interface function
  *
@@ -261 +214 @@
     size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
 {
-        usb_transfer_batch_t *batch = NULL;
-        hc_t *hc = NULL;
-        int ret = setup_batch(fun, target, USB_DIRECTION_OUT, data, size,
-            NULL, 0, NULL, callback, arg, "Interrupt OUT", &hc, &batch);
-        if (ret != EOK)
-                return ret;
+        assert(fun);
+        hc_t *hc = fun_to_hc(fun);
+        assert(hc);
+
+        usb_log_debug("Interrupt OUT %d:%d %zu.\n",
+            target.address, target.endpoint, size);
+
+        size_t res_bw;
+        endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
+            target.address, target.endpoint, USB_DIRECTION_OUT, &res_bw);
+        if (ep == NULL) {
+                usb_log_error("Endpoint(%d:%d) not registered for INT OUT.\n",
+                        target.address, target.endpoint);
+                return ENOENT;
+        }
+        const size_t bw = bandwidth_count_usb11(ep->speed, ep->transfer_type,
+            size, ep->max_packet_size);
+        if (res_bw < bw)
+        {
+                usb_log_error("Endpoint(%d:%d) INT IN needs %zu bw "
+                    "but only %zu is reserved.\n",
+                    target.address, target.endpoint, bw, res_bw);
+                return ENOENT;
+        }
+        assert(ep->speed ==
+            usb_device_keeper_get_speed(&hc->manager, target.address));
+        assert(ep->transfer_type == USB_TRANSFER_INTERRUPT);
+
+        usb_transfer_batch_t *batch =
+            batch_get(fun, target, ep->transfer_type, ep->max_packet_size,
+                ep->speed, data, size, NULL, 0, NULL, callback, arg, ep);
+        if (!batch)
+                return ENOMEM;
         batch_interrupt_out(batch);
-        ret = hc_schedule(hc, batch);
+        const int ret = hc_schedule(hc, batch);
         if (ret != EOK) {
                 batch_dispose(batch);
@@ -289 +269 @@
     size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
 {
-        usb_transfer_batch_t *batch = NULL;
-        hc_t *hc = NULL;
-        int ret = setup_batch(fun, target, USB_DIRECTION_IN, data, size,
-            NULL, 0, callback, NULL, arg, "Interrupt IN", &hc, &batch);
-        if (ret != EOK)
-                return ret;
+        assert(fun);
+        hc_t *hc = fun_to_hc(fun);
+        assert(hc);
+
+        usb_log_debug("Interrupt IN %d:%d %zu.\n",
+            target.address, target.endpoint, size);
+
+        size_t res_bw;
+        endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
+            target.address, target.endpoint, USB_DIRECTION_IN, &res_bw);
+        if (ep == NULL) {
+                usb_log_error("Endpoint(%d:%d) not registered for INT IN.\n",
+                    target.address, target.endpoint);
+                return ENOENT;
+        }
+        const size_t bw = bandwidth_count_usb11(ep->speed, ep->transfer_type,
+            size, ep->max_packet_size);
+        if (res_bw < bw)
+        {
+                usb_log_error("Endpoint(%d:%d) INT IN needs %zu bw "
+                    "but only %zu bw is reserved.\n",
+                    target.address, target.endpoint, bw, res_bw);
+                return ENOENT;
+        }
+
+        assert(ep->speed ==
+            usb_device_keeper_get_speed(&hc->manager, target.address));
+        assert(ep->transfer_type == USB_TRANSFER_INTERRUPT);
+
+        usb_transfer_batch_t *batch =
+            batch_get(fun, target, ep->transfer_type, ep->max_packet_size,
+                ep->speed, data, size, NULL, 0, callback, NULL, arg, ep);
+        if (!batch)
+                return ENOMEM;
         batch_interrupt_in(batch);
-        ret = hc_schedule(hc, batch);
+        const int ret = hc_schedule(hc, batch);
         if (ret != EOK) {
                 batch_dispose(batch);
@@ -317 +325 @@
     size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
 {
-        usb_transfer_batch_t *batch = NULL;
-        hc_t *hc = NULL;
-        int ret = setup_batch(fun, target, USB_DIRECTION_OUT, data, size,
-            NULL, 0, NULL, callback, arg, "Bulk OUT", &hc, &batch);
-        if (ret != EOK)
-                return ret;
+        assert(fun);
+        hc_t *hc = fun_to_hc(fun);
+        assert(hc);
+
+        usb_log_debug("Bulk OUT %d:%d %zu.\n",
+            target.address, target.endpoint, size);
+
+        endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
+            target.address, target.endpoint, USB_DIRECTION_OUT, NULL);
+        if (ep == NULL) {
+                usb_log_error("Endpoint(%d:%d) not registered for BULK OUT.\n",
+                        target.address, target.endpoint);
+                return ENOENT;
+        }
+        assert(ep->speed ==
+            usb_device_keeper_get_speed(&hc->manager, target.address));
+        assert(ep->transfer_type == USB_TRANSFER_BULK);
+
+        usb_transfer_batch_t *batch =
+            batch_get(fun, target, ep->transfer_type, ep->max_packet_size,
+                ep->speed, data, size, NULL, 0, NULL, callback, arg, ep);
+        if (!batch)
+                return ENOMEM;
         batch_bulk_out(batch);
-        ret = hc_schedule(hc, batch);
+        const int ret = hc_schedule(hc, batch);
         if (ret != EOK) {
                 batch_dispose(batch);
@@ -345 +370 @@
     size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
 {
-        usb_transfer_batch_t *batch = NULL;
-        hc_t *hc = NULL;
-        int ret = setup_batch(fun, target, USB_DIRECTION_IN, data, size,
-            NULL, 0, callback, NULL, arg, "Bulk IN", &hc, &batch);
-        if (ret != EOK)
-                return ret;
+        assert(fun);
+        hc_t *hc = fun_to_hc(fun);
+        assert(hc);
+        usb_log_debug("Bulk IN %d:%d %zu.\n",
+            target.address, target.endpoint, size);
+
+        endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
+            target.address, target.endpoint, USB_DIRECTION_IN, NULL);
+        if (ep == NULL) {
+                usb_log_error("Endpoint(%d:%d) not registered for BULK IN.\n",
+                        target.address, target.endpoint);
+                return ENOENT;
+        }
+        assert(ep->speed ==
+            usb_device_keeper_get_speed(&hc->manager, target.address));
+        assert(ep->transfer_type == USB_TRANSFER_BULK);
+
+        usb_transfer_batch_t *batch =
+            batch_get(fun, target, ep->transfer_type, ep->max_packet_size,
+                ep->speed, data, size, NULL, 0, callback, NULL, arg, ep);
+        if (!batch)
+                return ENOMEM;
         batch_bulk_in(batch);
-        ret = hc_schedule(hc, batch);
+        const int ret = hc_schedule(hc, batch);
         if (ret != EOK) {
                 batch_dispose(batch);
@@ -376 +417 @@
     usbhc_iface_transfer_out_callback_t callback, void *arg)
 {
-        usb_transfer_batch_t *batch = NULL;
-        hc_t *hc = NULL;
-        int ret = setup_batch(fun, target, USB_DIRECTION_BOTH, data, size,
-            setup_data, setup_size, NULL, callback, arg, "Control WRITE",
-            &hc, &batch);
-        if (ret != EOK)
-                return ret;
+        assert(fun);
+        hc_t *hc = fun_to_hc(fun);
+        assert(hc);
+        usb_speed_t speed =
+            usb_device_keeper_get_speed(&hc->manager, target.address);
+        usb_log_debug("Control WRITE (%d) %d:%d %zu.\n",
+            speed, target.address, target.endpoint, size);
+        endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
+            target.address, target.endpoint, USB_DIRECTION_BOTH, NULL);
+        if (ep == NULL) {
+                usb_log_warning("Endpoint(%d:%d) not registered for CONTROL.\n",
+                        target.address, target.endpoint);
+        }
+
+        if (setup_size != 8)
+                return EINVAL;
+
+        usb_transfer_batch_t *batch =
+            batch_get(fun, target, USB_TRANSFER_CONTROL, ep->max_packet_size, speed,
+                data, size, setup_data, setup_size, NULL, callback, arg, ep);
+        if (!batch)
+                return ENOMEM;
         usb_device_keeper_reset_if_need(&hc->manager, target, setup_data);
         batch_control_write(batch);
-        ret = hc_schedule(hc, batch);
+        const int ret = hc_schedule(hc, batch);
         if (ret != EOK) {
                 batch_dispose(batch);
@@ -409 +465 @@
     usbhc_iface_transfer_in_callback_t callback, void *arg)
 {
-        usb_transfer_batch_t *batch = NULL;
-        hc_t *hc = NULL;
-        int ret = setup_batch(fun, target, USB_DIRECTION_BOTH, data, size,
-            setup_data, setup_size, callback, NULL, arg, "Control READ",
-            &hc, &batch);
-        if (ret != EOK)
-                return ret;
+        assert(fun);
+        hc_t *hc = fun_to_hc(fun);
+        assert(hc);
+        usb_speed_t speed =
+            usb_device_keeper_get_speed(&hc->manager, target.address);
+
+        usb_log_debug("Control READ(%d) %d:%d %zu.\n",
+            speed, target.address, target.endpoint, size);
+        endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
+            target.address, target.endpoint, USB_DIRECTION_BOTH, NULL);
+        if (ep == NULL) {
+                usb_log_warning("Endpoint(%d:%d) not registered for CONTROL.\n",
+                        target.address, target.endpoint);
+        }
+        usb_transfer_batch_t *batch =
+            batch_get(fun, target, USB_TRANSFER_CONTROL, ep->max_packet_size, speed,
+                data, size, setup_data, setup_size, callback, NULL, arg, ep);
+        if (!batch)
+                return ENOMEM;
         batch_control_read(batch);
-        ret = hc_schedule(hc, batch);
+        const int ret = hc_schedule(hc, batch);
         if (ret != EOK) {
                 batch_dispose(batch);

uspace/drv/uhci-hcd/transfer_list.c

@@ -132 +132 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Create list for finished batches.
- *
- * @param[in] instance List to use.
- * @param[in] done list to fill
+/** Check list for finished batches.
+ *
+ * @param[in] instance List to use.
+ * @return Error code
+ *
+ * Creates a local list of finished batches and calls next_step on each and
+ * every one. This is safer because next_step may theoretically access
+ * this transfer list leading to the deadlock if its done inline.
  */
 void transfer_list_remove_finished(transfer_list_t *instance, link_t *done)
@@ -157 +161 @@
         }
         fibril_mutex_unlock(&instance->guard);
+
 }
 /*----------------------------------------------------------------------------*/
@@ -171 +176 @@
                     list_get_instance(current, usb_transfer_batch_t, link);
                 transfer_list_remove_batch(instance, batch);
-                usb_transfer_batch_finish_error(batch, EIO);
+                usb_transfer_batch_finish(batch, EIO);
         }
         fibril_mutex_unlock(&instance->guard);

uspace/drv/uhci-rhd/root_hub.h

@@ -40 +40 @@
 
 #define UHCI_ROOT_HUB_PORT_COUNT 2
-#define ROOT_HUB_WAIT_USEC 250000 /* 250 miliseconds */
+#define ROOT_HUB_WAIT_USEC 5000000 /* 5 seconds */
 
 typedef struct root_hub {

uspace/drv/usbkbd/kbddev.c

@@ -265 +265 @@
 static void usb_kbd_set_led(usb_kbd_t *kbd_dev) 
 {
-        if (kbd_dev->output_size == 0) {
-                return;
-        }
-        
         unsigned i = 0;
         
@@ -292 +288 @@
         
         int rc = usb_hid_report_output_translate(kbd_dev->parser, 
-            kbd_dev->led_path, 
-            USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY, 
-            kbd_dev->output_buffer, 
+            kbd_dev->led_path, USB_HID_PATH_COMPARE_END, kbd_dev->output_buffer, 
             kbd_dev->output_size, kbd_dev->led_data, kbd_dev->led_output_size);
         
@@ -545 +539 @@
  *                  according to HID Usage Tables.
  * @param count Number of key codes in report (size of the report).
- * @param report_id
+ * @param modifiers Bitmap of modifiers (Ctrl, Alt, Shift, GUI).
  * @param arg User-specified argument. Expects pointer to the keyboard device
  *            structure representing the keyboard.
@@ -552 +546 @@
  */
 static void usb_kbd_process_keycodes(const uint8_t *key_codes, size_t count,
-    uint8_t report_id, void *arg)
+    uint8_t modifiers, void *arg)
 {
         if (arg == NULL) {
@@ -563 +557 @@
         assert(kbd_dev != NULL);
 
-        usb_log_debug("Got keys from parser (report id: %u): %s\n", 
-            report_id, usb_debug_str_buffer(key_codes, count, 0));
+        usb_log_debug("Got keys from parser: %s\n", 
+            usb_debug_str_buffer(key_codes, count, 0));
         
         if (count != kbd_dev->key_count) {
@@ -614 +608 @@
         usb_hid_report_path_t *path = usb_hid_report_path();
         usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
-        usb_hid_report_path_set_report_id(path, 0);
         
         int rc = usb_hid_parse_report(kbd_dev->parser, buffer,
-            actual_size, path, 
-            USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY, 
-            callbacks, kbd_dev);
+            actual_size, path, USB_HID_PATH_COMPARE_STRICT, callbacks, kbd_dev);
 
         usb_hid_report_path_free (path);
@@ -767 +758 @@
         usb_hid_report_path_t *path = usb_hid_report_path();
         usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
-        
-        usb_hid_report_path_set_report_id(path, 0);
-        
         kbd_dev->key_count = usb_hid_report_input_length(
-            kbd_dev->parser, path, 
-            USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY);
+            kbd_dev->parser, path, USB_HID_PATH_COMPARE_STRICT);
         usb_hid_report_path_free (path);
         
@@ -790 +777 @@
         kbd_dev->output_buffer = usb_hid_report_output(kbd_dev->parser, 
             &kbd_dev->output_size);
-        if (kbd_dev->output_buffer == NULL && kbd_dev->output_size != 0) {
+        if (kbd_dev->output_buffer == NULL) {
                 usb_log_warning("Error creating output report buffer.\n");
                 free(kbd_dev->keys);
@@ -803 +790 @@
         
         kbd_dev->led_output_size = usb_hid_report_output_size(kbd_dev->parser, 
-            kbd_dev->led_path, 
-            USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY);
+            kbd_dev->led_path, USB_HID_PATH_COMPARE_END);
         
         usb_log_debug("Output report size (in items): %zu\n", 

uspace/drv/usbkbd/main.c

@@ -33 +33 @@
 /**
  * @file
- * Main routines of USB KBD driver.
+ * Main routines of USB HID driver.
  */
 
@@ -75 +75 @@
  * @sa usb_kbd_fibril(), usb_kbd_repeat_fibril()
  */
-static int usb_kbd_try_add_device(usb_device_t *dev)
+static int usbhid_try_add_device(usb_device_t *dev)
 {
         /* Create the function exposed under /dev/devices. */
@@ -105 +105 @@
                 usb_kbd_free(&kbd_dev);
                 return rc;
-        }
+        }       
         
         usb_log_debug("USB/HID KBD device structure initialized.\n");
@@ -195 +195 @@
  * @retval EREFUSED if the device is not supported.
  */
-static int usb_kbd_add_device(usb_device_t *dev)
+static int usbhid_add_device(usb_device_t *dev)
 {
-        usb_log_debug("usb_kbd_add_device()\n");
+        usb_log_debug("usbhid_add_device()\n");
         
         if (dev->interface_no < 0) {
                 usb_log_warning("Device is not a supported keyboard.\n");
-                usb_log_error("Failed to add USB KBD device: endpoint not "
-                    "found.\n");
+                usb_log_error("Failed to add HID device: endpoint not found."
+                    "\n");
                 return ENOTSUP;
         }
         
-        int rc = usb_kbd_try_add_device(dev);
+        int rc = usbhid_try_add_device(dev);
         
         if (rc != EOK) {
                 usb_log_warning("Device is not a supported keyboard.\n");
-                usb_log_error("Failed to add KBD device: %s.\n",
+                usb_log_error("Failed to add HID device: %s.\n",
                     str_error(rc));
                 return rc;
@@ -224 +224 @@
 /* Currently, the framework supports only device adding. Once the framework
  * supports unplug, more callbacks will be added. */
-static usb_driver_ops_t usb_kbd_driver_ops = {
-        .add_device = usb_kbd_add_device,
+static usb_driver_ops_t usbhid_driver_ops = {
+        .add_device = usbhid_add_device,
 };
 
 
 /* The driver itself. */
-static usb_driver_t usb_kbd_driver = {
+static usb_driver_t usbhid_driver = {
         .name = NAME,
-        .ops = &usb_kbd_driver_ops,
+        .ops = &usbhid_driver_ops,
         .endpoints = usb_kbd_endpoints
 };
@@ -238 +238 @@
 /*----------------------------------------------------------------------------*/
 
+//static driver_ops_t kbd_driver_ops = {
+//      .add_device = usbhid_add_device,
+//};
+
+///*----------------------------------------------------------------------------*/
+
+//static driver_t kbd_driver = {
+//      .name = NAME,
+//      .driver_ops = &kbd_driver_ops
+//};
+
+/*----------------------------------------------------------------------------*/
+
 int main(int argc, char *argv[])
 {
-        printf(NAME ": HelenOS USB KBD driver.\n");
+        printf(NAME ": HelenOS USB HID driver.\n");
 
         usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);
 
-        return usb_driver_main(&usb_kbd_driver);
+        return usb_driver_main(&usbhid_driver);
 }
 

uspace/drv/usbkbd/usbkbd.ma

@@ -1 @@
-10 usb&interface&class=HID&subclass=0x01&protocol=0x01
+100 usb&interface&class=HID&subclass=0x01&protocol=0x01
+10 usb&interface&class=HID

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

@@ -88 +88 @@
         /** */  
         int depth;      
-        uint8_t report_id;
         
         /** */  
         link_t link;
-
 } usb_hid_report_path_t;
 
@@ -157 +155 @@
         /** */  
         link_t feature;
-        
-        int use_report_id;
-
-        /** */
-        link_t stack;
 } usb_hid_report_parser_t;      
 
@@ -173 +166 @@
          * @param arg Custom argument.
          */
-        void (*keyboard)(const uint8_t *key_codes, size_t count, const uint8_t report_id, void *arg);
+        void (*keyboard)(const uint8_t *key_codes, size_t count, const uint8_t modifiers, void *arg);
 } usb_hid_report_in_callbacks_t;
 
@@ -276 +269 @@
 
 /** */
-int usb_hid_report_path_set_report_id(usb_hid_report_path_t *usage_path, uint8_t report_id);
-
-/** */
 int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path, int32_t usage_page, int32_t usage);
 

uspace/lib/usb/include/usb/host/batch.h

@@ -92 +92 @@
 void usb_transfer_batch_call_in(usb_transfer_batch_t *instance);
 void usb_transfer_batch_call_out(usb_transfer_batch_t *instance);
-void usb_transfer_batch_finish(usb_transfer_batch_t *instance);
-
-static inline void usb_transfer_batch_finish_error(
-    usb_transfer_batch_t *instance, int error)
-{
-        assert(instance);
-        instance->error = error;
-        usb_transfer_batch_finish(instance);
-}
+void usb_transfer_batch_finish(usb_transfer_batch_t *instance, int error);
 
 #endif

uspace/lib/usb/include/usb/host/device_keeper.h

@@ -96 +96 @@
 usb_speed_t usb_device_keeper_get_speed(usb_device_keeper_t *instance,
     usb_address_t address);
+
+void usb_device_keeper_use_control(usb_device_keeper_t *instance,
+    usb_target_t target);
+
+void usb_device_keeper_release_control(usb_device_keeper_t *instance,
+    usb_target_t target);
+
 #endif
 /**

uspace/lib/usb/include/usb/host/endpoint.h

@@ -39 +39 @@
 #include <bool.h>
 #include <adt/list.h>
-#include <fibril_synch.h>
-
 #include <usb/usb.h>
 
@@ -50 +48 @@
         usb_speed_t speed;
         size_t max_packet_size;
+        bool active;
         unsigned toggle:1;
-        fibril_mutex_t guard;
-        fibril_condvar_t avail;
-        volatile bool active;
         link_t same_device_eps;
 } endpoint_t;
@@ -62 +58 @@
 
 void endpoint_destroy(endpoint_t *instance);
-
-void endpoint_use(endpoint_t *instance);
-
-void endpoint_release(endpoint_t *instance);
 
 int endpoint_toggle_get(endpoint_t *instance);

uspace/lib/usb/src/devpoll.c

@@ -66 +66 @@
         usb_pipe_t *pipe
             = polling_data->dev->pipes[polling_data->pipe_index].pipe;
-        
-        usb_log_debug("Pipe interface number: %d, protocol: %d, subclass: %d, max packet size: %d\n", 
-            polling_data->dev->pipes[polling_data->pipe_index].interface_no,
-            polling_data->dev->pipes[polling_data->pipe_index].description->interface_protocol,
-            polling_data->dev->pipes[polling_data->pipe_index].description->interface_subclass,
-            pipe->max_packet_size);
 
         size_t failed_attempts = 0;
@@ -89 +83 @@
                 /* Quit the session regardless of errors. */
                 usb_pipe_end_session(pipe);
-                
-//              if (rc == ESTALL) {
-//                      usb_log_debug("Seding clear feature...\n");
-//                      usb_request_clear_feature(pipe, USB_REQUEST_TYPE_STANDARD,
-//                        USB_REQUEST_RECIPIENT_ENDPOINT, 0, pipe->endpoint_no);
-//                      continue;
-//              }
 
                 if (rc != EOK) {

uspace/lib/usb/src/hidparser.c

@@ -64 +64 @@
 int usb_hid_report_reset_local_items();
 void usb_hid_free_report_list(link_t *head);
-usb_hid_report_item_t *usb_hid_report_item_clone(const usb_hid_report_item_t *item);
+
 /*
  * Data translation private functions
@@ -106 +106 @@
     list_initialize(&(parser->feature));
 
-        list_initialize(&(parser->stack));
-
-        parser->use_report_id = 0;
     return EOK;   
 }
@@ -189 +186 @@
                                         tmp_usage_path = NULL;
 
-                                        usb_hid_report_path_set_report_id(report_item->usage_path, report_item->id);    
-                                        if(report_item->id != 0){
-                                                parser->use_report_id = 1;
-                                        }
                                         
                                         switch(tag) {
@@ -222 +215 @@
                                         if(!(new_report_item = malloc(sizeof(usb_hid_report_item_t)))) {
                                                 return ENOMEM;
-                                        }                                       
+                                        }
                                         memcpy(new_report_item,report_item, sizeof(usb_hid_report_item_t));
-                                        link_initialize(&(new_report_item->link));
-                                        
                                         /* reset local items */
                                         new_report_item->usage_minimum = 0;
                                         new_report_item->usage_maximum = 0;
-                                        new_report_item->designator_index = 0;
-                                        new_report_item->designator_minimum = 0;
-                                        new_report_item->designator_maximum = 0;
-                                        new_report_item->string_index = 0;
-                                        new_report_item->string_minimum = 0;
-                                        new_report_item->string_maximum = 0;
-
-                                        /* reset usage from current usage path */
-                                        usb_hid_report_usage_path_t *path = list_get_instance(&usage_path->link, usb_hid_report_usage_path_t, link);
-                                        path->usage = 0;
                                         
+                                        link_initialize(&(new_report_item->link));
                                         report_item = new_report_item;
                                                                                 
@@ -245 +227 @@
                                 case USB_HID_REPORT_TAG_PUSH:
                                         // push current state to stack
-                                        new_report_item = usb_hid_report_item_clone(report_item);
-                                        list_prepend (&parser->stack, &new_report_item->link);
-                                        
+                                        // not yet implemented
                                         break;
                                 case USB_HID_REPORT_TAG_POP:
                                         // restore current state from stack
-                                        if(list_empty (&parser->stack)) {
-                                                return EINVAL;
-                                        }
-                                        
-                                        report_item = list_get_instance(&parser->stack, usb_hid_report_item_t, link);
-                                        list_remove (parser->stack.next);
-                                        
+                                        // not yet implemented                                             
                                         break;
                                         
@@ -673 +647 @@
         }
 
-        parser->use_report_id = 0;
-
         usb_hid_free_report_list(&parser->input);
         usb_hid_free_report_list(&parser->output);
@@ -704 +676 @@
         size_t i=0;
         size_t j=0;
-        uint8_t report_id = 0;
 
         if(parser == NULL) {
@@ -715 +686 @@
         if(!(keys = malloc(sizeof(uint8_t) * key_count))){
                 return ENOMEM;
-        }
-
-        if(parser->use_report_id != 0) {
-                report_id = data[0];
-                usb_hid_report_path_set_report_id(path, report_id);
         }
 
@@ -727 +693 @@
 
                 item = list_get_instance(list_item, usb_hid_report_item_t, link);
-
                 if(!USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) && 
                    (usb_hid_report_compare_usage_path(item->usage_path, path, flags) == EOK)) {
@@ -750 +715 @@
         }
 
-        callbacks->keyboard(keys, key_count, report_id, arg);
+        callbacks->keyboard(keys, key_count, 0, arg);
            
         free(keys);     
@@ -774 +739 @@
         int32_t mask;
         const uint8_t *foo;
-
+        
         // now only common numbers llowed
         if(item->size > 32) {
@@ -793 +758 @@
                 (usb_pow(10,(item->unit_exponent))));
         }
-
         offset = item->offset + (j * item->size);
-        if(item->id != 0) {
-                offset += 8;
-                usb_log_debug("MOVED OFFSET BY 1Byte, REPORT_ID(%d)\n", item->id);
-        }
         
         // FIXME
@@ -982 +942 @@
 
         int only_page;
-
-        if(report_path->report_id != path->report_id) {
-                return 1;
-        }
 
         if(path->depth == 0){
@@ -1082 +1038 @@
         else {
                 path->depth = 0;
-                path->report_id = 0;
                 list_initialize(&path->link);
                 return path;
@@ -1200 +1155 @@
                 return 0;
         }
-
+        
         item = parser->output.next;
         while(&parser->output != item) {
@@ -1240 +1195 @@
         int length;
         int32_t tmp_value;
-        size_t offset_prefix = 0;
         
         if(parser == NULL) {
                 return EINVAL;
-        }
-
-        if(parser->use_report_id != 0) {
-                buffer[0] = path->report_id;
-                offset_prefix = 8;
         }
 
@@ -1269 +1218 @@
 //                              // variable item
                                 value = usb_hid_translate_data_reverse(report_item, data[idx++]);
-                                offset = report_item->offset + (i * report_item->size) + offset_prefix;
+                                offset = report_item->offset + (i * report_item->size);
                                 length = report_item->size;
                         }
@@ -1275 +1224 @@
                                 //bitmap
                                 value += usb_hid_translate_data_reverse(report_item, data[idx++]);
-                                offset = report_item->offset + offset_prefix;
+                                offset = report_item->offset;
                                 length = report_item->size * report_item->count;
                         }
@@ -1374 +1323 @@
 
 
-int usb_hid_report_path_set_report_id(usb_hid_report_path_t *path, uint8_t report_id)
-{
-        if(path == NULL){
-                return EINVAL;
-        }
-
-        path->report_id = report_id;
-        return EOK;
-}
-
-
-usb_hid_report_item_t *usb_hid_report_item_clone(const usb_hid_report_item_t *item)
-{
-        usb_hid_report_item_t *new_report_item;
-        
-        if(!(new_report_item = malloc(sizeof(usb_hid_report_item_t)))) {
-                return NULL;
-        }                                       
-        memcpy(new_report_item,item, sizeof(usb_hid_report_item_t));
-        link_initialize(&(new_report_item->link));
-
-        return new_report_item;
-}
-
 /**
  * @}

uspace/lib/usb/src/hidreport.c

@@ -80 +80 @@
                 d = usb_dp_get_sibling_descriptor(&parser, &parser_data, 
                     dev->descriptors.configuration, d);
-                ++i;
         }
         

uspace/lib/usb/src/host/batch.c

@@ -79 +79 @@
         instance->error = EOK;
         instance->ep = ep;
-        endpoint_use(instance->ep);
 }
 /*----------------------------------------------------------------------------*/
@@ -87 +86 @@
  *
  */
-void usb_transfer_batch_finish(usb_transfer_batch_t *instance)
+void usb_transfer_batch_finish(usb_transfer_batch_t *instance, int error)
 {
         assert(instance);
-        assert(instance->ep);
-        endpoint_release(instance->ep);
+        instance->error = error;
         instance->next_step(instance);
 }

uspace/lib/usb/src/host/device_keeper.c

@@ -264 +264 @@
         return instance->devices[address].speed;
 }
+/*----------------------------------------------------------------------------*/
+void usb_device_keeper_use_control(
+    usb_device_keeper_t *instance, usb_target_t target)
+{
+        assert(instance);
+        const uint16_t ep = 1 << target.endpoint;
+        fibril_mutex_lock(&instance->guard);
+        while (instance->devices[target.address].control_used & ep) {
+                fibril_condvar_wait(&instance->change, &instance->guard);
+        }
+        instance->devices[target.address].control_used |= ep;
+        fibril_mutex_unlock(&instance->guard);
+}
+/*----------------------------------------------------------------------------*/
+void usb_device_keeper_release_control(
+    usb_device_keeper_t *instance, usb_target_t target)
+{
+        assert(instance);
+        const uint16_t ep = 1 << target.endpoint;
+        fibril_mutex_lock(&instance->guard);
+        assert((instance->devices[target.address].control_used & ep) != 0);
+        instance->devices[target.address].control_used &= ~ep;
+        fibril_mutex_unlock(&instance->guard);
+        fibril_condvar_signal(&instance->change);
+}
 /**
  * @}

uspace/lib/usb/src/host/endpoint.c

@@ -34 +34 @@
  */
 
-#include <assert.h>
 #include <errno.h>
 #include <usb/host/endpoint.h>
@@ -50 +49 @@
         instance->max_packet_size = max_packet_size;
         instance->toggle = 0;
-        instance->active = false;
-        fibril_mutex_initialize(&instance->guard);
-        fibril_condvar_initialize(&instance->avail);
         link_initialize(&instance->same_device_eps);
         return EOK;
@@ -60 +56 @@
 {
         assert(instance);
-        assert(!instance->active);
         list_remove(&instance->same_device_eps);
         free(instance);
-}
-/*----------------------------------------------------------------------------*/
-void endpoint_use(endpoint_t *instance)
-{
-        assert(instance);
-        fibril_mutex_lock(&instance->guard);
-        while (instance->active)
-                fibril_condvar_wait(&instance->avail, &instance->guard);
-        instance->active = true;
-        fibril_mutex_unlock(&instance->guard);
-}
-/*----------------------------------------------------------------------------*/
-void endpoint_release(endpoint_t *instance)
-{
-        assert(instance);
-        fibril_mutex_lock(&instance->guard);
-        instance->active = false;
-        fibril_mutex_unlock(&instance->guard);
-        fibril_condvar_signal(&instance->avail);
 }
 /*----------------------------------------------------------------------------*/

uspace/lib/usb/src/hub.c

@@ -178 +178 @@
  * error codes than those listed as return codes by this function itself).
  *
- * The @p connection representing connection with host controller does not
- * need to be started.
- * This function duplicates the connection to allow simultaneous calls of
- * this function (i.e. from different fibrils).
- *
  * @param[in] parent Parent device (i.e. the hub device).
- * @param[in] connection Connection to host controller.
+ * @param[in] connection Opened connection to host controller.
  * @param[in] dev_speed New device speed.
  * @param[in] enable_port Function for enabling signaling through the port the
@@ -211 +206 @@
     ddf_dev_ops_t *dev_ops, void *new_dev_data, ddf_fun_t **new_fun)
 {
-        assert(connection != NULL);
-        // FIXME: this is awful, we are accessing directly the structure.
-        usb_hc_connection_t hc_conn = {
-                .hc_handle = connection->hc_handle,
-                .hc_phone = -1
-        };
+        CHECK_CONNECTION(connection);
+
+        /*
+         * Request new address.
+         */
+        usb_address_t dev_addr = usb_hc_request_address(connection, dev_speed);
+        if (dev_addr < 0) {
+                return EADDRNOTAVAIL;
+        }
 
         int rc;
 
-        rc = usb_hc_connection_open(&hc_conn);
-        if (rc != EOK) {
-                return rc;
-        }
-
-
-        /*
-         * Request new address.
-         */
-        usb_address_t dev_addr = usb_hc_request_address(&hc_conn, dev_speed);
-        if (dev_addr < 0) {
-                usb_hc_connection_close(&hc_conn);
-                return EADDRNOTAVAIL;
-        }
-
-
         /*
          * Reserve the default address.
          */
-        rc = usb_hc_reserve_default_address(&hc_conn, dev_speed);
+        rc = usb_hc_reserve_default_address(connection, dev_speed);
         if (rc != EOK) {
                 rc = EBUSY;
@@ -259 +241 @@
         usb_device_connection_t dev_conn;
         rc = usb_device_connection_initialize_on_default_address(&dev_conn,
-            &hc_conn);
+            connection);
         if (rc != EOK) {
                 rc = ENOTCONN;
@@ -276 +258 @@
          * endpoint.
          */
-        rc = usb_pipe_register(&ctrl_pipe, 0, &hc_conn);
+        rc = usb_pipe_register(&ctrl_pipe, 0, connection);
         if (rc != EOK) {
                 rc = EREFUSED;
@@ -304 +286 @@
          * Register the control endpoint for the new device.
          */
-        rc = usb_pipe_register(&ctrl_pipe, 0, &hc_conn);
+        rc = usb_pipe_register(&ctrl_pipe, 0, connection);
         if (rc != EOK) {
                 rc = EREFUSED;
@@ -313 +295 @@
          * Release the original endpoint.
          */
-        unregister_control_endpoint_on_default_address(&hc_conn);
+        unregister_control_endpoint_on_default_address(connection);
 
         /*
          * Once the address is changed, we can return the default address.
          */
-        usb_hc_release_default_address(&hc_conn);
+        usb_hc_release_default_address(connection);
 
 
@@ -343 +325 @@
                 .handle = child_handle
         };
-        rc = usb_hc_register_device(&hc_conn, &new_device);
+        rc = usb_hc_register_device(connection, &new_device);
         if (rc != EOK) {
                 rc = EDESTADDRREQ;
@@ -372 +354 @@
 
 leave_unregister_endpoint:
-        usb_pipe_unregister(&ctrl_pipe, &hc_conn);
+        usb_pipe_unregister(&ctrl_pipe, connection);
 
 leave_release_default_address:
-        usb_hc_release_default_address(&hc_conn);
+        usb_hc_release_default_address(connection);
 
 leave_release_free_address:
-        usb_hc_unregister_device(&hc_conn, dev_addr);
-
-        usb_hc_connection_close(&hc_conn);
+        usb_hc_unregister_device(connection, dev_addr);
 
         return rc;