Changeset b0f00a9 in mainline for uspace/lib/drv

Timestamp:

2011-11-06T22:21:05Z (14 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

898e847

Parents:

2bdf8313 (diff), 7b5f4c9 (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.

Location:

uspace/lib/drv

Files:

• Makefile (modified) (2 diffs)
• generic/dev_iface.c (modified) (2 diffs)
• generic/driver.c (modified) (26 diffs)
• generic/logbuf.c (added)
• generic/remote_nic.c (added)
• generic/remote_pci.c (added)
• generic/remote_usb.c (added)
• generic/remote_usbhc.c (added)
• generic/remote_usbhid.c (added)
• include/ddf/driver.h (modified) (6 diffs)
• include/ddf/interrupt.h (modified) (2 diffs)
• include/ddf/log.h (modified) (1 diff)
• include/ops/nic.h (added)
• include/pci_dev_iface.h (added)
• include/remote_nic.h (moved) (moved from uspace/srv/hid/fb/sgcn.h ) (2 diffs)
• include/remote_pci.h (added)
• include/remote_usb.h (added)
• include/remote_usbhc.h (added)
• include/remote_usbhid.h (added)
• include/usb_iface.h (added)
• include/usbhc_iface.h (added)
• include/usbhid_iface.h (added)

uspace/lib/drv/Makefile

@@ -29 +29 @@
 
 USPACE_PREFIX = ../..
-EXTRA_CFLAGS = -Iinclude
+EXTRA_CFLAGS = -Iinclude -I$(LIBUSB_PREFIX)/include
 LIBRARY = libdrv
 
@@ -36 +36 @@
         generic/dev_iface.c \
         generic/log.c \
+        generic/logbuf.c \
         generic/remote_hw_res.c \
-        generic/remote_char_dev.c
+        generic/remote_char_dev.c \
+        generic/remote_nic.c \
+        generic/remote_usb.c \
+        generic/remote_pci.c \
+        generic/remote_usbhc.c \
+        generic/remote_usbhid.c
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/lib/drv/generic/dev_iface.c

@@ -41 +41 @@
 #include "remote_hw_res.h"
 #include "remote_char_dev.h"
+#include "remote_nic.h"
+#include "remote_usb.h"
+#include "remote_usbhc.h"
+#include "remote_usbhid.h"
+#include "remote_pci.h"
 
 static iface_dipatch_table_t remote_ifaces = {
         .ifaces = {
                 &remote_hw_res_iface,
-                &remote_char_dev_iface
+                &remote_char_dev_iface,
+                &remote_nic_iface,
+                &remote_pci_iface,
+                &remote_usb_iface,
+                &remote_usbhc_iface,
+                &remote_usbhid_iface
         }
 };
@@ -58 +68 @@
 get_remote_method(remote_iface_t *rem_iface, sysarg_t iface_method_idx)
 {
-        if (iface_method_idx >= rem_iface->method_count) {
+        if (iface_method_idx >= rem_iface->method_count)
                 return NULL;
-        }
-
+        
         return rem_iface->methods[iface_method_idx];
 }

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;
@@ -259 +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;
 
@@ -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_added(ipc_callid_t iid, ipc_call_t *icall)
+{
+        fibril_mutex_lock(&devices_mutex);
+        ddf_dev_t *dev = driver_get_device(IPC_GET_ARG1(*icall));
+        fibril_mutex_unlock(&devices_mutex);
+        
+        if (dev != NULL && driver->driver_ops->device_added != NULL)
+                driver->driver_ops->device_added(dev);
+}
+
+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);
 }
 
@@ -285 +450 @@
         async_answer_0(iid, EOK);
         
-        bool cont = true;
-        while (cont) {
+        while (true) {
                 ipc_call_t call;
                 ipc_callid_t callid = async_get_call(&call);
                 
+                if (!IPC_GET_IMETHOD(call))
+                        break;
+                
                 switch (IPC_GET_IMETHOD(call)) {
-                case IPC_M_PHONE_HUNGUP:
-                        cont = false;
-                        continue;
-                case DRIVER_ADD_DEVICE:
-                        driver_add_device(callid, &call);
+                case DRIVER_DEV_ADD:
+                        driver_dev_add(callid, &call);
+                        break;
+                case DRIVER_DEV_ADDED:
+                        async_answer_0(callid, EOK);
+                        driver_dev_added(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);
                 }
         }
 }
 
-/**
- * Generic client connection handler both for applications and drivers.
- *
- * @param drv           True for driver client, false for other clients
- *                      (applications, services etc.).
+/** Generic client connection handler both for applications and drivers.
+ *
+ * @param drv True for driver client, false for other clients
+ *            (applications, services, etc.).
+ *
  */
 static void driver_connection_gen(ipc_callid_t iid, ipc_call_t *icall, bool drv)
@@ -316 +496 @@
          */
         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) {
                 printf("%s: driver_connection_gen error - no function with handle"
@@ -325 +509 @@
         }
         
+        if (fun->conn_handler != NULL) {
+                /* Driver has a custom connection handler. */
+                (*fun->conn_handler)(iid, icall, (void *)fun);
+                return;
+        }
         
         /*
@@ -340 +529 @@
                 return;
         
-        while (1) {
+        while (true) {
                 ipc_callid_t callid;
                 ipc_call_t call;
                 callid = async_get_call(&call);
                 sysarg_t method = IPC_GET_IMETHOD(call);
-                int iface_idx;
-                
-                switch  (method) {
-                case IPC_M_PHONE_HUNGUP:
+                
+                if (!method) {
                         /* Close device function */
                         if (fun->ops != NULL && fun->ops->close != NULL)
@@ -354 +541 @@
                         async_answer_0(callid, EOK);
                         return;
-                default:
-                        /* convert ipc interface id to interface index */
-                        
-                        iface_idx = DEV_IFACE_IDX(method);
-                        
-                        if (!is_valid_iface_idx(iface_idx)) {
-                                remote_handler_t *default_handler =
-                                    function_get_default_handler(fun);
-                                if (default_handler != NULL) {
-                                        (*default_handler)(fun, callid, &call);
-                                        break;
-                                }
-                                
-                                /*
-                                 * Function has no such interface and
-                                 * default handler is not provided.
-                                 */
-                                printf("%s: driver_connection_gen error - "
-                                    "invalid interface id %d.",
-                                    driver->name, iface_idx);
-                                async_answer_0(callid, ENOTSUP);
-                                break;
-                        }
-                        
-                        /* 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("Function with handle %" PRIun " has no interface "
-                                    "with id %d.\n", handle, iface_idx);
-                                async_answer_0(callid, ENOTSUP);
-                                break;
+                }
+                
+                /* Convert ipc interface id to interface index */
+                
+                int iface_idx = DEV_IFACE_IDX(method);
+                
+                if (!is_valid_iface_idx(iface_idx)) {
+                        remote_handler_t *default_handler =
+                            function_get_default_handler(fun);
+                        if (default_handler != NULL) {
+                                (*default_handler)(fun, callid, &call);
+                                continue;
                         }
                         
                         /*
-                         * Get the corresponding interface for remote request
-                         * handling ("remote interface").
+                         * Function has no such interface and
+                         * default handler is not provided.
                          */
-                        remote_iface_t *rem_iface = get_remote_iface(iface_idx);
-                        assert(rem_iface != NULL);
-                        
-                        /* get the method of the remote interface */
-                        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 (iface_method_ptr == NULL) {
-                                /* The interface has not such method */
-                                printf("%s: driver_connection_gen error - "
-                                    "invalid interface method.", driver->name);
-                                async_answer_0(callid, ENOTSUP);
-                                break;
-                        }
-                        
-                        /*
-                         * Call the remote interface's method, which will
-                         * receive parameters from the remote client and it will
-                         * pass it to the corresponding local interface method
-                         * associated with the function by its driver.
-                         */
-                        (*iface_method_ptr)(fun, ops, callid, &call);
-                        break;
+                        printf("%s: driver_connection_gen error - "
+                            "invalid interface id %d.",
+                            driver->name, iface_idx);
+                        async_answer_0(callid, ENOTSUP);
+                        continue;
                 }
+                
+                /* 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("Function with handle %" PRIun " has no interface "
+                            "with id %d.\n", handle, iface_idx);
+                        async_answer_0(callid, ENOTSUP);
+                        continue;
+                }
+                
+                /*
+                 * Get the corresponding interface for remote request
+                 * handling ("remote interface").
+                 */
+                remote_iface_t *rem_iface = get_remote_iface(iface_idx);
+                assert(rem_iface != NULL);
+                
+                /* get the method of the remote interface */
+                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 (iface_method_ptr == NULL) {
+                        /* The interface has not such method */
+                        printf("%s: driver_connection_gen error - "
+                            "invalid interface method.", driver->name);
+                        async_answer_0(callid, ENOTSUP);
+                        continue;
+                }
+                
+                /*
+                 * Call the remote interface's method, which will
+                 * receive parameters from the remote client and it will
+                 * pass it to the corresponding local interface method
+                 * associated with the function by its driver.
+                 */
+                (*iface_method_ptr)(fun, ops, callid, &call);
         }
 }
@@ -433 +618 @@
 
 /** 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 */
@@ -463 +658 @@
         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;
 }
@@ -495 +689 @@
 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.
@@ -505 +701 @@
 {
         clean_match_ids(&fun->match_ids);
+        if (fun->driver_data != NULL)
+                free(fun->driver_data);
         if (fun->name != NULL)
                 free(fun->name);
@@ -510 +708 @@
 }
 
+/** 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.
  *
@@ -541 +796 @@
                 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;
 
@@ -554 +812 @@
 }
 
+/** 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.
  *
@@ -564 +838 @@
 {
         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);
 }
 
@@ -589 +870 @@
 int ddf_fun_bind(ddf_fun_t *fun)
 {
+        assert(fun->bound == false);
         assert(fun->name != NULL);
         
@@ -605 +887 @@
 }
 
+/** 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.
  *
@@ -627 +969 @@
                 return ENOMEM;
         
-        match_id->id = match_id_str;
-        match_id->score = 90;
+        match_id->id = str_dup(match_id_str);
+        match_id->score = match_score;
         
         add_match_id(&fun->match_ids, match_id);
@@ -642 +984 @@
 }
 
-/** 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);
 }
 

uspace/lib/drv/include/ddf/driver.h

@@ -37 +37 @@
 #define DDF_DRIVER_H_
 
+#include <async.h>
 #include <ipc/devman.h>
 #include <ipc/dev_iface.h>
-
 #include "../dev_iface.h"
 
@@ -81 +81 @@
          */
         devman_handle_t handle;
+        /** Reference count */
+        atomic_t refcnt;
         
         /**
-         * Phone to the parent device driver (if it is different from this
+         * Session to the parent device driver (if it is different from this
          * driver)
          */
-        int parent_phone;
+        async_sess_t *parent_sess;
         
         /** Device name */
@@ -104 +106 @@
         /** Function indentifier (asigned by device manager) */
         devman_handle_t handle;
+        /** Reference count */
+        atomic_t refcnt;
         
         /** Device which this function belogs to */
@@ -118 +122 @@
         /** Implementation of operations provided by this function */
         ddf_dev_ops_t *ops;
+        /** Connection handler or @c NULL to use the DDF default handler. */
+        async_client_conn_t conn_handler;
         
         /** Link in the list of functions handled by the driver */
@@ -130 +136 @@
 typedef struct driver_ops {
         /** Callback method for passing a new device to the device driver */
-        int (*add_device)(ddf_dev_t *dev);
-        /* TODO: add other generic driver operations */
+        int (*add_device)(ddf_dev_t *);
+        /**
+         * Notification that the device was succesfully added.
+         * The driver can do any blocking operation without
+         * blocking the device manager.
+         */
+        void (*device_added)(ddf_dev_t *dev);
+        /** Ask driver to remove a device */
+        int (*dev_remove)(ddf_dev_t *);
+        /** Inform driver a device disappeared */
+        int (*dev_gone)(ddf_dev_t *);
+        /** Ask driver to online a specific function */
+        int (*fun_online)(ddf_fun_t *);
+        /** Ask driver to offline a specific function */
+        int (*fun_offline)(ddf_fun_t *);
 } driver_ops_t;
 
@@ -144 +163 @@
 extern int ddf_driver_main(driver_t *);
 
+extern void *ddf_dev_data_alloc(ddf_dev_t *, size_t);
 extern ddf_fun_t *ddf_fun_create(ddf_dev_t *, fun_type_t, const char *);
 extern void ddf_fun_destroy(ddf_fun_t *);
+extern void *ddf_fun_data_alloc(ddf_fun_t *, size_t);
 extern int ddf_fun_bind(ddf_fun_t *);
+extern int ddf_fun_unbind(ddf_fun_t *);
+extern int ddf_fun_online(ddf_fun_t *);
+extern int ddf_fun_offline(ddf_fun_t *);
 extern int ddf_fun_add_match_id(ddf_fun_t *, const char *, int);
 
-extern int ddf_fun_add_to_class(ddf_fun_t *, const char *);
+extern int ddf_fun_add_to_category(ddf_fun_t *, const char *);
 
 #endif

uspace/lib/drv/include/ddf/interrupt.h

@@ -36 +36 @@
 #define DDF_INTERRUPT_H_
 
-#include <kernel/ddi/irq.h>
+#include <abi/ddi/irq.h>
 #include <adt/list.h>
 #include <ddi.h>
@@ -60 +60 @@
 typedef struct interrupt_context_list {
         int curr_id;
-        link_t contexts;
+        list_t contexts;
         fibril_mutex_t mutex;
 } interrupt_context_list_t;

uspace/lib/drv/include/ddf/log.h

@@ -39 +39 @@
 extern void ddf_msg(log_level_t, const char *, ...);
 
+extern void ddf_dump_buffer(char *, size_t, const void *, size_t, size_t,
+    size_t);
+
 #endif
 

uspace/lib/drv/include/remote_nic.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2008 Pavel Rimsky
+ * Copyright (c) 2011 Radim Vansa
  * All rights reserved.
  *
@@ -27 +27 @@
  */
 
-/** @defgroup sgcnfb SGCN
- * @brief       userland driver of the Serengeti console output
+/** @addtogroup libdrv
  * @{
  */
- 
 /** @file
  */
 
-#ifndef FB_SGCN_H_
-#define FB_SGCN_H_
+#ifndef LIBDRV_REMOTE_NIC_H_
+#define LIBDRV_REMOTE_NIC_H_
 
-int sgcn_init(void);
+extern remote_iface_t remote_nic_iface;
 
 #endif
 
-/** 
+/**
  * @}
  */