Merge tag 'dt2' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc

Pull "ARM: More device tree support updates" from Olof Johansson:
 "This branch contains a number of updates for device tree support on
  several ARM platforms, in particular:

   * AT91 continues the device tree conversion adding support for a
     number of on-chip drivers and other functionality
   * ux500 adds probing of some of the core SoC blocks through device
     tree
   * Initial device tree support for ST SPEAr600 platforms
   * kirkwood continues the conversion to device-tree probing"

Manually merge arch/arm/mach-ux500/Kconfig due to MACH_U8500 rename, and
drivers/usb/gadget/at91_udc.c due to header file include cleanups.

Also do an "evil merge" for the MACH_U8500 config option rename that the
affected RMI4 touchscreen driver in staging.  It's called MACH_MOP500
now, and it was missed during previous merges.

* tag 'dt2' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc: (48 commits)
  ARM: SPEAr600: Add device-tree support to SPEAr600 boards
  ARM: ux500: Provide local timer support for Device Tree
  ARM: ux500: Enable PL022 SSP Controller in Device Tree
  ARM: ux500: Enable PL310 Level 2 Cache Controller in Device Tree
  ARM: ux500: Enable PL011 AMBA UART Controller for Device Tree
  ARM: ux500: Enable Cortex-A9 GIC (Generic Interrupt Controller) in Device Tree
  ARM: ux500: db8500: list most devices in the snowball device tree
  ARM: ux500: split dts file for snowball into generic part
  ARM: ux500: combine the board init functions for DT boot
  ARM: ux500: Initial Device Tree support for Snowball
  ARM: ux500: CONFIG: Enable Device Tree support for future endeavours
  ARM: kirkwood: use devicetree for rtc-mv
  ARM: kirkwood: rtc-mv devicetree bindings
  ARM: kirkwood: fdt: define uart[01] as disabled, enable uart0
  ARM: kirkwood: fdt: facilitate new boards during fdt migration
  ARM: kirkwood: fdt: absorb kirkwood_init()
  ARM: kirkwood: fdt: use mrvl ticker symbol
  ARM: orion: wdt: use resource vice direct access
  ARM: Kirkwood: Remove tclk from kirkwood_asoc_platform_data.
  ARM: orion: spi: remove enable_clock_fix which is not used
  ...

14 files changed, 452 insertions, 81 deletions

diff --git a/drivers/i2c/busses/i2c-gpio.c b/drivers/i2c/busses/i2c-gpio.c
index a651779d9ff7..c0330a41db03 100644
--- a/drivers/i2c/busses/i2c-gpio.c
+++ b/drivers/i2c/busses/i2c-gpio.c
@@ -14,8 +14,15 @@
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/platform_device.h>
-
-#include <asm/gpio.h>
+#include <linux/gpio.h>
+#include <linux/of_gpio.h>
+#include <linux/of_i2c.h>
+
+struct i2c_gpio_private_data {
+        struct i2c_adapter adap;
+        struct i2c_algo_bit_data bit_data;
+        struct i2c_gpio_platform_data pdata;
+};
 
 /* Toggle SDA by changing the direction of the pin */
 static void i2c_gpio_setsda_dir(void *data, int state)
@@ -78,24 +85,62 @@ static int i2c_gpio_getscl(void *data)
         return gpio_get_value(pdata->scl_pin);
 }
 
+static int __devinit of_i2c_gpio_probe(struct device_node *np,
+                             struct i2c_gpio_platform_data *pdata)
+{
+        u32 reg;
+
+        if (of_gpio_count(np) < 2)
+                return -ENODEV;
+
+        pdata->sda_pin = of_get_gpio(np, 0);
+        pdata->scl_pin = of_get_gpio(np, 1);
+
+        if (!gpio_is_valid(pdata->sda_pin) || !gpio_is_valid(pdata->scl_pin)) {
+                pr_err("%s: invalid GPIO pins, sda=%d/scl=%d\n",
+                       np->full_name, pdata->sda_pin, pdata->scl_pin);
+                return -ENODEV;
+        }
+
+        of_property_read_u32(np, "i2c-gpio,delay-us", &pdata->udelay);
+
+        if (!of_property_read_u32(np, "i2c-gpio,timeout-ms", &reg))
+                pdata->timeout = msecs_to_jiffies(reg);
+
+        pdata->sda_is_open_drain =
+                of_property_read_bool(np, "i2c-gpio,sda-open-drain");
+        pdata->scl_is_open_drain =
+                of_property_read_bool(np, "i2c-gpio,scl-open-drain");
+        pdata->scl_is_output_only =
+                of_property_read_bool(np, "i2c-gpio,scl-output-only");
+
+        return 0;
+}
+
 static int __devinit i2c_gpio_probe(struct platform_device *pdev)
 {
+        struct i2c_gpio_private_data *priv;
         struct i2c_gpio_platform_data *pdata;
         struct i2c_algo_bit_data *bit_data;
         struct i2c_adapter *adap;
         int ret;
 
-        pdata = pdev->dev.platform_data;
-        if (!pdata)
-                return -ENXIO;
-
-        ret = -ENOMEM;
-        adap = kzalloc(sizeof(struct i2c_adapter), GFP_KERNEL);
-        if (!adap)
-                goto err_alloc_adap;
-        bit_data = kzalloc(sizeof(struct i2c_algo_bit_data), GFP_KERNEL);
-        if (!bit_data)
-                goto err_alloc_bit_data;
+        priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+        adap = &priv->adap;
+        bit_data = &priv->bit_data;
+        pdata = &priv->pdata;
+
+        if (pdev->dev.of_node) {
+                ret = of_i2c_gpio_probe(pdev->dev.of_node, pdata);
+                if (ret)
+                        return ret;
+        } else {
+                if (!pdev->dev.platform_data)
+                        return -ENXIO;
+                memcpy(pdata, pdev->dev.platform_data, sizeof(*pdata));
+        }
 
         ret = gpio_request(pdata->sda_pin, "sda");
         if (ret)
@@ -143,6 +188,7 @@ static int __devinit i2c_gpio_probe(struct platform_device *pdev)
         adap->algo_data = bit_data;
         adap->class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
         adap->dev.parent = &pdev->dev;
+        adap->dev.of_node = pdev->dev.of_node;
 
         /*
          * If "dev->id" is negative we consider it as zero.
@@ -154,7 +200,9 @@ static int __devinit i2c_gpio_probe(struct platform_device *pdev)
         if (ret)
                 goto err_add_bus;
 
-        platform_set_drvdata(pdev, adap);
+        of_i2c_register_devices(adap);
+
+        platform_set_drvdata(pdev, priv);
 
         dev_info(&pdev->dev, "using pins %u (SDA) and %u (SCL%s)\n",
                  pdata->sda_pin, pdata->scl_pin,
@@ -168,34 +216,40 @@ err_add_bus:
 err_request_scl:
         gpio_free(pdata->sda_pin);
 err_request_sda:
-        kfree(bit_data);
-err_alloc_bit_data:
-        kfree(adap);
-err_alloc_adap:
         return ret;
 }
 
 static int __devexit i2c_gpio_remove(struct platform_device *pdev)
 {
+        struct i2c_gpio_private_data *priv;
         struct i2c_gpio_platform_data *pdata;
         struct i2c_adapter *adap;
 
-        adap = platform_get_drvdata(pdev);
-        pdata = pdev->dev.platform_data;
+        priv = platform_get_drvdata(pdev);
+        adap = &priv->adap;
+        pdata = &priv->pdata;
 
         i2c_del_adapter(adap);
         gpio_free(pdata->scl_pin);
         gpio_free(pdata->sda_pin);
-        kfree(adap->algo_data);
-        kfree(adap);
 
         return 0;
 }
 
+#if defined(CONFIG_OF)
+static const struct of_device_id i2c_gpio_dt_ids[] = {
+        { .compatible = "i2c-gpio", },
+        { /* sentinel */ }
+};
+
+MODULE_DEVICE_TABLE(of, i2c_gpio_dt_ids);
+#endif
+
 static struct platform_driver i2c_gpio_driver = {
         .driver         = {
                 .name   = "i2c-gpio",
                 .owner  = THIS_MODULE,
+                .of_match_table = of_match_ptr(i2c_gpio_dt_ids),
         },
         .probe          = i2c_gpio_probe,
         .remove         = __devexit_p(i2c_gpio_remove),
diff --git a/drivers/mtd/nand/atmel_nand.c b/drivers/mtd/nand/atmel_nand.c
index 35b4fb55dbd6..ae7e37d9ac17 100644
--- a/drivers/mtd/nand/atmel_nand.c
+++ b/drivers/mtd/nand/atmel_nand.c
@@ -27,6 +27,10 @@
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/platform_device.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/of_gpio.h>
+#include <linux/of_mtd.h>
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/nand.h>
 #include <linux/mtd/partitions.h>
@@ -34,22 +38,10 @@
 #include <linux/dmaengine.h>
 #include <linux/gpio.h>
 #include <linux/io.h>
+#include <linux/platform_data/atmel.h>
 
-#include <mach/board.h>
 #include <mach/cpu.h>
 
-#ifdef CONFIG_MTD_NAND_ATMEL_ECC_HW
-#define hard_ecc        1
-#else
-#define hard_ecc        0
-#endif
-
-#ifdef CONFIG_MTD_NAND_ATMEL_ECC_NONE
-#define no_ecc          1
-#else
-#define no_ecc          0
-#endif
-
 static int use_dma = 1;
 module_param(use_dma, int, 0);
 
@@ -95,7 +87,7 @@ struct atmel_nand_host {
         struct mtd_info         mtd;
         void __iomem            *io_base;
         dma_addr_t              io_phys;
-        struct atmel_nand_data  *board;
+        struct atmel_nand_data  board;
         struct device           *dev;
         void __iomem            *ecc;
 
@@ -113,8 +105,8 @@ static int cpu_has_dma(void)
  */
 static void atmel_nand_enable(struct atmel_nand_host *host)
 {
-        if (gpio_is_valid(host->board->enable_pin))
-                gpio_set_value(host->board->enable_pin, 0);
+        if (gpio_is_valid(host->board.enable_pin))
+                gpio_set_value(host->board.enable_pin, 0);
 }
 
 /*
@@ -122,8 +114,8 @@ static void atmel_nand_enable(struct atmel_nand_host *host)
  */
 static void atmel_nand_disable(struct atmel_nand_host *host)
 {
-        if (gpio_is_valid(host->board->enable_pin))
-                gpio_set_value(host->board->enable_pin, 1);
+        if (gpio_is_valid(host->board.enable_pin))
+                gpio_set_value(host->board.enable_pin, 1);
 }
 
 /*
@@ -144,9 +136,9 @@ static void atmel_nand_cmd_ctrl(struct mtd_info *mtd, int cmd, unsigned int ctrl
                 return;
 
         if (ctrl & NAND_CLE)
-                writeb(cmd, host->io_base + (1 << host->board->cle));
+                writeb(cmd, host->io_base + (1 << host->board.cle));
         else
-                writeb(cmd, host->io_base + (1 << host->board->ale));
+                writeb(cmd, host->io_base + (1 << host->board.ale));
 }
 
 /*
@@ -157,8 +149,8 @@ static int atmel_nand_device_ready(struct mtd_info *mtd)
         struct nand_chip *nand_chip = mtd->priv;
         struct atmel_nand_host *host = nand_chip->priv;
 
-        return gpio_get_value(host->board->rdy_pin) ^
-                !!host->board->rdy_pin_active_low;
+        return gpio_get_value(host->board.rdy_pin) ^
+                !!host->board.rdy_pin_active_low;
 }
 
 /*
@@ -273,7 +265,7 @@ static void atmel_read_buf(struct mtd_info *mtd, u8 *buf, int len)
                 if (atmel_nand_dma_op(mtd, buf, len, 1) == 0)
                         return;
 
-        if (host->board->bus_width_16)
+        if (host->board.bus_width_16)
                 atmel_read_buf16(mtd, buf, len);
         else
                 atmel_read_buf8(mtd, buf, len);
@@ -289,7 +281,7 @@ static void atmel_write_buf(struct mtd_info *mtd, const u8 *buf, int len)
                 if (atmel_nand_dma_op(mtd, (void *)buf, len, 0) == 0)
                         return;
 
-        if (host->board->bus_width_16)
+        if (host->board.bus_width_16)
                 atmel_write_buf16(mtd, buf, len);
         else
                 atmel_write_buf8(mtd, buf, len);
@@ -481,6 +473,56 @@ static void atmel_nand_hwctl(struct mtd_info *mtd, int mode)
         }
 }
 
+#if defined(CONFIG_OF)
+static int __devinit atmel_of_init_port(struct atmel_nand_host *host,
+                                         struct device_node *np)
+{
+        u32 val;
+        int ecc_mode;
+        struct atmel_nand_data *board = &host->board;
+        enum of_gpio_flags flags;
+
+        if (of_property_read_u32(np, "atmel,nand-addr-offset", &val) == 0) {
+                if (val >= 32) {
+                        dev_err(host->dev, "invalid addr-offset %u\n", val);
+                        return -EINVAL;
+                }
+                board->ale = val;
+        }
+
+        if (of_property_read_u32(np, "atmel,nand-cmd-offset", &val) == 0) {
+                if (val >= 32) {
+                        dev_err(host->dev, "invalid cmd-offset %u\n", val);
+                        return -EINVAL;
+                }
+                board->cle = val;
+        }
+
+        ecc_mode = of_get_nand_ecc_mode(np);
+
+        board->ecc_mode = ecc_mode < 0 ? NAND_ECC_SOFT : ecc_mode;
+
+        board->on_flash_bbt = of_get_nand_on_flash_bbt(np);
+
+        if (of_get_nand_bus_width(np) == 16)
+                board->bus_width_16 = 1;
+
+        board->rdy_pin = of_get_gpio_flags(np, 0, &flags);
+        board->rdy_pin_active_low = (flags == OF_GPIO_ACTIVE_LOW);
+
+        board->enable_pin = of_get_gpio(np, 1);
+        board->det_pin = of_get_gpio(np, 2);
+
+        return 0;
+}
+#else
+static int __devinit atmel_of_init_port(struct atmel_nand_host *host,
+                                         struct device_node *np)
+{
+        return -EINVAL;
+}
+#endif
+
 /*
  * Probe for the NAND device.
  */
@@ -491,6 +533,7 @@ static int __init atmel_nand_probe(struct platform_device *pdev)
         struct nand_chip *nand_chip;
         struct resource *regs;
         struct resource *mem;
+        struct mtd_part_parser_data ppdata = {};
         int res;
 
         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -517,8 +560,15 @@ static int __init atmel_nand_probe(struct platform_device *pdev)
 
         mtd = &host->mtd;
         nand_chip = &host->nand_chip;
-        host->board = pdev->dev.platform_data;
         host->dev = &pdev->dev;
+        if (pdev->dev.of_node) {
+                res = atmel_of_init_port(host, pdev->dev.of_node);
+                if (res)
+                        goto err_nand_ioremap;
+        } else {
+                memcpy(&host->board, pdev->dev.platform_data,
+                       sizeof(struct atmel_nand_data));
+        }
 
         nand_chip->priv = host;         /* link the private data structures */
         mtd->priv = nand_chip;
@@ -529,26 +579,25 @@ static int __init atmel_nand_probe(struct platform_device *pdev)
         nand_chip->IO_ADDR_W = host->io_base;
         nand_chip->cmd_ctrl = atmel_nand_cmd_ctrl;
 
-        if (gpio_is_valid(host->board->rdy_pin))
+        if (gpio_is_valid(host->board.rdy_pin))
                 nand_chip->dev_ready = atmel_nand_device_ready;
 
+        nand_chip->ecc.mode = host->board.ecc_mode;
+
         regs = platform_get_resource(pdev, IORESOURCE_MEM, 1);
-        if (!regs && hard_ecc) {
+        if (!regs && nand_chip->ecc.mode == NAND_ECC_HW) {
                 printk(KERN_ERR "atmel_nand: can't get I/O resource "
                                 "regs\nFalling back on software ECC\n");
+                nand_chip->ecc.mode = NAND_ECC_SOFT;
         }
 
-        nand_chip->ecc.mode = NAND_ECC_SOFT;    /* enable ECC */
-        if (no_ecc)
-                nand_chip->ecc.mode = NAND_ECC_NONE;
-        if (hard_ecc && regs) {
+        if (nand_chip->ecc.mode == NAND_ECC_HW) {
                 host->ecc = ioremap(regs->start, resource_size(regs));
                 if (host->ecc == NULL) {
                         printk(KERN_ERR "atmel_nand: ioremap failed\n");
                         res = -EIO;
                         goto err_ecc_ioremap;
                 }
-                nand_chip->ecc.mode = NAND_ECC_HW;
                 nand_chip->ecc.calculate = atmel_nand_calculate;
                 nand_chip->ecc.correct = atmel_nand_correct;
                 nand_chip->ecc.hwctl = atmel_nand_hwctl;
@@ -558,7 +607,7 @@ static int __init atmel_nand_probe(struct platform_device *pdev)
 
         nand_chip->chip_delay = 20;             /* 20us command delay time */
 
-        if (host->board->bus_width_16)  /* 16-bit bus width */
+        if (host->board.bus_width_16)   /* 16-bit bus width */
                 nand_chip->options |= NAND_BUSWIDTH_16;
 
         nand_chip->read_buf = atmel_read_buf;
@@ -567,15 +616,15 @@ static int __init atmel_nand_probe(struct platform_device *pdev)
         platform_set_drvdata(pdev, host);
         atmel_nand_enable(host);
 
-        if (gpio_is_valid(host->board->det_pin)) {
-                if (gpio_get_value(host->board->det_pin)) {
+        if (gpio_is_valid(host->board.det_pin)) {
+                if (gpio_get_value(host->board.det_pin)) {
                         printk(KERN_INFO "No SmartMedia card inserted.\n");
                         res = -ENXIO;
                         goto err_no_card;
                 }
         }
 
-        if (on_flash_bbt) {
+        if (host->board.on_flash_bbt || on_flash_bbt) {
                 printk(KERN_INFO "atmel_nand: Use On Flash BBT\n");
                 nand_chip->bbt_options |= NAND_BBT_USE_FLASH;
         }
@@ -650,8 +699,9 @@ static int __init atmel_nand_probe(struct platform_device *pdev)
         }
 
         mtd->name = "atmel_nand";
-        res = mtd_device_parse_register(mtd, NULL, 0,
-                        host->board->parts, host->board->num_parts);
+        ppdata.of_node = pdev->dev.of_node;
+        res = mtd_device_parse_register(mtd, NULL, &ppdata,
+                        host->board.parts, host->board.num_parts);
         if (!res)
                 return res;
 
@@ -695,11 +745,21 @@ static int __exit atmel_nand_remove(struct platform_device *pdev)
         return 0;
 }
 
+#if defined(CONFIG_OF)
+static const struct of_device_id atmel_nand_dt_ids[] = {
+        { .compatible = "atmel,at91rm9200-nand" },
+        { /* sentinel */ }
+};
+
+MODULE_DEVICE_TABLE(of, atmel_nand_dt_ids);
+#endif
+
 static struct platform_driver atmel_nand_driver = {
         .remove         = __exit_p(atmel_nand_remove),
         .driver         = {
                 .name   = "atmel_nand",
                 .owner  = THIS_MODULE,
+                .of_match_table = of_match_ptr(atmel_nand_dt_ids),
         },
 };
 
diff --git a/drivers/of/Kconfig b/drivers/of/Kconfig
index 6ea51dcbc728..8e84ce9765a9 100644
--- a/drivers/of/Kconfig
+++ b/drivers/of/Kconfig
@@ -91,4 +91,8 @@ config OF_PCI_IRQ
         help
           OpenFirmware PCI IRQ routing helpers
 
+config OF_MTD
+        depends on MTD
+        def_bool y
+
 endmenu # OF
diff --git a/drivers/of/Makefile b/drivers/of/Makefile
index a73f5a51ff4c..aa90e602c8a7 100644
--- a/drivers/of/Makefile
+++ b/drivers/of/Makefile
@@ -12,3 +12,4 @@ obj-$(CONFIG_OF_SELFTEST) += selftest.o
 obj-$(CONFIG_OF_MDIO)   += of_mdio.o
 obj-$(CONFIG_OF_PCI)    += of_pci.o
 obj-$(CONFIG_OF_PCI_IRQ)  += of_pci_irq.o
+obj-$(CONFIG_OF_MTD)    += of_mtd.o
diff --git a/drivers/of/of_mtd.c b/drivers/of/of_mtd.c
new file mode 100644
index 000000000000..e7cad627a5d1
--- /dev/null
+++ b/drivers/of/of_mtd.c
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2012 Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+ *
+ * OF helpers for mtd.
+ *
+ * This file is released under the GPLv2
+ *
+ */
+#include <linux/kernel.h>
+#include <linux/of_mtd.h>
+#include <linux/mtd/nand.h>
+#include <linux/export.h>
+
+/**
+ * It maps 'enum nand_ecc_modes_t' found in include/linux/mtd/nand.h
+ * into the device tree binding of 'nand-ecc', so that MTD
+ * device driver can get nand ecc from device tree.
+ */
+static const char *nand_ecc_modes[] = {
+        [NAND_ECC_NONE]         = "none",
+        [NAND_ECC_SOFT]         = "soft",
+        [NAND_ECC_HW]           = "hw",
+        [NAND_ECC_HW_SYNDROME]  = "hw_syndrome",
+        [NAND_ECC_HW_OOB_FIRST] = "hw_oob_first",
+        [NAND_ECC_SOFT_BCH]     = "soft_bch",
+};
+
+/**
+ * of_get_nand_ecc_mode - Get nand ecc mode for given device_node
+ * @np: Pointer to the given device_node
+ *
+ * The function gets ecc mode string from property 'nand-ecc-mode',
+ * and return its index in nand_ecc_modes table, or errno in error case.
+ */
+const int of_get_nand_ecc_mode(struct device_node *np)
+{
+        const char *pm;
+        int err, i;
+
+        err = of_property_read_string(np, "nand-ecc-mode", &pm);
+        if (err < 0)
+                return err;
+
+        for (i = 0; i < ARRAY_SIZE(nand_ecc_modes); i++)
+                if (!strcasecmp(pm, nand_ecc_modes[i]))
+                        return i;
+
+        return -ENODEV;
+}
+EXPORT_SYMBOL_GPL(of_get_nand_ecc_mode);
+
+/**
+ * of_get_nand_bus_width - Get nand bus witdh for given device_node
+ * @np: Pointer to the given device_node
+ *
+ * return bus width option, or errno in error case.
+ */
+int of_get_nand_bus_width(struct device_node *np)
+{
+        u32 val;
+
+        if (of_property_read_u32(np, "nand-bus-width", &val))
+                return 8;
+
+        switch(val) {
+        case 8:
+        case 16:
+                return val;
+        default:
+                return -EIO;
+        }
+}
+EXPORT_SYMBOL_GPL(of_get_nand_bus_width);
+
+/**
+ * of_get_nand_on_flash_bbt - Get nand on flash bbt for given device_node
+ * @np: Pointer to the given device_node
+ *
+ * return true if present false other wise
+ */
+bool of_get_nand_on_flash_bbt(struct device_node *np)
+{
+        return of_property_read_bool(np, "nand-on-flash-bbt");
+}
+EXPORT_SYMBOL_GPL(of_get_nand_on_flash_bbt);
diff --git a/drivers/rtc/rtc-mv.c b/drivers/rtc/rtc-mv.c
index 1300962486d1..b2185f4255aa 100644
--- a/drivers/rtc/rtc-mv.c
+++ b/drivers/rtc/rtc-mv.c
@@ -12,6 +12,7 @@
 #include <linux/bcd.h>
 #include <linux/io.h>
 #include <linux/platform_device.h>
+#include <linux/of.h>
 #include <linux/delay.h>
 #include <linux/gfp.h>
 #include <linux/module.h>
@@ -294,11 +295,19 @@ static int __exit mv_rtc_remove(struct platform_device *pdev)
         return 0;
 }
 
+#ifdef CONFIG_OF
+static struct of_device_id rtc_mv_of_match_table[] = {
+        { .compatible = "mrvl,orion-rtc", },
+        {}
+};
+#endif
+
 static struct platform_driver mv_rtc_driver = {
         .remove         = __exit_p(mv_rtc_remove),
         .driver         = {
                 .name   = "rtc-mv",
                 .owner  = THIS_MODULE,
+                .of_match_table = of_match_ptr(rtc_mv_of_match_table),
         },
 };
 
diff --git a/drivers/spi/spi-orion.c b/drivers/spi/spi-orion.c
index 13448c832c44..e496f799b7a9 100644
--- a/drivers/spi/spi-orion.c
+++ b/drivers/spi/spi-orion.c
@@ -359,11 +359,6 @@ static int orion_spi_setup(struct spi_device *spi)
 
         orion_spi = spi_master_get_devdata(spi->master);
 
-        /* Fix ac timing if required.   */
-        if (orion_spi->spi_info->enable_clock_fix)
-                orion_spi_setbits(orion_spi, ORION_SPI_IF_CONFIG_REG,
-                                  (1 << 14));
-
         if ((spi->max_speed_hz == 0)
                         || (spi->max_speed_hz > orion_spi->max_speed))
                 spi->max_speed_hz = orion_spi->max_speed;
diff --git a/drivers/staging/ste_rmi4/Makefile b/drivers/staging/ste_rmi4/Makefile
index 176f46900571..e4c03351420f 100644
--- a/drivers/staging/ste_rmi4/Makefile
+++ b/drivers/staging/ste_rmi4/Makefile
@@ -2,4 +2,4 @@
 # Makefile for the RMI4 touchscreen driver.
 #
 obj-$(CONFIG_TOUCHSCREEN_SYNAPTICS_I2C_RMI4) += synaptics_i2c_rmi4.o
-obj-$(CONFIG_MACH_U8500) += board-mop500-u8500uib-rmi4.o
+obj-$(CONFIG_MACH_MOP500) += board-mop500-u8500uib-rmi4.o
diff --git a/drivers/usb/Kconfig b/drivers/usb/Kconfig
index 48ac6e781ba2..cbd8f5f80596 100644
--- a/drivers/usb/Kconfig
+++ b/drivers/usb/Kconfig
@@ -44,7 +44,7 @@ config USB_ARCH_HAS_EHCI
         default y if PPC_MPC512x
         default y if ARCH_IXP4XX
         default y if ARCH_W90X900
-        default y if ARCH_AT91SAM9G45
+        default y if ARCH_AT91
         default y if ARCH_MXC
         default y if ARCH_OMAP3
         default y if ARCH_CNS3XXX
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index 26c0b75f152e..2633f7595116 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -137,7 +137,7 @@ choice
 
 config USB_AT91
         tristate "Atmel AT91 USB Device Port"
-        depends on ARCH_AT91 && !ARCH_AT91SAM9RL && !ARCH_AT91SAM9G45
+        depends on ARCH_AT91
         help
            Many Atmel AT91 processors (such as the AT91RM2000) have a
            full speed USB Device Port with support for five configurable
diff --git a/drivers/usb/gadget/at91_udc.c b/drivers/usb/gadget/at91_udc.c
index 2db5f68f7960..36fd2b4b49a2 100644
--- a/drivers/usb/gadget/at91_udc.c
+++ b/drivers/usb/gadget/at91_udc.c
@@ -29,6 +29,8 @@
 #include <linux/clk.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
+#include <linux/of.h>
+#include <linux/of_gpio.h>
 
 #include <asm/byteorder.h>
 #include <mach/hardware.h>
@@ -1707,7 +1709,27 @@ static void at91udc_shutdown(struct platform_device *dev)
         spin_unlock_irqrestore(&udc->lock, flags);
 }
 
-static int __init at91udc_probe(struct platform_device *pdev)
+static void __devinit at91udc_of_init(struct at91_udc *udc,
+                                     struct device_node *np)
+{
+        struct at91_udc_data *board = &udc->board;
+        u32 val;
+        enum of_gpio_flags flags;
+
+        if (of_property_read_u32(np, "atmel,vbus-polled", &val) == 0)
+                board->vbus_polled = 1;
+
+        board->vbus_pin = of_get_named_gpio_flags(np, "atmel,vbus-gpio", 0,
+                                                  &flags);
+        board->vbus_active_low = (flags & OF_GPIO_ACTIVE_LOW) ? 1 : 0;
+
+        board->pullup_pin = of_get_named_gpio_flags(np, "atmel,pullup-gpio", 0,
+                                                  &flags);
+
+        board->pullup_active_low = (flags & OF_GPIO_ACTIVE_LOW) ? 1 : 0;
+}
+
+static int __devinit at91udc_probe(struct platform_device *pdev)
 {
         struct device   *dev = &pdev->dev;
         struct at91_udc *udc;
@@ -1742,7 +1764,11 @@ static int __init at91udc_probe(struct platform_device *pdev)
         /* init software state */
         udc = &controller;
         udc->gadget.dev.parent = dev;
-        udc->board = *(struct at91_udc_data *) dev->platform_data;
+        if (pdev->dev.of_node)
+                at91udc_of_init(udc, pdev->dev.of_node);
+        else
+                memcpy(&udc->board, dev->platform_data,
+                       sizeof(struct at91_udc_data));
         udc->pdev = pdev;
         udc->enabled = 0;
         spin_lock_init(&udc->lock);
@@ -1971,6 +1997,15 @@ static int at91udc_resume(struct platform_device *pdev)
 #define at91udc_resume  NULL
 #endif
 
+#if defined(CONFIG_OF)
+static const struct of_device_id at91_udc_dt_ids[] = {
+        { .compatible = "atmel,at91rm9200-udc" },
+        { /* sentinel */ }
+};
+
+MODULE_DEVICE_TABLE(of, at91_udc_dt_ids);
+#endif
+
 static struct platform_driver at91_udc_driver = {
         .remove         = __exit_p(at91udc_remove),
         .shutdown       = at91udc_shutdown,
@@ -1979,6 +2014,7 @@ static struct platform_driver at91_udc_driver = {
         .driver         = {
                 .name   = (char *) driver_name,
                 .owner  = THIS_MODULE,
+                .of_match_table = of_match_ptr(at91_udc_dt_ids),
         },
 };
 
diff --git a/drivers/usb/host/ehci-atmel.c b/drivers/usb/host/ehci-atmel.c
index a5a3ef1f0096..19f318ababa2 100644
--- a/drivers/usb/host/ehci-atmel.c
+++ b/drivers/usb/host/ehci-atmel.c
@@ -13,6 +13,7 @@
 
 #include <linux/clk.h>
 #include <linux/platform_device.h>
+#include <linux/of_platform.h>
 
 /* interface and function clocks */
 static struct clk *iclk, *fclk;
@@ -115,6 +116,8 @@ static const struct hc_driver ehci_atmel_hc_driver = {
         .clear_tt_buffer_complete       = ehci_clear_tt_buffer_complete,
 };
 
+static u64 at91_ehci_dma_mask = DMA_BIT_MASK(32);
+
 static int __devinit ehci_atmel_drv_probe(struct platform_device *pdev)
 {
         struct usb_hcd *hcd;
@@ -137,6 +140,13 @@ static int __devinit ehci_atmel_drv_probe(struct platform_device *pdev)
                 goto fail_create_hcd;
         }
 
+        /* Right now device-tree probed devices don't get dma_mask set.
+         * Since shared usb code relies on it, set it here for now.
+         * Once we have dma capability bindings this can go away.
+         */
+        if (!pdev->dev.dma_mask)
+                pdev->dev.dma_mask = &at91_ehci_dma_mask;
+
         hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
         if (!hcd) {
                 retval = -ENOMEM;
@@ -225,9 +235,21 @@ static int __devexit ehci_atmel_drv_remove(struct platform_device *pdev)
         return 0;
 }
 
+#ifdef CONFIG_OF
+static const struct of_device_id atmel_ehci_dt_ids[] = {
+        { .compatible = "atmel,at91sam9g45-ehci" },
+        { /* sentinel */ }
+};
+
+MODULE_DEVICE_TABLE(of, atmel_ehci_dt_ids);
+#endif
+
 static struct platform_driver ehci_atmel_driver = {
         .probe          = ehci_atmel_drv_probe,
         .remove         = __devexit_p(ehci_atmel_drv_remove),
         .shutdown       = usb_hcd_platform_shutdown,
-        .driver.name    = "atmel-ehci",
+        .driver         = {
+                .name   = "atmel-ehci",
+                .of_match_table = of_match_ptr(atmel_ehci_dt_ids),
+        },
 };
diff --git a/drivers/usb/host/ohci-at91.c b/drivers/usb/host/ohci-at91.c
index 8e855eb0bf89..db8963f5fbce 100644
--- a/drivers/usb/host/ohci-at91.c
+++ b/drivers/usb/host/ohci-at91.c
@@ -14,6 +14,8 @@
 
 #include <linux/clk.h>
 #include <linux/platform_device.h>
+#include <linux/of_platform.h>
+#include <linux/of_gpio.h>
 
 #include <mach/hardware.h>
 #include <asm/gpio.h>
@@ -477,13 +479,109 @@ static irqreturn_t ohci_hcd_at91_overcurrent_irq(int irq, void *data)
         return IRQ_HANDLED;
 }
 
+#ifdef CONFIG_OF
+static const struct of_device_id at91_ohci_dt_ids[] = {
+        { .compatible = "atmel,at91rm9200-ohci" },
+        { /* sentinel */ }
+};
+
+MODULE_DEVICE_TABLE(of, at91_ohci_dt_ids);
+
+static u64 at91_ohci_dma_mask = DMA_BIT_MASK(32);
+
+static int __devinit ohci_at91_of_init(struct platform_device *pdev)
+{
+        struct device_node *np = pdev->dev.of_node;
+        int i, ret, gpio;
+        enum of_gpio_flags flags;
+        struct at91_usbh_data   *pdata;
+        u32 ports;
+
+        if (!np)
+                return 0;
+
+        /* Right now device-tree probed devices don't get dma_mask set.
+         * Since shared usb code relies on it, set it here for now.
+         * Once we have dma capability bindings this can go away.
+         */
+        if (!pdev->dev.dma_mask)
+                pdev->dev.dma_mask = &at91_ohci_dma_mask;
+
+        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return -ENOMEM;
+
+        if (!of_property_read_u32(np, "num-ports", &ports))
+                pdata->ports = ports;
+
+        for (i = 0; i < 2; i++) {
+                gpio = of_get_named_gpio_flags(np, "atmel,vbus-gpio", i, &flags);
+                pdata->vbus_pin[i] = gpio;
+                if (!gpio_is_valid(gpio))
+                        continue;
+                pdata->vbus_pin_active_low[i] = flags & OF_GPIO_ACTIVE_LOW;
+                ret = gpio_request(gpio, "ohci_vbus");
+                if (ret) {
+                        dev_warn(&pdev->dev, "can't request vbus gpio %d", gpio);
+                        continue;
+                }
+                ret = gpio_direction_output(gpio, !(flags & OF_GPIO_ACTIVE_LOW) ^ 1);
+                if (ret)
+                        dev_warn(&pdev->dev, "can't put vbus gpio %d as output %d",
+                                 !(flags & OF_GPIO_ACTIVE_LOW) ^ 1, gpio);
+        }
+
+        for (i = 0; i < 2; i++) {
+                gpio = of_get_named_gpio_flags(np, "atmel,oc-gpio", i, &flags);
+                pdata->overcurrent_pin[i] = gpio;
+                if (!gpio_is_valid(gpio))
+                        continue;
+                ret = gpio_request(gpio, "ohci_overcurrent");
+                if (ret) {
+                        dev_err(&pdev->dev, "can't request overcurrent gpio %d", gpio);
+                        continue;
+                }
+
+                ret = gpio_direction_input(gpio);
+                if (ret) {
+                        dev_err(&pdev->dev, "can't configure overcurrent gpio %d as input", gpio);
+                        continue;
+                }
+
+                ret = request_irq(gpio_to_irq(gpio),
+                                  ohci_hcd_at91_overcurrent_irq,
+                                  IRQF_SHARED, "ohci_overcurrent", pdev);
+                if (ret) {
+                        gpio_free(gpio);
+                        dev_warn(& pdev->dev, "cannot get GPIO IRQ for overcurrent\n");
+                }
+        }
+
+        pdev->dev.platform_data = pdata;
+
+        return 0;
+}
+#else
+static int __devinit ohci_at91_of_init(struct platform_device *pdev)
+{
+        return 0;
+}
+#endif
+
 /*-------------------------------------------------------------------------*/
 
 static int ohci_hcd_at91_drv_probe(struct platform_device *pdev)
 {
-        struct at91_usbh_data   *pdata = pdev->dev.platform_data;
+        struct at91_usbh_data   *pdata;
         int                     i;
 
+        i = ohci_at91_of_init(pdev);
+
+        if (i)
+                return i;
+
+        pdata = pdev->dev.platform_data;
+
         if (pdata) {
                 for (i = 0; i < ARRAY_SIZE(pdata->vbus_pin); i++) {
                         if (!gpio_is_valid(pdata->vbus_pin[i]))
@@ -596,5 +694,6 @@ static struct platform_driver ohci_hcd_at91_driver = {
         .driver         = {
                 .name   = "at91_ohci",
                 .owner  = THIS_MODULE,
+                .of_match_table = of_match_ptr(at91_ohci_dt_ids),
         },
 };
diff --git a/drivers/watchdog/orion_wdt.c b/drivers/watchdog/orion_wdt.c
index 4ad78f868515..1368e4ca3100 100644
--- a/drivers/watchdog/orion_wdt.c
+++ b/drivers/watchdog/orion_wdt.c
@@ -28,9 +28,9 @@
 /*
  * Watchdog timer block registers.
  */
-#define TIMER_CTRL              (TIMER_VIRT_BASE + 0x0000)
+#define TIMER_CTRL              0x0000
 #define  WDT_EN                 0x0010
-#define WDT_VAL                 (TIMER_VIRT_BASE + 0x0024)
+#define WDT_VAL                 0x0024
 
 #define WDT_MAX_CYCLE_COUNT     0xffffffff
 #define WDT_IN_USE              0
@@ -40,6 +40,7 @@ static int nowayout = WATCHDOG_NOWAYOUT;
 static int heartbeat = -1;              /* module parameter (seconds) */
 static unsigned int wdt_max_duration;   /* (seconds) */
 static unsigned int wdt_tclk;
+static void __iomem *wdt_reg;
 static unsigned long wdt_status;
 static DEFINE_SPINLOCK(wdt_lock);
 
@@ -48,7 +49,7 @@ static void orion_wdt_ping(void)
         spin_lock(&wdt_lock);
 
         /* Reload watchdog duration */
-        writel(wdt_tclk * heartbeat, WDT_VAL);
+        writel(wdt_tclk * heartbeat, wdt_reg + WDT_VAL);
 
         spin_unlock(&wdt_lock);
 }
@@ -60,7 +61,7 @@ static void orion_wdt_enable(void)
         spin_lock(&wdt_lock);
 
         /* Set watchdog duration */
-        writel(wdt_tclk * heartbeat, WDT_VAL);
+        writel(wdt_tclk * heartbeat, wdt_reg + WDT_VAL);
 
         /* Clear watchdog timer interrupt */
         reg = readl(BRIDGE_CAUSE);
@@ -68,9 +69,9 @@ static void orion_wdt_enable(void)
         writel(reg, BRIDGE_CAUSE);
 
         /* Enable watchdog timer */
-        reg = readl(TIMER_CTRL);
+        reg = readl(wdt_reg + TIMER_CTRL);
         reg |= WDT_EN;
-        writel(reg, TIMER_CTRL);
+        writel(reg, wdt_reg + TIMER_CTRL);
 
         /* Enable reset on watchdog */
         reg = readl(RSTOUTn_MASK);
@@ -92,9 +93,9 @@ static void orion_wdt_disable(void)
         writel(reg, RSTOUTn_MASK);
 
         /* Disable watchdog timer */
-        reg = readl(TIMER_CTRL);
+        reg = readl(wdt_reg + TIMER_CTRL);
         reg &= ~WDT_EN;
-        writel(reg, TIMER_CTRL);
+        writel(reg, wdt_reg + TIMER_CTRL);
 
         spin_unlock(&wdt_lock);
 }
@@ -102,7 +103,7 @@ static void orion_wdt_disable(void)
 static int orion_wdt_get_timeleft(int *time_left)
 {
         spin_lock(&wdt_lock);
-        *time_left = readl(WDT_VAL) / wdt_tclk;
+        *time_left = readl(wdt_reg + WDT_VAL) / wdt_tclk;
         spin_unlock(&wdt_lock);
         return 0;
 }
@@ -236,6 +237,7 @@ static struct miscdevice orion_wdt_miscdev = {
 static int __devinit orion_wdt_probe(struct platform_device *pdev)
 {
         struct orion_wdt_platform_data *pdata = pdev->dev.platform_data;
+        struct resource *res;
         int ret;
 
         if (pdata) {
@@ -245,6 +247,10 @@ static int __devinit orion_wdt_probe(struct platform_device *pdev)
                 return -ENODEV;
         }
 
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+
+        wdt_reg = ioremap(res->start, resource_size(res));
+
         if (orion_wdt_miscdev.parent)
                 return -EBUSY;
         orion_wdt_miscdev.parent = &pdev->dev;