Changeset ff16da5f in mainline

Timestamp:

2017-12-21T14:37:30Z (7 years ago)

Author:

Petr Mánek <petr.manek@…>

Branches:

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

Children:

119a794

Parents:

74c0de0

git-author:

Petr Mánek <petr.manek@…> (2017-12-21 14:37:23)

git-committer:

Petr Mánek <petr.manek@…> (2017-12-21 14:37:30)

Message:

usbdiag: added isochronous test

Location:

uspace

Files:

• app/tmon/commands.h (modified) (1 diff)
• app/tmon/main.c (modified) (1 diff)
• app/tmon/stress_test.c (modified) (2 diffs)
• drv/bus/usb/usbdiag/device.c (modified) (1 diff)
• drv/bus/usb/usbdiag/tests.c (modified) (1 diff)
• drv/bus/usb/usbdiag/tests.h (modified) (1 diff)
• lib/drv/generic/remote_usbdiag.c (modified) (4 diffs)
• lib/drv/include/usbdiag_iface.h (modified) (2 diffs)

uspace/app/tmon/commands.h

@@ -42 +42 @@
 int tmon_stress_bulk_in(int, char **);
 int tmon_stress_bulk_out(int, char **);
+int tmon_stress_isoch_in(int, char **);
+int tmon_stress_isoch_out(int, char **);
 
 #endif /* TMON_COMMANDS_H_ */

uspace/app/tmon/main.c

@@ -73 +73 @@
         },
         {
+                .name = "stress-isoch-in",
+                .description = "Stress benchmark isochronous in endpoints of a device.",
+                .action = tmon_stress_isoch_in,
+        },
+        {
+                .name = "stress-isoch-out",
+                .description = "Stress benchmark isochronous out endpoints of a device.",
+                .action = tmon_stress_isoch_out,
+        },
+        {
                 .name = NULL
         }

uspace/app/tmon/stress_test.c

@@ -130 +130 @@
 }
 
+static int run_isoch_in(async_exch_t *exch, const tmon_test_params_t *generic_params)
+{
+        const tmon_stress_test_params_t *params = (tmon_stress_test_params_t *) generic_params;
+        printf("Executing isochronous in stress test.\n"
+            "      Packet count: %d\n"
+            "      Packet size: %ld\n", params->cycles, params->size);
+
+        int rc = usbdiag_stress_isoch_in(exch, params->cycles, params->size);
+        if (rc) {
+                printf(NAME ": Test failed. %s\n", str_error(rc));
+                return 1;
+        }
+
+        return 0;
+}
+
+static int run_isoch_out(async_exch_t *exch, const tmon_test_params_t *generic_params)
+{
+        const tmon_stress_test_params_t *params = (tmon_stress_test_params_t *) generic_params;
+        printf("Executing isochronous out stress test.\n"
+            "      Packet count: %d\n"
+            "      Packet size: %ld\n", params->cycles, params->size);
+
+        int rc = usbdiag_stress_isoch_out(exch, params->cycles, params->size);
+        if (rc) {
+                printf(NAME ": Test failed. %s\n", str_error(rc));
+                return 1;
+        }
+
+        return 0;
+}
+
 int tmon_stress_intr_in(int argc, char *argv[])
 {
@@ -170 +202 @@
 }
 
+int tmon_stress_isoch_in(int argc, char *argv[])
+{
+        static const tmon_test_ops_t ops = {
+                .run = run_isoch_in,
+                .read_params = read_params
+        };
+
+        return tmon_test_main(argc, argv, &ops);
+}
+
+int tmon_stress_isoch_out(int argc, char *argv[])
+{
+        static const tmon_test_ops_t ops = {
+                .run = run_isoch_out,
+                .read_params = read_params
+        };
+
+        return tmon_test_main(argc, argv, &ops);
+}
+
 /** @}
  */

uspace/drv/bus/usb/usbdiag/device.c

@@ -53 +53 @@
         }
 
+TRANSLATE_FUNC(usb_diag_stress_intr_out)
+TRANSLATE_FUNC(usb_diag_stress_intr_in)
 TRANSLATE_FUNC(usb_diag_stress_bulk_out)
 TRANSLATE_FUNC(usb_diag_stress_bulk_in)
-TRANSLATE_FUNC(usb_diag_stress_intr_out)
-TRANSLATE_FUNC(usb_diag_stress_intr_in)
+TRANSLATE_FUNC(usb_diag_stress_isoch_out)
+TRANSLATE_FUNC(usb_diag_stress_isoch_in)
 
 static usbdiag_iface_t diag_interface = {
+        .stress_intr_out = TRANSLATE_FUNC_NAME(usb_diag_stress_intr_out),
+        .stress_intr_in = TRANSLATE_FUNC_NAME(usb_diag_stress_intr_in),
         .stress_bulk_out = TRANSLATE_FUNC_NAME(usb_diag_stress_bulk_out),
         .stress_bulk_in = TRANSLATE_FUNC_NAME(usb_diag_stress_bulk_in),
-        .stress_intr_out = TRANSLATE_FUNC_NAME(usb_diag_stress_intr_out),
-        .stress_intr_in = TRANSLATE_FUNC_NAME(usb_diag_stress_intr_in)
+        .stress_isoch_out = TRANSLATE_FUNC_NAME(usb_diag_stress_isoch_out),
+        .stress_isoch_in = TRANSLATE_FUNC_NAME(usb_diag_stress_isoch_in)
 };
 

uspace/drv/bus/usb/usbdiag/tests.c

@@ -178 +178 @@
 }
 
+int usb_diag_stress_isoch_out(usb_diag_dev_t *dev, int cycles, size_t size)
+{
+        if (!dev)
+                return EBADMEM;
+
+        char *buffer = (char *) malloc(size);
+        if (!buffer)
+                return ENOMEM;
+
+        memset(buffer, 42, size);
+
+        // TODO: Are we sure that no other test is running on this endpoint?
+
+        usb_log_info("Performing isochronous out stress test on device %s.", ddf_fun_get_name(dev->fun));
+        int rc = EOK;
+        for (int i = 0; i < cycles; ++i) {
+                // Write buffer to device.
+                if ((rc = usb_pipe_write(dev->isoch_out, buffer, size))) {
+                        usb_log_error("Isochronous OUT write failed. %s\n", str_error(rc));
+                        break;
+                }
+        }
+
+        free(buffer);
+        return rc;
+}
+
+int usb_diag_stress_isoch_in(usb_diag_dev_t *dev, int cycles, size_t size)
+{
+        if (!dev)
+                return EBADMEM;
+
+        char *buffer = (char *) malloc(size);
+        if (!buffer)
+                return ENOMEM;
+
+        // TODO: Are we sure that no other test is running on this endpoint?
+
+        usb_log_info("Performing isochronous in stress test on device %s.", ddf_fun_get_name(dev->fun));
+        int rc = EOK;
+        for (int i = 0; i < cycles; ++i) {
+                // Read device's response.
+                size_t remaining = size;
+                size_t transferred;
+
+                while (remaining > 0) {
+                        if ((rc = usb_pipe_read(dev->isoch_in, buffer + size - remaining, remaining, &transferred))) {
+                                usb_log_error("Isochronous IN read failed. %s\n", str_error(rc));
+                                break;
+                        }
+
+                        if (transferred > remaining) {
+                                usb_log_error("Isochronous IN read more than expected.\n");
+                                rc = EINVAL;
+                                break;
+                        }
+
+                        remaining -= transferred;
+                }
+
+                if (rc)
+                        break;
+        }
+
+        free(buffer);
+        return rc;
+}
+
 /**
  * @}

uspace/drv/bus/usb/usbdiag/tests.h

@@ -43 +43 @@
 int usb_diag_stress_bulk_out(usb_diag_dev_t *, int, size_t);
 int usb_diag_stress_bulk_in(usb_diag_dev_t *, int, size_t);
+int usb_diag_stress_isoch_out(usb_diag_dev_t *, int, size_t);
+int usb_diag_stress_isoch_in(usb_diag_dev_t *, int, size_t);
 
 #endif /* USB_DIAG_TESTS_H_ */

uspace/lib/drv/generic/remote_usbdiag.c

@@ -46 +46 @@
         IPC_M_USBDIAG_STRESS_INTR_OUT,
         IPC_M_USBDIAG_STRESS_BULK_IN,
-        IPC_M_USBDIAG_STRESS_BULK_OUT
+        IPC_M_USBDIAG_STRESS_BULK_OUT,
+        IPC_M_USBDIAG_STRESS_ISOCH_IN,
+        IPC_M_USBDIAG_STRESS_ISOCH_OUT
 } usb_iface_funcs_t;
 
@@ -90 +92 @@
 
         return async_req_3_0(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_STRESS_BULK_OUT, cycles, size);
+}
+
+int usbdiag_stress_isoch_in(async_exch_t *exch, int cycles, size_t size)
+{
+        if (!exch)
+                return EBADMEM;
+
+        return async_req_3_0(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_STRESS_ISOCH_IN, cycles, size);
+}
+
+int usbdiag_stress_isoch_out(async_exch_t *exch, int cycles, size_t size)
+{
+        if (!exch)
+                return EBADMEM;
+
+        return async_req_3_0(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_STRESS_ISOCH_OUT, cycles, size);
 }
 
@@ -96 +114 @@
 static void remote_usbdiag_stress_bulk_in(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
 static void remote_usbdiag_stress_bulk_out(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbdiag_stress_isoch_in(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbdiag_stress_isoch_out(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
 
 /** Remote USB diagnostic interface operations. */
 static const remote_iface_func_ptr_t remote_usbdiag_iface_ops [] = {
-[       IPC_M_USBDIAG_STRESS_INTR_IN] = remote_usbdiag_stress_intr_in,
+        [IPC_M_USBDIAG_STRESS_INTR_IN] = remote_usbdiag_stress_intr_in,
         [IPC_M_USBDIAG_STRESS_INTR_OUT] = remote_usbdiag_stress_intr_out,
-[       IPC_M_USBDIAG_STRESS_BULK_IN] = remote_usbdiag_stress_bulk_in,
-        [IPC_M_USBDIAG_STRESS_BULK_OUT] = remote_usbdiag_stress_bulk_out
+        [IPC_M_USBDIAG_STRESS_BULK_IN] = remote_usbdiag_stress_bulk_in,
+        [IPC_M_USBDIAG_STRESS_BULK_OUT] = remote_usbdiag_stress_bulk_out,
+        [IPC_M_USBDIAG_STRESS_ISOCH_IN] = remote_usbdiag_stress_isoch_in,
+        [IPC_M_USBDIAG_STRESS_ISOCH_OUT] = remote_usbdiag_stress_isoch_out
 };
 
@@ -171 +193 @@
 }
 
+void remote_usbdiag_stress_isoch_in(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
+{
+        const usbdiag_iface_t *diag_iface = (usbdiag_iface_t *) iface;
+
+        if (diag_iface->stress_isoch_in == NULL) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+
+        int cycles = DEV_IPC_GET_ARG1(*call);
+        size_t size = DEV_IPC_GET_ARG2(*call);
+        const int ret = diag_iface->stress_isoch_in(fun, cycles, size);
+        async_answer_0(callid, ret);
+}
+
+void remote_usbdiag_stress_isoch_out(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
+{
+        const usbdiag_iface_t *diag_iface = (usbdiag_iface_t *) iface;
+
+        if (diag_iface->stress_isoch_out == NULL) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+
+        int cycles = DEV_IPC_GET_ARG1(*call);
+        size_t size = DEV_IPC_GET_ARG2(*call);
+        const int ret = diag_iface->stress_isoch_out(fun, cycles, size);
+        async_answer_0(callid, ret);
+}
+
 /**
  * @}

uspace/lib/drv/include/usbdiag_iface.h

@@ -49 +49 @@
 int usbdiag_stress_bulk_in(async_exch_t*, int, size_t);
 int usbdiag_stress_bulk_out(async_exch_t*, int, size_t);
+int usbdiag_stress_isoch_in(async_exch_t*, int, size_t);
+int usbdiag_stress_isoch_out(async_exch_t*, int, size_t);
 
 /** USB diagnostic device communication interface. */
@@ -56 +58 @@
         int (*stress_bulk_in)(ddf_fun_t*, int, size_t);
         int (*stress_bulk_out)(ddf_fun_t*, int, size_t);
+        int (*stress_isoch_in)(ddf_fun_t*, int, size_t);
+        int (*stress_isoch_out)(ddf_fun_t*, int, size_t);
 } usbdiag_iface_t;