Changeset 2568c94 in mainline for uspace/drv/bus

Timestamp:

2012-08-17T17:15:19Z (13 years ago)

Author:

Maurizio Lombardi <m.lombardi85@…>

Branches:

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

Children:

1789023

Parents:

4f351432 (diff), 01e397ac (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

merge mainline changes

Location:

uspace/drv/bus

Files:

• isa/isa.c (modified) (17 diffs)
• pci/pciintel/pci.c (modified) (25 diffs)
• usb/ehci/main.c (modified) (3 diffs)
• usb/ehci/res.c (modified) (6 diffs)
• usb/ehci/res.h (modified) (1 diff)
• usb/ohci/hc.c (modified) (1 diff)
• usb/ohci/main.c (modified) (1 diff)
• usb/ohci/ohci.c (modified) (8 diffs)
• usb/ohci/res.c (modified) (3 diffs)
• usb/ohci/res.h (modified) (1 diff)
• usb/uhci/main.c (modified) (1 diff)
• usb/uhci/res.c (modified) (4 diffs)
• usb/uhci/res.h (modified) (1 diff)
• usb/uhci/uhci.c (modified) (7 diffs)
• usb/uhcirh/main.c (modified) (6 diffs)
• usb/uhcirh/port.c (modified) (1 diff)
• usb/usbflbk/main.c (modified) (2 diffs)
• usb/usbhid/generic/hiddev.c (modified) (9 diffs)
• usb/usbhid/generic/hiddev.h (modified) (1 diff)
• usb/usbhid/kbd/kbddev.c (modified) (7 diffs)
• usb/usbhid/main.c (modified) (3 diffs)
• usb/usbhid/mouse/mousedev.c (modified) (8 diffs)
• usb/usbhid/multimedia/multimedia.c (modified) (6 diffs)
• usb/usbhub/port.c (modified) (1 diff)
• usb/usbhub/usbhub.c (modified) (1 diff)
• usb/usbmast/main.c (modified) (6 diffs)
• usb/usbmast/scsi_ms.c (modified) (11 diffs)
• usb/usbmid/explore.c (modified) (1 diff)
• usb/usbmid/main.c (modified) (2 diffs)
• usb/usbmid/usbmid.c (modified) (4 diffs)
• usb/vhc/conndev.c (modified) (2 diffs)
• usb/vhc/connhost.c (modified) (3 diffs)
• usb/vhc/hub.c (modified) (4 diffs)
• usb/vhc/main.c (modified) (3 diffs)

uspace/drv/bus/isa/isa.c

@@ -73 +73 @@
 #define CHILD_FUN_CONF_PATH "/drv/isa/isa.dev"
 
-/** Obtain soft-state from device node */
-#define ISA_BUS(dev) ((isa_bus_t *) ((dev)->driver_data))
-
-/** Obtain soft-state from function node */
-#define ISA_FUN(fun) ((isa_fun_t *) ((fun)->driver_data))
-
 #define ISA_MAX_HW_RES 5
 
@@ -95 +89 @@
 } isa_fun_t;
 
+/** Obtain soft-state from device node */
+static isa_bus_t *isa_bus(ddf_dev_t *dev)
+{
+        return ddf_dev_data_get(dev);
+}
+
+/** Obtain soft-state from function node */
+static isa_fun_t *isa_fun(ddf_fun_t *fun)
+{
+        return ddf_fun_data_get(fun);
+}
+
 static hw_resource_list_t *isa_get_fun_resources(ddf_fun_t *fnode)
 {
-        isa_fun_t *fun = ISA_FUN(fnode);
+        isa_fun_t *fun = isa_fun(fnode);
         assert(fun != NULL);
 
@@ -107 +113 @@
         /* This is an old ugly way, copied from pci driver */
         assert(fnode);
-        isa_fun_t *isa_fun = fnode->driver_data;
+        isa_fun_t *fun = isa_fun(fnode);
 
         sysarg_t apic;
@@ -123 +129 @@
                 return false;
 
-        assert(isa_fun);
-        const hw_resource_list_t *res = &isa_fun->hw_resources;
+        const hw_resource_list_t *res = &fun->hw_resources;
         assert(res);
         for (size_t i = 0; i < res->count; ++i) {
@@ -150 +155 @@
 {
         assert(fnode);
-        isa_fun_t *isa_fun = fnode->driver_data;
-        const hw_resource_list_t *res = &isa_fun->hw_resources;
+        isa_fun_t *fun = isa_fun(fnode);
+        const hw_resource_list_t *res = &fun->hw_resources;
         assert(res);
         
@@ -339 +344 @@
 
                 ddf_msg(LVL_NOTE, "Added irq 0x%x to function %s", irq,
-                    fun->fnode->name);
+                    ddf_fun_get_name(fun->fnode));
         }
 }
@@ -355 +360 @@
                         fun->hw_resources.count++;
                         ddf_msg(LVL_NOTE, "Added dma 0x%x to function %s", dma,
-                            fun->fnode->name);
+                            ddf_fun_get_name(fun->fnode));
                         
                         return;
@@ -366 +371 @@
                         fun->hw_resources.count++;
                         ddf_msg(LVL_NOTE, "Added dma 0x%x to function %s", dma,
-                            fun->fnode->name);
+                            ddf_fun_get_name(fun->fnode));
                         
                         return;
@@ -372 +377 @@
                 
                 ddf_msg(LVL_WARN, "Skipped dma 0x%x for function %s", dma,
-                    fun->fnode->name);
+                    ddf_fun_get_name(fun->fnode));
         }
 }
@@ -391 +396 @@
                 ddf_msg(LVL_NOTE, "Added io range (addr=0x%x, size=0x%x) to "
                     "function %s", (unsigned int) addr, (unsigned int) len,
-                    fun->fnode->name);
+                    ddf_fun_get_name(fun->fnode));
         }
 }
@@ -463 +468 @@
         if (val == end) {
                 ddf_msg(LVL_ERROR, "Cannot read match score for function "
-                    "%s.", fun->fnode->name);
+                    "%s.", ddf_fun_get_name(fun->fnode));
                 return;
         }
@@ -471 +476 @@
         if (id == NULL) {
                 ddf_msg(LVL_ERROR, "Cannot read match ID for function %s.",
-                    fun->fnode->name);
+                    ddf_fun_get_name(fun->fnode));
                 return;
         }
 
         ddf_msg(LVL_DEBUG, "Adding match id '%s' with score %d to "
-            "function %s", id, score, fun->fnode->name);
+            "function %s", id, score, ddf_fun_get_name(fun->fnode));
 
         rc = ddf_fun_add_match_id(fun->fnode, id, score);
@@ -579 +584 @@
 
         /* Set device operations to the device. */
-        fun->fnode->ops = &isa_fun_ops;
-
-        ddf_msg(LVL_DEBUG, "Binding function %s.", fun->fnode->name);
+        ddf_fun_set_ops(fun->fnode, &isa_fun_ops);
+
+        ddf_msg(LVL_DEBUG, "Binding function %s.", ddf_fun_get_name(fun->fnode));
 
         /* XXX Handle error */
@@ -614 +619 @@
 
         ddf_msg(LVL_DEBUG, "isa_dev_add, device handle = %d",
-            (int) dev->handle);
+            (int) ddf_dev_get_handle(dev));
 
         isa = ddf_dev_data_alloc(dev, sizeof(isa_bus_t));
@@ -652 +657 @@
 static int isa_dev_remove(ddf_dev_t *dev)
 {
-        isa_bus_t *isa = ISA_BUS(dev);
+        isa_bus_t *isa = isa_bus(dev);
         int rc;
 
@@ -664 +669 @@
                 if (rc != EOK) {
                         fibril_mutex_unlock(&isa->mutex);
-                        ddf_msg(LVL_ERROR, "Failed offlining %s", fun->fnode->name);
+                        ddf_msg(LVL_ERROR, "Failed offlining %s", ddf_fun_get_name(fun->fnode));
                         return rc;
                 }
@@ -671 +676 @@
                 if (rc != EOK) {
                         fibril_mutex_unlock(&isa->mutex);
-                        ddf_msg(LVL_ERROR, "Failed unbinding %s", fun->fnode->name);
+                        ddf_msg(LVL_ERROR, "Failed unbinding %s", ddf_fun_get_name(fun->fnode));
                         return rc;
                 }

uspace/drv/bus/pci/pciintel/pci.c

@@ -50 +50 @@
 #include <ddf/driver.h>
 #include <ddf/log.h>
-#include <devman.h>
-#include <ipc/devman.h>
 #include <ipc/dev_iface.h>
 #include <ipc/irc.h>
@@ -71 +69 @@
 
 /** Obtain PCI function soft-state from DDF function node */
-#define PCI_FUN(fnode) ((pci_fun_t *) (fnode)->driver_data)
+static pci_fun_t *pci_fun(ddf_fun_t *fnode)
+{
+        return ddf_fun_data_get(fnode);
+}
 
 /** Obtain PCI bus soft-state from DDF device node */
-#define PCI_BUS(dnode) ((pci_bus_t *) (dnode)->driver_data)
+#if 0
+static pci_bus_t *pci_bus(ddf_dev_t *dnode)
+{
+        return ddf_dev_data_get(dnode);
+}
+#endif
 
 /** Obtain PCI bus soft-state from function soft-state */
-#define PCI_BUS_FROM_FUN(fun) ((fun)->busptr)
+static pci_bus_t *pci_bus_from_fun(pci_fun_t *fun)
+{
+        return fun->busptr;
+}
 
 /** Max is 47, align to something nice. */
@@ -84 +93 @@
 static hw_resource_list_t *pciintel_get_resources(ddf_fun_t *fnode)
 {
-        pci_fun_t *fun = PCI_FUN(fnode);
+        pci_fun_t *fun = pci_fun(fnode);
         
         if (fun == NULL)
@@ -95 +104 @@
         /* This is an old ugly way */
         assert(fnode);
-        pci_fun_t *dev_data = (pci_fun_t *) fnode->driver_data;
+        pci_fun_t *dev_data = pci_fun(fnode);
         
         sysarg_t apic;
@@ -138 +147 @@
         if (address > 252)
                 return EINVAL;
-        pci_conf_write_32(PCI_FUN(fun), address, data);
+        pci_conf_write_32(pci_fun(fun), address, data);
         return EOK;
 }
@@ -147 +156 @@
         if (address > 254)
                 return EINVAL;
-        pci_conf_write_16(PCI_FUN(fun), address, data);
+        pci_conf_write_16(pci_fun(fun), address, data);
         return EOK;
 }
@@ -156 +165 @@
         if (address > 255)
                 return EINVAL;
-        pci_conf_write_8(PCI_FUN(fun), address, data);
+        pci_conf_write_8(pci_fun(fun), address, data);
         return EOK;
 }
@@ -165 +174 @@
         if (address > 252)
                 return EINVAL;
-        *data = pci_conf_read_32(PCI_FUN(fun), address);
+        *data = pci_conf_read_32(pci_fun(fun), address);
         return EOK;
 }
@@ -174 +183 @@
         if (address > 254)
                 return EINVAL;
-        *data = pci_conf_read_16(PCI_FUN(fun), address);
+        *data = pci_conf_read_16(pci_fun(fun), address);
         return EOK;
 }
@@ -183 +192 @@
         if (address > 255)
                 return EINVAL;
-        *data = pci_conf_read_8(PCI_FUN(fun), address);
+        *data = pci_conf_read_8(pci_fun(fun), address);
         return EOK;
 }
@@ -225 +234 @@
 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);
+        pci_bus_t *bus = pci_bus_from_fun(fun);
         
         fibril_mutex_lock(&bus->conf_mutex);
@@ -252 +261 @@
 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);
+        pci_bus_t *bus = pci_bus_from_fun(fun);
         
         fibril_mutex_lock(&bus->conf_mutex);
@@ -480 +489 @@
         if (range_addr != 0) {
                 ddf_msg(LVL_DEBUG, "Function %s : address = %" PRIx64
-                    ", size = %x", fun->fnode->name, range_addr,
+                    ", size = %x", ddf_fun_get_name(fun->fnode), range_addr,
                     (unsigned int) range_size);
         }
@@ -506 +515 @@
         hw_res_list->count++;
         
-        ddf_msg(LVL_NOTE, "Function %s uses irq %x.", fun->fnode->name, irq);
+        ddf_msg(LVL_NOTE, "Function %s uses irq %x.", ddf_fun_get_name(fun->fnode), irq);
 }
 
@@ -523 +532 @@
 void pci_bus_scan(pci_bus_t *bus, int bus_num) 
 {
-        ddf_fun_t *fnode;
         pci_fun_t *fun;
+        int rc;
         
         int child_bus = 0;
@@ -531 +540 @@
         uint8_t header_type;
         
-        fun = pci_fun_new(bus);
-        
         for (dnum = 0; dnum < 32; dnum++) {
                 multi = true;
                 for (fnum = 0; multi && fnum < 8; fnum++) {
+                        fun = pci_fun_new(bus);
+                        
                         pci_fun_init(fun, bus_num, dnum, fnum);
                         if (fun->vendor_id == 0xffff) {
+                                pci_fun_delete(fun);
                                 /*
                                  * The device is not present, go on scanning the
@@ -559 +569 @@
                         if (fun_name == NULL) {
                                 ddf_msg(LVL_ERROR, "Out of memory.");
+                                pci_fun_delete(fun);
                                 return;
                         }
                         
-                        fnode = ddf_fun_create(bus->dnode, fun_inner, fun_name);
+                        rc = ddf_fun_set_name(fun->fnode, fun_name);
                         free(fun_name);
-                        if (fnode == NULL) {
-                                ddf_msg(LVL_ERROR, "Failed creating function.");
+                        if (rc != EOK) {
+                                ddf_msg(LVL_ERROR, "Failed setting function name.");
+                                pci_fun_delete(fun);
                                 return;
                         }
-                        
-                        fun->fnode = fnode;
                         
                         pci_alloc_resource_list(fun);
@@ -575 +585 @@
                         pci_read_interrupt(fun);
                         
-                        fnode->ops = &pci_fun_ops;
-                        fnode->driver_data = fun;
+                        ddf_fun_set_ops(fun->fnode, &pci_fun_ops);
                         
                         ddf_msg(LVL_DEBUG, "Adding new function %s.",
-                            fnode->name);
+                            ddf_fun_get_name(fun->fnode));
                         
                         pci_fun_create_match_ids(fun);
                         
-                        if (ddf_fun_bind(fnode) != EOK) {
+                        if (ddf_fun_bind(fun->fnode) != EOK) {
                                 pci_clean_resource_list(fun);
-                                clean_match_ids(&fnode->match_ids);
-                                free((char *) fnode->name);
-                                fnode->name = NULL;
+                                pci_fun_delete(fun);
                                 continue;
                         }
@@ -601 +608 @@
                                         pci_bus_scan(bus, child_bus);
                         }
-                        
-                        fun = pci_fun_new(bus);
                 }
-        }
-        
-        if (fun->vendor_id == 0xffff) {
-                /* Free the auxiliary function structure. */
-                pci_fun_delete(fun);
         }
 }
@@ -617 +617 @@
         ddf_fun_t *ctl = NULL;
         bool got_res = false;
+        async_sess_t *sess;
         int rc;
         
         ddf_msg(LVL_DEBUG, "pci_dev_add");
-        dnode->parent_sess = NULL;
         
         bus = ddf_dev_data_alloc(dnode, sizeof(pci_bus_t));
@@ -631 +631 @@
 
         bus->dnode = dnode;
-        dnode->driver_data = bus;
-        
-        dnode->parent_sess = devman_parent_device_connect(EXCHANGE_SERIALIZE,
-            dnode->handle, IPC_FLAG_BLOCKING);
-        if (!dnode->parent_sess) {
+        
+        sess = ddf_dev_parent_sess_create(dnode, EXCHANGE_SERIALIZE);
+        if (sess == NULL) {
                 ddf_msg(LVL_ERROR, "pci_dev_add failed to connect to the "
                     "parent driver.");
@@ -644 +642 @@
         hw_resource_list_t hw_resources;
         
-        rc = hw_res_get_resource_list(dnode->parent_sess, &hw_resources);
+        rc = hw_res_get_resource_list(sess, &hw_resources);
         if (rc != EOK) {
                 ddf_msg(LVL_ERROR, "pci_dev_add failed to get hw resources "
@@ -708 +706 @@
         
 fail:
-        if (dnode->parent_sess)
-                async_hangup(dnode->parent_sess);
-        
         if (got_res)
                 hw_res_clean_resource_list(&hw_resources);
@@ -742 +737 @@
 {
         pci_fun_t *fun;
-        
-        fun = (pci_fun_t *) calloc(1, sizeof(pci_fun_t));
+        ddf_fun_t *fnode;
+        
+        fnode = ddf_fun_create(bus->dnode, fun_inner, NULL);
+        if (fnode == NULL)
+                return NULL;
+
+        fun = ddf_fun_data_alloc(fnode, sizeof(pci_fun_t));
         if (fun == NULL)
                 return NULL;
 
         fun->busptr = bus;
+        fun->fnode = fnode;
         return fun;
 }
@@ -766 +767 @@
 void pci_fun_delete(pci_fun_t *fun)
 {
-        assert(fun != NULL);
         hw_res_clean_resource_list(&fun->hw_resources);
-        free(fun);
+        if (fun->fnode != NULL)
+                ddf_fun_destroy(fun->fnode);
 }
 

uspace/drv/bus/usb/ehci/main.c

@@ -84 +84 @@
         CHECK_RET_RETURN(ret,
             "Failed to get memory addresses for %" PRIun ": %s.\n",
-            device->handle, str_error(ret));
+            ddf_dev_get_handle(device), str_error(ret));
         usb_log_info("Memory mapped regs at 0x%" PRIxn " (size %zu), IRQ %d.\n",
             reg_base, reg_size, irq);
@@ -104 +104 @@
         /* High Speed, no bandwidth */
         hcd_init(ehci_hc, USB_SPEED_HIGH, 0, NULL);
-        hc_fun->ops = &hc_ops;
+        ddf_fun_set_ops(hc_fun,  &hc_ops);
 
         ret = ddf_fun_bind(hc_fun);
@@ -116 +116 @@
 
         usb_log_info("Controlling new EHCI device `%s' (handle %" PRIun ").\n",
-            device->name, device->handle);
+            ddf_dev_get_name(device), ddf_dev_get_handle(device));
 
         return EOK;

uspace/drv/bus/usb/ehci/res.c

@@ -76 +76 @@
  * @return Error code.
  */
-int get_my_registers(const ddf_dev_t *dev,
+int get_my_registers(ddf_dev_t *dev,
     uintptr_t *mem_reg_address, size_t *mem_reg_size, int *irq_no)
 {
@@ -82 +82 @@
         
         async_sess_t *parent_sess = devman_parent_device_connect(
-            EXCHANGE_SERIALIZE, dev->handle, IPC_FLAG_BLOCKING);
+            EXCHANGE_SERIALIZE, ddf_dev_get_handle(dev), IPC_FLAG_BLOCKING);
         if (!parent_sess)
                 return ENOMEM;
@@ -115 +115 @@
  * @return Error code.
  */
-int enable_interrupts(const ddf_dev_t *device)
+int enable_interrupts(ddf_dev_t *device)
 {
         async_sess_t *parent_sess = devman_parent_device_connect(
-            EXCHANGE_SERIALIZE, device->handle, IPC_FLAG_BLOCKING);
+            EXCHANGE_SERIALIZE, ddf_dev_get_handle(device), IPC_FLAG_BLOCKING);
         if (!parent_sess)
                 return ENOMEM;
@@ -134 +134 @@
  * @return Error code.
  */
-static int disable_extended_caps(const ddf_dev_t *device, unsigned eecp)
+static int disable_extended_caps(ddf_dev_t *device, unsigned eecp)
 {
         /* nothing to do */
@@ -141 +141 @@
 
         async_sess_t *parent_sess = devman_parent_device_connect(
-            EXCHANGE_SERIALIZE, device->handle, IPC_FLAG_BLOCKING);
+            EXCHANGE_SERIALIZE, ddf_dev_get_handle(device), IPC_FLAG_BLOCKING);
         if (!parent_sess)
                 return ENOMEM;
@@ -234 +234 @@
 }
 
-int disable_legacy(const ddf_dev_t *device, uintptr_t reg_base, size_t reg_size)
+int disable_legacy(ddf_dev_t *device, uintptr_t reg_base, size_t reg_size)
 {
         assert(device);

uspace/drv/bus/usb/ehci/res.h

@@ -38 +38 @@
 #include <ddf/driver.h>
 
-int get_my_registers(const ddf_dev_t *, uintptr_t *, size_t *, int *);
-int enable_interrupts(const ddf_dev_t *);
-int disable_legacy(const ddf_dev_t *, uintptr_t, size_t);
+int get_my_registers(ddf_dev_t *, uintptr_t *, size_t *, int *);
+int enable_interrupts(ddf_dev_t *);
+int disable_legacy(ddf_dev_t *, uintptr_t, size_t);
 
 #endif

uspace/drv/bus/usb/ohci/hc.c

@@ -187 +187 @@
 
         ret = usb_device_manager_bind_address(&instance->generic.dev_manager,
-            instance->rh.address, hub_fun->handle);
+            instance->rh.address, ddf_fun_get_handle(hub_fun));
         if (ret != EOK)
                 usb_log_warning("Failed to bind root hub address: %s.\n",

uspace/drv/bus/usb/ohci/main.c

@@ -59 +59 @@
                 return ret;
         }
-        usb_log_info("Controlling new OHCI device '%s'.\n", device->name);
+        usb_log_info("Controlling new OHCI device '%s'.\n", ddf_dev_get_name(device));
 
         return EOK;

uspace/drv/bus/usb/ohci/ohci.c

@@ -33 +33 @@
  * @brief OHCI driver
  */
+
+/* XXX Fix this */
+#define _DDF_DATA_IMPLANT
+
 #include <errno.h>
 #include <str_error.h>
@@ -52 +56 @@
 } ohci_t;
 
-static inline ohci_t * dev_to_ohci(ddf_dev_t *dev)
-{
-        assert(dev);
-        return dev->driver_data;
+static inline ohci_t *dev_to_ohci(ddf_dev_t *dev)
+{
+        return ddf_dev_data_get(dev);
 }
 /** IRQ handling callback, identifies device
@@ -87 +90 @@
 
         if (address != NULL) {
-                *address = dev_to_ohci(fun->dev)->hc.rh.address;
+                *address = dev_to_ohci(ddf_fun_get_dev(fun))->hc.rh.address;
         }
 
@@ -103 +106 @@
 {
         assert(fun);
-        ddf_fun_t *hc_fun = dev_to_ohci(fun->dev)->hc_fun;
+        ddf_fun_t *hc_fun = dev_to_ohci(ddf_fun_get_dev(fun))->hc_fun;
         assert(hc_fun);
 
         if (handle != NULL)
-                *handle = hc_fun->handle;
+                *handle = ddf_fun_get_handle(hc_fun);
         return EOK;
 }
@@ -152 +155 @@
 if (ret != EOK) { \
         if (instance->hc_fun) { \
-                instance->hc_fun->driver_data = NULL; \
                 ddf_fun_destroy(instance->hc_fun); \
         } \
         if (instance->rh_fun) { \
-                instance->rh_fun->driver_data = NULL; \
                 ddf_fun_destroy(instance->rh_fun); \
         } \
@@ -167 +168 @@
         CHECK_RET_DEST_FREE_RETURN(ret,
             "Failed to create OHCI HC function: %s.\n", str_error(ret));
-        instance->hc_fun->ops = &hc_ops;
-        instance->hc_fun->driver_data = &instance->hc;
+        ddf_fun_set_ops(instance->hc_fun, &hc_ops);
+        ddf_fun_data_implant(instance->hc_fun, &instance->hc);
 
         instance->rh_fun = ddf_fun_create(device, fun_inner, "ohci_rh");
@@ -174 +175 @@
         CHECK_RET_DEST_FREE_RETURN(ret,
             "Failed to create OHCI RH function: %s.\n", str_error(ret));
-        instance->rh_fun->ops = &rh_ops;
+        ddf_fun_set_ops(instance->rh_fun, &rh_ops);
 
         uintptr_t reg_base = 0;
@@ -183 +184 @@
         CHECK_RET_DEST_FREE_RETURN(ret,
             "Failed to get register memory addresses for %" PRIun ": %s.\n",
-            device->handle, str_error(ret));
+            ddf_dev_get_handle(device), str_error(ret));
         usb_log_debug("Memory mapped regs at %p (size %zu), IRQ %d.\n",
             (void *) reg_base, reg_size, irq);

uspace/drv/bus/usb/ohci/res.c

@@ -53 +53 @@
  * @return Error code.
  */
-int get_my_registers(const ddf_dev_t *dev,
+int get_my_registers(ddf_dev_t *dev,
     uintptr_t *mem_reg_address, size_t *mem_reg_size, int *irq_no)
 {
@@ -59 +59 @@
 
         async_sess_t *parent_sess =
-            devman_parent_device_connect(EXCHANGE_SERIALIZE, dev->handle,
-            IPC_FLAG_BLOCKING);
+            devman_parent_device_connect(EXCHANGE_SERIALIZE,
+            ddf_dev_get_handle(dev), IPC_FLAG_BLOCKING);
         if (!parent_sess)
                 return ENOMEM;
@@ -94 +94 @@
  * @return Error code.
  */
-int enable_interrupts(const ddf_dev_t *device)
+int enable_interrupts(ddf_dev_t *device)
 {
         async_sess_t *parent_sess =
-            devman_parent_device_connect(EXCHANGE_SERIALIZE, device->handle,
-            IPC_FLAG_BLOCKING);
+            devman_parent_device_connect(EXCHANGE_SERIALIZE,
+            ddf_dev_get_handle(device), IPC_FLAG_BLOCKING);
         if (!parent_sess)
                 return ENOMEM;

uspace/drv/bus/usb/ohci/res.h

@@ -37 +37 @@
 #include <ddf/driver.h>
 
-int get_my_registers(const ddf_dev_t *, uintptr_t *, size_t *, int *);
-int enable_interrupts(const ddf_dev_t *);
+int get_my_registers(ddf_dev_t *, uintptr_t *, size_t *, int *);
+int enable_interrupts(ddf_dev_t *);
 
 #endif

uspace/drv/bus/usb/uhci/main.c

@@ -70 +70 @@
         } else {
                 usb_log_info("Controlling new UHCI device '%s'.\n",
-                    device->name);
+                    ddf_dev_get_name(device));
         }
 

uspace/drv/bus/usb/uhci/res.c

@@ -51 +51 @@
  * @return Error code.
  */
-int get_my_registers(const ddf_dev_t *dev,
+int get_my_registers(ddf_dev_t *dev,
     uintptr_t *io_reg_address, size_t *io_reg_size, int *irq_no)
 {
@@ -57 +57 @@
 
         async_sess_t *parent_sess =
-            devman_parent_device_connect(EXCHANGE_SERIALIZE, dev->handle,
-            IPC_FLAG_BLOCKING);
+            devman_parent_device_connect(EXCHANGE_SERIALIZE,
+            ddf_dev_get_handle(dev), IPC_FLAG_BLOCKING);
         if (!parent_sess)
                 return ENOMEM;
@@ -92 +92 @@
  * @return Error code.
  */
-int enable_interrupts(const ddf_dev_t *device)
+int enable_interrupts(ddf_dev_t *device)
 {
         async_sess_t *parent_sess =
-            devman_parent_device_connect(EXCHANGE_SERIALIZE, device->handle,
-            IPC_FLAG_BLOCKING);
+            devman_parent_device_connect(EXCHANGE_SERIALIZE,
+            ddf_dev_get_handle(device), IPC_FLAG_BLOCKING);
         if (!parent_sess)
                 return ENOMEM;
@@ -111 +111 @@
  * @return Error code.
  */
-int disable_legacy(const ddf_dev_t *device)
+int disable_legacy(ddf_dev_t *device)
 {
         assert(device);
 
         async_sess_t *parent_sess = devman_parent_device_connect(
-            EXCHANGE_SERIALIZE, device->handle, IPC_FLAG_BLOCKING);
+            EXCHANGE_SERIALIZE, ddf_dev_get_handle(device), IPC_FLAG_BLOCKING);
         if (!parent_sess)
                 return ENOMEM;

uspace/drv/bus/usb/uhci/res.h

@@ -38 +38 @@
 #include <ddf/driver.h>
 
-int get_my_registers(const ddf_dev_t *, uintptr_t *, size_t *, int *);
-int enable_interrupts(const ddf_dev_t *);
-int disable_legacy(const ddf_dev_t *);
+int get_my_registers(ddf_dev_t *, uintptr_t *, size_t *, int *);
+int enable_interrupts(ddf_dev_t *);
+int disable_legacy(ddf_dev_t *);
 
 #endif

uspace/drv/bus/usb/uhci/uhci.c

@@ -33 +33 @@
  * @brief UHCI driver
  */
+
+/* XXX Fix this */
+#define _DDF_DATA_IMPLANT
+
 #include <errno.h>
 #include <str_error.h>
@@ -60 +64 @@
 } uhci_t;
 
-static inline uhci_t * dev_to_uhci(const ddf_dev_t *dev)
-{
-        assert(dev);
-        return dev->driver_data;
+static inline uhci_t *dev_to_uhci(ddf_dev_t *dev)
+{
+        return ddf_dev_data_get(dev);
 }
 
@@ -97 +100 @@
 static int usb_iface_get_hc_handle(ddf_fun_t *fun, devman_handle_t *handle)
 {
-        assert(fun);
-        ddf_fun_t *hc_fun = dev_to_uhci(fun->dev)->hc_fun;
+        ddf_fun_t *hc_fun = dev_to_uhci(ddf_fun_get_dev(fun))->hc_fun;
         assert(hc_fun);
 
         if (handle != NULL)
-                *handle = hc_fun->handle;
+                *handle = ddf_fun_get_handle(hc_fun);
         return EOK;
 }
@@ -118 +120 @@
 static hw_resource_list_t *get_resource_list(ddf_fun_t *fun)
 {
-        assert(fun);
-        rh_t *rh = fun->driver_data;
+        rh_t *rh = ddf_fun_data_get(fun);
         assert(rh);
         return &rh->resource_list;
@@ -160 +161 @@
 if (ret != EOK) { \
         if (instance->hc_fun) \
-                instance->hc_fun->driver_data = NULL; \
                 ddf_fun_destroy(instance->hc_fun); \
         if (instance->rh_fun) {\
-                instance->rh_fun->driver_data = NULL; \
                 ddf_fun_destroy(instance->rh_fun); \
         } \
@@ -174 +173 @@
         int ret = (instance->hc_fun == NULL) ? ENOMEM : EOK;
         CHECK_RET_DEST_FREE_RETURN(ret, "Failed to create UHCI HC function.\n");
-        instance->hc_fun->ops = &hc_ops;
-        instance->hc_fun->driver_data = &instance->hc.generic;
+        ddf_fun_set_ops(instance->hc_fun, &hc_ops);
+        ddf_fun_data_implant(instance->hc_fun, &instance->hc.generic);
 
         instance->rh_fun = ddf_fun_create(device, fun_inner, "uhci_rh");
         ret = (instance->rh_fun == NULL) ? ENOMEM : EOK;
         CHECK_RET_DEST_FREE_RETURN(ret, "Failed to create UHCI RH function.\n");
-        instance->rh_fun->ops = &rh_ops;
-        instance->rh_fun->driver_data = &instance->rh;
+        ddf_fun_set_ops(instance->rh_fun, &rh_ops);
+        ddf_fun_data_implant(instance->rh_fun, &instance->rh);
 
         uintptr_t reg_base = 0;
@@ -190 +189 @@
         CHECK_RET_DEST_FREE_RETURN(ret,
             "Failed to get I/O addresses for %" PRIun ": %s.\n",
-            device->handle, str_error(ret));
+            ddf_dev_get_handle(device), str_error(ret));
         usb_log_debug("I/O regs at 0x%p (size %zu), IRQ %d.\n",
             (void *) reg_base, reg_size, irq);

uspace/drv/bus/usb/uhcirh/main.c

@@ -48 +48 @@
 #define NAME "uhcirh"
 
-static int hc_get_my_registers(const ddf_dev_t *dev,
+static int hc_get_my_registers(ddf_dev_t *dev,
     uintptr_t *io_reg_address, size_t *io_reg_size);
 
@@ -88 +88 @@
 
         usb_log_debug2("uhci_rh_dev_add(handle=%" PRIun ")\n",
-            device->handle);
+            ddf_dev_get_handle(device));
 
         uintptr_t io_regs = 0;
@@ -98 +98 @@
 if (ret != EOK) { \
         usb_log_error(message); \
-        if (rh) \
-                free(rh); \
         return ret; \
 } else (void)0
@@ -109 +107 @@
             (void *) io_regs, io_size);
 
-        rh = malloc(sizeof(uhci_root_hub_t));
+        rh = ddf_dev_data_alloc(device, sizeof(uhci_root_hub_t));
         ret = (rh == NULL) ? ENOMEM : EOK;
         CHECK_RET_FREE_RH_RETURN(ret,
@@ -119 +117 @@
             ret, str_error(ret));
 
-        device->driver_data = rh;
         usb_log_info("Controlling root hub '%s' (%" PRIun ").\n",
-            device->name, device->handle);
+            ddf_dev_get_name(device), ddf_dev_get_handle(device));
         return EOK;
 }
@@ -133 +130 @@
  */
 int hc_get_my_registers(
-    const ddf_dev_t *dev, uintptr_t *io_reg_address, size_t *io_reg_size)
+    ddf_dev_t *dev, uintptr_t *io_reg_address, size_t *io_reg_size)
 {
-        assert(dev);
-
         async_sess_t *parent_sess =
-            devman_parent_device_connect(EXCHANGE_SERIALIZE, dev->handle,
-            IPC_FLAG_BLOCKING);
+            devman_parent_device_connect(EXCHANGE_SERIALIZE,
+            ddf_dev_get_handle(dev), IPC_FLAG_BLOCKING);
         if (!parent_sess)
                 return ENOMEM;

uspace/drv/bus/usb/uhcirh/port.c

@@ -279 +279 @@
         usb_log_info("%s: New device, address %d (handle %" PRIun ").\n",
             port->id_string, port->attached_device.address,
-            port->attached_device.fun->handle);
+            ddf_fun_get_handle(port->attached_device.fun));
         return EOK;
 }

uspace/drv/bus/usb/usbflbk/main.c

@@ -69 +69 @@
             " (node `%s', handle %" PRIun ").\n",
             dev->interface_no < 0 ? "device" : "interface",
-            dev->ddf_dev->name, fun_name, dev->ddf_dev->handle);
+            ddf_dev_get_name(dev->ddf_dev), fun_name, ddf_dev_get_handle(dev->ddf_dev));
 
         return EOK;
@@ -85 +85 @@
         const int ret = ddf_fun_unbind(ctl_fun);
         if (ret != EOK) {
-                usb_log_error("Failed to unbind %s.\n", ctl_fun->name);
+                usb_log_error("Failed to unbind %s.\n", ddf_fun_get_name(ctl_fun));
                 return ret;
         }

uspace/drv/bus/usb/usbhid/generic/hiddev.c

@@ -35 +35 @@
  */
 
+/* XXX Fix this */
+#define _DDF_DATA_IMPLANT
+
 #include <usb/debug.h>
 #include <usb/classes/classes.h>
@@ -81 +84 @@
 };
 
+/** Return hid_dev_t * for generic HID function node.
+ *
+ * For the generic HID subdriver the 'hid' function has usb_hid_gen_fun_t
+ * as soft state. Through that we can get to the usb_hid_dev_t.
+ */
+static usb_hid_dev_t *fun_hid_dev(ddf_fun_t *fun)
+{
+        return ((usb_hid_gen_fun_t *)ddf_fun_data_get(fun))->hid_dev;
+}
+
 static size_t usb_generic_hid_get_event_length(ddf_fun_t *fun)
 {
         usb_log_debug2("Generic HID: Get event length (fun: %p, "
-            "fun->driver_data: %p.\n", fun, fun->driver_data);
-
-        if (fun == NULL || fun->driver_data == NULL) {
-                return 0;
-        }
-
-        const usb_hid_dev_t *hid_dev = fun->driver_data;
+            "fun->driver_data: %p.\n", fun, ddf_fun_data_get(fun));
+
+        const usb_hid_dev_t *hid_dev = fun_hid_dev(fun);
 
         usb_log_debug2("hid_dev: %p, Max input report size (%zu).\n",
@@ -103 +112 @@
         usb_log_debug2("Generic HID: Get event.\n");
 
-        if (fun == NULL || fun->driver_data == NULL || buffer == NULL
-            || act_size == NULL || event_nr == NULL) {
+        if (buffer == NULL || act_size == NULL || event_nr == NULL) {
                 usb_log_debug("No function");
                 return EINVAL;
         }
 
-        const usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
+        const usb_hid_dev_t *hid_dev = fun_hid_dev(fun);
 
         if (hid_dev->input_report_size > size) {
@@ -132 +140 @@
         usb_log_debug("Generic HID: Get report descriptor length.\n");
 
-        if (fun == NULL || fun->driver_data == NULL) {
-                usb_log_debug("No function");
-                return EINVAL;
-        }
-
-        const usb_hid_dev_t *hid_dev = fun->driver_data;
+        const usb_hid_dev_t *hid_dev = fun_hid_dev(fun);
 
         usb_log_debug2("hid_dev->report_desc_size = %zu\n",
@@ -150 +153 @@
         usb_log_debug2("Generic HID: Get report descriptor.\n");
 
-        if (fun == NULL || fun->driver_data == NULL) {
-                usb_log_debug("No function");
-                return EINVAL;
-        }
-
-        const usb_hid_dev_t *hid_dev = fun->driver_data;
+        const usb_hid_dev_t *hid_dev = fun_hid_dev(fun);
 
         if (hid_dev->report_desc_size > size) {
@@ -183 +181 @@
                 return;
         }
-        usb_log_debug2("%s unbound.\n", fun->name);
-        /* We did not allocate this, so leave this alone
-         * the device would take care of it */
-        fun->driver_data = NULL;
+        usb_log_debug2("%s unbound.\n", ddf_fun_get_name(fun));
         ddf_fun_destroy(fun);
 }
@@ -192 +187 @@
 int usb_generic_hid_init(usb_hid_dev_t *hid_dev, void **data)
 {
+        usb_hid_gen_fun_t *hid_fun;
+
         if (hid_dev == NULL) {
                 return EINVAL;
@@ -205 +202 @@
         }
 
-        /* This is nasty, both device and this function have the same
-         * driver data, thus destruction causes to double free */
-        fun->driver_data = hid_dev;
-        fun->ops = &usb_generic_hid_ops;
+        /* Create softstate */
+        hid_fun = ddf_fun_data_alloc(fun, sizeof(usb_hid_gen_fun_t));
+        hid_fun->hid_dev = hid_dev;
+        ddf_fun_set_ops(fun, &usb_generic_hid_ops);
 
         int rc = ddf_fun_bind(fun);
@@ -214 +211 @@
                 usb_log_error("Could not bind DDF function: %s.\n",
                     str_error(rc));
-                fun->driver_data = NULL;
                 ddf_fun_destroy(fun);
                 return rc;
         }
 
-        usb_log_debug("HID function created. Handle: %" PRIun "\n", fun->handle);
+        usb_log_debug("HID function created. Handle: %" PRIun "\n",
+            ddf_fun_get_handle(fun));
         *data = fun;
 

uspace/drv/bus/usb/usbhid/generic/hiddev.h

@@ -47 +47 @@
 const char *HID_GENERIC_CLASS_NAME;
 
-
+/** The USB HID generic 'hid' function softstate */
+typedef struct {
+        struct usb_hid_dev *hid_dev;
+} usb_hid_gen_fun_t;
 
 int usb_generic_hid_init(struct usb_hid_dev *hid_dev, void **data);

uspace/drv/bus/usb/usbhid/kbd/kbddev.c

@@ -34 +34 @@
  * USB HID keyboard device structure and API.
  */
+
+/* XXX Fix this */
+#define _DDF_DATA_IMPLANT
 
 #include <errno.h>
@@ -162 +165 @@
     ipc_callid_t icallid, ipc_call_t *icall)
 {
-        if (fun == NULL || fun->driver_data == NULL) {
-                usb_log_error("%s: Missing parameter.\n", __FUNCTION__);
-                async_answer_0(icallid, EINVAL);
-                return;
-        }
-
         const sysarg_t method = IPC_GET_IMETHOD(*icall);
-        usb_kbd_t *kbd_dev = fun->driver_data;
+        usb_kbd_t *kbd_dev = ddf_fun_data_get(fun);
 
         switch (method) {
@@ -501 +498 @@
         /* Store the initialized HID device and HID ops
          * to the DDF function. */
-        fun->ops = &kbdops;
-        fun->driver_data = kbd_dev;
+        ddf_fun_set_ops(fun, &kbdops);
+        ddf_fun_data_implant(fun, kbd_dev);
 
         int rc = ddf_fun_bind(fun);
@@ -508 +505 @@
                 usb_log_error("Could not bind DDF function: %s.\n",
                     str_error(rc));
-                fun->driver_data = NULL; /* We did not allocate this. */
                 ddf_fun_destroy(fun);
                 return rc;
@@ -514 +510 @@
 
         usb_log_debug("%s function created. Handle: %" PRIun "\n",
-            HID_KBD_FUN_NAME, fun->handle);
+            HID_KBD_FUN_NAME, ddf_fun_get_handle(fun));
 
         usb_log_debug("Adding DDF function to category %s...\n",
@@ -524 +520 @@
                     HID_KBD_CLASS_NAME, str_error(rc));
                 if (ddf_fun_unbind(fun) == EOK) {
-                        fun->driver_data = NULL; /* We did not allocate this. */
                         ddf_fun_destroy(fun);
                 } else {
                         usb_log_error(
                             "Failed to unbind `%s', will not destroy.\n",
-                            fun->name);
+                            ddf_fun_get_name(fun));
                 }
                 return rc;
@@ -757 +752 @@
                 if (ddf_fun_unbind(kbd_dev->fun) != EOK) {
                         usb_log_warning("Failed to unbind %s.\n",
-                            kbd_dev->fun->name);
+                            ddf_fun_get_name(kbd_dev->fun));
                 } else {
-                        usb_log_debug2("%s unbound.\n", kbd_dev->fun->name);
-                        kbd_dev->fun->driver_data = NULL;
+                        usb_log_debug2("%s unbound.\n",
+                            ddf_fun_get_name(kbd_dev->fun));
                         ddf_fun_destroy(kbd_dev->fun);
                 }
         }
-        free(kbd_dev);
 }
 

uspace/drv/bus/usb/usbhid/main.c

@@ -103 +103 @@
         if (rc != EOK) {
                 usb_log_error("Failed to start polling fibril for `%s'.\n",
-                    dev->ddf_dev->name);
+                    ddf_dev_get_name(dev->ddf_dev));
                 usb_hid_deinit(hid_dev);
                 return rc;
@@ -109 +109 @@
         hid_dev->running = true;
 
-        usb_log_info("HID device `%s' ready to use.\n", dev->ddf_dev->name);
+        usb_log_info("HID device `%s' ready to use.\n",
+            ddf_dev_get_name(dev->ddf_dev));
 
         return EOK;
@@ -149 +150 @@
 
         usb_hid_deinit(hid_dev);
-        usb_log_debug2("%s destruction complete.\n", dev->ddf_dev->name);
+        usb_log_debug2("%s destruction complete.\n", ddf_dev_get_name(dev->ddf_dev));
         return EOK;
 }

uspace/drv/bus/usb/usbhid/mouse/mousedev.c

@@ -34 +34 @@
  * USB Mouse driver API.
  */
+
+/* XXX Fix this */
+#define _DDF_DATA_IMPLANT
 
 #include <usb/debug.h>
@@ -115 +118 @@
     ipc_callid_t icallid, ipc_call_t *icall)
 {
-        usb_mouse_t *mouse_dev = fun->driver_data;
+        usb_mouse_t *mouse_dev = ddf_fun_data_get(fun);
 
         if (mouse_dev == NULL) {
@@ -123 +126 @@
         }
 
-        usb_log_debug("%s: fun->name: %s\n", __FUNCTION__, fun->name);
+        usb_log_debug("%s: fun->name: %s\n", __FUNCTION__, ddf_fun_get_name(fun));
         usb_log_debug("%s: mouse_sess: %p\n",
             __FUNCTION__, mouse_dev->mouse_sess);
@@ -133 +136 @@
                         mouse_dev->mouse_sess = sess;
                         usb_log_debug("Console session to %s set ok (%p).\n",
-                            fun->name, sess);
+                            ddf_fun_get_name(fun), sess);
                         async_answer_0(icallid, EOK);
                 } else {
                         usb_log_error("Console session to %s already set.\n",
-                            fun->name);
+                            ddf_fun_get_name(fun));
                         async_answer_0(icallid, ELIMIT);
                         async_hangup(sess);
@@ -249 +252 @@
 if (fun) { \
         if (ddf_fun_unbind((fun)) == EOK) { \
-                (fun)->driver_data = NULL; \
                 ddf_fun_destroy((fun)); \
         } else { \
                 usb_log_error("Could not unbind function `%s', it " \
-                    "will not be destroyed.\n", (fun)->name); \
+                    "will not be destroyed.\n", ddf_fun_get_name(fun)); \
         } \
 } else (void)0
@@ -272 +274 @@
         }
 
-        fun->ops = &ops;
-        fun->driver_data = mouse;
+        ddf_fun_set_ops(fun, &ops);
+        ddf_fun_data_implant(fun, mouse);
 
         int rc = ddf_fun_bind(fun);
         if (rc != EOK) {
                 usb_log_error("Could not bind DDF function `%s': %s.\n",
-                    fun->name, str_error(rc));
-                fun->driver_data = NULL;
+                    ddf_fun_get_name(fun), str_error(rc));
                 ddf_fun_destroy(fun);
                 return rc;
@@ -285 +286 @@
 
         usb_log_debug("Adding DDF function `%s' to category %s...\n",
-            fun->name, HID_MOUSE_CATEGORY);
+            ddf_fun_get_name(fun), HID_MOUSE_CATEGORY);
         rc = ddf_fun_add_to_category(fun, HID_MOUSE_CATEGORY);
         if (rc != EOK) {
@@ -419 +420 @@
 
         free(mouse_dev->buttons);
-        free(mouse_dev);
 }
 

uspace/drv/bus/usb/usbhid/multimedia/multimedia.c

@@ -86 +86 @@
 {
         usb_log_debug(NAME " default_connection_handler()\n");
-        if (fun == NULL || fun->driver_data == NULL) {
-                async_answer_0(icallid, EINVAL);
-                return;
-        }
-
-        usb_multimedia_t *multim_dev = fun->driver_data;
+
+        usb_multimedia_t *multim_dev = ddf_fun_data_get(fun);
 
         async_sess_t *sess =
@@ -172 +168 @@
         }
 
-        fun->ops = &multimedia_ops;
+        ddf_fun_set_ops(fun, &multimedia_ops);
 
         usb_multimedia_t *multim_dev =
@@ -194 +190 @@
 
         usb_log_debug(NAME " function created (handle: %" PRIun ").\n",
-            fun->handle);
+            ddf_fun_get_handle(fun));
 
         rc = ddf_fun_add_to_category(fun, "keyboard");
@@ -203 +199 @@
                 if (ddf_fun_unbind(fun) != EOK) {
                         usb_log_error("Failed to unbind %s, won't destroy.\n",
-                            fun->name);
+                            ddf_fun_get_name(fun));
                 } else {
                         ddf_fun_destroy(fun);
@@ -220 +216 @@
 {
         ddf_fun_t *fun = data;
-        if (fun != NULL && fun->driver_data != NULL) {
-                usb_multimedia_t *multim_dev = fun->driver_data;
-                /* Hangup session to the console */
-                if (multim_dev->console_sess)
-                        async_hangup(multim_dev->console_sess);
-                if (ddf_fun_unbind(fun) != EOK) {
-                        usb_log_error("Failed to unbind %s, won't destroy.\n",
-                            fun->name);
-                } else {
-                        usb_log_debug2("%s unbound.\n", fun->name);
-                        /* This frees multim_dev too as it was stored in
-                         * fun->data */
-                        ddf_fun_destroy(fun);
-                }
+
+        usb_multimedia_t *multim_dev = ddf_fun_data_get(fun);
+
+        /* Hangup session to the console */
+        if (multim_dev->console_sess)
+                async_hangup(multim_dev->console_sess);
+        if (ddf_fun_unbind(fun) != EOK) {
+                usb_log_error("Failed to unbind %s, won't destroy.\n",
+                    ddf_fun_get_name(fun));
         } else {
-                usb_log_error(
-                    "Failed to deinit multimedia subdriver, data missing.\n");
+                usb_log_debug2("%s unbound.\n", ddf_fun_get_name(fun));
+                /* This frees multim_dev too as it was stored in
+                 * fun->data */
+                ddf_fun_destroy(fun);
         }
 }
@@ -244 +237 @@
         // TODO: checks
         ddf_fun_t *fun = data;
-        if (hid_dev == NULL || fun == NULL || fun->driver_data == NULL) {
+        if (hid_dev == NULL) {
                 return false;
         }
 
-        usb_multimedia_t *multim_dev = fun->driver_data;
+        usb_multimedia_t *multim_dev = ddf_fun_data_get(fun);
 
         usb_hid_report_path_t *path = usb_hid_report_path();

uspace/drv/bus/usb/usbhub/port.c

@@ -436 +436 @@
                 usb_log_info("Detected new device on `%s' (port %zu), "
                     "address %d (handle %" PRIun ").\n",
-                    data->hub->usb_device->ddf_dev->name,
-                    data->port->port_number, new_address, child_fun->handle);
+                    ddf_dev_get_name(data->hub->usb_device->ddf_dev),
+                    data->port->port_number, new_address,
+                    ddf_fun_get_handle(child_fun));
         } else {
                 usb_log_error("Failed registering device on port %zu: %s.\n",

uspace/drv/bus/usb/usbhub/usbhub.c

@@ -160 +160 @@
         hub_dev->running = true;
         usb_log_info("Controlling hub '%s' (%zu ports).\n",
-            hub_dev->usb_device->ddf_dev->name, hub_dev->port_count);
+            ddf_dev_get_name(hub_dev->usb_device->ddf_dev), hub_dev->port_count);
 
         usb_pipe_end_long_transfer(&usb_dev->ctrl_pipe);

uspace/drv/bus/usb/usbmast/main.c

@@ -160 +160 @@
         mdev->usb_dev = dev;
 
-        usb_log_info("Initializing mass storage `%s'.\n", dev->ddf_dev->name);
+        usb_log_info("Initializing mass storage `%s'.\n", ddf_dev_get_name(dev->ddf_dev));
         usb_log_debug("Bulk in endpoint: %d [%zuB].\n",
             dev->pipes[BULK_IN_EP].pipe.endpoint_no,
@@ -245 +245 @@
 
         /* Set up a connection handler. */
-        fun->conn_handler = usbmast_bd_connection;
+        ddf_fun_set_conn_handler(fun, usbmast_bd_connection);
 
         usb_log_debug("Inquire...\n");
@@ -252 +252 @@
         if (rc != EOK) {
                 usb_log_warning("Failed to inquire device `%s': %s.\n",
-                    mdev->ddf_dev->name, str_error(rc));
+                    ddf_dev_get_name(mdev->ddf_dev), str_error(rc));
                 rc = EIO;
                 goto error;
@@ -259 +259 @@
         usb_log_info("Mass storage `%s' LUN %u: " \
             "%s by %s rev. %s is %s (%s).\n",
-            mdev->ddf_dev->name,
+            ddf_dev_get_name(mdev->ddf_dev),
             lun,
             inquiry.product,
@@ -272 +272 @@
         if (rc != EOK) {
                 usb_log_warning("Failed to read capacity, device `%s': %s.\n",
-                    mdev->ddf_dev->name, str_error(rc));
+                    ddf_dev_get_name(mdev->ddf_dev), str_error(rc));
                 rc = EIO;
                 goto error;
@@ -310 +310 @@
         usbmast_fun_t *mfun;
 
-        mfun = (usbmast_fun_t *) ((ddf_fun_t *)arg)->driver_data;
+        mfun = (usbmast_fun_t *) ddf_fun_data_get((ddf_fun_t *)arg);
         bd_conn(iid, icall, &mfun->bds);
 }

uspace/drv/bus/usb/usbmast/scsi_ms.c

@@ -88 +88 @@
                 if (rc != EOK) {
                         usb_log_error("Inquiry transport failed, device %s: %s.\n",
-                           mfun->mdev->ddf_dev->name, str_error(rc));
+                           ddf_dev_get_name(mfun->mdev->ddf_dev), str_error(rc));
                         return rc;
                 }
@@ -96 +96 @@
 
                 usb_log_error("SCSI command failed, device %s.\n",
-                    mfun->mdev->ddf_dev->name);
+                    ddf_dev_get_name(mfun->mdev->ddf_dev));
 
                 rc = usbmast_request_sense(mfun, &sense_buf, sizeof(sense_buf));
@@ -147 +147 @@
         if (rc != EOK) {
                 usb_log_error("Inquiry transport failed, device %s: %s.\n",
-                   mfun->mdev->ddf_dev->name, str_error(rc));
+                   ddf_dev_get_name(mfun->mdev->ddf_dev), str_error(rc));
                 return rc;
         }
@@ -153 +153 @@
         if (cmd.status != CMDS_GOOD) {
                 usb_log_error("Inquiry command failed, device %s.\n",
-                   mfun->mdev->ddf_dev->name);
+                   ddf_dev_get_name(mfun->mdev->ddf_dev));
                 return EIO;
         }
@@ -215 +215 @@
         if (rc != EOK || cmd.status != CMDS_GOOD) {
                 usb_log_error("Request Sense failed, device %s: %s.\n",
-                   mfun->mdev->ddf_dev->name, str_error(rc));
+                   ddf_dev_get_name(mfun->mdev->ddf_dev), str_error(rc));
                 return rc;
         }
@@ -257 +257 @@
         if (rc != EOK) {
                 usb_log_error("Read Capacity (10) transport failed, device %s: %s.\n",
-                   mfun->mdev->ddf_dev->name, str_error(rc));
+                   ddf_dev_get_name(mfun->mdev->ddf_dev), str_error(rc));
                 return rc;
         }
@@ -263 +263 @@
         if (cmd.status != CMDS_GOOD) {
                 usb_log_error("Read Capacity (10) command failed, device %s.\n",
-                   mfun->mdev->ddf_dev->name);
+                   ddf_dev_get_name(mfun->mdev->ddf_dev));
                 return EIO;
         }
@@ -314 +314 @@
         if (rc != EOK) {
                 usb_log_error("Read (10) transport failed, device %s: %s.\n",
-                   mfun->mdev->ddf_dev->name, str_error(rc));
+                   ddf_dev_get_name(mfun->mdev->ddf_dev), str_error(rc));
                 return rc;
         }
@@ -320 +320 @@
         if (cmd.status != CMDS_GOOD) {
                 usb_log_error("Read (10) command failed, device %s.\n",
-                   mfun->mdev->ddf_dev->name);
+                   ddf_dev_get_name(mfun->mdev->ddf_dev));
                 return EIO;
         }
@@ -370 +370 @@
         if (rc != EOK) {
                 usb_log_error("Write (10) transport failed, device %s: %s.\n",
-                   mfun->mdev->ddf_dev->name, str_error(rc));
+                   ddf_dev_get_name(mfun->mdev->ddf_dev), str_error(rc));
                 return rc;
         }
@@ -376 +376 @@
         if (cmd.status != CMDS_GOOD) {
                 usb_log_error("Write (10) command failed, device %s.\n",
-                   mfun->mdev->ddf_dev->name);
+                   ddf_dev_get_name(mfun->mdev->ddf_dev));
                 return EIO;
         }

uspace/drv/bus/usb/usbmid/explore.c

@@ -172 +172 @@
                 return false;
         }
-        usb_mid->ctl_fun->ops = &mid_device_ops;
+        ddf_fun_set_ops(usb_mid->ctl_fun, &mid_device_ops);
 
         /* Bind control function. */

uspace/drv/bus/usb/usbmid/main.c

@@ -51 +51 @@
 static int usbmid_device_add(usb_device_t *dev)
 {
-        usb_log_info("Taking care of new MID `%s'.\n", dev->ddf_dev->name);
+        usb_log_info("Taking care of new MID `%s'.\n", ddf_dev_get_name(dev->ddf_dev));
 
         const bool accept = usbmid_explore_device(dev);
@@ -127 +127 @@
         assert(usb_mid);
 
-        usb_log_info("USB MID gone: `%s'.\n", dev->ddf_dev->name);
+        usb_log_info("USB MID gone: `%s'.\n", ddf_dev_get_name(dev->ddf_dev));
 
         /* Remove ctl function */

uspace/drv/bus/usb/usbmid/usbmid.c

@@ -30 +30 @@
  * @{
  */
+
+/* XXX Fix this */
+#define _DDF_DATA_IMPLANT
+
 /**
  * @file
@@ -47 +51 @@
 static int usb_iface_get_interface_impl(ddf_fun_t *fun, int *iface_no)
 {
-        assert(fun);
-
-        usbmid_interface_t *iface = fun->driver_data;
+        usbmid_interface_t *iface = ddf_fun_data_get(fun);
         assert(iface);
 
@@ -123 +125 @@
         }
 
+        match_id_list_t match_ids;
+        init_match_ids(&match_ids);
+
         rc = usb_device_create_match_ids_from_interface(device_descriptor,
-            interface_descriptor, &child->match_ids);
+            interface_descriptor, &match_ids);
         if (rc != EOK) {
                 ddf_fun_destroy(child);
                 return rc;
         }
+
+        list_foreach(match_ids.ids, link) {
+                match_id_t *match_id = list_get_instance(link, match_id_t, link);
+                rc = ddf_fun_add_match_id(child, match_id->id, match_id->score);
+                if (rc != EOK) {
+                        clean_match_ids(&match_ids);
+                        ddf_fun_destroy(child);
+                        return rc;
+                }
+        }
+        clean_match_ids(&match_ids);
 
         rc = ddf_fun_bind(child);
@@ -138 +154 @@
 
         iface->fun = child;
-        child->driver_data = iface;
-        child->ops = &child_device_ops;
+        ddf_fun_data_implant(child, iface);
+        ddf_fun_set_ops(child, &child_device_ops);
 
         return EOK;

uspace/drv/bus/usb/vhc/conndev.c

@@ -94 +94 @@
     ipc_call_t *icall)
 {
-        vhc_data_t *vhc = fun->dev->driver_data;
+        vhc_data_t *vhc = ddf_dev_data_get(ddf_fun_get_dev(fun));
         
         async_sess_t *callback =
@@ -125 +125 @@
 void on_client_close(ddf_fun_t *fun)
 {
-        vhc_data_t *vhc = fun->dev->driver_data;
+        vhc_data_t *vhc = ddf_dev_data_get(ddf_fun_get_dev(fun));
 
         if (plugged_device_handle != 0) {

uspace/drv/bus/usb/vhc/connhost.c

@@ -42 +42 @@
 
 #define GET_VHC_DATA(fun) \
-        ((vhc_data_t *)fun->dev->driver_data)
+        ((vhc_data_t *)ddf_dev_data_get(ddf_fun_get_dev(fun)))
 #define VHC_DATA(vhc, fun) \
         vhc_data_t *vhc = GET_VHC_DATA(fun); assert(vhc->magic == 0xdeadbeef)
@@ -483 +483 @@
         VHC_DATA(vhc, root_hub_fun);
 
-        *handle = vhc->hc_fun->handle;
+        *handle = ddf_fun_get_handle(vhc->hc_fun);
 
         return EOK;
@@ -492 +492 @@
         VHC_DATA(vhc, root_hub_fun);
 
-        devman_handle_t handle = root_hub_fun->handle;
+        devman_handle_t handle = ddf_fun_get_handle(root_hub_fun);
 
         usb_log_debug("tell_address_rh(handle=%" PRIun ")\n", handle);

uspace/drv/bus/usb/vhc/hub.c

@@ -100 +100 @@
         async_sess_t *sess;
         do {
-                sess = devman_device_connect(EXCHANGE_SERIALIZE, hc_dev->handle, 0);
+                sess = devman_device_connect(EXCHANGE_SERIALIZE,
+                    ddf_fun_get_handle(hc_dev), 0);
         } while (!sess);
         async_hangup(sess);
@@ -107 +108 @@
 
         usb_hc_connection_t hc_conn;
-        usb_hc_connection_initialize(&hc_conn, hc_dev->handle);
+        usb_hc_connection_initialize(&hc_conn, ddf_fun_get_handle(hc_dev));
 
         rc = usb_hc_connection_open(&hc_conn);
@@ -113 +114 @@
 
         ddf_fun_t *hub_dev;
-        rc = usb_hc_new_device_wrapper(hc_dev->dev, &hc_conn, USB_SPEED_FULL,
+        rc = usb_hc_new_device_wrapper(ddf_fun_get_dev(hc_dev), &hc_conn, USB_SPEED_FULL,
             pretend_port_rest, NULL, NULL, &rh_ops, hc_dev, &hub_dev);
         if (rc != EOK) {
@@ -123 +124 @@
 
         usb_log_info("Created root hub function (handle %zu).\n",
-            (size_t) hub_dev->handle);
+            (size_t) ddf_fun_get_handle(hub_dev));
 
         return 0;

uspace/drv/bus/usb/vhc/main.c

@@ -67 +67 @@
         }
 
-        vhc_data_t *data = malloc(sizeof(vhc_data_t));
+        vhc_data_t *data = ddf_dev_data_alloc(dev, sizeof(vhc_data_t));
         if (data == NULL) {
                 usb_log_fatal("Failed to allocate memory.\n");
@@ -89 +89 @@
         }
 
-        hc->ops = &vhc_ops;
+        ddf_fun_set_ops(hc, &vhc_ops);
         list_initialize(&data->devices);
         fibril_mutex_initialize(&data->guard);
         data->hub = &virtual_hub_device;
         data->hc_fun = hc;
-
-        dev->driver_data = data;
 
         rc = ddf_fun_bind(hc);
@@ -116 +114 @@
 
         usb_log_info("Virtual USB host controller ready (dev %zu, hc %zu).\n",
-            (size_t) dev->handle, (size_t) hc->handle);
-
-
+            (size_t) ddf_dev_get_handle(dev), (size_t) ddf_fun_get_handle(hc));
 
         rc = vhc_virtdev_plug_hub(data, data->hub, NULL);