Merge branch 'next-devicetree' of git://git.secretlab.ca/git/linux-2.6

* 'next-devicetree' of git://git.secretlab.ca/git/linux-2.6: (63 commits)
  of/platform: Register of_platform_drivers with an "of:" prefix
  of/address: Clean up function declarations
  of/spi: call of_register_spi_devices() from spi core code
  of: Provide default of_node_to_nid() implementation.
  of/device: Make of_device_make_bus_id() usable by other code.
  of/irq: Fix endian issues in parsing interrupt specifiers
  of: Fix phandle endian issues
  of/flattree: fix of_flat_dt_is_compatible() to match the full compatible string
  of: remove of_default_bus_ids
  of: make of_find_device_by_node generic
  microblaze: remove references to of_device and to_of_device
  sparc: remove references to of_device and to_of_device
  powerpc: remove references to of_device and to_of_device
  of/device: Replace of_device with platform_device in includes and core code
  of/device: Protect against binding of_platform_drivers to non-OF devices
  of: remove asm/of_device.h
  of: remove asm/of_platform.h
  of/platform: remove all of_bus_type and of_platform_bus_type references
  of: Merge of_platform_bus_type with platform_bus_type
  drivercore/of: Add OF style matching to platform bus
  ...

Fix up trivial conflicts in arch/microblaze/kernel/Makefile due to just
some obj-y removals by the devicetree branch, while the microblaze
updates added a new file.

74 files changed, 1780 insertions, 343 deletions

diff --git a/drivers/atm/fore200e.c b/drivers/atm/fore200e.c
index da8f176c051e..b7385e077717 100644
--- a/drivers/atm/fore200e.c
+++ b/drivers/atm/fore200e.c
@@ -2657,7 +2657,7 @@ static int __devinit fore200e_sba_probe(struct of_device *op,
 
         fore200e->bus = bus;
         fore200e->bus_dev = op;
-        fore200e->irq = op->irqs[0];
+        fore200e->irq = op->archdata.irqs[0];
         fore200e->phys_base = op->resource[0].start;
 
         sprintf(fore200e->name, "%s-%d", bus->model_name, index);
@@ -2795,7 +2795,7 @@ static int __init fore200e_module_init(void)
         printk(FORE200E "FORE Systems 200E-series ATM driver - version " FORE200E_VERSION "\n");
 
 #ifdef CONFIG_SBUS
-        err = of_register_driver(&fore200e_sba_driver, &of_bus_type);
+        err = of_register_platform_driver(&fore200e_sba_driver);
         if (err)
                 return err;
 #endif
@@ -2806,7 +2806,7 @@ static int __init fore200e_module_init(void)
 
 #ifdef CONFIG_SBUS
         if (err)
-                of_unregister_driver(&fore200e_sba_driver);
+                of_unregister_platform_driver(&fore200e_sba_driver);
 #endif
 
         return err;
@@ -2818,7 +2818,7 @@ static void __exit fore200e_module_cleanup(void)
         pci_unregister_driver(&fore200e_pca_driver);
 #endif
 #ifdef CONFIG_SBUS
-        of_unregister_driver(&fore200e_sba_driver);
+        of_unregister_platform_driver(&fore200e_sba_driver);
 #endif
 }
 
diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index 4d99c8bdfedc..f699fabf403b 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -12,6 +12,7 @@
 
 #include <linux/string.h>
 #include <linux/platform_device.h>
+#include <linux/of_device.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/dma-mapping.h>
@@ -635,6 +636,12 @@ static struct device_attribute platform_dev_attrs[] = {
 static int platform_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct platform_device  *pdev = to_platform_device(dev);
+        int rc;
+
+        /* Some devices have extra OF data and an OF-style MODALIAS */
+        rc = of_device_uevent(dev,env);
+        if (rc != -ENODEV)
+                return rc;
 
         add_uevent_var(env, "MODALIAS=%s%s", PLATFORM_MODULE_PREFIX,
                 (pdev->id_entry) ? pdev->id_entry->name : pdev->name);
@@ -673,7 +680,11 @@ static int platform_match(struct device *dev, struct device_driver *drv)
         struct platform_device *pdev = to_platform_device(dev);
         struct platform_driver *pdrv = to_platform_driver(drv);
 
-        /* match against the id table first */
+        /* Attempt an OF style match first */
+        if (of_driver_match_device(dev, drv))
+                return 1;
+
+        /* Then try to match against the id table */
         if (pdrv->id_table)
                 return platform_match_id(pdrv->id_table, pdev) != NULL;
 
diff --git a/drivers/char/bsr.c b/drivers/char/bsr.c
index 89d871ef8c2f..91917133ae0a 100644
--- a/drivers/char/bsr.c
+++ b/drivers/char/bsr.c
@@ -23,6 +23,7 @@
 #include <linux/of.h>
 #include <linux/of_device.h>
 #include <linux/of_platform.h>
+#include <linux/fs.h>
 #include <linux/module.h>
 #include <linux/cdev.h>
 #include <linux/list.h>
diff --git a/drivers/char/hw_random/n2-drv.c b/drivers/char/hw_random/n2-drv.c
index 101d5f235547..7a4f080f8356 100644
--- a/drivers/char/hw_random/n2-drv.c
+++ b/drivers/char/hw_random/n2-drv.c
@@ -762,12 +762,12 @@ static struct of_platform_driver n2rng_driver = {
 
 static int __init n2rng_init(void)
 {
-        return of_register_driver(&n2rng_driver, &of_bus_type);
+        return of_register_platform_driver(&n2rng_driver);
 }
 
 static void __exit n2rng_exit(void)
 {
-        of_unregister_driver(&n2rng_driver);
+        of_unregister_platform_driver(&n2rng_driver);
 }
 
 module_init(n2rng_init);
diff --git a/drivers/crypto/n2_core.c b/drivers/crypto/n2_core.c
index b99c38f23d61..26af2dd5d831 100644
--- a/drivers/crypto/n2_core.c
+++ b/drivers/crypto/n2_core.c
@@ -2247,20 +2247,20 @@ static struct of_platform_driver n2_mau_driver = {
 
 static int __init n2_init(void)
 {
-        int err = of_register_driver(&n2_crypto_driver, &of_bus_type);
+        int err = of_register_platform_driver(&n2_crypto_driver);
 
         if (!err) {
-                err = of_register_driver(&n2_mau_driver, &of_bus_type);
+                err = of_register_platform_driver(&n2_mau_driver);
                 if (err)
-                        of_unregister_driver(&n2_crypto_driver);
+                        of_unregister_platform_driver(&n2_crypto_driver);
         }
         return err;
 }
 
 static void __exit n2_exit(void)
 {
-        of_unregister_driver(&n2_mau_driver);
-        of_unregister_driver(&n2_crypto_driver);
+        of_unregister_platform_driver(&n2_mau_driver);
+        of_unregister_platform_driver(&n2_crypto_driver);
 }
 
 module_init(n2_init);
diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
index 4e51fe3c1fc4..6a6bd569e1f8 100644
--- a/drivers/gpio/gpiolib.c
+++ b/drivers/gpio/gpiolib.c
@@ -8,6 +8,7 @@
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
 #include <linux/gpio.h>
+#include <linux/of_gpio.h>
 #include <linux/idr.h>
 #include <linux/slab.h>
 
@@ -1100,16 +1101,24 @@ int gpiochip_add(struct gpio_chip *chip)
                 }
         }
 
+        of_gpiochip_add(chip);
+
 unlock:
         spin_unlock_irqrestore(&gpio_lock, flags);
-        if (status == 0)
-                status = gpiochip_export(chip);
+
+        if (status)
+                goto fail;
+
+        status = gpiochip_export(chip);
+        if (status)
+                goto fail;
+
+        return 0;
 fail:
         /* failures here can mean systems won't boot... */
-        if (status)
-                pr_err("gpiochip_add: gpios %d..%d (%s) failed to register\n",
-                        chip->base, chip->base + chip->ngpio - 1,
-                        chip->label ? : "generic");
+        pr_err("gpiochip_add: gpios %d..%d (%s) failed to register\n",
+                chip->base, chip->base + chip->ngpio - 1,
+                chip->label ? : "generic");
         return status;
 }
 EXPORT_SYMBOL_GPL(gpiochip_add);
@@ -1128,6 +1137,8 @@ int gpiochip_remove(struct gpio_chip *chip)
 
         spin_lock_irqsave(&gpio_lock, flags);
 
+        of_gpiochip_remove(chip);
+
         for (id = chip->base; id < chip->base + chip->ngpio; id++) {
                 if (test_bit(FLAG_REQUESTED, &gpio_desc[id].flags)) {
                         status = -EBUSY;
@@ -1148,6 +1159,38 @@ int gpiochip_remove(struct gpio_chip *chip)
 }
 EXPORT_SYMBOL_GPL(gpiochip_remove);
 
+/**
+ * gpiochip_find() - iterator for locating a specific gpio_chip
+ * @data: data to pass to match function
+ * @callback: Callback function to check gpio_chip
+ *
+ * Similar to bus_find_device.  It returns a reference to a gpio_chip as
+ * determined by a user supplied @match callback.  The callback should return
+ * 0 if the device doesn't match and non-zero if it does.  If the callback is
+ * non-zero, this function will return to the caller and not iterate over any
+ * more gpio_chips.
+ */
+struct gpio_chip *gpiochip_find(void *data,
+                                int (*match)(struct gpio_chip *chip, void *data))
+{
+        struct gpio_chip *chip = NULL;
+        unsigned long flags;
+        int i;
+
+        spin_lock_irqsave(&gpio_lock, flags);
+        for (i = 0; i < ARCH_NR_GPIOS; i++) {
+                if (!gpio_desc[i].chip)
+                        continue;
+
+                if (match(gpio_desc[i].chip, data)) {
+                        chip = gpio_desc[i].chip;
+                        break;
+                }
+        }
+        spin_unlock_irqrestore(&gpio_lock, flags);
+
+        return chip;
+}
 
 /* These "optional" allocation calls help prevent drivers from stomping
  * on each other, and help provide better diagnostics in debugfs.
diff --git a/drivers/gpio/xilinx_gpio.c b/drivers/gpio/xilinx_gpio.c
index b8fa65b5bfca..709690995d0d 100644
--- a/drivers/gpio/xilinx_gpio.c
+++ b/drivers/gpio/xilinx_gpio.c
@@ -161,14 +161,12 @@ static void xgpio_save_regs(struct of_mm_gpio_chip *mm_gc)
 static int __devinit xgpio_of_probe(struct device_node *np)
 {
         struct xgpio_instance *chip;
-        struct of_gpio_chip *ofchip;
         int status = 0;
         const u32 *tree_info;
 
         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
         if (!chip)
                 return -ENOMEM;
-        ofchip = &chip->mmchip.of_gc;
 
         /* Update GPIO state shadow register with default value */
         tree_info = of_get_property(np, "xlnx,dout-default", NULL);
@@ -182,21 +180,20 @@ static int __devinit xgpio_of_probe(struct device_node *np)
                 chip->gpio_dir = *tree_info;
 
         /* Check device node and parent device node for device width */
-        ofchip->gc.ngpio = 32; /* By default assume full GPIO controller */
+        chip->mmchip.gc.ngpio = 32; /* By default assume full GPIO controller */
         tree_info = of_get_property(np, "xlnx,gpio-width", NULL);
         if (!tree_info)
                 tree_info = of_get_property(np->parent,
                                             "xlnx,gpio-width", NULL);
         if (tree_info)
-                ofchip->gc.ngpio = *tree_info;
+                chip->mmchip.gc.ngpio = *tree_info;
 
         spin_lock_init(&chip->gpio_lock);
 
-        ofchip->gpio_cells = 2;
-        ofchip->gc.direction_input = xgpio_dir_in;
-        ofchip->gc.direction_output = xgpio_dir_out;
-        ofchip->gc.get = xgpio_get;
-        ofchip->gc.set = xgpio_set;
+        chip->mmchip.gc.direction_input = xgpio_dir_in;
+        chip->mmchip.gc.direction_output = xgpio_dir_out;
+        chip->mmchip.gc.get = xgpio_get;
+        chip->mmchip.gc.set = xgpio_set;
 
         chip->mmchip.save_regs = xgpio_save_regs;
 
diff --git a/drivers/hwmon/ultra45_env.c b/drivers/hwmon/ultra45_env.c
index 5da5942cf970..89643261ccdb 100644
--- a/drivers/hwmon/ultra45_env.c
+++ b/drivers/hwmon/ultra45_env.c
@@ -311,12 +311,12 @@ static struct of_platform_driver env_driver = {
 
 static int __init env_init(void)
 {
-        return of_register_driver(&env_driver, &of_bus_type);
+        return of_register_platform_driver(&env_driver);
 }
 
 static void __exit env_exit(void)
 {
-        of_unregister_driver(&env_driver);
+        of_unregister_platform_driver(&env_driver);
 }
 
 module_init(env_init);
diff --git a/drivers/i2c/busses/i2c-cpm.c b/drivers/i2c/busses/i2c-cpm.c
index b02b4533651d..e591de1bc704 100644
--- a/drivers/i2c/busses/i2c-cpm.c
+++ b/drivers/i2c/busses/i2c-cpm.c
@@ -652,6 +652,7 @@ static int __devinit cpm_i2c_probe(struct of_device *ofdev,
         cpm->adap = cpm_ops;
         i2c_set_adapdata(&cpm->adap, cpm);
         cpm->adap.dev.parent = &ofdev->dev;
+        cpm->adap.dev.of_node = of_node_get(ofdev->dev.of_node);
 
         result = cpm_i2c_setup(cpm);
         if (result) {
@@ -676,11 +677,6 @@ static int __devinit cpm_i2c_probe(struct of_device *ofdev,
         dev_dbg(&ofdev->dev, "hw routines for %s registered.\n",
                 cpm->adap.name);
 
-        /*
-         * register OF I2C devices
-         */
-        of_register_i2c_devices(&cpm->adap, ofdev->dev.of_node);
-
         return 0;
 out_shut:
         cpm_i2c_shutdown(cpm);
diff --git a/drivers/i2c/busses/i2c-ibm_iic.c b/drivers/i2c/busses/i2c-ibm_iic.c
index bf344135647a..1168d61418c9 100644
--- a/drivers/i2c/busses/i2c-ibm_iic.c
+++ b/drivers/i2c/busses/i2c-ibm_iic.c
@@ -745,6 +745,7 @@ static int __devinit iic_probe(struct of_device *ofdev,
         /* Register it with i2c layer */
         adap = &dev->adap;
         adap->dev.parent = &ofdev->dev;
+        adap->dev.of_node = of_node_get(np);
         strlcpy(adap->name, "IBM IIC", sizeof(adap->name));
         i2c_set_adapdata(adap, dev);
         adap->class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
@@ -760,9 +761,6 @@ static int __devinit iic_probe(struct of_device *ofdev,
         dev_info(&ofdev->dev, "using %s mode\n",
                  dev->fast_mode ? "fast (400 kHz)" : "standard (100 kHz)");
 
-        /* Now register all the child nodes */
-        of_register_i2c_devices(adap, np);
-
         return 0;
 
 error_cleanup:
diff --git a/drivers/i2c/busses/i2c-mpc.c b/drivers/i2c/busses/i2c-mpc.c
index 54247d475fc3..6545d1c99b61 100644
--- a/drivers/i2c/busses/i2c-mpc.c
+++ b/drivers/i2c/busses/i2c-mpc.c
@@ -625,13 +625,13 @@ static int __devinit fsl_i2c_probe(struct of_device *op,
         i2c->adap = mpc_ops;
         i2c_set_adapdata(&i2c->adap, i2c);
         i2c->adap.dev.parent = &op->dev;
+        i2c->adap.dev.of_node = of_node_get(op->dev.of_node);
 
         result = i2c_add_adapter(&i2c->adap);
         if (result < 0) {
                 dev_err(i2c->dev, "failed to add adapter\n");
                 goto fail_add;
         }
-        of_register_i2c_devices(&i2c->adap, op->dev.of_node);
 
         return result;
 
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index 0815e10da7c6..df937df845eb 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -30,6 +30,8 @@
 #include <linux/init.h>
 #include <linux/idr.h>
 #include <linux/mutex.h>
+#include <linux/of_i2c.h>
+#include <linux/of_device.h>
 #include <linux/completion.h>
 #include <linux/hardirq.h>
 #include <linux/irqflags.h>
@@ -70,6 +72,10 @@ static int i2c_device_match(struct device *dev, struct device_driver *drv)
         if (!client)
                 return 0;
 
+        /* Attempt an OF style match */
+        if (of_driver_match_device(dev, drv))
+                return 1;
+
         driver = to_i2c_driver(drv);
         /* match on an id table if there is one */
         if (driver->id_table)
@@ -790,6 +796,9 @@ static int i2c_register_adapter(struct i2c_adapter *adap)
         if (adap->nr < __i2c_first_dynamic_bus_num)
                 i2c_scan_static_board_info(adap);
 
+        /* Register devices from the device tree */
+        of_i2c_register_devices(adap);
+
         /* Notify drivers */
         mutex_lock(&core_lock);
         dummy = bus_for_each_drv(&i2c_bus_type, NULL, adap,
diff --git a/drivers/input/misc/sparcspkr.c b/drivers/input/misc/sparcspkr.c
index 1dacae4b43f0..f3bb92e9755f 100644
--- a/drivers/input/misc/sparcspkr.c
+++ b/drivers/input/misc/sparcspkr.c
@@ -353,14 +353,12 @@ static struct of_platform_driver grover_beep_driver = {
 
 static int __init sparcspkr_init(void)
 {
-        int err = of_register_driver(&bbc_beep_driver,
-                                     &of_platform_bus_type);
+        int err = of_register_platform_driver(&bbc_beep_driver);
 
         if (!err) {
-                err = of_register_driver(&grover_beep_driver,
-                                         &of_platform_bus_type);
+                err = of_register_platform_driver(&grover_beep_driver);
                 if (err)
-                        of_unregister_driver(&bbc_beep_driver);
+                        of_unregister_platform_driver(&bbc_beep_driver);
         }
 
         return err;
@@ -368,8 +366,8 @@ static int __init sparcspkr_init(void)
 
 static void __exit sparcspkr_exit(void)
 {
-        of_unregister_driver(&bbc_beep_driver);
-        of_unregister_driver(&grover_beep_driver);
+        of_unregister_platform_driver(&bbc_beep_driver);
+        of_unregister_platform_driver(&grover_beep_driver);
 }
 
 module_init(sparcspkr_init);
diff --git a/drivers/input/serio/i8042-sparcio.h b/drivers/input/serio/i8042-sparcio.h
index 04e32f2d1241..cb2a24b94746 100644
--- a/drivers/input/serio/i8042-sparcio.h
+++ b/drivers/input/serio/i8042-sparcio.h
@@ -58,9 +58,9 @@ static int __devinit sparc_i8042_probe(struct of_device *op, const struct of_dev
                 if (!strcmp(dp->name, OBP_PS2KBD_NAME1) ||
                     !strcmp(dp->name, OBP_PS2KBD_NAME2)) {
                         struct of_device *kbd = of_find_device_by_node(dp);
-                        unsigned int irq = kbd->irqs[0];
+                        unsigned int irq = kbd->archdata.irqs[0];
                         if (irq == 0xffffffff)
-                                irq = op->irqs[0];
+                                irq = op->archdata.irqs[0];
                         i8042_kbd_irq = irq;
                         kbd_iobase = of_ioremap(&kbd->resource[0],
                                                 0, 8, "kbd");
@@ -68,9 +68,9 @@ static int __devinit sparc_i8042_probe(struct of_device *op, const struct of_dev
                 } else if (!strcmp(dp->name, OBP_PS2MS_NAME1) ||
                            !strcmp(dp->name, OBP_PS2MS_NAME2)) {
                         struct of_device *ms = of_find_device_by_node(dp);
-                        unsigned int irq = ms->irqs[0];
+                        unsigned int irq = ms->archdata.irqs[0];
                         if (irq == 0xffffffff)
-                                irq = op->irqs[0];
+                                irq = op->archdata.irqs[0];
                         i8042_aux_irq = irq;
                 }
 
@@ -116,8 +116,7 @@ static int __init i8042_platform_init(void)
                 if (!kbd_iobase)
                         return -ENODEV;
         } else {
-                int err = of_register_driver(&sparc_i8042_driver,
-                                             &of_bus_type);
+                int err = of_register_platform_driver(&sparc_i8042_driver);
                 if (err)
                         return err;
 
@@ -141,7 +140,7 @@ static inline void i8042_platform_exit(void)
         struct device_node *root = of_find_node_by_path("/");
 
         if (strcmp(root->name, "SUNW,JavaStation-1"))
-                of_unregister_driver(&sparc_i8042_driver);
+                of_unregister_platform_driver(&sparc_i8042_driver);
 }
 
 #else /* !CONFIG_PCI */
diff --git a/drivers/macintosh/macio_sysfs.c b/drivers/macintosh/macio_sysfs.c
index 6999ce59fd10..6024038a5b9d 100644
--- a/drivers/macintosh/macio_sysfs.c
+++ b/drivers/macintosh/macio_sysfs.c
@@ -41,10 +41,7 @@ compatible_show (struct device *dev, struct device_attribute *attr, char *buf)
 static ssize_t modalias_show (struct device *dev, struct device_attribute *attr,
                               char *buf)
 {
-        struct of_device *ofdev = to_of_device(dev);
-        int len;
-
-        len = of_device_get_modalias(ofdev, buf, PAGE_SIZE - 2);
+        int len = of_device_get_modalias(dev, buf, PAGE_SIZE - 2);
 
         buf[len] = '\n';
         buf[len+1] = 0;
diff --git a/drivers/mmc/host/mmc_spi.c b/drivers/mmc/host/mmc_spi.c
index ad847a24a675..7b0f3ef50f96 100644
--- a/drivers/mmc/host/mmc_spi.c
+++ b/drivers/mmc/host/mmc_spi.c
@@ -1533,12 +1533,20 @@ static int __devexit mmc_spi_remove(struct spi_device *spi)
         return 0;
 }
 
+#if defined(CONFIG_OF)
+static struct of_device_id mmc_spi_of_match_table[] __devinitdata = {
+        { .compatible = "mmc-spi-slot", },
+};
+#endif
 
 static struct spi_driver mmc_spi_driver = {
         .driver = {
                 .name =         "mmc_spi",
                 .bus =          &spi_bus_type,
                 .owner =        THIS_MODULE,
+#if defined(CONFIG_OF)
+                .of_match_table = mmc_spi_of_match_table,
+#endif
         },
         .probe =        mmc_spi_probe,
         .remove =       __devexit_p(mmc_spi_remove),
diff --git a/drivers/mtd/maps/sun_uflash.c b/drivers/mtd/maps/sun_uflash.c
index 0391c2527bd7..8984236a8d0a 100644
--- a/drivers/mtd/maps/sun_uflash.c
+++ b/drivers/mtd/maps/sun_uflash.c
@@ -160,12 +160,12 @@ static struct of_platform_driver uflash_driver = {
 
 static int __init uflash_init(void)
 {
-        return of_register_driver(&uflash_driver, &of_bus_type);
+        return of_register_platform_driver(&uflash_driver);
 }
 
 static void __exit uflash_exit(void)
 {
-        of_unregister_driver(&uflash_driver);
+        of_unregister_platform_driver(&uflash_driver);
 }
 
 module_init(uflash_init);
diff --git a/drivers/net/fsl_pq_mdio.c b/drivers/net/fsl_pq_mdio.c
index b4c41d72c423..f53f850b6418 100644
--- a/drivers/net/fsl_pq_mdio.c
+++ b/drivers/net/fsl_pq_mdio.c
@@ -35,6 +35,7 @@
 #include <linux/mii.h>
 #include <linux/phy.h>
 #include <linux/of.h>
+#include <linux/of_address.h>
 #include <linux/of_mdio.h>
 #include <linux/of_platform.h>
 
diff --git a/drivers/net/ibm_newemac/core.c b/drivers/net/ibm_newemac/core.c
index 0f1d4e96cf89..eeec7bc2ce74 100644
--- a/drivers/net/ibm_newemac/core.c
+++ b/drivers/net/ibm_newemac/core.c
@@ -2339,11 +2339,11 @@ static int __devinit emac_wait_deps(struct emac_instance *dev)
                 deps[EMAC_DEP_MDIO_IDX].phandle = dev->mdio_ph;
         if (dev->blist && dev->blist > emac_boot_list)
                 deps[EMAC_DEP_PREV_IDX].phandle = 0xffffffffu;
-        bus_register_notifier(&of_platform_bus_type, &emac_of_bus_notifier);
+        bus_register_notifier(&platform_bus_type, &emac_of_bus_notifier);
         wait_event_timeout(emac_probe_wait,
                            emac_check_deps(dev, deps),
                            EMAC_PROBE_DEP_TIMEOUT);
-        bus_unregister_notifier(&of_platform_bus_type, &emac_of_bus_notifier);
+        bus_unregister_notifier(&platform_bus_type, &emac_of_bus_notifier);
         err = emac_check_deps(dev, deps) ? 0 : -ENODEV;
         for (i = 0; i < EMAC_DEP_COUNT; i++) {
                 if (deps[i].node)
diff --git a/drivers/net/myri_sbus.c b/drivers/net/myri_sbus.c
index 1a57c3da1f49..04e552aa14ec 100644
--- a/drivers/net/myri_sbus.c
+++ b/drivers/net/myri_sbus.c
@@ -1079,7 +1079,7 @@ static int __devinit myri_sbus_probe(struct of_device *op, const struct of_devic
 
         mp->dev = dev;
         dev->watchdog_timeo = 5*HZ;
-        dev->irq = op->irqs[0];
+        dev->irq = op->archdata.irqs[0];
         dev->netdev_ops = &myri_ops;
 
         /* Register interrupt handler now. */
@@ -1172,12 +1172,12 @@ static struct of_platform_driver myri_sbus_driver = {
 
 static int __init myri_sbus_init(void)
 {
-        return of_register_driver(&myri_sbus_driver, &of_bus_type);
+        return of_register_platform_driver(&myri_sbus_driver);
 }
 
 static void __exit myri_sbus_exit(void)
 {
-        of_unregister_driver(&myri_sbus_driver);
+        of_unregister_platform_driver(&myri_sbus_driver);
 }
 
 module_init(myri_sbus_init);
diff --git a/drivers/net/niu.c b/drivers/net/niu.c
index b9b950845b0e..404f2d552888 100644
--- a/drivers/net/niu.c
+++ b/drivers/net/niu.c
@@ -28,10 +28,7 @@
 #include <linux/slab.h>
 
 #include <linux/io.h>
-
-#ifdef CONFIG_SPARC64
 #include <linux/of_device.h>
-#endif
 
 #include "niu.h"
 
@@ -9114,12 +9111,12 @@ static int __devinit niu_n2_irq_init(struct niu *np, u8 *ldg_num_map)
         if (!int_prop)
                 return -ENODEV;
 
-        for (i = 0; i < op->num_irqs; i++) {
+        for (i = 0; i < op->archdata.num_irqs; i++) {
                 ldg_num_map[i] = int_prop[i];
-                np->ldg[i].irq = op->irqs[i];
+                np->ldg[i].irq = op->archdata.irqs[i];
         }
 
-        np->num_ldg = op->num_irqs;
+        np->num_ldg = op->archdata.num_irqs;
 
         return 0;
 #else
@@ -10249,14 +10246,14 @@ static int __init niu_init(void)
         niu_debug = netif_msg_init(debug, NIU_MSG_DEFAULT);
 
 #ifdef CONFIG_SPARC64
-        err = of_register_driver(&niu_of_driver, &of_bus_type);
+        err = of_register_platform_driver(&niu_of_driver);
 #endif
 
         if (!err) {
                 err = pci_register_driver(&niu_pci_driver);
 #ifdef CONFIG_SPARC64
                 if (err)
-                        of_unregister_driver(&niu_of_driver);
+                        of_unregister_platform_driver(&niu_of_driver);
 #endif
         }
 
@@ -10267,7 +10264,7 @@ static void __exit niu_exit(void)
 {
         pci_unregister_driver(&niu_pci_driver);
 #ifdef CONFIG_SPARC64
-        of_unregister_driver(&niu_of_driver);
+        of_unregister_platform_driver(&niu_of_driver);
 #endif
 }
 
diff --git a/drivers/net/niu.h b/drivers/net/niu.h
index d6715465f35d..a41fa8ebe05f 100644
--- a/drivers/net/niu.h
+++ b/drivers/net/niu.h
@@ -3236,7 +3236,7 @@ struct niu_phy_ops {
         int (*link_status)(struct niu *np, int *);
 };
 
-struct of_device;
+struct platform_device;
 struct niu {
         void __iomem                    *regs;
         struct net_device               *dev;
@@ -3297,7 +3297,7 @@ struct niu {
         struct niu_vpd                  vpd;
         u32                             eeprom_len;
 
-        struct of_device                *op;
+        struct platform_device          *op;
         void __iomem                    *vir_regs_1;
         void __iomem                    *vir_regs_2;
 };
diff --git a/drivers/net/sunbmac.c b/drivers/net/sunbmac.c
index 367e96f317d4..09c071bd6ad4 100644
--- a/drivers/net/sunbmac.c
+++ b/drivers/net/sunbmac.c
@@ -1201,7 +1201,7 @@ static int __devinit bigmac_ether_init(struct of_device *op,
         dev->watchdog_timeo = 5*HZ;
 
         /* Finish net device registration. */
-        dev->irq = bp->bigmac_op->irqs[0];
+        dev->irq = bp->bigmac_op->archdata.irqs[0];
         dev->dma = 0;
 
         if (register_netdev(dev)) {
@@ -1301,12 +1301,12 @@ static struct of_platform_driver bigmac_sbus_driver = {
 
 static int __init bigmac_init(void)
 {
-        return of_register_driver(&bigmac_sbus_driver, &of_bus_type);
+        return of_register_platform_driver(&bigmac_sbus_driver);
 }
 
 static void __exit bigmac_exit(void)
 {
-        of_unregister_driver(&bigmac_sbus_driver);
+        of_unregister_platform_driver(&bigmac_sbus_driver);
 }
 
 module_init(bigmac_init);
diff --git a/drivers/net/sunhme.c b/drivers/net/sunhme.c
index 3d9650b8d38f..eec443f64079 100644
--- a/drivers/net/sunhme.c
+++ b/drivers/net/sunhme.c
@@ -2561,7 +2561,7 @@ static int __init quattro_sbus_register_irqs(void)
                 if (skip)
                         continue;
 
-                err = request_irq(op->irqs[0],
+                err = request_irq(op->archdata.irqs[0],
                                   quattro_sbus_interrupt,
                                   IRQF_SHARED, "Quattro",
                                   qp);
@@ -2590,7 +2590,7 @@ static void quattro_sbus_free_irqs(void)
                 if (skip)
                         continue;
 
-                free_irq(op->irqs[0], qp);
+                free_irq(op->archdata.irqs[0], qp);
         }
 }
 #endif /* CONFIG_SBUS */
@@ -2790,7 +2790,7 @@ static int __devinit happy_meal_sbus_probe_one(struct of_device *op, int is_qfe)
         /* Happy Meal can do it all... */
         dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;
 
-        dev->irq = op->irqs[0];
+        dev->irq = op->archdata.irqs[0];
 
 #if defined(CONFIG_SBUS) && defined(CONFIG_PCI)
         /* Hook up SBUS register/descriptor accessors. */
@@ -3304,7 +3304,7 @@ static int __init happy_meal_sbus_init(void)
 {
         int err;
 
-        err = of_register_driver(&hme_sbus_driver, &of_bus_type);
+        err = of_register_platform_driver(&hme_sbus_driver);
         if (!err)
                 err = quattro_sbus_register_irqs();
 
@@ -3313,7 +3313,7 @@ static int __init happy_meal_sbus_init(void)
 
 static void happy_meal_sbus_exit(void)
 {
-        of_unregister_driver(&hme_sbus_driver);
+        of_unregister_platform_driver(&hme_sbus_driver);
         quattro_sbus_free_irqs();
 
         while (qfe_sbus_list) {
diff --git a/drivers/net/sunlance.c b/drivers/net/sunlance.c
index 7d9c33dd9d1a..ee364fa75634 100644
--- a/drivers/net/sunlance.c
+++ b/drivers/net/sunlance.c
@@ -1474,7 +1474,7 @@ no_link_test:
         dev->ethtool_ops = &sparc_lance_ethtool_ops;
         dev->netdev_ops = &sparc_lance_ops;
 
-        dev->irq = op->irqs[0];
+        dev->irq = op->archdata.irqs[0];
 
         /* We cannot sleep if the chip is busy during a
          * multicast list update event, because such events
@@ -1558,12 +1558,12 @@ static struct of_platform_driver sunlance_sbus_driver = {
 /* Find all the lance cards on the system and initialize them */
 static int __init sparc_lance_init(void)
 {
-        return of_register_driver(&sunlance_sbus_driver, &of_bus_type);
+        return of_register_platform_driver(&sunlance_sbus_driver);
 }
 
 static void __exit sparc_lance_exit(void)
 {
-        of_unregister_driver(&sunlance_sbus_driver);
+        of_unregister_platform_driver(&sunlance_sbus_driver);
 }
 
 module_init(sparc_lance_init);
diff --git a/drivers/net/sunqe.c b/drivers/net/sunqe.c
index 72b579c8d812..5f84a5dadedd 100644
--- a/drivers/net/sunqe.c
+++ b/drivers/net/sunqe.c
@@ -803,7 +803,7 @@ static struct sunqec * __devinit get_qec(struct of_device *child)
 
                         qec_init_once(qecp, op);
 
-                        if (request_irq(op->irqs[0], qec_interrupt,
+                        if (request_irq(op->archdata.irqs[0], qec_interrupt,
                                         IRQF_SHARED, "qec", (void *) qecp)) {
                                 printk(KERN_ERR "qec: Can't register irq.\n");
                                 goto fail;
@@ -901,7 +901,7 @@ static int __devinit qec_ether_init(struct of_device *op)
         SET_NETDEV_DEV(dev, &op->dev);
 
         dev->watchdog_timeo = 5*HZ;
-        dev->irq = op->irqs[0];
+        dev->irq = op->archdata.irqs[0];
         dev->dma = 0;
         dev->ethtool_ops = &qe_ethtool_ops;
         dev->netdev_ops = &qec_ops;
@@ -988,18 +988,18 @@ static struct of_platform_driver qec_sbus_driver = {
 
 static int __init qec_init(void)
 {
-        return of_register_driver(&qec_sbus_driver, &of_bus_type);
+        return of_register_platform_driver(&qec_sbus_driver);
 }
 
 static void __exit qec_exit(void)
 {
-        of_unregister_driver(&qec_sbus_driver);
+        of_unregister_platform_driver(&qec_sbus_driver);
 
         while (root_qec_dev) {
                 struct sunqec *next = root_qec_dev->next_module;
                 struct of_device *op = root_qec_dev->op;
 
-                free_irq(op->irqs[0], (void *) root_qec_dev);
+                free_irq(op->archdata.irqs[0], (void *) root_qec_dev);
                 of_iounmap(&op->resource[0], root_qec_dev->gregs,
                            GLOB_REG_SIZE);
                 kfree(root_qec_dev);
diff --git a/drivers/net/xilinx_emaclite.c b/drivers/net/xilinx_emaclite.c
index d04c5b262050..b2c2f391b29d 100644
--- a/drivers/net/xilinx_emaclite.c
+++ b/drivers/net/xilinx_emaclite.c
@@ -20,7 +20,7 @@
 #include <linux/skbuff.h>
 #include <linux/io.h>
 #include <linux/slab.h>
-
+#include <linux/of_address.h>
 #include <linux/of_device.h>
 #include <linux/of_platform.h>
 #include <linux/of_mdio.h>
diff --git a/drivers/of/Kconfig b/drivers/of/Kconfig
index 7cecc8fea9bd..6acbff389ab6 100644
--- a/drivers/of/Kconfig
+++ b/drivers/of/Kconfig
@@ -1,35 +1,61 @@
-config OF_FLATTREE
+config DTC
+        bool
+
+config OF
         bool
+
+menu "Flattened Device Tree and Open Firmware support"
         depends on OF
 
+config PROC_DEVICETREE
+        bool "Support for device tree in /proc"
+        depends on PROC_FS && !SPARC
+        help
+          This option adds a device-tree directory under /proc which contains
+          an image of the device tree that the kernel copies from Open
+          Firmware or other boot firmware. If unsure, say Y here.
+
+config OF_FLATTREE
+        bool
+        select DTC
+
 config OF_DYNAMIC
         def_bool y
-        depends on OF && PPC_OF
+        depends on PPC_OF
+
+config OF_ADDRESS
+        def_bool y
+        depends on !SPARC
+
+config OF_IRQ
+        def_bool y
+        depends on !SPARC
 
 config OF_DEVICE
         def_bool y
-        depends on OF && (SPARC || PPC_OF || MICROBLAZE)
 
 config OF_GPIO
         def_bool y
-        depends on OF && (PPC_OF || MICROBLAZE) && GPIOLIB
+        depends on GPIOLIB && !SPARC
         help
           OpenFirmware GPIO accessors
 
 config OF_I2C
         def_tristate I2C
-        depends on (PPC_OF || MICROBLAZE) && I2C
+        depends on I2C && !SPARC
         help
           OpenFirmware I2C accessors
 
 config OF_SPI
         def_tristate SPI
-        depends on OF && (PPC_OF || MICROBLAZE) && SPI
+        depends on SPI && !SPARC
         help
           OpenFirmware SPI accessors
 
 config OF_MDIO
         def_tristate PHYLIB
-        depends on OF && PHYLIB
+        depends on PHYLIB
         help
           OpenFirmware MDIO bus (Ethernet PHY) accessors
+
+endmenu # OF
diff --git a/drivers/of/Makefile b/drivers/of/Makefile
index f232cc98ce00..0052c405463a 100644
--- a/drivers/of/Makefile
+++ b/drivers/of/Makefile
@@ -1,5 +1,7 @@
 obj-y = base.o
 obj-$(CONFIG_OF_FLATTREE) += fdt.o
+obj-$(CONFIG_OF_ADDRESS)  += address.o
+obj-$(CONFIG_OF_IRQ)    += irq.o
 obj-$(CONFIG_OF_DEVICE) += device.o platform.o
 obj-$(CONFIG_OF_GPIO)   += gpio.o
 obj-$(CONFIG_OF_I2C)    += of_i2c.o
diff --git a/drivers/of/address.c b/drivers/of/address.c
new file mode 100644
index 000000000000..fcadb726d4f9
--- /dev/null
+++ b/drivers/of/address.c
@@ -0,0 +1,595 @@
+
+#include <linux/io.h>
+#include <linux/ioport.h>
+#include <linux/module.h>
+#include <linux/of_address.h>
+#include <linux/pci_regs.h>
+#include <linux/string.h>
+
+/* Max address size we deal with */
+#define OF_MAX_ADDR_CELLS       4
+#define OF_CHECK_COUNTS(na, ns) ((na) > 0 && (na) <= OF_MAX_ADDR_CELLS && \
+                        (ns) > 0)
+
+static struct of_bus *of_match_bus(struct device_node *np);
+static int __of_address_to_resource(struct device_node *dev, const u32 *addrp,
+                                    u64 size, unsigned int flags,
+                                    struct resource *r);
+
+/* Debug utility */
+#ifdef DEBUG
+static void of_dump_addr(const char *s, const u32 *addr, int na)
+{
+        printk(KERN_DEBUG "%s", s);
+        while (na--)
+                printk(" %08x", be32_to_cpu(*(addr++)));
+        printk("\n");
+}
+#else
+static void of_dump_addr(const char *s, const u32 *addr, int na) { }
+#endif
+
+/* Callbacks for bus specific translators */
+struct of_bus {
+        const char      *name;
+        const char      *addresses;
+        int             (*match)(struct device_node *parent);
+        void            (*count_cells)(struct device_node *child,
+                                       int *addrc, int *sizec);
+        u64             (*map)(u32 *addr, const u32 *range,
+                                int na, int ns, int pna);
+        int             (*translate)(u32 *addr, u64 offset, int na);
+        unsigned int    (*get_flags)(const u32 *addr);
+};
+
+/*
+ * Default translator (generic bus)
+ */
+
+static void of_bus_default_count_cells(struct device_node *dev,
+                                       int *addrc, int *sizec)
+{
+        if (addrc)
+                *addrc = of_n_addr_cells(dev);
+        if (sizec)
+                *sizec = of_n_size_cells(dev);
+}
+
+static u64 of_bus_default_map(u32 *addr, const u32 *range,
+                int na, int ns, int pna)
+{
+        u64 cp, s, da;
+
+        cp = of_read_number(range, na);
+        s  = of_read_number(range + na + pna, ns);
+        da = of_read_number(addr, na);
+
+        pr_debug("OF: default map, cp=%llx, s=%llx, da=%llx\n",
+                 (unsigned long long)cp, (unsigned long long)s,
+                 (unsigned long long)da);
+
+        if (da < cp || da >= (cp + s))
+                return OF_BAD_ADDR;
+        return da - cp;
+}
+
+static int of_bus_default_translate(u32 *addr, u64 offset, int na)
+{
+        u64 a = of_read_number(addr, na);
+        memset(addr, 0, na * 4);
+        a += offset;
+        if (na > 1)
+                addr[na - 2] = cpu_to_be32(a >> 32);
+        addr[na - 1] = cpu_to_be32(a & 0xffffffffu);
+
+        return 0;
+}
+
+static unsigned int of_bus_default_get_flags(const u32 *addr)
+{
+        return IORESOURCE_MEM;
+}
+
+#ifdef CONFIG_PCI
+/*
+ * PCI bus specific translator
+ */
+
+static int of_bus_pci_match(struct device_node *np)
+{
+        /* "vci" is for the /chaos bridge on 1st-gen PCI powermacs */
+        return !strcmp(np->type, "pci") || !strcmp(np->type, "vci");
+}
+
+static void of_bus_pci_count_cells(struct device_node *np,
+                                   int *addrc, int *sizec)
+{
+        if (addrc)
+                *addrc = 3;
+        if (sizec)
+                *sizec = 2;
+}
+
+static unsigned int of_bus_pci_get_flags(const u32 *addr)
+{
+        unsigned int flags = 0;
+        u32 w = addr[0];
+
+        switch((w >> 24) & 0x03) {
+        case 0x01:
+                flags |= IORESOURCE_IO;
+                break;
+        case 0x02: /* 32 bits */
+        case 0x03: /* 64 bits */
+                flags |= IORESOURCE_MEM;
+                break;
+        }
+        if (w & 0x40000000)
+                flags |= IORESOURCE_PREFETCH;
+        return flags;
+}
+
+static u64 of_bus_pci_map(u32 *addr, const u32 *range, int na, int ns, int pna)
+{
+        u64 cp, s, da;
+        unsigned int af, rf;
+
+        af = of_bus_pci_get_flags(addr);
+        rf = of_bus_pci_get_flags(range);
+
+        /* Check address type match */
+        if ((af ^ rf) & (IORESOURCE_MEM | IORESOURCE_IO))
+                return OF_BAD_ADDR;
+
+        /* Read address values, skipping high cell */
+        cp = of_read_number(range + 1, na - 1);
+        s  = of_read_number(range + na + pna, ns);
+        da = of_read_number(addr + 1, na - 1);
+
+        pr_debug("OF: PCI map, cp=%llx, s=%llx, da=%llx\n",
+                 (unsigned long long)cp, (unsigned long long)s,
+                 (unsigned long long)da);
+
+        if (da < cp || da >= (cp + s))
+                return OF_BAD_ADDR;
+        return da - cp;
+}
+
+static int of_bus_pci_translate(u32 *addr, u64 offset, int na)
+{
+        return of_bus_default_translate(addr + 1, offset, na - 1);
+}
+
+const u32 *of_get_pci_address(struct device_node *dev, int bar_no, u64 *size,
+                        unsigned int *flags)
+{
+        const u32 *prop;
+        unsigned int psize;
+        struct device_node *parent;
+        struct of_bus *bus;
+        int onesize, i, na, ns;
+
+        /* Get parent & match bus type */
+        parent = of_get_parent(dev);
+        if (parent == NULL)
+                return NULL;
+        bus = of_match_bus(parent);
+        if (strcmp(bus->name, "pci")) {
+                of_node_put(parent);
+                return NULL;
+        }
+        bus->count_cells(dev, &na, &ns);
+        of_node_put(parent);
+        if (!OF_CHECK_COUNTS(na, ns))
+                return NULL;
+
+        /* Get "reg" or "assigned-addresses" property */
+        prop = of_get_property(dev, bus->addresses, &psize);
+        if (prop == NULL)
+                return NULL;
+        psize /= 4;
+
+        onesize = na + ns;
+        for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++) {
+                u32 val = be32_to_cpu(prop[0]);
+                if ((val & 0xff) == ((bar_no * 4) + PCI_BASE_ADDRESS_0)) {
+                        if (size)
+                                *size = of_read_number(prop + na, ns);
+                        if (flags)
+                                *flags = bus->get_flags(prop);
+                        return prop;
+                }
+        }
+        return NULL;
+}
+EXPORT_SYMBOL(of_get_pci_address);
+
+int of_pci_address_to_resource(struct device_node *dev, int bar,
+                               struct resource *r)
+{
+        const u32       *addrp;
+        u64             size;
+        unsigned int    flags;
+
+        addrp = of_get_pci_address(dev, bar, &size, &flags);
+        if (addrp == NULL)
+                return -EINVAL;
+        return __of_address_to_resource(dev, addrp, size, flags, r);
+}
+EXPORT_SYMBOL_GPL(of_pci_address_to_resource);
+#endif /* CONFIG_PCI */
+
+/*
+ * ISA bus specific translator
+ */
+
+static int of_bus_isa_match(struct device_node *np)
+{
+        return !strcmp(np->name, "isa");
+}
+
+static void of_bus_isa_count_cells(struct device_node *child,
+                                   int *addrc, int *sizec)
+{
+        if (addrc)
+                *addrc = 2;
+        if (sizec)
+                *sizec = 1;
+}
+
+static u64 of_bus_isa_map(u32 *addr, const u32 *range, int na, int ns, int pna)
+{
+        u64 cp, s, da;
+
+        /* Check address type match */
+        if ((addr[0] ^ range[0]) & 0x00000001)
+                return OF_BAD_ADDR;
+
+        /* Read address values, skipping high cell */
+        cp = of_read_number(range + 1, na - 1);
+        s  = of_read_number(range + na + pna, ns);
+        da = of_read_number(addr + 1, na - 1);
+
+        pr_debug("OF: ISA map, cp=%llx, s=%llx, da=%llx\n",
+                 (unsigned long long)cp, (unsigned long long)s,
+                 (unsigned long long)da);
+
+        if (da < cp || da >= (cp + s))
+                return OF_BAD_ADDR;
+        return da - cp;
+}
+
+static int of_bus_isa_translate(u32 *addr, u64 offset, int na)
+{
+        return of_bus_default_translate(addr + 1, offset, na - 1);
+}
+
+static unsigned int of_bus_isa_get_flags(const u32 *addr)
+{
+        unsigned int flags = 0;
+        u32 w = addr[0];
+
+        if (w & 1)
+                flags |= IORESOURCE_IO;
+        else
+                flags |= IORESOURCE_MEM;
+        return flags;
+}
+
+/*
+ * Array of bus specific translators
+ */
+
+static struct of_bus of_busses[] = {
+#ifdef CONFIG_PCI
+        /* PCI */
+        {
+                .name = "pci",
+                .addresses = "assigned-addresses",
+                .match = of_bus_pci_match,
+                .count_cells = of_bus_pci_count_cells,
+                .map = of_bus_pci_map,
+                .translate = of_bus_pci_translate,
+                .get_flags = of_bus_pci_get_flags,
+        },
+#endif /* CONFIG_PCI */
+        /* ISA */
+        {
+                .name = "isa",
+                .addresses = "reg",
+                .match = of_bus_isa_match,
+                .count_cells = of_bus_isa_count_cells,
+                .map = of_bus_isa_map,
+                .translate = of_bus_isa_translate,
+                .get_flags = of_bus_isa_get_flags,
+        },
+        /* Default */
+        {
+                .name = "default",
+                .addresses = "reg",
+                .match = NULL,
+                .count_cells = of_bus_default_count_cells,
+                .map = of_bus_default_map,
+                .translate = of_bus_default_translate,
+                .get_flags = of_bus_default_get_flags,
+        },
+};
+
+static struct of_bus *of_match_bus(struct device_node *np)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(of_busses); i++)
+                if (!of_busses[i].match || of_busses[i].match(np))
+                        return &of_busses[i];
+        BUG();
+        return NULL;
+}
+
+static int of_translate_one(struct device_node *parent, struct of_bus *bus,
+                            struct of_bus *pbus, u32 *addr,
+                            int na, int ns, int pna, const char *rprop)
+{
+        const u32 *ranges;
+        unsigned int rlen;
+        int rone;
+        u64 offset = OF_BAD_ADDR;
+
+        /* Normally, an absence of a "ranges" property means we are
+         * crossing a non-translatable boundary, and thus the addresses
+         * below the current not cannot be converted to CPU physical ones.
+         * Unfortunately, while this is very clear in the spec, it's not
+         * what Apple understood, and they do have things like /uni-n or
+         * /ht nodes with no "ranges" property and a lot of perfectly
+         * useable mapped devices below them. Thus we treat the absence of
+         * "ranges" as equivalent to an empty "ranges" property which means
+         * a 1:1 translation at that level. It's up to the caller not to try
+         * to translate addresses that aren't supposed to be translated in
+         * the first place. --BenH.
+         *
+         * As far as we know, this damage only exists on Apple machines, so
+         * This code is only enabled on powerpc. --gcl
+         */
+        ranges = of_get_property(parent, rprop, &rlen);
+#if !defined(CONFIG_PPC)
+        if (ranges == NULL) {
+                pr_err("OF: no ranges; cannot translate\n");
+                return 1;
+        }
+#endif /* !defined(CONFIG_PPC) */
+        if (ranges == NULL || rlen == 0) {
+                offset = of_read_number(addr, na);
+                memset(addr, 0, pna * 4);
+                pr_debug("OF: empty ranges; 1:1 translation\n");
+                goto finish;
+        }
+
+        pr_debug("OF: walking ranges...\n");
+
+        /* Now walk through the ranges */
+        rlen /= 4;
+        rone = na + pna + ns;
+        for (; rlen >= rone; rlen -= rone, ranges += rone) {
+                offset = bus->map(addr, ranges, na, ns, pna);
+                if (offset != OF_BAD_ADDR)
+                        break;
+        }
+        if (offset == OF_BAD_ADDR) {
+                pr_debug("OF: not found !\n");
+                return 1;
+        }
+        memcpy(addr, ranges + na, 4 * pna);
+
+ finish:
+        of_dump_addr("OF: parent translation for:", addr, pna);
+        pr_debug("OF: with offset: %llx\n", (unsigned long long)offset);
+
+        /* Translate it into parent bus space */
+        return pbus->translate(addr, offset, pna);
+}
+
+/*
+ * Translate an address from the device-tree into a CPU physical address,
+ * this walks up the tree and applies the various bus mappings on the
+ * way.
+ *
+ * Note: We consider that crossing any level with #size-cells == 0 to mean
+ * that translation is impossible (that is we are not dealing with a value
+ * that can be mapped to a cpu physical address). This is not really specified
+ * that way, but this is traditionally the way IBM at least do things
+ */
+u64 __of_translate_address(struct device_node *dev, const u32 *in_addr,
+                           const char *rprop)
+{
+        struct device_node *parent = NULL;
+        struct of_bus *bus, *pbus;
+        u32 addr[OF_MAX_ADDR_CELLS];
+        int na, ns, pna, pns;
+        u64 result = OF_BAD_ADDR;
+
+        pr_debug("OF: ** translation for device %s **\n", dev->full_name);
+
+        /* Increase refcount at current level */
+        of_node_get(dev);
+
+        /* Get parent & match bus type */
+        parent = of_get_parent(dev);
+        if (parent == NULL)
+                goto bail;
+        bus = of_match_bus(parent);
+
+        /* Cound address cells & copy address locally */
+        bus->count_cells(dev, &na, &ns);
+        if (!OF_CHECK_COUNTS(na, ns)) {
+                printk(KERN_ERR "prom_parse: Bad cell count for %s\n",
+                       dev->full_name);
+                goto bail;
+        }
+        memcpy(addr, in_addr, na * 4);
+
+        pr_debug("OF: bus is %s (na=%d, ns=%d) on %s\n",
+            bus->name, na, ns, parent->full_name);
+        of_dump_addr("OF: translating address:", addr, na);
+
+        /* Translate */
+        for (;;) {
+                /* Switch to parent bus */
+                of_node_put(dev);
+                dev = parent;
+                parent = of_get_parent(dev);
+
+                /* If root, we have finished */
+                if (parent == NULL) {
+                        pr_debug("OF: reached root node\n");
+                        result = of_read_number(addr, na);
+                        break;
+                }
+
+                /* Get new parent bus and counts */
+                pbus = of_match_bus(parent);
+                pbus->count_cells(dev, &pna, &pns);
+                if (!OF_CHECK_COUNTS(pna, pns)) {
+                        printk(KERN_ERR "prom_parse: Bad cell count for %s\n",
+                               dev->full_name);
+                        break;
+                }
+
+                pr_debug("OF: parent bus is %s (na=%d, ns=%d) on %s\n",
+                    pbus->name, pna, pns, parent->full_name);
+
+                /* Apply bus translation */
+                if (of_translate_one(dev, bus, pbus, addr, na, ns, pna, rprop))
+                        break;
+
+                /* Complete the move up one level */
+                na = pna;
+                ns = pns;
+                bus = pbus;
+
+                of_dump_addr("OF: one level translation:", addr, na);
+        }
+ bail:
+        of_node_put(parent);
+        of_node_put(dev);
+
+        return result;
+}
+
+u64 of_translate_address(struct device_node *dev, const u32 *in_addr)
+{
+        return __of_translate_address(dev, in_addr, "ranges");
+}
+EXPORT_SYMBOL(of_translate_address);
+
+u64 of_translate_dma_address(struct device_node *dev, const u32 *in_addr)
+{
+        return __of_translate_address(dev, in_addr, "dma-ranges");
+}
+EXPORT_SYMBOL(of_translate_dma_address);
+
+const u32 *of_get_address(struct device_node *dev, int index, u64 *size,
+                    unsigned int *flags)
+{
+        const u32 *prop;
+        unsigned int psize;
+        struct device_node *parent;
+        struct of_bus *bus;
+        int onesize, i, na, ns;
+
+        /* Get parent & match bus type */
+        parent = of_get_parent(dev);
+        if (parent == NULL)
+                return NULL;
+        bus = of_match_bus(parent);
+        bus->count_cells(dev, &na, &ns);
+        of_node_put(parent);
+        if (!OF_CHECK_COUNTS(na, ns))
+                return NULL;
+
+        /* Get "reg" or "assigned-addresses" property */
+        prop = of_get_property(dev, bus->addresses, &psize);
+        if (prop == NULL)
+                return NULL;
+        psize /= 4;
+
+        onesize = na + ns;
+        for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++)
+                if (i == index) {
+                        if (size)
+                                *size = of_read_number(prop + na, ns);
+                        if (flags)
+                                *flags = bus->get_flags(prop);
+                        return prop;
+                }
+        return NULL;
+}
+EXPORT_SYMBOL(of_get_address);
+
+static int __of_address_to_resource(struct device_node *dev, const u32 *addrp,
+                                    u64 size, unsigned int flags,
+                                    struct resource *r)
+{
+        u64 taddr;
+
+        if ((flags & (IORESOURCE_IO | IORESOURCE_MEM)) == 0)
+                return -EINVAL;
+        taddr = of_translate_address(dev, addrp);
+        if (taddr == OF_BAD_ADDR)
+                return -EINVAL;
+        memset(r, 0, sizeof(struct resource));
+        if (flags & IORESOURCE_IO) {
+                unsigned long port;
+                port = pci_address_to_pio(taddr);
+                if (port == (unsigned long)-1)
+                        return -EINVAL;
+                r->start = port;
+                r->end = port + size - 1;
+        } else {
+                r->start = taddr;
+                r->end = taddr + size - 1;
+        }
+        r->flags = flags;
+        r->name = dev->full_name;
+        return 0;
+}
+
+/**
+ * of_address_to_resource - Translate device tree address and return as resource
+ *
+ * Note that if your address is a PIO address, the conversion will fail if
+ * the physical address can't be internally converted to an IO token with
+ * pci_address_to_pio(), that is because it's either called to early or it
+ * can't be matched to any host bridge IO space
+ */
+int of_address_to_resource(struct device_node *dev, int index,
+                           struct resource *r)
+{
+        const u32       *addrp;
+        u64             size;
+        unsigned int    flags;
+
+        addrp = of_get_address(dev, index, &size, &flags);
+        if (addrp == NULL)
+                return -EINVAL;
+        return __of_address_to_resource(dev, addrp, size, flags, r);
+}
+EXPORT_SYMBOL_GPL(of_address_to_resource);
+
+
+/**
+ * of_iomap - Maps the memory mapped IO for a given device_node
+ * @device:     the device whose io range will be mapped
+ * @index:      index of the io range
+ *
+ * Returns a pointer to the mapped memory
+ */
+void __iomem *of_iomap(struct device_node *np, int index)
+{
+        struct resource res;
+
+        if (of_address_to_resource(np, index, &res))
+                return NULL;
+
+        return ioremap(res.start, 1 + res.end - res.start);
+}
+EXPORT_SYMBOL(of_iomap);
diff --git a/drivers/of/base.c b/drivers/of/base.c
index b5ad9740d8b2..aa805250de76 100644
--- a/drivers/of/base.c
+++ b/drivers/of/base.c
@@ -545,74 +545,28 @@ struct device_node *of_find_matching_node(struct device_node *from,
 EXPORT_SYMBOL(of_find_matching_node);
 
 /**
- * of_modalias_table: Table of explicit compatible ==> modalias mappings
- *
- * This table allows particulare compatible property values to be mapped
- * to modalias strings.  This is useful for busses which do not directly
- * understand the OF device tree but are populated based on data contained
- * within the device tree.  SPI and I2C are the two current users of this
- * table.
- *
- * In most cases, devices do not need to be listed in this table because
- * the modalias value can be derived directly from the compatible table.
- * However, if for any reason a value cannot be derived, then this table
- * provides a method to override the implicit derivation.
- *
- * At the moment, a single table is used for all bus types because it is
- * assumed that the data size is small and that the compatible values
- * should already be distinct enough to differentiate between SPI, I2C
- * and other devices.
- */
-struct of_modalias_table {
-        char *of_device;
-        char *modalias;
-};
-static struct of_modalias_table of_modalias_table[] = {
-        { "fsl,mcu-mpc8349emitx", "mcu-mpc8349emitx" },
-        { "mmc-spi-slot", "mmc_spi" },
-};
-
-/**
  * of_modalias_node - Lookup appropriate modalias for a device node
  * @node:       pointer to a device tree node
  * @modalias:   Pointer to buffer that modalias value will be copied into
  * @len:        Length of modalias value
  *
- * Based on the value of the compatible property, this routine will determine
- * an appropriate modalias value for a particular device tree node.  Two
- * separate methods are attempted to derive a modalias value.
+ * Based on the value of the compatible property, this routine will attempt
+ * to choose an appropriate modalias value for a particular device tree node.
+ * It does this by stripping the manufacturer prefix (as delimited by a ',')
+ * from the first entry in the compatible list property.
  *
- * First method is to lookup the compatible value in of_modalias_table.
- * Second is to strip off the manufacturer prefix from the first
- * compatible entry and use the remainder as modalias
- *
- * This routine returns 0 on success
+ * This routine returns 0 on success, <0 on failure.
  */
 int of_modalias_node(struct device_node *node, char *modalias, int len)
 {
-        int i, cplen;
-        const char *compatible;
-        const char *p;
-
-        /* 1. search for exception list entry */
-        for (i = 0; i < ARRAY_SIZE(of_modalias_table); i++) {
-                compatible = of_modalias_table[i].of_device;
-                if (!of_device_is_compatible(node, compatible))
-                        continue;
-                strlcpy(modalias, of_modalias_table[i].modalias, len);
-                return 0;
-        }
+        const char *compatible, *p;
+        int cplen;
 
         compatible = of_get_property(node, "compatible", &cplen);
-        if (!compatible)
+        if (!compatible || strlen(compatible) > cplen)
                 return -ENODEV;
-
-        /* 2. take first compatible entry and strip manufacturer */
         p = strchr(compatible, ',');
-        if (!p)
-                return -ENODEV;
-        p++;
-        strlcpy(modalias, p, len);
+        strlcpy(modalias, p ? p + 1 : compatible, len);
         return 0;
 }
 EXPORT_SYMBOL_GPL(of_modalias_node);
@@ -651,14 +605,14 @@ EXPORT_SYMBOL(of_find_node_by_phandle);
 struct device_node *
 of_parse_phandle(struct device_node *np, const char *phandle_name, int index)
 {
-        const phandle *phandle;
+        const __be32 *phandle;
         int size;
 
         phandle = of_get_property(np, phandle_name, &size);
         if ((!phandle) || (size < sizeof(*phandle) * (index + 1)))
                 return NULL;
 
-        return of_find_node_by_phandle(phandle[index]);
+        return of_find_node_by_phandle(be32_to_cpup(phandle + index));
 }
 EXPORT_SYMBOL(of_parse_phandle);
 
@@ -714,16 +668,16 @@ int of_parse_phandles_with_args(struct device_node *np, const char *list_name,
 
         while (list < list_end) {
                 const __be32 *cells;
-                const phandle *phandle;
+                phandle phandle;
 
-                phandle = list++;
+                phandle = be32_to_cpup(list++);
                 args = list;
 
                 /* one cell hole in the list = <>; */
-                if (!*phandle)
+                if (!phandle)
                         goto next;
 
-                node = of_find_node_by_phandle(*phandle);
+                node = of_find_node_by_phandle(phandle);
                 if (!node) {
                         pr_debug("%s: could not find phandle\n",
                                  np->full_name);
diff --git a/drivers/of/device.c b/drivers/of/device.c
index 7d18f8e0b013..0d8a0644f540 100644
--- a/drivers/of/device.c
+++ b/drivers/of/device.c
@@ -20,13 +20,13 @@
 const struct of_device_id *of_match_device(const struct of_device_id *matches,
                                            const struct device *dev)
 {
-        if (!dev->of_node)
+        if ((!matches) || (!dev->of_node))
                 return NULL;
         return of_match_node(matches, dev->of_node);
 }
 EXPORT_SYMBOL(of_match_device);
 
-struct of_device *of_dev_get(struct of_device *dev)
+struct platform_device *of_dev_get(struct platform_device *dev)
 {
         struct device *tmp;
 
@@ -34,13 +34,13 @@ struct of_device *of_dev_get(struct of_device *dev)
                 return NULL;
         tmp = get_device(&dev->dev);
         if (tmp)
-                return to_of_device(tmp);
+                return to_platform_device(tmp);
         else
                 return NULL;
 }
 EXPORT_SYMBOL(of_dev_get);
 
-void of_dev_put(struct of_device *dev)
+void of_dev_put(struct platform_device *dev)
 {
         if (dev)
                 put_device(&dev->dev);
@@ -50,28 +50,25 @@ EXPORT_SYMBOL(of_dev_put);
 static ssize_t devspec_show(struct device *dev,
                                 struct device_attribute *attr, char *buf)
 {
-        struct of_device *ofdev;
+        struct platform_device *ofdev;
 
-        ofdev = to_of_device(dev);
+        ofdev = to_platform_device(dev);
         return sprintf(buf, "%s\n", ofdev->dev.of_node->full_name);
 }
 
 static ssize_t name_show(struct device *dev,
                                 struct device_attribute *attr, char *buf)
 {
-        struct of_device *ofdev;
+        struct platform_device *ofdev;
 
-        ofdev = to_of_device(dev);
+        ofdev = to_platform_device(dev);
         return sprintf(buf, "%s\n", ofdev->dev.of_node->name);
 }
 
 static ssize_t modalias_show(struct device *dev,
                                 struct device_attribute *attr, char *buf)
 {
-        struct of_device *ofdev = to_of_device(dev);
-        ssize_t len = 0;
-
-        len = of_device_get_modalias(ofdev, buf, PAGE_SIZE - 2);
+        ssize_t len = of_device_get_modalias(dev, buf, PAGE_SIZE - 2);
         buf[len] = '\n';
         buf[len+1] = 0;
         return len+1;
@@ -93,20 +90,25 @@ struct device_attribute of_platform_device_attrs[] = {
  */
 void of_release_dev(struct device *dev)
 {
-        struct of_device *ofdev;
+        struct platform_device *ofdev;
 
-        ofdev = to_of_device(dev);
+        ofdev = to_platform_device(dev);
         of_node_put(ofdev->dev.of_node);
         kfree(ofdev);
 }
 EXPORT_SYMBOL(of_release_dev);
 
-int of_device_register(struct of_device *ofdev)
+int of_device_register(struct platform_device *ofdev)
 {
         BUG_ON(ofdev->dev.of_node == NULL);
 
         device_initialize(&ofdev->dev);
 
+        /* name and id have to be set so that the platform bus doesn't get
+         * confused on matching */
+        ofdev->name = dev_name(&ofdev->dev);
+        ofdev->id = -1;
+
         /* device_add will assume that this device is on the same node as
          * the parent. If there is no parent defined, set the node
          * explicitly */
@@ -117,25 +119,24 @@ int of_device_register(struct of_device *ofdev)
 }
 EXPORT_SYMBOL(of_device_register);
 
-void of_device_unregister(struct of_device *ofdev)
+void of_device_unregister(struct platform_device *ofdev)
 {
         device_unregister(&ofdev->dev);
 }
 EXPORT_SYMBOL(of_device_unregister);
 
-ssize_t of_device_get_modalias(struct of_device *ofdev,
-                                char *str, ssize_t len)
+ssize_t of_device_get_modalias(struct device *dev, char *str, ssize_t len)
 {
         const char *compat;
         int cplen, i;
         ssize_t tsize, csize, repend;
 
         /* Name & Type */
-        csize = snprintf(str, len, "of:N%sT%s", ofdev->dev.of_node->name,
-                         ofdev->dev.of_node->type);
+        csize = snprintf(str, len, "of:N%sT%s", dev->of_node->name,
+                         dev->of_node->type);
 
         /* Get compatible property if any */
-        compat = of_get_property(ofdev->dev.of_node, "compatible", &cplen);
+        compat = of_get_property(dev->of_node, "compatible", &cplen);
         if (!compat)
                 return csize;
 
@@ -170,3 +171,51 @@ ssize_t of_device_get_modalias(struct of_device *ofdev,
 
         return tsize;
 }
+
+/**
+ * of_device_uevent - Display OF related uevent information
+ */
+int of_device_uevent(struct device *dev, struct kobj_uevent_env *env)
+{
+        const char *compat;
+        int seen = 0, cplen, sl;
+
+        if ((!dev) || (!dev->of_node))
+                return -ENODEV;
+
+        if (add_uevent_var(env, "OF_NAME=%s", dev->of_node->name))
+                return -ENOMEM;
+
+        if (add_uevent_var(env, "OF_TYPE=%s", dev->of_node->type))
+                return -ENOMEM;
+
+        /* Since the compatible field can contain pretty much anything
+         * it's not really legal to split it out with commas. We split it
+         * up using a number of environment variables instead. */
+
+        compat = of_get_property(dev->of_node, "compatible", &cplen);
+        while (compat && *compat && cplen > 0) {
+                if (add_uevent_var(env, "OF_COMPATIBLE_%d=%s", seen, compat))
+                        return -ENOMEM;
+
+                sl = strlen(compat) + 1;
+                compat += sl;
+                cplen -= sl;
+                seen++;
+        }
+
+        if (add_uevent_var(env, "OF_COMPATIBLE_N=%d", seen))
+                return -ENOMEM;
+
+        /* modalias is trickier, we add it in 2 steps */
+        if (add_uevent_var(env, "MODALIAS="))
+                return -ENOMEM;
+
+        sl = of_device_get_modalias(dev, &env->buf[env->buflen-1],
+                                    sizeof(env->buf) - env->buflen);
+        if (sl >= (sizeof(env->buf) - env->buflen))
+                return -ENOMEM;
+        env->buflen += sl;
+
+        return 0;
+}
diff --git a/drivers/of/fdt.c b/drivers/of/fdt.c
index b6987bba8556..65da5aec7552 100644
--- a/drivers/of/fdt.c
+++ b/drivers/of/fdt.c
@@ -69,9 +69,9 @@ int __init of_scan_flat_dt(int (*it)(unsigned long node,
                         u32 sz = be32_to_cpup((__be32 *)p);
                         p += 8;
                         if (be32_to_cpu(initial_boot_params->version) < 0x10)
-                                p = _ALIGN(p, sz >= 8 ? 8 : 4);
+                                p = ALIGN(p, sz >= 8 ? 8 : 4);
                         p += sz;
-                        p = _ALIGN(p, 4);
+                        p = ALIGN(p, 4);
                         continue;
                 }
                 if (tag != OF_DT_BEGIN_NODE) {
@@ -80,7 +80,7 @@ int __init of_scan_flat_dt(int (*it)(unsigned long node,
                 }
                 depth++;
                 pathp = (char *)p;
-                p = _ALIGN(p + strlen(pathp) + 1, 4);
+                p = ALIGN(p + strlen(pathp) + 1, 4);
                 if ((*pathp) == '/') {
                         char *lp, *np;
                         for (lp = NULL, np = pathp; *np; np++)
@@ -109,7 +109,7 @@ unsigned long __init of_get_flat_dt_root(void)
                 p += 4;
         BUG_ON(be32_to_cpup((__be32 *)p) != OF_DT_BEGIN_NODE);
         p += 4;
-        return _ALIGN(p + strlen((char *)p) + 1, 4);
+        return ALIGN(p + strlen((char *)p) + 1, 4);
 }
 
 /**
@@ -138,7 +138,7 @@ void *__init of_get_flat_dt_prop(unsigned long node, const char *name,
                 noff = be32_to_cpup((__be32 *)(p + 4));
                 p += 8;
                 if (be32_to_cpu(initial_boot_params->version) < 0x10)
-                        p = _ALIGN(p, sz >= 8 ? 8 : 4);
+                        p = ALIGN(p, sz >= 8 ? 8 : 4);
 
                 nstr = find_flat_dt_string(noff);
                 if (nstr == NULL) {
@@ -151,7 +151,7 @@ void *__init of_get_flat_dt_prop(unsigned long node, const char *name,
                         return (void *)p;
                 }
                 p += sz;
-                p = _ALIGN(p, 4);
+                p = ALIGN(p, 4);
         } while (1);
 }
 
@@ -169,7 +169,7 @@ int __init of_flat_dt_is_compatible(unsigned long node, const char *compat)
         if (cp == NULL)
                 return 0;
         while (cplen > 0) {
-                if (strncasecmp(cp, compat, strlen(compat)) == 0)
+                if (of_compat_cmp(cp, compat, strlen(compat)) == 0)
                         return 1;
                 l = strlen(cp) + 1;
                 cp += l;
@@ -184,7 +184,7 @@ static void *__init unflatten_dt_alloc(unsigned long *mem, unsigned long size,
 {
         void *res;
 
-        *mem = _ALIGN(*mem, align);
+        *mem = ALIGN(*mem, align);
         res = (void *)*mem;
         *mem += size;
 
@@ -220,7 +220,7 @@ unsigned long __init unflatten_dt_node(unsigned long mem,
         *p += 4;
         pathp = (char *)*p;
         l = allocl = strlen(pathp) + 1;
-        *p = _ALIGN(*p + l, 4);
+        *p = ALIGN(*p + l, 4);
 
         /* version 0x10 has a more compact unit name here instead of the full
          * path. we accumulate the full path size using "fpsize", we'll rebuild
@@ -299,7 +299,7 @@ unsigned long __init unflatten_dt_node(unsigned long mem,
                 noff = be32_to_cpup((__be32 *)((*p) + 4));
                 *p += 8;
                 if (be32_to_cpu(initial_boot_params->version) < 0x10)
-                        *p = _ALIGN(*p, sz >= 8 ? 8 : 4);
+                        *p = ALIGN(*p, sz >= 8 ? 8 : 4);
 
                 pname = find_flat_dt_string(noff);
                 if (pname == NULL) {
@@ -320,20 +320,20 @@ unsigned long __init unflatten_dt_node(unsigned long mem,
                         if ((strcmp(pname, "phandle") == 0) ||
                             (strcmp(pname, "linux,phandle") == 0)) {
                                 if (np->phandle == 0)
-                                        np->phandle = *((u32 *)*p);
+                                        np->phandle = be32_to_cpup((__be32*)*p);
                         }
                         /* And we process the "ibm,phandle" property
                          * used in pSeries dynamic device tree
                          * stuff */
                         if (strcmp(pname, "ibm,phandle") == 0)
-                                np->phandle = *((u32 *)*p);
+                                np->phandle = be32_to_cpup((__be32 *)*p);
                         pp->name = pname;
                         pp->length = sz;
                         pp->value = (void *)*p;
                         *prev_pp = pp;
                         prev_pp = &pp->next;
                 }
-                *p = _ALIGN((*p) + sz, 4);
+                *p = ALIGN((*p) + sz, 4);
         }
         /* with version 0x10 we may not have the name property, recreate
          * it here from the unit name if absent
diff --git a/drivers/of/gpio.c b/drivers/of/gpio.c
index a1b31a4abae4..905960338fb2 100644
--- a/drivers/of/gpio.c
+++ b/drivers/of/gpio.c
@@ -11,13 +11,14 @@
  * (at your option) any later version.
  */
 
-#include <linux/kernel.h>
+#include <linux/device.h>
 #include <linux/errno.h>
+#include <linux/module.h>
 #include <linux/io.h>
 #include <linux/of.h>
-#include <linux/slab.h>
+#include <linux/of_address.h>
 #include <linux/of_gpio.h>
-#include <asm/prom.h>
+#include <linux/slab.h>
 
 /**
  * of_get_gpio_flags - Get a GPIO number and flags to use with GPIO API
@@ -33,32 +34,32 @@ int of_get_gpio_flags(struct device_node *np, int index,
                       enum of_gpio_flags *flags)
 {
         int ret;
-        struct device_node *gc;
-        struct of_gpio_chip *of_gc = NULL;
+        struct device_node *gpio_np;
+        struct gpio_chip *gc;
         int size;
         const void *gpio_spec;
         const __be32 *gpio_cells;
 
         ret = of_parse_phandles_with_args(np, "gpios", "#gpio-cells", index,
-                                          &gc, &gpio_spec);
+                                          &gpio_np, &gpio_spec);
         if (ret) {
                 pr_debug("%s: can't parse gpios property\n", __func__);
                 goto err0;
         }
 
-        of_gc = gc->data;
-        if (!of_gc) {
+        gc = of_node_to_gpiochip(gpio_np);
+        if (!gc) {
                 pr_debug("%s: gpio controller %s isn't registered\n",
-                         np->full_name, gc->full_name);
+                         np->full_name, gpio_np->full_name);
                 ret = -ENODEV;
                 goto err1;
         }
 
-        gpio_cells = of_get_property(gc, "#gpio-cells", &size);
+        gpio_cells = of_get_property(gpio_np, "#gpio-cells", &size);
         if (!gpio_cells || size != sizeof(*gpio_cells) ||
-                        be32_to_cpup(gpio_cells) != of_gc->gpio_cells) {
+                        be32_to_cpup(gpio_cells) != gc->of_gpio_n_cells) {
                 pr_debug("%s: wrong #gpio-cells for %s\n",
-                         np->full_name, gc->full_name);
+                         np->full_name, gpio_np->full_name);
                 ret = -EINVAL;
                 goto err1;
         }
@@ -67,13 +68,13 @@ int of_get_gpio_flags(struct device_node *np, int index,
         if (flags)
                 *flags = 0;
 
-        ret = of_gc->xlate(of_gc, np, gpio_spec, flags);
+        ret = gc->of_xlate(gc, np, gpio_spec, flags);
         if (ret < 0)
                 goto err1;
 
-        ret += of_gc->gc.base;
+        ret += gc->base;
 err1:
-        of_node_put(gc);
+        of_node_put(gpio_np);
 err0:
         pr_debug("%s exited with status %d\n", __func__, ret);
         return ret;
@@ -116,7 +117,7 @@ EXPORT_SYMBOL(of_gpio_count);
 
 /**
  * of_gpio_simple_xlate - translate gpio_spec to the GPIO number and flags
- * @of_gc:      pointer to the of_gpio_chip structure
+ * @gc:         pointer to the gpio_chip structure
  * @np:         device node of the GPIO chip
  * @gpio_spec:  gpio specifier as found in the device tree
  * @flags:      a flags pointer to fill in
@@ -125,8 +126,8 @@ EXPORT_SYMBOL(of_gpio_count);
  * gpio chips. This function performs only one sanity check: whether gpio
  * is less than ngpios (that is specified in the gpio_chip).
  */
-int of_gpio_simple_xlate(struct of_gpio_chip *of_gc, struct device_node *np,
-                         const void *gpio_spec, enum of_gpio_flags *flags)
+static int of_gpio_simple_xlate(struct gpio_chip *gc, struct device_node *np,
+                                const void *gpio_spec, u32 *flags)
 {
         const __be32 *gpio = gpio_spec;
         const u32 n = be32_to_cpup(gpio);
@@ -137,12 +138,12 @@ int of_gpio_simple_xlate(struct of_gpio_chip *of_gc, struct device_node *np,
          * number and the flags from a single gpio cell -- this is possible,
          * but not recommended).
          */
-        if (of_gc->gpio_cells < 2) {
+        if (gc->of_gpio_n_cells < 2) {
                 WARN_ON(1);
                 return -EINVAL;
         }
 
-        if (n > of_gc->gc.ngpio)
+        if (n > gc->ngpio)
                 return -EINVAL;
 
         if (flags)
@@ -150,7 +151,6 @@ int of_gpio_simple_xlate(struct of_gpio_chip *of_gc, struct device_node *np,
 
         return n;
 }
-EXPORT_SYMBOL(of_gpio_simple_xlate);
 
 /**
  * of_mm_gpiochip_add - Add memory mapped GPIO chip (bank)
@@ -161,10 +161,8 @@ EXPORT_SYMBOL(of_gpio_simple_xlate);
  *
  * 1) In the gpio_chip structure:
  *    - all the callbacks
- *
- * 2) In the of_gpio_chip structure:
- *    - gpio_cells
- *    - xlate callback (optional)
+ *    - of_gpio_n_cells
+ *    - of_xlate callback (optional)
  *
  * 3) In the of_mm_gpio_chip structure:
  *    - save_regs callback (optional)
@@ -177,8 +175,7 @@ int of_mm_gpiochip_add(struct device_node *np,
                        struct of_mm_gpio_chip *mm_gc)
 {
         int ret = -ENOMEM;
-        struct of_gpio_chip *of_gc = &mm_gc->of_gc;
-        struct gpio_chip *gc = &of_gc->gc;
+        struct gpio_chip *gc = &mm_gc->gc;
 
         gc->label = kstrdup(np->full_name, GFP_KERNEL);
         if (!gc->label)
@@ -190,26 +187,19 @@ int of_mm_gpiochip_add(struct device_node *np,
 
         gc->base = -1;
 
-        if (!of_gc->xlate)
-                of_gc->xlate = of_gpio_simple_xlate;
-
         if (mm_gc->save_regs)
                 mm_gc->save_regs(mm_gc);
 
-        np->data = of_gc;
+        mm_gc->gc.of_node = np;
 
         ret = gpiochip_add(gc);
         if (ret)
                 goto err2;
 
-        /* We don't want to lose the node and its ->data */
-        of_node_get(np);
-
         pr_debug("%s: registered as generic GPIO chip, base is %d\n",
                  np->full_name, gc->base);
         return 0;
 err2:
-        np->data = NULL;
         iounmap(mm_gc->regs);
 err1:
         kfree(gc->label);
@@ -219,3 +209,36 @@ err0:
         return ret;
 }
 EXPORT_SYMBOL(of_mm_gpiochip_add);
+
+void of_gpiochip_add(struct gpio_chip *chip)
+{
+        if ((!chip->of_node) && (chip->dev))
+                chip->of_node = chip->dev->of_node;
+
+        if (!chip->of_node)
+                return;
+
+        if (!chip->of_xlate) {
+                chip->of_gpio_n_cells = 2;
+                chip->of_xlate = of_gpio_simple_xlate;
+        }
+
+        of_node_get(chip->of_node);
+}
+
+void of_gpiochip_remove(struct gpio_chip *chip)
+{
+        if (chip->of_node)
+                of_node_put(chip->of_node);
+}
+
+/* Private function for resolving node pointer to gpio_chip */
+static int of_gpiochip_is_match(struct gpio_chip *chip, void *data)
+{
+        return chip->of_node == data;
+}
+
+struct gpio_chip *of_node_to_gpiochip(struct device_node *np)
+{
+        return gpiochip_find(np, of_gpiochip_is_match);
+}
diff --git a/drivers/of/irq.c b/drivers/of/irq.c
new file mode 100644
index 000000000000..6e595e5a3977
--- /dev/null
+++ b/drivers/of/irq.c
@@ -0,0 +1,349 @@
+/*
+ *  Derived from arch/i386/kernel/irq.c
+ *    Copyright (C) 1992 Linus Torvalds
+ *  Adapted from arch/i386 by Gary Thomas
+ *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
+ *  Updated and modified by Cort Dougan <cort@fsmlabs.com>
+ *    Copyright (C) 1996-2001 Cort Dougan
+ *  Adapted for Power Macintosh by Paul Mackerras
+ *    Copyright (C) 1996 Paul Mackerras (paulus@cs.anu.edu.au)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * This file contains the code used to make IRQ descriptions in the
+ * device tree to actual irq numbers on an interrupt controller
+ * driver.
+ */
+
+#include <linux/errno.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_irq.h>
+#include <linux/string.h>
+
+/**
+ * irq_of_parse_and_map - Parse and map an interrupt into linux virq space
+ * @device: Device node of the device whose interrupt is to be mapped
+ * @index: Index of the interrupt to map
+ *
+ * This function is a wrapper that chains of_irq_map_one() and
+ * irq_create_of_mapping() to make things easier to callers
+ */
+unsigned int irq_of_parse_and_map(struct device_node *dev, int index)
+{
+        struct of_irq oirq;
+
+        if (of_irq_map_one(dev, index, &oirq))
+                return NO_IRQ;
+
+        return irq_create_of_mapping(oirq.controller, oirq.specifier,
+                                     oirq.size);
+}
+EXPORT_SYMBOL_GPL(irq_of_parse_and_map);
+
+/**
+ * of_irq_find_parent - Given a device node, find its interrupt parent node
+ * @child: pointer to device node
+ *
+ * Returns a pointer to the interrupt parent node, or NULL if the interrupt
+ * parent could not be determined.
+ */
+static struct device_node *of_irq_find_parent(struct device_node *child)
+{
+        struct device_node *p;
+        const __be32 *parp;
+
+        if (!of_node_get(child))
+                return NULL;
+
+        do {
+                parp = of_get_property(child, "interrupt-parent", NULL);
+                if (parp == NULL)
+                        p = of_get_parent(child);
+                else {
+                        if (of_irq_workarounds & OF_IMAP_NO_PHANDLE)
+                                p = of_node_get(of_irq_dflt_pic);
+                        else
+                                p = of_find_node_by_phandle(be32_to_cpup(parp));
+                }
+                of_node_put(child);
+                child = p;
+        } while (p && of_get_property(p, "#interrupt-cells", NULL) == NULL);
+
+        return p;
+}
+
+/**
+ * of_irq_map_raw - Low level interrupt tree parsing
+ * @parent:     the device interrupt parent
+ * @intspec:    interrupt specifier ("interrupts" property of the device)
+ * @ointsize:   size of the passed in interrupt specifier
+ * @addr:       address specifier (start of "reg" property of the device)
+ * @out_irq:    structure of_irq filled by this function
+ *
+ * Returns 0 on success and a negative number on error
+ *
+ * This function is a low-level interrupt tree walking function. It
+ * can be used to do a partial walk with synthetized reg and interrupts
+ * properties, for example when resolving PCI interrupts when no device
+ * node exist for the parent.
+ */
+int of_irq_map_raw(struct device_node *parent, const __be32 *intspec,
+                   u32 ointsize, const __be32 *addr, struct of_irq *out_irq)
+{
+        struct device_node *ipar, *tnode, *old = NULL, *newpar = NULL;
+        const __be32 *tmp, *imap, *imask;
+        u32 intsize = 1, addrsize, newintsize = 0, newaddrsize = 0;
+        int imaplen, match, i;
+
+        pr_debug("of_irq_map_raw: par=%s,intspec=[0x%08x 0x%08x...],ointsize=%d\n",
+                 parent->full_name, be32_to_cpup(intspec),
+                 be32_to_cpup(intspec + 1), ointsize);
+
+        ipar = of_node_get(parent);
+
+        /* First get the #interrupt-cells property of the current cursor
+         * that tells us how to interpret the passed-in intspec. If there
+         * is none, we are nice and just walk up the tree
+         */
+        do {
+                tmp = of_get_property(ipar, "#interrupt-cells", NULL);
+                if (tmp != NULL) {
+                        intsize = be32_to_cpu(*tmp);
+                        break;
+                }
+                tnode = ipar;
+                ipar = of_irq_find_parent(ipar);
+                of_node_put(tnode);
+        } while (ipar);
+        if (ipar == NULL) {
+                pr_debug(" -> no parent found !\n");
+                goto fail;
+        }
+
+        pr_debug("of_irq_map_raw: ipar=%s, size=%d\n", ipar->full_name, intsize);
+
+        if (ointsize != intsize)
+                return -EINVAL;
+
+        /* Look for this #address-cells. We have to implement the old linux
+         * trick of looking for the parent here as some device-trees rely on it
+         */
+        old = of_node_get(ipar);
+        do {
+                tmp = of_get_property(old, "#address-cells", NULL);
+                tnode = of_get_parent(old);
+                of_node_put(old);
+                old = tnode;
+        } while (old && tmp == NULL);
+        of_node_put(old);
+        old = NULL;
+        addrsize = (tmp == NULL) ? 2 : be32_to_cpu(*tmp);
+
+        pr_debug(" -> addrsize=%d\n", addrsize);
+
+        /* Now start the actual "proper" walk of the interrupt tree */
+        while (ipar != NULL) {
+                /* Now check if cursor is an interrupt-controller and if it is
+                 * then we are done
+                 */
+                if (of_get_property(ipar, "interrupt-controller", NULL) !=
+                                NULL) {
+                        pr_debug(" -> got it !\n");
+                        for (i = 0; i < intsize; i++)
+                                out_irq->specifier[i] =
+                                                of_read_number(intspec +i, 1);
+                        out_irq->size = intsize;
+                        out_irq->controller = ipar;
+                        of_node_put(old);
+                        return 0;
+                }
+
+                /* Now look for an interrupt-map */
+                imap = of_get_property(ipar, "interrupt-map", &imaplen);
+                /* No interrupt map, check for an interrupt parent */
+                if (imap == NULL) {
+                        pr_debug(" -> no map, getting parent\n");
+                        newpar = of_irq_find_parent(ipar);
+                        goto skiplevel;
+                }
+                imaplen /= sizeof(u32);
+
+                /* Look for a mask */
+                imask = of_get_property(ipar, "interrupt-map-mask", NULL);
+
+                /* If we were passed no "reg" property and we attempt to parse
+                 * an interrupt-map, then #address-cells must be 0.
+                 * Fail if it's not.
+                 */
+                if (addr == NULL && addrsize != 0) {
+                        pr_debug(" -> no reg passed in when needed !\n");
+                        goto fail;
+                }
+
+                /* Parse interrupt-map */
+                match = 0;
+                while (imaplen > (addrsize + intsize + 1) && !match) {
+                        /* Compare specifiers */
+                        match = 1;
+                        for (i = 0; i < addrsize && match; ++i) {
+                                u32 mask = imask ? imask[i] : 0xffffffffu;
+                                match = ((addr[i] ^ imap[i]) & mask) == 0;
+                        }
+                        for (; i < (addrsize + intsize) && match; ++i) {
+                                u32 mask = imask ? imask[i] : 0xffffffffu;
+                                match =
+                                   ((intspec[i-addrsize] ^ imap[i]) & mask) == 0;
+                        }
+                        imap += addrsize + intsize;
+                        imaplen -= addrsize + intsize;
+
+                        pr_debug(" -> match=%d (imaplen=%d)\n", match, imaplen);
+
+                        /* Get the interrupt parent */
+                        if (of_irq_workarounds & OF_IMAP_NO_PHANDLE)
+                                newpar = of_node_get(of_irq_dflt_pic);
+                        else
+                                newpar = of_find_node_by_phandle(be32_to_cpup(imap));
+                        imap++;
+                        --imaplen;
+
+                        /* Check if not found */
+                        if (newpar == NULL) {
+                                pr_debug(" -> imap parent not found !\n");
+                                goto fail;
+                        }
+
+                        /* Get #interrupt-cells and #address-cells of new
+                         * parent
+                         */
+                        tmp = of_get_property(newpar, "#interrupt-cells", NULL);
+                        if (tmp == NULL) {
+                                pr_debug(" -> parent lacks #interrupt-cells!\n");
+                                goto fail;
+                        }
+                        newintsize = be32_to_cpu(*tmp);
+                        tmp = of_get_property(newpar, "#address-cells", NULL);
+                        newaddrsize = (tmp == NULL) ? 0 : be32_to_cpu(*tmp);
+
+                        pr_debug(" -> newintsize=%d, newaddrsize=%d\n",
+                            newintsize, newaddrsize);
+
+                        /* Check for malformed properties */
+                        if (imaplen < (newaddrsize + newintsize))
+                                goto fail;
+
+                        imap += newaddrsize + newintsize;
+                        imaplen -= newaddrsize + newintsize;
+
+                        pr_debug(" -> imaplen=%d\n", imaplen);
+                }
+                if (!match)
+                        goto fail;
+
+                of_node_put(old);
+                old = of_node_get(newpar);
+                addrsize = newaddrsize;
+                intsize = newintsize;
+                intspec = imap - intsize;
+                addr = intspec - addrsize;
+
+        skiplevel:
+                /* Iterate again with new parent */
+                pr_debug(" -> new parent: %s\n", newpar ? newpar->full_name : "<>");
+                of_node_put(ipar);
+                ipar = newpar;
+                newpar = NULL;
+        }
+ fail:
+        of_node_put(ipar);
+        of_node_put(old);
+        of_node_put(newpar);
+
+        return -EINVAL;
+}
+EXPORT_SYMBOL_GPL(of_irq_map_raw);
+
+/**
+ * of_irq_map_one - Resolve an interrupt for a device
+ * @device: the device whose interrupt is to be resolved
+ * @index: index of the interrupt to resolve
+ * @out_irq: structure of_irq filled by this function
+ *
+ * This function resolves an interrupt, walking the tree, for a given
+ * device-tree node. It's the high level pendant to of_irq_map_raw().
+ */
+int of_irq_map_one(struct device_node *device, int index, struct of_irq *out_irq)
+{
+        struct device_node *p;
+        const __be32 *intspec, *tmp, *addr;
+        u32 intsize, intlen;
+        int res = -EINVAL;
+
+        pr_debug("of_irq_map_one: dev=%s, index=%d\n", device->full_name, index);
+
+        /* OldWorld mac stuff is "special", handle out of line */
+        if (of_irq_workarounds & OF_IMAP_OLDWORLD_MAC)
+                return of_irq_map_oldworld(device, index, out_irq);
+
+        /* Get the interrupts property */
+        intspec = of_get_property(device, "interrupts", &intlen);
+        if (intspec == NULL)
+                return -EINVAL;
+        intlen /= sizeof(*intspec);
+
+        pr_debug(" intspec=%d intlen=%d\n", be32_to_cpup(intspec), intlen);
+
+        /* Get the reg property (if any) */
+        addr = of_get_property(device, "reg", NULL);
+
+        /* Look for the interrupt parent. */
+        p = of_irq_find_parent(device);
+        if (p == NULL)
+                return -EINVAL;
+
+        /* Get size of interrupt specifier */
+        tmp = of_get_property(p, "#interrupt-cells", NULL);
+        if (tmp == NULL)
+                goto out;
+        intsize = be32_to_cpu(*tmp);
+
+        pr_debug(" intsize=%d intlen=%d\n", intsize, intlen);
+
+        /* Check index */
+        if ((index + 1) * intsize > intlen)
+                goto out;
+
+        /* Get new specifier and map it */
+        res = of_irq_map_raw(p, intspec + index * intsize, intsize,
+                             addr, out_irq);
+ out:
+        of_node_put(p);
+        return res;
+}
+EXPORT_SYMBOL_GPL(of_irq_map_one);
+
+/**
+ * of_irq_to_resource - Decode a node's IRQ and return it as a resource
+ * @dev: pointer to device tree node
+ * @index: zero-based index of the irq
+ * @r: pointer to resource structure to return result into.
+ */
+int of_irq_to_resource(struct device_node *dev, int index, struct resource *r)
+{
+        int irq = irq_of_parse_and_map(dev, index);
+
+        /* Only dereference the resource if both the
+         * resource and the irq are valid. */
+        if (r && irq != NO_IRQ) {
+                r->start = r->end = irq;
+                r->flags = IORESOURCE_IRQ;
+                r->name = dev->full_name;
+        }
+
+        return irq;
+}
+EXPORT_SYMBOL_GPL(of_irq_to_resource);
diff --git a/drivers/of/of_i2c.c b/drivers/of/of_i2c.c
index ab6522c8e4fe..0a694debd226 100644
--- a/drivers/of/of_i2c.c
+++ b/drivers/of/of_i2c.c
@@ -14,57 +14,65 @@
 #include <linux/i2c.h>
 #include <linux/of.h>
 #include <linux/of_i2c.h>
+#include <linux/of_irq.h>
 #include <linux/module.h>
 
-void of_register_i2c_devices(struct i2c_adapter *adap,
-                             struct device_node *adap_node)
+void of_i2c_register_devices(struct i2c_adapter *adap)
 {
         void *result;
         struct device_node *node;
 
-        for_each_child_of_node(adap_node, node) {
+        /* Only register child devices if the adapter has a node pointer set */
+        if (!adap->dev.of_node)
+                return;
+
+        dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");
+
+        for_each_child_of_node(adap->dev.of_node, node) {
                 struct i2c_board_info info = {};
                 struct dev_archdata dev_ad = {};
                 const __be32 *addr;
                 int len;
 
-                if (of_modalias_node(node, info.type, sizeof(info.type)) < 0)
+                dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);
+
+                if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
+                        dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
+                                node->full_name);
                         continue;
+                }
 
                 addr = of_get_property(node, "reg", &len);
-                if (!addr || len < sizeof(int) || *addr > (1 << 10) - 1) {
-                        printk(KERN_ERR
-                               "of-i2c: invalid i2c device entry\n");
+                if (!addr || (len < sizeof(int))) {
+                        dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
+                                node->full_name);
                         continue;
                 }
 
-                info.irq = irq_of_parse_and_map(node, 0);
-
                 info.addr = be32_to_cpup(addr);
+                if (info.addr > (1 << 10) - 1) {
+                        dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
+                                info.addr, node->full_name);
+                        continue;
+                }
 
-                info.of_node = node;
+                info.irq = irq_of_parse_and_map(node, 0);
+                info.of_node = of_node_get(node);
                 info.archdata = &dev_ad;
 
                 request_module("%s", info.type);
 
                 result = i2c_new_device(adap, &info);
                 if (result == NULL) {
-                        printk(KERN_ERR
-                               "of-i2c: Failed to load driver for %s\n",
-                               info.type);
+                        dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
+                                node->full_name);
+                        of_node_put(node);
                         irq_dispose_mapping(info.irq);
                         continue;
                 }
-
-                /*
-                 * Get the node to not lose the dev_archdata->of_node.
-                 * Currently there is no way to put it back, as well as no
-                 * of_unregister_i2c_devices() call.
-                 */
-                of_node_get(node);
         }
 }
-EXPORT_SYMBOL(of_register_i2c_devices);
+EXPORT_SYMBOL(of_i2c_register_devices);
 
 static int of_dev_node_match(struct device *dev, void *data)
 {
diff --git a/drivers/of/of_mdio.c b/drivers/of/of_mdio.c
index 42a6715f8e84..1fce00eb421b 100644
--- a/drivers/of/of_mdio.c
+++ b/drivers/of/of_mdio.c
@@ -15,6 +15,7 @@
 #include <linux/err.h>
 #include <linux/phy.h>
 #include <linux/of.h>
+#include <linux/of_irq.h>
 #include <linux/of_mdio.h>
 #include <linux/module.h>
 
diff --git a/drivers/of/of_spi.c b/drivers/of/of_spi.c
index 5fed7e3c7da3..1dbce58a58b0 100644
--- a/drivers/of/of_spi.c
+++ b/drivers/of/of_spi.c
@@ -9,17 +9,17 @@
 #include <linux/of.h>
 #include <linux/device.h>
 #include <linux/spi/spi.h>
+#include <linux/of_irq.h>
 #include <linux/of_spi.h>
 
 /**
  * of_register_spi_devices - Register child devices onto the SPI bus
  * @master:     Pointer to spi_master device
- * @np:         parent node of SPI device nodes
  *
- * Registers an spi_device for each child node of 'np' which has a 'reg'
+ * Registers an spi_device for each child node of master node which has a 'reg'
  * property.
  */
-void of_register_spi_devices(struct spi_master *master, struct device_node *np)
+void of_register_spi_devices(struct spi_master *master)
 {
         struct spi_device *spi;
         struct device_node *nc;
@@ -27,7 +27,10 @@ void of_register_spi_devices(struct spi_master *master, struct device_node *np)
         int rc;
         int len;
 
-        for_each_child_of_node(np, nc) {
+        if (!master->dev.of_node)
+                return;
+
+        for_each_child_of_node(master->dev.of_node, nc) {
                 /* Alloc an spi_device */
                 spi = spi_alloc_device(master);
                 if (!spi) {
diff --git a/drivers/of/platform.c b/drivers/of/platform.c
index 7dacc1ebe91e..bb72223c22ae 100644
--- a/drivers/of/platform.c
+++ b/drivers/of/platform.c
@@ -14,8 +14,105 @@
 #include <linux/errno.h>
 #include <linux/module.h>
 #include <linux/device.h>
+#include <linux/dma-mapping.h>
+#include <linux/slab.h>
+#include <linux/of_address.h>
 #include <linux/of_device.h>
+#include <linux/of_irq.h>
 #include <linux/of_platform.h>
+#include <linux/platform_device.h>
+
+static int of_dev_node_match(struct device *dev, void *data)
+{
+        return dev->of_node == data;
+}
+
+/**
+ * of_find_device_by_node - Find the platform_device associated with a node
+ * @np: Pointer to device tree node
+ *
+ * Returns platform_device pointer, or NULL if not found
+ */
+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);
+        return dev ? to_platform_device(dev) : NULL;
+}
+EXPORT_SYMBOL(of_find_device_by_node);
+
+static int platform_driver_probe_shim(struct platform_device *pdev)
+{
+        struct platform_driver *pdrv;
+        struct of_platform_driver *ofpdrv;
+        const struct of_device_id *match;
+
+        pdrv = container_of(pdev->dev.driver, struct platform_driver, driver);
+        ofpdrv = container_of(pdrv, struct of_platform_driver, platform_driver);
+
+        /* There is an unlikely chance that an of_platform driver might match
+         * on a non-OF platform device.  If so, then of_match_device() will
+         * come up empty.  Return -EINVAL in this case so other drivers get
+         * the chance to bind. */
+        match = of_match_device(pdev->dev.driver->of_match_table, &pdev->dev);
+        return match ? ofpdrv->probe(pdev, match) : -EINVAL;
+}
+
+static void platform_driver_shutdown_shim(struct platform_device *pdev)
+{
+        struct platform_driver *pdrv;
+        struct of_platform_driver *ofpdrv;
+
+        pdrv = container_of(pdev->dev.driver, struct platform_driver, driver);
+        ofpdrv = container_of(pdrv, struct of_platform_driver, platform_driver);
+        ofpdrv->shutdown(pdev);
+}
+
+/**
+ * of_register_platform_driver
+ */
+int of_register_platform_driver(struct of_platform_driver *drv)
+{
+        char *of_name;
+
+        /* setup of_platform_driver to platform_driver adaptors */
+        drv->platform_driver.driver = drv->driver;
+
+        /* Prefix the driver name with 'of:' to avoid namespace collisions
+         * and bogus matches.  There are some drivers in the tree that
+         * register both an of_platform_driver and a platform_driver with
+         * the same name.  This is a temporary measure until they are all
+         * cleaned up --gcl July 29, 2010 */
+        of_name = kmalloc(strlen(drv->driver.name) + 5, GFP_KERNEL);
+        if (!of_name)
+                return -ENOMEM;
+        sprintf(of_name, "of:%s", drv->driver.name);
+        drv->platform_driver.driver.name = of_name;
+
+        if (drv->probe)
+                drv->platform_driver.probe = platform_driver_probe_shim;
+        drv->platform_driver.remove = drv->remove;
+        if (drv->shutdown)
+                drv->platform_driver.shutdown = platform_driver_shutdown_shim;
+        drv->platform_driver.suspend = drv->suspend;
+        drv->platform_driver.resume = drv->resume;
+
+        return platform_driver_register(&drv->platform_driver);
+}
+EXPORT_SYMBOL(of_register_platform_driver);
+
+void of_unregister_platform_driver(struct of_platform_driver *drv)
+{
+        platform_driver_unregister(&drv->platform_driver);
+        kfree(drv->platform_driver.driver.name);
+        drv->platform_driver.driver.name = NULL;
+}
+EXPORT_SYMBOL(of_unregister_platform_driver);
+
+#if defined(CONFIG_PPC_DCR)
+#include <asm/dcr.h>
+#endif
 
 extern struct device_attribute of_platform_device_attrs[];
 
@@ -33,11 +130,11 @@ static int of_platform_device_probe(struct device *dev)
 {
         int error = -ENODEV;
         struct of_platform_driver *drv;
-        struct of_device *of_dev;
+        struct platform_device *of_dev;
         const struct of_device_id *match;
 
         drv = to_of_platform_driver(dev->driver);
-        of_dev = to_of_device(dev);
+        of_dev = to_platform_device(dev);
 
         if (!drv->probe)
                 return error;
@@ -55,7 +152,7 @@ static int of_platform_device_probe(struct device *dev)
 
 static int of_platform_device_remove(struct device *dev)
 {
-        struct of_device *of_dev = to_of_device(dev);
+        struct platform_device *of_dev = to_platform_device(dev);
         struct of_platform_driver *drv = to_of_platform_driver(dev->driver);
 
         if (dev->driver && drv->remove)
@@ -65,7 +162,7 @@ static int of_platform_device_remove(struct device *dev)
 
 static void of_platform_device_shutdown(struct device *dev)
 {
-        struct of_device *of_dev = to_of_device(dev);
+        struct platform_device *of_dev = to_platform_device(dev);
         struct of_platform_driver *drv = to_of_platform_driver(dev->driver);
 
         if (dev->driver && drv->shutdown)
@@ -76,7 +173,7 @@ static void of_platform_device_shutdown(struct device *dev)
 
 static int of_platform_legacy_suspend(struct device *dev, pm_message_t mesg)
 {
-        struct of_device *of_dev = to_of_device(dev);
+        struct platform_device *of_dev = to_platform_device(dev);
         struct of_platform_driver *drv = to_of_platform_driver(dev->driver);
         int ret = 0;
 
@@ -87,7 +184,7 @@ static int of_platform_legacy_suspend(struct device *dev, pm_message_t mesg)
 
 static int of_platform_legacy_resume(struct device *dev)
 {
-        struct of_device *of_dev = to_of_device(dev);
+        struct platform_device *of_dev = to_platform_device(dev);
         struct of_platform_driver *drv = to_of_platform_driver(dev->driver);
         int ret = 0;
 
@@ -384,15 +481,286 @@ int of_bus_type_init(struct bus_type *bus, const char *name)
 
 int of_register_driver(struct of_platform_driver *drv, struct bus_type *bus)
 {
-        drv->driver.bus = bus;
+        /*
+         * Temporary: of_platform_bus used to be distinct from the platform
+         * bus.  It isn't anymore, and so drivers on the platform bus need
+         * to be registered in a special way.
+         *
+         * After all of_platform_bus_type drivers are converted to
+         * platform_drivers, this exception can be removed.
+         */
+        if (bus == &platform_bus_type)
+                return of_register_platform_driver(drv);
 
         /* register with core */
+        drv->driver.bus = bus;
         return driver_register(&drv->driver);
 }
 EXPORT_SYMBOL(of_register_driver);
 
 void of_unregister_driver(struct of_platform_driver *drv)
 {
-        driver_unregister(&drv->driver);
+        if (drv->driver.bus == &platform_bus_type)
+                of_unregister_platform_driver(drv);
+        else
+                driver_unregister(&drv->driver);
 }
 EXPORT_SYMBOL(of_unregister_driver);
+
+#if !defined(CONFIG_SPARC)
+/*
+ * The following routines scan a subtree and registers a device for
+ * each applicable node.
+ *
+ * Note: sparc doesn't use these routines because it has a different
+ * mechanism for creating devices from device tree nodes.
+ */
+
+/**
+ * of_device_make_bus_id - Use the device node data to assign a unique name
+ * @dev: pointer to device structure that is linked to a device tree node
+ *
+ * This routine will first try using either the dcr-reg or the reg property
+ * value to derive a unique name.  As a last resort it will use the node
+ * name followed by a unique number.
+ */
+void of_device_make_bus_id(struct device *dev)
+{
+        static atomic_t bus_no_reg_magic;
+        struct device_node *node = dev->of_node;
+        const u32 *reg;
+        u64 addr;
+        int magic;
+
+#ifdef CONFIG_PPC_DCR
+        /*
+         * If it's a DCR based device, use 'd' for native DCRs
+         * and 'D' for MMIO DCRs.
+         */
+        reg = of_get_property(node, "dcr-reg", NULL);
+        if (reg) {
+#ifdef CONFIG_PPC_DCR_NATIVE
+                dev_set_name(dev, "d%x.%s", *reg, node->name);
+#else /* CONFIG_PPC_DCR_NATIVE */
+                u64 addr = of_translate_dcr_address(node, *reg, NULL);
+                if (addr != OF_BAD_ADDR) {
+                        dev_set_name(dev, "D%llx.%s",
+                                     (unsigned long long)addr, node->name);
+                        return;
+                }
+#endif /* !CONFIG_PPC_DCR_NATIVE */
+        }
+#endif /* CONFIG_PPC_DCR */
+
+        /*
+         * For MMIO, get the physical address
+         */
+        reg = of_get_property(node, "reg", NULL);
+        if (reg) {
+                addr = of_translate_address(node, reg);
+                if (addr != OF_BAD_ADDR) {
+                        dev_set_name(dev, "%llx.%s",
+                                     (unsigned long long)addr, node->name);
+                        return;
+                }
+        }
+
+        /*
+         * No BusID, use the node name and add a globally incremented
+         * counter (and pray...)
+         */
+        magic = atomic_add_return(1, &bus_no_reg_magic);
+        dev_set_name(dev, "%s.%d", node->name, magic - 1);
+}
+
+/**
+ * of_device_alloc - Allocate and initialize an of_device
+ * @np: device node to assign to device
+ * @bus_id: Name to assign to the device.  May be null to use default name.
+ * @parent: Parent device.
+ */
+struct platform_device *of_device_alloc(struct device_node *np,
+                                  const char *bus_id,
+                                  struct device *parent)
+{
+        struct platform_device *dev;
+        int rc, i, num_reg = 0, num_irq = 0;
+        struct resource *res, temp_res;
+
+        /* First count how many resources are needed */
+        while (of_address_to_resource(np, num_reg, &temp_res) == 0)
+                num_reg++;
+        while (of_irq_to_resource(np, num_irq, &temp_res) != NO_IRQ)
+                num_irq++;
+
+        /* Allocate memory for both the struct device and the resource table */
+        dev = kzalloc(sizeof(*dev) + (sizeof(*res) * (num_reg + num_irq)),
+                      GFP_KERNEL);
+        if (!dev)
+                return NULL;
+        res = (struct resource *) &dev[1];
+
+        /* Populate the resource table */
+        if (num_irq || num_reg) {
+                dev->num_resources = num_reg + num_irq;
+                dev->resource = res;
+                for (i = 0; i < num_reg; i++, res++) {
+                        rc = of_address_to_resource(np, i, res);
+                        WARN_ON(rc);
+                }
+                for (i = 0; i < num_irq; i++, res++) {
+                        rc = of_irq_to_resource(np, i, res);
+                        WARN_ON(rc == NO_IRQ);
+                }
+        }
+
+        dev->dev.of_node = of_node_get(np);
+#if defined(CONFIG_PPC) || defined(CONFIG_MICROBLAZE)
+        dev->dev.dma_mask = &dev->archdata.dma_mask;
+#endif
+        dev->dev.parent = parent;
+        dev->dev.release = of_release_dev;
+
+        if (bus_id)
+                dev_set_name(&dev->dev, "%s", bus_id);
+        else
+                of_device_make_bus_id(&dev->dev);
+
+        return dev;
+}
+EXPORT_SYMBOL(of_device_alloc);
+
+/**
+ * of_platform_device_create - Alloc, initialize and register an of_device
+ * @np: pointer to node to create device for
+ * @bus_id: name to assign device
+ * @parent: Linux device model parent device.
+ */
+struct platform_device *of_platform_device_create(struct device_node *np,
+                                            const char *bus_id,
+                                            struct device *parent)
+{
+        struct platform_device *dev;
+
+        dev = of_device_alloc(np, bus_id, parent);
+        if (!dev)
+                return NULL;
+
+#if defined(CONFIG_PPC) || defined(CONFIG_MICROBLAZE)
+        dev->archdata.dma_mask = 0xffffffffUL;
+#endif
+        dev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        dev->dev.bus = &platform_bus_type;
+
+        /* We do not fill the DMA ops for platform devices by default.
+         * This is currently the responsibility of the platform code
+         * to do such, possibly using a device notifier
+         */
+
+        if (of_device_register(dev) != 0) {
+                of_device_free(dev);
+                return NULL;
+        }
+
+        return dev;
+}
+EXPORT_SYMBOL(of_platform_device_create);
+
+/**
+ * of_platform_bus_create - Create an OF device for a bus node and all its
+ * children. Optionally recursively instantiate matching busses.
+ * @bus: device node of the bus to instantiate
+ * @matches: match table, NULL to use the default, OF_NO_DEEP_PROBE to
+ * disallow recursive creation of child busses
+ */
+static int of_platform_bus_create(const struct device_node *bus,
+                                  const struct of_device_id *matches,
+                                  struct device *parent)
+{
+        struct device_node *child;
+        struct platform_device *dev;
+        int rc = 0;
+
+        for_each_child_of_node(bus, child) {
+                pr_debug("   create child: %s\n", child->full_name);
+                dev = of_platform_device_create(child, NULL, parent);
+                if (dev == NULL)
+                        rc = -ENOMEM;
+                else if (!of_match_node(matches, child))
+                        continue;
+                if (rc == 0) {
+                        pr_debug("   and sub busses\n");
+                        rc = of_platform_bus_create(child, matches, &dev->dev);
+                }
+                if (rc) {
+                        of_node_put(child);
+                        break;
+                }
+        }
+        return rc;
+}
+
+/**
+ * of_platform_bus_probe - Probe the device-tree for platform busses
+ * @root: parent of the first level to probe or NULL for the root of the tree
+ * @matches: match table, NULL to use the default
+ * @parent: parent to hook devices from, NULL for toplevel
+ *
+ * Note that children of the provided root are not instantiated as devices
+ * unless the specified root itself matches the bus list and is not NULL.
+ */
+int of_platform_bus_probe(struct device_node *root,
+                          const struct of_device_id *matches,
+                          struct device *parent)
+{
+        struct device_node *child;
+        struct platform_device *dev;
+        int rc = 0;
+
+        if (WARN_ON(!matches || matches == OF_NO_DEEP_PROBE))
+                return -EINVAL;
+        if (root == NULL)
+                root = of_find_node_by_path("/");
+        else
+                of_node_get(root);
+        if (root == NULL)
+                return -EINVAL;
+
+        pr_debug("of_platform_bus_probe()\n");
+        pr_debug(" starting at: %s\n", root->full_name);
+
+        /* Do a self check of bus type, if there's a match, create
+         * children
+         */
+        if (of_match_node(matches, root)) {
+                pr_debug(" root match, create all sub devices\n");
+                dev = of_platform_device_create(root, NULL, parent);
+                if (dev == NULL) {
+                        rc = -ENOMEM;
+                        goto bail;
+                }
+                pr_debug(" create all sub busses\n");
+                rc = of_platform_bus_create(root, matches, &dev->dev);
+                goto bail;
+        }
+        for_each_child_of_node(root, child) {
+                if (!of_match_node(matches, child))
+                        continue;
+
+                pr_debug("  match: %s\n", child->full_name);
+                dev = of_platform_device_create(child, NULL, parent);
+                if (dev == NULL)
+                        rc = -ENOMEM;
+                else
+                        rc = of_platform_bus_create(child, matches, &dev->dev);
+                if (rc) {
+                        of_node_put(child);
+                        break;
+                }
+        }
+ bail:
+        of_node_put(root);
+        return rc;
+}
+EXPORT_SYMBOL(of_platform_bus_probe);
+#endif /* !CONFIG_SPARC */
diff --git a/drivers/parport/parport_sunbpp.c b/drivers/parport/parport_sunbpp.c
index 9a5b4b894161..210a6441a066 100644
--- a/drivers/parport/parport_sunbpp.c
+++ b/drivers/parport/parport_sunbpp.c
@@ -295,7 +295,7 @@ static int __devinit bpp_probe(struct of_device *op, const struct of_device_id *
         void __iomem *base;
         struct parport *p;
 
-        irq = op->irqs[0];
+        irq = op->archdata.irqs[0];
         base = of_ioremap(&op->resource[0], 0,
                           resource_size(&op->resource[0]),
                           "sunbpp");
@@ -393,12 +393,12 @@ static struct of_platform_driver bpp_sbus_driver = {
 
 static int __init parport_sunbpp_init(void)
 {
-        return of_register_driver(&bpp_sbus_driver, &of_bus_type);
+        return of_register_platform_driver(&bpp_sbus_driver);
 }
 
 static void __exit parport_sunbpp_exit(void)
 {
-        of_unregister_driver(&bpp_sbus_driver);
+        of_unregister_platform_driver(&bpp_sbus_driver);
 }
 
 MODULE_AUTHOR("Derrick J Brashear");
diff --git a/drivers/sbus/char/bbc_i2c.c b/drivers/sbus/char/bbc_i2c.c
index 8bfdd63a1fcb..3e89c313e98d 100644
--- a/drivers/sbus/char/bbc_i2c.c
+++ b/drivers/sbus/char/bbc_i2c.c
@@ -317,7 +317,7 @@ static struct bbc_i2c_bus * __init attach_one_i2c(struct of_device *op, int inde
 
         bp->waiting = 0;
         init_waitqueue_head(&bp->wq);
-        if (request_irq(op->irqs[0], bbc_i2c_interrupt,
+        if (request_irq(op->archdata.irqs[0], bbc_i2c_interrupt,
                         IRQF_SHARED, "bbc_i2c", bp))
                 goto fail;
 
@@ -373,7 +373,7 @@ static int __devinit bbc_i2c_probe(struct of_device *op,
 
         err = bbc_envctrl_init(bp);
         if (err) {
-                free_irq(op->irqs[0], bp);
+                free_irq(op->archdata.irqs[0], bp);
                 if (bp->i2c_bussel_reg)
                         of_iounmap(&op->resource[0], bp->i2c_bussel_reg, 1);
                 if (bp->i2c_control_regs)
@@ -392,7 +392,7 @@ static int __devexit bbc_i2c_remove(struct of_device *op)
 
         bbc_envctrl_cleanup(bp);
 
-        free_irq(op->irqs[0], bp);
+        free_irq(op->archdata.irqs[0], bp);
 
         if (bp->i2c_bussel_reg)
                 of_iounmap(&op->resource[0], bp->i2c_bussel_reg, 1);
@@ -425,12 +425,12 @@ static struct of_platform_driver bbc_i2c_driver = {
 
 static int __init bbc_i2c_init(void)
 {
-        return of_register_driver(&bbc_i2c_driver, &of_bus_type);
+        return of_register_platform_driver(&bbc_i2c_driver);
 }
 
 static void __exit bbc_i2c_exit(void)
 {
-        of_unregister_driver(&bbc_i2c_driver);
+        of_unregister_platform_driver(&bbc_i2c_driver);
 }
 
 module_init(bbc_i2c_init);
diff --git a/drivers/sbus/char/display7seg.c b/drivers/sbus/char/display7seg.c
index 4ad4d2c91075..47db97583ea7 100644
--- a/drivers/sbus/char/display7seg.c
+++ b/drivers/sbus/char/display7seg.c
@@ -277,12 +277,12 @@ static struct of_platform_driver d7s_driver = {
 
 static int __init d7s_init(void)
 {
-        return of_register_driver(&d7s_driver, &of_bus_type);
+        return of_register_platform_driver(&d7s_driver);
 }
 
 static void __exit d7s_exit(void)
 {
-        of_unregister_driver(&d7s_driver);
+        of_unregister_platform_driver(&d7s_driver);
 }
 
 module_init(d7s_init);
diff --git a/drivers/sbus/char/envctrl.c b/drivers/sbus/char/envctrl.c
index bd0bbc621351..3c27f45e2b6d 100644
--- a/drivers/sbus/char/envctrl.c
+++ b/drivers/sbus/char/envctrl.c
@@ -1140,12 +1140,12 @@ static struct of_platform_driver envctrl_driver = {
 
 static int __init envctrl_init(void)
 {
-        return of_register_driver(&envctrl_driver, &of_bus_type);
+        return of_register_platform_driver(&envctrl_driver);
 }
 
 static void __exit envctrl_exit(void)
 {
-        of_unregister_driver(&envctrl_driver);
+        of_unregister_platform_driver(&envctrl_driver);
 }
 
 module_init(envctrl_init);
diff --git a/drivers/sbus/char/flash.c b/drivers/sbus/char/flash.c
index ed9494e18859..8bb31c584b64 100644
--- a/drivers/sbus/char/flash.c
+++ b/drivers/sbus/char/flash.c
@@ -219,12 +219,12 @@ static struct of_platform_driver flash_driver = {
 
 static int __init flash_init(void)
 {
-        return of_register_driver(&flash_driver, &of_bus_type);
+        return of_register_platform_driver(&flash_driver);
 }
 
 static void __exit flash_cleanup(void)
 {
-        of_unregister_driver(&flash_driver);
+        of_unregister_platform_driver(&flash_driver);
 }
 
 module_init(flash_init);
diff --git a/drivers/sbus/char/uctrl.c b/drivers/sbus/char/uctrl.c
index 079da4cb45a5..41eb6725ff5f 100644
--- a/drivers/sbus/char/uctrl.c
+++ b/drivers/sbus/char/uctrl.c
@@ -368,7 +368,7 @@ static int __devinit uctrl_probe(struct of_device *op,
                 goto out_free;
         }
 
-        p->irq = op->irqs[0];
+        p->irq = op->archdata.irqs[0];
         err = request_irq(p->irq, uctrl_interrupt, 0, "uctrl", p);
         if (err) {
                 printk(KERN_ERR "uctrl: Unable to register irq.\n");
@@ -438,12 +438,12 @@ static struct of_platform_driver uctrl_driver = {
 
 static int __init uctrl_init(void)
 {
-        return of_register_driver(&uctrl_driver, &of_bus_type);
+        return of_register_platform_driver(&uctrl_driver);
 }
 
 static void __exit uctrl_exit(void)
 {
-        of_unregister_driver(&uctrl_driver);
+        of_unregister_platform_driver(&uctrl_driver);
 }
 
 module_init(uctrl_init);
diff --git a/drivers/scsi/qlogicpti.c b/drivers/scsi/qlogicpti.c
index ca5c15c779cf..53d7ed0dc169 100644
--- a/drivers/scsi/qlogicpti.c
+++ b/drivers/scsi/qlogicpti.c
@@ -729,7 +729,7 @@ static int __devinit qpti_register_irq(struct qlogicpti *qpti)
 {
         struct of_device *op = qpti->op;
 
-        qpti->qhost->irq = qpti->irq = op->irqs[0];
+        qpti->qhost->irq = qpti->irq = op->archdata.irqs[0];
 
         /* We used to try various overly-clever things to
          * reduce the interrupt processing overhead on
@@ -1302,7 +1302,7 @@ static int __devinit qpti_sbus_probe(struct of_device *op, const struct of_devic
         /* Sometimes Antares cards come up not completely
          * setup, and we get a report of a zero IRQ.
          */
-        if (op->irqs[0] == 0)
+        if (op->archdata.irqs[0] == 0)
                 return -ENODEV;
 
         host = scsi_host_alloc(tpnt, sizeof(struct qlogicpti));
@@ -1467,12 +1467,12 @@ static struct of_platform_driver qpti_sbus_driver = {
 
 static int __init qpti_init(void)
 {
-        return of_register_driver(&qpti_sbus_driver, &of_bus_type);
+        return of_register_platform_driver(&qpti_sbus_driver);
 }
 
 static void __exit qpti_exit(void)
 {
-        of_unregister_driver(&qpti_sbus_driver);
+        of_unregister_platform_driver(&qpti_sbus_driver);
 }
 
 MODULE_DESCRIPTION("QlogicISP SBUS driver");
diff --git a/drivers/scsi/sun_esp.c b/drivers/scsi/sun_esp.c
index 386dd9d602b6..89ba6fe02f80 100644
--- a/drivers/scsi/sun_esp.c
+++ b/drivers/scsi/sun_esp.c
@@ -116,7 +116,7 @@ static int __devinit esp_sbus_register_irq(struct esp *esp)
         struct Scsi_Host *host = esp->host;
         struct of_device *op = esp->dev;
 
-        host->irq = op->irqs[0];
+        host->irq = op->archdata.irqs[0];
         return request_irq(host->irq, scsi_esp_intr, IRQF_SHARED, "ESP", esp);
 }
 
@@ -644,12 +644,12 @@ static struct of_platform_driver esp_sbus_driver = {
 
 static int __init sunesp_init(void)
 {
-        return of_register_driver(&esp_sbus_driver, &of_bus_type);
+        return of_register_platform_driver(&esp_sbus_driver);
 }
 
 static void __exit sunesp_exit(void)
 {
-        of_unregister_driver(&esp_sbus_driver);
+        of_unregister_platform_driver(&esp_sbus_driver);
 }
 
 MODULE_DESCRIPTION("Sun ESP SCSI driver");
diff --git a/drivers/serial/sunhv.c b/drivers/serial/sunhv.c
index 890f91742962..a779e22d213e 100644
--- a/drivers/serial/sunhv.c
+++ b/drivers/serial/sunhv.c
@@ -525,7 +525,7 @@ static int __devinit hv_probe(struct of_device *op, const struct of_device_id *m
         unsigned long minor;
         int err;
 
-        if (op->irqs[0] == 0xffffffff)
+        if (op->archdata.irqs[0] == 0xffffffff)
                 return -ENODEV;
 
         port = kzalloc(sizeof(struct uart_port), GFP_KERNEL);
@@ -557,7 +557,7 @@ static int __devinit hv_probe(struct of_device *op, const struct of_device_id *m
 
         port->membase = (unsigned char __iomem *) __pa(port);
 
-        port->irq = op->irqs[0];
+        port->irq = op->archdata.irqs[0];
 
         port->dev = &op->dev;
 
@@ -644,12 +644,12 @@ static int __init sunhv_init(void)
         if (tlb_type != hypervisor)
                 return -ENODEV;
 
-        return of_register_driver(&hv_driver, &of_bus_type);
+        return of_register_platform_driver(&hv_driver);
 }
 
 static void __exit sunhv_exit(void)
 {
-        of_unregister_driver(&hv_driver);
+        of_unregister_platform_driver(&hv_driver);
 }
 
 module_init(sunhv_init);
diff --git a/drivers/serial/sunsab.c b/drivers/serial/sunsab.c
index 5e81bc6b48b0..9845fb1cfb1f 100644
--- a/drivers/serial/sunsab.c
+++ b/drivers/serial/sunsab.c
@@ -969,7 +969,7 @@ static int __devinit sunsab_init_one(struct uart_sunsab_port *up,
                 return -ENOMEM;
         up->regs = (union sab82532_async_regs __iomem *) up->port.membase;
 
-        up->port.irq = op->irqs[0];
+        up->port.irq = op->archdata.irqs[0];
 
         up->port.fifosize = SAB82532_XMIT_FIFO_SIZE;
         up->port.iotype = UPIO_MEM;
@@ -1130,12 +1130,12 @@ static int __init sunsab_init(void)
                 }
         }
 
-        return of_register_driver(&sab_driver, &of_bus_type);
+        return of_register_platform_driver(&sab_driver);
 }
 
 static void __exit sunsab_exit(void)
 {
-        of_unregister_driver(&sab_driver);
+        of_unregister_platform_driver(&sab_driver);
         if (sunsab_reg.nr) {
                 sunserial_unregister_minors(&sunsab_reg, sunsab_reg.nr);
         }
diff --git a/drivers/serial/sunsu.c b/drivers/serial/sunsu.c
index ffbf4553f665..3cdf74822db5 100644
--- a/drivers/serial/sunsu.c
+++ b/drivers/serial/sunsu.c
@@ -1443,7 +1443,7 @@ static int __devinit su_probe(struct of_device *op, const struct of_device_id *m
                 return -ENOMEM;
         }
 
-        up->port.irq = op->irqs[0];
+        up->port.irq = op->archdata.irqs[0];
 
         up->port.dev = &op->dev;
 
@@ -1586,7 +1586,7 @@ static int __init sunsu_init(void)
                         return err;
         }
 
-        err = of_register_driver(&su_driver, &of_bus_type);
+        err = of_register_platform_driver(&su_driver);
         if (err && num_uart)
                 sunserial_unregister_minors(&sunsu_reg, num_uart);
 
diff --git a/drivers/serial/sunzilog.c b/drivers/serial/sunzilog.c
index f9a24f4ebb34..d1e6bcb59546 100644
--- a/drivers/serial/sunzilog.c
+++ b/drivers/serial/sunzilog.c
@@ -1426,7 +1426,7 @@ static int __devinit zs_probe(struct of_device *op, const struct of_device_id *m
         rp = sunzilog_chip_regs[inst];
 
         if (zilog_irq == -1)
-                zilog_irq = op->irqs[0];
+                zilog_irq = op->archdata.irqs[0];
 
         up = &sunzilog_port_table[inst * 2];
 
@@ -1434,7 +1434,7 @@ static int __devinit zs_probe(struct of_device *op, const struct of_device_id *m
         up[0].port.mapbase = op->resource[0].start + 0x00;
         up[0].port.membase = (void __iomem *) &rp->channelA;
         up[0].port.iotype = UPIO_MEM;
-        up[0].port.irq = op->irqs[0];
+        up[0].port.irq = op->archdata.irqs[0];
         up[0].port.uartclk = ZS_CLOCK;
         up[0].port.fifosize = 1;
         up[0].port.ops = &sunzilog_pops;
@@ -1451,7 +1451,7 @@ static int __devinit zs_probe(struct of_device *op, const struct of_device_id *m
         up[1].port.mapbase = op->resource[0].start + 0x04;
         up[1].port.membase = (void __iomem *) &rp->channelB;
         up[1].port.iotype = UPIO_MEM;
-        up[1].port.irq = op->irqs[0];
+        up[1].port.irq = op->archdata.irqs[0];
         up[1].port.uartclk = ZS_CLOCK;
         up[1].port.fifosize = 1;
         up[1].port.ops = &sunzilog_pops;
@@ -1492,12 +1492,12 @@ static int __devinit zs_probe(struct of_device *op, const struct of_device_id *m
                        "is a %s\n",
                        dev_name(&op->dev),
                        (unsigned long long) up[0].port.mapbase,
-                       op->irqs[0], sunzilog_type(&up[0].port));
+                       op->archdata.irqs[0], sunzilog_type(&up[0].port));
                 printk(KERN_INFO "%s: Mouse at MMIO 0x%llx (irq = %d) "
                        "is a %s\n",
                        dev_name(&op->dev),
                        (unsigned long long) up[1].port.mapbase,
-                       op->irqs[0], sunzilog_type(&up[1].port));
+                       op->archdata.irqs[0], sunzilog_type(&up[1].port));
                 kbm_inst++;
         }
 
@@ -1576,7 +1576,7 @@ static int __init sunzilog_init(void)
                         goto out_free_tables;
         }
 
-        err = of_register_driver(&zs_driver, &of_bus_type);
+        err = of_register_platform_driver(&zs_driver);
         if (err)
                 goto out_unregister_uart;
 
@@ -1604,7 +1604,7 @@ out:
         return err;
 
 out_unregister_driver:
-        of_unregister_driver(&zs_driver);
+        of_unregister_platform_driver(&zs_driver);
 
 out_unregister_uart:
         if (num_sunzilog) {
@@ -1619,7 +1619,7 @@ out_free_tables:
 
 static void __exit sunzilog_exit(void)
 {
-        of_unregister_driver(&zs_driver);
+        of_unregister_platform_driver(&zs_driver);
 
         if (zilog_irq != -1) {
                 struct uart_sunzilog_port *up = sunzilog_irq_chain;
diff --git a/drivers/serial/uartlite.c b/drivers/serial/uartlite.c
index 8acccd564378..caf085d3a76a 100644
--- a/drivers/serial/uartlite.c
+++ b/drivers/serial/uartlite.c
@@ -21,6 +21,7 @@
 #include <asm/io.h>
 #if defined(CONFIG_OF) && (defined(CONFIG_PPC32) || defined(CONFIG_MICROBLAZE))
 #include <linux/of.h>
+#include <linux/of_address.h>
 #include <linux/of_device.h>
 #include <linux/of_platform.h>
 
diff --git a/drivers/spi/mpc512x_psc_spi.c b/drivers/spi/mpc512x_psc_spi.c
index 2534b1ec3edd..10baac3f8ea5 100644
--- a/drivers/spi/mpc512x_psc_spi.c
+++ b/drivers/spi/mpc512x_psc_spi.c
@@ -19,6 +19,7 @@
 #include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/interrupt.h>
+#include <linux/of_address.h>
 #include <linux/of_platform.h>
 #include <linux/workqueue.h>
 #include <linux/completion.h>
@@ -440,6 +441,7 @@ static int __init mpc512x_psc_spi_do_probe(struct device *dev, u32 regaddr,
         master->setup = mpc512x_psc_spi_setup;
         master->transfer = mpc512x_psc_spi_transfer;
         master->cleanup = mpc512x_psc_spi_cleanup;
+        master->dev.of_node = dev->of_node;
 
         tempp = ioremap(regaddr, size);
         if (!tempp) {
diff --git a/drivers/spi/mpc52xx_psc_spi.c b/drivers/spi/mpc52xx_psc_spi.c
index 7104cb739da7..66d170147dcc 100644
--- a/drivers/spi/mpc52xx_psc_spi.c
+++ b/drivers/spi/mpc52xx_psc_spi.c
@@ -16,8 +16,8 @@
 #include <linux/types.h>
 #include <linux/errno.h>
 #include <linux/interrupt.h>
+#include <linux/of_address.h>
 #include <linux/of_platform.h>
-#include <linux/of_spi.h>
 #include <linux/workqueue.h>
 #include <linux/completion.h>
 #include <linux/io.h>
@@ -398,6 +398,7 @@ static int __init mpc52xx_psc_spi_do_probe(struct device *dev, u32 regaddr,
         master->setup = mpc52xx_psc_spi_setup;
         master->transfer = mpc52xx_psc_spi_transfer;
         master->cleanup = mpc52xx_psc_spi_cleanup;
+        master->dev.of_node = dev->of_node;
 
         mps->psc = ioremap(regaddr, size);
         if (!mps->psc) {
@@ -470,7 +471,6 @@ static int __init mpc52xx_psc_spi_of_probe(struct of_device *op,
         const u32 *regaddr_p;
         u64 regaddr64, size64;
         s16 id = -1;
-        int rc;
 
         regaddr_p = of_get_address(op->dev.of_node, 0, &size64, NULL);
         if (!regaddr_p) {
@@ -491,13 +491,8 @@ static int __init mpc52xx_psc_spi_of_probe(struct of_device *op,
                 id = *psc_nump + 1;
         }
 
-        rc = mpc52xx_psc_spi_do_probe(&op->dev, (u32)regaddr64, (u32)size64,
+        return mpc52xx_psc_spi_do_probe(&op->dev, (u32)regaddr64, (u32)size64,
                                 irq_of_parse_and_map(op->dev.of_node, 0), id);
-        if (rc == 0)
-                of_register_spi_devices(dev_get_drvdata(&op->dev),
-                                        op->dev.of_node);
-
-        return rc;
 }
 
 static int __exit mpc52xx_psc_spi_of_remove(struct of_device *op)
diff --git a/drivers/spi/mpc52xx_spi.c b/drivers/spi/mpc52xx_spi.c
index b1a76bff775f..56136ff00e01 100644
--- a/drivers/spi/mpc52xx_spi.c
+++ b/drivers/spi/mpc52xx_spi.c
@@ -18,7 +18,6 @@
 #include <linux/interrupt.h>
 #include <linux/delay.h>
 #include <linux/spi/spi.h>
-#include <linux/of_spi.h>
 #include <linux/io.h>
 #include <linux/of_gpio.h>
 #include <linux/slab.h>
@@ -439,6 +438,7 @@ static int __devinit mpc52xx_spi_probe(struct of_device *op,
         master->setup = mpc52xx_spi_setup;
         master->transfer = mpc52xx_spi_transfer;
         master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_LSB_FIRST;
+        master->dev.of_node = op->dev.of_node;
 
         dev_set_drvdata(&op->dev, master);
 
@@ -512,7 +512,6 @@ static int __devinit mpc52xx_spi_probe(struct of_device *op,
         if (rc)
                 goto err_register;
 
-        of_register_spi_devices(master, op->dev.of_node);
         dev_info(&ms->master->dev, "registered MPC5200 SPI bus\n");
 
         return rc;
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index b3a1f9259b62..1bb1b88780ce 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -26,6 +26,7 @@
 #include <linux/slab.h>
 #include <linux/mod_devicetable.h>
 #include <linux/spi/spi.h>
+#include <linux/of_spi.h>
 
 
 /* SPI bustype and spi_master class are registered after board init code
@@ -540,6 +541,9 @@ int spi_register_master(struct spi_master *master)
         /* populate children from any spi device tables */
         scan_boardinfo(master);
         status = 0;
+
+        /* Register devices from the device tree */
+        of_register_spi_devices(master);
 done:
         return status;
 }
diff --git a/drivers/spi/spi_mpc8xxx.c b/drivers/spi/spi_mpc8xxx.c
index 97ab0a81338a..aad9ae1b9c69 100644
--- a/drivers/spi/spi_mpc8xxx.c
+++ b/drivers/spi/spi_mpc8xxx.c
@@ -38,7 +38,6 @@
 #include <linux/of_platform.h>
 #include <linux/gpio.h>
 #include <linux/of_gpio.h>
-#include <linux/of_spi.h>
 #include <linux/slab.h>
 
 #include <sysdev/fsl_soc.h>
@@ -1009,6 +1008,7 @@ mpc8xxx_spi_probe(struct device *dev, struct resource *mem, unsigned int irq)
         master->setup = mpc8xxx_spi_setup;
         master->transfer = mpc8xxx_spi_transfer;
         master->cleanup = mpc8xxx_spi_cleanup;
+        master->dev.of_node = dev->of_node;
 
         mpc8xxx_spi = spi_master_get_devdata(master);
         mpc8xxx_spi->dev = dev;
@@ -1299,8 +1299,6 @@ static int __devinit of_mpc8xxx_spi_probe(struct of_device *ofdev,
                 goto err;
         }
 
-        of_register_spi_devices(master, np);
-
         return 0;
 
 err:
diff --git a/drivers/spi/spi_ppc4xx.c b/drivers/spi/spi_ppc4xx.c
index d53466a249d9..0f5fa7e2a550 100644
--- a/drivers/spi/spi_ppc4xx.c
+++ b/drivers/spi/spi_ppc4xx.c
@@ -407,6 +407,7 @@ static int __init spi_ppc4xx_of_probe(struct of_device *op,
         master = spi_alloc_master(dev, sizeof *hw);
         if (master == NULL)
                 return -ENOMEM;
+        master->dev.of_node = np;
         dev_set_drvdata(dev, master);
         hw = spi_master_get_devdata(master);
         hw->master = spi_master_get(master);
@@ -545,7 +546,6 @@ static int __init spi_ppc4xx_of_probe(struct of_device *op,
         }
 
         dev_info(dev, "driver initialized\n");
-        of_register_spi_devices(master, np);
 
         return 0;
 
diff --git a/drivers/spi/xilinx_spi.c b/drivers/spi/xilinx_spi.c
index 1b47363cb73f..80f2db5bcfd6 100644
--- a/drivers/spi/xilinx_spi.c
+++ b/drivers/spi/xilinx_spi.c
@@ -390,6 +390,9 @@ struct spi_master *xilinx_spi_init(struct device *dev, struct resource *mem,
 
         master->bus_num = bus_num;
         master->num_chipselect = pdata->num_chipselect;
+#ifdef CONFIG_OF
+        master->dev.of_node = dev->of_node;
+#endif
 
         xspi->mem = *mem;
         xspi->irq = irq;
diff --git a/drivers/spi/xilinx_spi_of.c b/drivers/spi/xilinx_spi_of.c
index 4654805b08d8..f53d3f6b9f61 100644
--- a/drivers/spi/xilinx_spi_of.c
+++ b/drivers/spi/xilinx_spi_of.c
@@ -29,6 +29,7 @@
 #include <linux/io.h>
 #include <linux/slab.h>
 
+#include <linux/of_address.h>
 #include <linux/of_platform.h>
 #include <linux/of_device.h>
 #include <linux/of_spi.h>
@@ -80,9 +81,6 @@ static int __devinit xilinx_spi_of_probe(struct of_device *ofdev,
 
         dev_set_drvdata(&ofdev->dev, master);
 
-        /* Add any subnodes on the SPI bus */
-        of_register_spi_devices(master, ofdev->dev.of_node);
-
         return 0;
 }
 
diff --git a/drivers/usb/gadget/fsl_qe_udc.c b/drivers/usb/gadget/fsl_qe_udc.c
index 82506ca297d5..9648b75f0283 100644
--- a/drivers/usb/gadget/fsl_qe_udc.c
+++ b/drivers/usb/gadget/fsl_qe_udc.c
@@ -32,6 +32,7 @@
 #include <linux/interrupt.h>
 #include <linux/io.h>
 #include <linux/moduleparam.h>
+#include <linux/of_address.h>
 #include <linux/of_platform.h>
 #include <linux/dma-mapping.h>
 #include <linux/usb/ch9.h>
diff --git a/drivers/video/bw2.c b/drivers/video/bw2.c
index 09f1b9b462f4..c7796637bafd 100644
--- a/drivers/video/bw2.c
+++ b/drivers/video/bw2.c
@@ -390,12 +390,12 @@ static int __init bw2_init(void)
         if (fb_get_options("bw2fb", NULL))
                 return -ENODEV;
 
-        return of_register_driver(&bw2_driver, &of_bus_type);
+        return of_register_platform_driver(&bw2_driver);
 }
 
 static void __exit bw2_exit(void)
 {
-        of_unregister_driver(&bw2_driver);
+        of_unregister_platform_driver(&bw2_driver);
 }
 
 module_init(bw2_init);
diff --git a/drivers/video/cg14.c b/drivers/video/cg14.c
index e5dc2241194f..d09fde8beb69 100644
--- a/drivers/video/cg14.c
+++ b/drivers/video/cg14.c
@@ -610,12 +610,12 @@ static int __init cg14_init(void)
         if (fb_get_options("cg14fb", NULL))
                 return -ENODEV;
 
-        return of_register_driver(&cg14_driver, &of_bus_type);
+        return of_register_platform_driver(&cg14_driver);
 }
 
 static void __exit cg14_exit(void)
 {
-        of_unregister_driver(&cg14_driver);
+        of_unregister_platform_driver(&cg14_driver);
 }
 
 module_init(cg14_init);
diff --git a/drivers/video/cg3.c b/drivers/video/cg3.c
index 558d73a948a0..64aa29809fb9 100644
--- a/drivers/video/cg3.c
+++ b/drivers/video/cg3.c
@@ -477,12 +477,12 @@ static int __init cg3_init(void)
         if (fb_get_options("cg3fb", NULL))
                 return -ENODEV;
 
-        return of_register_driver(&cg3_driver, &of_bus_type);
+        return of_register_platform_driver(&cg3_driver);
 }
 
 static void __exit cg3_exit(void)
 {
-        of_unregister_driver(&cg3_driver);
+        of_unregister_platform_driver(&cg3_driver);
 }
 
 module_init(cg3_init);
diff --git a/drivers/video/cg6.c b/drivers/video/cg6.c
index 480d761a27a8..2389a719dcc7 100644
--- a/drivers/video/cg6.c
+++ b/drivers/video/cg6.c
@@ -870,12 +870,12 @@ static int __init cg6_init(void)
         if (fb_get_options("cg6fb", NULL))
                 return -ENODEV;
 
-        return of_register_driver(&cg6_driver, &of_bus_type);
+        return of_register_platform_driver(&cg6_driver);
 }
 
 static void __exit cg6_exit(void)
 {
-        of_unregister_driver(&cg6_driver);
+        of_unregister_platform_driver(&cg6_driver);
 }
 
 module_init(cg6_init);
diff --git a/drivers/video/controlfb.c b/drivers/video/controlfb.c
index 49fcbe8f18ac..c225dcce89e7 100644
--- a/drivers/video/controlfb.c
+++ b/drivers/video/controlfb.c
@@ -40,6 +40,8 @@
 #include <linux/vmalloc.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
 #include <linux/fb.h>
 #include <linux/init.h>
 #include <linux/pci.h>
diff --git a/drivers/video/ffb.c b/drivers/video/ffb.c
index 95c0227f47fc..f6ecfab296d3 100644
--- a/drivers/video/ffb.c
+++ b/drivers/video/ffb.c
@@ -1067,12 +1067,12 @@ static int __init ffb_init(void)
         if (fb_get_options("ffb", NULL))
                 return -ENODEV;
 
-        return of_register_driver(&ffb_driver, &of_bus_type);
+        return of_register_platform_driver(&ffb_driver);
 }
 
 static void __exit ffb_exit(void)
 {
-        of_unregister_driver(&ffb_driver);
+        of_unregister_platform_driver(&ffb_driver);
 }
 
 module_init(ffb_init);
diff --git a/drivers/video/leo.c b/drivers/video/leo.c
index 9e8bf7d5e249..ad677637ffbb 100644
--- a/drivers/video/leo.c
+++ b/drivers/video/leo.c
@@ -677,12 +677,12 @@ static int __init leo_init(void)
         if (fb_get_options("leofb", NULL))
                 return -ENODEV;
 
-        return of_register_driver(&leo_driver, &of_bus_type);
+        return of_register_platform_driver(&leo_driver);
 }
 
 static void __exit leo_exit(void)
 {
-        of_unregister_driver(&leo_driver);
+        of_unregister_platform_driver(&leo_driver);
 }
 
 module_init(leo_init);
diff --git a/drivers/video/offb.c b/drivers/video/offb.c
index 46dda7d8aaee..cb163a5397be 100644
--- a/drivers/video/offb.c
+++ b/drivers/video/offb.c
@@ -19,13 +19,14 @@
 #include <linux/mm.h>
 #include <linux/vmalloc.h>
 #include <linux/delay.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
 #include <linux/interrupt.h>
 #include <linux/fb.h>
 #include <linux/init.h>
 #include <linux/ioport.h>
 #include <linux/pci.h>
 #include <asm/io.h>
-#include <asm/prom.h>
 
 #ifdef CONFIG_PPC64
 #include <asm/pci-bridge.h>
diff --git a/drivers/video/p9100.c b/drivers/video/p9100.c
index 6552751e81aa..688b055abab2 100644
--- a/drivers/video/p9100.c
+++ b/drivers/video/p9100.c
@@ -367,12 +367,12 @@ static int __init p9100_init(void)
         if (fb_get_options("p9100fb", NULL))
                 return -ENODEV;
 
-        return of_register_driver(&p9100_driver, &of_bus_type);
+        return of_register_platform_driver(&p9100_driver);
 }
 
 static void __exit p9100_exit(void)
 {
-        of_unregister_driver(&p9100_driver);
+        of_unregister_platform_driver(&p9100_driver);
 }
 
 module_init(p9100_init);
diff --git a/drivers/video/sunxvr1000.c b/drivers/video/sunxvr1000.c
index 489b44e8db81..7288934c0d49 100644
--- a/drivers/video/sunxvr1000.c
+++ b/drivers/video/sunxvr1000.c
@@ -213,12 +213,12 @@ static int __init gfb_init(void)
         if (fb_get_options("gfb", NULL))
                 return -ENODEV;
 
-        return of_register_driver(&gfb_driver, &of_bus_type);
+        return of_register_platform_driver(&gfb_driver);
 }
 
 static void __exit gfb_exit(void)
 {
-        of_unregister_driver(&gfb_driver);
+        of_unregister_platform_driver(&gfb_driver);
 }
 
 module_init(gfb_init);
diff --git a/drivers/video/tcx.c b/drivers/video/tcx.c
index cc039b33d2d8..f375e0db6776 100644
--- a/drivers/video/tcx.c
+++ b/drivers/video/tcx.c
@@ -526,12 +526,12 @@ static int __init tcx_init(void)
         if (fb_get_options("tcxfb", NULL))
                 return -ENODEV;
 
-        return of_register_driver(&tcx_driver, &of_bus_type);
+        return of_register_platform_driver(&tcx_driver);
 }
 
 static void __exit tcx_exit(void)
 {
-        of_unregister_driver(&tcx_driver);
+        of_unregister_platform_driver(&tcx_driver);
 }
 
 module_init(tcx_init);
diff --git a/drivers/watchdog/cpwd.c b/drivers/watchdog/cpwd.c
index d62b9ce8f773..30a2512fd52e 100644
--- a/drivers/watchdog/cpwd.c
+++ b/drivers/watchdog/cpwd.c
@@ -545,7 +545,7 @@ static int __devinit cpwd_probe(struct of_device *op,
                 goto out;
         }
 
-        p->irq = op->irqs[0];
+        p->irq = op->archdata.irqs[0];
 
         spin_lock_init(&p->lock);
 
@@ -688,12 +688,12 @@ static struct of_platform_driver cpwd_driver = {
 
 static int __init cpwd_init(void)
 {
-        return of_register_driver(&cpwd_driver, &of_bus_type);
+        return of_register_platform_driver(&cpwd_driver);
 }
 
 static void __exit cpwd_exit(void)
 {
-        of_unregister_driver(&cpwd_driver);
+        of_unregister_platform_driver(&cpwd_driver);
 }
 
 module_init(cpwd_init);
diff --git a/drivers/watchdog/riowd.c b/drivers/watchdog/riowd.c
index 5dceeddc8859..4082b4ace1fc 100644
--- a/drivers/watchdog/riowd.c
+++ b/drivers/watchdog/riowd.c
@@ -250,12 +250,12 @@ static struct of_platform_driver riowd_driver = {
 
 static int __init riowd_init(void)
 {
-        return of_register_driver(&riowd_driver, &of_bus_type);
+        return of_register_platform_driver(&riowd_driver);
 }
 
 static void __exit riowd_exit(void)
 {
-        of_unregister_driver(&riowd_driver);
+        of_unregister_platform_driver(&riowd_driver);
 }
 
 module_init(riowd_init);