Changeset 12573db in mainline for uspace/srv/hid


Ignore:
Timestamp:
2011-01-31T20:32:33Z (15 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/fix-logger-deadlock, topic/msim-upgrade, topic/simplify-dev-export
Children:
37cf3792
Parents:
4fe94c66 (diff), 197ef43 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes.

Location:
uspace/srv/hid
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/hid/adb_mouse/adb_dev.c

    r4fe94c66 r12573db  
    3434 */
    3535
    36 #include <ipc/ipc.h>
    3736#include <ipc/adb.h>
    3837#include <async.h>
    … …  
    6867
    6968        /* NB: The callback connection is slotted for removal */
    70         sysarg_t taskhash;
    71         sysarg_t phonehash;
    72         if (ipc_connect_to_me(dev_phone, 0, 0, 0, &taskhash, &phonehash) != 0) {
     69        if (async_connect_to_me(dev_phone, 0, 0, 0, adb_dev_events) != 0) {
    7370                printf(NAME ": Failed to create callback from device\n");
    7471                return false;
    7572        }
    76 
    77         async_new_connection(taskhash, phonehash, 0, NULL, adb_dev_events);
    78 
     73       
    7974        return 0;
    8075}
    … …  
    10095                        retval = ENOENT;
    10196                }
    102                 ipc_answer_0(callid, retval);
     97                async_answer_0(callid, retval);
    10398        }
    10499}

  • uspace/srv/hid/adb_mouse/adb_mouse.c

    r4fe94c66 r12573db  
    3939 */
    4040
    41 #include <ipc/ipc.h>
    4241#include <ipc/mouse.h>
    4342#include <stdio.h>
    … …  
    9897        int retval;
    9998
    100         ipc_answer_0(iid, EOK);
     99        async_answer_0(iid, EOK);
    101100
    102101        while (1) {
    … …  
    105104                case IPC_M_PHONE_HUNGUP:
    106105                        if (client_phone != -1) {
    107                                 ipc_hangup(client_phone);
     106                                async_hangup(client_phone);
    108107                                client_phone = -1;
    109108                        }
    110109
    111                         ipc_answer_0(callid, EOK);
     110                        async_answer_0(callid, EOK);
    112111                        return;
    113112                case IPC_M_CONNECT_TO_ME:
    … …  
    122121                        retval = EINVAL;
    123122                }
    124                 ipc_answer_0(callid, retval);
     123                async_answer_0(callid, retval);
    125124        }
    126125}

  • uspace/srv/hid/char_mouse/char_mouse.c

    r4fe94c66 r12573db  
    3939 */
    4040
    41 #include <ipc/ipc.h>
    4241#include <ipc/mouse.h>
    4342#include <stdio.h>
    … …  
    8382        int retval;
    8483
    85         ipc_answer_0(iid, EOK);
     84        async_answer_0(iid, EOK);
    8685
    8786        while (1) {
    … …  
    9089                case IPC_M_PHONE_HUNGUP:
    9190                        if (client_phone != -1) {
    92                                 ipc_hangup(client_phone);
     91                                async_hangup(client_phone);
    9392                                client_phone = -1;
    9493                        }
    9594
    96                         ipc_answer_0(callid, EOK);
     95                        async_answer_0(callid, EOK);
    9796                        return;
    9897                case IPC_M_CONNECT_TO_ME:
    … …  
    107106                        retval = EINVAL;
    108107                }
    109                 ipc_answer_0(callid, retval);
     108                async_answer_0(callid, retval);
    110109        }
    111110}

  • uspace/srv/hid/char_mouse/chardev.c

    r4fe94c66 r12573db  
    3434 */
    3535
    36 #include <ipc/ipc.h>
    3736#include <ipc/char.h>
    3837#include <async.h>
    … …  
    7069
    7170        /* NB: The callback connection is slotted for removal */
    72         sysarg_t taskhash;
    73         sysarg_t phonehash;
    74         if (ipc_connect_to_me(dev_phone, 0, 0, 0, &taskhash, &phonehash) != 0) {
     71        if (async_connect_to_me(dev_phone, 0, 0, 0, chardev_events) != 0) {
    7572                printf(NAME ": Failed to create callback from device\n");
    7673                return false;
    7774        }
    78 
    79         async_new_connection(taskhash, phonehash, 0, NULL, chardev_events);
    8075
    8176        return 0;
    … …  
    115110                        retval = ENOENT;
    116111                }
    117                 ipc_answer_0(callid, retval);
     112                async_answer_0(callid, retval);
    118113        }
    119114}

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

    r4fe94c66 r12573db  
    3434
    3535#include <libc.h>
    36 #include <ipc/ipc.h>
    3736#include <ipc/kbd.h>
    3837#include <io/keycode.h>
    … …  
    4039#include <ipc/fb.h>
    4140#include <ipc/services.h>
     41#include <ipc/ns.h>
    4242#include <errno.h>
    4343#include <ipc/console.h>
    … …  
    116116static void curs_hide_sync(void)
    117117{
    118         ipc_call_sync_1_0(fb_info.phone, FB_CURSOR_VISIBILITY, false);
     118        async_req_1_0(fb_info.phone, FB_CURSOR_VISIBILITY, false);
    119119}
    120120
    … …  
    131131static void screen_yield(void)
    132132{
    133         ipc_call_sync_0_0(fb_info.phone, FB_SCREEN_YIELD);
     133        async_req_0_0(fb_info.phone, FB_SCREEN_YIELD);
    134134}
    135135
    136136static void screen_reclaim(void)
    137137{
    138         ipc_call_sync_0_0(fb_info.phone, FB_SCREEN_RECLAIM);
     138        async_req_0_0(fb_info.phone, FB_SCREEN_RECLAIM);
    139139}
    140140
    141141static void kbd_yield(void)
    142142{
    143         ipc_call_sync_0_0(kbd_phone, KBD_YIELD);
     143        async_req_0_0(kbd_phone, KBD_YIELD);
    144144}
    145145
    146146static void kbd_reclaim(void)
    147147{
    148         ipc_call_sync_0_0(kbd_phone, KBD_RECLAIM);
     148        async_req_0_0(kbd_phone, KBD_RECLAIM);
    149149}
    150150
    … …  
    437437                        retval = ENOENT;
    438438                }
    439                 ipc_answer_0(callid, retval);
     439                async_answer_0(callid, retval);
    440440        }
    441441}
    … …  
    472472                }
    473473
    474                 ipc_answer_0(callid, retval);
     474                async_answer_0(callid, retval);
    475475        }
    476476}
    … …  
    483483       
    484484        if (rc != EOK) {
    485                 ipc_answer_0(rid, rc);
     485                async_answer_0(rid, rc);
    486486                return;
    487487        }
    … …  
    498498       
    499499        gcons_notify_char(cons->index);
    500         ipc_answer_1(rid, EOK, size);
     500        async_answer_1(rid, EOK, size);
    501501       
    502502        free(buf);
    … …  
    508508        size_t size;
    509509        if (!async_data_read_receive(&callid, &size)) {
    510                 ipc_answer_0(callid, EINVAL);
    511                 ipc_answer_0(rid, EINVAL);
     510                async_answer_0(callid, EINVAL);
     511                async_answer_0(rid, EINVAL);
    512512                return;
    513513        }
    … …  
    515515        char *buf = (char *) malloc(size);
    516516        if (buf == NULL) {
    517                 ipc_answer_0(callid, ENOMEM);
    518                 ipc_answer_0(rid, ENOMEM);
     517                async_answer_0(callid, ENOMEM);
     518                async_answer_0(rid, ENOMEM);
    519519                return;
    520520        }
    … …  
    534534        if (pos == size) {
    535535                (void) async_data_read_finalize(callid, buf, size);
    536                 ipc_answer_1(rid, EOK, size);
     536                async_answer_1(rid, EOK, size);
    537537                free(buf);
    538538        } else {
    … …  
    552552recheck:
    553553        if (keybuffer_pop(&cons->keybuffer, &ev)) {
    554                 ipc_answer_4(rid, EOK, ev.type, ev.key, ev.mods, ev.c);
     554                async_answer_4(rid, EOK, ev.type, ev.key, ev.mods, ev.c);
    555555        } else {
    556556                fibril_condvar_wait(&input_cv, &input_mutex);
    … …  
    578578       
    579579        if (cons == NULL) {
    580                 ipc_answer_0(iid, ENOENT);
     580                async_answer_0(iid, ENOENT);
    581581                return;
    582582        }
    … …  
    597597       
    598598        /* Accept the connection */
    599         ipc_answer_0(iid, EOK);
     599        async_answer_0(iid, EOK);
    600600       
    601601        while (true) {
    … …  
    657657                        rc = ccap_fb_to_con(fb_info.color_cap, &arg1);
    658658                        if (rc != EOK) {
    659                                 ipc_answer_0(callid, rc);
     659                                async_answer_0(callid, rc);
    660660                                continue;
    661661                        }
    … …  
    701701                        break;
    702702                }
    703                 ipc_answer_3(callid, EOK, arg1, arg2, arg3);
     703                async_answer_3(callid, EOK, arg1, arg2, arg3);
    704704        }
    705705}
    … …  
    726726       
    727727        /* NB: The callback connection is slotted for removal */
    728         sysarg_t taskhash;
    729         sysarg_t phonehash;
    730         if (ipc_connect_to_me(kbd_phone, SERVICE_CONSOLE, 0, 0, &taskhash,
    731             &phonehash) != 0) {
     728        if (async_connect_to_me(kbd_phone, SERVICE_CONSOLE, 0, 0, keyboard_events)
     729            != 0) {
    732730                printf(NAME ": Failed to create callback from input device\n");
    733731                return false;
    734732        }
    735        
    736         async_new_connection(taskhash, phonehash, 0, NULL, keyboard_events);
    737733       
    738734        /* Connect to mouse device */
    … …  
    751747        }
    752748       
    753         if (ipc_connect_to_me(mouse_phone, SERVICE_CONSOLE, 0, 0, &taskhash,
    754             &phonehash) != 0) {
     749        if (async_connect_to_me(mouse_phone, SERVICE_CONSOLE, 0, 0, mouse_events)
     750            != 0) {
    755751                printf(NAME ": Failed to create callback from mouse device\n");
    756752                mouse_phone = -1;
    … …  
    758754        }
    759755       
    760         async_new_connection(taskhash, phonehash, 0, NULL, mouse_events);
    761756skip_mouse:
    762757       
    763758        /* Connect to framebuffer driver */
    764         fb_info.phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VIDEO, 0, 0);
     759        fb_info.phone = service_connect_blocking(SERVICE_VIDEO, 0, 0);
    765760        if (fb_info.phone < 0) {
    766761                printf(NAME ": Failed to connect to video service\n");
    … …  
    838833       
    839834        /* Receive kernel notifications */
     835        async_set_interrupt_received(interrupt_received);
    840836        if (event_subscribe(EVENT_KCONSOLE, 0) != EOK)
    841837                printf(NAME ": Error registering kconsole notifications\n");
    842        
    843         async_set_interrupt_received(interrupt_received);
    844838       
    845839        return true;

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

    r4fe94c66 r12573db  
    3434
    3535#include <ipc/fb.h>
    36 #include <ipc/ipc.h>
    3736#include <async.h>
    3837#include <stdio.h>

  • uspace/srv/hid/fb/ega.c

    r4fe94c66 r12573db  
    3939#include <align.h>
    4040#include <async.h>
    41 #include <ipc/ipc.h>
    4241#include <errno.h>
    4342#include <stdio.h>
    … …  
    4645#include <as.h>
    4746#include <ipc/fb.h>
    48 #include <ipc/ipc.h>
    4947#include <ipc/ns.h>
    5048#include <ipc/services.h>
    … …  
    262260       
    263261        if (client_connected) {
    264                 ipc_answer_0(iid, ELIMIT);
     262                async_answer_0(iid, ELIMIT);
    265263                return;
    266264        }
    … …  
    268266        /* Accept connection */
    269267        client_connected = 1;
    270         ipc_answer_0(iid, EOK);
     268        async_answer_0(iid, EOK);
    271269       
    272270        while (true) {
    … …  
    296294                case IPC_M_PHONE_HUNGUP:
    297295                        client_connected = 0;
    298                         ipc_answer_0(callid, EOK);
     296                        async_answer_0(callid, EOK);
    299297                       
    300298                        /* Exit thread */
    … …  
    332330                        break;
    333331                case FB_GET_CSIZE:
    334                         ipc_answer_2(callid, EOK, scr_width, scr_height);
     332                        async_answer_2(callid, EOK, scr_width, scr_height);
    335333                        continue;
    336334                case FB_GET_COLOR_CAP:
    337                         ipc_answer_1(callid, EOK, FB_CCAP_INDEXED);
     335                        async_answer_1(callid, EOK, FB_CCAP_INDEXED);
    338336                        continue;
    339337                case FB_CLEAR:
    … …  
    440438                        retval = EINVAL;
    441439                }
    442                 ipc_answer_0(callid, retval);
     440                async_answer_0(callid, retval);
    443441        }
    444442}

  • uspace/srv/hid/fb/fb.c

    r4fe94c66 r12573db  
    4747#include <as.h>
    4848#include <ipc/fb.h>
    49 #include <ipc/ipc.h>
    5049#include <ipc/ns.h>
    5150#include <ipc/services.h>
    … …  
    10891088                        void *dest = as_get_mappable_page(IPC_GET_ARG2(*call));
    10901089                        shm_size = IPC_GET_ARG2(*call);
    1091                         if (ipc_answer_1(callid, EOK, (sysarg_t) dest)) {
     1090                        if (async_answer_1(callid, EOK, (sysarg_t) dest)) {
    10921091                                shm_id = 0;
    10931092                                return false;
    … …  
    11661165       
    11671166        if (handled)
    1168                 ipc_answer_0(callid, retval);
     1167                async_answer_0(callid, retval);
    11691168        return handled;
    11701169}
    … …  
    14451444        }
    14461445        if (handled)
    1447                 ipc_answer_0(callid, retval);
     1446                async_answer_0(callid, retval);
    14481447        return handled;
    14491448}
    … …  
    14981497       
    14991498        if (handled)
    1500                 ipc_answer_0(callid, retval);
     1499                async_answer_0(callid, retval);
    15011500        return handled;
    15021501       
    … …  
    15821581       
    15831582        if (client_connected) {
    1584                 ipc_answer_0(iid, ELIMIT);
     1583                async_answer_0(iid, ELIMIT);
    15851584                return;
    15861585        }
    … …  
    15881587        /* Accept connection */
    15891588        client_connected = true;
    1590         ipc_answer_0(iid, EOK);
     1589        async_answer_0(iid, EOK);
    15911590       
    15921591        while (true) {
    … …  
    16411640                                break;
    16421641                        }
    1643                         ipc_answer_0(callid, EOK);
     1642                        async_answer_0(callid, EOK);
    16441643                       
    16451644                        draw_char(vport, ch, col, row);
    … …  
    16741673                        break;
    16751674                case FB_GET_CSIZE:
    1676                         ipc_answer_2(callid, EOK, vport->cols, vport->rows);
     1675                        async_answer_2(callid, EOK, vport->cols, vport->rows);
    16771676                        continue;
    16781677                case FB_GET_COLOR_CAP:
    1679                         ipc_answer_1(callid, EOK, FB_CCAP_RGB);
     1678                        async_answer_1(callid, EOK, FB_CCAP_RGB);
    16801679                        continue;
    16811680                case FB_SCROLL:
    … …  
    17421741                        break;
    17431742                case FB_GET_RESOLUTION:
    1744                         ipc_answer_2(callid, EOK, screen.xres, screen.yres);
     1743                        async_answer_2(callid, EOK, screen.xres, screen.yres);
    17451744                        continue;
    17461745                case FB_POINTER_MOVE:
    … …  
    17561755                        retval = ENOENT;
    17571756                }
    1758                 ipc_answer_0(callid, retval);
     1757                async_answer_0(callid, retval);
    17591758        }
    17601759}

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

    r4fe94c66 r12573db  
    2727 */
    2828
    29 #include <ipc/ipc.h>
    3029#include <ipc/services.h>
     30#include <ipc/ns.h>
    3131#include <sysinfo.h>
    3232#include <async.h>
    … …  
    5151       
    5252        dest = as_get_mappable_page(IPC_GET_ARG2(*call));
    53         if (ipc_answer_1(callid, EOK, (sysarg_t) dest) == 0) {
     53        if (async_answer_1(callid, EOK, (sysarg_t) dest) == 0) {
    5454                if (*area)
    5555                        as_area_destroy(*area);
    … …  
    114114                return -1;
    115115       
    116         if (ipc_connect_to_me(PHONE_NS, SERVICE_VIDEO, 0, 0, NULL, NULL) != 0)
     116        if (service_register(SERVICE_VIDEO) != EOK)
    117117                return -1;
    118118       

  • uspace/srv/hid/fb/serial_console.c

    r4fe94c66 r12573db  
    3939
    4040#include <stdio.h>
    41 #include <ipc/ipc.h>
    4241#include <async.h>
    4342#include <ipc/fb.h>
    … …  
    319318       
    320319        if (client_connected) {
    321                 ipc_answer_0(iid, ELIMIT);
     320                async_answer_0(iid, ELIMIT);
    322321                return;
    323322        }
    324323       
    325324        client_connected = 1;
    326         ipc_answer_0(iid, EOK);
     325        async_answer_0(iid, EOK);
    327326       
    328327        /* Clear the terminal, set scrolling region
    … …  
    348347                case IPC_M_PHONE_HUNGUP:
    349348                        client_connected = 0;
    350                         ipc_answer_0(callid, EOK);
     349                        async_answer_0(callid, EOK);
    351350                       
    352351                        /* Exit thread */
    … …  
    407406                        break;
    408407                case FB_GET_CSIZE:
    409                         ipc_answer_2(callid, EOK, scr_width, scr_height);
     408                        async_answer_2(callid, EOK, scr_width, scr_height);
    410409                        continue;
    411410                case FB_GET_COLOR_CAP:
    412                         ipc_answer_1(callid, EOK, color ? FB_CCAP_INDEXED :
     411                        async_answer_1(callid, EOK, color ? FB_CCAP_INDEXED :
    413412                            FB_CCAP_STYLE);
    414413                        continue;
    … …  
    478477                        retval = ENOENT;
    479478                }
    480                 ipc_answer_0(callid, retval);
     479                async_answer_0(callid, retval);
    481480        }
    482481}

  • uspace/srv/hid/fb/serial_console.h

    r4fe94c66 r12573db  
    3939#define FB_SERIAL_CONSOLE_H_
    4040
    41 #include <ipc/ipc.h>
     41#include <sys/types.h>
     42#include <ipc/common.h>
    4243
    4344typedef void (*putc_function_t)(char);

  • uspace/srv/hid/kbd/generic/kbd.c

    r4fe94c66 r12573db  
    3636 */
    3737
    38 #include <ipc/ipc.h>
    3938#include <ipc/services.h>
    4039#include <ipc/kbd.h>
    … …  
    173172        int retval;
    174173
    175         ipc_answer_0(iid, EOK);
     174        async_answer_0(iid, EOK);
    176175
    177176        while (1) {
    … …  
    180179                case IPC_M_PHONE_HUNGUP:
    181180                        if (client_phone != -1) {
    182                                 ipc_hangup(client_phone);
     181                                async_hangup(client_phone);
    183182                                client_phone = -1;
    184183                        }
    185184                       
    186                         ipc_answer_0(callid, EOK);
     185                        async_answer_0(callid, EOK);
    187186                        return;
    188187                case IPC_M_CONNECT_TO_ME:
    … …  
    205204                        retval = EINVAL;
    206205                }
    207                 ipc_answer_0(callid, retval);
     206                async_answer_0(callid, retval);
    208207        }       
    209208}
    … …  
    223222       
    224223        if (cir_service) {
    225                 while (cir_phone < 0) {
    226                         cir_phone = ipc_connect_me_to_blocking(PHONE_NS, cir_service,
    227                             0, 0);
    228                 }
     224                while (cir_phone < 0)
     225                        cir_phone = service_connect_blocking(cir_service, 0, 0);
    229226        }
    230227       

  • uspace/srv/hid/kbd/port/adb.c

    r4fe94c66 r12573db  
    3535 */
    3636
    37 #include <ipc/ipc.h>
    3837#include <ipc/adb.h>
    3938#include <async.h>
    … …  
    7170
    7271        /* NB: The callback connection is slotted for removal */
    73         sysarg_t taskhash;
    74         sysarg_t phonehash;
    75         if (ipc_connect_to_me(dev_phone, 0, 0, 0, &taskhash, &phonehash) != 0) {
     72        if (async_connect_to_me(dev_phone, 0, 0, 0, kbd_port_events) != 0) {
    7673                printf(NAME ": Failed to create callback from device\n");
    7774                return false;
    7875        }
    79 
    80         async_new_connection(taskhash, phonehash, 0, NULL, kbd_port_events);
    8176
    8277        return 0;
    … …  
    116111                        retval = ENOENT;
    117112                }
    118                 ipc_answer_0(callid, retval);
     113                async_answer_0(callid, retval);
    119114        }
    120115}

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

    r4fe94c66 r12573db  
    3535 */
    3636
    37 #include <ipc/ipc.h>
    3837#include <ipc/char.h>
    3938#include <async.h>
    … …  
    9190
    9291        /* NB: The callback connection is slotted for removal */
    93         sysarg_t taskhash;
    94         sysarg_t phonehash;
    95         if (ipc_connect_to_me(dev_phone, 0, 0, 0, &taskhash, &phonehash) != 0) {
     92        if (async_connect_to_me(dev_phone, 0, 0, 0, kbd_port_events) != 0) {
    9693                printf(NAME ": Failed to create callback from device\n");
    9794                return -1;
    9895        }
    99 
    100         async_new_connection(taskhash, phonehash, 0, NULL, kbd_port_events);
    10196
    10297        return 0;
    … …  
    136131                        retval = ENOENT;
    137132                }
    138                 ipc_answer_0(callid, retval);
     133                async_answer_0(callid, retval);
    139134        }
    140135}

  • uspace/srv/hid/kbd/port/gxemul.c

    r4fe94c66 r12573db  
    3535 */
    3636
    37 #include <ipc/ipc.h>
    3837#include <async.h>
    3938#include <sysinfo.h>
    … …  
    7473        async_set_interrupt_received(gxemul_irq_handler);
    7574        gxemul_cmds[0].addr = (void *) addr;
    76         ipc_register_irq(inr, device_assign_devno(), 0, &gxemul_kbd);
     75        register_irq(inr, device_assign_devno(), 0, &gxemul_kbd);
    7776        return 0;
    7877}

  • uspace/srv/hid/kbd/port/msim.c

    r4fe94c66 r12573db  
    3535 */
    3636
    37 #include <ipc/ipc.h>
    3837#include <async.h>
    3938#include <sysinfo.h>
    … …  
    7473        msim_cmds[0].addr = (void *) vaddr;
    7574        async_set_interrupt_received(msim_irq_handler);
    76         ipc_register_irq(inr, device_assign_devno(), 0, &msim_kbd);
     75        register_irq(inr, device_assign_devno(), 0, &msim_kbd);
    7776       
    7877        return 0;

  • uspace/srv/hid/kbd/port/ns16550.c

    r4fe94c66 r12573db  
    3535 */
    3636
    37 #include <ipc/ipc.h>
    3837#include <ipc/irc.h>
    3938#include <async.h>
    … …  
    111110       
    112111        async_set_interrupt_received(ns16550_irq_handler);
    113         ipc_register_irq(inr, device_assign_devno(), inr, &ns16550_kbd);
     112        register_irq(inr, device_assign_devno(), inr, &ns16550_kbd);
    114113       
    115114        return pio_enable((void *) ns16550_physical, 8, &vaddr);

  • uspace/srv/hid/kbd/port/pl050.c

    r4fe94c66 r12573db  
    3737#include <ddi.h>
    3838#include <libarch/ddi.h>
    39 #include <ipc/ipc.h>
    4039#include <async.h>
    4140#include <unistd.h>
    … …  
    101100       
    102101        async_set_interrupt_received(pl050_irq_handler);
    103         ipc_register_irq(inr, device_assign_devno(), 0, &pl050_kbd);
     102        register_irq(inr, device_assign_devno(), 0, &pl050_kbd);
    104103       
    105104        return 0;

  • uspace/srv/hid/kbd/port/z8530.c

    r4fe94c66 r12573db  
    3535 */
    3636
    37 #include <ipc/ipc.h>
    3837#include <ipc/irc.h>
    3938#include <async.h>
    … …  
    9998       
    10099        async_set_interrupt_received(z8530_irq_handler);
    101         ipc_register_irq(inr, device_assign_devno(), inr, &z8530_kbd);
     100        register_irq(inr, device_assign_devno(), inr, &z8530_kbd);
    102101       
    103102        return 0;

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

    r4fe94c66 r12573db  
    4242#include <io/console.h>
    4343#include <vfs/vfs.h>
    44 #include <ipc/ipc.h>
    4544#include <ipc/mouse.h>
    4645#include <async.h>
    … …  
    140139
    141140        async_set_interrupt_received(s3c24xx_ts_irq_handler);
    142         ipc_register_irq(inr, device_assign_devno(), 0, &ts_irq_code);
     141        register_irq(inr, device_assign_devno(), 0, &ts_irq_code);
    143142
    144143        s3c24xx_ts_wait_for_int_mode(ts, updn_down);
    … …  
    377376        int retval;
    378377
    379         ipc_answer_0(iid, EOK);
     378        async_answer_0(iid, EOK);
    380379
    381380        while (1) {
    … …  
    384383                case IPC_M_PHONE_HUNGUP:
    385384                        if (ts->client_phone != -1) {
    386                                 ipc_hangup(ts->client_phone);
     385                                async_hangup(ts->client_phone);
    387386                                ts->client_phone = -1;
    388387                        }
    389388
    390                         ipc_answer_0(callid, EOK);
     389                        async_answer_0(callid, EOK);
    391390                        return;
    392391                case IPC_M_CONNECT_TO_ME:
    … …  
    401400                        retval = EINVAL;
    402401                }
    403                 ipc_answer_0(callid, retval);
     402                async_answer_0(callid, retval);
    404403        }
    405404}
Note: See TracChangeset for help on using the changeset viewer.