linux/drivers/rtc/rtc-spear.c
<<
>>
Prefs
   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, err = 0;
 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        err = is_write_complete(config);
 251        if (err < 0)
 252                return err;
 253
 254        return 0;
 255}
 256
 257/*
 258 * spear_rtc_read_alarm - read the alarm time
 259 * @dev: rtc device in use
 260 * @alm: holds alarm date and time
 261 *
 262 * This function read alarm time and date. On success it will return 0
 263 * otherwise -ve error is returned.
 264 */
 265static int spear_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
 266{
 267        struct spear_rtc_config *config = dev_get_drvdata(dev);
 268        unsigned int time, date;
 269
 270        rtc_wait_not_busy(config);
 271
 272        time = readl(config->ioaddr + ALARM_TIME_REG);
 273        date = readl(config->ioaddr + ALARM_DATE_REG);
 274        alm->time.tm_sec = (time >> SECOND_SHIFT) & SECOND_MASK;
 275        alm->time.tm_min = (time >> MINUTE_SHIFT) & MIN_MASK;
 276        alm->time.tm_hour = (time >> HOUR_SHIFT) & HOUR_MASK;
 277        alm->time.tm_mday = (date >> MDAY_SHIFT) & DAY_MASK;
 278        alm->time.tm_mon = (date >> MONTH_SHIFT) & MONTH_MASK;
 279        alm->time.tm_year = (date >> YEAR_SHIFT) & YEAR_MASK;
 280
 281        bcd2tm(&alm->time);
 282        alm->enabled = readl(config->ioaddr + CTRL_REG) & INT_ENABLE;
 283
 284        return 0;
 285}
 286
 287/*
 288 * spear_rtc_set_alarm - set the alarm time
 289 * @dev: rtc device in use
 290 * @alm: holds alarm date and time
 291 *
 292 * This function set alarm time and date. On success it will return 0
 293 * otherwise -ve error is returned.
 294 */
 295static int spear_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
 296{
 297        struct spear_rtc_config *config = dev_get_drvdata(dev);
 298        unsigned int time, date, err = 0;
 299
 300        if (tm2bcd(&alm->time) < 0)
 301                return -EINVAL;
 302
 303        rtc_wait_not_busy(config);
 304
 305        time = (alm->time.tm_sec << SECOND_SHIFT) | (alm->time.tm_min <<
 306                        MINUTE_SHIFT) | (alm->time.tm_hour << HOUR_SHIFT);
 307        date = (alm->time.tm_mday << MDAY_SHIFT) | (alm->time.tm_mon <<
 308                        MONTH_SHIFT) | (alm->time.tm_year << YEAR_SHIFT);
 309
 310        writel(time, config->ioaddr + ALARM_TIME_REG);
 311        writel(date, config->ioaddr + ALARM_DATE_REG);
 312        err = is_write_complete(config);
 313        if (err < 0)
 314                return err;
 315
 316        if (alm->enabled)
 317                spear_rtc_enable_interrupt(config);
 318        else
 319                spear_rtc_disable_interrupt(config);
 320
 321        return 0;
 322}
 323
 324static int spear_alarm_irq_enable(struct device *dev, unsigned int enabled)
 325{
 326        struct spear_rtc_config *config = dev_get_drvdata(dev);
 327        int ret = 0;
 328
 329        spear_rtc_clear_interrupt(config);
 330
 331        switch (enabled) {
 332        case 0:
 333                /* alarm off */
 334                spear_rtc_disable_interrupt(config);
 335                break;
 336        case 1:
 337                /* alarm on */
 338                spear_rtc_enable_interrupt(config);
 339                break;
 340        default:
 341                ret = -EINVAL;
 342                break;
 343        }
 344
 345        return ret;
 346}
 347
 348static struct rtc_class_ops spear_rtc_ops = {
 349        .read_time = spear_rtc_read_time,
 350        .set_time = spear_rtc_set_time,
 351        .read_alarm = spear_rtc_read_alarm,
 352        .set_alarm = spear_rtc_set_alarm,
 353        .alarm_irq_enable = spear_alarm_irq_enable,
 354};
 355
 356static int __devinit spear_rtc_probe(struct platform_device *pdev)
 357{
 358        struct resource *res;
 359        struct spear_rtc_config *config;
 360        unsigned int status = 0;
 361        int irq;
 362
 363        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 364        if (!res) {
 365                dev_err(&pdev->dev, "no resource defined\n");
 366                return -EBUSY;
 367        }
 368        if (!request_mem_region(res->start, resource_size(res), pdev->name)) {
 369                dev_err(&pdev->dev, "rtc region already claimed\n");
 370                return -EBUSY;
 371        }
 372
 373        config = kzalloc(sizeof(*config), GFP_KERNEL);
 374        if (!config) {
 375                dev_err(&pdev->dev, "out of memory\n");
 376                status = -ENOMEM;
 377                goto err_release_region;
 378        }
 379
 380        config->clk = clk_get(&pdev->dev, NULL);
 381        if (IS_ERR(config->clk)) {
 382                status = PTR_ERR(config->clk);
 383                goto err_kfree;
 384        }
 385
 386        status = clk_enable(config->clk);
 387        if (status < 0)
 388                goto err_clk_put;
 389
 390        config->ioaddr = ioremap(res->start, resource_size(res));
 391        if (!config->ioaddr) {
 392                dev_err(&pdev->dev, "ioremap fail\n");
 393                status = -ENOMEM;
 394                goto err_disable_clock;
 395        }
 396
 397        spin_lock_init(&config->lock);
 398        platform_set_drvdata(pdev, config);
 399
 400        config->rtc = rtc_device_register(pdev->name, &pdev->dev,
 401                        &spear_rtc_ops, THIS_MODULE);
 402        if (IS_ERR(config->rtc)) {
 403                dev_err(&pdev->dev, "can't register RTC device, err %ld\n",
 404                                PTR_ERR(config->rtc));
 405                status = PTR_ERR(config->rtc);
 406                goto err_iounmap;
 407        }
 408
 409        /* alarm irqs */
 410        irq = platform_get_irq(pdev, 0);
 411        if (irq < 0) {
 412                dev_err(&pdev->dev, "no update irq?\n");
 413                status = irq;
 414                goto err_clear_platdata;
 415        }
 416
 417        status = request_irq(irq, spear_rtc_irq, 0, pdev->name, config);
 418        if (status) {
 419                dev_err(&pdev->dev, "Alarm interrupt IRQ%d already \
 420                                claimed\n", irq);
 421                goto err_clear_platdata;
 422        }
 423
 424        if (!device_can_wakeup(&pdev->dev))
 425                device_init_wakeup(&pdev->dev, 1);
 426
 427        return 0;
 428
 429err_clear_platdata:
 430        platform_set_drvdata(pdev, NULL);
 431        rtc_device_unregister(config->rtc);
 432err_iounmap:
 433        iounmap(config->ioaddr);
 434err_disable_clock:
 435        clk_disable(config->clk);
 436err_clk_put:
 437        clk_put(config->clk);
 438err_kfree:
 439        kfree(config);
 440err_release_region:
 441        release_mem_region(res->start, resource_size(res));
 442
 443        return status;
 444}
 445
 446static int __devexit spear_rtc_remove(struct platform_device *pdev)
 447{
 448        struct spear_rtc_config *config = platform_get_drvdata(pdev);
 449        int irq;
 450        struct resource *res;
 451
 452        /* leave rtc running, but disable irqs */
 453        spear_rtc_disable_interrupt(config);
 454        device_init_wakeup(&pdev->dev, 0);
 455        irq = platform_get_irq(pdev, 0);
 456        if (irq)
 457                free_irq(irq, pdev);
 458        clk_disable(config->clk);
 459        clk_put(config->clk);
 460        iounmap(config->ioaddr);
 461        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 462        if (res)
 463                release_mem_region(res->start, resource_size(res));
 464        platform_set_drvdata(pdev, NULL);
 465        rtc_device_unregister(config->rtc);
 466        kfree(config);
 467
 468        return 0;
 469}
 470
 471#ifdef CONFIG_PM
 472
 473static int spear_rtc_suspend(struct platform_device *pdev, pm_message_t state)
 474{
 475        struct spear_rtc_config *config = platform_get_drvdata(pdev);
 476        int irq;
 477
 478        irq = platform_get_irq(pdev, 0);
 479        if (device_may_wakeup(&pdev->dev)) {
 480                if (!enable_irq_wake(irq))
 481                        config->irq_wake = 1;
 482        } else {
 483                spear_rtc_disable_interrupt(config);
 484                clk_disable(config->clk);
 485        }
 486
 487        return 0;
 488}
 489
 490static int spear_rtc_resume(struct platform_device *pdev)
 491{
 492        struct spear_rtc_config *config = platform_get_drvdata(pdev);
 493        int irq;
 494
 495        irq = platform_get_irq(pdev, 0);
 496
 497        if (device_may_wakeup(&pdev->dev)) {
 498                if (config->irq_wake) {
 499                        disable_irq_wake(irq);
 500                        config->irq_wake = 0;
 501                }
 502        } else {
 503                clk_enable(config->clk);
 504                spear_rtc_enable_interrupt(config);
 505        }
 506
 507        return 0;
 508}
 509
 510#else
 511#define spear_rtc_suspend       NULL
 512#define spear_rtc_resume        NULL
 513#endif
 514
 515static void spear_rtc_shutdown(struct platform_device *pdev)
 516{
 517        struct spear_rtc_config *config = platform_get_drvdata(pdev);
 518
 519        spear_rtc_disable_interrupt(config);
 520        clk_disable(config->clk);
 521}
 522
 523#ifdef CONFIG_OF
 524static const struct of_device_id spear_rtc_id_table[] = {
 525        { .compatible = "st,spear600-rtc" },
 526        {}
 527};
 528MODULE_DEVICE_TABLE(of, spear_rtc_id_table);
 529#endif
 530
 531static struct platform_driver spear_rtc_driver = {
 532        .probe = spear_rtc_probe,
 533        .remove = __devexit_p(spear_rtc_remove),
 534        .suspend = spear_rtc_suspend,
 535        .resume = spear_rtc_resume,
 536        .shutdown = spear_rtc_shutdown,
 537        .driver = {
 538                .name = "rtc-spear",
 539                .of_match_table = of_match_ptr(spear_rtc_id_table),
 540        },
 541};
 542
 543module_platform_driver(spear_rtc_driver);
 544
 545MODULE_ALIAS("platform:rtc-spear");
 546MODULE_AUTHOR("Rajeev Kumar <rajeev-dlh.kumar@st.com>");
 547MODULE_DESCRIPTION("ST SPEAr Realtime Clock Driver (RTC)");
 548MODULE_LICENSE("GPL");
 549
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.