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 struct device *dev; 637 int rc; 638 639 timer = to_dmtimer(cookie); 640 if (unlikely(!timer)) 641 return -EINVAL; 642 643 WARN_ON(!timer->reserved); 644 timer->reserved = 0; 645 646 dev = &timer->pdev->dev; 647 rc = pm_runtime_resume_and_get(dev); 648 if (rc) 649 return rc; 650 651 /* Clear timer configuration */ 652 dmtimer_write(timer, OMAP_TIMER_CTRL_REG, 0); 653 654 pm_runtime_put_sync(dev); 655 656 return 0; 657 } 658 659 static int omap_dm_timer_get_irq(struct omap_dm_timer *cookie) 660 { 661 struct dmtimer *timer = to_dmtimer(cookie); 662 if (timer) 663 return timer->irq; 664 return -EINVAL; 665 } 666 667 #if defined(CONFIG_ARCH_OMAP1) 668 #include <linux/soc/ti/omap1-io.h> 669 670 static struct clk *omap_dm_timer_get_fclk(struct omap_dm_timer *cookie) 671 { 672 return NULL; 673 } 674 675 /** 676 * omap_dm_timer_modify_idlect_mask - Check if any running timers use ARMXOR 677 * @inputmask: current value of idlect mask 678 */ 679 __u32 omap_dm_timer_modify_idlect_mask(__u32 inputmask) 680 { 681 int i = 0; 682 struct dmtimer *timer = NULL; 683 unsigned long flags; 684 685 /* If ARMXOR cannot be idled this function call is unnecessary */ 686 if (!(inputmask & (1 << 1))) 687 return inputmask; 688 689 /* If any active timer is using ARMXOR return modified mask */ 690 spin_lock_irqsave(&dm_timer_lock, flags); 691 list_for_each_entry(timer, &omap_timer_list, node) { 692 u32 l; 693 694 l = dmtimer_read(timer, OMAP_TIMER_CTRL_REG); 695 if (l & OMAP_TIMER_CTRL_ST) { 696 if (((omap_readl(MOD_CONF_CTRL_1) >> (i * 2)) & 0x03) == 0) 697 inputmask &= ~(1 << 1); 698 else 699 inputmask &= ~(1 << 2); 700 } 701 i++; 702 } 703 spin_unlock_irqrestore(&dm_timer_lock, flags); 704 705 return inputmask; 706 } 707 708 #else 709 710 static struct clk *omap_dm_timer_get_fclk(struct omap_dm_timer *cookie) 711 { 712 struct dmtimer *timer = to_dmtimer(cookie); 713 714 if (timer && !IS_ERR(timer->fclk)) 715 return timer->fclk; 716 return NULL; 717 } 718 719 __u32 omap_dm_timer_modify_idlect_mask(__u32 inputmask) 720 { 721 BUG(); 722 723 return 0; 724 } 725 726 #endif 727 728 static int omap_dm_timer_start(struct omap_dm_timer *cookie) 729 { 730 struct dmtimer *timer; 731 struct device *dev; 732 int rc; 733 u32 l; 734 735 timer = to_dmtimer(cookie); 736 if (unlikely(!timer)) 737 return -EINVAL; 738 739 dev = &timer->pdev->dev; 740 741 rc = pm_runtime_resume_and_get(dev); 742 if (rc) 743 return rc; 744 745 l = dmtimer_read(timer, OMAP_TIMER_CTRL_REG); 746 if (!(l & OMAP_TIMER_CTRL_ST)) { 747 l |= OMAP_TIMER_CTRL_ST; 748 dmtimer_write(timer, OMAP_TIMER_CTRL_REG, l); 749 } 750 751 return 0; 752 } 753 754 static int omap_dm_timer_stop(struct omap_dm_timer *cookie) 755 { 756 struct dmtimer *timer; 757 struct device *dev; 758 unsigned long rate = 0; 759 760 timer = to_dmtimer(cookie); 761 if (unlikely(!timer)) 762 return -EINVAL; 763 764 dev = &timer->pdev->dev; 765 766 if (!timer->omap1) 767 rate = clk_get_rate(timer->fclk); 768 769 __omap_dm_timer_stop(timer, rate); 770 771 pm_runtime_put_sync(dev); 772 773 return 0; 774 } 775 776 static int omap_dm_timer_set_load(struct omap_dm_timer *cookie, 777 unsigned int load) 778 { 779 struct dmtimer *timer; 780 struct device *dev; 781 int rc; 782 783 timer = to_dmtimer(cookie); 784 if (unlikely(!timer)) 785 return -EINVAL; 786 787 dev = &timer->pdev->dev; 788 rc = pm_runtime_resume_and_get(dev); 789 if (rc) 790 return rc; 791 792 dmtimer_write(timer, OMAP_TIMER_LOAD_REG, load); 793 794 pm_runtime_put_sync(dev); 795 796 return 0; 797 } 798 799 static int omap_dm_timer_set_match(struct omap_dm_timer *cookie, int enable, 800 unsigned int match) 801 { 802 struct dmtimer *timer; 803 struct device *dev; 804 int rc; 805 u32 l; 806 807 timer = to_dmtimer(cookie); 808 if (unlikely(!timer)) 809 return -EINVAL; 810 811 dev = &timer->pdev->dev; 812 rc = pm_runtime_resume_and_get(dev); 813 if (rc) 814 return rc; 815 816 l = dmtimer_read(timer, OMAP_TIMER_CTRL_REG); 817 if (enable) 818 l |= OMAP_TIMER_CTRL_CE; 819 else 820 l &= ~OMAP_TIMER_CTRL_CE; 821 dmtimer_write(timer, OMAP_TIMER_MATCH_REG, match); 822 dmtimer_write(timer, OMAP_TIMER_CTRL_REG, l); 823 824 pm_runtime_put_sync(dev); 825 826 return 0; 827 } 828 829 static int omap_dm_timer_set_pwm(struct omap_dm_timer *cookie, int def_on, 830 int toggle, int trigger, int autoreload) 831 { 832 struct dmtimer *timer; 833 struct device *dev; 834 int rc; 835 u32 l; 836 837 timer = to_dmtimer(cookie); 838 if (unlikely(!timer)) 839 return -EINVAL; 840 841 dev = &timer->pdev->dev; 842 rc = pm_runtime_resume_and_get(dev); 843 if (rc) 844 return rc; 845 846 l = dmtimer_read(timer, OMAP_TIMER_CTRL_REG); 847 l &= ~(OMAP_TIMER_CTRL_GPOCFG | OMAP_TIMER_CTRL_SCPWM | 848 OMAP_TIMER_CTRL_PT | (0x03 << 10) | OMAP_TIMER_CTRL_AR); 849 if (def_on) 850 l |= OMAP_TIMER_CTRL_SCPWM; 851 if (toggle) 852 l |= OMAP_TIMER_CTRL_PT; 853 l |= trigger << 10; 854 if (autoreload) 855 l |= OMAP_TIMER_CTRL_AR; 856 dmtimer_write(timer, OMAP_TIMER_CTRL_REG, l); 857 858 pm_runtime_put_sync(dev); 859 860 return 0; 861 } 862 863 static int omap_dm_timer_get_pwm_status(struct omap_dm_timer *cookie) 864 { 865 struct dmtimer *timer; 866 struct device *dev; 867 int rc; 868 u32 l; 869 870 timer = to_dmtimer(cookie); 871 if (unlikely(!timer)) 872 return -EINVAL; 873 874 dev = &timer->pdev->dev; 875 rc = pm_runtime_resume_and_get(dev); 876 if (rc) 877 return rc; 878 879 l = dmtimer_read(timer, OMAP_TIMER_CTRL_REG); 880 881 pm_runtime_put_sync(dev); 882 883 return l; 884 } 885 886 static int omap_dm_timer_set_prescaler(struct omap_dm_timer *cookie, 887 int prescaler) 888 { 889 struct dmtimer *timer; 890 struct device *dev; 891 int rc; 892 u32 l; 893 894 timer = to_dmtimer(cookie); 895 if (unlikely(!timer) || prescaler < -1 || prescaler > 7) 896 return -EINVAL; 897 898 dev = &timer->pdev->dev; 899 rc = pm_runtime_resume_and_get(dev); 900 if (rc) 901 return rc; 902 903 l = dmtimer_read(timer, OMAP_TIMER_CTRL_REG); 904 l &= ~(OMAP_TIMER_CTRL_PRE | (0x07 << 2)); 905 if (prescaler >= 0) { 906 l |= OMAP_TIMER_CTRL_PRE; 907 l |= prescaler << 2; 908 } 909 dmtimer_write(timer, OMAP_TIMER_CTRL_REG, l); 910 911 pm_runtime_put_sync(dev); 912 913 return 0; 914 } 915 916 static int omap_dm_timer_set_int_enable(struct omap_dm_timer *cookie, 917 unsigned int value) 918 { 919 struct dmtimer *timer; 920 struct device *dev; 921 int rc; 922 923 timer = to_dmtimer(cookie); 924 if (unlikely(!timer)) 925 return -EINVAL; 926 927 dev = &timer->pdev->dev; 928 rc = pm_runtime_resume_and_get(dev); 929 if (rc) 930 return rc; 931 932 __omap_dm_timer_int_enable(timer, value); 933 934 pm_runtime_put_sync(dev); 935 936 return 0; 937 } 938 939 /** 940 * omap_dm_timer_set_int_disable - disable timer interrupts 941 * @timer: pointer to timer handle 942 * @mask: bit mask of interrupts to be disabled 943 * 944 * Disables the specified timer interrupts for a timer. 945 */ 946 static int omap_dm_timer_set_int_disable(struct omap_dm_timer *cookie, u32 mask) 947 { 948 struct dmtimer *timer; 949 struct device *dev; 950 u32 l = mask; 951 int rc; 952 953 timer = to_dmtimer(cookie); 954 if (unlikely(!timer)) 955 return -EINVAL; 956 957 dev = &timer->pdev->dev; 958 rc = pm_runtime_resume_and_get(dev); 959 if (rc) 960 return rc; 961 962 if (timer->revision == 1) 963 l = dmtimer_read(timer, timer->irq_ena) & ~mask; 964 965 dmtimer_write(timer, timer->irq_dis, l); 966 l = dmtimer_read(timer, OMAP_TIMER_WAKEUP_EN_REG) & ~mask; 967 dmtimer_write(timer, OMAP_TIMER_WAKEUP_EN_REG, l); 968 969 pm_runtime_put_sync(dev); 970 971 return 0; 972 } 973 974 static unsigned int omap_dm_timer_read_status(struct omap_dm_timer *cookie) 975 { 976 struct dmtimer *timer; 977 unsigned int l; 978 979 timer = to_dmtimer(cookie); 980 if (unlikely(!timer || !atomic_read(&timer->enabled))) { 981 pr_err("%s: timer not available or enabled.\n", __func__); 982 return 0; 983 } 984 985 l = dmtimer_read(timer, timer->irq_stat); 986 987 return l; 988 } 989 990 static int omap_dm_timer_write_status(struct omap_dm_timer *cookie, unsigned int value) 991 { 992 struct dmtimer *timer; 993 994 timer = to_dmtimer(cookie); 995 if (unlikely(!timer || !atomic_read(&timer->enabled))) 996 return -EINVAL; 997 998 __omap_dm_timer_write_status(timer, value); 999 1000 return 0; 1001 } 1002 1003 static unsigned int omap_dm_timer_read_counter(struct omap_dm_timer *cookie) 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 iavailable or enabled.\n", __func__); 1010 return 0; 1011 } 1012 1013 return __omap_dm_timer_read_counter(timer); 1014 } 1015 1016 static int omap_dm_timer_write_counter(struct omap_dm_timer *cookie, unsigned int value) 1017 { 1018 struct dmtimer *timer; 1019 1020 timer = to_dmtimer(cookie); 1021 if (unlikely(!timer || !atomic_read(&timer->enabled))) { 1022 pr_err("%s: timer not available or enabled.\n", __func__); 1023 return -EINVAL; 1024 } 1025 1026 dmtimer_write(timer, OMAP_TIMER_COUNTER_REG, value); 1027 1028 /* Save the context */ 1029 timer->context.tcrr = value; 1030 return 0; 1031 } 1032 1033 static int __maybe_unused omap_dm_timer_runtime_suspend(struct device *dev) 1034 { 1035 struct dmtimer *timer = dev_get_drvdata(dev); 1036 1037 atomic_set(&timer->enabled, 0); 1038 1039 if (timer->capability & OMAP_TIMER_ALWON || !timer->func_base) 1040 return 0; 1041 1042 omap_timer_save_context(timer); 1043 1044 return 0; 1045 } 1046 1047 static int __maybe_unused omap_dm_timer_runtime_resume(struct device *dev) 1048 { 1049 struct dmtimer *timer = dev_get_drvdata(dev); 1050 1051 if (!(timer->capability & OMAP_TIMER_ALWON) && timer->func_base) 1052 omap_timer_restore_context(timer); 1053 1054 atomic_set(&timer->enabled, 1); 1055 1056 return 0; 1057 } 1058 1059 static const struct dev_pm_ops omap_dm_timer_pm_ops = { 1060 SET_RUNTIME_PM_OPS(omap_dm_timer_runtime_suspend, 1061 omap_dm_timer_runtime_resume, NULL) 1062 }; 1063 1064 static const struct of_device_id omap_timer_match[]; 1065 1066 /** 1067 * omap_dm_timer_probe - probe function called for every registered device 1068 * @pdev: pointer to current timer platform device 1069 * 1070 * Called by driver framework at the end of device registration for all 1071 * timer devices. 1072 */ 1073 static int omap_dm_timer_probe(struct platform_device *pdev) 1074 { 1075 unsigned long flags; 1076 struct dmtimer *timer; 1077 struct device *dev = &pdev->dev; 1078 const struct dmtimer_platform_data *pdata; 1079 int ret; 1080 1081 pdata = of_device_get_match_data(dev); 1082 if (!pdata) 1083 pdata = dev_get_platdata(dev); 1084 else 1085 dev->platform_data = (void *)pdata; 1086 1087 if (!pdata) { 1088 dev_err(dev, "%s: no platform data.\n", __func__); 1089 return -ENODEV; 1090 } 1091 1092 timer = devm_kzalloc(dev, sizeof(*timer), GFP_KERNEL); 1093 if (!timer) 1094 return -ENOMEM; 1095 1096 timer->irq = platform_get_irq(pdev, 0); 1097 if (timer->irq < 0) 1098 return timer->irq; 1099 1100 timer->io_base = devm_platform_ioremap_resource(pdev, 0); 1101 if (IS_ERR(timer->io_base)) 1102 return PTR_ERR(timer->io_base); 1103 1104 platform_set_drvdata(pdev, timer); 1105 1106 if (dev->of_node) { 1107 if (of_property_read_bool(dev->of_node, "ti,timer-alwon")) 1108 timer->capability |= OMAP_TIMER_ALWON; 1109 if (of_property_read_bool(dev->of_node, "ti,timer-dsp")) 1110 timer->capability |= OMAP_TIMER_HAS_DSP_IRQ; 1111 if (of_property_read_bool(dev->of_node, "ti,timer-pwm")) 1112 timer->capability |= OMAP_TIMER_HAS_PWM; 1113 if (of_property_read_bool(dev->of_node, "ti,timer-secure")) 1114 timer->capability |= OMAP_TIMER_SECURE; 1115 } else { 1116 timer->id = pdev->id; 1117 timer->capability = pdata->timer_capability; 1118 timer->reserved = omap_dm_timer_reserved_systimer(timer->id); 1119 } 1120 1121 timer->omap1 = timer->capability & OMAP_TIMER_NEEDS_RESET; 1122 1123 /* OMAP1 devices do not yet use the clock framework for dmtimers */ 1124 if (!timer->omap1) { 1125 timer->fclk = devm_clk_get(dev, "fck"); 1126 if (IS_ERR(timer->fclk)) 1127 return PTR_ERR(timer->fclk); 1128 } else { 1129 timer->fclk = ERR_PTR(-ENODEV); 1130 } 1131 1132 if (!(timer->capability & OMAP_TIMER_ALWON)) { 1133 timer->nb.notifier_call = omap_timer_context_notifier; 1134 cpu_pm_register_notifier(&timer->nb); 1135 } 1136 1137 timer->errata = pdata->timer_errata; 1138 1139 timer->pdev = pdev; 1140 1141 pm_runtime_enable(dev); 1142 1143 if (!timer->reserved) { 1144 ret = pm_runtime_resume_and_get(dev); 1145 if (ret) { 1146 dev_err(dev, "%s: pm_runtime_get_sync failed!\n", 1147 __func__); 1148 goto err_disable; 1149 } 1150 __omap_dm_timer_init_regs(timer); 1151 1152 /* Clear timer configuration */ 1153 dmtimer_write(timer, OMAP_TIMER_CTRL_REG, 0); 1154 1155 pm_runtime_put(dev); 1156 } 1157 1158 /* add the timer element to the list */ 1159 spin_lock_irqsave(&dm_timer_lock, flags); 1160 list_add_tail(&timer->node, &omap_timer_list); 1161 spin_unlock_irqrestore(&dm_timer_lock, flags); 1162 1163 dev_dbg(dev, "Device Probed.\n"); 1164 1165 return 0; 1166 1167 err_disable: 1168 pm_runtime_disable(dev); 1169 return ret; 1170 } 1171 1172 /** 1173 * omap_dm_timer_remove - cleanup a registered timer device 1174 * @pdev: pointer to current timer platform device 1175 * 1176 * Called by driver framework whenever a timer device is unregistered. 1177 * In addition to freeing platform resources it also deletes the timer 1178 * entry from the local list. 1179 */ 1180 static void omap_dm_timer_remove(struct platform_device *pdev) 1181 { 1182 struct dmtimer *timer; 1183 unsigned long flags; 1184 int ret = -EINVAL; 1185 1186 spin_lock_irqsave(&dm_timer_lock, flags); 1187 list_for_each_entry(timer, &omap_timer_list, node) 1188 if (!strcmp(dev_name(&timer->pdev->dev), 1189 dev_name(&pdev->dev))) { 1190 if (!(timer->capability & OMAP_TIMER_ALWON)) 1191 cpu_pm_unregister_notifier(&timer->nb); 1192 list_del(&timer->node); 1193 ret = 0; 1194 break; 1195 } 1196 spin_unlock_irqrestore(&dm_timer_lock, flags); 1197 1198 pm_runtime_disable(&pdev->dev); 1199 1200 if (ret) 1201 dev_err(&pdev->dev, "Unable to determine timer entry in list of drivers on remove\n"); 1202 } 1203 1204 static const struct omap_dm_timer_ops dmtimer_ops = { 1205 .request_by_node = omap_dm_timer_request_by_node, 1206 .request_specific = omap_dm_timer_request_specific, 1207 .request = omap_dm_timer_request, 1208 .set_source = omap_dm_timer_set_source, 1209 .get_irq = omap_dm_timer_get_irq, 1210 .set_int_enable = omap_dm_timer_set_int_enable, 1211 .set_int_disable = omap_dm_timer_set_int_disable, 1212 .free = omap_dm_timer_free, 1213 .enable = omap_dm_timer_enable, 1214 .disable = omap_dm_timer_disable, 1215 .get_fclk = omap_dm_timer_get_fclk, 1216 .start = omap_dm_timer_start, 1217 .stop = omap_dm_timer_stop, 1218 .set_load = omap_dm_timer_set_load, 1219 .set_match = omap_dm_timer_set_match, 1220 .set_pwm = omap_dm_timer_set_pwm, 1221 .get_pwm_status = omap_dm_timer_get_pwm_status, 1222 .set_prescaler = omap_dm_timer_set_prescaler, 1223 .read_counter = omap_dm_timer_read_counter, 1224 .write_counter = omap_dm_timer_write_counter, 1225 .read_status = omap_dm_timer_read_status, 1226 .write_status = omap_dm_timer_write_status, 1227 }; 1228 1229 static const struct dmtimer_platform_data omap3plus_pdata = { 1230 .timer_errata = OMAP_TIMER_ERRATA_I103_I767, 1231 .timer_ops = &dmtimer_ops, 1232 }; 1233 1234 static const struct dmtimer_platform_data am6_pdata = { 1235 .timer_ops = &dmtimer_ops, 1236 }; 1237 1238 static const struct of_device_id omap_timer_match[] = { 1239 { 1240 .compatible = "ti,omap2420-timer", 1241 }, 1242 { 1243 .compatible = "ti,omap3430-timer", 1244 .data = &omap3plus_pdata, 1245 }, 1246 { 1247 .compatible = "ti,omap4430-timer", 1248 .data = &omap3plus_pdata, 1249 }, 1250 { 1251 .compatible = "ti,omap5430-timer", 1252 .data = &omap3plus_pdata, 1253 }, 1254 { 1255 .compatible = "ti,am335x-timer", 1256 .data = &omap3plus_pdata, 1257 }, 1258 { 1259 .compatible = "ti,am335x-timer-1ms", 1260 .data = &omap3plus_pdata, 1261 }, 1262 { 1263 .compatible = "ti,dm816-timer", 1264 .data = &omap3plus_pdata, 1265 }, 1266 { 1267 .compatible = "ti,am654-timer", 1268 .data = &am6_pdata, 1269 }, 1270 {}, 1271 }; 1272 MODULE_DEVICE_TABLE(of, omap_timer_match); 1273 1274 static struct platform_driver omap_dm_timer_driver = { 1275 .probe = omap_dm_timer_probe, 1276 .remove_new = omap_dm_timer_remove, 1277 .driver = { 1278 .name = "omap_timer", 1279 .of_match_table = omap_timer_match, 1280 .pm = &omap_dm_timer_pm_ops, 1281 }, 1282 }; 1283 1284 module_platform_driver(omap_dm_timer_driver); 1285 1286 MODULE_DESCRIPTION("OMAP Dual-Mode Timer Driver"); 1287 MODULE_AUTHOR("Texas Instruments Inc"); 1288