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); }