Index: uspace/app/tmon/Makefile =================================================================== --- uspace/app/tmon/Makefile (revision e67c50ac9b5c850d056f789863dea7d4da95af3a) +++ uspace/app/tmon/Makefile (revision 64ce0c1435496748632f7682b2657fdc79aad634) @@ -30,5 +30,5 @@ BINARY = tmon -LIBS = drv +LIBS = drv usb SOURCES = \ @@ -36,5 +36,5 @@ list.c\ tf.c\ - burst_tests.c\ + tests.c\ resolve.c Index: pace/app/tmon/burst_tests.c =================================================================== --- uspace/app/tmon/burst_tests.c (revision e67c50ac9b5c850d056f789863dea7d4da95af3a) +++ (revision ) @@ -1,446 +1,0 @@ -/* - * Copyright (c) 2017 Petr Manek - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup tmon - * @{ - */ -/** - * @file - * USB burst tests. - */ - -#include -#include -#include -#include -#include -#include -#include -#include "commands.h" -#include "tf.h" - -#define NAME "tmon" -#define INDENT " " - -/** Generic burst test parameters. */ -typedef struct tmon_burst_test_params { - /** Inherited base. */ - tmon_test_params_t base; - /** The count of reads/writes to perform. */ - uint32_t cycles; - /** Size of single read/write. */ - size_t size; -} tmon_burst_test_params_t; - -/** Static array of long options, from which test parameters are parsed. */ -static struct option long_options[] = { - {"cycles", required_argument, NULL, 'n'}, - {"size", required_argument, NULL, 's'}, - {0, 0, NULL, 0} -}; - -/** String of short options, from which test parameters are parsed. */ -static const char *short_options = "n:s:"; - -/** Common option parser for all burst tests. - * @param[in] argc Number of arguments. - * @param[in] argv Argument values. Must point to exactly `argc` strings. - * @param[out] params Parsed test parameters (if successful). - * - * @return EOK if successful (in such case caller becomes the owner of `params`). - */ -static int read_params(int argc, char *argv[], tmon_test_params_t **params) -{ - int rc; - tmon_burst_test_params_t *p = (tmon_burst_test_params_t *) malloc(sizeof(tmon_burst_test_params_t)); - if (!p) - return ENOMEM; - - // Default values. - p->cycles = 256; - p->size = 1024; - - // Parse other than default values. - int c; - for (c = 0, optreset = 1, optind = 0; c != -1;) { - c = getopt_long(argc, argv, short_options, long_options, NULL); - switch (c) { - case -1: - break; - case 'n': - if (!optarg || str_uint32_t(optarg, NULL, 10, false, &p->cycles) != EOK) { - puts(NAME ": Invalid number of cycles.\n"); - rc = EINVAL; - goto err_malloc; - } - break; - case 's': - if (!optarg || str_size_t(optarg, NULL, 10, false, &p->size) != EOK) { - puts(NAME ": Invalid data size.\n"); - rc = EINVAL; - goto err_malloc; - } - break; - } - } - - *params = (tmon_test_params_t *) p; - return EOK; - -err_malloc: - free(p); - *params = NULL; - return rc; -} - -/** Unit of quantity used for pretty formatting. */ -typedef struct tmon_unit { - /** Prefix letter, which is printed before the actual unit. */ - char prefix; - /** Factor of the unit. */ - uint64_t factor; -} tmon_unit_t; - -/** Static array of units with decreasing factors. */ -static const tmon_unit_t units[] = { - { .prefix = 'E', .factor = ((uint64_t) 1) << 60 }, - { .prefix = 'P', .factor = ((uint64_t) 1) << 50 }, - { .prefix = 'T', .factor = ((uint64_t) 1) << 40 }, - { .prefix = 'G', .factor = ((uint64_t) 1) << 30 }, - { .prefix = 'M', .factor = ((uint64_t) 1) << 20 }, - { .prefix = 'k', .factor = ((uint64_t) 1) << 10 } -}; - -/** Format size in bytes for human reading. - * @param[in] size The size to format. - * @param[in] fmt Format string. Must include one double and char. - * - * @return Heap-allocated string if successful (caller becomes its owner), NULL otherwise. - */ -static char * format_size(double size, const char *fmt) -{ - // Figure out the "tightest" unit. - unsigned i; - for (i = 0; i < ARRAY_SIZE(units); ++i) { - if (units[i].factor <= size) - break; - } - - char prefix[] = { '\0', '\0' }; - double factor = 1; - - if (i < ARRAY_SIZE(units)) { - prefix[0] = units[i].prefix; - factor = units[i].factor; - } - - // Format the size. - const double div_size = size / factor; - - char *out = NULL; - asprintf(&out, fmt, div_size, prefix); - - return out; -} - -/** Print burst test parameters. - * @param[in] params Test parameters to print. - */ -static void print_params(const tmon_burst_test_params_t *params) -{ - printf(INDENT "Number of cycles: %d\n", params->cycles); - - char *str_size = format_size(params->size, "%.3f %sB"); - printf(INDENT "Data size: %s\n", str_size); - free(str_size); -} - -/** Print burst test results. - * @param[in] params Test parameters. - * @param[in] duration Duration of the burst test. - */ -static void print_results(const tmon_burst_test_params_t *params, usbdiag_dur_t duration) -{ - printf(INDENT "Total duration: %ld ms\n", duration); - - const double dur_per_cycle = (double) duration / (double) params->cycles; - printf(INDENT "Duration per cycle: %.3f ms\n", dur_per_cycle); - - const size_t total_size = params->size * params->cycles; - char *str_total_size = format_size(total_size, "%.3f %sB"); - printf(INDENT "Total size: %s\n", str_total_size); - free(str_total_size); - - const double speed = 1000.0 * (double) total_size / (double) duration; - char *str_speed = format_size(speed, "%.3f %sB/s"); - printf(INDENT "Average speed: %s\n", str_speed); - free(str_speed); -} - -/** Run "interrupt in" burst test. - * @param[in] exch Open async exchange with the diagnostic device. - * @param[in] generic_params Test parameters. Must point to 'tmon_burst_test_params_t'. - * - * @return Exit code - */ -static int run_intr_in(async_exch_t *exch, const tmon_test_params_t *generic_params) -{ - const tmon_burst_test_params_t *params = (tmon_burst_test_params_t *) generic_params; - puts("Reading data from interrupt endpoint.\n"); - print_params(params); - - usbdiag_dur_t duration; - int rc = usbdiag_burst_intr_in(exch, params->cycles, params->size, &duration); - if (rc) { - printf(NAME ": Test failed with error: %s\n", str_error(rc)); - return 1; - } - - puts("Test succeeded.\n"); - print_results(params, duration); - return 0; -} - -/** Run "interrupt out" burst test. - * @param[in] exch Open async exchange with the diagnostic device. - * @param[in] generic_params Test parameters. Must point to 'tmon_burst_test_params_t'. - * - * @return Exit code - */ -static int run_intr_out(async_exch_t *exch, const tmon_test_params_t *generic_params) -{ - const tmon_burst_test_params_t *params = (tmon_burst_test_params_t *) generic_params; - puts("Writing data to interrupt endpoint.\n"); - print_params(params); - - usbdiag_dur_t duration; - int rc = usbdiag_burst_intr_out(exch, params->cycles, params->size, &duration); - if (rc) { - printf(NAME ": Test failed with error: %s\n", str_error(rc)); - return 1; - } - - puts("Test succeeded.\n"); - print_results(params, duration); - return 0; -} - -/** Run "bulk in" burst test. - * @param[in] exch Open async exchange with the diagnostic device. - * @param[in] generic_params Test parameters. Must point to 'tmon_burst_test_params_t'. - * - * @return Exit code - */ -static int run_bulk_in(async_exch_t *exch, const tmon_test_params_t *generic_params) -{ - const tmon_burst_test_params_t *params = (tmon_burst_test_params_t *) generic_params; - puts("Reading data from bulk endpoint.\n"); - print_params(params); - - usbdiag_dur_t duration; - int rc = usbdiag_burst_bulk_in(exch, params->cycles, params->size, &duration); - if (rc) { - printf(NAME ": Test failed with error: %s\n", str_error(rc)); - return 1; - } - - puts("Test succeeded.\n"); - print_results(params, duration); - return 0; -} - -/** Run "bulk out" burst test. - * @param[in] exch Open async exchange with the diagnostic device. - * @param[in] generic_params Test parameters. Must point to 'tmon_burst_test_params_t'. - * - * @return Exit code - */ -static int run_bulk_out(async_exch_t *exch, const tmon_test_params_t *generic_params) -{ - const tmon_burst_test_params_t *params = (tmon_burst_test_params_t *) generic_params; - puts("Writing data to bulk endpoint.\n"); - print_params(params); - - usbdiag_dur_t duration; - int rc = usbdiag_burst_bulk_out(exch, params->cycles, params->size, &duration); - if (rc) { - printf(NAME ": Test failed with error: %s\n", str_error(rc)); - return 1; - } - - puts("Test succeeded.\n"); - print_results(params, duration); - return 0; -} - -/** Run "isochronous in" burst test. - * @param[in] exch Open async exchange with the diagnostic device. - * @param[in] generic_params Test parameters. Must point to 'tmon_burst_test_params_t'. - * - * @return Exit code - */ -static int run_isoch_in(async_exch_t *exch, const tmon_test_params_t *generic_params) -{ - const tmon_burst_test_params_t *params = (tmon_burst_test_params_t *) generic_params; - puts("Reading data from isochronous endpoint.\n"); - print_params(params); - - usbdiag_dur_t duration; - int rc = usbdiag_burst_isoch_in(exch, params->cycles, params->size, &duration); - if (rc) { - printf(NAME ": Test failed with error: %s\n", str_error(rc)); - return 1; - } - - puts("Test succeeded.\n"); - print_results(params, duration); - return 0; -} - -/** Run "isochronous out" burst test. - * @param[in] exch Open async exchange with the diagnostic device. - * @param[in] generic_params Test parameters. Must point to 'tmon_burst_test_params_t'. - * - * @return Exit code - */ -static int run_isoch_out(async_exch_t *exch, const tmon_test_params_t *generic_params) -{ - const tmon_burst_test_params_t *params = (tmon_burst_test_params_t *) generic_params; - puts("Writing data to isochronous endpoint.\n"); - print_params(params); - - usbdiag_dur_t duration; - int rc = usbdiag_burst_isoch_out(exch, params->cycles, params->size, &duration); - if (rc) { - printf(NAME ": Test failed with error: %s\n", str_error(rc)); - return 1; - } - - puts("Test succeeded.\n"); - print_results(params, duration); - return 0; -} - -/** Interrupt in burst test command handler. - * @param[in] argc Number of arguments. - * @param[in] argv Argument values. Must point to exactly `argc` strings. - * - * @return Exit code - */ -int tmon_burst_intr_in(int argc, char *argv[]) -{ - static const tmon_test_ops_t ops = { - .run = run_intr_in, - .read_params = read_params - }; - - return tmon_test_main(argc, argv, &ops); -} - -/** Interrupt out burst test command handler. - * @param[in] argc Number of arguments. - * @param[in] argv Argument values. Must point to exactly `argc` strings. - * - * @return Exit code - */ -int tmon_burst_intr_out(int argc, char *argv[]) -{ - static const tmon_test_ops_t ops = { - .run = run_intr_out, - .read_params = read_params - }; - - return tmon_test_main(argc, argv, &ops); -} - -/** Interrupt bulk burst test command handler. - * @param[in] argc Number of arguments. - * @param[in] argv Argument values. Must point to exactly `argc` strings. - * - * @return Exit code - */ -int tmon_burst_bulk_in(int argc, char *argv[]) -{ - static const tmon_test_ops_t ops = { - .run = run_bulk_in, - .read_params = read_params - }; - - return tmon_test_main(argc, argv, &ops); -} - -/** Bulk out burst test command handler. - * @param[in] argc Number of arguments. - * @param[in] argv Argument values. Must point to exactly `argc` strings. - * - * @return Exit code - */ -int tmon_burst_bulk_out(int argc, char *argv[]) -{ - static const tmon_test_ops_t ops = { - .run = run_bulk_out, - .read_params = read_params - }; - - return tmon_test_main(argc, argv, &ops); -} - -/** Isochronous in burst test command handler. - * @param[in] argc Number of arguments. - * @param[in] argv Argument values. Must point to exactly `argc` strings. - * - * @return Exit code - */ -int tmon_burst_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); -} - -/** Isochronous out burst test command handler. - * @param[in] argc Number of arguments. - * @param[in] argv Argument values. Must point to exactly `argc` strings. - * - * @return Exit code - */ -int tmon_burst_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); -} - -/** @} - */ Index: uspace/app/tmon/commands.h =================================================================== --- uspace/app/tmon/commands.h (revision e67c50ac9b5c850d056f789863dea7d4da95af3a) +++ uspace/app/tmon/commands.h (revision 64ce0c1435496748632f7682b2657fdc79aad634) @@ -42,11 +42,11 @@ int tmon_list(int, char **); -/* Burst tests read/write into endpoints as fast as possible. */ -int tmon_burst_intr_in(int, char **); -int tmon_burst_intr_out(int, char **); -int tmon_burst_bulk_in(int, char **); -int tmon_burst_bulk_out(int, char **); -int tmon_burst_isoch_in(int, char **); -int tmon_burst_isoch_out(int, char **); +/* Tests commands differ by endpoint types. */ +int tmon_test_intr_in(int, char **); +int tmon_test_intr_out(int, char **); +int tmon_test_bulk_in(int, char **); +int tmon_test_bulk_out(int, char **); +int tmon_test_isoch_in(int, char **); +int tmon_test_isoch_out(int, char **); #endif /* TMON_COMMANDS_H_ */ Index: uspace/app/tmon/main.c =================================================================== --- uspace/app/tmon/main.c (revision e67c50ac9b5c850d056f789863dea7d4da95af3a) +++ uspace/app/tmon/main.c (revision 64ce0c1435496748632f7682b2657fdc79aad634) @@ -64,31 +64,31 @@ .name = "test-intr-in", .description = "Read from interrupt endpoint as fast as possible.", - .action = tmon_burst_intr_in, + .action = tmon_test_intr_in, }, { .name = "test-intr-out", .description = "Write to interrupt endpoint as fast as possible.", - .action = tmon_burst_intr_out, + .action = tmon_test_intr_out, }, { .name = "test-bulk-in", .description = "Read from bulk endpoint as fast as possible.", - .action = tmon_burst_bulk_in, + .action = tmon_test_bulk_in, }, { .name = "test-bulk-out", .description = "Write to bulk endpoint as fast as possible.", - .action = tmon_burst_bulk_out, + .action = tmon_test_bulk_out, }, { .name = "test-isoch-in", .description = "Read from isochronous endpoint as fast as possible.", - .action = tmon_burst_isoch_in, + .action = tmon_test_isoch_in, }, { .name = "test-isoch-out", .description = "Write to isochronous endpoint as fast as possible.", - .action = tmon_burst_isoch_out, - } + .action = tmon_test_isoch_out, + }, }; @@ -106,13 +106,18 @@ static tmon_opt_t options[] = { { - .long_name = "cycles", - .short_name = 'n', - .description = "Set the number of read/write cycles." + .long_name = "duration", + .short_name = 't', + .description = "Set the minimum test duration (in seconds)." }, { .long_name = "size", .short_name = 's', - .description = "Set the data size transferred in a single cycle." - } + .description = "Set the data size (in bytes) transferred in a single cycle." + }, + { + .long_name = "validate", + .short_name = 'v', + .description = "Validate the correctness of transferred data (impacts performance)." + }, }; Index: uspace/app/tmon/tests.c =================================================================== --- uspace/app/tmon/tests.c (revision 64ce0c1435496748632f7682b2657fdc79aad634) +++ uspace/app/tmon/tests.c (revision 64ce0c1435496748632f7682b2657fdc79aad634) @@ -0,0 +1,338 @@ +/* + * Copyright (c) 2017 Petr Manek + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tmon + * @{ + */ +/** + * @file + * USB tests. + */ + +#include +#include +#include +#include +#include +#include +#include +#include "commands.h" +#include "tf.h" + +#define NAME "tmon" +#define INDENT " " + +/** Static array of long options, from which test parameters are parsed. */ +static struct option long_options[] = { + {"duration", required_argument, NULL, 't'}, + {"size", required_argument, NULL, 's'}, + {"validate", required_argument, NULL, 'v'}, + {0, 0, NULL, 0} +}; + +/** String of short options, from which test parameters are parsed. */ +static const char *short_options = "t:s:v"; + +/** Common option parser for all tests. + * @param[in] argc Number of arguments. + * @param[in] argv Argument values. Must point to exactly `argc` strings. + * @param[out] params Parsed test parameters (if successful). + * + * @return EOK if successful (in such case caller becomes the owner of `params`). + */ +static int read_params(int argc, char *argv[], void **params) +{ + int rc; + usbdiag_test_params_t *p = (usbdiag_test_params_t *) malloc(sizeof(usbdiag_test_params_t)); + if (!p) + return ENOMEM; + + // Default values. + p->transfer_size = 0; + p->min_duration = 5000; + p->validate_data = false; + + // Parse other than default values. + int c; + uint32_t duration_uint; + for (c = 0, optreset = 1, optind = 0; c != -1;) { + c = getopt_long(argc, argv, short_options, long_options, NULL); + switch (c) { + case -1: + break; + case 'v': + p->validate_data = true; + break; + case 't': + if (!optarg || str_uint32_t(optarg, NULL, 10, false, &duration_uint) != EOK) { + puts(NAME ": Invalid duration.\n"); + rc = EINVAL; + goto err_malloc; + } + p->min_duration = (usbdiag_dur_t) duration_uint * 1000; + break; + case 's': + if (!optarg || str_size_t(optarg, NULL, 10, false, &p->transfer_size) != EOK) { + puts(NAME ": Invalid data size.\n"); + rc = EINVAL; + goto err_malloc; + } + break; + } + } + + *params = (void *) p; + return EOK; + +err_malloc: + free(p); + *params = NULL; + return rc; +} + +/** Print test parameters. + * @param[in] params Test parameters to print. + */ +static void print_params(const usbdiag_test_params_t *params) +{ + printf("Endpoint type: %s\n", usb_str_transfer_type(params->transfer_type)); + char *str_min_duration = tmon_format_duration(params->min_duration, "%.3f %s"); + printf("Min. duration: %s\n", str_min_duration); + free(str_min_duration); + + if (params->transfer_size) { + char *str_size = tmon_format_size(params->transfer_size, "%.3f %s"); + printf("Transfer size: %s\n", str_size); + free(str_size); + } else { + printf("Transfer size: (max. transfer size)\n"); + } + + printf("Validate data: %s\n", params->validate_data ? "yes" : "no"); +} + +/** Print test results. + * @param[in] params Test parameters. + * @param[in] results Test results. + */ +static void print_results(const usbdiag_test_params_t *params, const usbdiag_test_results_t *results) +{ + printf("Transfers performed: %u\n", results->transfer_count); + + char *str_total_duration = tmon_format_duration(results->act_duration, "%.3f %s"); + printf("Total duration: %s\n", str_total_duration); + free(str_total_duration); + + char *str_size_per_transfer = tmon_format_size(results->transfer_size, "%.3f %s"); + printf("Transfer size: %s\n", str_size_per_transfer); + free(str_size_per_transfer); + + const size_t total_size = results->transfer_size * results->transfer_count; + char *str_total_size = tmon_format_size(total_size, "%.3f %s"); + printf("Total size: %s\n", str_total_size); + free(str_total_size); + + const double dur_per_transfer = (double) results->act_duration / (double) results->transfer_count; + char *str_dur_per_transfer = tmon_format_duration(dur_per_transfer, "%.3f %s"); + printf("Avg. transfer duration: %s\n", str_dur_per_transfer); + free(str_dur_per_transfer); + + const double speed = 1000.0 * (double) total_size / (double) results->act_duration; + char *str_speed = tmon_format_size(speed, "%.3f %s/s"); + printf("Avg. speed: %s\n", str_speed); + free(str_speed); +} + +/** Run test on "in" endpoint. + * @param[in] exch Open async exchange with the diagnostic device. + * @param[in] generic_params Test parameters. Must point to 'usbdiag_test_params_t'. + * + * @return Exit code + */ +static int test_in(async_exch_t *exch, const void *generic_params) +{ + const usbdiag_test_params_t *params = (usbdiag_test_params_t *) generic_params; + print_params(params); + puts("\nTesting... "); + + usbdiag_test_results_t results; + int rc = usbdiag_test_in(exch, params, &results); + if (rc != EOK) { + puts("failed\n"); + printf(NAME ": %s\n", str_error(rc)); + return 1; + } + + puts("succeeded\n\n"); + print_results(params, &results); + return 0; +} + +/** Run test on "out" endpoint. + * @param[in] exch Open async exchange with the diagnostic device. + * @param[in] generic_params Test parameters. Must point to 'usbdiag_test_params_t'. + * + * @return Exit code + */ +static int test_out(async_exch_t *exch, const void *generic_params) +{ + const usbdiag_test_params_t *params = (usbdiag_test_params_t *) generic_params; + print_params(params); + puts("\nTesting... "); + + usbdiag_test_results_t results; + int rc = usbdiag_test_out(exch, params, &results); + if (rc) { + puts("failed\n"); + printf(NAME ": %s\n", str_error(rc)); + return 1; + } + + puts("succeeded\n\n"); + print_results(params, &results); + return 0; +} + +#define GEN_PRE_RUN(FN, TYPE) \ + static int pre_run_##FN(void *generic_params) \ + { \ + usbdiag_test_params_t *params = (usbdiag_test_params_t *) generic_params; \ + params->transfer_type = USB_TRANSFER_##TYPE; \ + return EOK; \ + } + +GEN_PRE_RUN(intr, INTERRUPT) +GEN_PRE_RUN(bulk, BULK) +GEN_PRE_RUN(isoch, ISOCHRONOUS) + +#undef GEN_PRE_RUN + +/** Interrupt in test command handler. + * @param[in] argc Number of arguments. + * @param[in] argv Argument values. Must point to exactly `argc` strings. + * + * @return Exit code + */ +int tmon_test_intr_in(int argc, char *argv[]) +{ + static const tmon_test_ops_t ops = { + .pre_run = pre_run_intr, + .run = test_in, + .read_params = read_params + }; + + return tmon_test_main(argc, argv, &ops); +} + +/** Interrupt out test command handler. + * @param[in] argc Number of arguments. + * @param[in] argv Argument values. Must point to exactly `argc` strings. + * + * @return Exit code + */ +int tmon_test_intr_out(int argc, char *argv[]) +{ + static const tmon_test_ops_t ops = { + .pre_run = pre_run_intr, + .run = test_out, + .read_params = read_params + }; + + return tmon_test_main(argc, argv, &ops); +} + +/** Interrupt bulk test command handler. + * @param[in] argc Number of arguments. + * @param[in] argv Argument values. Must point to exactly `argc` strings. + * + * @return Exit code + */ +int tmon_test_bulk_in(int argc, char *argv[]) +{ + static const tmon_test_ops_t ops = { + .pre_run = pre_run_bulk, + .run = test_in, + .read_params = read_params + }; + + return tmon_test_main(argc, argv, &ops); +} + +/** Bulk out test command handler. + * @param[in] argc Number of arguments. + * @param[in] argv Argument values. Must point to exactly `argc` strings. + * + * @return Exit code + */ +int tmon_test_bulk_out(int argc, char *argv[]) +{ + static const tmon_test_ops_t ops = { + .pre_run = pre_run_bulk, + .run = test_out, + .read_params = read_params + }; + + return tmon_test_main(argc, argv, &ops); +} + +/** Isochronous in test command handler. + * @param[in] argc Number of arguments. + * @param[in] argv Argument values. Must point to exactly `argc` strings. + * + * @return Exit code + */ +int tmon_test_isoch_in(int argc, char *argv[]) +{ + static const tmon_test_ops_t ops = { + .pre_run = pre_run_isoch, + .run = test_in, + .read_params = read_params + }; + + return tmon_test_main(argc, argv, &ops); +} + +/** Isochronous out test command handler. + * @param[in] argc Number of arguments. + * @param[in] argv Argument values. Must point to exactly `argc` strings. + * + * @return Exit code + */ +int tmon_test_isoch_out(int argc, char *argv[]) +{ + static const tmon_test_ops_t ops = { + .pre_run = pre_run_isoch, + .run = test_out, + .read_params = read_params + }; + + return tmon_test_main(argc, argv, &ops); +} + +/** @} + */ Index: uspace/app/tmon/tf.c =================================================================== --- uspace/app/tmon/tf.c (revision e67c50ac9b5c850d056f789863dea7d4da95af3a) +++ uspace/app/tmon/tf.c (revision 64ce0c1435496748632f7682b2657fdc79aad634) @@ -36,4 +36,5 @@ #include +#include #include #include @@ -74,10 +75,15 @@ } - printf("Using device: %s\n", path); + printf("Device: %s\n", path); // Read test parameters from options. - tmon_test_params_t *params = NULL; + void *params = NULL; if ((rc = ops->read_params(argc, argv, ¶ms))) { printf(NAME ": Reading test parameters failed. %s\n", str_error(rc)); + return 1; + } + + if ((rc = ops->pre_run(params))) { + printf(NAME ": Pre-run hook failed. %s\n", str_error(rc)); return 1; } @@ -106,4 +112,73 @@ } +/** Unit of quantity used for pretty formatting. */ +typedef struct tmon_unit { + /** Prefix letter, which is printed before the actual unit. */ + const char *unit; + /** Factor of the unit. */ + double factor; +} tmon_unit_t; + +/** Format a value for human reading. + * @param[in] val The value to format. + * @param[in] fmt Format string. Must include one double and char. + * + * @return Heap-allocated string if successful (caller becomes its owner), NULL otherwise. + */ +static char *format_unit(double val, const char *fmt, const tmon_unit_t *units, size_t len) +{ + // Figure out the "tightest" unit. + unsigned i; + for (i = 0; i < len; ++i) { + if (units[i].factor <= val) + break; + } + + if (i == len) --i; + const char *unit = units[i].unit; + double factor = units[i].factor; + + // Format the size. + const double div_size = val / factor; + + char *out = NULL; + asprintf(&out, fmt, div_size, unit); + + return out; +} + +/** Static array of size units with decreasing factors. */ +static const tmon_unit_t size_units[] = { + { .unit = "EB", .factor = 1ULL << 60 }, + { .unit = "PB", .factor = 1ULL << 50 }, + { .unit = "TB", .factor = 1ULL << 40 }, + { .unit = "GB", .factor = 1ULL << 30 }, + { .unit = "MB", .factor = 1ULL << 20 }, + { .unit = "kB", .factor = 1ULL << 10 }, + { .unit = "B", .factor = 1ULL }, +}; + +char *tmon_format_size(double val, const char *fmt) +{ + return format_unit(val, fmt, size_units, ARRAY_SIZE(size_units)); +} + +/** Static array of duration units with decreasing factors. */ +static const tmon_unit_t dur_units[] = { + { .unit = "d", .factor = 60 * 60 * 24 }, + { .unit = "h", .factor = 60 * 60 }, + { .unit = "min", .factor = 60 }, + { .unit = "s", .factor = 1 }, + { .unit = "ms", .factor = 1e-3 }, + { .unit = "us", .factor = 1e-6 }, + { .unit = "ns", .factor = 1e-9 }, + { .unit = "ps", .factor = 1e-12 }, +}; + +char *tmon_format_duration(usbdiag_dur_t val, const char *fmt) +{ + return format_unit(val / 1000.0, fmt, dur_units, ARRAY_SIZE(dur_units)); +} + /** @} */ Index: uspace/app/tmon/tf.h =================================================================== --- uspace/app/tmon/tf.h (revision e67c50ac9b5c850d056f789863dea7d4da95af3a) +++ uspace/app/tmon/tf.h (revision 64ce0c1435496748632f7682b2657fdc79aad634) @@ -38,17 +38,17 @@ #include - -/** Parameters common for all tests. */ -typedef struct tmon_test_params { - /* Nothing here. */ -} tmon_test_params_t; +#include /** Operations to implement by all tests. */ typedef struct tmon_test_ops { - int (*run)(async_exch_t *, const tmon_test_params_t *); - int (*read_params)(int, char **, tmon_test_params_t **); + int (*pre_run)(void *); + int (*run)(async_exch_t *, const void *); + int (*read_params)(int, char **, void **); } tmon_test_ops_t; int tmon_test_main(int, char **, const tmon_test_ops_t *); + +char *tmon_format_size(double, const char *); +char *tmon_format_duration(usbdiag_dur_t, const char *); #endif /* TMON_TF_H_ */ Index: uspace/drv/bus/usb/usbdiag/device.c =================================================================== --- uspace/drv/bus/usb/usbdiag/device.c (revision e67c50ac9b5c850d056f789863dea7d4da95af3a) +++ uspace/drv/bus/usb/usbdiag/device.c (revision 64ce0c1435496748632f7682b2657fdc79aad634) @@ -46,16 +46,6 @@ static usbdiag_iface_t diag_interface = { - .burst_intr_in = usbdiag_burst_test_intr_in, - .burst_intr_out = usbdiag_burst_test_intr_out, - .burst_bulk_in = usbdiag_burst_test_bulk_in, - .burst_bulk_out = usbdiag_burst_test_bulk_out, - .burst_isoch_in = usbdiag_burst_test_isoch_in, - .burst_isoch_out = usbdiag_burst_test_isoch_out, - .data_intr_in = usbdiag_data_test_intr_in, - .data_intr_out = usbdiag_data_test_intr_out, - .data_bulk_in = usbdiag_data_test_bulk_in, - .data_bulk_out = usbdiag_data_test_bulk_out, - .data_isoch_in = usbdiag_data_test_isoch_in, - .data_isoch_out = usbdiag_data_test_isoch_out + .test_in = usbdiag_dev_test_in, + .test_out = usbdiag_dev_test_out, }; @@ -86,10 +76,16 @@ } while (0); - _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); + _MAP_EP(dev->burst_intr_in, BURST_INTR_IN); + _MAP_EP(dev->burst_intr_out, BURST_INTR_OUT); + _MAP_EP(dev->burst_bulk_in, BURST_BULK_IN); + _MAP_EP(dev->burst_bulk_out, BURST_BULK_OUT); + _MAP_EP(dev->burst_isoch_in, BURST_ISOCH_IN); + _MAP_EP(dev->burst_isoch_out, BURST_ISOCH_OUT); + _MAP_EP(dev->data_intr_in, DATA_INTR_IN); + _MAP_EP(dev->data_intr_out, DATA_INTR_OUT); + _MAP_EP(dev->data_bulk_in, DATA_BULK_IN); + _MAP_EP(dev->data_bulk_out, DATA_BULK_OUT); + _MAP_EP(dev->data_isoch_in, DATA_ISOCH_IN); + _MAP_EP(dev->data_isoch_out, DATA_ISOCH_OUT); #undef _MAP_EP Index: uspace/drv/bus/usb/usbdiag/device.h =================================================================== --- uspace/drv/bus/usb/usbdiag/device.h (revision e67c50ac9b5c850d056f789863dea7d4da95af3a) +++ uspace/drv/bus/usb/usbdiag/device.h (revision 64ce0c1435496748632f7682b2657fdc79aad634) @@ -40,10 +40,17 @@ #include -#define USBDIAG_EP_INTR_IN 1 -#define USBDIAG_EP_INTR_OUT 2 -#define USBDIAG_EP_BULK_IN 3 -#define USBDIAG_EP_BULK_OUT 4 -#define USBDIAG_EP_ISOCH_IN 5 -#define USBDIAG_EP_ISOCH_OUT 6 +#define USBDIAG_EP_BURST_INTR_IN 1 +#define USBDIAG_EP_BURST_INTR_OUT 2 +#define USBDIAG_EP_BURST_BULK_IN 3 +#define USBDIAG_EP_BURST_BULK_OUT 4 +#define USBDIAG_EP_BURST_ISOCH_IN 5 +#define USBDIAG_EP_BURST_ISOCH_OUT 6 + +#define USBDIAG_EP_DATA_INTR_IN 7 +#define USBDIAG_EP_DATA_INTR_OUT 8 +#define USBDIAG_EP_DATA_BULK_IN 9 +#define USBDIAG_EP_DATA_BULK_OUT 10 +#define USBDIAG_EP_DATA_ISOCH_IN 11 +#define USBDIAG_EP_DATA_ISOCH_OUT 12 /** @@ -53,10 +60,19 @@ 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_pipe_t *burst_intr_in; + usb_pipe_t *burst_intr_out; + usb_pipe_t *burst_bulk_in; + usb_pipe_t *burst_bulk_out; + usb_pipe_t *burst_isoch_in; + usb_pipe_t *burst_isoch_out; + + usb_pipe_t *data_intr_in; + usb_pipe_t *data_intr_out; + usb_pipe_t *data_bulk_in; + usb_pipe_t *data_bulk_out; + usb_pipe_t *data_isoch_in; + usb_pipe_t *data_isoch_out; + } usbdiag_dev_t; Index: uspace/drv/bus/usb/usbdiag/main.c =================================================================== --- uspace/drv/bus/usb/usbdiag/main.c (revision e67c50ac9b5c850d056f789863dea7d4da95af3a) +++ uspace/drv/bus/usb/usbdiag/main.c (revision 64ce0c1435496748632f7682b2657fdc79aad634) @@ -139,45 +139,93 @@ } -static const usb_endpoint_description_t intr_in_ep = { - .transfer_type = USB_TRANSFER_INTERRUPT, - .direction = USB_DIRECTION_IN, - .interface_class = USB_CLASS_DIAGNOSTIC, - .interface_subclass = 0x00, - .interface_protocol = 0x01, - .flags = 0 -}; -static const usb_endpoint_description_t intr_out_ep = { - .transfer_type = USB_TRANSFER_INTERRUPT, - .direction = USB_DIRECTION_OUT, - .interface_class = USB_CLASS_DIAGNOSTIC, - .interface_subclass = 0x00, - .interface_protocol = 0x01, - .flags = 0 -}; -static const usb_endpoint_description_t bulk_in_ep = { - .transfer_type = USB_TRANSFER_BULK, - .direction = USB_DIRECTION_IN, - .interface_class = USB_CLASS_DIAGNOSTIC, - .interface_subclass = 0x00, - .interface_protocol = 0x01, - .flags = 0 -}; -static const usb_endpoint_description_t bulk_out_ep = { - .transfer_type = USB_TRANSFER_BULK, - .direction = USB_DIRECTION_OUT, - .interface_class = USB_CLASS_DIAGNOSTIC, - .interface_subclass = 0x00, - .interface_protocol = 0x01, - .flags = 0 -}; -static const usb_endpoint_description_t isoch_in_ep = { - .transfer_type = USB_TRANSFER_ISOCHRONOUS, - .direction = USB_DIRECTION_IN, - .interface_class = USB_CLASS_DIAGNOSTIC, - .interface_subclass = 0x00, - .interface_protocol = 0x01, - .flags = 0 -}; -static const usb_endpoint_description_t isoch_out_ep = { +static const usb_endpoint_description_t burst_intr_in_ep = { + .transfer_type = USB_TRANSFER_INTERRUPT, + .direction = USB_DIRECTION_IN, + .interface_class = USB_CLASS_DIAGNOSTIC, + .interface_subclass = 0x00, + .interface_protocol = 0x01, + .flags = 0 +}; +static const usb_endpoint_description_t burst_intr_out_ep = { + .transfer_type = USB_TRANSFER_INTERRUPT, + .direction = USB_DIRECTION_OUT, + .interface_class = USB_CLASS_DIAGNOSTIC, + .interface_subclass = 0x00, + .interface_protocol = 0x01, + .flags = 0 +}; +static const usb_endpoint_description_t burst_bulk_in_ep = { + .transfer_type = USB_TRANSFER_BULK, + .direction = USB_DIRECTION_IN, + .interface_class = USB_CLASS_DIAGNOSTIC, + .interface_subclass = 0x00, + .interface_protocol = 0x01, + .flags = 0 +}; +static const usb_endpoint_description_t burst_bulk_out_ep = { + .transfer_type = USB_TRANSFER_BULK, + .direction = USB_DIRECTION_OUT, + .interface_class = USB_CLASS_DIAGNOSTIC, + .interface_subclass = 0x00, + .interface_protocol = 0x01, + .flags = 0 +}; +static const usb_endpoint_description_t burst_isoch_in_ep = { + .transfer_type = USB_TRANSFER_ISOCHRONOUS, + .direction = USB_DIRECTION_IN, + .interface_class = USB_CLASS_DIAGNOSTIC, + .interface_subclass = 0x00, + .interface_protocol = 0x01, + .flags = 0 +}; +static const usb_endpoint_description_t burst_isoch_out_ep = { + .transfer_type = USB_TRANSFER_ISOCHRONOUS, + .direction = USB_DIRECTION_OUT, + .interface_class = USB_CLASS_DIAGNOSTIC, + .interface_subclass = 0x00, + .interface_protocol = 0x01, + .flags = 0 +}; +static const usb_endpoint_description_t data_intr_in_ep = { + .transfer_type = USB_TRANSFER_INTERRUPT, + .direction = USB_DIRECTION_IN, + .interface_class = USB_CLASS_DIAGNOSTIC, + .interface_subclass = 0x00, + .interface_protocol = 0x01, + .flags = 0 +}; +static const usb_endpoint_description_t data_intr_out_ep = { + .transfer_type = USB_TRANSFER_INTERRUPT, + .direction = USB_DIRECTION_OUT, + .interface_class = USB_CLASS_DIAGNOSTIC, + .interface_subclass = 0x00, + .interface_protocol = 0x01, + .flags = 0 +}; +static const usb_endpoint_description_t data_bulk_in_ep = { + .transfer_type = USB_TRANSFER_BULK, + .direction = USB_DIRECTION_IN, + .interface_class = USB_CLASS_DIAGNOSTIC, + .interface_subclass = 0x00, + .interface_protocol = 0x01, + .flags = 0 +}; +static const usb_endpoint_description_t data_bulk_out_ep = { + .transfer_type = USB_TRANSFER_BULK, + .direction = USB_DIRECTION_OUT, + .interface_class = USB_CLASS_DIAGNOSTIC, + .interface_subclass = 0x00, + .interface_protocol = 0x01, + .flags = 0 +}; +static const usb_endpoint_description_t data_isoch_in_ep = { + .transfer_type = USB_TRANSFER_ISOCHRONOUS, + .direction = USB_DIRECTION_IN, + .interface_class = USB_CLASS_DIAGNOSTIC, + .interface_subclass = 0x00, + .interface_protocol = 0x01, + .flags = 0 +}; +static const usb_endpoint_description_t data_isoch_out_ep = { .transfer_type = USB_TRANSFER_ISOCHRONOUS, .direction = USB_DIRECTION_OUT, @@ -189,10 +237,16 @@ static const usb_endpoint_description_t *diag_endpoints[] = { - [USBDIAG_EP_INTR_IN] = &intr_in_ep, - [USBDIAG_EP_INTR_OUT] = &intr_out_ep, - [USBDIAG_EP_BULK_IN] = &bulk_in_ep, - [USBDIAG_EP_BULK_OUT] = &bulk_out_ep, - [USBDIAG_EP_ISOCH_IN] = &isoch_in_ep, - [USBDIAG_EP_ISOCH_OUT] = &isoch_out_ep, + [USBDIAG_EP_BURST_INTR_IN] = &burst_intr_in_ep, + [USBDIAG_EP_BURST_INTR_OUT] = &burst_intr_out_ep, + [USBDIAG_EP_BURST_BULK_IN] = &burst_bulk_in_ep, + [USBDIAG_EP_BURST_BULK_OUT] = &burst_bulk_out_ep, + [USBDIAG_EP_BURST_ISOCH_IN] = &burst_isoch_in_ep, + [USBDIAG_EP_BURST_ISOCH_OUT] = &burst_isoch_out_ep, + [USBDIAG_EP_DATA_INTR_IN] = &data_intr_in_ep, + [USBDIAG_EP_DATA_INTR_OUT] = &data_intr_out_ep, + [USBDIAG_EP_DATA_BULK_IN] = &data_bulk_in_ep, + [USBDIAG_EP_DATA_BULK_OUT] = &data_bulk_out_ep, + [USBDIAG_EP_DATA_ISOCH_IN] = &data_isoch_in_ep, + [USBDIAG_EP_DATA_ISOCH_OUT] = &data_isoch_out_ep, NULL }; Index: uspace/drv/bus/usb/usbdiag/tests.c =================================================================== --- uspace/drv/bus/usb/usbdiag/tests.c (revision e67c50ac9b5c850d056f789863dea7d4da95af3a) +++ uspace/drv/bus/usb/usbdiag/tests.c (revision 64ce0c1435496748632f7682b2657fdc79aad634) @@ -44,10 +44,22 @@ #define NAME "usbdiag" -static int burst_in_test(usb_pipe_t *pipe, int cycles, size_t size, usbdiag_dur_t *duration) +static const uint32_t test_data_src = 0xDEADBEEF; + +static int test_in(usb_pipe_t *pipe, const usbdiag_test_params_t *params, usbdiag_test_results_t *results) { if (!pipe) return EBADMEM; - char *buffer = usb_pipe_alloc_buffer(pipe, size); + bool validate = params->validate_data; + size_t size = params->transfer_size; + if (!size) + size = pipe->desc.max_transfer_size; + + const uint32_t test_data = uint32_host2usb(test_data_src); + if (validate && size % sizeof(test_data)) + return EINVAL; + + size_t test_data_size = size / sizeof(test_data); + char *buffer = (char *) malloc(size); if (!buffer) return ENOMEM; @@ -55,11 +67,19 @@ // TODO: Are we sure that no other test is running on this endpoint? - usb_log_info("Performing %s IN burst test.", usb_str_transfer_type(pipe->desc.transfer_type)); + usb_log_info("Performing %s IN test with duration %ld ms.", usb_str_transfer_type(pipe->desc.transfer_type), params->min_duration); int rc = EOK; - struct timeval start_time; + uint32_t transfer_count = 0; + + struct timeval start_time, final_time, stop_time; gettimeofday(&start_time, NULL); - - for (int i = 0; i < cycles; ++i) { + gettimeofday(&stop_time, NULL); + + tv_add_diff(&stop_time, params->min_duration * 1000); + gettimeofday(&final_time, NULL); + + while (!tv_gt(&final_time, &stop_time)) { + ++transfer_count; + // Read device's response. size_t remaining = size; @@ -83,24 +103,53 @@ if (rc) break; - } - - struct timeval final_time; - gettimeofday(&final_time, NULL); + + if (validate) { + uint32_t *beef_buffer = (uint32_t *) buffer; + + /* Check if the beef is really dead. */ + for (size_t i = 0; i < test_data_size; ++i) { + if (beef_buffer[i] != test_data) { + usb_log_error("Read of %s IN endpoint returned " + "invalid data at address %zu. [ 0x%X != 0x%X ]", + usb_str_transfer_type(pipe->desc.transfer_type), i * sizeof(test_data), beef_buffer[i], test_data); + rc = EINVAL; + } + } + + if (rc) + break; + } + + gettimeofday(&final_time, NULL); + } + usbdiag_dur_t in_duration = ((final_time.tv_usec - start_time.tv_usec) / 1000) + ((final_time.tv_sec - start_time.tv_sec) * 1000); - usb_log_info("Burst test on %s IN endpoint completed in %lu ms.", usb_str_transfer_type(pipe->desc.transfer_type), in_duration); - - usb_pipe_free_buffer(pipe, buffer); - if (duration) - *duration = in_duration; + usb_log_info("Test on %s IN endpoint completed in %lu ms.", usb_str_transfer_type(pipe->desc.transfer_type), in_duration); + + results->act_duration = in_duration; + results->transfer_count = transfer_count; + results->transfer_size = size; + + free(buffer); return rc; } -static int burst_out_test(usb_pipe_t *pipe, int cycles, size_t size, usbdiag_dur_t *duration) +static int test_out(usb_pipe_t *pipe, const usbdiag_test_params_t *params, usbdiag_test_results_t *results) { if (!pipe) return EBADMEM; + + bool validate = params->validate_data; + size_t size = params->transfer_size; + if (!size) + size = pipe->desc.max_transfer_size; + + const uint32_t test_data = uint32_host2usb(test_data_src); + + if (validate && size % sizeof(test_data)) + return EINVAL; char *buffer = usb_pipe_alloc_buffer(pipe, size); @@ -108,15 +157,27 @@ return ENOMEM; - memset(buffer, 42, size); + if (validate) { + for (size_t i = 0; i < size; i += sizeof(test_data)) { + memcpy(buffer + i, &test_data, sizeof(test_data)); + } + } // TODO: Are we sure that no other test is running on this endpoint? - usb_log_info("Performing %s OUT burst test.", usb_str_transfer_type(pipe->desc.transfer_type)); + usb_log_info("Performing %s OUT test.", usb_str_transfer_type(pipe->desc.transfer_type)); int rc = EOK; - struct timeval start_time; + uint32_t transfer_count = 0; + + struct timeval start_time, final_time, stop_time; gettimeofday(&start_time, NULL); - - for (int i = 0; i < cycles; ++i) { + gettimeofday(&stop_time, NULL); + + tv_add_diff(&stop_time, params->min_duration * 1000); + gettimeofday(&final_time, NULL); + + while (!tv_gt(&final_time, &stop_time)) { + ++transfer_count; + // Write buffer to device. if ((rc = usb_pipe_write_dma(pipe, buffer, size))) { @@ -124,144 +185,23 @@ break; } - } - - struct timeval final_time; - gettimeofday(&final_time, NULL); + + gettimeofday(&final_time, NULL); + } + usbdiag_dur_t in_duration = ((final_time.tv_usec - start_time.tv_usec) / 1000) + ((final_time.tv_sec - start_time.tv_sec) * 1000); - usb_log_info("Burst test on %s OUT endpoint completed in %ld ms.", usb_str_transfer_type(pipe->desc.transfer_type), in_duration); - - usb_pipe_free_buffer(pipe, buffer); - if (duration) - *duration = in_duration; + usb_log_info("Test on %s OUT endpoint completed in %ld ms.", usb_str_transfer_type(pipe->desc.transfer_type), in_duration); + + results->act_duration = in_duration; + results->transfer_count = transfer_count; + results->transfer_size = size; + + free(buffer); return rc; } -static const uint32_t test_data_src = 0xDEADBEEF; - -static int data_in_test(usb_pipe_t *pipe, int cycles, size_t size, usbdiag_dur_t *duration) -{ - if (!pipe) - return EBADMEM; - - const uint32_t test_data = uint32_host2usb(test_data_src); - - if (size % sizeof(test_data)) - return EINVAL; - - char *buffer = usb_pipe_alloc_buffer(pipe, size); - if (!buffer) - return ENOMEM; - - // TODO: Are we sure that no other test is running on this endpoint? - - usb_log_info("Performing %s IN data test.", usb_str_transfer_type(pipe->desc.transfer_type)); - - int rc = EOK; - struct timeval start_time; - gettimeofday(&start_time, NULL); - - 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_dma(pipe, buffer + size - remaining, remaining, &transferred))) { - usb_log_error("Read of %s IN endpoint failed with error: %s", usb_str_transfer_type(pipe->desc.transfer_type), str_error(rc)); - break; - } - - if (transferred > remaining) { - usb_log_error("Read of %s IN endpoint returned more data than expected.", usb_str_transfer_type(pipe->desc.transfer_type)); - rc = EINVAL; - break; - } - - remaining -= transferred; - } - - if (rc) - break; - - for (size_t i = 0; i < size; i += sizeof(test_data)) { - if (*(uint32_t *)(buffer + i) != test_data) { - usb_log_error("Read of %s IN endpoint returned " - "invald data at address %zu.", - usb_str_transfer_type(pipe->desc.transfer_type), i); - rc = EINVAL; - break; - } - } - - if (rc) - break; - } - - struct timeval final_time; - gettimeofday(&final_time, NULL); - usbdiag_dur_t in_duration = ((final_time.tv_usec - start_time.tv_usec) / 1000) + - ((final_time.tv_sec - start_time.tv_sec) * 1000); - - usb_log_info("Data test on %s IN endpoint completed in %lu ms.", usb_str_transfer_type(pipe->desc.transfer_type), in_duration); - - usb_pipe_free_buffer(pipe, buffer); - if (duration) - *duration = in_duration; - - return rc; -} - -static int data_out_test(usb_pipe_t *pipe, int cycles, size_t size, usbdiag_dur_t *duration) -{ - if (!pipe) - return EBADMEM; - - const uint32_t test_data = uint32_host2usb(test_data_src); - - if (size % sizeof(test_data)) - return EINVAL; - - char *buffer = usb_pipe_alloc_buffer(pipe, size); - if (!buffer) - return ENOMEM; - - for (size_t i = 0; i < size; i += sizeof(test_data)) { - memcpy(buffer + i, &test_data, sizeof(test_data)); - } - - // TODO: Are we sure that no other test is running on this endpoint? - - usb_log_info("Performing %s OUT data test.", usb_str_transfer_type(pipe->desc.transfer_type)); - - int rc = EOK; - struct timeval start_time; - gettimeofday(&start_time, NULL); - - for (int i = 0; i < cycles; ++i) { - // Write buffer to device. - if ((rc = usb_pipe_write_dma(pipe, buffer, size))) { - usb_log_error("Write to %s OUT endpoint failed with error: %s", usb_str_transfer_type(pipe->desc.transfer_type), str_error(rc)); - break; - } - } - - struct timeval final_time; - gettimeofday(&final_time, NULL); - usbdiag_dur_t in_duration = ((final_time.tv_usec - start_time.tv_usec) / 1000) + - ((final_time.tv_sec - start_time.tv_sec) * 1000); - - usb_log_info("Data test on %s OUT endpoint completed in %ld ms.", usb_str_transfer_type(pipe->desc.transfer_type), in_duration); - - usb_pipe_free_buffer(pipe, buffer); - if (duration) - *duration = in_duration; - - return rc; -} - -int usbdiag_burst_test_intr_in(ddf_fun_t *fun, int cycles, size_t size, usbdiag_dur_t *duration) +int usbdiag_dev_test_in(ddf_fun_t *fun, const usbdiag_test_params_t *params, usbdiag_test_results_t *results) { usbdiag_dev_t *dev = ddf_fun_to_usbdiag_dev(fun); @@ -269,8 +209,24 @@ return EBADMEM; - return burst_in_test(dev->intr_in, cycles, size, duration); -} - -int usbdiag_burst_test_intr_out(ddf_fun_t *fun, int cycles, size_t size, usbdiag_dur_t *duration) + usb_pipe_t *pipe; + + switch (params->transfer_type) { + case USB_TRANSFER_INTERRUPT: + pipe = params->validate_data ? dev->data_intr_in : dev->burst_intr_in; + break; + case USB_TRANSFER_BULK: + pipe = params->validate_data ? dev->data_bulk_in : dev->burst_bulk_in; + break; + case USB_TRANSFER_ISOCHRONOUS: + pipe = params->validate_data ? dev->data_isoch_in : dev->burst_isoch_in; + break; + default: + return ENOTSUP; + } + + return test_in(pipe, params, results); +} + +int usbdiag_dev_test_out(ddf_fun_t *fun, const usbdiag_test_params_t *params, usbdiag_test_results_t *results) { usbdiag_dev_t *dev = ddf_fun_to_usbdiag_dev(fun); @@ -278,95 +234,21 @@ return EBADMEM; - return burst_out_test(dev->intr_out, cycles, size, duration); -} - -int usbdiag_burst_test_bulk_in(ddf_fun_t *fun, int cycles, size_t size, usbdiag_dur_t *duration) -{ - usbdiag_dev_t *dev = ddf_fun_to_usbdiag_dev(fun); - if (!dev) - return EBADMEM; - - return burst_in_test(dev->bulk_in, cycles, size, duration); -} - -int usbdiag_burst_test_bulk_out(ddf_fun_t *fun, int cycles, size_t size, usbdiag_dur_t *duration) -{ - usbdiag_dev_t *dev = ddf_fun_to_usbdiag_dev(fun); - if (!dev) - return EBADMEM; - - return burst_out_test(dev->bulk_out, cycles, size, duration); -} - -int usbdiag_burst_test_isoch_in(ddf_fun_t *fun, int cycles, size_t size, usbdiag_dur_t *duration) -{ - usbdiag_dev_t *dev = ddf_fun_to_usbdiag_dev(fun); - if (!dev) - return EBADMEM; - - return burst_in_test(dev->isoch_in, cycles, size, duration); -} - -int usbdiag_burst_test_isoch_out(ddf_fun_t *fun, int cycles, size_t size, usbdiag_dur_t *duration) -{ - usbdiag_dev_t *dev = ddf_fun_to_usbdiag_dev(fun); - if (!dev) - return EBADMEM; - - return burst_out_test(dev->isoch_out, cycles, size, duration); -} - -int usbdiag_data_test_intr_in(ddf_fun_t *fun, int cycles, size_t size, usbdiag_dur_t *duration) -{ - usbdiag_dev_t *dev = ddf_fun_to_usbdiag_dev(fun); - if (!dev) - return EBADMEM; - - return data_in_test(dev->intr_in, cycles, size, duration); -} - -int usbdiag_data_test_intr_out(ddf_fun_t *fun, int cycles, size_t size, usbdiag_dur_t *duration) -{ - usbdiag_dev_t *dev = ddf_fun_to_usbdiag_dev(fun); - if (!dev) - return EBADMEM; - - return data_out_test(dev->intr_out, cycles, size, duration); -} - -int usbdiag_data_test_bulk_in(ddf_fun_t *fun, int cycles, size_t size, usbdiag_dur_t *duration) -{ - usbdiag_dev_t *dev = ddf_fun_to_usbdiag_dev(fun); - if (!dev) - return EBADMEM; - - return data_in_test(dev->bulk_in, cycles, size, duration); -} - -int usbdiag_data_test_bulk_out(ddf_fun_t *fun, int cycles, size_t size, usbdiag_dur_t *duration) -{ - usbdiag_dev_t *dev = ddf_fun_to_usbdiag_dev(fun); - if (!dev) - return EBADMEM; - - return data_out_test(dev->bulk_out, cycles, size, duration); -} - -int usbdiag_data_test_isoch_in(ddf_fun_t *fun, int cycles, size_t size, usbdiag_dur_t *duration) -{ - usbdiag_dev_t *dev = ddf_fun_to_usbdiag_dev(fun); - if (!dev) - return EBADMEM; - - return data_in_test(dev->isoch_in, cycles, size, duration); -} - -int usbdiag_data_test_isoch_out(ddf_fun_t *fun, int cycles, size_t size, usbdiag_dur_t *duration) -{ - usbdiag_dev_t *dev = ddf_fun_to_usbdiag_dev(fun); - if (!dev) - return EBADMEM; - - return data_out_test(dev->isoch_out, cycles, size, duration); + usb_pipe_t *pipe; + + switch (params->transfer_type) { + case USB_TRANSFER_INTERRUPT: + pipe = params->validate_data ? dev->data_intr_out : dev->burst_intr_out; + break; + case USB_TRANSFER_BULK: + pipe = params->validate_data ? dev->data_bulk_out : dev->burst_bulk_out; + break; + case USB_TRANSFER_ISOCHRONOUS: + pipe = params->validate_data ? dev->data_isoch_out : dev->burst_isoch_out; + break; + default: + return ENOTSUP; + } + + return test_out(pipe, params, results); } Index: uspace/drv/bus/usb/usbdiag/tests.h =================================================================== --- uspace/drv/bus/usb/usbdiag/tests.h (revision e67c50ac9b5c850d056f789863dea7d4da95af3a) +++ uspace/drv/bus/usb/usbdiag/tests.h (revision 64ce0c1435496748632f7682b2657fdc79aad634) @@ -39,17 +39,6 @@ #include -int usbdiag_burst_test_intr_in(ddf_fun_t *, int, size_t, usbdiag_dur_t *); -int usbdiag_burst_test_intr_out(ddf_fun_t *, int, size_t, usbdiag_dur_t *); -int usbdiag_burst_test_bulk_in(ddf_fun_t *, int, size_t, usbdiag_dur_t *); -int usbdiag_burst_test_bulk_out(ddf_fun_t *, int, size_t, usbdiag_dur_t *); -int usbdiag_burst_test_isoch_in(ddf_fun_t *, int, size_t, usbdiag_dur_t *); -int usbdiag_burst_test_isoch_out(ddf_fun_t *, int, size_t, usbdiag_dur_t *); - -int usbdiag_data_test_intr_in(ddf_fun_t *, int, size_t, usbdiag_dur_t *); -int usbdiag_data_test_intr_out(ddf_fun_t *, int, size_t, usbdiag_dur_t *); -int usbdiag_data_test_bulk_in(ddf_fun_t *, int, size_t, usbdiag_dur_t *); -int usbdiag_data_test_bulk_out(ddf_fun_t *, int, size_t, usbdiag_dur_t *); -int usbdiag_data_test_isoch_in(ddf_fun_t *, int, size_t, usbdiag_dur_t *); -int usbdiag_data_test_isoch_out(ddf_fun_t *, int, size_t, usbdiag_dur_t *); +int usbdiag_dev_test_in(ddf_fun_t *, const usbdiag_test_params_t *, usbdiag_test_results_t *); +int usbdiag_dev_test_out(ddf_fun_t *, const usbdiag_test_params_t *, usbdiag_test_results_t *); #endif /* USBDIAG_TESTS_H_ */ Index: uspace/drv/bus/usb/xhci/endpoint.c =================================================================== --- uspace/drv/bus/usb/xhci/endpoint.c (revision e67c50ac9b5c850d056f789863dea7d4da95af3a) +++ uspace/drv/bus/usb/xhci/endpoint.c (revision 64ce0c1435496748632f7682b2657fdc79aad634) @@ -88,5 +88,11 @@ if (dev->speed >= USB_SPEED_SUPER) { ep->packets_per_uframe = xhci_ep->max_burst * xhci_ep->mult; - ep->max_transfer_size = ep->max_packet_size * ep->packets_per_uframe; + if (ep->transfer_type == USB_TRANSFER_ISOCHRONOUS + || ep->transfer_type == USB_TRANSFER_INTERRUPT) { + ep->max_transfer_size = ep->max_packet_size * ep->packets_per_uframe; + } + else { + ep->max_transfer_size = 200 * PAGE_SIZE; + } } Index: uspace/drv/bus/usb/xhci/transfers.c =================================================================== --- uspace/drv/bus/usb/xhci/transfers.c (revision e67c50ac9b5c850d056f789863dea7d4da95af3a) +++ uspace/drv/bus/usb/xhci/transfers.c (revision 64ce0c1435496748632f7682b2657fdc79aad634) @@ -126,4 +126,28 @@ } +static int calculate_trb_count(xhci_transfer_t *transfer) +{ + const size_t size = transfer->batch.buffer_size; + return (size + PAGE_SIZE - 1 )/ PAGE_SIZE; +} + +static void trb_set_buffer(xhci_transfer_t *transfer, xhci_trb_t *trb, + size_t i, size_t total, size_t *remaining) +{ + const uintptr_t ptr = dma_buffer_phys(&transfer->hc_buffer, + transfer->hc_buffer.virt + i * PAGE_SIZE); + + trb->parameter = host2xhci(64, ptr); + TRB_CTRL_SET_TD_SIZE(*trb, max(31, total - i - 1)); + if (*remaining > PAGE_SIZE) { + TRB_CTRL_SET_XFER_LEN(*trb, PAGE_SIZE); + *remaining -= PAGE_SIZE; + } + else { + TRB_CTRL_SET_XFER_LEN(*trb, *remaining); + *remaining = 0; + } +} + static int schedule_control(xhci_hc_t* hc, xhci_transfer_t* transfer) { @@ -133,8 +157,12 @@ usb_device_request_setup_packet_t* setup = &batch->setup.packet; - xhci_trb_t trbs[3]; - int trbs_used = 0; - - xhci_trb_t *trb_setup = trbs + trbs_used++; + size_t buffer_count = 0; + if (setup->length > 0) { + buffer_count = calculate_trb_count(transfer); + } + + xhci_trb_t trbs[buffer_count + 2]; + + xhci_trb_t *trb_setup = trbs; xhci_trb_clean(trb_setup); @@ -155,26 +183,25 @@ /* Data stage */ - xhci_trb_t *trb_data = NULL; if (setup->length > 0) { - trb_data = trbs + trbs_used++; - xhci_trb_clean(trb_data); - - trb_data->parameter = host2xhci(64, transfer->hc_buffer.phys); - - // data size (sent for OUT, or buffer size) - TRB_CTRL_SET_XFER_LEN(*trb_data, batch->buffer_size); - // FIXME: TD size 4.11.2.4 - TRB_CTRL_SET_TD_SIZE(*trb_data, 1); - - // Some more fields here, no idea what they mean - TRB_CTRL_SET_TRB_TYPE(*trb_data, XHCI_TRB_TYPE_DATA_STAGE); - int stage_dir = REQUEST_TYPE_IS_DEVICE_TO_HOST(setup->request_type) ? STAGE_IN : STAGE_OUT; - TRB_CTRL_SET_DIR(*trb_data, stage_dir); + size_t remaining = transfer->batch.buffer_size; + + for (size_t i = 0; i < buffer_count; ++i) { + xhci_trb_clean(&trbs[i + 1]); + trb_set_buffer(transfer, &trbs[i + 1], i, buffer_count, &remaining); + + TRB_CTRL_SET_DIR(trbs[i + 1], stage_dir); + TRB_CTRL_SET_TRB_TYPE(trbs[i + 1], XHCI_TRB_TYPE_DATA_STAGE); + + if (i == buffer_count - 1) break; + + /* Set the chain bit as this is not the last TRB */ + TRB_CTRL_SET_CHAIN(trbs[i], 1); + } } /* Status stage */ - xhci_trb_t *trb_status = trbs + trbs_used++; + xhci_trb_t *trb_status = trbs + buffer_count + 1; xhci_trb_clean(trb_status); @@ -192,35 +219,34 @@ return xhci_trb_ring_enqueue_multiple(get_ring(transfer), trbs, - trbs_used, &transfer->interrupt_trb_phys); + buffer_count + 2, &transfer->interrupt_trb_phys); } static int schedule_bulk(xhci_hc_t* hc, xhci_transfer_t *transfer) { - xhci_trb_t trb; - xhci_trb_clean(&trb); - trb.parameter = host2xhci(64, transfer->hc_buffer.phys); - - // data size (sent for OUT, or buffer size) - TRB_CTRL_SET_XFER_LEN(trb, transfer->batch.buffer_size); - /* The stream-enabled endpoints need to chain ED trb */ xhci_endpoint_t *ep = xhci_endpoint_get(transfer->batch.ep); if (!ep->primary_stream_data_size) { - // FIXME: TD size 4.11.2.4 - TRB_CTRL_SET_TD_SIZE(trb, 1); - - // we want an interrupt after this td is done - TRB_CTRL_SET_IOC(trb, 1); - TRB_CTRL_SET_TRB_TYPE(trb, XHCI_TRB_TYPE_NORMAL); + const size_t buffer_count = calculate_trb_count(transfer); + xhci_trb_t trbs[buffer_count]; + size_t remaining = transfer->batch.buffer_size; + + for (size_t i = 0; i < buffer_count; ++i) { + xhci_trb_clean(&trbs[i]); + trb_set_buffer(transfer, &trbs[i], i, buffer_count, &remaining); + TRB_CTRL_SET_TRB_TYPE(trbs[i], XHCI_TRB_TYPE_NORMAL); + + if (i == buffer_count - 1) break; + + /* Set the chain bit as this is not the last TRB */ + TRB_CTRL_SET_CHAIN(trbs[i], 1); + } + /* Set the interrupt bit for last TRB */ + TRB_CTRL_SET_IOC(trbs[buffer_count - 1], 1); xhci_trb_ring_t* ring = get_ring(transfer); - return xhci_trb_ring_enqueue(ring, &trb, &transfer->interrupt_trb_phys); + return xhci_trb_ring_enqueue_multiple(ring, &trbs[0], buffer_count, + &transfer->interrupt_trb_phys); } else { - TRB_CTRL_SET_TD_SIZE(trb, 2); - TRB_CTRL_SET_TRB_TYPE(trb, XHCI_TRB_TYPE_NORMAL); - TRB_CTRL_SET_CHAIN(trb, 1); - TRB_CTRL_SET_ENT(trb, 1); - xhci_trb_ring_t* ring = get_ring(transfer); if (!ring) { @@ -228,16 +254,23 @@ } - int err = xhci_trb_ring_enqueue(ring, &trb, &transfer->interrupt_trb_phys); - - if (err) { - return err; - } - - xhci_trb_clean(&trb); - trb.parameter = host2xhci(64, (uintptr_t) transfer); - TRB_CTRL_SET_TRB_TYPE(trb, XHCI_TRB_TYPE_EVENT_DATA); - TRB_CTRL_SET_IOC(trb, 1); - - return xhci_trb_ring_enqueue(ring, &trb, &transfer->interrupt_trb_phys); + const size_t buffer_count = calculate_trb_count(transfer); + xhci_trb_t trbs[buffer_count + 1]; + size_t remaining = transfer->batch.buffer_size; + + for (size_t i = 0; i < buffer_count; ++i) { + xhci_trb_clean(&trbs[i]); + trb_set_buffer(transfer, &trbs[i], i, buffer_count + 1, &remaining); + TRB_CTRL_SET_TRB_TYPE(trbs[i], XHCI_TRB_TYPE_NORMAL); + TRB_CTRL_SET_CHAIN(trbs[i], 1); + } + TRB_CTRL_SET_ENT(trbs[buffer_count - 1], 1); + + xhci_trb_clean(&trbs[buffer_count]); + trbs[buffer_count].parameter = host2xhci(64, (uintptr_t) transfer); + TRB_CTRL_SET_TRB_TYPE(trbs[buffer_count], XHCI_TRB_TYPE_EVENT_DATA); + TRB_CTRL_SET_IOC(trbs[buffer_count], 1); + + return xhci_trb_ring_enqueue_multiple(ring, &trbs[0], buffer_count + 1, + &transfer->interrupt_trb_phys); } } @@ -245,21 +278,24 @@ static int schedule_interrupt(xhci_hc_t* hc, xhci_transfer_t* transfer) { - xhci_trb_t trb; - xhci_trb_clean(&trb); - trb.parameter = host2xhci(64, transfer->hc_buffer.phys); - - // data size (sent for OUT, or buffer size) - TRB_CTRL_SET_XFER_LEN(trb, transfer->batch.buffer_size); - // FIXME: TD size 4.11.2.4 - TRB_CTRL_SET_TD_SIZE(trb, 1); - - // we want an interrupt after this td is done - TRB_CTRL_SET_IOC(trb, 1); - - TRB_CTRL_SET_TRB_TYPE(trb, XHCI_TRB_TYPE_NORMAL); + const size_t buffer_count = calculate_trb_count(transfer); + xhci_trb_t trbs[buffer_count]; + size_t remaining = transfer->batch.buffer_size; + + for (size_t i = 0; i < buffer_count; ++i) { + xhci_trb_clean(&trbs[i]); + trb_set_buffer(transfer, &trbs[i], i, buffer_count, &remaining); + TRB_CTRL_SET_TRB_TYPE(trbs[i], XHCI_TRB_TYPE_NORMAL); + + if (i == buffer_count - 1) break; + + /* Set the chain bit as this is not the last TRB */ + TRB_CTRL_SET_CHAIN(trbs[i], 1); + } + /* Set the interrupt bit for last TRB */ + TRB_CTRL_SET_IOC(trbs[buffer_count - 1], 1); xhci_trb_ring_t* ring = get_ring(transfer); - - return xhci_trb_ring_enqueue(ring, &trb, &transfer->interrupt_trb_phys); + return xhci_trb_ring_enqueue_multiple(ring, &trbs[0], buffer_count, + &transfer->interrupt_trb_phys); } Index: uspace/lib/drv/generic/remote_usbdiag.c =================================================================== --- uspace/lib/drv/generic/remote_usbdiag.c (revision e67c50ac9b5c850d056f789863dea7d4da95af3a) +++ uspace/lib/drv/generic/remote_usbdiag.c (revision 64ce0c1435496748632f7682b2657fdc79aad634) @@ -43,16 +43,6 @@ typedef enum { - IPC_M_USBDIAG_BURST_INTR_IN, - IPC_M_USBDIAG_BURST_INTR_OUT, - IPC_M_USBDIAG_BURST_BULK_IN, - IPC_M_USBDIAG_BURST_BULK_OUT, - IPC_M_USBDIAG_BURST_ISOCH_IN, - IPC_M_USBDIAG_BURST_ISOCH_OUT, - IPC_M_USBDIAG_DATA_INTR_IN, - IPC_M_USBDIAG_DATA_INTR_OUT, - IPC_M_USBDIAG_DATA_BULK_IN, - IPC_M_USBDIAG_DATA_BULK_OUT, - IPC_M_USBDIAG_DATA_ISOCH_IN, - IPC_M_USBDIAG_DATA_ISOCH_OUT + IPC_M_USBDIAG_TEST_IN, + IPC_M_USBDIAG_TEST_OUT, } usb_iface_funcs_t; @@ -68,200 +58,71 @@ } -int usbdiag_burst_intr_in(async_exch_t *exch, int cycles, size_t size, usbdiag_dur_t *duration) +int usbdiag_test_in(async_exch_t *exch, const usbdiag_test_params_t *params, usbdiag_test_results_t *results) { if (!exch) return EBADMEM; - sysarg_t duration_; - const int rc = async_req_3_1(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_BURST_INTR_IN, cycles, size, &duration_); - - if (rc == EOK && duration) - *duration = duration_; - - return rc; -} - -int usbdiag_burst_intr_out(async_exch_t *exch, int cycles, size_t size, usbdiag_dur_t *duration) + ipc_call_t answer; + aid_t req = async_send_1(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_TEST_IN, &answer); + + int rc = async_data_write_start(exch, params, sizeof(usbdiag_test_params_t)); + if (rc != EOK) { + async_exchange_end(exch); + async_forget(req); + return rc; + } + + rc = async_data_read_start(exch, results, sizeof(usbdiag_test_results_t)); + if (rc != EOK) { + async_exchange_end(exch); + async_forget(req); + return rc; + } + + async_exchange_end(exch); + + errno_t retval; + async_wait_for(req, &retval); + + return (int) retval; +} + +int usbdiag_test_out(async_exch_t *exch, const usbdiag_test_params_t *params, usbdiag_test_results_t *results) { if (!exch) return EBADMEM; - sysarg_t duration_; - const int rc = async_req_3_1(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_BURST_INTR_OUT, cycles, size, &duration_); - - if (rc == EOK && duration) - *duration = duration_; - - return rc; -} - -int usbdiag_burst_bulk_in(async_exch_t *exch, int cycles, size_t size, usbdiag_dur_t *duration) -{ - if (!exch) - return EBADMEM; - - sysarg_t duration_; - const int rc = async_req_3_1(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_BURST_BULK_IN, cycles, size, &duration_); - - if (rc == EOK && duration) - *duration = duration_; - - return rc; -} - -int usbdiag_burst_bulk_out(async_exch_t *exch, int cycles, size_t size, usbdiag_dur_t *duration) -{ - if (!exch) - return EBADMEM; - - sysarg_t duration_; - const int rc = async_req_3_1(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_BURST_BULK_OUT, cycles, size, &duration_); - - if (rc == EOK && duration) - *duration = duration_; - - return rc; -} - -int usbdiag_burst_isoch_in(async_exch_t *exch, int cycles, size_t size, usbdiag_dur_t *duration) -{ - if (!exch) - return EBADMEM; - - sysarg_t duration_; - const int rc = async_req_3_1(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_BURST_ISOCH_IN, cycles, size, &duration_); - - if (rc == EOK && duration) - *duration = duration_; - - return rc; -} - -int usbdiag_burst_isoch_out(async_exch_t *exch, int cycles, size_t size, usbdiag_dur_t *duration) -{ - if (!exch) - return EBADMEM; - - sysarg_t duration_; - const int rc = async_req_3_1(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_BURST_ISOCH_OUT, cycles, size, &duration_); - - if (rc == EOK && duration) - *duration = duration_; - - return rc; -} - -int usbdiag_data_intr_in(async_exch_t *exch, int cycles, size_t size, usbdiag_dur_t *duration) -{ - if (!exch) - return EBADMEM; - - sysarg_t duration_; - const int rc = async_req_3_1(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_DATA_INTR_IN, cycles, size, &duration_); - - if (rc == EOK && duration) - *duration = duration_; - - return rc; -} - -int usbdiag_data_intr_out(async_exch_t *exch, int cycles, size_t size, usbdiag_dur_t *duration) -{ - if (!exch) - return EBADMEM; - - sysarg_t duration_; - const int rc = async_req_3_1(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_DATA_INTR_OUT, cycles, size, &duration_); - - if (rc == EOK && duration) - *duration = duration_; - - return rc; -} - -int usbdiag_data_bulk_in(async_exch_t *exch, int cycles, size_t size, usbdiag_dur_t *duration) -{ - if (!exch) - return EBADMEM; - - sysarg_t duration_; - const int rc = async_req_3_1(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_DATA_BULK_IN, cycles, size, &duration_); - - if (rc == EOK && duration) - *duration = duration_; - - return rc; -} - -int usbdiag_data_bulk_out(async_exch_t *exch, int cycles, size_t size, usbdiag_dur_t *duration) -{ - if (!exch) - return EBADMEM; - - sysarg_t duration_; - const int rc = async_req_3_1(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_DATA_BULK_OUT, cycles, size, &duration_); - - if (rc == EOK && duration) - *duration = duration_; - - return rc; -} - -int usbdiag_data_isoch_in(async_exch_t *exch, int cycles, size_t size, usbdiag_dur_t *duration) -{ - if (!exch) - return EBADMEM; - - sysarg_t duration_; - const int rc = async_req_3_1(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_DATA_ISOCH_IN, cycles, size, &duration_); - - if (rc == EOK && duration) - *duration = duration_; - - return rc; -} - -int usbdiag_data_isoch_out(async_exch_t *exch, int cycles, size_t size, usbdiag_dur_t *duration) -{ - if (!exch) - return EBADMEM; - - sysarg_t duration_; - const int rc = async_req_3_1(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_DATA_ISOCH_OUT, cycles, size, &duration_); - - if (rc == EOK && duration) - *duration = duration_; - - return rc; -} - -static void remote_usbdiag_burst_intr_in(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); -static void remote_usbdiag_burst_intr_out(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); -static void remote_usbdiag_burst_bulk_in(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); -static void remote_usbdiag_burst_bulk_out(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); -static void remote_usbdiag_burst_isoch_in(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); -static void remote_usbdiag_burst_isoch_out(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); - -static void remote_usbdiag_data_intr_in(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); -static void remote_usbdiag_data_intr_out(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); -static void remote_usbdiag_data_bulk_in(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); -static void remote_usbdiag_data_bulk_out(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); -static void remote_usbdiag_data_isoch_in(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); -static void remote_usbdiag_data_isoch_out(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); + ipc_call_t answer; + aid_t req = async_send_1(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_TEST_OUT, &answer); + + int rc = async_data_write_start(exch, params, sizeof(usbdiag_test_params_t)); + if (rc != EOK) { + async_exchange_end(exch); + async_forget(req); + return rc; + } + + rc = async_data_read_start(exch, results, sizeof(usbdiag_test_results_t)); + if (rc != EOK) { + async_exchange_end(exch); + async_forget(req); + return rc; + } + + async_exchange_end(exch); + + errno_t retval; + async_wait_for(req, &retval); + + return (int) retval; +} + +static void remote_usbdiag_test_in(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbdiag_test_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_BURST_INTR_IN] = remote_usbdiag_burst_intr_in, - [IPC_M_USBDIAG_BURST_INTR_OUT] = remote_usbdiag_burst_intr_out, - [IPC_M_USBDIAG_BURST_BULK_IN] = remote_usbdiag_burst_bulk_in, - [IPC_M_USBDIAG_BURST_BULK_OUT] = remote_usbdiag_burst_bulk_out, - [IPC_M_USBDIAG_BURST_ISOCH_IN] = remote_usbdiag_burst_isoch_in, - [IPC_M_USBDIAG_BURST_ISOCH_OUT] = remote_usbdiag_burst_isoch_out, - [IPC_M_USBDIAG_DATA_INTR_IN] = remote_usbdiag_data_intr_in, - [IPC_M_USBDIAG_DATA_INTR_OUT] = remote_usbdiag_data_intr_out, - [IPC_M_USBDIAG_DATA_BULK_IN] = remote_usbdiag_data_bulk_in, - [IPC_M_USBDIAG_DATA_BULK_OUT] = remote_usbdiag_data_bulk_out, - [IPC_M_USBDIAG_DATA_ISOCH_IN] = remote_usbdiag_data_isoch_in, - [IPC_M_USBDIAG_DATA_ISOCH_OUT] = remote_usbdiag_data_isoch_out + [IPC_M_USBDIAG_TEST_IN] = remote_usbdiag_test_in, + [IPC_M_USBDIAG_TEST_OUT] = remote_usbdiag_test_out }; @@ -272,254 +133,106 @@ }; -void remote_usbdiag_burst_intr_in(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call) +void remote_usbdiag_test_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->burst_bulk_in == NULL) { - async_answer_0(callid, ENOTSUP); - return; - } - - int cycles = DEV_IPC_GET_ARG1(*call); - size_t size = DEV_IPC_GET_ARG2(*call); - usbdiag_dur_t duration; - const int ret = diag_iface->burst_intr_in(fun, cycles, size, &duration); + size_t size; + ipc_callid_t data_callid; + if (!async_data_write_receive(&data_callid, &size)) { + async_answer_0(data_callid, EINVAL); + async_answer_0(callid, EINVAL); + return; + } + + if (size != sizeof(usbdiag_test_params_t)) { + async_answer_0(data_callid, EINVAL); + async_answer_0(callid, EINVAL); + return; + } + + usbdiag_test_params_t params; + if (async_data_write_finalize(data_callid, ¶ms, size) != EOK) { + async_answer_0(callid, EINVAL); + return; + } + + usbdiag_test_results_t results; + const int ret = !diag_iface->test_in ? ENOTSUP : diag_iface->test_in(fun, ¶ms, &results); if (ret != EOK) { async_answer_0(callid, ret); - } else { - async_answer_1(callid, EOK, duration); - } -} - -void remote_usbdiag_burst_intr_out(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call) + return; + } + + if (!async_data_read_receive(&data_callid, &size)) { + async_answer_0(data_callid, EINVAL); + async_answer_0(callid, EINVAL); + return; + } + + if (size != sizeof(usbdiag_test_results_t)) { + async_answer_0(data_callid, EINVAL); + async_answer_0(callid, EINVAL); + return; + } + + if (async_data_read_finalize(data_callid, &results, size) != EOK) { + async_answer_0(callid, EINVAL); + return; + } + + async_answer_0(callid, ret); +} + +void remote_usbdiag_test_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->burst_bulk_out == NULL) { - async_answer_0(callid, ENOTSUP); - return; - } - - int cycles = DEV_IPC_GET_ARG1(*call); - size_t size = DEV_IPC_GET_ARG2(*call); - usbdiag_dur_t duration; - const int ret = diag_iface->burst_intr_out(fun, cycles, size, &duration); + size_t size; + ipc_callid_t data_callid; + if (!async_data_write_receive(&data_callid, &size)) { + async_answer_0(data_callid, EINVAL); + async_answer_0(callid, EINVAL); + return; + } + + if (size != sizeof(usbdiag_test_params_t)) { + async_answer_0(data_callid, EINVAL); + async_answer_0(callid, EINVAL); + return; + } + + usbdiag_test_params_t params; + if (async_data_write_finalize(data_callid, ¶ms, size) != EOK) { + async_answer_0(callid, EINVAL); + return; + } + + usbdiag_test_results_t results; + const int ret = !diag_iface->test_out ? ENOTSUP : diag_iface->test_out(fun, ¶ms, &results); if (ret != EOK) { async_answer_0(callid, ret); - } else { - async_answer_1(callid, EOK, duration); - } -} - -void remote_usbdiag_burst_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->burst_bulk_in == NULL) { - async_answer_0(callid, ENOTSUP); - return; - } - - int cycles = DEV_IPC_GET_ARG1(*call); - size_t size = DEV_IPC_GET_ARG2(*call); - usbdiag_dur_t duration; - const int ret = diag_iface->burst_bulk_in(fun, cycles, size, &duration); - - if (ret != EOK) { - async_answer_0(callid, ret); - } else { - async_answer_1(callid, EOK, duration); - } -} - -void remote_usbdiag_burst_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->burst_bulk_out == NULL) { - async_answer_0(callid, ENOTSUP); - return; - } - - int cycles = DEV_IPC_GET_ARG1(*call); - size_t size = DEV_IPC_GET_ARG2(*call); - usbdiag_dur_t duration; - const int ret = diag_iface->burst_bulk_out(fun, cycles, size, &duration); - - if (ret != EOK) { - async_answer_0(callid, ret); - } else { - async_answer_1(callid, EOK, duration); - } -} - -void remote_usbdiag_burst_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->burst_isoch_in == NULL) { - async_answer_0(callid, ENOTSUP); - return; - } - - int cycles = DEV_IPC_GET_ARG1(*call); - size_t size = DEV_IPC_GET_ARG2(*call); - usbdiag_dur_t duration; - const int ret = diag_iface->burst_isoch_in(fun, cycles, size, &duration); - - if (ret != EOK) { - async_answer_0(callid, ret); - } else { - async_answer_1(callid, EOK, duration); - } -} - -void remote_usbdiag_burst_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->burst_isoch_out == NULL) { - async_answer_0(callid, ENOTSUP); - return; - } - - int cycles = DEV_IPC_GET_ARG1(*call); - size_t size = DEV_IPC_GET_ARG2(*call); - usbdiag_dur_t duration; - const int ret = diag_iface->burst_isoch_out(fun, cycles, size, &duration); - - if (ret != EOK) { - async_answer_0(callid, ret); - } else { - async_answer_1(callid, EOK, duration); - } -} - -void remote_usbdiag_data_intr_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->data_bulk_in == NULL) { - async_answer_0(callid, ENOTSUP); - return; - } - - int cycles = DEV_IPC_GET_ARG1(*call); - size_t size = DEV_IPC_GET_ARG2(*call); - usbdiag_dur_t duration; - const int ret = diag_iface->data_intr_in(fun, cycles, size, &duration); - - if (ret != EOK) { - async_answer_0(callid, ret); - } else { - async_answer_1(callid, EOK, duration); - } -} - -void remote_usbdiag_data_intr_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->data_bulk_out == NULL) { - async_answer_0(callid, ENOTSUP); - return; - } - - int cycles = DEV_IPC_GET_ARG1(*call); - size_t size = DEV_IPC_GET_ARG2(*call); - usbdiag_dur_t duration; - const int ret = diag_iface->data_intr_out(fun, cycles, size, &duration); - - if (ret != EOK) { - async_answer_0(callid, ret); - } else { - async_answer_1(callid, EOK, duration); - } -} - -void remote_usbdiag_data_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->data_bulk_in == NULL) { - async_answer_0(callid, ENOTSUP); - return; - } - - int cycles = DEV_IPC_GET_ARG1(*call); - size_t size = DEV_IPC_GET_ARG2(*call); - usbdiag_dur_t duration; - const int ret = diag_iface->data_bulk_in(fun, cycles, size, &duration); - - if (ret != EOK) { - async_answer_0(callid, ret); - } else { - async_answer_1(callid, EOK, duration); - } -} - -void remote_usbdiag_data_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->data_bulk_out == NULL) { - async_answer_0(callid, ENOTSUP); - return; - } - - int cycles = DEV_IPC_GET_ARG1(*call); - size_t size = DEV_IPC_GET_ARG2(*call); - usbdiag_dur_t duration; - const int ret = diag_iface->data_bulk_out(fun, cycles, size, &duration); - - if (ret != EOK) { - async_answer_0(callid, ret); - } else { - async_answer_1(callid, EOK, duration); - } -} - -void remote_usbdiag_data_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->data_isoch_in == NULL) { - async_answer_0(callid, ENOTSUP); - return; - } - - int cycles = DEV_IPC_GET_ARG1(*call); - size_t size = DEV_IPC_GET_ARG2(*call); - usbdiag_dur_t duration; - const int ret = diag_iface->data_isoch_in(fun, cycles, size, &duration); - - if (ret != EOK) { - async_answer_0(callid, ret); - } else { - async_answer_1(callid, EOK, duration); - } -} - -void remote_usbdiag_data_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->data_isoch_out == NULL) { - async_answer_0(callid, ENOTSUP); - return; - } - - int cycles = DEV_IPC_GET_ARG1(*call); - size_t size = DEV_IPC_GET_ARG2(*call); - usbdiag_dur_t duration; - const int ret = diag_iface->data_isoch_out(fun, cycles, size, &duration); - - if (ret != EOK) { - async_answer_0(callid, ret); - } else { - async_answer_1(callid, EOK, duration); - } + return; + } + + if (!async_data_read_receive(&data_callid, &size)) { + async_answer_0(data_callid, EINVAL); + async_answer_0(callid, EINVAL); + return; + } + + if (size != sizeof(usbdiag_test_results_t)) { + async_answer_0(data_callid, EINVAL); + async_answer_0(callid, EINVAL); + return; + } + + if (async_data_read_finalize(data_callid, &results, size) != EOK) { + async_answer_0(callid, EINVAL); + return; + } + + async_answer_0(callid, ret); } Index: uspace/lib/drv/include/usbdiag_iface.h =================================================================== --- uspace/lib/drv/include/usbdiag_iface.h (revision e67c50ac9b5c850d056f789863dea7d4da95af3a) +++ uspace/lib/drv/include/usbdiag_iface.h (revision 64ce0c1435496748632f7682b2657fdc79aad634) @@ -39,4 +39,5 @@ #include +#include #include "ddf/driver.h" @@ -46,35 +47,29 @@ typedef unsigned long usbdiag_dur_t; +/** Test parameters. */ +typedef struct usbdiag_test_params { + usb_transfer_type_t transfer_type; + size_t transfer_size; + usbdiag_dur_t min_duration; + bool validate_data; +} usbdiag_test_params_t; + +/** Test results. */ +typedef struct usbdiag_test_results { + usbdiag_dur_t act_duration; + uint32_t transfer_count; + size_t transfer_size; +} usbdiag_test_results_t; + async_sess_t *usbdiag_connect(devman_handle_t); void usbdiag_disconnect(async_sess_t*); -int usbdiag_burst_intr_in(async_exch_t*, int, size_t, usbdiag_dur_t*); -int usbdiag_burst_intr_out(async_exch_t*, int, size_t, usbdiag_dur_t*); -int usbdiag_burst_bulk_in(async_exch_t*, int, size_t, usbdiag_dur_t*); -int usbdiag_burst_bulk_out(async_exch_t*, int, size_t, usbdiag_dur_t*); -int usbdiag_burst_isoch_in(async_exch_t*, int, size_t, usbdiag_dur_t*); -int usbdiag_burst_isoch_out(async_exch_t*, int, size_t, usbdiag_dur_t*); - -int usbdiag_data_intr_in(async_exch_t*, int, size_t, usbdiag_dur_t*); -int usbdiag_data_intr_out(async_exch_t*, int, size_t, usbdiag_dur_t*); -int usbdiag_data_bulk_in(async_exch_t*, int, size_t, usbdiag_dur_t*); -int usbdiag_data_bulk_out(async_exch_t*, int, size_t, usbdiag_dur_t*); -int usbdiag_data_isoch_in(async_exch_t*, int, size_t, usbdiag_dur_t*); -int usbdiag_data_isoch_out(async_exch_t*, int, size_t, usbdiag_dur_t*); +int usbdiag_test_in(async_exch_t*, const usbdiag_test_params_t *, usbdiag_test_results_t *); +int usbdiag_test_out(async_exch_t*, const usbdiag_test_params_t *, usbdiag_test_results_t *); /** USB diagnostic device communication interface. */ typedef struct { - int (*burst_intr_in)(ddf_fun_t*, int, size_t, usbdiag_dur_t*); - int (*burst_intr_out)(ddf_fun_t*, int, size_t, usbdiag_dur_t*); - int (*burst_bulk_in)(ddf_fun_t*, int, size_t, usbdiag_dur_t*); - int (*burst_bulk_out)(ddf_fun_t*, int, size_t, usbdiag_dur_t*); - int (*burst_isoch_in)(ddf_fun_t*, int, size_t, usbdiag_dur_t*); - int (*burst_isoch_out)(ddf_fun_t*, int, size_t, usbdiag_dur_t*); - int (*data_intr_in)(ddf_fun_t*, int, size_t, usbdiag_dur_t*); - int (*data_intr_out)(ddf_fun_t*, int, size_t, usbdiag_dur_t*); - int (*data_bulk_in)(ddf_fun_t*, int, size_t, usbdiag_dur_t*); - int (*data_bulk_out)(ddf_fun_t*, int, size_t, usbdiag_dur_t*); - int (*data_isoch_in)(ddf_fun_t*, int, size_t, usbdiag_dur_t*); - int (*data_isoch_out)(ddf_fun_t*, int, size_t, usbdiag_dur_t*); + int (*test_in)(ddf_fun_t*, const usbdiag_test_params_t *, usbdiag_test_results_t *); + int (*test_out)(ddf_fun_t*, const usbdiag_test_params_t *, usbdiag_test_results_t *); } usbdiag_iface_t; Index: uspace/lib/usbdev/src/pipesinit.c =================================================================== --- uspace/lib/usbdev/src/pipesinit.c (revision e67c50ac9b5c850d056f789863dea7d4da95af3a) +++ uspace/lib/usbdev/src/pipesinit.c (revision 64ce0c1435496748632f7682b2657fdc79aad634) @@ -146,5 +146,6 @@ if (interface_number_fits && interface_setting_fits - && endpoint_descriptions_fits) { + && endpoint_descriptions_fits + && !mapping->present) { return mapping; } @@ -153,4 +154,5 @@ mapping_count--; } + return NULL; } Index: uspace/lib/usbhost/src/endpoint.c =================================================================== --- uspace/lib/usbhost/src/endpoint.c (revision e67c50ac9b5c850d056f789863dea7d4da95af3a) +++ uspace/lib/usbhost/src/endpoint.c (revision 64ce0c1435496748632f7682b2657fdc79aad634) @@ -244,7 +244,5 @@ /** Limit transfers with reserved bandwidth to the amount reserved */ - if ((ep->transfer_type == USB_TRANSFER_INTERRUPT - || ep->transfer_type == USB_TRANSFER_ISOCHRONOUS) - && size > ep->max_transfer_size) + if (ep->direction == USB_DIRECTION_OUT && size > ep->max_transfer_size) return ENOSPC;