Changes in uspace/srv/devman/main.c [aa7dc64:ffa2c8ef] in mainline

File:

• uspace/srv/devman/main.c (modified) (14 diffs)

uspace/srv/devman/main.c

@@ -199 +199 @@
 static int assign_driver_fibril(void *arg)
 {
-        dev_node_t *dev_node = (dev_node_t *) arg;
-        assign_driver(dev_node, &drivers_list, &device_tree);
+        node_t *node = (node_t *) arg;
+        assign_driver(node, &drivers_list, &device_tree);
         return EOK;
 }
 
-/** Handle function registration.
+/** Handle child device registration.
  *
  * Child devices are registered by their parent's device driver.
  */
-static void devman_add_function(ipc_callid_t callid, ipc_call_t *call)
-{
-        fun_type_t ftype = (fun_type_t) IPC_GET_ARG1(*call);
-        devman_handle_t dev_handle = IPC_GET_ARG2(*call);
-        sysarg_t match_count = IPC_GET_ARG3(*call);
+static void devman_add_child(ipc_callid_t callid, ipc_call_t *call)
+{
+        devman_handle_t parent_handle = IPC_GET_ARG1(*call);
+        sysarg_t match_count = IPC_GET_ARG2(*call);
         dev_tree_t *tree = &device_tree;
         
         fibril_rwlock_write_lock(&tree->rwlock);
-
-        dev_node_t *dev = NULL;
-        dev_node_t *pdev = find_dev_node_no_lock(&device_tree, dev_handle);
-        
-        if (pdev == NULL) {
+        node_t *parent = find_dev_node_no_lock(&device_tree, parent_handle);
+        
+        if (parent == NULL) {
                 fibril_rwlock_write_unlock(&tree->rwlock);
                 async_answer_0(callid, ENOENT);
@@ -226 +223 @@
         }
         
-        if (ftype != fun_inner && ftype != fun_exposed) {
-                /* Unknown function type */
-                printf(NAME ": Error, unknown function type provided by driver!\n");
-
-                fibril_rwlock_write_unlock(&tree->rwlock);
-                async_answer_0(callid, EINVAL);
-                return;
-        }
-        
-        char *fun_name = NULL;
-        int rc = async_data_write_accept((void **)&fun_name, true, 0, 0, 0, 0);
+        char *dev_name = NULL;
+        int rc = async_data_write_accept((void **)&dev_name, true, 0, 0, 0, 0);
         if (rc != EOK) {
                 fibril_rwlock_write_unlock(&tree->rwlock);
@@ -243 +231 @@
         }
         
-        fun_node_t *fun = create_fun_node();
-        if (!insert_fun_node(&device_tree, fun, fun_name, pdev)) {
+        node_t *node = create_dev_node();
+        if (!insert_dev_node(&device_tree, node, dev_name, parent)) {
                 fibril_rwlock_write_unlock(&tree->rwlock);
-                delete_fun_node(fun);
+                delete_dev_node(node);
                 async_answer_0(callid, ENOMEM);
                 return;
         }
 
-        if (ftype == fun_inner) {
-                dev = create_dev_node();
-                if (dev == NULL) {
-                        fibril_rwlock_write_unlock(&tree->rwlock);
-                        delete_fun_node(fun);
-                        async_answer_0(callid, ENOMEM);
-                        return;
-                }
-
-                insert_dev_node(tree, dev, fun);
-        }
-
         fibril_rwlock_write_unlock(&tree->rwlock);
         
-        printf(NAME ": devman_add_function %s\n", fun->pathname);
-        
-        devman_receive_match_ids(match_count, &fun->match_ids);
-
-        if (ftype == fun_inner) {
-                assert(dev != NULL);
+        printf(NAME ": devman_add_child %s\n", node->pathname);
+        
+        devman_receive_match_ids(match_count, &node->match_ids);
+
+        /*
+         * Try to find a suitable driver and assign it to the device.  We do
+         * not want to block the current fibril that is used for processing
+         * incoming calls: we will launch a separate fibril to handle the
+         * driver assigning. That is because assign_driver can actually include
+         * task spawning which could take some time.
+         */
+        fid_t assign_fibril = fibril_create(assign_driver_fibril, node);
+        if (assign_fibril == 0) {
                 /*
-                 * Try to find a suitable driver and assign it to the device.  We do
-                 * not want to block the current fibril that is used for processing
-                 * incoming calls: we will launch a separate fibril to handle the
-                 * driver assigning. That is because assign_driver can actually include
-                 * task spawning which could take some time.
+                 * Fallback in case we are out of memory.
+                 * Probably not needed as we will die soon anyway ;-).
                  */
-                fid_t assign_fibril = fibril_create(assign_driver_fibril, dev);
-                if (assign_fibril == 0) {
-                        /*
-                         * Fallback in case we are out of memory.
-                         * Probably not needed as we will die soon anyway ;-).
-                         */
-                        (void) assign_driver_fibril(fun);
-                } else {
-                        fibril_add_ready(assign_fibril);
-                }
+                (void) assign_driver_fibril(node);
         } else {
-                devmap_register_tree_function(fun, tree);
-        }
-        
+                fibril_add_ready(assign_fibril);
+        }
+
         /* Return device handle to parent's driver. */
-        async_answer_1(callid, EOK, fun->handle);
+        async_answer_1(callid, EOK, node->handle);
 }
 
@@ -317 +288 @@
          * mapper.
          */
-        class_add_devmap_function(&class_list, cli);
+        class_add_devmap_device(&class_list, cli);
         
         free(devmap_pathname);
 }
 
-static void devman_add_function_to_class(ipc_callid_t callid, ipc_call_t *call)
+static void devman_add_device_to_class(ipc_callid_t callid, ipc_call_t *call)
 {
         devman_handle_t handle = IPC_GET_ARG1(*call);
@@ -335 +306 @@
         }       
         
-        fun_node_t *fun = find_fun_node(&device_tree, handle);
-        if (fun == NULL) {
+        node_t *dev = find_dev_node(&device_tree, handle);
+        if (dev == NULL) {
                 async_answer_0(callid, ENOENT);
                 return;
@@ -342 +313 @@
         
         dev_class_t *cl = get_dev_class(&class_list, class_name);
-        dev_class_info_t *class_info = add_function_to_class(fun, cl, NULL);
+        dev_class_info_t *class_info = add_device_to_class(dev, cl, NULL);
         
         /* Register the device's class alias by devmapper. */
         devmap_register_class_dev(class_info);
         
-        printf(NAME ": function'%s' added to class '%s', class name '%s' was "
-            "asigned to it\n", fun->pathname, class_name, class_info->dev_name);
+        printf(NAME ": device '%s' added to class '%s', class name '%s' was "
+            "asigned to it\n", dev->pathname, class_name, class_info->dev_name);
 
         async_answer_0(callid, EOK);
@@ -401 +372 @@
                         cont = false;
                         continue;
-                case DEVMAN_ADD_FUNCTION:
-                        devman_add_function(callid, &call);
+                case DEVMAN_ADD_CHILD_DEVICE:
+                        devman_add_child(callid, &call);
                         break;
                 case DEVMAN_ADD_DEVICE_TO_CLASS:
-                        devman_add_function_to_class(callid, &call);
+                        devman_add_device_to_class(callid, &call);
                         break;
                 default:
@@ -416 +387 @@
 /** Find handle for the device instance identified by the device's path in the
  * device tree. */
-static void devman_function_get_handle(ipc_callid_t iid, ipc_call_t *icall)
+static void devman_device_get_handle(ipc_callid_t iid, ipc_call_t *icall)
 {
         char *pathname;
@@ -426 +397 @@
         }
         
-        fun_node_t *fun = find_fun_node_by_path(&device_tree, pathname);
+        node_t * dev = find_dev_node_by_path(&device_tree, pathname);
         
         free(pathname);
 
-        if (fun == NULL) {
+        if (dev == NULL) {
                 async_answer_0(iid, ENOENT);
                 return;
         }
-
-        async_answer_1(iid, EOK, fun->handle);
+        
+        async_answer_1(iid, EOK, dev->handle);
 }
 
@@ -455 +426 @@
                         continue;
                 case DEVMAN_DEVICE_GET_HANDLE:
-                        devman_function_get_handle(callid, &call);
+                        devman_device_get_handle(callid, &call);
                         break;
                 default:
@@ -467 +438 @@
 {
         devman_handle_t handle = IPC_GET_ARG2(*icall);
-        devman_handle_t fwd_h;
-        fun_node_t *fun = NULL;
-        dev_node_t *dev = NULL;
-        
-        fun = find_fun_node(&device_tree, handle);
-        if (fun == NULL)
-                dev = find_dev_node(&device_tree, handle);
-        else
-                dev = fun->dev;
-
-        if (fun == NULL && dev == NULL) {
-                printf(NAME ": devman_forward error - no device or function with "
-                    "handle %" PRIun " was found.\n", handle);
+        
+        node_t *dev = find_dev_node(&device_tree, handle);
+        if (dev == NULL) {
+                printf(NAME ": devman_forward error - no device with handle %" PRIun
+                    " was found.\n", handle);
                 async_answer_0(iid, ENOENT);
                 return;
         }
-
-        if (fun == NULL && !drv_to_parent) {
-                printf(NAME ": devman_forward error - cannot connect to "
-                    "handle %" PRIun ", refers to a device.\n", handle);
-                async_answer_0(iid, ENOENT);
-                return;
-        }
         
         driver_t *driver = NULL;
         
         if (drv_to_parent) {
-                /* Connect to parent function of a device (or device function). */
-                if (dev->pfun->dev != NULL)
-                        driver = dev->pfun->dev->drv;
-                fwd_h = dev->pfun->handle;
+                if (dev->parent != NULL)
+                        driver = dev->parent->drv;
         } else if (dev->state == DEVICE_USABLE) {
-                /* Connect to the specified function */
                 driver = dev->drv;
                 assert(driver != NULL);
-
-                fwd_h = handle;
         }
         
@@ -527 +478 @@
         }
 
-        if (fun != NULL) {
-                printf(NAME ": devman_forward: forward connection to function %s to "
-                    "driver %s.\n", fun->pathname, driver->name);
-        } else {
-                printf(NAME ": devman_forward: forward connection to device %s to "
-                    "driver %s.\n", dev->pfun->pathname, driver->name);
-        }
-
-        async_forward_fast(iid, driver->phone, method, fwd_h, 0, IPC_FF_NONE);
+        printf(NAME ": devman_forward: forward connection to device %s to "
+            "driver %s.\n", dev->pathname, driver->name);
+        async_forward_fast(iid, driver->phone, method, dev->handle, 0, IPC_FF_NONE);
 }
 
@@ -543 +488 @@
 {
         devmap_handle_t devmap_handle = IPC_GET_ARG2(*icall);
-        fun_node_t *fun;
-        dev_node_t *dev;
-
-        fun = find_devmap_tree_function(&device_tree, devmap_handle);
-        if (fun == NULL)
-                fun = find_devmap_class_function(&class_list, devmap_handle);
-        
-        if (fun == NULL || fun->dev->drv == NULL) {
+        node_t *dev;
+
+        dev = find_devmap_tree_device(&device_tree, devmap_handle);
+        if (dev == NULL)
+                dev = find_devmap_class_device(&class_list, devmap_handle);
+        
+        if (dev == NULL || dev->drv == NULL) {
                 async_answer_0(iid, ENOENT);
                 return;
         }
-        
-        dev = fun->dev;
         
         if (dev->state != DEVICE_USABLE || dev->drv->phone <= 0) {
@@ -565 +507 @@
             IPC_FF_NONE);
         printf(NAME ": devman_connection_devmapper: forwarded connection to "
-            "device %s to driver %s.\n", fun->pathname, dev->drv->name);
+            "device %s to driver %s.\n", dev->pathname, dev->drv->name);
 }