Changes in / [c6394aa:b6c9e1e] in mainline

Location:

uspace

Files:

• app/usbinfo/dev.c (modified) (4 diffs)
• drv/ohci/Makefile (modified) (1 diff)
• drv/ohci/batch.c (modified) (9 diffs)
• drv/ohci/batch.h (modified) (2 diffs)
• drv/ohci/hc.c (modified) (6 diffs)
• drv/ohci/hc.h (modified) (2 diffs)
• drv/ohci/hw_struct/completion_codes.h (modified) (2 diffs)
• drv/ohci/hw_struct/endpoint_descriptor.c (deleted)
• drv/ohci/hw_struct/endpoint_descriptor.h (modified) (3 diffs)
• drv/ohci/hw_struct/transfer_descriptor.c (deleted)
• drv/ohci/hw_struct/transfer_descriptor.h (modified) (3 diffs)
• drv/ohci/iface.c (modified) (17 diffs)
• drv/ohci/ohci_regs.h (modified) (1 diff)
• drv/ohci/transfer_list.c (deleted)
• drv/ohci/transfer_list.h (deleted)
• drv/ohci/utils/malloc32.h (modified) (1 diff)
• drv/uhci-hcd/batch.c (modified) (1 diff)
• drv/uhci-hcd/hc.c (modified) (1 diff)
• drv/usbmid/main.c (modified) (2 diffs)
• lib/usb/Makefile (modified) (1 diff)
• lib/usb/include/usb/pipes.h (modified) (4 diffs)
• lib/usb/src/devdrv.c (modified) (2 diffs)
• lib/usb/src/devpoll.c (modified) (1 diff)
• lib/usb/src/host/batch.c (modified) (1 diff)
• lib/usb/src/hub.c (modified) (2 diffs)
• lib/usb/src/pipepriv.c (deleted)
• lib/usb/src/pipepriv.h (deleted)
• lib/usb/src/pipes.c (modified) (6 diffs)
• lib/usb/src/pipesinit.c (modified) (3 diffs)
• lib/usb/src/pipesio.c (modified) (23 diffs)
• lib/usb/src/recognise.c (modified) (1 diff)

uspace/app/usbinfo/dev.c

@@ -50 +50 @@
 
         int rc;
-        bool transfer_started = false;
 
         rc = usb_device_connection_initialize(&dev->wire, hc_handle, dev_addr);
@@ -77 +76 @@
         }
 
-        rc = usb_pipe_start_long_transfer(&dev->ctrl_pipe);
+        rc = usb_pipe_start_session(&dev->ctrl_pipe);
         if (rc != EOK) {
                 fprintf(stderr,
-                    NAME ": failed to start transfer on control pipe: %s.\n",
+                    NAME ": failed to start session on control pipe: %s.\n",
                     str_error(rc));
                 goto leave;
         }
-        transfer_started = true;
 
         rc = usb_request_get_device_descriptor(&dev->ctrl_pipe,
@@ -109 +107 @@
 
 leave:
-        if (transfer_started) {
-                usb_pipe_end_long_transfer(&dev->ctrl_pipe);
+        if (usb_pipe_is_session_started(&dev->ctrl_pipe)) {
+                usb_pipe_end_session(&dev->ctrl_pipe);
         }
 
@@ -120 +118 @@
 void destroy_device(usbinfo_device_t *dev)
 {
-        usb_pipe_end_long_transfer(&dev->ctrl_pipe);
+        usb_pipe_end_session(&dev->ctrl_pipe);
         free(dev);
 }

uspace/drv/ohci/Makefile

@@ -33 +33 @@
 
 SOURCES = \
+        iface.c \
         batch.c \
+        main.c \
         hc.c \
-        iface.c \
-        main.c \
         ohci.c \
-        pci.c \
         root_hub.c \
-        transfer_list.c \
-        hw_struct/endpoint_descriptor.c \
-        hw_struct/transfer_descriptor.c
-
+        pci.c
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/drv/ohci/batch.c

@@ -40 +40 @@
 #include "batch.h"
 #include "utils/malloc32.h"
-#include "hw_struct/endpoint_descriptor.h"
-#include "hw_struct/transfer_descriptor.h"
 
-typedef struct ohci_batch {
-        ed_t *ed;
-        td_t *tds;
-        size_t td_count;
-} ohci_batch_t;
-
-static void batch_control(usb_transfer_batch_t *instance,
-    usb_direction_t data_dir, usb_direction_t status_dir);
 static void batch_call_in_and_dispose(usb_transfer_batch_t *instance);
 static void batch_call_out_and_dispose(usb_transfer_batch_t *instance);
 
 #define DEFAULT_ERROR_COUNT 3
-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)
+    usbhc_iface_transfer_out_callback_t func_out,
+                void *arg,
+                usb_device_keeper_t *manager
+                )
 {
 #define CHECK_NULL_DISPOSE_RETURN(ptr, message...) \
@@ -72 +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);
-
-        ohci_batch_t *data = malloc(sizeof(ohci_batch_t));
-        CHECK_NULL_DISPOSE_RETURN(data, "Failed to allocate batch data.\n");
-        bzero(data, sizeof(ohci_batch_t));
-        instance->private_data = data;
-
-        /* we needs + 1 transfer descriptor as the last one won't be executed */
-        data->td_count = 1 +
-            ((buffer_size + OHCI_TD_MAX_TRANSFER - 1) / OHCI_TD_MAX_TRANSFER);
-        if (ep->transfer_type == USB_TRANSFER_CONTROL) {
-                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->td_count);
-
-        data->ed = malloc32(sizeof(ed_t));
-        CHECK_NULL_DISPOSE_RETURN(data->ed,
-            "Failed to allocate endpoint descriptor.\n");
+        usb_transfer_batch_init(instance, target, transfer_type, speed,
+            max_packet_size, buffer, NULL, buffer_size, NULL, setup_size,
+            func_in, func_out, arg, fun, NULL, NULL);
 
         if (buffer_size > 0) {
@@ -112 +90 @@
         }
 
+
         return instance;
 }
@@ -118 +97 @@
 {
         assert(instance);
-        ohci_batch_t *data = instance->private_data;
-        assert(data);
-        free32(data->ed);
-        free32(data->tds);
+        free32(instance->transport_buffer);
         free32(instance->setup_buffer);
-        free32(instance->transport_buffer);
-        free(data);
         free(instance);
-}
-/*----------------------------------------------------------------------------*/
-bool batch_is_complete(usb_transfer_batch_t *instance)
-{
-        assert(instance);
-        ohci_batch_t *data = instance->private_data;
-        assert(data);
-        size_t tds = data->td_count - 1;
-        usb_log_debug2("Batch(%p) checking %d td(s) for completion.\n",
-            instance, tds);
-        size_t i = 0;
-        for (; i < tds; ++i) {
-                if (!td_is_finished(&data->tds[i]))
-                        return false;
-                instance->error = td_error(&data->tds[i]);
-                /* FIXME: calculate real transfered size */
-                instance->transfered_size = instance->buffer_size;
-                if (instance->error != EOK) {
-                        usb_log_debug("Batch(%p) found error TD(%d):%x.\n",
-                            instance, i, data->tds[i].status);
-                        return true;
-//                      endpoint_toggle_set(instance->ep,
-                }
-        }
-        return true;
 }
 /*----------------------------------------------------------------------------*/
@@ -160 +109 @@
             instance->buffer_size);
         instance->next_step = batch_call_out_and_dispose;
-        batch_control(instance, USB_DIRECTION_OUT, USB_DIRECTION_IN);
+        /* TODO: implement */
         usb_log_debug("Batch(%p) CONTROL WRITE initialized.\n", instance);
 }
@@ -168 +117 @@
         assert(instance);
         instance->next_step = batch_call_in_and_dispose;
-        batch_control(instance, USB_DIRECTION_IN, USB_DIRECTION_OUT);
+        /* TODO: implement */
         usb_log_debug("Batch(%p) CONTROL READ initialized.\n", instance);
 }
@@ -175 +124 @@
 {
         assert(instance);
-        assert(instance->direction == USB_DIRECTION_IN);
+        instance->direction = USB_DIRECTION_IN;
         instance->next_step = batch_call_in_and_dispose;
         /* TODO: implement */
@@ -184 +133 @@
 {
         assert(instance);
-        assert(instance->direction == USB_DIRECTION_OUT);
+        instance->direction = USB_DIRECTION_OUT;
         /* We are data out, we are supposed to provide data */
         memcpy(instance->transport_buffer, instance->buffer,
@@ -211 +160 @@
 }
 /*----------------------------------------------------------------------------*/
-ed_t * batch_ed(usb_transfer_batch_t *instance)
-{
-        assert(instance);
-        ohci_batch_t *data = instance->private_data;
-        assert(data);
-        return data->ed;
-}
-/*----------------------------------------------------------------------------*/
-void batch_control(usb_transfer_batch_t *instance,
-    usb_direction_t data_dir, usb_direction_t status_dir)
-{
-        assert(instance);
-        ohci_batch_t *data = instance->private_data;
-        assert(data);
-        ed_init(data->ed, instance->ep);
-        ed_add_tds(data->ed, &data->tds[0], &data->tds[data->td_count - 1]);
-        usb_log_debug("Created ED: %x:%x:%x:%x.\n", data->ed->status,
-            data->ed->td_tail, data->ed->td_head, data->ed->next);
-        int toggle = 0;
-        /* setup stage */
-        td_init(&data->tds[0], USB_DIRECTION_BOTH, instance->setup_buffer,
-                instance->setup_size, toggle);
-        td_set_next(&data->tds[0], &data->tds[1]);
-        usb_log_debug("Created SETUP TD: %x:%x:%x:%x.\n", data->tds[0].status,
-            data->tds[0].cbp, data->tds[0].next, data->tds[0].be);
-
-        /* data stage */
-        size_t td_current = 1;
-        size_t remain_size = instance->buffer_size;
-        char *transfer_buffer = instance->transport_buffer;
-        while (remain_size > 0) {
-                size_t transfer_size = remain_size > OHCI_TD_MAX_TRANSFER ?
-                    OHCI_TD_MAX_TRANSFER : remain_size;
-                toggle = 1 - toggle;
-
-                td_init(&data->tds[td_current], data_dir, transfer_buffer,
-                    transfer_size, toggle);
-                td_set_next(&data->tds[td_current], &data->tds[td_current + 1]);
-                usb_log_debug("Created DATA TD: %x:%x:%x:%x.\n",
-                    data->tds[td_current].status, data->tds[td_current].cbp,
-                    data->tds[td_current].next, data->tds[td_current].be);
-
-                transfer_buffer += transfer_size;
-                remain_size -= transfer_size;
-                assert(td_current < data->td_count - 2);
-                ++td_current;
-        }
-
-        /* status stage */
-        assert(td_current == data->td_count - 2);
-        td_init(&data->tds[td_current], status_dir, NULL, 0, 1);
-        usb_log_debug("Created STATUS TD: %x:%x:%x:%x.\n",
-            data->tds[td_current].status, data->tds[td_current].cbp,
-            data->tds[td_current].next, data->tds[td_current].be);
-}
-/*----------------------------------------------------------------------------*/
 /** Helper function calls callback and correctly disposes of batch structure.
  *

uspace/drv/ohci/batch.h

@@ -26 +26 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup drvusbuhcihc
+/** @addtogroup drvusbohci
  * @{
  */
 /** @file
- * @brief UHCI driver USB transaction structure
+ * @brief OHCI driver USB transaction structure
  */
-#ifndef DRV_UHCI_BATCH_H
-#define DRV_UHCI_BATCH_H
+#ifndef DRV_OHCI_BATCH_H
+#define DRV_OHCI_BATCH_H
+
 
 #include <usbhc_iface.h>
 #include <usb/usb.h>
 #include <usb/host/device_keeper.h>
-#include <usb/host/endpoint.h>
 #include <usb/host/batch.h>
 
-#include "hw_struct/endpoint_descriptor.h"
-
 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,
+                usb_device_keeper_t *manager
+                );
 
 void batch_dispose(usb_transfer_batch_t *instance);
-
-bool batch_is_complete(usb_transfer_batch_t *instance);
 
 void batch_control_write(usb_transfer_batch_t *instance);
@@ -65 +70 @@
 
 void batch_bulk_out(usb_transfer_batch_t *instance);
-
-ed_t * batch_ed(usb_transfer_batch_t *instance);
 #endif
 /**

uspace/drv/ohci/hc.c

@@ -47 +47 @@
 static void hc_gain_control(hc_t *instance);
 static void hc_init_hw(hc_t *instance);
-static int hc_init_transfer_lists(hc_t *instance);
-static int hc_init_memory(hc_t *instance);
 /*----------------------------------------------------------------------------*/
 int hc_register_hub(hc_t *instance, ddf_fun_t *hub_fun)
@@ -61 +59 @@
             &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);
-
         char *match_str = NULL;
-        ret = asprintf(&match_str, "usb&class=hub");
-//      ret = (match_str == NULL) ? ret : EOK;
+        int 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_log_error("Failed to create root hub match-id string.\n");
                 return ret;
         }
@@ -118 +107 @@
         rh_init(&instance->rh, dev, instance->registers);
 
-        hc_init_memory(instance);
         hc_init_hw(instance);
 
@@ -129 +117 @@
         assert(instance);
         assert(batch);
-
-        /* check for root hub communication */
         if (batch->target.address == instance->rh.address) {
                 return rh_request(&instance->rh, batch);
         }
-
-        transfer_list_add_batch(
-            instance->transfers[batch->transfer_type], batch);
-
-        switch (batch->transfer_type) {
-        case USB_TRANSFER_CONTROL:
-                instance->registers->command_status |= CS_CLF;
-                break;
-        case USB_TRANSFER_BULK:
-                instance->registers->command_status |= CS_BLF;
-                break;
-        default:
-                break;
-        }
-        return EOK;
+        /* TODO: implement */
+        return ENOTSUP;
 }
 /*----------------------------------------------------------------------------*/
@@ -161 +134 @@
         usb_log_info("OHCI interrupt: %x.\n", status);
 
-        LIST_INITIALIZE(done);
-        transfer_list_remove_finished(&instance->transfers_interrupt, &done);
-        transfer_list_remove_finished(&instance->transfers_isochronous, &done);
-        transfer_list_remove_finished(&instance->transfers_control, &done);
-        transfer_list_remove_finished(&instance->transfers_bulk, &done);
-
-        while (!list_empty(&done)) {
-                link_t *item = done.next;
-                list_remove(item);
-                usb_transfer_batch_t *batch =
-                    list_get_instance(item, usb_transfer_batch_t, link);
-                usb_transfer_batch_finish(batch);
-        }
+        /* TODO: Check for further interrupt causes */
+        /* TODO: implement */
 }
 /*----------------------------------------------------------------------------*/
@@ -235 +197 @@
         assert(instance);
         const uint32_t fm_interval = instance->registers->fm_interval;
-
-        /* reset hc */
         instance->registers->command_status = CS_HCR;
         async_usleep(10);
-
-        /* restore fm_interval */
         instance->registers->fm_interval = fm_interval;
         assert((instance->registers->command_status & CS_HCR) == 0);
-
         /* hc is now in suspend state */
-
-        /* enable queues */
-        instance->registers->control |= (C_PLE | C_IE | C_CLE | C_BLE);
+        /* TODO: init HCCA block */
+        /* TODO: init queues */
+        /* TODO: enable queues */
         /* TODO: enable interrupts */
-        /* set periodic start to 90% */
-        instance->registers->periodic_start = (fm_interval / 10) * 9;
+        /* TODO: set periodic start to 90% */
 
         instance->registers->control &= (C_HCFS_OPERATIONAL << C_HCFS_SHIFT);
         usb_log_info("OHCI HC up and running.\n");
 }
-/*----------------------------------------------------------------------------*/
-int hc_init_transfer_lists(hc_t *instance)
-{
-        assert(instance);
-
-#define SETUP_TRANSFER_LIST(type, name) \
-do { \
-        int ret = transfer_list_init(&instance->type, name); \
-        if (ret != EOK) { \
-                usb_log_error("Failed(%d) to setup %s transfer list.\n", \
-                    ret, name); \
-                transfer_list_fini(&instance->transfers_isochronous); \
-                transfer_list_fini(&instance->transfers_interrupt); \
-                transfer_list_fini(&instance->transfers_control); \
-                transfer_list_fini(&instance->transfers_bulk); \
-        } \
-} while (0)
-
-        SETUP_TRANSFER_LIST(transfers_isochronous, "ISOCHRONOUS");
-        SETUP_TRANSFER_LIST(transfers_interrupt, "INTERRUPT");
-        SETUP_TRANSFER_LIST(transfers_control, "CONTROL");
-        SETUP_TRANSFER_LIST(transfers_bulk, "BULK");
-
-        transfer_list_set_next(&instance->transfers_interrupt,
-            &instance->transfers_isochronous);
-
-        /* Assign pointers to be used during scheduling */
-        instance->transfers[USB_TRANSFER_INTERRUPT] =
-          &instance->transfers_interrupt;
-        instance->transfers[USB_TRANSFER_ISOCHRONOUS] =
-          &instance->transfers_interrupt;
-        instance->transfers[USB_TRANSFER_CONTROL] =
-          &instance->transfers_control;
-        instance->transfers[USB_TRANSFER_BULK] =
-          &instance->transfers_bulk;
-
-        return EOK;
-#undef CHECK_RET_CLEAR_RETURN
-}
-/*----------------------------------------------------------------------------*/
-int hc_init_memory(hc_t *instance)
-{
-        assert(instance);
-        /* init queues */
-        hc_init_transfer_lists(instance);
-
-        /* init HCCA */
-        instance->hcca = malloc32(sizeof(hcca_t));
-        if (instance->hcca == NULL)
-                return ENOMEM;
-        bzero(instance->hcca, sizeof(hcca_t));
-        instance->registers->hcca = addr_to_phys(instance->hcca);
-
-        /* use queues */
-        instance->registers->bulk_head = instance->transfers_bulk.list_head_pa;
-        instance->registers->control_head =
-            instance->transfers_control.list_head_pa;
-
-        unsigned i = 0;
-        for (; i < 32; ++i) {
-                instance->hcca->int_ep[i] =
-                    instance->transfers_interrupt.list_head_pa;
-        }
-
-        return EOK;
-}
 /**
  * @}

uspace/drv/ohci/hc.h

@@ -48 +48 @@
 #include "ohci_regs.h"
 #include "root_hub.h"
-#include "transfer_list.h"
 #include "hw_struct/hcca.h"
 
@@ -55 +54 @@
         usb_address_t rh_address;
         rh_t rh;
-
-        hcca_t *hcca;
-
-        transfer_list_t transfers_isochronous;
-        transfer_list_t transfers_interrupt;
-        transfer_list_t transfers_control;
-        transfer_list_t transfers_bulk;
-
-        transfer_list_t *transfers[4];
-
         ddf_fun_t *ddf_instance;
         usb_device_keeper_t manager;

uspace/drv/ohci/hw_struct/completion_codes.h

@@ -35 +35 @@
 #define DRV_OHCI_HW_STRUCT_COMPLETION_CODES_H
 
-#include <errno.h>
-
 #define CC_NOERROR (0x0)
 #define CC_CRC (0x1)
@@ -52 +50 @@
 #define CC_NOACCESS2 (0xf)
 
-inline static int cc_to_rc(int cc)
-{
-        switch (cc) {
-        case CC_NOERROR:
-                return EOK;
-
-        case CC_CRC:
-                return EBADCHECKSUM;
-
-        case CC_PIDUNEXPECTED:
-        case CC_PIDFAIL:
-        case CC_BITSTUFF:
-                return EIO;
-
-        case CC_TOGGLE:
-        case CC_STALL:
-                return ESTALL;
-
-        case CC_NORESPONSE:
-                return ETIMEOUT;
-
-        case CC_DATAOVERRRUN:
-        case CC_DATAUNDERRRUN:
-        case CC_BUFFEROVERRRUN:
-        case CC_BUFFERUNDERRUN:
-                return EOVERFLOW;
-
-        case CC_NOACCESS1:
-        case CC_NOACCESS2:
-        default:
-                return ENOTSUP;
-        }
-}
-
 #endif
 /**

uspace/drv/ohci/hw_struct/endpoint_descriptor.h

@@ -35 +35 @@
 #define DRV_OHCI_HW_STRUCT_ENDPOINT_DESCRIPTOR_H
 
-#include <assert.h>
 #include <stdint.h>
-
-#include <usb/host/endpoint.h>
-
-#include "utils/malloc32.h"
-#include "transfer_descriptor.h"
 
 #include "completion_codes.h"
@@ -50 +44 @@
 #define ED_STATUS_FA_SHIFT (0)
 #define ED_STATUS_EN_MASK (0xf)    /* USB endpoint address */
-#define ED_STATUS_EN_SHIFT (7)
+#define ED_STATUS_EN_SHIFT (6)
 #define ED_STATUS_D_MASK (0x3)     /* direction */
-#define ED_STATUS_D_SHIFT (11)
+#define ED_STATUS_D_SHIFT (10)
 #define ED_STATUS_D_IN (0x1)
 #define ED_STATUS_D_OUT (0x2)
-#define ED_STATUS_D_TRANSFER (0x3)
 
-#define ED_STATUS_S_FLAG (1 << 13) /* speed flag: 1 = low */
+#define ED_STATUS_S_FLAG (1 << 13) /* speed flag */
 #define ED_STATUS_K_FLAG (1 << 14) /* skip flag (no not execute this ED) */
 #define ED_STATUS_F_FLAG (1 << 15) /* format: 1 = isochronous*/
@@ -78 +71 @@
 #define ED_NEXT_PTR_SHIFT (0)
 } __attribute__((packed)) ed_t;
-
-void ed_init(ed_t *instance, endpoint_t *ep);
-
-static inline void ed_add_tds(ed_t *instance, td_t *head, td_t *tail)
-{
-        assert(instance);
-        instance->td_head = addr_to_phys(head) & ED_TDHEAD_PTR_MASK;
-        instance->td_tail = addr_to_phys(tail) & ED_TDTAIL_PTR_MASK;
-}
-
-static inline void ed_append_ed(ed_t *instance, ed_t *next)
-{
-        assert(instance);
-        assert(next);
-        uint32_t pa = addr_to_phys(next);
-        assert((pa & ED_NEXT_PTR_MASK) << ED_NEXT_PTR_SHIFT == pa);
-        instance->next = pa;
-}
-
 #endif
 /**

uspace/drv/ohci/hw_struct/transfer_descriptor.h

@@ -35 +35 @@
 #define DRV_OHCI_HW_STRUCT_TRANSFER_DESCRIPTOR_H
 
-#include <bool.h>
 #include <stdint.h>
-#include "utils/malloc32.h"
 
 #include "completion_codes.h"
-
-/* OHCI TDs can handle up to 8KB buffers */
-#define OHCI_TD_MAX_TRANSFER (8 * 1024)
 
 typedef struct td {
@@ -57 +52 @@
 #define TD_STATUS_T_MASK (0x3)  /* data toggle 1x = use ED toggle carry */
 #define TD_STATUS_T_SHIFT (24)
-#define TD_STATUS_T_0 (0x2)
-#define TD_STATUS_T_1 (0x3)
 #define TD_STATUS_EC_MASK (0x3) /* error count */
 #define TD_STATUS_EC_SHIFT (26)
@@ -71 +64 @@
         volatile uint32_t be; /* buffer end, address of the last byte */
 } __attribute__((packed)) td_t;
-
-void td_init(
-    td_t *instance, usb_direction_t dir, void *buffer, size_t size, int toggle);
-
-inline static void td_set_next(td_t *instance, td_t *next)
-{
-        assert(instance);
-        instance->next = addr_to_phys(next) & TD_NEXT_PTR_MASK;
-}
-
-inline static bool td_is_finished(td_t *instance)
-{
-        assert(instance);
-        int cc = (instance->status >> TD_STATUS_CC_SHIFT) & TD_STATUS_CC_MASK;
-        /* something went wrong, error code is set */
-        if (cc != CC_NOACCESS1 && cc != CC_NOACCESS2 && cc != CC_NOERROR) {
-                return true;
-        }
-        /* everything done */
-        if (cc == CC_NOERROR && instance->cbp == 0) {
-                return true;
-        }
-        return false;
-}
-
-static inline int td_error(td_t *instance)
-{
-        assert(instance);
-        int cc = (instance->status >> TD_STATUS_CC_SHIFT) & TD_STATUS_CC_MASK;
-        return cc_to_rc(cc);
-}
 #endif
 /**

uspace/drv/ohci/iface.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Vojtech Horky, Jan Vesely
+ * Copyright (c) 2011 Vojtech Horky
  * All rights reserved.
  *
@@ -30 +30 @@
  */
 /** @file
- * @brief OHCI driver hc interface implementation
+ * USB-HC interface implementation.
  */
 #include <ddf/driver.h>
@@ -36 +36 @@
 
 #include <usb/debug.h>
-#include <usb/host/endpoint.h>
 
 #include "iface.h"
 #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
- *
- * @param[in] fun DDF function that was called.
- * @param[in] speed Speed to associate with the new default address.
+#define UNSUPPORTED(methodname) \
+        usb_log_warning("Unsupported interface method `%s()' in %s:%d.\n", \
+            methodname, __FILE__, __LINE__)
+
+/** Reserve default address.
+ *
+ * This function may block the caller.
+ *
+ * @param[in] fun Device function the action was invoked on.
+ * @param[in] speed Speed of the device for which the default address is
+ *      reserved.
  * @return Error code.
  */
@@ -102 +61 @@
         usb_device_keeper_reserve_default_address(&hc->manager, speed);
         return EOK;
-#if 0
-        endpoint_t *ep = malloc(sizeof(endpoint_t));
-        if (ep == NULL)
-                return ENOMEM;
-        const size_t max_packet_size = speed == USB_SPEED_LOW ? 8 : 64;
-        endpoint_init(ep, USB_TRANSFER_CONTROL, speed, max_packet_size);
-        int ret;
-try_retgister:
-        ret = usb_endpoint_manager_register_ep(&hc->ep_manager,
-            USB_ADDRESS_DEFAULT, 0, USB_DIRECTION_BOTH, ep, endpoint_destroy, 0);
-        if (ret == EEXISTS) {
-                async_usleep(1000);
-                goto try_retgister;
-        }
-        if (ret != EOK) {
-                endpoint_destroy(ep);
-        }
-        return ret;
-#endif
-}
-/*----------------------------------------------------------------------------*/
-/** Release default address interface function
- *
- * @param[in] fun DDF function that was called.
+}
+/*----------------------------------------------------------------------------*/
+/** Release default address.
+ *
+ * @param[in] fun Device function the action was invoked on.
  * @return Error code.
  */
@@ -134 +74 @@
         assert(hc);
         usb_log_debug("Default address release.\n");
-//      return usb_endpoint_manager_unregister_ep(&hc->ep_manager,
-//          USB_ADDRESS_DEFAULT, 0, USB_DIRECTION_BOTH);
         usb_device_keeper_release_default_address(&hc->manager);
         return EOK;
 }
 /*----------------------------------------------------------------------------*/
-/** Request address interface function
- *
- * @param[in] fun DDF function that was called.
- * @param[in] speed Speed to associate with the new default address.
- * @param[out] address Place to write a new address.
+/** Found free USB address.
+ *
+ * @param[in] fun Device function the action was invoked on.
+ * @param[in] speed Speed of the device that will get this address.
+ * @param[out] address Non-null pointer where to store the free address.
  * @return Error code.
  */
@@ -163 +101 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Bind address interface function
- *
- * @param[in] fun DDF function that was called.
- * @param[in] address Address of the device
- * @param[in] handle Devman handle of the device driver.
+/** Bind USB address with device devman handle.
+ *
+ * @param[in] fun Device function the action was invoked on.
+ * @param[in] address USB address of the device.
+ * @param[in] handle Devman handle of the device.
  * @return Error code.
  */
 static int bind_address(
-  ddf_fun_t *fun, usb_address_t address, devman_handle_t handle)
+    ddf_fun_t *fun, usb_address_t address, devman_handle_t handle)
 {
         assert(fun);
@@ -181 +119 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Release address interface function
- *
- * @param[in] fun DDF function that was called.
+/** Release previously requested address.
+ *
+ * @param[in] fun Device function the action was invoked on.
  * @param[in] address USB address to be released.
  * @return Error code.
@@ -214 +152 @@
     size_t max_packet_size, unsigned int interval)
 {
+        assert(fun);
         hc_t *hc = fun_to_hc(fun);
         assert(hc);
@@ -222 +161 @@
                 speed = ep_speed;
         }
-        const size_t size =
-            (transfer_type == USB_TRANSFER_INTERRUPT
-            || transfer_type == USB_TRANSFER_ISOCHRONOUS) ?
-            max_packet_size : 0;
-        int ret;
-
-        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;
-        }
-
+        const size_t size = max_packet_size;
         usb_log_debug("Register endpoint %d:%d %s %s(%d) %zu(%zu) %u.\n",
             address, endpoint, usb_str_transfer_type(transfer_type),
             usb_str_speed(speed), direction, size, max_packet_size, interval);
-
-        ret = usb_endpoint_manager_register_ep(&hc->ep_manager, ep, size);
-        if (ret != EOK) {
-                endpoint_destroy(ep);
-        } else {
-                usb_device_keeper_add_ep(&hc->manager, address, ep);
-        }
-        return ret;
-}
-/*----------------------------------------------------------------------------*/
+        // TODO use real endpoint here!
+        return usb_endpoint_manager_register_ep(&hc->ep_manager,NULL, 0);
+}
+/*----------------------------------------------------------------------------*/
+/** Unregister endpoint (free some bandwidth reservation).
+ *
+ * @param[in] fun Device function the action was invoked on.
+ * @param[in] address USB address of the device.
+ * @param[in] endpoint Endpoint number.
+ * @param[in] direction Endpoint data direction.
+ * @return Error code.
+ */
 static int unregister_endpoint(
     ddf_fun_t *fun, usb_address_t address,
     usb_endpoint_t endpoint, usb_direction_t direction)
 {
+        assert(fun);
         hc_t *hc = fun_to_hc(fun);
         assert(hc);
@@ -288 +215 @@
     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);
+
+        // FIXME: get from endpoint manager
+        size_t max_packet_size = 8;
+
+        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("Interrupt OUT %d:%d %zu(%zu).\n",
+            target.address, target.endpoint, size, max_packet_size);
+
+        usb_transfer_batch_t *batch =
+            batch_get(fun, target, USB_TRANSFER_INTERRUPT, max_packet_size,
+                speed, data, size, NULL, 0, NULL, callback, arg, &hc->manager);
+        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);
@@ -322 +261 @@
     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);
+
+        // FIXME: get from endpoint manager
+        size_t max_packet_size = 8;
+
+        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("Interrupt IN %d:%d %zu(%zu).\n",
+            target.address, target.endpoint, size, max_packet_size);
+
+        usb_transfer_batch_t *batch =
+            batch_get(fun, target, USB_TRANSFER_INTERRUPT, max_packet_size,
+                speed, data, size, NULL, 0, callback, NULL, arg, &hc->manager);
+        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);
@@ -356 +306 @@
     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);
+
+        // FIXME: get from endpoint manager
+        size_t max_packet_size = 8;
+
+        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("Bulk OUT %d:%d %zu(%zu).\n",
+            target.address, target.endpoint, size, max_packet_size);
+
+        usb_transfer_batch_t *batch =
+            batch_get(fun, target, USB_TRANSFER_BULK, max_packet_size, speed,
+                data, size, NULL, 0, NULL, callback, arg, &hc->manager);
+        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);
@@ -390 +352 @@
     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);
+
+        // FIXME: get from endpoint manager
+        size_t max_packet_size = 8;
+
+        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("Bulk IN %d:%d %zu(%zu).\n",
+            target.address, target.endpoint, size, max_packet_size);
+
+        usb_transfer_batch_t *batch =
+            batch_get(fun, target, USB_TRANSFER_BULK, max_packet_size, speed,
+                data, size, NULL, 0, callback, NULL, arg, &hc->manager);
+        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);
@@ -428 +401 @@
     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);
+
+        // FIXME: get from endpoint manager
+        size_t max_packet_size = 8;
+
+        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(%zu).\n",
+            speed, target.address, target.endpoint, size, max_packet_size);
+
+        if (setup_size != 8)
+                return EINVAL;
+
+        usb_transfer_batch_t *batch =
+            batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size,
+                speed, data, size, setup_data, setup_size, NULL, callback, arg,
+                &hc->manager);
+        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);
@@ -468 +455 @@
     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);
+
+        // FIXME: get from endpoint manager
+        size_t max_packet_size = 8;
+
+        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(%zu).\n",
+            speed, target.address, target.endpoint, size, max_packet_size);
+        usb_transfer_batch_t *batch =
+            batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size,
+                speed, data, size, setup_data, setup_size, callback, NULL, arg,
+                &hc->manager);
+        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);
@@ -483 +481 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Host controller interface implementation for OHCI. */
 usbhc_iface_t hc_iface = {
         .reserve_default_address = reserve_default_address,
@@ -502 +501 @@
         .control_read = control_read,
 };
+
 /**
  * @}

uspace/drv/ohci/ohci_regs.h

@@ -41 +41 @@
         const volatile uint32_t revision;
         volatile uint32_t control;
-#define C_CSBR_MASK (0x3) /* Control-bulk service ratio */
-#define C_CSBR_1_1  (0x0)
-#define C_CSBR_1_2  (0x1)
-#define C_CSBR_1_3  (0x2)
-#define C_CSBR_1_4  (0x3)
+#define C_CSBR_MASK (0x3)
 #define C_CSBR_SHIFT (0)
+#define C_PLE (1 << 2)
+#define C_IE (1 << 3)
+#define C_CLE (1 << 4)
+#define C_BLE (1 << 5)
 
-#define C_PLE (1 << 2)   /* Periodic list enable */
-#define C_IE  (1 << 3)   /* Isochronous enable */
-#define C_CLE (1 << 4)   /* Control list enable */
-#define C_BLE (1 << 5)   /* Bulk list enable */
+#define C_HCFS_MASK (0x3)
+#define C_HCFS_SHIFT (6)
+#define C_HCFS_RESET (0x0)
+#define C_HCFS_OPERATIONAL (0x1)
+#define C_HCFS_RESUME (0x2)
+#define C_HCFS_SUSPEND (0x3)
 
-#define C_HCFS_MASK        (0x3) /* Host controller functional state */
-#define C_HCFS_RESET       (0x0)
-#define C_HCFS_OPERATIONAL (0x1)
-#define C_HCFS_RESUME      (0x2)
-#define C_HCFS_SUSPEND     (0x3)
-#define C_HCFS_SHIFT       (6)
-
-#define C_IR  (1 << 8)   /* Interrupt routing, make sure it's 0 */
-#define C_RWC (1 << 9)   /* Remote wakeup connected, host specific */
-#define C_RWE (1 << 10)  /* Remote wakeup enable */
+#define C_IR (1 << 8)
+#define C_RWC (1 << 9)
+#define C_RWE (1 << 10)
 
         volatile uint32_t command_status;
-#define CS_HCR (1 << 0)   /* Host controller reset */
-#define CS_CLF (1 << 1)   /* Control list filled */
-#define CS_BLF (1 << 2)   /* Bulk list filled */
-#define CS_OCR (1 << 3)   /* Ownership change request */
-#define CS_SOC_MASK (0x3) /* Scheduling overrun count */
+#define CS_HCR (1 << 0)
+#define CS_CLF (1 << 1)
+#define CS_BLF (1 << 2)
+#define CS_OCR (1 << 3)
+#define CS_SOC_MASK (0x3)
 #define CS_SOC_SHIFT (16)
 
         volatile uint32_t interrupt_status;
-#define IS_SO   (1 << 0)  /* Scheduling overrun */
-#define IS_WDH  (1 << 1)  /* Write-back done head */
-#define IS_SF   (1 << 2)  /* Start of frame */
-#define IS_RD   (1 << 3)  /* Resume detected */
-#define IS_UE   (1 << 4)  /* Unrecoverable error */
-#define IS_FNO  (1 << 5)  /* Frame number overflow */
-#define IS_RHSC (1 << 6)  /* Root hub status change */
-#define IS_OC   (1 << 30) /* Ownership change */
+#define IS_SO (1 << 0)
+#define IS_WDH (1 << 1)
+#define IS_SF (1 << 2)
+#define IS_RD (1 << 3)
+#define IS_UE (1 << 4)
+#define IS_FNO (1 << 5)
+#define IS_RHSC (1 << 6)
+#define IS_OC (1 << 30)
 
-        /** Interupt enable/disable, reads give the same value, writing causes
-         * enable/disable */
         volatile uint32_t interupt_enable;
+#define IE_SO   (1 << 0)
+#define IE_WDH  (1 << 1)
+#define IE_SF   (1 << 2)
+#define IE_RD   (1 << 3)
+#define IE_UE   (1 << 4)
+#define IE_FNO  (1 << 5)
+#define IE_RHSC (1 << 6)
+#define IE_OC   (1 << 30)
+#define IE_MIE  (1 << 31)
+
         volatile uint32_t interrupt_disable;
-#define I_SO   (1 << 0)   /* Scheduling overrun */
-#define I_WDH  (1 << 1)   /* Done head write-back */
-#define I_SF   (1 << 2)   /* Start of frame */
-#define I_RD   (1 << 3)   /* Resume detect */
-#define I_UE   (1 << 4)   /* Unrecoverable error */
-#define I_FNO  (1 << 5)   /* Frame number overflow */
-#define I_RHSC (1 << 6)   /* Root hub status change */
-#define I_OC   (1 << 30)  /* Ownership change */
-#define I_MI   (1 << 31)  /* Master interrupt (all/any interrupts) */
-
-        /** HCCA pointer (see hw_struct hcca.h) */
         volatile uint32_t hcca;
-#define HCCA_PTR_MASK 0xffffff00 /* HCCA is 256B aligned */
-
-        /** Currently executed period endpoint */
-        const volatile uint32_t period_current;
-
-        /** The first control endpoint */
+        volatile uint32_t period_corrent;
         volatile uint32_t control_head;
-
-        /** Currently executed control endpoint */
         volatile uint32_t control_current;
-
-        /** The first bulk endpoint */
         volatile uint32_t bulk_head;
-
-        /** Currently executed bulk endpoint */
         volatile uint32_t bulk_current;
-
-        /** Done TD list, this value is periodically written to HCCA */
-        const volatile uint32_t done_head;
-
-        /** Frame time and max packet size for all transfers */
+        volatile uint32_t done_head;
         volatile uint32_t fm_interval;
-#define FMI_FI_MASK (0x1fff) /* Frame interval in bit times (should be 11999)*/
-#define FMI_FI_SHIFT (0)
-#define FMI_FSMPS_MASK (0x7fff) /* Full speed max packet size */
-#define FMI_FSMPS_SHIFT (16)
-#define FMI_TOGGLE_FLAG (1 << 31)
-
-        /** Bit times remaining in current frame */
-        const volatile uint32_t fm_remaining;
-#define FMR_FR_MASK FMI_FI_MASK
-#define FMR_FR_SHIFT FMI_FI_SHIFT
-#define FMR_TOGGLE_FLAG FMI_TOGGLE_FLAG
-
-        /** Frame number */
-        const volatile uint32_t fm_number;
-#define FMN_NUMBER_MASK (0xffff)
-
-        /** Remaining bit time in frame to start periodic transfers */
+        volatile uint32_t fm_remaining;
+        volatile uint32_t fm_number;
         volatile uint32_t periodic_start;
-#define PS_PS_MASK (0x1fff) /* bit time when periodic get priority (0x3e67) */
-
-        /** Threshold for starting LS transaction */
         volatile uint32_t ls_threshold;
-#define LST_LST_MASK (0x7fff)
-
-        /** The first root hub control register */
         volatile uint32_t rh_desc_a;
-#define RHDA_NDS_MASK (0xff) /* Number of downstream ports, max 15 */
-#define RHDA_NDS_SHIFT (0)
-#define RHDA_PSM_FLAG  (1 << 8)  /* Power switching mode: 0-global, 1-per port*/
-#define RHDA_NPS_FLAG  (1 << 9)  /* No power switch: 1-power on, 0-use PSM*/
-#define RHDA_DT_FLAG   (1 << 10) /* 1-Compound device, must be 0 */
-#define RHDA_OCPM_FLAG (1 << 11) /* Over-current mode: 0-global, 1-per port */
-#define RHDA_NOCP      (1 << 12) /* OC control: 0-use OCPM, 1-OC off */
-#define RHDA_POTPGT_MASK (0xff)  /* Power on to power good time */
-#define RHDA_POTPGT_SHIFT (24)
-
-        /** The other root hub control register */
         volatile uint32_t rh_desc_b;
-#define RHDB_DR_MASK (0xffff) /* Device removable mask */
-#define RHDB_DR_SHIFT (0)
-#define RHDB_PCC_MASK (0xffff) /* Power control mask */
-#define RHDB_PCC_SHIFT (16)
-
-/* Port device removable status */
-#define RHDB_DR_FLAG(port) (((1 << port) & RHDB_DR_MASK) << RHDB_DR_SHIFT)
-/* Port power control status: 1-per port power control, 0-global power switch */
-#define RHDB_PPC_FLAG(port) (((1 << port) & RHDB_DR_MASK) << RHDB_DR_SHIFT)
-
-        /** Root hub status register */
         volatile uint32_t rh_status;
-#define RHS_LPS_FLAG  (1 <<  0)/* read: 0,
-                                * write: 0-no effect,
-                                *        1-turn off port power for ports
-                                *        specified in PPCM(RHDB), or all ports,
-                                *        if power is set globally */
-#define RHS_CLEAR_PORT_POWER RHS_LPS_FLAG /* synonym for the above */
-#define RHS_OCI_FLAG  (1 <<  1)/* Over-current indicator, if per-port: 0 */
-#define RHS_DRWE_FLAG (1 << 15)/* read: 0-connect status change does not wake HC
-                                *       1-connect status change wakes HC
-                                * write: 1-set DRWE, 0-no effect */
-#define RHS_SET_DRWE RHS_DRWE_FLAG
-#define RHS_LPSC_FLAG (1 << 16)/* read: 0,
-                                * write: 0-no effect
-                                *        1-turn on port power for ports
-                                *        specified in PPCM(RHDB), or all ports,
-                                *        if power is set globally */
-#define RHS_SET_PORT_POWER RHS_LPSC_FLAG /* synonym for the above */
-#define RHS_OCIC_FLAG (1 << 17)/* Over-current indicator change   */
-#define RHS_CLEAR_DRWE (1 << 31)
-
-        /** Root hub per port status */
         volatile uint32_t rh_port_status[];
-#define RHPS_CCS_FLAG (1 << 0) /* r: current connect status,
-                                * w: 1-clear port enable, 0-nothing */
-#define RHPS_CLEAR_PORT_ENABLE RHPS_CCS_FLAG
-#define RHPS_PES_FLAG (1 << 1) /* r: port enable status
-                                * w: 1-set port enable, 0-nothing */
-#define RHPS_SET_PORT_ENABLE RHPS_PES_FLAG
-#define RHPS_PSS_FLAG (1 << 2) /* r: port suspend status
-                                * w: 1-set port suspend, 0-nothing */
-#define RHPS_SET_PORT_SUSPEND RHPS_PSS_FLAG
-#define RHPS_POCI_FLAG (1 << 3) /* r: port over-current (if reports are per-port
-                                 * w: 1-clear port suspend (start resume
-                                 *      if suspened)
-                                 *    0-nothing */
-#define RHPS_CLEAR_PORT_SUSPEND RHPS_POCI_FLAG
-#define RHPS_PRS_FLAG (1 << 4) /* r: port reset status
-                                * w: 1-set port reset, 0-nothing */
-#define RHPS_SET_PORT_RESET RHPS_PRS_FLAG
-#define RHPS_PPS_FLAG (1 << 8) /* r: port power status
-                                * w: 1-set port power, 0-nothing */
-#define RHPS_SET_PORT_POWER RHPS_PPS_FLAG
-#define RHPS_LSDA_FLAG (1 << 9) /* r: low speed device attached
-                                 * w: 1-clear port power, 0-nothing */
-#define RHPS_CLEAR_PORT_POWER RHPS_LSDA_FLAG
-#define RHPS_CSC_FLAG  (1 << 16) /* connect status change Write-Clean */
-#define RHPS_PESC_FLAG (1 << 17) /* port enable status change WC */
-#define RHPS_PSSC_FLAG (1 << 18) /* port suspend status change WC */
-#define RHPS_OCIC_FLAG (1 << 19) /* port over-current change WC */
-#define RHPS_PRSC_FLAG (1 << 20) /* port reset status change WC */
-#define RHPS_CHANGE_WC_MASK 0x1f0000
 } __attribute__((packed)) ohci_regs_t;
 #endif

uspace/drv/ohci/utils/malloc32.h

@@ -37 +37 @@
 #include <assert.h>
 #include <malloc.h>
-#include <errno.h>
 #include <mem.h>
 #include <as.h>

uspace/drv/uhci-hcd/batch.c

@@ -103 +103 @@
         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, 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);
 
 
         uhci_batch_t *data = malloc(sizeof(uhci_batch_t));
-        CHECK_NULL_DISPOSE_RETURN(data, "Failed to allocate batch data.\n");
+        CHECK_NULL_DISPOSE_RETURN(instance,
+            "Failed to allocate batch instance.\n");
         bzero(data, sizeof(uhci_batch_t));
         instance->private_data = data;

uspace/drv/uhci-hcd/hc.c

@@ -240 +240 @@
         usb_log_debug("Initialized device manager.\n");
 
-        ret = usb_endpoint_manager_init(&instance->ep_manager,
-            BANDWIDTH_AVAILABLE_USB11);
+        ret =
+            usb_endpoint_manager_init(&instance->ep_manager,
+                BANDWIDTH_AVAILABLE_USB11);
         assert(ret == EOK);
 

uspace/drv/usbmid/main.c

@@ -55 +55 @@
         int rc;
 
-        rc = usb_pipe_start_long_transfer(&dev->ctrl_pipe);
+        rc = usb_pipe_start_session(&dev->ctrl_pipe);
         if (rc != EOK) {
-                usb_log_error("Failed to start transfer on control pipe: %s.\n",
+                usb_log_error("Failed to start session on control pipe: %s.\n",
                     str_error(rc));
                 return rc;
@@ -64 +64 @@
         bool accept = usbmid_explore_device(dev);
 
-        usb_pipe_end_long_transfer(&dev->ctrl_pipe);
+        rc = usb_pipe_end_session(&dev->ctrl_pipe);
+        if (rc != EOK) {
+                usb_log_warning("Failed to end session on control pipe: %s.\n",
+                    str_error(rc));
+        }
 
         if (!accept) {

uspace/lib/usb/Makefile

@@ -43 +43 @@
         src/hidparser.c \
         src/hub.c \
-        src/pipepriv.c \
         src/pipes.c \
         src/pipesinit.c \

uspace/lib/usb/include/usb/pipes.h

@@ -42 +42 @@
 #include <ipc/devman.h>
 #include <ddf/driver.h>
-#include <fibril_synch.h>
 
 /** Abstraction of a physical connection to the device.
@@ -60 +59 @@
  * This endpoint must be bound with existing usb_device_connection_t
  * (i.e. the wire to send data over).
- *
- * Locking order: if you want to lock both mutexes
- * (@c guard and @c hc_phone_mutex), lock @c guard first.
- * It is not necessary to lock @c guard if you want to lock @c hc_phone_mutex
- * only.
  */
 typedef struct {
-        /** Guard of the whole pipe. */
-        fibril_mutex_t guard;
-
         /** The connection used for sending the data. */
         usb_device_connection_t *wire;
@@ -87 +78 @@
         /** Phone to the host controller.
          * Negative when no session is active.
-         * It is an error to access this member without @c hc_phone_mutex
-         * being locked.
-         * If call over the phone is to be made, it must be preceeded by
-         * call to pipe_add_ref() [internal libusb function].
          */
         int hc_phone;
-
-        /** Guard for serialization of requests over the phone. */
-        fibril_mutex_t hc_phone_mutex;
-
-        /** Number of active transfers over the pipe. */
-        int refcount;
 } usb_pipe_t;
 
@@ -162 +143 @@
 bool usb_pipe_is_session_started(usb_pipe_t *);
 
-int usb_pipe_start_long_transfer(usb_pipe_t *);
-void usb_pipe_end_long_transfer(usb_pipe_t *);
-
 int usb_pipe_read(usb_pipe_t *, void *, size_t, size_t *);
 int usb_pipe_write(usb_pipe_t *, void *, size_t);

uspace/lib/usb/src/devdrv.c

@@ -161 +161 @@
 
         /*
-         * We will do some querying of the device, it is worth to prepare
-         * the long transfer.
+         * For further actions, we need open session on default control pipe.
          */
-        rc = usb_pipe_start_long_transfer(&dev->ctrl_pipe);
-        if (rc != EOK) {
-                usb_log_error("Failed to start transfer: %s.\n",
+        rc = usb_pipe_start_session(&dev->ctrl_pipe);
+        if (rc != EOK) {
+                usb_log_error("Failed to start an IPC session: %s.\n",
                     str_error(rc));
                 return rc;
@@ -186 +185 @@
         }
 
-        usb_pipe_end_long_transfer(&dev->ctrl_pipe);
+        /* No checking here. */
+        usb_pipe_end_session(&dev->ctrl_pipe);
 
         /* Rollback actions. */

uspace/lib/usb/src/devpoll.c

@@ -77 +77 @@
                 int rc;
 
+                rc = usb_pipe_start_session(pipe);
+                if (rc != EOK) {
+                        failed_attempts++;
+                        continue;
+                }
+
                 size_t actual_size;
                 rc = usb_pipe_read(pipe, polling_data->buffer,
                     polling_data->request_size, &actual_size);
 
+                /* Quit the session regardless of errors. */
+                usb_pipe_end_session(pipe);
                 
 //              if (rc == ESTALL) {

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

@@ -63 +63 @@
         instance->transfer_type = transfer_type;
         instance->speed = speed;
-        instance->direction = ep->direction;
+        instance->direction = USB_DIRECTION_BOTH;
         instance->callback_in = func_in;
         instance->callback_out = func_out;

uspace/lib/usb/src/hub.c

@@ -288 +288 @@
         }
 
+
+        rc = usb_pipe_start_session(&ctrl_pipe);
+        if (rc != EOK) {
+                rc = ENOTCONN;
+                goto leave_release_default_address;
+        }
+
         rc = usb_request_set_address(&ctrl_pipe, dev_addr);
         if (rc != EOK) {
                 rc = ESTALL;
-                goto leave_release_default_address;
-        }
+                goto leave_stop_session;
+        }
+
+        usb_pipe_end_session(&ctrl_pipe);
 
         /*
@@ -352 +361 @@
          * Completely ignoring errors here.
          */
+
+leave_stop_session:
+        usb_pipe_end_session(&ctrl_pipe);
+
 leave_release_default_address:
         usb_pipe_unregister(&ctrl_pipe, &hc_conn);

uspace/lib/usb/src/pipes.c

@@ -41 +41 @@
 #include <errno.h>
 #include <assert.h>
-#include "pipepriv.h"
 
 #define IPC_AGAIN_DELAY (1000 * 2) /* 2ms */
@@ -242 +241 @@
  * necessary.
  *
- * @deprecated
- * Obsoleted with introduction of usb_pipe_start_long_transfer
- *
  * @param pipe Endpoint pipe to start the session on.
  * @return Error code.
@@ -250 +246 @@
 int usb_pipe_start_session(usb_pipe_t *pipe)
 {
-        usb_log_warning("usb_pipe_start_session() was deprecated.\n");
+        assert(pipe);
+
+        if (usb_pipe_is_session_started(pipe)) {
+                return EBUSY;
+        }
+
+        int phone = devman_device_connect(pipe->wire->hc_handle, 0);
+        if (phone < 0) {
+                return phone;
+        }
+
+        pipe->hc_phone = phone;
+
         return EOK;
 }
@@ -257 +265 @@
 /** Ends a session on the endpoint pipe.
  *
- * @deprecated
- * Obsoleted with introduction of usb_pipe_end_long_transfer
- *
  * @see usb_pipe_start_session
  *
@@ -267 +272 @@
 int usb_pipe_end_session(usb_pipe_t *pipe)
 {
-        usb_log_warning("usb_pipe_end_session() was deprecated.\n");
+        assert(pipe);
+
+        if (!usb_pipe_is_session_started(pipe)) {
+                return ENOENT;
+        }
+
+        int rc = async_hangup(pipe->hc_phone);
+        if (rc != EOK) {
+                return rc;
+        }
+
+        pipe->hc_phone = -1;
+
         return EOK;
 }
@@ -281 +298 @@
 bool usb_pipe_is_session_started(usb_pipe_t *pipe)
 {
-        pipe_acquire(pipe);
-        bool started = pipe->refcount > 0;
-        pipe_release(pipe);
-        return started;
-}
-
-/** Prepare pipe for a long transfer.
- *
- * By a long transfer is mean transfer consisting of several
- * requests to the HC.
- * Calling such function is optional and it has positive effect of
- * improved performance because IPC session is initiated only once.
- *
- * @param pipe Pipe over which the transfer will happen.
- * @return Error code.
- */
-int usb_pipe_start_long_transfer(usb_pipe_t *pipe)
-{
-        return pipe_add_ref(pipe);
-}
-
-/** Terminate a long transfer on a pipe.
- *
- * @see usb_pipe_start_long_transfer
- *
- * @param pipe Pipe where to end the long transfer.
- */
-void usb_pipe_end_long_transfer(usb_pipe_t *pipe)
-{
-        pipe_drop_ref(pipe);
+        return (pipe->hc_phone >= 0);
 }
 

uspace/lib/usb/src/pipesinit.c

@@ -356 +356 @@
         assert(connection);
 
-        fibril_mutex_initialize(&pipe->guard);
         pipe->wire = connection;
         pipe->hc_phone = -1;
-        fibril_mutex_initialize(&pipe->hc_phone_mutex);
         pipe->endpoint_no = endpoint_no;
         pipe->transfer_type = transfer_type;
         pipe->max_packet_size = max_packet_size;
         pipe->direction = direction;
-        pipe->refcount = 0;
 
         return EOK;
@@ -416 +413 @@
         int rc;
 
-        rc = usb_pipe_start_long_transfer(pipe);
+        TRY_LOOP(failed_attempts) {
+                rc = usb_pipe_start_session(pipe);
+                if (rc == EOK) {
+                        break;
+                }
+        }
         if (rc != EOK) {
                 return rc;
@@ -437 +439 @@
                 }
         }
-        usb_pipe_end_long_transfer(pipe);
+        usb_pipe_end_session(pipe);
         if (rc != EOK) {
                 return rc;

uspace/lib/usb/src/pipesio.c

@@ -49 +49 @@
 #include <assert.h>
 #include <usbhc_iface.h>
-#include "pipepriv.h"
 
 /** Request an in transfer, no checking of input parameters.
@@ -79 +78 @@
         }
 
-        /* Ensure serialization over the phone. */
-        pipe_start_transaction(pipe);
-
         /*
          * Make call identifying target USB device and type of transfer.
@@ -91 +87 @@
             NULL);
         if (opening_request == 0) {
-                pipe_end_transaction(pipe);
                 return ENOMEM;
         }
@@ -101 +96 @@
         aid_t data_request = async_data_read(pipe->hc_phone, buffer, size,
             &data_request_call);
-
-        /*
-         * Since now on, someone else might access the backing phone
-         * without breaking the transfer IPC protocol.
-         */
-        pipe_end_transaction(pipe);
 
         if (data_request == 0) {
@@ -157 +146 @@
 
         if (buffer == NULL) {
-                return EINVAL;
+                        return EINVAL;
         }
 
@@ -164 +153 @@
         }
 
+        if (!usb_pipe_is_session_started(pipe)) {
+                return EBADF;
+        }
+
         if (pipe->direction != USB_DIRECTION_IN) {
                 return EBADF;
@@ -172 +165 @@
         }
 
+        size_t act_size = 0;
         int rc;
-        rc = pipe_add_ref(pipe);
-        if (rc != EOK) {
-                return rc;
-        }
-
-
-        size_t act_size = 0;
 
         rc = usb_pipe_read_no_checks(pipe, buffer, size, &act_size);
-
-        pipe_drop_ref(pipe);
-
         if (rc != EOK) {
                 return rc;
@@ -226 +210 @@
         }
 
-        /* Ensure serialization over the phone. */
-        pipe_start_transaction(pipe);
-
         /*
          * Make call identifying target USB device and type of transfer.
@@ -238 +219 @@
             NULL);
         if (opening_request == 0) {
-                pipe_end_transaction(pipe);
                 return ENOMEM;
         }
@@ -246 +226 @@
          */
         int rc = async_data_write_start(pipe->hc_phone, buffer, size);
-
-        /*
-         * Since now on, someone else might access the backing phone
-         * without breaking the transfer IPC protocol.
-         */
-        pipe_end_transaction(pipe);
-
         if (rc != EOK) {
                 async_wait_for(opening_request, NULL);
@@ -287 +260 @@
         }
 
+        if (!usb_pipe_is_session_started(pipe)) {
+                return EBADF;
+        }
+
         if (pipe->direction != USB_DIRECTION_OUT) {
                 return EBADF;
@@ -295 +272 @@
         }
 
-        int rc;
-
-        rc = pipe_add_ref(pipe);
-        if (rc != EOK) {
-                return rc;
-        }
-
-        rc = usb_pipe_write_no_check(pipe, buffer, size);
-
-        pipe_drop_ref(pipe);
+        int rc = usb_pipe_write_no_check(pipe, buffer, size);
 
         return rc;
@@ -325 +293 @@
     void *data_buffer, size_t data_buffer_size, size_t *data_transfered_size)
 {
-        /* Ensure serialization over the phone. */
-        pipe_start_transaction(pipe);
-
         /*
          * Make call identifying target USB device and control transfer type.
@@ -346 +311 @@
             setup_buffer, setup_buffer_size);
         if (rc != EOK) {
-                pipe_end_transaction(pipe);
                 async_wait_for(opening_request, NULL);
                 return rc;
@@ -358 +322 @@
             data_buffer, data_buffer_size,
             &data_request_call);
-
-        /*
-         * Since now on, someone else might access the backing phone
-         * without breaking the transfer IPC protocol.
-         */
-        pipe_end_transaction(pipe);
-
-
         if (data_request == 0) {
                 async_wait_for(opening_request, NULL);
@@ -423 +379 @@
         }
 
+        if (!usb_pipe_is_session_started(pipe)) {
+                return EBADF;
+        }
+
         if ((pipe->direction != USB_DIRECTION_BOTH)
             || (pipe->transfer_type != USB_TRANSFER_CONTROL)) {
@@ -428 +388 @@
         }
 
-        int rc;
-
-        rc = pipe_add_ref(pipe);
-        if (rc != EOK) {
-                return rc;
-        }
-
         size_t act_size = 0;
-        rc = usb_pipe_control_read_no_check(pipe,
+        int rc = usb_pipe_control_read_no_check(pipe,
             setup_buffer, setup_buffer_size,
             data_buffer, data_buffer_size, &act_size);
-
-        pipe_drop_ref(pipe);
 
         if (rc != EOK) {
@@ -467 +418 @@
     void *data_buffer, size_t data_buffer_size)
 {
-        /* Ensure serialization over the phone. */
-        pipe_start_transaction(pipe);
-
         /*
          * Make call identifying target USB device and control transfer type.
@@ -480 +428 @@
             NULL);
         if (opening_request == 0) {
-                pipe_end_transaction(pipe);
                 return ENOMEM;
         }
@@ -490 +437 @@
             setup_buffer, setup_buffer_size);
         if (rc != EOK) {
-                pipe_end_transaction(pipe);
                 async_wait_for(opening_request, NULL);
                 return rc;
@@ -501 +447 @@
                 rc = async_data_write_start(pipe->hc_phone,
                     data_buffer, data_buffer_size);
-
-                /* All data sent, pipe can be released. */
-                pipe_end_transaction(pipe);
-
                 if (rc != EOK) {
                         async_wait_for(opening_request, NULL);
                         return rc;
                 }
-        } else {
-                /* No data to send, we can release the pipe for others. */
-                pipe_end_transaction(pipe);
         }
 
@@ -552 +491 @@
         }
 
+        if (!usb_pipe_is_session_started(pipe)) {
+                return EBADF;
+        }
+
         if ((pipe->direction != USB_DIRECTION_BOTH)
             || (pipe->transfer_type != USB_TRANSFER_CONTROL)) {
@@ -557 +500 @@
         }
 
-        int rc;
-
-        rc = pipe_add_ref(pipe);
-        if (rc != EOK) {
-                return rc;
-        }
-
-        rc = usb_pipe_control_write_no_check(pipe,
+        int rc = usb_pipe_control_write_no_check(pipe,
             setup_buffer, setup_buffer_size, data_buffer, data_buffer_size);
-
-        pipe_drop_ref(pipe);
 
         return rc;

uspace/lib/usb/src/recognise.c

@@ -404 +404 @@
         child->driver_data = dev_data;
 
+        rc = usb_pipe_start_session(&ctrl_pipe);
+        if (rc != EOK) {
+                goto failure;
+        }
+
         rc = usb_device_create_match_ids(&ctrl_pipe, &child->match_ids);
+        if (rc != EOK) {
+                goto failure;
+        }
+
+        rc = usb_pipe_end_session(&ctrl_pipe);
         if (rc != EOK) {
                 goto failure;