Changeset 4deca9b in mainline

Timestamp:

2011-04-12T11:43:35Z (13 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

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

Children:

651b352

Parents:

1324ff3 (diff), 910ca3f (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:

Extensive cleanup, preparation for OHCI rework

Location:

uspace

Files:

• drv/ohci/batch.c (modified) (14 diffs)
• drv/ohci/hc.c (modified) (6 diffs)
• drv/ohci/root_hub.c (modified) (6 diffs)
• drv/ohci/root_hub.h (modified) (2 diffs)
• drv/uhci-hcd/batch.c (modified) (23 diffs)
• drv/uhci-hcd/hc.c (modified) (1 diff)
• drv/uhci-hcd/iface.c (modified) (2 diffs)
• lib/usb/include/usb/host/batch.h (modified) (3 diffs)
• lib/usb/include/usb/host/device_keeper.h (modified) (2 diffs)
• lib/usb/include/usb/host/usb_endpoint_manager.h (modified) (2 diffs)
• lib/usb/src/host/batch.c (modified) (6 diffs)
• lib/usb/src/host/device_keeper.c (modified) (7 diffs)

uspace/drv/ohci/batch.c

@@ -73 +73 @@
         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, buffer, NULL, buffer_size, NULL, setup_size,
-            func_in, func_out, arg, fun, ep, NULL);
+        usb_transfer_batch_init(instance, ep, buffer, NULL, buffer_size,
+            NULL, setup_size, func_in, func_out, arg, fun, NULL);
 
         ohci_batch_t *data = malloc(sizeof(ohci_batch_t));
@@ -101 +98 @@
 
         if (buffer_size > 0) {
-                instance->transport_buffer = malloc32(buffer_size);
-                CHECK_NULL_DISPOSE_RETURN(instance->transport_buffer,
+                instance->data_buffer = malloc32(buffer_size);
+                CHECK_NULL_DISPOSE_RETURN(instance->data_buffer,
                     "Failed to allocate device accessible buffer.\n");
         }
@@ -124 +121 @@
         free32(data->tds);
         free32(instance->setup_buffer);
-        free32(instance->transport_buffer);
+        free32(instance->data_buffer);
         free(data);
         free(instance);
@@ -165 +162 @@
         assert(instance);
         /* We are data out, we are supposed to provide data */
-        memcpy(instance->transport_buffer, instance->buffer,
-            instance->buffer_size);
+        memcpy(instance->data_buffer, instance->buffer, instance->buffer_size);
         instance->next_step = batch_call_out_and_dispose;
         batch_control(instance, USB_DIRECTION_OUT, USB_DIRECTION_IN);
@@ -183 +179 @@
 {
         assert(instance);
-        assert(instance->direction == USB_DIRECTION_IN);
         instance->next_step = batch_call_in_and_dispose;
         batch_data(instance);
@@ -192 +187 @@
 {
         assert(instance);
-        assert(instance->direction == USB_DIRECTION_OUT);
         /* We are data out, we are supposed to provide data */
-        memcpy(instance->transport_buffer, instance->buffer,
-            instance->buffer_size);
+        memcpy(instance->data_buffer, instance->buffer, instance->buffer_size);
         instance->next_step = batch_call_out_and_dispose;
         batch_data(instance);
@@ -204 +197 @@
 {
         assert(instance);
-        instance->direction = USB_DIRECTION_IN;
         instance->next_step = batch_call_in_and_dispose;
         batch_data(instance);
@@ -213 +205 @@
 {
         assert(instance);
-        instance->direction = USB_DIRECTION_IN;
         instance->next_step = batch_call_in_and_dispose;
         batch_data(instance);
@@ -249 +240 @@
         size_t td_current = 1;
         size_t remain_size = instance->buffer_size;
-        char *transfer_buffer = instance->transport_buffer;
+        char *buffer = instance->data_buffer;
         while (remain_size > 0) {
                 size_t transfer_size = remain_size > OHCI_TD_MAX_TRANSFER ?
@@ -255 +246 @@
                 toggle = 1 - toggle;
 
-                td_init(&data->tds[td_current], data_dir, transfer_buffer,
+                td_init(&data->tds[td_current], data_dir, buffer,
                     transfer_size, toggle);
                 td_set_next(&data->tds[td_current], &data->tds[td_current + 1]);
@@ -262 +253 @@
                     data->tds[td_current].next, data->tds[td_current].be);
 
-                transfer_buffer += transfer_size;
+                buffer += transfer_size;
                 remain_size -= transfer_size;
                 assert(td_current < data->td_count - 2);
@@ -290 +281 @@
         size_t td_current = 0;
         size_t remain_size = instance->buffer_size;
-        char *transfer_buffer = instance->transport_buffer;
+        char *buffer = instance->data_buffer;
         while (remain_size > 0) {
                 size_t transfer_size = remain_size > OHCI_TD_MAX_TRANSFER ?
@@ -296 +287 @@
 
                 td_init(&data->tds[td_current], instance->ep->direction,
-                    transfer_buffer, transfer_size, -1);
+                    buffer, transfer_size, -1);
                 td_set_next(&data->tds[td_current], &data->tds[td_current + 1]);
                 usb_log_debug("Created DATA TD: %x:%x:%x:%x.\n",
@@ -302 +293 @@
                     data->tds[td_current].next, data->tds[td_current].be);
 
-                transfer_buffer += transfer_size;
+                buffer += transfer_size;
                 remain_size -= transfer_size;
                 assert(td_current < data->td_count);

uspace/drv/ohci/hc.c

@@ -55 +55 @@
         assert(hub_fun);
 
+        int ret;
+
         usb_address_t hub_address =
             device_keeper_get_free_address(&instance->manager, USB_SPEED_FULL);
+        if (hub_address <= 0) {
+                usb_log_error("Failed to get OHCI root hub address.\n");
+                return hub_address;
+        }
         instance->rh.address = hub_address;
         usb_device_keeper_bind(
             &instance->manager, hub_address, hub_fun->handle);
 
-        endpoint_t *ep = malloc(sizeof(endpoint_t));
-        assert(ep);
-        int ret = endpoint_init(ep, hub_address, 0, USB_DIRECTION_BOTH,
-            USB_TRANSFER_CONTROL, USB_SPEED_FULL, 64);
-        assert(ret == EOK);
-        ret = usb_endpoint_manager_register_ep(&instance->ep_manager, ep, 0);
-        assert(ret == EOK);
+        ret = usb_endpoint_manager_add_ep(&instance->ep_manager,
+            hub_address, 0, USB_DIRECTION_BOTH, USB_TRANSFER_CONTROL,
+            USB_SPEED_FULL, 64, 0);
+        if (ret != EOK) {
+                usb_log_error("Failed to add OHCI rh endpoint 0.\n");
+                usb_device_keeper_release(&instance->manager, hub_address);
+                return ret;
+        }
 
         char *match_str = NULL;
+        /* DDF needs heap allocated string */
         ret = asprintf(&match_str, "usb&class=hub");
-//      ret = (match_str == NULL) ? ret : EOK;
         if (ret < 0) {
                 usb_log_error(
                     "Failed(%d) to create root hub match-id string.\n", ret);
+                usb_device_keeper_release(&instance->manager, hub_address);
                 return ret;
         }
@@ -80 +88 @@
         ret = ddf_fun_add_match_id(hub_fun, match_str, 100);
         if (ret != EOK) {
-                usb_log_error("Failed add create root hub match-id.\n");
+                usb_log_error("Failed add root hub match-id.\n");
         }
         return ret;
@@ -115 +123 @@
         fibril_mutex_initialize(&instance->guard);
 
-        rh_init(&instance->rh, dev, instance->registers);
+        rh_init(&instance->rh, instance->registers);
 
         if (!interrupts) {
@@ -130 +138 @@
         assert(instance);
         assert(batch);
+        assert(batch->ep);
 
         /* check for root hub communication */
-        if (batch->target.address == instance->rh.address) {
+        if (batch->ep->address == instance->rh.address) {
                 return rh_request(&instance->rh, batch);
         }
 
         fibril_mutex_lock(&instance->guard);
-        switch (batch->transfer_type) {
+        switch (batch->ep->transfer_type) {
         case USB_TRANSFER_CONTROL:
                 instance->registers->control &= ~C_CLE;
                 transfer_list_add_batch(
-                    instance->transfers[batch->transfer_type], batch);
+                    instance->transfers[batch->ep->transfer_type], batch);
                 instance->registers->command_status |= CS_CLF;
                 usb_log_debug2("Set CS control transfer filled: %x.\n",
@@ -151 +160 @@
                 instance->registers->control &= ~C_BLE;
                 transfer_list_add_batch(
-                    instance->transfers[batch->transfer_type], batch);
+                    instance->transfers[batch->ep->transfer_type], batch);
                 instance->registers->command_status |= CS_BLF;
                 usb_log_debug2("Set bulk transfer filled: %x.\n",
@@ -161 +170 @@
                 instance->registers->control &= (~C_PLE & ~C_IE);
                 transfer_list_add_batch(
-                    instance->transfers[batch->transfer_type], batch);
+                    instance->transfers[batch->ep->transfer_type], batch);
                 instance->registers->control |= C_PLE | C_IE;
                 usb_log_debug2("Added periodic transfer: %x.\n",

uspace/drv/ohci/root_hub.c

@@ -205 +205 @@
  * @return Error code.
  */
-int rh_init(rh_t *instance, ddf_dev_t *dev, ohci_regs_t *regs) {
+int rh_init(rh_t *instance, ohci_regs_t *regs) {
         assert(instance);
-        //instance->address = -1;
         instance->registers = regs;
-        instance->device = dev;
         instance->port_count =
             (instance->registers->rh_desc_a >> RHDA_NDS_SHIFT) & RHDA_NDS_MASK;
         rh_init_descriptors(instance);
         // set port power mode to no-power-switching
-        instance->registers->rh_desc_a =
-                instance->registers->rh_desc_a | (1<<9);
+        instance->registers->rh_desc_a |= RHDA_NPS_FLAG;
 
         usb_log_info("OHCI root hub with %d ports.\n", instance->port_count);
-
-        //start generic usb hub driver
-
-        /* TODO: implement */
         return EOK;
 }
@@ -237 +230 @@
         assert(request);
         int opResult;
-        if (request->transfer_type == USB_TRANSFER_CONTROL) {
+        if (request->ep->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) {
+        } else if (request->ep->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,
+                memcpy(request->data_buffer, buffer,
                         request->transfered_size);
                 opResult = EOK;
@@ -374 +367 @@
         if (port < 1 || port > instance->port_count)
                 return EINVAL;
-        uint32_t * uint32_buffer = (uint32_t*) request->transport_buffer;
+        uint32_t * uint32_buffer = (uint32_t*) request->data_buffer;
         request->transfered_size = 4;
         uint32_buffer[0] = instance->registers->rh_port_status[port - 1];
@@ -400 +393 @@
 static int process_get_hub_status_request(rh_t *instance,
         usb_transfer_batch_t * request) {
-        uint32_t * uint32_buffer = (uint32_t*) request->transport_buffer;
+        uint32_t * uint32_buffer = (uint32_t*) request->data_buffer;
         request->transfered_size = 4;
         //bits, 0,1,16,17
@@ -550 +543 @@
         }
         request->transfered_size = size;
-        memcpy(request->transport_buffer, result_descriptor, size);
+        memcpy(request->data_buffer, result_descriptor, size);
         if (del)
                 free(result_descriptor);
@@ -571 +564 @@
         if (request->buffer_size != 1)
                 return EINVAL;
-        request->transport_buffer[0] = 1;
+        request->data_buffer[0] = 1;
         request->transfered_size = 1;
         return EOK;

uspace/drv/ohci/root_hub.h

@@ -50 +50 @@
         /** usb address of the root hub */
         usb_address_t address;
-        /** ddf device information */
-        ddf_dev_t *device;
         /** hub port count */
         int port_count;
@@ -58 +56 @@
 } rh_t;
 
-int rh_init(rh_t *instance, ddf_dev_t *dev, ohci_regs_t *regs);
+int rh_init(rh_t *instance, ohci_regs_t *regs);
 
 int rh_request(rh_t *instance, usb_transfer_batch_t *request);

uspace/drv/uhci-hcd/batch.c

@@ -30 +30 @@
  */
 /** @file
- * @brief UHCI driver USB transaction structure
+ * @brief UHCI driver USB transfer structure
  */
 #include <errno.h>
@@ -48 +48 @@
         qh_t *qh;
         td_t *tds;
-        size_t transfers;
+        size_t td_count;
 } uhci_batch_t;
 
@@ -61 +61 @@
  *
  * @param[in] fun DDF function to pass to callback.
- * @param[in] target Device and endpoint target of the transaction.
- * @param[in] transfer_type Interrupt, Control or Bulk.
- * @param[in] max_packet_size maximum allowed size of data transfers.
- * @param[in] speed Speed of the transaction.
+ * @param[in] ep Communication target
  * @param[in] buffer Data source/destination.
  * @param[in] size Size of the buffer.
  * @param[in] setup_buffer Setup data source (if not NULL)
  * @param[in] setup_size Size of setup_buffer (should be always 8)
- * @param[in] func_in function to call on inbound transaction completion
- * @param[in] func_out function to call on outbound transaction completion
+ * @param[in] func_in function to call on inbound transfer completion
+ * @param[in] func_out function to call on outbound transfer completion
  * @param[in] arg additional parameter to func_in or func_out
- * @param[in] ep Pointer to endpoint toggle management structure.
  * @return Valid pointer if all substructures were successfully created,
  * NULL otherwise.
  *
- * Determines the number of needed transfers (TDs). Prepares a transport buffer
- * (that is accessible by the hardware). Initializes parameters needed for the
- * transaction and callback.
+ * Determines the number of needed transfer descriptors (TDs).
+ * Prepares a transport buffer (that is accessible by the hardware).
+ * Initializes parameters needed for the transfer and callback.
  */
 usb_transfer_batch_t * batch_get(ddf_fun_t *fun, endpoint_t *ep,
@@ -103 +99 @@
         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, buffer, NULL, buffer_size, NULL, setup_size,
-            func_in, func_out, arg, fun, ep, NULL);
+        usb_transfer_batch_init(instance, ep,
+            buffer, NULL, buffer_size, NULL, setup_size,
+            func_in, func_out, arg, fun, NULL);
 
 
@@ -113 +109 @@
         instance->private_data = data;
 
-        data->transfers =
+        data->td_count =
             (buffer_size + ep->max_packet_size - 1) / ep->max_packet_size;
         if (ep->transfer_type == USB_TRANSFER_CONTROL) {
-                data->transfers += 2;
-        }
-
-        data->tds = malloc32(sizeof(td_t) * data->transfers);
+                data->td_count += 2;
+        }
+
+        data->tds = malloc32(sizeof(td_t) * data->td_count);
         CHECK_NULL_DISPOSE_RETURN(
             data->tds, "Failed to allocate transfer descriptors.\n");
-        bzero(data->tds, sizeof(td_t) * data->transfers);
+        bzero(data->tds, sizeof(td_t) * data->td_count);
 
         data->qh = malloc32(sizeof(qh_t));
@@ -131 +127 @@
 
         if (buffer_size > 0) {
-                instance->transport_buffer = malloc32(buffer_size);
-                CHECK_NULL_DISPOSE_RETURN(instance->transport_buffer,
+                instance->data_buffer = malloc32(buffer_size);
+                CHECK_NULL_DISPOSE_RETURN(instance->data_buffer,
                     "Failed to allocate device accessible buffer.\n");
         }
@@ -154 +150 @@
  *
  * Walk all TDs. Stop with false if there is an active one (it is to be
- * processed). Stop with true if an error is found. Return true if the last TS
+ * processed). Stop with true if an error is found. Return true if the last TD
  * is reached.
  */
@@ -164 +160 @@
 
         usb_log_debug2("Batch(%p) checking %d transfer(s) for completion.\n",
-            instance, data->transfers);
+            instance, data->td_count);
         instance->transfered_size = 0;
         size_t i = 0;
-        for (;i < data->transfers; ++i) {
+        for (;i < data->td_count; ++i) {
                 if (td_is_active(&data->tds[i])) {
                         return false;
@@ -177 +173 @@
                             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]));
@@ -195 +191 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Prepares control write transaction.
- *
- * @param[in] instance Batch structure to use.
- *
- * Uses genercir control function with pids OUT and IN.
+/** Prepares control write transfer.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Uses generic control function with pids OUT and IN.
  */
 void batch_control_write(usb_transfer_batch_t *instance)
@@ -205 +201 @@
         assert(instance);
         /* We are data out, we are supposed to provide data */
-        memcpy(instance->transport_buffer, instance->buffer,
-            instance->buffer_size);
+        memcpy(instance->data_buffer, instance->buffer, instance->buffer_size);
         batch_control(instance, USB_PID_OUT, USB_PID_IN);
         instance->next_step = batch_call_out_and_dispose;
@@ -212 +207 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Prepares control read transaction.
+/** Prepares control read transfer.
  *
  * @param[in] instance Batch structure to use.
@@ -226 +221 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Prepare interrupt in transaction.
- *
- * @param[in] instance Batch structure to use.
- *
- * Data transaction with PID_IN.
+/** Prepare interrupt in transfer.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Data transfer with PID_IN.
  */
 void batch_interrupt_in(usb_transfer_batch_t *instance)
 {
         assert(instance);
-        instance->direction = USB_DIRECTION_IN;
         batch_data(instance, USB_PID_IN);
         instance->next_step = batch_call_in_and_dispose;
@@ -241 +235 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Prepare interrupt out transaction.
- *
- * @param[in] instance Batch structure to use.
- *
- * Data transaction with PID_OUT.
+/** Prepare interrupt out transfer.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Data transfer with PID_OUT.
  */
 void batch_interrupt_out(usb_transfer_batch_t *instance)
 {
         assert(instance);
-        instance->direction = USB_DIRECTION_OUT;
         /* We are data out, we are supposed to provide data */
-        memcpy(instance->transport_buffer, instance->buffer,
-            instance->buffer_size);
+        memcpy(instance->data_buffer, instance->buffer, instance->buffer_size);
         batch_data(instance, USB_PID_OUT);
         instance->next_step = batch_call_out_and_dispose;
@@ -259 +251 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Prepare bulk in transaction.
- *
- * @param[in] instance Batch structure to use.
- *
- * Data transaction with PID_IN.
+/** Prepare bulk in transfer.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Data transfer with PID_IN.
  */
 void batch_bulk_in(usb_transfer_batch_t *instance)
@@ -269 +261 @@
         assert(instance);
         batch_data(instance, USB_PID_IN);
-        instance->direction = USB_DIRECTION_IN;
         instance->next_step = batch_call_in_and_dispose;
         usb_log_debug("Batch(%p) BULK IN initialized.\n", instance);
 }
 /*----------------------------------------------------------------------------*/
-/** Prepare bulk out transaction.
- *
- * @param[in] instance Batch structure to use.
- *
- * Data transaction with PID_OUT.
+/** Prepare bulk out transfer.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Data transfer with PID_OUT.
  */
 void batch_bulk_out(usb_transfer_batch_t *instance)
 {
         assert(instance);
-        instance->direction = USB_DIRECTION_OUT;
         /* We are data out, we are supposed to provide data */
-        memcpy(instance->transport_buffer, instance->buffer,
-            instance->buffer_size);
+        memcpy(instance->data_buffer, instance->buffer, instance->buffer_size);
         batch_data(instance, USB_PID_OUT);
         instance->next_step = batch_call_out_and_dispose;
@@ -292 +281 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Prepare generic data transaction
- *
- * @param[in] instance Batch structure to use.
- * @param[in] pid Pid to use for data transfers.
- *
- * Packets with alternating toggle bit and supplied pid value.
+/** Prepare generic data transfer
+ *
+ * @param[in] instance Batch structure to use.
+ * @param[in] pid Pid to use for data transactions.
+ *
+ * Transactions with alternating toggle bit and supplied pid value.
  * The last transfer is marked with IOC flag.
  */
@@ -306 +295 @@
         assert(data);
 
-        const bool low_speed = instance->speed == USB_SPEED_LOW;
+        const bool low_speed = instance->ep->speed == USB_SPEED_LOW;
         int toggle = endpoint_toggle_get(instance->ep);
         assert(toggle == 0 || toggle == 1);
 
-        size_t transfer = 0;
+        size_t td = 0;
         size_t remain_size = instance->buffer_size;
+        char *buffer = instance->data_buffer;
         while (remain_size > 0) {
-                char *trans_data =
-                    instance->transport_buffer + instance->buffer_size
-                    - remain_size;
-
                 const size_t packet_size =
-                    (instance->max_packet_size > remain_size) ?
-                    remain_size : instance->max_packet_size;
-
-                td_t *next_transfer = (transfer + 1 < data->transfers)
-                    ? &data->tds[transfer + 1] : NULL;
-
-                assert(transfer < data->transfers);
+                    (instance->ep->max_packet_size > remain_size) ?
+                    remain_size : instance->ep->max_packet_size;
+
+                td_t *next_td = (td + 1 < data->td_count)
+                    ? &data->tds[td + 1] : NULL;
+
+
+                usb_target_t target =
+                    { instance->ep->address, instance->ep->endpoint };
+
+                assert(td < data->td_count);
+                td_init(
+                    &data->tds[td], DEFAULT_ERROR_COUNT, packet_size,
+                    toggle, false, low_speed, target, pid, buffer, next_td);
+
+                ++td;
+                toggle = 1 - toggle;
+                buffer += packet_size;
                 assert(packet_size <= remain_size);
-
-                td_init(
-                    &data->tds[transfer], DEFAULT_ERROR_COUNT, packet_size,
-                    toggle, false, low_speed, instance->target, pid, trans_data,
-                    next_transfer);
-
-
-                toggle = 1 - toggle;
                 remain_size -= packet_size;
-                ++transfer;
-        }
-        td_set_ioc(&data->tds[transfer - 1]);
+        }
+        td_set_ioc(&data->tds[td - 1]);
         endpoint_toggle_set(instance->ep, toggle);
 }
 /*----------------------------------------------------------------------------*/
-/** Prepare generic control transaction
- *
- * @param[in] instance Batch structure to use.
- * @param[in] data_stage Pid to use for data transfers.
- * @param[in] status_stage Pid to use for data transfers.
+/** Prepare generic control transfer
+ *
+ * @param[in] instance Batch structure to use.
+ * @param[in] data_stage Pid to use for data tds.
+ * @param[in] status_stage Pid to use for data tds.
  *
  * Setup stage with toggle 0 and USB_PID_SETUP.
@@ -358 +346 @@
         uhci_batch_t *data = instance->private_data;
         assert(data);
-        assert(data->transfers >= 2);
-
-        const bool low_speed = instance->speed == USB_SPEED_LOW;
-        int toggle = 0;
+        assert(data->td_count >= 2);
+
+        const bool low_speed = instance->ep->speed == USB_SPEED_LOW;
+        const usb_target_t target =
+            { instance->ep->address, instance->ep->endpoint };
+
         /* setup stage */
         td_init(
-            data->tds, DEFAULT_ERROR_COUNT, instance->setup_size, toggle, false,
-            low_speed, instance->target, USB_PID_SETUP, instance->setup_buffer,
+            data->tds, DEFAULT_ERROR_COUNT, instance->setup_size, 0, false,
+            low_speed, target, USB_PID_SETUP, instance->setup_buffer,
             &data->tds[1]);
 
         /* data stage */
-        size_t transfer = 1;
+        size_t td = 1;
+        unsigned toggle = 1;
         size_t remain_size = instance->buffer_size;
+        char *buffer = instance->data_buffer;
         while (remain_size > 0) {
-                char *control_data =
-                    instance->transport_buffer + instance->buffer_size
-                    - remain_size;
-
+                const size_t packet_size =
+                    (instance->ep->max_packet_size > remain_size) ?
+                    remain_size : instance->ep->max_packet_size;
+
+                td_init(
+                    &data->tds[td], DEFAULT_ERROR_COUNT, packet_size,
+                    toggle, false, low_speed, target, data_stage,
+                    buffer, &data->tds[td + 1]);
+
+                ++td;
                 toggle = 1 - toggle;
-
-                const size_t packet_size =
-                    (instance->max_packet_size > remain_size) ?
-                    remain_size : instance->max_packet_size;
-
-                td_init(
-                    &data->tds[transfer], DEFAULT_ERROR_COUNT, packet_size,
-                    toggle, false, low_speed, instance->target, data_stage,
-                    control_data, &data->tds[transfer + 1]);
-
-                ++transfer;
-                assert(transfer < data->transfers);
+                buffer += packet_size;
+                assert(td < data->td_count);
                 assert(packet_size <= remain_size);
                 remain_size -= packet_size;
@@ -394 +382 @@
 
         /* status stage */
-        assert(transfer == data->transfers - 1);
+        assert(td == data->td_count - 1);
 
         td_init(
-            &data->tds[transfer], DEFAULT_ERROR_COUNT, 0, 1, false, low_speed,
-            instance->target, status_stage, NULL, NULL);
-        td_set_ioc(&data->tds[transfer]);
+            &data->tds[td], DEFAULT_ERROR_COUNT, 0, 1, false, low_speed,
+            target, status_stage, NULL, NULL);
+        td_set_ioc(&data->tds[td]);
 
         usb_log_debug2("Control last TD status: %x.\n",
-            data->tds[transfer].status);
+            data->tds[td].status);
 }
 /*----------------------------------------------------------------------------*/
@@ -413 +401 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Helper function calls callback and correctly disposes of batch structure.
+/** Helper function, calls callback and correctly destroys batch structure.
  *
  * @param[in] instance Batch structure to use.
@@ -424 +412 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Helper function calls callback and correctly disposes of batch structure.
+/** Helper function calls callback and correctly destroys batch structure.
  *
  * @param[in] instance Batch structure to use.
@@ -449 +437 @@
         free32(data->qh);
         free32(instance->setup_buffer);
-        free32(instance->transport_buffer);
+        free32(instance->data_buffer);
         free(data);
         free(instance);

uspace/drv/uhci-hcd/hc.c

@@ -329 +329 @@
 
         transfer_list_t *list =
-            instance->transfers[batch->speed][batch->transfer_type];
+            instance->transfers[batch->ep->speed][batch->ep->transfer_type];
         assert(list);
         transfer_list_add_batch(list, batch);

uspace/drv/uhci-hcd/iface.c

@@ -148 +148 @@
         assert(hc);
         const size_t size = max_packet_size;
-        int ret;
         usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, address);
         if (speed >= USB_SPEED_MAX) {
@@ -157 +156 @@
             usb_str_speed(speed), direction, size, max_packet_size, interval);
 
-
-        endpoint_t *ep = malloc(sizeof(endpoint_t));
-        if (ep == NULL)
-                return ENOMEM;
-        ret = endpoint_init(ep, address, endpoint, direction,
-            transfer_type, speed, max_packet_size);
-        if (ret != EOK) {
-                free(ep);
-                return ret;
-        }
-
-        ret = usb_endpoint_manager_register_ep(&hc->ep_manager, ep, size);
-        if (ret != EOK) {
-                endpoint_destroy(ep);
-        }
-        return ret;
+        return usb_endpoint_manager_add_ep(&hc->ep_manager, address, endpoint,
+            direction, transfer_type, speed, max_packet_size, size);
 }
 /*----------------------------------------------------------------------------*/

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

@@ -43 +43 @@
 typedef struct usb_transfer_batch usb_transfer_batch_t;
 struct usb_transfer_batch {
+        endpoint_t *ep;
         link_t link;
-        usb_target_t target;
-        usb_transfer_type_t transfer_type;
-        usb_speed_t speed;
-        usb_direction_t direction;
         usbhc_iface_transfer_in_callback_t callback_in;
         usbhc_iface_transfer_out_callback_t callback_out;
+        void *arg;
         char *buffer;
-        char *transport_buffer;
+        char *data_buffer;
         size_t buffer_size;
         char *setup_buffer;
         size_t setup_size;
-        size_t max_packet_size;
         size_t transfered_size;
         void (*next_step)(usb_transfer_batch_t *);
         int error;
         ddf_fun_t *fun;
-        void *arg;
-        endpoint_t *ep;
         void *private_data;
 };
@@ -67 +62 @@
 void usb_transfer_batch_init(
     usb_transfer_batch_t *instance,
-    usb_target_t target,
-    usb_transfer_type_t transfer_type,
-    usb_speed_t speed,
-    size_t max_packet_size,
+                endpoint_t *ep,
     char *buffer,
-    char *transport_buffer,
+    char *data_buffer,
     size_t buffer_size,
     char *setup_buffer,
@@ -80 +72 @@
     void *arg,
     ddf_fun_t *fun,
-                endpoint_t *ep,
     void *private_data
 );

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

@@ -54 +54 @@
         usb_speed_t speed;
         bool occupied;
-        link_t endpoints;
-        uint16_t control_used;
         devman_handle_t handle;
 };
@@ -65 +63 @@
         struct usb_device_info devices[USB_ADDRESS_COUNT];
         fibril_mutex_t guard;
-        fibril_condvar_t change;
         usb_address_t last_address;
 } usb_device_keeper_t;
 
 void usb_device_keeper_init(usb_device_keeper_t *instance);
-
-void usb_device_keeper_reserve_default_address(
-    usb_device_keeper_t *instance, usb_speed_t speed);
-
-void usb_device_keeper_release_default_address(usb_device_keeper_t *instance);
-
-void usb_device_keeper_reset_if_need(usb_device_keeper_t *instance,
-    usb_target_t target, const uint8_t *setup_data);
 
 usb_address_t device_keeper_get_free_address(usb_device_keeper_t *instance,

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

@@ -66 +66 @@
     endpoint_t *ep, size_t data_size);
 
-int usb_endpoint_manager_register_ep_wait(usb_endpoint_manager_t *instance,
-    usb_address_t address, usb_endpoint_t ep, usb_direction_t direction,
-    void *data, void (*data_remove_callback)(void* data, void* arg), void *arg,
-    size_t bw);
-
 int usb_endpoint_manager_unregister_ep(usb_endpoint_manager_t *instance,
     usb_address_t address, usb_endpoint_t ep, usb_direction_t direction);
@@ -80 +75 @@
 void usb_endpoint_manager_reset_if_need(
     usb_endpoint_manager_t *instance, usb_target_t target, const uint8_t *data);
+
+static inline int usb_endpoint_manager_add_ep(usb_endpoint_manager_t *instance,
+    usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction,
+    usb_transfer_type_t type, usb_speed_t speed, size_t max_packet_size,
+    size_t data_size)
+{
+        endpoint_t *ep = malloc(sizeof(endpoint_t));
+        if (ep == NULL)
+                return ENOMEM;
+
+        int ret = endpoint_init(ep, address, endpoint, direction, type, speed,
+            max_packet_size);
+        if (ret != EOK) {
+                free(ep);
+                return ret;
+        }
+
+        ret = usb_endpoint_manager_register_ep(instance, ep, data_size);
+        if (ret != EOK) {
+                endpoint_destroy(ep);
+                return ret;
+        }
+        return EOK;
+}
 #endif
 /**

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

@@ -41 +41 @@
 void usb_transfer_batch_init(
     usb_transfer_batch_t *instance,
-    usb_target_t target,
-    usb_transfer_type_t transfer_type,
-    usb_speed_t speed,
-    size_t max_packet_size,
+                endpoint_t *ep,
     char *buffer,
-    char *transport_buffer,
+    char *data_buffer,
     size_t buffer_size,
     char *setup_buffer,
@@ -54 +51 @@
     void *arg,
     ddf_fun_t *fun,
-                endpoint_t *ep,
     void *private_data
     )
@@ -60 +56 @@
         assert(instance);
         link_initialize(&instance->link);
-        instance->target = target;
-        instance->transfer_type = transfer_type;
-        instance->speed = speed;
-        instance->direction = ep->direction;
+        instance->ep = ep;
         instance->callback_in = func_in;
         instance->callback_out = func_out;
         instance->arg = arg;
         instance->buffer = buffer;
-        instance->transport_buffer = transport_buffer;
+        instance->data_buffer = data_buffer;
         instance->buffer_size = buffer_size;
         instance->setup_buffer = setup_buffer;
         instance->setup_size = setup_size;
-        instance->max_packet_size = max_packet_size;
         instance->fun = fun;
         instance->private_data = private_data;
@@ -78 +70 @@
         instance->next_step = NULL;
         instance->error = EOK;
-        instance->ep = ep;
         endpoint_use(instance->ep);
 }
@@ -105 +96 @@
         assert(instance);
         assert(instance->callback_in);
+        assert(instance->ep);
 
         /* We are data in, we need data */
-        memcpy(instance->buffer, instance->transport_buffer,
-            instance->buffer_size);
+        memcpy(instance->buffer, instance->data_buffer, instance->buffer_size);
 
         usb_log_debug("Batch %p done (T%d.%d, %s %s in, %zuB): %s (%d).\n",
-            instance,
-            instance->target.address, instance->target.endpoint,
-            usb_str_speed(instance->speed),
-            usb_str_transfer_type_short(instance->transfer_type),
-            instance->transfered_size,
-            str_error(instance->error), instance->error);
+            instance, instance->ep->address, instance->ep->endpoint,
+            usb_str_speed(instance->ep->speed),
+            usb_str_transfer_type_short(instance->ep->transfer_type),
+            instance->transfered_size, str_error(instance->error), instance->error);
 
         instance->callback_in(instance->fun, instance->error,
@@ -132 +121 @@
 
         usb_log_debug("Batch %p done (T%d.%d, %s %s out): %s (%d).\n",
-            instance,
-            instance->target.address, instance->target.endpoint,
-            usb_str_speed(instance->speed),
-            usb_str_transfer_type_short(instance->transfer_type),
+            instance, instance->ep->address, instance->ep->endpoint,
+            usb_str_speed(instance->ep->speed),
+            usb_str_transfer_type_short(instance->ep->transfer_type),
             str_error(instance->error), instance->error);
 

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

@@ -48 +48 @@
 {
         assert(instance);
-        fibril_mutex_initialize(&instance->guard);
-        fibril_condvar_initialize(&instance->change);
-        instance->last_address = 0;
         unsigned i = 0;
         for (; i < USB_ADDRESS_COUNT; ++i) {
@@ -60 +57 @@
         // (it is needed to allow smooth registration at default address)
         instance->devices[0].occupied = true;
+        instance->last_address = 0;
+        fibril_mutex_initialize(&instance->guard);
 }
-/*----------------------------------------------------------------------------*/
-/** Attempt to obtain address 0, blocks.
- *
- * @param[in] instance Device keeper structure to use.
- * @param[in] speed Speed of the device requesting default address.
- */
-void usb_device_keeper_reserve_default_address(
-    usb_device_keeper_t *instance, usb_speed_t speed)
-{
-        assert(instance);
-        fibril_mutex_lock(&instance->guard);
-        while (instance->devices[USB_ADDRESS_DEFAULT].occupied) {
-                fibril_condvar_wait(&instance->change, &instance->guard);
-        }
-        instance->devices[USB_ADDRESS_DEFAULT].occupied = true;
-        instance->devices[USB_ADDRESS_DEFAULT].speed = speed;
-        fibril_mutex_unlock(&instance->guard);
-}
-/*----------------------------------------------------------------------------*/
-/** Attempt to obtain address 0, blocks.
- *
- * @param[in] instance Device keeper structure to use.
- * @param[in] speed Speed of the device requesting default address.
- */
-void usb_device_keeper_release_default_address(usb_device_keeper_t *instance)
-{
-        assert(instance);
-        fibril_mutex_lock(&instance->guard);
-        instance->devices[USB_ADDRESS_DEFAULT].occupied = false;
-        fibril_mutex_unlock(&instance->guard);
-        fibril_condvar_signal(&instance->change);
-}
-/*----------------------------------------------------------------------------*/
 /*----------------------------------------------------------------------------*/
 /** Get a free USB address
@@ -120 +86 @@
         assert(new_address != USB_ADDRESS_DEFAULT);
         assert(instance->devices[new_address].occupied == false);
+
         instance->devices[new_address].occupied = true;
         instance->devices[new_address].speed = speed;
         instance->last_address = new_address;
+
         fibril_mutex_unlock(&instance->guard);
         return new_address;
@@ -138 +106 @@
         assert(instance);
         fibril_mutex_lock(&instance->guard);
+
         assert(address > 0);
         assert(address <= USB11_ADDRESS_MAX);
         assert(instance->devices[address].occupied);
+
         instance->devices[address].handle = handle;
         fibril_mutex_unlock(&instance->guard);
@@ -159 +129 @@
         fibril_mutex_lock(&instance->guard);
         assert(instance->devices[address].occupied);
+
         instance->devices[address].occupied = false;
         fibril_mutex_unlock(&instance->guard);
@@ -177 +148 @@
         while (address <= USB11_ADDRESS_MAX) {
                 if (instance->devices[address].handle == handle) {
+                        assert(instance->devices[address].occupied);
                         fibril_mutex_unlock(&instance->guard);
                         return address;
@@ -198 +170 @@
         assert(address >= 0);
         assert(address <= USB11_ADDRESS_MAX);
+
         return instance->devices[address].speed;
 }