Changes in / [374552ef:b6c7da6] in mainline

Location:

uspace

Files:

• drv/uhci-hcd/iface.c (modified) (2 diffs)
• drv/uhci-rhd/root_hub.c (modified) (1 diff)
• drv/usbhub/usbhub.c (modified) (1 diff)
• drv/vhc/connhost.c (modified) (4 diffs)
• lib/drv/generic/remote_usbhc.c (modified) (14 diffs)
• lib/drv/include/usbhc_iface.h (modified) (5 diffs)
• lib/usb/src/pipes.c (modified) (3 diffs)
• lib/usb/src/pipesio.c (modified) (4 diffs)
• lib/usb/src/usbdrv.c (modified) (21 diffs)

uspace/drv/uhci-hcd/iface.c ¶

@@ -164 +164 @@
         return EOK;
 }
-
-
+/*----------------------------------------------------------------------------*/
+static int control_write_setup(device_t *dev, usb_target_t target,
+    size_t max_packet_size,
+    void *data, size_t size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        dev_speed_t speed = FULL_SPEED;
+
+        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
+        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
+            max_packet_size, speed, NULL, 0, data, size, NULL, callback, arg);
+        if (!batch)
+                return ENOMEM;
+        batch_control_setup_old(batch);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+static int control_write_data(device_t *dev, usb_target_t target,
+    size_t max_packet_size,
+    void *data, size_t size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        dev_speed_t speed = FULL_SPEED;
+
+        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
+        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
+            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg);
+        if (!batch)
+                return ENOMEM;
+        batch_control_write_data_old(batch);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+static int control_write_status(device_t *dev, usb_target_t target,
+    usbhc_iface_transfer_in_callback_t callback, void *arg)
+{
+        size_t max_packet_size = 8;
+        dev_speed_t speed = FULL_SPEED;
+
+        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
+        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
+            max_packet_size, speed, NULL, 0, NULL, 0, callback, NULL, arg);
+        if (!batch)
+                return ENOMEM;
+        batch_control_write_status_old(batch);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+static int control_read_setup(device_t *dev, usb_target_t target,
+    size_t max_packet_size,
+    void *data, size_t size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        dev_speed_t speed = FULL_SPEED;
+
+        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
+        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
+            max_packet_size, speed, NULL, 0, data, size, NULL, callback, arg);
+        if (!batch)
+                return ENOMEM;
+        batch_control_setup_old(batch);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+static int control_read_data(device_t *dev, usb_target_t target,
+    size_t max_packet_size,
+    void *data, size_t size,
+    usbhc_iface_transfer_in_callback_t callback, void *arg)
+{
+        dev_speed_t speed = FULL_SPEED;
+
+        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
+        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
+            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg);
+        if (!batch)
+                return ENOMEM;
+        batch_control_read_data_old(batch);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+static int control_read_status(device_t *dev, usb_target_t target,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        size_t max_packet_size = 8;
+        dev_speed_t speed = FULL_SPEED;
+
+        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
+        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
+            max_packet_size, speed, NULL, 0, NULL, 0, NULL, callback, arg);
+        if (!batch)
+                return ENOMEM;
+        batch_control_read_status_old(batch);
+        return EOK;
+}
 /*----------------------------------------------------------------------------*/
 usbhc_iface_t uhci_iface = {
@@ -181 +273 @@
         .control_read = control_read,
         .control_write = control_write,
+
+        .control_write_setup = control_write_setup,
+        .control_write_data = control_write_data,
+        .control_write_status = control_write_status,
+
+        .control_read_setup = control_read_setup,
+        .control_read_data = control_read_data,
+        .control_read_status = control_read_status
 };
 /**

uspace/drv/uhci-rhd/root_hub.c ¶

@@ -47 +47 @@
         assert(rh);
         int ret;
-        ret = usb_hc_find(rh->handle, &instance->hc_handle);
+        ret = usb_drv_find_hc(rh, &instance->hc_handle);
         usb_log_info("rh found(%d) hc handle: %d.\n", ret, instance->hc_handle);
         if (ret != EOK) {

uspace/drv/usbhub/usbhub.c ¶

@@ -50 +50 @@
 #include "usb/usb.h"
 
-static int iface_get_hc_handle(device_t *device, devman_handle_t *handle)
-{
-        return usb_hc_find(device->handle, handle);
-}
-
 static usb_iface_t hub_usb_iface = {
-        .get_hc_handle = iface_get_hc_handle
+        .get_hc_handle = usb_drv_find_hc
 };
 

uspace/drv/vhc/connhost.c ¶

@@ -234 +234 @@
 }
 
+static int enqueue_transfer_setup(device_t *dev,
+    usb_target_t target, usb_transfer_type_t transfer_type,
+    void *buffer, size_t size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        usb_log_debug2("Transfer SETUP [%d.%d (%s); %zu].\n",
+            target.address, target.endpoint,
+            usb_str_transfer_type(transfer_type),
+            size);
+
+        transfer_info_t *transfer
+            = create_transfer_info(dev, USB_DIRECTION_OUT, arg);
+        transfer->out_callback = callback;
+
+        hc_add_transaction_to_device(true, target, transfer_type, buffer, size,
+            universal_callback, transfer);
+
+        return EOK;
+}
+
 static int enqueue_transfer_in(device_t *dev,
     usb_target_t target, usb_transfer_type_t transfer_type,
@@ -275 +295 @@
 }
 
+static int control_write_setup(device_t *dev, usb_target_t target,
+    size_t max_packet_size,
+    void *data, size_t size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        return enqueue_transfer_setup(dev, target, USB_TRANSFER_CONTROL,
+            data, size,
+            callback, arg);
+}
+
+static int control_write_data(device_t *dev, usb_target_t target,
+    size_t max_packet_size,
+    void *data, size_t size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        return enqueue_transfer_out(dev, target, USB_TRANSFER_CONTROL,
+            data, size,
+            callback, arg);
+}
+
+static int control_write_status(device_t *dev, usb_target_t target,
+    usbhc_iface_transfer_in_callback_t callback, void *arg)
+{
+        return enqueue_transfer_in(dev, target, USB_TRANSFER_CONTROL,
+            NULL, 0,
+            callback, arg);
+}
+
 static int control_write(device_t *dev, usb_target_t target,
     size_t max_packet_size,
@@ -291 +339 @@
 
         return EOK;
+}
+
+static int control_read_setup(device_t *dev, usb_target_t target,
+    size_t max_packet_size,
+    void *data, size_t size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        return enqueue_transfer_setup(dev, target, USB_TRANSFER_CONTROL,
+            data, size,
+            callback, arg);
+}
+
+static int control_read_data(device_t *dev, usb_target_t target,
+    size_t max_packet_size,
+    void *data, size_t size,
+    usbhc_iface_transfer_in_callback_t callback, void *arg)
+{
+        return enqueue_transfer_in(dev, target, USB_TRANSFER_CONTROL,
+            data, size,
+            callback, arg);
+}
+
+static int control_read_status(device_t *dev, usb_target_t target,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        return enqueue_transfer_out(dev, target, USB_TRANSFER_CONTROL,
+            NULL, 0,
+            callback, arg);
 }
 
@@ -379 +455 @@
         .interrupt_in = interrupt_in,
 
+        .control_write_setup = control_write_setup,
+        .control_write_data = control_write_data,
+        .control_write_status = control_write_status,
+
         .control_write = control_write,
+
+        .control_read_setup = control_read_setup,
+        .control_read_data = control_read_data,
+        .control_read_status = control_read_status,
+
         .control_read = control_read
 };

uspace/lib/drv/generic/remote_usbhc.c ¶

@@ -46 +46 @@
 static void remote_usbhc_interrupt_out(device_t *, void *, ipc_callid_t, ipc_call_t *);
 static void remote_usbhc_interrupt_in(device_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhc_control_write_setup(device_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhc_control_write_data(device_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhc_control_write_status(device_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhc_control_read_setup(device_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhc_control_read_data(device_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhc_control_read_status(device_t *, void *, ipc_callid_t, ipc_call_t *);
 static void remote_usbhc_control_write(device_t *, void *, ipc_callid_t, ipc_call_t *);
 static void remote_usbhc_control_read(device_t *, void *, ipc_callid_t, ipc_call_t *);
@@ -69 +75 @@
         remote_usbhc_interrupt_in,
 
+        remote_usbhc_control_write_setup,
+        remote_usbhc_control_write_data,
+        remote_usbhc_control_write_status,
+
+        remote_usbhc_control_read_setup,
+        remote_usbhc_control_read_data,
+        remote_usbhc_control_read_status,
+
         remote_usbhc_control_write,
         remote_usbhc_control_read
@@ -283 +297 @@
         }
 
-        size_t max_packet_size = DEV_IPC_GET_ARG3(*call);
+        size_t expected_len = DEV_IPC_GET_ARG3(*call);
         usb_target_t target = {
                 .address = DEV_IPC_GET_ARG1(*call),
@@ -291 +305 @@
         size_t len = 0;
         void *buffer = NULL;
-
-        int rc = async_data_write_accept(&buffer, false,
-            1, USB_MAX_PAYLOAD_SIZE,
-            0, &len);
-
-        if (rc != EOK) {
-                async_answer_0(callid, rc);
-                return;
+        if (expected_len > 0) {
+                int rc = async_data_write_accept(&buffer, false,
+                    1, USB_MAX_PAYLOAD_SIZE,
+                    0, &len);
+
+                if (rc != EOK) {
+                        async_answer_0(callid, rc);
+                        return;
+                }
         }
 
@@ -313 +328 @@
         trans->size = len;
 
-        rc = transfer_func(device, target, max_packet_size,
+        int rc = transfer_func(device, target, HACK_MAX_PACKET_SIZE,
             buffer, len,
             callback_out, trans);
@@ -339 +354 @@
         }
 
-        size_t max_packet_size = DEV_IPC_GET_ARG3(*call);
+        size_t len = DEV_IPC_GET_ARG3(*call);
         usb_target_t target = {
                 .address = DEV_IPC_GET_ARG1(*call),
@@ -345 +360 @@
         };
 
-        size_t len;
         ipc_callid_t data_callid;
         if (!async_data_read_receive(&data_callid, &len)) {
@@ -361 +375 @@
         trans->size = len;
 
-        int rc = transfer_func(device, target, max_packet_size,
+        int rc = transfer_func(device, target, HACK_MAX_PACKET_SIZE_INTERRUPT_IN,
             trans->buffer, len,
             callback_in, trans);
@@ -371 +385 @@
 }
 
+/** Process status part of control transfer.
+ *
+ * @param device Target device.
+ * @param callid Initiating caller.
+ * @param call Initiating call.
+ * @param direction Transfer direction (read ~ in, write ~ out).
+ * @param transfer_in_func Transfer function for control read (might be NULL).
+ * @param transfer_out_func Transfer function for control write (might be NULL).
+ */
+static void remote_usbhc_status_transfer(device_t *device,
+    ipc_callid_t callid, ipc_call_t *call,
+    usb_direction_t direction,
+    int (*transfer_in_func)(device_t *, usb_target_t,
+        usbhc_iface_transfer_in_callback_t, void *),
+    int (*transfer_out_func)(device_t *, usb_target_t,
+        usbhc_iface_transfer_out_callback_t, void *))
+{
+        switch (direction) {
+                case USB_DIRECTION_IN:
+                        if (!transfer_in_func) {
+                                async_answer_0(callid, ENOTSUP);
+                                return;
+                        }
+                        break;
+                case USB_DIRECTION_OUT:
+                        if (!transfer_out_func) {
+                                async_answer_0(callid, ENOTSUP);
+                                return;
+                        }
+                        break;
+                default:
+                        assert(false && "unreachable code");
+                        break;
+        }
+
+        usb_target_t target = {
+                .address = DEV_IPC_GET_ARG1(*call),
+                .endpoint = DEV_IPC_GET_ARG2(*call)
+        };
+
+        async_transaction_t *trans = async_transaction_create(callid);
+        if (trans == NULL) {
+                async_answer_0(callid, ENOMEM);
+                return;
+        }
+
+        int rc;
+        switch (direction) {
+                case USB_DIRECTION_IN:
+                        rc = transfer_in_func(device, target,
+                            callback_in, trans);
+                        break;
+                case USB_DIRECTION_OUT:
+                        rc = transfer_out_func(device, target,
+                            callback_out, trans);
+                        break;
+                default:
+                        assert(false && "unreachable code");
+                        break;
+        }
+
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                async_transaction_destroy(trans);
+        }
+}
+
+
 void remote_usbhc_interrupt_out(device_t *device, void *iface,
     ipc_callid_t callid, ipc_call_t *call)
@@ -389 +471 @@
         return remote_usbhc_in_transfer(device, callid, call,
             usb_iface->interrupt_in);
+}
+
+void remote_usbhc_control_write_setup(device_t *device, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
+        assert(usb_iface != NULL);
+
+        return remote_usbhc_out_transfer(device, callid, call,
+            usb_iface->control_write_setup);
+}
+
+void remote_usbhc_control_write_data(device_t *device, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
+        assert(usb_iface != NULL);
+
+        return remote_usbhc_out_transfer(device, callid, call,
+            usb_iface->control_write_data);
+}
+
+void remote_usbhc_control_write_status(device_t *device, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
+        assert(usb_iface != NULL);
+
+        return remote_usbhc_status_transfer(device, callid, call,
+            USB_DIRECTION_IN, usb_iface->control_write_status, NULL);
+}
+
+void remote_usbhc_control_read_setup(device_t *device, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
+        assert(usb_iface != NULL);
+
+        return remote_usbhc_out_transfer(device, callid, call,
+            usb_iface->control_read_setup);
+}
+
+void remote_usbhc_control_read_data(device_t *device, void *iface,
+            ipc_callid_t callid, ipc_call_t *call)
+{
+        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
+        assert(usb_iface != NULL);
+
+        return remote_usbhc_in_transfer(device, callid, call,
+            usb_iface->control_read_data);
+}
+
+void remote_usbhc_control_read_status(device_t *device, void *iface,
+            ipc_callid_t callid, ipc_call_t *call)
+{
+        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
+        assert(usb_iface != NULL);
+
+        return remote_usbhc_status_transfer(device, callid, call,
+            USB_DIRECTION_OUT, NULL, usb_iface->control_read_status);
 }
 
@@ -407 +549 @@
         };
         size_t data_buffer_len = DEV_IPC_GET_ARG3(*call);
-        size_t max_packet_size = DEV_IPC_GET_ARG4(*call);
 
         int rc;
@@ -443 +584 @@
         trans->size = data_buffer_len;
 
-        rc = usb_iface->control_write(device, target, max_packet_size,
+        rc = usb_iface->control_write(device, target, HACK_MAX_PACKET_SIZE,
             setup_packet, setup_packet_len,
             data_buffer, data_buffer_len,
@@ -470 +611 @@
                 .endpoint = DEV_IPC_GET_ARG2(*call)
         };
-        size_t max_packet_size = DEV_IPC_GET_ARG3(*call);
 
         int rc;
@@ -508 +648 @@
         }
 
-        rc = usb_iface->control_read(device, target, max_packet_size,
+        rc = usb_iface->control_read(device, target, HACK_MAX_PACKET_SIZE,
             setup_packet, setup_packet_len,
             trans->buffer, trans->size,

uspace/lib/drv/include/usbhc_iface.h ¶

@@ -53 +53 @@
  *   - argument #1 is target address
  *   - argument #2 is target endpoint
- *   - argument #3 is max packet size of the endpoint
+ *   - argument #3 is buffer size
  * - this call is immediately followed by IPC data write (from caller)
  * - the initial call (and the whole transaction) is answer after the
@@ -66 +66 @@
  *   - argument #1 is target address
  *   - argument #2 is target endpoint
- *   - argument #3 is max packet size of the endpoint
+ *   - argument #3 is buffer size
  * - this call is immediately followed by IPC data read (async version)
  * - the call is not answered until the device returns some data (or until
@@ -153 +153 @@
         IPC_M_USBHC_INTERRUPT_IN,
 
+
+        /** Start WRITE control transfer.
+         * See explanation at usb_iface_funcs_t (OUT transaction).
+         */
+        IPC_M_USBHC_CONTROL_WRITE_SETUP,
+
+        /** Send control-transfer data to device.
+         * See explanation at usb_iface_funcs_t (OUT transaction).
+         */
+        IPC_M_USBHC_CONTROL_WRITE_DATA,
+
+        /** Terminate WRITE control transfer.
+         * See explanation at usb_iface_funcs_t (NO-DATA transaction).
+         */
+        IPC_M_USBHC_CONTROL_WRITE_STATUS,
+
+
+
+        /** Start READ control transfer.
+         * See explanation at usb_iface_funcs_t (OUT transaction).
+         */
+        IPC_M_USBHC_CONTROL_READ_SETUP,
+
+        /** Get control-transfer data from device.
+         * See explanation at usb_iface_funcs_t (IN transaction).
+         */
+        IPC_M_USBHC_CONTROL_READ_DATA,
+
+        /** Terminate READ control transfer.
+         * See explanation at usb_iface_funcs_t (NO-DATA transaction).
+         */
+        IPC_M_USBHC_CONTROL_READ_STATUS,
+
         /** Issue control WRITE transfer.
          * See explanation at usb_iface_funcs_t (OUT transaction) for
@@ -161 +194 @@
         IPC_M_USBHC_CONTROL_WRITE,
 
-        /** Issue control READ transfer.
+        /** Issue control WRITE transfer.
          * See explanation at usb_iface_funcs_t (IN transaction) for
          * call parameters.
-         * This call is immediately followed by IPC data write from the caller
-         * (setup packet) and IPC data read (buffer that was read).
+         * This call is immediately followed by IPC data read from the caller
+         * (setup packet).
+         * Actual data are retrieved through IPC_M_USBHC_GET_BUFFER.
          */
         IPC_M_USBHC_CONTROL_READ,
@@ -207 +241 @@
         usbhc_iface_transfer_in_t interrupt_in;
 
+        usbhc_iface_transfer_setup_t control_write_setup;
+        usbhc_iface_transfer_out_t control_write_data;
+        int (*control_write_status)(device_t *, usb_target_t,
+            usbhc_iface_transfer_in_callback_t, void *);
+
+        usbhc_iface_transfer_setup_t control_read_setup;
+        usbhc_iface_transfer_in_t control_read_data;
+        int (*control_read_status)(device_t *, usb_target_t,
+            usbhc_iface_transfer_out_callback_t, void *);
+
         int (*control_write)(device_t *, usb_target_t,
             size_t,

uspace/lib/usb/src/pipes.c ¶

@@ -35 +35 @@
 #include <usb/usb.h>
 #include <usb/pipes.h>
-#include <usbhc_iface.h>
 #include <errno.h>
 #include <assert.h>
-
-/** Tell USB address assigned to given device.
- *
- * @param phone Phone to my HC.
- * @param dev Device in question.
- * @return USB address or error code.
- */
-static usb_address_t get_my_address(int phone, device_t *dev)
-{
-        sysarg_t address;
-        int rc = async_req_2_1(phone, DEV_IFACE_ID(USBHC_DEV_IFACE),
-            IPC_M_USBHC_GET_ADDRESS,
-            dev->handle, &address);
-
-        if (rc != EOK) {
-                return rc;
-        }
-
-        return (usb_address_t) address;
-}
+#include <usb/usbdrv.h>
 
 /** Initialize connection to USB device.
@@ -75 +55 @@
         usb_address_t my_address;
 
-        rc = usb_hc_find(device->handle, &hc_handle);
+        rc = usb_drv_find_hc(device, &hc_handle);
         if (rc != EOK) {
                 return rc;
@@ -85 +65 @@
         }
 
-        my_address = get_my_address(hc_phone, device);
+        my_address = usb_drv_get_my_address(hc_phone, device);
         if (my_address < 0) {
                 rc = my_address;

uspace/lib/usb/src/pipesio.c ¶

@@ -78 +78 @@
          * Make call identifying target USB device and type of transfer.
          */
-        aid_t opening_request = async_send_4(pipe->hc_phone,
+        aid_t opening_request = async_send_3(pipe->hc_phone,
             DEV_IFACE_ID(USBHC_DEV_IFACE), ipc_method,
             pipe->wire->address, pipe->endpoint_no,
-            pipe->max_packet_size,
             NULL);
         if (opening_request == 0) {
@@ -202 +201 @@
          * Make call identifying target USB device and type of transfer.
          */
-        aid_t opening_request = async_send_4(pipe->hc_phone,
+        aid_t opening_request = async_send_3(pipe->hc_phone,
             DEV_IFACE_ID(USBHC_DEV_IFACE), ipc_method,
             pipe->wire->address, pipe->endpoint_no,
-            pipe->max_packet_size,
             NULL);
         if (opening_request == 0) {
@@ -285 +283 @@
          * Make call identifying target USB device and control transfer type.
          */
-        aid_t opening_request = async_send_4(pipe->hc_phone,
+        aid_t opening_request = async_send_3(pipe->hc_phone,
             DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USBHC_CONTROL_READ,
             pipe->wire->address, pipe->endpoint_no,
-            pipe->max_packet_size,
             NULL);
         if (opening_request == 0) {
@@ -405 +402 @@
          * Make call identifying target USB device and control transfer type.
          */
-        aid_t opening_request = async_send_5(pipe->hc_phone,
+        aid_t opening_request = async_send_4(pipe->hc_phone,
             DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USBHC_CONTROL_WRITE,
             pipe->wire->address, pipe->endpoint_no,
             data_buffer_size,
-            pipe->max_packet_size,
             NULL);
         if (opening_request == 0) {

uspace/lib/usb/src/usbdrv.c ¶

@@ -34 +34 @@
  */
 #include <usb/usbdrv.h>
+#include <usbhc_iface.h>
+#include <usb_iface.h>
 #include <errno.h>
-
+#include <str_error.h>
+
+/** Information about pending transaction on HC. */
+typedef struct {
+        /** Phone to host controller driver. */
+        int phone;
+        /** Data buffer. */
+        void *buffer;
+        /** Buffer size. */
+        size_t size;
+        /** Storage for actual number of bytes transferred. */
+        size_t *size_transferred;
+        /** Initial call reply data. */
+        ipc_call_t reply;
+        /** Initial call identifier. */
+        aid_t request;
+        /** Reply data for data read call. */
+        ipc_call_t read_reply;
+        /** Data read call identifier. */
+        aid_t read_request;
+} transfer_info_t;
 
 /** Find handle of host controller the device is physically attached to.
@@ -45 +67 @@
 int usb_drv_find_hc(device_t *dev, devman_handle_t *handle)
 {
-        return ENOTSUP;
+        if (dev == NULL) {
+                return EBADMEM;
+        }
+        if (handle == NULL) {
+                return EBADMEM;
+        }
+
+        int parent_phone = devman_parent_device_connect(dev->handle,
+            IPC_FLAG_BLOCKING);
+        if (parent_phone < 0) {
+                return parent_phone;
+        }
+
+        devman_handle_t h;
+        int rc = async_req_1_1(parent_phone, DEV_IFACE_ID(USB_DEV_IFACE),
+            IPC_M_USB_GET_HOST_CONTROLLER_HANDLE, &h);
+
+        async_hangup(parent_phone);
+
+        if (rc != EOK) {
+                return rc;
+        }
+
+        *handle = h;
+
+        return EOK;
 }
 
@@ -58 +105 @@
     unsigned int flags)
 {
-        return ENOTSUP;
+        return devman_device_connect(hc_handle, flags);
 }
 
@@ -69 +116 @@
 int usb_drv_hc_connect_auto(device_t *dev, unsigned int flags)
 {
-        return ENOTSUP;
+        int rc;
+        devman_handle_t hc_handle;
+
+        /*
+         * Call parent hub to obtain device handle of respective HC.
+         */
+        rc = usb_drv_find_hc(dev, &hc_handle);
+        if (rc != EOK) {
+                return rc;
+        }
+        
+        return usb_drv_hc_connect(dev, hc_handle, flags);
 }
 
@@ -80 +138 @@
 usb_address_t usb_drv_get_my_address(int phone, device_t *dev)
 {
-        return ENOTSUP;
+        sysarg_t address;
+        int rc = async_req_2_1(phone, DEV_IFACE_ID(USBHC_DEV_IFACE),
+            IPC_M_USBHC_GET_ADDRESS,
+            dev->handle, &address);
+
+        if (rc != EOK) {
+                return rc;
+        }
+
+        return (usb_address_t) address;
 }
 
@@ -90 +157 @@
 int usb_drv_reserve_default_address(int phone)
 {
-        return ENOTSUP;
+        return async_req_1_0(phone, DEV_IFACE_ID(USBHC_DEV_IFACE),
+            IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS);
 }
 
@@ -100 +168 @@
 int usb_drv_release_default_address(int phone)
 {
-        return ENOTSUP;
+        return async_req_1_0(phone, DEV_IFACE_ID(USBHC_DEV_IFACE),
+            IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS);
 }
 
@@ -110 +179 @@
 usb_address_t usb_drv_request_address(int phone)
 {
-        return ENOTSUP;
+        sysarg_t address;
+        int rc = async_req_1_1(phone, DEV_IFACE_ID(USBHC_DEV_IFACE),
+            IPC_M_USBHC_REQUEST_ADDRESS, &address);
+        if (rc != EOK) {
+                return rc;
+        } else {
+                return (usb_address_t) address;
+        }
 }
 
@@ -123 +199 @@
     devman_handle_t handle)
 {
-        return ENOTSUP;
+        int rc = async_req_3_0(phone, DEV_IFACE_ID(USBHC_DEV_IFACE),
+            IPC_M_USBHC_BIND_ADDRESS,
+            address, handle);
+
+        return rc;
 }
 
@@ -134 +214 @@
 int usb_drv_release_address(int phone, usb_address_t address)
 {
-        return ENOTSUP;
-}
+        return async_req_2_0(phone, DEV_IFACE_ID(USBHC_DEV_IFACE),
+            IPC_M_USBHC_RELEASE_ADDRESS, address);
+}
+
+/** Send data to HCD.
+ *
+ * @param phone Phone to HC.
+ * @param method Method used for calling.
+ * @param target Targeted device.
+ * @param buffer Data buffer (NULL to skip data transfer phase).
+ * @param size Buffer size (must be zero when @p buffer is NULL).
+ * @param handle Storage for transaction handle (cannot be NULL).
+ * @return Error status.
+ * @retval EINVAL Invalid parameter.
+ * @retval ENOMEM Not enough memory to complete the operation.
+ */
+static int async_send_buffer(int phone, int method,
+    usb_target_t target,
+    void *buffer, size_t size,
+    usb_handle_t *handle)
+{
+        if (phone < 0) {
+                return EINVAL;
+        }
+
+        if ((buffer == NULL) && (size > 0)) {
+                return EINVAL;
+        }
+
+        if (handle == NULL) {
+                return EINVAL;
+        }
+
+        transfer_info_t *transfer
+            = (transfer_info_t *) malloc(sizeof(transfer_info_t));
+        if (transfer == NULL) {
+                return ENOMEM;
+        }
+
+        transfer->read_request = 0;
+        transfer->size_transferred = NULL;
+        transfer->buffer = NULL;
+        transfer->size = 0;
+        transfer->phone = phone;
+
+        int rc;
+
+        transfer->request = async_send_4(phone,
+            DEV_IFACE_ID(USBHC_DEV_IFACE),
+            method,
+            target.address, target.endpoint,
+            size,
+            &transfer->reply);
+
+        if (size > 0) {
+                rc = async_data_write_start(phone, buffer, size);
+                if (rc != EOK) {
+                        async_wait_for(transfer->request, NULL);
+                        return rc;
+                }
+        }
+
+        *handle = (usb_handle_t) transfer;
+
+        return EOK;
+}
+
+/** Prepare data retrieval.
+ *
+ * @param phone Opened phone to HCD.
+ * @param method Method used for calling.
+ * @param target Targeted device.
+ * @param buffer Buffer where to store retrieved data
+ *      (NULL to skip data transfer phase).
+ * @param size Buffer size (must be zero when @p buffer is NULL).
+ * @param actual_size Storage where actual number of bytes transferred will
+ *      be stored.
+ * @param handle Storage for transaction handle (cannot be NULL).
+ * @return Error status.
+ * @retval EINVAL Invalid parameter.
+ * @retval ENOMEM Not enough memory to complete the operation.
+ */
+static int async_recv_buffer(int phone, int method,
+    usb_target_t target,
+    void *buffer, size_t size, size_t *actual_size,
+    usb_handle_t *handle)
+{
+        if (phone < 0) {
+                return EINVAL;
+        }
+
+        if ((buffer == NULL) && (size > 0)) {
+                return EINVAL;
+        }
+
+        if (handle == NULL) {
+                return EINVAL;
+        }
+
+        transfer_info_t *transfer
+            = (transfer_info_t *) malloc(sizeof(transfer_info_t));
+        if (transfer == NULL) {
+                return ENOMEM;
+        }
+
+        transfer->read_request = 0;
+        transfer->size_transferred = actual_size;
+        transfer->buffer = buffer;
+        transfer->size = size;
+        transfer->phone = phone;
+
+        transfer->request = async_send_4(phone,
+            DEV_IFACE_ID(USBHC_DEV_IFACE),
+            method,
+            target.address, target.endpoint,
+            size,
+            &transfer->reply);
+
+        if (buffer != NULL) {
+                transfer->read_request = async_data_read(phone, buffer, size,
+                    &transfer->read_reply);
+        }
+
+        *handle = (usb_handle_t) transfer;
+
+        return EOK;
+}
+
 
 /** Blocks caller until given USB transaction is finished.
@@ -149 +355 @@
 int usb_drv_async_wait_for(usb_handle_t handle)
 {
-        return ENOTSUP;
+        if (handle == 0) {
+                return EBADMEM;
+        }
+
+        int rc = EOK;
+
+        transfer_info_t *transfer = (transfer_info_t *) handle;
+
+        sysarg_t answer_rc;
+
+        /*
+         * If the buffer is not NULL, we must accept some data.
+         */
+        if ((transfer->buffer != NULL) && (transfer->size > 0)) {
+                async_wait_for(transfer->read_request, &answer_rc);
+
+                if (answer_rc != EOK) {
+                        rc = (int) answer_rc;
+                        goto leave;
+                }
+
+                if (transfer->size_transferred != NULL) {
+                        *(transfer->size_transferred)
+                            = IPC_GET_ARG2(transfer->read_reply);
+                }
+        }
+
+        async_wait_for(transfer->request, &answer_rc);
+
+        if (answer_rc != EOK) {
+                rc = (int) answer_rc;
+                goto leave;
+        }
+
+leave:
+        free(transfer);
+
+        return rc;
 }
 
@@ -157 +400 @@
     usb_handle_t *handle)
 {
-        return ENOTSUP;
+        return async_send_buffer(phone,
+            IPC_M_USBHC_INTERRUPT_OUT,
+            target,
+            buffer, size,
+            handle);
 }
 
@@ -165 +412 @@
     usb_handle_t *handle)
 {
-        return ENOTSUP;
+        return async_recv_buffer(phone,
+            IPC_M_USBHC_INTERRUPT_IN,
+            target,
+            buffer, size, actual_size,
+            handle);
 }
 
@@ -173 +424 @@
     usb_handle_t *handle)
 {
-        return ENOTSUP;
+        return async_send_buffer(phone,
+            IPC_M_USBHC_CONTROL_WRITE_SETUP,
+            target,
+            buffer, size,
+            handle);
 }
 
@@ -181 +436 @@
     usb_handle_t *handle)
 {
-        return ENOTSUP;
+        return async_send_buffer(phone,
+            IPC_M_USBHC_CONTROL_WRITE_DATA,
+            target,
+            buffer, size,
+            handle);
 }
 
@@ -188 +447 @@
     usb_handle_t *handle)
 {
-        return ENOTSUP;
+        return async_recv_buffer(phone,
+            IPC_M_USBHC_CONTROL_WRITE_STATUS,
+            target,
+            NULL, 0, NULL,
+            handle);
 }
 
@@ -197 +460 @@
     usb_handle_t *handle)
 {
-        return ENOTSUP;
+        // FIXME - check input parameters instead of asserting them
+        assert(phone > 0);
+        assert(setup_packet != NULL);
+        assert(setup_packet_size > 0);
+        assert(((buffer != NULL) && (buffer_size > 0))
+            || ((buffer == NULL) && (buffer_size == 0)));
+        assert(handle != NULL);
+
+        transfer_info_t *transfer
+            = (transfer_info_t *) malloc(sizeof(transfer_info_t));
+        if (transfer == NULL) {
+                return ENOMEM;
+        }
+
+        transfer->read_request = 0;
+        transfer->size_transferred = NULL;
+        transfer->buffer = NULL;
+        transfer->size = 0;
+        transfer->phone = phone;
+
+        int rc;
+
+        transfer->request = async_send_3(phone,
+            DEV_IFACE_ID(USBHC_DEV_IFACE),
+            IPC_M_USBHC_CONTROL_WRITE,
+            target.address, target.endpoint,
+            &transfer->reply);
+
+        rc = async_data_write_start(phone, setup_packet, setup_packet_size);
+        if (rc != EOK) {
+                async_wait_for(transfer->request, NULL);
+                return rc;
+        }
+
+        if (buffer_size > 0) {
+                rc = async_data_write_start(phone, buffer, buffer_size);
+                if (rc != EOK) {
+                        async_wait_for(transfer->request, NULL);
+                        return rc;
+                }
+        }
+
+        *handle = (usb_handle_t) transfer;
+
+        return EOK;
 }
 
@@ -205 +512 @@
     usb_handle_t *handle)
 {
-        return ENOTSUP;
+        return async_send_buffer(phone,
+            IPC_M_USBHC_CONTROL_READ_SETUP,
+            target,
+            buffer, size,
+            handle);
 }
 
@@ -213 +524 @@
     usb_handle_t *handle)
 {
-        return ENOTSUP;
+        return async_recv_buffer(phone,
+            IPC_M_USBHC_CONTROL_READ_DATA,
+            target,
+            buffer, size, actual_size,
+            handle);
 }
 
@@ -220 +535 @@
     usb_handle_t *handle)
 {
-        return ENOTSUP;
+        return async_send_buffer(phone,
+            IPC_M_USBHC_CONTROL_READ_STATUS,
+            target,
+            NULL, 0,
+            handle);
 }
 
@@ -229 +548 @@
     usb_handle_t *handle)
 {
-        return ENOTSUP;
+        // FIXME - check input parameters instead of asserting them
+        assert(phone > 0);
+        assert(setup_packet != NULL);
+        assert(setup_packet_size > 0);
+        assert(buffer != NULL);
+        assert(buffer_size > 0);
+        assert(handle != NULL);
+
+        transfer_info_t *transfer
+            = (transfer_info_t *) malloc(sizeof(transfer_info_t));
+        if (transfer == NULL) {
+                return ENOMEM;
+        }
+
+        transfer->size_transferred = actual_size;
+        transfer->buffer = buffer;
+        transfer->size = buffer_size;
+        transfer->phone = phone;
+
+        int rc;
+
+        transfer->request = async_send_4(phone,
+            DEV_IFACE_ID(USBHC_DEV_IFACE),
+            IPC_M_USBHC_CONTROL_READ,
+            target.address, target.endpoint,
+            buffer_size,
+            &transfer->reply);
+
+        rc = async_data_write_start(phone, setup_packet, setup_packet_size);
+        if (rc != EOK) {
+                async_wait_for(transfer->request, NULL);
+                return rc;
+        }
+
+        transfer->read_request = async_data_read(phone, buffer, buffer_size,
+            &transfer->read_reply);
+
+        *handle = (usb_handle_t) transfer;
+
+        return EOK;
 }