Changeset b7fd2a0 in mainline for uspace/lib/usbdev


Ignore:
Timestamp:
2018-01-13T03:10:29Z (8 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a53ed3a
Parents:
36f0738
Message:

Use errno_t in all uspace and kernel code.

Change type of every variable, parameter and return value that holds an
<errno.h> constant to either errno_t (the usual case), or sys_errno_t
(some places in kernel). This is for the purpose of self-documentation,
as well as for type-checking with a bit of type definition hackery.

Although this is a massive commit, it is a simple text replacement, and thus
is very easy to verify. Simply do the following:

`
git checkout <this commit's hash>
git reset HEAD
git add .
tools/srepl '\berrno_t\b' int
git add .
tools/srepl '\bsys_errno_t\b' sysarg_t
git reset
git diff
`

While this doesn't ensure that the replacements are correct, it does ensure
that the commit doesn't do anything except those replacements. Since errno_t
is typedef'd to int in the usual case (and sys_errno_t to sysarg_t), even if
incorrect, this commit cannot change behavior.

Location:
uspace/lib/usbdev
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/usbdev/include/usb/dev/alternate_ifaces.h

    r36f0738 rb7fd2a0  
    6767
    6868size_t usb_interface_count_alternates(const uint8_t *, size_t, uint8_t);
    69 int usb_alternate_interfaces_init(usb_alternate_interfaces_t *,
     69errno_t usb_alternate_interfaces_init(usb_alternate_interfaces_t *,
    7070    const uint8_t *, size_t, int);
    7171void usb_alternate_interfaces_deinit(usb_alternate_interfaces_t *);

  • uspace/lib/usbdev/include/usb/dev/device.h

    r36f0738 rb7fd2a0  
    5858
    5959/* DDF parts */
    60 int usb_device_create_ddf(ddf_dev_t *, const usb_endpoint_description_t **, const char **);
     60errno_t usb_device_create_ddf(ddf_dev_t *, const usb_endpoint_description_t **, const char **);
    6161void usb_device_destroy_ddf(ddf_dev_t *);
    6262
    … …  
    7676void usb_device_bus_exchange_end(async_exch_t *);
    7777
    78 int usb_device_select_interface(usb_device_t *, uint8_t,
     78errno_t usb_device_select_interface(usb_device_t *, uint8_t,
    7979    const usb_endpoint_description_t **);
    8080
    81 int usb_device_create_pipes(usb_device_t *usb_dev,
     81errno_t usb_device_create_pipes(usb_device_t *usb_dev,
    8282    const usb_endpoint_description_t **endpoints);
    8383void usb_device_destroy_pipes(usb_device_t *);

  • uspace/lib/usbdev/include/usb/dev/driver.h

    r36f0738 rb7fd2a0  
    4343typedef struct {
    4444        /** Callback when a new device was added to the system. */
    45         int (*device_add)(usb_device_t *);
     45        errno_t (*device_add)(usb_device_t *);
    4646        /** Callback when a device is about to be removed from the system. */
    47         int (*device_rem)(usb_device_t *);
     47        errno_t (*device_rem)(usb_device_t *);
    4848        /** Callback when a device was removed from the system. */
    49         int (*device_gone)(usb_device_t *);
     49        errno_t (*device_gone)(usb_device_t *);
    5050} usb_driver_ops_t;
    5151

  • uspace/lib/usbdev/include/usb/dev/pipes.h

    r36f0738 rb7fd2a0  
    109109} usb_endpoint_mapping_t;
    110110
    111 int usb_pipe_initialize(usb_pipe_t *, usb_endpoint_t, usb_transfer_type_t,
     111errno_t usb_pipe_initialize(usb_pipe_t *, usb_endpoint_t, usb_transfer_type_t,
    112112    size_t, usb_direction_t, unsigned, usb_dev_session_t *);
    113 int usb_pipe_initialize_default_control(usb_pipe_t *, usb_dev_session_t *);
     113errno_t usb_pipe_initialize_default_control(usb_pipe_t *, usb_dev_session_t *);
    114114
    115 int usb_pipe_probe_default_control(usb_pipe_t *);
    116 int usb_pipe_initialize_from_configuration(usb_endpoint_mapping_t *,
     115errno_t usb_pipe_probe_default_control(usb_pipe_t *);
     116errno_t usb_pipe_initialize_from_configuration(usb_endpoint_mapping_t *,
    117117    size_t, const uint8_t *, size_t, usb_dev_session_t *);
    118118
    119 int usb_pipe_register(usb_pipe_t *, unsigned);
    120 int usb_pipe_unregister(usb_pipe_t *);
     119errno_t usb_pipe_register(usb_pipe_t *, unsigned);
     120errno_t usb_pipe_unregister(usb_pipe_t *);
    121121
    122 int usb_pipe_read(usb_pipe_t *, void *, size_t, size_t *);
    123 int usb_pipe_write(usb_pipe_t *, const void *, size_t);
     122errno_t usb_pipe_read(usb_pipe_t *, void *, size_t, size_t *);
     123errno_t usb_pipe_write(usb_pipe_t *, const void *, size_t);
    124124
    125 int usb_pipe_control_read(usb_pipe_t *, const void *, size_t,
     125errno_t usb_pipe_control_read(usb_pipe_t *, const void *, size_t,
    126126    void *, size_t, size_t *);
    127 int usb_pipe_control_write(usb_pipe_t *, const void *, size_t,
     127errno_t usb_pipe_control_write(usb_pipe_t *, const void *, size_t,
    128128    const void *, size_t);
    129129

  • uspace/lib/usbdev/include/usb/dev/poll.h

    r36f0738 rb7fd2a0  
    8787         * @return Whether to continue in polling.
    8888         */
    89         bool (*on_error)(usb_device_t *dev, int err_code, void *arg);
     89        bool (*on_error)(usb_device_t *dev, errno_t err_code, void *arg);
    9090        /** Argument to pass to callbacks. */
    9191        void *arg;
    … …  
    9595typedef void (*usb_polling_terminted_callback_t)(usb_device_t *, bool, void *);
    9696
    97 extern int usb_device_auto_polling(usb_device_t *, usb_endpoint_t,
     97extern errno_t usb_device_auto_polling(usb_device_t *, usb_endpoint_t,
    9898    const usb_device_auto_polling_t *, size_t);
    9999
    100 extern int usb_device_auto_poll(usb_device_t *, usb_endpoint_t,
     100extern errno_t usb_device_auto_poll(usb_device_t *, usb_endpoint_t,
    101101    usb_polling_callback_t, size_t, int, usb_polling_terminted_callback_t, void *);
    102102
    103 extern int usb_device_auto_polling_desc(usb_device_t *,
     103extern errno_t usb_device_auto_polling_desc(usb_device_t *,
    104104    const usb_endpoint_description_t *, const usb_device_auto_polling_t *,
    105105    size_t);
    106106
    107 extern int usb_device_auto_poll_desc(usb_device_t *,
     107extern errno_t usb_device_auto_poll_desc(usb_device_t *,
    108108    const usb_endpoint_description_t *, usb_polling_callback_t, size_t, int,
    109109    usb_polling_terminted_callback_t, void *);

  • uspace/lib/usbdev/include/usb/dev/recognise.h

    r36f0738 rb7fd2a0  
    4242#include <devman.h>
    4343
    44 extern int usb_device_create_match_ids_from_device_descriptor(
     44extern errno_t usb_device_create_match_ids_from_device_descriptor(
    4545    const usb_standard_device_descriptor_t *, match_id_list_t *);
    4646
    47 extern int usb_device_create_match_ids_from_interface(
     47extern errno_t usb_device_create_match_ids_from_interface(
    4848    const usb_standard_device_descriptor_t *,
    4949    const usb_standard_interface_descriptor_t *, match_id_list_t *);
    5050
    51 extern int usb_device_create_match_ids(usb_pipe_t *, match_id_list_t *);
     51extern errno_t usb_device_create_match_ids(usb_pipe_t *, match_id_list_t *);
    5252
    5353#endif

  • uspace/lib/usbdev/include/usb/dev/request.h

    r36f0738 rb7fd2a0  
    4444#include <usb/request.h>
    4545
    46 int usb_control_request_set(usb_pipe_t *,
     46errno_t usb_control_request_set(usb_pipe_t *,
    4747    usb_request_type_t, usb_request_recipient_t, uint8_t,
    4848    uint16_t, uint16_t, const void *, size_t);
    4949
    50 int usb_control_request_get(usb_pipe_t *,
     50errno_t usb_control_request_get(usb_pipe_t *,
    5151    usb_request_type_t, usb_request_recipient_t, uint8_t,
    5252    uint16_t, uint16_t, void *, size_t, size_t *);
    5353
    54 int usb_request_get_status(usb_pipe_t *, usb_request_recipient_t,
     54errno_t usb_request_get_status(usb_pipe_t *, usb_request_recipient_t,
    5555    uint16_t, uint16_t *);
    56 int usb_request_clear_feature(usb_pipe_t *, usb_request_type_t,
     56errno_t usb_request_clear_feature(usb_pipe_t *, usb_request_type_t,
    5757    usb_request_recipient_t, uint16_t, uint16_t);
    58 int usb_request_set_feature(usb_pipe_t *, usb_request_type_t,
     58errno_t usb_request_set_feature(usb_pipe_t *, usb_request_type_t,
    5959    usb_request_recipient_t, uint16_t, uint16_t);
    60 int usb_request_get_descriptor(usb_pipe_t *, usb_request_type_t,
     60errno_t usb_request_get_descriptor(usb_pipe_t *, usb_request_type_t,
    6161    usb_request_recipient_t, uint8_t, uint8_t, uint16_t, void *, size_t,
    6262    size_t *);
    63 int usb_request_get_descriptor_alloc(usb_pipe_t *, usb_request_type_t,
     63errno_t usb_request_get_descriptor_alloc(usb_pipe_t *, usb_request_type_t,
    6464    usb_request_recipient_t, uint8_t, uint8_t, uint16_t, void **, size_t *);
    65 int usb_request_get_device_descriptor(usb_pipe_t *,
     65errno_t usb_request_get_device_descriptor(usb_pipe_t *,
    6666    usb_standard_device_descriptor_t *);
    67 int usb_request_get_bare_configuration_descriptor(usb_pipe_t *, int,
     67errno_t usb_request_get_bare_configuration_descriptor(usb_pipe_t *, int,
    6868    usb_standard_configuration_descriptor_t *);
    69 int usb_request_get_full_configuration_descriptor(usb_pipe_t *, int,
     69errno_t usb_request_get_full_configuration_descriptor(usb_pipe_t *, int,
    7070    void *, size_t, size_t *);
    71 int usb_request_get_full_configuration_descriptor_alloc(usb_pipe_t *,
     71errno_t usb_request_get_full_configuration_descriptor_alloc(usb_pipe_t *,
    7272    int, const void **, size_t *);
    73 int usb_request_set_descriptor(usb_pipe_t *, usb_request_type_t,
     73errno_t usb_request_set_descriptor(usb_pipe_t *, usb_request_type_t,
    7474    usb_request_recipient_t, uint8_t, uint8_t, uint16_t, const void *, size_t);
    7575
    76 int usb_request_get_configuration(usb_pipe_t *, uint8_t *);
    77 int usb_request_set_configuration(usb_pipe_t *, uint8_t);
     76errno_t usb_request_get_configuration(usb_pipe_t *, uint8_t *);
     77errno_t usb_request_set_configuration(usb_pipe_t *, uint8_t);
    7878
    79 int usb_request_get_interface(usb_pipe_t *, uint8_t, uint8_t *);
    80 int usb_request_set_interface(usb_pipe_t *, uint8_t, uint8_t);
     79errno_t usb_request_get_interface(usb_pipe_t *, uint8_t, uint8_t *);
     80errno_t usb_request_set_interface(usb_pipe_t *, uint8_t, uint8_t);
    8181
    82 int usb_request_get_supported_languages(usb_pipe_t *,
     82errno_t usb_request_get_supported_languages(usb_pipe_t *,
    8383    l18_win_locales_t **, size_t *);
    84 int usb_request_get_string(usb_pipe_t *, size_t, l18_win_locales_t,
     84errno_t usb_request_get_string(usb_pipe_t *, size_t, l18_win_locales_t,
    8585    char **);
    8686
    87 int usb_request_clear_endpoint_halt(usb_pipe_t *, uint16_t);
    88 int usb_pipe_clear_halt(usb_pipe_t *, usb_pipe_t *);
    89 int usb_request_get_endpoint_status(usb_pipe_t *, usb_pipe_t *, uint16_t *);
     87errno_t usb_request_clear_endpoint_halt(usb_pipe_t *, uint16_t);
     88errno_t usb_pipe_clear_halt(usb_pipe_t *, usb_pipe_t *);
     89errno_t usb_request_get_endpoint_status(usb_pipe_t *, usb_pipe_t *, uint16_t *);
    9090
    9191#endif

  • uspace/lib/usbdev/src/altiface.c

    r36f0738 rb7fd2a0  
    8888 * @return Error code.
    8989 */
    90 int usb_alternate_interfaces_init(usb_alternate_interfaces_t *alternates,
     90errno_t usb_alternate_interfaces_init(usb_alternate_interfaces_t *alternates,
    9191    const uint8_t *config_descr, size_t config_descr_size, int interface_number)
    9292{

  • uspace/lib/usbdev/src/devdrv.c

    r36f0738 rb7fd2a0  
    131131 * @return Error code.
    132132 */
    133 int usb_device_select_interface(usb_device_t *usb_dev,
     133errno_t usb_device_select_interface(usb_device_t *usb_dev,
    134134    uint8_t alternate_setting, const usb_endpoint_description_t **endpoints)
    135135{
    … …  
    141141
    142142        /* Change the interface itself. */
    143         int rc = usb_request_set_interface(&usb_dev->ctrl_pipe,
     143        errno_t rc = usb_request_set_interface(&usb_dev->ctrl_pipe,
    144144            usb_dev->interface_no, alternate_setting);
    145145        if (rc != EOK) {
    … …  
    165165 * @return Error code.
    166166 */
    167 static int usb_device_retrieve_descriptors(usb_device_t *usb_dev)
     167static errno_t usb_device_retrieve_descriptors(usb_device_t *usb_dev)
    168168{
    169169        assert(usb_dev);
    … …  
    171171
    172172        /* Get the device descriptor. */
    173         int rc = usb_request_get_device_descriptor(&usb_dev->ctrl_pipe,
     173        errno_t rc = usb_request_get_device_descriptor(&usb_dev->ctrl_pipe,
    174174            &usb_dev->descriptors.device);
    175175        if (rc != EOK) {
    … …  
    217217 * @return Error code.
    218218 */
    219 int usb_device_create_pipes(usb_device_t *usb_dev,
     219errno_t usb_device_create_pipes(usb_device_t *usb_dev,
    220220    const usb_endpoint_description_t **endpoints)
    221221{
    … …  
    245245
    246246        /* Find the mapping from configuration descriptor. */
    247         int rc = usb_pipe_initialize_from_configuration(pipes, pipe_count,
     247        errno_t rc = usb_pipe_initialize_from_configuration(pipes, pipe_count,
    248248            usb_dev->descriptors.full_config,
    249249            usb_dev->descriptors.full_config_size,
    … …  
    393393 * @return Error code.
    394394 */
    395 static int usb_device_init(usb_device_t *usb_dev, ddf_dev_t *ddf_dev,
     395static errno_t usb_device_init(usb_device_t *usb_dev, ddf_dev_t *ddf_dev,
    396396    const usb_endpoint_description_t **endpoints, const char **errstr_ptr,
    397397    devman_handle_t handle, int interface_no)
    … …  
    420420        /* This pipe was registered by the hub driver,
    421421         * during device initialization. */
    422         int rc = usb_pipe_initialize_default_control(
     422        errno_t rc = usb_pipe_initialize_default_control(
    423423            &usb_dev->ctrl_pipe, usb_dev->bus_session);
    424424        if (rc != EOK) {
    … …  
    457457}
    458458
    459 static int usb_device_get_info(async_sess_t *sess, devman_handle_t *handle,
     459static errno_t usb_device_get_info(async_sess_t *sess, devman_handle_t *handle,
    460460        int *iface_no)
    461461{
    … …  
    467467                return EPARTY;
    468468       
    469         int ret = usb_get_my_device_handle(exch, handle);
     469        errno_t ret = usb_get_my_device_handle(exch, handle);
    470470        if (ret == EOK) {
    471471                ret = usb_get_my_interface(exch, iface_no);
    … …  
    480480}
    481481
    482 int usb_device_create_ddf(ddf_dev_t *ddf_dev,
     482errno_t usb_device_create_ddf(ddf_dev_t *ddf_dev,
    483483    const usb_endpoint_description_t **desc, const char **err)
    484484{
    … …  
    492492        if (sess == NULL)
    493493                return ENOMEM;
    494         const int ret = usb_device_get_info(sess, &h, &iface_no);
     494        const errno_t ret = usb_device_get_info(sess, &h, &iface_no);
    495495        if (ret != EOK)
    496496                return ret;
    … …  
    521521
    522522        async_sess_t *sess = devman_device_connect(handle, IPC_FLAG_BLOCKING);
    523         int ret = usb_device_get_info(sess, &h, &iface_no);
     523        errno_t ret = usb_device_get_info(sess, &h, &iface_no);
    524524        if (sess)
    525525                async_hangup(sess);

  • uspace/lib/usbdev/src/devpoll.c

    r36f0738 rb7fd2a0  
    7777 * @return Always EOK.
    7878 */
    79 static int polling_fibril(void *arg)
     79static errno_t polling_fibril(void *arg)
    8080{
    8181        assert(arg);
    … …  
    102102        while (failed_attempts <= params->max_failures) {
    103103                size_t actual_size;
    104                 const int rc = usb_pipe_read(pipe, data->buffer,
     104                const errno_t rc = usb_pipe_read(pipe, data->buffer,
    105105                    data->request_size, &actual_size);
    106106
    … …  
    206206 * @retval EOK New fibril polling the device was already started.
    207207 */
    208 static int usb_device_auto_polling_internal(usb_device_t *dev,
     208static errno_t usb_device_auto_polling_internal(usb_device_t *dev,
    209209    usb_endpoint_mapping_t *epm, const usb_device_auto_polling_t *polling,
    210210    size_t request_size)
    … …  
    275275 * @retval EOK New fibril polling the device was already started.
    276276 */
    277 int usb_device_auto_polling(usb_device_t *usb_dev, usb_endpoint_t ep,
     277errno_t usb_device_auto_polling(usb_device_t *usb_dev, usb_endpoint_t ep,
    278278    const usb_device_auto_polling_t *polling, size_t req_size)
    279279{
    … …  
    301301 * @retval EOK New fibril polling the device was already started.
    302302 */
    303 int usb_device_auto_poll(usb_device_t *dev, usb_endpoint_t ep,
     303errno_t usb_device_auto_poll(usb_device_t *dev, usb_endpoint_t ep,
    304304    usb_polling_callback_t callback, size_t request_size, int delay,
    305305    usb_polling_terminted_callback_t terminated_callback, void *arg)
    … …  
    321321}
    322322
    323 int usb_device_auto_polling_desc(usb_device_t *usb_dev,
     323errno_t usb_device_auto_polling_desc(usb_device_t *usb_dev,
    324324    const usb_endpoint_description_t *desc,
    325325    const usb_device_auto_polling_t *polling, size_t req_size)
    … …  
    330330}
    331331
    332 int usb_device_auto_poll_desc(usb_device_t * usb_dev,
     332errno_t usb_device_auto_poll_desc(usb_device_t * usb_dev,
    333333    const usb_endpoint_description_t *desc, usb_polling_callback_t callback,
    334334    size_t req_size, int delay,

  • uspace/lib/usbdev/src/driver.c

    r36f0738 rb7fd2a0  
    5252 * @return Error code.
    5353 */
    54 static int generic_device_add(ddf_dev_t *gen_dev)
     54static errno_t generic_device_add(ddf_dev_t *gen_dev)
    5555{
    5656        assert(driver);
    … …  
    6060        /* Initialize generic USB driver data. */
    6161        const char *err_msg = NULL;
    62         int rc = usb_device_create_ddf(gen_dev, driver->endpoints, &err_msg);
     62        errno_t rc = usb_device_create_ddf(gen_dev, driver->endpoints, &err_msg);
    6363        if (rc != EOK) {
    6464                usb_log_error("USB device `%s' init failed (%s): %s.\n",
    … …  
    8181 * @return Error code.
    8282 */
    83 static int generic_device_remove(ddf_dev_t *gen_dev)
     83static errno_t generic_device_remove(ddf_dev_t *gen_dev)
    8484{
    8585        assert(driver);
    … …  
    8989        /* Just tell the driver to stop whatever it is doing */
    9090        usb_device_t *usb_dev = ddf_dev_data_get(gen_dev);
    91         const int ret = driver->ops->device_rem(usb_dev);
     91        const errno_t ret = driver->ops->device_rem(usb_dev);
    9292        if (ret != EOK)
    9393                return ret;
    … …  
    103103 * @return Error code.
    104104 */
    105 static int generic_device_gone(ddf_dev_t *gen_dev)
     105static errno_t generic_device_gone(ddf_dev_t *gen_dev)
    106106{
    107107        assert(driver);
    … …  
    110110                return ENOTSUP;
    111111        usb_device_t *usb_dev = ddf_dev_data_get(gen_dev);
    112         const int ret = driver->ops->device_gone(usb_dev);
     112        const errno_t ret = driver->ops->device_gone(usb_dev);
    113113        if (ret == EOK)
    114114                usb_device_destroy_ddf(gen_dev);

  • uspace/lib/usbdev/src/pipes.c

    r36f0738 rb7fd2a0  
    7474 * @return Error code.
    7575 */
    76 int usb_pipe_control_read(usb_pipe_t *pipe,
     76errno_t usb_pipe_control_read(usb_pipe_t *pipe,
    7777    const void *setup_buffer, size_t setup_buffer_size,
    7878    void *buffer, size_t buffer_size, size_t *transfered_size)
    … …  
    9898        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
    9999        size_t act_size = 0;
    100         const int rc = usb_read(exch, pipe->endpoint_no, setup_packet, buffer,
     100        const errno_t rc = usb_read(exch, pipe->endpoint_no, setup_packet, buffer,
    101101            buffer_size, &act_size);
    102102        async_exchange_end(exch);
    … …  
    124124 * @return Error code.
    125125 */
    126 int usb_pipe_control_write(usb_pipe_t *pipe,
     126errno_t usb_pipe_control_write(usb_pipe_t *pipe,
    127127    const void *setup_buffer, size_t setup_buffer_size,
    128128    const void *buffer, size_t buffer_size)
    … …  
    151151
    152152        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
    153         const int rc = usb_write(exch,
     153        const errno_t rc = usb_write(exch,
    154154            pipe->endpoint_no, setup_packet, buffer, buffer_size);
    155155        async_exchange_end(exch);
    … …  
    170170 * @return Error code.
    171171 */
    172 int usb_pipe_read(usb_pipe_t *pipe,
     172errno_t usb_pipe_read(usb_pipe_t *pipe,
    173173    void *buffer, size_t size, size_t *size_transfered)
    174174{
    … …  
    198198        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
    199199        size_t act_size = 0;
    200         const int rc =
     200        const errno_t rc =
    201201            usb_read(exch, pipe->endpoint_no, 0, buffer, size, &act_size);
    202202        async_exchange_end(exch);
    … …  
    216216 * @return Error code.
    217217 */
    218 int usb_pipe_write(usb_pipe_t *pipe, const void *buffer, size_t size)
     218errno_t usb_pipe_write(usb_pipe_t *pipe, const void *buffer, size_t size)
    219219{
    220220        assert(pipe);
    … …  
    238238
    239239        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
    240         const int rc = usb_write(exch, pipe->endpoint_no, 0, buffer, size);
     240        const errno_t rc = usb_write(exch, pipe->endpoint_no, 0, buffer, size);
    241241        async_exchange_end(exch);
    242242        return rc;
    … …  
    252252 * @return Error code.
    253253 */
    254 int usb_pipe_initialize(usb_pipe_t *pipe, usb_endpoint_t endpoint_no,
     254errno_t usb_pipe_initialize(usb_pipe_t *pipe, usb_endpoint_t endpoint_no,
    255255    usb_transfer_type_t transfer_type, size_t max_packet_size,
    256256    usb_direction_t direction, unsigned packets, usb_dev_session_t *bus_session)
    … …  
    274274 * @return Error code.
    275275 */
    276 int usb_pipe_initialize_default_control(usb_pipe_t *pipe,
     276errno_t usb_pipe_initialize_default_control(usb_pipe_t *pipe,
    277277    usb_dev_session_t *bus_session)
    278278{
    279279        assert(pipe);
    280280
    281         const int rc = usb_pipe_initialize(pipe, 0, USB_TRANSFER_CONTROL,
     281        const errno_t rc = usb_pipe_initialize(pipe, 0, USB_TRANSFER_CONTROL,
    282282            CTRL_PIPE_MIN_PACKET_SIZE, USB_DIRECTION_BOTH, 1, bus_session);
    283283
    … …  
    293293 * @return Error code.
    294294 */
    295 int usb_pipe_register(usb_pipe_t *pipe, unsigned interval)
     295errno_t usb_pipe_register(usb_pipe_t *pipe, unsigned interval)
    296296{
    297297        assert(pipe);
    … …  
    300300        if (!exch)
    301301                return ENOMEM;
    302         const int ret = usb_register_endpoint(exch, pipe->endpoint_no,
     302        const errno_t ret = usb_register_endpoint(exch, pipe->endpoint_no,
    303303            pipe->transfer_type, pipe->direction, pipe->max_packet_size,
    304304            pipe->packets, interval);
    … …  
    312312 * @return Error code.
    313313 */
    314 int usb_pipe_unregister(usb_pipe_t *pipe)
     314errno_t usb_pipe_unregister(usb_pipe_t *pipe)
    315315{
    316316        assert(pipe);
    … …  
    319319        if (!exch)
    320320                return ENOMEM;
    321         const int ret = usb_unregister_endpoint(exch, pipe->endpoint_no,
     321        const errno_t ret = usb_unregister_endpoint(exch, pipe->endpoint_no,
    322322            pipe->direction);
    323323        async_exchange_end(exch);

  • uspace/lib/usbdev/src/pipesinit.c

    r36f0738 rb7fd2a0  
    152152 * @return Error code.
    153153 */
    154 static int process_endpoint(
     154static errno_t process_endpoint(
    155155    usb_endpoint_mapping_t *mapping, size_t mapping_count,
    156156    usb_standard_interface_descriptor_t *interface,
    … …  
    194194        }
    195195
    196         int rc = usb_pipe_initialize(&ep_mapping->pipe,
     196        errno_t rc = usb_pipe_initialize(&ep_mapping->pipe,
    197197            ep_no, description.transfer_type,
    198198            ED_MPS_PACKET_SIZE_GET(
    … …  
    221221 * @return Error code.
    222222 */
    223 static int process_interface(
     223static errno_t process_interface(
    224224    usb_endpoint_mapping_t *mapping, size_t mapping_count,
    225225    const usb_dp_parser_t *parser, const usb_dp_parser_data_t *parser_data,
    … …  
    281281 * @return Error code.
    282282 */
    283 int usb_pipe_initialize_from_configuration(
     283errno_t usb_pipe_initialize_from_configuration(
    284284    usb_endpoint_mapping_t *mapping, size_t mapping_count,
    285285    const uint8_t *config_descriptor, size_t config_descriptor_size,
    … …  
    338338 * @return Error code.
    339339 */
    340 int usb_pipe_probe_default_control(usb_pipe_t *pipe)
     340errno_t usb_pipe_probe_default_control(usb_pipe_t *pipe)
    341341{
    342342        assert(pipe);
    … …  
    351351        uint8_t dev_descr_start[CTRL_PIPE_MIN_PACKET_SIZE];
    352352        size_t transferred_size;
    353         int rc;
     353        errno_t rc;
    354354        for (size_t attempt_var = 0; attempt_var < 3; ++attempt_var) {
    355355                rc = usb_request_get_descriptor(pipe, USB_REQUEST_TYPE_STANDARD,

  • uspace/lib/usbdev/src/recognise.c

    r36f0738 rb7fd2a0  
    6060 * @return Error code.
    6161 */
    62 static int usb_add_match_id(match_id_list_t *matches, int score,
     62static errno_t usb_add_match_id(match_id_list_t *matches, int score,
    6363    const char *match_str)
    6464{
    … …  
    8989                int __rc = asprintf(&str, format, ##__VA_ARGS__); \
    9090                if (__rc >= 0) { \
    91                         int __rc = usb_add_match_id((match_ids), (score), str); \
     91                        errno_t __rc = usb_add_match_id((match_ids), (score), str); \
    9292                        if (__rc != EOK) { \
    9393                                free(str); \
    … …  
    108108 * @retval ENOENT Device class is not "use interface".
    109109 */
    110 int usb_device_create_match_ids_from_interface(
     110errno_t usb_device_create_match_ids_from_interface(
    111111    const usb_standard_device_descriptor_t *desc_device,
    112112    const usb_standard_interface_descriptor_t *desc_interface,
    … …  
    220220 * @return Error code.
    221221 */
    222 int usb_device_create_match_ids_from_device_descriptor(
     222errno_t usb_device_create_match_ids_from_device_descriptor(
    223223    const usb_standard_device_descriptor_t *device_descriptor,
    224224    match_id_list_t *matches)
    … …  
    264264 * @return Error code.
    265265 */
    266 int usb_device_create_match_ids(usb_pipe_t *ctrl_pipe,
     266errno_t usb_device_create_match_ids(usb_pipe_t *ctrl_pipe,
    267267    match_id_list_t *matches)
    268268{
    269269        assert(ctrl_pipe);
    270         int rc;
     270        errno_t rc;
    271271        /*
    272272         * Retrieve device descriptor and add matches from it.

  • uspace/lib/usbdev/src/request.c

    r36f0738 rb7fd2a0  
    6868 *
    6969 */
    70 int usb_control_request_set(usb_pipe_t *pipe,
     70errno_t usb_control_request_set(usb_pipe_t *pipe,
    7171    usb_request_type_t request_type, usb_request_recipient_t recipient,
    7272    uint8_t request, uint16_t value, uint16_t index,
    … …  
    127127 *
    128128 */
    129 int usb_control_request_get(usb_pipe_t *pipe,
     129errno_t usb_control_request_get(usb_pipe_t *pipe,
    130130    usb_request_type_t request_type, usb_request_recipient_t recipient,
    131131    uint8_t request, uint16_t value, uint16_t index,
    … …  
    170170 * @return Error code.
    171171 */
    172 int usb_request_get_status(usb_pipe_t *pipe,
     172errno_t usb_request_get_status(usb_pipe_t *pipe,
    173173    usb_request_recipient_t recipient, uint16_t index,
    174174    uint16_t *status)
    … …  
    184184        uint16_t status_usb_endianess;
    185185        size_t data_transfered_size;
    186         int rc = usb_control_request_get(pipe, USB_REQUEST_TYPE_STANDARD,
     186        errno_t rc = usb_control_request_get(pipe, USB_REQUEST_TYPE_STANDARD,
    187187            recipient, USB_DEVREQ_GET_STATUS, 0, uint16_host2usb(index),
    188188            &status_usb_endianess, 2, &data_transfered_size);
    … …  
    208208 * @return Error code.
    209209 */
    210 int usb_request_clear_feature(usb_pipe_t *pipe,
     210errno_t usb_request_clear_feature(usb_pipe_t *pipe,
    211211    usb_request_type_t request_type, usb_request_recipient_t recipient,
    212212    uint16_t feature_selector, uint16_t index)
    … …  
    232232 * @return Error code.
    233233 */
    234 int usb_request_set_feature(usb_pipe_t *pipe,
     234errno_t usb_request_set_feature(usb_pipe_t *pipe,
    235235    usb_request_type_t request_type, usb_request_recipient_t recipient,
    236236    uint16_t feature_selector, uint16_t index)
    … …  
    260260 * @return Error code.
    261261 */
    262 int usb_request_get_descriptor(usb_pipe_t *pipe,
     262errno_t usb_request_get_descriptor(usb_pipe_t *pipe,
    263263    usb_request_type_t request_type, usb_request_recipient_t recipient,
    264264    uint8_t descriptor_type, uint8_t descriptor_index,
    … …  
    298298 * @return
    299299 */
    300 int usb_request_get_descriptor_alloc(usb_pipe_t * pipe,
     300errno_t usb_request_get_descriptor_alloc(usb_pipe_t * pipe,
    301301    usb_request_type_t request_type, usb_request_recipient_t recipient,
    302302    uint8_t descriptor_type, uint8_t descriptor_index,
    … …  
    308308        }
    309309
    310         int rc;
     310        errno_t rc;
    311311
    312312        /*
    … …  
    364364 * @return Error code.
    365365 */
    366 int usb_request_get_device_descriptor(usb_pipe_t *pipe,
     366errno_t usb_request_get_device_descriptor(usb_pipe_t *pipe,
    367367    usb_standard_device_descriptor_t *descriptor)
    368368{
    … …  
    373373        size_t actually_transferred = 0;
    374374        usb_standard_device_descriptor_t descriptor_tmp;
    375         int rc = usb_request_get_descriptor(pipe,
     375        errno_t rc = usb_request_get_descriptor(pipe,
    376376            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
    377377            USB_DESCTYPE_DEVICE, 0, 0, &descriptor_tmp, sizeof(descriptor_tmp),
    … …  
    404404 * @return Error code.
    405405 */
    406 int usb_request_get_bare_configuration_descriptor(usb_pipe_t *pipe,
     406errno_t usb_request_get_bare_configuration_descriptor(usb_pipe_t *pipe,
    407407    int index, usb_standard_configuration_descriptor_t *descriptor)
    408408{
    … …  
    417417        size_t actually_transferred = 0;
    418418        usb_standard_configuration_descriptor_t descriptor_tmp;
    419         const int rc = usb_request_get_descriptor(pipe,
     419        const errno_t rc = usb_request_get_descriptor(pipe,
    420420            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
    421421            USB_DESCTYPE_CONFIGURATION, index, 0,
    … …  
    448448 * @return Error code.
    449449 */
    450 int usb_request_get_full_configuration_descriptor(usb_pipe_t *pipe,
     450errno_t usb_request_get_full_configuration_descriptor(usb_pipe_t *pipe,
    451451    int index, void *descriptor, size_t descriptor_size, size_t *actual_size)
    452452{
    … …  
    473473 * @return Error code.
    474474 */
    475 int usb_request_get_full_configuration_descriptor_alloc(
     475errno_t usb_request_get_full_configuration_descriptor_alloc(
    476476    usb_pipe_t *pipe, int index,
    477477    const void **descriptor_ptr, size_t *descriptor_size)
    478478{
    479         int rc;
     479        errno_t rc;
    480480
    481481        if (descriptor_ptr == NULL) {
    … …  
    539539 * @return Error code.
    540540 */
    541 int usb_request_set_descriptor(usb_pipe_t *pipe,
     541errno_t usb_request_set_descriptor(usb_pipe_t *pipe,
    542542    usb_request_type_t request_type, usb_request_recipient_t recipient,
    543543    uint8_t descriptor_type, uint8_t descriptor_index,
    … …  
    565565 * @return Error code.
    566566 */
    567 int usb_request_get_configuration(usb_pipe_t *pipe,
     567errno_t usb_request_get_configuration(usb_pipe_t *pipe,
    568568    uint8_t *configuration_value)
    569569{
    … …  
    571571        size_t actual_size;
    572572
    573         const int rc = usb_control_request_get(pipe,
     573        const errno_t rc = usb_control_request_get(pipe,
    574574            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
    575575            USB_DEVREQ_GET_CONFIGURATION, 0, 0, &value, 1, &actual_size);
    … …  
    595595 * @return Error code.
    596596 */
    597 int usb_request_set_configuration(usb_pipe_t *pipe,
     597errno_t usb_request_set_configuration(usb_pipe_t *pipe,
    598598    uint8_t configuration_value)
    599599{
    … …  
    614614 * @return Error code.
    615615 */
    616 int usb_request_get_interface(usb_pipe_t *pipe,
     616errno_t usb_request_get_interface(usb_pipe_t *pipe,
    617617    uint8_t interface_index, uint8_t *alternate_setting)
    618618{
    … …  
    620620        size_t actual_size;
    621621
    622         const int rc = usb_control_request_get(pipe,
     622        const errno_t rc = usb_control_request_get(pipe,
    623623            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_INTERFACE,
    624624            USB_DEVREQ_GET_INTERFACE,
    … …  
    647647 * @return Error code.
    648648 */
    649 int usb_request_set_interface(usb_pipe_t *pipe,
     649errno_t usb_request_set_interface(usb_pipe_t *pipe,
    650650    uint8_t interface_index, uint8_t alternate_setting)
    651651{
    … …  
    666666 * @return Error code.
    667667 */
    668 int usb_request_get_supported_languages(usb_pipe_t *pipe,
     668errno_t usb_request_get_supported_languages(usb_pipe_t *pipe,
    669669    l18_win_locales_t **languages_ptr, size_t *languages_count)
    670670{
    … …  
    675675        uint8_t *string_descriptor = NULL;
    676676        size_t string_descriptor_size = 0;
    677         const int rc = usb_request_get_descriptor_alloc(pipe,
     677        const errno_t rc = usb_request_get_descriptor_alloc(pipe,
    678678            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
    679679            USB_DESCTYPE_STRING, 0, 0,
    … …  
    733733 * @return Error code.
    734734 */
    735 int usb_request_get_string(usb_pipe_t *pipe,
     735errno_t usb_request_get_string(usb_pipe_t *pipe,
    736736    size_t index, l18_win_locales_t lang, char **string_ptr)
    737737{
    … …  
    751751        }
    752752
    753         int rc;
     753        errno_t rc;
    754754
    755755        /* Prepare dynamically allocated variables. */
    … …  
    824824 * @return Error code.
    825825 */
    826 int usb_request_clear_endpoint_halt(usb_pipe_t *pipe, uint16_t ep_index)
     826errno_t usb_request_clear_endpoint_halt(usb_pipe_t *pipe, uint16_t ep_index)
    827827{
    828828        return usb_request_clear_feature(pipe,
    … …  
    838838 * @return Error code.
    839839 */
    840 int usb_pipe_clear_halt(usb_pipe_t *ctrl_pipe, usb_pipe_t *target_pipe)
     840errno_t usb_pipe_clear_halt(usb_pipe_t *ctrl_pipe, usb_pipe_t *target_pipe)
    841841{
    842842        if ((ctrl_pipe == NULL) || (target_pipe == NULL)) {
    … …  
    854854 * @return Error code.
    855855 */
    856 int usb_request_get_endpoint_status(usb_pipe_t *ctrl_pipe, usb_pipe_t *pipe,
     856errno_t usb_request_get_endpoint_status(usb_pipe_t *ctrl_pipe, usb_pipe_t *pipe,
    857857    uint16_t *status)
    858858{
    859859        uint16_t status_tmp;
    860860        uint16_t pipe_index = (uint16_t) pipe->endpoint_no;
    861         int rc = usb_request_get_status(ctrl_pipe,
     861        errno_t rc = usb_request_get_status(ctrl_pipe,
    862862            USB_REQUEST_RECIPIENT_ENDPOINT, uint16_host2usb(pipe_index),
    863863            &status_tmp);
Note: See TracChangeset for help on using the changeset viewer.