Changeset fd312d5 in mainline

Timestamp:

2017-12-20T16:06:56Z (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:

cec130b

Parents:

f98f4b7

Message:

usbdiag: more robust testing framework, added bulk in stress test, refactored remote usbdiag interface, new command for tmon

Location:

uspace

Files:

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

uspace/app/tmon/commands.h

@@ -38 +38 @@
 
 int tmon_list(int, char **);
-int tmon_test_bulk(int, char **);
+int tmon_stress_bulk_in(int, char **);
+int tmon_stress_bulk_out(int, char **);
 
 #endif /* TMON_COMMANDS_H_ */

uspace/app/tmon/main.c

@@ -40 +40 @@
 #define NAME "tmon"
 
-static int fallback(int argc, char *argv[])
-{
-        // FIXME
-        printf(NAME ": Not implemented, lol!\n");
-        return 1;
-}
-
 typedef struct {
         const char *name;
@@ -60 +53 @@
         },
         {
-                .name = "test-bulk",
-                .description = "Benchmark bulk endpoints of a diagnostic device.",
-                .action = tmon_test_bulk,
+                .name = "stress-bulk-in",
+                .description = "Stress benchmark bulk in endpoints of a diagnostic device.",
+                .action = tmon_stress_bulk_in,
         },
         {
-                .name = "test-intr",
-                .description = "Benchmark interrupt endpoints of a diagnostic device.",
-                .action = fallback,
-        },
-        {
-                .name = "test-isoch",
-                .description = "Benchmark isochronous endpoints of a diagnostic device.",
-                .action = fallback,
+                .name = "stress-bulk-out",
+                .description = "Benchmark bulk out endpoints of a diagnostic device.",
+                .action = tmon_stress_bulk_out,
         },
         {

uspace/app/tmon/test.c

@@ -114 +114 @@
 }
 
-static int bulk_worker(devman_handle_t fun) {
+static int stress_bulk_in(devman_handle_t fun) {
         async_sess_t *sess = usbdiag_connect(fun);
         async_exch_t *exch = async_exchange_begin(sess);
 
-        // TODO: do some testing
-        int y;
-        int rc = usbdiag_test(exch, 4200, &y);
+        const int cycles = 1024;
+        const size_t size = 65432;
+        int rc = usbdiag_stress_bulk_in(exch, cycles, size);
 
         if (rc) {
                 printf(NAME ": %s\n", str_error(rc));
-        } else {
-                printf("The number is %d.\n", y);
         }
 
@@ -133 +131 @@
 }
 
-int tmon_test_bulk(int argc, char *argv[])
+static int stress_bulk_out(devman_handle_t fun) {
+        async_sess_t *sess = usbdiag_connect(fun);
+        async_exch_t *exch = async_exchange_begin(sess);
+
+        const int cycles = 1024;
+        const size_t size = 65432;
+        int rc = usbdiag_stress_bulk_out(exch, cycles, size);
+
+        if (rc) {
+                printf(NAME ": %s\n", str_error(rc));
+        }
+
+        async_exchange_end(exch);
+        usbdiag_disconnect(sess);
+        return 0;
+}
+
+int tmon_stress_bulk_in(int argc, char *argv[])
 {
-        return resolve_and_test(argc, argv, bulk_worker);
+        return resolve_and_test(argc, argv, stress_bulk_in);
+}
+
+int tmon_stress_bulk_out(int argc, char *argv[])
+{
+        return resolve_and_test(argc, argv, stress_bulk_out);
 }
 

uspace/drv/bus/usb/usbdiag/Makefile

@@ -35 +35 @@
 SOURCES = \
         device.c \
+        tests.c \
         main.c \
 

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

@@ -41 +41 @@
 
 #include "device.h"
+#include "tests.h"
 
 #define NAME "usbdiag"
 
-
-static int some_test(ddf_fun_t *fun, int x, int *y)
-{
-        int rc = EOK;
-        usb_diag_dev_t *dev = ddf_fun_to_usb_diag_dev(fun);
-
-        const size_t size = min(dev->bulk_in->desc.max_packet_size, dev->bulk_out->desc.max_packet_size);
-        char *buffer = (char *) malloc(size);
-        memset(buffer, 42, sizeof(buffer));
-
-        // Write buffer to device.
-        if ((rc = usb_pipe_write(dev->bulk_out, buffer, size))) {
-                usb_log_error("Bulk OUT write failed. %s\n", str_error(rc));
+#define TRANSLATE_FUNC_NAME(fun) translate_##fun
+#define TRANSLATE_FUNC(fun) \
+        static int TRANSLATE_FUNC_NAME(fun)(ddf_fun_t *f, int cycles, size_t size)\
+        {\
+                usb_diag_dev_t *dev = ddf_fun_to_usb_diag_dev(f);\
+                return fun(dev, cycles, size);\
         }
 
-        // Read device's response.
-        size_t remaining = size;
-        size_t transferred;
-        while (remaining > 0) {
-                if ((rc = usb_pipe_read(dev->bulk_in, buffer + size - remaining, remaining, &transferred))) {
-                        usb_log_error("Bulk IN read failed. %s\n", str_error(rc));
-                        break;
-                }
-
-                if (transferred > remaining) {
-                        usb_log_error("Bulk IN read more than expected.\n");
-                        rc = EINVAL;
-                        break;
-                }
-
-                remaining -= transferred;
-        }
-
-        // TODO: Check output?
-
-        free(buffer);
-
-        *y = x + 42;
-        return rc;
-}
+TRANSLATE_FUNC(usb_diag_stress_bulk_out)
+TRANSLATE_FUNC(usb_diag_stress_bulk_in)
 
 static usbdiag_iface_t diag_interface = {
-        .test = some_test,
+        .stress_bulk_out = TRANSLATE_FUNC_NAME(usb_diag_stress_bulk_out),
+        .stress_bulk_in = TRANSLATE_FUNC_NAME(usb_diag_stress_bulk_in)
 };
+
+#undef TRANSLATE_FUNC_NAME
+#undef TRANSLATE_FUNC
 
 static ddf_dev_ops_t diag_ops = {
@@ -105 +80 @@
         dev->fun = fun;
 
-        usb_endpoint_mapping_t *epm_out = usb_device_get_mapped_ep(dev->usb_dev, USB_DIAG_EP_BULK_OUT);
-        usb_endpoint_mapping_t *epm_in = usb_device_get_mapped_ep(dev->usb_dev, USB_DIAG_EP_BULK_IN);
+#define _MAP_EP(target, ep_no) do {\
+        usb_endpoint_mapping_t *epm = usb_device_get_mapped_ep(dev->usb_dev, USB_DIAG_EP_##ep_no);\
+        if (!epm || !epm->present) {\
+                usb_log_error("Failed to map endpoint: " #ep_no ".\n");\
+                rc = ENOENT;\
+                goto err_fun;\
+        }\
+        target = &epm->pipe;\
+        } while (0);
 
-        if (!epm_in || !epm_out || !epm_in->present || !epm_out->present) {
-                usb_log_error("Required EPs were not mapped.\n");
-                rc = ENOENT;
-                goto err_fun;
-        }
+        _MAP_EP(dev->intr_in, INTR_IN);
+        _MAP_EP(dev->intr_out, INTR_OUT);
+        _MAP_EP(dev->bulk_in, BULK_IN);
+        _MAP_EP(dev->bulk_out, BULK_OUT);
+        _MAP_EP(dev->isoch_in, ISOCH_IN);
+        _MAP_EP(dev->isoch_out, ISOCH_OUT);
 
-        dev->bulk_out = &epm_out->pipe;
-        dev->bulk_in = &epm_in->pipe;
+#undef _MAP_EP
 
         return EOK;

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

@@ -52 +52 @@
         usb_device_t *usb_dev;
         ddf_fun_t *fun;
+        usb_pipe_t *intr_in;
+        usb_pipe_t *intr_out;
         usb_pipe_t *bulk_in;
         usb_pipe_t *bulk_out;
+        usb_pipe_t *isoch_in;
+        usb_pipe_t *isoch_out;
 } usb_diag_dev_t;
 

uspace/lib/drv/generic/remote_usbdiag.c

@@ -43 +43 @@
 
 typedef enum {
-        IPC_M_USBDIAG_TEST,
+        IPC_M_USBDIAG_STRESS_BULK_OUT,
+        IPC_M_USBDIAG_STRESS_BULK_IN
 } usb_iface_funcs_t;
 
@@ -57 +58 @@
 }
 
-int usbdiag_test(async_exch_t *exch, int x, int *y)
+int usbdiag_stress_bulk_out(async_exch_t *exch, int cycles, size_t size)
 {
         if (!exch)
                 return EBADMEM;
 
-        sysarg_t y_;
-        const int ret = async_req_2_1(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_TEST, x, &y_);
-
-        if (y)
-                *y = (int) y_;
-
-        return ret;
+        return async_req_3_0(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_STRESS_BULK_OUT, cycles, size);
 }
 
-static void remote_usbdiag_test(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+int usbdiag_stress_bulk_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_BULK_IN, cycles, size);
+}
+
+static void remote_usbdiag_stress_bulk_out(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbdiag_stress_bulk_in(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_TEST] = remote_usbdiag_test,
+        [IPC_M_USBDIAG_STRESS_BULK_OUT] = remote_usbdiag_stress_bulk_out,
+        [IPC_M_USBDIAG_STRESS_BULK_IN] = remote_usbdiag_stress_bulk_in,
 };
 
@@ -84 +89 @@
 };
 
-void remote_usbdiag_test(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
+void remote_usbdiag_stress_bulk_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->test == NULL) {
+        if (diag_iface->stress_bulk_out == NULL) {
                 async_answer_0(callid, ENOTSUP);
                 return;
         }
 
-        int x = DEV_IPC_GET_ARG1(*call);
-        int y;
-        const int ret = diag_iface->test(fun, x, &y);
-        if (ret != EOK) {
-                async_answer_0(callid, ret);
-        } else {
-                async_answer_1(callid, EOK, y);
+        int cycles = DEV_IPC_GET_ARG1(*call);
+        size_t size = DEV_IPC_GET_ARG2(*call);
+        const int ret = diag_iface->stress_bulk_out(fun, cycles, size);
+        async_answer_0(callid, ret);
+}
+
+void remote_usbdiag_stress_bulk_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_bulk_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_bulk_in(fun, cycles, size);
+        async_answer_0(callid, ret);
 }
 

uspace/lib/drv/include/usbdiag_iface.h

@@ -45 +45 @@
 async_sess_t *usbdiag_connect(devman_handle_t);
 void usbdiag_disconnect(async_sess_t*);
-int usbdiag_test(async_exch_t*, int, int*);
+int usbdiag_stress_bulk_in(async_exch_t*, int, size_t);
+int usbdiag_stress_bulk_out(async_exch_t*, int, size_t);
 
 /** USB diagnostic device communication interface. */
 typedef struct {
-        int (*test)(ddf_fun_t*, int, int*);
+        int (*stress_bulk_in)(ddf_fun_t*, int, size_t);
+        int (*stress_bulk_out)(ddf_fun_t*, int, size_t);
 } usbdiag_iface_t;