Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/devman/main.c

    r0418050 r6e50466  
    7575        iid = async_get_call(&icall);
    7676        if (IPC_GET_IMETHOD(icall) != DEVMAN_DRIVER_REGISTER) {
    77                 async_answer_0(iid, EREFUSED);
     77                ipc_answer_0(iid, EREFUSED);
    7878                return NULL;
    7979        }
    … …  
    8484        int rc = async_data_write_accept((void **) &drv_name, true, 0, 0, 0, 0);
    8585        if (rc != EOK) {
    86                 async_answer_0(iid, rc);
     86                ipc_answer_0(iid, rc);
    8787                return NULL;
    8888        }
    … …  
    9898                free(drv_name);
    9999                drv_name = NULL;
    100                 async_answer_0(iid, ENOENT);
     100                ipc_answer_0(iid, ENOENT);
    101101                return NULL;
    102102        }
    … …  
    110110        ipc_callid_t callid = async_get_call(&call);
    111111        if (IPC_GET_IMETHOD(call) != IPC_M_CONNECT_TO_ME) {
    112                 async_answer_0(callid, ENOTSUP);
    113                 async_answer_0(iid, ENOTSUP);
     112                ipc_answer_0(callid, ENOTSUP);
     113                ipc_answer_0(iid, ENOTSUP);
    114114                return NULL;
    115115        }
    … …  
    121121            driver->name);
    122122       
    123         async_answer_0(callid, EOK);
    124         async_answer_0(iid, EOK);
     123        ipc_answer_0(callid, EOK);
     124        ipc_answer_0(iid, EOK);
    125125       
    126126        return driver;
    … …  
    144144                printf(NAME ": ERROR: devman_receive_match_id - invalid "
    145145                    "protocol.\n");
    146                 async_answer_0(callid, EINVAL);
     146                ipc_answer_0(callid, EINVAL);
    147147                delete_match_id(match_id);
    148148                return EINVAL;
    … …  
    152152                printf(NAME ": ERROR: devman_receive_match_id - failed to "
    153153                    "allocate match id.\n");
    154                 async_answer_0(callid, ENOMEM);
     154                ipc_answer_0(callid, ENOMEM);
    155155                return ENOMEM;
    156156        }
    157157       
    158         async_answer_0(callid, EOK);
     158        ipc_answer_0(callid, EOK);
    159159       
    160160        match_id->score = IPC_GET_ARG1(call);
    … …  
    199199static int assign_driver_fibril(void *arg)
    200200{
    201         dev_node_t *dev_node = (dev_node_t *) arg;
    202         assign_driver(dev_node, &drivers_list, &device_tree);
     201        node_t *node = (node_t *) arg;
     202        assign_driver(node, &drivers_list, &device_tree);
    203203        return EOK;
    204204}
    205205
    206 /** Handle function registration.
     206/** Handle child device registration.
    207207 *
    208208 * Child devices are registered by their parent's device driver.
    209209 */
    210 static void devman_add_function(ipc_callid_t callid, ipc_call_t *call)
    211 {
    212         fun_type_t ftype = (fun_type_t) IPC_GET_ARG1(*call);
    213         devman_handle_t dev_handle = IPC_GET_ARG2(*call);
    214         sysarg_t match_count = IPC_GET_ARG3(*call);
     210static void devman_add_child(ipc_callid_t callid, ipc_call_t *call)
     211{
     212        devman_handle_t parent_handle = IPC_GET_ARG1(*call);
     213        sysarg_t match_count = IPC_GET_ARG2(*call);
    215214        dev_tree_t *tree = &device_tree;
    216215       
    217216        fibril_rwlock_write_lock(&tree->rwlock);
    218 
    219         dev_node_t *dev = NULL;
    220         dev_node_t *pdev = find_dev_node_no_lock(&device_tree, dev_handle);
    221        
    222         if (pdev == NULL) {
     217        node_t *parent = find_dev_node_no_lock(&device_tree, parent_handle);
     218       
     219        if (parent == NULL) {
    223220                fibril_rwlock_write_unlock(&tree->rwlock);
    224                 async_answer_0(callid, ENOENT);
    225                 return;
    226         }
    227        
    228         if (ftype != fun_inner && ftype != fun_exposed) {
    229                 /* Unknown function type */
    230                 printf(NAME ": Error, unknown function type provided by driver!\n");
    231 
    232                 fibril_rwlock_write_unlock(&tree->rwlock);
    233                 async_answer_0(callid, EINVAL);
    234                 return;
    235         }
    236        
    237         char *fun_name = NULL;
    238         int rc = async_data_write_accept((void **)&fun_name, true, 0, 0, 0, 0);
     221                ipc_answer_0(callid, ENOENT);
     222                return;
     223        }
     224       
     225        char *dev_name = NULL;
     226        int rc = async_data_write_accept((void **)&dev_name, true, 0, 0, 0, 0);
    239227        if (rc != EOK) {
    240228                fibril_rwlock_write_unlock(&tree->rwlock);
    241                 async_answer_0(callid, rc);
    242                 return;
    243         }
    244        
    245         fun_node_t *fun = create_fun_node();
    246         if (!insert_fun_node(&device_tree, fun, fun_name, pdev)) {
     229                ipc_answer_0(callid, rc);
     230                return;
     231        }
     232       
     233        node_t *node = create_dev_node();
     234        if (!insert_dev_node(&device_tree, node, dev_name, parent)) {
    247235                fibril_rwlock_write_unlock(&tree->rwlock);
    248                 delete_fun_node(fun);
    249                 async_answer_0(callid, ENOMEM);
    250                 return;
    251         }
    252 
    253         if (ftype == fun_inner) {
    254                 dev = create_dev_node();
    255                 if (dev == NULL) {
    256                         fibril_rwlock_write_unlock(&tree->rwlock);
    257                         delete_fun_node(fun);
    258                         async_answer_0(callid, ENOMEM);
    259                         return;
    260                 }
    261 
    262                 insert_dev_node(tree, dev, fun);
     236                delete_dev_node(node);
     237                ipc_answer_0(callid, ENOMEM);
     238                return;
    263239        }
    264240
    265241        fibril_rwlock_write_unlock(&tree->rwlock);
    266242       
    267         printf(NAME ": devman_add_function %s\n", fun->pathname);
    268        
    269         devman_receive_match_ids(match_count, &fun->match_ids);
    270 
    271         if (ftype == fun_inner) {
    272                 assert(dev != NULL);
     243        printf(NAME ": devman_add_child %s\n", node->pathname);
     244       
     245        devman_receive_match_ids(match_count, &node->match_ids);
     246
     247        /*
     248         * Try to find a suitable driver and assign it to the device.  We do
     249         * not want to block the current fibril that is used for processing
     250         * incoming calls: we will launch a separate fibril to handle the
     251         * driver assigning. That is because assign_driver can actually include
     252         * task spawning which could take some time.
     253         */
     254        fid_t assign_fibril = fibril_create(assign_driver_fibril, node);
     255        if (assign_fibril == 0) {
    273256                /*
    274                  * Try to find a suitable driver and assign it to the device.  We do
    275                  * not want to block the current fibril that is used for processing
    276                  * incoming calls: we will launch a separate fibril to handle the
    277                  * driver assigning. That is because assign_driver can actually include
    278                  * task spawning which could take some time.
     257                 * Fallback in case we are out of memory.
     258                 * Probably not needed as we will die soon anyway ;-).
    279259                 */
    280                 fid_t assign_fibril = fibril_create(assign_driver_fibril, dev);
    281                 if (assign_fibril == 0) {
    282                         /*
    283                          * Fallback in case we are out of memory.
    284                          * Probably not needed as we will die soon anyway ;-).
    285                          */
    286                         (void) assign_driver_fibril(fun);
    287                 } else {
    288                         fibril_add_ready(assign_fibril);
    289                 }
     260                (void) assign_driver_fibril(node);
    290261        } else {
    291                 devmap_register_tree_function(fun, tree);
    292         }
    293        
     262                fibril_add_ready(assign_fibril);
     263        }
     264
    294265        /* Return device handle to parent's driver. */
    295         async_answer_1(callid, EOK, fun->handle);
     266        ipc_answer_1(callid, EOK, node->handle);
    296267}
    297268
    … …  
    317288         * mapper.
    318289         */
    319         class_add_devmap_function(&class_list, cli);
     290        class_add_devmap_device(&class_list, cli);
    320291       
    321292        free(devmap_pathname);
    322293}
    323294
    324 static void devman_add_function_to_class(ipc_callid_t callid, ipc_call_t *call)
     295static void devman_add_device_to_class(ipc_callid_t callid, ipc_call_t *call)
    325296{
    326297        devman_handle_t handle = IPC_GET_ARG1(*call);
    … …  
    331302            0, 0, 0, 0);
    332303        if (rc != EOK) {
    333                 async_answer_0(callid, rc);
     304                ipc_answer_0(callid, rc);
    334305                return;
    335306        }       
    336307       
    337         fun_node_t *fun = find_fun_node(&device_tree, handle);
    338         if (fun == NULL) {
    339                 async_answer_0(callid, ENOENT);
     308        node_t *dev = find_dev_node(&device_tree, handle);
     309        if (dev == NULL) {
     310                ipc_answer_0(callid, ENOENT);
    340311                return;
    341312        }
    342313       
    343314        dev_class_t *cl = get_dev_class(&class_list, class_name);
    344         dev_class_info_t *class_info = add_function_to_class(fun, cl, NULL);
     315        dev_class_info_t *class_info = add_device_to_class(dev, cl, NULL);
    345316       
    346317        /* Register the device's class alias by devmapper. */
    347318        devmap_register_class_dev(class_info);
    348319       
    349         printf(NAME ": function'%s' added to class '%s', class name '%s' was "
    350             "asigned to it\n", fun->pathname, class_name, class_info->dev_name);
    351 
    352         async_answer_0(callid, EOK);
     320        printf(NAME ": device '%s' added to class '%s', class name '%s' was "
     321            "asigned to it\n", dev->pathname, class_name, class_info->dev_name);
     322
     323        ipc_answer_0(callid, EOK);
    353324}
    354325
    … …  
    372343{
    373344        /* Accept the connection. */
    374         async_answer_0(iid, EOK);
     345        ipc_answer_0(iid, EOK);
    375346       
    376347        driver_t *driver = devman_driver_register();
    … …  
    401372                        cont = false;
    402373                        continue;
    403                 case DEVMAN_ADD_FUNCTION:
    404                         devman_add_function(callid, &call);
     374                case DEVMAN_ADD_CHILD_DEVICE:
     375                        devman_add_child(callid, &call);
    405376                        break;
    406377                case DEVMAN_ADD_DEVICE_TO_CLASS:
    407                         devman_add_function_to_class(callid, &call);
     378                        devman_add_device_to_class(callid, &call);
    408379                        break;
    409380                default:
    410                         async_answer_0(callid, EINVAL);
     381                        ipc_answer_0(callid, EINVAL);
    411382                        break;
    412383                }
    … …  
    416387/** Find handle for the device instance identified by the device's path in the
    417388 * device tree. */
    418 static void devman_function_get_handle(ipc_callid_t iid, ipc_call_t *icall)
     389static void devman_device_get_handle(ipc_callid_t iid, ipc_call_t *icall)
    419390{
    420391        char *pathname;
    … …  
    422393        int rc = async_data_write_accept((void **) &pathname, true, 0, 0, 0, 0);
    423394        if (rc != EOK) {
    424                 async_answer_0(iid, rc);
    425                 return;
    426         }
    427        
    428         fun_node_t *fun = find_fun_node_by_path(&device_tree, pathname);
     395                ipc_answer_0(iid, rc);
     396                return;
     397        }
     398       
     399        node_t * dev = find_dev_node_by_path(&device_tree, pathname);
    429400       
    430401        free(pathname);
    431402
    432         if (fun == NULL) {
    433                 async_answer_0(iid, ENOENT);
    434                 return;
    435         }
    436 
    437         async_answer_1(iid, EOK, fun->handle);
     403        if (dev == NULL) {
     404                ipc_answer_0(iid, ENOENT);
     405                return;
     406        }
     407       
     408        ipc_answer_1(iid, EOK, dev->handle);
    438409}
    439410
    … …  
    443414{
    444415        /* Accept connection. */
    445         async_answer_0(iid, EOK);
     416        ipc_answer_0(iid, EOK);
    446417       
    447418        bool cont = true;
    … …  
    455426                        continue;
    456427                case DEVMAN_DEVICE_GET_HANDLE:
    457                         devman_function_get_handle(callid, &call);
     428                        devman_device_get_handle(callid, &call);
    458429                        break;
    459430                default:
    460                         async_answer_0(callid, ENOENT);
     431                        ipc_answer_0(callid, ENOENT);
    461432                }
    462433        }
    … …  
    467438{
    468439        devman_handle_t handle = IPC_GET_ARG2(*icall);
    469         devman_handle_t fwd_h;
    470         fun_node_t *fun = NULL;
    471         dev_node_t *dev = NULL;
    472        
    473         fun = find_fun_node(&device_tree, handle);
    474         if (fun == NULL)
    475                 dev = find_dev_node(&device_tree, handle);
    476         else
    477                 dev = fun->dev;
    478 
    479         /*
    480          * For a valid function to connect to we need a device. The root
    481          * function, for example, has no device and cannot be connected to.
    482          * This means @c dev needs to be valid regardless whether we are
    483          * connecting to a device or to a function.
    484          */
     440       
     441        node_t *dev = find_dev_node(&device_tree, handle);
    485442        if (dev == NULL) {
    486                 printf(NAME ": devman_forward error - no device or function with "
    487                     "handle %" PRIun " was found.\n", handle);
    488                 async_answer_0(iid, ENOENT);
    489                 return;
    490         }
    491 
    492         if (fun == NULL && !drv_to_parent) {
    493                 printf(NAME ": devman_forward error - cannot connect to "
    494                     "handle %" PRIun ", refers to a device.\n", handle);
    495                 async_answer_0(iid, ENOENT);
     443                printf(NAME ": devman_forward error - no device with handle %" PRIun
     444                    " was found.\n", handle);
     445                ipc_answer_0(iid, ENOENT);
    496446                return;
    497447        }
    … …  
    500450       
    501451        if (drv_to_parent) {
    502                 /* Connect to parent function of a device (or device function). */
    503                 if (dev->pfun->dev != NULL)
    504                         driver = dev->pfun->dev->drv;
    505                 fwd_h = dev->pfun->handle;
     452                if (dev->parent != NULL)
     453                        driver = dev->parent->drv;
    506454        } else if (dev->state == DEVICE_USABLE) {
    507                 /* Connect to the specified function */
    508455                driver = dev->drv;
    509456                assert(driver != NULL);
    510 
    511                 fwd_h = handle;
    512457        }
    513458       
    … …  
    515460                printf(NAME ": devman_forward error - the device is not in %" PRIun
    516461                    " usable state.\n", handle);
    517                 async_answer_0(iid, ENOENT);
     462                ipc_answer_0(iid, ENOENT);
    518463                return;
    519464        }
    … …  
    529474                    driver->name);
    530475                printf("the driver's phone is %" PRIun ").\n", driver->phone);
    531                 async_answer_0(iid, EINVAL);
    532                 return;
    533         }
    534 
    535         if (fun != NULL) {
    536                 printf(NAME ": devman_forward: forward connection to function %s to "
    537                     "driver %s.\n", fun->pathname, driver->name);
    538         } else {
    539                 printf(NAME ": devman_forward: forward connection to device %s to "
    540                     "driver %s.\n", dev->pfun->pathname, driver->name);
    541         }
    542 
    543         async_forward_fast(iid, driver->phone, method, fwd_h, 0, IPC_FF_NONE);
     476                ipc_answer_0(iid, EINVAL);
     477                return;
     478        }
     479
     480        printf(NAME ": devman_forward: forward connection to device %s to "
     481            "driver %s.\n", dev->pathname, driver->name);
     482        ipc_forward_fast(iid, driver->phone, method, dev->handle, 0, IPC_FF_NONE);
    544483}
    545484
    … …  
    549488{
    550489        devmap_handle_t devmap_handle = IPC_GET_ARG2(*icall);
    551         fun_node_t *fun;
    552         dev_node_t *dev;
    553 
    554         fun = find_devmap_tree_function(&device_tree, devmap_handle);
    555         if (fun == NULL)
    556                 fun = find_devmap_class_function(&class_list, devmap_handle);
    557        
    558         if (fun == NULL || fun->dev->drv == NULL) {
    559                 async_answer_0(iid, ENOENT);
    560                 return;
    561         }
    562        
    563         dev = fun->dev;
     490        node_t *dev;
     491
     492        dev = find_devmap_tree_device(&device_tree, devmap_handle);
     493        if (dev == NULL)
     494                dev = find_devmap_class_device(&class_list, devmap_handle);
     495       
     496        if (dev == NULL || dev->drv == NULL) {
     497                ipc_answer_0(iid, ENOENT);
     498                return;
     499        }
    564500       
    565501        if (dev->state != DEVICE_USABLE || dev->drv->phone <= 0) {
    566                 async_answer_0(iid, EINVAL);
    567                 return;
    568         }
    569        
    570         async_forward_fast(iid, dev->drv->phone, DRIVER_CLIENT, fun->handle, 0,
     502                ipc_answer_0(iid, EINVAL);
     503                return;
     504        }
     505       
     506        ipc_forward_fast(iid, dev->drv->phone, DRIVER_CLIENT, dev->handle, 0,
    571507            IPC_FF_NONE);
    572508        printf(NAME ": devman_connection_devmapper: forwarded connection to "
    573             "device %s to driver %s.\n", fun->pathname, dev->drv->name);
     509            "device %s to driver %s.\n", dev->pathname, dev->drv->name);
    574510}
    575511
    … …  
    599535        default:
    600536                /* No such interface */
    601                 async_answer_0(iid, ENOENT);
     537                ipc_answer_0(iid, ENOENT);
    602538        }
    603539}
    … …  
    650586
    651587        /* Register device manager at naming service. */
    652         if (service_register(SERVICE_DEVMAN) != EOK)
     588        sysarg_t phonead;
     589        if (ipc_connect_to_me(PHONE_NS, SERVICE_DEVMAN, 0, 0, &phonead) != 0)
    653590                return -1;
    654591
Note: See TracChangeset for help on using the changeset viewer.