Changeset 70c85211 in mainline for uspace/lib/drv/generic/remote_usbhc.c

Timestamp:

2010-12-03T13:03:26Z (13 years ago)

Author:

Lubos Slovak <lubos.slovak@…>

Branches:

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

Children:

101ef25c

Parents:

bbc28be (diff), 4570779 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merged branch development into lelian/hidd

File:

• uspace/lib/drv/generic/remote_usbhc.c (modified) (7 diffs)

uspace/lib/drv/generic/remote_usbhc.c

@@ -42 +42 @@
 #define USB_MAX_PAYLOAD_SIZE 1020
 
+static void remote_usbhc_get_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
 static void remote_usbhc_get_buffer(device_t *, void *, ipc_callid_t, ipc_call_t *);
 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_usb(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(device_t *, void *, ipc_callid_t, ipc_call_t *);
 
 /** Remote USB interface operations. */
 static remote_iface_func_ptr_t remote_usbhc_iface_ops [] = {
-        &remote_usbhc_get_buffer,
-        &remote_usbhc_interrupt_out,
-        &remote_usbhc_interrupt_in
+        remote_usbhc_get_address,
+        remote_usbhc_get_buffer,
+        remote_usbhc_interrupt_out,
+        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
 };
 
@@ -68 +82 @@
 } async_transaction_t;
 
+void remote_usbhc_get_address(device_t *device, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
+
+        if (!usb_iface->tell_address) {
+                ipc_answer_0(callid, ENOTSUP);
+                return;
+        }
+
+        devman_handle_t handle = IPC_GET_ARG1(*call);
+
+        usb_address_t address;
+        int rc = usb_iface->tell_address(device, handle, &address);
+        if (rc != EOK) {
+                ipc_answer_0(callid, rc);
+        } else {
+                ipc_answer_1(callid, EOK, address);
+        }
+}
 
 void remote_usbhc_get_buffer(device_t *device, void *iface,
@@ -125 +159 @@
 }
 
-void remote_usbhc_interrupt_out(device_t *device, void *iface,
-            ipc_callid_t callid, ipc_call_t *call)
-{
-        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
+/** Process an outgoing transfer (both OUT and SETUP).
+ *
+ * @param device Target device.
+ * @param callid Initiating caller.
+ * @param call Initiating call.
+ * @param transfer_func Transfer function (might be NULL).
+ */
+static void remote_usbhc_out_transfer(device_t *device,
+    ipc_callid_t callid, ipc_call_t *call,
+    usbhc_iface_transfer_out_t transfer_func)
+{
+        if (!transfer_func) {
+                ipc_answer_0(callid, ENOTSUP);
+                return;
+        }
 
         size_t expected_len = IPC_GET_ARG3(*call);
@@ -149 +194 @@
         }
 
-        if (!usb_iface->interrupt_out) {
-                ipc_answer_0(callid, ENOTSUP);
-                return;
-        }
-
         async_transaction_t *trans = malloc(sizeof(async_transaction_t));
         trans->caller = callid;
-        trans->buffer = NULL;
-        trans->size = 0;
-
-        int rc = usb_iface->interrupt_out(device, target, buffer, len,
+        trans->buffer = buffer;
+        trans->size = len;
+
+        int rc = transfer_func(device, target, buffer, len,
             callback_out, trans);
 
         if (rc != EOK) {
                 ipc_answer_0(callid, rc);
+                if (buffer != NULL) {
+                        free(buffer);
+                }
                 free(trans);
         }
 }
 
-void remote_usbhc_interrupt_in(device_t *device, void *iface,
-            ipc_callid_t callid, ipc_call_t *call)
-{
-        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
+/** Process an incoming transfer.
+ *
+ * @param device Target device.
+ * @param callid Initiating caller.
+ * @param call Initiating call.
+ * @param transfer_func Transfer function (might be NULL).
+ */
+static void remote_usbhc_in_transfer(device_t *device,
+    ipc_callid_t callid, ipc_call_t *call,
+    usbhc_iface_transfer_in_t transfer_func)
+{
+        if (!transfer_func) {
+                ipc_answer_0(callid, ENOTSUP);
+                return;
+        }
 
         size_t len = IPC_GET_ARG3(*call);
@@ -179 +233 @@
         };
 
-        if (!usb_iface->interrupt_in) {
-                ipc_answer_0(callid, ENOTSUP);
-                return;
-        }
-
         async_transaction_t *trans = malloc(sizeof(async_transaction_t));
         trans->caller = callid;
@@ -189 +238 @@
         trans->size = len;
 
-        int rc = usb_iface->interrupt_in(device, target, trans->buffer, len,
+        int rc = transfer_func(device, target, trans->buffer, len,
             callback_in, trans);
 
@@ -199 +248 @@
 }
 
+/** 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) {
+                                ipc_answer_0(callid, ENOTSUP);
+                                return;
+                        }
+                        break;
+                case USB_DIRECTION_OUT:
+                        if (!transfer_out_func) {
+                                ipc_answer_0(callid, ENOTSUP);
+                                return;
+                        }
+                        break;
+                default:
+                        assert(false && "unreachable code");
+                        break;
+        }
+
+        usb_target_t target = {
+                .address = IPC_GET_ARG1(*call),
+                .endpoint = IPC_GET_ARG2(*call)
+        };
+
+        async_transaction_t *trans = malloc(sizeof(async_transaction_t));
+        trans->caller = callid;
+        trans->buffer = NULL;
+        trans->size = 0;
+
+        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) {
+                ipc_answer_0(callid, rc);
+                free(trans);
+        }
+        return;
+}
+
+
+void remote_usbhc_interrupt_out(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->interrupt_out);
+}
+
+void remote_usbhc_interrupt_in(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->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);
+}
+
+
 
 /**