Changeset 071a1ddb in mainline for uspace/lib

Timestamp:

2017-12-08T21:17:27Z (8 years ago)

Author:

Jiří Zárevúcky <zarevucky.jiri@…>

Branches:

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

Children:

0722869, 569a51a

Parents:

9233e9d

git-author:

Jiří Zárevúcky <zarevucky.jiri@…> (2017-12-08 00:30:18)

git-committer:

Jiří Zárevúcky <zarevucky.jiri@…> (2017-12-08 21:17:27)

Message:

Return IRQ handles via a separate out parameter in all uspace code.

Location:

uspace/lib

Files:

• c/generic/async.c (modified) (2 diffs)
• c/include/async.h (modified) (1 diff)
• drv/generic/interrupt.c (modified) (1 diff)
• drv/include/ddf/interrupt.h (modified) (1 diff)
• usbhost/include/usb/host/ddf_helpers.h (modified) (1 diff)
• usbhost/src/ddf_helpers.c (modified) (3 diffs)

uspace/lib/c/generic/async.c

@@ -1051 +1051 @@
  * @param ucode   Top-half pseudocode handler.
  *
- * @return IRQ capability handle on success.
+ * @param[out] handle  IRQ capability handle on success.
+ *
  * @return Negative error code.
  *
  */
 int async_irq_subscribe(int inr, async_notification_handler_t handler,
-    void *data, const irq_code_t *ucode)
+    void *data, const irq_code_t *ucode, cap_handle_t *handle)
 {
         notification_t *notification =
@@ -1078 +1079 @@
         cap_handle_t cap;
         int rc = ipc_irq_subscribe(inr, imethod, ucode, &cap);
-        if (rc != EOK) {
-                return rc;
-        }
-        return cap;
+        if (rc == EOK && handle != NULL) {
+                *handle = cap;
+        }
+        return rc;
 }
 

uspace/lib/c/include/async.h

@@ -169 +169 @@
 
 extern int async_irq_subscribe(int, async_notification_handler_t, void *,
-    const irq_code_t *);
+    const irq_code_t *, cap_handle_t *);
 extern int async_irq_unsubscribe(int);
 

uspace/lib/drv/generic/interrupt.c

@@ -44 +44 @@
 
 int register_interrupt_handler(ddf_dev_t *dev, int irq,
-    interrupt_handler_t *handler, const irq_code_t *irq_code)
+    interrupt_handler_t *handler, const irq_code_t *irq_code,
+    cap_handle_t *handle)
 {
         return async_irq_subscribe(irq, (async_notification_handler_t) handler,
-            dev, irq_code);
+            dev, irq_code, handle);
 }
 

uspace/lib/drv/include/ddf/interrupt.h

@@ -51 +51 @@
 
 extern int register_interrupt_handler(ddf_dev_t *, int, interrupt_handler_t *,
-    const irq_code_t *);
+    const irq_code_t *, cap_handle_t *);
 extern int unregister_interrupt_handler(ddf_dev_t *, int);
 

uspace/lib/usbhost/include/usb/host/ddf_helpers.h

@@ -75 +75 @@
     const hw_res_list_parsed_t *hw_res,
     interrupt_handler_t handler,
-    int (*gen_irq_code)(irq_code_t *, const hw_res_list_parsed_t *));
+    int (*gen_irq_code)(irq_code_t *, const hw_res_list_parsed_t *),
+    cap_handle_t *handle);
 void ddf_hcd_gen_irq_handler(ipc_call_t *call, ddf_dev_t *dev);
 

uspace/lib/usbhost/src/ddf_helpers.c

@@ -742 +742 @@
  * @param[in] gen_irq_code IRQ code generator.
  *
- * @return IRQ capability handle on success.
- * @return Negative error code.
+ * @param[out] handle  IRQ capability handle on success.
+ *
+ * @return Error code.
  */
 int hcd_ddf_setup_interrupts(ddf_dev_t *device,
     const hw_res_list_parsed_t *hw_res,
     interrupt_handler_t handler,
-    int (*gen_irq_code)(irq_code_t *, const hw_res_list_parsed_t *hw_res))
+    int (*gen_irq_code)(irq_code_t *, const hw_res_list_parsed_t *hw_res),
+    cap_handle_t *handle)
 {
 
@@ -765 +767 @@
 
         /* Register handler to avoid interrupt lockup */
-        const int irq_cap = register_interrupt_handler(device, irq, handler,
-            &irq_code);
+        int ret = register_interrupt_handler(device, irq, handler,
+            &irq_code, handle);
         irq_code_clean(&irq_code);
-        if (irq_cap < 0) {
-                usb_log_error("Failed to register interrupt handler: %s.\n",
-                    str_error(irq_cap));
-                return irq_cap;
-        }
-
-        /* Enable interrupts */
-        int ret = hcd_ddf_enable_interrupt(device, irq);
         if (ret != EOK) {
                 usb_log_error("Failed to register interrupt handler: %s.\n",
                     str_error(ret));
-                unregister_interrupt_handler(device, irq_cap);
-                return ret;
-        }
-        return irq_cap;
+                return ret;
+        }
+
+        /* Enable interrupts */
+        ret = hcd_ddf_enable_interrupt(device, irq);
+        if (ret != EOK) {
+                usb_log_error("Failed to register interrupt handler: %s.\n",
+                    str_error(ret));
+                unregister_interrupt_handler(device, *handle);
+        }
+        return ret;
 }
 
@@ -876 +877 @@
         interrupt_handler_t *irq_handler =
             driver->irq_handler ? driver->irq_handler : ddf_hcd_gen_irq_handler;
-        const int irq_cap = hcd_ddf_setup_interrupts(device, &hw_res,
-            irq_handler, driver->irq_code_gen);
-        bool irqs_enabled = !(irq_cap < 0);
+        int irq_cap;
+        ret = hcd_ddf_setup_interrupts(device, &hw_res,
+            irq_handler, driver->irq_code_gen, &irq_cap);
+        bool irqs_enabled = (ret == EOK);
         if (irqs_enabled) {
                 usb_log_debug("Hw interrupts enabled.\n");
         }
 
-        if (driver->claim)
+        if (driver->claim) {
                 ret = driver->claim(device);
-        if (ret != EOK) {
-                usb_log_error("Failed to claim `%s' for driver `%s'",
-                    ddf_dev_get_name(device), driver->name);
-                return ret;
+                if (ret != EOK) {
+                        usb_log_error("Failed to claim `%s' for driver `%s'",
+                            ddf_dev_get_name(device), driver->name);
+                        return ret;
+                }
         }