Changeset 5a6cc679 in mainline for uspace/drv/bus


Ignore:
Timestamp:
2018-01-31T02:21:24Z (8 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/drv/bus
Files:
54 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/bus/adb/cuda_adb/cuda_adb.c

    r132ab5d1 r5a6cc679  
    5656
    5757static void cuda_dev_connection(ipc_callid_t, ipc_call_t *, void *);
    58 static int cuda_init(cuda_t *);
     58static errno_t cuda_init(cuda_t *);
    5959static void cuda_irq_handler(ipc_call_t *, void *);
    6060
    … …  
    108108};
    109109
    110 static int cuda_dev_create(cuda_t *cuda, const char *name, const char *id,
     110static errno_t cuda_dev_create(cuda_t *cuda, const char *name, const char *id,
    111111    adb_dev_t **rdev)
    112112{
    113113        adb_dev_t *dev = NULL;
    114114        ddf_fun_t *fun;
    115         int rc;
     115        errno_t rc;
    116116
    117117        fun = ddf_fun_create(cuda->dev, fun_inner, name);
    … …  
    155155}
    156156
    157 int cuda_add(cuda_t *cuda, cuda_res_t *res)
     157errno_t cuda_add(cuda_t *cuda, cuda_res_t *res)
    158158{
    159159        adb_dev_t *kbd = NULL;
    160160        adb_dev_t *mouse = NULL;
    161         int rc;
     161        errno_t rc;
    162162
    163163        cuda->phys_base = res->base;
    … …  
    187187}
    188188
    189 int cuda_remove(cuda_t *cuda)
     189errno_t cuda_remove(cuda_t *cuda)
    190190{
    191191        return ENOTSUP;
    192192}
    193193
    194 int cuda_gone(cuda_t *cuda)
     194errno_t cuda_gone(cuda_t *cuda)
    195195{
    196196        return ENOTSUP;
    … …  
    229229}
    230230
    231 static int cuda_init(cuda_t *cuda)
    232 {
    233         int rc;
     231static errno_t cuda_init(cuda_t *cuda)
     232{
     233        errno_t rc;
    234234
    235235        void *vaddr;

  • uspace/drv/bus/adb/cuda_adb/cuda_adb.h

    r132ab5d1 r5a6cc679  
    8787} cuda_t;
    8888
    89 extern int cuda_add(cuda_t *, cuda_res_t *);
    90 extern int cuda_remove(cuda_t *);
    91 extern int cuda_gone(cuda_t *);
     89extern errno_t cuda_add(cuda_t *, cuda_res_t *);
     90extern errno_t cuda_remove(cuda_t *);
     91extern errno_t cuda_gone(cuda_t *);
    9292
    9393#endif

  • uspace/drv/bus/adb/cuda_adb/main.c

    r132ab5d1 r5a6cc679  
    4343#define NAME  "cuda_adb"
    4444
    45 static int cuda_dev_add(ddf_dev_t *dev);
    46 static int cuda_dev_remove(ddf_dev_t *dev);
    47 static int cuda_dev_gone(ddf_dev_t *dev);
    48 static int cuda_fun_online(ddf_fun_t *fun);
    49 static int cuda_fun_offline(ddf_fun_t *fun);
     45static errno_t cuda_dev_add(ddf_dev_t *dev);
     46static errno_t cuda_dev_remove(ddf_dev_t *dev);
     47static errno_t cuda_dev_gone(ddf_dev_t *dev);
     48static errno_t cuda_fun_online(ddf_fun_t *fun);
     49static errno_t cuda_fun_offline(ddf_fun_t *fun);
    5050
    5151static driver_ops_t driver_ops = {
    … …  
    6262};
    6363
    64 static int cuda_get_res(ddf_dev_t *dev, cuda_res_t *res)
     64static errno_t cuda_get_res(ddf_dev_t *dev, cuda_res_t *res)
    6565{
    6666        async_sess_t *parent_sess;
    6767        hw_res_list_parsed_t hw_res;
    68         int rc;
     68        errno_t rc;
    6969
    7070        parent_sess = ddf_dev_parent_sess_get(dev);
    … …  
    9797}
    9898
    99 static int cuda_dev_add(ddf_dev_t *dev)
     99static errno_t cuda_dev_add(ddf_dev_t *dev)
    100100{
    101101        cuda_t *cuda;
    102102        cuda_res_t cuda_res;
    103         int rc;
     103        errno_t rc;
    104104
    105105        ddf_msg(LVL_DEBUG, "cuda_dev_add(%p)", dev);
    … …  
    122122}
    123123
    124 static int cuda_dev_remove(ddf_dev_t *dev)
     124static errno_t cuda_dev_remove(ddf_dev_t *dev)
    125125{
    126126        cuda_t *cuda = (cuda_t *)ddf_dev_data_get(dev);
    … …  
    131131}
    132132
    133 static int cuda_dev_gone(ddf_dev_t *dev)
     133static errno_t cuda_dev_gone(ddf_dev_t *dev)
    134134{
    135135        cuda_t *cuda = (cuda_t *)ddf_dev_data_get(dev);
    … …  
    140140}
    141141
    142 static int cuda_fun_online(ddf_fun_t *fun)
     142static errno_t cuda_fun_online(ddf_fun_t *fun)
    143143{
    144144        ddf_msg(LVL_DEBUG, "cuda_fun_online()");
    … …  
    146146}
    147147
    148 static int cuda_fun_offline(ddf_fun_t *fun)
     148static errno_t cuda_fun_offline(ddf_fun_t *fun)
    149149{
    150150        ddf_msg(LVL_DEBUG, "cuda_fun_offline()");

  • uspace/drv/bus/isa/i8237.c

    r132ab5d1 r5a6cc679  
    279279 *
    280280 */
    281 static inline int dma_controller_init(dma_controller_t *controller)
     281static inline errno_t dma_controller_init(dma_controller_t *controller)
    282282{
    283283        assert(controller);
    284         int ret = pio_enable(DMA_CONTROLLER_PAGE_BASE, sizeof(dma_page_regs_t),
     284        errno_t ret = pio_enable(DMA_CONTROLLER_PAGE_BASE, sizeof(dma_page_regs_t),
    285285            (void **) &controller->page_table);
    286286        if (ret != EOK)
    … …  
    339339 * @return Error code.
    340340 */
    341 int dma_channel_setup(unsigned int channel, uint32_t pa, uint32_t size,
     341errno_t dma_channel_setup(unsigned int channel, uint32_t pa, uint32_t size,
    342342    uint8_t mode)
    343343{
    … …  
    454454 * @return Error code.
    455455 */
    456 int dma_channel_remain(unsigned channel, size_t *size)
     456errno_t dma_channel_remain(unsigned channel, size_t *size)
    457457{
    458458        assert(size);

  • uspace/drv/bus/isa/i8237.h

    r132ab5d1 r5a6cc679  
    3838#define DRV_BUS_ISA_I8237_H
    3939
    40 extern int dma_channel_setup(unsigned, uint32_t, uint32_t, uint8_t);
    41 extern int dma_channel_remain(unsigned, size_t *);
     40extern errno_t dma_channel_setup(unsigned, uint32_t, uint32_t, uint8_t);
     41extern errno_t dma_channel_remain(unsigned, size_t *);
    4242
    4343#endif

  • uspace/drv/bus/isa/isa.c

    r132ab5d1 r5a6cc679  
    130130}
    131131
    132 static int isa_fun_enable_interrupt(ddf_fun_t *fnode, int irq)
     132static errno_t isa_fun_enable_interrupt(ddf_fun_t *fnode, int irq)
    133133{
    134134        isa_fun_t *fun = isa_fun(fnode);
    … …  
    140140}
    141141
    142 static int isa_fun_disable_interrupt(ddf_fun_t *fnode, int irq)
     142static errno_t isa_fun_disable_interrupt(ddf_fun_t *fnode, int irq)
    143143{
    144144        isa_fun_t *fun = isa_fun(fnode);
    … …  
    150150}
    151151
    152 static int isa_fun_clear_interrupt(ddf_fun_t *fnode, int irq)
     152static errno_t isa_fun_clear_interrupt(ddf_fun_t *fnode, int irq)
    153153{
    154154        isa_fun_t *fun = isa_fun(fnode);
    … …  
    160160}
    161161
    162 static int isa_fun_setup_dma(ddf_fun_t *fnode,
     162static errno_t isa_fun_setup_dma(ddf_fun_t *fnode,
    163163    unsigned int channel, uint32_t pa, uint32_t size, uint8_t mode)
    164164{
    … …  
    182182}
    183183
    184 static int isa_fun_remain_dma(ddf_fun_t *fnode,
     184static errno_t isa_fun_remain_dma(ddf_fun_t *fnode,
    185185    unsigned channel, size_t *size)
    186186{
    … …  
    232232};
    233233
    234 static int isa_dev_add(ddf_dev_t *dev);
    235 static int isa_dev_remove(ddf_dev_t *dev);
    236 static int isa_fun_online(ddf_fun_t *fun);
    237 static int isa_fun_offline(ddf_fun_t *fun);
     234static errno_t isa_dev_add(ddf_dev_t *dev);
     235static errno_t isa_dev_remove(ddf_dev_t *dev);
     236static errno_t isa_fun_online(ddf_fun_t *fun);
     237static errno_t isa_fun_offline(ddf_fun_t *fun);
    238238
    239239/** The isa device driver's standard operations */
    … …  
    277277        int fd;
    278278        size_t len;
    279         int rc;
     279        errno_t rc;
    280280        size_t nread;
    281281        struct stat st;
    … …  
    578578            "function %s", id, score, ddf_fun_get_name(fun->fnode));
    579579
    580         int rc = ddf_fun_add_match_id(fun->fnode, id, score);
     580        errno_t rc = ddf_fun_add_match_id(fun->fnode, id, score);
    581581        if (rc != EOK) {
    582582                ddf_msg(LVL_ERROR, "Failed adding match ID: %s",
    … …  
    698698}
    699699
    700 static int isa_dev_add(ddf_dev_t *dev)
     700static errno_t isa_dev_add(ddf_dev_t *dev)
    701701{
    702702        async_sess_t *sess;
    703         int rc;
     703        errno_t rc;
    704704
    705705        ddf_msg(LVL_DEBUG, "isa_dev_add, device handle = %d",
    … …  
    767767}
    768768
    769 static int isa_dev_remove(ddf_dev_t *dev)
     769static errno_t isa_dev_remove(ddf_dev_t *dev)
    770770{
    771771        isa_bus_t *isa = isa_bus(dev);
    … …  
    777777                    isa_fun_t, bus_link);
    778778
    779                 int rc = ddf_fun_offline(fun->fnode);
     779                errno_t rc = ddf_fun_offline(fun->fnode);
    780780                if (rc != EOK) {
    781781                        fibril_mutex_unlock(&isa->mutex);
    … …  
    807807}
    808808
    809 static int isa_fun_online(ddf_fun_t *fun)
     809static errno_t isa_fun_online(ddf_fun_t *fun)
    810810{
    811811        ddf_msg(LVL_DEBUG, "isa_fun_online()");
    … …  
    813813}
    814814
    815 static int isa_fun_offline(ddf_fun_t *fun)
     815static errno_t isa_fun_offline(ddf_fun_t *fun)
    816816{
    817817        ddf_msg(LVL_DEBUG, "isa_fun_offline()");

  • uspace/drv/bus/pci/pciintel/pci.c

    r132ab5d1 r5a6cc679  
    114114}
    115115
    116 static int pciintel_enable_interrupt(ddf_fun_t *fnode, int irq)
     116static errno_t pciintel_enable_interrupt(ddf_fun_t *fnode, int irq)
    117117{
    118118        pci_fun_t *fun = pci_fun(fnode);
    … …  
    124124}
    125125
    126 static int pciintel_disable_interrupt(ddf_fun_t *fnode, int irq)
     126static errno_t pciintel_disable_interrupt(ddf_fun_t *fnode, int irq)
    127127{
    128128        pci_fun_t *fun = pci_fun(fnode);
    … …  
    134134}
    135135
    136 static int pciintel_clear_interrupt(ddf_fun_t *fnode, int irq)
     136static errno_t pciintel_clear_interrupt(ddf_fun_t *fnode, int irq)
    137137{
    138138        pci_fun_t *fun = pci_fun(fnode);
    … …  
    154154
    155155
    156 static int config_space_write_32(ddf_fun_t *fun, uint32_t address,
     156static errno_t config_space_write_32(ddf_fun_t *fun, uint32_t address,
    157157    uint32_t data)
    158158{
    … …  
    163163}
    164164
    165 static int config_space_write_16(
     165static errno_t config_space_write_16(
    166166    ddf_fun_t *fun, uint32_t address, uint16_t data)
    167167{
    … …  
    172172}
    173173
    174 static int config_space_write_8(
     174static errno_t config_space_write_8(
    175175    ddf_fun_t *fun, uint32_t address, uint8_t data)
    176176{
    … …  
    181181}
    182182
    183 static int config_space_read_32(
     183static errno_t config_space_read_32(
    184184    ddf_fun_t *fun, uint32_t address, uint32_t *data)
    185185{
    … …  
    190190}
    191191
    192 static int config_space_read_16(
     192static errno_t config_space_read_16(
    193193    ddf_fun_t *fun, uint32_t address, uint16_t *data)
    194194{
    … …  
    199199}
    200200
    201 static int config_space_read_8(
     201static errno_t config_space_read_8(
    202202    ddf_fun_t *fun, uint32_t address, uint8_t *data)
    203203{
    … …  
    234234};
    235235
    236 static int pci_dev_add(ddf_dev_t *);
    237 static int pci_fun_online(ddf_fun_t *);
    238 static int pci_fun_offline(ddf_fun_t *);
     236static errno_t pci_dev_add(ddf_dev_t *);
     237static errno_t pci_fun_online(ddf_fun_t *);
     238static errno_t pci_fun_offline(ddf_fun_t *);
    239239
    240240/** PCI bus driver standard operations */
    … …  
    382382void pci_fun_create_match_ids(pci_fun_t *fun)
    383383{
    384         int rc;
     384        errno_t rc;
    385385        int ret;
    386386        char match_id_str[ID_MAX_STR_LEN];
    … …  
    602602{
    603603        pci_fun_t *fun;
    604         int rc;
     604        errno_t rc;
    605605       
    606606        int child_bus = 0;
    … …  
    684684}
    685685
    686 static int pci_dev_add(ddf_dev_t *dnode)
     686static errno_t pci_dev_add(ddf_dev_t *dnode)
    687687{
    688688        hw_resource_list_t hw_resources;
    … …  
    691691        bool got_res = false;
    692692        async_sess_t *sess;
    693         int rc;
     693        errno_t rc;
    694694       
    695695        ddf_msg(LVL_DEBUG, "pci_dev_add");
    … …  
    810810}
    811811
    812 static int pci_fun_online(ddf_fun_t *fun)
     812static errno_t pci_fun_online(ddf_fun_t *fun)
    813813{
    814814        ddf_msg(LVL_DEBUG, "pci_fun_online()");
    … …  
    816816}
    817817
    818 static int pci_fun_offline(ddf_fun_t *fun)
     818static errno_t pci_fun_offline(ddf_fun_t *fun)
    819819{
    820820        ddf_msg(LVL_DEBUG, "pci_fun_offline()");

  • uspace/drv/bus/usb/ehci/ehci_bus.h

    r132ab5d1 r5a6cc679  
    7272void ehci_bus_prepare_ops(void);
    7373
    74 int ehci_bus_init(ehci_bus_t *, hc_t *);
     74errno_t ehci_bus_init(ehci_bus_t *, hc_t *);
    7575
    7676/** Get and convert assigned ehci_endpoint_t structure

  • uspace/drv/bus/usb/ehci/ehci_rh.c

    r132ab5d1 r5a6cc679  
    9999 * initializes internal virtual hub.
    100100 */
    101 int ehci_rh_init(ehci_rh_t *instance, ehci_caps_regs_t *caps, ehci_regs_t *regs,
     101errno_t ehci_rh_init(ehci_rh_t *instance, ehci_caps_regs_t *caps, ehci_regs_t *regs,
    102102    fibril_mutex_t *guard, const char *name)
    103103{
    … …  
    141141 * status change requests might be postponed until there is something to report.
    142142 */
    143 int ehci_rh_schedule(ehci_rh_t *instance, usb_transfer_batch_t *batch)
     143errno_t ehci_rh_schedule(ehci_rh_t *instance, usb_transfer_batch_t *batch)
    144144{
    145145        assert(instance);
    … …  
    184184 * processing of a postponed request.
    185185 */
    186 int ehci_rh_interrupt(ehci_rh_t *instance)
     186errno_t ehci_rh_interrupt(ehci_rh_t *instance)
    187187{
    188188        fibril_mutex_lock(instance->guard);
    … …  
    231231 * @return Error code.
    232232 */
    233 static int req_get_status(usbvirt_device_t *device,
     233static errno_t req_get_status(usbvirt_device_t *device,
    234234    const usb_device_request_setup_packet_t *setup_packet,
    235235    uint8_t *data, size_t *act_size)
    … …  
    254254 * @return Error code.
    255255 */
    256 static int req_clear_hub_feature(usbvirt_device_t *device,
     256static errno_t req_clear_hub_feature(usbvirt_device_t *device,
    257257    const usb_device_request_setup_packet_t *setup_packet,
    258258    uint8_t *data, size_t *act_size)
    … …  
    282282 * @return Error code.
    283283 */
    284 static int req_get_port_status(usbvirt_device_t *device,
     284static errno_t req_get_port_status(usbvirt_device_t *device,
    285285    const usb_device_request_setup_packet_t *setup_packet,
    286286    uint8_t *data, size_t *act_size)
    … …  
    325325} ehci_rh_job_t;
    326326
    327 static int stop_reset(void *arg)
     327static errno_t stop_reset(void *arg)
    328328{
    329329        ehci_rh_job_t *job = arg;
    … …  
    354354}
    355355
    356 static int stop_resume(void *arg)
     356static errno_t stop_resume(void *arg)
    357357{
    358358        ehci_rh_job_t *job = arg;
    … …  
    367367}
    368368
    369 static int delayed_job(int (*func)(void*), ehci_rh_t *rh, unsigned port)
     369static errno_t delayed_job(errno_t (*func)(void*), ehci_rh_t *rh, unsigned port)
    370370{
    371371        ehci_rh_job_t *job = malloc(sizeof(*job));
    … …  
    393393 * @return Error code.
    394394 */
    395 static int req_clear_port_feature(usbvirt_device_t *device,
     395static errno_t req_clear_port_feature(usbvirt_device_t *device,
    396396    const usb_device_request_setup_packet_t *setup_packet,
    397397    uint8_t *data, size_t *act_size)
    … …  
    472472 * @return Error code.
    473473 */
    474 static int req_set_port_feature(usbvirt_device_t *device,
     474static errno_t req_set_port_feature(usbvirt_device_t *device,
    475475    const usb_device_request_setup_packet_t *setup_packet,
    476476    uint8_t *data, size_t *act_size)
    … …  
    521521 * only need 1 byte.
    522522 */
    523 static int req_status_change_handler(usbvirt_device_t *device,
     523static errno_t req_status_change_handler(usbvirt_device_t *device,
    524524    usb_endpoint_t endpoint, usb_transfer_type_t tr_type,
    525525    void *buffer, size_t buffer_size, size_t *actual_size)

  • uspace/drv/bus/usb/ehci/ehci_rh.h

    r132ab5d1 r5a6cc679  
    7979} ehci_rh_t;
    8080
    81 int ehci_rh_init(ehci_rh_t *instance, ehci_caps_regs_t *caps, ehci_regs_t *regs,
     81errno_t ehci_rh_init(ehci_rh_t *instance, ehci_caps_regs_t *caps, ehci_regs_t *regs,
    8282    fibril_mutex_t *guard, const char *name);
    83 int ehci_rh_schedule(ehci_rh_t *instance, usb_transfer_batch_t *batch);
    84 int ehci_rh_interrupt(ehci_rh_t *instance);
     83errno_t ehci_rh_schedule(ehci_rh_t *instance, usb_transfer_batch_t *batch);
     84errno_t ehci_rh_interrupt(ehci_rh_t *instance);
    8585
    8686/** Get EHCI rh address.

  • uspace/drv/bus/usb/ehci/endpoint_list.c

    r132ab5d1 r5a6cc679  
    5050 * Allocates memory for internal ed_t structure.
    5151 */
    52 int endpoint_list_init(endpoint_list_t *instance, const char *name)
     52errno_t endpoint_list_init(endpoint_list_t *instance, const char *name)
    5353{
    5454        assert(instance);

  • uspace/drv/bus/usb/ehci/endpoint_list.h

    r132ab5d1 r5a6cc679  
    6868}
    6969
    70 int endpoint_list_init(endpoint_list_t *instance, const char *name);
     70errno_t endpoint_list_init(endpoint_list_t *instance, const char *name);
    7171void endpoint_list_chain(endpoint_list_t *instance, const endpoint_list_t *next);
    7272void endpoint_list_append_ep(endpoint_list_t *instance, ehci_endpoint_t *ep);

  • uspace/drv/bus/usb/ehci/hc.c

    r132ab5d1 r5a6cc679  
    8989};
    9090
    91 static int hc_init_memory(hc_t *instance);
     91static errno_t hc_init_memory(hc_t *instance);
    9292
    9393/** Generate IRQ code.
    … …  
    9999 * @return Error code.
    100100 */
    101 int hc_gen_irq_code(irq_code_t *code, hc_device_t *hcd, const hw_res_list_parsed_t *hw_res, int *irq)
     101errno_t hc_gen_irq_code(irq_code_t *code, hc_device_t *hcd, const hw_res_list_parsed_t *hw_res, int *irq)
    102102{
    103103        assert(code);
    … …  
    151151 * @return Error code
    152152 */
    153 int hc_add(hc_device_t *hcd, const hw_res_list_parsed_t *hw_res)
     153errno_t hc_add(hc_device_t *hcd, const hw_res_list_parsed_t *hw_res)
    154154{
    155155        hc_t *instance = hcd_to_hc(hcd);
    … …  
    160160            return EINVAL;
    161161
    162         int ret = pio_enable_range(&hw_res->mem_ranges.ranges[0],
     162        errno_t ret = pio_enable_range(&hw_res->mem_ranges.ranges[0],
    163163            (void **)&instance->caps);
    164164        if (ret != EOK) {
    … …  
    265265}
    266266
    267 int ehci_hc_status(bus_t *bus_base, uint32_t *status)
     267errno_t ehci_hc_status(bus_t *bus_base, uint32_t *status)
    268268{
    269269        assert(bus_base);
    … …  
    289289 * @return Error code.
    290290 */
    291 int ehci_hc_schedule(usb_transfer_batch_t *batch)
     291errno_t ehci_hc_schedule(usb_transfer_batch_t *batch)
    292292{
    293293        assert(batch);
    … …  
    477477 * @return Error code.
    478478 */
    479 int hc_init_memory(hc_t *instance)
     479errno_t hc_init_memory(hc_t *instance)
    480480{
    481481        assert(instance);
    482482        usb_log_debug2("HC(%p): Initializing Async list(%p).", instance,
    483483            &instance->async_list);
    484         int ret = endpoint_list_init(&instance->async_list, "ASYNC");
     484        errno_t ret = endpoint_list_init(&instance->async_list, "ASYNC");
    485485        if (ret != EOK) {
    486486                usb_log_error("HC(%p): Failed to setup ASYNC list: %s",

  • uspace/drv/bus/usb/ehci/hc.h

    r132ab5d1 r5a6cc679  
    100100
    101101/* Boottime operations */
    102 extern int hc_add(hc_device_t *, const hw_res_list_parsed_t *);
    103 extern int hc_start(hc_device_t *);
    104 extern int hc_setup_roothub(hc_device_t *);
    105 extern int hc_gen_irq_code(irq_code_t *, hc_device_t *, const hw_res_list_parsed_t *, int *);
    106 extern int hc_gone(hc_device_t *);
     102extern errno_t hc_add(hc_device_t *, const hw_res_list_parsed_t *);
     103extern errno_t hc_start(hc_device_t *);
     104extern errno_t hc_setup_roothub(hc_device_t *);
     105extern errno_t hc_gen_irq_code(irq_code_t *, hc_device_t *, const hw_res_list_parsed_t *, int *);
     106extern errno_t hc_gone(hc_device_t *);
    107107
    108108/** Runtime operations */
    109109extern void ehci_hc_interrupt(bus_t *, uint32_t);
    110 extern int ehci_hc_status(bus_t *, uint32_t *);
    111 extern int ehci_hc_schedule(usb_transfer_batch_t *);
     110extern errno_t ehci_hc_status(bus_t *, uint32_t *);
     111extern errno_t ehci_hc_schedule(usb_transfer_batch_t *);
    112112
    113113#endif

  • uspace/drv/bus/usb/ehci/hw_struct/transfer_descriptor.c

    r132ab5d1 r5a6cc679  
    4444
    4545
    46 int td_error(const td_t *td)
     46errno_t td_error(const td_t *td)
    4747{
    4848        assert(td);

  • uspace/drv/bus/usb/ehci/hw_struct/transfer_descriptor.h

    r132ab5d1 r5a6cc679  
    9797}
    9898
    99 int td_error(const td_t *td);
     99errno_t td_error(const td_t *td);
    100100
    101101void td_init(td_t *td, uintptr_t next_phys, uintptr_t buf, usb_direction_t dir,

  • uspace/drv/bus/usb/ehci/res.c

    r132ab5d1 r5a6cc679  
    6363 * @return Error code.
    6464 */
    65 static int disable_extended_caps(async_sess_t *parent_sess, unsigned eecp)
     65static errno_t disable_extended_caps(async_sess_t *parent_sess, unsigned eecp)
    6666{
    6767        /* nothing to do */
    … …  
    7171        /* Read the first EEC. i.e. Legacy Support register */
    7272        uint32_t usblegsup;
    73         int ret = pci_config_space_read_32(parent_sess,
     73        errno_t ret = pci_config_space_read_32(parent_sess,
    7474            eecp + USBLEGSUP_OFFSET, &usblegsup);
    7575        if (ret != EOK) {
    … …  
    173173}
    174174
    175 int disable_legacy(hc_device_t *hcd)
     175errno_t disable_legacy(hc_device_t *hcd)
    176176{
    177177        hc_t *hc = hcd_to_hc(hcd);
    … …  
    182182
    183183        usb_log_debug("Disabling EHCI legacy support.");
    184 
    185184
    186185        const uint32_t hcc_params = EHCI_RD(hc->caps->hccparams);

  • uspace/drv/bus/usb/ehci/res.h

    r132ab5d1 r5a6cc679  
    3838typedef struct hc_device hc_device_t;
    3939
    40 extern int disable_legacy(hc_device_t *);
     40extern errno_t disable_legacy(hc_device_t *);
    4141
    4242#endif

  • uspace/drv/bus/usb/ohci/endpoint_list.c

    r132ab5d1 r5a6cc679  
    5151 * Allocates memory for internal ed_t structure.
    5252 */
    53 int endpoint_list_init(endpoint_list_t *instance, const char *name)
     53errno_t endpoint_list_init(endpoint_list_t *instance, const char *name)
    5454{
    5555        assert(instance);

  • uspace/drv/bus/usb/ohci/endpoint_list.h

    r132ab5d1 r5a6cc679  
    7171}
    7272
    73 int endpoint_list_init(endpoint_list_t *instance, const char *name);
     73errno_t endpoint_list_init(endpoint_list_t *instance, const char *name);
    7474void endpoint_list_set_next(
    7575    const endpoint_list_t *instance, const endpoint_list_t *next);

  • uspace/drv/bus/usb/ohci/hc.c

    r132ab5d1 r5a6cc679  
    9090};
    9191
    92 static int hc_init_transfer_lists(hc_t *instance);
    93 static int hc_init_memory(hc_t *instance);
     92static errno_t hc_init_transfer_lists(hc_t *instance);
     93static errno_t hc_init_memory(hc_t *instance);
    9494
    9595/** Generate IRQ code.
    … …  
    102102 * @return Error code.
    103103 */
    104 int hc_gen_irq_code(irq_code_t *code, hc_device_t *hcd, const hw_res_list_parsed_t *hw_res, int *irq)
     104errno_t hc_gen_irq_code(irq_code_t *code, hc_device_t *hcd, const hw_res_list_parsed_t *hw_res, int *irq)
    105105{
    106106        assert(code);
    … …  
    151151 * @return Error code
    152152 */
    153 int hc_add(hc_device_t *hcd, const hw_res_list_parsed_t *hw_res)
     153errno_t hc_add(hc_device_t *hcd, const hw_res_list_parsed_t *hw_res)
    154154{
    155155        hc_t *instance = hcd_to_hc(hcd);
    … …  
    159159            return EINVAL;
    160160
    161         int ret = pio_enable_range(&hw_res->mem_ranges.ranges[0],
     161        errno_t ret = pio_enable_range(&hw_res->mem_ranges.ranges[0],
    162162            (void **) &instance->registers);
    163163        if (ret != EOK) {
    … …  
    263263}
    264264
    265 int ohci_hc_status(bus_t *bus_base, uint32_t *status)
     265errno_t ohci_hc_status(bus_t *bus_base, uint32_t *status)
    266266{
    267267        assert(bus_base);
    … …  
    285285 * @return Error code.
    286286 */
    287 int ohci_hc_schedule(usb_transfer_batch_t *batch)
     287errno_t ohci_hc_schedule(usb_transfer_batch_t *batch)
    288288{
    289289        assert(batch);
    … …  
    547547 * @return Error code
    548548 */
    549 int hc_init_transfer_lists(hc_t *instance)
     549errno_t hc_init_transfer_lists(hc_t *instance)
    550550{
    551551        assert(instance);
    … …  
    553553do { \
    554554        const char *name = usb_str_transfer_type(type); \
    555         const int ret = endpoint_list_init(&instance->lists[type], name); \
     555        const errno_t ret = endpoint_list_init(&instance->lists[type], name); \
    556556        if (ret != EOK) { \
    557557                usb_log_error("Failed to setup %s endpoint list: %s.", \
    … …  
    581581 * @return Error code.
    582582 */
    583 int hc_init_memory(hc_t *instance)
     583errno_t hc_init_memory(hc_t *instance)
    584584{
    585585        assert(instance);
    … …  
    587587        memset(&instance->rh, 0, sizeof(instance->rh));
    588588        /* Init queues */
    589         int ret = hc_init_transfer_lists(instance);
     589        errno_t ret = hc_init_transfer_lists(instance);
    590590        if (ret != EOK) {
    591591                return ret;

  • uspace/drv/bus/usb/ohci/hc.h

    r132ab5d1 r5a6cc679  
    8989}
    9090
    91 extern int hc_add(hc_device_t *, const hw_res_list_parsed_t *);
    92 extern int hc_gen_irq_code(irq_code_t *, hc_device_t *, const hw_res_list_parsed_t *, int *);
    93 extern int hc_gain_control(hc_device_t *);
    94 extern int hc_start(hc_device_t *);
    95 extern int hc_setup_roothub(hc_device_t *);
    96 extern int hc_gone(hc_device_t *);
     91extern errno_t hc_add(hc_device_t *, const hw_res_list_parsed_t *);
     92extern errno_t hc_gen_irq_code(irq_code_t *, hc_device_t *, const hw_res_list_parsed_t *, int *);
     93extern errno_t hc_gain_control(hc_device_t *);
     94extern errno_t hc_start(hc_device_t *);
     95extern errno_t hc_setup_roothub(hc_device_t *);
     96extern errno_t hc_gone(hc_device_t *);
    9797
    9898extern void hc_enqueue_endpoint(hc_t *, const endpoint_t *);
    9999extern void hc_dequeue_endpoint(hc_t *, const endpoint_t *);
    100100
    101 extern int ohci_hc_schedule(usb_transfer_batch_t *);
    102 extern int ohci_hc_status(bus_t *, uint32_t *);
     101extern errno_t ohci_hc_schedule(usb_transfer_batch_t *);
     102extern errno_t ohci_hc_status(bus_t *, uint32_t *);
    103103extern void ohci_hc_interrupt(bus_t *, uint32_t);
    104104

  • uspace/drv/bus/usb/ohci/hw_struct/completion_codes.h

    r132ab5d1 r5a6cc679  
    5454};
    5555
    56 inline static int cc_to_rc(unsigned int cc)
     56inline static errno_t cc_to_rc(unsigned int cc)
    5757{
    5858        switch (cc) {

  • uspace/drv/bus/usb/ohci/hw_struct/transfer_descriptor.h

    r132ab5d1 r5a6cc679  
    119119 * @return Error code.
    120120 */
    121 static inline int td_error(const td_t *instance)
     121static inline errno_t td_error(const td_t *instance)
    122122{
    123123        assert(instance);

  • uspace/drv/bus/usb/ohci/ohci_bus.h

    r132ab5d1 r5a6cc679  
    6565} ohci_bus_t;
    6666
    67 int ohci_bus_init(ohci_bus_t *, hc_t *);
     67errno_t ohci_bus_init(ohci_bus_t *, hc_t *);
    6868void ohci_ep_toggle_reset(endpoint_t *);
    6969

  • uspace/drv/bus/usb/ohci/ohci_rh.c

    r132ab5d1 r5a6cc679  
    109109 * initializes internal virtual hub.
    110110 */
    111 int ohci_rh_init(ohci_rh_t *instance, ohci_regs_t *regs,
     111errno_t ohci_rh_init(ohci_rh_t *instance, ohci_regs_t *regs,
    112112    fibril_mutex_t *guard, const char *name)
    113113{
    … …  
    176176 * status change requests might be postponed until there is something to report.
    177177 */
    178 int ohci_rh_schedule(ohci_rh_t *instance, usb_transfer_batch_t *batch)
     178errno_t ohci_rh_schedule(ohci_rh_t *instance, usb_transfer_batch_t *batch)
    179179{
    180180        assert(instance);
    … …  
    214214 * processing of a postponed request.
    215215 */
    216 int ohci_rh_interrupt(ohci_rh_t *instance)
     216errno_t ohci_rh_interrupt(ohci_rh_t *instance)
    217217{
    218218        fibril_mutex_lock(instance->guard);
    … …  
    259259 * @return Error code.
    260260 */
    261 static int req_get_status(usbvirt_device_t *device,
     261static errno_t req_get_status(usbvirt_device_t *device,
    262262    const usb_device_request_setup_packet_t *setup_packet,
    263263    uint8_t *data, size_t *act_size)
    … …  
    282282 * @return Error code.
    283283 */
    284 static int req_clear_hub_feature(usbvirt_device_t *device,
     284static errno_t req_clear_hub_feature(usbvirt_device_t *device,
    285285    const usb_device_request_setup_packet_t *setup_packet,
    286286    uint8_t *data, size_t *act_size)
    … …  
    312312 * @return Error code.
    313313 */
    314 static int req_get_port_status(usbvirt_device_t *device,
     314static errno_t req_get_port_status(usbvirt_device_t *device,
    315315    const usb_device_request_setup_packet_t *setup_packet,
    316316    uint8_t *data, size_t *act_size)
    … …  
    336336 * @return Error code.
    337337 */
    338 static int req_clear_port_feature(usbvirt_device_t *device,
     338static errno_t req_clear_port_feature(usbvirt_device_t *device,
    339339    const usb_device_request_setup_packet_t *setup_packet,
    340340    uint8_t *data, size_t *act_size)
    … …  
    400400 * @return Error code.
    401401 */
    402 static int req_set_port_feature(usbvirt_device_t *device,
     402static errno_t req_set_port_feature(usbvirt_device_t *device,
    403403    const usb_device_request_setup_packet_t *setup_packet,
    404404    uint8_t *data, size_t *act_size)
    … …  
    451451 * only need 1 byte.
    452452 */
    453 static int req_status_change_handler(usbvirt_device_t *device,
     453static errno_t req_status_change_handler(usbvirt_device_t *device,
    454454    usb_endpoint_t endpoint, usb_transfer_type_t tr_type,
    455455    void *buffer, size_t buffer_size, size_t *actual_size)

  • uspace/drv/bus/usb/ohci/ohci_rh.h

    r132ab5d1 r5a6cc679  
    6666} ohci_rh_t;
    6767
    68 int ohci_rh_init(ohci_rh_t *, ohci_regs_t *, fibril_mutex_t *, const char *);
    69 int ohci_rh_schedule(ohci_rh_t *instance, usb_transfer_batch_t *batch);
    70 int ohci_rh_interrupt(ohci_rh_t *instance);
     68errno_t ohci_rh_init(ohci_rh_t *, ohci_regs_t *, fibril_mutex_t *, const char *);
     69errno_t ohci_rh_schedule(ohci_rh_t *instance, usb_transfer_batch_t *batch);
     70errno_t ohci_rh_interrupt(ohci_rh_t *instance);
    7171
    7272/** Get OHCI rh address.

  • uspace/drv/bus/usb/uhci/hc.c

    r132ab5d1 r5a6cc679  
    9797
    9898static void hc_init_hw(const hc_t *instance);
    99 static int hc_init_mem_structures(hc_t *instance);
    100 static int hc_init_transfer_lists(hc_t *instance);
    101 
    102 static int hc_debug_checker(void *arg);
     99static errno_t hc_init_mem_structures(hc_t *instance);
     100static errno_t hc_init_transfer_lists(hc_t *instance);
     101
     102static errno_t hc_debug_checker(void *arg);
    103103
    104104
    … …  
    110110 * @return Error code.
    111111 */
    112 int hc_gen_irq_code(irq_code_t *code, hc_device_t *hcd, const hw_res_list_parsed_t *hw_res, int *irq)
     112errno_t hc_gen_irq_code(irq_code_t *code, hc_device_t *hcd, const hw_res_list_parsed_t *hw_res, int *irq)
    113113{
    114114        assert(code);
    … …  
    207207 * interrupt fibrils.
    208208 */
    209 int hc_add(hc_device_t *hcd, const hw_res_list_parsed_t *hw_res)
     209errno_t hc_add(hc_device_t *hcd, const hw_res_list_parsed_t *hw_res)
    210210{
    211211        hc_t *instance = hcd_to_hc(hcd);
    … …  
    218218
    219219        /* allow access to hc control registers */
    220         int ret = pio_enable_range(&hw_res->io_ranges.ranges[0],
     220        errno_t ret = pio_enable_range(&hw_res->io_ranges.ranges[0],
    221221            (void **) &instance->registers);
    222222        if (ret != EOK) {
    … …  
    327327}
    328328
    329 static int endpoint_register(endpoint_t *ep)
     329static errno_t endpoint_register(endpoint_t *ep)
    330330{
    331331        hc_t * const hc = bus_to_hc(endpoint_get_bus(ep));
    332332
    333         const int err = usb2_bus_endpoint_register(&hc->bus_helper, ep);
     333        const errno_t err = usb2_bus_endpoint_register(&hc->bus_helper, ep);
    334334        if (err)
    335335                return err;
    … …  
    449449 *  - frame list page (needs to be one UHCI hw accessible 4K page)
    450450 */
    451 int hc_init_mem_structures(hc_t *instance)
     451errno_t hc_init_mem_structures(hc_t *instance)
    452452{
    453453        assert(instance);
    … …  
    468468
    469469        /* Init transfer lists */
    470         int ret = hc_init_transfer_lists(instance);
     470        errno_t ret = hc_init_transfer_lists(instance);
    471471        if (ret != EOK) {
    472472                usb_log_error("Failed to initialize transfer lists.");
    … …  
    498498 * USB scheduling. Sets pointer table for quick access.
    499499 */
    500 int hc_init_transfer_lists(hc_t *instance)
     500errno_t hc_init_transfer_lists(hc_t *instance)
    501501{
    502502        assert(instance);
    503503#define SETUP_TRANSFER_LIST(type, name) \
    504504do { \
    505         int ret = transfer_list_init(&instance->transfers_##type, name); \
     505        errno_t ret = transfer_list_init(&instance->transfers_##type, name); \
    506506        if (ret != EOK) { \
    507507                usb_log_error("Failed to setup %s transfer list: %s.", \
    … …  
    550550}
    551551
    552 static int hc_status(bus_t *bus, uint32_t *status)
     552static errno_t hc_status(bus_t *bus, uint32_t *status)
    553553{
    554554        hc_t *instance = bus_to_hc(bus);
    … …  
    571571 * @return Error code
    572572 */
    573 static int hc_schedule(usb_transfer_batch_t *batch)
     573static errno_t hc_schedule(usb_transfer_batch_t *batch)
    574574{
    575575        uhci_transfer_batch_t *uhci_batch = uhci_transfer_batch_get(batch);
    … …  
    586586                return ENOTSUP;
    587587
    588         int err;
     588        errno_t err;
    589589        if ((err = uhci_transfer_batch_prepare(uhci_batch)))
    590590                return err;
    … …  
    598598 * @return EOK (should never return)
    599599 */
    600 int hc_debug_checker(void *arg)
     600errno_t hc_debug_checker(void *arg)
    601601{
    602602        hc_t *instance = arg;

  • uspace/drv/bus/usb/uhci/hc.h

    r132ab5d1 r5a6cc679  
    157157int hc_unschedule_batch(usb_transfer_batch_t *);
    158158
    159 extern int hc_add(hc_device_t *, const hw_res_list_parsed_t *);
    160 extern int hc_gen_irq_code(irq_code_t *, hc_device_t *, const hw_res_list_parsed_t *, int *);
    161 extern int hc_start(hc_device_t *);
    162 extern int hc_setup_roothub(hc_device_t *);
    163 extern int hc_gone(hc_device_t *);
     159extern errno_t hc_add(hc_device_t *, const hw_res_list_parsed_t *);
     160extern errno_t hc_gen_irq_code(irq_code_t *, hc_device_t *, const hw_res_list_parsed_t *, int *);
     161extern errno_t hc_start(hc_device_t *);
     162extern errno_t hc_setup_roothub(hc_device_t *);
     163extern errno_t hc_gone(hc_device_t *);
    164164
    165165#endif

  • uspace/drv/bus/usb/uhci/hw_struct/transfer_descriptor.c

    r132ab5d1 r5a6cc679  
    119119 * @return Error code.
    120120 */
    121 int td_status(const td_t *instance)
     121errno_t td_status(const td_t *instance)
    122122{
    123123        assert(instance);

  • uspace/drv/bus/usb/uhci/hw_struct/transfer_descriptor.h

    r132ab5d1 r5a6cc679  
    102102    const void *buffer, const td_t *next);
    103103
    104 int td_status(const td_t *instance);
     104errno_t td_status(const td_t *instance);
    105105
    106106void td_print_status(const td_t *instance);

  • uspace/drv/bus/usb/uhci/main.c

    r132ab5d1 r5a6cc679  
    4949#define NAME "uhci"
    5050
    51 static int disable_legacy(hc_device_t *);
     51static errno_t disable_legacy(hc_device_t *);
    5252
    5353static const hc_driver_t uhci_driver = {
    … …  
    6767 * @return Error code.
    6868 */
    69 static int disable_legacy(hc_device_t *hcd)
     69static errno_t disable_legacy(hc_device_t *hcd)
    7070{
    7171        assert(hcd);

  • uspace/drv/bus/usb/uhci/transfer_list.c

    r132ab5d1 r5a6cc679  
    5555 * Allocates memory for internal qh_t structure.
    5656 */
    57 int transfer_list_init(transfer_list_t *instance, const char *name)
     57errno_t transfer_list_init(transfer_list_t *instance, const char *name)
    5858{
    5959        assert(instance);

  • uspace/drv/bus/usb/uhci/transfer_list.h

    r132ab5d1 r5a6cc679  
    5757
    5858void transfer_list_fini(transfer_list_t *);
    59 int transfer_list_init(transfer_list_t *, const char *);
     59errno_t transfer_list_init(transfer_list_t *, const char *);
    6060void transfer_list_set_next(transfer_list_t *, transfer_list_t *);
    61 int transfer_list_add_batch(transfer_list_t *, uhci_transfer_batch_t *);
     61errno_t transfer_list_add_batch(transfer_list_t *, uhci_transfer_batch_t *);
    6262void transfer_list_remove_batch(transfer_list_t *, uhci_transfer_batch_t *);
    6363void transfer_list_check_finished(transfer_list_t *);

  • uspace/drv/bus/usb/uhci/uhci_rh.c

    r132ab5d1 r5a6cc679  
    7979 * @return Error code, EOK on success.
    8080 */
    81 int uhci_rh_init(uhci_rh_t *instance, ioport16_t *ports, const char *name)
     81errno_t uhci_rh_init(uhci_rh_t *instance, ioport16_t *ports, const char *name)
    8282{
    8383        assert(instance);
    … …  
    9999 * not have to be.
    100100 */
    101 int uhci_rh_schedule(uhci_rh_t *instance, usb_transfer_batch_t *batch)
     101errno_t uhci_rh_schedule(uhci_rh_t *instance, usb_transfer_batch_t *batch)
    102102{
    103103        assert(instance);
    … …  
    189189 * it is usefull for debuging purposes only.
    190190 */
    191 static int req_get_port_state(usbvirt_device_t *device,
     191static errno_t req_get_port_state(usbvirt_device_t *device,
    192192    const usb_device_request_setup_packet_t *setup_packet,
    193193    uint8_t *data, size_t *act_size)
    … …  
    224224 * @note: reset change status needs to be handled in sw.
    225225 */
    226 static int req_get_port_status(usbvirt_device_t *device,
     226static errno_t req_get_port_status(usbvirt_device_t *device,
    227227    const usb_device_request_setup_packet_t *setup_packet,
    228228    uint8_t *data, size_t *act_size)
    … …  
    263263 * @return Error code.
    264264 */
    265 static int req_clear_port_feature(usbvirt_device_t *device,
     265static errno_t req_clear_port_feature(usbvirt_device_t *device,
    266266    const usb_device_request_setup_packet_t *setup_packet,
    267267    uint8_t *data, size_t *act_size)
    … …  
    336336 * @return Error code.
    337337 */
    338 static int req_set_port_feature(usbvirt_device_t *device,
     338static errno_t req_set_port_feature(usbvirt_device_t *device,
    339339    const usb_device_request_setup_packet_t *setup_packet,
    340340    uint8_t *data, size_t *act_size)
    … …  
    398398 * only need 1 byte.
    399399 */
    400 static int req_status_change_handler(usbvirt_device_t *device,
     400static errno_t req_status_change_handler(usbvirt_device_t *device,
    401401    usb_endpoint_t endpoint, usb_transfer_type_t tr_type,
    402402    void *buffer, size_t buffer_size, size_t *actual_size)

  • uspace/drv/bus/usb/uhci/uhci_rh.h

    r132ab5d1 r5a6cc679  
    5656} uhci_rh_t;
    5757
    58 int uhci_rh_init(uhci_rh_t *instance, ioport16_t *ports, const char *name);
    59 int uhci_rh_schedule(uhci_rh_t *instance, usb_transfer_batch_t *batch);
     58errno_t uhci_rh_init(uhci_rh_t *instance, ioport16_t *ports, const char *name);
     59errno_t uhci_rh_schedule(uhci_rh_t *instance, usb_transfer_batch_t *batch);
    6060
    6161/** Get UHCI rh address.

  • uspace/drv/bus/usb/usbflbk/main.c

    r132ab5d1 r5a6cc679  
    4646 * @return Error code.
    4747 */
    48 static int usbfallback_device_add(usb_device_t *dev)
     48static errno_t usbfallback_device_add(usb_device_t *dev)
    4949{
    5050        usb_log_info("Pretending to control %s `%s'.",
    … …  
    5959 * @return Error code.
    6060 */
    61 static int usbfallback_device_gone(usb_device_t *dev)
     61static errno_t usbfallback_device_gone(usb_device_t *dev)
    6262{
    6363        assert(dev);

  • uspace/drv/bus/usb/usbhub/port.c

    r132ab5d1 r5a6cc679  
    101101 * Routine for adding a new device in USB2.
    102102 */
    103 static int enumerate_device_usb2(usb_hub_port_t *port, async_exch_t *exch)
    104 {
    105         int err;
     103static errno_t enumerate_device_usb2(usb_hub_port_t *port, async_exch_t *exch)
     104{
     105        errno_t err;
    106106
    107107        port_log(debug, port, "Requesting default address.");
    … …  
    145145 * Routine for adding a new device in USB 3.
    146146 */
    147 static int enumerate_device_usb3(usb_hub_port_t *port, async_exch_t *exch)
    148 {
    149         int err;
     147static errno_t enumerate_device_usb3(usb_hub_port_t *port, async_exch_t *exch)
     148{
     149        errno_t err;
    150150
    151151        port_log(debug, port, "Issuing a warm reset.");
    … …  
    170170}
    171171
    172 static int enumerate_device(usb_port_t *port_base)
     172static errno_t enumerate_device(usb_port_t *port_base)
    173173{
    174174        usb_hub_port_t *port = get_hub_port(port_base);
    … …  
    181181        }
    182182
    183         const int err = port->hub->speed == USB_SPEED_SUPER
     183        const errno_t err = port->hub->speed == USB_SPEED_SUPER
    184184                ? enumerate_device_usb3(port, exch)
    185185                : enumerate_device_usb2(port, exch);

  • uspace/drv/bus/usb/usbhub/usbhub.c

    r132ab5d1 r5a6cc679  
    9999};
    100100
    101 static int usb_set_first_configuration(usb_device_t *);
    102 static int usb_hub_process_hub_specific_info(usb_hub_dev_t *);
     101static errno_t usb_set_first_configuration(usb_device_t *);
     102static errno_t usb_hub_process_hub_specific_info(usb_hub_dev_t *);
    103103static void usb_hub_over_current(const usb_hub_dev_t *, usb_hub_status_t);
    104 static int usb_hub_polling_init(usb_hub_dev_t *, usb_endpoint_mapping_t *);
     104static errno_t usb_hub_polling_init(usb_hub_dev_t *, usb_endpoint_mapping_t *);
    105105static void usb_hub_global_interrupt(const usb_hub_dev_t *);
    106106
    107107static bool usb_hub_polling_error_callback(usb_device_t *dev,
    108         int err_code, void *arg)
     108        errno_t err_code, void *arg)
    109109{
    110110        assert(dev);
    … …  
    125125 * @return error code
    126126 */
    127 int usb_hub_device_add(usb_device_t *usb_dev)
     127errno_t usb_hub_device_add(usb_device_t *usb_dev)
    128128{
    129129        int err;
    … …  
    198198}
    199199
    200 static int usb_hub_cleanup(usb_hub_dev_t *hub)
     200static errno_t usb_hub_cleanup(usb_hub_dev_t *hub)
    201201{
    202202        free(hub->polling.buffer);
    … …  
    228228 * @return error code
    229229 */
    230 int usb_hub_device_remove(usb_device_t *usb_dev)
     230errno_t usb_hub_device_remove(usb_device_t *usb_dev)
    231231{
    232232        assert(usb_dev);
    … …  
    249249 * @return error code
    250250 */
    251 int usb_hub_device_gone(usb_device_t *usb_dev)
     251errno_t usb_hub_device_gone(usb_device_t *usb_dev)
    252252{
    253253        assert(usb_dev);
    … …  
    270270 * @param mapping The mapping of Status Change Endpoint
    271271 */
    272 static int usb_hub_polling_init(usb_hub_dev_t *hub_dev,
     272static errno_t usb_hub_polling_init(usb_hub_dev_t *hub_dev,
    273273        usb_endpoint_mapping_t *mapping)
    274274{
    275         int err;
     275        errno_t err;
    276276        usb_polling_t *polling = &hub_dev->polling;
    277277
    … …  
    369369 * @return error code
    370370 */
    371 static int usb_hub_process_hub_specific_info(usb_hub_dev_t *hub_dev)
     371static errno_t usb_hub_process_hub_specific_info(usb_hub_dev_t *hub_dev)
    372372{
    373373        assert(hub_dev);
    … …  
    382382        usb_hub_descriptor_header_t descriptor;
    383383        size_t received_size;
    384         int opResult = usb_request_get_descriptor(control_pipe,
     384        errno_t opResult = usb_request_get_descriptor(control_pipe,
    385385            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_DEVICE,
    386386            desc_type, 0, 0, &descriptor,
    … …  
    436436 * @return error code
    437437 */
    438 static int usb_set_first_configuration(usb_device_t *usb_device)
     438static errno_t usb_set_first_configuration(usb_device_t *usb_device)
    439439{
    440440        assert(usb_device);
    … …  
    462462        /* Set configuration. Use the configuration that was in
    463463         * usb_device->descriptors.configuration i.e. The first one. */
    464         int opResult = usb_request_set_configuration(
     464        errno_t opResult = usb_request_set_configuration(
    465465            usb_device_get_default_pipe(usb_device),
    466466            config_descriptor->configuration_number);
    … …  
    500500        /* Over-current condition is gone, it is safe to turn the ports on. */
    501501        for (size_t port = 0; port < hub_dev->port_count; ++port) {
    502                 const int ret = usb_hub_set_port_feature(hub_dev, port,
     502                const errno_t ret = usb_hub_set_port_feature(hub_dev, port,
    503503                    USB_HUB_FEATURE_PORT_POWER);
    504504                if (ret != EOK) {
    … …  
    637637        /* NOTE: We can't use standard USB GET_STATUS request, because
    638638         * hubs reply is 4byte instead of 2 */
    639         const int opResult = usb_pipe_control_read(control_pipe,
     639        const errno_t opResult = usb_pipe_control_read(control_pipe,
    640640            &get_hub_status_request, sizeof(get_hub_status_request),
    641641            &status, sizeof(usb_hub_status_t), &rcvd_size);
    … …  
    655655                usb_hub_over_current(hub_dev, status);
    656656                /* Ack change in hub OC flag */
    657                 const int ret = usb_request_clear_feature(
     657                const errno_t ret = usb_request_clear_feature(
    658658                    control_pipe, USB_REQUEST_TYPE_CLASS,
    659659                    USB_REQUEST_RECIPIENT_DEVICE,
    … …  
    679679                 * Just ACK the change.
    680680                 */
    681                 const int ret = usb_request_clear_feature(
     681                const errno_t ret = usb_request_clear_feature(
    682682                    control_pipe, USB_REQUEST_TYPE_CLASS,
    683683                    USB_REQUEST_RECIPIENT_DEVICE,

  • uspace/drv/bus/usb/usbhub/usbhub.h

    r132ab5d1 r5a6cc679  
    7878extern const usb_endpoint_description_t *usb_hub_endpoints [];
    7979
    80 int usb_hub_device_add(usb_device_t *);
    81 int usb_hub_device_remove(usb_device_t *);
    82 int usb_hub_device_gone(usb_device_t *);
     80errno_t usb_hub_device_add(usb_device_t *);
     81errno_t usb_hub_device_remove(usb_device_t *);
     82errno_t usb_hub_device_gone(usb_device_t *);
    8383
    84 int usb_hub_set_depth(const usb_hub_dev_t *);
    85 int usb_hub_get_port_status(const usb_hub_dev_t *, size_t, usb_port_status_t *);
    86 int usb_hub_set_port_feature(const usb_hub_dev_t *, size_t, usb_hub_class_feature_t);
    87 int usb_hub_clear_port_feature(const usb_hub_dev_t *, size_t, usb_hub_class_feature_t);
     84errno_t usb_hub_set_depth(const usb_hub_dev_t *);
     85errno_t usb_hub_get_port_status(const usb_hub_dev_t *, size_t, usb_port_status_t *);
     86errno_t usb_hub_set_port_feature(const usb_hub_dev_t *, size_t, usb_hub_class_feature_t);
     87errno_t usb_hub_clear_port_feature(const usb_hub_dev_t *, size_t, usb_hub_class_feature_t);
    8888
    8989bool hub_port_changes_callback(usb_device_t *, uint8_t *, size_t, void *);
    9090
    91 int usb_hub_reserve_default_address(usb_hub_dev_t *, async_exch_t *, usb_port_t *);
    92 int usb_hub_release_default_address(usb_hub_dev_t *, async_exch_t *);
     91errno_t usb_hub_reserve_default_address(usb_hub_dev_t *, async_exch_t *, usb_port_t *);
     92errno_t usb_hub_release_default_address(usb_hub_dev_t *, async_exch_t *);
    9393
    9494#endif

  • uspace/drv/bus/usb/usbmid/explore.c

    r132ab5d1 r5a6cc679  
    6666 * @param list List where to add the interfaces.
    6767 */
    68 static int create_interfaces(const uint8_t *config_descriptor,
     68static errno_t create_interfaces(const uint8_t *config_descriptor,
    6969    size_t config_descriptor_size, list_t *list, usb_device_t *usb_dev)
    7070{
    … …  
    111111
    112112                usbmid_interface_t *iface = NULL;
    113                 const int rc = usbmid_spawn_interface_child(usb_dev, &iface,
     113                const errno_t rc = usbmid_spawn_interface_child(usb_dev, &iface,
    114114                        &usb_device_descriptors(usb_dev)->device, interface);
    115115                if (rc != EOK) {
    … …  
    134134 * @return Whether to accept this device.
    135135 */
    136 int usbmid_explore_device(usb_device_t *dev)
     136errno_t usbmid_explore_device(usb_device_t *dev)
    137137{
    138138        assert(dev);
    … …  
    157157
    158158        /* Select the first configuration */
    159         int rc = usb_request_set_configuration(usb_device_get_default_pipe(dev),
     159        errno_t rc = usb_request_set_configuration(usb_device_get_default_pipe(dev),
    160160            config_descriptor->configuration_number);
    161161        if (rc != EOK) {

  • uspace/drv/bus/usb/usbmid/main.c

    r132ab5d1 r5a6cc679  
    4949 * @return Error code.
    5050 */
    51 static int usbmid_device_add(usb_device_t *dev)
     51static errno_t usbmid_device_add(usb_device_t *dev)
    5252{
    5353        usb_log_info("Taking care of new MID `%s'.", usb_device_get_name(dev));
    … …  
    8282 * @return Error code.
    8383 */
    84 static int usbmid_device_remove(usb_device_t *dev)
     84static errno_t usbmid_device_remove(usb_device_t *dev)
    8585{
    8686        assert(dev);
    … …  
    8989
    9090        /* Remove ctl function */
    91         int ret = ddf_fun_unbind(usb_mid->ctl_fun);
     91        errno_t ret = ddf_fun_unbind(usb_mid->ctl_fun);
    9292        if (ret != EOK) {
    9393                usb_log_error("Failed to unbind USB MID ctl function: %s.",
    … …  
    103103
    104104                /* Tell the child to go offline. */
    105                 int pret = ddf_fun_offline(iface->fun);
     105                errno_t pret = ddf_fun_offline(iface->fun);
    106106                if (pret != EOK) {
    107107                        usb_log_warning("Failed to turn off child `%s': %s",
    … …  
    118118 * @return Error code.
    119119 */
    120 static int usbmid_device_gone(usb_device_t *dev)
     120static errno_t usbmid_device_gone(usb_device_t *dev)
    121121{
    122122        assert(dev);
    … …  
    127127
    128128        /* Remove ctl function */
    129         int ret = ddf_fun_unbind(usb_mid->ctl_fun);
     129        errno_t ret = ddf_fun_unbind(usb_mid->ctl_fun);
    130130        if (ret != EOK) {
    131131                usb_log_error("Failed to unbind USB MID ctl function: %s.",
    … …  
    149149}
    150150
    151 static int usbmid_function_offline(ddf_fun_t *fun)
     151static errno_t usbmid_function_offline(ddf_fun_t *fun)
    152152{
    153153        usb_device_t *usb_dev = ddf_dev_data_get(ddf_fun_get_dev(fun));

  • uspace/drv/bus/usb/usbmid/usbmid.c

    r132ab5d1 r5a6cc679  
    5252 * @return Error code.
    5353 */
    54 static int usb_iface_description(ddf_fun_t *fun, usb_device_desc_t *desc)
     54static errno_t usb_iface_description(ddf_fun_t *fun, usb_device_desc_t *desc)
    5555{
    5656        usbmid_interface_t *iface = ddf_fun_data_get(fun);
    … …  
    6464
    6565        usb_device_desc_t tmp_desc;
    66         const int ret = usb_get_my_description(exch, &tmp_desc);
     66        const errno_t ret = usb_get_my_description(exch, &tmp_desc);
    6767
    6868        if (ret == EOK && desc) {
    … …  
    8686};
    8787
    88 int usbmid_interface_destroy(usbmid_interface_t *mid_iface)
     88errno_t usbmid_interface_destroy(usbmid_interface_t *mid_iface)
    8989{
    9090        assert(mid_iface);
    9191        assert_link_not_used(&mid_iface->link);
    92         const int ret = ddf_fun_unbind(mid_iface->fun);
     92        const errno_t ret = ddf_fun_unbind(mid_iface->fun);
    9393        if (ret != EOK) {
    9494                return ret;
    … …  
    106106 * @return Error code.
    107107 */
    108 int usbmid_spawn_interface_child(usb_device_t *parent,
     108errno_t usbmid_spawn_interface_child(usb_device_t *parent,
    109109    usbmid_interface_t **iface_ret,
    110110    const usb_standard_device_descriptor_t *device_descriptor,
    … …  
    113113        ddf_fun_t *child = NULL;
    114114        char *child_name = NULL;
    115         int rc;
     115        errno_t rc;
    116116
    117117        /*

  • uspace/drv/bus/usb/usbmid/usbmid.h

    r132ab5d1 r5a6cc679  
    6262} usb_mid_t;
    6363
    64 extern int usbmid_explore_device(usb_device_t *);
    65 extern int usbmid_spawn_interface_child(usb_device_t *, usbmid_interface_t **,
     64extern errno_t usbmid_explore_device(usb_device_t *);
     65extern errno_t usbmid_spawn_interface_child(usb_device_t *, usbmid_interface_t **,
    6666    const usb_standard_device_descriptor_t *,
    6767    const usb_standard_interface_descriptor_t *);
    6868extern void usbmid_dump_descriptors(uint8_t *, size_t);
    69 extern int usbmid_interface_destroy(usbmid_interface_t *mid_iface);
     69extern errno_t usbmid_interface_destroy(usbmid_interface_t *mid_iface);
    7070
    7171static inline usbmid_interface_t * usbmid_interface_from_link(link_t *item)

  • uspace/drv/bus/usb/vhc/conndev.c

    r132ab5d1 r5a6cc679  
    7575        }
    7676       
    77         int data_request_rc;
    78         int opening_request_rc;
     77        errno_t data_request_rc;
     78        errno_t opening_request_rc;
    7979        async_wait_for(data_request, &data_request_rc);
    8080        async_wait_for(opening_request, &opening_request_rc);
    … …  
    102102       
    103103        if (callback) {
    104                 int rc = vhc_virtdev_plug(vhc, callback, &plugged_device_handle);
     104                errno_t rc = vhc_virtdev_plug(vhc, callback, &plugged_device_handle);
    105105                if (rc != EOK) {
    106106                        async_answer_0(icallid, rc);

  • uspace/drv/bus/usb/vhc/devconn.c

    r132ab5d1 r5a6cc679  
    4949}
    5050
    51 static int vhc_virtdev_plug_generic(vhc_data_t *vhc,
     51static errno_t vhc_virtdev_plug_generic(vhc_data_t *vhc,
    5252    async_sess_t *sess, usbvirt_device_t *virtdev,
    5353    uintptr_t *handle, bool connect, usb_address_t address)
    … …  
    8585}
    8686
    87 int vhc_virtdev_plug(vhc_data_t *vhc, async_sess_t *sess, uintptr_t *handle)
     87errno_t vhc_virtdev_plug(vhc_data_t *vhc, async_sess_t *sess, uintptr_t *handle)
    8888{
    8989        return vhc_virtdev_plug_generic(vhc, sess, NULL, handle, true, 0);
    9090}
    9191
    92 int vhc_virtdev_plug_local(vhc_data_t *vhc, usbvirt_device_t *dev, uintptr_t *handle)
     92errno_t vhc_virtdev_plug_local(vhc_data_t *vhc, usbvirt_device_t *dev, uintptr_t *handle)
    9393{
    9494        return vhc_virtdev_plug_generic(vhc, NULL, dev, handle, true, 0);
    9595}
    9696
    97 int vhc_virtdev_plug_hub(vhc_data_t *vhc, usbvirt_device_t *dev,
     97errno_t vhc_virtdev_plug_hub(vhc_data_t *vhc, usbvirt_device_t *dev,
    9898    uintptr_t *handle, usb_address_t address)
    9999{

  • uspace/drv/bus/usb/vhc/hub/hub.c

    r132ab5d1 r5a6cc679  
    6363static void set_port_status_change(hub_port_t *, hub_status_change_t);
    6464static void clear_port_status_change(hub_port_t *, uint16_t);
    65 static int set_port_state_delayed_fibril(void *);
     65static errno_t set_port_state_delayed_fibril(void *);
    6666static void set_port_state_delayed(hub_t *, size_t, suseconds_t,
    6767    hub_port_state_t, hub_port_state_t);
    … …  
    163163 * @return Error code.
    164164 */
    165 int hub_disconnect_device(hub_t *hub, void *device)
     165errno_t hub_disconnect_device(hub_t *hub, void *device)
    166166{
    167167        size_t index = hub_find_device(hub, device);
    … …  
    461461 * @return Always EOK.
    462462 */
    463 static int set_port_state_delayed_fibril(void *arg)
     463static errno_t set_port_state_delayed_fibril(void *arg)
    464464{
    465465        struct delay_port_state_change *change

  • uspace/drv/bus/usb/vhc/hub/hub.h

    r132ab5d1 r5a6cc679  
    102102void hub_init(hub_t *);
    103103size_t hub_connect_device(hub_t *, void *);
    104 int hub_disconnect_device(hub_t *, void *);
     104errno_t hub_disconnect_device(hub_t *, void *);
    105105size_t hub_find_device(hub_t *, void *);
    106106void hub_acquire(hub_t *);

  • uspace/drv/bus/usb/vhc/hub/virthub.c

    r132ab5d1 r5a6cc679  
    147147 * @return Error code.
    148148 */
    149 int virthub_init(usbvirt_device_t *dev, const char* name)
     149errno_t virthub_init(usbvirt_device_t *dev, const char* name)
    150150{
    151151        if (dev == NULL) {
    … …  
    197197 * @return Error code.
    198198 */
    199 int virthub_disconnect_device(usbvirt_device_t *dev, vhc_virtdev_t *conn)
     199errno_t virthub_disconnect_device(usbvirt_device_t *dev, vhc_virtdev_t *conn)
    200200{
    201201        assert(dev != NULL);

  • uspace/drv/bus/usb/vhc/hub/virthub.h

    r132ab5d1 r5a6cc679  
    8080extern hub_descriptor_t hub_descriptor;
    8181
    82 int virthub_init(usbvirt_device_t *, const char *name);
     82errno_t virthub_init(usbvirt_device_t *, const char *name);
    8383int virthub_connect_device(usbvirt_device_t *, vhc_virtdev_t *);
    84 int virthub_disconnect_device(usbvirt_device_t *, vhc_virtdev_t *);
     84errno_t virthub_disconnect_device(usbvirt_device_t *, vhc_virtdev_t *);
    8585bool virthub_is_device_enabled(usbvirt_device_t *, vhc_virtdev_t *);
    8686void virthub_get_status(usbvirt_device_t *, char *, size_t);

  • uspace/drv/bus/usb/vhc/hub/virthubops.c

    r132ab5d1 r5a6cc679  
    6363
    6464/** Callback for data request. */
    65 static int req_on_status_change_pipe(usbvirt_device_t *dev,
     65static errno_t req_on_status_change_pipe(usbvirt_device_t *dev,
    6666    usb_endpoint_t endpoint, usb_transfer_type_t tr_type,
    6767    void *buffer, size_t buffer_size, size_t *actual_size)
    … …  
    109109 * @return Error code.
    110110 */
    111 static int req_clear_hub_feature(usbvirt_device_t *dev,
     111static errno_t req_clear_hub_feature(usbvirt_device_t *dev,
    112112    const usb_device_request_setup_packet_t *request, uint8_t *data,
    113113    size_t *act_size)
    … …  
    123123 * @return Error code.
    124124 */
    125 static int req_clear_port_feature(usbvirt_device_t *dev,
    126     const usb_device_request_setup_packet_t *request, uint8_t *data,
    127     size_t *act_size)
    128 {
    129         int rc;
     125static errno_t req_clear_port_feature(usbvirt_device_t *dev,
     126    const usb_device_request_setup_packet_t *request, uint8_t *data,
     127    size_t *act_size)
     128{
     129        errno_t rc;
    130130        size_t port = request->index - 1;
    131131        usb_hub_class_feature_t feature = request->value;
    … …  
    203203 * @return Error code.
    204204 */
    205 static int req_get_bus_state(usbvirt_device_t *dev,
     205static errno_t req_get_bus_state(usbvirt_device_t *dev,
    206206    const usb_device_request_setup_packet_t *request, uint8_t *data,
    207207    size_t *act_size)
    … …  
    217217 * @return Error code.
    218218 */
    219 static int req_get_descriptor(usbvirt_device_t *dev,
     219static errno_t req_get_descriptor(usbvirt_device_t *dev,
    220220    const usb_device_request_setup_packet_t *request, uint8_t *data,
    221221    size_t *act_size)
    … …  
    238238 * @return Error code.
    239239 */
    240 static int req_get_hub_status(usbvirt_device_t *dev,
     240static errno_t req_get_hub_status(usbvirt_device_t *dev,
    241241    const usb_device_request_setup_packet_t *request, uint8_t *data,
    242242    size_t *act_size)
    … …  
    257257 * @return Error code.
    258258 */
    259 static int req_get_port_status(usbvirt_device_t *dev,
     259static errno_t req_get_port_status(usbvirt_device_t *dev,
    260260    const usb_device_request_setup_packet_t *request, uint8_t *data,
    261261    size_t *act_size)
    … …  
    282282 * @return Error code.
    283283 */
    284 static int req_set_hub_feature(usbvirt_device_t *dev,
     284static errno_t req_set_hub_feature(usbvirt_device_t *dev,
    285285    const usb_device_request_setup_packet_t *request, uint8_t *data,
    286286    size_t *act_size)
    … …  
    296296 * @return Error code.
    297297 */
    298 static int req_set_port_feature(usbvirt_device_t *dev,
    299     const usb_device_request_setup_packet_t *request, uint8_t *data,
    300     size_t *act_size)
    301 {
    302         int rc = ENOTSUP;
     298static errno_t req_set_port_feature(usbvirt_device_t *dev,
     299    const usb_device_request_setup_packet_t *request, uint8_t *data,
     300    size_t *act_size)
     301{
     302        errno_t rc = ENOTSUP;
    303303        size_t port = request->index - 1;
    304304        usb_hub_class_feature_t feature = request->value;

  • uspace/drv/bus/usb/vhc/main.c

    r132ab5d1 r5a6cc679  
    5050};
    5151
    52 static int vhc_control_node(ddf_dev_t *dev, ddf_fun_t **fun)
     52static errno_t vhc_control_node(ddf_dev_t *dev, ddf_fun_t **fun)
    5353{
    5454        assert(dev);
    … …  
    6464        }
    6565        ddf_fun_set_ops(*fun, &vhc_ops);
    66         const int ret = ddf_fun_bind(*fun);
     66        const errno_t ret = ddf_fun_bind(*fun);
    6767        if (ret != EOK) {
    6868                ddf_fun_destroy(*fun);
    … …  
    7373}
    7474
    75 static int vhc_dev_add(ddf_dev_t *dev)
     75static errno_t vhc_dev_add(ddf_dev_t *dev)
    7676{
    7777        /* Initialize generic structures */
    78         int ret = hcd_ddf_setup_hc(dev, sizeof(vhc_data_t));
     78        errno_t ret = hcd_ddf_setup_hc(dev, sizeof(vhc_data_t));
    7979        if (ret != EOK) {
    8080                usb_log_error("Failed to init HCD structures: %s.",

  • uspace/drv/bus/usb/vhc/transfer.c

    r132ab5d1 r5a6cc679  
    6161}
    6262
    63 static int process_transfer_local(usb_transfer_batch_t *batch,
     63static errno_t process_transfer_local(usb_transfer_batch_t *batch,
    6464    usbvirt_device_t *dev, size_t *actual_data_size)
    6565{
    66         int rc;
     66        errno_t rc;
    6767
    6868        const usb_direction_t dir = batch->dir;
    … …  
    9797}
    9898
    99 static int process_transfer_remote(usb_transfer_batch_t *batch,
     99static errno_t process_transfer_remote(usb_transfer_batch_t *batch,
    100100    async_sess_t *sess, size_t *actual_data_size)
    101101{
    102         int rc;
     102        errno_t rc;
    103103
    104104        const usb_direction_t dir = batch->dir;
    … …  
    146146
    147147static void execute_transfer_callback_and_free(vhc_transfer_t *transfer,
    148     size_t data_transfer_size, int outcome)
     148    size_t data_transfer_size, errno_t outcome)
    149149{
    150150        assert(outcome != ENAK);
    … …  
    192192};
    193193
    194 int vhc_init(vhc_data_t *instance)
     194errno_t vhc_init(vhc_data_t *instance)
    195195{
    196196        assert(instance);
    … …  
    203203}
    204204
    205 int vhc_schedule(usb_transfer_batch_t *batch)
     205errno_t vhc_schedule(usb_transfer_batch_t *batch)
    206206{
    207207        assert(batch);
    … …  
    233233}
    234234
    235 int vhc_transfer_queue_processor(void *arg)
     235errno_t vhc_transfer_queue_processor(void *arg)
    236236{
    237237        vhc_virtdev_t *dev = arg;
    … …  
    248248                fibril_mutex_unlock(&dev->guard);
    249249
    250                 int rc = EOK;
     250                errno_t rc = EOK;
    251251                size_t data_transfer_size = 0;
    252252                if (dev->dev_sess) {

  • uspace/drv/bus/usb/vhc/vhcd.h

    r132ab5d1 r5a6cc679  
    9090    ipc_call_t *icall);
    9191
    92 int vhc_virtdev_plug(vhc_data_t *, async_sess_t *, uintptr_t *);
    93 int vhc_virtdev_plug_local(vhc_data_t *, usbvirt_device_t *, uintptr_t *);
    94 int vhc_virtdev_plug_hub(vhc_data_t *, usbvirt_device_t *, uintptr_t *, usb_address_t address);
     92errno_t vhc_virtdev_plug(vhc_data_t *, async_sess_t *, uintptr_t *);
     93errno_t vhc_virtdev_plug_local(vhc_data_t *, usbvirt_device_t *, uintptr_t *);
     94errno_t vhc_virtdev_plug_hub(vhc_data_t *, usbvirt_device_t *, uintptr_t *, usb_address_t address);
    9595void vhc_virtdev_unplug(vhc_data_t *, uintptr_t);
    9696
    97 int vhc_init(vhc_data_t *);
    98 int vhc_schedule(usb_transfer_batch_t *);
    99 int vhc_transfer_queue_processor(void *arg);
     97errno_t vhc_init(vhc_data_t *);
     98errno_t vhc_schedule(usb_transfer_batch_t *);
     99errno_t vhc_transfer_queue_processor(void *arg);
    100100
    101101#endif
Note: See TracChangeset for help on using the changeset viewer.