Changeset 7de1988c in mainline for uspace/drv/bus/usb/ohci

Timestamp:

2013-09-12T20:53:09Z (13 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

ddd0499d

Parents:

8049b79

Message:

Adapt drivers using parsed HW resources to use the new interface.

Location:

uspace/drv/bus/usb/ohci

Files:

• hc.c (modified) (6 diffs)
• hc.h (modified) (1 diff)
• ohci.c (modified) (3 diffs)
• res.c (modified) (3 diffs)
• res.h (modified) (1 diff)

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

@@ -106 +106 @@
  * @param[out] cmds Commands buffer.
  * @param[in] cmds_size Size of the commands buffer (bytes).
- * @param[in] regs Physical address of device's registers.
- * @param[in] reg_size Size of the register area (bytes).
+ * @param[in] regs Device's register range.
  *
  * @return Error code.
@@ -113 +112 @@
 int
 hc_get_irq_code(irq_pio_range_t ranges[], size_t ranges_size, irq_cmd_t cmds[],
-    size_t cmds_size, uintptr_t regs, size_t reg_size)
+    size_t cmds_size, addr_range_t *regs)
 {
         if ((ranges_size < sizeof(ohci_pio_ranges)) ||
             (cmds_size < sizeof(ohci_irq_commands)) ||
-            (reg_size < sizeof(ohci_regs_t)))
+            (RNGSZ(*regs) < sizeof(ohci_regs_t)))
                 return EOVERFLOW;
 
         memcpy(ranges, ohci_pio_ranges, sizeof(ohci_pio_ranges));
-        ranges[0].base = regs;
+        ranges[0].base = RNGABS(*regs);
 
         memcpy(cmds, ohci_irq_commands, sizeof(ohci_irq_commands));
-        ohci_regs_t *registers = (ohci_regs_t *) regs;
+        ohci_regs_t *registers = (ohci_regs_t *) RNGABSPTR(*regs);
         cmds[0].addr = (void *) &registers->interrupt_status;
         cmds[3].addr = (void *) &registers->interrupt_status;
@@ -135 +134 @@
  *
  * @param[in] device Host controller DDF device
- * @param[in] reg_base Register range base
- * @param[in] reg_size Register range size
+ * @param[in] regs Register range
  * @param[in] irq Interrupt number
  * @paran[in] handler Interrupt handler
@@ -142 +140 @@
  * @return EOK on success or negative error code
  */
-int hc_register_irq_handler(ddf_dev_t *device, uintptr_t reg_base, size_t reg_size,
-    int irq, interrupt_handler_t handler)
+int hc_register_irq_handler(ddf_dev_t *device, addr_range_t *regs, int irq,
+    interrupt_handler_t handler)
 {
         int rc;
@@ -158 +156 @@
 
         rc = hc_get_irq_code(irq_ranges, sizeof(irq_ranges), irq_cmds,
-            sizeof(irq_cmds), reg_base, reg_size);
+            sizeof(irq_cmds), regs);
         if (rc != EOK) {
                 usb_log_error("Failed to generate IRQ code: %s.\n",
@@ -259 +257 @@
  *
  * @param[in] instance Memory place for the structure.
- * @param[in] regs Address of the memory mapped I/O registers.
- * @param[in] reg_size Size of the memory mapped area.
+ * @param[in] regs Device's I/O registers range.
  * @param[in] interrupts True if w interrupts should be used
  * @return Error code
  */
-int hc_init(hc_t *instance, uintptr_t regs, size_t reg_size, bool interrupts)
-{
-        assert(instance);
-
-        int rc =
-            pio_enable((void*)regs, reg_size, (void**)&instance->registers);
+int hc_init(hc_t *instance, addr_range_t *regs, bool interrupts)
+{
+        assert(instance);
+
+        int rc = pio_enable_range(regs, (void **) &instance->registers);
         if (rc != EOK) {
                 usb_log_error("Failed to gain access to device registers: %s.\n",

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

@@ -75 +75 @@
 } hc_t;
 
-int hc_get_irq_code(irq_pio_range_t [], size_t, irq_cmd_t [], size_t, uintptr_t,
-    size_t);
-int hc_register_irq_handler(ddf_dev_t *, uintptr_t, size_t, int, interrupt_handler_t);
+int hc_get_irq_code(irq_pio_range_t [], size_t, irq_cmd_t [], size_t,
+    addr_range_t *);
+int hc_register_irq_handler(ddf_dev_t *, addr_range_t *, int,
+    interrupt_handler_t);
 int hc_register_hub(hc_t *instance, ddf_fun_t *hub_fun);
-int hc_init(hc_t *instance, uintptr_t regs, size_t reg_size, bool interrupts);
+int hc_init(hc_t *instance, addr_range_t *regs, bool interrupts);
 
 /** Safely dispose host controller internal structures

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

@@ -177 +177 @@
         ddf_fun_set_ops(instance->rh_fun, &rh_ops);
 
-        uintptr_t reg_base = 0;
-        size_t reg_size = 0;
+        addr_range_t regs;
         int irq = 0;
 
-        rc = get_my_registers(device, &reg_base, &reg_size, &irq);
+        rc = get_my_registers(device, &regs, &irq);
         if (rc != EOK) {
                 usb_log_error("Failed to get register memory addresses "
@@ -190 +189 @@
 
         usb_log_debug("Memory mapped regs at %p (size %zu), IRQ %d.\n",
-            (void *) reg_base, reg_size, irq);
-
-        rc = hc_register_irq_handler(device, reg_base, reg_size, irq, irq_handler);
+            RNGABSPTR(regs), RNGSZ(regs), irq);
+
+        rc = hc_register_irq_handler(device, &regs, irq, irq_handler);
         if (rc != EOK) {
                 usb_log_error("Failed to register interrupt handler: %s.\n",
@@ -215 +214 @@
         }
 
-        rc = hc_init(&instance->hc, reg_base, reg_size, interrupts);
+        rc = hc_init(&instance->hc, &regs, interrupts);
         if (rc != EOK) {
                 usb_log_error("Failed to init ohci_hcd: %s.\n", str_error(rc));

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

@@ -48 +48 @@
  *
  * @param[in] dev Device asking for the addresses.
- * @param[out] mem_reg_address Base address of the memory range.
- * @param[out] mem_reg_size Size of the memory range.
+ * @param[out] p_regs Pointer to register range.
  * @param[out] irq_no IRQ assigned to the device.
  * @return Error code.
  */
-int get_my_registers(ddf_dev_t *dev,
-    uintptr_t *mem_reg_address, size_t *mem_reg_size, int *irq_no)
+int get_my_registers(ddf_dev_t *dev, addr_range_t *p_regs, int *irq_no)
 {
         assert(dev);
@@ -66 +64 @@
         hw_res_list_parsed_t hw_res;
         hw_res_list_parsed_init(&hw_res);
-        const int ret =  hw_res_get_list_parsed(parent_sess, &hw_res, 0);
+        const int ret = hw_res_get_list_parsed(parent_sess, &hw_res, 0);
         async_hangup(parent_sess);
         if (ret != EOK) {
@@ -78 +76 @@
         }
 
-        if (mem_reg_address)
-                *mem_reg_address = hw_res.mem_ranges.ranges[0].address;
-        if (mem_reg_size)
-                *mem_reg_size = hw_res.mem_ranges.ranges[0].size;
+        if (p_regs)
+                *p_regs = hw_res.mem_ranges.ranges[0];
         if (irq_no)
                 *irq_no = hw_res.irqs.irqs[0];

uspace/drv/bus/usb/ohci/res.h

@@ -36 +36 @@
 
 #include <ddf/driver.h>
+#include <device/hw_res_parsed.h>
 
-int get_my_registers(ddf_dev_t *, uintptr_t *, size_t *, int *);
+int get_my_registers(ddf_dev_t *, addr_range_t *, int *);
 int enable_interrupts(ddf_dev_t *);