Changeset 17aca1c in mainline for uspace/srv/hid


Ignore:
Timestamp:
2011-02-04T20:56:52Z (15 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
0397e5a4, e29e09cf
Parents:
e778543 (diff), 0b37882 (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

    re778543 r17aca1c  
    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

    re778543 r17aca1c  
    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

    re778543 r17aca1c  
    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

    re778543 r17aca1c  
    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

    re778543 r17aca1c  
    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
    … …  
    438438                        retval = ENOENT;
    439439                }
    440                 ipc_answer_0(callid, retval);
     440                async_answer_0(callid, retval);
    441441        }
    442442}
    … …  
    474474                }
    475475
    476                 ipc_answer_0(callid, retval);
     476                async_answer_0(callid, retval);
    477477        }
    478478}
    … …  
    485485       
    486486        if (rc != EOK) {
    487                 ipc_answer_0(rid, rc);
     487                async_answer_0(rid, rc);
    488488                return;
    489489        }
    … …  
    500500       
    501501        gcons_notify_char(cons->index);
    502         ipc_answer_1(rid, EOK, size);
     502        async_answer_1(rid, EOK, size);
    503503       
    504504        free(buf);
    … …  
    510510        size_t size;
    511511        if (!async_data_read_receive(&callid, &size)) {
    512                 ipc_answer_0(callid, EINVAL);
    513                 ipc_answer_0(rid, EINVAL);
     512                async_answer_0(callid, EINVAL);
     513                async_answer_0(rid, EINVAL);
    514514                return;
    515515        }
    … …  
    517517        char *buf = (char *) malloc(size);
    518518        if (buf == NULL) {
    519                 ipc_answer_0(callid, ENOMEM);
    520                 ipc_answer_0(rid, ENOMEM);
     519                async_answer_0(callid, ENOMEM);
     520                async_answer_0(rid, ENOMEM);
    521521                return;
    522522        }
    … …  
    536536        if (pos == size) {
    537537                (void) async_data_read_finalize(callid, buf, size);
    538                 ipc_answer_1(rid, EOK, size);
     538                async_answer_1(rid, EOK, size);
    539539                free(buf);
    540540        } else {
    … …  
    554554recheck:
    555555        if (keybuffer_pop(&cons->keybuffer, &ev)) {
    556                 ipc_answer_4(rid, EOK, ev.type, ev.key, ev.mods, ev.c);
     556                async_answer_4(rid, EOK, ev.type, ev.key, ev.mods, ev.c);
    557557        } else {
    558558                fibril_condvar_wait(&input_cv, &input_mutex);
    … …  
    580580       
    581581        if (cons == NULL) {
    582                 ipc_answer_0(iid, ENOENT);
     582                async_answer_0(iid, ENOENT);
    583583                return;
    584584        }
    … …  
    599599       
    600600        /* Accept the connection */
    601         ipc_answer_0(iid, EOK);
     601        async_answer_0(iid, EOK);
    602602       
    603603        while (true) {
    … …  
    659659                        rc = ccap_fb_to_con(fb_info.color_cap, &arg1);
    660660                        if (rc != EOK) {
    661                                 ipc_answer_0(callid, rc);
     661                                async_answer_0(callid, rc);
    662662                                continue;
    663663                        }
    … …  
    703703                        break;
    704704                }
    705                 ipc_answer_3(callid, EOK, arg1, arg2, arg3);
     705                async_answer_3(callid, EOK, arg1, arg2, arg3);
    706706        }
    707707}
    … …  
    762762        if (retval != EOK) {
    763763                async_wait_for(req, NULL);
    764                 ipc_hangup(devmap_phone);
     764                async_hangup(devmap_phone);
    765765                return retval;
    766766        }
    … …  
    769769
    770770        if (retval != EOK) {
    771                 ipc_hangup(devmap_phone);
     771                async_hangup(devmap_phone);
    772772                return retval;
    773773        }
    … …  
    775775        devmap_handle_t handle = (devmap_handle_t) IPC_GET_ARG1(answer);
    776776
    777         ipc_hangup(devmap_phone);
     777        async_hangup(devmap_phone);
    778778
    779779        int phone = async_connect_me_to(PHONE_NS,
    … …  
    864864        }
    865865       
    866         sysarg_t taskhash;
    867         sysarg_t phonehash;
    868         if (ipc_connect_to_me(mouse_phone, SERVICE_CONSOLE, 0, 0, &taskhash,
    869             &phonehash) != 0) {
     866        if (async_connect_to_me(mouse_phone, SERVICE_CONSOLE, 0, 0, mouse_events)
     867            != 0) {
    870868                printf(NAME ": Failed to create callback from mouse device\n");
    871869                mouse_phone = -1;
    … …  
    873871        }
    874872       
    875         async_new_connection(taskhash, phonehash, 0, NULL, mouse_events);
    876873skip_mouse:
    877874       
    878875        /* Connect to framebuffer driver */
    879         fb_info.phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VIDEO, 0, 0);
     876        fb_info.phone = service_connect_blocking(SERVICE_VIDEO, 0, 0);
    880877        if (fb_info.phone < 0) {
    881878                printf(NAME ": Failed to connect to video service\n");
    … …  
    953950       
    954951        /* Receive kernel notifications */
     952        async_set_interrupt_received(interrupt_received);
    955953        if (event_subscribe(EVENT_KCONSOLE, 0) != EOK)
    956954                printf(NAME ": Error registering kconsole notifications\n");
    957        
    958         async_set_interrupt_received(interrupt_received);
    959955       
    960956        /* Start fibril for checking on hot-plugged keyboards. */

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

    re778543 r17aca1c  
    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

    re778543 r17aca1c  
    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

    re778543 r17aca1c  
    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

    re778543 r17aca1c  
    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

    re778543 r17aca1c  
    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

    re778543 r17aca1c  
    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

    re778543 r17aca1c  
    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

    re778543 r17aca1c  
    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

    re778543 r17aca1c  
    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

    re778543 r17aca1c  
    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

    re778543 r17aca1c  
    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

    re778543 r17aca1c  
    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

    re778543 r17aca1c  
    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

    re778543 r17aca1c  
    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

    re778543 r17aca1c  
    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.