pdevinfo.id = -1;
        pdevinfo.res = resources;
        pdevinfo.num_res = count;
-       pdevinfo.acpi_node.companion = adev;
+       pdevinfo.fwnode = acpi_fwnode_handle(adev);
        pdevinfo.dma_mask = DMA_BIT_MASK(32);
        pdev = platform_device_register_full(&pdevinfo);
        if (IS_ERR(pdev))
 
        memset(&pdevinfo, 0, sizeof(pdevinfo));
        pdevinfo.name = "dock";
        pdevinfo.id = dock_station_count;
-       pdevinfo.acpi_node.companion = adev;
+       pdevinfo.fwnode = acpi_fwnode_handle(adev);
        pdevinfo.data = &ds;
        pdevinfo.size_data = sizeof(ds);
        dd = platform_device_register_full(&pdevinfo);
 
                goto err_alloc;
 
        pdev->dev.parent = pdevinfo->parent;
-       ACPI_COMPANION_SET(&pdev->dev, pdevinfo->acpi_node.companion);
+       pdev->dev.fwnode = pdevinfo->fwnode;
 
        if (pdevinfo->dma_mask) {
                /*
 
 
 enum of_gpio_flags;
 
+struct acpi_device;
+
 /**
  * struct acpi_gpio_info - ACPI GPIO specific information
  * @gpioint: if %true this GPIO is of type GpioInt otherwise type is GpioIo
 
                return AE_OK;
 
        memset(&info, 0, sizeof(info));
-       info.acpi_node.companion = adev;
+       info.fwnode = acpi_fwnode_handle(adev);
        info.irq = -1;
 
        INIT_LIST_HEAD(&resource_list);
        client->dev.bus = &i2c_bus_type;
        client->dev.type = &i2c_client_type;
        client->dev.of_node = info->of_node;
-       ACPI_COMPANION_SET(&client->dev, info->acpi_node.companion);
+       client->dev.fwnode = info->fwnode;
 
        i2c_dev_set_name(adap, client);
        status = device_register(&client->dev);
 
 
 static inline struct acpi_device *acpi_node(struct fwnode_handle *fwnode)
 {
-       return fwnode ? container_of(fwnode, struct acpi_device, fwnode) : NULL;
+       return is_acpi_node(fwnode) ?
+               container_of(fwnode, struct acpi_device, fwnode) : NULL;
 }
 
 static inline struct fwnode_handle *acpi_fwnode_handle(struct acpi_device *adev)
 
        return adev ? adev->handle : NULL;
 }
 
-#define ACPI_COMPANION(dev)            ((dev)->acpi_node.companion)
-#define ACPI_COMPANION_SET(dev, adev)  ACPI_COMPANION(dev) = (adev)
+#define ACPI_COMPANION(dev)            acpi_node((dev)->fwnode)
+#define ACPI_COMPANION_SET(dev, adev)  (dev)->fwnode = (adev) ? \
+       acpi_fwnode_handle(adev) : NULL
 #define ACPI_HANDLE(dev)               acpi_device_handle(ACPI_COMPANION(dev))
 
 static inline void acpi_preset_companion(struct device *dev,
 
 struct subsys_private;
 struct bus_type;
 struct device_node;
+struct fwnode_handle;
 struct iommu_ops;
 struct iommu_group;
 
        unsigned long segment_boundary_mask;
 };
 
-struct acpi_device;
-
-struct acpi_dev_node {
-#ifdef CONFIG_ACPI
-       struct acpi_device *companion;
-#endif
-};
-
 /**
  * struct device - The basic device structure
  * @parent:    The device's "parent" device, the device to which it is attached.
  * @cma_area:  Contiguous memory area for dma allocations
  * @archdata:  For arch-specific additions.
  * @of_node:   Associated device tree node.
- * @acpi_node: Associated ACPI device node.
+ * @fwnode:    Associated device node supplied by platform firmware.
  * @devt:      For creating the sysfs "dev".
  * @id:                device instance
  * @devres_lock: Spinlock to protect the resource of the device.
        struct dev_archdata     archdata;
 
        struct device_node      *of_node; /* associated device tree node */
-       struct acpi_dev_node    acpi_node; /* associated ACPI device node */
+       struct fwnode_handle    *fwnode; /* firmware device node */
 
        dev_t                   devt;   /* dev_t, creates the sysfs "dev" */
        u32                     id;     /* device instance */
 
--- /dev/null
+/*
+ * fwnode.h - Firmware device node object handle type definition.
+ *
+ * Copyright (C) 2015, Intel Corporation
+ * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef _LINUX_FWNODE_H_
+#define _LINUX_FWNODE_H_
+
+enum fwnode_type {
+       FWNODE_INVALID = 0,
+       FWNODE_OF,
+       FWNODE_ACPI,
+};
+
+struct fwnode_handle {
+       enum fwnode_type type;
+};
+
+#endif
 
  * @platform_data: stored in i2c_client.dev.platform_data
  * @archdata: copied into i2c_client.dev.archdata
  * @of_node: pointer to OpenFirmware device node
- * @acpi_node: ACPI device node
+ * @fwnode: device node supplied by the platform firmware
  * @irq: stored in i2c_client.irq
  *
  * I2C doesn't actually support hardware probing, although controllers and
        void            *platform_data;
        struct dev_archdata     *archdata;
        struct device_node *of_node;
-       struct acpi_dev_node acpi_node;
+       struct fwnode_handle *fwnode;
        int             irq;
 };
 
 
 
 struct platform_device_info {
                struct device *parent;
-               struct acpi_dev_node acpi_node;
+               struct fwnode_handle *fwnode;
 
                const char *name;
                int id;
 
 #ifndef _LINUX_PROPERTY_H_
 #define _LINUX_PROPERTY_H_
 
+#include <linux/fwnode.h>
 #include <linux/types.h>
 
 struct device;
 int device_property_read_string(struct device *dev, const char *propname,
                                const char **val);
 
-enum fwnode_type {
-       FWNODE_INVALID = 0,
-       FWNODE_OF,
-       FWNODE_ACPI,
-};
-
-struct fwnode_handle {
-       enum fwnode_type type;
-};
-
 bool fwnode_property_present(struct fwnode_handle *fwnode, const char *propname);
 int fwnode_property_read_u8_array(struct fwnode_handle *fwnode,
                                  const char *propname, u8 *val,