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

Timestamp:

2011-05-12T16:49:44Z (14 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

f36787d7

Parents:

e80329d6 (diff), 750636a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes.

File:

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

uspace/lib/drv/generic/driver.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2010 Lenka Trochtova
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -46 +47 @@
 #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 "driver.h"
-
-/* driver structure */
-
+#include "dev_iface.h"
+#include "ddf/driver.h"
+#include "ddf/interrupt.h"
+
+/** Driver structure */
 static driver_t *driver;
 
-/* devices */
-
-LIST_INITIALIZE(devices);
-FIBRIL_MUTEX_INITIALIZE(devices_mutex);
-
-/* interrupts */
-
+/** Devices */
+LIST_INITIALIZE(functions);
+FIBRIL_MUTEX_INITIALIZE(functions_mutex);
+
+/** Interrupts */
 static interrupt_context_list_t interrupt_contexts;
 
@@ -77 +80 @@
 };
 
+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)
 {
-        int id = (int)IPC_GET_METHOD(*icall);
+        int id = (int)IPC_GET_IMETHOD(*icall);
         interrupt_context_t *ctx;
         
         ctx = find_interrupt_context_by_id(&interrupt_contexts, id);
-        if (NULL != ctx && NULL != ctx->handler)
+        if (ctx != NULL && ctx->handler != NULL)
                 (*ctx->handler)(ctx->dev, iid, icall);
 }
 
+interrupt_context_t *create_interrupt_context(void)
+{
+        interrupt_context_t *ctx;
+        
+        ctx = (interrupt_context_t *) malloc(sizeof(interrupt_context_t));
+        if (ctx != NULL)
+                memset(ctx, 0, sizeof(interrupt_context_t));
+        
+        return ctx;
+}
+
+void delete_interrupt_context(interrupt_context_t *ctx)
+{
+        if (ctx != NULL)
+                free(ctx);
+}
+
+void init_interrupt_context_list(interrupt_context_list_t *list)
+{
+        memset(list, 0, sizeof(interrupt_context_list_t));
+        fibril_mutex_initialize(&list->mutex);
+        list_initialize(&list->contexts);
+}
+
+void
+add_interrupt_context(interrupt_context_list_t *list, interrupt_context_t *ctx)
+{
+        fibril_mutex_lock(&list->mutex);
+        ctx->id = list->curr_id++;
+        list_append(&ctx->link, &list->contexts);
+        fibril_mutex_unlock(&list->mutex);
+}
+
+void remove_interrupt_context(interrupt_context_list_t *list,
+    interrupt_context_t *ctx)
+{
+        fibril_mutex_lock(&list->mutex);
+        list_remove(&ctx->link);
+        fibril_mutex_unlock(&list->mutex);
+}
+
+interrupt_context_t *
+find_interrupt_context_by_id(interrupt_context_list_t *list, int id)
+{
+        fibril_mutex_lock(&list->mutex);
+        
+        link_t *link = list->contexts.next;
+        interrupt_context_t *ctx;
+        
+        while (link != &list->contexts) {
+                ctx = list_get_instance(link, interrupt_context_t, link);
+                if (ctx->id == id) {
+                        fibril_mutex_unlock(&list->mutex);
+                        return ctx;
+                }
+                link = link->next;
+        }
+        
+        fibril_mutex_unlock(&list->mutex);
+        return NULL;
+}
+
+interrupt_context_t *
+find_interrupt_context(interrupt_context_list_t *list, ddf_dev_t *dev, int irq)
+{
+        fibril_mutex_lock(&list->mutex);
+        
+        link_t *link = list->contexts.next;
+        interrupt_context_t *ctx;
+        
+        while (link != &list->contexts) {
+                ctx = list_get_instance(link, interrupt_context_t, link);
+                if (ctx->irq == irq && ctx->dev == dev) {
+                        fibril_mutex_unlock(&list->mutex);
+                        return ctx;
+                }
+                link = link->next;
+        }
+        
+        fibril_mutex_unlock(&list->mutex);
+        return NULL;
+}
+
+
 int
-register_interrupt_handler(device_t *dev, int irq, interrupt_handler_t *handler,
+register_interrupt_handler(ddf_dev_t *dev, int irq, interrupt_handler_t *handler,
     irq_code_t *pseudocode)
 {
@@ -100 +191 @@
         add_interrupt_context(&interrupt_contexts, ctx);
         
-        if (NULL == pseudocode)
+        if (pseudocode == NULL)
                 pseudocode = &default_pseudocode;
         
-        int res = ipc_register_irq(irq, dev->handle, ctx->id, pseudocode);
-        if (0 != res) {
+        int res = register_irq(irq, dev->handle, ctx->id, pseudocode);
+        if (res != EOK) {
                 remove_interrupt_context(&interrupt_contexts, ctx);
                 delete_interrupt_context(ctx);
@@ -112 +203 @@
 }
 
-int unregister_interrupt_handler(device_t *dev, int irq)
+int unregister_interrupt_handler(ddf_dev_t *dev, int irq)
 {
         interrupt_context_t *ctx = find_interrupt_context(&interrupt_contexts,
             dev, irq);
-        int res = ipc_unregister_irq(irq, dev->handle);
-
-        if (NULL != ctx) {
+        int res = unregister_irq(irq, dev->handle);
+        
+        if (ctx != NULL) {
                 remove_interrupt_context(&interrupt_contexts, ctx);
                 delete_interrupt_context(ctx);
         }
+        
         return res;
 }
 
-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, device_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 (handle == dev->handle) {
-                        fibril_mutex_unlock(&devices_mutex);
-                        return dev;
+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;
                 }
+                
                 link = link->next;
         }
-        fibril_mutex_unlock(&devices_mutex);
-
+        
+        fibril_mutex_unlock(&functions_mutex);
+        
         return NULL;
 }
@@ -161 +256 @@
 {
         char *dev_name = NULL;
-        int res = EOK;
-        
-        device_handle_t dev_handle =  IPC_GET_ARG1(*icall);
-        device_t *dev = create_device();
+        int res;
+        
+        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();
         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);
+
+        /*
+         * 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);
-        if (0 == res) {
-                printf("%s: new device with handle = %x was added.\n",
-                    driver->name, dev_handle);
-        } else {
-                printf("%s: failed to add a new device with handle = %d.\n",
-                    driver->name, dev_handle);
-                remove_from_devices_list(dev);
+        if (res != EOK)
                 delete_device(dev);
-        }
-        
-        ipc_answer_0(iid, res);
+        
+        async_answer_0(iid, res);
 }
 
@@ -188 +283 @@
 {
         /* Accept connection */
-        ipc_answer_0(iid, EOK);
-
+        async_answer_0(iid, EOK);
+        
         bool cont = true;
         while (cont) {
                 ipc_call_t call;
                 ipc_callid_t callid = async_get_call(&call);
-
-                switch (IPC_GET_METHOD(call)) {
+                
+                switch (IPC_GET_IMETHOD(call)) {
                 case IPC_M_PHONE_HUNGUP:
                         cont = false;
@@ -203 +298 @@
                         break;
                 default:
-                        if (!(callid & IPC_CALLID_NOTIFICATION))
-                                ipc_answer_0(callid, ENOENT);
+                        async_answer_0(callid, ENOENT);
                 }
         }
@@ -221 +315 @@
          * the device to which the client connected.
          */
-        device_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"
-                    " %x was found.\n", driver->name, handle);
-                ipc_answer_0(iid, ENOENT);
+        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"
+                    " %" PRIun " was found.\n", driver->name, handle);
+                async_answer_0(iid, ENOENT);
                 return;
         }
@@ -236 +330 @@
          * use the device.
          */
-
+        
         int ret = EOK;
-        /* open the device */
-        if (NULL != dev->ops && NULL != dev->ops->open)
-                ret = (*dev->ops->open)(dev);
-        
-        ipc_answer_0(iid, ret); 
-        if (EOK != ret)
+        /* Open device function */
+        if (fun->ops != NULL && fun->ops->open != NULL)
+                ret = (*fun->ops->open)(fun);
+        
+        async_answer_0(iid, ret);
+        if (ret != EOK)
                 return;
-
+        
         while (1) {
                 ipc_callid_t callid;
                 ipc_call_t call;
                 callid = async_get_call(&call);
-                ipcarg_t method = IPC_GET_METHOD(call);
+                sysarg_t method = IPC_GET_IMETHOD(call);
                 int iface_idx;
                 
                 switch  (method) {
-                case IPC_M_PHONE_HUNGUP:                
-                        /* close the device */
-                        if (NULL != dev->ops && NULL != dev->ops->close)
-                                (*dev->ops->close)(dev);
-                        ipc_answer_0(callid, EOK);
+                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);
                         return;
-                default:                
+                default:
                         /* convert ipc interface id to interface index */
                         
@@ -267 +361 @@
                         if (!is_valid_iface_idx(iface_idx)) {
                                 remote_handler_t *default_handler =
-                                    device_get_default_handler(dev);
-                                if (NULL != default_handler) {
-                                        (*default_handler)(dev, callid, &call);
+                                    function_get_default_handler(fun);
+                                if (default_handler != NULL) {
+                                        (*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.
                                  */
@@ -279 +374 @@
                                     "invalid interface id %d.",
                                     driver->name, iface_idx);
-                                ipc_answer_0(callid, ENOTSUP);
+                                async_answer_0(callid, ENOTSUP);
                                 break;
                         }
-
-                        /* calling one of the device's interfaces */
                         
-                        /* get the device interface structure */
-                        void *iface = device_get_iface(dev, iface_idx);
-                        if (NULL == iface) {
+                        /* calling one of the function's interfaces */
+                        
+                        /* Get the interface ops structure. */
+                        void *ops = function_get_ops(fun, iface_idx);
+                        if (ops == NULL) {
                                 printf("%s: driver_connection_gen error - ",
                                     driver->name);
-                                printf("device with handle %d has no interface "
+                                printf("Function with handle %" PRIun " has no interface "
                                     "with id %d.\n", handle, iface_idx);
-                                ipc_answer_0(callid, ENOTSUP);
+                                async_answer_0(callid, ENOTSUP);
                                 break;
                         }
-
+                        
                         /*
                          * Get the corresponding interface for remote request
                          * handling ("remote interface").
                          */
-                        remote_iface_t* rem_iface = get_remote_iface(iface_idx);
-                        assert(NULL != rem_iface);
-
+                        remote_iface_t *rem_iface = get_remote_iface(iface_idx);
+                        assert(rem_iface != NULL);
+                        
                         /* get the method of the remote interface */
-                        ipcarg_t iface_method_idx = IPC_GET_ARG1(call);
+                        sysarg_t iface_method_idx = IPC_GET_ARG1(call);
                         remote_iface_func_ptr_t iface_method_ptr =
                             get_remote_method(rem_iface, iface_method_idx);
-                        if (NULL == iface_method_ptr) {
-                                // the interface has not such method
+                        if (iface_method_ptr == NULL) {
+                                /* The interface has not such method */
                                 printf("%s: driver_connection_gen error - "
                                     "invalid interface method.", driver->name);
-                                ipc_answer_0(callid, ENOTSUP);
+                                async_answer_0(callid, ENOTSUP);
                                 break;
                         }
@@ -319 +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, iface, callid, &call);
+                        (*iface_method_ptr)(fun, ops, callid, &call);
                         break;
                 }
@@ -337 +432 @@
 }
 
-
 /** Function for handling connections to device driver. */
 static void driver_connection(ipc_callid_t iid, ipc_call_t *icall)
 {
         /* Select interface */
-        switch ((ipcarg_t) (IPC_GET_ARG1(*icall))) {
+        switch ((sysarg_t) (IPC_GET_ARG1(*icall))) {
         case DRIVER_DEVMAN:
-                /* handle PnP events from device manager */
+                /* Handle request from device manager */
                 driver_connection_devman(iid, icall);
                 break;
         case DRIVER_DRIVER:
-                /* handle request from drivers of child devices */
+                /* Handle request from drivers of child devices */
                 driver_connection_driver(iid, icall);
                 break;
         case DRIVER_CLIENT:
-                /* handle requests from client applications */
+                /* Handle request from client applications */
                 driver_connection_client(iid, icall);
                 break;
-
         default:
                 /* No such interface */
-                ipc_answer_0(iid, ENOENT);
-        }
-}
-
-int child_device_register(device_t *child, device_t *parent)
-{
-        assert(NULL != child->name);
-
+                async_answer_0(iid, ENOENT);
+        }
+}
+
+/** Create new device structure.
+ *
+ * @return              The device structure.
+ */
+static ddf_dev_t *create_device(void)
+{
+        ddf_dev_t *dev;
+
+        dev = malloc(sizeof(ddf_dev_t));
+        if (dev == 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 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_devices_list(child);
-        res = devman_child_device_register(child->name, &child->match_ids,
-            parent->handle, &child->handle);
-        if (EOK == 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;
-        remove_from_devices_list(child);        
+        }
+        
+        fun->bound = true;
         return res;
 }
 
-int driver_main(driver_t *drv)
-{
+/** 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;
+
         /*
          * Remember the driver structure - driver_ops will be called by generic
@@ -384 +663 @@
          */
         driver = drv;
-
+        
         /* Initialize the list of interrupt contexts. */
         init_interrupt_context_list(&interrupt_contexts);
@@ -392 +671 @@
         
         /*
-         * Register driver by device manager with generic handler for incoming
-         * connections.
+         * Register driver with device manager using generic handler for
+         * incoming connections.
          */
-        devman_driver_register(driver->name, driver_connection);
+        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;
 
         async_manager();
-
+        
         /* Never reached. */
         return 0;