Changes in uspace/lib/usbhost/src/ddf_helpers.c [68e5406:cccd60c3] in mainline

File:

• uspace/lib/usbhost/src/ddf_helpers.c (modified) (8 diffs)

uspace/lib/usbhost/src/ddf_helpers.c

@@ -481 +481 @@
         }};
 
-        usb_address_t address;
-        ret = hcd_request_address(hcd, speed, &address);
-        if (ret != EOK) {
+        const usb_address_t address = hcd_request_address(hcd, speed);
+        if (address < 0) {
                 usb_log_error("Failed to reserve new address: %s.",
-                    str_error(ret));
-                return ret;
+                    str_error(address));
+                return address;
         }
 
@@ -519 +518 @@
         usb_log_debug("Device(%d): Requesting first 8B of device descriptor.",
             address);
-        size_t got;
-        ret = hcd_send_batch_sync(hcd, default_target, USB_DIRECTION_IN,
+        ssize_t got = hcd_send_batch_sync(hcd, default_target, USB_DIRECTION_IN,
             &desc, CTRL_PIPE_MIN_PACKET_SIZE, *(uint64_t *)&get_device_desc_8,
-            "read first 8 bytes of dev descriptor", &got);
-
-        if (ret == EOK && got != CTRL_PIPE_MIN_PACKET_SIZE) {
-                ret = EOVERFLOW;
-        }
-
-        if (ret != EOK) {
+            "read first 8 bytes of dev descriptor");
+
+        if (got != CTRL_PIPE_MIN_PACKET_SIZE) {
+                ret = got < 0 ? got : EOVERFLOW;
                 usb_log_error("Device(%d): Failed to get 8B of dev descr: %s.",
                     address, str_error(ret));
@@ -557 +552 @@
 
         usb_log_debug("Device(%d): Setting USB address.", address);
-        ret = hcd_send_batch_sync(hcd, default_target, USB_DIRECTION_OUT,
-            NULL, 0, *(uint64_t *)&set_address, "set address", &got);
+        got = hcd_send_batch_sync(hcd, default_target, USB_DIRECTION_OUT,
+            NULL, 0, *(uint64_t *)&set_address, "set address");
 
         usb_log_debug("Device(%d): Removing default (0:0) EP.", address);
         hcd_remove_ep(hcd, default_target, USB_DIRECTION_BOTH);
 
-        if (ret != EOK) {
+        if (got != 0) {
                 usb_log_error("Device(%d): Failed to set new address: %s.",
-                    address, str_error(ret));
+                    address, str_error(got));
                 hcd_remove_ep(hcd, target, USB_DIRECTION_BOTH);
                 hcd_release_address(hcd, address);
-                return ret;
+                return got;
         }
 
@@ -577 +572 @@
         usb_log_debug("Device(%d): Requesting full device descriptor.",
             address);
-        ret = hcd_send_batch_sync(hcd, target, USB_DIRECTION_IN,
+        got = hcd_send_batch_sync(hcd, target, USB_DIRECTION_IN,
             &desc, sizeof(desc), *(uint64_t *)&get_device_desc,
-            "read device descriptor", &got);
+            "read device descriptor");
         if (ret != EOK) {
                 usb_log_error("Device(%d): Failed to set get dev descriptor: %s",
@@ -747 +742 @@
  * @param[in] gen_irq_code IRQ code generator.
  *
- * @param[out] handle  IRQ capability handle on success.
- *
- * @return Error code.
+ * @return IRQ capability handle on success.
+ * @return Negative 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 *, int *),
-    cap_handle_t *handle)
+    int (*gen_irq_code)(irq_code_t *, const hw_res_list_parsed_t *hw_res))
 {
 
@@ -764 +757 @@
         irq_code_t irq_code = {0};
 
-        int irq;
-        int ret = gen_irq_code(&irq_code, hw_res, &irq);
-        if (ret != EOK) {
+        const int irq = gen_irq_code(&irq_code, hw_res);
+        if (irq < 0) {
                 usb_log_error("Failed to generate IRQ code: %s.\n",
-                    str_error(ret));
-                return ret;
+                    str_error(irq));
+                return irq;
         }
 
         /* Register handler to avoid interrupt lockup */
-        ret = register_interrupt_handler(device, irq, handler,
-            &irq_code, handle);
+        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_interrupt(device, irq);
         if (ret != EOK) {
                 usb_log_error("Failed to register interrupt handler: %s.\n",
                     str_error(ret));
-                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;
+                unregister_interrupt_handler(device, irq_cap);
+                return ret;
+        }
+        return irq_cap;
 }
 
@@ -795 +788 @@
  *
  * @param[in] dev DDF instance of the device to use.
+ * @param[in] iid (Unused).
  * @param[in] call Pointer to the call from kernel.
  */
-void ddf_hcd_gen_irq_handler(ipc_call_t *call, ddf_dev_t *dev)
+void ddf_hcd_gen_irq_handler(ipc_callid_t iid, ipc_call_t *call, ddf_dev_t *dev)
 {
         assert(dev);
@@ -883 +877 @@
         interrupt_handler_t *irq_handler =
             driver->irq_handler ? driver->irq_handler : ddf_hcd_gen_irq_handler;
-        int irq_cap;
-        ret = hcd_ddf_setup_interrupts(device, &hw_res,
-            irq_handler, driver->irq_code_gen, &irq_cap);
-        bool irqs_enabled = (ret == EOK);
+        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");
         }
 
-        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;
         }