Changes in uspace/lib/drv/generic/driver.c [26fa82bc:5fdd7c3] in mainline

File:

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

uspace/lib/drv/generic/driver.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2010 Lenka Trochtova
- * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -47 +46 @@
 #include <stdlib.h>
 #include <str.h>
-#include <str_error.h>
 #include <ctype.h>
 #include <errno.h>
 #include <inttypes.h>
-#include <devman.h>
 
 #include <ipc/driver.h>
 
 #include "dev_iface.h"
-#include "ddf/driver.h"
-#include "ddf/interrupt.h"
+#include "driver.h"
 
 /** Driver structure */
@@ -63 +59 @@
 
 /** Devices */
-LIST_INITIALIZE(functions);
-FIBRIL_MUTEX_INITIALIZE(functions_mutex);
+LIST_INITIALIZE(devices);
+FIBRIL_MUTEX_INITIALIZE(devices_mutex);
 
 /** Interrupts */
@@ -80 +76 @@
 };
 
-static ddf_dev_t *create_device(void);
-static void delete_device(ddf_dev_t *);
-static remote_handler_t *function_get_default_handler(ddf_fun_t *);
-static void *function_get_ops(ddf_fun_t *, dev_inferface_idx_t);
 
 static void driver_irq_handler(ipc_callid_t iid, ipc_call_t *icall)
@@ -158 +150 @@
 
 interrupt_context_t *
-find_interrupt_context(interrupt_context_list_t *list, ddf_dev_t *dev, int irq)
+find_interrupt_context(interrupt_context_list_t *list, device_t *dev, int irq)
 {
         fibril_mutex_lock(&list->mutex);
@@ -180 +172 @@
 
 int
-register_interrupt_handler(ddf_dev_t *dev, int irq, interrupt_handler_t *handler,
+register_interrupt_handler(device_t *dev, int irq, interrupt_handler_t *handler,
     irq_code_t *pseudocode)
 {
@@ -194 +186 @@
                 pseudocode = &default_pseudocode;
         
-        int res = register_irq(irq, dev->handle, ctx->id, pseudocode);
+        int res = ipc_register_irq(irq, dev->handle, ctx->id, pseudocode);
         if (res != EOK) {
                 remove_interrupt_context(&interrupt_contexts, ctx);
@@ -203 +195 @@
 }
 
-int unregister_interrupt_handler(ddf_dev_t *dev, int irq)
+int unregister_interrupt_handler(device_t *dev, int irq)
 {
         interrupt_context_t *ctx = find_interrupt_context(&interrupt_contexts,
             dev, irq);
-        int res = unregister_irq(irq, dev->handle);
+        int res = ipc_unregister_irq(irq, dev->handle);
         
         if (ctx != NULL) {
@@ -217 +209 @@
 }
 
-static void add_to_functions_list(ddf_fun_t *fun)
-{
-        fibril_mutex_lock(&functions_mutex);
-        list_append(&fun->link, &functions);
-        fibril_mutex_unlock(&functions_mutex);
-}
-
-static void remove_from_functions_list(ddf_fun_t *fun)
-{
-        fibril_mutex_lock(&functions_mutex);
-        list_remove(&fun->link);
-        fibril_mutex_unlock(&functions_mutex);
-}
-
-static ddf_fun_t *driver_get_function(link_t *functions, devman_handle_t handle)
-{
-        ddf_fun_t *fun = NULL;
-        
-        fibril_mutex_lock(&functions_mutex);
-        link_t *link = functions->next;
-        
-        while (link != functions) {
-                fun = list_get_instance(link, ddf_fun_t, link);
-                if (fun->handle == handle) {
-                        fibril_mutex_unlock(&functions_mutex);
-                        return fun;
+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;
                 }
-                
                 link = link->next;
         }
         
-        fibril_mutex_unlock(&functions_mutex);
+        fibril_mutex_unlock(&devices_mutex);
         
         return NULL;
@@ -259 +250 @@
         
         devman_handle_t dev_handle = IPC_GET_ARG1(*icall);
-        devman_handle_t parent_fun_handle = IPC_GET_ARG2(*icall);
-        
-        ddf_dev_t *dev = create_device();
+        devman_handle_t parent_dev_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;
-
-        /*
-         * Currently not used, parent fun handle is stored in context
-         * of the connection to the parent device driver.
-         */
-        (void) parent_fun_handle;
+        
+        add_to_devices_list(dev);
+        dev->parent = driver_get_device(&devices, parent_dev_handle);
         
         res = driver->driver_ops->add_device(dev);
-        if (res != EOK)
+        if (res == EOK) {
+                printf("%s: new device with handle=%" PRIun " was added.\n",
+                    driver->name, dev_handle);
+        } else {
+                printf("%s: failed to add a new device with handle = %" PRIun ".\n",
+                    driver->name, dev_handle);
+                remove_from_devices_list(dev);
                 delete_device(dev);
-        
-        async_answer_0(iid, res);
+        }
+        
+        ipc_answer_0(iid, res);
 }
 
@@ -283 +278 @@
 {
         /* Accept connection */
-        async_answer_0(iid, EOK);
+        ipc_answer_0(iid, EOK);
         
         bool cont = true;
@@ -298 +293 @@
                         break;
                 default:
-                        async_answer_0(callid, ENOENT);
+                        ipc_answer_0(callid, ENOENT);
                 }
         }
@@ -316 +311 @@
          */
         devman_handle_t handle = IPC_GET_ARG2(*icall);
-        ddf_fun_t *fun = driver_get_function(&functions, handle);
-
-        if (fun == NULL) {
-                printf("%s: driver_connection_gen error - no function with handle"
+        device_t *dev = driver_get_device(&devices, handle);
+
+        if (dev == NULL) {
+                printf("%s: driver_connection_gen error - no device with handle"
                     " %" PRIun " was found.\n", driver->name, handle);
-                async_answer_0(iid, ENOENT);
+                ipc_answer_0(iid, ENOENT);
                 return;
         }
@@ -332 +327 @@
         
         int ret = EOK;
-        /* Open device function */
-        if (fun->ops != NULL && fun->ops->open != NULL)
-                ret = (*fun->ops->open)(fun);
-        
-        async_answer_0(iid, ret);
+        /* open the device */
+        if (dev->ops != NULL && dev->ops->open != NULL)
+                ret = (*dev->ops->open)(dev);
+        
+        ipc_answer_0(iid, ret);
         if (ret != EOK)
                 return;
@@ -349 +344 @@
                 switch  (method) {
                 case IPC_M_PHONE_HUNGUP:
-                        /* Close device function */
-                        if (fun->ops != NULL && fun->ops->close != NULL)
-                                (*fun->ops->close)(fun);
-                        async_answer_0(callid, EOK);
+                        /* close the device */
+                        if (dev->ops != NULL && dev->ops->close != NULL)
+                                (*dev->ops->close)(dev);
+                        ipc_answer_0(callid, EOK);
                         return;
                 default:
@@ -361 +356 @@
                         if (!is_valid_iface_idx(iface_idx)) {
                                 remote_handler_t *default_handler =
-                                    function_get_default_handler(fun);
+                                    device_get_default_handler(dev);
                                 if (default_handler != NULL) {
-                                        (*default_handler)(fun, callid, &call);
+                                        (*default_handler)(dev, callid, &call);
                                         break;
                                 }
-                                
                                 /*
-                                 * Function has no such interface and
+                                 * This is not device's interface and the
                                  * default handler is not provided.
                                  */
@@ -374 +368 @@
                                     "invalid interface id %d.",
                                     driver->name, iface_idx);
-                                async_answer_0(callid, ENOTSUP);
+                                ipc_answer_0(callid, ENOTSUP);
                                 break;
                         }
                         
-                        /* calling one of the function's interfaces */
+                        /* calling one of the device's interfaces */
                         
                         /* Get the interface ops structure. */
-                        void *ops = function_get_ops(fun, iface_idx);
+                        void *ops = device_get_ops(dev, iface_idx);
                         if (ops == NULL) {
                                 printf("%s: driver_connection_gen error - ",
                                     driver->name);
-                                printf("Function with handle %" PRIun " has no interface "
+                                printf("device with handle %" PRIun " has no interface "
                                     "with id %d.\n", handle, iface_idx);
-                                async_answer_0(callid, ENOTSUP);
+                                ipc_answer_0(callid, ENOTSUP);
                                 break;
                         }
@@ -403 +397 @@
                             get_remote_method(rem_iface, iface_method_idx);
                         if (iface_method_ptr == NULL) {
-                                /* The interface has not such method */
+                                // the interface has not such method
                                 printf("%s: driver_connection_gen error - "
                                     "invalid interface method.", driver->name);
-                                async_answer_0(callid, ENOTSUP);
+                                ipc_answer_0(callid, ENOTSUP);
                                 break;
                         }
@@ -414 +408 @@
                          * receive parameters from the remote client and it will
                          * pass it to the corresponding local interface method
-                         * associated with the function by its driver.
+                         * associated with the device by its driver.
                          */
-                        (*iface_method_ptr)(fun, ops, callid, &call);
+                        (*iface_method_ptr)(dev, ops, callid, &call);
                         break;
                 }
@@ -431 +425 @@
         driver_connection_gen(iid, icall, false);
 }
+
 
 /** Function for handling connections to device driver. */
@@ -451 +446 @@
         default:
                 /* No such interface */
-                async_answer_0(iid, ENOENT);
+                ipc_answer_0(iid, ENOENT);
         }
 }
@@ -459 +454 @@
  * @return              The device structure.
  */
-static ddf_dev_t *create_device(void)
-{
-        ddf_dev_t *dev;
-
-        dev = malloc(sizeof(ddf_dev_t));
-        if (dev == NULL)
+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);
+        }
+
+        return dev;
+}
+
+/** Delete device structure.
+ *
+ * @param dev           The device structure.
+ */
+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)
+{
+        assert(is_valid_iface_idx(idx));
+        if (dev->ops == NULL)
                 return NULL;
-
-        memset(dev, 0, sizeof(ddf_dev_t));
-        return dev;
-}
-
-/** Create new function structure.
- *
- * @return              The device structure.
- */
-static ddf_fun_t *create_function(void)
-{
-        ddf_fun_t *fun;
-
-        fun = calloc(1, sizeof(ddf_fun_t));
-        if (fun == NULL)
+        return dev->ops->interfaces[idx];
+}
+
+int child_device_register(device_t *child, device_t *parent)
+{
+        assert(child->name != NULL);
+        
+        int res;
+        
+        add_to_devices_list(child);
+        res = devman_child_device_register(child->name, &child->match_ids,
+            parent->handle, &child->handle);
+        if (res != EOK) {
+                remove_from_devices_list(child);
+                return res;
+        }
+        
+        return res;
+}
+
+/** Wrapper for child_device_register for devices with single match id.
+ *
+ * @param parent Parent device.
+ * @param child_name Child device name.
+ * @param child_match_id Child device match id.
+ * @param child_match_score Child device match score.
+ * @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 rc;
+        
+        child = create_device();
+        if (child == NULL) {
+                rc = ENOMEM;
+                goto failure;
+        }
+        
+        child->name = child_name;
+        
+        match_id = create_match_id();
+        if (match_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);
+        if (rc != EOK)
+                goto failure;
+        
+        return EOK;
+        
+failure:
+        if (match_id != NULL) {
+                match_id->id = NULL;
+                delete_match_id(match_id);
+        }
+        
+        if (child != NULL) {
+                child->name = NULL;
+                delete_device(child);
+        }
+        
+        return rc;
+}
+
+/** Get default handler for client requests */
+remote_handler_t *device_get_default_handler(device_t *dev)
+{
+        if (dev->ops == NULL)
                 return NULL;
-
-        init_match_ids(&fun->match_ids);
-        link_initialize(&fun->link);
-
-        return fun;
-}
-
-/** Delete device structure.
- *
- * @param dev           The device structure.
- */
-static void delete_device(ddf_dev_t *dev)
-{
-        free(dev);
-}
-
-/** Delete device structure.
- *
- * @param dev           The device structure.
- */
-static void delete_function(ddf_fun_t *fun)
-{
-        clean_match_ids(&fun->match_ids);
-        if (fun->name != NULL)
-                free(fun->name);
-        free(fun);
-}
-
-/** Create a DDF function node.
- *
- * Create a DDF function (in memory). Both child devices and external clients
- * communicate with a device via its functions.
- *
- * The created function node is fully formed, but only exists in the memory
- * of the client task. In order to be visible to the system, the function
- * must be bound using ddf_fun_bind().
- *
- * This function should only fail if there is not enough free memory.
- * Specifically, this function succeeds even if @a dev already has
- * a (bound) function with the same name.
- *
- * Type: A function of type fun_inner indicates that DDF should attempt
- * to attach child devices to the function. fun_exposed means that
- * the function should be exported to external clients (applications).
- *
- * @param dev           Device to which we are adding function
- * @param ftype         Type of function (fun_inner or fun_exposed)
- * @param name          Name of function
- *
- * @return              New function or @c NULL if memory is not available
- */
-ddf_fun_t *ddf_fun_create(ddf_dev_t *dev, fun_type_t ftype, const char *name)
-{
-        ddf_fun_t *fun;
-
-        fun = create_function();
-        if (fun == NULL)
-                return NULL;
-
-        fun->bound = false;
-        fun->dev = dev;
-        fun->ftype = ftype;
-
-        fun->name = str_dup(name);
-        if (fun->name == NULL) {
-                delete_function(fun);
-                return NULL;
-        }
-
-        return fun;
-}
-
-/** Destroy DDF function node.
- *
- * Destroy a function previously created with ddf_fun_create(). The function
- * must not be bound.
- *
- * @param fun           Function to destroy
- */
-void ddf_fun_destroy(ddf_fun_t *fun)
-{
-        assert(fun->bound == false);
-        delete_function(fun);
-}
-
-static void *function_get_ops(ddf_fun_t *fun, dev_inferface_idx_t idx)
-{
-        assert(is_valid_iface_idx(idx));
-        if (fun->ops == NULL)
-                return NULL;
-        return fun->ops->interfaces[idx];
-}
-
-/** Bind a function node.
- *
- * Bind the specified function to the system. This effectively makes
- * the function visible to the system (uploads it to the server).
- *
- * This function can fail for several reasons. Specifically,
- * it will fail if the device already has a bound function of
- * the same name.
- *
- * @param fun           Function to bind
- * @return              EOK on success or negative error code
- */
-int ddf_fun_bind(ddf_fun_t *fun)
-{
-        assert(fun->name != NULL);
-        
-        int res;
-        
-        add_to_functions_list(fun);
-        res = devman_add_function(fun->name, fun->ftype, &fun->match_ids,
-            fun->dev->handle, &fun->handle);
-        if (res != EOK) {
-                remove_from_functions_list(fun);
-                return res;
-        }
-        
-        fun->bound = true;
-        return res;
-}
-
-/** Add single match ID to inner function.
- *
- * Construct and add a single match ID to the specified function.
- * Cannot be called when the function node is bound.
- *
- * @param fun                   Function
- * @param match_id_str          Match string
- * @param match_score           Match score
- * @return                      EOK on success, ENOMEM if out of memory.
- */
-int ddf_fun_add_match_id(ddf_fun_t *fun, const char *match_id_str,
-    int match_score)
-{
-        match_id_t *match_id;
-        
-        assert(fun->bound == false);
-        assert(fun->ftype == fun_inner);
-        
-        match_id = create_match_id();
-        if (match_id == NULL)
-                return ENOMEM;
-        
-        match_id->id = match_id_str;
-        match_id->score = 90;
-        
-        add_match_id(&fun->match_ids, match_id);
-        return EOK;
-}
-
-/** Get default handler for client requests */
-static remote_handler_t *function_get_default_handler(ddf_fun_t *fun)
-{
-        if (fun->ops == NULL)
-                return NULL;
-        return fun->ops->default_handler;
-}
-
-/** Add exposed function to class.
- *
- * Must only be called when the function is bound.
- */
-int ddf_fun_add_to_class(ddf_fun_t *fun, const char *class_name)
-{
-        assert(fun->bound == true);
-        assert(fun->ftype == fun_exposed);
-        
-        return devman_add_device_to_class(fun->handle, class_name);
-}
-
-int ddf_driver_main(driver_t *drv)
-{
-        int rc;
-
+        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);
+}
+
+int driver_main(driver_t *drv)
+{
         /*
          * Remember the driver structure - driver_ops will be called by generic
@@ -671 +584 @@
         
         /*
-         * Register driver with device manager using generic handler for
-         * incoming connections.
+         * Register driver by device manager with generic handler for incoming
+         * connections.
          */
-        rc = devman_driver_register(driver->name, driver_connection);
-        if (rc != EOK) {
-                printf("Error: Failed to register driver with device manager "
-                    "(%s).\n", (rc == EEXISTS) ? "driver already started" :
-                    str_error(rc));
-                
-                return 1;
-        }
-        
-        /* Return success from the task since server has started. */
-        rc = task_retval(0);
-        if (rc != EOK)
-                return 1;
-
+        devman_driver_register(driver->name, driver_connection);
+        
         async_manager();