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

Pull late ARM soc platform updates from Olof Johansson:
 "This branch contains updates to OMAP and Marvell platforms (kirkwood,
  dove, mvebu) that came in after we had done the big multiplatform
  merges, so they were kept separate from the rest, and not separated
  into the traditional topics of cleanup/driver/platform features.

  For OMAP, the updates are:
   - Runtime PM conversions for the GPMC and RNG IP blocks
   - Preparation patches for the OMAP common clock framework conversion
   - clkdev alias additions required by other drivers
   - Performance Monitoring Unit (PMU) support for OMAP2, 3, and
     non-4430 OMAP4
   - OMAP hwmod code and data improvements
   - Preparation patches for the IOMMU runtime PM conversion
   - Preparation patches for OMAP4 full-chip retention support

  For Kirkwood/Dove/mvebu:
   - New driver for "address decoder controller" for mvebu, which is a
     piece of hardware that configures addressable devices and
     peripherals.  First user is the boot rom aperture on armada XP
     since it is needed for SMP support.
   - New device tree bindings for peripherals such as gpio-fan, iconnect
     nand, mv_cesa and the above address decoder controller.
   - Some defconfig updates, mostly to enable new DT boards and a few
     drivers.
   - New drivers using the pincontrol subsystem for dove, kirkwood and
     mvebu
   - New clean gpio driver for mvebu"

* tag 'soc-late' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc: (98 commits)
  ARM: mvebu: fix build breaks from multi-platform conversion
  ARM: OMAP4460/4470: PMU: Enable PMU for OMAP4460/70
  ARM: OMAP2+: PMU: Add runtime PM support
  ARM: OMAP4430: PMU: prepare to create PMU device via HWMOD
  ARM: OMAP2+: PMU: Convert OMAP2/3 devices to use HWMOD
  ARM: OMAP3: hwmod data: Add debugss HWMOD data
  ARM: OMAP2+: clockdomain/hwmod: add workaround for EMU clockdomain idle problems
  ARM: OMAP: Add a timer attribute for timers that can interrupt the DSP
  hwrng: OMAP: remove SoC restrictions from driver registration
  ARM: OMAP: split OMAP1, OMAP2+ RNG device registration
  hwrng: OMAP: convert to use runtime PM
  hwrng: OMAP: store per-device data in per-device variables, not file statics
  ARM: OMAP2xxx: hwmod/CM: add RNG integration data
  ARM: OMAP2+: gpmc: minimal driver support
  ARM: OMAP2+: gpmc: Adapt to HWMOD
  ARM: OMAP2/3: hwmod data: add gpmc
  ARM: OMAP4: hwmod data: add mmu hwmod for ipu and dsp
  ARM: OMAP3: hwmod data: add mmu data for iva and isp
  ARM: OMAP: iommu: fix including iommu.h without IOMMU_API selected
  ARM: OMAP4: hwmod data: add missing HWMOD_NO_IDLEST flags to some PRCM IP blocks
  ...

1 files changed, 70 insertions, 51 deletions

diff --git a/drivers/char/hw_random/omap-rng.c b/drivers/char/hw_random/omap-rng.c
index 4fbdceb6f773..a5effd813abd 100644
--- a/drivers/char/hw_random/omap-rng.c
+++ b/drivers/char/hw_random/omap-rng.c
@@ -18,11 +18,12 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/random.h>
-#include <linux/clk.h>
 #include <linux/err.h>
 #include <linux/platform_device.h>
 #include <linux/hw_random.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/pm_runtime.h>
 
 #include <asm/io.h>
 
@@ -46,26 +47,36 @@
 #define RNG_SYSSTATUS           0x44            /* System status
                                                         [0] = RESETDONE */
 
-static void __iomem *rng_base;
-static struct clk *rng_ick;
-static struct platform_device *rng_dev;
+/**
+ * struct omap_rng_private_data - RNG IP block-specific data
+ * @base: virtual address of the beginning of the RNG IP block registers
+ * @mem_res: struct resource * for the IP block registers physical memory
+ */
+struct omap_rng_private_data {
+        void __iomem *base;
+        struct resource *mem_res;
+};
 
-static inline u32 omap_rng_read_reg(int reg)
+static inline u32 omap_rng_read_reg(struct omap_rng_private_data *priv, int reg)
 {
-        return __raw_readl(rng_base + reg);
+        return __raw_readl(priv->base + reg);
 }
 
-static inline void omap_rng_write_reg(int reg, u32 val)
+static inline void omap_rng_write_reg(struct omap_rng_private_data *priv,
+                                      int reg, u32 val)
 {
-        __raw_writel(val, rng_base + reg);
+        __raw_writel(val, priv->base + reg);
 }
 
 static int omap_rng_data_present(struct hwrng *rng, int wait)
 {
+        struct omap_rng_private_data *priv;
         int data, i;
 
+        priv = (struct omap_rng_private_data *)rng->priv;
+
         for (i = 0; i < 20; i++) {
-                data = omap_rng_read_reg(RNG_STAT_REG) ? 0 : 1;
+                data = omap_rng_read_reg(priv, RNG_STAT_REG) ? 0 : 1;
                 if (data || !wait)
                         break;
                 /* RNG produces data fast enough (2+ MBit/sec, even
@@ -80,9 +91,13 @@ static int omap_rng_data_present(struct hwrng *rng, int wait)
 
 static int omap_rng_data_read(struct hwrng *rng, u32 *data)
 {
-        *data = omap_rng_read_reg(RNG_OUT_REG);
+        struct omap_rng_private_data *priv;
+
+        priv = (struct omap_rng_private_data *)rng->priv;
+
+        *data = omap_rng_read_reg(priv, RNG_OUT_REG);
 
-        return 4;
+        return sizeof(u32);
 }
 
 static struct hwrng omap_rng_ops = {
@@ -93,69 +108,68 @@ static struct hwrng omap_rng_ops = {
 
 static int __devinit omap_rng_probe(struct platform_device *pdev)
 {
-        struct resource *res;
+        struct omap_rng_private_data *priv;
         int ret;
 
-        /*
-         * A bit ugly, and it will never actually happen but there can
-         * be only one RNG and this catches any bork
-         */
-        if (rng_dev)
-                return -EBUSY;
-
-        if (cpu_is_omap24xx()) {
-                rng_ick = clk_get(&pdev->dev, "ick");
-                if (IS_ERR(rng_ick)) {
-                        dev_err(&pdev->dev, "Could not get rng_ick\n");
-                        ret = PTR_ERR(rng_ick);
-                        return ret;
-                } else
-                        clk_enable(rng_ick);
-        }
+        priv = kzalloc(sizeof(struct omap_rng_private_data), GFP_KERNEL);
+        if (!priv) {
+                dev_err(&pdev->dev, "could not allocate memory\n");
+                return -ENOMEM;
+        };
 
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        omap_rng_ops.priv = (unsigned long)priv;
+        dev_set_drvdata(&pdev->dev, priv);
 
-        rng_base = devm_request_and_ioremap(&pdev->dev, res);
-        if (!rng_base) {
+        priv->mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!priv->mem_res) {
+                ret = -ENOENT;
+                goto err_ioremap;
+        }
+
+        priv->base = devm_request_and_ioremap(&pdev->dev, priv->mem_res);
+        if (!priv->base) {
                 ret = -ENOMEM;
                 goto err_ioremap;
         }
-        dev_set_drvdata(&pdev->dev, res);
+        dev_set_drvdata(&pdev->dev, priv);
+
+        pm_runtime_enable(&pdev->dev);
+        pm_runtime_get_sync(&pdev->dev);
 
         ret = hwrng_register(&omap_rng_ops);
         if (ret)
                 goto err_register;
 
         dev_info(&pdev->dev, "OMAP Random Number Generator ver. %02x\n",
-                omap_rng_read_reg(RNG_REV_REG));
-        omap_rng_write_reg(RNG_MASK_REG, 0x1);
+                 omap_rng_read_reg(priv, RNG_REV_REG));
 
-        rng_dev = pdev;
+        omap_rng_write_reg(priv, RNG_MASK_REG, 0x1);
 
         return 0;
 
 err_register:
-        rng_base = NULL;
+        priv->base = NULL;
+        pm_runtime_disable(&pdev->dev);
 err_ioremap:
-        if (cpu_is_omap24xx()) {
-                clk_disable(rng_ick);
-                clk_put(rng_ick);
-        }
+        kfree(priv);
+
         return ret;
 }
 
 static int __exit omap_rng_remove(struct platform_device *pdev)
 {
+        struct omap_rng_private_data *priv = dev_get_drvdata(&pdev->dev);
+
         hwrng_unregister(&omap_rng_ops);
 
-        omap_rng_write_reg(RNG_MASK_REG, 0x0);
+        omap_rng_write_reg(priv, RNG_MASK_REG, 0x0);
 
-        if (cpu_is_omap24xx()) {
-                clk_disable(rng_ick);
-                clk_put(rng_ick);
-        }
+        pm_runtime_put_sync(&pdev->dev);
+        pm_runtime_disable(&pdev->dev);
+
+        release_mem_region(priv->mem_res->start, resource_size(priv->mem_res));
 
-        rng_base = NULL;
+        kfree(priv);
 
         return 0;
 }
@@ -164,13 +178,21 @@ static int __exit omap_rng_remove(struct platform_device *pdev)
 
 static int omap_rng_suspend(struct device *dev)
 {
-        omap_rng_write_reg(RNG_MASK_REG, 0x0);
+        struct omap_rng_private_data *priv = dev_get_drvdata(dev);
+
+        omap_rng_write_reg(priv, RNG_MASK_REG, 0x0);
+        pm_runtime_put_sync(dev);
+
         return 0;
 }
 
 static int omap_rng_resume(struct device *dev)
 {
-        omap_rng_write_reg(RNG_MASK_REG, 0x1);
+        struct omap_rng_private_data *priv = dev_get_drvdata(dev);
+
+        pm_runtime_get_sync(dev);
+        omap_rng_write_reg(priv, RNG_MASK_REG, 0x1);
+
         return 0;
 }
 
@@ -198,9 +220,6 @@ static struct platform_driver omap_rng_driver = {
 
 static int __init omap_rng_init(void)
 {
-        if (!cpu_is_omap16xx() && !cpu_is_omap24xx())
-                return -ENODEV;
-
         return platform_driver_register(&omap_rng_driver);
 }