Changeset 68414f4a in mainline

Timestamp:

2011-02-13T20:03:45Z (13 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

bab6388

Parents:

8b1e15ac

Message:

Refactor drivers

• Rename soft-state structures to have the simplest names
• Use soft-state structures as a starting point instead of DDF device or function nodes
• Convert to standard naming scheme

Location:

uspace/drv

Files:

• isa/isa.c (modified) (23 diffs)
• ns8250/ns8250.c (modified) (30 diffs)
• pciintel/pci.c (modified) (22 diffs)
• pciintel/pci.h (modified) (3 diffs)
• root/root.c (modified) (6 diffs)
• rootpc/rootpc.c (modified) (5 diffs)
• rootvirt/rootvirt.c (modified) (4 diffs)

uspace/drv/isa/isa.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2010 Lenka Trochtova
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -60 +61 @@
 #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_fun_data {
+typedef struct isa_fun {
+        function_t *fnode;
         hw_resource_list_t hw_resources;
-} isa_fun_data_t;
-
-static hw_resource_list_t *isa_get_fun_resources(function_t *fun)
-{
-        isa_fun_data_t *fun_data;
-
-        fun_data = (isa_fun_data_t *)fun->driver_data;
-        if (fun_data == NULL)
-                return NULL;
-
-        return &fun_data->hw_resources;
-}
-
-static bool isa_enable_fun_interrupt(function_t *fun)
+} isa_fun_t;
+
+static hw_resource_list_t *isa_get_fun_resources(function_t *fnode)
+{
+        isa_fun_t *fun = ISA_FUN(fnode);
+        assert(fun != NULL);
+
+        return &fun->hw_resources;
+}
+
+static bool isa_enable_fun_interrupt(function_t *fnode)
 {
         // TODO
@@ -89 +91 @@
 };
 
-static device_ops_t isa_fun_dev_ops;
+static device_ops_t isa_fun_ops;
 
 static int isa_add_device(device_t *dev);
@@ -104 +106 @@
 };
 
-
-static isa_fun_data_t *create_isa_fun_data() 
-{
-        isa_fun_data_t *data;
-
-        data = (isa_fun_data_t *) malloc(sizeof(isa_fun_data_t));
-        if (data != NULL)
-                memset(data, 0, sizeof(isa_fun_data_t));
-
-        return data;
-}
-
-static function_t *create_isa_fun()
-{
-        function_t *fun = create_function();
+static isa_fun_t *isa_fun_create()
+{
+        isa_fun_t *fun = calloc(1, sizeof(isa_fun_t));
         if (fun == NULL)
                 return NULL;
 
-        isa_fun_data_t *data = create_isa_fun_data();
-        if (data == NULL) {
-                delete_function(fun);
+        function_t *fnode = create_function();
+        if (fnode == NULL) {
+                free(fun);
                 return NULL;
         }
 
-        fun->driver_data = data;
+        fun->fnode = fnode;
+        fnode->driver_data = fun;
         return fun;
 }
 
-static char *read_fun_conf(const char *conf_path)
+static char *fun_conf_read(const char *conf_path)
 {
         bool suc = false;
@@ -151 +142 @@
         lseek(fd, 0, SEEK_SET); 
         if (len == 0) {
-                printf(NAME ": read_fun_conf error: configuration file '%s' "
+                printf(NAME ": fun_conf_read error: configuration file '%s' "
                     "is empty.\n", conf_path);
                 goto cleanup;
@@ -158 +149 @@
         buf = malloc(len + 1);
         if (buf == NULL) {
-                printf(NAME ": read_fun_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_fun_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 +240 @@
 }
 
-static void isa_fun_set_irq(function_t *fun, int irq)
-{
-        isa_fun_data_t *data = (isa_fun_data_t *)fun->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 +249 @@
                 resources[count].res.interrupt.irq = irq;
 
-                data->hw_resources.count++;
-
-                printf(NAME ": added irq 0x%x to function %s\n", irq, fun->name);
-        }
-}
-
-static void isa_fun_set_io_range(function_t *fun, size_t addr, size_t len)
-{
-        isa_fun_data_t *data = (isa_fun_data_t *)fun->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 +267 @@
                 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 "
                     "function %s\n", (unsigned int) addr, (unsigned int) len,
-                    fun->name);
-        }
-}
-
-static void get_dev_irq(function_t *fun, char *val)
+                    fun->fnode->name);
+        }
+}
+
+static void fun_parse_irq(isa_fun_t *fun, char *val)
 {
         int irq = 0;
@@ -299 +287 @@
 }
 
-static void get_dev_io_range(function_t *fun, char *val)
+static void fun_parse_io_range(isa_fun_t *fun, char *val)
 {
         size_t addr, len;
@@ -331 +319 @@
 }
 
-static void get_fun_match_id(function_t *fun, char *val)
+static void fun_parse_match_id(isa_fun_t *fun, char *val)
 {
         char *id = NULL;
@@ -337 +325 @@
         char *end = NULL;
 
-        val = skip_spaces(val); 
+        val = skip_spaces(val);
 
         score = (int)strtol(val, &end, 10);
         if (val == end) {
                 printf(NAME " : error - could not read match score for "
-                    "function %s.\n", fun->name);
+                    "function %s.\n", fun->fnode->name);
                 return;
         }
@@ -349 +337 @@
         if (match_id == NULL) {
                 printf(NAME " : failed to allocate match id for function %s.\n",
-                    fun->name);
+                    fun->fnode->name);
                 return;
         }
@@ -357 +345 @@
         if (id == NULL) {
                 printf(NAME " : error - could not read match id for "
-                    "function %s.\n", fun->name);
+                    "function %s.\n", fun->fnode->name);
                 delete_match_id(match_id);
                 return;
@@ -366 +354 @@
 
         printf(NAME ": adding match id '%s' with score %d to function %s\n", id,
-            score, fun->name);
-        add_match_id(&fun->match_ids, match_id);
-}
-
-static bool read_fun_prop(function_t *fun, char *line, const char *prop,
-    void (*read_fn)(function_t *, char *))
+            score, fun->fnode->name);
+        add_match_id(&fun->fnode->match_ids, match_id);
+}
+
+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);
@@ -386 +374 @@
 }
 
-static void get_fun_prop(function_t *fun, char *line)
+static void fun_prop_parse(isa_fun_t *fun, char *line)
 {
         /* Skip leading spaces. */
         line = skip_spaces(line);
 
-        if (!read_fun_prop(fun, line, "io_range", &get_dev_io_range) &&
-            !read_fun_prop(fun, line, "irq", &get_dev_irq) &&
-            !read_fun_prop(fun, line, "match", &get_fun_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 +388 @@
 }
 
-static void child_alloc_hw_res(function_t *fun)
-{
-        isa_fun_data_t *data = (isa_fun_data_t *)fun->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_fun_info(char *fun_conf, device_t *dev)
+static char *isa_fun_read_info(char *fun_conf, device_t *dev)
 {
         char *line;
@@ -430 +417 @@
                 return NULL;
 
-        function_t *fun = create_isa_fun();
+        isa_fun_t *fun = isa_fun_create();
         if (fun == NULL) {
                 free(fun_name);
@@ -436 +423 @@
         }
 
-        fun->name = fun_name;
-        fun->ftype = fun_inner;
+        function_t *fnode = fun->fnode;
+        fnode->name = fun_name;
+        fnode->ftype = fun_inner;
 
         /* Allocate buffer for the list of hardware resources of the device. */
-        child_alloc_hw_res(fun);
+        fun_hw_res_alloc(fun);
 
         /* Get properties of the device (match ids, irq and io range). */
@@ -455 +443 @@
                  * and store it in the device structure.
                  */
-                get_fun_prop(fun, line);
-
-                //printf(NAME ": next line ='%s'\n", fun_conf);
-                //printf(NAME ": current line ='%s'\n", line);
+                fun_prop_parse(fun, line);
         }
 
         /* Set device operations to the device. */
-        fun->ops = &isa_fun_dev_ops;
+        fnode->ops = &isa_fun_ops;
 
         printf(NAME ": register_function(fun, dev); function is %s.\n",
-            fun->name);
-        register_function(fun, dev);
+            fnode->name);
+        register_function(fnode, dev);
 
         return fun_conf;
 }
 
-static void parse_fun_conf(char *conf, device_t *dev)
+static void fun_conf_parse(char *conf, device_t *dev)
 {
         while (conf != NULL && *conf != '\0') {
-                conf = read_isa_fun_info(conf, dev);
-        }
-}
-
-static void add_legacy_children(device_t *dev)
+                conf = isa_fun_read_info(conf, dev);
+        }
+}
+
+static void isa_functions_add(device_t *dev)
 {
         char *fun_conf;
 
-        fun_conf = read_fun_conf(CHILD_FUN_CONF_PATH);
+        fun_conf = fun_conf_read(CHILD_FUN_CONF_PATH);
         if (fun_conf != NULL) {
-                parse_fun_conf(fun_conf, dev);
+                fun_conf_parse(fun_conf, dev);
                 free(fun_conf);
         }
@@ -502 +487 @@
         register_function(ctl, dev);
 
-        /* Add child devices. */
-        add_legacy_children(dev);
-        printf(NAME ": finished the enumeration of legacy devices\n");
+        /* Add functions as specified in the configuration file. */
+        isa_functions_add(dev);
+        printf(NAME ": finished the enumeration of legacy functions\n");
 
         return EOK;
@@ -511 +496 @@
 static void isa_init() 
 {
-        isa_fun_dev_ops.interfaces[HW_RES_DEV_IFACE] = &isa_fun_hw_res_ops;
+        isa_fun_ops.interfaces[HW_RES_DEV_IFACE] = &isa_fun_hw_res_ops;
 }
 
@@ -524 +509 @@
  * @}
  */
- 

uspace/drv/ns8250/ns8250.c

@@ -1 @@
-/*                        
+/*
  * Copyright (c) 2010 Lenka Trochtova
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -68 +69 @@
 #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. */
 typedef enum {
@@ -85 +92 @@
 
 /** The driver data for the serial port devices. */
-typedef struct ns8250_dev_data {
+typedef struct ns8250 {
+        /** DDF device node */
+        device_t *dev;
+        /** DDF function node */
+        function_t *fun;
         /** Is there any client conntected to the device? */
         bool client_connected;
@@ -98 +109 @@
         /** 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)
+{
+        free(ns);
 }
 
@@ -171 +181 @@
 /** 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.
@@ -180 +190 @@
 static int ns8250_read(function_t *fun, char *buf, size_t count)
 {
+        ns8250_t *ns = NS8250(fun);
         int ret = EOK;
-        ns8250_dev_data_t *data = (ns8250_dev_data_t *) fun->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 +205 @@
 /** 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.
+ * @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(function_t *fun, char *buf, size_t count)
 {
-        ns8250_dev_data_t *data = (ns8250_dev_data_t *) fun->dev->driver_data;
+        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;
@@ -244 +254 @@
 };
 
-/** 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 +268 @@
 /** 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 +288 @@
 /** 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 +312 @@
         
         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 +319 @@
 /** 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 +331 @@
         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 +358 @@
                 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 +374 @@
                         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 +384 @@
         if (!irq || !ioport) {
                 printf(NAME ": missing hw resource(s) for the device %s.\n",
-                    dev->name);
+                    ns->dev->name);
                 ret = ENOENT;
                 goto failed;
@@ -397 +393 @@
         
 failed:
-        ns8250_dev_cleanup(dev);
+        ns8250_dev_cleanup(ns);
         hw_res_clean_resource_list(&hw_resources);
         return ret;
@@ -404 +400 @@
 /** 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.
@@ -416 +412 @@
 /** 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 +421 @@
 /** 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 +612 @@
  * 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 +636 @@
  * 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 +650 @@
                         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();
         }
@@ -685 +677 @@
     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)
 {
-        function_t *fun;
-
+        ns8250_t *ns = NULL;
+        function_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 = create_function();
         fun->ftype = fun_exposed;
@@ -766 +767 @@
         fun->ops = &ns8250_dev_ops;
         register_function(fun, dev);
+        ns->fun = fun;
         
         add_function_to_class(fun, "serial");
@@ -773 +775 @@
         
         return EOK;
+fail:
+        if (need_cleanup)
+                ns8250_dev_cleanup(ns);
+        if (ns != NULL)
+                ns8250_delete(ns);
+        return rc;
 }
 
@@ -784 +792 @@
 static int ns8250_open(function_t *fun)
 {
-        ns8250_dev_data_t *data = (ns8250_dev_data_t *) fun->dev->driver_data;
+        ns8250_t *data = (ns8250_t *) fun->dev->driver_data;
         int res;
         
@@ -808 +816 @@
 static void ns8250_close(function_t *fun)
 {
-        ns8250_dev_data_t *data = (ns8250_dev_data_t *) fun->dev->driver_data;
+        ns8250_t *data = (ns8250_t *) fun->dev->driver_data;
         
         fibril_mutex_lock(&data->mutex);
@@ -833 +841 @@
     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;
         
@@ -864 +872 @@
             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;

uspace/drv/pciintel/pci.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2010 Lenka Trochtova
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -61 +62 @@
         ((1 << 31) | (bus << 16) | (dev << 11) | (fn << 8) | (reg & ~3))
 
-static hw_resource_list_t *pciintel_get_child_resources(function_t *fun)
-{
-        pci_fun_data_t *fun_data = (pci_fun_data_t *) fun->driver_data;
-        
-        if (fun_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) (PCI_BUS(fun->fnode->dev))
+
+static hw_resource_list_t *pciintel_get_resources(function_t *fnode)
+{
+        pci_fun_t *fun = PCI_FUN(fnode);
+        
+        if (fun == NULL)
                 return NULL;
-        return &fun_data->hw_resources;
-}
-
-static bool pciintel_enable_child_interrupt(function_t *fun)
+        return &fun->hw_resources;
+}
+
+static bool pciintel_enable_interrupt(function_t *fnode)
 {
         /* TODO */
@@ -77 +87 @@
 }
 
-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 device_ops_t pci_fun_ops;
 
 static int pci_add_device(device_t *);
 
-/** The pci bus driver's standard operations. */
+/** 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 +107 @@
 };
 
-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(function_t *fun, int reg, uint8_t *buf, size_t len)
-{
-        assert(fun->dev != NULL);
-        
-        pci_fun_data_t *fun_data = (pci_fun_data_t *) fun->driver_data;
-        pci_bus_data_t *bus_data = (pci_bus_data_t *) fun->dev->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 *) malloc(sizeof(pci_bus_t));
+        if (bus != NULL) {
+                memset(bus, 0, sizeof(pci_bus_t));
+                fibril_mutex_initialize(&bus->conf_mutex);
+        }
+
+        return bus;
+}
+
+static void pci_bus_delete(pci_bus_t *bus)
+{
+        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(fun_data->bus, fun_data->dev, fun_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 +149 @@
         }
         
-        fibril_mutex_unlock(&bus_data->conf_mutex);
-}
-
-static void pci_conf_write(function_t *fun, int reg, uint8_t *buf, size_t len)
-{
-        assert(fun->dev != NULL);
-        
-        pci_fun_data_t *fun_data = (pci_fun_data_t *) fun->driver_data;
-        pci_bus_data_t *bus_data = (pci_bus_data_t *) fun->dev->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(fun_data->bus, fun_data->dev, fun_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 +176 @@
         }
         
-        fibril_mutex_unlock(&bus_data->conf_mutex);
-}
-
-uint8_t pci_conf_read_8(function_t *fun, int reg)
+        fibril_mutex_unlock(&bus->conf_mutex);
+}
+
+uint8_t pci_conf_read_8(pci_fun_t *fun, int reg)
 {
         uint8_t res;
@@ -189 +186 @@
 }
 
-uint16_t pci_conf_read_16(function_t *fun, int reg)
+uint16_t pci_conf_read_16(pci_fun_t *fun, int reg)
 {
         uint16_t res;
@@ -196 +193 @@
 }
 
-uint32_t pci_conf_read_32(function_t *fun, int reg)
+uint32_t pci_conf_read_32(pci_fun_t *fun, int reg)
 {
         uint32_t res;
@@ -203 +200 @@
 }
 
-void pci_conf_write_8(function_t *fun, int reg, uint8_t val)
+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(function_t *fun, int reg, uint16_t val)
+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(function_t *fun, int reg, uint32_t val)
+void pci_conf_write_32(pci_fun_t *fun, int reg, uint32_t val)
 {
         pci_conf_write(fun, reg, (uint8_t *) &val, 4);
 }
 
-void create_pci_match_ids(function_t *fun)
-{
-        pci_fun_data_t *fun_data = (pci_fun_data_t *) fun->driver_data;
+void pci_fun_create_match_ids(pci_fun_t *fun)
+{
         match_id_t *match_id = NULL;
         char *match_id_str;
@@ -227 +223 @@
         if (match_id != NULL) {
                 asprintf(&match_id_str, "pci/ven=%04x&dev=%04x",
-                    fun_data->vendor_id, fun_data->device_id);
+                    fun->vendor_id, fun->device_id);
                 match_id->id = match_id_str;
                 match_id->score = 90;
-                add_match_id(&fun->match_ids, match_id);
+                add_match_id(&fun->fnode->match_ids, match_id);
         }
 
@@ -236 +232 @@
 }
 
-void
-pci_add_range(function_t *fun, uint64_t range_addr, size_t range_size, bool io)
-{
-        pci_fun_data_t *fun_data = (pci_fun_data_t *) fun->driver_data;
-        hw_resource_list_t *hw_res_list = &fun_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 +260 @@
  * 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(function_t *fun, int addr)
+int pci_read_bar(pci_fun_t *fun, int addr)
 {       
         /* Value of the BAR */
@@ -322 +317 @@
         
         if (range_addr != 0) {
-                printf(NAME ": function %s : ", fun->name);
+                printf(NAME ": function %s : ", fun->fnode->name);
                 printf("address = %" PRIx64, range_addr);
                 printf(", size = %x\n", (unsigned int) range_size);
@@ -335 +330 @@
 }
 
-void pci_add_interrupt(function_t *fun, int irq)
-{
-        pci_fun_data_t *fun_data = (pci_fun_data_t *) fun->driver_data;
-        hw_resource_list_t *hw_res_list = &fun_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 +344 @@
         hw_res_list->count++;
         
-        printf(NAME ": function %s uses irq %x.\n", fun->name, irq);
-}
-
-void pci_read_interrupt(function_t *fun)
+        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);
@@ -362 +356 @@
 /** Enumerate (recursively) and register the devices connected to a pci bus.
  *
- * @param dev           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 *dev, int bus_num) 
-{
-        function_t *fun = create_function();
-        pci_fun_data_t *fun_data = create_pci_fun_data();
-        fun->driver_data = fun_data;
+void pci_bus_scan(pci_bus_t *bus, int bus_num) 
+{
+        function_t *fnode = create_function();
+        pci_fun_t *fun = pci_fun_new();
+        fnode->driver_data = fun;
         
         int child_bus = 0;
@@ -377 +371 @@
 
         /* We need this early, before registering. */
-        fun->dev = dev;
+        fun->fnode = fnode;
+        fnode->dev = bus->dnode;
+        fnode->driver_data = fun;
         
         for (dnum = 0; dnum < 32; dnum++) {
                 multi = true;
                 for (fnum = 0; multi && fnum < 8; fnum++) {
-                        init_pci_fun_data(fun_data, bus_num, dnum, fnum);
-                        fun_data->vendor_id = pci_conf_read_16(fun,
+                        pci_fun_init(fun, bus_num, dnum, fnum);
+                        fun->vendor_id = pci_conf_read_16(fun,
                             PCI_VENDOR_ID);
-                        fun_data->device_id = pci_conf_read_16(fun,
+                        fun->device_id = pci_conf_read_16(fun,
                             PCI_DEVICE_ID);
-                        if (fun_data->vendor_id == 0xffff) {
+                        if (fun->vendor_id == 0xffff) {
                                 /*
                                  * The device is not present, go on scanning the
@@ -406 +402 @@
                         header_type = header_type & 0x7F;
                         
-                        create_pci_fun_name(fun);
+                        pci_fun_create_name(fun);
                         
                         pci_alloc_resource_list(fun);
@@ -412 +408 @@
                         pci_read_interrupt(fun);
                         
-                        fun->ftype = fun_inner;
-                        fun->ops = &pci_child_ops;
+                        fnode->ftype = fun_inner;
+                        fnode->ops = &pci_fun_ops;
                         
                         printf(NAME ": adding new function %s.\n",
-                            fun->name);
-                        
-                        create_pci_match_ids(fun);
-                        
-                        if (register_function(fun, dev) != EOK) {
+                            fnode->name);
+                        
+                        pci_fun_create_match_ids(fun);
+                        
+                        if (register_function(fnode, bus->dnode) != EOK) {
                                 pci_clean_resource_list(fun);
-                                clean_match_ids(&fun->match_ids);
-                                free((char *) fun->name);
-                                fun->name = NULL;
+                                clean_match_ids(&fnode->match_ids);
+                                free((char *) fnode->name);
+                                fnode->name = NULL;
                                 continue;
                         }
@@ -435 +431 @@
                                     "secondary bus number = %d.\n", bus_num);
                                 if (child_bus > bus_num)
-                                        pci_bus_scan(dev, child_bus);
+                                        pci_bus_scan(bus, child_bus);
                         }
                         
                         /* Alloc new aux. fun. structure. */
-                        fun = create_function();
+                        fnode = create_function();
 
                         /* We need this early, before registering. */
-                        fun->dev = dev;
-
-                        fun_data = create_pci_fun_data();
-                        fun->driver_data = fun_data;
+                        fnode->dev = bus->dnode;
+
+                        fun = pci_fun_new();
+                        fun->fnode = fnode;
+                        fnode->driver_data = fun;
                 }
         }
         
-        if (fun_data->vendor_id == 0xffff) {
-                delete_function(fun);
+        if (fun->vendor_id == 0xffff) {
+                delete_function(fnode);
                 /* Free the auxiliary function structure. */
-                delete_pci_fun_data(fun_data);
-        }
-}
-
-static int pci_add_device(device_t *dev)
+                pci_fun_delete(fun);
+        }
+}
+
+static int pci_add_device(device_t *dnode)
 {
         int rc;
-
+        
         printf(NAME ": pci_add_device\n");
         
-        pci_bus_data_t *bus_data = create_pci_bus_data();
-        if (bus_data == NULL) {
+        pci_bus_t *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,
+        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;
+                pci_bus_delete(bus);
+                return dnode->parent_phone;
         }
         
         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);
+                pci_bus_delete(bus);
+                async_hangup(dnode->parent_phone);
                 return rc;
         }       
@@ -495 +494 @@
         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);
+                pci_bus_delete(bus);
+                async_hangup(dnode->parent_phone);
                 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;
-        
-        /* Make the bus device more visible. Does not do anything. */
+        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");
-
+        
         function_t *ctl = create_function();
         ctl->ftype = fun_exposed;
         ctl->name = "ctl";
-        register_function(ctl, dev);
-        
-        /* Enumerate child devices. */
+        register_function(ctl, dnode);
+        
+        /* Enumerate functions. */
         printf(NAME ": scanning the bus\n");
-        pci_bus_scan(dev, 0);
+        pci_bus_scan(bus, 0);
         
         hw_res_clean_resource_list(&hw_resources);
@@ -529 +526 @@
 static void pciintel_init(void)
 {
-        pci_child_ops.interfaces[HW_RES_DEV_IFACE] = &pciintel_child_hw_res_ops;
-}
-
-pci_fun_data_t *create_pci_fun_data(void)
-{
-        pci_fun_data_t *res = (pci_fun_data_t *) malloc(sizeof(pci_fun_data_t));
+        pci_fun_ops.interfaces[HW_RES_DEV_IFACE] = &pciintel_hw_res_ops;
+}
+
+pci_fun_t *pci_fun_new(void)
+{
+        pci_fun_t *res = (pci_fun_t *) malloc(sizeof(pci_fun_t));
         
         if (res != NULL)
-                memset(res, 0, sizeof(pci_fun_data_t));
+                memset(res, 0, sizeof(pci_fun_t));
         return res;
 }
 
-void init_pci_fun_data(pci_fun_data_t *fun_data, int bus, int dev, int fn)
-{
-        fun_data->bus = bus;
-        fun_data->dev = dev;
-        fun_data->fn = fn;
-}
-
-void delete_pci_fun_data(pci_fun_data_t *fun_data)
-{
-        if (fun_data != NULL) {
-                hw_res_clean_resource_list(&fun_data->hw_resources);
-                free(fun_data);
-        }
-}
-
-void create_pci_fun_name(function_t *fun)
-{
-        pci_fun_data_t *fun_data = (pci_fun_data_t *) fun->driver_data;
+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)
+{
+        if (fun != NULL) {
+                hw_res_clean_resource_list(&fun->hw_resources);
+                free(fun);
+        }
+}
+
+void pci_fun_create_name(pci_fun_t *fun)
+{
         char *name = NULL;
         
-        asprintf(&name, "%02x:%02x.%01x", fun_data->bus, fun_data->dev,
-            fun_data->fn);
-        fun->name = name;
-}
-
-bool pci_alloc_resource_list(function_t *fun)
-{
-        pci_fun_data_t *fun_data = (pci_fun_data_t *)fun->driver_data;
-        
-        fun_data->hw_resources.resources =
+        asprintf(&name, "%02x:%02x.%01x", fun->bus, fun->dev,
+            fun->fn);
+        fun->fnode->name = 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 fun_data->hw_resources.resources != NULL;
-}
-
-void pci_clean_resource_list(function_t *fun)
-{
-        pci_fun_data_t *fun_data = (pci_fun_data_t *) fun->driver_data;
-        
-        if (fun_data->hw_resources.resources != NULL) {
-                free(fun_data->hw_resources.resources);
-                fun_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(function_t *fun)
+void pci_read_bars(pci_fun_t *fun)
 {
         /*

uspace/drv/pciintel/pci.h

@@ -1 +1 @@
 /*
  * Copyright (c) 2010 Lenka Trochtova
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -45 +46 @@
 
 typedef struct pci_fun_data {
+        function_t *fnode;
+
         int bus;
         int dev;
@@ -51 +54 @@
         int device_id;
         hw_resource_list_t hw_resources;
-} pci_fun_data_t;
+} pci_fun_t;
 
-extern void create_pci_match_ids(function_t *);
+typedef struct pciintel_bus {
+        /** DDF device node */
+        device_t *dnode;
+        uint32_t conf_io_addr;
+        void *conf_data_port;
+        void *conf_addr_port;
+        fibril_mutex_t conf_mutex;
+} pci_bus_t;
 
-extern uint8_t pci_conf_read_8(function_t *, int);
-extern uint16_t pci_conf_read_16(function_t *, int);
-extern uint32_t pci_conf_read_32(function_t *, int);
-extern void pci_conf_write_8(function_t *, int, uint8_t);
-extern void pci_conf_write_16(function_t *, int, uint16_t);
-extern void pci_conf_write_32(function_t *, int, uint32_t);
+extern void pci_fun_create_match_ids(pci_fun_t *);
 
-extern void pci_add_range(function_t *, uint64_t, size_t, bool);
-extern int pci_read_bar(function_t *, int);
-extern void pci_read_interrupt(function_t *);
-extern void pci_add_interrupt(function_t *, int);
+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_bus_scan(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 pci_fun_data_t *create_pci_fun_data(void);
-extern void init_pci_fun_data(pci_fun_data_t *, int, int, int);
-extern void delete_pci_fun_data(pci_fun_data_t *);
-extern void create_pci_fun_name(function_t *);
+extern pci_fun_t *pci_fun_new(void);
+extern void pci_fun_init(pci_fun_t *, int, int, int);
+extern void pci_fun_delete(pci_fun_t *);
+extern void pci_fun_create_name(pci_fun_t *);
 
-extern bool pci_alloc_resource_list(function_t *);
-extern void pci_clean_resource_list(function_t *);
+extern void pci_bus_scan(pci_bus_t *, int);
 
-extern void pci_read_bars(function_t *);
+extern bool pci_alloc_resource_list(pci_fun_t *);
+extern void pci_clean_resource_list(pci_fun_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.
  *
@@ -55 +56 @@
 #define NAME "root"
 
-#define PLATFORM_DEVICE_NAME "hw"
-#define PLATFORM_DEVICE_MATCH_ID_FMT "platform/%s"
-#define PLATFORM_DEVICE_MATCH_SCORE 100
+#define PLATFORM_FUN_NAME "hw"
+#define PLATFORM_FUN_MATCH_ID_FMT "platform/%s"
+#define PLATFORM_FUN_MATCH_SCORE 100
 
-#define VIRTUAL_DEVICE_NAME "virt"
-#define VIRTUAL_DEVICE_MATCH_ID "rootvirt"
-#define VIRTUAL_DEVICE_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(device_t *dev);
@@ -76 +77 @@
 };
 
-/** Create the device which represents the root of virtual device tree.
+/** Create the function which represents the root of virtual device tree.
  *
- * @param parent Parent of the newly created device.
- * @return Error code.
+ * @param dev   Device
+ * @return      EOK on success or negative error code
  */
-static int add_virtual_root_child(device_t *parent)
+static int add_virtual_root_fun(device_t *dev)
 {
-        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);
+        printf(NAME ": adding new function for virtual devices.\n");
+        printf(NAME ":   function node is `%s' (%d %s)\n", VIRTUAL_FUN_NAME,
+            VIRTUAL_FUN_MATCH_SCORE, VIRTUAL_FUN_MATCH_ID);
 
-        int res = register_function_wrapper(parent, VIRTUAL_DEVICE_NAME,
-            VIRTUAL_DEVICE_MATCH_ID, VIRTUAL_DEVICE_MATCH_SCORE);
+        int res = register_function_wrapper(dev, VIRTUAL_FUN_NAME,
+            VIRTUAL_FUN_MATCH_ID, VIRTUAL_FUN_MATCH_SCORE);
 
         return res;
 }
 
-/** Create the device which represents the root of HW device tree.
+/** Create the function which represents the root of HW device tree.
  *
- * @param parent        Parent of the newly created device.
- * @return 0 on success, negative error number otherwise.
+ * @param dev   Device
+ * @return      EOK on success or negative error code
  */
-static int add_platform_child(device_t *parent)
+static int add_platform_fun(device_t *dev)
 {
         char *match_id;
@@ -106 +107 @@
 
         /* Get platform name from sysinfo. */
-
         platform = sysinfo_get_data("platform", &platform_size);
         if (platform == NULL) {
@@ -123 +123 @@
 
         /* 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. */
+        /* 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);
 
-        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 = register_function_wrapper(parent, PLATFORM_DEVICE_NAME,
-            match_id, PLATFORM_DEVICE_MATCH_SCORE);
+        res = register_function_wrapper(dev, PLATFORM_FUN_NAME,
+            match_id, PLATFORM_FUN_MATCH_SCORE);
 
         return res;
@@ -156 +154 @@
          * 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");

uspace/drv/rootpc/rootpc.c

@@ -55 +55 @@
 #define NAME "rootpc"
 
-typedef struct rootpc_fun_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_fun_data_t;
+} rootpc_fun_t;
 
 static int rootpc_add_device(device_t *dev);
@@ -82 +85 @@
 };
 
-static rootpc_fun_data_t pci_data = {
+static rootpc_fun_t pci_data = {
         .hw_resources = {
                 1,
@@ -89 +92 @@
 };
 
-static hw_resource_list_t *rootpc_get_fun_resources(function_t *fun)
-{
-        rootpc_fun_data_t *data;
-        
-        data = (rootpc_fun_data_t *) fun->driver_data;
-        if (NULL == data)
-                return NULL;
-        
-        return &data->hw_resources;
-}
-
-static bool rootpc_enable_fun_interrupt(function_t *fun)
+static hw_resource_list_t *rootpc_get_resources(function_t *fnode)
+{
+        rootpc_fun_t *fun = ROOTPC_FUN(fnode);
+        
+        assert(fun != NULL);
+        return &fun->hw_resources;
+}
+
+static bool rootpc_enable_interrupt(function_t *fun)
 {
         /* TODO */
@@ -108 +108 @@
 
 static hw_res_ops_t fun_hw_res_ops = {
-        &rootpc_get_fun_resources,
-        &rootpc_enable_fun_interrupt
+        &rootpc_get_resources,
+        &rootpc_enable_interrupt
 };
 
@@ -116 +116 @@
 
 static bool
-rootpc_add_fun(device_t *parent, const char *name, const char *str_match_id,
-    rootpc_fun_data_t *drv_data)
+rootpc_add_fun(device_t *dev, const char *name, const char *str_match_id,
+    rootpc_fun_t *fun)
 {
         printf(NAME ": adding new function '%s'.\n", name);
         
-        function_t *fun = NULL;
+        function_t *fnode = NULL;
         match_id_t *match_id = NULL;
         
         /* Create new device. */
-        fun = create_function();
-        if (fun == NULL)
+        fnode = create_function();
+        if (fnode == NULL)
                 goto failure;
         
-        fun->name = name;
-        fun->driver_data = drv_data;
-        fun->ftype = fun_inner;
+        fnode->name = name;
+        fnode->driver_data = fun;
+        fnode->ftype = fun_inner;
         
         /* 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(&fun->match_ids, match_id);
+        add_match_id(&fnode->match_ids, match_id);
         
         /* Set provided operations to the device. */
-        fun->ops = &rootpc_fun_ops;
+        fnode->ops = &rootpc_fun_ops;
         
         /* Register function. */
-        if (EOK != register_function(fun, parent))
+        if (register_function(fnode, dev) != EOK)
                 goto failure;
-        printf(NAME ": registered function handle = %u\n", fun->handle);
+        printf(NAME ": registered function handle = %u\n", fnode->handle);
         
         return true;
         
 failure:
-        if (NULL != match_id)
+        if (match_id != NULL)
                 match_id->id = NULL;
         
-        if (NULL != fun) {
-                fun->name = NULL;
-                delete_function(fun);
+        if (fnode != NULL) {
+                fnode->name = NULL;
+                delete_function(fnode);
         }
         

uspace/drv/rootvirt/rootvirt.c

@@ -61 +61 @@
 };
 
-static int add_device(device_t *dev);
+static int rootvirt_add_device(device_t *dev);
 
 static driver_ops_t rootvirt_ops = {
-        .add_device = &add_device
+        .add_device = &rootvirt_add_device
 };
 
@@ -78 +78 @@
  * @return              EOK on success or negative error code.
  */
-static int add_child(device_t *vdev, virtual_function_t *vfun)
+static int rootvirt_add_fun(device_t *vdev, virtual_function_t *vfun)
 {
         printf(NAME ": registering function `%s' (match \"%s\")\n",
@@ -97 +97 @@
 }
 
-static int add_device(device_t *dev)
+static int rootvirt_add_device(device_t *dev)
 {
         static int instances = 0;
@@ -117 +117 @@
         virtual_function_t *vfun = virtual_functions;
         while (vfun->name != NULL) {
-                (void) add_child(dev, vfun);
+                (void) rootvirt_add_fun(dev, vfun);
                 vfun++;
         }