drivers/clocksource/timer-ti-dm.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * linux/arch/arm/plat-omap/dmtimer.c
   4  *
   5  * OMAP Dual-Mode Timers
   6  *
   7  * Copyright (C) 2010 Texas Instruments Incorporated - https://www.ti.com/
   8  * Tarun Kanti DebBarma <tarun.kanti@ti.com>
   9  * Thara Gopinath <thara@ti.com>
  10  *
  11  * dmtimer adaptation to platform_driver.
  12  *
  13  * Copyright (C) 2005 Nokia Corporation
  14  * OMAP2 support by Juha Yrjola
  15  * API improvements and OMAP2 clock framework support by Timo Teras
  16  *
  17  * Copyright (C) 2009 Texas Instruments
  18  * Added OMAP4 support - Santosh Shilimkar <santosh.shilimkar@ti.com>
  19  */
  20
  21 #include <linux/clk.h>
  22 #include <linux/clk-provider.h>
  23 #include <linux/cpu_pm.h>
  24 #include <linux/module.h>
  25 #include <linux/io.h>
  26 #include <linux/device.h>
  27 #include <linux/err.h>
  28 #include <linux/pm_runtime.h>
  29 #include <linux/of.h>
  30 #include <linux/of_device.h>
  31 #include <linux/platform_device.h>
  32 #include <linux/platform_data/dmtimer-omap.h>
  33
  34 #include <clocksource/timer-ti-dm.h>
  35
  36 /*
  37  * timer errata flags
  38  *
  39  * Errata i103/i767 impacts all OMAP3/4/5 devices including AM33xx. This
  40  * errata prevents us from using posted mode on these devices, unless the
  41  * timer counter register is never read. For more details please refer to
  42  * the OMAP3/4/5 errata documents.
  43  */
  44 #define OMAP_TIMER_ERRATA_I103_I767                     0x80000000
  45
  46 /* posted mode types */
  47 #define OMAP_TIMER_NONPOSTED                    0x00
  48 #define OMAP_TIMER_POSTED                       0x01
  49
  50 /* register offsets with the write pending bit encoded */
  51 #define WPSHIFT                                 16
  52
  53 #define OMAP_TIMER_WAKEUP_EN_REG                (_OMAP_TIMER_WAKEUP_EN_OFFSET \
  54                                                         | (WP_NONE << WPSHIFT))
  55
  56 #define OMAP_TIMER_CTRL_REG                     (_OMAP_TIMER_CTRL_OFFSET \
  57                                                         | (WP_TCLR << WPSHIFT))
  58
  59 #define OMAP_TIMER_COUNTER_REG                  (_OMAP_TIMER_COUNTER_OFFSET \
  60                                                         | (WP_TCRR << WPSHIFT))
  61
  62 #define OMAP_TIMER_LOAD_REG                     (_OMAP_TIMER_LOAD_OFFSET \
  63                                                         | (WP_TLDR << WPSHIFT))
  64
  65 #define OMAP_TIMER_TRIGGER_REG                  (_OMAP_TIMER_TRIGGER_OFFSET \
  66                                                         | (WP_TTGR << WPSHIFT))
  67
  68 #define OMAP_TIMER_WRITE_PEND_REG               (_OMAP_TIMER_WRITE_PEND_OFFSET \
  69                                                         | (WP_NONE << WPSHIFT))
  70
  71 #define OMAP_TIMER_MATCH_REG                    (_OMAP_TIMER_MATCH_OFFSET \
  72                                                         | (WP_TMAR << WPSHIFT))
  73
  74 #define OMAP_TIMER_CAPTURE_REG                  (_OMAP_TIMER_CAPTURE_OFFSET \
  75                                                         | (WP_NONE << WPSHIFT))
  76
  77 #define OMAP_TIMER_IF_CTRL_REG                  (_OMAP_TIMER_IF_CTRL_OFFSET \
  78                                                         | (WP_NONE << WPSHIFT))
  79
  80 #define OMAP_TIMER_CAPTURE2_REG                 (_OMAP_TIMER_CAPTURE2_OFFSET \
  81                                                         | (WP_NONE << WPSHIFT))
  82
  83 #define OMAP_TIMER_TICK_POS_REG                 (_OMAP_TIMER_TICK_POS_OFFSET \
  84                                                         | (WP_TPIR << WPSHIFT))
  85
  86 #define OMAP_TIMER_TICK_NEG_REG                 (_OMAP_TIMER_TICK_NEG_OFFSET \
  87                                                         | (WP_TNIR << WPSHIFT))
  88
  89 #define OMAP_TIMER_TICK_COUNT_REG               (_OMAP_TIMER_TICK_COUNT_OFFSET \
  90                                                         | (WP_TCVR << WPSHIFT))
  91
  92 #define OMAP_TIMER_TICK_INT_MASK_SET_REG                                \
  93                 (_OMAP_TIMER_TICK_INT_MASK_SET_OFFSET | (WP_TOCR << WPSHIFT))
  94
  95 #define OMAP_TIMER_TICK_INT_MASK_COUNT_REG                              \
  96                 (_OMAP_TIMER_TICK_INT_MASK_COUNT_OFFSET | (WP_TOWR << WPSHIFT))
  97
  98 struct timer_regs {
  99         u32 ocp_cfg;
 100         u32 tidr;
 101         u32 tier;
 102         u32 twer;
 103         u32 tclr;
 104         u32 tcrr;
 105         u32 tldr;
 106         u32 ttrg;
 107         u32 twps;
 108         u32 tmar;
 109         u32 tcar1;
 110         u32 tsicr;
 111         u32 tcar2;
 112         u32 tpir;
 113         u32 tnir;
 114         u32 tcvr;
 115         u32 tocr;
 116         u32 towr;
 117 };
 118
 119 struct dmtimer {
 120         struct omap_dm_timer cookie;
 121         int id;
 122         int irq;
 123         struct clk *fclk;
 124
 125         void __iomem    *io_base;
 126         int             irq_stat;       /* TISR/IRQSTATUS interrupt status */
 127         int             irq_ena;        /* irq enable */
 128         int             irq_dis;        /* irq disable, only on v2 ip */
 129         void __iomem    *pend;          /* write pending */
 130         void __iomem    *func_base;     /* function register base */
 131
 132         atomic_t enabled;
 133         unsigned long rate;
 134         unsigned reserved:1;
 135         unsigned posted:1;
 136         unsigned omap1:1;
 137         struct timer_regs context;
 138         int revision;
 139         u32 capability;
 140         u32 errata;
 141         struct platform_device *pdev;
 142         struct list_head node;
 143         struct notifier_block nb;
 144 };
 145
 146 static u32 omap_reserved_systimers;
 147 static LIST_HEAD(omap_timer_list);
 148 static DEFINE_SPINLOCK(dm_timer_lock);
 149
 150 enum {
 151         REQUEST_ANY = 0,
 152         REQUEST_BY_ID,
 153         REQUEST_BY_CAP,
 154         REQUEST_BY_NODE,
 155 };
 156
 157 /**
 158  * dmtimer_read - read timer registers in posted and non-posted mode
 159  * @timer:      timer pointer over which read operation to perform
 160  * @reg:        lowest byte holds the register offset
 161  *
 162  * The posted mode bit is encoded in reg. Note that in posted mode, write
 163  * pending bit must be checked. Otherwise a read of a non completed write
 164  * will produce an error.
 165  */
 166 static inline u32 dmtimer_read(struct dmtimer *timer, u32 reg)
 167 {
 168         u16 wp, offset;
 169
 170         wp = reg >> WPSHIFT;
 171         offset = reg & 0xff;
 172
 173         /* Wait for a possible write pending bit in posted mode */
 174         if (wp && timer->posted)
 175                 while (readl_relaxed(timer->pend) & wp)
 176                         cpu_relax();
 177
 178         return readl_relaxed(timer->func_base + offset);
 179 }
 180
 181 /**
 182  * dmtimer_write - write timer registers in posted and non-posted mode
 183  * @timer:      timer pointer over which write operation is to perform
 184  * @reg:        lowest byte holds the register offset
 185  * @value:      data to write into the register
 186  *
 187  * The posted mode bit is encoded in reg. Note that in posted mode, the write
 188  * pending bit must be checked. Otherwise a write on a register which has a
 189  * pending write will be lost.
 190  */
 191 static inline void dmtimer_write(struct dmtimer *timer, u32 reg, u32 val)
 192 {
 193         u16 wp, offset;
 194
 195         wp = reg >> WPSHIFT;
 196         offset = reg & 0xff;
 197
 198         /* Wait for a possible write pending bit in posted mode */
 199         if (wp && timer->posted)
 200                 while (readl_relaxed(timer->pend) & wp)
 201                         cpu_relax();
 202
 203         writel_relaxed(val, timer->func_base + offset);
 204 }
 205
 206 static inline void __omap_dm_timer_init_regs(struct dmtimer *timer)
 207 {
 208         u32 tidr;
 209
 210         /* Assume v1 ip if bits [31:16] are zero */
 211         tidr = readl_relaxed(timer->io_base);
 212         if (!(tidr >> 16)) {
 213                 timer->revision = 1;
 214                 timer->irq_stat = OMAP_TIMER_V1_STAT_OFFSET;
 215                 timer->irq_ena = OMAP_TIMER_V1_INT_EN_OFFSET;
 216                 timer->irq_dis = OMAP_TIMER_V1_INT_EN_OFFSET;
 217                 timer->pend = timer->io_base + _OMAP_TIMER_WRITE_PEND_OFFSET;
 218                 timer->func_base = timer->io_base;
 219         } else {
 220                 timer->revision = 2;
 221                 timer->irq_stat = OMAP_TIMER_V2_IRQSTATUS - OMAP_TIMER_V2_FUNC_OFFSET;
 222                 timer->irq_ena = OMAP_TIMER_V2_IRQENABLE_SET - OMAP_TIMER_V2_FUNC_OFFSET;
 223                 timer->irq_dis = OMAP_TIMER_V2_IRQENABLE_CLR - OMAP_TIMER_V2_FUNC_OFFSET;
 224                 timer->pend = timer->io_base +
 225                         _OMAP_TIMER_WRITE_PEND_OFFSET +
 226                                 OMAP_TIMER_V2_FUNC_OFFSET;
 227                 timer->func_base = timer->io_base + OMAP_TIMER_V2_FUNC_OFFSET;
 228         }
 229 }
 230
 231 /*
 232  * __omap_dm_timer_enable_posted - enables write posted mode
 233  * @timer:      pointer to timer instance handle
 234  *
 235  * Enables the write posted mode for the timer. When posted mode is enabled
 236  * writes to certain timer registers are immediately acknowledged by the
 237  * internal bus and hence prevents stalling the CPU waiting for the write to
 238  * complete. Enabling this feature can improve performance for writing to the
 239  * timer registers.
 240  */
 241 static inline void __omap_dm_timer_enable_posted(struct dmtimer *timer)
 242 {
 243         if (timer->posted)
 244                 return;
 245
 246         if (timer->errata & OMAP_TIMER_ERRATA_I103_I767) {
 247                 timer->posted = OMAP_TIMER_NONPOSTED;
 248                 dmtimer_write(timer, OMAP_TIMER_IF_CTRL_REG, 0);
 249                 return;
 250         }
 251
 252         dmtimer_write(timer, OMAP_TIMER_IF_CTRL_REG, OMAP_TIMER_CTRL_POSTED);
 253         timer->context.tsicr = OMAP_TIMER_CTRL_POSTED;
 254         timer->posted = OMAP_TIMER_POSTED;
 255 }
 256
 257 static inline void __omap_dm_timer_stop(struct dmtimer *timer,
 258                                         unsigned long rate)
 259 {
 260         u32 l;
 261
 262         l = dmtimer_read(timer, OMAP_TIMER_CTRL_REG);
 263         if (l & OMAP_TIMER_CTRL_ST) {
 264                 l &= ~0x1;
 265                 dmtimer_write(timer, OMAP_TIMER_CTRL_REG, l);
 266 #ifdef CONFIG_ARCH_OMAP2PLUS
 267                 /* Readback to make sure write has completed */
 268                 dmtimer_read(timer, OMAP_TIMER_CTRL_REG);
 269                 /*
 270                  * Wait for functional clock period x 3.5 to make sure that
 271                  * timer is stopped
 272                  */
 273                 udelay(3500000 / rate + 1);
 274 #endif
 275         }
 276
 277         /* Ack possibly pending interrupt */
 278         dmtimer_write(timer, timer->irq_stat, OMAP_TIMER_INT_OVERFLOW);
 279 }
 280
 281 static inline void __omap_dm_timer_int_enable(struct dmtimer *timer,
 282                                               unsigned int value)
 283 {
 284         dmtimer_write(timer, timer->irq_ena, value);
 285         dmtimer_write(timer, OMAP_TIMER_WAKEUP_EN_REG, value);
 286 }
 287
 288 static inline unsigned int
 289 __omap_dm_timer_read_counter(struct dmtimer *timer)
 290 {
 291         return dmtimer_read(timer, OMAP_TIMER_COUNTER_REG);
 292 }
 293
 294 static inline void __omap_dm_timer_write_status(struct dmtimer *timer,
 295                                                 unsigned int value)
 296 {
 297         dmtimer_write(timer, timer->irq_stat, value);
 298 }
 299
 300 static void omap_timer_restore_context(struct dmtimer *timer)
 301 {
 302         dmtimer_write(timer, OMAP_TIMER_OCP_CFG_OFFSET, timer->context.ocp_cfg);
 303
 304         dmtimer_write(timer, OMAP_TIMER_WAKEUP_EN_REG, timer->context.twer);
 305         dmtimer_write(timer, OMAP_TIMER_COUNTER_REG, timer->context.tcrr);
 306         dmtimer_write(timer, OMAP_TIMER_LOAD_REG, timer->context.tldr);
 307         dmtimer_write(timer, OMAP_TIMER_MATCH_REG, timer->context.tmar);
 308         dmtimer_write(timer, OMAP_TIMER_IF_CTRL_REG, timer->context.tsicr);
 309         dmtimer_write(timer, timer->irq_ena, timer->context.tier);
 310         dmtimer_write(timer, OMAP_TIMER_CTRL_REG, timer->context.tclr);
 311 }
 312
 313 static void omap_timer_save_context(struct dmtimer *timer)
 314 {
 315         timer->context.ocp_cfg = dmtimer_read(timer, OMAP_TIMER_OCP_CFG_OFFSET);
 316
 317         timer->context.tclr = dmtimer_read(timer, OMAP_TIMER_CTRL_REG);
 318         timer->context.twer = dmtimer_read(timer, OMAP_TIMER_WAKEUP_EN_REG);
 319         timer->context.tldr = dmtimer_read(timer, OMAP_TIMER_LOAD_REG);
 320         timer->context.tmar = dmtimer_read(timer, OMAP_TIMER_MATCH_REG);
 321         timer->context.tier = dmtimer_read(timer, timer->irq_ena);
 322         timer->context.tsicr = dmtimer_read(timer, OMAP_TIMER_IF_CTRL_REG);
 323 }
 324
 325 static int omap_timer_context_notifier(struct notifier_block *nb,
 326                                        unsigned long cmd, void *v)
 327 {
 328         struct dmtimer *timer;
 329
 330         timer = container_of(nb, struct dmtimer, nb);
 331
 332         switch (cmd) {
 333         case CPU_CLUSTER_PM_ENTER:
 334                 if ((timer->capability & OMAP_TIMER_ALWON) ||
 335                     !atomic_read(&timer->enabled))
 336                         break;
 337                 omap_timer_save_context(timer);
 338                 break;
 339         case CPU_CLUSTER_PM_ENTER_FAILED:       /* No need to restore context */
 340                 break;
 341         case CPU_CLUSTER_PM_EXIT:
 342                 if ((timer->capability & OMAP_TIMER_ALWON) ||
 343                     !atomic_read(&timer->enabled))
 344                         break;
 345                 omap_timer_restore_context(timer);
 346                 break;
 347         }
 348
 349         return NOTIFY_OK;
 350 }
 351
 352 static int omap_dm_timer_reset(struct dmtimer *timer)
 353 {
 354         u32 l, timeout = 100000;
 355
 356         if (timer->revision != 1)
 357                 return -EINVAL;
 358
 359         dmtimer_write(timer, OMAP_TIMER_IF_CTRL_REG, 0x06);
 360
 361         do {
 362                 l = dmtimer_read(timer, OMAP_TIMER_V1_SYS_STAT_OFFSET);
 363         } while (!l && timeout--);
 364
 365         if (!timeout) {
 366                 dev_err(&timer->pdev->dev, "Timer failed to reset\n");
 367                 return -ETIMEDOUT;
 368         }
 369
 370         /* Configure timer for smart-idle mode */
 371         l = dmtimer_read(timer, OMAP_TIMER_OCP_CFG_OFFSET);
 372         l |= 0x2 << 0x3;
 373         dmtimer_write(timer, OMAP_TIMER_OCP_CFG_OFFSET, l);
 374
 375         timer->posted = 0;
 376
 377         return 0;
 378 }
 379
 380 /*
 381  * Functions exposed to PWM and remoteproc drivers via platform_data.
 382  * Do not use these in the driver, these will get deprecated and will
 383  * will be replaced by Linux generic framework functions such as
 384  * chained interrupts and clock framework.
 385  */
 386 static struct dmtimer *to_dmtimer(struct omap_dm_timer *cookie)
 387 {
 388         if (!cookie)
 389                 return NULL;
 390
 391         return container_of(cookie, struct dmtimer, cookie);
 392 }
 393
 394 static int omap_dm_timer_set_source(struct omap_dm_timer *cookie, int source)
 395 {
 396         int ret;
 397         const char *parent_name;
 398         struct clk *parent;
 399         struct dmtimer_platform_data *pdata;
 400         struct dmtimer *timer;
 401
 402         timer = to_dmtimer(cookie);
 403         if (unlikely(!timer) || IS_ERR(timer->fclk))
 404                 return -EINVAL;
 405
 406         switch (source) {
 407         case OMAP_TIMER_SRC_SYS_CLK:
 408                 parent_name = "timer_sys_ck";
 409                 break;
 410         case OMAP_TIMER_SRC_32_KHZ:
 411                 parent_name = "timer_32k_ck";
 412                 break;
 413         case OMAP_TIMER_SRC_EXT_CLK:
 414                 parent_name = "timer_ext_ck";
 415                 break;
 416         default:
 417                 return -EINVAL;
 418         }
 419
 420         pdata = timer->pdev->dev.platform_data;
 421
 422         /*
 423          * FIXME: Used for OMAP1 devices only because they do not currently
 424          * use the clock framework to set the parent clock. To be removed
 425          * once OMAP1 migrated to using clock framework for dmtimers
 426          */
 427         if (timer->omap1 && pdata && pdata->set_timer_src)
 428                 return pdata->set_timer_src(timer->pdev, source);
 429
 430 #if defined(CONFIG_COMMON_CLK)
 431         /* Check if the clock has configurable parents */
 432         if (clk_hw_get_num_parents(__clk_get_hw(timer->fclk)) < 2)
 433                 return 0;
 434 #endif
 435
 436         parent = clk_get(&timer->pdev->dev, parent_name);
 437         if (IS_ERR(parent)) {
 438                 pr_err("%s: %s not found\n", __func__, parent_name);
 439                 return -EINVAL;
 440         }
 441
 442         ret = clk_set_parent(timer->fclk, parent);
 443         if (ret < 0)
 444                 pr_err("%s: failed to set %s as parent\n", __func__,
 445                         parent_name);
 446
 447         clk_put(parent);
 448
 449         return ret;
 450 }
 451
 452 static void omap_dm_timer_enable(struct omap_dm_timer *cookie)
 453 {
 454         struct dmtimer *timer = to_dmtimer(cookie);
 455         struct device *dev = &timer->pdev->dev;
 456         int rc;
 457
 458         rc = pm_runtime_resume_and_get(dev);
 459         if (rc)
 460                 dev_err(dev, "could not enable timer\n");
 461 }
 462
 463 static void omap_dm_timer_disable(struct omap_dm_timer *cookie)
 464 {
 465         struct dmtimer *timer = to_dmtimer(cookie);
 466         struct device *dev = &timer->pdev->dev;
 467
 468         pm_runtime_put_sync(dev);
 469 }
 470
 471 static int omap_dm_timer_prepare(struct dmtimer *timer)
 472 {
 473         struct device *dev = &timer->pdev->dev;
 474         int rc;
 475
 476         rc = pm_runtime_resume_and_get(dev);
 477         if (rc)
 478                 return rc;
 479
 480         if (timer->capability & OMAP_TIMER_NEEDS_RESET) {
 481                 rc = omap_dm_timer_reset(timer);
 482                 if (rc) {
 483                         pm_runtime_put_sync(dev);
 484                         return rc;
 485                 }
 486         }
 487
 488         __omap_dm_timer_enable_posted(timer);
 489         pm_runtime_put_sync(dev);
 490
 491         return 0;
 492 }
 493
 494 static inline u32 omap_dm_timer_reserved_systimer(int id)
 495 {
 496         return (omap_reserved_systimers & (1 << (id - 1))) ? 1 : 0;
 497 }
 498
 499 static struct dmtimer *_omap_dm_timer_request(int req_type, void *data)
 500 {
 501         struct dmtimer *timer = NULL, *t;
 502         struct device_node *np = NULL;
 503         unsigned long flags;
 504         u32 cap = 0;
 505         int id = 0;
 506
 507         switch (req_type) {
 508         case REQUEST_BY_ID:
 509                 id = *(int *)data;
 510                 break;
 511         case REQUEST_BY_CAP:
 512                 cap = *(u32 *)data;
 513                 break;
 514         case REQUEST_BY_NODE:
 515                 np = (struct device_node *)data;
 516                 break;
 517         default:
 518                 /* REQUEST_ANY */
 519                 break;
 520         }
 521
 522         spin_lock_irqsave(&dm_timer_lock, flags);
 523         list_for_each_entry(t, &omap_timer_list, node) {
 524                 if (t->reserved)
 525                         continue;
 526
 527                 switch (req_type) {
 528                 case REQUEST_BY_ID:
 529                         if (id == t->pdev->id) {
 530                                 timer = t;
 531                                 timer->reserved = 1;
 532                                 goto found;
 533                         }
 534                         break;
 535                 case REQUEST_BY_CAP:
 536                         if (cap == (t->capability & cap)) {
 537                                 /*
 538                                  * If timer is not NULL, we have already found
 539                                  * one timer. But it was not an exact match
 540                                  * because it had more capabilities than what
 541                                  * was required. Therefore, unreserve the last
 542                                  * timer found and see if this one is a better
 543                                  * match.
 544                                  */
 545                                 if (timer)
 546                                         timer->reserved = 0;
 547                                 timer = t;
 548                                 timer->reserved = 1;
 549
 550                                 /* Exit loop early if we find an exact match */
 551                                 if (t->capability == cap)
 552                                         goto found;
 553                         }
 554                         break;
 555                 case REQUEST_BY_NODE:
 556                         if (np == t->pdev->dev.of_node) {
 557                                 timer = t;
 558                                 timer->reserved = 1;
 559                                 goto found;
 560                         }
 561                         break;
 562                 default:
 563                         /* REQUEST_ANY */
 564                         timer = t;
 565                         timer->reserved = 1;
 566                         goto found;
 567                 }
 568         }
 569 found:
 570         spin_unlock_irqrestore(&dm_timer_lock, flags);
 571
 572         if (timer && omap_dm_timer_prepare(timer)) {
 573                 timer->reserved = 0;
 574                 timer = NULL;
 575         }
 576
 577         if (!timer)
 578                 pr_debug("%s: timer request failed!\n", __func__);
 579
 580         return timer;
 581 }
 582
 583 static struct omap_dm_timer *omap_dm_timer_request(void)
 584 {
 585         struct dmtimer *timer;
 586
 587         timer = _omap_dm_timer_request(REQUEST_ANY, NULL);
 588         if (!timer)
 589                 return NULL;
 590
 591         return &timer->cookie;
 592 }
 593
 594 static struct omap_dm_timer *omap_dm_timer_request_specific(int id)
 595 {
 596         struct dmtimer *timer;
 597
 598         /* Requesting timer by ID is not supported when device tree is used */
 599         if (of_have_populated_dt()) {
 600                 pr_warn("%s: Please use omap_dm_timer_request_by_node()\n",
 601                         __func__);
 602                 return NULL;
 603         }
 604
 605         timer = _omap_dm_timer_request(REQUEST_BY_ID, &id);
 606         if (!timer)
 607                 return NULL;
 608
 609         return &timer->cookie;
 610 }
 611
 612 /**
 613  * omap_dm_timer_request_by_node - Request a timer by device-tree node
 614  * @np:         Pointer to device-tree timer node
 615  *
 616  * Request a timer based upon a device node pointer. Returns pointer to
 617  * timer handle on success and a NULL pointer on failure.
 618  */
 619 static struct omap_dm_timer *omap_dm_timer_request_by_node(struct device_node *np)
 620 {
 621         struct dmtimer *timer;
 622
 623         if (!np)
 624                 return NULL;
 625
 626         timer = _omap_dm_timer_request(REQUEST_BY_NODE, np);
 627         if (!timer)
 628                 return NULL;
 629
 630         return &timer->cookie;
 631 }
 632
 633 static int omap_dm_timer_free(struct omap_dm_timer *cookie)
 634 {
 635         struct dmtimer *timer;
 636
 637         timer = to_dmtimer(cookie);
 638         if (unlikely(!timer))
 639                 return -EINVAL;
 640
 641         WARN_ON(!timer->reserved);
 642         timer->reserved = 0;
 643         return 0;
 644 }
 645
 646 int omap_dm_timer_get_irq(struct omap_dm_timer *cookie)
 647 {
 648         struct dmtimer *timer = to_dmtimer(cookie);
 649         if (timer)
 650                 return timer->irq;
 651         return -EINVAL;
 652 }
 653
 654 #if defined(CONFIG_ARCH_OMAP1)
 655 #include <linux/soc/ti/omap1-io.h>
 656
 657 static struct clk *omap_dm_timer_get_fclk(struct omap_dm_timer *cookie)
 658 {
 659         return NULL;
 660 }
 661
 662 /**
 663  * omap_dm_timer_modify_idlect_mask - Check if any running timers use ARMXOR
 664  * @inputmask: current value of idlect mask
 665  */
 666 __u32 omap_dm_timer_modify_idlect_mask(__u32 inputmask)
 667 {
 668         int i = 0;
 669         struct dmtimer *timer = NULL;
 670         unsigned long flags;
 671
 672         /* If ARMXOR cannot be idled this function call is unnecessary */
 673         if (!(inputmask & (1 << 1)))
 674                 return inputmask;
 675
 676         /* If any active timer is using ARMXOR return modified mask */
 677         spin_lock_irqsave(&dm_timer_lock, flags);
 678         list_for_each_entry(timer, &omap_timer_list, node) {
 679                 u32 l;
 680
 681                 l = dmtimer_read(timer, OMAP_TIMER_CTRL_REG);
 682                 if (l & OMAP_TIMER_CTRL_ST) {
 683                         if (((omap_readl(MOD_CONF_CTRL_1) >> (i * 2)) & 0x03) == 0)
 684                                 inputmask &= ~(1 << 1);
 685                         else
 686                                 inputmask &= ~(1 << 2);
 687                 }
 688                 i++;
 689         }
 690         spin_unlock_irqrestore(&dm_timer_lock, flags);
 691
 692         return inputmask;
 693 }
 694
 695 #else
 696
 697 static struct clk *omap_dm_timer_get_fclk(struct omap_dm_timer *cookie)
 698 {
 699         struct dmtimer *timer = to_dmtimer(cookie);
 700
 701         if (timer && !IS_ERR(timer->fclk))
 702                 return timer->fclk;
 703         return NULL;
 704 }
 705
 706 __u32 omap_dm_timer_modify_idlect_mask(__u32 inputmask)
 707 {
 708         BUG();
 709
 710         return 0;
 711 }
 712
 713 #endif
 714
 715 static int omap_dm_timer_start(struct omap_dm_timer *cookie)
 716 {
 717         struct dmtimer *timer;
 718         struct device *dev;
 719         int rc;
 720         u32 l;
 721
 722         timer = to_dmtimer(cookie);
 723         if (unlikely(!timer))
 724                 return -EINVAL;
 725
 726         dev = &timer->pdev->dev;
 727
 728         rc = pm_runtime_resume_and_get(dev);
 729         if (rc)
 730                 return rc;
 731
 732         l = dmtimer_read(timer, OMAP_TIMER_CTRL_REG);
 733         if (!(l & OMAP_TIMER_CTRL_ST)) {
 734                 l |= OMAP_TIMER_CTRL_ST;
 735                 dmtimer_write(timer, OMAP_TIMER_CTRL_REG, l);
 736         }
 737
 738         return 0;
 739 }
 740
 741 static int omap_dm_timer_stop(struct omap_dm_timer *cookie)
 742 {
 743         struct dmtimer *timer;
 744         struct device *dev;
 745         unsigned long rate = 0;
 746
 747         timer = to_dmtimer(cookie);
 748         if (unlikely(!timer))
 749                 return -EINVAL;
 750
 751         dev = &timer->pdev->dev;
 752
 753         if (!timer->omap1)
 754                 rate = clk_get_rate(timer->fclk);
 755
 756         __omap_dm_timer_stop(timer, rate);
 757
 758         pm_runtime_put_sync(dev);
 759
 760         return 0;
 761 }
 762
 763 static int omap_dm_timer_set_load(struct omap_dm_timer *cookie,
 764                                   unsigned int load)
 765 {
 766         struct dmtimer *timer;
 767         struct device *dev;
 768         int rc;
 769
 770         timer = to_dmtimer(cookie);
 771         if (unlikely(!timer))
 772                 return -EINVAL;
 773
 774         dev = &timer->pdev->dev;
 775         rc = pm_runtime_resume_and_get(dev);
 776         if (rc)
 777                 return rc;
 778
 779         dmtimer_write(timer, OMAP_TIMER_LOAD_REG, load);
 780
 781         pm_runtime_put_sync(dev);
 782
 783         return 0;
 784 }
 785
 786 static int omap_dm_timer_set_match(struct omap_dm_timer *cookie, int enable,
 787                                    unsigned int match)
 788 {
 789         struct dmtimer *timer;
 790         struct device *dev;
 791         int rc;
 792         u32 l;
 793
 794         timer = to_dmtimer(cookie);
 795         if (unlikely(!timer))
 796                 return -EINVAL;
 797
 798         dev = &timer->pdev->dev;
 799         rc = pm_runtime_resume_and_get(dev);
 800         if (rc)
 801                 return rc;
 802
 803         l = dmtimer_read(timer, OMAP_TIMER_CTRL_REG);
 804         if (enable)
 805                 l |= OMAP_TIMER_CTRL_CE;
 806         else
 807                 l &= ~OMAP_TIMER_CTRL_CE;
 808         dmtimer_write(timer, OMAP_TIMER_MATCH_REG, match);
 809         dmtimer_write(timer, OMAP_TIMER_CTRL_REG, l);
 810
 811         pm_runtime_put_sync(dev);
 812
 813         return 0;
 814 }
 815
 816 static int omap_dm_timer_set_pwm(struct omap_dm_timer *cookie, int def_on,
 817                                  int toggle, int trigger, int autoreload)
 818 {
 819         struct dmtimer *timer;
 820         struct device *dev;
 821         int rc;
 822         u32 l;
 823
 824         timer = to_dmtimer(cookie);
 825         if (unlikely(!timer))
 826                 return -EINVAL;
 827
 828         dev = &timer->pdev->dev;
 829         rc = pm_runtime_resume_and_get(dev);
 830         if (rc)
 831                 return rc;
 832
 833         l = dmtimer_read(timer, OMAP_TIMER_CTRL_REG);
 834         l &= ~(OMAP_TIMER_CTRL_GPOCFG | OMAP_TIMER_CTRL_SCPWM |
 835                OMAP_TIMER_CTRL_PT | (0x03 << 10) | OMAP_TIMER_CTRL_AR);
 836         if (def_on)
 837                 l |= OMAP_TIMER_CTRL_SCPWM;
 838         if (toggle)
 839                 l |= OMAP_TIMER_CTRL_PT;
 840         l |= trigger << 10;
 841         if (autoreload)
 842                 l |= OMAP_TIMER_CTRL_AR;
 843         dmtimer_write(timer, OMAP_TIMER_CTRL_REG, l);
 844
 845         pm_runtime_put_sync(dev);
 846
 847         return 0;
 848 }
 849
 850 static int omap_dm_timer_get_pwm_status(struct omap_dm_timer *cookie)
 851 {
 852         struct dmtimer *timer;
 853         struct device *dev;
 854         int rc;
 855         u32 l;
 856
 857         timer = to_dmtimer(cookie);
 858         if (unlikely(!timer))
 859                 return -EINVAL;
 860
 861         dev = &timer->pdev->dev;
 862         rc = pm_runtime_resume_and_get(dev);
 863         if (rc)
 864                 return rc;
 865
 866         l = dmtimer_read(timer, OMAP_TIMER_CTRL_REG);
 867
 868         pm_runtime_put_sync(dev);
 869
 870         return l;
 871 }
 872
 873 static int omap_dm_timer_set_prescaler(struct omap_dm_timer *cookie,
 874                                        int prescaler)
 875 {
 876         struct dmtimer *timer;
 877         struct device *dev;
 878         int rc;
 879         u32 l;
 880
 881         timer = to_dmtimer(cookie);
 882         if (unlikely(!timer) || prescaler < -1 || prescaler > 7)
 883                 return -EINVAL;
 884
 885         dev = &timer->pdev->dev;
 886         rc = pm_runtime_resume_and_get(dev);
 887         if (rc)
 888                 return rc;
 889
 890         l = dmtimer_read(timer, OMAP_TIMER_CTRL_REG);
 891         l &= ~(OMAP_TIMER_CTRL_PRE | (0x07 << 2));
 892         if (prescaler >= 0) {
 893                 l |= OMAP_TIMER_CTRL_PRE;
 894                 l |= prescaler << 2;
 895         }
 896         dmtimer_write(timer, OMAP_TIMER_CTRL_REG, l);
 897
 898         pm_runtime_put_sync(dev);
 899
 900         return 0;
 901 }
 902
 903 static int omap_dm_timer_set_int_enable(struct omap_dm_timer *cookie,
 904                                         unsigned int value)
 905 {
 906         struct dmtimer *timer;
 907         struct device *dev;
 908         int rc;
 909
 910         timer = to_dmtimer(cookie);
 911         if (unlikely(!timer))
 912                 return -EINVAL;
 913
 914         dev = &timer->pdev->dev;
 915         rc = pm_runtime_resume_and_get(dev);
 916         if (rc)
 917                 return rc;
 918
 919         __omap_dm_timer_int_enable(timer, value);
 920
 921         pm_runtime_put_sync(dev);
 922
 923         return 0;
 924 }
 925
 926 /**
 927  * omap_dm_timer_set_int_disable - disable timer interrupts
 928  * @timer:      pointer to timer handle
 929  * @mask:       bit mask of interrupts to be disabled
 930  *
 931  * Disables the specified timer interrupts for a timer.
 932  */
 933 static int omap_dm_timer_set_int_disable(struct omap_dm_timer *cookie, u32 mask)
 934 {
 935         struct dmtimer *timer;
 936         struct device *dev;
 937         u32 l = mask;
 938         int rc;
 939
 940         timer = to_dmtimer(cookie);
 941         if (unlikely(!timer))
 942                 return -EINVAL;
 943
 944         dev = &timer->pdev->dev;
 945         rc = pm_runtime_resume_and_get(dev);
 946         if (rc)
 947                 return rc;
 948
 949         if (timer->revision == 1)
 950                 l = dmtimer_read(timer, timer->irq_ena) & ~mask;
 951
 952         dmtimer_write(timer, timer->irq_dis, l);
 953         l = dmtimer_read(timer, OMAP_TIMER_WAKEUP_EN_REG) & ~mask;
 954         dmtimer_write(timer, OMAP_TIMER_WAKEUP_EN_REG, l);
 955
 956         pm_runtime_put_sync(dev);
 957
 958         return 0;
 959 }
 960
 961 static unsigned int omap_dm_timer_read_status(struct omap_dm_timer *cookie)
 962 {
 963         struct dmtimer *timer;
 964         unsigned int l;
 965
 966         timer = to_dmtimer(cookie);
 967         if (unlikely(!timer || !atomic_read(&timer->enabled))) {
 968                 pr_err("%s: timer not available or enabled.\n", __func__);
 969                 return 0;
 970         }
 971
 972         l = dmtimer_read(timer, timer->irq_stat);
 973
 974         return l;
 975 }
 976
 977 static int omap_dm_timer_write_status(struct omap_dm_timer *cookie, unsigned int value)
 978 {
 979         struct dmtimer *timer;
 980
 981         timer = to_dmtimer(cookie);
 982         if (unlikely(!timer || !atomic_read(&timer->enabled)))
 983                 return -EINVAL;
 984
 985         __omap_dm_timer_write_status(timer, value);
 986
 987         return 0;
 988 }
 989
 990 static unsigned int omap_dm_timer_read_counter(struct omap_dm_timer *cookie)
 991 {
 992         struct dmtimer *timer;
 993
 994         timer = to_dmtimer(cookie);
 995         if (unlikely(!timer || !atomic_read(&timer->enabled))) {
 996                 pr_err("%s: timer not iavailable or enabled.\n", __func__);
 997                 return 0;
 998         }
 999
1000         return __omap_dm_timer_read_counter(timer);
1001 }
1002
1003 static int omap_dm_timer_write_counter(struct omap_dm_timer *cookie, unsigned int value)
1004 {
1005         struct dmtimer *timer;
1006
1007         timer = to_dmtimer(cookie);
1008         if (unlikely(!timer || !atomic_read(&timer->enabled))) {
1009                 pr_err("%s: timer not available or enabled.\n", __func__);
1010                 return -EINVAL;
1011         }
1012
1013         dmtimer_write(timer, OMAP_TIMER_COUNTER_REG, value);
1014
1015         /* Save the context */
1016         timer->context.tcrr = value;
1017         return 0;
1018 }
1019
1020 static int __maybe_unused omap_dm_timer_runtime_suspend(struct device *dev)
1021 {
1022         struct dmtimer *timer = dev_get_drvdata(dev);
1023
1024         atomic_set(&timer->enabled, 0);
1025
1026         if (timer->capability & OMAP_TIMER_ALWON || !timer->func_base)
1027                 return 0;
1028
1029         omap_timer_save_context(timer);
1030
1031         return 0;
1032 }
1033
1034 static int __maybe_unused omap_dm_timer_runtime_resume(struct device *dev)
1035 {
1036         struct dmtimer *timer = dev_get_drvdata(dev);
1037
1038         if (!(timer->capability & OMAP_TIMER_ALWON) && timer->func_base)
1039                 omap_timer_restore_context(timer);
1040
1041         atomic_set(&timer->enabled, 1);
1042
1043         return 0;
1044 }
1045
1046 static const struct dev_pm_ops omap_dm_timer_pm_ops = {
1047         SET_RUNTIME_PM_OPS(omap_dm_timer_runtime_suspend,
1048                            omap_dm_timer_runtime_resume, NULL)
1049 };
1050
1051 static const struct of_device_id omap_timer_match[];
1052
1053 /**
1054  * omap_dm_timer_probe - probe function called for every registered device
1055  * @pdev:       pointer to current timer platform device
1056  *
1057  * Called by driver framework at the end of device registration for all
1058  * timer devices.
1059  */
1060 static int omap_dm_timer_probe(struct platform_device *pdev)
1061 {
1062         unsigned long flags;
1063         struct dmtimer *timer;
1064         struct device *dev = &pdev->dev;
1065         const struct dmtimer_platform_data *pdata;
1066         int ret;
1067
1068         pdata = of_device_get_match_data(dev);
1069         if (!pdata)
1070                 pdata = dev_get_platdata(dev);
1071         else
1072                 dev->platform_data = (void *)pdata;
1073
1074         if (!pdata) {
1075                 dev_err(dev, "%s: no platform data.\n", __func__);
1076                 return -ENODEV;
1077         }
1078
1079         timer = devm_kzalloc(dev, sizeof(*timer), GFP_KERNEL);
1080         if (!timer)
1081                 return  -ENOMEM;
1082
1083         timer->irq = platform_get_irq(pdev, 0);
1084         if (timer->irq < 0)
1085                 return timer->irq;
1086
1087         timer->io_base = devm_platform_ioremap_resource(pdev, 0);
1088         if (IS_ERR(timer->io_base))
1089                 return PTR_ERR(timer->io_base);
1090
1091         platform_set_drvdata(pdev, timer);
1092
1093         if (dev->of_node) {
1094                 if (of_find_property(dev->of_node, "ti,timer-alwon", NULL))
1095                         timer->capability |= OMAP_TIMER_ALWON;
1096                 if (of_find_property(dev->of_node, "ti,timer-dsp", NULL))
1097                         timer->capability |= OMAP_TIMER_HAS_DSP_IRQ;
1098                 if (of_find_property(dev->of_node, "ti,timer-pwm", NULL))
1099                         timer->capability |= OMAP_TIMER_HAS_PWM;
1100                 if (of_find_property(dev->of_node, "ti,timer-secure", NULL))
1101                         timer->capability |= OMAP_TIMER_SECURE;
1102         } else {
1103                 timer->id = pdev->id;
1104                 timer->capability = pdata->timer_capability;
1105                 timer->reserved = omap_dm_timer_reserved_systimer(timer->id);
1106         }
1107
1108         timer->omap1 = timer->capability & OMAP_TIMER_NEEDS_RESET;
1109
1110         /* OMAP1 devices do not yet use the clock framework for dmtimers */
1111         if (!timer->omap1) {
1112                 timer->fclk = devm_clk_get(dev, "fck");
1113                 if (IS_ERR(timer->fclk))
1114                         return PTR_ERR(timer->fclk);
1115         } else {
1116                 timer->fclk = ERR_PTR(-ENODEV);
1117         }
1118
1119         if (!(timer->capability & OMAP_TIMER_ALWON)) {
1120                 timer->nb.notifier_call = omap_timer_context_notifier;
1121                 cpu_pm_register_notifier(&timer->nb);
1122         }
1123
1124         timer->errata = pdata->timer_errata;
1125
1126         timer->pdev = pdev;
1127
1128         pm_runtime_enable(dev);
1129
1130         if (!timer->reserved) {
1131                 ret = pm_runtime_resume_and_get(dev);
1132                 if (ret) {
1133                         dev_err(dev, "%s: pm_runtime_get_sync failed!\n",
1134                                 __func__);
1135                         goto err_disable;
1136                 }
1137                 __omap_dm_timer_init_regs(timer);
1138                 pm_runtime_put(dev);
1139         }
1140
1141         /* add the timer element to the list */
1142         spin_lock_irqsave(&dm_timer_lock, flags);
1143         list_add_tail(&timer->node, &omap_timer_list);
1144         spin_unlock_irqrestore(&dm_timer_lock, flags);
1145
1146         dev_dbg(dev, "Device Probed.\n");
1147
1148         return 0;
1149
1150 err_disable:
1151         pm_runtime_disable(dev);
1152         return ret;
1153 }
1154
1155 /**
1156  * omap_dm_timer_remove - cleanup a registered timer device
1157  * @pdev:       pointer to current timer platform device
1158  *
1159  * Called by driver framework whenever a timer device is unregistered.
1160  * In addition to freeing platform resources it also deletes the timer
1161  * entry from the local list.
1162  */
1163 static int omap_dm_timer_remove(struct platform_device *pdev)
1164 {
1165         struct dmtimer *timer;
1166         unsigned long flags;
1167         int ret = -EINVAL;
1168
1169         spin_lock_irqsave(&dm_timer_lock, flags);
1170         list_for_each_entry(timer, &omap_timer_list, node)
1171                 if (!strcmp(dev_name(&timer->pdev->dev),
1172                             dev_name(&pdev->dev))) {
1173                         if (!(timer->capability & OMAP_TIMER_ALWON))
1174                                 cpu_pm_unregister_notifier(&timer->nb);
1175                         list_del(&timer->node);
1176                         ret = 0;
1177                         break;
1178                 }
1179         spin_unlock_irqrestore(&dm_timer_lock, flags);
1180
1181         pm_runtime_disable(&pdev->dev);
1182
1183         return ret;
1184 }
1185
1186 static const struct omap_dm_timer_ops dmtimer_ops = {
1187         .request_by_node = omap_dm_timer_request_by_node,
1188         .request_specific = omap_dm_timer_request_specific,
1189         .request = omap_dm_timer_request,
1190         .set_source = omap_dm_timer_set_source,
1191         .get_irq = omap_dm_timer_get_irq,
1192         .set_int_enable = omap_dm_timer_set_int_enable,
1193         .set_int_disable = omap_dm_timer_set_int_disable,
1194         .free = omap_dm_timer_free,
1195         .enable = omap_dm_timer_enable,
1196         .disable = omap_dm_timer_disable,
1197         .get_fclk = omap_dm_timer_get_fclk,
1198         .start = omap_dm_timer_start,
1199         .stop = omap_dm_timer_stop,
1200         .set_load = omap_dm_timer_set_load,
1201         .set_match = omap_dm_timer_set_match,
1202         .set_pwm = omap_dm_timer_set_pwm,
1203         .get_pwm_status = omap_dm_timer_get_pwm_status,
1204         .set_prescaler = omap_dm_timer_set_prescaler,
1205         .read_counter = omap_dm_timer_read_counter,
1206         .write_counter = omap_dm_timer_write_counter,
1207         .read_status = omap_dm_timer_read_status,
1208         .write_status = omap_dm_timer_write_status,
1209 };
1210
1211 static const struct dmtimer_platform_data omap3plus_pdata = {
1212         .timer_errata = OMAP_TIMER_ERRATA_I103_I767,
1213         .timer_ops = &dmtimer_ops,
1214 };
1215
1216 static const struct dmtimer_platform_data am6_pdata = {
1217         .timer_ops = &dmtimer_ops,
1218 };
1219
1220 static const struct of_device_id omap_timer_match[] = {
1221         {
1222                 .compatible = "ti,omap2420-timer",
1223         },
1224         {
1225                 .compatible = "ti,omap3430-timer",
1226                 .data = &omap3plus_pdata,
1227         },
1228         {
1229                 .compatible = "ti,omap4430-timer",
1230                 .data = &omap3plus_pdata,
1231         },
1232         {
1233                 .compatible = "ti,omap5430-timer",
1234                 .data = &omap3plus_pdata,
1235         },
1236         {
1237                 .compatible = "ti,am335x-timer",
1238                 .data = &omap3plus_pdata,
1239         },
1240         {
1241                 .compatible = "ti,am335x-timer-1ms",
1242                 .data = &omap3plus_pdata,
1243         },
1244         {
1245                 .compatible = "ti,dm816-timer",
1246                 .data = &omap3plus_pdata,
1247         },
1248         {
1249                 .compatible = "ti,am654-timer",
1250                 .data = &am6_pdata,
1251         },
1252         {},
1253 };
1254 MODULE_DEVICE_TABLE(of, omap_timer_match);
1255
1256 static struct platform_driver omap_dm_timer_driver = {
1257         .probe  = omap_dm_timer_probe,
1258         .remove = omap_dm_timer_remove,
1259         .driver = {
1260                 .name   = "omap_timer",
1261                 .of_match_table = of_match_ptr(omap_timer_match),
1262                 .pm = &omap_dm_timer_pm_ops,
1263         },
1264 };
1265
1266 module_platform_driver(omap_dm_timer_driver);
1267
1268 MODULE_DESCRIPTION("OMAP Dual-Mode Timer Driver");
1269 MODULE_LICENSE("GPL");
1270 MODULE_AUTHOR("Texas Instruments Inc");