Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r5a6cc679 ra35b458  
    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.