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;
 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 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        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 362        if (!res) {
 363                dev_err(&pdev->dev, "no resource defined\n");
 364                return -EBUSY;
 365        }
 366
 367        config = devm_kzalloc(&pdev->dev, sizeof(*config), GFP_KERNEL);
 368        if (!config) {
 369                dev_err(&pdev->dev, "out of memory\n");
 370                return -ENOMEM;
 371        }
 372
 373        /* alarm irqs */
 374        irq = platform_get_irq(pdev, 0);
 375        if (irq < 0) {
 376                dev_err(&pdev->dev, "no update irq?\n");
 377                return irq;
 378        }
 379
 380        status = devm_request_irq(&pdev->dev, irq, spear_rtc_irq, 0, pdev->name,
 381                        config);
 382        if (status) {
 383                dev_err(&pdev->dev, "Alarm interrupt IRQ%d already claimed\n",
 384                                irq);
 385                return status;
 386        }
 387
 388        config->ioaddr = devm_request_and_ioremap(&pdev->dev, res);
 389        if (!config->ioaddr) {
 390                dev_err(&pdev->dev, "request-ioremap fail\n");
 391                return -ENOMEM;
 392        }
 393
 394        config->clk = devm_clk_get(&pdev->dev, NULL);
 395        if (IS_ERR(config->clk))
 396                return PTR_ERR(config->clk);
 397
 398        status = clk_prepare_enable(config->clk);
 399        if (status < 0)
 400                return status;
 401
 402        spin_lock_init(&config->lock);
 403        platform_set_drvdata(pdev, config);
 404
 405        config->rtc = rtc_device_register(pdev->name, &pdev->dev,
 406                        &spear_rtc_ops, THIS_MODULE);
 407        if (IS_ERR(config->rtc)) {
 408                dev_err(&pdev->dev, "can't register RTC device, err %ld\n",
 409                                PTR_ERR(config->rtc));
 410                status = PTR_ERR(config->rtc);
 411                goto err_disable_clock;
 412        }
 413
 414        config->rtc->uie_unsupported = 1;
 415
 416        if (!device_can_wakeup(&pdev->dev))
 417                device_init_wakeup(&pdev->dev, 1);
 418
 419        return 0;
 420
 421err_disable_clock:
 422        platform_set_drvdata(pdev, NULL);
 423        clk_disable_unprepare(config->clk);
 424
 425        return status;
 426}
 427
 428static int spear_rtc_remove(struct platform_device *pdev)
 429{
 430        struct spear_rtc_config *config = platform_get_drvdata(pdev);
 431
 432        rtc_device_unregister(config->rtc);
 433        spear_rtc_disable_interrupt(config);
 434        clk_disable_unprepare(config->clk);
 435        device_init_wakeup(&pdev->dev, 0);
 436
 437        return 0;
 438}
 439
 440#ifdef CONFIG_PM
 441
 442static int spear_rtc_suspend(struct platform_device *pdev, pm_message_t state)
 443{
 444        struct spear_rtc_config *config = platform_get_drvdata(pdev);
 445        int irq;
 446
 447        irq = platform_get_irq(pdev, 0);
 448        if (device_may_wakeup(&pdev->dev)) {
 449                if (!enable_irq_wake(irq))
 450                        config->irq_wake = 1;
 451        } else {
 452                spear_rtc_disable_interrupt(config);
 453                clk_disable(config->clk);
 454        }
 455
 456        return 0;
 457}
 458
 459static int spear_rtc_resume(struct platform_device *pdev)
 460{
 461        struct spear_rtc_config *config = platform_get_drvdata(pdev);
 462        int irq;
 463
 464        irq = platform_get_irq(pdev, 0);
 465
 466        if (device_may_wakeup(&pdev->dev)) {
 467                if (config->irq_wake) {
 468                        disable_irq_wake(irq);
 469                        config->irq_wake = 0;
 470                }
 471        } else {
 472                clk_enable(config->clk);
 473                spear_rtc_enable_interrupt(config);
 474        }
 475
 476        return 0;
 477}
 478
 479#else
 480#define spear_rtc_suspend       NULL
 481#define spear_rtc_resume        NULL
 482#endif
 483
 484static void spear_rtc_shutdown(struct platform_device *pdev)
 485{
 486        struct spear_rtc_config *config = platform_get_drvdata(pdev);
 487
 488        spear_rtc_disable_interrupt(config);
 489        clk_disable(config->clk);
 490}
 491
 492#ifdef CONFIG_OF
 493static const struct of_device_id spear_rtc_id_table[] = {
 494        { .compatible = "st,spear600-rtc" },
 495        {}
 496};
 497MODULE_DEVICE_TABLE(of, spear_rtc_id_table);
 498#endif
 499
 500static struct platform_driver spear_rtc_driver = {
 501        .probe = spear_rtc_probe,
 502        .remove = spear_rtc_remove,
 503        .suspend = spear_rtc_suspend,
 504        .resume = spear_rtc_resume,
 505        .shutdown = spear_rtc_shutdown,
 506        .driver = {
 507                .name = "rtc-spear",
 508                .of_match_table = of_match_ptr(spear_rtc_id_table),
 509        },
 510};
 511
 512module_platform_driver(spear_rtc_driver);
 513
 514MODULE_ALIAS("platform:rtc-spear");
 515MODULE_AUTHOR("Rajeev Kumar <rajeev-dlh.kumar@st.com>");
 516MODULE_DESCRIPTION("ST SPEAr Realtime Clock Driver (RTC)");
 517MODULE_LICENSE("GPL");
 518
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.