Changeset b7fd2a0 in mainline for uspace/drv/hid


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/drv/hid
Files:
32 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/hid/adb-kbd/adb-kbd.c

    r36f0738 rb7fd2a0  
    4848
    4949/** Add ADB keyboard device */
    50 int adb_kbd_add(adb_kbd_t *kbd)
    51 {
    52         int rc;
     50errno_t adb_kbd_add(adb_kbd_t *kbd)
     51{
     52        errno_t rc;
    5353        bool bound = false;
    5454
    … …  
    119119
    120120/** Remove ADB keyboard device */
    121 int adb_kbd_remove(adb_kbd_t *con)
     121errno_t adb_kbd_remove(adb_kbd_t *con)
    122122{
    123123        return ENOTSUP;
    … …  
    125125
    126126/** ADB keyboard device gone */
    127 int adb_kbd_gone(adb_kbd_t *con)
     127errno_t adb_kbd_gone(adb_kbd_t *con)
    128128{
    129129        return ENOTSUP;
    … …  
    140140                ipc_callid_t callid = async_get_call(&call);
    141141
    142                 int retval = EOK;
     142                errno_t retval = EOK;
    143143
    144144                if (!IPC_GET_IMETHOD(call)) {
    … …  
    162162        kbd_event_type_t etype;
    163163        unsigned int key;
    164         int rc;
     164        errno_t rc;
    165165
    166166        rc = adb_kbd_key_translate(b, &etype, &key);

  • uspace/drv/hid/adb-kbd/adb-kbd.h

    r36f0738 rb7fd2a0  
    4444} adb_kbd_t;
    4545
    46 extern int adb_kbd_add(adb_kbd_t *);
    47 extern int adb_kbd_remove(adb_kbd_t *);
    48 extern int adb_kbd_gone(adb_kbd_t *);
     46extern errno_t adb_kbd_add(adb_kbd_t *);
     47extern errno_t adb_kbd_remove(adb_kbd_t *);
     48extern errno_t adb_kbd_gone(adb_kbd_t *);
    4949
    5050#endif

  • uspace/drv/hid/adb-kbd/ctl.c

    r36f0738 rb7fd2a0  
    179179 * @return EOK on success, ENOENT if no translation exists
    180180 */
    181 int adb_kbd_key_translate(sysarg_t scancode, kbd_event_type_t *rtype,
     181errno_t adb_kbd_key_translate(sysarg_t scancode, kbd_event_type_t *rtype,
    182182    unsigned int *rkey)
    183183{

  • uspace/drv/hid/adb-kbd/ctl.h

    r36f0738 rb7fd2a0  
    3535#define CTL_H
    3636
    37 extern int adb_kbd_key_translate(sysarg_t, kbd_event_type_t *, unsigned int *);
     37extern errno_t adb_kbd_key_translate(sysarg_t, kbd_event_type_t *, unsigned int *);
    3838
    3939#endif

  • uspace/drv/hid/adb-kbd/main.c

    r36f0738 rb7fd2a0  
    4242#define NAME  "adb-kbd"
    4343
    44 static int adb_kbd_dev_add(ddf_dev_t *dev);
    45 static int adb_kbd_dev_remove(ddf_dev_t *dev);
    46 static int adb_kbd_dev_gone(ddf_dev_t *dev);
    47 static int adb_kbd_fun_online(ddf_fun_t *fun);
    48 static int adb_kbd_fun_offline(ddf_fun_t *fun);
     44static errno_t adb_kbd_dev_add(ddf_dev_t *dev);
     45static errno_t adb_kbd_dev_remove(ddf_dev_t *dev);
     46static errno_t adb_kbd_dev_gone(ddf_dev_t *dev);
     47static errno_t adb_kbd_fun_online(ddf_fun_t *fun);
     48static errno_t adb_kbd_fun_offline(ddf_fun_t *fun);
    4949
    5050static driver_ops_t driver_ops = {
    … …  
    6161};
    6262
    63 static int adb_kbd_dev_add(ddf_dev_t *dev)
     63static errno_t adb_kbd_dev_add(ddf_dev_t *dev)
    6464{
    6565        adb_kbd_t *adb_kbd;
    … …  
    7777}
    7878
    79 static int adb_kbd_dev_remove(ddf_dev_t *dev)
     79static errno_t adb_kbd_dev_remove(ddf_dev_t *dev)
    8080{
    8181        adb_kbd_t *adb_kbd = (adb_kbd_t *)ddf_dev_data_get(dev);
    … …  
    8686}
    8787
    88 static int adb_kbd_dev_gone(ddf_dev_t *dev)
     88static errno_t adb_kbd_dev_gone(ddf_dev_t *dev)
    8989{
    9090        adb_kbd_t *adb_kbd = (adb_kbd_t *)ddf_dev_data_get(dev);
    … …  
    9595}
    9696
    97 static int adb_kbd_fun_online(ddf_fun_t *fun)
     97static errno_t adb_kbd_fun_online(ddf_fun_t *fun)
    9898{
    9999        ddf_msg(LVL_DEBUG, "adb_kbd_fun_online()");
    … …  
    101101}
    102102
    103 static int adb_kbd_fun_offline(ddf_fun_t *fun)
     103static errno_t adb_kbd_fun_offline(ddf_fun_t *fun)
    104104{
    105105        ddf_msg(LVL_DEBUG, "adb_kbd_fun_offline()");

  • uspace/drv/hid/adb-mouse/adb-mouse.c

    r36f0738 rb7fd2a0  
    9797                ipc_callid_t callid = async_get_call(&call);
    9898
    99                 int retval = EOK;
     99                errno_t retval = EOK;
    100100
    101101                if (!IPC_GET_IMETHOD(call)) {
    … …  
    117117
    118118/** Add ADB mouse device */
    119 int adb_mouse_add(adb_mouse_t *mouse)
    120 {
    121         int rc;
     119errno_t adb_mouse_add(adb_mouse_t *mouse)
     120{
     121        errno_t rc;
    122122        bool bound = false;
    123123
    … …  
    188188
    189189/** Remove ADB mouse device */
    190 int adb_mouse_remove(adb_mouse_t *con)
     190errno_t adb_mouse_remove(adb_mouse_t *con)
    191191{
    192192        return ENOTSUP;
    … …  
    194194
    195195/** ADB mouse device gone */
    196 int adb_mouse_gone(adb_mouse_t *con)
     196errno_t adb_mouse_gone(adb_mouse_t *con)
    197197{
    198198        return ENOTSUP;

  • uspace/drv/hid/adb-mouse/adb-mouse.h

    r36f0738 rb7fd2a0  
    4747} adb_mouse_t;
    4848
    49 extern int adb_mouse_add(adb_mouse_t *);
    50 extern int adb_mouse_remove(adb_mouse_t *);
    51 extern int adb_mouse_gone(adb_mouse_t *);
     49extern errno_t adb_mouse_add(adb_mouse_t *);
     50extern errno_t adb_mouse_remove(adb_mouse_t *);
     51extern errno_t adb_mouse_gone(adb_mouse_t *);
    5252
    5353#endif

  • uspace/drv/hid/adb-mouse/main.c

    r36f0738 rb7fd2a0  
    4242#define NAME  "adb-mouse"
    4343
    44 static int adb_mouse_dev_add(ddf_dev_t *dev);
    45 static int adb_mouse_dev_remove(ddf_dev_t *dev);
    46 static int adb_mouse_dev_gone(ddf_dev_t *dev);
    47 static int adb_mouse_fun_online(ddf_fun_t *fun);
    48 static int adb_mouse_fun_offline(ddf_fun_t *fun);
     44static errno_t adb_mouse_dev_add(ddf_dev_t *dev);
     45static errno_t adb_mouse_dev_remove(ddf_dev_t *dev);
     46static errno_t adb_mouse_dev_gone(ddf_dev_t *dev);
     47static errno_t adb_mouse_fun_online(ddf_fun_t *fun);
     48static errno_t adb_mouse_fun_offline(ddf_fun_t *fun);
    4949
    5050static driver_ops_t driver_ops = {
    … …  
    6161};
    6262
    63 static int adb_mouse_dev_add(ddf_dev_t *dev)
     63static errno_t adb_mouse_dev_add(ddf_dev_t *dev)
    6464{
    6565        adb_mouse_t *adb_mouse;
    … …  
    7777}
    7878
    79 static int adb_mouse_dev_remove(ddf_dev_t *dev)
     79static errno_t adb_mouse_dev_remove(ddf_dev_t *dev)
    8080{
    8181        adb_mouse_t *adb_mouse = (adb_mouse_t *)ddf_dev_data_get(dev);
    … …  
    8686}
    8787
    88 static int adb_mouse_dev_gone(ddf_dev_t *dev)
     88static errno_t adb_mouse_dev_gone(ddf_dev_t *dev)
    8989{
    9090        adb_mouse_t *adb_mouse = (adb_mouse_t *)ddf_dev_data_get(dev);
    … …  
    9595}
    9696
    97 static int adb_mouse_fun_online(ddf_fun_t *fun)
     97static errno_t adb_mouse_fun_online(ddf_fun_t *fun)
    9898{
    9999        ddf_msg(LVL_DEBUG, "adb_mouse_fun_online()");
    … …  
    101101}
    102102
    103 static int adb_mouse_fun_offline(ddf_fun_t *fun)
     103static errno_t adb_mouse_fun_offline(ddf_fun_t *fun)
    104104{
    105105        ddf_msg(LVL_DEBUG, "adb_mouse_fun_offline()");

  • uspace/drv/hid/atkbd/atkbd.c

    r36f0738 rb7fd2a0  
    200200 *
    201201 */
    202 static int polling(void *arg)
     202static errno_t polling(void *arg)
    203203{
    204204        at_kbd_t *kbd = arg;
    205205        size_t nwr;
    206         int rc;
     206        errno_t rc;
    207207       
    208208        while (true) {
    … …  
    355355 *
    356356 */
    357 int at_kbd_init(at_kbd_t *kbd, ddf_dev_t *dev)
     357errno_t at_kbd_init(at_kbd_t *kbd, ddf_dev_t *dev)
    358358{
    359359        async_sess_t *parent_sess;
    360         int rc;
     360        errno_t rc;
    361361       
    362362        assert(kbd);
    … …  
    385385        ddf_fun_set_ops(kbd->kbd_fun, &kbd_ops);
    386386       
    387         int ret = ddf_fun_bind(kbd->kbd_fun);
     387        errno_t ret = ddf_fun_bind(kbd->kbd_fun);
    388388        if (ret != EOK) {
    389389                ddf_msg(LVL_ERROR, "Failed binding function 'kbd'.");

  • uspace/drv/hid/atkbd/atkbd.h

    r36f0738 rb7fd2a0  
    5454} at_kbd_t;
    5555
    56 extern int at_kbd_init(at_kbd_t *, ddf_dev_t *);
     56extern errno_t at_kbd_init(at_kbd_t *, ddf_dev_t *);
    5757
    5858#endif

  • uspace/drv/hid/atkbd/main.c

    r36f0738 rb7fd2a0  
    4646#define NAME "atkbd"
    4747
    48 static int at_kbd_add(ddf_dev_t *device);
     48static errno_t at_kbd_add(ddf_dev_t *device);
    4949
    5050/** DDF driver ops. */
    … …  
    8383 *
    8484 */
    85 static int at_kbd_add(ddf_dev_t *device)
     85static errno_t at_kbd_add(ddf_dev_t *device)
    8686{
    87         int rc;
     87        errno_t rc;
    8888
    8989        if (!device)

  • uspace/drv/hid/ps2mouse/main.c

    r36f0738 rb7fd2a0  
    4545#define NAME "ps2mouse"
    4646
    47 static int mouse_add(ddf_dev_t *device);
     47static errno_t mouse_add(ddf_dev_t *device);
    4848
    4949/** DDF driver ops. */
    … …  
    7878 * @return Error code.
    7979 */
    80 static int mouse_add(ddf_dev_t *device)
     80static errno_t mouse_add(ddf_dev_t *device)
    8181{
    82         int rc;
     82        errno_t rc;
    8383
    8484        if (!device)

  • uspace/drv/hid/ps2mouse/ps2mouse.c

    r36f0738 rb7fd2a0  
    7777        uint8_t data = 0; \
    7878        size_t nread; \
    79         const int rc = chardev_read((mouse)->chardev, &data, 1, &nread); \
     79        const errno_t rc = chardev_read((mouse)->chardev, &data, 1, &nread); \
    8080        if (rc != EOK) { \
    8181                ddf_msg(LVL_ERROR, "Failed reading byte: %s", str_error_name(rc));\
    … …  
    9494        uint8_t data = (value); \
    9595        size_t nwr; \
    96         const int rc = chardev_write((mouse)->chardev, &data, 1, &nwr); \
     96        const errno_t rc = chardev_write((mouse)->chardev, &data, 1, &nwr); \
    9797        if (rc != EOK) { \
    9898                ddf_msg(LVL_ERROR, "Failed writing byte: %s", str_error_name(rc)); \
    … …  
    101101} while (0)
    102102
    103 static int polling_ps2(void *);
    104 static int polling_intellimouse(void *);
    105 static int probe_intellimouse(ps2_mouse_t *, bool);
     103static errno_t polling_ps2(void *);
     104static errno_t polling_intellimouse(void *);
     105static errno_t probe_intellimouse(ps2_mouse_t *, bool);
    106106static void default_connection_handler(ddf_fun_t *, ipc_callid_t, ipc_call_t *);
    107107
    … …  
    120120 * @return EOK on success or non-zero error code
    121121 */
    122 int ps2_mouse_init(ps2_mouse_t *mouse, ddf_dev_t *dev)
     122errno_t ps2_mouse_init(ps2_mouse_t *mouse, ddf_dev_t *dev)
    123123{
    124124        async_sess_t *parent_sess;
    125125        bool bound = false;
    126         int rc;
     126        errno_t rc;
    127127
    128128        mouse->client_sess = NULL;
    … …  
    165165
    166166        /* Probe IntelliMouse extensions. */
    167         int (*polling_f)(void*) = polling_ps2;
     167        errno_t (*polling_f)(void*) = polling_ps2;
    168168        if (probe_intellimouse(mouse, false) == EOK) {
    169169                ddf_msg(LVL_NOTE, "Enabled IntelliMouse extensions");
    … …  
    223223 * @return EOK on success or non-zero error code
    224224 */
    225 static int ps2_mouse_read_packet(ps2_mouse_t *mouse, void *pbuf, size_t psize)
    226 {
    227         int rc;
     225static errno_t ps2_mouse_read_packet(ps2_mouse_t *mouse, void *pbuf, size_t psize)
     226{
     227        errno_t rc;
    228228        size_t pos;
    229229        size_t nread;
    … …  
    248248 * @return Never.
    249249 */
    250 int polling_ps2(void *arg)
     250errno_t polling_ps2(void *arg)
    251251{
    252252        ps2_mouse_t *mouse = (ps2_mouse_t *) arg;
    253         int rc;
     253        errno_t rc;
    254254
    255255        bool buttons[PS2_BUTTON_COUNT] = {};
    … …  
    300300 * @return Never.
    301301 */
    302 static int polling_intellimouse(void *arg)
     302static errno_t polling_intellimouse(void *arg)
    303303{
    304304        ps2_mouse_t *mouse = (ps2_mouse_t *) arg;
    305         int rc;
     305        errno_t rc;
    306306
    307307        bool buttons[INTELLIMOUSE_BUTTON_COUNT] = {};
    … …  
    373373 * See http://www.computer-engineering.org/ps2mouse/ for details.
    374374 */
    375 static int probe_intellimouse(ps2_mouse_t *mouse, bool buttons)
     375static errno_t probe_intellimouse(ps2_mouse_t *mouse, bool buttons)
    376376{
    377377        MOUSE_WRITE_BYTE(mouse, PS2_MOUSE_SET_SAMPLE_RATE);

  • uspace/drv/hid/ps2mouse/ps2mouse.h

    r36f0738 rb7fd2a0  
    5353} ps2_mouse_t;
    5454
    55 extern int ps2_mouse_init(ps2_mouse_t *, ddf_dev_t *);
     55extern errno_t ps2_mouse_init(ps2_mouse_t *, ddf_dev_t *);
    5656
    5757#endif

  • uspace/drv/hid/usbhid/blink1/blink1.c

    r36f0738 rb7fd2a0  
    6060} blink1_report_t;
    6161
    62 static int usb_blink1_color_set(ddf_fun_t *fun, pixel_t pixel)
     62static errno_t usb_blink1_color_set(ddf_fun_t *fun, pixel_t pixel)
    6363{
    6464        usb_blink1_t *blink1_dev = (usb_blink1_t *) ddf_fun_data_get(fun);
    … …  
    9393};
    9494
    95 int usb_blink1_init(usb_hid_dev_t *hid_dev, void **data)
     95errno_t usb_blink1_init(usb_hid_dev_t *hid_dev, void **data)
    9696{
    9797        if (hid_dev == NULL) {
    … …  
    121121        ddf_fun_set_ops(fun, &blink1_ops);
    122122       
    123         int rc = ddf_fun_bind(fun);
     123        errno_t rc = ddf_fun_bind(fun);
    124124        if (rc != EOK) {
    125125                usb_log_error("Could not bind DDF function `%s': %s.\n",
    … …  
    159159        usb_blink1_t *blink1_dev = (usb_blink1_t *) data;
    160160       
    161         int rc = ddf_fun_unbind(blink1_dev->fun);
     161        errno_t rc = ddf_fun_unbind(blink1_dev->fun);
    162162        if (rc != EOK) {
    163163                usb_log_error("Could not unbind function `%s', it "

  • uspace/drv/hid/usbhid/blink1/blink1.h

    r36f0738 rb7fd2a0  
    5252extern const char *HID_BLINK1_CATEGORY;
    5353
    54 extern int usb_blink1_init(usb_hid_dev_t *, void **);
     54extern errno_t usb_blink1_init(usb_hid_dev_t *, void **);
    5555extern void usb_blink1_deinit(usb_hid_dev_t *, void *);
    5656

  • uspace/drv/hid/usbhid/generic/hiddev.c

    r36f0738 rb7fd2a0  
    6060
    6161static size_t usb_generic_hid_get_event_length(ddf_fun_t *fun);
    62 static int usb_generic_hid_get_event(ddf_fun_t *fun, uint8_t *buffer,
     62static errno_t usb_generic_hid_get_event(ddf_fun_t *fun, uint8_t *buffer,
    6363    size_t size, size_t *act_size, int *event_nr, unsigned int flags);
    64 static int usb_generic_hid_client_connected(ddf_fun_t *fun);
     64static errno_t usb_generic_hid_client_connected(ddf_fun_t *fun);
    6565static size_t usb_generic_get_report_descriptor_length(ddf_fun_t *fun);
    66 static int usb_generic_get_report_descriptor(ddf_fun_t *fun, uint8_t *desc,
     66static errno_t usb_generic_get_report_descriptor(ddf_fun_t *fun, uint8_t *desc,
    6767    size_t size, size_t *actual_size);
    6868
    … …  
    102102}
    103103
    104 static int usb_generic_hid_get_event(ddf_fun_t *fun, uint8_t *buffer,
     104static errno_t usb_generic_hid_get_event(ddf_fun_t *fun, uint8_t *buffer,
    105105    size_t size, size_t *act_size, int *event_nr, unsigned int flags)
    106106{
    … …  
    143143}
    144144
    145 static int usb_generic_get_report_descriptor(ddf_fun_t *fun, uint8_t *desc,
     145static errno_t usb_generic_get_report_descriptor(ddf_fun_t *fun, uint8_t *desc,
    146146    size_t size, size_t *actual_size)
    147147{
    … …  
    160160}
    161161
    162 static int usb_generic_hid_client_connected(ddf_fun_t *fun)
     162static errno_t usb_generic_hid_client_connected(ddf_fun_t *fun)
    163163{
    164164        usb_log_debug("Generic HID: Client connected.\n");
    … …  
    180180}
    181181
    182 int usb_generic_hid_init(usb_hid_dev_t *hid_dev, void **data)
     182errno_t usb_generic_hid_init(usb_hid_dev_t *hid_dev, void **data)
    183183{
    184184        usb_hid_gen_fun_t *hid_fun;
    … …  
    202202        ddf_fun_set_ops(fun, &usb_generic_hid_ops);
    203203
    204         int rc = ddf_fun_bind(fun);
     204        errno_t rc = ddf_fun_bind(fun);
    205205        if (rc != EOK) {
    206206                usb_log_error("Could not bind DDF function: %s.\n",

  • uspace/drv/hid/usbhid/generic/hiddev.h

    r36f0738 rb7fd2a0  
    5151} usb_hid_gen_fun_t;
    5252
    53 extern int usb_generic_hid_init(usb_hid_dev_t *, void **);
     53extern errno_t usb_generic_hid_init(usb_hid_dev_t *, void **);
    5454extern void usb_generic_hid_deinit(usb_hid_dev_t *, void *);
    5555extern bool usb_generic_hid_polling_callback(usb_hid_dev_t *, void *);

  • uspace/drv/hid/usbhid/kbd/kbddev.c

    r36f0738 rb7fd2a0  
    257257
    258258        // TODO: what about the Report ID?
    259         int rc = usb_hid_report_output_translate(&hid_dev->report, 0,
     259        errno_t rc = usb_hid_report_output_translate(&hid_dev->report, 0,
    260260            kbd_dev->output_buffer, kbd_dev->output_size);
    261261
    … …  
    435435        }
    436436
    437         int ret =
     437        errno_t ret =
    438438           usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
    439439        if (ret != EOK) {
    … …  
    480480/* HID/KBD structure manipulation                                             */
    481481
    482 static int kbd_dev_init(usb_kbd_t *kbd_dev, usb_hid_dev_t *hid_dev)
     482static errno_t kbd_dev_init(usb_kbd_t *kbd_dev, usb_hid_dev_t *hid_dev)
    483483{
    484484        assert(kbd_dev);
    … …  
    507507        }
    508508
    509         int ret =
     509        errno_t ret =
    510510            usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
    511511        if (ret != EOK) {
    … …  
    616616 * @return Other value inherited from function usbhid_dev_init().
    617617 */
    618 int usb_kbd_init(usb_hid_dev_t *hid_dev, void **data)
     618errno_t usb_kbd_init(usb_hid_dev_t *hid_dev, void **data)
    619619{
    620620        usb_log_debug("Initializing HID/KBD structure...\n");
    … …  
    642642        }
    643643
    644         int ret = kbd_dev_init(kbd_dev, hid_dev);
     644        errno_t ret = kbd_dev_init(kbd_dev, hid_dev);
    645645        if (ret != EOK) {
    646646                usb_log_error("Failed to initialize KBD device  structure.\n");
    … …  
    775775}
    776776
    777 int usb_kbd_set_boot_protocol(usb_hid_dev_t *hid_dev)
     777errno_t usb_kbd_set_boot_protocol(usb_hid_dev_t *hid_dev)
    778778{
    779779        assert(hid_dev);
    780         int rc = usb_hid_parse_report_descriptor(
     780        errno_t rc = usb_hid_parse_report_descriptor(
    781781            &hid_dev->report, USB_KBD_BOOT_REPORT_DESCRIPTOR,
    782782            sizeof(USB_KBD_BOOT_REPORT_DESCRIPTOR));

  • uspace/drv/hid/usbhid/kbd/kbddev.h

    r36f0738 rb7fd2a0  
    115115extern const char *HID_KBD_CATEGORY;
    116116
    117 extern int usb_kbd_init(usb_hid_dev_t *, void **);
     117extern errno_t usb_kbd_init(usb_hid_dev_t *, void **);
    118118extern bool usb_kbd_polling_callback(usb_hid_dev_t *, void *);
    119119extern int usb_kbd_is_initialized(const usb_kbd_t *);
    … …  
    122122extern void usb_kbd_push_ev(usb_kbd_t *, int, unsigned int);
    123123extern void usb_kbd_deinit(usb_hid_dev_t *, void *);
    124 extern int usb_kbd_set_boot_protocol(usb_hid_dev_t *);
     124extern errno_t usb_kbd_set_boot_protocol(usb_hid_dev_t *);
    125125
    126126#endif /* USB_HID_KBDDEV_H_ */

  • uspace/drv/hid/usbhid/kbd/kbdrepeat.c

    r36f0738 rb7fd2a0  
    117117 * @retval EINVAL if no argument is supplied.
    118118 */
    119 int usb_kbd_repeat_fibril(void *arg)
     119errno_t usb_kbd_repeat_fibril(void *arg)
    120120{
    121121        usb_log_debug("Autorepeat fibril spawned.\n");

  • uspace/drv/hid/usbhid/kbd/kbdrepeat.h

    r36f0738 rb7fd2a0  
    5959
    6060
    61 int usb_kbd_repeat_fibril(void *arg);
     61errno_t usb_kbd_repeat_fibril(void *arg);
    6262
    6363void usb_kbd_repeat_start(struct usb_kbd_t *kbd, unsigned int key);

  • uspace/drv/hid/usbhid/main.c

    r36f0738 rb7fd2a0  
    5656 * @return Error code.
    5757 */
    58 static int usb_hid_device_add(usb_device_t *dev)
     58static errno_t usb_hid_device_add(usb_device_t *dev)
    5959{
    6060        usb_log_debug("%s\n", __FUNCTION__);
    … …  
    7777        }
    7878
    79         int rc = usb_hid_init(hid_dev, dev);
     79        errno_t rc = usb_hid_init(hid_dev, dev);
    8080        if (rc != EOK) {
    8181                usb_log_error("Failed to initialize USB/HID device.\n");
    … …  
    122122 * @return Error code.
    123123 */
    124 static int usb_hid_device_rem(usb_device_t *dev)
     124static errno_t usb_hid_device_rem(usb_device_t *dev)
    125125{
    126126        // TODO: Stop device polling
    … …  
    135135 * @return Error code.
    136136 */
    137 static int usb_hid_device_gone(usb_device_t *dev)
     137static errno_t usb_hid_device_gone(usb_device_t *dev)
    138138{
    139139        assert(dev);

  • uspace/drv/hid/usbhid/mouse/mousedev.c

    r36f0738 rb7fd2a0  
    204204                return true;
    205205        }
    206         int ret =
     206        errno_t ret =
    207207           usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_BUTTON, 0);
    208208        if (ret != EOK) {
    … …  
    296296}
    297297
    298 static int mouse_dev_init(usb_mouse_t *mouse_dev, usb_hid_dev_t *hid_dev)
     298static errno_t mouse_dev_init(usb_mouse_t *mouse_dev, usb_hid_dev_t *hid_dev)
    299299{
    300300        // FIXME: This may not be optimal since stupid hardware vendor may
    … …  
    320320}
    321321
    322 int usb_mouse_init(usb_hid_dev_t *hid_dev, void **data)
     322errno_t usb_mouse_init(usb_hid_dev_t *hid_dev, void **data)
    323323{
    324324        usb_log_debug("Initializing HID/Mouse structure...\n");
    … …  
    347347        }
    348348
    349         int ret = mouse_dev_init(mouse_dev, hid_dev);
     349        errno_t ret = mouse_dev_init(mouse_dev, hid_dev);
    350350        if (ret != EOK) {
    351351                usb_log_error("Failed to init HID mouse device structure.\n");
    … …  
    403403        /* Hangup session to the console */
    404404        if (mouse_dev->mouse_sess != NULL) {
    405                 const int ret = async_hangup(mouse_dev->mouse_sess);
     405                const errno_t ret = async_hangup(mouse_dev->mouse_sess);
    406406                if (ret != EOK)
    407407                        usb_log_warning("Failed to hang up mouse session: "
    … …  
    413413}
    414414
    415 int usb_mouse_set_boot_protocol(usb_hid_dev_t *hid_dev)
    416 {
    417         int rc = usb_hid_parse_report_descriptor(
     415errno_t usb_mouse_set_boot_protocol(usb_hid_dev_t *hid_dev)
     416{
     417        errno_t rc = usb_hid_parse_report_descriptor(
    418418            &hid_dev->report, USB_MOUSE_BOOT_REPORT_DESCRIPTOR,
    419419            sizeof(USB_MOUSE_BOOT_REPORT_DESCRIPTOR));

  • uspace/drv/hid/usbhid/mouse/mousedev.h

    r36f0738 rb7fd2a0  
    5959extern const char *HID_MOUSE_CATEGORY;
    6060
    61 extern int usb_mouse_init(usb_hid_dev_t *, void **);
     61extern errno_t usb_mouse_init(usb_hid_dev_t *, void **);
    6262extern bool usb_mouse_polling_callback(usb_hid_dev_t *, void *);
    6363extern void usb_mouse_deinit(usb_hid_dev_t *, void *);
    64 extern int usb_mouse_set_boot_protocol(usb_hid_dev_t *);
     64extern errno_t usb_mouse_set_boot_protocol(usb_hid_dev_t *);
    6565
    6666#endif // USB_HID_MOUSEDEV_H_

  • uspace/drv/hid/usbhid/multimedia/multimedia.c

    r36f0738 rb7fd2a0  
    153153}
    154154
    155 int usb_multimedia_init(struct usb_hid_dev *hid_dev, void **data)
     155errno_t usb_multimedia_init(struct usb_hid_dev *hid_dev, void **data)
    156156{
    157157        if (hid_dev == NULL || hid_dev->usb_dev == NULL) {
    … …  
    182182        //todo Autorepeat?
    183183
    184         int rc = ddf_fun_bind(fun);
     184        errno_t rc = ddf_fun_bind(fun);
    185185        if (rc != EOK) {
    186186                usb_log_error("Could not bind DDF function: %s.\n",
    … …  
    248248                return true; /* This might be a temporary failure. */
    249249
    250         int ret =
     250        errno_t ret =
    251251            usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_CONSUMER, 0);
    252252        if (ret != EOK) {

  • uspace/drv/hid/usbhid/multimedia/multimedia.h

    r36f0738 rb7fd2a0  
    4040#include "../usbhid.h"
    4141
    42 extern int usb_multimedia_init(usb_hid_dev_t *, void **);
     42extern errno_t usb_multimedia_init(usb_hid_dev_t *, void **);
    4343extern void usb_multimedia_deinit(usb_hid_dev_t *, void *);
    4444extern bool usb_multimedia_polling_callback(usb_hid_dev_t *, void *);

  • uspace/drv/hid/usbhid/usbhid.c

    r36f0738 rb7fd2a0  
    6161};
    6262
    63 static int usb_hid_set_boot_kbd_subdriver(usb_hid_dev_t *hid_dev)
     63static errno_t usb_hid_set_boot_kbd_subdriver(usb_hid_dev_t *hid_dev)
    6464{
    6565        assert(hid_dev != NULL);
    … …  
    7777}
    7878
    79 static int usb_hid_set_boot_mouse_subdriver(usb_hid_dev_t *hid_dev)
     79static errno_t usb_hid_set_boot_mouse_subdriver(usb_hid_dev_t *hid_dev)
    8080{
    8181        assert(hid_dev != NULL);
    … …  
    9393}
    9494
    95 static int usb_hid_set_generic_hid_subdriver(usb_hid_dev_t *hid_dev)
     95static errno_t usb_hid_set_generic_hid_subdriver(usb_hid_dev_t *hid_dev)
    9696{
    9797        assert(hid_dev != NULL);
    … …  
    182182}
    183183
    184 static int usb_hid_save_subdrivers(usb_hid_dev_t *hid_dev,
     184static errno_t usb_hid_save_subdrivers(usb_hid_dev_t *hid_dev,
    185185    const usb_hid_subdriver_t **subdrivers, unsigned count)
    186186{
    … …  
    215215}
    216216
    217 static int usb_hid_find_subdrivers(usb_hid_dev_t *hid_dev)
     217static errno_t usb_hid_find_subdrivers(usb_hid_dev_t *hid_dev)
    218218{
    219219        assert(hid_dev != NULL);
    … …  
    267267}
    268268
    269 static int usb_hid_check_pipes(usb_hid_dev_t *hid_dev, usb_device_t *dev)
     269static errno_t usb_hid_check_pipes(usb_hid_dev_t *hid_dev, usb_device_t *dev)
    270270{
    271271        assert(hid_dev);
    … …  
    293293}
    294294
    295 static int usb_hid_init_report(usb_hid_dev_t *hid_dev)
     295static errno_t usb_hid_init_report(usb_hid_dev_t *hid_dev)
    296296{
    297297        assert(hid_dev != NULL);
    … …  
    342342 * @return Error code.
    343343 */
    344 int usb_hid_init(usb_hid_dev_t *hid_dev, usb_device_t *dev)
     344errno_t usb_hid_init(usb_hid_dev_t *hid_dev, usb_device_t *dev)
    345345{
    346346        assert(hid_dev);
    … …  
    355355        hid_dev->poll_pipe_mapping = NULL;
    356356
    357         int rc = usb_hid_check_pipes(hid_dev, dev);
     357        errno_t rc = usb_hid_check_pipes(hid_dev, dev);
    358358        if (rc != EOK) {
    359359                return rc;
    … …  
    420420                if (hid_dev->subdrivers[i].init != NULL) {
    421421                        usb_log_debug("Initializing subdriver %d.\n",i);
    422                         const int pret = hid_dev->subdrivers[i].init(hid_dev,
     422                        const errno_t pret = hid_dev->subdrivers[i].init(hid_dev,
    423423                            &hid_dev->subdrivers[i].data);
    424424                        if (pret != EOK) {
    … …  
    473473
    474474        /* Parse the input report */
    475         const int rc = usb_hid_parse_report(
     475        const errno_t rc = usb_hid_parse_report(
    476476            &hid_dev->report, buffer, buffer_size, &hid_dev->report_id);
    477477        if (rc != EOK) {

  • uspace/drv/hid/usbhid/usbhid.h

    r36f0738 rb7fd2a0  
    5555 * @return Error code.
    5656 */
    57 typedef int (*usb_hid_driver_init_t)(usb_hid_dev_t *dev, void **data);
     57typedef errno_t (*usb_hid_driver_init_t)(usb_hid_dev_t *dev, void **data);
    5858
    5959/** Subdriver deinitialization callback.
    … …  
    134134extern const usb_endpoint_description_t *usb_hid_endpoints[];
    135135
    136 int usb_hid_init(usb_hid_dev_t *hid_dev, usb_device_t *dev);
     136errno_t usb_hid_init(usb_hid_dev_t *hid_dev, usb_device_t *dev);
    137137
    138138void usb_hid_deinit(usb_hid_dev_t *hid_dev);

  • uspace/drv/hid/xtkbd/main.c

    r36f0738 rb7fd2a0  
    4646#define NAME "xtkbd"
    4747
    48 static int xt_kbd_add(ddf_dev_t *device);
     48static errno_t xt_kbd_add(ddf_dev_t *device);
    4949
    5050/** DDF driver ops. */
    … …  
    8383 *
    8484 */
    85 static int xt_kbd_add(ddf_dev_t *device)
     85static errno_t xt_kbd_add(ddf_dev_t *device)
    8686{
    87         int rc;
     87        errno_t rc;
    8888
    8989        if (!device)

  • uspace/drv/hid/xtkbd/xtkbd.c

    r36f0738 rb7fd2a0  
    205205 *
    206206 */
    207 static int polling(void *arg)
     207static errno_t polling(void *arg)
    208208{
    209209        xt_kbd_t *kbd = arg;
    210210        size_t nread;
    211         int rc;
     211        errno_t rc;
    212212       
    213213        while (true) {
    … …  
    353353               
    354354                size_t nwr;
    355                 int rc = chardev_write(kbd->chardev, &cmds[0], 1, &nwr);
     355                errno_t rc = chardev_write(kbd->chardev, &cmds[0], 1, &nwr);
    356356                if (rc != EOK) {
    357357                        async_answer_0(icallid, rc);
    … …  
    410410 *
    411411 */
    412 int xt_kbd_init(xt_kbd_t *kbd, ddf_dev_t *dev)
     412errno_t xt_kbd_init(xt_kbd_t *kbd, ddf_dev_t *dev)
    413413{
    414414        async_sess_t *parent_sess;
    415415        bool bound = false;
    416         int rc;
     416        errno_t rc;
    417417       
    418418        kbd->client_sess = NULL;

  • uspace/drv/hid/xtkbd/xtkbd.h

    r36f0738 rb7fd2a0  
    5555} xt_kbd_t;
    5656
    57 extern int xt_kbd_init(xt_kbd_t *, ddf_dev_t *);
     57extern errno_t xt_kbd_init(xt_kbd_t *, ddf_dev_t *);
    5858
    5959#endif
Note: See TracChangeset for help on using the changeset viewer.