drivers/clocksource/timer-starfive.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Starfive Timer driver
   4  *
   5  * Copyright 2021 StarFive, Inc. All rights reserved.
   6  */
   7
   8 #include <linux/clk.h>
   9 #include <linux/clocksource.h>
  10 #include <linux/clockchips.h>
  11 #include <linux/err.h>
  12 #include <linux/kernel.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/irq.h>
  15 #include <linux/io.h>
  16 #include <linux/iopoll.h>
  17 #include <linux/of.h>
  18 #include <linux/of_address.h>
  19 #include <linux/of_clk.h>
  20 #include <linux/of_irq.h>
  21 #include <linux/sched_clock.h>
  22 #include <linux/module.h>
  23 #include <linux/reset.h>
  24 #include "timer-starfive.h"
  25
  26 #define CLOCK_SOURCE_RATE       200
  27 #define VALID_BITS              32
  28 #define DELAY_US                0
  29 #define TIMEOUT_US              10000
  30 #define CLOCKEVENT_RATING       300
  31 #define MAX_TICKS               0xffffffff
  32 #define MIN_TICKS               0xf
  33
  34 struct starfive_timer __initdata jh7110_starfive_timer = {
  35         .ctrl           = STF_TIMER_CTL,
  36         .load           = STF_TIMER_LOAD,
  37         .enable         = STF_TIMER_ENABLE,
  38         .reload         = STF_TIMER_RELOAD,
  39         .value          = STF_TIMER_VALUE,
  40         .intclr         = STF_TIMER_INT_CLR,
  41         .intmask        = STF_TIMER_INT_MASK,
  42         .timer_base     = {TIMER_BASE(0), TIMER_BASE(1), TIMER_BASE(2),
  43                         TIMER_BASE(3), TIMER_BASE(4), TIMER_BASE(5),
  44                         TIMER_BASE(6), TIMER_BASE(7)},
  45 };
  46
  47 struct starfive_timer_misc_count sfcmisc = {
  48         .clk_count = 0,
  49         .flg_init_clk = false,
  50 };
  51
  52 static inline struct starfive_clkevt *
  53 to_starfive_clkevt(struct clock_event_device *evt)
  54 {
  55         return container_of(evt, struct starfive_clkevt, evt);
  56 }
  57
  58 static inline struct starfive_clkevt *
  59 to_starfive_clksrc(struct clocksource *cs)
  60 {
  61         return container_of(cs, struct starfive_clkevt, cs);
  62 }
  63
  64 static inline void timer_set_mod(struct starfive_clkevt *clkevt, int mod)
  65 {
  66         writel(mod, clkevt->ctrl);
  67 }
  68
  69 /*
  70  * After disable timer, then enable, the timer will start
  71  * from the reload count value(0x08[31:0]).
  72  */
  73 static inline void timer_int_enable(struct starfive_clkevt *clkevt)
  74 {
  75         writel(INTMASK_ENABLE_DIS, clkevt->intmask);
  76 }
  77
  78 static inline void timer_int_disable(struct starfive_clkevt *clkevt)
  79 {
  80         writel(INTMASK_ENABLE, clkevt->intmask);
  81 }
  82
  83 static inline void timer_int_clear(struct starfive_clkevt *clkevt)
  84 {
  85         /* waiting interrupt can be to clearing */
  86         u32 value;
  87         int ret = 0;
  88
  89         value = readl(clkevt->intclr);
  90         ret = readl_poll_timeout_atomic(clkevt->intclr, value,
  91                         !(value & INT_STATUS_CLR_AVA), DELAY_US, TIMEOUT_US);
  92         if (!ret)
  93                 writel(1, clkevt->intclr);
  94 }
  95
  96 /*
  97  * The initial value to be loaded into the
  98  * counter and is also used as the reload value.
  99  */
 100 static inline void timer_set_val(struct starfive_clkevt *clkevt, u32 val)
 101 {
 102         writel(val, clkevt->load);
 103 }
 104
 105 static inline u32 timer_get_val(struct starfive_clkevt *clkevt)
 106 {
 107         return readl(clkevt->value);
 108 }
 109
 110 static inline u32 timer_get_load_val(struct starfive_clkevt *clkevt)
 111 {
 112         return readl(clkevt->load);
 113 }
 114
 115 /*
 116  * Write RELOAD register to reload preset value to counter.
 117  * (Write 0 and write 1 are both ok)
 118  */
 119 static inline void
 120 timer_set_reload(struct starfive_clkevt *clkevt)
 121 {
 122         writel(1, clkevt->reload);
 123 }
 124
 125 static inline void timer_enable(struct starfive_clkevt *clkevt)
 126 {
 127         writel(TIMER_ENA, clkevt->enable);
 128 }
 129
 130 static inline void timer_disable(struct starfive_clkevt *clkevt)
 131 {
 132         writel(TIMER_ENA_DIS, clkevt->enable);
 133 }
 134
 135 static void timer_shutdown(struct starfive_clkevt *clkevt)
 136 {
 137         timer_int_disable(clkevt);
 138         timer_disable(clkevt);
 139 }
 140
 141 #ifdef CONFIG_PM_SLEEP
 142
 143 static void starfive_timer_suspend(struct clocksource *cs)
 144 {
 145         struct starfive_clkevt *clkevt;
 146         struct clk *pclk;
 147
 148         clkevt = to_starfive_clksrc(cs);
 149
 150         clkevt->reload_val = timer_get_load_val(clkevt);
 151         timer_disable(clkevt);
 152         timer_int_disable(clkevt);
 153
 154         clkevt->misc->clk_count--;
 155
 156         if (clkevt->misc->clk_count < 1)
 157                 pclk = of_clk_get_by_name(clkevt->device_node, "apb_clk");
 158
 159         if (!clkevt->misc->flg_init_clk) {
 160                 const char *name = NULL;
 161
 162                 of_property_read_string_index(clkevt->device_node,
 163                                 "clock-names", clkevt->index, &name);
 164                 clkevt->clk = of_clk_get_by_name(clkevt->device_node, name);
 165                 clk_prepare_enable(clkevt->clk);
 166                 clk_disable_unprepare(clkevt->clk);
 167
 168                 if (clkevt->misc->clk_count < 1) {
 169                         clk_prepare_enable(pclk);
 170                         clk_disable_unprepare(pclk);
 171                 }
 172         } else {
 173                 clk_disable_unprepare(clkevt->clk);
 174
 175                 if (clkevt->misc->clk_count < 1)
 176                         clk_disable_unprepare(pclk);
 177         }
 178 }
 179
 180 static void starfive_timer_resume(struct clocksource *cs)
 181 {
 182         struct starfive_clkevt *clkevt;
 183
 184         clkevt = to_starfive_clksrc(cs);
 185
 186         clkevt->misc->flg_init_clk = true;
 187
 188         if (clkevt->misc->clk_count < 1) {
 189                 struct clk *pclk;
 190
 191                 pclk = of_clk_get_by_name(clkevt->device_node, "apb_clk");
 192                 clk_prepare_enable(pclk);
 193         }
 194         clk_prepare_enable(clkevt->clk);
 195         clkevt->misc->clk_count++;
 196
 197         timer_set_val(clkevt, clkevt->reload_val);
 198         timer_set_reload(clkevt);
 199         timer_int_enable(clkevt);
 200         timer_enable(clkevt);
 201 }
 202
 203 #endif /*CONIFG PM SLEEP*/
 204
 205 static int starfive_timer_shutdown(struct clock_event_device *evt)
 206 {
 207         struct starfive_clkevt *clkevt;
 208
 209         clkevt = to_starfive_clkevt(evt);
 210         timer_shutdown(clkevt);
 211
 212         return 0;
 213 }
 214
 215 static int
 216 starfive_get_clock_rate(struct starfive_clkevt *clkevt, struct device_node *np)
 217 {
 218         int ret;
 219         u32 rate;
 220
 221         if (clkevt->clk) {
 222                 clkevt->rate = clk_get_rate(clkevt->clk);
 223                 if (clkevt->rate > 0) {
 224                         pr_debug("clk_get_rate clkevt->rate: %lld\n",
 225                                 clkevt->rate);
 226                         return 0;
 227                 }
 228         }
 229
 230         /* Next we try to get clock-frequency from dts.*/
 231         ret = of_property_read_u32(np, "clock-frequency", &rate);
 232         if (!ret) {
 233                 pr_debug("Timer: try get clock-frequency:%d MHz\n", rate);
 234                 clkevt->rate = (u64)rate;
 235                 return 0;
 236         }
 237         pr_err("Timer: get rate failed, need clock-frequency define in dts.\n");
 238
 239         return -ENOENT;
 240 }
 241
 242 static u64 starfive_clocksource_mmio_readl_down(struct clocksource *c)
 243 {
 244         return ~(u64)readl_relaxed(to_starfive_clksrc(c)->value) & c->mask;
 245 }
 246
 247 static int starfive_clocksource_init(struct starfive_clkevt *clkevt,
 248                                 const char *name, struct device_node *np)
 249 {
 250
 251         if (VALID_BITS > 64 || VALID_BITS < 16)
 252                 return -EINVAL;
 253
 254         clkevt->cs.name = name;
 255         clkevt->cs.rating = CLOCK_SOURCE_RATE;
 256         clkevt->cs.read = starfive_clocksource_mmio_readl_down;
 257         clkevt->cs.mask = CLOCKSOURCE_MASK(VALID_BITS);
 258         clkevt->cs.flags = CLOCK_SOURCE_IS_CONTINUOUS;
 259         clkevt->cs.suspend = starfive_timer_suspend;
 260         clkevt->cs.resume = starfive_timer_resume;
 261
 262         timer_set_mod(clkevt, MOD_CONTIN);
 263         timer_set_val(clkevt, MAX_TICKS);  /* val = rate --> 1s */
 264         timer_int_disable(clkevt);
 265         timer_int_clear(clkevt);
 266         timer_int_enable(clkevt);
 267         timer_enable(clkevt);
 268
 269         clocksource_register_hz(&clkevt->cs, clkevt->rate);
 270
 271         return 0;
 272 }
 273
 274 /*
 275  * IRQ handler for the timer
 276  */
 277 static irqreturn_t starfive_timer_interrupt(int irq, void *priv)
 278 {
 279         struct clock_event_device *evt = (struct clock_event_device  *)priv;
 280         struct starfive_clkevt *clkevt = to_starfive_clkevt(evt);
 281
 282         timer_int_clear(clkevt);
 283         if (evt->event_handler)
 284                 evt->event_handler(evt);
 285
 286         return IRQ_HANDLED;
 287 }
 288
 289 static int starfive_timer_set_periodic(struct clock_event_device *evt)
 290 {
 291         struct starfive_clkevt *clkevt;
 292
 293         clkevt = to_starfive_clkevt(evt);
 294
 295         timer_disable(clkevt);
 296         timer_set_mod(clkevt, MOD_CONTIN);
 297         timer_set_val(clkevt, clkevt->periodic);
 298         timer_int_disable(clkevt);
 299         timer_int_clear(clkevt);
 300         timer_int_enable(clkevt);
 301         timer_enable(clkevt);
 302
 303         return 0;
 304 }
 305
 306 static int starfive_timer_set_oneshot(struct clock_event_device *evt)
 307 {
 308         struct starfive_clkevt *clkevt;
 309
 310         clkevt = to_starfive_clkevt(evt);
 311
 312         timer_disable(clkevt);
 313         timer_set_mod(clkevt, MOD_SINGLE);
 314         timer_set_val(clkevt, MAX_TICKS);
 315         timer_int_disable(clkevt);
 316         timer_int_clear(clkevt);
 317         timer_int_enable(clkevt);
 318         timer_enable(clkevt);
 319
 320         return 0;
 321 }
 322
 323 static int starfive_timer_set_next_event(unsigned long next,
 324                                         struct clock_event_device *evt)
 325 {
 326         struct starfive_clkevt *clkevt;
 327
 328         clkevt = to_starfive_clkevt(evt);
 329
 330         timer_disable(clkevt);
 331         timer_set_mod(clkevt, MOD_SINGLE);
 332         timer_set_val(clkevt, next);
 333         timer_enable(clkevt);
 334
 335         return 0;
 336 }
 337
 338 static void starfive_set_clockevent(struct clock_event_device *evt)
 339 {
 340         evt->features   = CLOCK_EVT_FEAT_PERIODIC |
 341                         CLOCK_EVT_FEAT_ONESHOT |
 342                         CLOCK_EVT_FEAT_DYNIRQ;
 343         evt->set_state_shutdown = starfive_timer_shutdown;
 344         evt->set_state_periodic = starfive_timer_set_periodic;
 345         evt->set_state_oneshot  = starfive_timer_set_oneshot;
 346         evt->set_state_oneshot_stopped = starfive_timer_shutdown;
 347         evt->set_next_event     = starfive_timer_set_next_event;
 348         evt->rating             = CLOCKEVENT_RATING;
 349 }
 350
 351 static int starfive_clockevents_register(struct starfive_clkevt *clkevt, unsigned int irq,
 352                                 struct device_node *np, const char *name)
 353 {
 354         int ret = 0;
 355
 356         ret = starfive_get_clock_rate(clkevt, np);
 357         if (ret)
 358                 return -EINVAL;
 359
 360         clkevt->periodic = DIV_ROUND_CLOSEST(clkevt->rate, HZ);
 361
 362         starfive_set_clockevent(&clkevt->evt);
 363         clkevt->evt.name = name;
 364         clkevt->evt.irq = irq;
 365         clkevt->evt.cpumask = cpu_possible_mask;
 366
 367         ret = request_irq(irq, starfive_timer_interrupt,
 368                         IRQF_TIMER | IRQF_IRQPOLL, name, &clkevt->evt);
 369         if (ret)
 370                 pr_err("%s: request_irq failed\n", name);
 371
 372         clockevents_config_and_register(&clkevt->evt, clkevt->rate,
 373                         MIN_TICKS, MAX_TICKS);
 374
 375         return ret;
 376 }
 377
 378 static void __init starfive_clkevt_init(struct starfive_timer *timer,
 379                                         struct starfive_clkevt *clkevt,
 380                                         void __iomem *base, int index)
 381 {
 382         void __iomem *timer_base;
 383
 384         timer_base = base + timer->timer_base[index];
 385         clkevt->base    = timer_base;
 386         clkevt->ctrl    = timer_base + timer->ctrl;
 387         clkevt->load    = timer_base + timer->load;
 388         clkevt->enable  = timer_base + timer->enable;
 389         clkevt->reload  = timer_base + timer->reload;
 390         clkevt->value   = timer_base + timer->value;
 391         clkevt->intclr  = timer_base + timer->intclr;
 392         clkevt->intmask = timer_base + timer->intmask;
 393 }
 394
 395 static int __init do_starfive_timer_of_init(struct device_node *np,
 396                                         struct starfive_timer *timer)
 397 {
 398         int index, count, irq, ret = -EINVAL;
 399         const char *name = NULL;
 400         struct clk *clk;
 401         struct clk *pclk;
 402         struct reset_control *prst;
 403         struct reset_control *rst;
 404         struct starfive_clkevt *clkevt[4];
 405         void __iomem *base;
 406
 407         base = of_iomap(np, 0);
 408         if (!base)
 409                 return -ENXIO;
 410
 411         if (!of_device_is_available(np)) {
 412                 ret = -EINVAL;
 413                 goto err;
 414         }
 415
 416         pclk = of_clk_get_by_name(np, "apb_clk");
 417         if (!IS_ERR(pclk))
 418                 if (clk_prepare_enable(pclk))
 419                         pr_warn("pclk for %pOFn is present,"
 420                                 "but could not be activated\n", np);
 421
 422         prst = of_reset_control_get(np, "apb_rst");
 423         if (!IS_ERR(prst)) {
 424                 reset_control_assert(prst);
 425                 reset_control_deassert(prst);
 426         }
 427
 428         count = of_irq_count(np);
 429         if (count > NR_TIMERS || count <= 0) {
 430                 ret = -EINVAL;
 431                 goto count_err;
 432         }
 433
 434         for (index = 0; index < count; index++) {
 435                 /* one of timer is wdog-timer, skip...*/
 436                 of_property_read_string_index(np, "clock-names", index, &name);
 437                 if (strncmp(name, "timer", strlen("timer")))
 438                         continue;
 439
 440                 clkevt[index] = kzalloc(sizeof(*clkevt[index]), GFP_KERNEL);
 441                 if (!clkevt[index]) {
 442                         ret = -ENOMEM;
 443                         goto clkevt_err;
 444                 }
 445                 clkevt[index]->device_node = np;
 446                 clkevt[index]->index = index;
 447                 clkevt[index]->misc = &sfcmisc;
 448
 449                 starfive_clkevt_init(timer, clkevt[index], base, index);
 450
 451                 /* Ensure timers are disabled */
 452                 timer_disable(clkevt[index]);
 453
 454                 clk = of_clk_get_by_name(np, name);
 455                 if (!IS_ERR(clk)) {
 456                         clkevt[index]->clk = clk;
 457
 458                         if (clk_prepare_enable(clk)) {
 459                                 pr_warn("clk for %pOFn is present,"
 460                                         "but could not be activated\n", np);
 461                         }
 462                 }
 463
 464                 clkevt[index]->misc->clk_count++;
 465
 466                 rst = of_reset_control_get(np, name);
 467                 if (!IS_ERR(rst)) {
 468                         reset_control_assert(rst);
 469                         reset_control_deassert(rst);
 470                 }
 471
 472                 irq = irq_of_parse_and_map(np, index);
 473                 if (irq < 0) {
 474                         ret = -EINVAL;
 475                         goto irq_err;
 476                 }
 477
 478                 snprintf(clkevt[index]->name, sizeof(clkevt[index]->name), "%s.ch%d",
 479                                         np->full_name, index);
 480
 481                 ret = starfive_clockevents_register(clkevt[index], irq, np, clkevt[index]->name);
 482                 if (ret) {
 483                         pr_err("%s: init clockevents failed.\n", clkevt[index]->name);
 484                         goto register_err;
 485                 }
 486                 clkevt[index]->irq = irq;
 487
 488                 ret = starfive_clocksource_init(clkevt[index], clkevt[index]->name, np);
 489                 if (ret)
 490                         goto init_err;
 491         }
 492         if (!IS_ERR(pclk))
 493                 clk_put(pclk);
 494
 495         return 0;
 496
 497 init_err:
 498 register_err:
 499         free_irq(clkevt[index]->irq, &clkevt[index]->evt);
 500 irq_err:
 501         if (!rst) {
 502                 reset_control_assert(rst);
 503                 reset_control_put(rst);
 504         }
 505         if (!clkevt[index]->clk) {
 506                 clk_disable_unprepare(clkevt[index]->clk);
 507                 clk_put(clkevt[index]->clk);
 508         }
 509         kfree(clkevt[index]);
 510 clkevt_err:
 511 count_err:
 512         if (!IS_ERR(pclk)) {
 513                 if (!index)
 514                         clk_disable_unprepare(pclk);
 515                 clk_put(pclk);
 516         }
 517 err:
 518         iounmap(base);
 519         return ret;
 520 }
 521
 522 static int __init starfive_timer_of_init(struct device_node *np)
 523 {
 524         return do_starfive_timer_of_init(np, &jh7110_starfive_timer);
 525 }
 526 TIMER_OF_DECLARE(starfive_timer, "starfive,jh7110-timers", starfive_timer_of_init);
 527
 528 MODULE_AUTHOR("xingyu.wu <xingyu.wu@starfivetech.com>");
 529 MODULE_AUTHOR("samin.guo <samin.guo@starfivetech.com>");
 530 MODULE_DESCRIPTION("StarFive Timer Device Driver");
 531 MODULE_LICENSE("GPL v2");