Changeset b7b7898 in mainline for uspace/drv/bus/usb/usbdiag/tests.c


Ignore:
Timestamp:
2017-12-22T12:03:16Z (6 years ago)
Author:
Petr Mánek <petr.manek@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
96c416a
Parents:
2986763
git-author:
Petr Mánek <petr.manek@…> (2017-12-22 12:02:50)
git-committer:
Petr Mánek <petr.manek@…> (2017-12-22 12:03:16)
Message:

usbdiag: refactoring

Reconciliated the usb_diag and usbdiag prefix in favor of the latter. Removed a ton of copy-pasta code for the burst tests in favor of single generic static burst test for every direction, which is then called by individual functions for different endpoint type. This also allowed to get rid of the ugly translation macros in device.c. Deleted unused usbdiag.h header file. Refactored the remote interface to comply with all aforementioned modifications.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r2986763 rb7b7898  
    3737#include <str_error.h>
    3838#include <usb/debug.h>
     39#include "device.h"
    3940#include "tests.h"
    4041
    4142#define NAME "usbdiag"
    4243
     44static int burst_in_test(usb_pipe_t *pipe, int cycles, size_t size)
     45{
     46        if (!pipe)
     47                return EBADMEM;
    4348
    44 int usb_diag_stress_intr_out(usb_diag_dev_t *dev, int cycles, size_t size)
     49        char *buffer = (char *) malloc(size);
     50        if (!buffer)
     51                return ENOMEM;
     52
     53        // TODO: Are we sure that no other test is running on this endpoint?
     54
     55        usb_log_info("Performing %s IN burst test.", usb_str_transfer_type(pipe->desc.transfer_type));
     56        int rc = EOK;
     57        for (int i = 0; i < cycles; ++i) {
     58                // Read device's response.
     59                size_t remaining = size;
     60                size_t transferred;
     61
     62                while (remaining > 0) {
     63                        if ((rc = usb_pipe_read(pipe, buffer + size - remaining, remaining, &transferred))) {
     64                                usb_log_error("Read of %s IN endpoint failed with error: %s\n", usb_str_transfer_type(pipe->desc.transfer_type), str_error(rc));
     65                                break;
     66                        }
     67
     68                        if (transferred > remaining) {
     69                                usb_log_error("Read of %s IN endpoint returned more data than expected.\n", usb_str_transfer_type(pipe->desc.transfer_type));
     70                                rc = EINVAL;
     71                                break;
     72                        }
     73
     74                        remaining -= transferred;
     75                }
     76
     77                if (rc)
     78                        break;
     79        }
     80        usb_log_info("Burst test on %s IN endpoint completed.", usb_str_transfer_type(pipe->desc.transfer_type));
     81
     82        free(buffer);
     83        return rc;
     84}
     85
     86static int burst_out_test(usb_pipe_t *pipe, int cycles, size_t size)
    4587{
    46         if (!dev)
     88        if (!pipe)
    4789                return EBADMEM;
    4890
    … …  
    5597        // TODO: Are we sure that no other test is running on this endpoint?
    5698
    57         usb_log_info("Performing interrupt out stress test on device %s.", ddf_fun_get_name(dev->fun));
     99        usb_log_info("Performing %s OUT burst test.", usb_str_transfer_type(pipe->desc.transfer_type));
    58100        int rc = EOK;
    59101        for (int i = 0; i < cycles; ++i) {
    60102                // Write buffer to device.
    61                 if ((rc = usb_pipe_write(dev->intr_out, buffer, size))) {
    62                         usb_log_error("Interrupt OUT write failed. %s\n", str_error(rc));
     103                if ((rc = usb_pipe_write(pipe, buffer, size))) {
     104                        usb_log_error("Write to %s OUT endpoint failed with error: %s\n", usb_str_transfer_type(pipe->desc.transfer_type), str_error(rc));
    63105                        break;
    64106                }
    65107        }
     108        usb_log_info("Burst test on %s OUT endpoint completed.", usb_str_transfer_type(pipe->desc.transfer_type));
    66109
    67110        free(buffer);
    … …  
    69112}
    70113
    71 int usb_diag_stress_intr_in(usb_diag_dev_t *dev, int cycles, size_t size)
     114int usbdiag_burst_test_intr_in(ddf_fun_t *fun, int cycles, size_t size)
    72115{
     116        usbdiag_dev_t *dev = ddf_fun_to_usbdiag_dev(fun);
    73117        if (!dev)
    74118                return EBADMEM;
    75119
    76         char *buffer = (char *) malloc(size);
    77         if (!buffer)
    78                 return ENOMEM;
    79 
    80         // TODO: Are we sure that no other test is running on this endpoint?
    81 
    82         usb_log_info("Performing interrupt in stress test on device %s.", ddf_fun_get_name(dev->fun));
    83         int rc = EOK;
    84         for (int i = 0; i < cycles; ++i) {
    85                 // Read device's response.
    86                 size_t remaining = size;
    87                 size_t transferred;
    88 
    89                 while (remaining > 0) {
    90                         if ((rc = usb_pipe_read(dev->intr_in, buffer + size - remaining, remaining, &transferred))) {
    91                                 usb_log_error("Interrupt IN read failed. %s\n", str_error(rc));
    92                                 break;
    93                         }
    94 
    95                         if (transferred > remaining) {
    96                                 usb_log_error("Interrupt IN read more than expected.\n");
    97                                 rc = EINVAL;
    98                                 break;
    99                         }
    100 
    101                         remaining -= transferred;
    102                 }
    103 
    104                 if (rc)
    105                         break;
    106         }
    107 
    108         free(buffer);
    109         return rc;
     120        return burst_in_test(dev->intr_in, cycles, size);
    110121}
    111122
    112 int usb_diag_stress_bulk_out(usb_diag_dev_t *dev, int cycles, size_t size)
     123int usbdiag_burst_test_intr_out(ddf_fun_t *fun, int cycles, size_t size)
    113124{
     125        usbdiag_dev_t *dev = ddf_fun_to_usbdiag_dev(fun);
    114126        if (!dev)
    115127                return EBADMEM;
    116128
    117         char *buffer = (char *) malloc(size);
    118         if (!buffer)
    119                 return ENOMEM;
    120 
    121         memset(buffer, 42, size);
    122 
    123         // TODO: Are we sure that no other test is running on this endpoint?
    124 
    125         usb_log_info("Performing bulk out stress test on device %s.", ddf_fun_get_name(dev->fun));
    126         int rc = EOK;
    127         for (int i = 0; i < cycles; ++i) {
    128                 // Write buffer to device.
    129                 if ((rc = usb_pipe_write(dev->bulk_out, buffer, size))) {
    130                         usb_log_error("Bulk OUT write failed. %s\n", str_error(rc));
    131                         break;
    132                 }
    133         }
    134 
    135         free(buffer);
    136         return rc;
     129        return burst_out_test(dev->intr_out, cycles, size);
    137130}
    138131
    139 int usb_diag_stress_bulk_in(usb_diag_dev_t *dev, int cycles, size_t size)
     132int usbdiag_burst_test_bulk_in(ddf_fun_t *fun, int cycles, size_t size)
    140133{
     134        usbdiag_dev_t *dev = ddf_fun_to_usbdiag_dev(fun);
    141135        if (!dev)
    142136                return EBADMEM;
    143137
    144         char *buffer = (char *) malloc(size);
    145         if (!buffer)
    146                 return ENOMEM;
    147 
    148         // TODO: Are we sure that no other test is running on this endpoint?
    149 
    150         usb_log_info("Performing bulk in stress test on device %s.", ddf_fun_get_name(dev->fun));
    151         int rc = EOK;
    152         for (int i = 0; i < cycles; ++i) {
    153                 // Read device's response.
    154                 size_t remaining = size;
    155                 size_t transferred;
    156 
    157                 while (remaining > 0) {
    158                         if ((rc = usb_pipe_read(dev->bulk_in, buffer + size - remaining, remaining, &transferred))) {
    159                                 usb_log_error("Bulk IN read failed. %s\n", str_error(rc));
    160                                 break;
    161                         }
    162 
    163                         if (transferred > remaining) {
    164                                 usb_log_error("Bulk IN read more than expected.\n");
    165                                 rc = EINVAL;
    166                                 break;
    167                         }
    168 
    169                         remaining -= transferred;
    170                 }
    171 
    172                 if (rc)
    173                         break;
    174         }
    175 
    176         free(buffer);
    177         return rc;
     138        return burst_in_test(dev->bulk_in, cycles, size);
    178139}
    179140
    180 int usb_diag_stress_isoch_out(usb_diag_dev_t *dev, int cycles, size_t size)
     141int usbdiag_burst_test_bulk_out(ddf_fun_t *fun, int cycles, size_t size)
    181142{
     143        usbdiag_dev_t *dev = ddf_fun_to_usbdiag_dev(fun);
    182144        if (!dev)
    183145                return EBADMEM;
    184146
    185         char *buffer = (char *) malloc(size);
    186         if (!buffer)
    187                 return ENOMEM;
    188 
    189         memset(buffer, 42, size);
    190 
    191         // TODO: Are we sure that no other test is running on this endpoint?
    192 
    193         usb_log_info("Performing isochronous out stress test on device %s.", ddf_fun_get_name(dev->fun));
    194         int rc = EOK;
    195         for (int i = 0; i < cycles; ++i) {
    196                 // Write buffer to device.
    197                 if ((rc = usb_pipe_write(dev->isoch_out, buffer, size))) {
    198                         usb_log_error("Isochronous OUT write failed. %s\n", str_error(rc));
    199                         break;
    200                 }
    201         }
    202 
    203         free(buffer);
    204         return rc;
     147        return burst_out_test(dev->bulk_out, cycles, size);
    205148}
    206149
    207 int usb_diag_stress_isoch_in(usb_diag_dev_t *dev, int cycles, size_t size)
     150int usbdiag_burst_test_isoch_in(ddf_fun_t *fun, int cycles, size_t size)
    208151{
     152        usbdiag_dev_t *dev = ddf_fun_to_usbdiag_dev(fun);
    209153        if (!dev)
    210154                return EBADMEM;
    211155
    212         char *buffer = (char *) malloc(size);
    213         if (!buffer)
    214                 return ENOMEM;
     156        return burst_in_test(dev->isoch_in, cycles, size);
     157}
    215158
    216         // TODO: Are we sure that no other test is running on this endpoint?
     159int usbdiag_burst_test_isoch_out(ddf_fun_t *fun, int cycles, size_t size)
     160{
     161        usbdiag_dev_t *dev = ddf_fun_to_usbdiag_dev(fun);
     162        if (!dev)
     163                return EBADMEM;
    217164
    218         usb_log_info("Performing isochronous in stress test on device %s.", ddf_fun_get_name(dev->fun));
    219         int rc = EOK;
    220         for (int i = 0; i < cycles; ++i) {
    221                 // Read device's response.
    222                 size_t remaining = size;
    223                 size_t transferred;
    224 
    225                 while (remaining > 0) {
    226                         if ((rc = usb_pipe_read(dev->isoch_in, buffer + size - remaining, remaining, &transferred))) {
    227                                 usb_log_error("Isochronous IN read failed. %s\n", str_error(rc));
    228                                 break;
    229                         }
    230 
    231                         if (transferred > remaining) {
    232                                 usb_log_error("Isochronous IN read more than expected.\n");
    233                                 rc = EINVAL;
    234                                 break;
    235                         }
    236 
    237                         remaining -= transferred;
    238                 }
    239 
    240                 if (rc)
    241                         break;
    242         }
    243 
    244         free(buffer);
    245         return rc;
     165        return burst_out_test(dev->isoch_out, cycles, size);
    246166}
    247167
Note: See TracChangeset for help on using the changeset viewer.