Changes in / [4e38d69:03197ffc] in mainline

Location:

uspace

Files:

• app/netstart/self_test.c (added)
• app/netstart/self_test.h (added)
• lib/c/generic/async.c (modified) (1 diff)
• lib/c/include/async.h (modified) (1 diff)
• lib/drv/generic/remote_usbhc.c (modified) (10 diffs)
• lib/drv/include/usbhc_iface.h (modified) (2 diffs)
• lib/packet/include/net_byteorder.h (deleted)
• lib/packet/include/net_err.h (deleted)
• lib/packet/include/socket_errno.h (deleted)
• lib/usb/src/usbdrv.c (modified) (10 diffs)

uspace/lib/c/generic/async.c

@@ -1567 +1567 @@
 }
 
-/** Start IPC_M_DATA_READ using the async framework.
- *
- * @param phoneid Phone that will be used to contact the receiving side.
- * @param dst Address of the beginning of the destination buffer.
- * @param size Size of the destination buffer (in bytes).
- * @param dataptr Storage of call data (arg 2 holds actual data size).
- * @return Hash of the sent message or 0 on error.
- */
-aid_t async_data_read(int phoneid, void *dst, size_t size, ipc_call_t *dataptr)
-{
-        return async_send_2(phoneid, IPC_M_DATA_READ, (sysarg_t) dst,
-            (sysarg_t) size, dataptr);
-}
-
 /** Wrapper for IPC_M_DATA_READ calls using the async framework.
  *

uspace/lib/c/include/async.h

@@ -340 +340 @@
             (arg4), (answer))
 
-extern aid_t async_data_read(int, void *, size_t, ipc_call_t *);
 extern int async_data_read_start(int, void *, size_t);
 extern bool async_data_read_receive(ipc_callid_t *, size_t *);

uspace/lib/drv/generic/remote_usbhc.c

@@ -42 +42 @@
 
 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 *);
@@ -63 +64 @@
         remote_usbhc_get_address,
 
+        remote_usbhc_get_buffer,
+
         remote_usbhc_reserve_default_address,
         remote_usbhc_release_default_address,
@@ -95 +98 @@
 typedef struct {
         ipc_callid_t caller;
-        ipc_callid_t data_caller;
         void *buffer;
         void *setup_packet;
@@ -125 +127 @@
 
         trans->caller = caller;
-        trans->data_caller = 0;
         trans->buffer = NULL;
         trans->setup_packet = NULL;
@@ -154 +155 @@
 }
 
+void remote_usbhc_get_buffer(device_t *device, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        sysarg_t buffer_hash = DEV_IPC_GET_ARG1(*call);
+        async_transaction_t * trans = (async_transaction_t *)buffer_hash;
+        if (trans == NULL) {
+                async_answer_0(callid, ENOENT);
+                return;
+        }
+        if (trans->buffer == NULL) {
+                async_answer_0(callid, EINVAL);
+                async_transaction_destroy(trans);
+                return;
+        }
+
+        ipc_callid_t cid;
+        size_t accepted_size;
+        if (!async_data_read_receive(&cid, &accepted_size)) {
+                async_answer_0(callid, EINVAL);
+                async_transaction_destroy(trans);
+                return;
+        }
+
+        if (accepted_size > trans->size) {
+                accepted_size = trans->size;
+        }
+        async_data_read_finalize(cid, trans->buffer, accepted_size);
+
+        async_answer_1(callid, EOK, accepted_size);
+
+        async_transaction_destroy(trans);
+}
+
 void remote_usbhc_reserve_default_address(device_t *device, void *iface,
     ipc_callid_t callid, ipc_call_t *call)
@@ -261 +295 @@
 
         trans->size = actual_size;
-
-        if (trans->data_caller) {
-                async_data_read_finalize(trans->data_caller,
-                    trans->buffer, actual_size);
-        }
-
-        async_answer_0(trans->caller, USB_OUTCOME_OK);
-
-        async_transaction_destroy(trans);
+        async_answer_1(trans->caller, USB_OUTCOME_OK, (sysarg_t)trans);
 }
 
@@ -350 +376 @@
         };
 
-        ipc_callid_t data_callid;
-        if (!async_data_read_receive(&data_callid, &len)) {
-                async_answer_0(callid, EPARTY);
-                return;
-        }
-
         async_transaction_t *trans = async_transaction_create(callid);
         if (trans == NULL) {
@@ -361 +381 @@
                 return;
         }
-        trans->data_caller = data_callid;
         trans->buffer = malloc(len);
         trans->size = len;
@@ -611 +630 @@
         }
 
-        ipc_callid_t data_callid;
-        if (!async_data_read_receive(&data_callid, &data_len)) {
-                async_answer_0(callid, EPARTY);
-                free(setup_packet);
-                return;
-        }
-
         async_transaction_t *trans = async_transaction_create(callid);
         if (trans == NULL) {
@@ -624 +636 @@
                 return;
         }
-        trans->data_caller = data_callid;
         trans->setup_packet = setup_packet;
         trans->size = data_len;

uspace/lib/drv/include/usbhc_iface.h

@@ -66 +66 @@
  *   - argument #2 is target 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
  *   error occurs)
+ * - if the call is answered with EOK, first argument of the answer is buffer
+ *   hash that could be used to retrieve the actual data
  *
  * Some special methods (NO-DATA transactions) do not send any data. These
  * might behave as both OUT or IN transactions because communication parts
  * where actual buffers are exchanged are omitted.
- **
+ *
+ * The mentioned data retrieval can be done any time after receiving EOK
+ * answer to IN method.
+ * This retrieval is done using the IPC_M_USBHC_GET_BUFFER where
+ * the first argument is buffer hash from call answer.
+ * This call must be immediately followed by data read-in and after the
+ * data are transferred, the initial call (IPC_M_USBHC_GET_BUFFER)
+ * is answered. Each buffer can be retrieved only once.
+ *
  * For all these methods, wrap functions exists. Important rule: functions
  * for IN transactions have (as parameters) buffers where retrieved data
@@ -95 +104 @@
         IPC_M_USBHC_GET_ADDRESS,
 
+        /** Asks for data buffer.
+         * See explanation at usb_iface_funcs_t.
+         * This function does not have counter part in functional interface
+         * as it is handled by the remote part itself.
+         */
+        IPC_M_USBHC_GET_BUFFER,
+
 
         /** Reserve usage of default address.

uspace/lib/usb/src/usbdrv.c

@@ -49 +49 @@
         /** Storage for actual number of bytes transferred. */
         size_t *size_transferred;
-        /** Initial call reply data. */
+        /** Initial call replay 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;
 
@@ -144 +140 @@
 
         if (rc != EOK) {
+                printf("usb_drv_get_my_address over %d failed: %s\n", phone, str_error(rc));
                 return rc;
         }
@@ -253 +250 @@
         }
 
-        transfer->read_request = 0;
         transfer->size_transferred = NULL;
         transfer->buffer = NULL;
@@ -319 +315 @@
         }
 
-        transfer->read_request = 0;
         transfer->size_transferred = actual_size;
         transfer->buffer = buffer;
@@ -332 +327 @@
             &transfer->reply);
 
-        if (buffer != NULL) {
-                transfer->read_request = async_data_read(phone, buffer, size,
-                    &transfer->read_reply);
-        }
-
         *handle = (usb_handle_t) transfer;
 
@@ -342 +332 @@
 }
 
+/** Read buffer from HCD.
+ *
+ * @param phone Opened phone to HCD.
+ * @param hash Buffer hash (obtained after completing IN transaction).
+ * @param buffer Buffer where to store data data.
+ * @param size Buffer size.
+ * @param actual_size Storage where actual number of bytes transferred will
+ *      be stored.
+ * @return Error status.
+ */
+static int read_buffer_in(int phone, sysarg_t hash,
+    void *buffer, size_t size, size_t *actual_size)
+{
+        ipc_call_t answer_data;
+        sysarg_t answer_rc;
+        aid_t req;
+        int rc;
+
+        req = async_send_2(phone,
+            DEV_IFACE_ID(USBHC_DEV_IFACE),
+            IPC_M_USBHC_GET_BUFFER,
+            hash,
+            &answer_data);
+
+        rc = async_data_read_start(phone, buffer, size);
+        if (rc != EOK) {
+                async_wait_for(req, NULL);
+                return EINVAL;
+        }
+
+        async_wait_for(req, &answer_rc);
+        rc = (int)answer_rc;
+
+        if (rc != EOK) {
+                return rc;
+        }
+
+        *actual_size = IPC_GET_ARG1(answer_data);
+
+        return EOK;
+}
 
 /** Blocks caller until given USB transaction is finished.
@@ -364 +395 @@
 
         sysarg_t answer_rc;
+        async_wait_for(transfer->request, &answer_rc);
+
+        if (answer_rc != EOK) {
+                rc = (int) answer_rc;
+                goto leave;
+        }
 
         /*
@@ -369 +406 @@
          */
         if ((transfer->buffer != NULL) && (transfer->size > 0)) {
-                async_wait_for(transfer->read_request, &answer_rc);
-
-                if (answer_rc != EOK) {
-                        rc = (int) answer_rc;
+                /*
+                 * The buffer hash identifies the data on the server
+                 * side.
+                 * We will use it when actually reading-in the data.
+                 */
+                sysarg_t buffer_hash = IPC_GET_ARG1(transfer->reply);
+                if (buffer_hash == 0) {
+                        rc = ENOENT;
                         goto leave;
                 }
 
-                if (transfer->size_transferred != NULL) {
-                        *(transfer->size_transferred)
-                            = IPC_GET_ARG2(transfer->read_reply);
+                size_t actual_size;
+                rc = read_buffer_in(transfer->phone, buffer_hash,
+                    transfer->buffer, transfer->size, &actual_size);
+
+                if (rc != EOK) {
+                        goto leave;
                 }
-        }
-
-        async_wait_for(transfer->request, &answer_rc);
-
-        if (answer_rc != EOK) {
-                rc = (int) answer_rc;
-                goto leave;
+
+                if (transfer->size_transferred) {
+                        *(transfer->size_transferred) = actual_size;
+                }
         }
 
@@ -474 +515 @@
         }
 
-        transfer->read_request = 0;
         transfer->size_transferred = NULL;
         transfer->buffer = NULL;
@@ -580 +620 @@
         }
 
-        transfer->read_request = async_data_read(phone, buffer, buffer_size,
-            &transfer->read_reply);
-
         *handle = (usb_handle_t) transfer;