drivers/rtc/rtc-omap.c

   1 /*
   2  * TI OMAP1 Real Time Clock interface for Linux
   3  *
   4  * Copyright (C) 2003 MontaVista Software, Inc.
   5  * Author: George G. Davis <gdavis@mvista.com> or <source@mvista.com>
   6  *
   7  * Copyright (C) 2006 David Brownell (new RTC framework)
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License
  11  * as published by the Free Software Foundation; either version
  12  * 2 of the License, or (at your option) any later version.
  13  */
  14
  15 #include <linux/kernel.h>
  16 #include <linux/init.h>
  17 #include <linux/module.h>
  18 #include <linux/ioport.h>
  19 #include <linux/delay.h>
  20 #include <linux/rtc.h>
  21 #include <linux/bcd.h>
  22 #include <linux/platform_device.h>
  23
  24 #include <asm/io.h>
  25
  26
  27 /* The OMAP1 RTC is a year/month/day/hours/minutes/seconds BCD clock
  28  * with century-range alarm matching, driven by the 32kHz clock.
  29  *
  30  * The main user-visible ways it differs from PC RTCs are by omitting
  31  * "don't care" alarm fields and sub-second periodic IRQs, and having
  32  * an autoadjust mechanism to calibrate to the true oscillator rate.
  33  *
  34  * Board-specific wiring options include using split power mode with
  35  * RTC_OFF_NOFF used as the reset signal (so the RTC won't be reset),
  36  * and wiring RTC_WAKE_INT (so the RTC alarm can wake the system from
  37  * low power modes) for OMAP1 boards (OMAP-L138 has this built into
  38  * the SoC). See the BOARD-SPECIFIC CUSTOMIZATION comment.
  39  */
  40
  41 #define OMAP_RTC_BASE                   0xfffb4800
  42
  43 /* RTC registers */
  44 #define OMAP_RTC_SECONDS_REG            0x00
  45 #define OMAP_RTC_MINUTES_REG            0x04
  46 #define OMAP_RTC_HOURS_REG              0x08
  47 #define OMAP_RTC_DAYS_REG               0x0C
  48 #define OMAP_RTC_MONTHS_REG             0x10
  49 #define OMAP_RTC_YEARS_REG              0x14
  50 #define OMAP_RTC_WEEKS_REG              0x18
  51
  52 #define OMAP_RTC_ALARM_SECONDS_REG      0x20
  53 #define OMAP_RTC_ALARM_MINUTES_REG      0x24
  54 #define OMAP_RTC_ALARM_HOURS_REG        0x28
  55 #define OMAP_RTC_ALARM_DAYS_REG         0x2c
  56 #define OMAP_RTC_ALARM_MONTHS_REG       0x30
  57 #define OMAP_RTC_ALARM_YEARS_REG        0x34
  58
  59 #define OMAP_RTC_CTRL_REG               0x40
  60 #define OMAP_RTC_STATUS_REG             0x44
  61 #define OMAP_RTC_INTERRUPTS_REG         0x48
  62
  63 #define OMAP_RTC_COMP_LSB_REG           0x4c
  64 #define OMAP_RTC_COMP_MSB_REG           0x50
  65 #define OMAP_RTC_OSC_REG                0x54
  66
  67 /* OMAP_RTC_CTRL_REG bit fields: */
  68 #define OMAP_RTC_CTRL_SPLIT             (1<<7)
  69 #define OMAP_RTC_CTRL_DISABLE           (1<<6)
  70 #define OMAP_RTC_CTRL_SET_32_COUNTER    (1<<5)
  71 #define OMAP_RTC_CTRL_TEST              (1<<4)
  72 #define OMAP_RTC_CTRL_MODE_12_24        (1<<3)
  73 #define OMAP_RTC_CTRL_AUTO_COMP         (1<<2)
  74 #define OMAP_RTC_CTRL_ROUND_30S         (1<<1)
  75 #define OMAP_RTC_CTRL_STOP              (1<<0)
  76
  77 /* OMAP_RTC_STATUS_REG bit fields: */
  78 #define OMAP_RTC_STATUS_POWER_UP        (1<<7)
  79 #define OMAP_RTC_STATUS_ALARM           (1<<6)
  80 #define OMAP_RTC_STATUS_1D_EVENT        (1<<5)
  81 #define OMAP_RTC_STATUS_1H_EVENT        (1<<4)
  82 #define OMAP_RTC_STATUS_1M_EVENT        (1<<3)
  83 #define OMAP_RTC_STATUS_1S_EVENT        (1<<2)
  84 #define OMAP_RTC_STATUS_RUN             (1<<1)
  85 #define OMAP_RTC_STATUS_BUSY            (1<<0)
  86
  87 /* OMAP_RTC_INTERRUPTS_REG bit fields: */
  88 #define OMAP_RTC_INTERRUPTS_IT_ALARM    (1<<3)
  89 #define OMAP_RTC_INTERRUPTS_IT_TIMER    (1<<2)
  90
  91 static void __iomem     *rtc_base;
  92
  93 #define rtc_read(addr)          __raw_readb(rtc_base + (addr))
  94 #define rtc_write(val, addr)    __raw_writeb(val, rtc_base + (addr))
  95
  96
  97 /* we rely on the rtc framework to handle locking (rtc->ops_lock),
  98  * so the only other requirement is that register accesses which
  99  * require BUSY to be clear are made with IRQs locally disabled
 100  */
 101 static void rtc_wait_not_busy(void)
 102 {
 103         int     count = 0;
 104         u8      status;
 105
 106         /* BUSY may stay active for 1/32768 second (~30 usec) */
 107         for (count = 0; count < 50; count++) {
 108                 status = rtc_read(OMAP_RTC_STATUS_REG);
 109                 if ((status & (u8)OMAP_RTC_STATUS_BUSY) == 0)
 110                         break;
 111                 udelay(1);
 112         }
 113         /* now we have ~15 usec to read/write various registers */
 114 }
 115
 116 static irqreturn_t rtc_irq(int irq, void *rtc)
 117 {
 118         unsigned long           events = 0;
 119         u8                      irq_data;
 120
 121         irq_data = rtc_read(OMAP_RTC_STATUS_REG);
 122
 123         /* alarm irq? */
 124         if (irq_data & OMAP_RTC_STATUS_ALARM) {
 125                 rtc_write(OMAP_RTC_STATUS_ALARM, OMAP_RTC_STATUS_REG);
 126                 events |= RTC_IRQF | RTC_AF;
 127         }
 128
 129         /* 1/sec periodic/update irq? */
 130         if (irq_data & OMAP_RTC_STATUS_1S_EVENT)
 131                 events |= RTC_IRQF | RTC_UF;
 132
 133         rtc_update_irq(rtc, 1, events);
 134
 135         return IRQ_HANDLED;
 136 }
 137
 138 static int omap_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
 139 {
 140         u8 reg;
 141
 142         local_irq_disable();
 143         rtc_wait_not_busy();
 144         reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);
 145         if (enabled)
 146                 reg |= OMAP_RTC_INTERRUPTS_IT_ALARM;
 147         else
 148                 reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
 149         rtc_wait_not_busy();
 150         rtc_write(reg, OMAP_RTC_INTERRUPTS_REG);
 151         local_irq_enable();
 152
 153         return 0;
 154 }
 155
 156 /* this hardware doesn't support "don't care" alarm fields */
 157 static int tm2bcd(struct rtc_time *tm)
 158 {
 159         if (rtc_valid_tm(tm) != 0)
 160                 return -EINVAL;
 161
 162         tm->tm_sec = bin2bcd(tm->tm_sec);
 163         tm->tm_min = bin2bcd(tm->tm_min);
 164         tm->tm_hour = bin2bcd(tm->tm_hour);
 165         tm->tm_mday = bin2bcd(tm->tm_mday);
 166
 167         tm->tm_mon = bin2bcd(tm->tm_mon + 1);
 168
 169         /* epoch == 1900 */
 170         if (tm->tm_year < 100 || tm->tm_year > 199)
 171                 return -EINVAL;
 172         tm->tm_year = bin2bcd(tm->tm_year - 100);
 173
 174         return 0;
 175 }
 176
 177 static void bcd2tm(struct rtc_time *tm)
 178 {
 179         tm->tm_sec = bcd2bin(tm->tm_sec);
 180         tm->tm_min = bcd2bin(tm->tm_min);
 181         tm->tm_hour = bcd2bin(tm->tm_hour);
 182         tm->tm_mday = bcd2bin(tm->tm_mday);
 183         tm->tm_mon = bcd2bin(tm->tm_mon) - 1;
 184         /* epoch == 1900 */
 185         tm->tm_year = bcd2bin(tm->tm_year) + 100;
 186 }
 187
 188
 189 static int omap_rtc_read_time(struct device *dev, struct rtc_time *tm)
 190 {
 191         /* we don't report wday/yday/isdst ... */
 192         local_irq_disable();
 193         rtc_wait_not_busy();
 194
 195         tm->tm_sec = rtc_read(OMAP_RTC_SECONDS_REG);
 196         tm->tm_min = rtc_read(OMAP_RTC_MINUTES_REG);
 197         tm->tm_hour = rtc_read(OMAP_RTC_HOURS_REG);
 198         tm->tm_mday = rtc_read(OMAP_RTC_DAYS_REG);
 199         tm->tm_mon = rtc_read(OMAP_RTC_MONTHS_REG);
 200         tm->tm_year = rtc_read(OMAP_RTC_YEARS_REG);
 201
 202         local_irq_enable();
 203
 204         bcd2tm(tm);
 205         return 0;
 206 }
 207
 208 static int omap_rtc_set_time(struct device *dev, struct rtc_time *tm)
 209 {
 210         if (tm2bcd(tm) < 0)
 211                 return -EINVAL;
 212         local_irq_disable();
 213         rtc_wait_not_busy();
 214
 215         rtc_write(tm->tm_year, OMAP_RTC_YEARS_REG);
 216         rtc_write(tm->tm_mon, OMAP_RTC_MONTHS_REG);
 217         rtc_write(tm->tm_mday, OMAP_RTC_DAYS_REG);
 218         rtc_write(tm->tm_hour, OMAP_RTC_HOURS_REG);
 219         rtc_write(tm->tm_min, OMAP_RTC_MINUTES_REG);
 220         rtc_write(tm->tm_sec, OMAP_RTC_SECONDS_REG);
 221
 222         local_irq_enable();
 223
 224         return 0;
 225 }
 226
 227 static int omap_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
 228 {
 229         local_irq_disable();
 230         rtc_wait_not_busy();
 231
 232         alm->time.tm_sec = rtc_read(OMAP_RTC_ALARM_SECONDS_REG);
 233         alm->time.tm_min = rtc_read(OMAP_RTC_ALARM_MINUTES_REG);
 234         alm->time.tm_hour = rtc_read(OMAP_RTC_ALARM_HOURS_REG);
 235         alm->time.tm_mday = rtc_read(OMAP_RTC_ALARM_DAYS_REG);
 236         alm->time.tm_mon = rtc_read(OMAP_RTC_ALARM_MONTHS_REG);
 237         alm->time.tm_year = rtc_read(OMAP_RTC_ALARM_YEARS_REG);
 238
 239         local_irq_enable();
 240
 241         bcd2tm(&alm->time);
 242         alm->enabled = !!(rtc_read(OMAP_RTC_INTERRUPTS_REG)
 243                         & OMAP_RTC_INTERRUPTS_IT_ALARM);
 244
 245         return 0;
 246 }
 247
 248 static int omap_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
 249 {
 250         u8 reg;
 251
 252         if (tm2bcd(&alm->time) < 0)
 253                 return -EINVAL;
 254
 255         local_irq_disable();
 256         rtc_wait_not_busy();
 257
 258         rtc_write(alm->time.tm_year, OMAP_RTC_ALARM_YEARS_REG);
 259         rtc_write(alm->time.tm_mon, OMAP_RTC_ALARM_MONTHS_REG);
 260         rtc_write(alm->time.tm_mday, OMAP_RTC_ALARM_DAYS_REG);
 261         rtc_write(alm->time.tm_hour, OMAP_RTC_ALARM_HOURS_REG);
 262         rtc_write(alm->time.tm_min, OMAP_RTC_ALARM_MINUTES_REG);
 263         rtc_write(alm->time.tm_sec, OMAP_RTC_ALARM_SECONDS_REG);
 264
 265         reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);
 266         if (alm->enabled)
 267                 reg |= OMAP_RTC_INTERRUPTS_IT_ALARM;
 268         else
 269                 reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
 270         rtc_write(reg, OMAP_RTC_INTERRUPTS_REG);
 271
 272         local_irq_enable();
 273
 274         return 0;
 275 }
 276
 277 static struct rtc_class_ops omap_rtc_ops = {
 278         .read_time      = omap_rtc_read_time,
 279         .set_time       = omap_rtc_set_time,
 280         .read_alarm     = omap_rtc_read_alarm,
 281         .set_alarm      = omap_rtc_set_alarm,
 282         .alarm_irq_enable = omap_rtc_alarm_irq_enable,
 283 };
 284
 285 static int omap_rtc_alarm;
 286 static int omap_rtc_timer;
 287
 288 static int __init omap_rtc_probe(struct platform_device *pdev)
 289 {
 290         struct resource         *res, *mem;
 291         struct rtc_device       *rtc;
 292         u8                      reg, new_ctrl;
 293
 294         omap_rtc_timer = platform_get_irq(pdev, 0);
 295         if (omap_rtc_timer <= 0) {
 296                 pr_debug("%s: no update irq?\n", pdev->name);
 297                 return -ENOENT;
 298         }
 299
 300         omap_rtc_alarm = platform_get_irq(pdev, 1);
 301         if (omap_rtc_alarm <= 0) {
 302                 pr_debug("%s: no alarm irq?\n", pdev->name);
 303                 return -ENOENT;
 304         }
 305
 306         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 307         if (!res) {
 308                 pr_debug("%s: RTC resource data missing\n", pdev->name);
 309                 return -ENOENT;
 310         }
 311
 312         mem = request_mem_region(res->start, resource_size(res), pdev->name);
 313         if (!mem) {
 314                 pr_debug("%s: RTC registers at %08x are not free\n",
 315                         pdev->name, res->start);
 316                 return -EBUSY;
 317         }
 318
 319         rtc_base = ioremap(res->start, resource_size(res));
 320         if (!rtc_base) {
 321                 pr_debug("%s: RTC registers can't be mapped\n", pdev->name);
 322                 goto fail;
 323         }
 324
 325         rtc = rtc_device_register(pdev->name, &pdev->dev,
 326                         &omap_rtc_ops, THIS_MODULE);
 327         if (IS_ERR(rtc)) {
 328                 pr_debug("%s: can't register RTC device, err %ld\n",
 329                         pdev->name, PTR_ERR(rtc));
 330                 goto fail0;
 331         }
 332         platform_set_drvdata(pdev, rtc);
 333         dev_set_drvdata(&rtc->dev, mem);
 334
 335         /* clear pending irqs, and set 1/second periodic,
 336          * which we'll use instead of update irqs
 337          */
 338         rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
 339
 340         /* clear old status */
 341         reg = rtc_read(OMAP_RTC_STATUS_REG);
 342         if (reg & (u8) OMAP_RTC_STATUS_POWER_UP) {
 343                 pr_info("%s: RTC power up reset detected\n",
 344                         pdev->name);
 345                 rtc_write(OMAP_RTC_STATUS_POWER_UP, OMAP_RTC_STATUS_REG);
 346         }
 347         if (reg & (u8) OMAP_RTC_STATUS_ALARM)
 348                 rtc_write(OMAP_RTC_STATUS_ALARM, OMAP_RTC_STATUS_REG);
 349
 350         /* handle periodic and alarm irqs */
 351         if (request_irq(omap_rtc_timer, rtc_irq, IRQF_DISABLED,
 352                         dev_name(&rtc->dev), rtc)) {
 353                 pr_debug("%s: RTC timer interrupt IRQ%d already claimed\n",
 354                         pdev->name, omap_rtc_timer);
 355                 goto fail1;
 356         }
 357         if ((omap_rtc_timer != omap_rtc_alarm) &&
 358                 (request_irq(omap_rtc_alarm, rtc_irq, IRQF_DISABLED,
 359                         dev_name(&rtc->dev), rtc))) {
 360                 pr_debug("%s: RTC alarm interrupt IRQ%d already claimed\n",
 361                         pdev->name, omap_rtc_alarm);
 362                 goto fail2;
 363         }
 364
 365         /* On boards with split power, RTC_ON_NOFF won't reset the RTC */
 366         reg = rtc_read(OMAP_RTC_CTRL_REG);
 367         if (reg & (u8) OMAP_RTC_CTRL_STOP)
 368                 pr_info("%s: already running\n", pdev->name);
 369
 370         /* force to 24 hour mode */
 371         new_ctrl = reg & ~(OMAP_RTC_CTRL_SPLIT|OMAP_RTC_CTRL_AUTO_COMP);
 372         new_ctrl |= OMAP_RTC_CTRL_STOP;
 373
 374         /* BOARD-SPECIFIC CUSTOMIZATION CAN GO HERE:
 375          *
 376          *  - Device wake-up capability setting should come through chip
 377          *    init logic. OMAP1 boards should initialize the "wakeup capable"
 378          *    flag in the platform device if the board is wired right for
 379          *    being woken up by RTC alarm. For OMAP-L138, this capability
 380          *    is built into the SoC by the "Deep Sleep" capability.
 381          *
 382          *  - Boards wired so RTC_ON_nOFF is used as the reset signal,
 383          *    rather than nPWRON_RESET, should forcibly enable split
 384          *    power mode.  (Some chip errata report that RTC_CTRL_SPLIT
 385          *    is write-only, and always reads as zero...)
 386          */
 387
 388         if (new_ctrl & (u8) OMAP_RTC_CTRL_SPLIT)
 389                 pr_info("%s: split power mode\n", pdev->name);
 390
 391         if (reg != new_ctrl)
 392                 rtc_write(new_ctrl, OMAP_RTC_CTRL_REG);
 393
 394         return 0;
 395
 396 fail2:
 397         free_irq(omap_rtc_timer, NULL);
 398 fail1:
 399         rtc_device_unregister(rtc);
 400 fail0:
 401         iounmap(rtc_base);
 402 fail:
 403         release_mem_region(mem->start, resource_size(mem));
 404         return -EIO;
 405 }
 406
 407 static int __exit omap_rtc_remove(struct platform_device *pdev)
 408 {
 409         struct rtc_device       *rtc = platform_get_drvdata(pdev);
 410         struct resource         *mem = dev_get_drvdata(&rtc->dev);
 411
 412         device_init_wakeup(&pdev->dev, 0);
 413
 414         /* leave rtc running, but disable irqs */
 415         rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
 416
 417         free_irq(omap_rtc_timer, rtc);
 418
 419         if (omap_rtc_timer != omap_rtc_alarm)
 420                 free_irq(omap_rtc_alarm, rtc);
 421
 422         rtc_device_unregister(rtc);
 423         iounmap(rtc_base);
 424         release_mem_region(mem->start, resource_size(mem));
 425         return 0;
 426 }
 427
 428 #ifdef CONFIG_PM
 429
 430 static u8 irqstat;
 431
 432 static int omap_rtc_suspend(struct platform_device *pdev, pm_message_t state)
 433 {
 434         irqstat = rtc_read(OMAP_RTC_INTERRUPTS_REG);
 435
 436         /* FIXME the RTC alarm is not currently acting as a wakeup event
 437          * source, and in fact this enable() call is just saving a flag
 438          * that's never used...
 439          */
 440         if (device_may_wakeup(&pdev->dev))
 441                 enable_irq_wake(omap_rtc_alarm);
 442         else
 443                 rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
 444
 445         return 0;
 446 }
 447
 448 static int omap_rtc_resume(struct platform_device *pdev)
 449 {
 450         if (device_may_wakeup(&pdev->dev))
 451                 disable_irq_wake(omap_rtc_alarm);
 452         else
 453                 rtc_write(irqstat, OMAP_RTC_INTERRUPTS_REG);
 454         return 0;
 455 }
 456
 457 #else
 458 #define omap_rtc_suspend NULL
 459 #define omap_rtc_resume  NULL
 460 #endif
 461
 462 static void omap_rtc_shutdown(struct platform_device *pdev)
 463 {
 464         rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
 465 }
 466
 467 MODULE_ALIAS("platform:omap_rtc");
 468 static struct platform_driver omap_rtc_driver = {
 469         .remove         = __exit_p(omap_rtc_remove),
 470         .suspend        = omap_rtc_suspend,
 471         .resume         = omap_rtc_resume,
 472         .shutdown       = omap_rtc_shutdown,
 473         .driver         = {
 474                 .name   = "omap_rtc",
 475                 .owner  = THIS_MODULE,
 476         },
 477 };
 478
 479 static int __init rtc_init(void)
 480 {
 481         return platform_driver_probe(&omap_rtc_driver, omap_rtc_probe);
 482 }
 483 module_init(rtc_init);
 484
 485 static void __exit rtc_exit(void)
 486 {
 487         platform_driver_unregister(&omap_rtc_driver);
 488 }
 489 module_exit(rtc_exit);
 490
 491 MODULE_AUTHOR("George G. Davis (and others)");
 492 MODULE_LICENSE("GPL");