1 files changed, 55 insertions, 104 deletions

diff --git a/drivers/clocksource/h8300_tpu.c b/drivers/clocksource/h8300_tpu.c
index 5487410bfabb..d4c1a287c262 100644
--- a/drivers/clocksource/h8300_tpu.c
+++ b/drivers/clocksource/h8300_tpu.c
@@ -1,42 +1,30 @@
 /*
- *  H8/300 TPU Driver
+ *  H8S TPU Driver
  *
  *  Copyright 2015 Yoshinori Sato <ysato@users.sourcefoge.jp>
  *
  */
 
 #include <linux/errno.h>
-#include <linux/sched.h>
 #include <linux/kernel.h>
-#include <linux/interrupt.h>
 #include <linux/init.h>
-#include <linux/platform_device.h>
-#include <linux/slab.h>
 #include <linux/clocksource.h>
-#include <linux/module.h>
 #include <linux/clk.h>
 #include <linux/io.h>
 #include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/of_irq.h>
 
-#include <asm/irq.h>
+#define TCR     0x0
+#define TSR     0x5
+#define TCNT    0x6
 
-#define TCR     0
-#define TMDR    1
-#define TIOR    2
-#define TER     4
-#define TSR     5
-#define TCNT    6
-#define TGRA    8
-#define TGRB    10
-#define TGRC    12
-#define TGRD    14
+#define TCFV    0x10
 
 struct tpu_priv {
-        struct platform_device *pdev;
         struct clocksource cs;
-        struct clk *clk;
-        unsigned long mapbase1;
-        unsigned long mapbase2;
+        void __iomem *mapbase1;
+        void __iomem *mapbase2;
         raw_spinlock_t lock;
         unsigned int cs_enabled;
 };
@@ -45,8 +33,8 @@ static inline unsigned long read_tcnt32(struct tpu_priv *p)
 {
         unsigned long tcnt;
 
-        tcnt = ctrl_inw(p->mapbase1 + TCNT) << 16;
-        tcnt |= ctrl_inw(p->mapbase2 + TCNT);
+        tcnt = ioread16be(p->mapbase1 + TCNT) << 16;
+        tcnt |= ioread16be(p->mapbase2 + TCNT);
         return tcnt;
 }
 
@@ -55,7 +43,7 @@ static int tpu_get_counter(struct tpu_priv *p, unsigned long long *val)
         unsigned long v1, v2, v3;
         int o1, o2;
 
-        o1 = ctrl_inb(p->mapbase1 + TSR) & 0x10;
+        o1 = ioread8(p->mapbase1 + TSR) & TCFV;
 
         /* Make sure the timer value is stable. Stolen from acpi_pm.c */
         do {
@@ -63,7 +51,7 @@ static int tpu_get_counter(struct tpu_priv *p, unsigned long long *val)
                 v1 = read_tcnt32(p);
                 v2 = read_tcnt32(p);
                 v3 = read_tcnt32(p);
-                o1 = ctrl_inb(p->mapbase1 + TSR) & 0x10;
+                o1 = ioread8(p->mapbase1 + TSR) & TCFV;
         } while (unlikely((o1 != o2) || (v1 > v2 && v1 < v3)
                           || (v2 > v3 && v2 < v1) || (v3 > v1 && v3 < v2)));
 
@@ -96,10 +84,10 @@ static int tpu_clocksource_enable(struct clocksource *cs)
 
         WARN_ON(p->cs_enabled);
 
-        ctrl_outw(0, p->mapbase1 + TCNT);
-        ctrl_outw(0, p->mapbase2 + TCNT);
-        ctrl_outb(0x0f, p->mapbase1 + TCR);
-        ctrl_outb(0x03, p->mapbase2 + TCR);
+        iowrite16be(0, p->mapbase1 + TCNT);
+        iowrite16be(0, p->mapbase2 + TCNT);
+        iowrite8(0x0f, p->mapbase1 + TCR);
+        iowrite8(0x03, p->mapbase2 + TCR);
 
         p->cs_enabled = true;
         return 0;
@@ -111,96 +99,59 @@ static void tpu_clocksource_disable(struct clocksource *cs)
 
         WARN_ON(!p->cs_enabled);
 
-        ctrl_outb(0, p->mapbase1 + TCR);
-        ctrl_outb(0, p->mapbase2 + TCR);
+        iowrite8(0, p->mapbase1 + TCR);
+        iowrite8(0, p->mapbase2 + TCR);
         p->cs_enabled = false;
 }
 
+static struct tpu_priv tpu_priv = {
+        .cs = {
+                .name = "H8S_TPU",
+                .rating = 200,
+                .read = tpu_clocksource_read,
+                .enable = tpu_clocksource_enable,
+                .disable = tpu_clocksource_disable,
+                .mask = CLOCKSOURCE_MASK(sizeof(unsigned long) * 8),
+                .flags = CLOCK_SOURCE_IS_CONTINUOUS,
+        },
+};
+
 #define CH_L 0
 #define CH_H 1
 
-static int __init tpu_setup(struct tpu_priv *p, struct platform_device *pdev)
+static void __init h8300_tpu_init(struct device_node *node)
 {
-        struct resource *res[2];
-
-        p->pdev = pdev;
+        void __iomem *base[2];
+        struct clk *clk;
 
-        res[CH_L] = platform_get_resource(p->pdev, IORESOURCE_MEM, CH_L);
-        res[CH_H] = platform_get_resource(p->pdev, IORESOURCE_MEM, CH_H);
-        if (!res[CH_L] || !res[CH_H]) {
-                dev_err(&p->pdev->dev, "failed to get I/O memory\n");
-                return -ENXIO;
+        clk = of_clk_get(node, 0);
+        if (IS_ERR(clk)) {
+                pr_err("failed to get clock for clocksource\n");
+                return;
         }
 
-        p->clk = clk_get(&p->pdev->dev, "fck");
-        if (IS_ERR(p->clk)) {
-                dev_err(&p->pdev->dev, "can't get clk\n");
-                return PTR_ERR(p->clk);
+        base[CH_L] = of_iomap(node, CH_L);
+        if (!base[CH_L]) {
+                pr_err("failed to map registers for clocksource\n");
+                goto free_clk;
         }
-
-        p->mapbase1 = res[CH_L]->start;
-        p->mapbase2 = res[CH_H]->start;
-
-        p->cs.name = pdev->name;
-        p->cs.rating = 200;
-        p->cs.read = tpu_clocksource_read;
-        p->cs.enable = tpu_clocksource_enable;
-        p->cs.disable = tpu_clocksource_disable;
-        p->cs.mask = CLOCKSOURCE_MASK(sizeof(unsigned long) * 8);
-        p->cs.flags = CLOCK_SOURCE_IS_CONTINUOUS;
-        clocksource_register_hz(&p->cs, clk_get_rate(p->clk) / 64);
-        platform_set_drvdata(pdev, p);
-
-        return 0;
-}
-
-static int tpu_probe(struct platform_device *pdev)
-{
-        struct tpu_priv *p = platform_get_drvdata(pdev);
-
-        if (p) {
-                dev_info(&pdev->dev, "kept as earlytimer\n");
-                return 0;
+        base[CH_H] = of_iomap(node, CH_H);
+        if (!base[CH_H]) {
+                pr_err("failed to map registers for clocksource\n");
+                goto unmap_L;
         }
 
-        p = devm_kzalloc(&pdev->dev, sizeof(*p), GFP_KERNEL);
-        if (!p)
-                return -ENOMEM;
+        tpu_priv.mapbase1 = base[CH_L];
+        tpu_priv.mapbase2 = base[CH_H];
 
-        return tpu_setup(p, pdev);
-}
-
-static int tpu_remove(struct platform_device *pdev)
-{
-        return -EBUSY;
-}
-
-static const struct of_device_id tpu_of_table[] = {
-        { .compatible = "renesas,tpu" },
-        { }
-};
+        clocksource_register_hz(&tpu_priv.cs, clk_get_rate(clk) / 64);
 
-static struct platform_driver tpu_driver = {
-        .probe          = tpu_probe,
-        .remove         = tpu_remove,
-        .driver         = {
-                .name   = "h8s-tpu",
-                .of_match_table = of_match_ptr(tpu_of_table),
-        }
-};
-
-static int __init tpu_init(void)
-{
-        return platform_driver_register(&tpu_driver);
-}
+        return;
 
-static void __exit tpu_exit(void)
-{
-        platform_driver_unregister(&tpu_driver);
+unmap_L:
+        iounmap(base[CH_H]);
+free_clk:
+        clk_put(clk);
 }
 
-subsys_initcall(tpu_init);
-module_exit(tpu_exit);
-MODULE_AUTHOR("Yoshinori Sato");
-MODULE_DESCRIPTION("H8S Timer Pulse Unit Driver");
-MODULE_LICENSE("GPL v2");
+CLOCKSOURCE_OF_DECLARE(h8300_tpu, "renesas,tpu", h8300_tpu_init);