Changeset 56fd7cf in mainline for uspace/drv/bus/usb

Timestamp:

2012-08-17T11:37:03Z (13 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

1d5a540

Parents:

be2a38ad

Message:

Make ddf_dev_t and ddf_fun_t opaque. This further tighthens the DDF interface.

Location:

uspace/drv/bus/usb

Files:

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

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);