Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    ra35b458 r5a6cc679  
    6262{
    6363        fibril_mutex_lock(mtx);
    64 
     64       
    6565        if ((*dst == NULL) && (src != NULL))
    6666                *dst = src;
    67 
     67       
    6868        fibril_mutex_unlock(mtx);
    6969}
    … …  
    8181        case INTERFACE_DDF_DRIVER:
    8282                fibril_mutex_lock(&devman_driver_block_mutex);
    83 
     83               
    8484                while (devman_driver_block_sess == NULL) {
    8585                        clone_session(&devman_driver_mutex, devman_driver_sess,
    8686                            &devman_driver_block_sess);
    87 
     87                       
    8888                        if (devman_driver_block_sess == NULL)
    8989                                devman_driver_block_sess =
    … …  
    9191                                    INTERFACE_DDF_DRIVER, 0);
    9292                }
    93 
     93               
    9494                fibril_mutex_unlock(&devman_driver_block_mutex);
    95 
     95               
    9696                clone_session(&devman_driver_mutex, devman_driver_block_sess,
    9797                    &devman_driver_sess);
    98 
     98               
    9999                return async_exchange_begin(devman_driver_block_sess);
    100100        case INTERFACE_DDF_CLIENT:
    101101                fibril_mutex_lock(&devman_client_block_mutex);
    102 
     102               
    103103                while (devman_client_block_sess == NULL) {
    104104                        clone_session(&devman_client_mutex, devman_client_sess,
    105105                            &devman_client_block_sess);
    106 
     106                       
    107107                        if (devman_client_block_sess == NULL)
    108108                                devman_client_block_sess =
    … …  
    110110                                    INTERFACE_DDF_CLIENT, 0);
    111111                }
    112 
     112               
    113113                fibril_mutex_unlock(&devman_client_block_mutex);
    114 
     114               
    115115                clone_session(&devman_client_mutex, devman_client_block_sess,
    116116                    &devman_client_sess);
    117 
     117               
    118118                return async_exchange_begin(devman_client_block_sess);
    119119        default:
    … …  
    134134        case INTERFACE_DDF_DRIVER:
    135135                fibril_mutex_lock(&devman_driver_mutex);
    136 
     136               
    137137                if (devman_driver_sess == NULL)
    138138                        devman_driver_sess =
    139139                            service_connect(SERVICE_DEVMAN,
    140140                            INTERFACE_DDF_DRIVER, 0);
    141 
     141               
    142142                fibril_mutex_unlock(&devman_driver_mutex);
    143 
     143               
    144144                if (devman_driver_sess == NULL)
    145145                        return NULL;
    146 
     146               
    147147                return async_exchange_begin(devman_driver_sess);
    148148        case INTERFACE_DDF_CLIENT:
    149149                fibril_mutex_lock(&devman_client_mutex);
    150 
     150               
    151151                if (devman_client_sess == NULL)
    152152                        devman_client_sess =
    153153                            service_connect(SERVICE_DEVMAN,
    154154                            INTERFACE_DDF_CLIENT, 0);
    155 
     155               
    156156                fibril_mutex_unlock(&devman_client_mutex);
    157 
     157               
    158158                if (devman_client_sess == NULL)
    159159                        return NULL;
    160 
     160               
    161161                return async_exchange_begin(devman_client_sess);
    162162        default:
    … …  
    179179{
    180180        async_exch_t *exch = devman_exchange_begin_blocking(INTERFACE_DDF_DRIVER);
    181 
     181       
    182182        ipc_call_t answer;
    183183        aid_t req = async_send_2(exch, DEVMAN_DRIVER_REGISTER, 0, 0, &answer);
    184184        errno_t retval = async_data_write_start(exch, name, str_size(name));
    185 
    186         devman_exchange_end(exch);
    187 
     185       
     186        devman_exchange_end(exch);
     187       
    188188        if (retval != EOK) {
    189189                async_forget(req);
    190190                return retval;
    191191        }
    192 
     192       
    193193        exch = devman_exchange_begin(INTERFACE_DDF_DRIVER);
    194194        async_connect_to_me(exch, 0, 0, 0);
    195195        devman_exchange_end(exch);
    196 
     196       
    197197        async_wait_for(req, &retval);
    198198        return retval;
    … …  
    218218        unsigned long match_count = list_count(&match_ids->ids);
    219219        async_exch_t *exch = devman_exchange_begin_blocking(INTERFACE_DDF_DRIVER);
    220 
     220       
    221221        ipc_call_t answer;
    222222        aid_t req = async_send_3(exch, DEVMAN_ADD_FUNCTION, (sysarg_t) ftype,
    … …  
    228228                return retval;
    229229        }
    230 
     230       
    231231        list_foreach(match_ids->ids, link, match_id_t, match_id) {
    232232                ipc_call_t answer2;
    … …  
    241241                        return retval;
    242242                }
    243 
     243               
    244244                async_wait_for(req2, &retval);
    245245                if (retval != EOK) {
    … …  
    249249                }
    250250        }
    251 
    252         devman_exchange_end(exch);
    253 
     251       
     252        devman_exchange_end(exch);
     253       
    254254        async_wait_for(req, &retval);
    255255        if (retval == EOK) {
    … …  
    260260                        *funh = -1;
    261261        }
    262 
     262       
    263263        return retval;
    264264}
    … …  
    268268{
    269269        async_exch_t *exch = devman_exchange_begin_blocking(INTERFACE_DDF_DRIVER);
    270 
     270       
    271271        ipc_call_t answer;
    272272        aid_t req = async_send_1(exch, DEVMAN_ADD_DEVICE_TO_CATEGORY,
    … …  
    274274        errno_t retval = async_data_write_start(exch, cat_name,
    275275            str_size(cat_name));
    276 
    277         devman_exchange_end(exch);
    278 
     276       
     277        devman_exchange_end(exch);
     278       
    279279        if (retval != EOK) {
    280280                async_forget(req);
    281281                return retval;
    282282        }
    283 
     283       
    284284        async_wait_for(req, &retval);
    285285        return retval;
    … …  
    289289{
    290290        async_sess_t *sess;
    291 
     291       
    292292        if (flags & IPC_FLAG_BLOCKING)
    293293                sess = service_connect_blocking(SERVICE_DEVMAN,
    … …  
    296296                sess = service_connect(SERVICE_DEVMAN,
    297297                    INTERFACE_DEVMAN_DEVICE, handle);
    298 
     298       
    299299        return sess;
    300300}
    … …  
    311311        async_exch_t *exch;
    312312        errno_t retval;
    313 
     313       
    314314        exch = devman_exchange_begin_blocking(INTERFACE_DDF_DRIVER);
    315315        retval = async_req_1_0(exch, DEVMAN_REMOVE_FUNCTION, (sysarg_t) funh);
    316316        devman_exchange_end(exch);
    317 
     317       
    318318        return retval;
    319319}
    … …  
    324324        if (exch == NULL)
    325325                return ENOMEM;
    326 
     326       
    327327        errno_t retval = async_req_1_0(exch, DEVMAN_DRV_FUN_ONLINE, funh);
    328 
     328       
    329329        devman_exchange_end(exch);
    330330        return retval;
    … …  
    336336        if (exch == NULL)
    337337                return ENOMEM;
    338 
     338       
    339339        errno_t retval = async_req_1_0(exch, DEVMAN_DRV_FUN_OFFLINE, funh);
    340 
     340       
    341341        devman_exchange_end(exch);
    342342        return retval;
    … …  
    347347{
    348348        async_sess_t *sess;
    349 
     349       
    350350        if (flags & IPC_FLAG_BLOCKING)
    351351                sess = service_connect_blocking(SERVICE_DEVMAN,
    … …  
    354354                sess = service_connect_blocking(SERVICE_DEVMAN,
    355355                    INTERFACE_DEVMAN_PARENT, handle);
    356 
     356       
    357357        return sess;
    358358}
    … …  
    362362{
    363363        async_exch_t *exch;
    364 
     364       
    365365        if (flags & IPC_FLAG_BLOCKING)
    366366                exch = devman_exchange_begin_blocking(INTERFACE_DDF_CLIENT);
    … …  
    370370                        return ENOMEM;
    371371        }
    372 
     372       
    373373        ipc_call_t answer;
    374374        aid_t req = async_send_2(exch, DEVMAN_DEVICE_GET_HANDLE, flags, 0,
    … …  
    376376        errno_t retval = async_data_write_start(exch, pathname,
    377377            str_size(pathname));
    378 
    379         devman_exchange_end(exch);
    380 
     378       
     379        devman_exchange_end(exch);
     380       
    381381        if (retval != EOK) {
    382382                async_forget(req);
    383383                return retval;
    384384        }
    385 
     385       
    386386        async_wait_for(req, &retval);
    387 
     387       
    388388        if (retval != EOK) {
    389389                if (handle != NULL)
    390390                        *handle = (devman_handle_t) -1;
    391 
    392                 return retval;
    393         }
    394 
     391               
     392                return retval;
     393        }
     394       
    395395        if (handle != NULL)
    396396                *handle = (devman_handle_t) IPC_GET_ARG1(answer);
    397 
     397       
    398398        return retval;
    399399}
    … …  
    406406        size_t act_size;
    407407        errno_t dretval;
    408 
     408       
    409409        exch = devman_exchange_begin_blocking(INTERFACE_DDF_CLIENT);
    410 
     410       
    411411        ipc_call_t answer;
    412412        aid_t req = async_send_2(exch, method, arg1, arg2, &answer);
    413413        aid_t dreq = async_data_read(exch, buf, buf_size - 1, &dreply);
    414414        async_wait_for(dreq, &dretval);
    415 
    416         devman_exchange_end(exch);
    417 
     415       
     416        devman_exchange_end(exch);
     417       
    418418        if (dretval != EOK) {
    419419                async_forget(req);
    420420                return dretval;
    421421        }
    422 
     422       
    423423        errno_t retval;
    424424        async_wait_for(req, &retval);
    425 
    426         if (retval != EOK) {
    427                 return retval;
    428         }
    429 
     425       
     426        if (retval != EOK) {
     427                return retval;
     428        }
     429       
    430430        if (r1 != NULL)
    431431                *r1 = IPC_GET_ARG1(answer);
    … …  
    433433        assert(act_size <= buf_size - 1);
    434434        buf[act_size] = '\0';
    435 
     435       
    436436        return EOK;
    437437}
    … …  
    475475        if (exch == NULL)
    476476                return ENOMEM;
    477 
     477       
    478478        errno_t retval = async_req_1_0(exch, DEVMAN_FUN_ONLINE, funh);
    479 
     479       
    480480        devman_exchange_end(exch);
    481481        return retval;
    … …  
    487487        if (exch == NULL)
    488488                return ENOMEM;
    489 
     489       
    490490        errno_t retval = async_req_1_0(exch, DEVMAN_FUN_OFFLINE, funh);
    491 
     491       
    492492        devman_exchange_end(exch);
    493493        return retval;
    … …  
    502502        aid_t req = async_send_1(exch, method, arg1, &answer);
    503503        errno_t rc = async_data_read_start(exch, handle_buf, buf_size);
    504 
    505         devman_exchange_end(exch);
    506 
     504       
     505        devman_exchange_end(exch);
     506       
    507507        if (rc != EOK) {
    508508                async_forget(req);
    509509                return rc;
    510510        }
    511 
     511       
    512512        errno_t retval;
    513513        async_wait_for(req, &retval);
    514 
    515         if (retval != EOK) {
    516                 return retval;
    517         }
    518 
     514       
     515        if (retval != EOK) {
     516                return retval;
     517        }
     518       
    519519        *act_size = IPC_GET_ARG1(answer);
    520520        return EOK;
    … …  
    579579        if (exch == NULL)
    580580                return ENOMEM;
    581 
     581       
    582582        errno_t retval = async_req_1_1(exch, DEVMAN_FUN_GET_CHILD,
    583583            funh, devh);
    584 
     584       
    585585        devman_exchange_end(exch);
    586586        return retval;
    … …  
    599599        if (exch == NULL)
    600600                return ENOMEM;
    601 
     601       
    602602        errno_t retval = async_req_1_1(exch, DEVMAN_DEV_GET_PARENT,
    603603            devh, funh);
    604 
     604       
    605605        devman_exchange_end(exch);
    606606        return retval;
    … …  
    612612        if (exch == NULL)
    613613                return ENOMEM;
    614 
     614       
    615615        errno_t retval = async_req_1_1(exch, DEVMAN_FUN_SID_TO_HANDLE,
    616616            sid, handle);
    617 
     617       
    618618        devman_exchange_end(exch);
    619619        return retval;
    … …  
    640640        if (exch == NULL)
    641641                return ENOMEM;
    642 
     642       
    643643        ipc_call_t answer;
    644644        aid_t req = async_send_0(exch, DEVMAN_DRIVER_GET_HANDLE, &answer);
    645645        errno_t retval = async_data_write_start(exch, drvname,
    646646            str_size(drvname));
    647 
    648         devman_exchange_end(exch);
    649 
     647       
     648        devman_exchange_end(exch);
     649       
    650650        if (retval != EOK) {
    651651                async_forget(req);
    652652                return retval;
    653653        }
    654 
     654       
    655655        async_wait_for(req, &retval);
    656 
     656       
    657657        if (retval != EOK) {
    658658                if (handle != NULL)
    659659                        *handle = (devman_handle_t) -1;
    660 
    661                 return retval;
    662         }
    663 
     660               
     661                return retval;
     662        }
     663       
    664664        if (handle != NULL)
    665665                *handle = (devman_handle_t) IPC_GET_ARG1(answer);
    666 
     666       
    667667        return retval;
    668668}
    … …  
    695695        if (exch == NULL)
    696696                return ENOMEM;
    697 
     697       
    698698        errno_t rc = async_req_1_1(exch, DEVMAN_DRIVER_GET_STATE, drvh,
    699699            &state);
    700 
     700       
    701701        devman_exchange_end(exch);
    702702        if (rc != EOK)
    … …  
    712712        if (exch == NULL)
    713713                return ENOMEM;
    714 
     714       
    715715        errno_t rc = async_req_1_0(exch, DEVMAN_DRIVER_LOAD, drvh);
    716 
     716       
    717717        devman_exchange_end(exch);
    718718        return rc;
    … …  
    724724        if (exch == NULL)
    725725                return ENOMEM;
    726 
     726       
    727727        errno_t rc = async_req_1_0(exch, DEVMAN_DRIVER_UNLOAD, drvh);
    728 
     728       
    729729        devman_exchange_end(exch);
    730730        return rc;
Note: See TracChangeset for help on using the changeset viewer.