Changes in uspace/drv/uhci-hcd/main.c [b375bb8:357a302] in mainline

File:

• uspace/drv/uhci-hcd/main.c (modified) (2 diffs)

uspace/drv/uhci-hcd/main.c

@@ -32 +32 @@
  * @brief UHCI driver
  */
-#include <ddf/driver.h>
-#include <ddf/interrupt.h>
-#include <device/hw_res.h>
+#include <driver.h>
+#include <usb_iface.h>
+
 #include <errno.h>
-#include <str_error.h>
 
-#include <usb_iface.h>
-#include <usb/ddfiface.h>
 #include <usb/debug.h>
 
@@ -49 +46 @@
 #define NAME "uhci-hcd"
 
-static int uhci_add_device(ddf_dev_t *device);
-/*----------------------------------------------------------------------------*/
+static int usb_iface_get_hc_handle(device_t *dev, devman_handle_t *handle)
+{
+        /* This shall be called only for the UHCI itself. */
+        assert(dev->parent == NULL);
+
+        *handle = dev->handle;
+        return EOK;
+}
+
+static int usb_iface_get_address(device_t *dev, devman_handle_t handle,
+    usb_address_t *address)
+{
+        assert(dev);
+        uhci_t *hc = dev_to_uhci(dev);
+        assert(hc);
+
+        usb_address_t addr = usb_address_keeping_find(&hc->address_manager,
+            handle);
+        if (addr < 0) {
+                return addr;
+        }
+
+        if (address != NULL) {
+                *address = addr;
+        }
+
+        return EOK;
+}
+
+static usb_iface_t hc_usb_iface = {
+        .get_hc_handle = usb_iface_get_hc_handle,
+        .get_address = usb_iface_get_address
+};
+
+static device_ops_t uhci_ops = {
+        .interfaces[USB_DEV_IFACE] = &hc_usb_iface,
+        .interfaces[USBHC_DEV_IFACE] = &uhci_iface
+};
+
+static int uhci_add_device(device_t *device)
+{
+        assert(device);
+
+        usb_log_info("uhci_add_device() called\n");
+        device->ops = &uhci_ops;
+
+        uintptr_t io_reg_base;
+        size_t io_reg_size;
+        int irq;
+
+        int rc = pci_get_my_registers(device,
+            &io_reg_base, &io_reg_size, &irq);
+
+        if (rc != EOK) {
+                usb_log_error("Failed(%d) to get I/O registers addresses for device:.\n",
+                    rc, device->handle);
+                return rc;
+        }
+
+        usb_log_info("I/O regs at 0x%X (size %zu), IRQ %d.\n",
+            io_reg_base, io_reg_size, irq);
+
+        uhci_t *uhci_hc = malloc(sizeof(uhci_t));
+        if (!uhci_hc) {
+                usb_log_error("Failed to allocaete memory for uhci hcd driver.\n");
+                return ENOMEM;
+        }
+
+        int ret = uhci_init(uhci_hc, (void*)io_reg_base, io_reg_size);
+        if (ret != EOK) {
+                usb_log_error("Failed to init uhci-hcd.\n");
+                return ret;
+        }
+        device_t *rh;
+        ret = setup_root_hub(&rh, device);
+
+        if (ret != EOK) {
+                usb_log_error("Failed to setup uhci root hub.\n");
+                /* TODO: destroy uhci here */
+                return ret;
+        }
+
+        ret = child_device_register(rh, device);
+        if (ret != EOK) {
+                usb_log_error("Failed to register root hub.\n");
+                /* TODO: destroy uhci here */
+                return ret;
+        }
+
+        device->driver_data = uhci_hc;
+
+        return EOK;
+}
+
 static driver_ops_t uhci_driver_ops = {
         .add_device = uhci_add_device,
 };
-/*----------------------------------------------------------------------------*/
+
 static driver_t uhci_driver = {
         .name = NAME,
         .driver_ops = &uhci_driver_ops
 };
-/*----------------------------------------------------------------------------*/
-static void irq_handler(ddf_dev_t *dev, ipc_callid_t iid, ipc_call_t *call)
-{
-        assert(dev);
-        uhci_t *hc = dev_to_uhci(dev);
-        uint16_t status = IPC_GET_ARG1(*call);
-        assert(hc);
-        uhci_interrupt(hc, status);
-}
-/*----------------------------------------------------------------------------*/
-static int uhci_add_device(ddf_dev_t *device)
-{
-        assert(device);
-        uhci_t *hcd = NULL;
-#define CHECK_RET_FREE_HC_RETURN(ret, message...) \
-if (ret != EOK) { \
-        usb_log_error(message); \
-        if (hcd != NULL) \
-                free(hcd); \
-        return ret; \
-}
 
-        usb_log_info("uhci_add_device() called\n");
-
-        uintptr_t io_reg_base = 0;
-        size_t io_reg_size = 0;
-        int irq = 0;
-
-        int ret =
-            pci_get_my_registers(device, &io_reg_base, &io_reg_size, &irq);
-        CHECK_RET_FREE_HC_RETURN(ret,
-            "Failed(%d) to get I/O addresses:.\n", ret, device->handle);
-        usb_log_info("I/O regs at 0x%X (size %zu), IRQ %d.\n",
-            io_reg_base, io_reg_size, irq);
-
-        ret = pci_disable_legacy(device);
-        CHECK_RET_FREE_HC_RETURN(ret,
-            "Failed(%d) disable legacy USB: %s.\n", ret, str_error(ret));
-
-#if 0
-        ret = pci_enable_interrupts(device);
-        if (ret != EOK) {
-                usb_log_warning(
-                    "Failed(%d) to enable interrupts, fall back to polling.\n",
-                    ret);
-        }
-#endif
-
-        hcd = malloc(sizeof(uhci_t));
-        ret = (hcd != NULL) ? EOK : ENOMEM;
-        CHECK_RET_FREE_HC_RETURN(ret,
-            "Failed(%d) to allocate memory for uhci hcd.\n", ret);
-
-        ret = uhci_init(hcd, device, (void*)io_reg_base, io_reg_size);
-        CHECK_RET_FREE_HC_RETURN(ret, "Failed(%d) to init uhci-hcd.\n",
-            ret);
-#undef CHECK_RET_FREE_HC_RETURN
-
-        /*
-         * We might free hcd, but that does not matter since no one
-         * else would access driver_data anyway.
-         */
-        device->driver_data = hcd;
-
-        ddf_fun_t *rh = NULL;
-#define CHECK_RET_FINI_FREE_RETURN(ret, message...) \
-if (ret != EOK) { \
-        usb_log_error(message); \
-        if (hcd != NULL) {\
-                uhci_fini(hcd); \
-                free(hcd); \
-        } \
-        if (rh != NULL) \
-                free(rh); \
-        return ret; \
-}
-
-        /* It does no harm if we register this on polling */
-        ret = register_interrupt_handler(device, irq, irq_handler,
-            &hcd->interrupt_code);
-        CHECK_RET_FINI_FREE_RETURN(ret,
-            "Failed(%d) to register interrupt handler.\n", ret);
-
-        ret = setup_root_hub(&rh, device);
-        CHECK_RET_FINI_FREE_RETURN(ret,
-            "Failed(%d) to setup UHCI root hub.\n", ret);
-        rh->driver_data = hcd->ddf_instance;
-
-        ret = ddf_fun_bind(rh);
-        CHECK_RET_FINI_FREE_RETURN(ret,
-            "Failed(%d) to register UHCI root hub.\n", ret);
-
-        return EOK;
-#undef CHECK_RET_FINI_FREE_RETURN
-}
-/*----------------------------------------------------------------------------*/
 int main(int argc, char *argv[])
 {
-        sleep(3);
-        usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);
+        /*
+         * Do some global initializations.
+         */
+        sleep(5);
+        usb_log_enable(USB_LOG_LEVEL_INFO, NAME);
 
-        return ddf_driver_main(&uhci_driver);
+        return driver_main(&uhci_driver);
 }
 /**