Changeset 6610565b in mainline for uspace/lib/drv

Timestamp:

2011-01-10T16:20:56Z (15 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

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

Children:

1ffa73b, 8048c648, 8426912a, 977fcea, f401312

Parents:

a97ea0f (diff), 4a5c6c1 (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) (1 diff)
• generic/dev_iface.c (modified) (4 diffs)
• generic/driver.c (modified) (26 diffs)
• generic/remote_char_dev.c (moved) (moved from uspace/lib/drv/generic/remote_char.c ) (9 diffs)
• generic/remote_hw_res.c (moved) (moved from uspace/lib/drv/generic/remote_res.c ) (2 diffs)
• include/dev_iface.h (modified) (1 diff)
• include/driver.h (modified) (6 diffs)
• include/ops/char_dev.h (moved) (moved from uspace/lib/drv/include/char.h ) (1 diff)
• include/ops/hw_res.h (moved) (moved from uspace/lib/drv/include/resource.h ) (1 diff)
• include/remote_char_dev.h (moved) (moved from uspace/lib/drv/include/remote_res.h ) (1 diff)
• include/remote_hw_res.h (moved) (moved from uspace/lib/drv/include/remote_char.h ) (1 diff)

uspace/lib/drv/Makefile

@@ -35 +35 @@
         generic/driver.c \
         generic/dev_iface.c \
-        generic/remote_res.c \
+        generic/remote_char_dev.c \
+        generic/remote_hw_res.c \
         generic/remote_usb.c \
-        generic/remote_usbhc.c \
-        generic/remote_char.c
+        generic/remote_usbhc.c
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/lib/drv/generic/dev_iface.c

@@ -36 +36 @@
  */
 
+#include <assert.h>
+
 #include "dev_iface.h"
-#include "remote_res.h"
-#include "remote_char.h"
+#include "remote_hw_res.h"
+#include "remote_char_dev.h"
 #include "remote_usb.h"
 #include "remote_usbhc.h"
@@ -44 +46 @@
 static iface_dipatch_table_t remote_ifaces = {
         .ifaces = {
-                &remote_res_iface,
-                &remote_char_iface,
+                &remote_hw_res_iface,
+                &remote_char_dev_iface,
                 &remote_usb_iface,
                 &remote_usbhc_iface
@@ -51 +53 @@
 };
 
-remote_iface_t* get_remote_iface(int idx)
-{       
+remote_iface_t *get_remote_iface(int idx)
+{
         assert(is_valid_iface_idx(idx));
         return remote_ifaces.ifaces[idx];
@@ -63 +65 @@
                 return NULL;
         }
+
         return rem_iface->methods[iface_method_idx];
+}
+
+bool is_valid_iface_idx(int idx)
+{
+        return (0 <= idx) && (idx < DEV_IFACE_MAX);
 }
 

uspace/lib/drv/generic/driver.c

@@ -52 +52 @@
 #include <ipc/driver.h>
 
+#include "dev_iface.h"
 #include "driver.h"
 
-/* driver structure */
-
+/** Driver structure */
 static driver_t *driver;
 
-/* devices */
-
+/** Devices */
 LIST_INITIALIZE(devices);
 FIBRIL_MUTEX_INITIALIZE(devices_mutex);
 
-/* interrupts */
-
+/** Interrupts */
 static interrupt_context_list_t interrupt_contexts;
 
@@ -85 +83 @@
         
         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, device_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
@@ -101 +183 @@
         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) {
+        if (res != EOK) {
                 remove_interrupt_context(&interrupt_contexts, ctx);
                 delete_interrupt_context(ctx);
@@ -118 +200 @@
             dev, irq);
         int res = ipc_unregister_irq(irq, dev->handle);
-
-        if (NULL != ctx) {
+        
+        if (ctx != NULL) {
                 remove_interrupt_context(&interrupt_contexts, ctx);
                 delete_interrupt_context(ctx);
         }
+        
         return res;
 }
@@ -140 +223 @@
 }
 
-static device_t * driver_get_device(link_t *devices, devman_handle_t handle)
+static device_t *driver_get_device(link_t *devices, devman_handle_t handle)
 {
         device_t *dev = NULL;
@@ -146 +229 @@
         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) {
+                if (dev->handle == handle) {
                         fibril_mutex_unlock(&devices_mutex);
                         return dev;
@@ -154 +238 @@
                 link = link->next;
         }
+        
         fibril_mutex_unlock(&devices_mutex);
-
+        
         return NULL;
 }
@@ -162 +247 @@
 {
         char *dev_name = NULL;
-        int res = EOK;
-        
-        devman_handle_t dev_handle =  IPC_GET_ARG1(*icall);
+        int res;
+        
+        devman_handle_t dev_handle = IPC_GET_ARG1(*icall);
         devman_handle_t parent_dev_handle = IPC_GET_ARG2(*icall);
-    
+        
         device_t *dev = create_device();
         dev->handle = dev_handle;
@@ -177 +262 @@
         
         res = driver->driver_ops->add_device(dev);
-        if (0 == res) {
+        if (res == EOK) {
                 printf("%s: new device with handle=%" PRIun " was added.\n",
                     driver->name, dev_handle);
@@ -194 +279 @@
         /* Accept connection */
         ipc_answer_0(iid, EOK);
-
+        
         bool cont = true;
         while (cont) {
                 ipc_call_t call;
                 ipc_callid_t callid = async_get_call(&call);
-
+                
                 switch (IPC_GET_IMETHOD(call)) {
                 case IPC_M_PHONE_HUNGUP:
@@ -240 +325 @@
          * use the device.
          */
-
+        
         int ret = EOK;
         /* open the device */
-        if (NULL != dev->ops && NULL != dev->ops->open)
+        if (dev->ops != NULL && dev->ops->open != NULL)
                 ret = (*dev->ops->open)(dev);
         
-        ipc_answer_0(iid, ret); 
-        if (EOK != ret)
+        ipc_answer_0(iid, ret);
+        if (ret != EOK)
                 return;
-
+        
         while (1) {
                 ipc_callid_t callid;
@@ -258 +343 @@
                 
                 switch  (method) {
-                case IPC_M_PHONE_HUNGUP:                
+                case IPC_M_PHONE_HUNGUP:
                         /* close the device */
-                        if (NULL != dev->ops && NULL != dev->ops->close)
+                        if (dev->ops != NULL && dev->ops->close != NULL)
                                 (*dev->ops->close)(dev);
                         ipc_answer_0(callid, EOK);
                         return;
-                default:                
+                default:
                         /* convert ipc interface id to interface index */
                         
@@ -272 +357 @@
                                 remote_handler_t *default_handler =
                                     device_get_default_handler(dev);
-                                if (NULL != default_handler) {
+                                if (default_handler != NULL) {
                                         (*default_handler)(dev, callid, &call);
                                         break;
@@ -286 +371 @@
                                 break;
                         }
-
+                        
                         /* calling one of the device's interfaces */
                         
-                        /* get the device interface structure */
-                        void *iface = device_get_iface(dev, iface_idx);
-                        if (NULL == iface) {
+                        /* Get the interface ops structure. */
+                        void *ops = device_get_ops(dev, iface_idx);
+                        if (ops == NULL) {
                                 printf("%s: driver_connection_gen error - ",
                                     driver->name);
@@ -299 +384 @@
                                 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 */
                         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) {
+                        if (iface_method_ptr == NULL) {
                                 // the interface has not such method
                                 printf("%s: driver_connection_gen error - "
@@ -325 +410 @@
                          * associated with the device by its driver.
                          */
-                        (*iface_method_ptr)(dev, iface, callid, &call);
+                        (*iface_method_ptr)(dev, ops, callid, &call);
                         break;
                 }
@@ -348 +433 @@
         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 */
@@ -366 +450 @@
 }
 
+/** Create new device structure.
+ *
+ * @return              The device structure.
+ */
+device_t *create_device(void)
+{
+        device_t *dev = malloc(sizeof(device_t));
+
+        if (dev != NULL) {
+                memset(dev, 0, sizeof(device_t));
+                init_match_ids(&dev->match_ids);
+        }
+
+        return dev;
+}
+
+/** Delete device structure.
+ *
+ * @param dev           The device structure.
+ */
+void delete_device(device_t *dev)
+{
+        clean_match_ids(&dev->match_ids);
+        if (dev->name != NULL)
+                free(dev->name);
+        free(dev);
+}
+
+void *device_get_ops(device_t *dev, dev_inferface_idx_t idx)
+{
+        assert(is_valid_iface_idx(idx));
+        if (dev->ops == NULL)
+                return NULL;
+        return dev->ops->interfaces[idx];
+}
+
 int child_device_register(device_t *child, device_t *parent)
 {
-        assert(NULL != child->name);
-
+        assert(child->name != NULL);
+        
         int res;
         
@@ -375 +495 @@
         res = devman_child_device_register(child->name, &child->match_ids,
             parent->handle, &child->handle);
-        if (EOK == res)
+        if (res != EOK) {
+                remove_from_devices_list(child);
                 return res;
-        remove_from_devices_list(child);        
+        }
+        
         return res;
 }
@@ -396 +518 @@
         match_id_t *match_id = NULL;
         int rc;
-
+        
         child = create_device();
         if (child == NULL) {
@@ -402 +524 @@
                 goto failure;
         }
-
+        
         child->name = child_name;
-
+        
         match_id = create_match_id();
         if (match_id == NULL) {
@@ -410 +532 @@
                 goto failure;
         }
-
+        
         match_id->id = child_match_id;
         match_id->score = child_match_score;
         add_match_id(&child->match_ids, match_id);
-
+        
         rc = child_device_register(child, parent);
-        if (EOK != rc)
+        if (rc != EOK)
                 goto failure;
 
@@ -422 +544 @@
                 *child_handle = child->handle;
         }
+
         return EOK;
-
+        
 failure:
         if (match_id != NULL) {
@@ -429 +552 @@
                 delete_match_id(match_id);
         }
-
+        
         if (child != NULL) {
                 child->name = NULL;
                 delete_device(child);
         }
-
+        
         return rc;
+}
+
+/** Get default handler for client requests */
+remote_handler_t *device_get_default_handler(device_t *dev)
+{
+        if (dev->ops == NULL)
+                return NULL;
+        return dev->ops->default_handler;
+}
+
+int add_device_to_class(device_t *dev, const char *class_name)
+{
+        return devman_add_device_to_class(dev->handle, class_name);
 }
 
@@ -445 +581 @@
          */
         driver = drv;
-
+        
         /* Initialize the list of interrupt contexts. */
         init_interrupt_context_list(&interrupt_contexts);
@@ -457 +593 @@
          */
         devman_driver_register(driver->name, driver_connection);
-
+        
         async_manager();
-
+        
         /* Never reached. */
         return 0;

uspace/lib/drv/generic/remote_char_dev.c

@@ -37 +37 @@
 #include <errno.h>
 
-#include "char.h"
+#include "ops/char_dev.h"
 #include "driver.h"
 
@@ -46 +46 @@
 
 /** Remote character interface operations. */
-static remote_iface_func_ptr_t remote_char_iface_ops [] = {
+static remote_iface_func_ptr_t remote_char_dev_iface_ops[] = {
         &remote_char_read,
         &remote_char_write
@@ -56 +56 @@
  * character interface.
  */
-remote_iface_t remote_char_iface = {
-        .method_count = sizeof(remote_char_iface_ops) /
+remote_iface_t remote_char_dev_iface = {
+        .method_count = sizeof(remote_char_dev_iface_ops) /
             sizeof(remote_iface_func_ptr_t),
-        .methods = remote_char_iface_ops
+        .methods = remote_char_dev_iface_ops
 };
 
@@ -69 +69 @@
  *
  * @param dev           The device from which the data are read.
- * @param iface         The local interface structure.
+ * @param ops           The local ops structure.
  */
 static void
-remote_char_read(device_t *dev, void *iface, ipc_callid_t callid,
+remote_char_read(device_t *dev, void *ops, ipc_callid_t callid,
     ipc_call_t *call)
-{       
-        char_iface_t *char_iface = (char_iface_t *) iface;
+{
+        char_dev_ops_t *char_dev_ops = (char_dev_ops_t *) ops;
         ipc_callid_t cid;
         
@@ -85 +85 @@
         }
         
-        if (!char_iface->read) {
+        if (!char_dev_ops->read) {
                 async_data_read_finalize(cid, NULL, 0);
                 ipc_answer_0(callid, ENOTSUP);
@@ -95 +95 @@
         
         char buf[MAX_CHAR_RW_COUNT];
-        int ret = (*char_iface->read)(dev, buf, len);
+        int ret = (*char_dev_ops->read)(dev, buf, len);
         
         if (ret < 0) {
@@ -116 +116 @@
  *
  * @param dev           The device to which the data are written.
- * @param iface         The local interface structure.
+ * @param ops           The local ops structure.
  */
 static void
-remote_char_write(device_t *dev, void *iface, ipc_callid_t callid,
+remote_char_write(device_t *dev, void *ops, ipc_callid_t callid,
     ipc_call_t *call)
 {
-        char_iface_t *char_iface = (char_iface_t *) iface;
+        char_dev_ops_t *char_dev_ops = (char_dev_ops_t *) ops;
         ipc_callid_t cid;
         size_t len;
@@ -132 +132 @@
         }
         
-        if (!char_iface->write) {
+        if (!char_dev_ops->write) {
                 async_data_write_finalize(cid, NULL, 0);
                 ipc_answer_0(callid, ENOTSUP);
                 return;
-        }       
+        }
         
         if (len > MAX_CHAR_RW_COUNT)
@@ -145 +145 @@
         async_data_write_finalize(cid, buf, len);
         
-        int ret = (*char_iface->write)(dev, buf, len);
+        int ret = (*char_dev_ops->write)(dev, buf, len);
         if (ret < 0) {
                 /* Some error occured. */

uspace/lib/drv/generic/remote_hw_res.c

@@ -37 +37 @@
 #include <errno.h>
 
+#include "ops/hw_res.h"
 #include "driver.h"
-#include "resource.h"
 
-static void remote_res_get_resources(device_t *, void *, ipc_callid_t,
+static void remote_hw_res_get_resource_list(device_t *, void *, ipc_callid_t,
     ipc_call_t *);
-static void remote_res_enable_interrupt(device_t *, void *, ipc_callid_t,
+static void remote_hw_res_enable_interrupt(device_t *, void *, ipc_callid_t,
     ipc_call_t *);
 
-static remote_iface_func_ptr_t remote_res_iface_ops [] = {
-        &remote_res_get_resources,
-        &remote_res_enable_interrupt
+static remote_iface_func_ptr_t remote_hw_res_iface_ops [] = {
+        &remote_hw_res_get_resource_list,
+        &remote_hw_res_enable_interrupt
 };
 
-remote_iface_t remote_res_iface = {
-        .method_count = sizeof(remote_res_iface_ops) /
+remote_iface_t remote_hw_res_iface = {
+        .method_count = sizeof(remote_hw_res_iface_ops) /
             sizeof(remote_iface_func_ptr_t),
-        .methods = remote_res_iface_ops
+        .methods = remote_hw_res_iface_ops
 };
 
-static void remote_res_enable_interrupt(device_t *dev, void *iface,
+static void remote_hw_res_enable_interrupt(device_t *dev, void *ops,
     ipc_callid_t callid, ipc_call_t *call)
 {
-        resource_iface_t *ires = (resource_iface_t *) iface;
+        hw_res_ops_t *hw_res_ops = (hw_res_ops_t *) ops;
         
-        if (NULL == ires->enable_interrupt)
+        if (hw_res_ops->enable_interrupt == NULL)
                 ipc_answer_0(callid, ENOTSUP);
-        else if (ires->enable_interrupt(dev))
+        else if (hw_res_ops->enable_interrupt(dev))
                 ipc_answer_0(callid, EOK);
         else
@@ -69 +69 @@
 }
 
-static void remote_res_get_resources(device_t *dev, void *iface,
+static void remote_hw_res_get_resource_list(device_t *dev, void *ops,
     ipc_callid_t callid, ipc_call_t *call)
 {
-        resource_iface_t *ires = (resource_iface_t *) iface;
-        if (NULL == ires->get_resources) {
+        hw_res_ops_t *hw_res_ops = (hw_res_ops_t *) ops;
+
+        if (hw_res_ops->get_resource_list == NULL) {
                 ipc_answer_0(callid, ENOTSUP);
                 return;
         }
         
-        hw_resource_list_t *hw_resources = ires->get_resources(dev);
-        if (NULL == hw_resources){
+        hw_resource_list_t *hw_resources = hw_res_ops->get_resource_list(dev);
+        if (hw_resources == NULL){
                 ipc_answer_0(callid, ENOENT);
                 return;
-        }       
+        }
         
-        ipc_answer_1(callid, EOK, hw_resources->count); 
+        ipc_answer_1(callid, EOK, hw_resources->count);
 
         size_t len;
         if (!async_data_read_receive(&callid, &len)) {
-                /* protocol error - the recipient is not accepting data */
+                /* Protocol error - the recipient is not accepting data */
                 return;
         }

uspace/lib/drv/include/dev_iface.h

@@ -36 +36 @@
 #define LIBDRV_DEV_IFACE_H_
 
-#include "driver.h"
+#include <ipc/dev_iface.h>
 
-/* TODO declare device interface structures here */
+/*
+ * Device interface
+ */
+
+struct device;
+
+/*
+ * First two parameters: device and interface structure registered by the
+ * devices driver.
+ */
+typedef void remote_iface_func_t(struct device *, void *, ipc_callid_t,
+    ipc_call_t *);
+typedef remote_iface_func_t *remote_iface_func_ptr_t;
+typedef void remote_handler_t(struct device *, ipc_callid_t, ipc_call_t *);
+
+typedef struct {
+        size_t method_count;
+        remote_iface_func_ptr_t *methods;
+} remote_iface_t;
+
+typedef struct {
+        remote_iface_t *ifaces[DEV_IFACE_COUNT];
+} iface_dipatch_table_t;
+
+extern remote_iface_t *get_remote_iface(int);
+extern remote_iface_func_ptr_t get_remote_method(remote_iface_t *, sysarg_t);
+
+
+extern bool is_valid_iface_idx(int);
 
 #endif

uspace/lib/drv/include/driver.h

@@ -41 +41 @@
 #include <ipc/devman.h>
 #include <ipc/dev_iface.h>
-#include <device/hw_res.h>
-#include <device/char.h>
 #include <assert.h>
 #include <ddi.h>
@@ -49 +47 @@
 #include <malloc.h>
 
+#include "dev_iface.h"
+
 struct device;
 typedef struct device device_t;
 
-/* device interface */
+/*
+ * Device class
+ */
 
-/*
- * First two parameters: device and interface structure registered by the
- * devices driver.
- */
-typedef void remote_iface_func_t(device_t *, void *, ipc_callid_t,
-    ipc_call_t *);
-typedef remote_iface_func_t *remote_iface_func_ptr_t;
-typedef void remote_handler_t(device_t *, ipc_callid_t, ipc_call_t *);
-
-typedef struct {
-        size_t method_count;
-        remote_iface_func_ptr_t *methods;
-} remote_iface_t;
-
-typedef struct {
-        remote_iface_t *ifaces[DEV_IFACE_COUNT];
-} iface_dipatch_table_t;
-
-
-static inline bool is_valid_iface_idx(int idx)
-{
-        return 0 <= idx && idx < DEV_IFACE_MAX;
-}
-
-remote_iface_t *get_remote_iface(int);
-remote_iface_func_ptr_t get_remote_method(remote_iface_t *, sysarg_t);
-
-
-/* device class */
-
-/** Devices operations. */
+/** Devices operations */
 typedef struct device_ops {
         /**
@@ -110 +82 @@
 
 
-/* device */
+/*
+ * Device
+ */
 
-/** The device. */
+/** Device structure */
 struct device {
         /**
@@ -121 +95 @@
         
         /**
-         * The phone to the parent device driver (if it is different from this
-         * driver).
+         * Phone to the parent device driver (if it is different from this
+         * driver)
          */
         int parent_phone;
         
-        /** Parent device if handled by this driver, NULL otherwise. */
+        /** Parent device if handled by this driver, NULL otherwise */
         device_t *parent;
-        /** The device's name. */
+        /** Device name */
         const char *name;
-        /** The list of device ids for device-to-driver matching. */
+        /** List of device ids for device-to-driver matching */
         match_id_list_t match_ids;
-        /** The device driver's data associated with this device. */
+        /** Driver-specific data associated with this device */
         void *driver_data;
-        /** The implementation of operations provided by this device. */
+        /** The implementation of operations provided by this device */
         device_ops_t *ops;
         
-        /**
-         * Pointer to the previous and next device in the list of devices
-         * handled by the driver.
-         */
+        /** Link in the list of devices handled by the driver */
         link_t link;
 };
 
+/*
+ * Driver
+ */
 
-/* driver */
-
-/** Generic device driver operations. */
+/** Generic device driver operations */
 typedef struct driver_ops {
-        /** Callback method for passing a new device to the device driver.*/
+        /** Callback method for passing a new device to the device driver */
         int (*add_device)(device_t *dev);
-        /* TODO add other generic driver operations */
+        /* TODO: add other generic driver operations */
 } driver_ops_t;
 
-/** The driver structure.*/
+/** Driver structure */
 typedef struct driver {
-        /** The name of the device driver. */
+        /** Name of the device driver */
         const char *name;
-        /** Generic device driver operations. */
+        /** Generic device driver operations */
         driver_ops_t *driver_ops;
 } driver_t;
@@ -168 +140 @@
  * @return              The device structure.
  */
-static inline device_t *create_device(void)
-{
-        device_t *dev = malloc(sizeof(device_t));
-        if (NULL != dev) {
-                memset(dev, 0, sizeof(device_t));
-                init_match_ids(&dev->match_ids);
-        }       
-        return dev;
-}
+extern device_t *create_device(void);
+extern void delete_device(device_t *);
+extern void *device_get_ops(device_t *, dev_inferface_idx_t);
 
-/** Delete device structure.
- *
- * @param dev           The device structure.
+extern int child_device_register(device_t *, device_t *);
+extern int child_device_register_wrapper(device_t *, const char *, const char *,
+    int, devman_handle_t *);
+
+/*
+ * Interrupts
  */
-static inline void delete_device(device_t *dev)
-{
-        clean_match_ids(&dev->match_ids);
-        if (NULL != dev->name)
-                free(dev->name);
-        free(dev);
-}
-
-static inline void *device_get_iface(device_t *dev, dev_inferface_idx_t idx)
-{
-        assert(is_valid_iface_idx(idx));
-        if (NULL == dev->ops)
-                return NULL;
-        return dev->ops->interfaces[idx];
-}
-
-int child_device_register(device_t *, device_t *);
-int child_device_register_wrapper(device_t *, const char *, const char *, int,
-    devman_handle_t *);
-
-
-/* interrupts */
 
 typedef void interrupt_handler_t(device_t *, ipc_callid_t, ipc_call_t *);
@@ -221 +168 @@
 } interrupt_context_list_t;
 
-static inline interrupt_context_t *create_interrupt_context(void)
-{
-        interrupt_context_t *ctx;
-        
-        ctx = (interrupt_context_t *) malloc(sizeof(interrupt_context_t));
-        if (NULL != ctx)
-                memset(ctx, 0, sizeof(interrupt_context_t));
-        
-        return ctx;
-}
+extern interrupt_context_t *create_interrupt_context(void);
+extern void delete_interrupt_context(interrupt_context_t *);
+extern void init_interrupt_context_list(interrupt_context_list_t *);
+extern void add_interrupt_context(interrupt_context_list_t *,
+    interrupt_context_t *);
+extern void remove_interrupt_context(interrupt_context_list_t *,
+    interrupt_context_t *);
+extern interrupt_context_t *find_interrupt_context_by_id(
+    interrupt_context_list_t *, int);
+extern interrupt_context_t *find_interrupt_context(
+    interrupt_context_list_t *, device_t *, int);
 
-static inline void delete_interrupt_context(interrupt_context_t *ctx)
-{
-        if (NULL != ctx)
-                free(ctx);
-}
+extern int register_interrupt_handler(device_t *, int, interrupt_handler_t *,
+    irq_code_t *);
+extern int unregister_interrupt_handler(device_t *, int);
 
-static inline 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);
-}
-
-static inline 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);
-}
-
-static inline 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);
-}
-
-static inline 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 (id == ctx->id) {
-                        fibril_mutex_unlock(&list->mutex);
-                        return ctx;
-                }
-                link = link->next;
-        }
-        
-        fibril_mutex_unlock(&list->mutex);
-        return NULL;
-}
-
-static inline interrupt_context_t *
-find_interrupt_context(interrupt_context_list_t *list, device_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 (irq == ctx->irq && dev == ctx->dev) {
-                        fibril_mutex_unlock(&list->mutex);
-                        return ctx;
-                }
-                link = link->next;
-        }
-        
-        fibril_mutex_unlock(&list->mutex);
-        return NULL;
-}
-
-int register_interrupt_handler(device_t *, int, interrupt_handler_t *,
-    irq_code_t *);
-int unregister_interrupt_handler(device_t *, int);
-
-
-/* default handler for client requests */
-
-static inline remote_handler_t *device_get_default_handler(device_t *dev)
-{
-        if (NULL == dev->ops)
-                return NULL;
-        return dev->ops->default_handler;
-}
-
-static inline int add_device_to_class(device_t *dev, const char *class_name)
-{
-        return devman_add_device_to_class(dev->handle, class_name);
-}
+extern remote_handler_t *device_get_default_handler(device_t *);
+extern int add_device_to_class(device_t *, const char *);
 
 #endif

uspace/lib/drv/include/ops/char_dev.h

@@ -33 +33 @@
  */
 
-#ifndef LIBDRV_CHAR_H_
-#define LIBDRV_CHAR_H_
+#ifndef LIBDRV_OPS_CHAR_DEV_H_
+#define LIBDRV_OPS_CHAR_DEV_H_
 
-#include "driver.h"
+#include "../driver.h"
 
-typedef struct char_iface {
+typedef struct {
         int (*read)(device_t *, char *, size_t);
         int (*write)(device_t *, char *, size_t);
-} char_iface_t;
+} char_dev_ops_t;
 
 #endif

uspace/lib/drv/include/ops/hw_res.h

@@ -33 +33 @@
  */
 
-#ifndef LIBDRV_RESOURCE_H_
-#define LIBDRV_RESOURCE_H_
+#ifndef LIBDRV_OPS_HW_RES_H_
+#define LIBDRV_OPS_HW_RES_H_
 
-#include "driver.h"
+#include <device/hw_res.h>
+#include <sys/types.h>
 
-typedef struct resource_iface {
-         hw_resource_list_t *(* get_resources)(device_t *);
+#include "../driver.h"
+
+typedef struct {
+         hw_resource_list_t *(*get_resource_list)(device_t *);
          bool (*enable_interrupt)(device_t *);
-} resource_iface_t;
-
+} hw_res_ops_t;
 
 #endif

uspace/lib/drv/include/remote_char_dev.h

@@ -33 +33 @@
  */
 
-#ifndef LIBDRV_REMOTE_RES_H_
-#define LIBDRV_REMOTE_RES_H_
+#ifndef LIBDRV_REMOTE_CHAR_DEV_H_
+#define LIBDRV_REMOTE_CHAR_DEV_H_
 
-remote_iface_t remote_res_iface;
+extern remote_iface_t remote_char_dev_iface;
 
 #endif

uspace/lib/drv/include/remote_hw_res.h

@@ -33 +33 @@
  */
 
-#ifndef LIBDRV_REMOTE_CHAR_H_
-#define LIBDRV_REMOTE_CHAR_H_
+#ifndef LIBDRV_REMOTE_HW_RES_H_
+#define LIBDRV_REMOTE_HW_RES_H_
 
-remote_iface_t remote_char_iface;
+extern remote_iface_t remote_hw_res_iface;
 
 #endif