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

Pull ARM SoC cleanups from Arnd Bergmann:
 "This time around, the cleanup branch contains mostly code removal.  A
  number of board files for at91, imx and msm have become obsolete
  because of the DT conversion and are now ready to be removed.  The
  OMAP platform has traditionally had its own DMA engine abstraction and
  as this is being phased out, a lot of the original code is now unused
  and can be removed as well.

  S3C24xx can be simplified now that the restart code is a proper device
  driver.

  Finally, a number of cleanups in shmobile are done to prepare for the
  addition of new code in other branches"

* tag 'cleanup-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc: (43 commits)
  ARM: at91: Remove the support for the RSI EWS board
  arm: mach-omap2: Convert pr_warning to pr_warn
  ARM: OMAP: Remove unused pieces of legacy DMA API
  ARM: at91: remove board file for Acme Systems Fox G20
  ARM: orion5x: Convert pr_warning to pr_warn
  ARM: S3C24XX: remove separate restart code
  ARM: EXYNOS: Do not calculate boot address twice
  ARM: sunxi: Remove sun4i reboot code from mach directory
  ARM: imx: Remove mach-mxt_td60 board file
  ARM: shmobile: armadillo800eva legacy: Use rmobile_add_devices_to_domains()
  ARM: shmobile: r8a7740: Clean up pm domain table
  ARM: shmobile: r8a7740: Use rmobile_add_devices_to_domains()
  ARM: shmobile: sh7372: Make domain_devices[] static __initdata
  ARM: shmobile: mackerel: Make domain_devices[] static __initdata
  clocksource: tcb_clksrc: sanitize IRQ request
  ARM: at91/tclib: mask interruptions at shutdown and probe
  ARM: at91/tclib: move initialization from alloc to probe
  ARM: at91/tclib: prefer using of devm_* functions
  ARM: clps711x: Switch CLPS711X subarch to use clk and clocksource driver
  ARM: shmobile: r8a7791 is now called "R-Car M2-W"
  ...

1 files changed, 44 insertions, 57 deletions

diff --git a/drivers/misc/atmel_tclib.c b/drivers/misc/atmel_tclib.c
index c8d8e38d0d8a..0ca05c3ec8d6 100644
--- a/drivers/misc/atmel_tclib.c
+++ b/drivers/misc/atmel_tclib.c
@@ -35,60 +35,31 @@ static LIST_HEAD(tc_list);
 /**
  * atmel_tc_alloc - allocate a specified TC block
  * @block: which block to allocate
- * @name: name to be associated with the iomem resource
  *
  * Caller allocates a block.  If it is available, a pointer to a
  * pre-initialized struct atmel_tc is returned. The caller can access
  * the registers directly through the "regs" field.
  */
-struct atmel_tc *atmel_tc_alloc(unsigned block, const char *name)
+struct atmel_tc *atmel_tc_alloc(unsigned block)
 {
         struct atmel_tc         *tc;
         struct platform_device  *pdev = NULL;
-        struct resource         *r;
-        size_t                  size;
 
         spin_lock(&tc_list_lock);
         list_for_each_entry(tc, &tc_list, node) {
-                if (tc->pdev->dev.of_node) {
-                        if (of_alias_get_id(tc->pdev->dev.of_node, "tcb")
-                                        == block) {
-                                pdev = tc->pdev;
-                                break;
-                        }
-                } else if (tc->pdev->id == block) {
+                if (tc->allocated)
+                        continue;
+
+                if ((tc->pdev->dev.of_node && tc->id == block) ||
+                    (tc->pdev->id == block)) {
                         pdev = tc->pdev;
+                        tc->allocated = true;
                         break;
                 }
         }
-
-        if (!pdev || tc->iomem)
-                goto fail;
-
-        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!r)
-                goto fail;
-
-        size = resource_size(r);
-        r = request_mem_region(r->start, size, name);
-        if (!r)
-                goto fail;
-
-        tc->regs = ioremap(r->start, size);
-        if (!tc->regs)
-                goto fail_ioremap;
-
-        tc->iomem = r;
-
-out:
         spin_unlock(&tc_list_lock);
-        return tc;
 
-fail_ioremap:
-        release_mem_region(r->start, size);
-fail:
-        tc = NULL;
-        goto out;
+        return pdev ? tc : NULL;
 }
 EXPORT_SYMBOL_GPL(atmel_tc_alloc);
 
@@ -96,19 +67,14 @@ EXPORT_SYMBOL_GPL(atmel_tc_alloc);
  * atmel_tc_free - release a specified TC block
  * @tc: Timer/counter block that was returned by atmel_tc_alloc()
  *
- * This reverses the effect of atmel_tc_alloc(), unmapping the I/O
- * registers, invalidating the resource returned by that routine and
- * making the TC available to other drivers.
+ * This reverses the effect of atmel_tc_alloc(), invalidating the resource
+ * returned by that routine and making the TC available to other drivers.
  */
 void atmel_tc_free(struct atmel_tc *tc)
 {
         spin_lock(&tc_list_lock);
-        if (tc->regs) {
-                iounmap(tc->regs);
-                release_mem_region(tc->iomem->start, resource_size(tc->iomem));
-                tc->regs = NULL;
-                tc->iomem = NULL;
-        }
+        if (tc->allocated)
+                tc->allocated = false;
         spin_unlock(&tc_list_lock);
 }
 EXPORT_SYMBOL_GPL(atmel_tc_free);
@@ -142,25 +108,27 @@ static int __init tc_probe(struct platform_device *pdev)
         struct atmel_tc *tc;
         struct clk      *clk;
         int             irq;
-
-        if (!platform_get_resource(pdev, IORESOURCE_MEM, 0))
-                return -EINVAL;
+        struct resource *r;
+        unsigned int    i;
 
         irq = platform_get_irq(pdev, 0);
         if (irq < 0)
                 return -EINVAL;
 
-        tc = kzalloc(sizeof(struct atmel_tc), GFP_KERNEL);
+        tc = devm_kzalloc(&pdev->dev, sizeof(struct atmel_tc), GFP_KERNEL);
         if (!tc)
                 return -ENOMEM;
 
         tc->pdev = pdev;
 
-        clk = clk_get(&pdev->dev, "t0_clk");
-        if (IS_ERR(clk)) {
-                kfree(tc);
-                return -EINVAL;
-        }
+        clk = devm_clk_get(&pdev->dev, "t0_clk");
+        if (IS_ERR(clk))
+                return PTR_ERR(clk);
+
+        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        tc->regs = devm_ioremap_resource(&pdev->dev, r);
+        if (IS_ERR(tc->regs))
+                return PTR_ERR(tc->regs);
 
         /* Now take SoC information if available */
         if (pdev->dev.of_node) {
@@ -168,13 +136,17 @@ static int __init tc_probe(struct platform_device *pdev)
                 match = of_match_node(atmel_tcb_dt_ids, pdev->dev.of_node);
                 if (match)
                         tc->tcb_config = match->data;
+
+                tc->id = of_alias_get_id(tc->pdev->dev.of_node, "tcb");
+        } else {
+                tc->id = pdev->id;
         }
 
         tc->clk[0] = clk;
-        tc->clk[1] = clk_get(&pdev->dev, "t1_clk");
+        tc->clk[1] = devm_clk_get(&pdev->dev, "t1_clk");
         if (IS_ERR(tc->clk[1]))
                 tc->clk[1] = clk;
-        tc->clk[2] = clk_get(&pdev->dev, "t2_clk");
+        tc->clk[2] = devm_clk_get(&pdev->dev, "t2_clk");
         if (IS_ERR(tc->clk[2]))
                 tc->clk[2] = clk;
 
@@ -186,18 +158,33 @@ static int __init tc_probe(struct platform_device *pdev)
         if (tc->irq[2] < 0)
                 tc->irq[2] = irq;
 
+        for (i = 0; i < 3; i++)
+                writel(ATMEL_TC_ALL_IRQ, tc->regs + ATMEL_TC_REG(i, IDR));
+
         spin_lock(&tc_list_lock);
         list_add_tail(&tc->node, &tc_list);
         spin_unlock(&tc_list_lock);
 
+        platform_set_drvdata(pdev, tc);
+
         return 0;
 }
 
+static void tc_shutdown(struct platform_device *pdev)
+{
+        int i;
+        struct atmel_tc *tc = platform_get_drvdata(pdev);
+
+        for (i = 0; i < 3; i++)
+                writel(ATMEL_TC_ALL_IRQ, tc->regs + ATMEL_TC_REG(i, IDR));
+}
+
 static struct platform_driver tc_driver = {
         .driver = {
                 .name   = "atmel_tcb",
                 .of_match_table = of_match_ptr(atmel_tcb_dt_ids),
         },
+        .shutdown = tc_shutdown,
 };
 
 static int __init tc_init(void)