Changes in uspace/lib/drv/generic/driver.c [79a141a:f278930] in mainline

File:

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

uspace/lib/drv/generic/driver.c

@@ -63 +63 @@
 
 /** Devices */
+LIST_INITIALIZE(devices);
+FIBRIL_MUTEX_INITIALIZE(devices_mutex);
+
+/** Functions */
 LIST_INITIALIZE(functions);
 FIBRIL_MUTEX_INITIALIZE(functions_mutex);
@@ -82 +86 @@
 static ddf_dev_t *create_device(void);
 static void delete_device(ddf_dev_t *);
+static void dev_add_ref(ddf_dev_t *);
+static void dev_del_ref(ddf_dev_t *);
+static void fun_add_ref(ddf_fun_t *);
+static void fun_del_ref(ddf_fun_t *);
 static remote_handler_t *function_get_default_handler(ddf_fun_t *);
 static void *function_get_ops(ddf_fun_t *, dev_inferface_idx_t);
@@ -139 +147 @@
 find_interrupt_context_by_id(interrupt_context_list_t *list, int id)
 {
+        interrupt_context_t *ctx;
+        
         fibril_mutex_lock(&list->mutex);
         
-        link_t *link = list->contexts.next;
-        interrupt_context_t *ctx;
-        
-        while (link != &list->contexts) {
+        list_foreach(list->contexts, link) {
                 ctx = list_get_instance(link, interrupt_context_t, link);
                 if (ctx->id == id) {
@@ -150 +157 @@
                         return ctx;
                 }
-                link = link->next;
         }
         
@@ -160 +166 @@
 find_interrupt_context(interrupt_context_list_t *list, ddf_dev_t *dev, int irq)
 {
+        interrupt_context_t *ctx;
+        
         fibril_mutex_lock(&list->mutex);
         
-        link_t *link = list->contexts.next;
-        interrupt_context_t *ctx;
-        
-        while (link != &list->contexts) {
+        list_foreach(list->contexts, link) {
                 ctx = list_get_instance(link, interrupt_context_t, link);
                 if (ctx->irq == irq && ctx->dev == dev) {
@@ -171 +176 @@
                         return ctx;
                 }
-                link = link->next;
         }
         
@@ -231 +235 @@
 }
 
-static ddf_fun_t *driver_get_function(link_t *functions, devman_handle_t handle)
+static ddf_dev_t *driver_get_device(devman_handle_t handle)
+{
+        ddf_dev_t *dev = NULL;
+        
+        assert(fibril_mutex_is_locked(&devices_mutex));
+        
+        list_foreach(devices, link) {
+                dev = list_get_instance(link, ddf_dev_t, link);
+                if (dev->handle == handle)
+                        return dev;
+        }
+        
+        return NULL;
+}
+
+static ddf_fun_t *driver_get_function(devman_handle_t handle)
 {
         ddf_fun_t *fun = NULL;
         
-        fibril_mutex_lock(&functions_mutex);
-        link_t *link = functions->next;
-        
-        while (link != functions) {
+        assert(fibril_mutex_is_locked(&functions_mutex));
+        
+        list_foreach(functions, link) {
                 fun = list_get_instance(link, ddf_fun_t, link);
-                if (fun->handle == handle) {
-                        fibril_mutex_unlock(&functions_mutex);
+                if (fun->handle == handle)
                         return fun;
-                }
-                
-                link = link->next;
-        }
-        
-        fibril_mutex_unlock(&functions_mutex);
+        }
         
         return NULL;
 }
 
-static void driver_add_device(ipc_callid_t iid, ipc_call_t *icall)
+static void driver_dev_add(ipc_callid_t iid, ipc_call_t *icall)
 {
         char *dev_name = NULL;
@@ -262 +274 @@
         
         ddf_dev_t *dev = create_device();
+
+        /* Add one reference that will be dropped by driver_dev_remove() */
+        dev_add_ref(dev);
         dev->handle = dev_handle;
 
@@ -274 +289 @@
         
         res = driver->driver_ops->add_device(dev);
-        if (res != EOK)
-                delete_device(dev);
+        
+        if (res != EOK) {
+                dev_del_ref(dev);
+                async_answer_0(iid, res);
+                return;
+        }
+        
+        fibril_mutex_lock(&devices_mutex);
+        list_append(&dev->link, &devices);
+        fibril_mutex_unlock(&devices_mutex);
         
         async_answer_0(iid, res);
+}
+
+static void driver_dev_remove(ipc_callid_t iid, ipc_call_t *icall)
+{
+        devman_handle_t devh;
+        ddf_dev_t *dev;
+        int rc;
+        
+        devh = IPC_GET_ARG1(*icall);
+        
+        fibril_mutex_lock(&devices_mutex);
+        dev = driver_get_device(devh);
+        if (dev != NULL)
+                dev_add_ref(dev);
+        fibril_mutex_unlock(&devices_mutex);
+        
+        if (dev == NULL) {
+                async_answer_0(iid, ENOENT);
+                return;
+        }
+        
+        if (driver->driver_ops->dev_remove != NULL)
+                rc = driver->driver_ops->dev_remove(dev);
+        else
+                rc = ENOTSUP;
+        
+        if (rc == EOK)
+                dev_del_ref(dev);
+        
+        async_answer_0(iid, (sysarg_t) rc);
+}
+
+static void driver_fun_online(ipc_callid_t iid, ipc_call_t *icall)
+{
+        devman_handle_t funh;
+        ddf_fun_t *fun;
+        int rc;
+        
+        funh = IPC_GET_ARG1(*icall);
+        
+        /*
+         * Look the function up. Bump reference count so that
+         * the function continues to exist until we return
+         * from the driver.
+         */
+        fibril_mutex_lock(&functions_mutex);
+        
+        fun = driver_get_function(funh);
+        if (fun != NULL)
+                fun_add_ref(fun);
+        
+        fibril_mutex_unlock(&functions_mutex);
+        
+        if (fun == NULL) {
+                async_answer_0(iid, ENOENT);
+                return;
+        }
+        
+        /* Call driver entry point */
+        if (driver->driver_ops->fun_online != NULL)
+                rc = driver->driver_ops->fun_online(fun);
+        else
+                rc = ENOTSUP;
+        
+        fun_del_ref(fun);
+        
+        async_answer_0(iid, (sysarg_t) rc);
+}
+
+static void driver_fun_offline(ipc_callid_t iid, ipc_call_t *icall)
+{
+        devman_handle_t funh;
+        ddf_fun_t *fun;
+        int rc;
+        
+        funh = IPC_GET_ARG1(*icall);
+        
+        /*
+         * Look the function up. Bump reference count so that
+         * the function continues to exist until we return
+         * from the driver.
+         */
+        fibril_mutex_lock(&functions_mutex);
+        
+        fun = driver_get_function(funh);
+        if (fun != NULL)
+                fun_add_ref(fun);
+        
+        fibril_mutex_unlock(&functions_mutex);
+        
+        if (fun == NULL) {
+                async_answer_0(iid, ENOENT);
+                return;
+        }
+        
+        /* Call driver entry point */
+        if (driver->driver_ops->fun_offline != NULL)
+                rc = driver->driver_ops->fun_offline(fun);
+        else
+                rc = ENOTSUP;
+        
+        async_answer_0(iid, (sysarg_t) rc);
 }
 
@@ -293 +418 @@
                 
                 switch (IPC_GET_IMETHOD(call)) {
-                case DRIVER_ADD_DEVICE:
-                        driver_add_device(callid, &call);
+                case DRIVER_DEV_ADD:
+                        driver_dev_add(callid, &call);
+                        break;
+                case DRIVER_DEV_REMOVE:
+                        driver_dev_remove(callid, &call);
+                        break;
+                case DRIVER_FUN_ONLINE:
+                        driver_fun_online(callid, &call);
+                        break;
+                case DRIVER_FUN_OFFLINE:
+                        driver_fun_offline(callid, &call);
                         break;
                 default:
-                        async_answer_0(callid, ENOENT);
+                        async_answer_0(callid, ENOTSUP);
                 }
         }
@@ -315 +449 @@
          */
         devman_handle_t handle = IPC_GET_ARG2(*icall);
-        ddf_fun_t *fun = driver_get_function(&functions, handle);
+
+        fibril_mutex_lock(&functions_mutex);
+        ddf_fun_t *fun = driver_get_function(handle);
+        fibril_mutex_unlock(&functions_mutex);
+        /* XXX Need a lock on fun */
         
         if (fun == NULL) {
@@ -321 +459 @@
                     " %" PRIun " was found.\n", driver->name, handle);
                 async_answer_0(iid, ENOENT);
+                return;
+        }
+        
+        if (fun->conn_handler != NULL) {
+                /* Driver has a custom connection handler. */
+                (*fun->conn_handler)(iid, icall, (void *)fun);
                 return;
         }
@@ -427 +571 @@
 
 /** Function for handling connections to device driver. */
-static void driver_connection(ipc_callid_t iid, ipc_call_t *icall)
-{
+static void driver_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
+{
+        sysarg_t conn_type;
+
+        if (iid == 0) {
+                /* Callback connection from devman */
+                /* XXX Use separate handler for this type of connection */
+                conn_type = DRIVER_DEVMAN;
+        } else {
+                conn_type = IPC_GET_ARG1(*icall);
+        }
+
         /* Select interface */
-        switch ((sysarg_t) (IPC_GET_ARG1(*icall))) {
+        switch (conn_type) {
         case DRIVER_DEVMAN:
                 /* Handle request from device manager */
@@ -457 +611 @@
         ddf_dev_t *dev;
 
-        dev = malloc(sizeof(ddf_dev_t));
+        dev = calloc(1, sizeof(ddf_dev_t));
         if (dev == NULL)
                 return NULL;
 
-        memset(dev, 0, sizeof(ddf_dev_t));
         return dev;
 }
@@ -489 +642 @@
 static void delete_device(ddf_dev_t *dev)
 {
+        if (dev->driver_data != NULL)
+                free(dev->driver_data);
         free(dev);
 }
 
-/** Delete device structure.
+/** Delete function structure.
  *
  * @param dev           The device structure.
@@ -499 +654 @@
 {
         clean_match_ids(&fun->match_ids);
+        if (fun->driver_data != NULL)
+                free(fun->driver_data);
         if (fun->name != NULL)
                 free(fun->name);
@@ -504 +661 @@
 }
 
+/** Increase device reference count. */
+static void dev_add_ref(ddf_dev_t *dev)
+{
+        atomic_inc(&dev->refcnt);
+}
+
+/** Decrease device reference count.
+ *
+ * Free the device structure if the reference count drops to zero.
+ */
+static void dev_del_ref(ddf_dev_t *dev)
+{
+        if (atomic_predec(&dev->refcnt) == 0)
+                delete_device(dev);
+}
+
+/** Increase function reference count.
+ *
+ * This also increases reference count on the device. The device structure
+ * will thus not be deallocated while there are some associated function
+ * structures.
+ */
+static void fun_add_ref(ddf_fun_t *fun)
+{
+        dev_add_ref(fun->dev);
+        atomic_inc(&fun->refcnt);
+}
+
+/** Decrease function reference count.
+ *
+ * Free the function structure if the reference count drops to zero.
+ */
+static void fun_del_ref(ddf_fun_t *fun)
+{
+        ddf_dev_t *dev = fun->dev;
+
+        if (atomic_predec(&fun->refcnt) == 0)
+                delete_function(fun);
+
+        dev_del_ref(dev);
+}
+
+/** Allocate driver-specific device data. */
+extern void *ddf_dev_data_alloc(ddf_dev_t *dev, size_t size)
+{
+        void *data;
+
+        assert(dev->driver_data == NULL);
+
+        data = calloc(1, size);
+        if (data == NULL)
+                return NULL;
+
+        dev->driver_data = data;
+        return data;
+}
+
 /** Create a DDF function node.
  *
@@ -535 +749 @@
                 return NULL;
 
+        /* Add one reference that will be dropped by ddf_fun_destroy() */
+        fun->dev = dev;
+        fun_add_ref(fun);
+
         fun->bound = false;
-        fun->dev = dev;
         fun->ftype = ftype;
 
@@ -548 +765 @@
 }
 
+/** Allocate driver-specific function data. */
+extern void *ddf_fun_data_alloc(ddf_fun_t *fun, size_t size)
+{
+        void *data;
+
+        assert(fun->bound == false);
+        assert(fun->driver_data == NULL);
+
+        data = calloc(1, size);
+        if (data == NULL)
+                return NULL;
+
+        fun->driver_data = data;
+        return data;
+}
+
 /** Destroy DDF function node.
  *
@@ -558 +791 @@
 {
         assert(fun->bound == false);
-        delete_function(fun);
+
+        /*
+         * Drop the reference added by ddf_fun_create(). This will deallocate
+         * the function as soon as all other references are dropped (i.e.
+         * as soon control leaves all driver entry points called in context
+         * of this function.
+         */
+        fun_del_ref(fun);
 }
 
@@ -583 +823 @@
 int ddf_fun_bind(ddf_fun_t *fun)
 {
+        assert(fun->bound == false);
         assert(fun->name != NULL);
         
@@ -599 +840 @@
 }
 
+/** Unbind a function node.
+ *
+ * Unbind the specified function from the system. This effectively makes
+ * the function invisible to the system.
+ *
+ * @param fun           Function to unbind
+ * @return              EOK on success or negative error code
+ */
+int ddf_fun_unbind(ddf_fun_t *fun)
+{
+        int res;
+        
+        assert(fun->bound == true);
+        
+        res = devman_remove_function(fun->handle);
+        if (res != EOK)
+                return res;
+
+        remove_from_functions_list(fun);
+        
+        fun->bound = false;
+        return EOK;
+}
+
+/** Online function.
+ *
+ * @param fun           Function to online
+ * @return              EOK on success or negative error code
+ */
+int ddf_fun_online(ddf_fun_t *fun)
+{
+        int res;
+        
+        assert(fun->bound == true);
+        
+        res = devman_drv_fun_online(fun->handle);
+        if (res != EOK)
+                return res;
+        
+        return EOK;
+}
+
+/** Offline function.
+ *
+ * @param fun           Function to offline
+ * @return              EOK on success or negative error code
+ */
+int ddf_fun_offline(ddf_fun_t *fun)
+{
+        int res;
+        
+        assert(fun->bound == true);
+        
+        res = devman_drv_fun_offline(fun->handle);
+        if (res != EOK)
+                return res;
+        
+        return EOK;
+}
+
 /** Add single match ID to inner function.
  *
@@ -621 +922 @@
                 return ENOMEM;
         
-        match_id->id = match_id_str;
+        match_id->id = str_dup(match_id_str);
         match_id->score = 90;
         
@@ -636 +937 @@
 }
 
-/** Add exposed function to class.
+/** Add exposed function to category.
  *
  * Must only be called when the function is bound.
  */
-int ddf_fun_add_to_class(ddf_fun_t *fun, const char *class_name)
+int ddf_fun_add_to_category(ddf_fun_t *fun, const char *cat_name)
 {
         assert(fun->bound == true);
         assert(fun->ftype == fun_exposed);
         
-        return devman_add_device_to_class(fun->handle, class_name);
+        return devman_add_device_to_category(fun->handle, cat_name);
 }