drivers/clocksource/timer-sun5i.c

   1 /*
   2  * Allwinner SoCs hstimer driver.
   3  *
   4  * Copyright (C) 2013 Maxime Ripard
   5  *
   6  * Maxime Ripard <maxime.ripard@free-electrons.com>
   7  *
   8  * This file is licensed under the terms of the GNU General Public
   9  * License version 2.  This program is licensed "as is" without any
  10  * warranty of any kind, whether express or implied.
  11  */
  12
  13 #include <linux/clk.h>
  14 #include <linux/clockchips.h>
  15 #include <linux/delay.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/irq.h>
  18 #include <linux/irqreturn.h>
  19 #include <linux/reset.h>
  20 #include <linux/slab.h>
  21 #include <linux/of.h>
  22 #include <linux/of_address.h>
  23 #include <linux/of_irq.h>
  24
  25 #define TIMER_IRQ_EN_REG                0x00
  26 #define TIMER_IRQ_EN(val)                       BIT(val)
  27 #define TIMER_IRQ_ST_REG                0x04
  28 #define TIMER_CTL_REG(val)              (0x20 * (val) + 0x10)
  29 #define TIMER_CTL_ENABLE                        BIT(0)
  30 #define TIMER_CTL_RELOAD                        BIT(1)
  31 #define TIMER_CTL_CLK_PRES(val)                 (((val) & 0x7) << 4)
  32 #define TIMER_CTL_ONESHOT                       BIT(7)
  33 #define TIMER_INTVAL_LO_REG(val)        (0x20 * (val) + 0x14)
  34 #define TIMER_INTVAL_HI_REG(val)        (0x20 * (val) + 0x18)
  35 #define TIMER_CNTVAL_LO_REG(val)        (0x20 * (val) + 0x1c)
  36 #define TIMER_CNTVAL_HI_REG(val)        (0x20 * (val) + 0x20)
  37
  38 #define TIMER_SYNC_TICKS        3
  39
  40 struct sun5i_timer {
  41         void __iomem            *base;
  42         struct clk              *clk;
  43         struct notifier_block   clk_rate_cb;
  44         u32                     ticks_per_jiffy;
  45 };
  46
  47 #define to_sun5i_timer(x) \
  48         container_of(x, struct sun5i_timer, clk_rate_cb)
  49
  50 struct sun5i_timer_clksrc {
  51         struct sun5i_timer      timer;
  52         struct clocksource      clksrc;
  53 };
  54
  55 #define to_sun5i_timer_clksrc(x) \
  56         container_of(x, struct sun5i_timer_clksrc, clksrc)
  57
  58 struct sun5i_timer_clkevt {
  59         struct sun5i_timer              timer;
  60         struct clock_event_device       clkevt;
  61 };
  62
  63 #define to_sun5i_timer_clkevt(x) \
  64         container_of(x, struct sun5i_timer_clkevt, clkevt)
  65
  66 /*
  67  * When we disable a timer, we need to wait at least for 2 cycles of
  68  * the timer source clock. We will use for that the clocksource timer
  69  * that is already setup and runs at the same frequency than the other
  70  * timers, and we never will be disabled.
  71  */
  72 static void sun5i_clkevt_sync(struct sun5i_timer_clkevt *ce)
  73 {
  74         u32 old = readl(ce->timer.base + TIMER_CNTVAL_LO_REG(1));
  75
  76         while ((old - readl(ce->timer.base + TIMER_CNTVAL_LO_REG(1))) < TIMER_SYNC_TICKS)
  77                 cpu_relax();
  78 }
  79
  80 static void sun5i_clkevt_time_stop(struct sun5i_timer_clkevt *ce, u8 timer)
  81 {
  82         u32 val = readl(ce->timer.base + TIMER_CTL_REG(timer));
  83         writel(val & ~TIMER_CTL_ENABLE, ce->timer.base + TIMER_CTL_REG(timer));
  84
  85         sun5i_clkevt_sync(ce);
  86 }
  87
  88 static void sun5i_clkevt_time_setup(struct sun5i_timer_clkevt *ce, u8 timer, u32 delay)
  89 {
  90         writel(delay, ce->timer.base + TIMER_INTVAL_LO_REG(timer));
  91 }
  92
  93 static void sun5i_clkevt_time_start(struct sun5i_timer_clkevt *ce, u8 timer, bool periodic)
  94 {
  95         u32 val = readl(ce->timer.base + TIMER_CTL_REG(timer));
  96
  97         if (periodic)
  98                 val &= ~TIMER_CTL_ONESHOT;
  99         else
 100                 val |= TIMER_CTL_ONESHOT;
 101
 102         writel(val | TIMER_CTL_ENABLE | TIMER_CTL_RELOAD,
 103                ce->timer.base + TIMER_CTL_REG(timer));
 104 }
 105
 106 static int sun5i_clkevt_shutdown(struct clock_event_device *clkevt)
 107 {
 108         struct sun5i_timer_clkevt *ce = to_sun5i_timer_clkevt(clkevt);
 109
 110         sun5i_clkevt_time_stop(ce, 0);
 111         return 0;
 112 }
 113
 114 static int sun5i_clkevt_set_oneshot(struct clock_event_device *clkevt)
 115 {
 116         struct sun5i_timer_clkevt *ce = to_sun5i_timer_clkevt(clkevt);
 117
 118         sun5i_clkevt_time_stop(ce, 0);
 119         sun5i_clkevt_time_start(ce, 0, false);
 120         return 0;
 121 }
 122
 123 static int sun5i_clkevt_set_periodic(struct clock_event_device *clkevt)
 124 {
 125         struct sun5i_timer_clkevt *ce = to_sun5i_timer_clkevt(clkevt);
 126
 127         sun5i_clkevt_time_stop(ce, 0);
 128         sun5i_clkevt_time_setup(ce, 0, ce->timer.ticks_per_jiffy);
 129         sun5i_clkevt_time_start(ce, 0, true);
 130         return 0;
 131 }
 132
 133 static int sun5i_clkevt_next_event(unsigned long evt,
 134                                    struct clock_event_device *clkevt)
 135 {
 136         struct sun5i_timer_clkevt *ce = to_sun5i_timer_clkevt(clkevt);
 137
 138         sun5i_clkevt_time_stop(ce, 0);
 139         sun5i_clkevt_time_setup(ce, 0, evt - TIMER_SYNC_TICKS);
 140         sun5i_clkevt_time_start(ce, 0, false);
 141
 142         return 0;
 143 }
 144
 145 static irqreturn_t sun5i_timer_interrupt(int irq, void *dev_id)
 146 {
 147         struct sun5i_timer_clkevt *ce = (struct sun5i_timer_clkevt *)dev_id;
 148
 149         writel(0x1, ce->timer.base + TIMER_IRQ_ST_REG);
 150         ce->clkevt.event_handler(&ce->clkevt);
 151
 152         return IRQ_HANDLED;
 153 }
 154
 155 static cycle_t sun5i_clksrc_read(struct clocksource *clksrc)
 156 {
 157         struct sun5i_timer_clksrc *cs = to_sun5i_timer_clksrc(clksrc);
 158
 159         return ~readl(cs->timer.base + TIMER_CNTVAL_LO_REG(1));
 160 }
 161
 162 static int sun5i_rate_cb_clksrc(struct notifier_block *nb,
 163                                 unsigned long event, void *data)
 164 {
 165         struct clk_notifier_data *ndata = data;
 166         struct sun5i_timer *timer = to_sun5i_timer(nb);
 167         struct sun5i_timer_clksrc *cs = container_of(timer, struct sun5i_timer_clksrc, timer);
 168
 169         switch (event) {
 170         case PRE_RATE_CHANGE:
 171                 clocksource_unregister(&cs->clksrc);
 172                 break;
 173
 174         case POST_RATE_CHANGE:
 175                 clocksource_register_hz(&cs->clksrc, ndata->new_rate);
 176                 break;
 177
 178         default:
 179                 break;
 180         }
 181
 182         return NOTIFY_DONE;
 183 }
 184
 185 static int __init sun5i_setup_clocksource(struct device_node *node,
 186                                           void __iomem *base,
 187                                           struct clk *clk, int irq)
 188 {
 189         struct sun5i_timer_clksrc *cs;
 190         unsigned long rate;
 191         int ret;
 192
 193         cs = kzalloc(sizeof(*cs), GFP_KERNEL);
 194         if (!cs)
 195                 return -ENOMEM;
 196
 197         ret = clk_prepare_enable(clk);
 198         if (ret) {
 199                 pr_err("Couldn't enable parent clock\n");
 200                 goto err_free;
 201         }
 202
 203         rate = clk_get_rate(clk);
 204         if (!rate) {
 205                 pr_err("Couldn't get parent clock rate\n");
 206                 ret = -EINVAL;
 207                 goto err_disable_clk;
 208         }
 209
 210         cs->timer.base = base;
 211         cs->timer.clk = clk;
 212         cs->timer.clk_rate_cb.notifier_call = sun5i_rate_cb_clksrc;
 213         cs->timer.clk_rate_cb.next = NULL;
 214
 215         ret = clk_notifier_register(clk, &cs->timer.clk_rate_cb);
 216         if (ret) {
 217                 pr_err("Unable to register clock notifier.\n");
 218                 goto err_disable_clk;
 219         }
 220
 221         writel(~0, base + TIMER_INTVAL_LO_REG(1));
 222         writel(TIMER_CTL_ENABLE | TIMER_CTL_RELOAD,
 223                base + TIMER_CTL_REG(1));
 224
 225         cs->clksrc.name = node->name;
 226         cs->clksrc.rating = 340;
 227         cs->clksrc.read = sun5i_clksrc_read;
 228         cs->clksrc.mask = CLOCKSOURCE_MASK(32);
 229         cs->clksrc.flags = CLOCK_SOURCE_IS_CONTINUOUS;
 230
 231         ret = clocksource_register_hz(&cs->clksrc, rate);
 232         if (ret) {
 233                 pr_err("Couldn't register clock source.\n");
 234                 goto err_remove_notifier;
 235         }
 236
 237         return 0;
 238
 239 err_remove_notifier:
 240         clk_notifier_unregister(clk, &cs->timer.clk_rate_cb);
 241 err_disable_clk:
 242         clk_disable_unprepare(clk);
 243 err_free:
 244         kfree(cs);
 245         return ret;
 246 }
 247
 248 static int sun5i_rate_cb_clkevt(struct notifier_block *nb,
 249                                 unsigned long event, void *data)
 250 {
 251         struct clk_notifier_data *ndata = data;
 252         struct sun5i_timer *timer = to_sun5i_timer(nb);
 253         struct sun5i_timer_clkevt *ce = container_of(timer, struct sun5i_timer_clkevt, timer);
 254
 255         if (event == POST_RATE_CHANGE) {
 256                 clockevents_update_freq(&ce->clkevt, ndata->new_rate);
 257                 ce->timer.ticks_per_jiffy = DIV_ROUND_UP(ndata->new_rate, HZ);
 258         }
 259
 260         return NOTIFY_DONE;
 261 }
 262
 263 static int __init sun5i_setup_clockevent(struct device_node *node, void __iomem *base,
 264                                          struct clk *clk, int irq)
 265 {
 266         struct sun5i_timer_clkevt *ce;
 267         unsigned long rate;
 268         int ret;
 269         u32 val;
 270
 271         ce = kzalloc(sizeof(*ce), GFP_KERNEL);
 272         if (!ce)
 273                 return -ENOMEM;
 274
 275         ret = clk_prepare_enable(clk);
 276         if (ret) {
 277                 pr_err("Couldn't enable parent clock\n");
 278                 goto err_free;
 279         }
 280
 281         rate = clk_get_rate(clk);
 282         if (!rate) {
 283                 pr_err("Couldn't get parent clock rate\n");
 284                 ret = -EINVAL;
 285                 goto err_disable_clk;
 286         }
 287
 288         ce->timer.base = base;
 289         ce->timer.ticks_per_jiffy = DIV_ROUND_UP(rate, HZ);
 290         ce->timer.clk = clk;
 291         ce->timer.clk_rate_cb.notifier_call = sun5i_rate_cb_clkevt;
 292         ce->timer.clk_rate_cb.next = NULL;
 293
 294         ret = clk_notifier_register(clk, &ce->timer.clk_rate_cb);
 295         if (ret) {
 296                 pr_err("Unable to register clock notifier.\n");
 297                 goto err_disable_clk;
 298         }
 299
 300         ce->clkevt.name = node->name;
 301         ce->clkevt.features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT;
 302         ce->clkevt.set_next_event = sun5i_clkevt_next_event;
 303         ce->clkevt.set_state_shutdown = sun5i_clkevt_shutdown;
 304         ce->clkevt.set_state_periodic = sun5i_clkevt_set_periodic;
 305         ce->clkevt.set_state_oneshot = sun5i_clkevt_set_oneshot;
 306         ce->clkevt.tick_resume = sun5i_clkevt_shutdown;
 307         ce->clkevt.rating = 340;
 308         ce->clkevt.irq = irq;
 309         ce->clkevt.cpumask = cpu_possible_mask;
 310
 311         /* Enable timer0 interrupt */
 312         val = readl(base + TIMER_IRQ_EN_REG);
 313         writel(val | TIMER_IRQ_EN(0), base + TIMER_IRQ_EN_REG);
 314
 315         clockevents_config_and_register(&ce->clkevt, rate,
 316                                         TIMER_SYNC_TICKS, 0xffffffff);
 317
 318         ret = request_irq(irq, sun5i_timer_interrupt, IRQF_TIMER | IRQF_IRQPOLL,
 319                           "sun5i_timer0", ce);
 320         if (ret) {
 321                 pr_err("Unable to register interrupt\n");
 322                 goto err_remove_notifier;
 323         }
 324
 325         return 0;
 326
 327 err_remove_notifier:
 328         clk_notifier_unregister(clk, &ce->timer.clk_rate_cb);
 329 err_disable_clk:
 330         clk_disable_unprepare(clk);
 331 err_free:
 332         kfree(ce);
 333         return ret;
 334 }
 335
 336 static int __init sun5i_timer_init(struct device_node *node)
 337 {
 338         struct reset_control *rstc;
 339         void __iomem *timer_base;
 340         struct clk *clk;
 341         int irq, ret;
 342
 343         timer_base = of_io_request_and_map(node, 0, of_node_full_name(node));
 344         if (IS_ERR(timer_base)) {
 345                 pr_err("Can't map registers");
 346                 return PTR_ERR(timer_base);;
 347         }
 348
 349         irq = irq_of_parse_and_map(node, 0);
 350         if (irq <= 0) {
 351                 pr_err("Can't parse IRQ");
 352                 return -EINVAL;
 353         }
 354
 355         clk = of_clk_get(node, 0);
 356         if (IS_ERR(clk)) {
 357                 pr_err("Can't get timer clock");
 358                 return PTR_ERR(clk);
 359         }
 360
 361         rstc = of_reset_control_get(node, NULL);
 362         if (!IS_ERR(rstc))
 363                 reset_control_deassert(rstc);
 364
 365         ret = sun5i_setup_clocksource(node, timer_base, clk, irq);
 366         if (ret)
 367                 return ret;
 368
 369         return sun5i_setup_clockevent(node, timer_base, clk, irq);
 370 }
 371 CLOCKSOURCE_OF_DECLARE(sun5i_a13, "allwinner,sun5i-a13-hstimer",
 372                            sun5i_timer_init);
 373 CLOCKSOURCE_OF_DECLARE(sun7i_a20, "allwinner,sun7i-a20-hstimer",
 374                            sun5i_timer_init);