Changeset 2185776 in mainline for uspace/srv/hw/bus/usb/hcd/virtual/connhost.c

Timestamp:

2010-10-26T13:47:46Z (13 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

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

Children:

56cb9bd

Parents:

23cb44b

Message:

Async communication with HCD

Added asynchronous versions of functions for sending/retrieving
data to/from HCD. These work pretty the same as functions for
sending messages in the async framework.

File:

• uspace/srv/hw/bus/usb/hcd/virtual/connhost.c (modified) (5 diffs)

uspace/srv/hw/bus/usb/hcd/virtual/connhost.c

@@ -52 +52 @@
 } transaction_details_t;
 
+
 /** Callback for outgoing transaction.
  */
@@ -193 +194 @@
 
 
+typedef struct {
+        ipc_callid_t caller;
+        void *buffer;
+        size_t size;
+} async_transaction_t;
+
+static void async_out_callback(void * buffer, size_t len,
+    usb_transaction_outcome_t outcome, void * arg)
+{
+        async_transaction_t * trans = (async_transaction_t *)arg;
+        
+        dprintf(2, "async_out_callback(buffer, %u, %d, %p) -> %x",
+            len, outcome, arg, trans->caller);
+        
+        // FIXME - answer according to outcome
+        ipc_answer_1(trans->caller, EOK, 0);
+        
+        free(trans);
+        if (buffer) {
+                free(buffer);
+        }
+        dprintf(4, "async_out_callback answered");
+}
+
+static void async_to_device(ipc_callid_t iid, ipc_call_t icall, bool setup_transaction)
+{
+        size_t expected_len = IPC_GET_ARG3(icall);
+        usb_target_t target = {
+                .address = IPC_GET_ARG1(icall),
+                .endpoint = IPC_GET_ARG2(icall)
+        };
+        
+        dprintf(1, "async_to_device: dev=%d:%d, size=%d, iid=%x",
+            target.address, target.endpoint, expected_len, iid);
+        
+        size_t len = 0;
+        void * buffer = NULL;
+        if (expected_len > 0) {
+                int rc = async_data_write_accept(&buffer, false,
+                    1, USB_MAX_PAYLOAD_SIZE,
+                    0, &len);
+                
+                if (rc != EOK) {
+                        ipc_answer_0(iid, rc);
+                        return;
+                }
+        }
+        
+        async_transaction_t * trans = malloc(sizeof(async_transaction_t));
+        trans->caller = iid;
+        trans->buffer = NULL;
+        trans->size = 0;
+        
+        hc_add_transaction_to_device(setup_transaction, target,
+            buffer, len,
+            async_out_callback, trans);
+        
+        dprintf(2, "async transaction to device scheduled (%p)", trans);
+}
+
+static void async_in_callback(void * buffer, size_t len,
+    usb_transaction_outcome_t outcome, void * arg)
+{       
+        async_transaction_t * trans = (async_transaction_t *)arg;
+        
+        dprintf(2, "async_in_callback(buffer, %u, %d, %p) -> %x",
+            len, outcome, arg, trans->caller);
+        
+        trans->buffer = buffer;
+        trans->size = len;
+        
+        ipc_callid_t caller = trans->caller;
+        
+        if (buffer == NULL) {
+                free(trans);
+                trans = NULL;
+        }
+        
+        
+        // FIXME - answer according to outcome
+        ipc_answer_1(caller, EOK, (ipcarg_t)trans);
+        dprintf(4, "async_in_callback answered (%#x)", (ipcarg_t)trans);
+}
+
+static void async_from_device(ipc_callid_t iid, ipc_call_t icall)
+{
+        usb_target_t target = {
+                .address = IPC_GET_ARG1(icall),
+                .endpoint = IPC_GET_ARG2(icall)
+        };
+        size_t len = IPC_GET_ARG3(icall);
+        
+        dprintf(1, "async_from_device: dev=%d:%d, size=%d, iid=%x",
+            target.address, target.endpoint, len, iid);
+        
+        void * buffer = NULL;
+        if (len > 0) {
+                buffer = malloc(len);
+        }
+        
+        async_transaction_t * trans = malloc(sizeof(async_transaction_t));
+        trans->caller = iid;
+        trans->buffer = NULL;
+        trans->size = 0;
+        
+        hc_add_transaction_from_device(target,
+            buffer, len,
+            async_in_callback, trans);
+        
+        dprintf(2, "async transfer from device scheduled (%p)", trans);
+}
+
+static void async_get_buffer(ipc_callid_t iid, ipc_call_t icall)
+{
+        ipcarg_t buffer_hash = IPC_GET_ARG1(icall);
+        async_transaction_t * trans = (async_transaction_t *)buffer_hash;
+        if (trans == NULL) {
+                ipc_answer_0(iid, ENOENT);
+                return;
+        }
+        if (trans->buffer == NULL) {
+                ipc_answer_0(iid, EINVAL);
+                free(trans);
+                return;
+        }
+        
+        ipc_callid_t callid;
+        size_t accepted_size;
+        if (!async_data_read_receive(&callid, &accepted_size)) {
+                ipc_answer_0(iid, EINVAL);
+                return;
+        }
+        
+        if (accepted_size > trans->size) {
+                accepted_size = trans->size;
+        }
+        async_data_read_finalize(callid, trans->buffer, accepted_size);
+        
+        ipc_answer_1(iid, EOK, accepted_size);
+        
+        free(trans->buffer);
+        free(trans);
+}
+
 
 /** Connection handler for communcation with host.
@@ -214 +359 @@
                 
                 callid = async_get_call(&call);
+                
+                dprintf(6, "host on %#x calls [%x: %u (%u, %u, %u, %u, %u)]",
+                    phone_hash,
+                    callid,
+                    IPC_GET_METHOD(call),
+                    IPC_GET_ARG1(call), IPC_GET_ARG2(call), IPC_GET_ARG3(call),
+                    IPC_GET_ARG4(call), IPC_GET_ARG5(call));
                 
                 switch (IPC_GET_METHOD(call)) {
@@ -231 +383 @@
                                 break;
                         
+                        /* callback-result methods */
                         
                         case IPC_M_USB_HCD_INTERRUPT_OUT:
@@ -259 +412 @@
                                     true, host_phone);
                                 break;
-                                
-                        case IPC_M_USB_HCD_CONTROL_READ_DATA:
-                        case IPC_M_USB_HCD_CONTROL_READ_STATUS:
+                        
+                        /* async methods */
+                        
+                        case IPC_M_USB_HCD_GET_BUFFER_ASYNC:
+                                async_get_buffer(callid, call);
+                                break;
+        
+                        case IPC_M_USB_HCD_INTERRUPT_OUT_ASYNC:
+                        case IPC_M_USB_HCD_CONTROL_WRITE_DATA_ASYNC:
+                        case IPC_M_USB_HCD_CONTROL_READ_STATUS_ASYNC:
+                                async_to_device(callid, call, false);
+                                break;
+                        
+                        case IPC_M_USB_HCD_CONTROL_WRITE_SETUP_ASYNC:
+                        case IPC_M_USB_HCD_CONTROL_READ_SETUP_ASYNC:
+                                async_to_device(callid, call, true);
+                                break;
+                        
+                        case IPC_M_USB_HCD_INTERRUPT_IN_ASYNC:
+                        case IPC_M_USB_HCD_CONTROL_WRITE_STATUS_ASYNC:
+                        case IPC_M_USB_HCD_CONTROL_READ_DATA_ASYNC:
+                                async_from_device(callid, call);
+                                break;
+                        
+                        /* end of known methods */
                         
                         default: