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

Timestamp:

2011-02-11T22:26:36Z (13 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

68414f4a

Parents:

1b367b4

Message:

Finish splitting device node: devman client in C library, drv library. Update device drivers accordingly.

File:

• uspace/lib/drv/generic/driver.c (modified) (16 diffs)

uspace/lib/drv/generic/driver.c

@@ -59 +59 @@
 
 /** Devices */
-LIST_INITIALIZE(devices);
-FIBRIL_MUTEX_INITIALIZE(devices_mutex);
+LIST_INITIALIZE(functions);
+FIBRIL_MUTEX_INITIALIZE(functions_mutex);
 
 /** Interrupts */
@@ -209 +209 @@
 }
 
-static void add_to_devices_list(device_t *dev)
-{
-        fibril_mutex_lock(&devices_mutex);
-        list_append(&dev->link, &devices);
-        fibril_mutex_unlock(&devices_mutex);
-}
-
-static void remove_from_devices_list(device_t *dev)
-{
-        fibril_mutex_lock(&devices_mutex);
-        list_remove(&dev->link);
-        fibril_mutex_unlock(&devices_mutex);
-}
-
-static device_t *driver_get_device(link_t *devices, devman_handle_t handle)
-{
-        device_t *dev = NULL;
-        
-        fibril_mutex_lock(&devices_mutex);
-        link_t *link = devices->next;
-        
-        while (link != devices) {
-                dev = list_get_instance(link, device_t, link);
-                if (dev->handle == handle) {
-                        fibril_mutex_unlock(&devices_mutex);
-                        return dev;
+static void add_to_functions_list(function_t *fun)
+{
+        fibril_mutex_lock(&functions_mutex);
+        list_append(&fun->link, &functions);
+        fibril_mutex_unlock(&functions_mutex);
+}
+
+static void remove_from_functions_list(function_t *fun)
+{
+        fibril_mutex_lock(&functions_mutex);
+        list_remove(&fun->link);
+        fibril_mutex_unlock(&functions_mutex);
+}
+
+static function_t *driver_get_function(link_t *functions, devman_handle_t handle)
+{
+        function_t *fun = NULL;
+        printf("driver_get_function handle=%" PRIun "\n", handle);
+        
+        fibril_mutex_lock(&functions_mutex);
+        link_t *link = functions->next;
+        
+        while (link != functions) {
+                fun = list_get_instance(link, function_t, link);
+                printf(" - fun handle %" PRIun "\n", fun->handle);
+                if (fun->handle == handle) {
+                        fibril_mutex_unlock(&functions_mutex);
+                        return fun;
                 }
+                
                 link = link->next;
         }
         
-        fibril_mutex_unlock(&devices_mutex);
+        fibril_mutex_unlock(&functions_mutex);
         
         return NULL;
@@ -250 +253 @@
         
         devman_handle_t dev_handle = IPC_GET_ARG1(*icall);
-        devman_handle_t parent_dev_handle = IPC_GET_ARG2(*icall);
+        devman_handle_t parent_fun_handle = IPC_GET_ARG2(*icall);
         
         device_t *dev = create_device();
         dev->handle = dev_handle;
-        
+
         async_data_write_accept((void **) &dev_name, true, 0, 0, 0, 0);
         dev->name = dev_name;
-        
-        add_to_devices_list(dev);
-        dev->parent = driver_get_device(&devices, parent_dev_handle);
+
+        /*
+         * Currently not used, parent fun handle is stored in context
+         * of the connection to the parent device driver.
+         */
+        (void) parent_fun_handle;
         
         res = driver->driver_ops->add_device(dev);
@@ -268 +274 @@
                 printf("%s: failed to add a new device with handle = %" PRIun ".\n",
                     driver->name, dev_handle);
-                remove_from_devices_list(dev);
                 delete_device(dev);
         }
@@ -311 +316 @@
          */
         devman_handle_t handle = IPC_GET_ARG2(*icall);
-        device_t *dev = driver_get_device(&devices, handle);
-
-        if (dev == NULL) {
-                printf("%s: driver_connection_gen error - no device with handle"
+        function_t *fun = driver_get_function(&functions, handle);
+
+        if (fun == NULL) {
+                printf("%s: driver_connection_gen error - no function with handle"
                     " %" PRIun " was found.\n", driver->name, handle);
                 async_answer_0(iid, ENOENT);
@@ -327 +332 @@
         
         int ret = EOK;
-        /* open the device */
-        if (dev->ops != NULL && dev->ops->open != NULL)
-                ret = (*dev->ops->open)(dev);
+        /* Open device function */
+        if (fun->ops != NULL && fun->ops->open != NULL)
+                ret = (*fun->ops->open)(fun);
         
         async_answer_0(iid, ret);
@@ -344 +349 @@
                 switch  (method) {
                 case IPC_M_PHONE_HUNGUP:
-                        /* close the device */
-                        if (dev->ops != NULL && dev->ops->close != NULL)
-                                (*dev->ops->close)(dev);
+                        /* Close device function */
+                        if (fun->ops != NULL && fun->ops->close != NULL)
+                                (*fun->ops->close)(fun);
                         async_answer_0(callid, EOK);
                         return;
@@ -356 +361 @@
                         if (!is_valid_iface_idx(iface_idx)) {
                                 remote_handler_t *default_handler =
-                                    device_get_default_handler(dev);
+                                    function_get_default_handler(fun);
                                 if (default_handler != NULL) {
-                                        (*default_handler)(dev, callid, &call);
+                                        (*default_handler)(fun, callid, &call);
                                         break;
                                 }
+                                
                                 /*
-                                 * This is not device's interface and the
+                                 * Function has no such interface and
                                  * default handler is not provided.
                                  */
@@ -372 +378 @@
                         }
                         
-                        /* calling one of the device's interfaces */
+                        /* calling one of the function's interfaces */
                         
                         /* Get the interface ops structure. */
-                        void *ops = device_get_ops(dev, iface_idx);
+                        void *ops = function_get_ops(fun, iface_idx);
                         if (ops == NULL) {
                                 printf("%s: driver_connection_gen error - ",
                                     driver->name);
-                                printf("device with handle %" PRIun " has no interface "
+                                printf("Function with handle %" PRIun " has no interface "
                                     "with id %d.\n", handle, iface_idx);
                                 async_answer_0(callid, ENOTSUP);
@@ -408 +414 @@
                          * receive parameters from the remote client and it will
                          * pass it to the corresponding local interface method
-                         * associated with the device by its driver.
+                         * associated with the function by its driver.
                          */
-                        (*iface_method_ptr)(dev, ops, callid, &call);
+                        (*iface_method_ptr)(fun, ops, callid, &call);
                         break;
                 }
@@ -425 +431 @@
         driver_connection_gen(iid, icall, false);
 }
-
 
 /** Function for handling connections to device driver. */
@@ -456 +461 @@
 device_t *create_device(void)
 {
-        device_t *dev = malloc(sizeof(device_t));
-
-        if (dev != NULL) {
-                memset(dev, 0, sizeof(device_t));
-                init_match_ids(&dev->match_ids);
-        }
-
+        device_t *dev;
+
+        dev = malloc(sizeof(device_t));
+        if (dev == NULL)
+                return NULL;
+
+        memset(dev, 0, sizeof(device_t));
         return dev;
 }
 
+/** Create new function structure.
+ *
+ * @return              The device structure.
+ */
+function_t *create_function(void)
+{
+        function_t *fun;
+
+        fun = malloc(sizeof(function_t));
+        if (fun == NULL)
+                return NULL;
+
+        memset(fun, 0, sizeof(device_t));
+
+        init_match_ids(&fun->match_ids);
+        link_initialize(&fun->link);
+
+        return fun;
+}
+
 /** Delete device structure.
  *
@@ -472 +497 @@
 void delete_device(device_t *dev)
 {
-        clean_match_ids(&dev->match_ids);
-        if (dev->name != NULL)
-                free(dev->name);
         free(dev);
 }
 
-void *device_get_ops(device_t *dev, dev_inferface_idx_t idx)
+/** Delete device structure.
+ *
+ * @param dev           The device structure.
+ */
+void delete_function(function_t *fun)
+{
+        clean_match_ids(&fun->match_ids);
+        if (fun->name != NULL)
+                free(fun->name);
+        free(fun);
+}
+
+void *function_get_ops(function_t *fun, dev_inferface_idx_t idx)
 {
         assert(is_valid_iface_idx(idx));
-        if (dev->ops == NULL)
+        if (fun->ops == NULL)
                 return NULL;
-        return dev->ops->interfaces[idx];
-}
-
-int child_device_register(device_t *child, device_t *parent)
-{
-        assert(child->name != NULL);
+        return fun->ops->interfaces[idx];
+}
+
+int register_function(function_t *fun, device_t *dev)
+{
+        assert(fun->name != NULL);
         
         int res;
         
-        add_to_devices_list(child);
-        res = devman_child_device_register(child->name, &child->match_ids,
-            parent->handle, &child->handle);
+        fun->dev = dev;
+        
+        add_to_functions_list(fun);
+        res = devman_add_function(fun->name, fun->ftype, &fun->match_ids,
+            dev->handle, &fun->handle);
         if (res != EOK) {
-                remove_from_devices_list(child);
+                remove_from_functions_list(fun);
                 return res;
         }
@@ -511 +547 @@
  * @return Error code.
  */
-int child_device_register_wrapper(device_t *parent, const char *child_name,
-    const char *child_match_id, int child_match_score)
-{
-        device_t *child = NULL;
-        match_id_t *match_id = NULL;
+int register_function_wrapper(device_t *dev, const char *fun_name,
+    const char *match_id, int match_score)
+{
+        function_t *fun = NULL;
+        match_id_t *m_id = NULL;
         int rc;
         
-        child = create_device();
-        if (child == NULL) {
+        fun = create_function();
+        if (fun == NULL) {
                 rc = ENOMEM;
                 goto failure;
         }
         
-        child->name = child_name;
-        
-        match_id = create_match_id();
-        if (match_id == NULL) {
+        fun->dev = dev;
+        fun->name = fun_name;
+        fun->ftype = fun_inner;
+        
+        m_id = create_match_id();
+        if (m_id == NULL) {
                 rc = ENOMEM;
                 goto failure;
         }
         
-        match_id->id = child_match_id;
-        match_id->score = child_match_score;
-        add_match_id(&child->match_ids, match_id);
-        
-        rc = child_device_register(child, parent);
+        m_id->id = match_id;
+        m_id->score = match_score;
+        add_match_id(&fun->match_ids, m_id);
+        
+        rc = register_function(fun, dev);
         if (rc != EOK)
                 goto failure;
@@ -543 +581 @@
         
 failure:
-        if (match_id != NULL) {
-                match_id->id = NULL;
-                delete_match_id(match_id);
-        }
-        
-        if (child != NULL) {
-                child->name = NULL;
-                delete_device(child);
+        if (m_id != NULL) {
+                m_id->id = NULL;
+                delete_match_id(m_id);
+        }
+        
+        if (fun != NULL) {
+                fun->name = NULL;
+                delete_function(fun);
         }
         
@@ -557 +595 @@
 
 /** Get default handler for client requests */
-remote_handler_t *device_get_default_handler(device_t *dev)
-{
-        if (dev->ops == NULL)
+remote_handler_t *function_get_default_handler(function_t *fun)
+{
+        if (fun->ops == NULL)
                 return NULL;
-        return dev->ops->default_handler;
-}
-
-int add_device_to_class(device_t *dev, const char *class_name)
-{
-        return devman_add_device_to_class(dev->handle, class_name);
+        return fun->ops->default_handler;
+}
+
+int add_function_to_class(function_t *fun, const char *class_name)
+{
+        return devman_add_device_to_class(fun->handle, class_name);
 }