Changeset 0c968a17 in mainline

Timestamp:

2011-02-15T22:58:28Z (14 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

8b1ea2d4

Parents:

6a343bdf (diff), aa7dc64 (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 DDF and drivers refactoring work. Major points:

• Split driver.h into ddf/driver.h and ddf/interrupt.h
• Rename entities in ddf/driver.h (now they start with 'ddf_')
• Refactor driver.h API (ddf_fun_create/destroy/bind, for example)
• Refactor drivers to use soft-state structures for context

Location:

uspace

Files:

• app/tester/hw/serial/serial1.c (modified) (1 diff)
• drv/isa/isa.c (modified) (22 diffs)
• drv/ns8250/ns8250.c (modified) (37 diffs)
• drv/pciintel/pci.c (modified) (19 diffs)
• drv/pciintel/pci.h (modified) (3 diffs)
• drv/root/root.c (modified) (9 diffs)
• drv/rootpc/rootpc.c (modified) (8 diffs)
• drv/rootvirt/rootvirt.c (modified) (5 diffs)
• drv/test1/char.c (modified) (2 diffs)
• drv/test1/test1.c (modified) (4 diffs)
• drv/test1/test1.h (modified) (1 diff)
• drv/test2/test2.c (modified) (4 diffs)
• lib/c/generic/devman.c (modified) (8 diffs)
• lib/c/include/devman.h (modified) (1 diff)
• lib/c/include/ipc/devman.h (modified) (2 diffs)
• lib/drv/generic/driver.c (modified) (18 diffs)
• lib/drv/generic/remote_char_dev.c (modified) (5 diffs)
• lib/drv/generic/remote_hw_res.c (modified) (5 diffs)
• lib/drv/include/ddf/driver.h (moved) (moved from uspace/lib/drv/include/driver.h ) (7 diffs)
• lib/drv/include/ddf/interrupt.h (added)
• lib/drv/include/dev_iface.h (modified) (2 diffs)
• lib/drv/include/ops/char_dev.h (modified) (1 diff)
• lib/drv/include/ops/hw_res.h (modified) (1 diff)
• srv/devman/devman.c (modified) (34 diffs)
• srv/devman/devman.h (modified) (13 diffs)
• srv/devman/main.c (modified) (14 diffs)
• srv/devman/match.c (modified) (1 diff)

uspace/app/tester/hw/serial/serial1.c

@@ -74 +74 @@
         
         devman_handle_t handle;
-        res = devman_device_get_handle("/hw/pci0/00:01.0/com1", &handle,
+        res = devman_device_get_handle("/hw/pci0/00:01.0/com1/a", &handle,
             IPC_FLAG_BLOCKING);
         if (res != EOK)

uspace/drv/isa/isa.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2010 Lenka Trochtova
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -43 +44 @@
 #include <stdlib.h>
 #include <str.h>
+#include <str_error.h>
 #include <ctype.h>
 #include <macros.h>
@@ -50 +52 @@
 #include <sys/stat.h>
 
-#include <driver.h>
+#include <ddf/driver.h>
 #include <ops/hw_res.h>
 
@@ -58 +60 @@
 
 #define NAME "isa"
-#define CHILD_DEV_CONF_PATH "/drv/isa/isa.dev"
+#define CHILD_FUN_CONF_PATH "/drv/isa/isa.dev"
+
+/** Obtain soft-state pointer from function node pointer */
+#define ISA_FUN(fnode) ((isa_fun_t *) ((fnode)->driver_data))
 
 #define ISA_MAX_HW_RES 4
 
-typedef struct isa_child_data {
+typedef struct isa_fun {
+        ddf_fun_t *fnode;
         hw_resource_list_t hw_resources;
-} isa_child_data_t;
-
-static hw_resource_list_t *isa_get_child_resources(device_t *dev)
-{
-        isa_child_data_t *dev_data;
-
-        dev_data = (isa_child_data_t *)dev->driver_data;
-        if (dev_data == NULL)
-                return NULL;
-
-        return &dev_data->hw_resources;
-}
-
-static bool isa_enable_child_interrupt(device_t *dev)
+} isa_fun_t;
+
+static hw_resource_list_t *isa_get_fun_resources(ddf_fun_t *fnode)
+{
+        isa_fun_t *fun = ISA_FUN(fnode);
+        assert(fun != NULL);
+
+        return &fun->hw_resources;
+}
+
+static bool isa_enable_fun_interrupt(ddf_fun_t *fnode)
 {
         // TODO
@@ -84 +87 @@
 }
 
-static hw_res_ops_t isa_child_hw_res_ops = {
-        &isa_get_child_resources,
-        &isa_enable_child_interrupt
+static hw_res_ops_t isa_fun_hw_res_ops = {
+        &isa_get_fun_resources,
+        &isa_enable_fun_interrupt
 };
 
-static device_ops_t isa_child_dev_ops;
-
-static int isa_add_device(device_t *dev);
+static ddf_dev_ops_t isa_fun_ops;
+
+static int isa_add_device(ddf_dev_t *dev);
 
 /** The isa device driver's standard operations */
@@ -104 +107 @@
 };
 
-
-static isa_child_data_t *create_isa_child_data() 
-{
-        isa_child_data_t *data;
-
-        data = (isa_child_data_t *) malloc(sizeof(isa_child_data_t));
-        if (data != NULL)
-                memset(data, 0, sizeof(isa_child_data_t));
-
-        return data;
-}
-
-static device_t *create_isa_child_dev()
-{
-        device_t *dev = create_device();
-        if (dev == NULL)
+static isa_fun_t *isa_fun_create(ddf_dev_t *dev, const char *name)
+{
+        isa_fun_t *fun = calloc(1, sizeof(isa_fun_t));
+        if (fun == NULL)
                 return NULL;
 
-        isa_child_data_t *data = create_isa_child_data();
-        if (data == NULL) {
-                delete_device(dev);
+        ddf_fun_t *fnode = ddf_fun_create(dev, fun_inner, name);
+        if (fnode == NULL) {
+                free(fun);
                 return NULL;
         }
 
-        dev->driver_data = data;
-        return dev;
-}
-
-static char *read_dev_conf(const char *conf_path)
+        fun->fnode = fnode;
+        fnode->driver_data = fun;
+        return fun;
+}
+
+static char *fun_conf_read(const char *conf_path)
 {
         bool suc = false;
@@ -151 +143 @@
         lseek(fd, 0, SEEK_SET); 
         if (len == 0) {
-                printf(NAME ": read_dev_conf error: configuration file '%s' "
+                printf(NAME ": fun_conf_read error: configuration file '%s' "
                     "is empty.\n", conf_path);
                 goto cleanup;
@@ -158 +150 @@
         buf = malloc(len + 1);
         if (buf == NULL) {
-                printf(NAME ": read_dev_conf error: memory allocation failed.\n");
+                printf(NAME ": fun_conf_read error: memory allocation failed.\n");
                 goto cleanup;
         }
 
         if (0 >= read(fd, buf, len)) {
-                printf(NAME ": read_dev_conf error: unable to read file '%s'.\n",
+                printf(NAME ": fun_conf_read error: unable to read file '%s'.\n",
                     conf_path);
                 goto cleanup;
@@ -249 +241 @@
 }
 
-static void isa_child_set_irq(device_t *dev, int irq)
-{
-        isa_child_data_t *data = (isa_child_data_t *)dev->driver_data;
-
-        size_t count = data->hw_resources.count;
-        hw_resource_t *resources = data->hw_resources.resources;
+static void isa_fun_set_irq(isa_fun_t *fun, int irq)
+{
+        size_t count = fun->hw_resources.count;
+        hw_resource_t *resources = fun->hw_resources.resources;
 
         if (count < ISA_MAX_HW_RES) {
@@ -260 +250 @@
                 resources[count].res.interrupt.irq = irq;
 
-                data->hw_resources.count++;
-
-                printf(NAME ": added irq 0x%x to device %s\n", irq, dev->name);
-        }
-}
-
-static void isa_child_set_io_range(device_t *dev, size_t addr, size_t len)
-{
-        isa_child_data_t *data = (isa_child_data_t *)dev->driver_data;
-
-        size_t count = data->hw_resources.count;
-        hw_resource_t *resources = data->hw_resources.resources;
+                fun->hw_resources.count++;
+
+                printf(NAME ": added irq 0x%x to function %s\n", irq,
+                    fun->fnode->name);
+        }
+}
+
+static void isa_fun_set_io_range(isa_fun_t *fun, size_t addr, size_t len)
+{
+        size_t count = fun->hw_resources.count;
+        hw_resource_t *resources = fun->hw_resources.resources;
 
         if (count < ISA_MAX_HW_RES) {
@@ -279 +268 @@
                 resources[count].res.io_range.endianness = LITTLE_ENDIAN;
 
-                data->hw_resources.count++;
+                fun->hw_resources.count++;
 
                 printf(NAME ": added io range (addr=0x%x, size=0x%x) to "
-                    "device %s\n", (unsigned int) addr, (unsigned int) len,
-                    dev->name);
-        }
-}
-
-static void get_dev_irq(device_t *dev, char *val)
+                    "function %s\n", (unsigned int) addr, (unsigned int) len,
+                    fun->fnode->name);
+        }
+}
+
+static void fun_parse_irq(isa_fun_t *fun, char *val)
 {
         int irq = 0;
         char *end = NULL;
 
-        val = skip_spaces(val); 
+        val = skip_spaces(val);
         irq = (int)strtol(val, &end, 0x10);
 
         if (val != end)
-                isa_child_set_irq(dev, irq);
-}
-
-static void get_dev_io_range(device_t *dev, char *val)
+                isa_fun_set_irq(fun, irq);
+}
+
+static void fun_parse_io_range(isa_fun_t *fun, char *val)
 {
         size_t addr, len;
         char *end = NULL;
 
-        val = skip_spaces(val); 
+        val = skip_spaces(val);
         addr = strtol(val, &end, 0x10);
 
@@ -310 +299 @@
                 return;
 
-        val = skip_spaces(end); 
+        val = skip_spaces(end);
         len = strtol(val, &end, 0x10);
 
@@ -316 +305 @@
                 return;
 
-        isa_child_set_io_range(dev, addr, len);
+        isa_fun_set_io_range(fun, addr, len);
 }
 
@@ -331 +320 @@
 }
 
-static void get_dev_match_id(device_t *dev, char *val)
+static void fun_parse_match_id(isa_fun_t *fun, char *val)
 {
         char *id = NULL;
         int score = 0;
         char *end = NULL;
-
-        val = skip_spaces(val); 
+        int rc;
+
+        val = skip_spaces(val);
 
         score = (int)strtol(val, &end, 10);
         if (val == end) {
                 printf(NAME " : error - could not read match score for "
-                    "device %s.\n", dev->name);
+                    "function %s.\n", fun->fnode->name);
                 return;
         }
 
-        match_id_t *match_id = create_match_id();
-        if (match_id == NULL) {
-                printf(NAME " : failed to allocate match id for device %s.\n",
-                    dev->name);
-                return;
-        }
-
-        val = skip_spaces(end); 
+        val = skip_spaces(end);
         get_match_id(&id, val);
         if (id == NULL) {
                 printf(NAME " : error - could not read match id for "
-                    "device %s.\n", dev->name);
-                delete_match_id(match_id);
+                    "function %s.\n", fun->fnode->name);
                 return;
         }
 
-        match_id->id = id;
-        match_id->score = score;
-
-        printf(NAME ": adding match id '%s' with score %d to device %s\n", id,
-            score, dev->name);
-        add_match_id(&dev->match_ids, match_id);
-}
-
-static bool read_dev_prop(device_t *dev, char *line, const char *prop,
-    void (*read_fn)(device_t *, char *))
+        printf(NAME ": adding match id '%s' with score %d to function %s\n", id,
+            score, fun->fnode->name);
+
+        rc = ddf_fun_add_match_id(fun->fnode, id, score);
+        if (rc != EOK)
+                printf(NAME ": error adding match ID: %s\n", str_error(rc));
+}
+
+static bool prop_parse(isa_fun_t *fun, char *line, const char *prop,
+    void (*read_fn)(isa_fun_t *, char *))
 {
         size_t proplen = str_size(prop);
@@ -378 +360 @@
                 line += proplen;
                 line = skip_spaces(line);
-                (*read_fn)(dev, line);
+                (*read_fn)(fun, line);
 
                 return true;
@@ -386 +368 @@
 }
 
-static void get_dev_prop(device_t *dev, char *line)
+static void fun_prop_parse(isa_fun_t *fun, char *line)
 {
         /* Skip leading spaces. */
         line = skip_spaces(line);
 
-        if (!read_dev_prop(dev, line, "io_range", &get_dev_io_range) &&
-            !read_dev_prop(dev, line, "irq", &get_dev_irq) &&
-            !read_dev_prop(dev, line, "match", &get_dev_match_id))
+        if (!prop_parse(fun, line, "io_range", &fun_parse_io_range) &&
+            !prop_parse(fun, line, "irq", &fun_parse_irq) &&
+            !prop_parse(fun, line, "match", &fun_parse_match_id))
         {
             printf(NAME " error undefined device property at line '%s'\n",
@@ -400 +382 @@
 }
 
-static void child_alloc_hw_res(device_t *dev)
-{
-        isa_child_data_t *data = (isa_child_data_t *)dev->driver_data;
-        data->hw_resources.resources = 
+static void fun_hw_res_alloc(isa_fun_t *fun)
+{
+        fun->hw_resources.resources = 
             (hw_resource_t *)malloc(sizeof(hw_resource_t) * ISA_MAX_HW_RES);
 }
 
-static char *read_isa_dev_info(char *dev_conf, device_t *parent)
+static char *isa_fun_read_info(char *fun_conf, ddf_dev_t *dev)
 {
         char *line;
-        char *dev_name = NULL;
+        char *fun_name = NULL;
 
         /* Skip empty lines. */
         while (true) {
-                line = str_get_line(dev_conf, &dev_conf);
+                line = str_get_line(fun_conf, &fun_conf);
 
                 if (line == NULL) {
@@ -426 +407 @@
 
         /* Get device name. */
-        dev_name = get_device_name(line);
-        if (dev_name == NULL)
+        fun_name = get_device_name(line);
+        if (fun_name == NULL)
                 return NULL;
 
-        device_t *dev = create_isa_child_dev();
-        if (dev == NULL) {
-                free(dev_name);
+        isa_fun_t *fun = isa_fun_create(dev, fun_name);
+        if (fun == NULL) {
+                free(fun_name);
                 return NULL;
         }
 
-        dev->name = dev_name;
-
         /* Allocate buffer for the list of hardware resources of the device. */
-        child_alloc_hw_res(dev);
+        fun_hw_res_alloc(fun);
 
         /* Get properties of the device (match ids, irq and io range). */
         while (true) {
-                line = str_get_line(dev_conf, &dev_conf);
+                line = str_get_line(fun_conf, &fun_conf);
 
                 if (line_empty(line)) {
@@ -454 +433 @@
                  * and store it in the device structure.
                  */
-                get_dev_prop(dev, line);
-
-                //printf(NAME ": next line ='%s'\n", dev_conf);
-                //printf(NAME ": current line ='%s'\n", line);
+                fun_prop_parse(fun, line);
         }
 
         /* Set device operations to the device. */
-        dev->ops = &isa_child_dev_ops;
-
-        printf(NAME ": child_device_register(dev, parent); device is %s.\n",
-            dev->name);
-        child_device_register(dev, parent);
-
-        return dev_conf;
-}
-
-static void parse_dev_conf(char *conf, device_t *parent)
+        fun->fnode->ops = &isa_fun_ops;
+
+        printf(NAME ": Binding function %s.\n", fun->fnode->name);
+
+        /* XXX Handle error */
+        (void) ddf_fun_bind(fun->fnode);
+
+        return fun_conf;
+}
+
+static void fun_conf_parse(char *conf, ddf_dev_t *dev)
 {
         while (conf != NULL && *conf != '\0') {
-                conf = read_isa_dev_info(conf, parent);
-        }
-}
-
-static void add_legacy_children(device_t *parent)
-{
-        char *dev_conf;
-
-        dev_conf = read_dev_conf(CHILD_DEV_CONF_PATH);
-        if (dev_conf != NULL) {
-                parse_dev_conf(dev_conf, parent);
-                free(dev_conf);
-        }
-}
-
-static int isa_add_device(device_t *dev)
+                conf = isa_fun_read_info(conf, dev);
+        }
+}
+
+static void isa_functions_add(ddf_dev_t *dev)
+{
+        char *fun_conf;
+
+        fun_conf = fun_conf_read(CHILD_FUN_CONF_PATH);
+        if (fun_conf != NULL) {
+                fun_conf_parse(fun_conf, dev);
+                free(fun_conf);
+        }
+}
+
+static int isa_add_device(ddf_dev_t *dev)
 {
         printf(NAME ": isa_add_device, device handle = %d\n",
             (int) dev->handle);
 
-        /* Add child devices. */
-        add_legacy_children(dev);
-        printf(NAME ": finished the enumeration of legacy devices\n");
+        /* Make the bus device more visible. Does not do anything. */
+        printf(NAME ": adding a 'ctl' function\n");
+
+        ddf_fun_t *ctl = ddf_fun_create(dev, fun_exposed, "ctl");
+        if (ctl == NULL) {
+                printf(NAME ": Error creating control function.\n");
+                return EXDEV;
+        }
+
+        if (ddf_fun_bind(ctl) != EOK) {
+                printf(NAME ": Error binding control function.\n");
+                return EXDEV;
+        }
+
+        /* Add functions as specified in the configuration file. */
+        isa_functions_add(dev);
+        printf(NAME ": finished the enumeration of legacy functions\n");
 
         return EOK;
@@ -502 +493 @@
 static void isa_init() 
 {
-        isa_child_dev_ops.interfaces[HW_RES_DEV_IFACE] = &isa_child_hw_res_ops;
+        isa_fun_ops.interfaces[HW_RES_DEV_IFACE] = &isa_fun_hw_res_ops;
 }
 
@@ -509 +500 @@
         printf(NAME ": HelenOS ISA bus driver\n");
         isa_init();
-        return driver_main(&isa_driver);
+        return ddf_driver_main(&isa_driver);
 }
 
@@ -515 +506 @@
  * @}
  */
- 

uspace/drv/ns8250/ns8250.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2010 Lenka Trochtova
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -52 +53 @@
 #include <libarch/ddi.h>
 
-#include <driver.h>
+#include <ddf/driver.h>
+#include <ddf/interrupt.h>
 #include <ops/char_dev.h>
 
@@ -67 +69 @@
 #define MAX_BAUD_RATE 115200
 #define DLAB_MASK (1 << 7)
+
+/** Obtain soft-state structure from function node */
+#define NS8250(fnode) ((ns8250_t *) ((fnode)->dev->driver_data))
+
+/** Obtain soft-state structure from device node */
+#define NS8250_FROM_DEV(dnode) ((ns8250_t *) ((dnode)->driver_data))
 
 /** The number of bits of one data unit send by the serial port. */
@@ -85 +93 @@
 
 /** The driver data for the serial port devices. */
-typedef struct ns8250_dev_data {
+typedef struct ns8250 {
+        /** DDF device node */
+        ddf_dev_t *dev;
+        /** DDF function node */
+        ddf_fun_t *fun;
         /** Is there any client conntected to the device? */
         bool client_connected;
@@ -98 +110 @@
         /** The fibril mutex for synchronizing the access to the device. */
         fibril_mutex_t mutex;
-} ns8250_dev_data_t;
-
-/** Create driver data for a device.
- *
- * @return              The driver data.
- */
-static ns8250_dev_data_t *create_ns8250_dev_data(void)
-{
-        ns8250_dev_data_t *data;
-        
-        data = (ns8250_dev_data_t *) malloc(sizeof(ns8250_dev_data_t));
-        if (NULL != data) {
-                memset(data, 0, sizeof(ns8250_dev_data_t));
-                fibril_mutex_initialize(&data->mutex);
-        }
-        return data;
-}
-
-/** Delete driver data.
- *
- * @param data          The driver data structure.
- */
-static void delete_ns8250_dev_data(ns8250_dev_data_t *data)
-{
-        if (data != NULL)
-                free(data);
+} ns8250_t;
+
+/** Create per-device soft-state structure.
+ *
+ * @return      Pointer to soft-state structure.
+ */
+static ns8250_t *ns8250_new(void)
+{
+        ns8250_t *ns;
+        
+        ns = (ns8250_t *) calloc(1, sizeof(ns8250_t));
+        if (ns == NULL)
+                return NULL;
+        
+        fibril_mutex_initialize(&ns->mutex);
+        return ns;
+}
+
+/** Delete soft-state structure.
+ *
+ * @param ns    The driver data structure.
+ */
+static void ns8250_delete(ns8250_t *ns)
+{
+        assert(ns != NULL);
+        free(ns);
 }
 
@@ -171 +183 @@
 /** Read data from the serial port device.
  *
- * @param dev           The serial port device.
+ * @param fun           The serial port function
  * @param buf           The ouput buffer for read data.
  * @param count         The number of bytes to be read.
@@ -178 +190 @@
  *                      error number otherwise.
  */
-static int ns8250_read(device_t *dev, char *buf, size_t count)
-{
+static int ns8250_read(ddf_fun_t *fun, char *buf, size_t count)
+{
+        ns8250_t *ns = NS8250(fun);
         int ret = EOK;
-        ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
-        
-        fibril_mutex_lock(&data->mutex);
-        while (!buf_is_empty(&data->input_buffer) && (size_t)ret < count) {
-                buf[ret] = (char)buf_pop_front(&data->input_buffer);
+        
+        fibril_mutex_lock(&ns->mutex);
+        while (!buf_is_empty(&ns->input_buffer) && (size_t)ret < count) {
+                buf[ret] = (char)buf_pop_front(&ns->input_buffer);
                 ret++;
         }
-        fibril_mutex_unlock(&data->mutex);
+        fibril_mutex_unlock(&ns->mutex);
         
         return ret;
@@ -195 +207 @@
 /** Write a character to the serial port.
  *
- * @param data          The serial port device's driver data.
- * @param c             The character to be written.
- */
-static inline void ns8250_putchar(ns8250_dev_data_t *data, uint8_t c)
-{
-        fibril_mutex_lock(&data->mutex);
-        ns8250_write_8(data->port, c);
-        fibril_mutex_unlock(&data->mutex);
+ * @param ns            Serial port device
+ * @param c             The character to be written
+ */
+static inline void ns8250_putchar(ns8250_t *ns, uint8_t c)
+{
+        fibril_mutex_lock(&ns->mutex);
+        ns8250_write_8(ns->port, c);
+        fibril_mutex_unlock(&ns->mutex);
 }
 
 /** Write data to the serial port.
  *
- * @param dev           The serial port device.
- * @param buf           The data to be written.
- * @param count         The number of bytes to be written.
- * @return              Zero on success.
- */
-static int ns8250_write(device_t *dev, char *buf, size_t count) 
-{
-        ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
+ * @param fun           The serial port function
+ * @param buf           The data to be written
+ * @param count         The number of bytes to be written
+ * @return              Zero on success
+ */
+static int ns8250_write(ddf_fun_t *fun, char *buf, size_t count)
+{
+        ns8250_t *ns = NS8250(fun);
         size_t idx;
         
         for (idx = 0; idx < count; idx++)
-                ns8250_putchar(data, (uint8_t) buf[idx]);
+                ns8250_putchar(ns, (uint8_t) buf[idx]);
         
         return 0;
 }
 
-static device_ops_t ns8250_dev_ops;
+static ddf_dev_ops_t ns8250_dev_ops;
 
 /** The character interface's callbacks. */
@@ -231 +243 @@
 };
 
-static int ns8250_add_device(device_t *dev);
+static int ns8250_add_device(ddf_dev_t *dev);
 
 /** The serial port device driver's standard operations. */
@@ -244 +256 @@
 };
 
-/** Clean up the serial port device structure.
- *
- * @param dev           The device structure.
- */
-static void ns8250_dev_cleanup(device_t *dev)
-{
-        if (dev->driver_data != NULL) {
-                delete_ns8250_dev_data((ns8250_dev_data_t*) dev->driver_data);
-                dev->driver_data = NULL;
-        }
-        
-        if (dev->parent_phone > 0) {
-                async_hangup(dev->parent_phone);
-                dev->parent_phone = 0;
+/** Clean up the serial port soft-state
+ *
+ * @param ns            Serial port device
+ */
+static void ns8250_dev_cleanup(ns8250_t *ns)
+{
+        if (ns->dev->parent_phone > 0) {
+                async_hangup(ns->dev->parent_phone);
+                ns->dev->parent_phone = 0;
         }
 }
@@ -263 +270 @@
 /** Enable the i/o ports of the device.
  *
- * @param dev           The serial port device.
- * @return              True on success, false otherwise.
- */
-static bool ns8250_pio_enable(device_t *dev)
-{
-        printf(NAME ": ns8250_pio_enable %s\n", dev->name);
-        
-        ns8250_dev_data_t *data = (ns8250_dev_data_t *)dev->driver_data;
+ * @param ns            Serial port device
+ * @return              True on success, false otherwise
+ */
+static bool ns8250_pio_enable(ns8250_t *ns)
+{
+        printf(NAME ": ns8250_pio_enable %s\n", ns->dev->name);
         
         /* Gain control over port's registers. */
-        if (pio_enable((void *)(uintptr_t) data->io_addr, REG_COUNT,
-            (void **) &data->port)) {
+        if (pio_enable((void *)(uintptr_t) ns->io_addr, REG_COUNT,
+            (void **) &ns->port)) {
                 printf(NAME ": error - cannot gain the port %#" PRIx32 " for device "
-                    "%s.\n", data->io_addr, dev->name);
+                    "%s.\n", ns->io_addr, ns->dev->name);
                 return false;
         }
@@ -285 +290 @@
 /** Probe the serial port device for its presence.
  *
- * @param dev           The serial port device.
- * @return              True if the device is present, false otherwise.
- */
-static bool ns8250_dev_probe(device_t *dev)
-{
-        printf(NAME ": ns8250_dev_probe %s\n", dev->name);
-        
-        ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
-        ioport8_t *port_addr = data->port;
+ * @param ns            Serial port device
+ * @return              True if the device is present, false otherwise
+ */
+static bool ns8250_dev_probe(ns8250_t *ns)
+{
+        printf(NAME ": ns8250_dev_probe %s\n", ns->dev->name);
+        
+        ioport8_t *port_addr = ns->port;
         bool res = true;
         uint8_t olddata;
@@ -310 +314 @@
         
         if (!res)
-                printf(NAME ": device %s is not present.\n", dev->name);
+                printf(NAME ": device %s is not present.\n", ns->dev->name);
         
         return res;
@@ -317 +321 @@
 /** Initialize serial port device.
  *
- * @param dev           The serial port device.
- * @return              Zero on success, negative error number otherwise.
- */
-static int ns8250_dev_initialize(device_t *dev)
-{
-        printf(NAME ": ns8250_dev_initialize %s\n", dev->name);
+ * @param ns            Serial port device
+ * @return              Zero on success, negative error number otherwise
+ */
+static int ns8250_dev_initialize(ns8250_t *ns)
+{
+        printf(NAME ": ns8250_dev_initialize %s\n", ns->dev->name);
         
         int ret = EOK;
@@ -329 +333 @@
         memset(&hw_resources, 0, sizeof(hw_resource_list_t));
         
-        /* Allocate driver data for the device. */
-        ns8250_dev_data_t *data = create_ns8250_dev_data();
-        if (data == NULL)
-                return ENOMEM;
-        dev->driver_data = data;
-        
         /* Connect to the parent's driver. */
-        dev->parent_phone = devman_parent_device_connect(dev->handle,
+        ns->dev->parent_phone = devman_parent_device_connect(ns->dev->handle,
             IPC_FLAG_BLOCKING);
-        if (dev->parent_phone < 0) {
+        if (ns->dev->parent_phone < 0) {
                 printf(NAME ": failed to connect to the parent driver of the "
-                    "device %s.\n", dev->name);
-                ret = dev->parent_phone;
+                    "device %s.\n", ns->dev->name);
+                ret = ns->dev->parent_phone;
                 goto failed;
         }
         
         /* Get hw resources. */
-        ret = hw_res_get_resource_list(dev->parent_phone, &hw_resources);
+        ret = hw_res_get_resource_list(ns->dev->parent_phone, &hw_resources);
         if (ret != EOK) {
                 printf(NAME ": failed to get hw resources for the device "
-                    "%s.\n", dev->name);
+                    "%s.\n", ns->dev->name);
                 goto failed;
         }
@@ -362 +360 @@
                 switch (res->type) {
                 case INTERRUPT:
-                        data->irq = res->res.interrupt.irq;
+                        ns->irq = res->res.interrupt.irq;
                         irq = true;
                         printf(NAME ": the %s device was asigned irq = 0x%x.\n",
-                            dev->name, data->irq);
+                            ns->dev->name, ns->irq);
                         break;
                         
                 case IO_RANGE:
-                        data->io_addr = res->res.io_range.address;
+                        ns->io_addr = res->res.io_range.address;
                         if (res->res.io_range.size < REG_COUNT) {
                                 printf(NAME ": i/o range assigned to the device "
-                                    "%s is too small.\n", dev->name);
+                                    "%s is too small.\n", ns->dev->name);
                                 ret = ELIMIT;
                                 goto failed;
@@ -378 +376 @@
                         ioport = true;
                         printf(NAME ": the %s device was asigned i/o address = "
-                            "0x%x.\n", dev->name, data->io_addr);
+                            "0x%x.\n", ns->dev->name, ns->io_addr);
                         break;
                         
@@ -388 +386 @@
         if (!irq || !ioport) {
                 printf(NAME ": missing hw resource(s) for the device %s.\n",
-                    dev->name);
+                    ns->dev->name);
                 ret = ENOENT;
                 goto failed;
@@ -397 +395 @@
         
 failed:
-        ns8250_dev_cleanup(dev);
+        ns8250_dev_cleanup(ns);
         hw_res_clean_resource_list(&hw_resources);
         return ret;
@@ -404 +402 @@
 /** Enable interrupts on the serial port device.
  *
- * Interrupt when data is received.
+ * Interrupt when data is received
  *
  * @param port          The base address of the serial port device's ports.
  */
 static inline void ns8250_port_interrupts_enable(ioport8_t *port)
-{       
+{
         pio_write_8(port + 1, 0x1);     /* Interrupt when data received. */
         pio_write_8(port + 4, 0xB);
@@ -416 +414 @@
 /** Disable interrupts on the serial port device.
  *
- * @param port          The base address of the serial port device's ports.
+ * @param port          The base address of the serial port device's ports
  */
 static inline void ns8250_port_interrupts_disable(ioport8_t *port)
@@ -425 +423 @@
 /** Enable interrupts for the serial port device.
  *
- * @param dev           The device.
- * @return              Zero on success, negative error number otherwise.
- */
-static int ns8250_interrupt_enable(device_t *dev)
-{
-        ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
-        
+ * @param ns            Serial port device
+ * @return              Zero on success, negative error number otherwise
+ */
+static int ns8250_interrupt_enable(ns8250_t *ns)
+{
         /* Enable interrupt on the serial port. */
-        ns8250_port_interrupts_enable(data->port);
+        ns8250_port_interrupts_enable(ns->port);
         
         return EOK;
@@ -618 +614 @@
  * Set the default parameters of the serial communication.
  *
- * @param dev           The serial port device.
- */
-static void ns8250_initialize_port(device_t *dev)
-{
-        ns8250_dev_data_t *data = (ns8250_dev_data_t *)dev->driver_data;
-        ioport8_t *port = data->port;
+ * @param ns            Serial port device
+ */
+static void ns8250_initialize_port(ns8250_t *ns)
+{
+        ioport8_t *port = ns->port;
         
         /* Disable interrupts. */
@@ -643 +638 @@
  * buffer.
  *
- * @param dev           The serial port device.
- */
-static void ns8250_read_from_device(device_t *dev)
-{
-        ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
-        ioport8_t *port = data->port;
+ * @param ns            Serial port device
+ */
+static void ns8250_read_from_device(ns8250_t *ns)
+{
+        ioport8_t *port = ns->port;
         bool cont = true;
         
         while (cont) {
-                fibril_mutex_lock(&data->mutex);
+                fibril_mutex_lock(&ns->mutex);
                 
                 cont = ns8250_received(port);
@@ -658 +652 @@
                         uint8_t val = ns8250_read_8(port);
                         
-                        if (data->client_connected) {
-                                if (!buf_push_back(&data->input_buffer, val)) {
+                        if (ns->client_connected) {
+                                if (!buf_push_back(&ns->input_buffer, val)) {
                                         printf(NAME ": buffer overflow on "
-                                            "%s.\n", dev->name);
+                                            "%s.\n", ns->dev->name);
                                 } else {
                                         printf(NAME ": the character %c saved "
                                             "to the buffer of %s.\n",
-                                            val, dev->name);
+                                            val, ns->dev->name);
                                 }
                         }
                 }
                 
-                fibril_mutex_unlock(&data->mutex);
+                fibril_mutex_unlock(&ns->mutex);
                 fibril_yield();
         }
@@ -682 +676 @@
  * @param dev           The serial port device.
  */
-static inline void ns8250_interrupt_handler(device_t *dev, ipc_callid_t iid,
+static inline void ns8250_interrupt_handler(ddf_dev_t *dev, ipc_callid_t iid,
     ipc_call_t *icall)
 {
-        ns8250_read_from_device(dev);
+        ns8250_read_from_device(NS8250_FROM_DEV(dev));
 }
 
 /** Register the interrupt handler for the device.
  *
+ * @param ns            Serial port device
+ */
+static inline int ns8250_register_interrupt_handler(ns8250_t *ns)
+{
+        return register_interrupt_handler(ns->dev, ns->irq,
+            ns8250_interrupt_handler, NULL);
+}
+
+/** Unregister the interrupt handler for the device.
+ *
+ * @param ns            Serial port device
+ */
+static inline int ns8250_unregister_interrupt_handler(ns8250_t *ns)
+{
+        return unregister_interrupt_handler(ns->dev, ns->irq);
+}
+
+/** The add_device callback method of the serial port driver.
+ *
+ * Probe and initialize the newly added device.
+ *
  * @param dev           The serial port device.
  */
-static inline int ns8250_register_interrupt_handler(device_t *dev)
-{
-        ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
-        
-        return register_interrupt_handler(dev, data->irq,
-            ns8250_interrupt_handler, NULL);
-}
-
-/** Unregister the interrupt handler for the device.
- *
- * @param dev           The serial port device.
- */
-static inline int ns8250_unregister_interrupt_handler(device_t *dev)
-{
-        ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
-        
-        return unregister_interrupt_handler(dev, data->irq);
-}
-
-/** The add_device callback method of the serial port driver.
- *
- * Probe and initialize the newly added device.
- *
- * @param dev           The serial port device.
- */
-static int ns8250_add_device(device_t *dev)
-{
+static int ns8250_add_device(ddf_dev_t *dev)
+{
+        ns8250_t *ns = NULL;
+        ddf_fun_t *fun = NULL;
+        bool need_cleanup = false;
+        int rc;
+        
         printf(NAME ": ns8250_add_device %s (handle = %d)\n",
             dev->name, (int) dev->handle);
         
-        int res = ns8250_dev_initialize(dev);
-        if (res != EOK)
-                return res;
-        
-        if (!ns8250_pio_enable(dev)) {
-                ns8250_dev_cleanup(dev);
-                return EADDRNOTAVAIL;
+        /* Allocate soft-state for the device */
+        ns = ns8250_new();
+        if (ns == NULL) {
+                rc = ENOMEM;
+                goto fail;
+        }
+        
+        ns->dev = dev;
+        dev->driver_data = ns;
+        
+        rc = ns8250_dev_initialize(ns);
+        if (rc != EOK)
+                goto fail;
+        
+        need_cleanup = true;
+        
+        if (!ns8250_pio_enable(ns)) {
+                rc = EADDRNOTAVAIL;
+                goto fail;
         }
         
         /* Find out whether the device is present. */
-        if (!ns8250_dev_probe(dev)) {
-                ns8250_dev_cleanup(dev);
-                return ENOENT;
+        if (!ns8250_dev_probe(ns)) {
+                rc = ENOENT;
+                goto fail;
         }
         
         /* Serial port initialization (baud rate etc.). */
-        ns8250_initialize_port(dev);
+        ns8250_initialize_port(ns);
         
         /* Register interrupt handler. */
-        if (ns8250_register_interrupt_handler(dev) != EOK) {
+        if (ns8250_register_interrupt_handler(ns) != EOK) {
                 printf(NAME ": failed to register interrupt handler.\n");
-                ns8250_dev_cleanup(dev);
-                return res;
+                rc = EADDRNOTAVAIL;
+                goto fail;
         }
         
         /* Enable interrupt. */
-        res = ns8250_interrupt_enable(dev);
-        if (res != EOK) {
+        rc = ns8250_interrupt_enable(ns);
+        if (rc != EOK) {
                 printf(NAME ": failed to enable the interrupt. Error code = "
-                    "%d.\n", res);
-                ns8250_dev_cleanup(dev);
-                ns8250_unregister_interrupt_handler(dev);
-                return res;
+                    "%d.\n", rc);
+                goto fail;
+        }
+        
+        fun = ddf_fun_create(dev, fun_exposed, "a");
+        if (fun == NULL) {
+                printf(NAME ": error creating function.\n");
+                goto fail;
         }
         
         /* Set device operations. */
-        dev->ops = &ns8250_dev_ops;
-        
-        add_device_to_class(dev, "serial");
+        fun->ops = &ns8250_dev_ops;
+        rc = ddf_fun_bind(fun);
+        if (rc != EOK) {
+                printf(NAME ": error binding function.\n");
+                goto fail;
+        }
+
+        ns->fun = fun;
+        
+        ddf_fun_add_to_class(fun, "serial");
         
         printf(NAME ": the %s device has been successfully initialized.\n",
@@ -766 +784 @@
         
         return EOK;
+fail:
+        if (fun != NULL)
+                ddf_fun_destroy(fun);
+        if (need_cleanup)
+                ns8250_dev_cleanup(ns);
+        if (ns != NULL)
+                ns8250_delete(ns);
+        return rc;
 }
 
@@ -775 +801 @@
  * @param dev           The device.
  */
-static int ns8250_open(device_t *dev)
-{
-        ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
+static int ns8250_open(ddf_fun_t *fun)
+{
+        ns8250_t *data = (ns8250_t *) fun->dev->driver_data;
         int res;
         
@@ -788 +814 @@
         }
         fibril_mutex_unlock(&data->mutex);
-
+        
         return res;
 }
@@ -799 +825 @@
  * @param dev           The device.
  */
-static void ns8250_close(device_t *dev)
-{
-        ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
+static void ns8250_close(ddf_fun_t *fun)
+{
+        ns8250_t *data = (ns8250_t *) fun->dev->driver_data;
         
         fibril_mutex_lock(&data->mutex);
@@ -823 +849 @@
  */
 static void
-ns8250_get_props(device_t *dev, unsigned int *baud_rate, unsigned int *parity,
+ns8250_get_props(ddf_dev_t *dev, unsigned int *baud_rate, unsigned int *parity,
     unsigned int *word_length, unsigned int* stop_bits)
 {
-        ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
+        ns8250_t *data = (ns8250_t *) dev->driver_data;
         ioport8_t *port = data->port;
         
@@ -850 +876 @@
  * @param stop_bits     The number of stop bits to be used.
  */
-static int ns8250_set_props(device_t *dev, unsigned int baud_rate,
+static int ns8250_set_props(ddf_dev_t *dev, unsigned int baud_rate,
     unsigned int parity, unsigned int word_length, unsigned int stop_bits)
 {
@@ -857 +883 @@
             stop_bits);
         
-        ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
+        ns8250_t *data = (ns8250_t *) dev->driver_data;
         ioport8_t *port = data->port;
         int ret;
@@ -877 +903 @@
  * Configure the parameters of the serial communication.
  */
-static void ns8250_default_handler(device_t *dev, ipc_callid_t callid,
+static void ns8250_default_handler(ddf_fun_t *fun, ipc_callid_t callid,
     ipc_call_t *call)
 {
@@ -886 +912 @@
         switch (method) {
         case SERIAL_GET_COM_PROPS:
-                ns8250_get_props(dev, &baud_rate, &parity, &word_length,
+                ns8250_get_props(fun->dev, &baud_rate, &parity, &word_length,
                     &stop_bits);
                 async_answer_4(callid, EOK, baud_rate, parity, word_length,
@@ -897 +923 @@
                 word_length = IPC_GET_ARG3(*call);
                 stop_bits = IPC_GET_ARG4(*call);
-                ret = ns8250_set_props(dev, baud_rate, parity, word_length,
+                ret = ns8250_set_props(fun->dev, baud_rate, parity, word_length,
                     stop_bits);
                 async_answer_0(callid, ret);
@@ -925 +951 @@
         printf(NAME ": HelenOS serial port driver\n");
         ns8250_init();
-        return driver_main(&ns8250_driver);
+        return ddf_driver_main(&ns8250_driver);
 }
 

uspace/drv/pciintel/pci.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2010 Lenka Trochtova
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -44 +45 @@
 #include <ctype.h>
 #include <macros.h>
-
-#include <driver.h>
+#include <str_error.h>
+
+#include <ddf/driver.h>
 #include <devman.h>
 #include <ipc/devman.h>
@@ -61 +63 @@
         ((1 << 31) | (bus << 16) | (dev << 11) | (fn << 8) | (reg & ~3))
 
-static hw_resource_list_t *pciintel_get_child_resources(device_t *dev)
-{
-        pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data;
-        
-        if (dev_data == NULL)
+/** Obtain PCI function soft-state from DDF function node */
+#define PCI_FUN(fnode) ((pci_fun_t *) (fnode)->driver_data)
+
+/** Obtain PCI bus soft-state from DDF device node */
+#define PCI_BUS(dnode) ((pci_bus_t *) (dnode)->driver_data)
+
+/** Obtain PCI bus soft-state from function soft-state */
+#define PCI_BUS_FROM_FUN(fun) ((fun)->busptr)
+
+static hw_resource_list_t *pciintel_get_resources(ddf_fun_t *fnode)
+{
+        pci_fun_t *fun = PCI_FUN(fnode);
+        
+        if (fun == NULL)
                 return NULL;
-        return &dev_data->hw_resources;
-}
-
-static bool pciintel_enable_child_interrupt(device_t *dev)
+        return &fun->hw_resources;
+}
+
+static bool pciintel_enable_interrupt(ddf_fun_t *fnode)
 {
         /* TODO */
@@ -77 +88 @@
 }
 
-static hw_res_ops_t pciintel_child_hw_res_ops = {
-        &pciintel_get_child_resources,
-        &pciintel_enable_child_interrupt
+static hw_res_ops_t pciintel_hw_res_ops = {
+        &pciintel_get_resources,
+        &pciintel_enable_interrupt
 };
 
-static device_ops_t pci_child_ops;
-
-static int pci_add_device(device_t *);
-
-/** The pci bus driver's standard operations. */
+static ddf_dev_ops_t pci_fun_ops;
+
+static int pci_add_device(ddf_dev_t *);
+
+/** PCI bus driver standard operations */
 static driver_ops_t pci_ops = {
         .add_device = &pci_add_device
 };
 
-/** The pci bus driver structure. */
+/** PCI bus driver structure */
 static driver_t pci_driver = {
         .name = NAME,
@@ -97 +108 @@
 };
 
-typedef struct pciintel_bus_data {
-        uint32_t conf_io_addr;
-        void *conf_data_port;
-        void *conf_addr_port;
-        fibril_mutex_t conf_mutex;
-} pci_bus_data_t;
-
-static pci_bus_data_t *create_pci_bus_data(void)
-{
-        pci_bus_data_t *bus_data;
-        
-        bus_data = (pci_bus_data_t *) malloc(sizeof(pci_bus_data_t));
-        if (bus_data != NULL) {
-                memset(bus_data, 0, sizeof(pci_bus_data_t));
-                fibril_mutex_initialize(&bus_data->conf_mutex);
-        }
-
-        return bus_data;
-}
-
-static void delete_pci_bus_data(pci_bus_data_t *bus_data)
-{
-        free(bus_data);
-}
-
-static void pci_conf_read(device_t *dev, int reg, uint8_t *buf, size_t len)
-{
-        assert(dev->parent != NULL);
-        
-        pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data;
-        pci_bus_data_t *bus_data = (pci_bus_data_t *) dev->parent->driver_data;
-        
-        fibril_mutex_lock(&bus_data->conf_mutex);
+static pci_bus_t *pci_bus_new(void)
+{
+        pci_bus_t *bus;
+        
+        bus = (pci_bus_t *) calloc(1, sizeof(pci_bus_t));
+        if (bus == NULL)
+                return NULL;
+        
+        fibril_mutex_initialize(&bus->conf_mutex);
+        return bus;
+}
+
+static void pci_bus_delete(pci_bus_t *bus)
+{
+        assert(bus != NULL);
+        free(bus);
+}
+
+static void pci_conf_read(pci_fun_t *fun, int reg, uint8_t *buf, size_t len)
+{
+        pci_bus_t *bus = PCI_BUS_FROM_FUN(fun);
+        
+        fibril_mutex_lock(&bus->conf_mutex);
         
         uint32_t conf_addr;
-        conf_addr = CONF_ADDR(dev_data->bus, dev_data->dev, dev_data->fn, reg);
-        void *addr = bus_data->conf_data_port + (reg & 3);
-        
-        pio_write_32(bus_data->conf_addr_port, conf_addr);
+        conf_addr = CONF_ADDR(fun->bus, fun->dev, fun->fn, reg);
+        void *addr = bus->conf_data_port + (reg & 3);
+        
+        pio_write_32(bus->conf_addr_port, conf_addr);
         
         switch (len) {
@@ -149 +150 @@
         }
         
-        fibril_mutex_unlock(&bus_data->conf_mutex);
-}
-
-static void pci_conf_write(device_t *dev, int reg, uint8_t *buf, size_t len)
-{
-        assert(dev->parent != NULL);
-        
-        pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data;
-        pci_bus_data_t *bus_data = (pci_bus_data_t *) dev->parent->driver_data;
-        
-        fibril_mutex_lock(&bus_data->conf_mutex);
+        fibril_mutex_unlock(&bus->conf_mutex);
+}
+
+static void pci_conf_write(pci_fun_t *fun, int reg, uint8_t *buf, size_t len)
+{
+        pci_bus_t *bus = PCI_BUS_FROM_FUN(fun);
+        
+        fibril_mutex_lock(&bus->conf_mutex);
         
         uint32_t conf_addr;
-        conf_addr = CONF_ADDR(dev_data->bus, dev_data->dev, dev_data->fn, reg);
-        void *addr = bus_data->conf_data_port + (reg & 3);
-        
-        pio_write_32(bus_data->conf_addr_port, conf_addr);
+        conf_addr = CONF_ADDR(fun->bus, fun->dev, fun->fn, reg);
+        void *addr = bus->conf_data_port + (reg & 3);
+        
+        pio_write_32(bus->conf_addr_port, conf_addr);
         
         switch (len) {
@@ -179 +177 @@
         }
         
-        fibril_mutex_unlock(&bus_data->conf_mutex);
-}
-
-uint8_t pci_conf_read_8(device_t *dev, int reg)
+        fibril_mutex_unlock(&bus->conf_mutex);
+}
+
+uint8_t pci_conf_read_8(pci_fun_t *fun, int reg)
 {
         uint8_t res;
-        pci_conf_read(dev, reg, &res, 1);
+        pci_conf_read(fun, reg, &res, 1);
         return res;
 }
 
-uint16_t pci_conf_read_16(device_t *dev, int reg)
+uint16_t pci_conf_read_16(pci_fun_t *fun, int reg)
 {
         uint16_t res;
-        pci_conf_read(dev, reg, (uint8_t *) &res, 2);
+        pci_conf_read(fun, reg, (uint8_t *) &res, 2);
         return res;
 }
 
-uint32_t pci_conf_read_32(device_t *dev, int reg)
+uint32_t pci_conf_read_32(pci_fun_t *fun, int reg)
 {
         uint32_t res;
-        pci_conf_read(dev, reg, (uint8_t *) &res, 4);
+        pci_conf_read(fun, reg, (uint8_t *) &res, 4);
         return res;
 }
 
-void pci_conf_write_8(device_t *dev, int reg, uint8_t val)
-{
-        pci_conf_write(dev, reg, (uint8_t *) &val, 1);
-}
-
-void pci_conf_write_16(device_t *dev, int reg, uint16_t val)
-{
-        pci_conf_write(dev, reg, (uint8_t *) &val, 2);
-}
-
-void pci_conf_write_32(device_t *dev, int reg, uint32_t val)
-{
-        pci_conf_write(dev, reg, (uint8_t *) &val, 4);
-}
-
-void create_pci_match_ids(device_t *dev)
-{
-        pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data;
-        match_id_t *match_id = NULL;
+void pci_conf_write_8(pci_fun_t *fun, int reg, uint8_t val)
+{
+        pci_conf_write(fun, reg, (uint8_t *) &val, 1);
+}
+
+void pci_conf_write_16(pci_fun_t *fun, int reg, uint16_t val)
+{
+        pci_conf_write(fun, reg, (uint8_t *) &val, 2);
+}
+
+void pci_conf_write_32(pci_fun_t *fun, int reg, uint32_t val)
+{
+        pci_conf_write(fun, reg, (uint8_t *) &val, 4);
+}
+
+void pci_fun_create_match_ids(pci_fun_t *fun)
+{
         char *match_id_str;
-        
-        match_id = create_match_id();
-        if (match_id != NULL) {
-                asprintf(&match_id_str, "pci/ven=%04x&dev=%04x",
-                    dev_data->vendor_id, dev_data->device_id);
-                match_id->id = match_id_str;
-                match_id->score = 90;
-                add_match_id(&dev->match_ids, match_id);
-        }
-
+        int rc;
+        
+        asprintf(&match_id_str, "pci/ven=%04x&dev=%04x",
+            fun->vendor_id, fun->device_id);
+
+        if (match_id_str == NULL) {
+                printf(NAME ": out of memory creating match ID.\n");
+                return;
+        }
+
+        rc = ddf_fun_add_match_id(fun->fnode, match_id_str, 90);
+        if (rc != EOK) {
+                printf(NAME ": error adding match ID: %s\n",
+                    str_error(rc));
+        }
+        
         /* TODO add more ids (with subsys ids, using class id etc.) */
 }
 
-void
-pci_add_range(device_t *dev, uint64_t range_addr, size_t range_size, bool io)
-{
-        pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data;
-        hw_resource_list_t *hw_res_list = &dev_data->hw_resources;
+void pci_add_range(pci_fun_t *fun, uint64_t range_addr, size_t range_size,
+    bool io)
+{
+        hw_resource_list_t *hw_res_list = &fun->hw_resources;
         hw_resource_t *hw_resources =  hw_res_list->resources;
         size_t count = hw_res_list->count;
@@ -265 +266 @@
  * address add it to the devices hw resource list.
  *
- * @param dev   The pci device.
+ * @param fun   PCI function
  * @param addr  The address of the BAR in the PCI configuration address space of
- *              the device.
- * @return      The addr the address of the BAR which should be read next.
+ *              the device
+ * @return      The addr the address of the BAR which should be read next
  */
-int pci_read_bar(device_t *dev, int addr)
-{       
+int pci_read_bar(pci_fun_t *fun, int addr)
+{
         /* Value of the BAR */
         uint32_t val, mask;
@@ -285 +286 @@
         
         /* Get the value of the BAR. */
-        val = pci_conf_read_32(dev, addr);
+        val = pci_conf_read_32(fun, addr);
         
         io = (bool) (val & 1);
@@ -305 +306 @@
         
         /* Get the address mask. */
-        pci_conf_write_32(dev, addr, 0xffffffff);
-        mask = pci_conf_read_32(dev, addr);
+        pci_conf_write_32(fun, addr, 0xffffffff);
+        mask = pci_conf_read_32(fun, addr);
         
         /* Restore the original value. */
-        pci_conf_write_32(dev, addr, val);
-        val = pci_conf_read_32(dev, addr);
+        pci_conf_write_32(fun, addr, val);
+        val = pci_conf_read_32(fun, addr);
         
         range_size = pci_bar_mask_to_size(mask);
         
         if (addrw64) {
-                range_addr = ((uint64_t)pci_conf_read_32(dev, addr + 4) << 32) |
+                range_addr = ((uint64_t)pci_conf_read_32(fun, addr + 4) << 32) |
                     (val & 0xfffffff0);
         } else {
@@ -322 +323 @@
         
         if (range_addr != 0) {
-                printf(NAME ": device %s : ", dev->name);
+                printf(NAME ": function %s : ", fun->fnode->name);
                 printf("address = %" PRIx64, range_addr);
                 printf(", size = %x\n", (unsigned int) range_size);
         }
         
-        pci_add_range(dev, range_addr, range_size, io);
+        pci_add_range(fun, range_addr, range_size, io);
         
         if (addrw64)
@@ -335 +336 @@
 }
 
-void pci_add_interrupt(device_t *dev, int irq)
-{
-        pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data;
-        hw_resource_list_t *hw_res_list = &dev_data->hw_resources;
+void pci_add_interrupt(pci_fun_t *fun, int irq)
+{
+        hw_resource_list_t *hw_res_list = &fun->hw_resources;
         hw_resource_t *hw_resources = hw_res_list->resources;
         size_t count = hw_res_list->count;
@@ -350 +350 @@
         hw_res_list->count++;
         
-        printf(NAME ": device %s uses irq %x.\n", dev->name, irq);
-}
-
-void pci_read_interrupt(device_t *dev)
-{
-        uint8_t irq = pci_conf_read_8(dev, PCI_BRIDGE_INT_LINE);
+        printf(NAME ": function %s uses irq %x.\n", fun->fnode->name, irq);
+}
+
+void pci_read_interrupt(pci_fun_t *fun)
+{
+        uint8_t irq = pci_conf_read_8(fun, PCI_BRIDGE_INT_LINE);
         if (irq != 0xff)
-                pci_add_interrupt(dev, irq);
+                pci_add_interrupt(fun, irq);
 }
 
 /** Enumerate (recursively) and register the devices connected to a pci bus.
  *
- * @param parent        The host-to-pci bridge device.
- * @param bus_num       The bus number.
+ * @param bus           Host-to-PCI bridge
+ * @param bus_num       Bus number
  */
-void pci_bus_scan(device_t *parent, int bus_num) 
-{
-        device_t *dev = create_device();
-        pci_dev_data_t *dev_data = create_pci_dev_data();
-        dev->driver_data = dev_data;
-        dev->parent = parent;
+void pci_bus_scan(pci_bus_t *bus, int bus_num) 
+{
+        ddf_fun_t *fnode;
+        pci_fun_t *fun;
         
         int child_bus = 0;
         int dnum, fnum;
         bool multi;
-        uint8_t header_type; 
+        uint8_t header_type;
+        
+        fun = pci_fun_new(bus);
         
         for (dnum = 0; dnum < 32; dnum++) {
                 multi = true;
                 for (fnum = 0; multi && fnum < 8; fnum++) {
-                        init_pci_dev_data(dev_data, bus_num, dnum, fnum);
-                        dev_data->vendor_id = pci_conf_read_16(dev,
+                        pci_fun_init(fun, bus_num, dnum, fnum);
+                        fun->vendor_id = pci_conf_read_16(fun,
                             PCI_VENDOR_ID);
-                        dev_data->device_id = pci_conf_read_16(dev,
+                        fun->device_id = pci_conf_read_16(fun,
                             PCI_DEVICE_ID);
-                        if (dev_data->vendor_id == 0xffff) {
+                        if (fun->vendor_id == 0xffff) {
                                 /*
                                  * The device is not present, go on scanning the
@@ -396 +396 @@
                         }
                         
-                        header_type = pci_conf_read_8(dev, PCI_HEADER_TYPE);
+                        header_type = pci_conf_read_8(fun, PCI_HEADER_TYPE);
                         if (fnum == 0) {
                                 /* Is the device multifunction? */
@@ -404 +404 @@
                         header_type = header_type & 0x7F;
                         
-                        create_pci_dev_name(dev);
-                        
-                        pci_alloc_resource_list(dev);
-                        pci_read_bars(dev);
-                        pci_read_interrupt(dev);
-                        
-                        dev->ops = &pci_child_ops;
-                        
-                        printf(NAME ": adding new child device %s.\n",
-                            dev->name);
-                        
-                        create_pci_match_ids(dev);
-                        
-                        if (child_device_register(dev, parent) != EOK) {
-                                pci_clean_resource_list(dev);
-                                clean_match_ids(&dev->match_ids);
-                                free((char *) dev->name);
-                                dev->name = NULL;
+                        char *fun_name = pci_fun_create_name(fun);
+                        if (fun_name == NULL) {
+                                printf(NAME ": out of memory.\n");
+                                return;
+                        }
+                        
+                        fnode = ddf_fun_create(bus->dnode, fun_inner, fun_name);
+                        if (fnode == NULL) {
+                                printf(NAME ": error creating function.\n");
+                                return;
+                        }
+                        
+                        free(fun_name);
+                        fun->fnode = fnode;
+                        
+                        pci_alloc_resource_list(fun);
+                        pci_read_bars(fun);
+                        pci_read_interrupt(fun);
+                        
+                        fnode->ops = &pci_fun_ops;
+                        fnode->driver_data = fun;
+                        
+                        printf(NAME ": adding new function %s.\n",
+                            fnode->name);
+                        
+                        pci_fun_create_match_ids(fun);
+                        
+                        if (ddf_fun_bind(fnode) != EOK) {
+                                pci_clean_resource_list(fun);
+                                clean_match_ids(&fnode->match_ids);
+                                free((char *) fnode->name);
+                                fnode->name = NULL;
                                 continue;
                         }
@@ -427 +441 @@
                         if (header_type == PCI_HEADER_TYPE_BRIDGE ||
                             header_type == PCI_HEADER_TYPE_CARDBUS) {
-                                child_bus = pci_conf_read_8(dev,
+                                child_bus = pci_conf_read_8(fun,
                                     PCI_BRIDGE_SEC_BUS_NUM);
                                 printf(NAME ": device is pci-to-pci bridge, "
                                     "secondary bus number = %d.\n", bus_num);
                                 if (child_bus > bus_num)
-                                        pci_bus_scan(parent, child_bus);
+                                        pci_bus_scan(bus, child_bus);
                         }
                         
-                        /* Alloc new aux. dev. structure. */
-                        dev = create_device();
-                        dev_data = create_pci_dev_data();
-                        dev->driver_data = dev_data;
-                        dev->parent = parent;
+                        fun = pci_fun_new(bus);
                 }
         }
         
-        if (dev_data->vendor_id == 0xffff) {
-                delete_device(dev);
-                /* Free the auxiliary device structure. */
-                delete_pci_dev_data(dev_data);
-        }
-}
-
-static int pci_add_device(device_t *dev)
-{
+        if (fun->vendor_id == 0xffff) {
+                /* Free the auxiliary function structure. */
+                pci_fun_delete(fun);
+        }
+}
+
+static int pci_add_device(ddf_dev_t *dnode)
+{
+        pci_bus_t *bus = NULL;
+        ddf_fun_t *ctl = NULL;
+        bool got_res = false;
         int rc;
-
+        
         printf(NAME ": pci_add_device\n");
-        
-        pci_bus_data_t *bus_data = create_pci_bus_data();
-        if (bus_data == NULL) {
+        dnode->parent_phone = -1;
+        
+        bus = pci_bus_new();
+        if (bus == NULL) {
                 printf(NAME ": pci_add_device allocation failed.\n");
-                return ENOMEM;
-        }
-        
-        dev->parent_phone = devman_parent_device_connect(dev->handle,
+                rc = ENOMEM;
+                goto fail;
+        }
+        bus->dnode = dnode;
+        dnode->driver_data = bus;
+        
+        dnode->parent_phone = devman_parent_device_connect(dnode->handle,
             IPC_FLAG_BLOCKING);
-        if (dev->parent_phone < 0) {
+        if (dnode->parent_phone < 0) {
                 printf(NAME ": pci_add_device failed to connect to the "
                     "parent's driver.\n");
-                delete_pci_bus_data(bus_data);
-                return dev->parent_phone;
+                rc = dnode->parent_phone;
+                goto fail;
         }
         
         hw_resource_list_t hw_resources;
         
-        rc = hw_res_get_resource_list(dev->parent_phone, &hw_resources);
+        rc = hw_res_get_resource_list(dnode->parent_phone, &hw_resources);
         if (rc != EOK) {
                 printf(NAME ": pci_add_device failed to get hw resources for "
                     "the device.\n");
-                delete_pci_bus_data(bus_data);
-                async_hangup(dev->parent_phone);
-                return rc;
-        }       
+                goto fail;
+        }
+        got_res = true;
         
         printf(NAME ": conf_addr = %" PRIx64 ".\n",
@@ -489 +504 @@
         assert(hw_resources.resources[0].res.io_range.size == 8);
         
-        bus_data->conf_io_addr =
+        bus->conf_io_addr =
             (uint32_t) hw_resources.resources[0].res.io_range.address;
         
-        if (pio_enable((void *)(uintptr_t)bus_data->conf_io_addr, 8,
-            &bus_data->conf_addr_port)) {
+        if (pio_enable((void *)(uintptr_t)bus->conf_io_addr, 8,
+            &bus->conf_addr_port)) {
                 printf(NAME ": failed to enable configuration ports.\n");
-                delete_pci_bus_data(bus_data);
-                async_hangup(dev->parent_phone);
+                rc = EADDRNOTAVAIL;
+                goto fail;
+        }
+        bus->conf_data_port = (char *) bus->conf_addr_port + 4;
+        
+        /* Make the bus device more visible. It has no use yet. */
+        printf(NAME ": adding a 'ctl' function\n");
+        
+        ctl = ddf_fun_create(bus->dnode, fun_exposed, "ctl");
+        if (ctl == NULL) {
+                printf(NAME ": error creating control function.\n");
+                rc = ENOMEM;
+                goto fail;
+        }
+        
+        rc = ddf_fun_bind(ctl);
+        if (rc != EOK) {
+                printf(NAME ": error binding control function.\n");
+                goto fail;
+        }
+        
+        /* Enumerate functions. */
+        printf(NAME ": scanning the bus\n");
+        pci_bus_scan(bus, 0);
+        
+        hw_res_clean_resource_list(&hw_resources);
+        
+        return EOK;
+        
+fail:
+        if (bus != NULL)
+                pci_bus_delete(bus);
+        if (dnode->parent_phone >= 0)
+                async_hangup(dnode->parent_phone);
+        if (got_res)
                 hw_res_clean_resource_list(&hw_resources);
-                return EADDRNOTAVAIL;
-        }
-        bus_data->conf_data_port = (char *) bus_data->conf_addr_port + 4;
-        
-        dev->driver_data = bus_data;
-        
-        /* Enumerate child devices. */
-        printf(NAME ": scanning the bus\n");
-        pci_bus_scan(dev, 0);
-        
-        hw_res_clean_resource_list(&hw_resources);
-        
-        return EOK;
+        if (ctl != NULL)
+                ddf_fun_destroy(ctl);
+
+        return rc;
 }
 
 static void pciintel_init(void)
 {
-        pci_child_ops.interfaces[HW_RES_DEV_IFACE] = &pciintel_child_hw_res_ops;
-}
-
-pci_dev_data_t *create_pci_dev_data(void)
-{
-        pci_dev_data_t *res = (pci_dev_data_t *) malloc(sizeof(pci_dev_data_t));
-        
-        if (res != NULL)
-                memset(res, 0, sizeof(pci_dev_data_t));
-        return res;
-}
-
-void init_pci_dev_data(pci_dev_data_t *dev_data, int bus, int dev, int fn)
-{
-        dev_data->bus = bus;
-        dev_data->dev = dev;
-        dev_data->fn = fn;
-}
-
-void delete_pci_dev_data(pci_dev_data_t *dev_data)
-{
-        if (dev_data != NULL) {
-                hw_res_clean_resource_list(&dev_data->hw_resources);
-                free(dev_data);
-        }
-}
-
-void create_pci_dev_name(device_t *dev)
-{
-        pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data;
+        pci_fun_ops.interfaces[HW_RES_DEV_IFACE] = &pciintel_hw_res_ops;
+}
+
+pci_fun_t *pci_fun_new(pci_bus_t *bus)
+{
+        pci_fun_t *fun;
+        
+        fun = (pci_fun_t *) calloc(1, sizeof(pci_fun_t));
+        if (fun == NULL)
+                return NULL;
+
+        fun->busptr = bus;
+        return fun;
+}
+
+void pci_fun_init(pci_fun_t *fun, int bus, int dev, int fn)
+{
+        fun->bus = bus;
+        fun->dev = dev;
+        fun->fn = fn;
+}
+
+void pci_fun_delete(pci_fun_t *fun)
+{
+        assert(fun != NULL);
+        hw_res_clean_resource_list(&fun->hw_resources);
+        free(fun);
+}
+
+char *pci_fun_create_name(pci_fun_t *fun)
+{
         char *name = NULL;
         
-        asprintf(&name, "%02x:%02x.%01x", dev_data->bus, dev_data->dev,
-            dev_data->fn);
-        dev->name = name;
-}
-
-bool pci_alloc_resource_list(device_t *dev)
-{
-        pci_dev_data_t *dev_data = (pci_dev_data_t *)dev->driver_data;
-        
-        dev_data->hw_resources.resources =
+        asprintf(&name, "%02x:%02x.%01x", fun->bus, fun->dev,
+            fun->fn);
+        return name;
+}
+
+bool pci_alloc_resource_list(pci_fun_t *fun)
+{
+        fun->hw_resources.resources =
             (hw_resource_t *) malloc(PCI_MAX_HW_RES * sizeof(hw_resource_t));
-        return dev_data->hw_resources.resources != NULL;
-}
-
-void pci_clean_resource_list(device_t *dev)
-{
-        pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data;
-        
-        if (dev_data->hw_resources.resources != NULL) {
-                free(dev_data->hw_resources.resources);
-                dev_data->hw_resources.resources = NULL;
-        }
-}
-
-/** Read the base address registers (BARs) of the device and adds the addresses
- * to its hw resource list.
+        return fun->hw_resources.resources != NULL;
+}
+
+void pci_clean_resource_list(pci_fun_t *fun)
+{
+        if (fun->hw_resources.resources != NULL) {
+                free(fun->hw_resources.resources);
+                fun->hw_resources.resources = NULL;
+        }
+}
+
+/** Read the base address registers (BARs) of the function and add the addresses
+ * to its HW resource list.
  *
- * @param dev the pci device.
+ * @param fun   PCI function
  */
-void pci_read_bars(device_t *dev)
+void pci_read_bars(pci_fun_t *fun)
 {
         /*
@@ -585 +621 @@
         
         while (addr <= PCI_BASE_ADDR_5)
-                addr = pci_read_bar(dev, addr);
+                addr = pci_read_bar(fun, addr);
 }
 
@@ -597 +633 @@
         printf(NAME ": HelenOS pci bus driver (intel method 1).\n");
         pciintel_init();
-        return driver_main(&pci_driver);
+        return ddf_driver_main(&pci_driver);
 }
 

uspace/drv/pciintel/pci.h

@@ -1 +1 @@
 /*
  * Copyright (c) 2010 Lenka Trochtova
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -36 +37 @@
 #define PCI_H_
 
-#include <stdlib.h>
-#include <driver.h>
-#include <malloc.h>
-
+#include <ddf/driver.h>
 #include "pci_regs.h"
 
 #define PCI_MAX_HW_RES 8
 
-typedef struct pci_dev_data {
+typedef struct pciintel_bus {
+        /** DDF device node */
+        ddf_dev_t *dnode;
+        uint32_t conf_io_addr;
+        void *conf_data_port;
+        void *conf_addr_port;
+        fibril_mutex_t conf_mutex;
+} pci_bus_t;
+
+typedef struct pci_fun_data {
+        pci_bus_t *busptr;
+        ddf_fun_t *fnode;
+
         int bus;
         int dev;
@@ -51 +61 @@
         int device_id;
         hw_resource_list_t hw_resources;
-} pci_dev_data_t;
+} pci_fun_t;
 
-extern void create_pci_match_ids(device_t *);
+extern void pci_fun_create_match_ids(pci_fun_t *);
 
-extern uint8_t pci_conf_read_8(device_t *, int);
-extern uint16_t pci_conf_read_16(device_t *, int);
-extern uint32_t pci_conf_read_32(device_t *, int);
-extern void pci_conf_write_8(device_t *, int, uint8_t);
-extern void pci_conf_write_16(device_t *, int, uint16_t);
-extern void pci_conf_write_32(device_t *, int, uint32_t);
+extern uint8_t pci_conf_read_8(pci_fun_t *, int);
+extern uint16_t pci_conf_read_16(pci_fun_t *, int);
+extern uint32_t pci_conf_read_32(pci_fun_t *, int);
+extern void pci_conf_write_8(pci_fun_t *, int, uint8_t);
+extern void pci_conf_write_16(pci_fun_t *, int, uint16_t);
+extern void pci_conf_write_32(pci_fun_t *, int, uint32_t);
 
-extern void pci_add_range(device_t *, uint64_t, size_t, bool);
-extern int pci_read_bar(device_t *, int);
-extern void pci_read_interrupt(device_t *);
-extern void pci_add_interrupt(device_t *, int);
+extern void pci_add_range(pci_fun_t *, uint64_t, size_t, bool);
+extern int pci_read_bar(pci_fun_t *, int);
+extern void pci_read_interrupt(pci_fun_t *);
+extern void pci_add_interrupt(pci_fun_t *, int);
 
-extern void pci_bus_scan(device_t *, int);
+extern pci_fun_t *pci_fun_new(pci_bus_t *);
+extern void pci_fun_init(pci_fun_t *, int, int, int);
+extern void pci_fun_delete(pci_fun_t *);
+extern char *pci_fun_create_name(pci_fun_t *);
 
-extern pci_dev_data_t *create_pci_dev_data(void);
-extern void init_pci_dev_data(pci_dev_data_t *, int, int, int);
-extern void delete_pci_dev_data(pci_dev_data_t *);
-extern void create_pci_dev_name(device_t *);
+extern void pci_bus_scan(pci_bus_t *, int);
 
-extern bool pci_alloc_resource_list(device_t *);
-extern void pci_clean_resource_list(device_t *);
+extern bool pci_alloc_resource_list(pci_fun_t *);
+extern void pci_clean_resource_list(pci_fun_t *);
 
-extern void pci_read_bars(device_t *);
+extern void pci_read_bars(pci_fun_t *);
 extern size_t pci_bar_mask_to_size(uint32_t);
 

uspace/drv/root/root.c

@@ -2 +2 @@
  * Copyright (c) 2010 Lenka Trochtova
  * Copyright (c) 2010 Vojtech Horky
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -44 +45 @@
 #include <stdlib.h>
 #include <str.h>
+#include <str_error.h>
 #include <ctype.h>
 #include <macros.h>
@@ -49 +51 @@
 #include <sysinfo.h>
 
-#include <driver.h>
+#include <ddf/driver.h>
 #include <devman.h>
 #include <ipc/devman.h>
@@ -55 +57 @@
 #define NAME "root"
 
-#define PLATFORM_DEVICE_NAME "hw"
-#define PLATFORM_DEVICE_MATCH_ID_FMT "platform/%s"
-#define PLATFORM_DEVICE_MATCH_SCORE 100
-
-#define VIRTUAL_DEVICE_NAME "virt"
-#define VIRTUAL_DEVICE_MATCH_ID "rootvirt"
-#define VIRTUAL_DEVICE_MATCH_SCORE 100
-
-static int root_add_device(device_t *dev);
+#define PLATFORM_FUN_NAME "hw"
+#define PLATFORM_FUN_MATCH_ID_FMT "platform/%s"
+#define PLATFORM_FUN_MATCH_SCORE 100
+
+#define VIRTUAL_FUN_NAME "virt"
+#define VIRTUAL_FUN_MATCH_ID "rootvirt"
+#define VIRTUAL_FUN_MATCH_SCORE 100
+
+static int root_add_device(ddf_dev_t *dev);
 
 /** The root device driver's standard operations. */
@@ -76 +78 @@
 };
 
-/** Create the device which represents the root of virtual device tree.
- *
- * @param parent Parent of the newly created device.
- * @return Error code.
- */
-static int add_virtual_root_child(device_t *parent)
-{
-        printf(NAME ": adding new child for virtual devices.\n");
-        printf(NAME ":   device node is `%s' (%d %s)\n", VIRTUAL_DEVICE_NAME,
-            VIRTUAL_DEVICE_MATCH_SCORE, VIRTUAL_DEVICE_MATCH_ID);
-
-        int res = child_device_register_wrapper(parent, VIRTUAL_DEVICE_NAME,
-            VIRTUAL_DEVICE_MATCH_ID, VIRTUAL_DEVICE_MATCH_SCORE);
-
-        return res;
-}
-
-/** Create the device which represents the root of HW device tree.
- *
- * @param parent        Parent of the newly created device.
- * @return 0 on success, negative error number otherwise.
- */
-static int add_platform_child(device_t *parent)
+/** Create the function which represents the root of virtual device tree.
+ *
+ * @param dev   Device
+ * @return      EOK on success or negative error code
+ */
+static int add_virtual_root_fun(ddf_dev_t *dev)
+{
+        const char *name = VIRTUAL_FUN_NAME;
+        ddf_fun_t *fun;
+        int rc;
+
+        printf(NAME ": adding new function for virtual devices.\n");
+        printf(NAME ":   function node is `%s' (%d %s)\n", name,
+            VIRTUAL_FUN_MATCH_SCORE, VIRTUAL_FUN_MATCH_ID);
+
+        fun = ddf_fun_create(dev, fun_inner, name);
+        if (fun == NULL) {
+                printf(NAME ": error creating function %s\n", name);
+                return ENOMEM;
+        }
+
+        rc = ddf_fun_add_match_id(fun, VIRTUAL_FUN_MATCH_ID,
+            VIRTUAL_FUN_MATCH_SCORE);
+        if (rc != EOK) {
+                printf(NAME ": error adding match IDs to function %s\n", name);
+                ddf_fun_destroy(fun);
+                return rc;
+        }
+
+        rc = ddf_fun_bind(fun);
+        if (rc != EOK) {
+                printf(NAME ": error binding function %s: %s\n", name,
+                    str_error(rc));
+                ddf_fun_destroy(fun);
+                return rc;
+        }
+
+        return EOK;
+}
+
+/** Create the function which represents the root of HW device tree.
+ *
+ * @param dev   Device
+ * @return      EOK on success or negative error code
+ */
+static int add_platform_fun(ddf_dev_t *dev)
 {
         char *match_id;
         char *platform;
         size_t platform_size;
-        int res;
+
+        const char *name = PLATFORM_FUN_NAME;
+        ddf_fun_t *fun;
+        int rc;
 
         /* Get platform name from sysinfo. */
-
         platform = sysinfo_get_data("platform", &platform_size);
         if (platform == NULL) {
@@ -123 +150 @@
 
         /* Construct match ID. */
-
-        if (asprintf(&match_id, PLATFORM_DEVICE_MATCH_ID_FMT, platform) == -1) {
+        if (asprintf(&match_id, PLATFORM_FUN_MATCH_ID_FMT, platform) == -1) {
                 printf(NAME ": Memory allocation failed.\n");
                 return ENOMEM;
         }
 
-        /* Add child. */
-
-        printf(NAME ": adding new child for platform device.\n");
-        printf(NAME ":   device node is `%s' (%d %s)\n", PLATFORM_DEVICE_NAME,
-            PLATFORM_DEVICE_MATCH_SCORE, match_id);
-
-        res = child_device_register_wrapper(parent, PLATFORM_DEVICE_NAME,
-            match_id, PLATFORM_DEVICE_MATCH_SCORE);
-
-        return res;
+        /* Add function. */
+        printf(NAME ": adding platform function\n");
+        printf(NAME ":   function node is `%s' (%d %s)\n", PLATFORM_FUN_NAME,
+            PLATFORM_FUN_MATCH_SCORE, match_id);
+
+        fun = ddf_fun_create(dev, fun_inner, name);
+        if (fun == NULL) {
+                printf(NAME ": error creating function %s\n", name);
+                return ENOMEM;
+        }
+
+        rc = ddf_fun_add_match_id(fun, match_id, PLATFORM_FUN_MATCH_SCORE);
+        if (rc != EOK) {
+                printf(NAME ": error adding match IDs to function %s\n", name);
+                ddf_fun_destroy(fun);
+                return rc;
+        }
+
+        rc = ddf_fun_bind(fun);
+        if (rc != EOK) {
+                printf(NAME ": error binding function %s: %s\n", name,
+                    str_error(rc));
+                ddf_fun_destroy(fun);
+                return rc;
+        }
+
+        return EOK;
 }
 
@@ -146 +189 @@
  *                      of HW and pseudo devices).
  */
-static int root_add_device(device_t *dev)
+static int root_add_device(ddf_dev_t *dev)
 {
         printf(NAME ": root_add_device, device handle=%" PRIun "\n",
             dev->handle);
-        
+
         /*
          * Register virtual devices root.
@@ -156 +199 @@
          * vital for the system.
          */
-        add_virtual_root_child(dev);
+        add_virtual_root_fun(dev);
 
         /* Register root device's children. */
-        int res = add_platform_child(dev);
+        int res = add_platform_fun(dev);
         if (EOK != res)
                 printf(NAME ": failed to add child device for platform.\n");
-        
+
         return res;
 }
@@ -169 +212 @@
 {
         printf(NAME ": HelenOS root device driver\n");
-        return driver_main(&root_driver);
+        return ddf_driver_main(&root_driver);
 }
 

uspace/drv/rootpc/rootpc.c

@@ -46 +46 @@
 #include <macros.h>
 
-#include <driver.h>
+#include <ddf/driver.h>
 #include <devman.h>
 #include <ipc/devman.h>
@@ -55 +55 @@
 #define NAME "rootpc"
 
-typedef struct rootpc_child_dev_data {
+/** Obtain function soft-state from DDF function node */
+#define ROOTPC_FUN(fnode) ((rootpc_fun_t *) (fnode)->driver_data)
+
+typedef struct rootpc_fun {
         hw_resource_list_t hw_resources;
-} rootpc_child_dev_data_t;
-
-static int rootpc_add_device(device_t *dev);
+} rootpc_fun_t;
+
+static int rootpc_add_device(ddf_dev_t *dev);
 static void root_pc_init(void);
 
@@ -82 +85 @@
 };
 
-static rootpc_child_dev_data_t pci_data = {
+static rootpc_fun_t pci_data = {
         .hw_resources = {
                 1,
@@ -89 +92 @@
 };
 
-static hw_resource_list_t *rootpc_get_child_resources(device_t *dev)
-{
-        rootpc_child_dev_data_t *data;
-        
-        data = (rootpc_child_dev_data_t *) dev->driver_data;
-        if (NULL == data)
-                return NULL;
-        
-        return &data->hw_resources;
-}
-
-static bool rootpc_enable_child_interrupt(device_t *dev)
+static hw_resource_list_t *rootpc_get_resources(ddf_fun_t *fnode)
+{
+        rootpc_fun_t *fun = ROOTPC_FUN(fnode);
+        
+        assert(fun != NULL);
+        return &fun->hw_resources;
+}
+
+static bool rootpc_enable_interrupt(ddf_fun_t *fun)
 {
         /* TODO */
@@ -107 +107 @@
 }
 
-static hw_res_ops_t child_hw_res_ops = {
-        &rootpc_get_child_resources,
-        &rootpc_enable_child_interrupt
+static hw_res_ops_t fun_hw_res_ops = {
+        &rootpc_get_resources,
+        &rootpc_enable_interrupt
 };
 
 /* Initialized in root_pc_init() function. */
-static device_ops_t rootpc_child_ops;
+static ddf_dev_ops_t rootpc_fun_ops;
 
 static bool
-rootpc_add_child(device_t *parent, const char *name, const char *str_match_id,
-    rootpc_child_dev_data_t *drv_data)
-{
-        printf(NAME ": adding new child device '%s'.\n", name);
-        
-        device_t *child = NULL;
+rootpc_add_fun(ddf_dev_t *dev, const char *name, const char *str_match_id,
+    rootpc_fun_t *fun)
+{
+        printf(NAME ": adding new function '%s'.\n", name);
+        
+        ddf_fun_t *fnode = NULL;
         match_id_t *match_id = NULL;
         
         /* Create new device. */
-        child = create_device();
-        if (NULL == child)
+        fnode = ddf_fun_create(dev, fun_inner, name);
+        if (fnode == NULL)
                 goto failure;
         
-        child->name = name;
-        child->driver_data = drv_data;
+        fnode->driver_data = fun;
         
         /* Initialize match id list */
         match_id = create_match_id();
-        if (NULL == match_id)
+        if (match_id == NULL)
                 goto failure;
         
         match_id->id = str_match_id;
         match_id->score = 100;
-        add_match_id(&child->match_ids, match_id);
+        add_match_id(&fnode->match_ids, match_id);
         
         /* Set provided operations to the device. */
-        child->ops = &rootpc_child_ops;
-        
-        /* Register child device. */
-        if (EOK != child_device_register(child, parent))
+        fnode->ops = &rootpc_fun_ops;
+        
+        /* Register function. */
+        if (ddf_fun_bind(fnode) != EOK) {
+                printf(NAME ": error binding function %s.\n", name);
                 goto failure;
+        }
         
         return true;
         
 failure:
-        if (NULL != match_id)
+        if (match_id != NULL)
                 match_id->id = NULL;
         
-        if (NULL != child) {
-                child->name = NULL;
-                delete_device(child);
-        }
-        
-        printf(NAME ": failed to add child device '%s'.\n", name);
+        if (fnode != NULL)
+                ddf_fun_destroy(fnode);
+        
+        printf(NAME ": failed to add function '%s'.\n", name);
         
         return false;
 }
 
-static bool rootpc_add_children(device_t *dev)
-{
-        return rootpc_add_child(dev, "pci0", "intel_pci", &pci_data);
+static bool rootpc_add_functions(ddf_dev_t *dev)
+{
+        return rootpc_add_fun(dev, "pci0", "intel_pci", &pci_data);
 }
 
@@ -175 +174 @@
  * @return              Zero on success, negative error number otherwise.
  */
-static int rootpc_add_device(device_t *dev)
+static int rootpc_add_device(ddf_dev_t *dev)
 {
         printf(NAME ": rootpc_add_device, device handle = %d\n",
             (int)dev->handle);
         
-        /* Register child devices. */
-        if (!rootpc_add_children(dev)) {
-                printf(NAME ": failed to add child devices for PC platform.\n");
+        /* Register functions. */
+        if (!rootpc_add_functions(dev)) {
+                printf(NAME ": failed to add functions for PC platform.\n");
         }
         
@@ -190 +189 @@
 static void root_pc_init(void)
 {
-        rootpc_child_ops.interfaces[HW_RES_DEV_IFACE] = &child_hw_res_ops;
+        rootpc_fun_ops.interfaces[HW_RES_DEV_IFACE] = &fun_hw_res_ops;
 }
 
@@ -197 +196 @@
         printf(NAME ": HelenOS PC platform driver\n");
         root_pc_init();
-        return driver_main(&rootpc_driver);
+        return ddf_driver_main(&rootpc_driver);
 }
 

uspace/drv/rootvirt/rootvirt.c

@@ -39 +39 @@
 #include <errno.h>
 #include <str_error.h>
-#include <driver.h>
+#include <ddf/driver.h>
 
 #define NAME "rootvirt"
 
-/** Virtual device entry. */
+/** Virtual function entry */
 typedef struct {
-        /** Device name. */
+        /** Function name */
         const char *name;
-        /** Device match id. */
+        /** Function match ID */
         const char *match_id;
-} virtual_device_t;
+} virtual_function_t;
 
-/** List of existing virtual devices. */
-virtual_device_t virtual_devices[] = {
+/** List of existing virtual functions */
+virtual_function_t virtual_functions[] = {
 #include "devices.def"
-        /* Terminating item. */
+        /* Terminating item */
         {
                 .name = NULL,
@@ -61 +61 @@
 };
 
-static int add_device(device_t *dev);
+static int rootvirt_add_device(ddf_dev_t *dev);
 
 static driver_ops_t rootvirt_ops = {
-        .add_device = &add_device
+        .add_device = &rootvirt_add_device
 };
 
@@ -72 +72 @@
 };
 
-/** Add child device.
+/** Add function to the virtual device.
  *
- * @param parent Parent device.
- * @param virt_dev Virtual device to add.
- * @return Error code.
+ * @param vdev          The virtual device
+ * @param vfun          Virtual function description
+ * @return              EOK on success or negative error code.
  */
-static int add_child(device_t *parent, virtual_device_t *virt_dev)
+static int rootvirt_add_fun(ddf_dev_t *vdev, virtual_function_t *vfun)
 {
-        printf(NAME ": registering child device `%s' (match \"%s\")\n",
-            virt_dev->name, virt_dev->match_id);
+        ddf_fun_t *fun;
+        int rc;
 
-        int rc = child_device_register_wrapper(parent, virt_dev->name,
-            virt_dev->match_id, 10);
+        printf(NAME ": registering function `%s' (match \"%s\")\n",
+            vfun->name, vfun->match_id);
 
-        if (rc == EOK) {
-                printf(NAME ": registered child device `%s'\n",
-                    virt_dev->name);
-        } else {
-                printf(NAME ": failed to register child device `%s': %s\n",
-                    virt_dev->name, str_error(rc));
+        fun = ddf_fun_create(vdev, fun_inner, vfun->name);
+        if (fun == NULL) {
+                printf(NAME ": error creating function %s\n", vfun->name);
+                return ENOMEM;
         }
 
-        return rc;
+        rc = ddf_fun_add_match_id(fun, vfun->match_id, 10);
+        if (rc != EOK) {
+                printf(NAME ": error adding match IDs to function %s\n",
+                    vfun->name);
+                ddf_fun_destroy(fun);
+                return rc;
+        }
+
+        rc = ddf_fun_bind(fun);
+        if (rc != EOK) {
+                printf(NAME ": error binding function %s: %s\n", vfun->name,
+                    str_error(rc));
+                ddf_fun_destroy(fun);
+                return rc;
+        }
+
+        printf(NAME ": registered child device `%s'\n", vfun->name);
+        return EOK;
 }
 
-static int add_device(device_t *dev)
+static int rootvirt_add_device(ddf_dev_t *dev)
 {
         static int instances = 0;
@@ -109 +124 @@
         }
 
-        printf(NAME ": add_device(name=\"%s\", handle=%d)\n",
-            dev->name, (int)dev->handle);
-        
+        printf(NAME ": add_device(handle=%d)\n", (int)dev->handle);
+
         /*
-         * Go through all virtual devices and try to add them.
+         * Go through all virtual functions and try to add them.
          * We silently ignore failures.
          */
-        virtual_device_t *virt_dev = virtual_devices;
-        while (virt_dev->name != NULL) {
-                (void) add_child(dev, virt_dev);
-                virt_dev++;
+        virtual_function_t *vfun = virtual_functions;
+        while (vfun->name != NULL) {
+                (void) rootvirt_add_fun(dev, vfun);
+                vfun++;
         }
 
@@ -128 +142 @@
 {
         printf(NAME ": HelenOS virtual devices root driver\n");
-        return driver_main(&rootvirt_driver);
+        return ddf_driver_main(&rootvirt_driver);
 }
 

uspace/drv/test1/char.c

@@ -37 +37 @@
 #include "test1.h"
 
-static int impl_char_read(device_t *dev, char *buf, size_t count) {
+static int impl_char_read(ddf_fun_t *fun, char *buf, size_t count) {
         memset(buf, 0, count);
         return count;
 }
 
-static int imp_char_write(device_t *dev, char *buf, size_t count) {
+static int imp_char_write(ddf_fun_t *fun, char *buf, size_t count) {
         return count;
 }
@@ -51 +51 @@
 };
 
-device_ops_t char_device_ops = {
+ddf_dev_ops_t char_device_ops = {
         .interfaces[CHAR_DEV_IFACE] = &char_dev_ops
 };

uspace/drv/test1/test1.c

@@ -34 +34 @@
 #include <errno.h>
 #include <str_error.h>
+#include <ddf/driver.h>
+
 #include "test1.h"
 
-static int add_device(device_t *dev);
+static int test1_add_device(ddf_dev_t *dev);
 
 static driver_ops_t driver_ops = {
-        .add_device = &add_device
+        .add_device = &test1_add_device
 };
 
-static driver_t the_driver = {
+static driver_t test1_driver = {
         .name = NAME,
         .driver_ops = &driver_ops
@@ -55 +57 @@
  * @param score Device match score.
  */
-static void register_child_verbose(device_t *parent, const char *message,
+static int register_fun_verbose(ddf_dev_t *parent, const char *message,
     const char *name, const char *match_id, int match_score)
 {
-        printf(NAME ": registering child device `%s': %s.\n",
-           name, message);
+        ddf_fun_t *fun;
+        int rc;
 
-        int rc = child_device_register_wrapper(parent, name,
-            match_id, match_score);
+        printf(NAME ": registering function `%s': %s.\n", name, message);
 
-        if (rc == EOK) {
-                printf(NAME ": registered child device `%s'.\n", name);
-        } else {
-                printf(NAME ": failed to register child `%s' (%s).\n",
-                    name, str_error(rc));
+        fun = ddf_fun_create(parent, fun_inner, name);
+        if (fun == NULL) {
+                printf(NAME ": error creating function %s\n", name);
+                return ENOMEM;
         }
+
+        rc = ddf_fun_add_match_id(fun, match_id, match_score);
+        if (rc != EOK) {
+                printf(NAME ": error adding match IDs to function %s\n", name);
+                ddf_fun_destroy(fun);
+                return rc;
+        }
+
+        rc = ddf_fun_bind(fun);
+        if (rc != EOK) {
+                printf(NAME ": error binding function %s: %s\n", name,
+                    str_error(rc));
+                ddf_fun_destroy(fun);
+                return rc;
+        }
+
+        printf(NAME ": registered child device `%s'\n", name);
+        return EOK;
 }
 
@@ -89 +107 @@
  * @return Error code reporting success of the operation.
  */
-static int add_device(device_t *dev)
+static int test1_add_device(ddf_dev_t *dev)
 {
+        ddf_fun_t *fun_a;
+        int rc;
+
         printf(NAME ": add_device(name=\"%s\", handle=%d)\n",
             dev->name, (int) dev->handle);
 
-        add_device_to_class(dev, "virtual");
+        fun_a = ddf_fun_create(dev, fun_exposed, "a");
+        if (fun_a == NULL) {
+                printf(NAME ": error creating function 'a'.\n");
+                return ENOMEM;
+        }
+
+        rc = ddf_fun_bind(fun_a);
+        if (rc != EOK) {
+                printf(NAME ": error binding function 'a'.\n");
+                return rc;
+        }
+
+        ddf_fun_add_to_class(fun_a, "virtual");
 
         if (str_cmp(dev->name, "null") == 0) {
-                dev->ops = &char_device_ops;
-                add_device_to_class(dev, "virt-null");
-        } else if (dev->parent == NULL) {
-                register_child_verbose(dev, "cloning myself ;-)", "clone",
+                fun_a->ops = &char_device_ops;
+                ddf_fun_add_to_class(fun_a, "virt-null");
+        } else if (str_cmp(dev->name, "test1") == 0) {
+                (void) register_fun_verbose(dev, "cloning myself ;-)", "clone",
                     "virtual&test1", 10);
         } else if (str_cmp(dev->name, "clone") == 0) {
-                register_child_verbose(dev, "run by the same task", "child",
+                (void) register_fun_verbose(dev, "run by the same task", "child",
                     "virtual&test1&child", 10);
         }
@@ -115 +148 @@
 {
         printf(NAME ": HelenOS test1 virtual device driver\n");
-        return driver_main(&the_driver);
+        return ddf_driver_main(&test1_driver);
 }
 

uspace/drv/test1/test1.h

@@ -32 +32 @@
 #define DRV_TEST1_TEST1_H_
 
-#include <driver.h>
+#include <ddf/driver.h>
 
 #define NAME "test1"
 
-extern device_ops_t char_device_ops;
+extern ddf_dev_ops_t char_device_ops;
 
 #endif

uspace/drv/test2/test2.c

@@ -31 +31 @@
 
 #include <assert.h>
+#include <async.h>
 #include <stdio.h>
 #include <errno.h>
 #include <str_error.h>
-#include <driver.h>
+#include <ddf/driver.h>
 
 #define NAME "test2"
 
-static int add_device(device_t *dev);
+static int test2_add_device(ddf_dev_t *dev);
 
 static driver_ops_t driver_ops = {
-        .add_device = &add_device
+        .add_device = &test2_add_device
 };
 
-static driver_t the_driver = {
+static driver_t test2_driver = {
         .name = NAME,
         .driver_ops = &driver_ops
@@ -57 +58 @@
  * @param score Device match score.
  */
-static void register_child_verbose(device_t *parent, const char *message,
+static int register_fun_verbose(ddf_dev_t *parent, const char *message,
     const char *name, const char *match_id, int match_score)
 {
-        printf(NAME ": registering child device `%s': %s.\n",
-           name, message);
+        ddf_fun_t *fun;
+        int rc;
 
-        int rc = child_device_register_wrapper(parent, name,
-            match_id, match_score);
+        printf(NAME ": registering function `%s': %s.\n", name, message);
 
-        if (rc == EOK) {
-                printf(NAME ": registered child device `%s'.\n", name);
-        } else {
-                printf(NAME ": failed to register child `%s' (%s).\n",
-                    name, str_error(rc));
+        fun = ddf_fun_create(parent, fun_inner, name);
+        if (fun == NULL) {
+                printf(NAME ": error creating function %s\n", name);
+                return ENOMEM;
         }
+
+        rc = ddf_fun_add_match_id(fun, match_id, match_score);
+        if (rc != EOK) {
+                printf(NAME ": error adding match IDs to function %s\n", name);
+                ddf_fun_destroy(fun);
+                return rc;
+        }
+
+        rc = ddf_fun_bind(fun);
+        if (rc != EOK) {
+                printf(NAME ": error binding function %s: %s\n", name,
+                    str_error(rc));
+                ddf_fun_destroy(fun);
+                return rc;
+        }
+
+        printf(NAME ": registered child device `%s'\n", name);
+        return EOK;
 }
 
 /** Add child devices after some sleep.
  *
- * @param arg Parent device structure (device_t *).
+ * @param arg Parent device structure (ddf_dev_t *).
  * @return Always EOK.
  */
 static int postponed_birth(void *arg)
 {
-        device_t *dev = (device_t *) arg;
+        ddf_dev_t *dev = (ddf_dev_t *) arg;
+        ddf_fun_t *fun_a;
+        int rc;
 
         async_usleep(1000);
 
-        register_child_verbose(dev, "child driven by the same task",
+        (void) register_fun_verbose(dev, "child driven by the same task",
             "child", "virtual&test2", 10);
-        register_child_verbose(dev, "child driven by test1",
+        (void) register_fun_verbose(dev, "child driven by test1",
             "test1", "virtual&test1", 10);
 
-        add_device_to_class(dev, "virtual");
+        fun_a = ddf_fun_create(dev, fun_exposed, "a");
+        if (fun_a == NULL) {
+                printf(NAME ": error creating function 'a'.\n");
+                return ENOMEM;
+        }
+
+        rc = ddf_fun_bind(fun_a);
+        if (rc != EOK) {
+                printf(NAME ": error binding function 'a'.\n");
+                return rc;
+        }
+
+        ddf_fun_add_to_class(fun_a, "virtual");
 
         return EOK;
 }
 
-
-static int add_device(device_t *dev)
+static int test2_add_device(ddf_dev_t *dev)
 {
-        printf(NAME ": add_device(name=\"%s\", handle=%d)\n",
+        printf(NAME ": test2_add_device(name=\"%s\", handle=%d)\n",
             dev->name, (int) dev->handle);
 
-        if (dev->parent == NULL) {
+        if (str_cmp(dev->name, "child") != 0) {
                 fid_t postpone = fibril_create(postponed_birth, dev);
                 if (postpone == 0) {
@@ -109 +139 @@
                 fibril_add_ready(postpone);
         } else {
-                register_child_verbose(dev, "child without available driver",
+                (void) register_fun_verbose(dev, "child without available driver",
                     "ERROR", "non-existent.match.id", 10);
         }
@@ -119 +149 @@
 {
         printf(NAME ": HelenOS test2 virtual device driver\n");
-        return driver_main(&the_driver);
+        return ddf_driver_main(&test2_driver);
 }
 

uspace/lib/c/generic/devman.c

@@ -123 +123 @@
 }
 
-static int devman_send_match_id(int phone, match_id_t *match_id) \
-{
-        ipc_call_t answer;
-        aid_t req = async_send_1(phone, DEVMAN_ADD_MATCH_ID, match_id->score, &answer);
-        int retval = async_data_write_start(phone, match_id->id, str_size(match_id->id));
+static int devman_send_match_id(int phone, match_id_t *match_id)
+{
+        ipc_call_t answer;
+
+        aid_t req = async_send_1(phone, DEVMAN_ADD_MATCH_ID, match_id->score,
+            &answer);
+        int retval = async_data_write_start(phone, match_id->id,
+            str_size(match_id->id));
+
         async_wait_for(req, NULL);
         return retval;
@@ -133 +137 @@
 
 
-static int devman_send_match_ids(int phone, match_id_list_t *match_ids) 
+static int devman_send_match_ids(int phone, match_id_list_t *match_ids)
 {
         link_t *link = match_ids->ids.next;
         match_id_t *match_id = NULL;
         int ret = EOK;
-        
+
         while (link != &match_ids->ids) {
                 match_id = list_get_instance(link, match_id_t, link); 
-                if (EOK != (ret = devman_send_match_id(phone, match_id))) 
-                {
-                        printf("Driver failed to send match id, error number = %d\n", ret);
-                        return ret;                     
-                }
+                ret = devman_send_match_id(phone, match_id);
+                if (ret != EOK) {
+                        printf("Driver failed to send match id, error %d\n",
+                            ret);
+                        return ret;
+                }
+
                 link = link->next;
         }
-        return ret;     
-}
-
-int devman_child_device_register(
-        const char *name, match_id_list_t *match_ids, devman_handle_t parent_handle, devman_handle_t *handle)
-{               
+
+        return ret;
+}
+
+/** Add function to a device.
+ *
+ * Request devman to add a new function to the specified device owned by
+ * this driver task.
+ *
+ * @param name          Name of the new function
+ * @param ftype         Function type, fun_inner or fun_exposed
+ * @param match_ids     Match IDs (should be empty for fun_exposed)
+ * @param devh          Devman handle of the device
+ * @param funh          Place to store handle of the new function
+ *
+ * @return              EOK on success or negative error code.
+ */
+int devman_add_function(const char *name, fun_type_t ftype,
+    match_id_list_t *match_ids, devman_handle_t devh, devman_handle_t *funh)
+{
         int phone = devman_get_phone(DEVMAN_DRIVER, IPC_FLAG_BLOCKING);
+        int fun_handle;
         
         if (phone < 0)
@@ -161 +182 @@
         async_serialize_start();
         
-        int match_count = list_count(&match_ids->ids);  
-        ipc_call_t answer;
-        aid_t req = async_send_2(phone, DEVMAN_ADD_CHILD_DEVICE, parent_handle, match_count, &answer);
+        int match_count = list_count(&match_ids->ids);
+        ipc_call_t answer;
+
+        aid_t req = async_send_3(phone, DEVMAN_ADD_FUNCTION, (sysarg_t) ftype,
+            devh, match_count, &answer);
 
         sysarg_t retval = async_data_write_start(phone, name, str_size(name));
@@ -178 +201 @@
         async_serialize_end();
         
-        if (retval != EOK) {
-                if (handle != NULL) {
-                        *handle = -1;
-                }
-                return retval;
-        }       
-        
-        if (handle != NULL)
-                *handle = (int) IPC_GET_ARG1(answer);   
-                
-        return retval;
-}
-
-int devman_add_device_to_class(devman_handle_t devman_handle, const char *class_name)
+        if (retval == EOK)
+                fun_handle = (int) IPC_GET_ARG1(answer);
+        else
+                fun_handle = -1;
+        
+        *funh = fun_handle;
+
+        return retval;
+}
+
+int devman_add_device_to_class(devman_handle_t devman_handle,
+    const char *class_name)
 {
         int phone = devman_get_phone(DEVMAN_DRIVER, IPC_FLAG_BLOCKING);
@@ -200 +221 @@
         async_serialize_start();
         ipc_call_t answer;
-        aid_t req = async_send_1(phone, DEVMAN_ADD_DEVICE_TO_CLASS, devman_handle, &answer);
-        
-        sysarg_t retval = async_data_write_start(phone, class_name, str_size(class_name));
+        aid_t req = async_send_1(phone, DEVMAN_ADD_DEVICE_TO_CLASS,
+            devman_handle, &answer);
+        
+        sysarg_t retval = async_data_write_start(phone, class_name,
+            str_size(class_name));
         if (retval != EOK) {
                 async_wait_for(req, NULL);
@@ -212 +235 @@
         async_serialize_end();
         
-        return retval;  
+        return retval;
 }
 
@@ -265 +288 @@
 }
 
-int devman_device_get_handle(const char *pathname, devman_handle_t *handle, unsigned int flags)
+int devman_device_get_handle(const char *pathname, devman_handle_t *handle,
+    unsigned int flags)
 {
         int phone = devman_get_phone(DEVMAN_CLIENT, flags);
@@ -278 +302 @@
             &answer);
         
-        sysarg_t retval = async_data_write_start(phone, pathname, str_size(pathname));
+        sysarg_t retval = async_data_write_start(phone, pathname,
+            str_size(pathname));
         if (retval != EOK) {
                 async_wait_for(req, NULL);

uspace/lib/c/include/devman.h

@@ -45 +45 @@
 
 extern int devman_driver_register(const char *, async_client_conn_t);
-extern int devman_child_device_register(const char *, match_id_list_t *,
+extern int devman_add_function(const char *, fun_type_t, match_id_list_t *,
     devman_handle_t, devman_handle_t *);
 

uspace/lib/c/include/ipc/devman.h

@@ -42 +42 @@
 
 typedef sysarg_t devman_handle_t;
+
+typedef enum {
+        /** Invalid value for debugging purposes */
+        fun_invalid = 0,
+        /** Function to which child devices attach */
+        fun_inner,
+        /** Fuction exported to external clients (leaf function) */
+        fun_exposed
+} fun_type_t;
 
 /** Ids of device models used for device-to-driver matching.
@@ -127 +136 @@
 typedef enum {
         DEVMAN_DRIVER_REGISTER = IPC_FIRST_USER_METHOD,
-        DEVMAN_ADD_CHILD_DEVICE,
+        DEVMAN_ADD_FUNCTION,
         DEVMAN_ADD_MATCH_ID,
         DEVMAN_ADD_DEVICE_TO_CLASS

uspace/lib/drv/generic/driver.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2010 Lenka Trochtova
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -49 +50 @@
 #include <errno.h>
 #include <inttypes.h>
+#include <devman.h>
 
 #include <ipc/driver.h>
 
 #include "dev_iface.h"
-#include "driver.h"
+#include "ddf/driver.h"
+#include "ddf/interrupt.h"
 
 /** Driver structure */
@@ -59 +62 @@
 
 /** Devices */
-LIST_INITIALIZE(devices);
-FIBRIL_MUTEX_INITIALIZE(devices_mutex);
+LIST_INITIALIZE(functions);
+FIBRIL_MUTEX_INITIALIZE(functions_mutex);
 
 /** Interrupts */
@@ -76 +79 @@
 };
 
+static ddf_dev_t *create_device(void);
+static void delete_device(ddf_dev_t *);
+static remote_handler_t *function_get_default_handler(ddf_fun_t *);
+static void *function_get_ops(ddf_fun_t *, dev_inferface_idx_t);
 
 static void driver_irq_handler(ipc_callid_t iid, ipc_call_t *icall)
@@ -150 +157 @@
 
 interrupt_context_t *
-find_interrupt_context(interrupt_context_list_t *list, device_t *dev, int irq)
+find_interrupt_context(interrupt_context_list_t *list, ddf_dev_t *dev, int irq)
 {
         fibril_mutex_lock(&list->mutex);
@@ -172 +179 @@
 
 int
-register_interrupt_handler(device_t *dev, int irq, interrupt_handler_t *handler,
+register_interrupt_handler(ddf_dev_t *dev, int irq, interrupt_handler_t *handler,
     irq_code_t *pseudocode)
 {
@@ -195 +202 @@
 }
 
-int unregister_interrupt_handler(device_t *dev, int irq)
+int unregister_interrupt_handler(ddf_dev_t *dev, int irq)
 {
         interrupt_context_t *ctx = find_interrupt_context(&interrupt_contexts,
@@ -209 +216 @@
 }
 
-static void add_to_devices_list(device_t *dev)
-{
-        fibril_mutex_lock(&devices_mutex);
-        list_append(&dev->link, &devices);
-        fibril_mutex_unlock(&devices_mutex);
-}
-
-static void remove_from_devices_list(device_t *dev)
-{
-        fibril_mutex_lock(&devices_mutex);
-        list_remove(&dev->link);
-        fibril_mutex_unlock(&devices_mutex);
-}
-
-static device_t *driver_get_device(link_t *devices, devman_handle_t handle)
-{
-        device_t *dev = NULL;
-        
-        fibril_mutex_lock(&devices_mutex);
-        link_t *link = devices->next;
-        
-        while (link != devices) {
-                dev = list_get_instance(link, device_t, link);
-                if (dev->handle == handle) {
-                        fibril_mutex_unlock(&devices_mutex);
-                        return dev;
+static void add_to_functions_list(ddf_fun_t *fun)
+{
+        fibril_mutex_lock(&functions_mutex);
+        list_append(&fun->link, &functions);
+        fibril_mutex_unlock(&functions_mutex);
+}
+
+static void remove_from_functions_list(ddf_fun_t *fun)
+{
+        fibril_mutex_lock(&functions_mutex);
+        list_remove(&fun->link);
+        fibril_mutex_unlock(&functions_mutex);
+}
+
+static ddf_fun_t *driver_get_function(link_t *functions, devman_handle_t handle)
+{
+        ddf_fun_t *fun = NULL;
+        
+        fibril_mutex_lock(&functions_mutex);
+        link_t *link = functions->next;
+        
+        while (link != functions) {
+                fun = list_get_instance(link, ddf_fun_t, link);
+                if (fun->handle == handle) {
+                        fibril_mutex_unlock(&functions_mutex);
+                        return fun;
                 }
+                
                 link = link->next;
         }
         
-        fibril_mutex_unlock(&devices_mutex);
+        fibril_mutex_unlock(&functions_mutex);
         
         return NULL;
@@ -250 +258 @@
         
         devman_handle_t dev_handle = IPC_GET_ARG1(*icall);
-        devman_handle_t parent_dev_handle = IPC_GET_ARG2(*icall);
-        
-        device_t *dev = create_device();
+        devman_handle_t parent_fun_handle = IPC_GET_ARG2(*icall);
+        
+        ddf_dev_t *dev = create_device();
         dev->handle = dev_handle;
-        
+
         async_data_write_accept((void **) &dev_name, true, 0, 0, 0, 0);
         dev->name = dev_name;
-        
-        add_to_devices_list(dev);
-        dev->parent = driver_get_device(&devices, parent_dev_handle);
+
+        /*
+         * Currently not used, parent fun handle is stored in context
+         * of the connection to the parent device driver.
+         */
+        (void) parent_fun_handle;
         
         res = driver->driver_ops->add_device(dev);
@@ -268 +279 @@
                 printf("%s: failed to add a new device with handle = %" PRIun ".\n",
                     driver->name, dev_handle);
-                remove_from_devices_list(dev);
                 delete_device(dev);
         }
@@ -311 +321 @@
          */
         devman_handle_t handle = IPC_GET_ARG2(*icall);
-        device_t *dev = driver_get_device(&devices, handle);
-
-        if (dev == NULL) {
-                printf("%s: driver_connection_gen error - no device with handle"
+        ddf_fun_t *fun = driver_get_function(&functions, handle);
+
+        if (fun == NULL) {
+                printf("%s: driver_connection_gen error - no function with handle"
                     " %" PRIun " was found.\n", driver->name, handle);
                 async_answer_0(iid, ENOENT);
@@ -327 +337 @@
         
         int ret = EOK;
-        /* open the device */
-        if (dev->ops != NULL && dev->ops->open != NULL)
-                ret = (*dev->ops->open)(dev);
+        /* Open device function */
+        if (fun->ops != NULL && fun->ops->open != NULL)
+                ret = (*fun->ops->open)(fun);
         
         async_answer_0(iid, ret);
@@ -344 +354 @@
                 switch  (method) {
                 case IPC_M_PHONE_HUNGUP:
-                        /* close the device */
-                        if (dev->ops != NULL && dev->ops->close != NULL)
-                                (*dev->ops->close)(dev);
+                        /* Close device function */
+                        if (fun->ops != NULL && fun->ops->close != NULL)
+                                (*fun->ops->close)(fun);
                         async_answer_0(callid, EOK);
                         return;
@@ -356 +366 @@
                         if (!is_valid_iface_idx(iface_idx)) {
                                 remote_handler_t *default_handler =
-                                    device_get_default_handler(dev);
+                                    function_get_default_handler(fun);
                                 if (default_handler != NULL) {
-                                        (*default_handler)(dev, callid, &call);
+                                        (*default_handler)(fun, callid, &call);
                                         break;
                                 }
+                                
                                 /*
-                                 * This is not device's interface and the
+                                 * Function has no such interface and
                                  * default handler is not provided.
                                  */
@@ -372 +383 @@
                         }
                         
-                        /* calling one of the device's interfaces */
+                        /* calling one of the function's interfaces */
                         
                         /* Get the interface ops structure. */
-                        void *ops = device_get_ops(dev, iface_idx);
+                        void *ops = function_get_ops(fun, iface_idx);
                         if (ops == NULL) {
                                 printf("%s: driver_connection_gen error - ",
                                     driver->name);
-                                printf("device with handle %" PRIun " has no interface "
+                                printf("Function with handle %" PRIun " has no interface "
                                     "with id %d.\n", handle, iface_idx);
                                 async_answer_0(callid, ENOTSUP);
@@ -408 +419 @@
                          * receive parameters from the remote client and it will
                          * pass it to the corresponding local interface method
-                         * associated with the device by its driver.
+                         * associated with the function by its driver.
                          */
-                        (*iface_method_ptr)(dev, ops, callid, &call);
+                        (*iface_method_ptr)(fun, ops, callid, &call);
                         break;
                 }
@@ -425 +436 @@
         driver_connection_gen(iid, icall, false);
 }
-
 
 /** Function for handling connections to device driver. */
@@ -454 +464 @@
  * @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);
-        }
-
+static ddf_dev_t *create_device(void)
+{
+        ddf_dev_t *dev;
+
+        dev = malloc(sizeof(ddf_dev_t));
+        if (dev == NULL)
+                return NULL;
+
+        memset(dev, 0, sizeof(ddf_dev_t));
         return dev;
 }
 
+/** Create new function structure.
+ *
+ * @return              The device structure.
+ */
+static ddf_fun_t *create_function(void)
+{
+        ddf_fun_t *fun;
+
+        fun = calloc(1, sizeof(ddf_fun_t));
+        if (fun == NULL)
+                return NULL;
+
+        init_match_ids(&fun->match_ids);
+        link_initialize(&fun->link);
+
+        return fun;
+}
+
 /** 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);
+static void delete_device(ddf_dev_t *dev)
+{
         free(dev);
 }
 
-void *device_get_ops(device_t *dev, dev_inferface_idx_t idx)
+/** Delete device structure.
+ *
+ * @param dev           The device structure.
+ */
+static void delete_function(ddf_fun_t *fun)
+{
+        clean_match_ids(&fun->match_ids);
+        if (fun->name != NULL)
+                free(fun->name);
+        free(fun);
+}
+
+/** Create a DDF function node.
+ *
+ * Create a DDF function (in memory). Both child devices and external clients
+ * communicate with a device via its functions.
+ *
+ * The created function node is fully formed, but only exists in the memory
+ * of the client task. In order to be visible to the system, the function
+ * must be bound using ddf_fun_bind().
+ *
+ * This function should only fail if there is not enough free memory.
+ * Specifically, this function succeeds even if @a dev already has
+ * a (bound) function with the same name.
+ *
+ * Type: A function of type fun_inner indicates that DDF should attempt
+ * to attach child devices to the function. fun_exposed means that
+ * the function should be exported to external clients (applications).
+ *
+ * @param dev           Device to which we are adding function
+ * @param ftype         Type of function (fun_inner or fun_exposed)
+ * @param name          Name of function
+ *
+ * @return              New function or @c NULL if memory is not available
+ */
+ddf_fun_t *ddf_fun_create(ddf_dev_t *dev, fun_type_t ftype, const char *name)
+{
+        ddf_fun_t *fun;
+
+        fun = create_function();
+        if (fun == NULL)
+                return NULL;
+
+        fun->bound = false;
+        fun->dev = dev;
+        fun->ftype = ftype;
+
+        fun->name = str_dup(name);
+        if (fun->name == NULL) {
+                delete_function(fun);
+                return NULL;
+        }
+
+        return fun;
+}
+
+/** Destroy DDF function node.
+ *
+ * Destroy a function previously created with ddf_fun_create(). The function
+ * must not be bound.
+ *
+ * @param fun           Function to destroy
+ */
+void ddf_fun_destroy(ddf_fun_t *fun)
+{
+        assert(fun->bound == false);
+        delete_function(fun);
+}
+
+static void *function_get_ops(ddf_fun_t *fun, dev_inferface_idx_t idx)
 {
         assert(is_valid_iface_idx(idx));
-        if (dev->ops == NULL)
+        if (fun->ops == NULL)
                 return NULL;
-        return dev->ops->interfaces[idx];
-}
-
-int child_device_register(device_t *child, device_t *parent)
-{
-        assert(child->name != NULL);
+        return fun->ops->interfaces[idx];
+}
+
+/** Bind a function node.
+ *
+ * Bind the specified function to the system. This effectively makes
+ * the function visible to the system (uploads it to the server).
+ *
+ * This function can fail for several reasons. Specifically,
+ * it will fail if the device already has a bound function of
+ * the same name.
+ *
+ * @param fun           Function to bind
+ * @return              EOK on success or negative error code
+ */
+int ddf_fun_bind(ddf_fun_t *fun)
+{
+        assert(fun->name != NULL);
         
         int res;
         
-        add_to_devices_list(child);
-        res = devman_child_device_register(child->name, &child->match_ids,
-            parent->handle, &child->handle);
+        add_to_functions_list(fun);
+        res = devman_add_function(fun->name, fun->ftype, &fun->match_ids,
+            fun->dev->handle, &fun->handle);
         if (res != EOK) {
-                remove_from_devices_list(child);
+                remove_from_functions_list(fun);
                 return res;
         }
         
+        fun->bound = true;
         return res;
 }
 
-/** Wrapper for child_device_register for devices with single match id.
- *
- * @param parent Parent device.
- * @param child_name Child device name.
- * @param child_match_id Child device match id.
- * @param child_match_score Child device match score.
- * @return Error code.
- */
-int child_device_register_wrapper(device_t *parent, const char *child_name,
-    const char *child_match_id, int child_match_score)
-{
-        device_t *child = NULL;
-        match_id_t *match_id = NULL;
-        int rc;
-        
-        child = create_device();
-        if (child == NULL) {
-                rc = ENOMEM;
-                goto failure;
-        }
-        
-        child->name = child_name;
+/** Add single match ID to inner function.
+ *
+ * Construct and add a single match ID to the specified function.
+ * Cannot be called when the function node is bound.
+ *
+ * @param fun                   Function
+ * @param match_id_str          Match string
+ * @param match_score           Match score
+ * @return                      EOK on success, ENOMEM if out of memory.
+ */
+int ddf_fun_add_match_id(ddf_fun_t *fun, const char *match_id_str,
+    int match_score)
+{
+        match_id_t *match_id;
+        
+        assert(fun->bound == false);
+        assert(fun->ftype == fun_inner);
         
         match_id = create_match_id();
-        if (match_id == NULL) {
-                rc = ENOMEM;
-                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 (rc != EOK)
-                goto failure;
-        
+        if (match_id == NULL)
+                return ENOMEM;
+        
+        match_id->id = match_id_str;
+        match_id->score = 90;
+        
+        add_match_id(&fun->match_ids, match_id);
         return EOK;
-        
-failure:
-        if (match_id != NULL) {
-                match_id->id = NULL;
-                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)
+static remote_handler_t *function_get_default_handler(ddf_fun_t *fun)
+{
+        if (fun->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);
-}
-
-int driver_main(driver_t *drv)
+        return fun->ops->default_handler;
+}
+
+/** Add exposed function to class.
+ *
+ * Must only be called when the function is bound.
+ */
+int ddf_fun_add_to_class(ddf_fun_t *fun, const char *class_name)
+{
+        assert(fun->bound == true);
+        assert(fun->ftype == fun_exposed);
+        
+        return devman_add_device_to_class(fun->handle, class_name);
+}
+
+int ddf_driver_main(driver_t *drv)
 {
         /*

uspace/lib/drv/generic/remote_char_dev.c

@@ -37 +37 @@
 
 #include "ops/char_dev.h"
-#include "driver.h"
+#include "ddf/driver.h"
 
 #define MAX_CHAR_RW_COUNT 256
 
-static void remote_char_read(device_t *, void *, ipc_callid_t, ipc_call_t *);
-static void remote_char_write(device_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_char_read(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_char_write(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
 
 /** Remote character interface operations. */
@@ -67 +67 @@
  * local interface to the remote client.
  *
- * @param dev           The device from which the data are read.
+ * @param fun           The function from which the data are read.
  * @param ops           The local ops structure.
  */
 static void
-remote_char_read(device_t *dev, void *ops, ipc_callid_t callid,
+remote_char_read(ddf_fun_t *fun, void *ops, ipc_callid_t callid,
     ipc_call_t *call)
 {
@@ -94 +94 @@
         
         char buf[MAX_CHAR_RW_COUNT];
-        int ret = (*char_dev_ops->read)(dev, buf, len);
+        int ret = (*char_dev_ops->read)(fun, buf, len);
         
         if (ret < 0) {
@@ -114 +114 @@
  * local interface to the remote client.
  *
- * @param dev           The device to which the data are written.
+ * @param fun           The function to which the data are written.
  * @param ops           The local ops structure.
  */
 static void
-remote_char_write(device_t *dev, void *ops, ipc_callid_t callid,
+remote_char_write(ddf_fun_t *fun, void *ops, ipc_callid_t callid,
     ipc_call_t *call)
 {
@@ -144 +144 @@
         async_data_write_finalize(cid, buf, len);
         
-        int ret = (*char_dev_ops->write)(dev, buf, len);
+        int ret = (*char_dev_ops->write)(fun, buf, len);
         if (ret < 0) {
                 /* Some error occured. */

uspace/lib/drv/generic/remote_hw_res.c

@@ -37 +37 @@
 
 #include "ops/hw_res.h"
-#include "driver.h"
+#include "ddf/driver.h"
 
-static void remote_hw_res_get_resource_list(device_t *, void *, ipc_callid_t,
+static void remote_hw_res_get_resource_list(ddf_fun_t *, void *, ipc_callid_t,
     ipc_call_t *);
-static void remote_hw_res_enable_interrupt(device_t *, void *, ipc_callid_t,
+static void remote_hw_res_enable_interrupt(ddf_fun_t *, void *, ipc_callid_t,
     ipc_call_t *);
 
@@ -55 +55 @@
 };
 
-static void remote_hw_res_enable_interrupt(device_t *dev, void *ops,
+static void remote_hw_res_enable_interrupt(ddf_fun_t *fun, void *ops,
     ipc_callid_t callid, ipc_call_t *call)
 {
@@ -62 +62 @@
         if (hw_res_ops->enable_interrupt == NULL)
                 async_answer_0(callid, ENOTSUP);
-        else if (hw_res_ops->enable_interrupt(dev))
+        else if (hw_res_ops->enable_interrupt(fun))
                 async_answer_0(callid, EOK);
         else
@@ -68 +68 @@
 }
 
-static void remote_hw_res_get_resource_list(device_t *dev, void *ops,
+static void remote_hw_res_get_resource_list(ddf_fun_t *fun, void *ops,
     ipc_callid_t callid, ipc_call_t *call)
 {
@@ -78 +78 @@
         }
         
-        hw_resource_list_t *hw_resources = hw_res_ops->get_resource_list(dev);
+        hw_resource_list_t *hw_resources = hw_res_ops->get_resource_list(fun);
         if (hw_resources == NULL){
                 async_answer_0(callid, ENOENT);

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2010 Lenka Trochtova
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -33 +34 @@
  */
 
-#ifndef LIBDRV_DRIVER_H_
-#define LIBDRV_DRIVER_H_
+#ifndef DDF_DRIVER_H_
+#define DDF_DRIVER_H_
 
-#include <kernel/ddi/irq.h>
-#include <adt/list.h>
-#include <devman.h>
 #include <ipc/devman.h>
 #include <ipc/dev_iface.h>
-#include <assert.h>
-#include <ddi.h>
-#include <libarch/ddi.h>
-#include <fibril_synch.h>
-#include <malloc.h>
 
-#include "dev_iface.h"
+#include "../dev_iface.h"
 
-struct device;
-typedef struct device device_t;
+typedef struct ddf_dev ddf_dev_t;
+typedef struct ddf_fun ddf_fun_t;
 
 /*
- * Device class
+ * Device
  */
 
 /** Devices operations */
-typedef struct device_ops {
+typedef struct ddf_dev_ops {
         /**
          * Optional callback function called when a client is connecting to the
          * device.
          */
-        int (*open)(device_t *);
+        int (*open)(ddf_fun_t *);
         
         /**
@@ -68 +61 @@
          * the device.
          */
-        void (*close)(device_t *);
+        void (*close)(ddf_fun_t *);
         
         /** The table of standard interfaces implemented by the device. */
@@ -79 +72 @@
          */
         remote_handler_t *default_handler;
-} device_ops_t;
-
-
-/*
- * Device
- */
+} ddf_dev_ops_t;
 
 /** Device structure */
-struct device {
+struct ddf_dev {
         /**
          * Globally unique device identifier (assigned to the device by the
@@ -100 +88 @@
         int parent_phone;
         
-        /** Parent device if handled by this driver, NULL otherwise */
-        device_t *parent;
         /** Device name */
         const char *name;
-        /** List of device ids for device-to-driver matching */
-        match_id_list_t match_ids;
+        
         /** Driver-specific data associated with this device */
         void *driver_data;
-        /** The implementation of operations provided by this device */
-        device_ops_t *ops;
         
         /** Link in the list of devices handled by the driver */
+        link_t link;
+};
+
+/** Function structure */
+struct ddf_fun {
+        /** True if bound to the device manager */
+        bool bound;
+        /** Function indentifier (asigned by device manager) */
+        devman_handle_t handle;
+        
+        /** Device which this function belogs to */
+        ddf_dev_t *dev;
+        
+        /** Function type */
+        fun_type_t ftype;
+        /** Function name */
+        const char *name;
+        /** List of device ids for driver matching */
+        match_id_list_t match_ids;
+        /** Driver-specific data associated with this function */
+        void *driver_data;
+        /** Implementation of operations provided by this function */
+        ddf_dev_ops_t *ops;
+        
+        /** Link in the list of functions handled by the driver */
         link_t link;
 };
@@ -122 +130 @@
 typedef struct driver_ops {
         /** Callback method for passing a new device to the device driver */
-        int (*add_device)(device_t *dev);
+        int (*add_device)(ddf_dev_t *dev);
         /* TODO: add other generic driver operations */
 } driver_ops_t;
@@ -134 +142 @@
 } driver_t;
 
-int driver_main(driver_t *);
+extern int ddf_driver_main(driver_t *);
 
-/** Create new device structure.
- *
- * @return              The device structure.
- */
-extern device_t *create_device(void);
-extern void delete_device(device_t *);
-extern void *device_get_ops(device_t *, dev_inferface_idx_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 int ddf_fun_bind(ddf_fun_t *);
+extern int ddf_fun_add_match_id(ddf_fun_t *, const char *, int);
 
-extern int child_device_register(device_t *, device_t *);
-extern int child_device_register_wrapper(device_t *, const char *, const char *,
-    int);
-
-/*
- * Interrupts
- */
-
-typedef void interrupt_handler_t(device_t *, ipc_callid_t, ipc_call_t *);
-
-typedef struct interrupt_context {
-        int id;
-        device_t *dev;
-        int irq;
-        interrupt_handler_t *handler;
-        link_t link;
-} interrupt_context_t;
-
-typedef struct interrupt_context_list {
-        int curr_id;
-        link_t contexts;
-        fibril_mutex_t mutex;
-} interrupt_context_list_t;
-
-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);
-
-extern int register_interrupt_handler(device_t *, int, interrupt_handler_t *,
-    irq_code_t *);
-extern int unregister_interrupt_handler(device_t *, int);
-
-extern remote_handler_t *device_get_default_handler(device_t *);
-extern int add_device_to_class(device_t *, const char *);
+extern int ddf_fun_add_to_class(ddf_fun_t *, const char *);
 
 #endif

uspace/lib/drv/include/dev_iface.h

@@ -43 +43 @@
  */
 
-struct device;
+struct ddf_fun;
 
 /*
@@ -49 +49 @@
  * devices driver.
  */
-typedef void remote_iface_func_t(struct device *, void *, ipc_callid_t,
+typedef void remote_iface_func_t(struct ddf_fun *, 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 void remote_handler_t(struct ddf_fun *, ipc_callid_t, ipc_call_t *);
 
 typedef struct {

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

@@ -36 +36 @@
 #define LIBDRV_OPS_CHAR_DEV_H_
 
-#include "../driver.h"
+#include "../ddf/driver.h"
 
 typedef struct {
-        int (*read)(device_t *, char *, size_t);
-        int (*write)(device_t *, char *, size_t);
+        int (*read)(ddf_fun_t *, char *, size_t);
+        int (*write)(ddf_fun_t *, char *, size_t);
 } char_dev_ops_t;
 

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

@@ -39 +39 @@
 #include <sys/types.h>
 
-#include "../driver.h"
+#include "../ddf/driver.h"
 
 typedef struct {
-         hw_resource_list_t *(*get_resource_list)(device_t *);
-         bool (*enable_interrupt)(device_t *);
+         hw_resource_list_t *(*get_resource_list)(ddf_fun_t *);
+         bool (*enable_interrupt)(ddf_fun_t *);
 } hw_res_ops_t;
 

uspace/srv/devman/devman.c

@@ -41 +41 @@
 #include "devman.h"
 
+fun_node_t *find_node_child(fun_node_t *parent, const char *name);
+
 /* hash table operations */
 
@@ -51 +53 @@
     link_t *item)
 {
-        node_t *dev = hash_table_get_instance(item, node_t, devman_link);
+        dev_node_t *dev = hash_table_get_instance(item, dev_node_t, devman_dev);
         return (dev->handle == (devman_handle_t) key[0]);
 }
 
-static int devmap_devices_compare(unsigned long key[], hash_count_t keys,
+static int devman_functions_compare(unsigned long key[], hash_count_t keys,
     link_t *item)
 {
-        node_t *dev = hash_table_get_instance(item, node_t, devmap_link);
-        return (dev->devmap_handle == (devmap_handle_t) key[0]);
+        fun_node_t *fun = hash_table_get_instance(item, fun_node_t, devman_fun);
+        return (fun->handle == (devman_handle_t) key[0]);
+}
+
+static int devmap_functions_compare(unsigned long key[], hash_count_t keys,
+    link_t *item)
+{
+        fun_node_t *fun = hash_table_get_instance(item, fun_node_t, devmap_fun);
+        return (fun->devmap_handle == (devmap_handle_t) key[0]);
 }
 
@@ -82 +91 @@
 };
 
+static hash_table_operations_t devman_functions_ops = {
+        .hash = devices_hash,
+        .compare = devman_functions_compare,
+        .remove_callback = devices_remove_callback
+};
+
 static hash_table_operations_t devmap_devices_ops = {
         .hash = devices_hash,
-        .compare = devmap_devices_compare,
+        .compare = devmap_functions_compare,
         .remove_callback = devices_remove_callback
 };
@@ -373 +388 @@
 }
 
-/** Create root device node in the device tree.
+/** Create root device and function node in the device tree.
  *
  * @param tree  The device tree.
  * @return      True on success, false otherwise.
  */
-bool create_root_node(dev_tree_t *tree)
-{
-        node_t *node;
-
-        printf(NAME ": create_root_node\n");
-
+bool create_root_nodes(dev_tree_t *tree)
+{
+        fun_node_t *fun;
+        dev_node_t *dev;
+        
+        printf(NAME ": create_root_nodes\n");
+        
         fibril_rwlock_write_lock(&tree->rwlock);
-        node = create_dev_node();
-        if (node != NULL) {
-                insert_dev_node(tree, node, clone_string(""), NULL);
-                match_id_t *id = create_match_id();
-                id->id = clone_string("root");
-                id->score = 100;
-                add_match_id(&node->match_ids, id);
-                tree->root_node = node;
-        }
+        
+        /*
+         * Create root function. This is a pseudo function to which
+         * the root device node is attached. It allows us to match
+         * the root device driver in a standard manner, i.e. against
+         * the parent function.
+         */
+        
+        fun = create_fun_node();
+        if (fun == NULL) {
+                fibril_rwlock_write_unlock(&tree->rwlock);
+                return false;
+        }
+        
+        insert_fun_node(tree, fun, clone_string(""), NULL);
+        match_id_t *id = create_match_id();
+        id->id = clone_string("root");
+        id->score = 100;
+        add_match_id(&fun->match_ids, id);
+        tree->root_node = fun;
+        
+        /*
+         * Create root device node.
+         */
+        dev = create_dev_node();
+        if (dev == NULL) {
+                fibril_rwlock_write_unlock(&tree->rwlock);
+                return false;
+        }
+        
+        insert_dev_node(tree, dev, fun);
+        
         fibril_rwlock_write_unlock(&tree->rwlock);
-
-        return node != NULL;
+        
+        return dev != NULL;
 }
 
@@ -414 +453 @@
  *                      is found.
  */
-driver_t *find_best_match_driver(driver_list_t *drivers_list, node_t *node)
+driver_t *find_best_match_driver(driver_list_t *drivers_list, dev_node_t *node)
 {
         driver_t *best_drv = NULL, *drv = NULL;
@@ -442 +481 @@
  * @param drv           The driver.
  */
-void attach_driver(node_t *node, driver_t *drv)
+void attach_driver(dev_node_t *dev, driver_t *drv)
 {
         printf(NAME ": attach_driver %s to device %s\n",
-            drv->name, node->pathname);
+            drv->name, dev->pfun->pathname);
         
         fibril_mutex_lock(&drv->driver_mutex);
         
-        node->drv = drv;
-        list_append(&node->driver_devices, &drv->devices);
+        dev->drv = drv;
+        list_append(&dev->driver_devices, &drv->devices);
         
         fibril_mutex_unlock(&drv->driver_mutex);
@@ -530 +569 @@
 static void pass_devices_to_driver(driver_t *driver, dev_tree_t *tree)
 {
-        node_t *dev;
+        dev_node_t *dev;
         link_t *link;
         int phone;
@@ -551 +590 @@
         link = driver->devices.next;
         while (link != &driver->devices) {
-                dev = list_get_instance(link, node_t, driver_devices);
+                dev = list_get_instance(link, dev_node_t, driver_devices);
                 if (dev->passed_to_driver) {
                         link = link->next;
@@ -669 +708 @@
 }
 
-/** Create devmap path and name for the device. */
-static void devmap_register_tree_device(node_t *node, dev_tree_t *tree)
+/** Create devmap path and name for the function. */
+void devmap_register_tree_function(fun_node_t *fun, dev_tree_t *tree)
 {
         char *devmap_pathname = NULL;
         char *devmap_name = NULL;
         
-        asprintf(&devmap_name, "%s", node->pathname);
+        asprintf(&devmap_name, "%s", fun->pathname);
         if (devmap_name == NULL)
                 return;
@@ -689 +728 @@
         
         devmap_device_register_with_iface(devmap_pathname,
-            &node->devmap_handle, DEVMAN_CONNECT_FROM_DEVMAP);
-        
-        tree_add_devmap_device(tree, node);
+            &fun->devmap_handle, DEVMAN_CONNECT_FROM_DEVMAP);
+        
+        tree_add_devmap_function(tree, fun);
         
         free(devmap_name);
@@ -702 +741 @@
  * @param node          The device's node in the device tree.
  */
-void add_device(int phone, driver_t *drv, node_t *node, dev_tree_t *tree)
+void add_device(int phone, driver_t *drv, dev_node_t *dev, dev_tree_t *tree)
 {
         /*
@@ -709 +748 @@
          */
         printf(NAME ": add_device (driver `%s', device `%s')\n", drv->name,
-            node->name);
+            dev->pfun->name);
         
         sysarg_t rc;
@@ -716 +755 @@
         /* Send the device to the driver. */
         devman_handle_t parent_handle;
-        if (node->parent) {
-                parent_handle = node->parent->handle;
+        if (dev->pfun) {
+                parent_handle = dev->pfun->handle;
         } else {
                 parent_handle = 0;
         }
 
-        aid_t req = async_send_2(phone, DRIVER_ADD_DEVICE, node->handle,
+        aid_t req = async_send_2(phone, DRIVER_ADD_DEVICE, dev->handle,
             parent_handle, &answer);
         
         /* Send the device's name to the driver. */
-        rc = async_data_write_start(phone, node->name,
-            str_size(node->name) + 1);
+        rc = async_data_write_start(phone, dev->pfun->name,
+            str_size(dev->pfun->name) + 1);
         if (rc != EOK) {
                 /* TODO handle error */
@@ -737 +776 @@
         switch(rc) {
         case EOK:
-                node->state = DEVICE_USABLE;
-                devmap_register_tree_device(node, tree);
+                dev->state = DEVICE_USABLE;
                 break;
         case ENOENT:
-                node->state = DEVICE_NOT_PRESENT;
+                dev->state = DEVICE_NOT_PRESENT;
                 break;
         default:
-                node->state = DEVICE_INVALID;
-        }
-        
-        node->passed_to_driver = true;
+                dev->state = DEVICE_INVALID;
+        }
+        
+        dev->passed_to_driver = true;
 
         return;
@@ -759 +797 @@
  *                      successfully assigned to the device, false otherwise.
  */
-bool assign_driver(node_t *node, driver_list_t *drivers_list, dev_tree_t *tree)
-{
+bool assign_driver(dev_node_t *dev, driver_list_t *drivers_list,
+    dev_tree_t *tree)
+{
+        assert(dev != NULL);
+        assert(drivers_list != NULL);
+        assert(tree != NULL);
+        
         /*
          * Find the driver which is the most suitable for handling this device.
          */
-        driver_t *drv = find_best_match_driver(drivers_list, node);
+        driver_t *drv = find_best_match_driver(drivers_list, dev);
         if (drv == NULL) {
                 printf(NAME ": no driver found for device '%s'.\n",
-                    node->pathname);
+                    dev->pfun->pathname);
                 return false;
         }
         
         /* Attach the driver to the device. */
-        attach_driver(node, drv);
+        attach_driver(dev, drv);
         
         fibril_mutex_lock(&drv->driver_mutex);
@@ -786 +829 @@
                 int phone = async_connect_me_to(drv->phone, DRIVER_DEVMAN, 0, 0);
                 if (phone >= 0) {
-                        add_device(phone, drv, node, tree);
+                        add_device(phone, drv, dev, tree);
                         async_hangup(phone);
                 }
@@ -810 +853 @@
         hash_table_create(&tree->devman_devices, DEVICE_BUCKETS, 1,
             &devman_devices_ops);
-        hash_table_create(&tree->devmap_devices, DEVICE_BUCKETS, 1,
+        hash_table_create(&tree->devman_functions, DEVICE_BUCKETS, 1,
+            &devman_functions_ops);
+        hash_table_create(&tree->devmap_functions, DEVICE_BUCKETS, 1,
             &devmap_devices_ops);
         
         fibril_rwlock_initialize(&tree->rwlock);
         
-        /* Create root node and add it to the device tree. */
-        if (!create_root_node(tree))
+        /* Create root function and root device and add them to the device tree. */
+        if (!create_root_nodes(tree))
                 return false;
 
         /* Find suitable driver and start it. */
-        return assign_driver(tree->root_node, drivers_list, tree);
+        return assign_driver(tree->root_node->child, drivers_list, tree);
 }
 
@@ -829 +874 @@
  * @return              A device node structure.
  */
-node_t *create_dev_node(void)
-{
-        node_t *res = malloc(sizeof(node_t));
+dev_node_t *create_dev_node(void)
+{
+        dev_node_t *res = malloc(sizeof(dev_node_t));
         
         if (res != NULL) {
-                memset(res, 0, sizeof(node_t));
-                list_initialize(&res->children);
-                list_initialize(&res->match_ids.ids);
-                list_initialize(&res->classes);
+                memset(res, 0, sizeof(dev_node_t));
+                list_initialize(&res->functions);
+                link_initialize(&res->driver_devices);
+                link_initialize(&res->devman_dev);
         }
         
@@ -847 +892 @@
  * @param node          The device node structure.
  */
-void delete_dev_node(node_t *node)
-{
-        assert(list_empty(&node->children));
-        assert(node->parent == NULL);
-        assert(node->drv == NULL);
-        
-        clean_match_ids(&node->match_ids);
-        free_not_null(node->name);
-        free_not_null(node->pathname);
-        free(node);
+void delete_dev_node(dev_node_t *dev)
+{
+        assert(list_empty(&dev->functions));
+        assert(dev->pfun == NULL);
+        assert(dev->drv == NULL);
+        
+        free(dev);
 }
 
@@ -865 +907 @@
  * @return              The device node.
  */
-node_t *find_dev_node_no_lock(dev_tree_t *tree, devman_handle_t handle)
+dev_node_t *find_dev_node_no_lock(dev_tree_t *tree, devman_handle_t handle)
 {
         unsigned long key = handle;
@@ -873 +915 @@
         
         link = hash_table_find(&tree->devman_devices, &key);
-        return hash_table_get_instance(link, node_t, devman_link);
+        return hash_table_get_instance(link, dev_node_t, devman_dev);
 }
 
@@ -882 +924 @@
  * @return              The device node.
  */
-node_t *find_dev_node(dev_tree_t *tree, devman_handle_t handle)
-{
-        node_t *node = NULL;
+dev_node_t *find_dev_node(dev_tree_t *tree, devman_handle_t handle)
+{
+        dev_node_t *dev = NULL;
         
         fibril_rwlock_read_lock(&tree->rwlock);
-        node = find_dev_node_no_lock(tree, handle);
+        dev = find_dev_node_no_lock(tree, handle);
         fibril_rwlock_read_unlock(&tree->rwlock);
         
-        return node;
-}
-
+        return dev;
+}
+
+/* Function nodes */
+
+/** Create a new function node.
+ *
+ * @return              A function node structure.
+ */
+fun_node_t *create_fun_node(void)
+{
+        fun_node_t *res = malloc(sizeof(fun_node_t));
+        
+        if (res != NULL) {
+                memset(res, 0, sizeof(fun_node_t));
+                link_initialize(&res->dev_functions);
+                list_initialize(&res->match_ids.ids);
+                list_initialize(&res->classes);
+                link_initialize(&res->devman_fun);
+                link_initialize(&res->devmap_fun);
+        }
+        
+        return res;
+}
+
+/** Delete a function node.
+ *
+ * @param fun           The device node structure.
+ */
+void delete_fun_node(fun_node_t *fun)
+{
+        assert(fun->dev == NULL);
+        assert(fun->child == NULL);
+        
+        clean_match_ids(&fun->match_ids);
+        free_not_null(fun->name);
+        free_not_null(fun->pathname);
+        free(fun);
+}
+
+/** Find the function node with the specified handle.
+ *
+ * @param tree          The device tree where we look for the device node.
+ * @param handle        The handle of the function.
+ * @return              The function node.
+ */
+fun_node_t *find_fun_node_no_lock(dev_tree_t *tree, devman_handle_t handle)
+{
+        unsigned long key = handle;
+        link_t *link;
+        
+        assert(fibril_rwlock_is_locked(&tree->rwlock));
+        
+        link = hash_table_find(&tree->devman_functions, &key);
+        if (link == NULL)
+                return NULL;
+        
+        return hash_table_get_instance(link, fun_node_t, devman_fun);
+}
+
+/** Find the function node with the specified handle.
+ *
+ * @param tree          The device tree where we look for the device node.
+ * @param handle        The handle of the function.
+ * @return              The function node.
+ */
+fun_node_t *find_fun_node(dev_tree_t *tree, devman_handle_t handle)
+{
+        fun_node_t *fun = NULL;
+        
+        fibril_rwlock_read_lock(&tree->rwlock);
+        fun = find_fun_node_no_lock(tree, handle);
+        fibril_rwlock_read_unlock(&tree->rwlock);
+        
+        return fun;
+}
 
 /** Create and set device's full path in device tree.
@@ -901 +1016 @@
  *                      resources etc.).
  */
-static bool set_dev_path(node_t *node, node_t *parent)
-{
-        assert(node->name != NULL);
-        
-        size_t pathsize = (str_size(node->name) + 1);
+static bool set_fun_path(fun_node_t *fun, fun_node_t *parent)
+{
+        assert(fun->name != NULL);
+        
+        size_t pathsize = (str_size(fun->name) + 1);
         if (parent != NULL)
                 pathsize += str_size(parent->pathname) + 1;
         
-        node->pathname = (char *) malloc(pathsize);
-        if (node->pathname == NULL) {
+        fun->pathname = (char *) malloc(pathsize);
+        if (fun->pathname == NULL) {
                 printf(NAME ": failed to allocate device path.\n");
                 return false;
@@ -916 +1031 @@
         
         if (parent != NULL) {
-                str_cpy(node->pathname, pathsize, parent->pathname);
-                str_append(node->pathname, pathsize, "/");
-                str_append(node->pathname, pathsize, node->name);
+                str_cpy(fun->pathname, pathsize, parent->pathname);
+                str_append(fun->pathname, pathsize, "/");
+                str_append(fun->pathname, pathsize, fun->name);
         } else {
-                str_cpy(node->pathname, pathsize, node->name);
+                str_cpy(fun->pathname, pathsize, fun->name);
         }
         
@@ -936 +1051 @@
  *                      etc.).
  */
-bool insert_dev_node(dev_tree_t *tree, node_t *node, char *dev_name,
-    node_t *parent)
-{
-        assert(node != NULL);
+bool insert_dev_node(dev_tree_t *tree, dev_node_t *dev, fun_node_t *pfun)
+{
+        assert(dev != NULL);
         assert(tree != NULL);
-        assert(dev_name != NULL);
         assert(fibril_rwlock_is_write_locked(&tree->rwlock));
         
-        node->name = dev_name;
-        if (!set_dev_path(node, parent)) {
+        /* Add the node to the handle-to-node map. */
+        dev->handle = ++tree->current_handle;
+        unsigned long key = dev->handle;
+        hash_table_insert(&tree->devman_devices, &key, &dev->devman_dev);
+
+        /* Add the node to the list of its parent's children. */
+        printf("insert_dev_node: dev=%p, dev->pfun := %p\n", dev, pfun);
+        dev->pfun = pfun;
+        pfun->child = dev;
+        
+        return true;
+}
+
+/** Insert new function into device tree.
+ *
+ * @param tree          The device tree.
+ * @param node          The newly added function node. 
+ * @param dev_name      The name of the newly added function.
+ * @param parent        Owning device node.
+ *
+ * @return              True on success, false otherwise (insufficient resources
+ *                      etc.).
+ */
+bool insert_fun_node(dev_tree_t *tree, fun_node_t *fun, char *fun_name,
+    dev_node_t *dev)
+{
+        fun_node_t *pfun;
+        
+        assert(fun != NULL);
+        assert(tree != NULL);
+        assert(fun_name != NULL);
+        assert(fibril_rwlock_is_write_locked(&tree->rwlock));
+        
+        /*
+         * The root function is a special case, it does not belong to any
+         * device so for the root function dev == NULL.
+         */
+        pfun = (dev != NULL) ? dev->pfun : NULL;
+        
+        fun->name = fun_name;
+        if (!set_fun_path(fun, pfun)) {
                 return false;
         }
         
         /* Add the node to the handle-to-node map. */
-        node->handle = ++tree->current_handle;
-        unsigned long key = node->handle;
-        hash_table_insert(&tree->devman_devices, &key, &node->devman_link);
+        fun->handle = ++tree->current_handle;
+        unsigned long key = fun->handle;
+        hash_table_insert(&tree->devman_functions, &key, &fun->devman_fun);
 
         /* Add the node to the list of its parent's children. */
-        node->parent = parent;
-        if (parent != NULL)
-                list_append(&node->sibling, &parent->children);
+        fun->dev = dev;
+        if (dev != NULL)
+                list_append(&fun->dev_functions, &dev->functions);
         
         return true;
 }
 
-/** Find device node with a specified path in the device tree.
+/** Find function node with a specified path in the device tree.
  * 
- * @param path          The path of the device node in the device tree.
+ * @param path          The path of the function node in the device tree.
  * @param tree          The device tree.
- * @return              The device node if it is present in the tree, NULL
+ * @return              The function node if it is present in the tree, NULL
  *                      otherwise.
  */
-node_t *find_dev_node_by_path(dev_tree_t *tree, char *path)
+fun_node_t *find_fun_node_by_path(dev_tree_t *tree, char *path)
 {
         fibril_rwlock_read_lock(&tree->rwlock);
         
-        node_t *dev = tree->root_node;
+        fun_node_t *fun = tree->root_node;
         /*
-         * Relative path to the device from its parent (but with '/' at the
+         * Relative path to the function from its parent (but with '/' at the
          * beginning)
          */
@@ -982 +1134 @@
         bool cont = (rel_path[0] == '/');
         
-        while (cont && dev != NULL) {
+        while (cont && fun != NULL) {
                 next_path_elem  = get_path_elem_end(rel_path + 1);
                 if (next_path_elem[0] == '/') {
@@ -991 +1143 @@
                 }
                 
-                dev = find_node_child(dev, rel_path + 1);
+                fun = find_node_child(fun, rel_path + 1);
                 
                 if (cont) {
@@ -1002 +1154 @@
         fibril_rwlock_read_unlock(&tree->rwlock);
         
-        return dev;
-}
-
-/** Find child device node with a specified name.
+        return fun;
+}
+
+/** Find child function node with a specified name.
  *
  * Device tree rwlock should be held at least for reading.
  *
- * @param parent        The parent device node.
- * @param name          The name of the child device node.
- * @return              The child device node.
- */
-node_t *find_node_child(node_t *parent, const char *name)
-{
-        node_t *dev;
+ * @param parent        The parent function node.
+ * @param name          The name of the child function.
+ * @return              The child function node.
+ */
+fun_node_t *find_node_child(fun_node_t *pfun, const char *name)
+{
+        fun_node_t *fun;
         link_t *link;
         
-        link = parent->children.next;
-        
-        while (link != &parent->children) {
-                dev = list_get_instance(link, node_t, sibling);
+        link = pfun->child->functions.next;
+        
+        while (link != &pfun->child->functions) {
+                fun = list_get_instance(link, fun_node_t, dev_functions);
                 
-                if (str_cmp(name, dev->name) == 0)
-                        return dev;
+                if (str_cmp(name, fun->name) == 0)
+                        return fun;
                 
                 link = link->next;
@@ -1107 +1259 @@
 }
 
-/** Add the device to the class.
+/** Add the device function to the class.
  *
  * The device may be added to multiple classes and a class may contain multiple
@@ -1120 +1272 @@
  *                      with the class.
  */
-dev_class_info_t *add_device_to_class(node_t *dev, dev_class_t *cl,
+dev_class_info_t *add_function_to_class(fun_node_t *fun, dev_class_t *cl,
     const char *base_dev_name)
 {
-        dev_class_info_t *info = create_dev_class_info();
+        dev_class_info_t *info;
+
+        assert(fun != NULL);
+        assert(cl != NULL);
+
+        info = create_dev_class_info();
+
         
         if (info != NULL) {
                 info->dev_class = cl;
-                info->dev = dev;
+                info->fun = fun;
                 
                 /* Add the device to the class. */
@@ -1135 +1293 @@
                 
                 /* Add the class to the device. */
-                list_append(&info->dev_classes, &dev->classes);
+                list_append(&info->dev_classes, &fun->classes);
                 
                 /* Create unique name for the device within the class. */
@@ -1189 +1347 @@
         list_initialize(&class_list->classes);
         fibril_rwlock_initialize(&class_list->rwlock);
-        hash_table_create(&class_list->devmap_devices, DEVICE_BUCKETS, 1,
+        hash_table_create(&class_list->devmap_functions, DEVICE_BUCKETS, 1,
             &devmap_devices_class_ops);
 }
@@ -1196 +1354 @@
 /* Devmap devices */
 
-node_t *find_devmap_tree_device(dev_tree_t *tree, devmap_handle_t devmap_handle)
-{
-        node_t *dev = NULL;
+fun_node_t *find_devmap_tree_function(dev_tree_t *tree, devmap_handle_t devmap_handle)
+{
+        fun_node_t *fun = NULL;
         link_t *link;
         unsigned long key = (unsigned long) devmap_handle;
         
         fibril_rwlock_read_lock(&tree->rwlock);
-        link = hash_table_find(&tree->devmap_devices, &key);
+        link = hash_table_find(&tree->devmap_functions, &key);
         if (link != NULL)
-                dev = hash_table_get_instance(link, node_t, devmap_link);
+                fun = hash_table_get_instance(link, fun_node_t, devmap_fun);
         fibril_rwlock_read_unlock(&tree->rwlock);
         
-        return dev;
-}
-
-node_t *find_devmap_class_device(class_list_t *classes,
+        return fun;
+}
+
+fun_node_t *find_devmap_class_function(class_list_t *classes,
     devmap_handle_t devmap_handle)
 {
-        node_t *dev = NULL;
+        fun_node_t *fun = NULL;
         dev_class_info_t *cli;
         link_t *link;
@@ -1220 +1378 @@
         
         fibril_rwlock_read_lock(&classes->rwlock);
-        link = hash_table_find(&classes->devmap_devices, &key);
+        link = hash_table_find(&classes->devmap_functions, &key);
         if (link != NULL) {
                 cli = hash_table_get_instance(link, dev_class_info_t,
                     devmap_link);
-                dev = cli->dev;
+                fun = cli->fun;
         }
         fibril_rwlock_read_unlock(&classes->rwlock);
         
-        return dev;
-}
-
-void class_add_devmap_device(class_list_t *class_list, dev_class_info_t *cli)
+        return fun;
+}
+
+void class_add_devmap_function(class_list_t *class_list, dev_class_info_t *cli)
 {
         unsigned long key = (unsigned long) cli->devmap_handle;
         
         fibril_rwlock_write_lock(&class_list->rwlock);
-        hash_table_insert(&class_list->devmap_devices, &key, &cli->devmap_link);
+        hash_table_insert(&class_list->devmap_functions, &key, &cli->devmap_link);
         fibril_rwlock_write_unlock(&class_list->rwlock);
 
-        assert(find_devmap_class_device(class_list, cli->devmap_handle) != NULL);
-}
-
-void tree_add_devmap_device(dev_tree_t *tree, node_t *node)
-{
-        unsigned long key = (unsigned long) node->devmap_handle;
+        assert(find_devmap_class_function(class_list, cli->devmap_handle) != NULL);
+}
+
+void tree_add_devmap_function(dev_tree_t *tree, fun_node_t *fun)
+{
+        unsigned long key = (unsigned long) fun->devmap_handle;
         fibril_rwlock_write_lock(&tree->rwlock);
-        hash_table_insert(&tree->devmap_devices, &key, &node->devmap_link);
+        hash_table_insert(&tree->devmap_functions, &key, &fun->devmap_fun);
         fibril_rwlock_write_unlock(&tree->rwlock);
 }

uspace/srv/devman/devman.h

@@ -56 +56 @@
 #define DEVMAP_SEPARATOR '\\'
 
-struct node;
-typedef struct node node_t;
+struct dev_node;
+typedef struct dev_node dev_node_t;
+
+struct fun_node;
+typedef struct fun_node fun_node_t;
 
 typedef enum {
@@ -117 +120 @@
 } device_state_t;
 
-/** Representation of a node in the device tree. */
-struct node {
+/** Device node in the device tree. */
+struct dev_node {
         /** The global unique identifier of the device. */
         devman_handle_t handle;
-        /** The name of the device specified by its parent. */
-        char *name;
-        
-        /**
-         * Full path and name of the device in device hierarchi (i. e. in full
-         * path in device tree).
-         */
-        char *pathname;
-        
-        /** The node of the parent device. */
-        node_t *parent;
-        
-        /**
-         * Pointers to previous and next child devices in the linked list of
-         * parent device's node.
-         */
-        link_t sibling;
-        
-        /** List of child device nodes. */
-        link_t children;
-        /** List of device ids for device-to-driver matching. */
-        match_id_list_t match_ids;
+        
+        /** (Parent) function the device is attached to. */
+        fun_node_t *pfun;
+        
+        /** List of device functions. */
+        link_t functions;
         /** Driver of this device. */
         driver_t *drv;
         /** The state of the device. */
         device_state_t state;
-        /**
-         * Pointer to the previous and next device in the list of devices
-         * owned by one driver.
-         */
+        /** Link to list of devices owned by driver (driver_t.devices) */
         link_t driver_devices;
         
-        /** The list of device classes to which this device belongs. */
-        link_t classes;
-        /** Devmap handle if the device is registered by devmapper. */
-        devmap_handle_t devmap_handle;
-        
         /**
          * Used by the hash table of devices indexed by devman device handles.
          */
-        link_t devman_link;
-        
-        /**
-         * Used by the hash table of devices indexed by devmap device handles.
-         */
-        link_t devmap_link;
-
+        link_t devman_dev;
+        
         /**
          * Whether this device was already passed to the driver.
@@ -173 +147 @@
         bool passed_to_driver;
 };
+
+/** Function node in the device tree. */
+struct fun_node {
+        /** The global unique identifier of the function */
+        devman_handle_t handle;
+        /** Name of the function, assigned by the device driver */
+        char *name;
+        
+        /** Full path and name of the device in device hierarchy */
+        char *pathname;
+        
+        /** Device which this function belongs to */
+        dev_node_t *dev;
+        
+        /** Link to list of functions in the device (ddf_dev_t.functions) */
+        link_t dev_functions;
+        
+        /** Child device node (if any attached). */
+        dev_node_t *child;
+        /** List of device ids for device-to-driver matching. */
+        match_id_list_t match_ids;
+        
+        /** The list of device classes to which this device function belongs. */
+        link_t classes;
+        /** Devmap handle if the device function is registered by devmap. */
+        devmap_handle_t devmap_handle;
+        
+        /**
+         * Used by the hash table of functions indexed by devman device handles.
+         */
+        link_t devman_fun;
+        
+        /**
+         * Used by the hash table of functions indexed by devmap device handles.
+         */
+        link_t devmap_fun;
+};
+
 
 /** Represents device tree. */
 typedef struct dev_tree {
         /** Root device node. */
-        node_t *root_node;
+        fun_node_t *root_node;
         
         /**
@@ -191 +203 @@
         hash_table_t devman_devices;
         
+        /** Hash table of all devices indexed by devman handles. */
+        hash_table_t devman_functions;
+        
         /**
          * Hash table of devices registered by devmapper, indexed by devmap
          * handles.
          */
-        hash_table_t devmap_devices;
+        hash_table_t devmap_functions;
 } dev_tree_t;
 
@@ -227 +242 @@
 
 /**
- * Provides n-to-m mapping between device nodes and classes - each device may
- * be register to the arbitrary number of classes and each class may contain
- * the arbitrary number of devices.
+ * Provides n-to-m mapping between function nodes and classes - each function
+ * can register in an arbitrary number of classes and each class can contain
+ * an arbitrary number of device functions.
  */
 typedef struct dev_class_info {
@@ -235 +250 @@
         dev_class_t *dev_class;
         /** The device. */
-        node_t *dev;
+        fun_node_t *fun;
         
         /**
@@ -249 +264 @@
         link_t dev_classes;
         
-        /** The name of the device within the class. */
+        /** The name of the device function within the class. */
         char *dev_name;
         /** The handle of the device by device mapper in the class namespace. */
@@ -270 +285 @@
          * indexed by devmap handles.
          */
-        hash_table_t devmap_devices;
+        hash_table_t devmap_functions;
         
         /** Fibril mutex for list of classes. */
@@ -278 +293 @@
 /* Match ids and scores */
 
-extern int get_match_score(driver_t *, node_t *);
+extern int get_match_score(driver_t *, dev_node_t *);
 
 extern bool parse_match_ids(char *, match_id_list_t *);
@@ -292 +307 @@
 extern int lookup_available_drivers(driver_list_t *, const char *);
 
-extern driver_t *find_best_match_driver(driver_list_t *, node_t *);
-extern bool assign_driver(node_t *, driver_list_t *, dev_tree_t *);
+extern driver_t *find_best_match_driver(driver_list_t *, dev_node_t *);
+extern bool assign_driver(dev_node_t *, driver_list_t *, dev_tree_t *);
 
 extern void add_driver(driver_list_t *, driver_t *);
-extern void attach_driver(node_t *, driver_t *);
-extern void add_device(int, driver_t *, node_t *, dev_tree_t *);
+extern void attach_driver(dev_node_t *, driver_t *);
+extern void add_device(int, driver_t *, dev_node_t *, dev_tree_t *);
 extern bool start_driver(driver_t *);
 
@@ -310 +325 @@
 /* Device nodes */
 
-extern node_t *create_dev_node(void);
-extern void delete_dev_node(node_t *node);
-extern node_t *find_dev_node_no_lock(dev_tree_t *tree,
+extern dev_node_t *create_dev_node(void);
+extern void delete_dev_node(dev_node_t *node);
+extern dev_node_t *find_dev_node_no_lock(dev_tree_t *tree,
     devman_handle_t handle);
-extern node_t *find_dev_node(dev_tree_t *tree, devman_handle_t handle);
-extern node_t *find_dev_node_by_path(dev_tree_t *, char *);
-extern node_t *find_node_child(node_t *, const char *);
+extern dev_node_t *find_dev_node(dev_tree_t *tree, devman_handle_t handle);
+extern dev_node_t *find_dev_function(dev_node_t *, const char *);
+
+extern fun_node_t *create_fun_node(void);
+extern void delete_fun_node(fun_node_t *);
+extern fun_node_t *find_fun_node_no_lock(dev_tree_t *tree,
+    devman_handle_t handle);
+extern fun_node_t *find_fun_node(dev_tree_t *tree, devman_handle_t handle);
+extern fun_node_t *find_fun_node_by_path(dev_tree_t *, char *);
 
 /* Device tree */
 
 extern bool init_device_tree(dev_tree_t *, driver_list_t *);
-extern bool create_root_node(dev_tree_t *);
-extern bool insert_dev_node(dev_tree_t *, node_t *, char *, node_t *);
+extern bool create_root_nodes(dev_tree_t *);
+extern bool insert_dev_node(dev_tree_t *, dev_node_t *, fun_node_t *);
+extern bool insert_fun_node(dev_tree_t *, fun_node_t *, char *, dev_node_t *);
 
 /* Device classes */
@@ -330 +352 @@
 extern size_t get_new_class_dev_idx(dev_class_t *);
 extern char *create_dev_name_for_class(dev_class_t *, const char *);
-extern dev_class_info_t *add_device_to_class(node_t *, dev_class_t *,
+extern dev_class_info_t *add_function_to_class(fun_node_t *, dev_class_t *,
     const char *);
 
@@ -341 +363 @@
 /* Devmap devices */
 
-extern node_t *find_devmap_tree_device(dev_tree_t *, devmap_handle_t);
-extern node_t *find_devmap_class_device(class_list_t *, devmap_handle_t);
-
-extern void class_add_devmap_device(class_list_t *, dev_class_info_t *);
-extern void tree_add_devmap_device(dev_tree_t *, node_t *);
+extern void devmap_register_tree_function(fun_node_t *, dev_tree_t *);
+
+extern fun_node_t *find_devmap_tree_function(dev_tree_t *, devmap_handle_t);
+extern fun_node_t *find_devmap_class_function(class_list_t *, devmap_handle_t);
+
+extern void class_add_devmap_function(class_list_t *, dev_class_info_t *);
+extern void tree_add_devmap_function(dev_tree_t *, fun_node_t *);
 
 #endif

uspace/srv/devman/main.c

@@ -199 +199 @@
 static int assign_driver_fibril(void *arg)
 {
-        node_t *node = (node_t *) arg;
-        assign_driver(node, &drivers_list, &device_tree);
+        dev_node_t *dev_node = (dev_node_t *) arg;
+        assign_driver(dev_node, &drivers_list, &device_tree);
         return EOK;
 }
 
-/** Handle child device registration.
+/** Handle function registration.
  *
  * Child devices are registered by their parent's device driver.
  */
-static void devman_add_child(ipc_callid_t callid, ipc_call_t *call)
-{
-        devman_handle_t parent_handle = IPC_GET_ARG1(*call);
-        sysarg_t match_count = IPC_GET_ARG2(*call);
+static void devman_add_function(ipc_callid_t callid, ipc_call_t *call)
+{
+        fun_type_t ftype = (fun_type_t) IPC_GET_ARG1(*call);
+        devman_handle_t dev_handle = IPC_GET_ARG2(*call);
+        sysarg_t match_count = IPC_GET_ARG3(*call);
         dev_tree_t *tree = &device_tree;
         
         fibril_rwlock_write_lock(&tree->rwlock);
-        node_t *parent = find_dev_node_no_lock(&device_tree, parent_handle);
-        
-        if (parent == NULL) {
+
+        dev_node_t *dev = NULL;
+        dev_node_t *pdev = find_dev_node_no_lock(&device_tree, dev_handle);
+        
+        if (pdev == NULL) {
                 fibril_rwlock_write_unlock(&tree->rwlock);
                 async_answer_0(callid, ENOENT);
@@ -223 +226 @@
         }
         
-        char *dev_name = NULL;
-        int rc = async_data_write_accept((void **)&dev_name, true, 0, 0, 0, 0);
+        if (ftype != fun_inner && ftype != fun_exposed) {
+                /* Unknown function type */
+                printf(NAME ": Error, unknown function type provided by driver!\n");
+
+                fibril_rwlock_write_unlock(&tree->rwlock);
+                async_answer_0(callid, EINVAL);
+                return;
+        }
+        
+        char *fun_name = NULL;
+        int rc = async_data_write_accept((void **)&fun_name, true, 0, 0, 0, 0);
         if (rc != EOK) {
                 fibril_rwlock_write_unlock(&tree->rwlock);
@@ -231 +243 @@
         }
         
-        node_t *node = create_dev_node();
-        if (!insert_dev_node(&device_tree, node, dev_name, parent)) {
+        fun_node_t *fun = create_fun_node();
+        if (!insert_fun_node(&device_tree, fun, fun_name, pdev)) {
                 fibril_rwlock_write_unlock(&tree->rwlock);
-                delete_dev_node(node);
+                delete_fun_node(fun);
                 async_answer_0(callid, ENOMEM);
                 return;
         }
 
+        if (ftype == fun_inner) {
+                dev = create_dev_node();
+                if (dev == NULL) {
+                        fibril_rwlock_write_unlock(&tree->rwlock);
+                        delete_fun_node(fun);
+                        async_answer_0(callid, ENOMEM);
+                        return;
+                }
+
+                insert_dev_node(tree, dev, fun);
+        }
+
         fibril_rwlock_write_unlock(&tree->rwlock);
         
-        printf(NAME ": devman_add_child %s\n", node->pathname);
-        
-        devman_receive_match_ids(match_count, &node->match_ids);
-
-        /*
-         * Try to find a suitable driver and assign it to the device.  We do
-         * not want to block the current fibril that is used for processing
-         * incoming calls: we will launch a separate fibril to handle the
-         * driver assigning. That is because assign_driver can actually include
-         * task spawning which could take some time.
-         */
-        fid_t assign_fibril = fibril_create(assign_driver_fibril, node);
-        if (assign_fibril == 0) {
+        printf(NAME ": devman_add_function %s\n", fun->pathname);
+        
+        devman_receive_match_ids(match_count, &fun->match_ids);
+
+        if (ftype == fun_inner) {
+                assert(dev != NULL);
                 /*
-                 * Fallback in case we are out of memory.
-                 * Probably not needed as we will die soon anyway ;-).
+                 * Try to find a suitable driver and assign it to the device.  We do
+                 * not want to block the current fibril that is used for processing
+                 * incoming calls: we will launch a separate fibril to handle the
+                 * driver assigning. That is because assign_driver can actually include
+                 * task spawning which could take some time.
                  */
-                (void) assign_driver_fibril(node);
+                fid_t assign_fibril = fibril_create(assign_driver_fibril, dev);
+                if (assign_fibril == 0) {
+                        /*
+                         * Fallback in case we are out of memory.
+                         * Probably not needed as we will die soon anyway ;-).
+                         */
+                        (void) assign_driver_fibril(fun);
+                } else {
+                        fibril_add_ready(assign_fibril);
+                }
         } else {
-                fibril_add_ready(assign_fibril);
-        }
-
+                devmap_register_tree_function(fun, tree);
+        }
+        
         /* Return device handle to parent's driver. */
-        async_answer_1(callid, EOK, node->handle);
+        async_answer_1(callid, EOK, fun->handle);
 }
 
@@ -288 +317 @@
          * mapper.
          */
-        class_add_devmap_device(&class_list, cli);
+        class_add_devmap_function(&class_list, cli);
         
         free(devmap_pathname);
 }
 
-static void devman_add_device_to_class(ipc_callid_t callid, ipc_call_t *call)
+static void devman_add_function_to_class(ipc_callid_t callid, ipc_call_t *call)
 {
         devman_handle_t handle = IPC_GET_ARG1(*call);
@@ -306 +335 @@
         }       
         
-        node_t *dev = find_dev_node(&device_tree, handle);
-        if (dev == NULL) {
+        fun_node_t *fun = find_fun_node(&device_tree, handle);
+        if (fun == NULL) {
                 async_answer_0(callid, ENOENT);
                 return;
@@ -313 +342 @@
         
         dev_class_t *cl = get_dev_class(&class_list, class_name);
-        dev_class_info_t *class_info = add_device_to_class(dev, cl, NULL);
+        dev_class_info_t *class_info = add_function_to_class(fun, cl, NULL);
         
         /* Register the device's class alias by devmapper. */
         devmap_register_class_dev(class_info);
         
-        printf(NAME ": device '%s' added to class '%s', class name '%s' was "
-            "asigned to it\n", dev->pathname, class_name, class_info->dev_name);
+        printf(NAME ": function'%s' added to class '%s', class name '%s' was "
+            "asigned to it\n", fun->pathname, class_name, class_info->dev_name);
 
         async_answer_0(callid, EOK);
@@ -372 +401 @@
                         cont = false;
                         continue;
-                case DEVMAN_ADD_CHILD_DEVICE:
-                        devman_add_child(callid, &call);
+                case DEVMAN_ADD_FUNCTION:
+                        devman_add_function(callid, &call);
                         break;
                 case DEVMAN_ADD_DEVICE_TO_CLASS:
-                        devman_add_device_to_class(callid, &call);
+                        devman_add_function_to_class(callid, &call);
                         break;
                 default:
@@ -387 +416 @@
 /** Find handle for the device instance identified by the device's path in the
  * device tree. */
-static void devman_device_get_handle(ipc_callid_t iid, ipc_call_t *icall)
+static void devman_function_get_handle(ipc_callid_t iid, ipc_call_t *icall)
 {
         char *pathname;
@@ -397 +426 @@
         }
         
-        node_t * dev = find_dev_node_by_path(&device_tree, pathname);
+        fun_node_t *fun = find_fun_node_by_path(&device_tree, pathname);
         
         free(pathname);
 
-        if (dev == NULL) {
+        if (fun == NULL) {
                 async_answer_0(iid, ENOENT);
                 return;
         }
-        
-        async_answer_1(iid, EOK, dev->handle);
+
+        async_answer_1(iid, EOK, fun->handle);
 }
 
@@ -426 +455 @@
                         continue;
                 case DEVMAN_DEVICE_GET_HANDLE:
-                        devman_device_get_handle(callid, &call);
+                        devman_function_get_handle(callid, &call);
                         break;
                 default:
@@ -438 +467 @@
 {
         devman_handle_t handle = IPC_GET_ARG2(*icall);
-        
-        node_t *dev = find_dev_node(&device_tree, handle);
-        if (dev == NULL) {
-                printf(NAME ": devman_forward error - no device with handle %" PRIun
-                    " was found.\n", handle);
+        devman_handle_t fwd_h;
+        fun_node_t *fun = NULL;
+        dev_node_t *dev = NULL;
+        
+        fun = find_fun_node(&device_tree, handle);
+        if (fun == NULL)
+                dev = find_dev_node(&device_tree, handle);
+        else
+                dev = fun->dev;
+
+        if (fun == NULL && dev == NULL) {
+                printf(NAME ": devman_forward error - no device or function with "
+                    "handle %" PRIun " was found.\n", handle);
                 async_answer_0(iid, ENOENT);
                 return;
         }
+
+        if (fun == NULL && !drv_to_parent) {
+                printf(NAME ": devman_forward error - cannot connect to "
+                    "handle %" PRIun ", refers to a device.\n", handle);
+                async_answer_0(iid, ENOENT);
+                return;
+        }
         
         driver_t *driver = NULL;
         
         if (drv_to_parent) {
-                if (dev->parent != NULL)
-                        driver = dev->parent->drv;
+                /* Connect to parent function of a device (or device function). */
+                if (dev->pfun->dev != NULL)
+                        driver = dev->pfun->dev->drv;
+                fwd_h = dev->pfun->handle;
         } else if (dev->state == DEVICE_USABLE) {
+                /* Connect to the specified function */
                 driver = dev->drv;
                 assert(driver != NULL);
+
+                fwd_h = handle;
         }
         
@@ -478 +527 @@
         }
 
-        printf(NAME ": devman_forward: forward connection to device %s to "
-            "driver %s.\n", dev->pathname, driver->name);
-        async_forward_fast(iid, driver->phone, method, dev->handle, 0, IPC_FF_NONE);
+        if (fun != NULL) {
+                printf(NAME ": devman_forward: forward connection to function %s to "
+                    "driver %s.\n", fun->pathname, driver->name);
+        } else {
+                printf(NAME ": devman_forward: forward connection to device %s to "
+                    "driver %s.\n", dev->pfun->pathname, driver->name);
+        }
+
+        async_forward_fast(iid, driver->phone, method, fwd_h, 0, IPC_FF_NONE);
 }
 
@@ -488 +543 @@
 {
         devmap_handle_t devmap_handle = IPC_GET_ARG2(*icall);
-        node_t *dev;
-
-        dev = find_devmap_tree_device(&device_tree, devmap_handle);
-        if (dev == NULL)
-                dev = find_devmap_class_device(&class_list, devmap_handle);
-        
-        if (dev == NULL || dev->drv == NULL) {
+        fun_node_t *fun;
+        dev_node_t *dev;
+
+        fun = find_devmap_tree_function(&device_tree, devmap_handle);
+        if (fun == NULL)
+                fun = find_devmap_class_function(&class_list, devmap_handle);
+        
+        if (fun == NULL || fun->dev->drv == NULL) {
                 async_answer_0(iid, ENOENT);
                 return;
         }
+        
+        dev = fun->dev;
         
         if (dev->state != DEVICE_USABLE || dev->drv->phone <= 0) {
@@ -507 +565 @@
             IPC_FF_NONE);
         printf(NAME ": devman_connection_devmapper: forwarded connection to "
-            "device %s to driver %s.\n", dev->pathname, dev->drv->name);
+            "device %s to driver %s.\n", fun->pathname, dev->drv->name);
 }
 

uspace/srv/devman/match.c

@@ -57 +57 @@
 }
 
-int get_match_score(driver_t *drv, node_t *dev)
+int get_match_score(driver_t *drv, dev_node_t *dev)
 {
         link_t *drv_head = &drv->match_ids.ids;
-        link_t *dev_head = &dev->match_ids.ids;
+        link_t *dev_head = &dev->pfun->match_ids.ids;
         
         if (list_empty(drv_head) || list_empty(dev_head))