Changeset a46e56b in mainline for uspace/lib/c/generic/io


Ignore:
Timestamp:
2018-03-22T06:49:35Z (7 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
77f0a1d
Parents:
3e242d2
git-author:
Jakub Jermar <jakub@…> (2018-03-21 23:29:06)
git-committer:
Jakub Jermar <jakub@…> (2018-03-22 06:49:35)
Message:

Prefer handle over ID in naming handle variables

Location:
uspace/lib/c/generic/io
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/io/chardev_srv.c

    r3e242d2 ra46e56b  
    4343static chardev_srv_t *chardev_srv_create(chardev_srvs_t *);
    4444
    45 static void chardev_read_srv(chardev_srv_t *srv, cap_call_handle_t callid,
     45static void chardev_read_srv(chardev_srv_t *srv, cap_call_handle_t chandle,
    4646    ipc_call_t *call)
    4747{
    … …  
    5050        size_t nread;
    5151        errno_t rc;
    52         cap_call_handle_t rcallid;
     52        cap_call_handle_t rcall_handle;
    5353
    54         if (!async_data_read_receive(&rcallid, &size)) {
    55                 async_answer_0(callid, EINVAL);
     54        if (!async_data_read_receive(&rcall_handle, &size)) {
     55                async_answer_0(chandle, EINVAL);
    5656                return;
    5757        }
    … …  
    5959        buf = malloc(size);
    6060        if (buf == NULL) {
    61                 async_answer_0(rcallid, ENOMEM);
    62                 async_answer_0(callid, ENOMEM);
     61                async_answer_0(rcall_handle, ENOMEM);
     62                async_answer_0(chandle, ENOMEM);
    6363                return;
    6464        }
    6565
    6666        if (srv->srvs->ops->read == NULL) {
    67                 async_answer_0(rcallid, ENOTSUP);
    68                 async_answer_0(callid, ENOTSUP);
     67                async_answer_0(rcall_handle, ENOTSUP);
     68                async_answer_0(chandle, ENOTSUP);
    6969                free(buf);
    7070                return;
    … …  
    7373        rc = srv->srvs->ops->read(srv, buf, size, &nread);
    7474        if (rc != EOK && nread == 0) {
    75                 async_answer_0(rcallid, rc);
    76                 async_answer_0(callid, rc);
     75                async_answer_0(rcall_handle, rc);
     76                async_answer_0(chandle, rc);
    7777                free(buf);
    7878                return;
    7979        }
    8080
    81         async_data_read_finalize(rcallid, buf, nread);
     81        async_data_read_finalize(rcall_handle, buf, nread);
    8282
    8383        free(buf);
    84         async_answer_2(callid, EOK, (sysarg_t) rc, nread);
     84        async_answer_2(chandle, EOK, (sysarg_t) rc, nread);
    8585}
    8686
    87 static void chardev_write_srv(chardev_srv_t *srv, cap_call_handle_t callid,
     87static void chardev_write_srv(chardev_srv_t *srv, cap_call_handle_t chandle,
    8888    ipc_call_t *call)
    8989{
    … …  
    9595        rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
    9696        if (rc != EOK) {
    97                 async_answer_0(callid, rc);
     97                async_answer_0(chandle, rc);
    9898                return;
    9999        }
    100100
    101101        if (srv->srvs->ops->write == NULL) {
    102                 async_answer_0(callid, ENOTSUP);
     102                async_answer_0(chandle, ENOTSUP);
    103103                return;
    104104        }
    … …  
    107107        free(data);
    108108        if (rc != EOK && nwr == 0) {
    109                 async_answer_0(callid, rc);
     109                async_answer_0(chandle, rc);
    110110                return;
    111111        }
    112112
    113         async_answer_2(callid, EOK, (sysarg_t) rc, nwr);
     113        async_answer_2(chandle, EOK, (sysarg_t) rc, nwr);
    114114}
    115115
    … …  
    132132}
    133133
    134 errno_t chardev_conn(cap_call_handle_t iid, ipc_call_t *icall, chardev_srvs_t *srvs)
     134errno_t chardev_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, chardev_srvs_t *srvs)
    135135{
    136136        chardev_srv_t *srv;
    … …  
    138138
    139139        /* Accept the connection */
    140         async_answer_0(iid, EOK);
     140        async_answer_0(icall_handle, EOK);
    141141
    142142        srv = chardev_srv_create(srvs);
    … …  
    152152        while (true) {
    153153                ipc_call_t call;
    154                 cap_call_handle_t callid = async_get_call(&call);
     154                cap_call_handle_t chandle = async_get_call(&call);
    155155                sysarg_t method = IPC_GET_IMETHOD(call);
    156156
    157157                if (!method) {
    158158                        /* The other side has hung up */
    159                         async_answer_0(callid, EOK);
     159                        async_answer_0(chandle, EOK);
    160160                        break;
    161161                }
    … …  
    163163                switch (method) {
    164164                case CHARDEV_READ:
    165                         chardev_read_srv(srv, callid, &call);
     165                        chardev_read_srv(srv, chandle, &call);
    166166                        break;
    167167                case CHARDEV_WRITE:
    168                         chardev_write_srv(srv, callid, &call);
     168                        chardev_write_srv(srv, chandle, &call);
    169169                        break;
    170170                default:
    171171                        if (srv->srvs->ops->def_handler != NULL)
    172                                 srv->srvs->ops->def_handler(srv, callid, &call);
     172                                srv->srvs->ops->def_handler(srv, chandle, &call);
    173173                        else
    174                                 async_answer_0(callid, ENOTSUP);
     174                                async_answer_0(chandle, ENOTSUP);
    175175                }
    176176        }

  • uspace/lib/c/generic/io/con_srv.c

    r3e242d2 ra46e56b  
    6666}
    6767
    68 static void con_read_srv(con_srv_t *srv, cap_call_handle_t callid,
     68static void con_read_srv(con_srv_t *srv, cap_call_handle_t chandle,
    6969    ipc_call_t *call)
    7070{
    … …  
    7272        size_t size;
    7373        errno_t rc;
    74         cap_call_handle_t rcallid;
    75 
    76         if (!async_data_read_receive(&rcallid, &size)) {
    77                 async_answer_0(callid, EINVAL);
     74        cap_call_handle_t rcall_handle;
     75
     76        if (!async_data_read_receive(&rcall_handle, &size)) {
     77                async_answer_0(chandle, EINVAL);
    7878                return;
    7979        }
    … …  
    8181        buf = malloc(size);
    8282        if (buf == NULL) {
    83                 async_answer_0(rcallid, ENOMEM);
    84                 async_answer_0(callid, ENOMEM);
     83                async_answer_0(rcall_handle, ENOMEM);
     84                async_answer_0(chandle, ENOMEM);
    8585                return;
    8686        }
    8787
    8888        if (srv->srvs->ops->read == NULL) {
    89                 async_answer_0(rcallid, ENOTSUP);
    90                 async_answer_0(callid, ENOTSUP);
     89                async_answer_0(rcall_handle, ENOTSUP);
     90                async_answer_0(chandle, ENOTSUP);
    9191                free(buf);
    9292                return;
    … …  
    9696        rc = srv->srvs->ops->read(srv, buf, size, &nread);
    9797        if (rc != EOK) {
    98                 async_answer_0(rcallid, rc);
    99                 async_answer_0(callid, rc);
     98                async_answer_0(rcall_handle, rc);
     99                async_answer_0(chandle, rc);
    100100                free(buf);
    101101                return;
    102102        }
    103103
    104         async_data_read_finalize(rcallid, buf, nread);
     104        async_data_read_finalize(rcall_handle, buf, nread);
    105105        free(buf);
    106106
    107         async_answer_1(callid, EOK, nread);
    108 }
    109 
    110 static void con_write_srv(con_srv_t *srv, cap_call_handle_t callid,
     107        async_answer_1(chandle, EOK, nread);
     108}
     109
     110static void con_write_srv(con_srv_t *srv, cap_call_handle_t chandle,
    111111    ipc_call_t *call)
    112112{
    … …  
    117117        rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
    118118        if (rc != EOK) {
    119                 async_answer_0(callid, rc);
     119                async_answer_0(chandle, rc);
    120120                return;
    121121        }
    122122
    123123        if (srv->srvs->ops->write == NULL) {
    124                 async_answer_0(callid, ENOTSUP);
     124                async_answer_0(chandle, ENOTSUP);
    125125                return;
    126126        }
    … …  
    130130        free(data);
    131131
    132         async_answer_1(callid, rc, nwritten);
    133 }
    134 
    135 static void con_sync_srv(con_srv_t *srv, cap_call_handle_t callid,
     132        async_answer_1(chandle, rc, nwritten);
     133}
     134
     135static void con_sync_srv(con_srv_t *srv, cap_call_handle_t chandle,
    136136    ipc_call_t *call)
    137137{
    138138        if (srv->srvs->ops->sync == NULL) {
    139                 async_answer_0(callid, ENOTSUP);
     139                async_answer_0(chandle, ENOTSUP);
    140140                return;
    141141        }
    142142
    143143        srv->srvs->ops->sync(srv);
    144         async_answer_0(callid, EOK);
    145 }
    146 
    147 static void con_clear_srv(con_srv_t *srv, cap_call_handle_t callid,
     144        async_answer_0(chandle, EOK);
     145}
     146
     147static void con_clear_srv(con_srv_t *srv, cap_call_handle_t chandle,
    148148    ipc_call_t *call)
    149149{
    150150        if (srv->srvs->ops->clear == NULL) {
    151                 async_answer_0(callid, ENOTSUP);
     151                async_answer_0(chandle, ENOTSUP);
    152152                return;
    153153        }
    154154
    155155        srv->srvs->ops->clear(srv);
    156         async_answer_0(callid, EOK);
    157 }
    158 
    159 static void con_set_pos_srv(con_srv_t *srv, cap_call_handle_t callid,
     156        async_answer_0(chandle, EOK);
     157}
     158
     159static void con_set_pos_srv(con_srv_t *srv, cap_call_handle_t chandle,
    160160    ipc_call_t *call)
    161161{
    … …  
    167167
    168168        if (srv->srvs->ops->set_pos == NULL) {
    169                 async_answer_0(callid, ENOTSUP);
     169                async_answer_0(chandle, ENOTSUP);
    170170                return;
    171171        }
    172172
    173173        srv->srvs->ops->set_pos(srv, col, row);
    174         async_answer_0(callid, EOK);
    175 }
    176 
    177 static void con_get_pos_srv(con_srv_t *srv, cap_call_handle_t callid,
     174        async_answer_0(chandle, EOK);
     175}
     176
     177static void con_get_pos_srv(con_srv_t *srv, cap_call_handle_t chandle,
    178178    ipc_call_t *call)
    179179{
    … …  
    183183
    184184        if (srv->srvs->ops->get_pos == NULL) {
    185                 async_answer_0(callid, ENOTSUP);
     185                async_answer_0(chandle, ENOTSUP);
    186186                return;
    187187        }
    188188
    189189        rc = srv->srvs->ops->get_pos(srv, &col, &row);
    190         async_answer_2(callid, rc, col, row);
    191 }
    192 
    193 static void con_get_size_srv(con_srv_t *srv, cap_call_handle_t callid,
     190        async_answer_2(chandle, rc, col, row);
     191}
     192
     193static void con_get_size_srv(con_srv_t *srv, cap_call_handle_t chandle,
    194194    ipc_call_t *call)
    195195{
    … …  
    199199
    200200        if (srv->srvs->ops->get_size == NULL) {
    201                 async_answer_0(callid, ENOTSUP);
     201                async_answer_0(chandle, ENOTSUP);
    202202                return;
    203203        }
    204204
    205205        rc = srv->srvs->ops->get_size(srv, &cols, &rows);
    206         async_answer_2(callid, rc, cols, rows);
    207 }
    208 
    209 static void con_get_color_cap_srv(con_srv_t *srv, cap_call_handle_t callid,
     206        async_answer_2(chandle, rc, cols, rows);
     207}
     208
     209static void con_get_color_cap_srv(con_srv_t *srv, cap_call_handle_t chandle,
    210210    ipc_call_t *call)
    211211{
    … …  
    214214
    215215        if (srv->srvs->ops->get_color_cap == NULL) {
    216                 async_answer_0(callid, ENOTSUP);
     216                async_answer_0(chandle, ENOTSUP);
    217217                return;
    218218        }
    219219
    220220        rc = srv->srvs->ops->get_color_cap(srv, &ccap);
    221         async_answer_1(callid, rc, (sysarg_t)ccap);
    222 }
    223 
    224 static void con_set_style_srv(con_srv_t *srv, cap_call_handle_t callid,
     221        async_answer_1(chandle, rc, (sysarg_t)ccap);
     222}
     223
     224static void con_set_style_srv(con_srv_t *srv, cap_call_handle_t chandle,
    225225    ipc_call_t *call)
    226226{
    … …  
    230230
    231231        if (srv->srvs->ops->set_style == NULL) {
    232                 async_answer_0(callid, ENOTSUP);
     232                async_answer_0(chandle, ENOTSUP);
    233233                return;
    234234        }
    235235
    236236        srv->srvs->ops->set_style(srv, style);
    237         async_answer_0(callid, EOK);
    238 }
    239 
    240 static void con_set_color_srv(con_srv_t *srv, cap_call_handle_t callid,
     237        async_answer_0(chandle, EOK);
     238}
     239
     240static void con_set_color_srv(con_srv_t *srv, cap_call_handle_t chandle,
    241241    ipc_call_t *call)
    242242{
    … …  
    250250
    251251        if (srv->srvs->ops->set_color == NULL) {
    252                 async_answer_0(callid, ENOTSUP);
     252                async_answer_0(chandle, ENOTSUP);
    253253                return;
    254254        }
    255255
    256256        srv->srvs->ops->set_color(srv, bgcolor, fgcolor, flags);
    257         async_answer_0(callid, EOK);
    258 }
    259 
    260 static void con_set_rgb_color_srv(con_srv_t *srv, cap_call_handle_t callid,
     257        async_answer_0(chandle, EOK);
     258}
     259
     260static void con_set_rgb_color_srv(con_srv_t *srv, cap_call_handle_t chandle,
    261261    ipc_call_t *call)
    262262{
    … …  
    268268
    269269        if (srv->srvs->ops->set_rgb_color == NULL) {
    270                 async_answer_0(callid, ENOTSUP);
     270                async_answer_0(chandle, ENOTSUP);
    271271                return;
    272272        }
    273273
    274274        srv->srvs->ops->set_rgb_color(srv, bgcolor, fgcolor);
    275         async_answer_0(callid, EOK);
    276 }
    277 
    278 static void con_set_cursor_visibility_srv(con_srv_t *srv, cap_call_handle_t callid,
     275        async_answer_0(chandle, EOK);
     276}
     277
     278static void con_set_cursor_visibility_srv(con_srv_t *srv, cap_call_handle_t chandle,
    279279    ipc_call_t *call)
    280280{
    … …  
    284284
    285285        if (srv->srvs->ops->set_cursor_visibility == NULL) {
    286                 async_answer_0(callid, ENOTSUP);
     286                async_answer_0(chandle, ENOTSUP);
    287287                return;
    288288        }
    289289
    290290        srv->srvs->ops->set_cursor_visibility(srv, show);
    291         async_answer_0(callid, EOK);
    292 }
    293 
    294 static void con_get_event_srv(con_srv_t *srv, cap_call_handle_t callid,
     291        async_answer_0(chandle, EOK);
     292}
     293
     294static void con_get_event_srv(con_srv_t *srv, cap_call_handle_t chandle,
    295295    ipc_call_t *call)
    296296{
    … …  
    300300
    301301        if (srv->srvs->ops->get_event == NULL) {
    302                 async_answer_0(callid, ENOTSUP);
     302                async_answer_0(chandle, ENOTSUP);
    303303                return;
    304304        }
    … …  
    306306        rc = srv->srvs->ops->get_event(srv, &event);
    307307        if (rc != EOK) {
    308                 async_answer_0(callid, rc);
     308                async_answer_0(chandle, rc);
    309309                return;
    310310        }
    … …  
    312312        rc = console_ev_encode(&event, &result);
    313313        if (rc != EOK) {
    314                 async_answer_0(callid, rc);
    315                 return;
    316         }
    317 
    318         async_answer_5(callid, rc, IPC_GET_ARG1(result), IPC_GET_ARG2(result),
     314                async_answer_0(chandle, rc);
     315                return;
     316        }
     317
     318        async_answer_5(chandle, rc, IPC_GET_ARG1(result), IPC_GET_ARG2(result),
    319319            IPC_GET_ARG3(result), IPC_GET_ARG4(result), IPC_GET_ARG5(result));
    320320}
    … …  
    340340}
    341341
    342 errno_t con_conn(cap_call_handle_t iid, ipc_call_t *icall, con_srvs_t *srvs)
     342errno_t con_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, con_srvs_t *srvs)
    343343{
    344344        con_srv_t *srv;
    … …  
    346346
    347347        /* Accept the connection */
    348         async_answer_0(iid, EOK);
     348        async_answer_0(icall_handle, EOK);
    349349
    350350        srv = con_srv_create(srvs);
    … …  
    366366        while (true) {
    367367                ipc_call_t call;
    368                 cap_call_handle_t callid = 0;
    369 
    370                 while (callid == 0) {
     368                cap_call_handle_t chandle = 0;
     369
     370                while (chandle == 0) {
    371371                        /* XXX Need to be able to abort immediately */
    372                         callid = async_get_call_timeout(&call,
     372                        chandle = async_get_call_timeout(&call,
    373373                            srvs->abort_timeout);
    374374
    375375                        if (srv->srvs->aborted) {
    376                                 if (callid != 0)
    377                                         async_answer_0(callid, EINTR);
     376                                if (chandle != 0)
     377                                        async_answer_0(chandle, EINTR);
    378378                                break;
    379379                        }
    380380                }
    381381
    382                 if (callid == 0)
     382                if (chandle == 0)
    383383                        break;
    384384
    … …  
    387387                if (!method) {
    388388                        /* The other side has hung up */
    389                         async_answer_0(callid, EOK);
     389                        async_answer_0(chandle, EOK);
    390390                        break;
    391391                }
    … …  
    393393                switch (method) {
    394394                case VFS_OUT_READ:
    395                         con_read_srv(srv, callid, &call);
     395                        con_read_srv(srv, chandle, &call);
    396396                        break;
    397397                case VFS_OUT_WRITE:
    398                         con_write_srv(srv, callid, &call);
     398                        con_write_srv(srv, chandle, &call);
    399399                        break;
    400400                case VFS_OUT_SYNC:
    401                         con_sync_srv(srv, callid, &call);
     401                        con_sync_srv(srv, chandle, &call);
    402402                        break;
    403403                case CONSOLE_CLEAR:
    404                         con_clear_srv(srv, callid, &call);
     404                        con_clear_srv(srv, chandle, &call);
    405405                        break;
    406406                case CONSOLE_SET_POS:
    407                         con_set_pos_srv(srv, callid, &call);
     407                        con_set_pos_srv(srv, chandle, &call);
    408408                        break;
    409409                case CONSOLE_GET_POS:
    410                         con_get_pos_srv(srv, callid, &call);
     410                        con_get_pos_srv(srv, chandle, &call);
    411411                        break;
    412412                case CONSOLE_GET_SIZE:
    413                         con_get_size_srv(srv, callid, &call);
     413                        con_get_size_srv(srv, chandle, &call);
    414414                        break;
    415415                case CONSOLE_GET_COLOR_CAP:
    416                         con_get_color_cap_srv(srv, callid, &call);
     416                        con_get_color_cap_srv(srv, chandle, &call);
    417417                        break;
    418418                case CONSOLE_SET_STYLE:
    419                         con_set_style_srv(srv, callid, &call);
     419                        con_set_style_srv(srv, chandle, &call);
    420420                        break;
    421421                case CONSOLE_SET_COLOR:
    422                         con_set_color_srv(srv, callid, &call);
     422                        con_set_color_srv(srv, chandle, &call);
    423423                        break;
    424424                case CONSOLE_SET_RGB_COLOR:
    425                         con_set_rgb_color_srv(srv, callid, &call);
     425                        con_set_rgb_color_srv(srv, chandle, &call);
    426426                        break;
    427427                case CONSOLE_SET_CURSOR_VISIBILITY:
    428                         con_set_cursor_visibility_srv(srv, callid, &call);
     428                        con_set_cursor_visibility_srv(srv, chandle, &call);
    429429                        break;
    430430                case CONSOLE_GET_EVENT:
    431                         con_get_event_srv(srv, callid, &call);
     431                        con_get_event_srv(srv, chandle, &call);
    432432                        break;
    433433                default:
    434                         async_answer_0(callid, ENOTSUP);
     434                        async_answer_0(chandle, ENOTSUP);
    435435                }
    436436        }

  • uspace/lib/c/generic/io/input.c

    r3e242d2 ra46e56b  
    4343#include <stdlib.h>
    4444
    45 static void input_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg);
     45static void input_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
    4646
    4747errno_t input_open(async_sess_t *sess, input_ev_ops_t *ev_ops,
    … …  
    9292}
    9393
    94 static void input_ev_active(input_t *input, cap_call_handle_t callid,
     94static void input_ev_active(input_t *input, cap_call_handle_t chandle,
    9595    ipc_call_t *call)
    9696{
    9797        errno_t rc = input->ev_ops->active(input);
    98         async_answer_0(callid, rc);
    99 }
    100 
    101 static void input_ev_deactive(input_t *input, cap_call_handle_t callid,
     98        async_answer_0(chandle, rc);
     99}
     100
     101static void input_ev_deactive(input_t *input, cap_call_handle_t chandle,
    102102    ipc_call_t *call)
    103103{
    104104        errno_t rc = input->ev_ops->deactive(input);
    105         async_answer_0(callid, rc);
    106 }
    107 
    108 static void input_ev_key(input_t *input, cap_call_handle_t callid,
     105        async_answer_0(chandle, rc);
     106}
     107
     108static void input_ev_key(input_t *input, cap_call_handle_t chandle,
    109109    ipc_call_t *call)
    110110{
    … …  
    121121
    122122        rc = input->ev_ops->key(input, type, key, mods, c);
    123         async_answer_0(callid, rc);
    124 }
    125 
    126 static void input_ev_move(input_t *input, cap_call_handle_t callid,
     123        async_answer_0(chandle, rc);
     124}
     125
     126static void input_ev_move(input_t *input, cap_call_handle_t chandle,
    127127    ipc_call_t *call)
    128128{
    … …  
    135135
    136136        rc = input->ev_ops->move(input, dx, dy);
    137         async_answer_0(callid, rc);
    138 }
    139 
    140 static void input_ev_abs_move(input_t *input, cap_call_handle_t callid,
     137        async_answer_0(chandle, rc);
     138}
     139
     140static void input_ev_abs_move(input_t *input, cap_call_handle_t chandle,
    141141    ipc_call_t *call)
    142142{
    … …  
    153153
    154154        rc = input->ev_ops->abs_move(input, x, y, max_x, max_y);
    155         async_answer_0(callid, rc);
    156 }
    157 
    158 static void input_ev_button(input_t *input, cap_call_handle_t callid,
     155        async_answer_0(chandle, rc);
     156}
     157
     158static void input_ev_button(input_t *input, cap_call_handle_t chandle,
    159159    ipc_call_t *call)
    160160{
    … …  
    167167
    168168        rc = input->ev_ops->button(input, bnum, press);
    169         async_answer_0(callid, rc);
    170 }
    171 
    172 static void input_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     169        async_answer_0(chandle, rc);
     170}
     171
     172static void input_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    173173{
    174174        input_t *input = (input_t *)arg;
    … …  
    176176        while (true) {
    177177                ipc_call_t call;
    178                 cap_call_handle_t callid = async_get_call(&call);
     178                cap_call_handle_t chandle = async_get_call(&call);
    179179
    180180                if (!IPC_GET_IMETHOD(call)) {
    … …  
    185185                switch (IPC_GET_IMETHOD(call)) {
    186186                case INPUT_EVENT_ACTIVE:
    187                         input_ev_active(input, callid, &call);
     187                        input_ev_active(input, chandle, &call);
    188188                        break;
    189189                case INPUT_EVENT_DEACTIVE:
    190                         input_ev_deactive(input, callid, &call);
     190                        input_ev_deactive(input, chandle, &call);
    191191                        break;
    192192                case INPUT_EVENT_KEY:
    193                         input_ev_key(input, callid, &call);
     193                        input_ev_key(input, chandle, &call);
    194194                        break;
    195195                case INPUT_EVENT_MOVE:
    196                         input_ev_move(input, callid, &call);
     196                        input_ev_move(input, chandle, &call);
    197197                        break;
    198198                case INPUT_EVENT_ABS_MOVE:
    199                         input_ev_abs_move(input, callid, &call);
     199                        input_ev_abs_move(input, chandle, &call);
    200200                        break;
    201201                case INPUT_EVENT_BUTTON:
    202                         input_ev_button(input, callid, &call);
     202                        input_ev_button(input, chandle, &call);
    203203                        break;
    204204                default:
    205                         async_answer_0(callid, ENOTSUP);
     205                        async_answer_0(chandle, ENOTSUP);
    206206                }
    207207        }
Note: See TracChangeset for help on using the changeset viewer.