Changes in uspace/drv/bus/usb/ohci/hc.c [8b54fe6:ef9460b] in mainline

File:

• uspace/drv/bus/usb/ohci/hc.c (modified) (12 diffs)

uspace/drv/bus/usb/ohci/hc.c

@@ -42 +42 @@
 
 #include "hc.h"
-#include "ohci_endpoint.h"
+#include "hcd_endpoint.h"
 
 #define OHCI_USED_INTERRUPTS \
@@ -61 +61 @@
 static int hc_init_memory(hc_t *instance);
 static int interrupt_emulator(hc_t *instance);
-static int hc_schedule(hcd_t *hcd, usb_transfer_batch_t *batch);
+
 /*----------------------------------------------------------------------------*/
 /** Get number of commands used in IRQ code.
@@ -128 +128 @@
 
         const usb_address_t hub_address =
-            usb_device_manager_get_free_address(
-                &instance->generic.dev_manager, USB_SPEED_FULL);
+            device_keeper_get_free_address(&instance->manager, USB_SPEED_FULL);
         if (hub_address <= 0) {
                 usb_log_error("Failed to get OHCI root hub address: %s\n",
@@ -136 +135 @@
         }
         instance->rh.address = hub_address;
-        usb_device_manager_bind(
-            &instance->generic.dev_manager, hub_address, hub_fun->handle);
-
-#define CHECK_RET_UNREG_RETURN(ret, message...) \
+        usb_device_keeper_bind(
+            &instance->manager, hub_address, hub_fun->handle);
+
+#define CHECK_RET_RELEASE(ret, message...) \
 if (ret != EOK) { \
         usb_log_error(message); \
-        usb_endpoint_manager_unregister_ep( \
-            &instance->generic.ep_manager, hub_address, 0, USB_DIRECTION_BOTH);\
-        usb_device_manager_release( \
-            &instance->generic.dev_manager, hub_address); \
+        hc_remove_endpoint(instance, hub_address, 0, USB_DIRECTION_BOTH); \
+        usb_device_keeper_release(&instance->manager, hub_address); \
         return ret; \
 } else (void)0
-        int ret = usb_endpoint_manager_add_ep(
-            &instance->generic.ep_manager, hub_address, 0, USB_DIRECTION_BOTH,
-            USB_TRANSFER_CONTROL, USB_SPEED_FULL, 64, 0);
-        CHECK_RET_UNREG_RETURN(ret,
-            "Failed to register root hub control endpoint: %s.\n",
-            str_error(ret));
+
+        int ret = hc_add_endpoint(instance, hub_address, 0, USB_SPEED_FULL,
+            USB_TRANSFER_CONTROL, USB_DIRECTION_BOTH, 64, 0, 0);
+        CHECK_RET_RELEASE(ret,
+            "Failed to add OHCI root hub endpoint 0: %s.\n", str_error(ret));
 
         ret = ddf_fun_add_match_id(hub_fun, "usb&class=hub", 100);
-        CHECK_RET_UNREG_RETURN(ret,
+        CHECK_RET_RELEASE(ret,
             "Failed to add root hub match-id: %s.\n", str_error(ret));
 
         ret = ddf_fun_bind(hub_fun);
-        CHECK_RET_UNREG_RETURN(ret,
+        CHECK_RET_RELEASE(ret,
             "Failed to bind root hub function: %s.\n", str_error(ret));
 
@@ -191 +187 @@
 
         list_initialize(&instance->pending_batches);
-
-        ret = hcd_init(&instance->generic, BANDWIDTH_AVAILABLE_USB11,
-            bandwidth_count_usb11);
-        CHECK_RET_RETURN(ret, "Failed to initialize generic driver: %s.\n",
+        usb_device_keeper_init(&instance->manager);
+
+        ret = usb_endpoint_manager_init(&instance->ep_manager,
+            BANDWIDTH_AVAILABLE_USB11);
+        CHECK_RET_RETURN(ret, "Failed to initialize endpoint manager: %s.\n",
             str_error(ret));
-        instance->generic.private_data = instance;
-        instance->generic.schedule = hc_schedule;
-        instance->generic.ep_add_hook = ohci_endpoint_init;
 
         ret = hc_init_memory(instance);
@@ -221 +215 @@
 }
 /*----------------------------------------------------------------------------*/
-void hc_enqueue_endpoint(hc_t *instance, endpoint_t *ep)
-{
-        endpoint_list_t *list = &instance->lists[ep->transfer_type];
-        ohci_endpoint_t *ohci_ep = ohci_endpoint_get(ep);
-        /* Enqueue ep */
+/** Create and register endpoint structures.
+ *
+ * @param[in] instance OHCI driver structure.
+ * @param[in] address USB address of the device.
+ * @param[in] endpoint USB endpoint number.
+ * @param[in] speed Communication speeed of the device.
+ * @param[in] type Endpoint's transfer type.
+ * @param[in] direction Endpoint's direction.
+ * @param[in] mps Maximum packet size the endpoint accepts.
+ * @param[in] size Maximum allowed buffer size.
+ * @param[in] interval Time between transfers(interrupt transfers only).
+ * @return Error code
+ */
+int hc_add_endpoint(
+    hc_t *instance, usb_address_t address, usb_endpoint_t endpoint,
+    usb_speed_t speed, usb_transfer_type_t type, usb_direction_t direction,
+    size_t mps, size_t size, unsigned interval)
+{
+        endpoint_t *ep =
+            endpoint_get(address, endpoint, direction, type, speed, mps);
+        if (ep == NULL)
+                return ENOMEM;
+
+        hcd_endpoint_t *hcd_ep = hcd_endpoint_assign(ep);
+        if (hcd_ep == NULL) {
+                endpoint_destroy(ep);
+                return ENOMEM;
+        }
+
+        int ret =
+            usb_endpoint_manager_register_ep(&instance->ep_manager, ep, size);
+        if (ret != EOK) {
+                hcd_endpoint_clear(ep);
+                endpoint_destroy(ep);
+                return ret;
+        }
+
+        /* Enqueue hcd_ep */
         switch (ep->transfer_type) {
         case USB_TRANSFER_CONTROL:
                 instance->registers->control &= ~C_CLE;
-                endpoint_list_add_ep(list, ohci_ep);
+                endpoint_list_add_ep(
+                    &instance->lists[ep->transfer_type], hcd_ep);
                 instance->registers->control_current = 0;
                 instance->registers->control |= C_CLE;
@@ -235 +263 @@
         case USB_TRANSFER_BULK:
                 instance->registers->control &= ~C_BLE;
-                endpoint_list_add_ep(list, ohci_ep);
+                endpoint_list_add_ep(
+                    &instance->lists[ep->transfer_type], hcd_ep);
                 instance->registers->control |= C_BLE;
                 break;
@@ -241 +270 @@
         case USB_TRANSFER_INTERRUPT:
                 instance->registers->control &= (~C_PLE & ~C_IE);
-                endpoint_list_add_ep(list, ohci_ep);
+                endpoint_list_add_ep(
+                    &instance->lists[ep->transfer_type], hcd_ep);
                 instance->registers->control |= C_PLE | C_IE;
                 break;
         }
-}
-/*----------------------------------------------------------------------------*/
-void hc_dequeue_endpoint(hc_t *instance, endpoint_t *ep)
-{
-        /* Dequeue ep */
-        endpoint_list_t *list = &instance->lists[ep->transfer_type];
-        ohci_endpoint_t *ohci_ep = ohci_endpoint_get(ep);
-        switch (ep->transfer_type) {
-        case USB_TRANSFER_CONTROL:
-                instance->registers->control &= ~C_CLE;
-                endpoint_list_remove_ep(list, ohci_ep);
-                instance->registers->control_current = 0;
-                instance->registers->control |= C_CLE;
-                break;
-        case USB_TRANSFER_BULK:
-                instance->registers->control &= ~C_BLE;
-                endpoint_list_remove_ep(list, ohci_ep);
-                instance->registers->control |= C_BLE;
-                break;
-        case USB_TRANSFER_ISOCHRONOUS:
-        case USB_TRANSFER_INTERRUPT:
-                instance->registers->control &= (~C_PLE & ~C_IE);
-                endpoint_list_remove_ep(list, ohci_ep);
-                instance->registers->control |= C_PLE | C_IE;
-                break;
-        default:
-                break;
-        }
+
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+/** Dequeue and delete endpoint structures
+ *
+ * @param[in] instance OHCI hc driver structure.
+ * @param[in] address USB address of the device.
+ * @param[in] endpoint USB endpoint number.
+ * @param[in] direction Direction of the endpoint.
+ * @return Error code
+ */
+int hc_remove_endpoint(hc_t *instance, usb_address_t address,
+    usb_endpoint_t endpoint, usb_direction_t direction)
+{
+        assert(instance);
+        fibril_mutex_lock(&instance->guard);
+        endpoint_t *ep = usb_endpoint_manager_get_ep(&instance->ep_manager,
+            address, endpoint, direction, NULL);
+        if (ep == NULL) {
+                usb_log_error("Endpoint unregister failed: No such EP.\n");
+                fibril_mutex_unlock(&instance->guard);
+                return ENOENT;
+        }
+
+        hcd_endpoint_t *hcd_ep = hcd_endpoint_get(ep);
+        if (hcd_ep) {
+                /* Dequeue hcd_ep */
+                switch (ep->transfer_type) {
+                case USB_TRANSFER_CONTROL:
+                        instance->registers->control &= ~C_CLE;
+                        endpoint_list_remove_ep(
+                            &instance->lists[ep->transfer_type], hcd_ep);
+                        instance->registers->control_current = 0;
+                        instance->registers->control |= C_CLE;
+                        break;
+                case USB_TRANSFER_BULK:
+                        instance->registers->control &= ~C_BLE;
+                        endpoint_list_remove_ep(
+                            &instance->lists[ep->transfer_type], hcd_ep);
+                        instance->registers->control |= C_BLE;
+                        break;
+                case USB_TRANSFER_ISOCHRONOUS:
+                case USB_TRANSFER_INTERRUPT:
+                        instance->registers->control &= (~C_PLE & ~C_IE);
+                        endpoint_list_remove_ep(
+                            &instance->lists[ep->transfer_type], hcd_ep);
+                        instance->registers->control |= C_PLE | C_IE;
+                        break;
+                default:
+                        break;
+                }
+                hcd_endpoint_clear(ep);
+        } else {
+                usb_log_warning("Endpoint without hcd equivalent structure.\n");
+        }
+        int ret = usb_endpoint_manager_unregister_ep(&instance->ep_manager,
+            address, endpoint, direction);
+        fibril_mutex_unlock(&instance->guard);
+        return ret;
+}
+/*----------------------------------------------------------------------------*/
+/** Get access to endpoint structures
+ *
+ * @param[in] instance OHCI hc driver structure.
+ * @param[in] address USB address of the device.
+ * @param[in] endpoint USB endpoint number.
+ * @param[in] direction Direction of the endpoint.
+ * @param[out] bw Reserved bandwidth.
+ * @return Error code
+ */
+endpoint_t * hc_get_endpoint(hc_t *instance, usb_address_t address,
+    usb_endpoint_t endpoint, usb_direction_t direction, size_t *bw)
+{
+        assert(instance);
+        fibril_mutex_lock(&instance->guard);
+        endpoint_t *ep = usb_endpoint_manager_get_ep(&instance->ep_manager,
+            address, endpoint, direction, bw);
+        fibril_mutex_unlock(&instance->guard);
+        return ep;
 }
 /*----------------------------------------------------------------------------*/
@@ -281 +363 @@
  * @return Error code.
  */
-int hc_schedule(hcd_t *hcd, usb_transfer_batch_t *batch)
-{
-        assert(hcd);
-        hc_t *instance = hcd->private_data;
-        assert(instance);
+int hc_schedule(hc_t *instance, usb_transfer_batch_t *batch)
+{
+        assert(instance);
+        assert(batch);
+        assert(batch->ep);
 
         /* Check for root hub communication */
@@ -292 +374 @@
                 return EOK;
         }
-        ohci_transfer_batch_t *ohci_batch = ohci_transfer_batch_get(batch);
-        if (!ohci_batch)
-                return ENOMEM;
 
         fibril_mutex_lock(&instance->guard);
-        list_append(&ohci_batch->link, &instance->pending_batches);
-        ohci_transfer_batch_commit(ohci_batch);
+        list_append(&batch->link, &instance->pending_batches);
+        batch_commit(batch);
 
         /* Control and bulk schedules need a kick to start working */
@@ -338 +417 @@
                     instance->registers->periodic_current);
 
-                link_t *current = list_first(&instance->pending_batches);
-                while (current && current != &instance->pending_batches.head) {
+                link_t *current = instance->pending_batches.head.next;
+                while (current != &instance->pending_batches.head) {
                         link_t *next = current->next;
-                        ohci_transfer_batch_t *batch =
-                            ohci_transfer_batch_from_link(current);
-
-                        if (ohci_transfer_batch_is_complete(batch)) {
+                        usb_transfer_batch_t *batch =
+                            usb_transfer_batch_from_link(current);
+
+                        if (batch_is_complete(batch)) {
                                 list_remove(current);
-                                ohci_transfer_batch_finish_dispose(batch);
+                                usb_transfer_batch_finish(batch);
                         }
 
@@ -355 +434 @@
 
         if (status & I_UE) {
-                usb_log_fatal("Error like no other!\n");
                 hc_start(instance);
         }