Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rbe12474 rd87561c  
    11/*
    22 * Copyright (c) 2007 Josef Cejka
    3  * Copyright (c) 2013 Jiri Svoboda
     3 * Copyright (c) 2011 Jiri Svoboda
    44 * Copyright (c) 2010 Lenka Trochtova
    55 * All rights reserved.
    … …  
    7777 *
    7878 */
    79 async_exch_t *devman_exchange_begin_blocking(iface_t iface)
     79async_exch_t *devman_exchange_begin_blocking(devman_interface_t iface)
    8080{
    8181        switch (iface) {
    82         case INTERFACE_DDF_DRIVER:
     82        case DEVMAN_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(SERVICE_DEVMAN,
    92                                     INTERFACE_DDF_DRIVER, 0);
     91                                    service_connect_blocking(EXCHANGE_PARALLEL,
     92                                    SERVICE_DEVMAN, DEVMAN_DRIVER, 0);
    9393                }
    9494               
    … …  
    9999               
    100100                return async_exchange_begin(devman_driver_block_sess);
    101         case INTERFACE_DDF_CLIENT:
     101        case DEVMAN_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(SERVICE_DEVMAN,
    111                                     INTERFACE_DDF_CLIENT, 0);
     110                                    service_connect_blocking(EXCHANGE_SERIALIZE,
     111                                    SERVICE_DEVMAN, DEVMAN_CLIENT, 0);
    112112                }
    113113               
    … …  
    130130 *
    131131 */
    132 async_exch_t *devman_exchange_begin(iface_t iface)
     132async_exch_t *devman_exchange_begin(devman_interface_t iface)
    133133{
    134134        switch (iface) {
    135         case INTERFACE_DDF_DRIVER:
     135        case DEVMAN_DRIVER:
    136136                fibril_mutex_lock(&devman_driver_mutex);
    137137               
    138138                if (devman_driver_sess == NULL)
    139139                        devman_driver_sess =
    140                             service_connect(SERVICE_DEVMAN,
    141                             INTERFACE_DDF_DRIVER, 0);
     140                            service_connect(EXCHANGE_PARALLEL, SERVICE_DEVMAN,
     141                            DEVMAN_DRIVER, 0);
    142142               
    143143                fibril_mutex_unlock(&devman_driver_mutex);
    … …  
    147147               
    148148                return async_exchange_begin(devman_driver_sess);
    149         case INTERFACE_DDF_CLIENT:
     149        case DEVMAN_CLIENT:
    150150                fibril_mutex_lock(&devman_client_mutex);
    151151               
    152152                if (devman_client_sess == NULL)
    153153                        devman_client_sess =
    154                             service_connect(SERVICE_DEVMAN,
    155                             INTERFACE_DDF_CLIENT, 0);
     154                            service_connect(EXCHANGE_SERIALIZE, SERVICE_DEVMAN,
     155                            DEVMAN_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(INTERFACE_DDF_DRIVER);
     181        async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
    182182       
    183183        ipc_call_t answer;
    … …  
    192192        }
    193193       
    194         exch = devman_exchange_begin(INTERFACE_DDF_DRIVER);
    195         async_connect_to_me(exch, 0, 0, 0);
     194        exch = devman_exchange_begin(DEVMAN_DRIVER);
     195        async_connect_to_me(exch, 0, 0, 0, NULL, NULL);
    196196        devman_exchange_end(exch);
    197197       
    … …  
    217217    match_id_list_t *match_ids, devman_handle_t devh, devman_handle_t *funh)
    218218{
    219         unsigned long match_count = list_count(&match_ids->ids);
    220         async_exch_t *exch = devman_exchange_begin_blocking(INTERFACE_DDF_DRIVER);
     219        int match_count = list_count(&match_ids->ids);
     220        async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
    221221       
    222222        ipc_call_t answer;
    … …  
    230230        }
    231231       
    232         list_foreach(match_ids->ids, link, match_id_t, match_id) {
     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               
    233237                ipc_call_t answer2;
    234238                aid_t req2 = async_send_1(exch, DEVMAN_ADD_MATCH_ID,
    … …  
    268272    const char *cat_name)
    269273{
    270         async_exch_t *exch = devman_exchange_begin_blocking(INTERFACE_DDF_DRIVER);
     274        async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
    271275       
    272276        ipc_call_t answer;
    … …  
    287291}
    288292
    289 async_sess_t *devman_device_connect(devman_handle_t handle, unsigned int flags)
     293async_sess_t *devman_device_connect(exch_mgmt_t mgmt, devman_handle_t handle,
     294    unsigned int flags)
    290295{
    291296        async_sess_t *sess;
    292297       
    293298        if (flags & IPC_FLAG_BLOCKING)
    294                 sess = service_connect_blocking(SERVICE_DEVMAN,
    295                     INTERFACE_DEVMAN_DEVICE, handle);
     299                sess = service_connect_blocking(mgmt, SERVICE_DEVMAN,
     300                            DEVMAN_CONNECT_TO_DEVICE, handle);
    296301        else
    297                 sess = service_connect(SERVICE_DEVMAN,
    298                     INTERFACE_DEVMAN_DEVICE, handle);
     302                sess = service_connect(mgmt, SERVICE_DEVMAN,
     303                            DEVMAN_CONNECT_TO_DEVICE, handle);
    299304       
    300305        return sess;
    … …  
    313318        sysarg_t retval;
    314319       
    315         exch = devman_exchange_begin_blocking(INTERFACE_DDF_DRIVER);
     320        exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
    316321        retval = async_req_1_0(exch, DEVMAN_REMOVE_FUNCTION, (sysarg_t) funh);
    317322        devman_exchange_end(exch);
    … …  
    322327int devman_drv_fun_online(devman_handle_t funh)
    323328{
    324         async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_DRIVER);
     329        async_exch_t *exch = devman_exchange_begin(DEVMAN_DRIVER);
    325330        if (exch == NULL)
    326331                return ENOMEM;
    … …  
    334339int devman_drv_fun_offline(devman_handle_t funh)
    335340{
    336         async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_DRIVER);
     341        async_exch_t *exch = devman_exchange_begin(DEVMAN_DRIVER);
    337342        if (exch == NULL)
    338343                return ENOMEM;
    … …  
    344349}
    345350
    346 async_sess_t *devman_parent_device_connect(devman_handle_t handle,
    347     unsigned int flags)
     351async_sess_t *devman_parent_device_connect(exch_mgmt_t mgmt,
     352    devman_handle_t handle, unsigned int flags)
    348353{
    349354        async_sess_t *sess;
    350355       
    351356        if (flags & IPC_FLAG_BLOCKING)
    352                 sess = service_connect_blocking(SERVICE_DEVMAN,
    353                     INTERFACE_DEVMAN_PARENT, handle);
     357                sess = service_connect_blocking(mgmt, SERVICE_DEVMAN,
     358                            DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle);
    354359        else
    355                 sess = service_connect_blocking(SERVICE_DEVMAN,
    356                     INTERFACE_DEVMAN_PARENT, handle);
     360                sess = service_connect(mgmt, SERVICE_DEVMAN,
     361                            DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle);
    357362       
    358363        return sess;
    … …  
    365370       
    366371        if (flags & IPC_FLAG_BLOCKING)
    367                 exch = devman_exchange_begin_blocking(INTERFACE_DDF_CLIENT);
     372                exch = devman_exchange_begin_blocking(DEVMAN_CLIENT);
    368373        else {
    369                 exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
     374                exch = devman_exchange_begin(DEVMAN_CLIENT);
    370375                if (exch == NULL)
    371376                        return ENOMEM;
    … …  
    400405}
    401406
    402 static int devman_get_str_internal(sysarg_t method, sysarg_t arg1,
    403     sysarg_t arg2, sysarg_t *r1, char *buf, size_t buf_size)
     407static int devman_get_str_internal(sysarg_t method, sysarg_t arg1, char *buf,
     408    size_t buf_size)
    404409{
    405410        async_exch_t *exch;
    … …  
    408413        sysarg_t dretval;
    409414       
    410         exch = devman_exchange_begin_blocking(INTERFACE_DDF_CLIENT);
     415        exch = devman_exchange_begin_blocking(DEVMAN_CLIENT);
    411416       
    412417        ipc_call_t answer;
    413         aid_t req = async_send_2(exch, method, arg1, arg2, &answer);
     418        aid_t req = async_send_1(exch, method, arg1, &answer);
    414419        aid_t dreq = async_data_read(exch, buf, buf_size - 1, &dreply);
    415420        async_wait_for(dreq, &dretval);
    … …  
    429434        }
    430435       
    431         if (r1 != NULL)
    432                 *r1 = IPC_GET_ARG1(answer);
    433436        act_size = IPC_GET_ARG2(dreply);
    434437        assert(act_size <= buf_size - 1);
    … …  
    440443int devman_fun_get_path(devman_handle_t handle, char *buf, size_t buf_size)
    441444{
    442         return devman_get_str_internal(DEVMAN_FUN_GET_PATH, handle, 0, NULL,
    443             buf, buf_size);
    444 }
    445 
    446 int 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;
     445        return devman_get_str_internal(DEVMAN_FUN_GET_PATH, handle, buf,
     446            buf_size);
    459447}
    460448
    461449int devman_fun_get_name(devman_handle_t handle, char *buf, size_t buf_size)
    462450{
    463         return devman_get_str_internal(DEVMAN_FUN_GET_NAME, handle, 0, NULL,
    464             buf, buf_size);
     451        return devman_get_str_internal(DEVMAN_FUN_GET_NAME, handle, buf,
     452            buf_size);
    465453}
    466454
    467455int devman_fun_get_driver_name(devman_handle_t handle, char *buf, size_t buf_size)
    468456{
    469         return devman_get_str_internal(DEVMAN_FUN_GET_DRIVER_NAME, handle, 0,
    470             NULL, buf, buf_size);
     457        return devman_get_str_internal(DEVMAN_FUN_GET_DRIVER_NAME, handle, buf,
     458            buf_size);
    471459}
    472460
    473461int devman_fun_online(devman_handle_t funh)
    474462{
    475         async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
     463        async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
    476464        if (exch == NULL)
    477465                return ENOMEM;
    … …  
    485473int devman_fun_offline(devman_handle_t funh)
    486474{
    487         async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
     475        async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
    488476        if (exch == NULL)
    489477                return ENOMEM;
    … …  
    498486    devman_handle_t *handle_buf, size_t buf_size, size_t *act_size)
    499487{
    500         async_exch_t *exch = devman_exchange_begin_blocking(INTERFACE_DDF_CLIENT);
     488        async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_CLIENT);
    501489
    502490        ipc_call_t answer;
    … …  
    577565int devman_fun_get_child(devman_handle_t funh, devman_handle_t *devh)
    578566{
    579         async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
     567        async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
    580568        if (exch == NULL)
    581569                return ENOMEM;
    … …  
    595583}
    596584
    597 int 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 
    610585int devman_fun_sid_to_handle(service_id_t sid, devman_handle_t *handle)
    611586{
    612         async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
     587        async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
    613588        if (exch == NULL)
    614589                return ENOMEM;
    … …  
    621596}
    622597
    623 int 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 
    629 int 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 
    636 int 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 
    671 int 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 
    686 int 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 
    692 int 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 
    710 int 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 
    722598/** @}
    723599 */
Note: See TracChangeset for help on using the changeset viewer.