Changeset 5a6cc679 in mainline for uspace/lib/usbdev


Ignore:
Timestamp:
2018-01-31T02:21:24Z (7 years ago)
Author:
Jenda <jenda.jzqk73@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a0a9cc2
Parents:
132ab5d1
Message:

Merge commit '50f19b7ee8e94570b5c63896736c4eb49cfa18db' into forwardport

Not all ints are converted to errno_t in xhci tree yet, however it compiles and works :)

Location:
uspace/lib/usbdev
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/usbdev/include/usb/dev/alternate_ifaces.h

    r132ab5d1 r5a6cc679  
    3838#define LIBUSBDEV_ALTERNATE_IFACES_H_
    3939
     40#include <errno.h>
    4041#include <usb/descriptor.h>
    4142#include <stddef.h>
     
    6667
    6768size_t usb_interface_count_alternates(const uint8_t *, size_t, uint8_t);
    68 int usb_alternate_interfaces_init(usb_alternate_interfaces_t *,
     69errno_t usb_alternate_interfaces_init(usb_alternate_interfaces_t *,
    6970    const uint8_t *, size_t, int);
    7071void usb_alternate_interfaces_deinit(usb_alternate_interfaces_t *);
  • uspace/lib/usbdev/include/usb/dev/device.h

    r132ab5d1 r5a6cc679  
    5959
    6060/* DDF parts */
    61 int usb_device_create_ddf(ddf_dev_t *, const usb_endpoint_description_t **, const char **);
     61errno_t usb_device_create_ddf(ddf_dev_t *, const usb_endpoint_description_t **, const char **);
    6262void usb_device_destroy_ddf(ddf_dev_t *);
    6363
     
    7777void usb_device_bus_exchange_end(async_exch_t *);
    7878
    79 int usb_device_select_interface(usb_device_t *, uint8_t,
     79errno_t usb_device_select_interface(usb_device_t *, uint8_t,
    8080    const usb_endpoint_description_t **);
    8181
    82 int usb_device_create_pipes(usb_device_t *usb_dev,
     82errno_t usb_device_create_pipes(usb_device_t *usb_dev,
    8383    const usb_endpoint_description_t **endpoints);
    8484void usb_device_destroy_pipes(usb_device_t *);
  • uspace/lib/usbdev/include/usb/dev/driver.h

    r132ab5d1 r5a6cc679  
    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_remove)(usb_device_t *);
     47        errno_t (*device_remove)(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        /** Callback asking the driver to online a specific function. */
    51         int (*function_online)(ddf_fun_t *);
     51        errno_t (*function_online)(ddf_fun_t *);
    5252        /** Callback asking the driver to offline a specific function. */
    53         int (*function_offline)(ddf_fun_t *);
     53        errno_t (*function_offline)(ddf_fun_t *);
    5454} usb_driver_ops_t;
    5555
  • uspace/lib/usbdev/include/usb/dev/pipes.h

    r132ab5d1 r5a6cc679  
    9898} usb_endpoint_mapping_t;
    9999
    100 int usb_pipe_initialize(usb_pipe_t *, usb_dev_session_t *);
    101 int usb_pipe_initialize_default_control(usb_pipe_t *, usb_dev_session_t *);
     100errno_t usb_pipe_initialize(usb_pipe_t *, usb_dev_session_t *);
     101errno_t usb_pipe_initialize_default_control(usb_pipe_t *, usb_dev_session_t *);
    102102
    103 int usb_pipe_initialize_from_configuration(usb_endpoint_mapping_t *,
     103errno_t usb_pipe_initialize_from_configuration(usb_endpoint_mapping_t *,
    104104    size_t, const uint8_t *, size_t, usb_dev_session_t *);
    105105
    106 int usb_pipe_register(usb_pipe_t *, const usb_standard_endpoint_descriptor_t *, const usb_superspeed_endpoint_companion_descriptor_t *);
    107 int usb_pipe_unregister(usb_pipe_t *);
     106errno_t usb_pipe_register(usb_pipe_t *, const usb_standard_endpoint_descriptor_t *, const usb_superspeed_endpoint_companion_descriptor_t *);
     107errno_t usb_pipe_unregister(usb_pipe_t *);
    108108
    109 int usb_pipe_read(usb_pipe_t *, void *, size_t, size_t *);
    110 int usb_pipe_write(usb_pipe_t *, const void *, size_t);
     109errno_t usb_pipe_read(usb_pipe_t *, void *, size_t, size_t *);
     110errno_t usb_pipe_write(usb_pipe_t *, const void *, size_t);
    111111
    112 int usb_pipe_control_read(usb_pipe_t *, const void *, size_t,
     112errno_t usb_pipe_control_read(usb_pipe_t *, const void *, size_t,
    113113    void *, size_t, size_t *);
    114 int usb_pipe_control_write(usb_pipe_t *, const void *, size_t,
     114errno_t usb_pipe_control_write(usb_pipe_t *, const void *, size_t,
    115115    const void *, size_t);
    116116
  • uspace/lib/usbdev/include/usb/dev/poll.h

    r132ab5d1 r5a6cc679  
    118118         * @return Whether to continue in polling.
    119119         */
    120         bool (*on_error)(usb_device_t *dev, int err_code, void *arg);
     120        bool (*on_error)(usb_device_t *dev, errno_t err_code, void *arg);
    121121
    122122
     
    139139} usb_polling_t;
    140140
    141 int usb_polling_init(usb_polling_t *);
     141errno_t usb_polling_init(usb_polling_t *);
    142142void usb_polling_fini(usb_polling_t *);
    143143
    144 int usb_polling_start(usb_polling_t *);
    145 int usb_polling_join(usb_polling_t *);
     144errno_t usb_polling_start(usb_polling_t *);
     145errno_t usb_polling_join(usb_polling_t *);
    146146
    147147#endif
  • uspace/lib/usbdev/include/usb/dev/recognise.h

    r132ab5d1 r5a6cc679  
    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

    r132ab5d1 r5a6cc679  
    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_pipe_clear_halt(usb_pipe_t *, usb_pipe_t *);
    88 int usb_request_get_endpoint_status(usb_pipe_t *, usb_pipe_t *, uint16_t *);
     87errno_t usb_pipe_clear_halt(usb_pipe_t *, usb_pipe_t *);
     88errno_t usb_request_get_endpoint_status(usb_pipe_t *, usb_pipe_t *, uint16_t *);
    8989
    9090#endif
  • uspace/lib/usbdev/src/altiface.c

    r132ab5d1 r5a6cc679  
    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

    r132ab5d1 r5a6cc679  
    141141 * @return Error code.
    142142 */
    143 int usb_device_select_interface(usb_device_t *usb_dev,
     143errno_t usb_device_select_interface(usb_device_t *usb_dev,
    144144    uint8_t alternate_setting, const usb_endpoint_description_t **endpoints)
    145145{
     
    151151
    152152        /* Change the interface itself. */
    153         int rc = usb_request_set_interface(&usb_dev->ctrl_pipe,
     153        errno_t rc = usb_request_set_interface(&usb_dev->ctrl_pipe,
    154154            usb_dev->interface_no, alternate_setting);
    155155        if (rc != EOK) {
     
    175175 * @return Error code.
    176176 */
    177 static int usb_device_retrieve_descriptors(usb_device_t *usb_dev)
     177static errno_t usb_device_retrieve_descriptors(usb_device_t *usb_dev)
    178178{
    179179        assert(usb_dev);
     
    181181
    182182        /* Get the device descriptor. */
    183         int rc = usb_request_get_device_descriptor(&usb_dev->ctrl_pipe,
     183        errno_t rc = usb_request_get_device_descriptor(&usb_dev->ctrl_pipe,
    184184            &usb_dev->descriptors.device);
    185185        if (rc != EOK) {
     
    227227 * @return Error code.
    228228 */
    229 int usb_device_create_pipes(usb_device_t *usb_dev,
     229errno_t usb_device_create_pipes(usb_device_t *usb_dev,
    230230    const usb_endpoint_description_t **endpoints)
    231231{
     
    255255
    256256        /* Find the mapping from configuration descriptor. */
    257         int rc = usb_pipe_initialize_from_configuration(pipes, pipe_count,
     257        errno_t rc = usb_pipe_initialize_from_configuration(pipes, pipe_count,
    258258            usb_dev->descriptors.full_config,
    259259            usb_dev->descriptors.full_config_size,
     
    429429 * @return Error code.
    430430 */
    431 static int usb_device_init(usb_device_t *usb_dev, ddf_dev_t *ddf_dev,
     431static errno_t usb_device_init(usb_device_t *usb_dev, ddf_dev_t *ddf_dev,
    432432    const usb_endpoint_description_t **endpoints, const char **errstr_ptr)
    433433{
     
    453453        /* This pipe was registered by the hub driver,
    454454         * during device initialization. */
    455         int rc = usb_pipe_initialize_default_control(&usb_dev->ctrl_pipe, usb_dev->bus_session);
     455        errno_t rc = usb_pipe_initialize_default_control(&usb_dev->ctrl_pipe, usb_dev->bus_session);
    456456        if (rc != EOK) {
    457457                usb_dev_disconnect(usb_dev->bus_session);
     
    489489}
    490490
    491 static int usb_device_get_info(async_sess_t *sess, usb_device_t *dev)
     491static errno_t usb_device_get_info(async_sess_t *sess, usb_device_t *dev)
    492492{
    493493        assert(dev);
     
    498498
    499499        usb_device_desc_t dev_desc;
    500         const int ret = usb_get_my_description(exch, &dev_desc);
     500        const errno_t ret = usb_get_my_description(exch, &dev_desc);
    501501
    502502        if (ret == EOK) {
     
    512512}
    513513
    514 int usb_device_create_ddf(ddf_dev_t *ddf_dev,
     514errno_t usb_device_create_ddf(ddf_dev_t *ddf_dev,
    515515    const usb_endpoint_description_t **desc, const char **err)
    516516{
     
    529529        }
    530530
    531         const int ret = usb_device_get_info(sess, usb_dev);
     531        const errno_t ret = usb_device_get_info(sess, usb_dev);
    532532        if (ret != EOK)
    533533                return ret;
     
    552552
    553553        async_sess_t *sess = devman_device_connect(handle, IPC_FLAG_BLOCKING);
    554         int ret = usb_device_get_info(sess, usb_dev);
     554        errno_t ret = usb_device_get_info(sess, usb_dev);
    555555        if (sess)
    556556                async_hangup(sess);
  • uspace/lib/usbdev/src/devpoll.c

    r132ab5d1 r5a6cc679  
    103103 * @return Always EOK.
    104104 */
    105 static int polling_fibril(void *arg)
     105static errno_t polling_fibril(void *arg)
    106106{
    107107        assert(arg);
     
    130130        while (failed_attempts <= polling->max_failures) {
    131131                size_t actual_size;
    132                 const int rc = usb_pipe_read(pipe, polling->buffer,
     132                const errno_t rc = usb_pipe_read(pipe, polling->buffer,
    133133                    polling->request_size, &actual_size);
    134134
     
    233233 * @retval EOK New fibril polling the device was already started.
    234234 */
    235 int usb_polling_start(usb_polling_t *polling)
     235errno_t usb_polling_start(usb_polling_t *polling)
    236236{
    237237        if (!polling || !polling->device || !polling->ep_mapping || !polling->on_data)
     
    272272 *  @retval EOK Polling fibril has been successfully terminated.
    273273 */
    274 int usb_polling_join(usb_polling_t *polling)
    275 {
    276         int rc;
     274errno_t usb_polling_join(usb_polling_t *polling)
     275{
     276        errno_t rc;
    277277        if (!polling)
    278278                return EBADMEM;
  • uspace/lib/usbdev/src/driver.c

    r132ab5d1 r5a6cc679  
    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.",
     
    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);
     
    9090        /* Just tell the driver to stop whatever it is doing */
    9191        usb_device_t *usb_dev = ddf_dev_data_get(gen_dev);
    92         int ret = driver->ops->device_remove(usb_dev);
     92        const errno_t ret = driver->ops->device_remove(usb_dev);
    9393        if (ret != EOK)
    9494                return ret;
     
    105105 * @return Error code.
    106106 */
    107 static int generic_device_gone(ddf_dev_t *gen_dev)
     107static errno_t generic_device_gone(ddf_dev_t *gen_dev)
    108108{
    109109        assert(driver);
     
    112112                return ENOTSUP;
    113113        usb_device_t *usb_dev = ddf_dev_data_get(gen_dev);
    114         const int ret = driver->ops->device_gone(usb_dev);
     114        const errno_t ret = driver->ops->device_gone(usb_dev);
    115115        if (ret == EOK)
    116116                usb_device_destroy_ddf(gen_dev);
  • uspace/lib/usbdev/src/pipes.c

    r132ab5d1 r5a6cc679  
    7373 * @return Error code.
    7474 */
    75 int usb_pipe_control_read(usb_pipe_t *pipe,
     75errno_t usb_pipe_control_read(usb_pipe_t *pipe,
    7676    const void *setup_buffer, size_t setup_buffer_size,
    7777    void *buffer, size_t buffer_size, size_t *transferred_size)
     
    9797        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
    9898        size_t act_size = 0;
    99         const int rc = usbhc_read(exch, pipe->desc.endpoint_no, setup_packet, buffer,
     99        const errno_t rc = usbhc_read(exch, pipe->desc.endpoint_no, setup_packet, buffer,
    100100            buffer_size, &act_size);
    101101        async_exchange_end(exch);
     
    123123 * @return Error code.
    124124 */
    125 int usb_pipe_control_write(usb_pipe_t *pipe,
     125errno_t usb_pipe_control_write(usb_pipe_t *pipe,
    126126    const void *setup_buffer, size_t setup_buffer_size,
    127127    const void *buffer, size_t buffer_size)
     
    150150
    151151        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
    152         const int rc = usbhc_write(exch,
     152        const errno_t rc = usbhc_write(exch,
    153153            pipe->desc.endpoint_no, setup_packet, buffer, buffer_size);
    154154        async_exchange_end(exch);
     
    169169 * @return Error code.
    170170 */
    171 int usb_pipe_read(usb_pipe_t *pipe,
     171errno_t usb_pipe_read(usb_pipe_t *pipe,
    172172    void *buffer, size_t size, size_t *size_transferred)
    173173{
     
    192192        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
    193193        size_t act_size = 0;
    194         const int rc =
     194        const errno_t rc =
    195195            usbhc_read(exch, pipe->desc.endpoint_no, 0, buffer, size, &act_size);
    196196        async_exchange_end(exch);
     
    210210 * @return Error code.
    211211 */
    212 int usb_pipe_write(usb_pipe_t *pipe, const void *buffer, size_t size)
     212errno_t usb_pipe_write(usb_pipe_t *pipe, const void *buffer, size_t size)
    213213{
    214214        assert(pipe);
     
    227227
    228228        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
    229         const int rc = usbhc_write(exch, pipe->desc.endpoint_no, 0, buffer, size);
     229        const errno_t rc = usbhc_write(exch, pipe->desc.endpoint_no, 0, buffer, size);
    230230        async_exchange_end(exch);
    231231        return rc;
     
    238238 * @return Error code.
    239239 */
    240 int usb_pipe_initialize(usb_pipe_t *pipe, usb_dev_session_t *bus_session)
     240errno_t usb_pipe_initialize(usb_pipe_t *pipe, usb_dev_session_t *bus_session)
    241241{
    242242        assert(pipe);
     
    263263 * @return Error code.
    264264 */
    265 int usb_pipe_initialize_default_control(usb_pipe_t *pipe, usb_dev_session_t *bus_session)
    266 {
    267         const int ret = usb_pipe_initialize(pipe, bus_session);
     265errno_t usb_pipe_initialize_default_control(usb_pipe_t *pipe, usb_dev_session_t *bus_session)
     266{
     267        const errno_t ret = usb_pipe_initialize(pipe, bus_session);
    268268        if (ret)
    269269                return ret;
     
    282282 * @return Error code.
    283283 */
    284 int usb_pipe_register(usb_pipe_t *pipe, const usb_standard_endpoint_descriptor_t *ep_desc, const usb_superspeed_endpoint_companion_descriptor_t *comp_desc)
     284errno_t usb_pipe_register(usb_pipe_t *pipe, const usb_standard_endpoint_descriptor_t *ep_desc, const usb_superspeed_endpoint_companion_descriptor_t *comp_desc)
    285285{
    286286        assert(pipe);
     
    309309#undef COPY
    310310
    311         const int ret = usbhc_register_endpoint(exch, &pipe->desc, &descriptors);
     311        const errno_t ret = usbhc_register_endpoint(exch, &pipe->desc, &descriptors);
    312312        async_exchange_end(exch);
    313313        return ret;
     
    319319 * @return Error code.
    320320 */
    321 int usb_pipe_unregister(usb_pipe_t *pipe)
     321errno_t usb_pipe_unregister(usb_pipe_t *pipe)
    322322{
    323323        assert(pipe);
     
    327327                return ENOMEM;
    328328
    329         const int ret = usbhc_unregister_endpoint(exch, &pipe->desc);
     329        const errno_t ret = usbhc_unregister_endpoint(exch, &pipe->desc);
    330330
    331331        async_exchange_end(exch);
  • uspace/lib/usbdev/src/pipesinit.c

    r132ab5d1 r5a6cc679  
    165165 * @return Error code.
    166166 */
    167 static int process_endpoint(
     167static errno_t process_endpoint(
    168168    usb_endpoint_mapping_t *mapping, size_t mapping_count,
    169169    usb_standard_interface_descriptor_t *interface,
     
    200200        }
    201201
    202         int err = usb_pipe_initialize(&ep_mapping->pipe, bus_session);
     202        errno_t err = usb_pipe_initialize(&ep_mapping->pipe, bus_session);
    203203        if (err)
    204204                return err;
     
    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,
     
    291291 * @return Error code.
    292292 */
    293 int usb_pipe_initialize_from_configuration(
     293errno_t usb_pipe_initialize_from_configuration(
    294294    usb_endpoint_mapping_t *mapping, size_t mapping_count,
    295295    const uint8_t *config_descriptor, size_t config_descriptor_size,
  • uspace/lib/usbdev/src/recognise.c

    r132ab5d1 r5a6cc679  
    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

    r132ab5d1 r5a6cc679  
    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_transferred_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_transferred_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 static int usb_request_clear_endpoint_halt(usb_pipe_t *pipe, uint16_t ep_index)
     826static errno_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)) {
     
    856856 * @return Error code.
    857857 */
    858 int usb_request_get_endpoint_status(usb_pipe_t *ctrl_pipe, usb_pipe_t *pipe,
     858errno_t usb_request_get_endpoint_status(usb_pipe_t *ctrl_pipe, usb_pipe_t *pipe,
    859859    uint16_t *status)
    860860{
    861861        uint16_t status_tmp;
    862862        uint16_t pipe_index = (uint16_t) pipe->desc.endpoint_no;
    863         int rc = usb_request_get_status(ctrl_pipe,
     863        errno_t rc = usb_request_get_status(ctrl_pipe,
    864864            USB_REQUEST_RECIPIENT_ENDPOINT, uint16_host2usb(pipe_index),
    865865            &status_tmp);
Note: See TracChangeset for help on using the changeset viewer.