Changeset e9d15d9 in mainline for uspace/lib

Timestamp:

2017-08-18T21:15:26Z (8 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

24abb85d

Parents:

1c85bae

Message:

Turn IRQ structures into kernel objects

ipc_irq_subscribe() now returns a capability for the underlying IRQ kernel
object. ipc_irq_unsubscribe() can now be done only with a valid IRQ capability.

Location:

uspace/lib

Files:

• c/generic/async.c (modified) (2 diffs)
• c/generic/irq.c (modified) (2 diffs)
• c/include/async.h (modified) (1 diff)
• c/include/ipc/irq.h (modified) (1 diff)
• drv/generic/interrupt.c (modified) (1 diff)
• usbhost/src/ddf_helpers.c (modified) (7 diffs)

uspace/lib/c/generic/async.c

@@ -1027 +1027 @@
  * @param ucode   Top-half pseudocode handler.
  *
- * @return Zero on success or a negative error code.
+ * @return IRQ capability on success.
+ * @return Negative error code.
  *
  */
@@ -1056 +1057 @@
 /** Unsubscribe from IRQ notification.
  *
- * @param inr     IRQ number.
- * @param devno   Device number of the device generating inr.
+ * @param cap     IRQ capability. 
  *
  * @return Zero on success or a negative error code.
  *
  */
-int async_irq_unsubscribe(int inr, int devno)
+int async_irq_unsubscribe(int cap)
 {
         // TODO: Remove entry from hash table
         //       to avoid memory leak
         
-        return ipc_irq_unsubscribe(inr, devno);
+        return ipc_irq_unsubscribe(cap);
 }
 

uspace/lib/c/generic/irq.c

@@ -59 +59 @@
  * @param ucode  Top-half pseudocode handler.
  *
- * @return Value returned by the kernel.
+ * @return IRQ capability returned by the kernel.
+ * @return Error code returned by the kernel.
  *
  */
@@ -74 +75 @@
 /** Unsubscribe from IRQ notification.
  *
- * @param inr   IRQ number.
- * @param devno Device number of the device generating inr.
+ * @param cap   IRQ capability.
  *
  * @return Value returned by the kernel.
  *
  */
-int ipc_irq_unsubscribe(int inr, int devno)
+int ipc_irq_unsubscribe(int cap)
 {
-        return __SYSCALL2(SYS_IPC_IRQ_UNSUBSCRIBE, inr, devno);
+        return __SYSCALL1(SYS_IPC_IRQ_UNSUBSCRIBE, cap);
 }
 

uspace/lib/c/include/async.h

@@ -168 +168 @@
 extern int async_irq_subscribe(int, int, async_notification_handler_t, void *,
     const irq_code_t *);
-extern int async_irq_unsubscribe(int, int);
+extern int async_irq_unsubscribe(int);
 
 extern int async_event_subscribe(event_type_t, async_notification_handler_t,

uspace/lib/c/include/ipc/irq.h

@@ -40 +40 @@
 
 extern int ipc_irq_subscribe(int, int, sysarg_t, const irq_code_t *);
-extern int ipc_irq_unsubscribe(int, int);
+extern int ipc_irq_unsubscribe(int);
 
 #endif

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 *pseudocode)
+    interrupt_handler_t *handler, const irq_code_t *irq_code)
 {
         return async_irq_subscribe(irq, dev->handle,
-            (async_notification_handler_t) handler, dev, pseudocode);
+            (async_notification_handler_t) handler, dev, irq_code);
 }
 
-int unregister_interrupt_handler(ddf_dev_t *dev, int irq)
+int unregister_interrupt_handler(ddf_dev_t *dev, int cap)
 {
-        return async_irq_unsubscribe(irq, dev->handle);
+        return async_irq_unsubscribe(cap);
 }
 

uspace/lib/usbhost/src/ddf_helpers.c

@@ -748 +748 @@
  * @param[in] gen_irq_code IRQ code generator.
  *
- * @return EOK on success or negative error code
+ * @return IRQ kernel object capability on success.
+ * @return Negative error code.
  */
 int hcd_ddf_setup_interrupts(ddf_dev_t *device,
@@ -770 +771 @@
 
         /* Register handler to avoid interrupt lockup */
-        int ret = register_interrupt_handler(device, irq, handler, &irq_code);
+        const int irq_cap = register_interrupt_handler(device, irq, handler,
+            &irq_code);
         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_interrupts(device);
         if (ret != EOK) {
                 usb_log_error("Failed to register interrupt handler: %s.\n",
                     str_error(ret));
-                return ret;
-        }
-
-        /* Enable interrupts */
-        ret = hcd_ddf_enable_interrupts(device);
-        if (ret != EOK) {
-                usb_log_error("Failed to register interrupt handler: %s.\n",
-                    str_error(ret));
-                unregister_interrupt_handler(device, irq);
-                return ret;
-        }
-        assert(irq > 0);
-        return irq;
+                unregister_interrupt_handler(device, irq_cap);
+                return ret;
+        }
+        return irq_cap;
 }
 
@@ -882 +883 @@
         interrupt_handler_t *irq_handler =
             driver->irq_handler ? driver->irq_handler : ddf_hcd_gen_irq_handler;
-        const int irq = hcd_ddf_setup_interrupts(device, &hw_res, irq_handler,
-            driver->irq_code_gen);
-        if (!(irq < 0)) {
+        const int irq_cap = hcd_ddf_setup_interrupts(device, &hw_res,
+            irq_handler, driver->irq_code_gen);
+        bool irqs_enabled = !(irq_cap < 0);
+        if (irqs_enabled) {
                 usb_log_debug("Hw interrupts enabled.\n");
         }
@@ -899 +901 @@
         /* Init hw driver */
         hcd_t *hcd = dev_to_hcd(device);
-        ret = driver->init(hcd, &hw_res, !(irq < 0));
+        ret = driver->init(hcd, &hw_res, irqs_enabled);
         hw_res_list_parsed_clean(&hw_res);
         if (ret != EOK) {
@@ -907 +909 @@
 
         /* Need working irq replacement to setup root hub */
-        if ((irq < 0) && hcd->ops.status_hook) {
+        if (!irqs_enabled && hcd->ops.status_hook) {
                 hcd->polling_fibril = fibril_create(interrupt_polling, hcd);
                 if (hcd->polling_fibril == 0) {
@@ -916 +918 @@
                 fibril_add_ready(hcd->polling_fibril);
                 usb_log_warning("Failed to enable interrupts: %s."
-                    " Falling back to polling.\n", str_error(irq));
+                    " Falling back to polling.\n", str_error(irq_cap));
         }
 
@@ -930 +932 @@
 irq_unregister:
                 /* Unregistering non-existent should be ok */
-                unregister_interrupt_handler(device, irq);
+                unregister_interrupt_handler(device, irq_cap);
                 hcd_ddf_clean_hc(device);
                 return ret;