Changeset b7b7898 in mainline for uspace/drv/bus/usb/usbdiag


Ignore:
Timestamp:
2017-12-22T12:03:16Z (8 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.

Location:
uspace/drv/bus/usb/usbdiag
Files:
1 deleted
5 edited

Legend:

Unmodified
Added
Removed

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

    r2986763 rb7b7898  
    4545#define NAME "usbdiag"
    4646
    47 #define TRANSLATE_FUNC_NAME(fun) translate_##fun
    48 #define TRANSLATE_FUNC(fun) \
    49         static int TRANSLATE_FUNC_NAME(fun)(ddf_fun_t *f, int cycles, size_t size)\
    50         {\
    51                 usb_diag_dev_t *dev = ddf_fun_to_usb_diag_dev(f);\
    52                 return fun(dev, cycles, size);\
    53         }
    54 
    55 TRANSLATE_FUNC(usb_diag_stress_intr_out)
    56 TRANSLATE_FUNC(usb_diag_stress_intr_in)
    57 TRANSLATE_FUNC(usb_diag_stress_bulk_out)
    58 TRANSLATE_FUNC(usb_diag_stress_bulk_in)
    59 TRANSLATE_FUNC(usb_diag_stress_isoch_out)
    60 TRANSLATE_FUNC(usb_diag_stress_isoch_in)
    61 
    6247static usbdiag_iface_t diag_interface = {
    63         .stress_intr_out = TRANSLATE_FUNC_NAME(usb_diag_stress_intr_out),
    64         .stress_intr_in = TRANSLATE_FUNC_NAME(usb_diag_stress_intr_in),
    65         .stress_bulk_out = TRANSLATE_FUNC_NAME(usb_diag_stress_bulk_out),
    66         .stress_bulk_in = TRANSLATE_FUNC_NAME(usb_diag_stress_bulk_in),
    67         .stress_isoch_out = TRANSLATE_FUNC_NAME(usb_diag_stress_isoch_out),
    68         .stress_isoch_in = TRANSLATE_FUNC_NAME(usb_diag_stress_isoch_in)
     48        .burst_intr_in = usbdiag_burst_test_intr_in,
     49        .burst_intr_out = usbdiag_burst_test_intr_out,
     50        .burst_bulk_in = usbdiag_burst_test_bulk_in,
     51        .burst_bulk_out = usbdiag_burst_test_bulk_out,
     52        .burst_isoch_in = usbdiag_burst_test_isoch_in,
     53        .burst_isoch_out = usbdiag_burst_test_isoch_out
    6954};
    70 
    71 #undef TRANSLATE_FUNC_NAME
    72 #undef TRANSLATE_FUNC
    7355
    7456static ddf_dev_ops_t diag_ops = {
    … …  
    7658};
    7759
    78 static int device_init(usb_diag_dev_t *dev)
     60static int device_init(usbdiag_dev_t *dev)
    7961{
    8062        int rc;
    … …  
    8971
    9072#define _MAP_EP(target, ep_no) do {\
    91         usb_endpoint_mapping_t *epm = usb_device_get_mapped_ep(dev->usb_dev, USB_DIAG_EP_##ep_no);\
     73        usb_endpoint_mapping_t *epm = usb_device_get_mapped_ep(dev->usb_dev, USBDIAG_EP_##ep_no);\
    9274        if (!epm || !epm->present) {\
    9375                usb_log_error("Failed to map endpoint: " #ep_no ".\n");\
    … …  
    11597}
    11698
    117 static void device_fini(usb_diag_dev_t *dev)
     99static void device_fini(usbdiag_dev_t *dev)
    118100{
    119101        ddf_fun_destroy(dev->fun);
    120102}
    121103
    122 int usb_diag_dev_create(usb_device_t *dev, usb_diag_dev_t **out_diag_dev)
     104int usbdiag_dev_create(usb_device_t *dev, usbdiag_dev_t **out_diag_dev)
    123105{
    124106        assert(dev);
    125107        assert(out_diag_dev);
    126108
    127         usb_diag_dev_t *diag_dev = usb_device_data_alloc(dev, sizeof(usb_diag_dev_t));
     109        usbdiag_dev_t *diag_dev = usb_device_data_alloc(dev, sizeof(usbdiag_dev_t));
    128110        if (!diag_dev)
    129111                return ENOMEM;
    … …  
    143125}
    144126
    145 void usb_diag_dev_destroy(usb_diag_dev_t *dev)
     127void usbdiag_dev_destroy(usbdiag_dev_t *dev)
    146128{
    147129        assert(dev);

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

    r2986763 rb7b7898  
    3434 */
    3535
    36 #ifndef USB_DIAG_DEVICE_H_
    37 #define USB_DIAG_DEVICE_H_
     36#ifndef USBDIAG_DEVICE_H_
     37#define USBDIAG_DEVICE_H_
    3838
    3939#include <usb/dev/device.h>
    4040
    41 #define USB_DIAG_EP_INTR_IN    1
    42 #define USB_DIAG_EP_INTR_OUT   2
    43 #define USB_DIAG_EP_BULK_IN    3
    44 #define USB_DIAG_EP_BULK_OUT   4
    45 #define USB_DIAG_EP_ISOCH_IN   5
    46 #define USB_DIAG_EP_ISOCH_OUT  6
     41#define USBDIAG_EP_INTR_IN    1
     42#define USBDIAG_EP_INTR_OUT   2
     43#define USBDIAG_EP_BULK_IN    3
     44#define USBDIAG_EP_BULK_OUT   4
     45#define USBDIAG_EP_ISOCH_IN   5
     46#define USBDIAG_EP_ISOCH_OUT  6
    4747
    4848/**
    4949 * USB diagnostic device.
    5050 */
    51 typedef struct usb_diag_dev {
     51typedef struct usbdiag_dev {
    5252        usb_device_t *usb_dev;
    5353        ddf_fun_t *fun;
    … …  
    5858        usb_pipe_t *isoch_in;
    5959        usb_pipe_t *isoch_out;
    60 } usb_diag_dev_t;
     60} usbdiag_dev_t;
    6161
    62 int usb_diag_dev_create(usb_device_t *, usb_diag_dev_t **);
    63 void usb_diag_dev_destroy(usb_diag_dev_t *);
     62int usbdiag_dev_create(usb_device_t *, usbdiag_dev_t **);
     63void usbdiag_dev_destroy(usbdiag_dev_t *);
    6464
    65 static inline usb_diag_dev_t * usb_device_to_usb_diag_dev(usb_device_t *usb_dev)
     65static inline usbdiag_dev_t * usb_device_to_usbdiag_dev(usb_device_t *usb_dev)
    6666{
    6767        assert(usb_dev);
    … …  
    6969}
    7070
    71 static inline usb_diag_dev_t * ddf_dev_to_usb_diag_dev(ddf_dev_t *ddf_dev)
     71static inline usbdiag_dev_t * ddf_dev_to_usbdiag_dev(ddf_dev_t *ddf_dev)
    7272{
    7373        assert(ddf_dev);
    74         return usb_device_to_usb_diag_dev(usb_device_get(ddf_dev));
     74        return usb_device_to_usbdiag_dev(usb_device_get(ddf_dev));
    7575}
    7676
    77 static inline usb_diag_dev_t * ddf_fun_to_usb_diag_dev(ddf_fun_t *ddf_fun)
     77static inline usbdiag_dev_t * ddf_fun_to_usbdiag_dev(ddf_fun_t *ddf_fun)
    7878{
    7979        assert(ddf_fun);
    80         return ddf_dev_to_usb_diag_dev(ddf_fun_get_dev(ddf_fun));
     80        return ddf_dev_to_usbdiag_dev(ddf_fun_get_dev(ddf_fun));
    8181}
    8282
    83 #endif /* USB_DIAG_USBDIAG_H_ */
     83#endif /* USBDIAG_USBDIAG_H_ */
    8484
    8585/**

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

    r2986763 rb7b7898  
    4141#include <str_error.h>
    4242
    43 #include "usbdiag.h"
    4443#include "device.h"
    4544
    … …  
    5150        usb_log_info("Adding device '%s'", usb_device_get_name(dev));
    5251
    53         usb_diag_dev_t *diag_dev;
    54         if ((rc = usb_diag_dev_create(dev, &diag_dev))) {
     52        usbdiag_dev_t *diag_dev;
     53        if ((rc = usbdiag_dev_create(dev, &diag_dev))) {
    5554                usb_log_error("Failed create device: %s.\n", str_error(rc));
    5655                goto err;
    … …  
    7372        ddf_fun_unbind(diag_dev->fun);
    7473err_create:
    75         usb_diag_dev_destroy(diag_dev);
     74        usbdiag_dev_destroy(diag_dev);
    7675err:
    7776        return rc;
    … …  
    8382        usb_log_info("Removing device '%s'", usb_device_get_name(dev));
    8483
    85         usb_diag_dev_t *diag_dev = usb_device_to_usb_diag_dev(dev);
     84        usbdiag_dev_t *diag_dev = usb_device_to_usbdiag_dev(dev);
    8685
    8786        /* TODO: Make sure nothing is going on with the device. */
    … …  
    9291        }
    9392
    94         usb_diag_dev_destroy(diag_dev);
     93        usbdiag_dev_destroy(diag_dev);
    9594
    9695        return EOK;
    … …  
    104103        usb_log_info("Device '%s' gone.", usb_device_get_name(dev));
    105104
    106         usb_diag_dev_t *diag_dev = usb_device_to_usb_diag_dev(dev);
     105        usbdiag_dev_t *diag_dev = usb_device_to_usbdiag_dev(dev);
    107106
    108107        /* TODO: Make sure nothing is going on with the device. */
    … …  
    110109        /* TODO: Remove device from list */
    111110
    112         usb_diag_dev_destroy(diag_dev);
     111        usbdiag_dev_destroy(diag_dev);
    113112
    114113        return EOK;
    … …  
    175174
    176175static const usb_endpoint_description_t *diag_endpoints[] = {
    177         [USB_DIAG_EP_INTR_IN] = &intr_in_ep,
    178         [USB_DIAG_EP_INTR_OUT] = &intr_out_ep,
    179         [USB_DIAG_EP_BULK_IN] = &bulk_in_ep,
    180         [USB_DIAG_EP_BULK_OUT] = &bulk_out_ep,
    181         [USB_DIAG_EP_ISOCH_IN] = &isoch_in_ep,
    182         [USB_DIAG_EP_ISOCH_OUT] = &isoch_out_ep,
     176        [USBDIAG_EP_INTR_IN] = &intr_in_ep,
     177        [USBDIAG_EP_INTR_OUT] = &intr_out_ep,
     178        [USBDIAG_EP_BULK_IN] = &bulk_in_ep,
     179        [USBDIAG_EP_BULK_OUT] = &bulk_out_ep,
     180        [USBDIAG_EP_ISOCH_IN] = &isoch_in_ep,
     181        [USBDIAG_EP_ISOCH_OUT] = &isoch_out_ep,
    183182        NULL
    184183};

  • 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

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

    r2986763 rb7b7898  
    3434 */
    3535
    36 #ifndef USB_DIAG_TESTS_H_
    37 #define USB_DIAG_TESTS_H_
     36#ifndef USBDIAG_TESTS_H_
     37#define USBDIAG_TESTS_H_
    3838
    39 #include "device.h"
     39#include <ddf/driver.h>
    4040
    41 int usb_diag_stress_intr_out(usb_diag_dev_t *, int, size_t);
    42 int usb_diag_stress_intr_in(usb_diag_dev_t *, int, size_t);
    43 int usb_diag_stress_bulk_out(usb_diag_dev_t *, int, size_t);
    44 int usb_diag_stress_bulk_in(usb_diag_dev_t *, int, size_t);
    45 int usb_diag_stress_isoch_out(usb_diag_dev_t *, int, size_t);
    46 int usb_diag_stress_isoch_in(usb_diag_dev_t *, int, size_t);
     41int usbdiag_burst_test_intr_in(ddf_fun_t *, int, size_t);
     42int usbdiag_burst_test_intr_out(ddf_fun_t *, int, size_t);
     43int usbdiag_burst_test_bulk_in(ddf_fun_t *, int, size_t);
     44int usbdiag_burst_test_bulk_out(ddf_fun_t *, int, size_t);
     45int usbdiag_burst_test_isoch_in(ddf_fun_t *, int, size_t);
     46int usbdiag_burst_test_isoch_out(ddf_fun_t *, int, size_t);
    4747
    48 #endif /* USB_DIAG_TESTS_H_ */
     48#endif /* USBDIAG_TESTS_H_ */
    4949
    5050/**
Note: See TracChangeset for help on using the changeset viewer.