Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/devman.c

    rd87561c rbe12474  
    11/*
    22 * Copyright (c) 2007 Josef Cejka
    3  * Copyright (c) 2011 Jiri Svoboda
     3 * Copyright (c) 2013 Jiri Svoboda
    44 * Copyright (c) 2010 Lenka Trochtova
    55 * All rights reserved.
    … …  
    7777 *
    7878 */
    79 async_exch_t *devman_exchange_begin_blocking(devman_interface_t iface)
     79async_exch_t *devman_exchange_begin_blocking(iface_t iface)
    8080{
    8181        switch (iface) {
    82         case DEVMAN_DRIVER:
     82        case INTERFACE_DDF_DRIVER:
    8383                fibril_mutex_lock(&devman_driver_block_mutex);
    8484               
    … …  
    8989                        if (devman_driver_block_sess == NULL)
    9090                                devman_driver_block_sess =
    91                                     service_connect_blocking(EXCHANGE_PARALLEL,
    92                                     SERVICE_DEVMAN, DEVMAN_DRIVER, 0);
     91                                    service_connect_blocking(SERVICE_DEVMAN,
     92                                    INTERFACE_DDF_DRIVER, 0);
    9393                }
    9494               
    … …  
    9999               
    100100                return async_exchange_begin(devman_driver_block_sess);
    101         case DEVMAN_CLIENT:
     101        case INTERFACE_DDF_CLIENT:
    102102                fibril_mutex_lock(&devman_client_block_mutex);
    103103               
    … …  
    108108                        if (devman_client_block_sess == NULL)
    109109                                devman_client_block_sess =
    110                                     service_connect_blocking(EXCHANGE_SERIALIZE,
    111                                     SERVICE_DEVMAN, DEVMAN_CLIENT, 0);
     110                                    service_connect_blocking(SERVICE_DEVMAN,
     111                                    INTERFACE_DDF_CLIENT, 0);
    112112                }
    113113               
    … …  
    130130 *
    131131 */
    132 async_exch_t *devman_exchange_begin(devman_interface_t iface)
     132async_exch_t *devman_exchange_begin(iface_t iface)
    133133{
    134134        switch (iface) {
    135         case DEVMAN_DRIVER:
     135        case INTERFACE_DDF_DRIVER:
    136136                fibril_mutex_lock(&devman_driver_mutex);
    137137               
    138138                if (devman_driver_sess == NULL)
    139139                        devman_driver_sess =
    140                             service_connect(EXCHANGE_PARALLEL, SERVICE_DEVMAN,
    141                             DEVMAN_DRIVER, 0);
     140                            service_connect(SERVICE_DEVMAN,
     141                            INTERFACE_DDF_DRIVER, 0);
    142142               
    143143                fibril_mutex_unlock(&devman_driver_mutex);
    … …  
    147147               
    148148                return async_exchange_begin(devman_driver_sess);
    149         case DEVMAN_CLIENT:
     149        case INTERFACE_DDF_CLIENT:
    150150                fibril_mutex_lock(&devman_client_mutex);
    151151               
    152152                if (devman_client_sess == NULL)
    153153                        devman_client_sess =
    154                             service_connect(EXCHANGE_SERIALIZE, SERVICE_DEVMAN,
    155                             DEVMAN_CLIENT, 0);
     154                            service_connect(SERVICE_DEVMAN,
     155                            INTERFACE_DDF_CLIENT, 0);
    156156               
    157157                fibril_mutex_unlock(&devman_client_mutex);
    … …  
    179179int devman_driver_register(const char *name)
    180180{
    181         async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
     181        async_exch_t *exch = devman_exchange_begin_blocking(INTERFACE_DDF_DRIVER);
    182182       
    183183        ipc_call_t answer;
    … …  
    192192        }
    193193       
    194         exch = devman_exchange_begin(DEVMAN_DRIVER);
    195         async_connect_to_me(exch, 0, 0, 0, NULL, NULL);
     194        exch = devman_exchange_begin(INTERFACE_DDF_DRIVER);
     195        async_connect_to_me(exch, 0, 0, 0);
    196196        devman_exchange_end(exch);
    197197       
    … …  
    217217    match_id_list_t *match_ids, devman_handle_t devh, devman_handle_t *funh)
    218218{
    219         int match_count = list_count(&match_ids->ids);
    220         async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
     219        unsigned long match_count = list_count(&match_ids->ids);
     220        async_exch_t *exch = devman_exchange_begin_blocking(INTERFACE_DDF_DRIVER);
    221221       
    222222        ipc_call_t answer;
    … …  
    230230        }
    231231       
    232         match_id_t *match_id = NULL;
    233        
    234         list_foreach(match_ids->ids, link) {
    235                 match_id = list_get_instance(link, match_id_t, link);
    236                
     232        list_foreach(match_ids->ids, link, match_id_t, match_id) {
    237233                ipc_call_t answer2;
    238234                aid_t req2 = async_send_1(exch, DEVMAN_ADD_MATCH_ID,
    … …  
    272268    const char *cat_name)
    273269{
    274         async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
     270        async_exch_t *exch = devman_exchange_begin_blocking(INTERFACE_DDF_DRIVER);
    275271       
    276272        ipc_call_t answer;
    … …  
    291287}
    292288
    293 async_sess_t *devman_device_connect(exch_mgmt_t mgmt, devman_handle_t handle,
    294     unsigned int flags)
     289async_sess_t *devman_device_connect(devman_handle_t handle, unsigned int flags)
    295290{
    296291        async_sess_t *sess;
    297292       
    298293        if (flags & IPC_FLAG_BLOCKING)
    299                 sess = service_connect_blocking(mgmt, SERVICE_DEVMAN,
    300                             DEVMAN_CONNECT_TO_DEVICE, handle);
     294                sess = service_connect_blocking(SERVICE_DEVMAN,
     295                    INTERFACE_DEVMAN_DEVICE, handle);
    301296        else
    302                 sess = service_connect(mgmt, SERVICE_DEVMAN,
    303                             DEVMAN_CONNECT_TO_DEVICE, handle);
     297                sess = service_connect(SERVICE_DEVMAN,
     298                    INTERFACE_DEVMAN_DEVICE, handle);
    304299       
    305300        return sess;
    … …  
    318313        sysarg_t retval;
    319314       
    320         exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
     315        exch = devman_exchange_begin_blocking(INTERFACE_DDF_DRIVER);
    321316        retval = async_req_1_0(exch, DEVMAN_REMOVE_FUNCTION, (sysarg_t) funh);
    322317        devman_exchange_end(exch);
    … …  
    327322int devman_drv_fun_online(devman_handle_t funh)
    328323{
    329         async_exch_t *exch = devman_exchange_begin(DEVMAN_DRIVER);
     324        async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_DRIVER);
    330325        if (exch == NULL)
    331326                return ENOMEM;
    … …  
    339334int devman_drv_fun_offline(devman_handle_t funh)
    340335{
    341         async_exch_t *exch = devman_exchange_begin(DEVMAN_DRIVER);
     336        async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_DRIVER);
    342337        if (exch == NULL)
    343338                return ENOMEM;
    … …  
    349344}
    350345
    351 async_sess_t *devman_parent_device_connect(exch_mgmt_t mgmt,
    352     devman_handle_t handle, unsigned int flags)
     346async_sess_t *devman_parent_device_connect(devman_handle_t handle,
     347    unsigned int flags)
    353348{
    354349        async_sess_t *sess;
    355350       
    356351        if (flags & IPC_FLAG_BLOCKING)
    357                 sess = service_connect_blocking(mgmt, SERVICE_DEVMAN,
    358                             DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle);
     352                sess = service_connect_blocking(SERVICE_DEVMAN,
     353                    INTERFACE_DEVMAN_PARENT, handle);
    359354        else
    360                 sess = service_connect(mgmt, SERVICE_DEVMAN,
    361                             DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle);
     355                sess = service_connect_blocking(SERVICE_DEVMAN,
     356                    INTERFACE_DEVMAN_PARENT, handle);
    362357       
    363358        return sess;
    … …  
    370365       
    371366        if (flags & IPC_FLAG_BLOCKING)
    372                 exch = devman_exchange_begin_blocking(DEVMAN_CLIENT);
     367                exch = devman_exchange_begin_blocking(INTERFACE_DDF_CLIENT);
    373368        else {
    374                 exch = devman_exchange_begin(DEVMAN_CLIENT);
     369                exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
    375370                if (exch == NULL)
    376371                        return ENOMEM;
    … …  
    405400}
    406401
    407 static int devman_get_str_internal(sysarg_t method, sysarg_t arg1, char *buf,
    408     size_t buf_size)
     402static int devman_get_str_internal(sysarg_t method, sysarg_t arg1,
     403    sysarg_t arg2, sysarg_t *r1, char *buf, size_t buf_size)
    409404{
    410405        async_exch_t *exch;
    … …  
    413408        sysarg_t dretval;
    414409       
    415         exch = devman_exchange_begin_blocking(DEVMAN_CLIENT);
     410        exch = devman_exchange_begin_blocking(INTERFACE_DDF_CLIENT);
    416411       
    417412        ipc_call_t answer;
    418         aid_t req = async_send_1(exch, method, arg1, &answer);
     413        aid_t req = async_send_2(exch, method, arg1, arg2, &answer);
    419414        aid_t dreq = async_data_read(exch, buf, buf_size - 1, &dreply);
    420415        async_wait_for(dreq, &dretval);
    … …  
    434429        }
    435430       
     431        if (r1 != NULL)
     432                *r1 = IPC_GET_ARG1(answer);
    436433        act_size = IPC_GET_ARG2(dreply);
    437434        assert(act_size <= buf_size - 1);
    … …  
    443440int devman_fun_get_path(devman_handle_t handle, char *buf, size_t buf_size)
    444441{
    445         return devman_get_str_internal(DEVMAN_FUN_GET_PATH, handle, buf,
    446             buf_size);
     442        return devman_get_str_internal(DEVMAN_FUN_GET_PATH, handle, 0, NULL,
     443            buf, buf_size);
     444}
     445
     446int devman_fun_get_match_id(devman_handle_t handle, size_t index, char *buf,
     447    size_t buf_size, unsigned int *rscore)
     448{
     449        int rc;
     450        sysarg_t score = 0;
     451
     452        rc = devman_get_str_internal(DEVMAN_FUN_GET_MATCH_ID, handle, index,
     453            &score, buf, buf_size);
     454        if (rc != EOK)
     455                return rc;
     456
     457        *rscore = score;
     458        return rc;
    447459}
    448460
    449461int devman_fun_get_name(devman_handle_t handle, char *buf, size_t buf_size)
    450462{
    451         return devman_get_str_internal(DEVMAN_FUN_GET_NAME, handle, buf,
    452             buf_size);
     463        return devman_get_str_internal(DEVMAN_FUN_GET_NAME, handle, 0, NULL,
     464            buf, buf_size);
    453465}
    454466
    455467int devman_fun_get_driver_name(devman_handle_t handle, char *buf, size_t buf_size)
    456468{
    457         return devman_get_str_internal(DEVMAN_FUN_GET_DRIVER_NAME, handle, buf,
    458             buf_size);
     469        return devman_get_str_internal(DEVMAN_FUN_GET_DRIVER_NAME, handle, 0,
     470            NULL, buf, buf_size);
    459471}
    460472
    461473int devman_fun_online(devman_handle_t funh)
    462474{
    463         async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
     475        async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
    464476        if (exch == NULL)
    465477                return ENOMEM;
    … …  
    473485int devman_fun_offline(devman_handle_t funh)
    474486{
    475         async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
     487        async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
    476488        if (exch == NULL)
    477489                return ENOMEM;
    … …  
    486498    devman_handle_t *handle_buf, size_t buf_size, size_t *act_size)
    487499{
    488         async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_CLIENT);
     500        async_exch_t *exch = devman_exchange_begin_blocking(INTERFACE_DDF_CLIENT);
    489501
    490502        ipc_call_t answer;
    … …  
    565577int devman_fun_get_child(devman_handle_t funh, devman_handle_t *devh)
    566578{
    567         async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
     579        async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
    568580        if (exch == NULL)
    569581                return ENOMEM;
    … …  
    583595}
    584596
     597int devman_dev_get_parent(devman_handle_t devh, devman_handle_t *funh)
     598{
     599        async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
     600        if (exch == NULL)
     601                return ENOMEM;
     602       
     603        sysarg_t retval = async_req_1_1(exch, DEVMAN_DEV_GET_PARENT,
     604            devh, funh);
     605       
     606        devman_exchange_end(exch);
     607        return (int) retval;
     608}
     609
    585610int devman_fun_sid_to_handle(service_id_t sid, devman_handle_t *handle)
    586611{
    587         async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
     612        async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
    588613        if (exch == NULL)
    589614                return ENOMEM;
    … …  
    596621}
    597622
     623int devman_get_drivers(devman_handle_t **drvs,
     624    size_t *count)
     625{
     626        return devman_get_handles_internal(DEVMAN_GET_DRIVERS, 0, drvs, count);
     627}
     628
     629int devman_driver_get_devices(devman_handle_t drvh, devman_handle_t **devs,
     630    size_t *count)
     631{
     632        return devman_get_handles_internal(DEVMAN_DRIVER_GET_DEVICES,
     633            drvh, devs, count);
     634}
     635
     636int devman_driver_get_handle(const char *drvname, devman_handle_t *handle)
     637{
     638        async_exch_t *exch;
     639
     640        exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
     641        if (exch == NULL)
     642                return ENOMEM;
     643       
     644        ipc_call_t answer;
     645        aid_t req = async_send_0(exch, DEVMAN_DRIVER_GET_HANDLE, &answer);
     646        sysarg_t retval = async_data_write_start(exch, drvname,
     647            str_size(drvname));
     648       
     649        devman_exchange_end(exch);
     650       
     651        if (retval != EOK) {
     652                async_forget(req);
     653                return retval;
     654        }
     655       
     656        async_wait_for(req, &retval);
     657       
     658        if (retval != EOK) {
     659                if (handle != NULL)
     660                        *handle = (devman_handle_t) -1;
     661               
     662                return retval;
     663        }
     664       
     665        if (handle != NULL)
     666                *handle = (devman_handle_t) IPC_GET_ARG1(answer);
     667       
     668        return retval;
     669}
     670
     671int devman_driver_get_match_id(devman_handle_t handle, size_t index, char *buf,
     672    size_t buf_size, unsigned int *rscore)
     673{
     674        int rc;
     675        sysarg_t score = 0;
     676
     677        rc = devman_get_str_internal(DEVMAN_DRIVER_GET_MATCH_ID, handle, index,
     678            &score, buf, buf_size);
     679        if (rc != EOK)
     680                return rc;
     681
     682        *rscore = score;
     683        return rc;
     684}
     685
     686int devman_driver_get_name(devman_handle_t handle, char *buf, size_t buf_size)
     687{
     688        return devman_get_str_internal(DEVMAN_DRIVER_GET_NAME, handle, 0, NULL,
     689            buf, buf_size);
     690}
     691
     692int devman_driver_get_state(devman_handle_t drvh, driver_state_t *rstate)
     693{
     694        sysarg_t state;
     695        async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
     696        if (exch == NULL)
     697                return ENOMEM;
     698       
     699        int rc = async_req_1_1(exch, DEVMAN_DRIVER_GET_STATE, drvh,
     700            &state);
     701       
     702        devman_exchange_end(exch);
     703        if (rc != EOK)
     704                return rc;
     705
     706        *rstate = state;
     707        return rc;
     708}
     709
     710int devman_driver_load(devman_handle_t drvh)
     711{
     712        async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
     713        if (exch == NULL)
     714                return ENOMEM;
     715       
     716        int rc = async_req_1_0(exch, DEVMAN_DRIVER_LOAD, drvh);
     717       
     718        devman_exchange_end(exch);
     719        return rc;
     720}
     721
    598722/** @}
    599723 */
Note: See TracChangeset for help on using the changeset viewer.