Changeset b7fd2a0 in mainline for uspace/lib/usbhost/src


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/usbhost/src
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/usbhost/src/ddf_helpers.c

    r36f0738 rb7fd2a0  
    9191
    9292
    93 static int hcd_ddf_new_device(ddf_dev_t *device, usb_dev_t *hub, unsigned port);
    94 static int hcd_ddf_remove_device(ddf_dev_t *device, usb_dev_t *hub, unsigned port);
     93static errno_t hcd_ddf_new_device(ddf_dev_t *device, usb_dev_t *hub, unsigned port);
     94static errno_t hcd_ddf_remove_device(ddf_dev_t *device, usb_dev_t *hub, unsigned port);
    9595
    9696
    … …  
    107107 * @return Error code.
    108108 */
    109 static int register_endpoint(
     109static errno_t register_endpoint(
    110110    ddf_fun_t *fun, usb_endpoint_t endpoint,
    111111    usb_transfer_type_t transfer_type, usb_direction_t direction,
    … …  
    136136 * @return Error code.
    137137 */
    138 static int unregister_endpoint(
     138static errno_t unregister_endpoint(
    139139    ddf_fun_t *fun, usb_endpoint_t endpoint, usb_direction_t direction)
    140140{
    … …  
    151151}
    152152
    153 static int reserve_default_address(ddf_fun_t *fun, usb_speed_t speed)
     153static errno_t reserve_default_address(ddf_fun_t *fun, usb_speed_t speed)
    154154{
    155155        assert(fun);
    … …  
    164164}
    165165
    166 static int release_default_address(ddf_fun_t *fun)
     166static errno_t release_default_address(ddf_fun_t *fun)
    167167{
    168168        assert(fun);
    … …  
    176176}
    177177
    178 static int device_enumerate(ddf_fun_t *fun, unsigned port)
     178static errno_t device_enumerate(ddf_fun_t *fun, unsigned port)
    179179{
    180180        assert(fun);
    … …  
    188188}
    189189
    190 static int device_remove(ddf_fun_t *fun, unsigned port)
     190static errno_t device_remove(ddf_fun_t *fun, unsigned port)
    191191{
    192192        assert(fun);
    … …  
    206206 * @return Error code.
    207207 */
    208 static int get_my_device_handle(ddf_fun_t *fun, devman_handle_t *handle)
     208static errno_t get_my_device_handle(ddf_fun_t *fun, devman_handle_t *handle)
    209209{
    210210        assert(fun);
    … …  
    224224 * @return Error code.
    225225 */
    226 static int dev_read(ddf_fun_t *fun, usb_endpoint_t endpoint,
     226static errno_t dev_read(ddf_fun_t *fun, usb_endpoint_t endpoint,
    227227    uint64_t setup_data, uint8_t *data, size_t size,
    228228    usbhc_iface_transfer_in_callback_t callback, void *arg)
    … …  
    250250 * @return Error code.
    251251 */
    252 static int dev_write(ddf_fun_t *fun, usb_endpoint_t endpoint,
     252static errno_t dev_write(ddf_fun_t *fun, usb_endpoint_t endpoint,
    253253    uint64_t setup_data, const uint8_t *data, size_t size,
    254254    usbhc_iface_transfer_out_callback_t callback, void *arg)
    … …  
    313313};
    314314
    315 static int hcd_ddf_add_device(ddf_dev_t *parent, usb_dev_t *hub_dev,
     315static errno_t hcd_ddf_add_device(ddf_dev_t *parent, usb_dev_t *hub_dev,
    316316    unsigned port, usb_address_t address, usb_speed_t speed, const char *name,
    317317    const match_id_list_t *mids)
    … …  
    351351        }
    352352
    353         int ret = ddf_fun_bind(fun);
     353        errno_t ret = ddf_fun_bind(fun);
    354354        if (ret != EOK) {
    355355                ddf_fun_destroy(fun);
    … …  
    389389
    390390/* This is a copy of lib/usbdev/src/recognise.c */
    391 static int create_match_ids(match_id_list_t *l,
     391static errno_t create_match_ids(match_id_list_t *l,
    392392    usb_standard_device_descriptor_t *d)
    393393{
    … …  
    418418}
    419419
    420 static int hcd_ddf_remove_device(ddf_dev_t *device, usb_dev_t *hub,
     420static errno_t hcd_ddf_remove_device(ddf_dev_t *device, usb_dev_t *hub,
    421421    unsigned port)
    422422{
    … …  
    443443                list_remove(&victim->link);
    444444                fibril_mutex_unlock(&hub->guard);
    445                 const int ret = ddf_fun_unbind(victim->fun);
     445                const errno_t ret = ddf_fun_unbind(victim->fun);
    446446                if (ret == EOK) {
    447447                        usb_address_t address = victim->address;
    … …  
    458458}
    459459
    460 static int hcd_ddf_new_device(ddf_dev_t *device, usb_dev_t *hub, unsigned port)
     460static errno_t hcd_ddf_new_device(ddf_dev_t *device, usb_dev_t *hub, unsigned port)
    461461{
    462462        assert(device);
    … …  
    468468
    469469        /* This checks whether the default address is reserved and gets speed */
    470         int ret = usb_bus_get_speed(&hcd->bus, USB_ADDRESS_DEFAULT, &speed);
     470        errno_t ret = usb_bus_get_speed(&hcd->bus, USB_ADDRESS_DEFAULT, &speed);
    471471        if (ret != EOK) {
    472472                usb_log_error("Failed to verify speed: %s.", str_error(ret));
    … …  
    621621 * @return Error code
    622622 */
    623 int hcd_ddf_setup_root_hub(ddf_dev_t *device)
     623errno_t hcd_ddf_setup_root_hub(ddf_dev_t *device)
    624624{
    625625        assert(device);
    … …  
    628628
    629629        hcd_reserve_default_address(hcd, hcd->bus.max_speed);
    630         const int ret = hcd_ddf_new_device(device, NULL, 0);
     630        const errno_t ret = hcd_ddf_new_device(device, NULL, 0);
    631631        hcd_release_default_address(hcd);
    632632        return ret;
    … …  
    643643 * This function does all the ddf work for hc driver.
    644644 */
    645 int hcd_ddf_setup_hc(ddf_dev_t *device, usb_speed_t max_speed,
     645errno_t hcd_ddf_setup_hc(ddf_dev_t *device, usb_speed_t max_speed,
    646646    size_t bw, bw_count_func_t bw_count)
    647647{
    … …  
    656656        hcd_init(&instance->hcd, max_speed, bw, bw_count);
    657657
    658         int ret = ENOMEM;
     658        errno_t ret = ENOMEM;
    659659        instance->ctl_fun = ddf_fun_create(device, fun_exposed, "ctl");
    660660        if (!instance->ctl_fun) {
    … …  
    691691        hc_dev_t *hc = dev_to_hc_dev(device);
    692692        assert(hc);
    693         const int ret = ddf_fun_unbind(hc->ctl_fun);
     693        const errno_t ret = ddf_fun_unbind(hc->ctl_fun);
    694694        if (ret == EOK)
    695695                ddf_fun_destroy(hc->ctl_fun);
    … …  
    703703 * @return Error code.
    704704 */
    705 int hcd_ddf_enable_interrupt(ddf_dev_t *device, int inum)
     705errno_t hcd_ddf_enable_interrupt(ddf_dev_t *device, int inum)
    706706{
    707707        async_sess_t *parent_sess = ddf_dev_parent_sess_get(device);
    … …  
    713713
    714714//TODO: Cache parent session in HCD
    715 int hcd_ddf_get_registers(ddf_dev_t *device, hw_res_list_parsed_t *hw_res)
     715errno_t hcd_ddf_get_registers(ddf_dev_t *device, hw_res_list_parsed_t *hw_res)
    716716{
    717717        async_sess_t *parent_sess = ddf_dev_parent_sess_get(device);
    … …  
    720720
    721721        hw_res_list_parsed_init(hw_res);
    722         const int ret = hw_res_get_list_parsed(parent_sess, hw_res, 0);
     722        const errno_t ret = hw_res_get_list_parsed(parent_sess, hw_res, 0);
    723723        if (ret != EOK)
    724724                hw_res_list_parsed_clean(hw_res);
    … …  
    751751 * @return Error code.
    752752 */
    753 int hcd_ddf_setup_interrupts(ddf_dev_t *device,
     753errno_t hcd_ddf_setup_interrupts(ddf_dev_t *device,
    754754    const hw_res_list_parsed_t *hw_res,
    755755    interrupt_handler_t handler,
    756     int (*gen_irq_code)(irq_code_t *, const hw_res_list_parsed_t *, int *),
     756    errno_t (*gen_irq_code)(irq_code_t *, const hw_res_list_parsed_t *, int *),
    757757    cap_handle_t *handle)
    758758{
    … …  
    765765
    766766        int irq;
    767         int ret = gen_irq_code(&irq_code, hw_res, &irq);
     767        errno_t ret = gen_irq_code(&irq_code, hw_res, &irq);
    768768        if (ret != EOK) {
    769769                usb_log_error("Failed to generate IRQ code: %s.\n",
    … …  
    809809}
    810810
    811 static int interrupt_polling(void *arg)
     811static errno_t interrupt_polling(void *arg)
    812812{
    813813        hcd_t *hcd = arg;
    … …  
    847847 *  - registers root hub
    848848 */
    849 int hcd_ddf_add_hc(ddf_dev_t *device, const ddf_hc_driver_t *driver)
     849errno_t hcd_ddf_add_hc(ddf_dev_t *device, const ddf_hc_driver_t *driver)
    850850{
    851851        assert(driver);
    … …  
    857857        };
    858858
    859         int ret = EOK;
     859        errno_t ret = EOK;
    860860        const usb_speed_t speed = driver->hc_speed;
    861861        if (speed >= ARRAY_SIZE(bw) || bw[speed].bw == 0) {
    … …  
    884884            driver->irq_handler ? driver->irq_handler : ddf_hcd_gen_irq_handler;
    885885        int irq_cap;
    886         int irq_ret = hcd_ddf_setup_interrupts(device, &hw_res,
     886        errno_t irq_ret = hcd_ddf_setup_interrupts(device, &hw_res,
    887887            irq_handler, driver->irq_code_gen, &irq_cap);
    888888        bool irqs_enabled = (irq_ret == EOK);

  • uspace/lib/usbhost/src/hcd.c

    r36f0738 rb7fd2a0  
    4949 * @return Error code.
    5050 */
    51 static int register_helper(endpoint_t *ep, void *arg)
     51static errno_t register_helper(endpoint_t *ep, void *arg)
    5252{
    5353        hcd_t *hcd = arg;
    … …  
    102102}
    103103
    104 int hcd_request_address(hcd_t *hcd, usb_speed_t speed, usb_address_t *address)
     104errno_t hcd_request_address(hcd_t *hcd, usb_speed_t speed, usb_address_t *address)
    105105{
    106106        assert(hcd);
    … …  
    108108}
    109109
    110 int hcd_release_address(hcd_t *hcd, usb_address_t address)
     110errno_t hcd_release_address(hcd_t *hcd, usb_address_t address)
    111111{
    112112        assert(hcd);
    … …  
    115115}
    116116
    117 int hcd_reserve_default_address(hcd_t *hcd, usb_speed_t speed)
     117errno_t hcd_reserve_default_address(hcd_t *hcd, usb_speed_t speed)
    118118{
    119119        assert(hcd);
    … …  
    122122}
    123123
    124 int hcd_add_ep(hcd_t *hcd, usb_target_t target, usb_direction_t dir,
     124errno_t hcd_add_ep(hcd_t *hcd, usb_target_t target, usb_direction_t dir,
    125125    usb_transfer_type_t type, size_t max_packet_size, unsigned packets,
    126126    size_t size, usb_address_t tt_address, unsigned tt_port)
    … …  
    132132}
    133133
    134 int hcd_remove_ep(hcd_t *hcd, usb_target_t target, usb_direction_t dir)
     134errno_t hcd_remove_ep(hcd_t *hcd, usb_target_t target, usb_direction_t dir)
    135135{
    136136        assert(hcd);
    … …  
    147147} toggle_t;
    148148
    149 static void toggle_reset_callback(int retval, void *arg)
     149static void toggle_reset_callback(errno_t retval, void *arg)
    150150{
    151151        assert(arg);
    … …  
    172172 * @return Error code.
    173173 */
    174 int hcd_send_batch(
     174errno_t hcd_send_batch(
    175175    hcd_t *hcd, usb_target_t target, usb_direction_t direction,
    176176    void *data, size_t size, uint64_t setup_data,
    … …  
    232232        }
    233233
    234         const int ret = hcd->ops.schedule(hcd, batch);
     234        const errno_t ret = hcd->ops.schedule(hcd, batch);
    235235        if (ret != EOK)
    236236                usb_transfer_batch_destroy(batch);
    … …  
    244244typedef struct {
    245245        volatile unsigned done;
    246         int ret;
     246        errno_t ret;
    247247        size_t size;
    248248} sync_data_t;
    249249
    250 static void transfer_in_cb(int ret, size_t size, void* data)
     250static void transfer_in_cb(errno_t ret, size_t size, void* data)
    251251{
    252252        sync_data_t *d = data;
    … …  
    257257}
    258258
    259 static void transfer_out_cb(int ret, void* data)
     259static void transfer_out_cb(errno_t ret, void* data)
    260260{
    261261        sync_data_t *d = data;
    … …  
    266266
    267267/** this is really ugly version of sync usb communication */
    268 int hcd_send_batch_sync(
     268errno_t hcd_send_batch_sync(
    269269    hcd_t *hcd, usb_target_t target, usb_direction_t dir,
    270270    void *data, size_t size, uint64_t setup_data, const char* name, size_t *out_size)
    … …  
    273273        sync_data_t sd = { .done = 0, .ret = EBUSY, .size = size };
    274274
    275         const int ret = hcd_send_batch(hcd, target, dir, data, size, setup_data,
     275        const errno_t ret = hcd_send_batch(hcd, target, dir, data, size, setup_data,
    276276            dir == USB_DIRECTION_IN ? transfer_in_cb : NULL,
    277277            dir == USB_DIRECTION_OUT ? transfer_out_cb : NULL, &sd, name);

  • uspace/lib/usbhost/src/usb_bus.c

    r36f0738 rb7fd2a0  
    105105 * @return Error code.
    106106 */
    107 static int usb_bus_get_free_address(usb_bus_t *instance, usb_address_t *address)
     107static errno_t usb_bus_get_free_address(usb_bus_t *instance, usb_address_t *address)
    108108{
    109109
    … …  
    200200 * @return Error code.
    201201 */
    202 int usb_bus_init(usb_bus_t *instance,
     202errno_t usb_bus_init(usb_bus_t *instance,
    203203    size_t available_bandwidth, bw_count_func_t bw_count, usb_speed_t max_speed)
    204204{
    … …  
    224224 * @return Error code.
    225225 */
    226 int usb_bus_register_ep(usb_bus_t *instance, endpoint_t *ep, size_t data_size)
     226errno_t usb_bus_register_ep(usb_bus_t *instance, endpoint_t *ep, size_t data_size)
    227227{
    228228        assert(instance);
    … …  
    262262 * @return Error code.
    263263 */
    264 int usb_bus_unregister_ep(usb_bus_t *instance, endpoint_t *ep)
     264errno_t usb_bus_unregister_ep(usb_bus_t *instance, endpoint_t *ep)
    265265{
    266266        assert(instance);
    … …  
    316316 * @return Error code.
    317317 */
    318 int usb_bus_add_ep(usb_bus_t *instance,
     318errno_t usb_bus_add_ep(usb_bus_t *instance,
    319319    usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction,
    320320    usb_transfer_type_t type, size_t max_packet_size, unsigned packets,
    … …  
    364364
    365365        if (callback) {
    366                 const int ret = callback(ep, arg);
     366                const errno_t ret = callback(ep, arg);
    367367                if (ret != EOK) {
    368368                        fibril_mutex_unlock(&instance->guard);
    … …  
    394394 * @return Error code.
    395395 */
    396 int usb_bus_remove_ep(usb_bus_t *instance,
     396errno_t usb_bus_remove_ep(usb_bus_t *instance,
    397397    usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction,
    398398    ep_remove_callback_t callback, void *arg)
    … …  
    417417}
    418418
    419 int usb_bus_reset_toggle(usb_bus_t *instance, usb_target_t target, bool all)
     419errno_t usb_bus_reset_toggle(usb_bus_t *instance, usb_target_t target, bool all)
    420420{
    421421        assert(instance);
    … …  
    423423                return EINVAL;
    424424
    425         int ret = ENOENT;
     425        errno_t ret = ENOENT;
    426426
    427427        fibril_mutex_lock(&instance->guard);
    … …  
    446446 * @return Error code.
    447447 */
    448 int usb_bus_remove_address(usb_bus_t *instance,
     448errno_t usb_bus_remove_address(usb_bus_t *instance,
    449449    usb_address_t address, ep_remove_callback_t callback, void *arg)
    450450{
    … …  
    455455        fibril_mutex_lock(&instance->guard);
    456456
    457         const int ret = instance->devices[address].occupied ? EOK : ENOENT;
     457        const errno_t ret = instance->devices[address].occupied ? EOK : ENOENT;
    458458        instance->devices[address].occupied = false;
    459459
    … …  
    481481 * @note Default address is only available in strict mode.
    482482 */
    483 int usb_bus_request_address(usb_bus_t *instance,
     483errno_t usb_bus_request_address(usb_bus_t *instance,
    484484    usb_address_t *address, bool strict, usb_speed_t speed)
    485485{
    … …  
    493493
    494494        usb_address_t addr = *address;
    495         int rc;
     495        errno_t rc;
    496496
    497497        fibril_mutex_lock(&instance->guard);
    … …  
    539539 * @return Error code.
    540540 */
    541 int usb_bus_get_speed(usb_bus_t *instance, usb_address_t address,
     541errno_t usb_bus_get_speed(usb_bus_t *instance, usb_address_t address,
    542542    usb_speed_t *speed)
    543543{
    … …  
    549549        fibril_mutex_lock(&instance->guard);
    550550
    551         const int ret = instance->devices[address].occupied ? EOK : ENOENT;
     551        const errno_t ret = instance->devices[address].occupied ? EOK : ENOENT;
    552552        if (speed && instance->devices[address].occupied) {
    553553                *speed = instance->devices[address].speed;

  • uspace/lib/usbhost/src/usb_transfer_batch.c

    r36f0738 rb7fd2a0  
    114114 */
    115115void usb_transfer_batch_finish_error(const usb_transfer_batch_t *instance,
    116     const void *data, size_t size, int error)
     116    const void *data, size_t size, errno_t error)
    117117{
    118118        assert(instance);
Note: See TracChangeset for help on using the changeset viewer.