Changes in uspace/lib/drv/generic/driver.c [3e6a98c5:58563585] in mainline

File:

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

uspace/lib/drv/generic/driver.c

@@ -36 +36 @@
 /** @file
  */
-
-#define _DDF_DATA_IMPLANT
 
 #include <assert.h>
@@ -51 +49 @@
 #include <str_error.h>
 #include <ctype.h>
-#include <errno.h>
 #include <inttypes.h>
 #include <devman.h>
-
-#include <ipc/driver.h>
 
 #include "dev_iface.h"
@@ -63 +58 @@
 
 /** Driver structure */
-static driver_t *driver;
+static const driver_t *driver;
 
 /** Devices */
@@ -98 +93 @@
 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);
+        list_foreach(devices, link, ddf_dev_t, dev) {
                 if (dev->handle == handle)
                         return dev;
@@ -113 +105 @@
 static ddf_fun_t *driver_get_function(devman_handle_t handle)
 {
-        ddf_fun_t *fun = NULL;
-        
         assert(fibril_mutex_is_locked(&functions_mutex));
         
-        list_foreach(functions, link) {
-                fun = list_get_instance(link, ddf_fun_t, link);
+        list_foreach(functions, link, ddf_fun_t, fun) {
                 if (fun->handle == handle)
                         return fun;
@@ -131 +120 @@
         devman_handle_t parent_fun_handle = IPC_GET_ARG2(*icall);
         
+        char *dev_name = NULL;
+        int rc = async_data_write_accept((void **) &dev_name, true, 0, 0, 0, 0);
+        if (rc != EOK) {
+                async_answer_0(iid, rc);
+                return;
+        }
+        
         ddf_dev_t *dev = create_device();
+        if (!dev) {
+                free(dev_name);
+                async_answer_0(iid, ENOMEM);
+                return;
+        }
         
         /* Add one reference that will be dropped by driver_dev_remove() */
         dev_add_ref(dev);
         dev->handle = dev_handle;
-        
-        char *dev_name = NULL;
-        async_data_write_accept((void **) &dev_name, true, 0, 0, 0, 0);
         dev->name = dev_name;
         
@@ -286 +284 @@
 }
 
-static void driver_connection_devman(ipc_callid_t iid, ipc_call_t *icall)
+static void driver_connection_devman(ipc_callid_t iid, ipc_call_t *icall,
+    void *arg)
 {
         /* Accept connection */
@@ -336 +335 @@
         fibril_mutex_lock(&functions_mutex);
         ddf_fun_t *fun = driver_get_function(handle);
+        if (fun != NULL)
+                fun_add_ref(fun);
         fibril_mutex_unlock(&functions_mutex);
-        /* XXX Need a lock on fun */
         
         if (fun == NULL) {
@@ -349 +349 @@
                 /* Driver has a custom connection handler. */
                 (*fun->conn_handler)(iid, icall, (void *)fun);
+                fun_del_ref(fun);
                 return;
         }
@@ -363 +364 @@
         
         async_answer_0(iid, ret);
-        if (ret != EOK)
+        if (ret != EOK) {
+                fun_del_ref(fun);
                 return;
+        }
         
         while (true) {
@@ -377 +380 @@
                                 (*fun->ops->close)(fun);
                         async_answer_0(callid, EOK);
+                        fun_del_ref(fun);
                         return;
                 }
@@ -419 +423 @@
                  * handling ("remote interface").
                  */
-                remote_iface_t *rem_iface = get_remote_iface(iface_idx);
+                const remote_iface_t *rem_iface = get_remote_iface(iface_idx);
                 assert(rem_iface != NULL);
                 
@@ -444 +448 @@
 }
 
-static void driver_connection_driver(ipc_callid_t iid, ipc_call_t *icall)
+static void driver_connection_driver(ipc_callid_t iid, ipc_call_t *icall,
+    void *arg)
 {
         driver_connection_gen(iid, icall, true);
 }
 
-static void driver_connection_client(ipc_callid_t iid, ipc_call_t *icall)
+static void driver_connection_client(ipc_callid_t iid, ipc_call_t *icall,
+    void *arg)
 {
         driver_connection_gen(iid, icall, false);
-}
-
-/** Function for handling connections to device driver. */
-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 (conn_type) {
-        case DRIVER_DEVMAN:
-                /* Handle request from device manager */
-                driver_connection_devman(iid, icall);
-                break;
-        case DRIVER_DRIVER:
-                /* Handle request from drivers of child devices */
-                driver_connection_driver(iid, icall);
-                break;
-        case DRIVER_CLIENT:
-                /* Handle request from client applications */
-                driver_connection_client(iid, icall);
-                break;
-        default:
-                /* No such interface */
-                async_answer_0(iid, ENOENT);
-        }
 }
 
@@ -530 +503 @@
         if (dev->driver_data != NULL)
                 free(dev->driver_data);
+        if (dev->name)
+                free(dev->name);
         free(dev);
 }
@@ -602 +577 @@
 }
 
-/** Implant foreign driver-specific device data.
- *
- * XXX This is used to transition USB to new interface. Do not use
- * in new code. Use of this function must be removed.
- */
-void ddf_fun_data_implant(ddf_fun_t *fun, void *data)
-{
-        assert(fun->driver_data == NULL);
-        fun->driver_data = data;
-}
-
 /** Return driver-specific device data. */
 void *ddf_dev_data_get(ddf_dev_t *dev)
@@ -639 +603 @@
  * The session will be automatically closed when @a dev is destroyed.
  *
- * @param dev   Device
- * @param mgmt  Exchange management style
- * @return      New session or NULL if session could not be created
- */
-async_sess_t *ddf_dev_parent_sess_create(ddf_dev_t *dev, exch_mgmt_t mgmt)
+ * @param dev Device
+ *
+ * @return New session or NULL if session could not be created
+ *
+ */
+async_sess_t *ddf_dev_parent_sess_create(ddf_dev_t *dev)
 {
         assert(dev->parent_sess == NULL);
-        dev->parent_sess = devman_parent_device_connect(mgmt, dev->handle,
+        dev->parent_sess = devman_parent_device_connect(dev->handle,
             IPC_FLAG_BLOCKING);
 
@@ -821 +786 @@
         assert(fun->bound == false);
         assert(fun->name != NULL);
+        assert(fun->dev != NULL);
         
         add_to_functions_list(fun);
@@ -925 +891 @@
 
 /** Set function ops. */
-void ddf_fun_set_ops(ddf_fun_t *fun, ddf_dev_ops_t *dev_ops)
+void ddf_fun_set_ops(ddf_fun_t *fun, const ddf_dev_ops_t *dev_ops)
 {
         assert(fun->conn_handler == NULL);
@@ -935 +901 @@
  * This allows handling connections the non-devman way.
  */
-void ddf_fun_set_conn_handler(ddf_fun_t *fun, async_client_conn_t conn)
+void ddf_fun_set_conn_handler(ddf_fun_t *fun, async_port_handler_t conn)
 {
         assert(fun->ops == NULL);
@@ -962 +928 @@
 }
 
-int ddf_driver_main(driver_t *drv)
+int ddf_driver_main(const driver_t *drv)
 {
         /*
@@ -970 +936 @@
         driver = drv;
         
-        /* Initialize interrupt module */
-        interrupt_init();
-        
         /*
          * Register driver with device manager using generic handler for
          * incoming connections.
          */
-        async_set_client_connection(driver_connection);
-        int rc = devman_driver_register(driver->name);
+        port_id_t port;
+        int rc = async_create_port(INTERFACE_DDF_DRIVER, driver_connection_driver,
+            NULL, &port);
+        if (rc != EOK)
+                return rc;
+        
+        rc = async_create_port(INTERFACE_DDF_DEVMAN, driver_connection_devman,
+            NULL, &port);
+        if (rc != EOK)
+                return rc;
+        
+        async_set_fallback_port_handler(driver_connection_client, NULL);
+        
+        rc = devman_driver_register(driver->name);
         if (rc != EOK) {
                 printf("Error: Failed to register driver with device manager "
-                    "(%s).\n", (rc == EEXISTS) ? "driver already started" :
+                    "(%s).\n", (rc == EEXIST) ? "driver already started" :
                     str_error(rc));