Changeset 48fe0c9 in mainline for uspace/drv/ohci/hc.c

Timestamp:

2011-03-21T13:43:27Z (13 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

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

Children:

361e61b, 5971dd3, 8a951ca

Parents:

0e45e7f (diff), 925e099 (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:

OHCI hc driver software side implementation

File:

• uspace/drv/ohci/hc.c (moved) (moved from uspace/drv/ohci/ohci_hc.c ) (1 diff)

uspace/drv/ohci/hc.c

@@ -39 +39 @@
 #include <usb/debug.h>
 #include <usb/usb.h>
+#include <usb/hub.h>
 #include <usb/ddfiface.h>
-#include <usb_iface.h>
+#include <usb/usbdevice.h>
 
-#include "ohci_hc.h"
+#include "hc.h"
 
-int ohci_hc_init(ohci_hc_t *instance, ddf_fun_t *fun,
+static int dummy_reset(int foo, void *arg)
+{
+        hc_t *hc = (hc_t*)arg;
+        assert(hc);
+        hc->rh.address = 0;
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+int hc_init(hc_t *instance, ddf_fun_t *fun, ddf_dev_t *dev,
     uintptr_t regs, size_t reg_size, bool interrupts)
 {
         assert(instance);
-        int ret = pio_enable((void*)regs, reg_size, (void**)&instance->registers);
+        int ret = EOK;
+
+        ret = pio_enable((void*)regs, reg_size, (void**)&instance->registers);
         if (ret != EOK) {
                 usb_log_error("Failed to gain access to device registers.\n");
                 return ret;
         }
-        instance->registers->interrupt_disable = 0;
-        /* enable interrupt on root hub status change */
-        instance->registers->interupt_enable |= IE_RHSC | IE_MIE;
+        instance->ddf_instance = fun;
+        device_keeper_init(&instance->manager);
 
 
-        ohci_rh_init(&instance->rh, instance->registers);
+        rh_init(&instance->rh, dev, instance->registers);
         /* TODO: implement */
-        /* TODO: register root hub */
         return EOK;
 }
 /*----------------------------------------------------------------------------*/
-int ohci_hc_schedule(ohci_hc_t *instance, batch_t *batch)
+int hc_register_hub(hc_t *instance)
+{
+        async_usleep(1000000);
+#define CHECK_RET_RETURN(ret, msg...) \
+        if (ret != EOK) { \
+                usb_log_error(msg); \
+                return ret; \
+        } else (void)0
+        assert(instance);
+        assert(instance->ddf_instance);
+        assert(instance->ddf_instance->handle);
+        ddf_dev_t *dev = instance->rh.device;
+        int ret = EOK;
+
+        usb_hc_connection_t conn;
+        ret =
+            usb_hc_connection_initialize(&conn, instance->ddf_instance->handle);
+        CHECK_RET_RETURN(ret, "Failed to initialize hc connection.\n");
+
+        ret = usb_hc_connection_open(&conn);
+        CHECK_RET_RETURN(ret, "Failed to open hc connection.\n");
+
+        usb_address_t address;
+        devman_handle_t handle;
+        ret = usb_hc_new_device_wrapper(dev, &conn, USB_SPEED_FULL, dummy_reset,
+            0, instance, &address, &handle, NULL, NULL, NULL);
+        CHECK_RET_RETURN(ret, "Failed to add rh device.\n");
+
+        ret = usb_hc_connection_close(&conn);
+        CHECK_RET_RETURN(ret, "Failed to close hc connection.\n");
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+int hc_schedule(hc_t *instance, batch_t *batch)
 {
         assert(instance);
         assert(batch);
         if (batch->target.address == instance->rh.address) {
-                ohci_rh_request(&instance->rh, batch);
-                return EOK;
+                return rh_request(&instance->rh, batch);
         }
         /* TODO: implement */
-        return EOK;
+        return ENOTSUP;
 }
 /*----------------------------------------------------------------------------*/
-void ohci_hc_interrupt(ohci_hc_t *instance, uint16_t status)
+void hc_interrupt(hc_t *instance, uint16_t status)
 {
         assert(instance);
         /* TODO: Check for interrupt cause */
-        ohci_rh_interrupt(&instance->rh);
+        rh_interrupt(&instance->rh);
         /* TODO: implement */
 }