Changeset 5a6cc679 in mainline for uspace/srv/hid


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/srv/hid
Files:
39 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/hid/compositor/compositor.c

    r132ab5d1 r5a6cc679  
    151151static bool active = false;
    152152
    153 static int comp_active(input_t *);
    154 static int comp_deactive(input_t *);
    155 static int comp_key_press(input_t *, kbd_event_type_t, keycode_t, keymod_t, wchar_t);
    156 static int comp_mouse_move(input_t *, int, int);
    157 static int comp_abs_move(input_t *, unsigned, unsigned, unsigned, unsigned);
    158 static int comp_mouse_button(input_t *, int, int);
     153static errno_t comp_active(input_t *);
     154static errno_t comp_deactive(input_t *);
     155static errno_t comp_key_press(input_t *, kbd_event_type_t, keycode_t, keymod_t, wchar_t);
     156static errno_t comp_mouse_move(input_t *, int, int);
     157static errno_t comp_abs_move(input_t *, unsigned, unsigned, unsigned, unsigned);
     158static errno_t comp_mouse_button(input_t *, int, int);
    159159
    160160static input_ev_ops_t input_ev_ops = {
    … …  
    602602        }
    603603       
    604         int rc = async_data_read_finalize(callid, event, len);
     604        errno_t rc = async_data_read_finalize(callid, event, len);
    605605        if (rc != EOK) {
    606606                async_answer_0(iid, ENOMEM);
    … …  
    706706       
    707707        void *new_cell_storage;
    708         int rc = async_share_out_finalize(callid, &new_cell_storage);
     708        errno_t rc = async_share_out_finalize(callid, &new_cell_storage);
    709709        if ((rc != EOK) || (new_cell_storage == AS_MAP_FAILED)) {
    710710                async_answer_0(iid, ENOMEM);
    … …  
    10491049        /* Retrieve the mode that shall be set. */
    10501050        vslmode_t new_mode;
    1051         int rc = visualizer_get_mode(vp->sess, &new_mode, mode_idx);
     1051        errno_t rc = visualizer_get_mode(vp->sess, &new_mode, mode_idx);
    10521052        if (rc != EOK) {
    10531053                fibril_mutex_unlock(&viewport_list_mtx);
    … …  
    11771177static async_sess_t *vsl_connect(service_id_t sid, const char *svc)
    11781178{
    1179         int rc;
     1179        errno_t rc;
    11801180        async_sess_t *sess;
    11811181
    … …  
    12061206static viewport_t *viewport_create(service_id_t sid)
    12071207{
    1208         int rc;
     1208        errno_t rc;
    12091209        char *vsl_name = NULL;
    12101210        viewport_t *vp = NULL;
    … …  
    14771477#endif
    14781478
    1479 static int comp_abs_move(input_t *input, unsigned x , unsigned y,
     1479static errno_t comp_abs_move(input_t *input, unsigned x , unsigned y,
    14801480    unsigned max_x, unsigned max_y)
    14811481{
    … …  
    15121512}
    15131513
    1514 static int comp_mouse_move(input_t *input, int dx, int dy)
     1514static errno_t comp_mouse_move(input_t *input, int dx, int dy)
    15151515{
    15161516        pointer_t *pointer = input_pointer(input);
    … …  
    16241624}
    16251625
    1626 static int comp_mouse_button(input_t *input, int bnum, int bpress)
     1626static errno_t comp_mouse_button(input_t *input, int bnum, int bpress)
    16271627{
    16281628        pointer_t *pointer = input_pointer(input);
    … …  
    18091809}
    18101810
    1811 static int comp_active(input_t *input)
     1811static errno_t comp_active(input_t *input)
    18121812{
    18131813        active = true;
    … …  
    18171817}
    18181818
    1819 static int comp_deactive(input_t *input)
     1819static errno_t comp_deactive(input_t *input)
    18201820{
    18211821        active = false;
    … …  
    18231823}
    18241824
    1825 static int comp_key_press(input_t *input, kbd_event_type_t type, keycode_t key,
     1825static errno_t comp_key_press(input_t *input, kbd_event_type_t type, keycode_t key,
    18261826    keymod_t mods, wchar_t c)
    18271827{
    … …  
    21432143}
    21442144
    2145 static int input_connect(const char *svc)
     2145static errno_t input_connect(const char *svc)
    21462146{
    21472147        async_sess_t *sess;
    21482148        service_id_t dsid;
    21492149
    2150         int rc = loc_service_get_id(svc, &dsid, 0);
     2150        errno_t rc = loc_service_get_id(svc, &dsid, 0);
    21512151        if (rc != EOK) {
    21522152                printf("%s: Input service %s not found\n", NAME, svc);
    … …  
    21992199        /* Create viewports and connect them to visualizers. */
    22002200        category_id_t cat_id;
    2201         int rc = loc_category_get_id("visualizer", &cat_id, IPC_FLAG_BLOCKING);
     2201        errno_t rc = loc_category_get_id("visualizer", &cat_id, IPC_FLAG_BLOCKING);
    22022202        if (rc != EOK)
    22032203                goto ret;
    … …  
    22402240}
    22412241
    2242 static int compositor_srv_init(char *input_svc, char *name)
     2242static errno_t compositor_srv_init(char *input_svc, char *name)
    22432243{
    22442244        /* Coordinates of the central pixel. */
    … …  
    22512251        async_set_fallback_port_handler(client_connection, NULL);
    22522252       
    2253         int rc = loc_server_register(NAME);
     2253        errno_t rc = loc_server_register(NAME);
    22542254        if (rc != EOK) {
    22552255                printf("%s: Unable to register server (%s)\n", NAME, str_error(rc));
    … …  
    23132313        printf("%s: HelenOS Compositor server\n", NAME);
    23142314       
    2315         int rc = compositor_srv_init(argv[1], argv[2]);
     2315        errno_t rc = compositor_srv_init(argv[1], argv[2]);
    23162316        if (rc != EOK)
    23172317                return rc;

  • uspace/srv/hid/console/console.c

    r132ab5d1 r5a6cc679  
    101101static console_t *active_console = &consoles[0];
    102102
    103 static int input_ev_active(input_t *);
    104 static int input_ev_deactive(input_t *);
    105 static int input_ev_key(input_t *, kbd_event_type_t, keycode_t, keymod_t, wchar_t);
    106 static int input_ev_move(input_t *, int, int);
    107 static int input_ev_abs_move(input_t *, unsigned, unsigned, unsigned, unsigned);
    108 static int input_ev_button(input_t *, int, int);
     103static errno_t input_ev_active(input_t *);
     104static errno_t input_ev_deactive(input_t *);
     105static errno_t input_ev_key(input_t *, kbd_event_type_t, keycode_t, keymod_t, wchar_t);
     106static errno_t input_ev_move(input_t *, int, int);
     107static errno_t input_ev_abs_move(input_t *, unsigned, unsigned, unsigned, unsigned);
     108static errno_t input_ev_button(input_t *, int, int);
    109109
    110110static input_ev_ops_t input_ev_ops = {
    … …  
    117117};
    118118
    119 static int cons_open(con_srvs_t *, con_srv_t *);
    120 static int cons_close(con_srv_t *);
    121 static int cons_read(con_srv_t *, void *, size_t, size_t *);
    122 static int cons_write(con_srv_t *, void *, size_t, size_t *);
     119static errno_t cons_open(con_srvs_t *, con_srv_t *);
     120static errno_t cons_close(con_srv_t *);
     121static errno_t cons_read(con_srv_t *, void *, size_t, size_t *);
     122static errno_t cons_write(con_srv_t *, void *, size_t, size_t *);
    123123static void cons_sync(con_srv_t *);
    124124static void cons_clear(con_srv_t *);
    125125static void cons_set_pos(con_srv_t *, sysarg_t col, sysarg_t row);
    126 static int cons_get_pos(con_srv_t *, sysarg_t *, sysarg_t *);
    127 static int cons_get_size(con_srv_t *, sysarg_t *, sysarg_t *);
    128 static int cons_get_color_cap(con_srv_t *, console_caps_t *);
     126static errno_t cons_get_pos(con_srv_t *, sysarg_t *, sysarg_t *);
     127static errno_t cons_get_size(con_srv_t *, sysarg_t *, sysarg_t *);
     128static errno_t cons_get_color_cap(con_srv_t *, console_caps_t *);
    129129static void cons_set_style(con_srv_t *, console_style_t);
    130130static void cons_set_color(con_srv_t *, console_color_t, console_color_t,
    … …  
    132132static void cons_set_rgb_color(con_srv_t *, pixel_t, pixel_t);
    133133static void cons_set_cursor_visibility(con_srv_t *, bool);
    134 static int cons_get_event(con_srv_t *, cons_event_t *);
     134static errno_t cons_get_event(con_srv_t *, cons_event_t *);
    135135
    136136static con_ops_t con_ops = {
    … …  
    230230}
    231231
    232 static int input_ev_active(input_t *input)
     232static errno_t input_ev_active(input_t *input)
    233233{
    234234        active = true;
    … …  
    239239}
    240240
    241 static int input_ev_deactive(input_t *input)
     241static errno_t input_ev_deactive(input_t *input)
    242242{
    243243        active = false;
    … …  
    247247}
    248248
    249 static int input_ev_key(input_t *input, kbd_event_type_t type, keycode_t key,
     249static errno_t input_ev_key(input_t *input, kbd_event_type_t type, keycode_t key,
    250250    keymod_t mods, wchar_t c)
    251251{
    … …  
    274274}
    275275
    276 static int input_ev_move(input_t *input, int dx, int dy)
    277 {
    278         return EOK;
    279 }
    280 
    281 static int input_ev_abs_move(input_t *input, unsigned x , unsigned y,
     276static errno_t input_ev_move(input_t *input, int dx, int dy)
     277{
     278        return EOK;
     279}
     280
     281static errno_t input_ev_abs_move(input_t *input, unsigned x , unsigned y,
    282282    unsigned max_x, unsigned max_y)
    283283{
    … …  
    285285}
    286286
    287 static int input_ev_button(input_t *input, int bnum, int bpress)
     287static errno_t input_ev_button(input_t *input, int bnum, int bpress)
    288288{
    289289        return EOK;
    … …  
    328328}
    329329
    330 static int cons_open(con_srvs_t *srvs, con_srv_t *srv)
    331 {
    332         return EOK;
    333 }
    334 
    335 static int cons_close(con_srv_t *srv)
    336 {
    337         return EOK;
    338 }
    339 
    340 static int cons_read(con_srv_t *srv, void *buf, size_t size, size_t *nread)
     330static errno_t cons_open(con_srvs_t *srvs, con_srv_t *srv)
     331{
     332        return EOK;
     333}
     334
     335static errno_t cons_close(con_srv_t *srv)
     336{
     337        return EOK;
     338}
     339
     340static errno_t cons_read(con_srv_t *srv, void *buf, size_t size, size_t *nread)
    341341{
    342342        uint8_t *bbuf = buf;
    … …  
    382382}
    383383
    384 static int cons_write(con_srv_t *srv, void *data, size_t size, size_t *nwritten)
     384static errno_t cons_write(con_srv_t *srv, void *data, size_t size, size_t *nwritten)
    385385{
    386386        console_t *cons = srv_to_console(srv);
    … …  
    423423}
    424424
    425 static int cons_get_pos(con_srv_t *srv, sysarg_t *col, sysarg_t *row)
     425static errno_t cons_get_pos(con_srv_t *srv, sysarg_t *col, sysarg_t *row)
    426426{
    427427        console_t *cons = srv_to_console(srv);
    … …  
    434434}
    435435
    436 static int cons_get_size(con_srv_t *srv, sysarg_t *cols, sysarg_t *rows)
     436static errno_t cons_get_size(con_srv_t *srv, sysarg_t *cols, sysarg_t *rows)
    437437{
    438438        console_t *cons = srv_to_console(srv);
    … …  
    446446}
    447447
    448 static int cons_get_color_cap(con_srv_t *srv, console_caps_t *ccaps)
     448static errno_t cons_get_color_cap(con_srv_t *srv, console_caps_t *ccaps)
    449449{
    450450        console_t *cons = srv_to_console(srv);
    … …  
    493493}
    494494
    495 static int cons_get_event(con_srv_t *srv, cons_event_t *event)
     495static errno_t cons_get_event(con_srv_t *srv, cons_event_t *event)
    496496{
    497497        console_t *cons = srv_to_console(srv);
    … …  
    528528}
    529529
    530 static int input_connect(const char *svc)
     530static errno_t input_connect(const char *svc)
    531531{
    532532        async_sess_t *sess;
    533533        service_id_t dsid;
    534534       
    535         int rc = loc_service_get_id(svc, &dsid, 0);
     535        errno_t rc = loc_service_get_id(svc, &dsid, 0);
    536536        if (rc != EOK) {
    537537                printf("%s: Input service %s not found\n", NAME, svc);
    … …  
    562562        service_id_t dsid;
    563563       
    564         int rc = loc_service_get_id(svc, &dsid, 0);
     564        errno_t rc = loc_service_get_id(svc, &dsid, 0);
    565565        if (rc == EOK) {
    566566                sess = loc_service_connect(dsid, INTERFACE_OUTPUT, 0);
    … …  
    579579{
    580580        /* Connect to input service */
    581         int rc = input_connect(input_svc);
     581        errno_t rc = input_connect(input_svc);
    582582        if (rc != EOK)
    583583                return false;

  • uspace/srv/hid/input/ctl/kbdev.c

    r132ab5d1 r5a6cc679  
    5151#include "../kbd_port.h"
    5252
    53 static int kbdev_ctl_init(kbd_dev_t *);
     53static errno_t kbdev_ctl_init(kbd_dev_t *);
    5454static void kbdev_ctl_set_ind(kbd_dev_t *, unsigned int);
    5555
    … …  
    9090}
    9191
    92 static int kbdev_ctl_init(kbd_dev_t *kdev)
     92static errno_t kbdev_ctl_init(kbd_dev_t *kdev)
    9393{
    9494        async_sess_t *sess = loc_service_connect(kdev->svc_id,
    … …  
    119119       
    120120        port_id_t port;
    121         int rc = async_create_callback_port(exch, INTERFACE_KBD_CB, 0, 0,
     121        errno_t rc = async_create_callback_port(exch, INTERFACE_KBD_CB, 0, 0,
    122122            kbdev_callback_conn, kbdev, &port);
    123123       
    … …  
    150150{
    151151        kbdev_t *kbdev;
    152         int retval;
     152        errno_t retval;
    153153        int type, key;
    154154

  • uspace/srv/hid/input/ctl/stty.c

    r132ab5d1 r5a6cc679  
    4646
    4747static void stty_ctl_parse(sysarg_t);
    48 static int stty_ctl_init(kbd_dev_t *);
     48static errno_t stty_ctl_init(kbd_dev_t *);
    4949static void stty_ctl_set_ind(kbd_dev_t *, unsigned int);
    5050
    … …  
    237237};
    238238
    239 static int stty_ctl_init(kbd_dev_t *kdev)
     239static errno_t stty_ctl_init(kbd_dev_t *kdev)
    240240{
    241241        kbd_dev = kdev;

  • uspace/srv/hid/input/ctl/sun.c

    r132ab5d1 r5a6cc679  
    4444
    4545static void sun_ctl_parse(sysarg_t);
    46 static int sun_ctl_init(kbd_dev_t *);
     46static errno_t sun_ctl_init(kbd_dev_t *);
    4747static void sun_ctl_set_ind(kbd_dev_t *, unsigned int);
    4848
    … …  
    6060static int scanmap_simple[];
    6161
    62 static int sun_ctl_init(kbd_dev_t *kdev)
     62static errno_t sun_ctl_init(kbd_dev_t *kdev)
    6363{
    6464        kbd_dev = kdev;

  • uspace/srv/hid/input/input.c

    r132ab5d1 r5a6cc679  
    473473        kdev->ctl_ops = &kbdev_ctl;
    474474       
    475         int rc = loc_service_get_name(service_id, &kdev->svc_name);
     475        errno_t rc = loc_service_get_name(service_id, &kdev->svc_name);
    476476        if (rc != EOK) {
    477477                kdev->svc_name = NULL;
    … …  
    510510        mdev->proto_ops = &mousedev_proto;
    511511       
    512         int rc = loc_service_get_name(service_id, &mdev->svc_name);
     512        errno_t rc = loc_service_get_name(service_id, &mdev->svc_name);
    513513        if (rc != EOK) {
    514514                mdev->svc_name = NULL;
    … …  
    530530}
    531531
    532 static int serial_consumer(void *arg)
     532static errno_t serial_consumer(void *arg)
    533533{
    534534        serial_dev_t *sdev = (serial_dev_t *) arg;
    … …  
    554554{
    555555        bool match = false;
    556         int rc;
     556        errno_t rc;
    557557
    558558        serial_dev_t *sdev = serial_dev_new();
    … …  
    633633}
    634634
    635 static int dev_check_new_kbdevs(void)
     635static errno_t dev_check_new_kbdevs(void)
    636636{
    637637        category_id_t keyboard_cat;
    … …  
    639639        size_t count, i;
    640640        bool already_known;
    641         int rc;
     641        errno_t rc;
    642642       
    643643        rc = loc_category_get_id("keyboard", &keyboard_cat, IPC_FLAG_BLOCKING);
    … …  
    684684}
    685685
    686 static int dev_check_new_mousedevs(void)
     686static errno_t dev_check_new_mousedevs(void)
    687687{
    688688        category_id_t mouse_cat;
    … …  
    690690        size_t count, i;
    691691        bool already_known;
    692         int rc;
     692        errno_t rc;
    693693       
    694694        rc = loc_category_get_id("mouse", &mouse_cat, IPC_FLAG_BLOCKING);
    … …  
    735735}
    736736
    737 static int dev_check_new_serialdevs(void)
     737static errno_t dev_check_new_serialdevs(void)
    738738{
    739739        category_id_t serial_cat;
    … …  
    741741        size_t count, i;
    742742        bool already_known;
    743         int rc;
     743        errno_t rc;
    744744       
    745745        rc = loc_category_get_id("serial", &serial_cat, IPC_FLAG_BLOCKING);
    … …  
    786786}
    787787
    788 static int dev_check_new(void)
    789 {
    790         int rc;
     788static errno_t dev_check_new(void)
     789{
     790        errno_t rc;
    791791       
    792792        fibril_mutex_lock(&discovery_lock);
    … …  
    823823
    824824/** Start listening for new devices. */
    825 static int input_start_dev_discovery(void)
    826 {
    827         int rc = loc_register_cat_change_cb(cat_change_cb);
     825static errno_t input_start_dev_discovery(void)
     826{
     827        errno_t rc = loc_register_cat_change_cb(cat_change_cb);
    828828        if (rc != EOK) {
    829829                printf("%s: Failed registering callback for device discovery: "
    … …  
    842842int main(int argc, char **argv)
    843843{
    844         int rc;
     844        errno_t rc;
    845845
    846846        if (argc < 2) {

  • uspace/srv/hid/input/kbd_ctl.h

    r132ab5d1 r5a6cc679  
    4444typedef struct kbd_ctl_ops {
    4545        void (*parse)(sysarg_t);
    46         int (*init)(struct kbd_dev *);
     46        errno_t (*init)(struct kbd_dev *);
    4747        void (*set_ind)(struct kbd_dev *, unsigned int);
    4848} kbd_ctl_ops_t;

  • uspace/srv/hid/input/kbd_port.h

    r132ab5d1 r5a6cc679  
    4343
    4444typedef struct kbd_port_ops {
    45         int (*init)(struct kbd_dev *);
     45        errno_t (*init)(struct kbd_dev *);
    4646        void (*write)(uint8_t);
    4747} kbd_port_ops_t;

  • uspace/srv/hid/input/layout.h

    r132ab5d1 r5a6cc679  
    5151/** Layout ops */
    5252typedef struct layout_ops {
    53         int (*create)(layout_t *);
     53        errno_t (*create)(layout_t *);
    5454        void (*destroy)(layout_t *);
    5555        wchar_t (*parse_ev)(layout_t *, kbd_event_t *);

  • uspace/srv/hid/input/layout/ar.c

    r132ab5d1 r5a6cc679  
    3939#include "../kbd.h"
    4040
    41 static int ar_create(layout_t *);
     41static errno_t ar_create(layout_t *);
    4242static void ar_destroy(layout_t *);
    4343static wchar_t ar_parse_ev(layout_t *, kbd_event_t *ev);
    … …  
    200200}
    201201
    202 static int ar_create(layout_t *state)
     202static errno_t ar_create(layout_t *state)
    203203{
    204204        return EOK;

  • uspace/srv/hid/input/layout/cz.c

    r132ab5d1 r5a6cc679  
    4040#include "../layout.h"
    4141
    42 static int cz_create(layout_t *);
     42static errno_t cz_create(layout_t *);
    4343static void cz_destroy(layout_t *);
    4444static wchar_t cz_parse_ev(layout_t *, kbd_event_t *ev);
    … …  
    385385}
    386386
    387 static int cz_create(layout_t *state)
     387static errno_t cz_create(layout_t *state)
    388388{
    389389        layout_cz_t *cz_state;

  • uspace/srv/hid/input/layout/us_dvorak.c

    r132ab5d1 r5a6cc679  
    3838#include "../kbd.h"
    3939
    40 static int us_dvorak_create(layout_t *);
     40static errno_t us_dvorak_create(layout_t *);
    4141static void us_dvorak_destroy(layout_t *);
    4242static wchar_t us_dvorak_parse_ev(layout_t *, kbd_event_t *ev);
    … …  
    209209}
    210210
    211 static int us_dvorak_create(layout_t *state)
     211static errno_t us_dvorak_create(layout_t *state)
    212212{
    213213        return EOK;

  • uspace/srv/hid/input/layout/us_qwerty.c

    r132ab5d1 r5a6cc679  
    3838#include "../kbd.h"
    3939
    40 static int us_qwerty_create(layout_t *);
     40static errno_t us_qwerty_create(layout_t *);
    4141static void us_qwerty_destroy(layout_t *);
    4242static wchar_t us_qwerty_parse_ev(layout_t *, kbd_event_t *ev);
    … …  
    203203}
    204204
    205 static int us_qwerty_create(layout_t *state)
     205static errno_t us_qwerty_create(layout_t *state)
    206206{
    207207        return EOK;

  • uspace/srv/hid/input/mouse_port.h

    r132ab5d1 r5a6cc679  
    4343
    4444typedef struct mouse_port_ops {
    45         int (*init)(struct mouse_dev *);
     45        errno_t (*init)(struct mouse_dev *);
    4646        void (*write)(uint8_t);
    4747} mouse_port_ops_t;

  • uspace/srv/hid/input/mouse_proto.h

    r132ab5d1 r5a6cc679  
    4444typedef struct mouse_proto_ops {
    4545        void (*parse)(sysarg_t);
    46         int (*init)(struct mouse_dev *);
     46        errno_t (*init)(struct mouse_dev *);
    4747} mouse_proto_ops_t;
    4848

  • uspace/srv/hid/input/port/chardev.c

    r132ab5d1 r5a6cc679  
    4545#include "../kbd.h"
    4646
    47 static int kbd_port_fibril(void *);
     47static errno_t kbd_port_fibril(void *);
    4848
    49 static int chardev_port_init(kbd_dev_t *);
     49static errno_t chardev_port_init(kbd_dev_t *);
    5050static void chardev_port_write(uint8_t);
    5151
    … …  
    6969static const unsigned int num_devs = sizeof(in_devs) / sizeof(in_devs[0]);
    7070
    71 static int chardev_port_init(kbd_dev_t *kdev)
     71static errno_t chardev_port_init(kbd_dev_t *kdev)
    7272{
    7373        service_id_t service_id;
    7474        unsigned int i;
    7575        fid_t fid;
    76         int rc;
     76        errno_t rc;
    7777       
    7878        kbd_dev = kdev;
    … …  
    121121static void chardev_port_write(uint8_t data)
    122122{
    123         int rc;
     123        errno_t rc;
    124124        size_t nwr;
    125125
    … …  
    131131}
    132132
    133 static int kbd_port_fibril(void *arg)
     133static errno_t kbd_port_fibril(void *arg)
    134134{
    135         int rc;
     135        errno_t rc;
    136136        size_t nread;
    137137        uint8_t b;

  • uspace/srv/hid/input/proto/mousedev.c

    r132ab5d1 r5a6cc679  
    8585                }
    8686               
    87                 int retval;
     87                errno_t retval;
    8888               
    8989                switch (IPC_GET_IMETHOD(call)) {
    … …  
    114114}
    115115
    116 static int mousedev_proto_init(mouse_dev_t *mdev)
     116static errno_t mousedev_proto_init(mouse_dev_t *mdev)
    117117{
    118118        async_sess_t *sess = loc_service_connect(mdev->svc_id, INTERFACE_DDF, 0);
    … …  
    141141       
    142142        port_id_t port;
    143         int rc = async_create_callback_port(exch, INTERFACE_MOUSE_CB, 0, 0,
     143        errno_t rc = async_create_callback_port(exch, INTERFACE_MOUSE_CB, 0, 0,
    144144            mousedev_callback_conn, mousedev, &port);
    145145       

  • uspace/srv/hid/isdv4_tablet/isdv4.c

    r132ab5d1 r5a6cc679  
    294294}
    295295
    296 static int read_packets(isdv4_state_t *state, packet_consumer_fn consumer)
     296static errno_t read_packets(isdv4_state_t *state, packet_consumer_fn consumer)
    297297{
    298298        bool reading = true;
    299299        while (reading) {
    300300                size_t nread;
    301                 int rc;
     301                errno_t rc;
    302302
    303303                rc = chardev_read(state->chardev, state->buf + state->buf_end,
    … …  
    363363static bool write_command(chardev_t *chardev, uint8_t command)
    364364{
    365         int rc;
     365        errno_t rc;
    366366        size_t nwr;
    367367
    … …  
    370370}
    371371
    372 int isdv4_init(isdv4_state_t *state, async_sess_t *sess,
     372errno_t isdv4_init(isdv4_state_t *state, async_sess_t *sess,
    373373    isdv4_event_fn event_fn)
    374374{
    375375        chardev_t *chardev;
    376         int rc;
     376        errno_t rc;
    377377
    378378        rc = chardev_open(sess, &chardev);
    … …  
    396396}
    397397
    398 int isdv4_init_tablet(isdv4_state_t *state)
     398errno_t isdv4_init_tablet(isdv4_state_t *state)
    399399{
    400400        if (!write_command(state->chardev, CMD_STOP))
    … …  
    407407                return EIO;
    408408
    409         int rc = read_packets(state, parse_response_stylus);
     409        errno_t rc = read_packets(state, parse_response_stylus);
    410410        if (rc != EOK)
    411411                return rc;
    … …  
    424424}
    425425
    426 int isdv4_read_events(isdv4_state_t *state)
     426errno_t isdv4_read_events(isdv4_state_t *state)
    427427{
    428428        return read_packets(state, parse_event);

  • uspace/srv/hid/isdv4_tablet/isdv4.h

    r132ab5d1 r5a6cc679  
    9090};
    9191
    92 extern int isdv4_init(isdv4_state_t *, async_sess_t *, isdv4_event_fn);
    93 extern int isdv4_init_tablet(isdv4_state_t *);
    94 extern int isdv4_read_events(isdv4_state_t *state);
     92extern errno_t isdv4_init(isdv4_state_t *, async_sess_t *, isdv4_event_fn);
     93extern errno_t isdv4_init_tablet(isdv4_state_t *);
     94extern errno_t isdv4_read_events(isdv4_state_t *state);
    9595extern void isdv4_fini(isdv4_state_t *);
    9696

  • uspace/srv/hid/isdv4_tablet/main.c

    r132ab5d1 r5a6cc679  
    5050}
    5151
    52 static int read_fibril(void *unused)
    53 {
    54         int rc = isdv4_read_events(&state);
     52static errno_t read_fibril(void *unused)
     53{
     54        errno_t rc = isdv4_read_events(&state);
    5555        if (rc != EOK) {
    5656                fprintf(stderr, "Failed reading events");
    … …  
    182182
    183183        int arg = 1;
    184         int rc;
     184        errno_t rc;
    185185
    186186        isdv4_event_fn event_fn = emit_event;

  • uspace/srv/hid/output/ctl/serial.c

    r132ab5d1 r5a6cc679  
    6060}
    6161
    62 static int serial_yield(outdev_t *dev)
     62static errno_t serial_yield(outdev_t *dev)
    6363{
    6464        vt100_state_t *state = (vt100_state_t *) dev->data;
    … …  
    6767}
    6868
    69 static int serial_claim(outdev_t *dev)
     69static errno_t serial_claim(outdev_t *dev)
    7070{
    7171        vt100_state_t *state = (vt100_state_t *) dev->data;
    … …  
    122122};
    123123
    124 int serial_init(vt100_putchar_t putchar_fn,
     124errno_t serial_init(vt100_putchar_t putchar_fn,
    125125    vt100_control_puts_t control_puts_fn, vt100_flush_t flush_fn)
    126126{

  • uspace/srv/hid/output/ctl/serial.h

    r132ab5d1 r5a6cc679  
    3636#include "../proto/vt100.h"
    3737
    38 extern int serial_init(vt100_putchar_t, vt100_control_puts_t, vt100_flush_t);
     38extern errno_t serial_init(vt100_putchar_t, vt100_control_puts_t, vt100_flush_t);
    3939
    4040#endif

  • uspace/srv/hid/output/output.c

    r132ab5d1 r5a6cc679  
    8080static void srv_yield(ipc_callid_t iid, ipc_call_t *icall)
    8181{
    82         int ret = EOK;
     82        errno_t ret = EOK;
    8383       
    8484        list_foreach(outdevs, link, outdev_t, dev) {
    8585                assert(dev->ops.yield);
    8686               
    87                 int rc = dev->ops.yield(dev);
     87                errno_t rc = dev->ops.yield(dev);
    8888                if (rc != EOK)
    8989                        ret = rc;
    … …  
    9595static void srv_claim(ipc_callid_t iid, ipc_call_t *icall)
    9696{
    97         int ret = EOK;
     97        errno_t ret = EOK;
    9898       
    9999        list_foreach(outdevs, link, outdev_t, dev) {
    100100                assert(dev->ops.claim);
    101101               
    102                 int rc = dev->ops.claim(dev);
     102                errno_t rc = dev->ops.claim(dev);
    103103                if (rc != EOK)
    104104                        ret = rc;
    … …  
    170170        }
    171171       
    172         int rc = async_share_out_finalize(callid, &frontbuf->data);
     172        errno_t rc = async_share_out_finalize(callid, &frontbuf->data);
    173173        if ((rc != EOK) || (frontbuf->data == AS_MAP_FAILED)) {
    174174                free(frontbuf);
    … …  
    467467        /* Register server */
    468468        async_set_fallback_port_handler(client_connection, NULL);
    469         int rc = loc_server_register(NAME);
     469        errno_t rc = loc_server_register(NAME);
    470470        if (rc != EOK) {
    471471                printf("%s: Unable to register driver\n", NAME);

  • uspace/srv/hid/output/output.h

    r132ab5d1 r5a6cc679  
    4242
    4343typedef struct {
    44         int (* yield)(struct outdev *dev);
    45         int (* claim)(struct outdev *dev);
     44        errno_t (* yield)(struct outdev *dev);
     45        errno_t (* claim)(struct outdev *dev);
    4646       
    4747        void (* get_dimensions)(struct outdev *dev, sysarg_t *cols,

  • uspace/srv/hid/output/port/chardev.c

    r132ab5d1 r5a6cc679  
    9999        service_id_t *svc;
    100100        size_t svcs;
    101         int rc;
     101        errno_t rc;
    102102
    103103        rc = loc_category_get_svcs(serial_cat_id, &svc, &svcs);
    … …  
    157157static void check_for_dev(void)
    158158{
    159         int rc;
     159        errno_t rc;
    160160        bool found;
    161161        service_id_t sid;
    … …  
    205205}
    206206
    207 int chardev_init(void)
     207errno_t chardev_init(void)
    208208{
    209209        if (!config_key_exists("console")) {
    … …  
    224224        }
    225225
    226         int rc = loc_category_get_id("serial", &serial_cat_id, IPC_FLAG_BLOCKING);
     226        errno_t rc = loc_category_get_id("serial", &serial_cat_id, IPC_FLAG_BLOCKING);
    227227        if (rc != EOK) {
    228228                printf("%s: Failed to get \"serial\" category ID.\n", NAME);

  • uspace/srv/hid/output/port/chardev.h

    r132ab5d1 r5a6cc679  
    3333#define OUTPUT_PORT_CHARDEV_H_
    3434
    35 extern int chardev_init(void);
     35extern errno_t chardev_init(void);
    3636
    3737#endif

  • uspace/srv/hid/output/port/ega.c

    r132ab5d1 r5a6cc679  
    117117}
    118118
    119 static int ega_yield(outdev_t *dev)
     119static errno_t ega_yield(outdev_t *dev)
    120120{
    121121        return EOK;
    122122}
    123123
    124 static int ega_claim(outdev_t *dev)
     124static errno_t ega_claim(outdev_t *dev)
    125125{
    126126        return EOK;
    … …  
    183183};
    184184
    185 int ega_init(void)
     185errno_t ega_init(void)
    186186{
    187187        sysarg_t present;
    188         int rc = sysinfo_get_value("fb", &present);
     188        errno_t rc = sysinfo_get_value("fb", &present);
    189189        if (rc != EOK)
    190190                present = false;

  • uspace/srv/hid/output/port/ega.h

    r132ab5d1 r5a6cc679  
    3333#define OUTPUT_PORT_EGA_H_
    3434
    35 extern int ega_init(void);
     35extern errno_t ega_init(void);
    3636
    3737#endif

  • uspace/srv/hid/output/port/kfb.c

    r132ab5d1 r5a6cc679  
    419419}
    420420
    421 static int kfb_yield(fbdev_t *dev)
     421static errno_t kfb_yield(fbdev_t *dev)
    422422{
    423423        if (kfb.backbuf == NULL) {
    … …  
    435435}
    436436
    437 static int kfb_claim(fbdev_t *dev)
     437static errno_t kfb_claim(fbdev_t *dev)
    438438{
    439439        if (kfb.backbuf == NULL)
    … …  
    460460}
    461461
    462 static int kfb_get_resolution(fbdev_t *dev, sysarg_t *width, sysarg_t *height)
     462static errno_t kfb_get_resolution(fbdev_t *dev, sysarg_t *width, sysarg_t *height)
    463463{
    464464        *width = kfb.width;
    … …  
    474474}
    475475
    476 static int kfb_vp_create(fbdev_t *dev, fbvp_t *vp)
     476static errno_t kfb_vp_create(fbdev_t *dev, fbvp_t *vp)
    477477{
    478478        kfb_vp_t *kfb_vp = malloc(sizeof(kfb_vp_t));
    … …  
    620620}
    621621
    622 int kfb_init(void)
     622errno_t kfb_init(void)
    623623{
    624624        sysarg_t present;
    625         int rc = sysinfo_get_value("fb", &present);
     625        errno_t rc = sysinfo_get_value("fb", &present);
    626626        if (rc != EOK)
    627627                present = false;

  • uspace/srv/hid/output/port/kfb.h

    r132ab5d1 r5a6cc679  
    3737#define FB_PORT_KFB_H_
    3838
    39 extern int kfb_init(void);
     39extern errno_t kfb_init(void);
    4040
    4141#endif

  • uspace/srv/hid/output/proto/vt100.c

    r132ab5d1 r5a6cc679  
    181181}
    182182
    183 int vt100_yield(vt100_state_t *state)
     183errno_t vt100_yield(vt100_state_t *state)
    184184{
    185185        return EOK;
    186186}
    187187
    188 int vt100_claim(vt100_state_t *state)
     188errno_t vt100_claim(vt100_state_t *state)
    189189{
    190190        return EOK;

  • uspace/srv/hid/output/proto/vt100.h

    r132ab5d1 r5a6cc679  
    5656extern void vt100_state_destroy(vt100_state_t *);
    5757
    58 extern int vt100_yield(vt100_state_t *);
    59 extern int vt100_claim(vt100_state_t *);
     58extern errno_t vt100_yield(vt100_state_t *);
     59extern errno_t vt100_claim(vt100_state_t *);
    6060extern void vt100_get_dimensions(vt100_state_t *, sysarg_t *, sysarg_t *);
    6161

  • uspace/srv/hid/remcons/remcons.c

    r132ab5d1 r5a6cc679  
    7070    sizeof(telnet_force_character_mode_command) / sizeof(telnet_cmd_t);
    7171
    72 static int remcons_open(con_srvs_t *, con_srv_t *);
    73 static int remcons_close(con_srv_t *);
    74 static int remcons_write(con_srv_t *, void *, size_t, size_t *);
     72static errno_t remcons_open(con_srvs_t *, con_srv_t *);
     73static errno_t remcons_close(con_srv_t *);
     74static errno_t remcons_write(con_srv_t *, void *, size_t, size_t *);
    7575static void remcons_sync(con_srv_t *);
    7676static void remcons_clear(con_srv_t *);
    7777static void remcons_set_pos(con_srv_t *, sysarg_t col, sysarg_t row);
    78 static int remcons_get_pos(con_srv_t *, sysarg_t *, sysarg_t *);
    79 static int remcons_get_size(con_srv_t *, sysarg_t *, sysarg_t *);
    80 static int remcons_get_color_cap(con_srv_t *, console_caps_t *);
    81 static int remcons_get_event(con_srv_t *, cons_event_t *);
     78static errno_t remcons_get_pos(con_srv_t *, sysarg_t *, sysarg_t *);
     79static errno_t remcons_get_size(con_srv_t *, sysarg_t *, sysarg_t *);
     80static errno_t remcons_get_color_cap(con_srv_t *, console_caps_t *);
     81static errno_t remcons_get_event(con_srv_t *, cons_event_t *);
    8282
    8383static con_ops_t con_ops = {
    … …  
    114114}
    115115
    116 static int remcons_open(con_srvs_t *srvs, con_srv_t *srv)
     116static errno_t remcons_open(con_srvs_t *srvs, con_srv_t *srv)
    117117{
    118118        telnet_user_t *user = srv_to_user(srv);
    … …  
    127127}
    128128
    129 static int remcons_close(con_srv_t *srv)
     129static errno_t remcons_close(con_srv_t *srv)
    130130{
    131131        telnet_user_t *user = srv_to_user(srv);
    … …  
    137137}
    138138
    139 static int remcons_write(con_srv_t *srv, void *data, size_t size, size_t *nwritten)
    140 {
    141         telnet_user_t *user = srv_to_user(srv);
    142         int rc;
     139static errno_t remcons_write(con_srv_t *srv, void *data, size_t size, size_t *nwritten)
     140{
     141        telnet_user_t *user = srv_to_user(srv);
     142        errno_t rc;
    143143
    144144        rc = telnet_user_send_data(user, data, size);
    … …  
    167167}
    168168
    169 static int remcons_get_pos(con_srv_t *srv, sysarg_t *col, sysarg_t *row)
     169static errno_t remcons_get_pos(con_srv_t *srv, sysarg_t *col, sysarg_t *row)
    170170{
    171171        telnet_user_t *user = srv_to_user(srv);
    … …  
    177177}
    178178
    179 static int remcons_get_size(con_srv_t *srv, sysarg_t *cols, sysarg_t *rows)
     179static errno_t remcons_get_size(con_srv_t *srv, sysarg_t *cols, sysarg_t *rows)
    180180{
    181181        (void) srv;
    … …  
    187187}
    188188
    189 static int remcons_get_color_cap(con_srv_t *srv, console_caps_t *ccaps)
     189static errno_t remcons_get_color_cap(con_srv_t *srv, console_caps_t *ccaps)
    190190{
    191191        (void) srv;
    … …  
    195195}
    196196
    197 static int remcons_get_event(con_srv_t *srv, cons_event_t *event)
     197static errno_t remcons_get_event(con_srv_t *srv, cons_event_t *event)
    198198{
    199199        telnet_user_t *user = srv_to_user(srv);
    200200        kbd_event_t kevent;
    201         int rc;
     201        errno_t rc;
    202202
    203203        rc = telnet_user_get_next_keyboard_event(user, &kevent);
    … …  
    232232 * @param arg Corresponding @c telnet_user_t structure.
    233233 */
    234 static int spawn_task_fibril(void *arg)
     234static errno_t spawn_task_fibril(void *arg)
    235235{
    236236        telnet_user_t *user = arg;
    … …  
    238238        task_id_t task;
    239239        task_wait_t wait;
    240         int rc = task_spawnl(&task, &wait, APP_GETTERM, APP_GETTERM, user->service_name,
     240        errno_t rc = task_spawnl(&task, &wait, APP_GETTERM, APP_GETTERM, user->service_name,
    241241            "/loc", "--msg", "--", APP_SHELL, NULL);
    242242        if (rc != EOK) {
    … …  
    300300        telnet_user_add(user);
    301301
    302         int rc = loc_service_register(user->service_name, &user->service_id);
     302        errno_t rc = loc_service_register(user->service_name, &user->service_id);
    303303        if (rc != EOK) {
    304304                telnet_user_error(user, "Unable to register %s with loc: %s.",
    … …  
    344344int main(int argc, char *argv[])
    345345{
    346         int rc;
     346        errno_t rc;
    347347        tcp_listener_t *lst;
    348348        tcp_t *tcp;

  • uspace/srv/hid/remcons/user.c

    r132ab5d1 r5a6cc679  
    187187 * might be negative.
    188188 */
    189 static int telnet_user_recv_next_byte_no_lock(telnet_user_t *user, char *byte)
     189static errno_t telnet_user_recv_next_byte_no_lock(telnet_user_t *user, char *byte)
    190190{
    191191        /* No more buffered data? */
    192192        if (user->socket_buffer_len <= user->socket_buffer_pos) {
    193                 int rc;
     193                errno_t rc;
    194194                size_t recv_length;
    195195
    … …  
    272272 * @return Error code.
    273273 */
    274 int telnet_user_get_next_keyboard_event(telnet_user_t *user, kbd_event_t *event)
     274errno_t telnet_user_get_next_keyboard_event(telnet_user_t *user, kbd_event_t *event)
    275275{
    276276        fibril_mutex_lock(&user->guard);
    … …  
    283283                /* Skip zeros, bail-out on error. */
    284284                while (next_byte == 0) {
    285                         int rc = telnet_user_recv_next_byte_no_lock(user, &next_byte);
     285                        errno_t rc = telnet_user_recv_next_byte_no_lock(user, &next_byte);
    286286                        if (rc != EOK) {
    287287                                fibril_mutex_unlock(&user->guard);
    … …  
    339339 * @param size Size of @p data buffer in bytes.
    340340 */
    341 static int telnet_user_send_data_no_lock(telnet_user_t *user, uint8_t *data, size_t size)
     341static errno_t telnet_user_send_data_no_lock(telnet_user_t *user, uint8_t *data, size_t size)
    342342{
    343343        uint8_t *converted = malloc(3 * size + 1);
    … …  
    362362
    363363
    364         int rc = tcp_conn_send(user->conn, converted, converted_size);
     364        errno_t rc = tcp_conn_send(user->conn, converted, converted_size);
    365365        free(converted);
    366366
    … …  
    374374 * @param size Size of @p data buffer in bytes.
    375375 */
    376 int telnet_user_send_data(telnet_user_t *user, uint8_t *data, size_t size)
     376errno_t telnet_user_send_data(telnet_user_t *user, uint8_t *data, size_t size)
    377377{
    378378        fibril_mutex_lock(&user->guard);
    379379
    380         int rc = telnet_user_send_data_no_lock(user, data, size);
     380        errno_t rc = telnet_user_send_data_no_lock(user, data, size);
    381381
    382382        fibril_mutex_unlock(&user->guard);

  • uspace/srv/hid/remcons/user.h

    r132ab5d1 r5a6cc679  
    8787extern bool telnet_user_is_zombie(telnet_user_t *);
    8888extern void telnet_user_notify_client_disconnected(telnet_user_t *);
    89 extern int telnet_user_get_next_keyboard_event(telnet_user_t *, kbd_event_t *);
    90 extern int telnet_user_send_data(telnet_user_t *, uint8_t *, size_t);
     89extern errno_t telnet_user_get_next_keyboard_event(telnet_user_t *, kbd_event_t *);
     90extern errno_t telnet_user_send_data(telnet_user_t *, uint8_t *, size_t);
    9191extern void telnet_user_update_cursor_x(telnet_user_t *, int);
    9292

  • uspace/srv/hid/rfb/main.c

    r132ab5d1 r5a6cc679  
    5252static rfb_t rfb;
    5353
    54 static int rfb_claim(visualizer_t *vs)
    55 {
    56         return EOK;
    57 }
    58 
    59 static int rfb_yield(visualizer_t *vs)
    60 {
    61         return EOK;
    62 }
    63 
    64 static int rfb_suspend(visualizer_t *vs)
    65 {
    66         return EOK;
    67 }
    68 
    69 static int rfb_wakeup(visualizer_t *vs)
    70 {
    71         return EOK;
    72 }
    73 
    74 static int rfb_handle_damage_pixels(visualizer_t *vs,
     54static errno_t rfb_claim(visualizer_t *vs)
     55{
     56        return EOK;
     57}
     58
     59static errno_t rfb_yield(visualizer_t *vs)
     60{
     61        return EOK;
     62}
     63
     64static errno_t rfb_suspend(visualizer_t *vs)
     65{
     66        return EOK;
     67}
     68
     69static errno_t rfb_wakeup(visualizer_t *vs)
     70{
     71        return EOK;
     72}
     73
     74static errno_t rfb_handle_damage_pixels(visualizer_t *vs,
    7575    sysarg_t x0, sysarg_t y0, sysarg_t width, sysarg_t height,
    7676    sysarg_t x_offset, sysarg_t y_offset)
    … …  
    126126}
    127127
    128 static int rfb_change_mode(visualizer_t *vs, vslmode_t new_mode)
     128static errno_t rfb_change_mode(visualizer_t *vs, vslmode_t new_mode)
    129129{
    130130        return EOK;
    … …  
    217217        async_set_fallback_port_handler(client_connection, NULL);
    218218
    219         int rc = loc_server_register(NAME);
     219        errno_t rc = loc_server_register(NAME);
    220220        if (rc != EOK) {
    221221                printf("%s: Unable to register server.\n", NAME);

  • uspace/srv/hid/rfb/rfb.c

    r132ab5d1 r5a6cc679  
    6262
    6363/** Receive one character (with buffering) */
    64 static int recv_char(tcp_conn_t *conn, char *c)
     64static errno_t recv_char(tcp_conn_t *conn, char *c)
    6565{
    6666        size_t nrecv;
    67         int rc;
     67        errno_t rc;
    6868
    6969        if (rbuf_out == rbuf_in) {
    … …  
    8383
    8484/** Receive count characters (with buffering) */
    85 static int recv_chars(tcp_conn_t *conn, char *c, size_t count)
     85static errno_t recv_chars(tcp_conn_t *conn, char *c, size_t count)
    8686{
    8787        for (size_t i = 0; i < count; i++) {
    88                 int rc = recv_char(conn, c);
     88                errno_t rc = recv_char(conn, c);
    8989                if (rc != EOK)
    9090                        return rc;
    … …  
    9494}
    9595
    96 static int recv_skip_chars(tcp_conn_t *conn, size_t count)
     96static errno_t recv_skip_chars(tcp_conn_t *conn, size_t count)
    9797{
    9898        for (size_t i = 0; i < count; i++) {
    9999                char c;
    100                 int rc = recv_char(conn, &c);
     100                errno_t rc = recv_char(conn, &c);
    101101                if (rc != EOK)
    102102                        return rc;
    … …  
    173173}
    174174
    175 int rfb_init(rfb_t *rfb, uint16_t width, uint16_t height, const char *name)
     175errno_t rfb_init(rfb_t *rfb, uint16_t width, uint16_t height, const char *name)
    176176{
    177177        memset(rfb, 0, sizeof(rfb_t));
    … …  
    196196}
    197197
    198 int rfb_set_size(rfb_t *rfb, uint16_t width, uint16_t height)
     198errno_t rfb_set_size(rfb_t *rfb, uint16_t width, uint16_t height)
    199199{
    200200        size_t new_size = width * height * sizeof(pixel_t);
    … …  
    216216}
    217217
    218 static int recv_message(tcp_conn_t *conn, char type, void *buf, size_t size)
     218static errno_t recv_message(tcp_conn_t *conn, char type, void *buf, size_t size)
    219219{
    220220        memcpy(buf, &type, 1);
    … …  
    435435}
    436436
    437 static int rfb_tile_encode_solid(rfb_t *rfb, cpixel_ctx_t *cpixel,
     437static errno_t rfb_tile_encode_solid(rfb_t *rfb, cpixel_ctx_t *cpixel,
    438438    rfb_rectangle_t *tile, void *buf, size_t *size)
    439439{
    … …  
    476476                        uint8_t tile_enctype = RFB_TILE_ENCODING_SOLID;
    477477                        size_t tile_size;
    478                         int rc = rfb_tile_encode_solid(rfb, &cpixel, &tile, buf,
     478                        errno_t rc = rfb_tile_encode_solid(rfb, &cpixel, &tile, buf,
    479479                            &tile_size);
    480480                        if (rc != EOK) {
    … …  
    492492}
    493493
    494 static int rfb_send_framebuffer_update(rfb_t *rfb, tcp_conn_t *conn,
     494static errno_t rfb_send_framebuffer_update(rfb_t *rfb, tcp_conn_t *conn,
    495495    bool incremental)
    496496{
    … …  
    556556       
    557557        if (!rfb->pixel_format.true_color) {
    558                 int rc = tcp_conn_send(conn, send_palette, send_palette_size);
     558                errno_t rc = tcp_conn_send(conn, send_palette, send_palette_size);
    559559                if (rc != EOK) {
    560560                        free(buf);
    … …  
    563563        }
    564564       
    565         int rc = tcp_conn_send(conn, buf, buf_size);
     565        errno_t rc = tcp_conn_send(conn, buf, buf_size);
    566566        free(buf);
    567567       
    … …  
    569569}
    570570
    571 static int rfb_set_pixel_format(rfb_t *rfb, rfb_pixel_format_t *pixel_format)
     571static errno_t rfb_set_pixel_format(rfb_t *rfb, rfb_pixel_format_t *pixel_format)
    572572{
    573573        rfb->pixel_format = *pixel_format;
    … …  
    599599{
    600600        /* Version handshake */
    601         int rc = tcp_conn_send(conn, "RFB 003.008\n", 12);
     601        errno_t rc = tcp_conn_send(conn, "RFB 003.008\n", 12);
    602602        if (rc != EOK) {
    603603                log_msg(LOG_DEFAULT, LVL_WARN, "Failed sending server version: %s",
    … …  
    759759}
    760760
    761 int rfb_listen(rfb_t *rfb, uint16_t port)
     761errno_t rfb_listen(rfb_t *rfb, uint16_t port)
    762762{
    763763        tcp_t *tcp = NULL;
    764764        tcp_listener_t *lst = NULL;
    765765        inet_ep_t ep;
    766         int rc;
     766        errno_t rc;
    767767       
    768768        rc = tcp_create(&tcp);

  • uspace/srv/hid/rfb/rfb.h

    r132ab5d1 r5a6cc679  
    164164
    165165
    166 extern int rfb_init(rfb_t *, uint16_t, uint16_t, const char *);
    167 extern int rfb_set_size(rfb_t *, uint16_t, uint16_t);
    168 extern int rfb_listen(rfb_t *, uint16_t);
     166extern errno_t rfb_init(rfb_t *, uint16_t, uint16_t, const char *);
     167extern errno_t rfb_set_size(rfb_t *, uint16_t, uint16_t);
     168extern errno_t rfb_listen(rfb_t *, uint16_t);
    169169
    170170#endif

  • uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.c

    r132ab5d1 r5a6cc679  
    8585       
    8686        async_set_fallback_port_handler(s3c24xx_ts_connection, NULL);
    87         int rc = loc_server_register(NAME);
     87        errno_t rc = loc_server_register(NAME);
    8888        if (rc != EOK) {
    8989                printf("%s: Unable to register driver.\n", NAME);
Note: See TracChangeset for help on using the changeset viewer.