Changeset a46e56b in mainline for uspace/lib/drv/generic/driver.c


Ignore:
Timestamp:
2018-03-22T06:49:35Z (7 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
77f0a1d
Parents:
3e242d2
git-author:
Jakub Jermar <jakub@…> (2018-03-21 23:29:06)
git-committer:
Jakub Jermar <jakub@…> (2018-03-22 06:49:35)
Message:

Prefer handle over ID in naming handle variables

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/drv/generic/driver.c

    r3e242d2 ra46e56b  
    118118}
    119119
    120 static void driver_dev_add(cap_call_handle_t iid, ipc_call_t *icall)
     120static void driver_dev_add(cap_call_handle_t icall_handle, ipc_call_t *icall)
    121121{
    122122        devman_handle_t dev_handle = IPC_GET_ARG1(*icall);
    … …  
    126126        errno_t rc = async_data_write_accept((void **) &dev_name, true, 0, 0, 0, 0);
    127127        if (rc != EOK) {
    128                 async_answer_0(iid, rc);
     128                async_answer_0(icall_handle, rc);
    129129                return;
    130130        }
    … …  
    134134        if (stopping) {
    135135                fibril_rwlock_read_unlock(&stopping_lock);
    136                 async_answer_0(iid, EIO);
     136                async_answer_0(icall_handle, EIO);
    137137                return;
    138138        }
    … …  
    142142                fibril_rwlock_read_unlock(&stopping_lock);
    143143                free(dev_name);
    144                 async_answer_0(iid, ENOMEM);
     144                async_answer_0(icall_handle, ENOMEM);
    145145                return;
    146146        }
    … …  
    162162                fibril_rwlock_read_unlock(&stopping_lock);
    163163                dev_del_ref(dev);
    164                 async_answer_0(iid, res);
     164                async_answer_0(icall_handle, res);
    165165                return;
    166166        }
    … …  
    171171        fibril_rwlock_read_unlock(&stopping_lock);
    172172
    173         async_answer_0(iid, res);
    174 }
    175 
    176 static void driver_dev_remove(cap_call_handle_t iid, ipc_call_t *icall)
     173        async_answer_0(icall_handle, res);
     174}
     175
     176static void driver_dev_remove(cap_call_handle_t icall_handle, ipc_call_t *icall)
    177177{
    178178        devman_handle_t devh = IPC_GET_ARG1(*icall);
    … …  
    185185
    186186        if (dev == NULL) {
    187                 async_answer_0(iid, ENOENT);
     187                async_answer_0(icall_handle, ENOENT);
    188188                return;
    189189        }
    … …  
    204204
    205205        dev_del_ref(dev);
    206         async_answer_0(iid, rc);
    207 }
    208 
    209 static void driver_dev_gone(cap_call_handle_t iid, ipc_call_t *icall)
     206        async_answer_0(icall_handle, rc);
     207}
     208
     209static void driver_dev_gone(cap_call_handle_t icall_handle, ipc_call_t *icall)
    210210{
    211211        devman_handle_t devh = IPC_GET_ARG1(*icall);
    … …  
    218218
    219219        if (dev == NULL) {
    220                 async_answer_0(iid, ENOENT);
     220                async_answer_0(icall_handle, ENOENT);
    221221                return;
    222222        }
    … …  
    237237
    238238        dev_del_ref(dev);
    239         async_answer_0(iid, rc);
    240 }
    241 
    242 static void driver_fun_online(cap_call_handle_t iid, ipc_call_t *icall)
     239        async_answer_0(icall_handle, rc);
     240}
     241
     242static void driver_fun_online(cap_call_handle_t icall_handle, ipc_call_t *icall)
    243243{
    244244        devman_handle_t funh = IPC_GET_ARG1(*icall);
    … …  
    258258
    259259        if (fun == NULL) {
    260                 async_answer_0(iid, ENOENT);
     260                async_answer_0(icall_handle, ENOENT);
    261261                return;
    262262        }
    … …  
    272272        fun_del_ref(fun);
    273273
    274         async_answer_0(iid, rc);
    275 }
    276 
    277 static void driver_fun_offline(cap_call_handle_t iid, ipc_call_t *icall)
     274        async_answer_0(icall_handle, rc);
     275}
     276
     277static void driver_fun_offline(cap_call_handle_t icall_handle, ipc_call_t *icall)
    278278{
    279279        devman_handle_t funh = IPC_GET_ARG1(*icall);
    … …  
    293293
    294294        if (fun == NULL) {
    295                 async_answer_0(iid, ENOENT);
     295                async_answer_0(icall_handle, ENOENT);
    296296                return;
    297297        }
    … …  
    305305                rc = ENOTSUP;
    306306
    307         async_answer_0(iid, rc);
    308 }
    309 
    310 static void driver_stop(cap_call_handle_t iid, ipc_call_t *icall)
     307        async_answer_0(icall_handle, rc);
     308}
     309
     310static void driver_stop(cap_call_handle_t icall_handle, ipc_call_t *icall)
    311311{
    312312        /* Prevent new devices from being added */
    … …  
    321321                stopping = false;
    322322                fibril_rwlock_write_unlock(&stopping_lock);
    323                 async_answer_0(iid, EBUSY);
     323                async_answer_0(icall_handle, EBUSY);
    324324                return;
    325325        }
    … …  
    333333
    334334        /* Reply with success and terminate */
    335         async_answer_0(iid, EOK);
     335        async_answer_0(icall_handle, EOK);
    336336        exit(0);
    337337}
    338338
    339 static void driver_connection_devman(cap_call_handle_t iid, ipc_call_t *icall,
     339static void driver_connection_devman(cap_call_handle_t icall_handle, ipc_call_t *icall,
    340340    void *arg)
    341341{
    342342        /* Accept connection */
    343         async_answer_0(iid, EOK);
     343        async_answer_0(icall_handle, EOK);
    344344
    345345        while (true) {
    346346                ipc_call_t call;
    347                 cap_call_handle_t callid = async_get_call(&call);
     347                cap_call_handle_t chandle = async_get_call(&call);
    348348
    349349                if (!IPC_GET_IMETHOD(call))
    … …  
    352352                switch (IPC_GET_IMETHOD(call)) {
    353353                case DRIVER_DEV_ADD:
    354                         driver_dev_add(callid, &call);
     354                        driver_dev_add(chandle, &call);
    355355                        break;
    356356                case DRIVER_DEV_REMOVE:
    357                         driver_dev_remove(callid, &call);
     357                        driver_dev_remove(chandle, &call);
    358358                        break;
    359359                case DRIVER_DEV_GONE:
    360                         driver_dev_gone(callid, &call);
     360                        driver_dev_gone(chandle, &call);
    361361                        break;
    362362                case DRIVER_FUN_ONLINE:
    363                         driver_fun_online(callid, &call);
     363                        driver_fun_online(chandle, &call);
    364364                        break;
    365365                case DRIVER_FUN_OFFLINE:
    366                         driver_fun_offline(callid, &call);
     366                        driver_fun_offline(chandle, &call);
    367367                        break;
    368368                case DRIVER_STOP:
    369                         driver_stop(callid, &call);
     369                        driver_stop(chandle, &call);
    370370                        break;
    371371                default:
    372                         async_answer_0(callid, ENOTSUP);
     372                        async_answer_0(chandle, ENOTSUP);
    373373                }
    374374        }
    … …  
    381381 *
    382382 */
    383 static void driver_connection_gen(cap_call_handle_t iid, ipc_call_t *icall, bool drv)
     383static void driver_connection_gen(cap_call_handle_t icall_handle, ipc_call_t *icall, bool drv)
    384384{
    385385        /*
    … …  
    398398                printf("%s: driver_connection_gen error - no function with handle"
    399399                    " %" PRIun " was found.\n", driver->name, handle);
    400                 async_answer_0(iid, ENOENT);
     400                async_answer_0(icall_handle, ENOENT);
    401401                return;
    402402        }
    … …  
    404404        if (fun->conn_handler != NULL) {
    405405                /* Driver has a custom connection handler. */
    406                 (*fun->conn_handler)(iid, icall, (void *)fun);
     406                (*fun->conn_handler)(icall_handle, icall, (void *)fun);
    407407                fun_del_ref(fun);
    408408                return;
    … …  
    419419                ret = (*fun->ops->open)(fun);
    420420
    421         async_answer_0(iid, ret);
     421        async_answer_0(icall_handle, ret);
    422422        if (ret != EOK) {
    423423                fun_del_ref(fun);
    … …  
    426426
    427427        while (true) {
    428                 cap_call_handle_t callid;
     428                cap_call_handle_t chandle;
    429429                ipc_call_t call;
    430                 callid = async_get_call(&call);
     430                chandle = async_get_call(&call);
    431431                sysarg_t method = IPC_GET_IMETHOD(call);
    432432
    … …  
    435435                        if (fun->ops != NULL && fun->ops->close != NULL)
    436436                                (*fun->ops->close)(fun);
    437                         async_answer_0(callid, EOK);
     437                        async_answer_0(chandle, EOK);
    438438                        fun_del_ref(fun);
    439439                        return;
    … …  
    448448                            function_get_default_handler(fun);
    449449                        if (default_handler != NULL) {
    450                                 (*default_handler)(fun, callid, &call);
     450                                (*default_handler)(fun, chandle, &call);
    451451                                continue;
    452452                        }
    … …  
    459459                            "invalid interface id %d.",
    460460                            driver->name, iface_idx);
    461                         async_answer_0(callid, ENOTSUP);
     461                        async_answer_0(chandle, ENOTSUP);
    462462                        continue;
    463463                }
    … …  
    471471                        printf("Function with handle %" PRIun " has no interface "
    472472                            "with id %d.\n", handle, iface_idx);
    473                         async_answer_0(callid, ENOTSUP);
     473                        async_answer_0(chandle, ENOTSUP);
    474474                        continue;
    475475                }
    … …  
    490490                        printf("%s: driver_connection_gen error - "
    491491                            "invalid interface method.", driver->name);
    492                         async_answer_0(callid, ENOTSUP);
     492                        async_answer_0(chandle, ENOTSUP);
    493493                        continue;
    494494                }
    … …  
    500500                 * associated with the function by its driver.
    501501                 */
    502                 (*iface_method_ptr)(fun, ops, callid, &call);
    503         }
    504 }
    505 
    506 static void driver_connection_driver(cap_call_handle_t iid, ipc_call_t *icall,
     502                (*iface_method_ptr)(fun, ops, chandle, &call);
     503        }
     504}
     505
     506static void driver_connection_driver(cap_call_handle_t icall_handle, ipc_call_t *icall,
    507507    void *arg)
    508508{
    509         driver_connection_gen(iid, icall, true);
    510 }
    511 
    512 static void driver_connection_client(cap_call_handle_t iid, ipc_call_t *icall,
     509        driver_connection_gen(icall_handle, icall, true);
     510}
     511
     512static void driver_connection_client(cap_call_handle_t icall_handle, ipc_call_t *icall,
    513513    void *arg)
    514514{
    515         driver_connection_gen(iid, icall, false);
     515        driver_connection_gen(icall_handle, icall, false);
    516516}
    517517
Note: See TracChangeset for help on using the changeset viewer.