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

Timestamp:

2011-09-24T14:20:29Z (13 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

5bf76c1

Parents:

867e2555 (diff), 1ab4aca (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) (18 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);
@@ -227 +235 @@
 }
 
-static ddf_fun_t *driver_get_function(list_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);
-        
-        list_foreach(*functions, link) {
+        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;
-                }
-        }
-        
-        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;
@@ -252 +271 @@
         
         devman_handle_t dev_handle = IPC_GET_ARG1(*icall);
-        devman_handle_t parent_fun_handle = IPC_GET_ARG2(*icall);
+        devman_handle_t parent_fun_handle = IPC_GET_ARG2(*icall);
         
         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;
 
@@ -267 +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_dev_gone(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_gone != NULL)
+                rc = driver->driver_ops->dev_gone(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);
 }
 
@@ -286 +448 @@
                 
                 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_DEV_GONE:
+                        driver_dev_gone(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);
                 }
         }
@@ -308 +482 @@
          */
         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) {
@@ -428 +606 @@
 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 */
@@ -456 +644 @@
         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;
 }
@@ -488 +675 @@
 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.
@@ -498 +687 @@
 {
         clean_match_ids(&fun->match_ids);
+        if (fun->driver_data != NULL)
+                free(fun->driver_data);
         if (fun->name != NULL)
                 free(fun->name);
@@ -503 +694 @@
 }
 
+/** 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.
  *
@@ -534 +782 @@
                 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;
 
@@ -547 +798 @@
 }
 
+/** 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.
  *
@@ -557 +824 @@
 {
         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);
 }
 
@@ -582 +856 @@
 int ddf_fun_bind(ddf_fun_t *fun)
 {
+        assert(fun->bound == false);
         assert(fun->name != NULL);
         
@@ -598 +873 @@
 }
 
+/** 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.
  *
@@ -635 +970 @@
 }
 
-/** 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);
 }