Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset b10a434 in mainline


Ignore:
Timestamp:
2017-12-22T13:22:54Z (4 years ago)
Author:
Petr Mánek <petr.manek@…>
Branches:
lfn, master
Children:
00d23a2
Parents:
96c416a
git-author:
Petr Mánek <petr.manek@…> (2017-12-22 13:22:51)
git-committer:
Petr Mánek <petr.manek@…> (2017-12-22 13:22:54)
Message:

usbdiag: refactoring

Remote usbdiag interface has been modified to allow reporting test duration back to the caller. The usbdiag driver has been modified to pass such information to the remote interface. The tmon utility has been modified to display some basic statistical information derived from the received value.

Location:
uspace
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/tmon/burst_tests.c

    r96c416a rb10a434  
    4343#include "tf.h"
    4444
    45 #define NAME "tmon"
     45#define NAME   "tmon"
     46#define INDENT "      "
    4647
    4748typedef struct tmon_burst_test_params {
     
    103104}
    104105
     106static void print_params(const tmon_burst_test_params_t *params)
     107{
     108        printf(INDENT "Number of cycles: %d\n", params->cycles);
     109        printf(INDENT "Data size: %ld B\n", params->size);
     110}
     111
     112static void print_results(const tmon_burst_test_params_t *params, usbdiag_dur_t duration)
     113{
     114        printf(INDENT "Total duration: %ld ms\n", duration);
     115
     116        const double dur_per_cycle = (double) duration / (double) params->cycles;
     117        printf(INDENT "Duration per cycle: %0.3f ms\n", dur_per_cycle);
     118
     119        const double speed = (double) params->size / (double) duration;
     120        printf(INDENT "Transfer speed: %0.3f B/s\n", speed);
     121}
     122
    105123static int run_intr_in(async_exch_t *exch, const tmon_test_params_t *generic_params)
    106124{
    107125        const tmon_burst_test_params_t *params = (tmon_burst_test_params_t *) generic_params;
    108         printf("Executing interrupt in test.\n"
    109             "      Number of cycles: %d\n"
    110             "      Data size: %ld B\n", params->cycles, params->size);
    111 
    112         int rc = usbdiag_burst_intr_in(exch, params->cycles, params->size);
    113         if (rc) {
    114                 printf(NAME ": Test failed. %s\n", str_error(rc));
    115                 return 1;
    116         }
    117 
     126        puts("Reading data from interrupt endpoint.\n");
     127        print_params(params);
     128
     129        usbdiag_dur_t duration;
     130        int rc = usbdiag_burst_intr_in(exch, params->cycles, params->size, &duration);
     131        if (rc) {
     132                printf(NAME ": Test failed with error: %s\n", str_error(rc));
     133                return 1;
     134        }
     135
     136        puts("Test succeeded.\n");
     137        print_results(params, duration);
    118138        return 0;
    119139}
     
    122142{
    123143        const tmon_burst_test_params_t *params = (tmon_burst_test_params_t *) generic_params;
    124         printf("Executing interrupt out test.\n"
    125             "      Number of cycles: %d\n"
    126             "      Data size: %ld B\n", params->cycles, params->size);
    127 
    128         int rc = usbdiag_burst_intr_out(exch, params->cycles, params->size);
    129         if (rc) {
    130                 printf(NAME ": Test failed. %s\n", str_error(rc));
    131                 return 1;
    132         }
    133 
     144        puts("Writing data to interrupt endpoint.\n");
     145        print_params(params);
     146
     147        usbdiag_dur_t duration;
     148        int rc = usbdiag_burst_intr_out(exch, params->cycles, params->size, &duration);
     149        if (rc) {
     150                printf(NAME ": Test failed with error: %s\n", str_error(rc));
     151                return 1;
     152        }
     153
     154        puts("Test succeeded.\n");
     155        print_results(params, duration);
    134156        return 0;
    135157}
     
    138160{
    139161        const tmon_burst_test_params_t *params = (tmon_burst_test_params_t *) generic_params;
    140         printf("Executing bulk in test.\n"
    141             "      Number of cycles: %d\n"
    142             "      Data size: %ld B\n", params->cycles, params->size);
    143 
    144         int rc = usbdiag_burst_bulk_in(exch, params->cycles, params->size);
    145         if (rc) {
    146                 printf(NAME ": Test failed. %s\n", str_error(rc));
    147                 return 1;
    148         }
    149 
     162        puts("Reading data from bulk endpoint.\n");
     163        print_params(params);
     164
     165        usbdiag_dur_t duration;
     166        int rc = usbdiag_burst_bulk_in(exch, params->cycles, params->size, &duration);
     167        if (rc) {
     168                printf(NAME ": Test failed with error: %s\n", str_error(rc));
     169                return 1;
     170        }
     171
     172        puts("Test succeeded.\n");
     173        print_results(params, duration);
    150174        return 0;
    151175}
     
    154178{
    155179        const tmon_burst_test_params_t *params = (tmon_burst_test_params_t *) generic_params;
    156         printf("Executing bulk out test.\n"
    157             "      Number of cycles: %d\n"
    158             "      Data size: %ld B\n", params->cycles, params->size);
    159 
    160         int rc = usbdiag_burst_bulk_out(exch, params->cycles, params->size);
    161         if (rc) {
    162                 printf(NAME ": Test failed. %s\n", str_error(rc));
    163                 return 1;
    164         }
    165 
     180        puts("Writing data to bulk endpoint.\n");
     181        print_params(params);
     182
     183        usbdiag_dur_t duration;
     184        int rc = usbdiag_burst_bulk_out(exch, params->cycles, params->size, &duration);
     185        if (rc) {
     186                printf(NAME ": Test failed with error: %s\n", str_error(rc));
     187                return 1;
     188        }
     189
     190        puts("Test succeeded.\n");
     191        print_results(params, duration);
    166192        return 0;
    167193}
     
    170196{
    171197        const tmon_burst_test_params_t *params = (tmon_burst_test_params_t *) generic_params;
    172         printf("Executing isochronous in test.\n"
    173             "      Number of cycles: %d\n"
    174             "      Data size: %ld B\n", params->cycles, params->size);
    175 
    176         int rc = usbdiag_burst_isoch_in(exch, params->cycles, params->size);
    177         if (rc) {
    178                 printf(NAME ": Test failed. %s\n", str_error(rc));
    179                 return 1;
    180         }
    181 
     198        puts("Reading data from isochronous endpoint.\n");
     199        print_params(params);
     200
     201        usbdiag_dur_t duration;
     202        int rc = usbdiag_burst_isoch_in(exch, params->cycles, params->size, &duration);
     203        if (rc) {
     204                printf(NAME ": Test failed with error: %s\n", str_error(rc));
     205                return 1;
     206        }
     207
     208        puts("Test succeeded.\n");
     209        print_results(params, duration);
    182210        return 0;
    183211}
     
    186214{
    187215        const tmon_burst_test_params_t *params = (tmon_burst_test_params_t *) generic_params;
    188         printf("Executing isochronous out test.\n"
    189             "      Number of cycles: %d\n"
    190             "      Data size: %ld B\n", params->cycles, params->size);
    191 
    192         int rc = usbdiag_burst_isoch_out(exch, params->cycles, params->size);
    193         if (rc) {
    194                 printf(NAME ": Test failed. %s\n", str_error(rc));
    195                 return 1;
    196         }
    197 
     216        puts("Writing data to isochronous endpoint.\n");
     217        print_params(params);
     218
     219        usbdiag_dur_t duration;
     220        int rc = usbdiag_burst_isoch_out(exch, params->cycles, params->size, &duration);
     221        if (rc) {
     222                printf(NAME ": Test failed with error: %s\n", str_error(rc));
     223                return 1;
     224        }
     225
     226        puts("Test succeeded.\n");
     227        print_results(params, duration);
    198228        return 0;
    199229}
  • uspace/drv/bus/usb/usbdiag/tests.c

    r96c416a rb10a434  
    3737#include <str_error.h>
    3838#include <usb/debug.h>
     39#include <usbdiag_iface.h>
    3940#include <time.h>
    4041#include "device.h"
     
    4344#define NAME "usbdiag"
    4445
    45 static int burst_in_test(usb_pipe_t *pipe, int cycles, size_t size, unsigned long *duration)
     46static int burst_in_test(usb_pipe_t *pipe, int cycles, size_t size, usbdiag_dur_t *duration)
    4647{
    4748        if (!pipe)
     
    8687        struct timeval final_time;
    8788        gettimeofday(&final_time, NULL);
    88         unsigned long in_duration = ((final_time.tv_usec - start_time.tv_usec) / 1000) +
     89        usbdiag_dur_t in_duration = ((final_time.tv_usec - start_time.tv_usec) / 1000) +
    8990            ((final_time.tv_sec - start_time.tv_sec) * 1000);
    9091
     
    9899}
    99100
    100 static int burst_out_test(usb_pipe_t *pipe, int cycles, size_t size, unsigned long *duration)
     101static int burst_out_test(usb_pipe_t *pipe, int cycles, size_t size, usbdiag_dur_t *duration)
    101102{
    102103        if (!pipe)
     
    127128        struct timeval final_time;
    128129        gettimeofday(&final_time, NULL);
    129         unsigned long in_duration = ((final_time.tv_usec - start_time.tv_usec) / 1000) +
     130        usbdiag_dur_t in_duration = ((final_time.tv_usec - start_time.tv_usec) / 1000) +
    130131            ((final_time.tv_sec - start_time.tv_sec) * 1000);
    131132
     
    139140}
    140141
    141 int usbdiag_burst_test_intr_in(ddf_fun_t *fun, int cycles, size_t size)
     142int usbdiag_burst_test_intr_in(ddf_fun_t *fun, int cycles, size_t size, usbdiag_dur_t *duration)
    142143{
    143144        usbdiag_dev_t *dev = ddf_fun_to_usbdiag_dev(fun);
     
    145146                return EBADMEM;
    146147
    147         // FIXME: report duration
    148         return burst_in_test(dev->intr_in, cycles, size, NULL);
     148        return burst_in_test(dev->intr_in, cycles, size, duration);
    149149}
    150150
    151 int usbdiag_burst_test_intr_out(ddf_fun_t *fun, int cycles, size_t size)
     151int usbdiag_burst_test_intr_out(ddf_fun_t *fun, int cycles, size_t size, usbdiag_dur_t *duration)
    152152{
    153153        usbdiag_dev_t *dev = ddf_fun_to_usbdiag_dev(fun);
     
    155155                return EBADMEM;
    156156
    157         // FIXME: report duration
    158         return burst_out_test(dev->intr_out, cycles, size, NULL);
     157        return burst_out_test(dev->intr_out, cycles, size, duration);
    159158}
    160159
    161 int usbdiag_burst_test_bulk_in(ddf_fun_t *fun, int cycles, size_t size)
     160int usbdiag_burst_test_bulk_in(ddf_fun_t *fun, int cycles, size_t size, usbdiag_dur_t *duration)
    162161{
    163162        usbdiag_dev_t *dev = ddf_fun_to_usbdiag_dev(fun);
     
    165164                return EBADMEM;
    166165
    167         // FIXME: report duration
    168         return burst_in_test(dev->bulk_in, cycles, size, NULL);
     166        return burst_in_test(dev->bulk_in, cycles, size, duration);
    169167}
    170168
    171 int usbdiag_burst_test_bulk_out(ddf_fun_t *fun, int cycles, size_t size)
     169int usbdiag_burst_test_bulk_out(ddf_fun_t *fun, int cycles, size_t size, usbdiag_dur_t *duration)
    172170{
    173171        usbdiag_dev_t *dev = ddf_fun_to_usbdiag_dev(fun);
     
    175173                return EBADMEM;
    176174
    177         // FIXME: report duration
    178         return burst_out_test(dev->bulk_out, cycles, size, NULL);
     175        return burst_out_test(dev->bulk_out, cycles, size, duration);
    179176}
    180177
    181 int usbdiag_burst_test_isoch_in(ddf_fun_t *fun, int cycles, size_t size)
     178int usbdiag_burst_test_isoch_in(ddf_fun_t *fun, int cycles, size_t size, usbdiag_dur_t *duration)
    182179{
    183180        usbdiag_dev_t *dev = ddf_fun_to_usbdiag_dev(fun);
     
    185182                return EBADMEM;
    186183
    187         // FIXME: report duration
    188         return burst_in_test(dev->isoch_in, cycles, size, NULL);
     184        return burst_in_test(dev->isoch_in, cycles, size, duration);
    189185}
    190186
    191 int usbdiag_burst_test_isoch_out(ddf_fun_t *fun, int cycles, size_t size)
     187int usbdiag_burst_test_isoch_out(ddf_fun_t *fun, int cycles, size_t size, usbdiag_dur_t *duration)
    192188{
    193189        usbdiag_dev_t *dev = ddf_fun_to_usbdiag_dev(fun);
     
    195191                return EBADMEM;
    196192
    197         // FIXME: report duration
    198         return burst_out_test(dev->isoch_out, cycles, size, NULL);
     193        return burst_out_test(dev->isoch_out, cycles, size, duration);
    199194}
    200195
  • uspace/drv/bus/usb/usbdiag/tests.h

    r96c416a rb10a434  
    3939#include <ddf/driver.h>
    4040
    41 int usbdiag_burst_test_intr_in(ddf_fun_t *, int, size_t);
    42 int usbdiag_burst_test_intr_out(ddf_fun_t *, int, size_t);
    43 int usbdiag_burst_test_bulk_in(ddf_fun_t *, int, size_t);
    44 int usbdiag_burst_test_bulk_out(ddf_fun_t *, int, size_t);
    45 int usbdiag_burst_test_isoch_in(ddf_fun_t *, int, size_t);
    46 int usbdiag_burst_test_isoch_out(ddf_fun_t *, int, size_t);
     41int usbdiag_burst_test_intr_in(ddf_fun_t *, int, size_t, usbdiag_dur_t *);
     42int usbdiag_burst_test_intr_out(ddf_fun_t *, int, size_t, usbdiag_dur_t *);
     43int usbdiag_burst_test_bulk_in(ddf_fun_t *, int, size_t, usbdiag_dur_t *);
     44int usbdiag_burst_test_bulk_out(ddf_fun_t *, int, size_t, usbdiag_dur_t *);
     45int usbdiag_burst_test_isoch_in(ddf_fun_t *, int, size_t, usbdiag_dur_t *);
     46int usbdiag_burst_test_isoch_out(ddf_fun_t *, int, size_t, usbdiag_dur_t *);
    4747
    4848#endif /* USBDIAG_TESTS_H_ */
  • uspace/lib/drv/generic/remote_usbdiag.c

    r96c416a rb10a434  
    6262}
    6363
    64 int usbdiag_burst_intr_in(async_exch_t *exch, int cycles, size_t size)
    65 {
    66         if (!exch)
    67                 return EBADMEM;
    68 
    69         return async_req_3_0(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_BURST_INTR_IN, cycles, size);
    70 }
    71 
    72 int usbdiag_burst_intr_out(async_exch_t *exch, int cycles, size_t size)
    73 {
    74         if (!exch)
    75                 return EBADMEM;
    76 
    77         return async_req_3_0(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_BURST_INTR_OUT, cycles, size);
    78 }
    79 
    80 int usbdiag_burst_bulk_in(async_exch_t *exch, int cycles, size_t size)
    81 {
    82         if (!exch)
    83                 return EBADMEM;
    84 
    85         return async_req_3_0(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_BURST_BULK_IN, cycles, size);
    86 }
    87 
    88 int usbdiag_burst_bulk_out(async_exch_t *exch, int cycles, size_t size)
    89 {
    90         if (!exch)
    91                 return EBADMEM;
    92 
    93         return async_req_3_0(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_BURST_BULK_OUT, cycles, size);
    94 }
    95 
    96 int usbdiag_burst_isoch_in(async_exch_t *exch, int cycles, size_t size)
    97 {
    98         if (!exch)
    99                 return EBADMEM;
    100 
    101         return async_req_3_0(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_BURST_ISOCH_IN, cycles, size);
    102 }
    103 
    104 int usbdiag_burst_isoch_out(async_exch_t *exch, int cycles, size_t size)
    105 {
    106         if (!exch)
    107                 return EBADMEM;
    108 
    109         return async_req_3_0(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_BURST_ISOCH_OUT, cycles, size);
     64int usbdiag_burst_intr_in(async_exch_t *exch, int cycles, size_t size, usbdiag_dur_t *duration)
     65{
     66        if (!exch)
     67                return EBADMEM;
     68
     69        sysarg_t duration_;
     70        const int rc = async_req_3_1(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_BURST_INTR_IN, cycles, size, &duration_);
     71
     72        if (rc == EOK && duration)
     73                *duration = duration_;
     74
     75        return rc;
     76}
     77
     78int usbdiag_burst_intr_out(async_exch_t *exch, int cycles, size_t size, usbdiag_dur_t *duration)
     79{
     80        if (!exch)
     81                return EBADMEM;
     82
     83        sysarg_t duration_;
     84        const int rc = async_req_3_1(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_BURST_INTR_OUT, cycles, size, &duration_);
     85
     86        if (rc == EOK && duration)
     87                *duration = duration_;
     88
     89        return rc;
     90}
     91
     92int usbdiag_burst_bulk_in(async_exch_t *exch, int cycles, size_t size, usbdiag_dur_t *duration)
     93{
     94        if (!exch)
     95                return EBADMEM;
     96
     97        sysarg_t duration_;
     98        const int rc = async_req_3_1(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_BURST_BULK_IN, cycles, size, &duration_);
     99
     100        if (rc == EOK && duration)
     101                *duration = duration_;
     102
     103        return rc;
     104}
     105
     106int usbdiag_burst_bulk_out(async_exch_t *exch, int cycles, size_t size, usbdiag_dur_t *duration)
     107{
     108        if (!exch)
     109                return EBADMEM;
     110
     111        sysarg_t duration_;
     112        const int rc = async_req_3_1(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_BURST_BULK_OUT, cycles, size, &duration_);
     113
     114        if (rc == EOK && duration)
     115                *duration = duration_;
     116
     117        return rc;
     118}
     119
     120int usbdiag_burst_isoch_in(async_exch_t *exch, int cycles, size_t size, usbdiag_dur_t *duration)
     121{
     122        if (!exch)
     123                return EBADMEM;
     124
     125        sysarg_t duration_;
     126        const int rc = async_req_3_1(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_BURST_ISOCH_IN, cycles, size, &duration_);
     127
     128        if (rc == EOK && duration)
     129                *duration = duration_;
     130
     131        return rc;
     132}
     133
     134int usbdiag_burst_isoch_out(async_exch_t *exch, int cycles, size_t size, usbdiag_dur_t *duration)
     135{
     136        if (!exch)
     137                return EBADMEM;
     138
     139        sysarg_t duration_;
     140        const int rc = async_req_3_1(exch, DEV_IFACE_ID(USBDIAG_DEV_IFACE), IPC_M_USBDIAG_BURST_ISOCH_OUT, cycles, size, &duration_);
     141
     142        if (rc == EOK && duration)
     143                *duration = duration_;
     144
     145        return rc;
    110146}
    111147
     
    144180        int cycles = DEV_IPC_GET_ARG1(*call);
    145181        size_t size = DEV_IPC_GET_ARG2(*call);
    146         const int ret = diag_iface->burst_intr_in(fun, cycles, size);
    147         async_answer_0(callid, ret);
     182        usbdiag_dur_t duration;
     183        const int ret = diag_iface->burst_intr_in(fun, cycles, size, &duration);
     184
     185        if (ret != EOK) {
     186                async_answer_0(callid, ret);
     187        } else {
     188                async_answer_1(callid, EOK, duration);
     189        }
    148190}
    149191
     
    159201        int cycles = DEV_IPC_GET_ARG1(*call);
    160202        size_t size = DEV_IPC_GET_ARG2(*call);
    161         const int ret = diag_iface->burst_intr_out(fun, cycles, size);
    162         async_answer_0(callid, ret);
     203        usbdiag_dur_t duration;
     204        const int ret = diag_iface->burst_intr_out(fun, cycles, size, &duration);
     205
     206        if (ret != EOK) {
     207                async_answer_0(callid, ret);
     208        } else {
     209                async_answer_1(callid, EOK, duration);
     210        }
    163211}
    164212
     
    174222        int cycles = DEV_IPC_GET_ARG1(*call);
    175223        size_t size = DEV_IPC_GET_ARG2(*call);
    176         const int ret = diag_iface->burst_bulk_in(fun, cycles, size);
    177         async_answer_0(callid, ret);
     224        usbdiag_dur_t duration;
     225        const int ret = diag_iface->burst_bulk_in(fun, cycles, size, &duration);
     226
     227        if (ret != EOK) {
     228                async_answer_0(callid, ret);
     229        } else {
     230                async_answer_1(callid, EOK, duration);
     231        }
    178232}
    179233
     
    189243        int cycles = DEV_IPC_GET_ARG1(*call);
    190244        size_t size = DEV_IPC_GET_ARG2(*call);
    191         const int ret = diag_iface->burst_bulk_out(fun, cycles, size);
    192         async_answer_0(callid, ret);
     245        usbdiag_dur_t duration;
     246        const int ret = diag_iface->burst_bulk_out(fun, cycles, size, &duration);
     247
     248        if (ret != EOK) {
     249                async_answer_0(callid, ret);
     250        } else {
     251                async_answer_1(callid, EOK, duration);
     252        }
    193253}
    194254
     
    204264        int cycles = DEV_IPC_GET_ARG1(*call);
    205265        size_t size = DEV_IPC_GET_ARG2(*call);
    206         const int ret = diag_iface->burst_isoch_in(fun, cycles, size);
    207         async_answer_0(callid, ret);
     266        usbdiag_dur_t duration;
     267        const int ret = diag_iface->burst_isoch_in(fun, cycles, size, &duration);
     268
     269        if (ret != EOK) {
     270                async_answer_0(callid, ret);
     271        } else {
     272                async_answer_1(callid, EOK, duration);
     273        }
    208274}
    209275
     
    219285        int cycles = DEV_IPC_GET_ARG1(*call);
    220286        size_t size = DEV_IPC_GET_ARG2(*call);
    221         const int ret = diag_iface->burst_isoch_out(fun, cycles, size);
    222         async_answer_0(callid, ret);
     287        usbdiag_dur_t duration;
     288        const int ret = diag_iface->burst_isoch_out(fun, cycles, size, &duration);
     289
     290        if (ret != EOK) {
     291                async_answer_0(callid, ret);
     292        } else {
     293                async_answer_1(callid, EOK, duration);
     294        }
    223295}
    224296
  • uspace/lib/drv/include/usbdiag_iface.h

    r96c416a rb10a434  
    4343#define USBDIAG_CATEGORY "usbdiag"
    4444
     45/** Milliseconds */
     46typedef unsigned long usbdiag_dur_t;
     47
    4548async_sess_t *usbdiag_connect(devman_handle_t);
    4649void usbdiag_disconnect(async_sess_t*);
    47 int usbdiag_burst_intr_in(async_exch_t*, int, size_t);
    48 int usbdiag_burst_intr_out(async_exch_t*, int, size_t);
    49 int usbdiag_burst_bulk_in(async_exch_t*, int, size_t);
    50 int usbdiag_burst_bulk_out(async_exch_t*, int, size_t);
    51 int usbdiag_burst_isoch_in(async_exch_t*, int, size_t);
    52 int usbdiag_burst_isoch_out(async_exch_t*, int, size_t);
     50int usbdiag_burst_intr_in(async_exch_t*, int, size_t, usbdiag_dur_t*);
     51int usbdiag_burst_intr_out(async_exch_t*, int, size_t, usbdiag_dur_t*);
     52int usbdiag_burst_bulk_in(async_exch_t*, int, size_t, usbdiag_dur_t*);
     53int usbdiag_burst_bulk_out(async_exch_t*, int, size_t, usbdiag_dur_t*);
     54int usbdiag_burst_isoch_in(async_exch_t*, int, size_t, usbdiag_dur_t*);
     55int usbdiag_burst_isoch_out(async_exch_t*, int, size_t, usbdiag_dur_t*);
    5356
    5457/** USB diagnostic device communication interface. */
    5558typedef struct {
    56         int (*burst_intr_in)(ddf_fun_t*, int, size_t);
    57         int (*burst_intr_out)(ddf_fun_t*, int, size_t);
    58         int (*burst_bulk_in)(ddf_fun_t*, int, size_t);
    59         int (*burst_bulk_out)(ddf_fun_t*, int, size_t);
    60         int (*burst_isoch_in)(ddf_fun_t*, int, size_t);
    61         int (*burst_isoch_out)(ddf_fun_t*, int, size_t);
     59        int (*burst_intr_in)(ddf_fun_t*, int, size_t, usbdiag_dur_t*);
     60        int (*burst_intr_out)(ddf_fun_t*, int, size_t, usbdiag_dur_t*);
     61        int (*burst_bulk_in)(ddf_fun_t*, int, size_t, usbdiag_dur_t*);
     62        int (*burst_bulk_out)(ddf_fun_t*, int, size_t, usbdiag_dur_t*);
     63        int (*burst_isoch_in)(ddf_fun_t*, int, size_t, usbdiag_dur_t*);
     64        int (*burst_isoch_out)(ddf_fun_t*, int, size_t, usbdiag_dur_t*);
    6265} usbdiag_iface_t;
    6366
Note: See TracChangeset for help on using the changeset viewer.