LXR linux/drivers/rtc/rtc-spear.c

   1/*
   2 * drivers/rtc/rtc-spear.c
   3 *
   4 * Copyright (C) 2010 ST Microelectronics
   5 * Rajeev Kumar<rajeev-dlh.kumar@st.com>
   6 *
   7 * This file is licensed under the terms of the GNU General Public
   8 * License version 2. This program is licensed "as is" without any
   9 * warranty of any kind, whether express or implied.
  10 */
  11
  12#include <linux/bcd.h>
  13#include <linux/clk.h>
  14#include <linux/delay.h>
  15#include <linux/init.h>
  16#include <linux/io.h>
  17#include <linux/irq.h>
  18#include <linux/module.h>
  19#include <linux/of.h>
  20#include <linux/platform_device.h>
  21#include <linux/rtc.h>
  22#include <linux/slab.h>
  23#include <linux/spinlock.h>
  24
  25/* RTC registers */
  26#define TIME_REG                0x00
  27#define DATE_REG                0x04
  28#define ALARM_TIME_REG          0x08
  29#define ALARM_DATE_REG          0x0C
  30#define CTRL_REG                0x10
  31#define STATUS_REG              0x14
  32
  33/* TIME_REG & ALARM_TIME_REG */
  34#define SECONDS_UNITS           (0xf<<0)        /* seconds units position */
  35#define SECONDS_TENS            (0x7<<4)        /* seconds tens position */
  36#define MINUTES_UNITS           (0xf<<8)        /* minutes units position */
  37#define MINUTES_TENS            (0x7<<12)       /* minutes tens position */
  38#define HOURS_UNITS             (0xf<<16)       /* hours units position */
  39#define HOURS_TENS              (0x3<<20)       /* hours tens position */
  40
  41/* DATE_REG & ALARM_DATE_REG */
  42#define DAYS_UNITS              (0xf<<0)        /* days units position */
  43#define DAYS_TENS               (0x3<<4)        /* days tens position */
  44#define MONTHS_UNITS            (0xf<<8)        /* months units position */
  45#define MONTHS_TENS             (0x1<<12)       /* months tens position */
  46#define YEARS_UNITS             (0xf<<16)       /* years units position */
  47#define YEARS_TENS              (0xf<<20)       /* years tens position */
  48#define YEARS_HUNDREDS          (0xf<<24)       /* years hundereds position */
  49#define YEARS_MILLENIUMS        (0xf<<28)       /* years millenium position */
  50
  51/* MASK SHIFT TIME_REG & ALARM_TIME_REG*/
  52#define SECOND_SHIFT            0x00            /* seconds units */
  53#define MINUTE_SHIFT            0x08            /* minutes units position */
  54#define HOUR_SHIFT              0x10            /* hours units position */
  55#define MDAY_SHIFT              0x00            /* Month day shift */
  56#define MONTH_SHIFT             0x08            /* Month shift */
  57#define YEAR_SHIFT              0x10            /* Year shift */
  58
  59#define SECOND_MASK             0x7F
  60#define MIN_MASK                0x7F
  61#define HOUR_MASK               0x3F
  62#define DAY_MASK                0x3F
  63#define MONTH_MASK              0x7F
  64#define YEAR_MASK               0xFFFF
  65
  66/* date reg equal to time reg, for debug only */
  67#define TIME_BYP                (1<<9)
  68#define INT_ENABLE              (1<<31)         /* interrupt enable */
  69
  70/* STATUS_REG */
  71#define CLK_UNCONNECTED         (1<<0)
  72#define PEND_WR_TIME            (1<<2)
  73#define PEND_WR_DATE            (1<<3)
  74#define LOST_WR_TIME            (1<<4)
  75#define LOST_WR_DATE            (1<<5)
  76#define RTC_INT_MASK            (1<<31)
  77#define STATUS_BUSY             (PEND_WR_TIME | PEND_WR_DATE)
  78#define STATUS_FAIL             (LOST_WR_TIME | LOST_WR_DATE)
  79
  80struct spear_rtc_config {
  81        struct rtc_device *rtc;
  82        struct clk *clk;
  83        spinlock_t lock;
  84        void __iomem *ioaddr;
  85        unsigned int irq_wake;
  86};
  87
  88static inline void spear_rtc_clear_interrupt(struct spear_rtc_config *config)
  89{
  90        unsigned int val;
  91        unsigned long flags;
  92
  93        spin_lock_irqsave(&config->lock, flags);
  94        val = readl(config->ioaddr + STATUS_REG);
  95        val |= RTC_INT_MASK;
  96        writel(val, config->ioaddr + STATUS_REG);
  97        spin_unlock_irqrestore(&config->lock, flags);
  98}
  99
 100static inline void spear_rtc_enable_interrupt(struct spear_rtc_config *config)
 101{
 102        unsigned int val;
 103
 104        val = readl(config->ioaddr + CTRL_REG);
 105        if (!(val & INT_ENABLE)) {
 106                spear_rtc_clear_interrupt(config);
 107                val |= INT_ENABLE;
 108                writel(val, config->ioaddr + CTRL_REG);
 109        }
 110}
 111
 112static inline void spear_rtc_disable_interrupt(struct spear_rtc_config *config)
 113{
 114        unsigned int val;
 115
 116        val = readl(config->ioaddr + CTRL_REG);
 117        if (val & INT_ENABLE) {
 118                val &= ~INT_ENABLE;
 119                writel(val, config->ioaddr + CTRL_REG);
 120        }
 121}
 122
 123static inline int is_write_complete(struct spear_rtc_config *config)
 124{
 125        int ret = 0;
 126        unsigned long flags;
 127
 128        spin_lock_irqsave(&config->lock, flags);
 129        if ((readl(config->ioaddr + STATUS_REG)) & STATUS_FAIL)
 130                ret = -EIO;
 131        spin_unlock_irqrestore(&config->lock, flags);
 132
 133        return ret;
 134}
 135
 136static void rtc_wait_not_busy(struct spear_rtc_config *config)
 137{
 138        int status, count = 0;
 139        unsigned long flags;
 140
 141        /* Assuming BUSY may stay active for 80 msec) */
 142        for (count = 0; count < 80; count++) {
 143                spin_lock_irqsave(&config->lock, flags);
 144                status = readl(config->ioaddr + STATUS_REG);
 145                spin_unlock_irqrestore(&config->lock, flags);
 146                if ((status & STATUS_BUSY) == 0)
 147                        break;
 148                /* check status busy, after each msec */
 149                msleep(1);
 150        }
 151}
 152
 153static irqreturn_t spear_rtc_irq(int irq, void *dev_id)
 154{
 155        struct spear_rtc_config *config = dev_id;
 156        unsigned long flags, events = 0;
 157        unsigned int irq_data;
 158
 159        spin_lock_irqsave(&config->lock, flags);
 160        irq_data = readl(config->ioaddr + STATUS_REG);
 161        spin_unlock_irqrestore(&config->lock, flags);
 162
 163        if ((irq_data & RTC_INT_MASK)) {
 164                spear_rtc_clear_interrupt(config);
 165                events = RTC_IRQF | RTC_AF;
 166                rtc_update_irq(config->rtc, 1, events);
 167                return IRQ_HANDLED;
 168        } else
 169                return IRQ_NONE;
 170
 171}
 172
 173static int tm2bcd(struct rtc_time *tm)
 174{
 175        if (rtc_valid_tm(tm) != 0)
 176                return -EINVAL;
 177        tm->tm_sec = bin2bcd(tm->tm_sec);
 178        tm->tm_min = bin2bcd(tm->tm_min);
 179        tm->tm_hour = bin2bcd(tm->tm_hour);
 180        tm->tm_mday = bin2bcd(tm->tm_mday);
 181        tm->tm_mon = bin2bcd(tm->tm_mon + 1);
 182        tm->tm_year = bin2bcd(tm->tm_year);
 183
 184        return 0;
 185}
 186
 187static void bcd2tm(struct rtc_time *tm)
 188{
 189        tm->tm_sec = bcd2bin(tm->tm_sec);
 190        tm->tm_min = bcd2bin(tm->tm_min);
 191        tm->tm_hour = bcd2bin(tm->tm_hour);
 192        tm->tm_mday = bcd2bin(tm->tm_mday);
 193        tm->tm_mon = bcd2bin(tm->tm_mon) - 1;
 194        /* epoch == 1900 */
 195        tm->tm_year = bcd2bin(tm->tm_year);
 196}
 197
 198/*
 199 * spear_rtc_read_time - set the time
 200 * @dev: rtc device in use
 201 * @tm: holds date and time
 202 *
 203 * This function read time and date. On success it will return 0
 204 * otherwise -ve error is returned.
 205 */
 206static int spear_rtc_read_time(struct device *dev, struct rtc_time *tm)
 207{
 208        struct spear_rtc_config *config = dev_get_drvdata(dev);
 209        unsigned int time, date;
 210
 211        /* we don't report wday/yday/isdst ... */
 212        rtc_wait_not_busy(config);
 213
 214        time = readl(config->ioaddr + TIME_REG);
 215        date = readl(config->ioaddr + DATE_REG);
 216        tm->tm_sec = (time >> SECOND_SHIFT) & SECOND_MASK;
 217        tm->tm_min = (time >> MINUTE_SHIFT) & MIN_MASK;
 218        tm->tm_hour = (time >> HOUR_SHIFT) & HOUR_MASK;
 219        tm->tm_mday = (date >> MDAY_SHIFT) & DAY_MASK;
 220        tm->tm_mon = (date >> MONTH_SHIFT) & MONTH_MASK;
 221        tm->tm_year = (date >> YEAR_SHIFT) & YEAR_MASK;
 222
 223        bcd2tm(tm);
 224        return 0;
 225}
 226
 227/*
 228 * spear_rtc_set_time - set the time
 229 * @dev: rtc device in use
 230 * @tm: holds date and time
 231 *
 232 * This function set time and date. On success it will return 0
 233 * otherwise -ve error is returned.
 234 */
 235static int spear_rtc_set_time(struct device *dev, struct rtc_time *tm)
 236{
 237        struct spear_rtc_config *config = dev_get_drvdata(dev);
 238        unsigned int time, date;
 239
 240        if (tm2bcd(tm) < 0)
 241                return -EINVAL;
 242
 243        rtc_wait_not_busy(config);
 244        time = (tm->tm_sec << SECOND_SHIFT) | (tm->tm_min << MINUTE_SHIFT) |
 245                (tm->tm_hour << HOUR_SHIFT);
 246        date = (tm->tm_mday << MDAY_SHIFT) | (tm->tm_mon << MONTH_SHIFT) |
 247                (tm->tm_year << YEAR_SHIFT);
 248        writel(time, config->ioaddr + TIME_REG);
 249        writel(date, config->ioaddr + DATE_REG);
 250
 251        return is_write_complete(config);
 252}
 253
 254/*
 255 * spear_rtc_read_alarm - read the alarm time
 256 * @dev: rtc device in use
 257 * @alm: holds alarm date and time
 258 *
 259 * This function read alarm time and date. On success it will return 0
 260 * otherwise -ve error is returned.
 261 */
 262static int spear_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
 263{
 264        struct spear_rtc_config *config = dev_get_drvdata(dev);
 265        unsigned int time, date;
 266
 267        rtc_wait_not_busy(config);
 268
 269        time = readl(config->ioaddr + ALARM_TIME_REG);
 270        date = readl(config->ioaddr + ALARM_DATE_REG);
 271        alm->time.tm_sec = (time >> SECOND_SHIFT) & SECOND_MASK;
 272        alm->time.tm_min = (time >> MINUTE_SHIFT) & MIN_MASK;
 273        alm->time.tm_hour = (time >> HOUR_SHIFT) & HOUR_MASK;
 274        alm->time.tm_mday = (date >> MDAY_SHIFT) & DAY_MASK;
 275        alm->time.tm_mon = (date >> MONTH_SHIFT) & MONTH_MASK;
 276        alm->time.tm_year = (date >> YEAR_SHIFT) & YEAR_MASK;
 277
 278        bcd2tm(&alm->time);
 279        alm->enabled = readl(config->ioaddr + CTRL_REG) & INT_ENABLE;
 280
 281        return 0;
 282}
 283
 284/*
 285 * spear_rtc_set_alarm - set the alarm time
 286 * @dev: rtc device in use
 287 * @alm: holds alarm date and time
 288 *
 289 * This function set alarm time and date. On success it will return 0
 290 * otherwise -ve error is returned.
 291 */
 292static int spear_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
 293{
 294        struct spear_rtc_config *config = dev_get_drvdata(dev);
 295        unsigned int time, date;
 296        int err;
 297
 298        if (tm2bcd(&alm->time) < 0)
 299                return -EINVAL;
 300
 301        rtc_wait_not_busy(config);
 302
 303        time = (alm->time.tm_sec << SECOND_SHIFT) | (alm->time.tm_min <<
 304                        MINUTE_SHIFT) | (alm->time.tm_hour << HOUR_SHIFT);
 305        date = (alm->time.tm_mday << MDAY_SHIFT) | (alm->time.tm_mon <<
 306                        MONTH_SHIFT) | (alm->time.tm_year << YEAR_SHIFT);
 307
 308        writel(time, config->ioaddr + ALARM_TIME_REG);
 309        writel(date, config->ioaddr + ALARM_DATE_REG);
 310        err = is_write_complete(config);
 311        if (err < 0)
 312                return err;
 313
 314        if (alm->enabled)
 315                spear_rtc_enable_interrupt(config);
 316        else
 317                spear_rtc_disable_interrupt(config);
 318
 319        return 0;
 320}
 321
 322static int spear_alarm_irq_enable(struct device *dev, unsigned int enabled)
 323{
 324        struct spear_rtc_config *config = dev_get_drvdata(dev);
 325        int ret = 0;
 326
 327        spear_rtc_clear_interrupt(config);
 328
 329        switch (enabled) {
 330        case 0:
 331                /* alarm off */
 332                spear_rtc_disable_interrupt(config);
 333                break;
 334        case 1:
 335                /* alarm on */
 336                spear_rtc_enable_interrupt(config);
 337                break;
 338        default:
 339                ret = -EINVAL;
 340                break;
 341        }
 342
 343        return ret;
 344}
 345
 346static const struct rtc_class_ops spear_rtc_ops = {
 347        .read_time = spear_rtc_read_time,
 348        .set_time = spear_rtc_set_time,
 349        .read_alarm = spear_rtc_read_alarm,
 350        .set_alarm = spear_rtc_set_alarm,
 351        .alarm_irq_enable = spear_alarm_irq_enable,
 352};
 353
 354static int spear_rtc_probe(struct platform_device *pdev)
 355{
 356        struct resource *res;
 357        struct spear_rtc_config *config;
 358        int status = 0;
 359        int irq;
 360
 361        config = devm_kzalloc(&pdev->dev, sizeof(*config), GFP_KERNEL);
 362        if (!config)
 363                return -ENOMEM;
 364
 365        /* alarm irqs */
 366        irq = platform_get_irq(pdev, 0);
 367        if (irq < 0) {
 368                dev_err(&pdev->dev, "no update irq?\n");
 369                return irq;
 370        }
 371
 372        status = devm_request_irq(&pdev->dev, irq, spear_rtc_irq, 0, pdev->name,
 373                        config);
 374        if (status) {
 375                dev_err(&pdev->dev, "Alarm interrupt IRQ%d already claimed\n",
 376                                irq);
 377                return status;
 378        }
 379
 380        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 381        config->ioaddr = devm_ioremap_resource(&pdev->dev, res);
 382        if (IS_ERR(config->ioaddr))
 383                return PTR_ERR(config->ioaddr);
 384
 385        config->clk = devm_clk_get(&pdev->dev, NULL);
 386        if (IS_ERR(config->clk))
 387                return PTR_ERR(config->clk);
 388
 389        status = clk_prepare_enable(config->clk);
 390        if (status < 0)
 391                return status;
 392
 393        spin_lock_init(&config->lock);
 394        platform_set_drvdata(pdev, config);
 395
 396        config->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
 397                                        &spear_rtc_ops, THIS_MODULE);
 398        if (IS_ERR(config->rtc)) {
 399                dev_err(&pdev->dev, "can't register RTC device, err %ld\n",
 400                                PTR_ERR(config->rtc));
 401                status = PTR_ERR(config->rtc);
 402                goto err_disable_clock;
 403        }
 404
 405        config->rtc->uie_unsupported = 1;
 406
 407        if (!device_can_wakeup(&pdev->dev))
 408                device_init_wakeup(&pdev->dev, 1);
 409
 410        return 0;
 411
 412err_disable_clock:
 413        clk_disable_unprepare(config->clk);
 414
 415        return status;
 416}
 417
 418static int spear_rtc_remove(struct platform_device *pdev)
 419{
 420        struct spear_rtc_config *config = platform_get_drvdata(pdev);
 421
 422        spear_rtc_disable_interrupt(config);
 423        clk_disable_unprepare(config->clk);
 424        device_init_wakeup(&pdev->dev, 0);
 425
 426        return 0;
 427}
 428
 429#ifdef CONFIG_PM_SLEEP
 430static int spear_rtc_suspend(struct device *dev)
 431{
 432        struct platform_device *pdev = to_platform_device(dev);
 433        struct spear_rtc_config *config = platform_get_drvdata(pdev);
 434        int irq;
 435
 436        irq = platform_get_irq(pdev, 0);
 437        if (device_may_wakeup(&pdev->dev)) {
 438                if (!enable_irq_wake(irq))
 439                        config->irq_wake = 1;
 440        } else {
 441                spear_rtc_disable_interrupt(config);
 442                clk_disable(config->clk);
 443        }
 444
 445        return 0;
 446}
 447
 448static int spear_rtc_resume(struct device *dev)
 449{
 450        struct platform_device *pdev = to_platform_device(dev);
 451        struct spear_rtc_config *config = platform_get_drvdata(pdev);
 452        int irq;
 453
 454        irq = platform_get_irq(pdev, 0);
 455
 456        if (device_may_wakeup(&pdev->dev)) {
 457                if (config->irq_wake) {
 458                        disable_irq_wake(irq);
 459                        config->irq_wake = 0;
 460                }
 461        } else {
 462                clk_enable(config->clk);
 463                spear_rtc_enable_interrupt(config);
 464        }
 465
 466        return 0;
 467}
 468#endif
 469
 470static SIMPLE_DEV_PM_OPS(spear_rtc_pm_ops, spear_rtc_suspend, spear_rtc_resume);
 471
 472static void spear_rtc_shutdown(struct platform_device *pdev)
 473{
 474        struct spear_rtc_config *config = platform_get_drvdata(pdev);
 475
 476        spear_rtc_disable_interrupt(config);
 477        clk_disable(config->clk);
 478}
 479
 480#ifdef CONFIG_OF
 481static const struct of_device_id spear_rtc_id_table[] = {
 482        { .compatible = "st,spear600-rtc" },
 483        {}
 484};
 485MODULE_DEVICE_TABLE(of, spear_rtc_id_table);
 486#endif
 487
 488static struct platform_driver spear_rtc_driver = {
 489        .probe = spear_rtc_probe,
 490        .remove = spear_rtc_remove,
 491        .shutdown = spear_rtc_shutdown,
 492        .driver = {
 493                .name = "rtc-spear",
 494                .pm = &spear_rtc_pm_ops,
 495                .of_match_table = of_match_ptr(spear_rtc_id_table),
 496        },
 497};
 498
 499module_platform_driver(spear_rtc_driver);
 500
 501MODULE_ALIAS("platform:rtc-spear");
 502MODULE_AUTHOR("Rajeev Kumar <rajeev-dlh.kumar@st.com>");
 503MODULE_DESCRIPTION("ST SPEAr Realtime Clock Driver (RTC)");
 504MODULE_LICENSE("GPL");
 505