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/lib/drv/generic/remote_usbdiag.c

    r2986763 rb7b7898  
    4343
    4444typedef enum {
    45         IPC_M_USBDIAG_STRESS_INTR_IN,
    46         IPC_M_USBDIAG_STRESS_INTR_OUT,
    47         IPC_M_USBDIAG_STRESS_BULK_IN,
    48         IPC_M_USBDIAG_STRESS_BULK_OUT,
    49         IPC_M_USBDIAG_STRESS_ISOCH_IN,
    50         IPC_M_USBDIAG_STRESS_ISOCH_OUT
     45        IPC_M_USBDIAG_BURST_INTR_IN,
     46        IPC_M_USBDIAG_BURST_INTR_OUT,
     47        IPC_M_USBDIAG_BURST_BULK_IN,
     48        IPC_M_USBDIAG_BURST_BULK_OUT,
     49        IPC_M_USBDIAG_BURST_ISOCH_IN,
     50        IPC_M_USBDIAG_BURST_ISOCH_OUT
    5151} usb_iface_funcs_t;
    5252
    … …  
    6262}
    6363
    64 int usbdiag_stress_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_STRESS_INTR_IN, cycles, size);
    70 }
    71 
    72 int usbdiag_stress_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_STRESS_INTR_OUT, cycles, size);
    78 }
    79 
    80 int usbdiag_stress_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_STRESS_BULK_IN, cycles, size);
    86 }
    87 
    88 int usbdiag_stress_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_STRESS_BULK_OUT, cycles, size);
    94 }
    95 
    96 int usbdiag_stress_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_STRESS_ISOCH_IN, cycles, size);
    102 }
    103 
    104 int usbdiag_stress_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_STRESS_ISOCH_OUT, cycles, size);
    110 }
    111 
    112 static void remote_usbdiag_stress_intr_in(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    113 static void remote_usbdiag_stress_intr_out(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    114 static void remote_usbdiag_stress_bulk_in(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    115 static void remote_usbdiag_stress_bulk_out(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    116 static void remote_usbdiag_stress_isoch_in(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    117 static void remote_usbdiag_stress_isoch_out(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     64int 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
     72int 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
     80int 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
     88int 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
     96int 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
     104int 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);
     110}
     111
     112static void remote_usbdiag_burst_intr_in(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     113static void remote_usbdiag_burst_intr_out(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     114static void remote_usbdiag_burst_bulk_in(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     115static void remote_usbdiag_burst_bulk_out(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     116static void remote_usbdiag_burst_isoch_in(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     117static void remote_usbdiag_burst_isoch_out(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    118118
    119119/** Remote USB diagnostic interface operations. */
    120120static const remote_iface_func_ptr_t remote_usbdiag_iface_ops [] = {
    121         [IPC_M_USBDIAG_STRESS_INTR_IN] = remote_usbdiag_stress_intr_in,
    122         [IPC_M_USBDIAG_STRESS_INTR_OUT] = remote_usbdiag_stress_intr_out,
    123         [IPC_M_USBDIAG_STRESS_BULK_IN] = remote_usbdiag_stress_bulk_in,
    124         [IPC_M_USBDIAG_STRESS_BULK_OUT] = remote_usbdiag_stress_bulk_out,
    125         [IPC_M_USBDIAG_STRESS_ISOCH_IN] = remote_usbdiag_stress_isoch_in,
    126         [IPC_M_USBDIAG_STRESS_ISOCH_OUT] = remote_usbdiag_stress_isoch_out
     121        [IPC_M_USBDIAG_BURST_INTR_IN] = remote_usbdiag_burst_intr_in,
     122        [IPC_M_USBDIAG_BURST_INTR_OUT] = remote_usbdiag_burst_intr_out,
     123        [IPC_M_USBDIAG_BURST_BULK_IN] = remote_usbdiag_burst_bulk_in,
     124        [IPC_M_USBDIAG_BURST_BULK_OUT] = remote_usbdiag_burst_bulk_out,
     125        [IPC_M_USBDIAG_BURST_ISOCH_IN] = remote_usbdiag_burst_isoch_in,
     126        [IPC_M_USBDIAG_BURST_ISOCH_OUT] = remote_usbdiag_burst_isoch_out
    127127};
    128128
    … …  
    133133};
    134134
    135 void remote_usbdiag_stress_intr_in(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
    136 {
    137         const usbdiag_iface_t *diag_iface = (usbdiag_iface_t *) iface;
    138 
    139         if (diag_iface->stress_bulk_in == NULL) {
    140                 async_answer_0(callid, ENOTSUP);
    141                 return;
    142         }
    143 
    144         int cycles = DEV_IPC_GET_ARG1(*call);
    145         size_t size = DEV_IPC_GET_ARG2(*call);
    146         const int ret = diag_iface->stress_intr_in(fun, cycles, size);
    147         async_answer_0(callid, ret);
    148 }
    149 
    150 void remote_usbdiag_stress_intr_out(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
    151 {
    152         const usbdiag_iface_t *diag_iface = (usbdiag_iface_t *) iface;
    153 
    154         if (diag_iface->stress_bulk_out == NULL) {
    155                 async_answer_0(callid, ENOTSUP);
    156                 return;
    157         }
    158 
    159         int cycles = DEV_IPC_GET_ARG1(*call);
    160         size_t size = DEV_IPC_GET_ARG2(*call);
    161         const int ret = diag_iface->stress_intr_out(fun, cycles, size);
    162         async_answer_0(callid, ret);
    163 }
    164 
    165 void remote_usbdiag_stress_bulk_in(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
    166 {
    167         const usbdiag_iface_t *diag_iface = (usbdiag_iface_t *) iface;
    168 
    169         if (diag_iface->stress_bulk_in == NULL) {
    170                 async_answer_0(callid, ENOTSUP);
    171                 return;
    172         }
    173 
    174         int cycles = DEV_IPC_GET_ARG1(*call);
    175         size_t size = DEV_IPC_GET_ARG2(*call);
    176         const int ret = diag_iface->stress_bulk_in(fun, cycles, size);
    177         async_answer_0(callid, ret);
    178 }
    179 
    180 void remote_usbdiag_stress_bulk_out(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
    181 {
    182         const usbdiag_iface_t *diag_iface = (usbdiag_iface_t *) iface;
    183 
    184         if (diag_iface->stress_bulk_out == NULL) {
    185                 async_answer_0(callid, ENOTSUP);
    186                 return;
    187         }
    188 
    189         int cycles = DEV_IPC_GET_ARG1(*call);
    190         size_t size = DEV_IPC_GET_ARG2(*call);
    191         const int ret = diag_iface->stress_bulk_out(fun, cycles, size);
    192         async_answer_0(callid, ret);
    193 }
    194 
    195 void remote_usbdiag_stress_isoch_in(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
    196 {
    197         const usbdiag_iface_t *diag_iface = (usbdiag_iface_t *) iface;
    198 
    199         if (diag_iface->stress_isoch_in == NULL) {
    200                 async_answer_0(callid, ENOTSUP);
    201                 return;
    202         }
    203 
    204         int cycles = DEV_IPC_GET_ARG1(*call);
    205         size_t size = DEV_IPC_GET_ARG2(*call);
    206         const int ret = diag_iface->stress_isoch_in(fun, cycles, size);
    207         async_answer_0(callid, ret);
    208 }
    209 
    210 void remote_usbdiag_stress_isoch_out(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
    211 {
    212         const usbdiag_iface_t *diag_iface = (usbdiag_iface_t *) iface;
    213 
    214         if (diag_iface->stress_isoch_out == NULL) {
    215                 async_answer_0(callid, ENOTSUP);
    216                 return;
    217         }
    218 
    219         int cycles = DEV_IPC_GET_ARG1(*call);
    220         size_t size = DEV_IPC_GET_ARG2(*call);
    221         const int ret = diag_iface->stress_isoch_out(fun, cycles, size);
     135void remote_usbdiag_burst_intr_in(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
     136{
     137        const usbdiag_iface_t *diag_iface = (usbdiag_iface_t *) iface;
     138
     139        if (diag_iface->burst_bulk_in == NULL) {
     140                async_answer_0(callid, ENOTSUP);
     141                return;
     142        }
     143
     144        int cycles = DEV_IPC_GET_ARG1(*call);
     145        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);
     148}
     149
     150void remote_usbdiag_burst_intr_out(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
     151{
     152        const usbdiag_iface_t *diag_iface = (usbdiag_iface_t *) iface;
     153
     154        if (diag_iface->burst_bulk_out == NULL) {
     155                async_answer_0(callid, ENOTSUP);
     156                return;
     157        }
     158
     159        int cycles = DEV_IPC_GET_ARG1(*call);
     160        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);
     163}
     164
     165void remote_usbdiag_burst_bulk_in(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
     166{
     167        const usbdiag_iface_t *diag_iface = (usbdiag_iface_t *) iface;
     168
     169        if (diag_iface->burst_bulk_in == NULL) {
     170                async_answer_0(callid, ENOTSUP);
     171                return;
     172        }
     173
     174        int cycles = DEV_IPC_GET_ARG1(*call);
     175        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);
     178}
     179
     180void remote_usbdiag_burst_bulk_out(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
     181{
     182        const usbdiag_iface_t *diag_iface = (usbdiag_iface_t *) iface;
     183
     184        if (diag_iface->burst_bulk_out == NULL) {
     185                async_answer_0(callid, ENOTSUP);
     186                return;
     187        }
     188
     189        int cycles = DEV_IPC_GET_ARG1(*call);
     190        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);
     193}
     194
     195void remote_usbdiag_burst_isoch_in(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
     196{
     197        const usbdiag_iface_t *diag_iface = (usbdiag_iface_t *) iface;
     198
     199        if (diag_iface->burst_isoch_in == NULL) {
     200                async_answer_0(callid, ENOTSUP);
     201                return;
     202        }
     203
     204        int cycles = DEV_IPC_GET_ARG1(*call);
     205        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);
     208}
     209
     210void remote_usbdiag_burst_isoch_out(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
     211{
     212        const usbdiag_iface_t *diag_iface = (usbdiag_iface_t *) iface;
     213
     214        if (diag_iface->burst_isoch_out == NULL) {
     215                async_answer_0(callid, ENOTSUP);
     216                return;
     217        }
     218
     219        int cycles = DEV_IPC_GET_ARG1(*call);
     220        size_t size = DEV_IPC_GET_ARG2(*call);
     221        const int ret = diag_iface->burst_isoch_out(fun, cycles, size);
    222222        async_answer_0(callid, ret);
    223223}
Note: See TracChangeset for help on using the changeset viewer.