static int ibmebus_match_path(struct device *dev, void *data)
 {
-       struct device_node *dn = to_of_device(dev)->dev.of_node;
+       struct device_node *dn = to_platform_device(dev)->dev.of_node;
        return (dn->full_name &&
                (strcasecmp((char *)data, dn->full_name) == 0));
 }
 
 static int ibmebus_match_node(struct device *dev, void *data)
 {
-       return to_of_device(dev)->dev.of_node == data;
+       return to_platform_device(dev)->dev.of_node == data;
 }
 
 static int ibmebus_create_device(struct device_node *dn)
 {
-       struct of_device *dev;
+       struct platform_device *dev;
        int ret;
 
        dev = of_device_alloc(dn, NULL, &ibmebus_bus_device);
 
        if ((dev = bus_find_device(&ibmebus_bus_type, NULL, path,
                                   ibmebus_match_path))) {
-               of_device_unregister(to_of_device(dev));
+               of_device_unregister(to_platform_device(dev));
 
                kfree(path);
                return count;
 
 
 static int of_dev_node_match(struct device *dev, void *data)
 {
-       return to_of_device(dev)->dev.of_node == data;
+       return to_platform_device(dev)->dev.of_node == data;
 }
 
-struct of_device *of_find_device_by_node(struct device_node *np)
+struct platform_device *of_find_device_by_node(struct device_node *np)
 {
        struct device *dev;
 
        dev = bus_find_device(&platform_bus_type, NULL, np, of_dev_node_match);
        if (dev)
-               return to_of_device(dev);
+               return to_platform_device(dev);
        return NULL;
 }
 EXPORT_SYMBOL(of_find_device_by_node);
  * lacking some bits needed here.
  */
 
-static int __devinit of_pci_phb_probe(struct of_device *dev,
+static int __devinit of_pci_phb_probe(struct platform_device *dev,
                                      const struct of_device_id *match)
 {
        struct pci_controller *phb;
 
 {
        struct device_node *np;
        const u32 *cell_index;
-       struct of_device *ofdev;
+       struct platform_device *ofdev;
 
        for_each_compatible_node(np, NULL, "fsl,mpc5121-psc") {
                cell_index = of_get_property(np, "cell-index", NULL);
 
        return 0;
 }
 
-static int __devinit mpc52xx_wkup_gpiochip_probe(struct of_device *ofdev,
+static int __devinit mpc52xx_wkup_gpiochip_probe(struct platform_device *ofdev,
                                        const struct of_device_id *match)
 {
        struct mpc52xx_gpiochip *chip;
        return 0;
 }
 
-static int mpc52xx_gpiochip_remove(struct of_device *ofdev)
+static int mpc52xx_gpiochip_remove(struct platform_device *ofdev)
 {
        return -EBUSY;
 }
        return 0;
 }
 
-static int __devinit mpc52xx_simple_gpiochip_probe(struct of_device *ofdev,
+static int __devinit mpc52xx_simple_gpiochip_probe(struct platform_device *ofdev,
                                        const struct of_device_id *match)
 {
        struct mpc52xx_gpiochip *chip;
 
 /* ---------------------------------------------------------------------
  * of_platform bus binding code
  */
-static int __devinit mpc52xx_gpt_probe(struct of_device *ofdev,
+static int __devinit mpc52xx_gpt_probe(struct platform_device *ofdev,
                                       const struct of_device_id *match)
 {
        struct mpc52xx_gpt_priv *gpt;
        return 0;
 }
 
-static int mpc52xx_gpt_remove(struct of_device *ofdev)
+static int mpc52xx_gpt_remove(struct platform_device *ofdev)
 {
        return -EBUSY;
 }
 
 }
 EXPORT_SYMBOL(mpc52xx_lpbfifo_abort);
 
-static int __devinit
-mpc52xx_lpbfifo_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit mpc52xx_lpbfifo_probe(struct platform_device *op,
+                                          const struct of_device_id *match)
 {
        struct resource res;
        int rc = -ENOMEM;
 }
 
 
-static int __devexit mpc52xx_lpbfifo_remove(struct of_device *op)
+static int __devexit mpc52xx_lpbfifo_remove(struct platform_device *op)
 {
        if (lpbfifo.dev != &op->dev)
                return 0;
 
        .ops = &ep8248e_mdio_ops,
 };
 
-static int __devinit ep8248e_mdio_probe(struct of_device *ofdev,
+static int __devinit ep8248e_mdio_probe(struct platform_device *ofdev,
                                         const struct of_device_id *match)
 {
        struct mii_bus *bus;
        return ret;
 }
 
-static int ep8248e_mdio_remove(struct of_device *ofdev)
+static int ep8248e_mdio_remove(struct platform_device *ofdev)
 {
        BUG();
        return 0;
 
        int has_deep_sleep;
 };
 
-static struct of_device *pmc_dev;
+static struct platform_device *pmc_dev;
 static int has_deep_sleep, deep_sleeping;
 static int pmc_irq;
 static struct mpc83xx_pmc __iomem *pmc_regs;
        .end = mpc83xx_suspend_end,
 };
 
-static int pmc_probe(struct of_device *ofdev,
+static int pmc_probe(struct platform_device *ofdev,
                      const struct of_device_id *match)
 {
        struct device_node *np = ofdev->dev.of_node;
        return ret;
 }
 
-static int pmc_remove(struct of_device *ofdev)
+static int pmc_remove(struct platform_device *ofdev)
 {
        return -EPERM;
 };
 
        .map    = msic_host_map,
 };
 
-static int axon_msi_shutdown(struct of_device *device)
+static int axon_msi_shutdown(struct platform_device *device)
 {
        struct axon_msic *msic = dev_get_drvdata(&device->dev);
        u32 tmp;
        return 0;
 }
 
-static int axon_msi_probe(struct of_device *device,
+static int axon_msi_probe(struct platform_device *device,
                          const struct of_device_id *device_id)
 {
        struct device_node *dn = device->dev.of_node;
 
 }
 
 
-static int __devinit gpio_mdio_probe(struct of_device *ofdev,
+static int __devinit gpio_mdio_probe(struct platform_device *ofdev,
                                     const struct of_device_id *match)
 {
        struct device *dev = &ofdev->dev;
 }
 
 
-static int gpio_mdio_remove(struct of_device *dev)
+static int gpio_mdio_remove(struct platform_device *dev)
 {
        struct mii_bus *bus = dev_get_drvdata(&dev->dev);
 
 
 static int azfs_major, azfs_minor;
 
 struct axon_ram_bank {
-       struct of_device        *device;
+       struct platform_device  *device;
        struct gendisk          *disk;
        unsigned int            irq_id;
        unsigned long           ph_addr;
 static ssize_t
 axon_ram_sysfs_ecc(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       struct of_device *device = to_of_device(dev);
+       struct platform_device *device = to_platform_device(dev);
        struct axon_ram_bank *bank = device->dev.platform_data;
 
        BUG_ON(!bank);
 static irqreturn_t
 axon_ram_irq_handler(int irq, void *dev)
 {
-       struct of_device *device = dev;
+       struct platform_device *device = dev;
        struct axon_ram_bank *bank = device->dev.platform_data;
 
        BUG_ON(!bank);
  * axon_ram_probe - probe() method for platform driver
  * @device, @device_id: see of_platform_driver method
  */
-static int
-axon_ram_probe(struct of_device *device, const struct of_device_id *device_id)
+static int axon_ram_probe(struct platform_device *device,
+                         const struct of_device_id *device_id)
 {
        static int axon_ram_bank_id = -1;
        struct axon_ram_bank *bank;
  * @device: see of_platform_driver method
  */
 static int
-axon_ram_remove(struct of_device *device)
+axon_ram_remove(struct platform_device *device)
 {
        struct axon_ram_bank *bank = device->dev.platform_data;
 
 
 /* OF platform driver                                                       */
 /* ======================================================================== */
 
-static int __devinit
-mpc52xx_bcom_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit mpc52xx_bcom_probe(struct platform_device *op,
+                                       const struct of_device_id *match)
 {
        struct device_node *ofn_sram;
        struct resource res_bcom;
 }
 
 
-static int
-mpc52xx_bcom_remove(struct of_device *op)
+static int mpc52xx_bcom_remove(struct platform_device *op)
 {
        /* Clean up the engine */
        bcom_engine_cleanup();
 
        raw_spin_unlock(&desc->lock);
 }
 
-static int fsl_of_msi_remove(struct of_device *ofdev)
+static int fsl_of_msi_remove(struct platform_device *ofdev)
 {
        struct fsl_msi *msi = ofdev->dev.platform_data;
        int virq, i;
        return 0;
 }
 
-static int __devinit fsl_of_msi_probe(struct of_device *dev,
+static int __devinit fsl_of_msi_probe(struct platform_device *dev,
                                const struct of_device_id *match)
 {
        struct fsl_msi *msi;
 
        .enter = pmc_suspend_enter,
 };
 
-static int pmc_probe(struct of_device *ofdev, const struct of_device_id *id)
+static int pmc_probe(struct platform_device *ofdev,
+                    const struct of_device_id *id)
 {
        pmc_regs = of_iomap(ofdev->dev.of_node, 0);
        if (!pmc_regs)
 
  * master port with system-specific info, and registers the
  * master port with the RapidIO subsystem.
  */
-int fsl_rio_setup(struct of_device *dev)
+int fsl_rio_setup(struct platform_device *dev)
 {
        struct rio_ops *ops;
        struct rio_mport *port;
 
 /* The probe function for RapidIO peer-to-peer network.
  */
-static int __devinit fsl_of_rio_rpn_probe(struct of_device *dev,
+static int __devinit fsl_of_rio_rpn_probe(struct platform_device *dev,
                                     const struct of_device_id *match)
 {
        int rc;
 
        struct mutex            msg_mutex;
        pmi_message_t           msg;
        struct completion       *completion;
-       struct of_device        *dev;
+       struct platform_device  *dev;
        int                     irq;
        u8 __iomem              *pmi_reg;
        struct work_struct      work;
        spin_unlock(&data->handler_spinlock);
 }
 
-static int pmi_of_probe(struct of_device *dev,
+static int pmi_of_probe(struct platform_device *dev,
                        const struct of_device_id *match)
 {
        struct device_node *np = dev->dev.of_node;
        return rc;
 }
 
-static int pmi_of_remove(struct of_device *dev)
+static int pmi_of_remove(struct platform_device *dev)
 {
        struct pmi_handler *handler, *tmp;
 
 
 EXPORT_SYMBOL(qe_get_num_of_snums);
 
 #if defined(CONFIG_SUSPEND) && defined(CONFIG_PPC_85xx)
-static int qe_resume(struct of_device *ofdev)
+static int qe_resume(struct platform_device *ofdev)
 {
        if (!qe_alive_during_sleep())
                qe_reset();
        return 0;
 }
 
-static int qe_probe(struct of_device *ofdev, const struct of_device_id *id)
+static int qe_probe(struct platform_device *ofdev,
+                   const struct of_device_id *id)
 {
        return 0;
 }