linux/drivers/rtc/rtc-wm8350.c
<<
>>
Prefs
   1/*
   2 *      Real Time Clock driver for Wolfson Microelectronics WM8350
   3 *
   4 *      Copyright (C) 2007, 2008 Wolfson Microelectronics PLC.
   5 *
   6 *  Author: Liam Girdwood
   7 *          linux@wolfsonmicro.com
   8 *
   9 *  This program is free software; you can redistribute  it and/or modify it
  10 *  under  the terms of  the GNU General  Public License as published by the
  11 *  Free Software Foundation;  either version 2 of the  License, or (at your
  12 *  option) any later version.
  13 *
  14 */
  15
  16#include <linux/module.h>
  17#include <linux/kernel.h>
  18#include <linux/time.h>
  19#include <linux/rtc.h>
  20#include <linux/bcd.h>
  21#include <linux/interrupt.h>
  22#include <linux/ioctl.h>
  23#include <linux/completion.h>
  24#include <linux/mfd/wm8350/rtc.h>
  25#include <linux/mfd/wm8350/core.h>
  26#include <linux/delay.h>
  27#include <linux/platform_device.h>
  28
  29#define WM8350_SET_ALM_RETRIES  5
  30#define WM8350_SET_TIME_RETRIES 5
  31#define WM8350_GET_TIME_RETRIES 5
  32
  33#define to_wm8350_from_rtc_dev(d) container_of(d, struct wm8350, rtc.pdev.dev)
  34
  35/*
  36 * Read current time and date in RTC
  37 */
  38static int wm8350_rtc_readtime(struct device *dev, struct rtc_time *tm)
  39{
  40        struct wm8350 *wm8350 = dev_get_drvdata(dev);
  41        u16 time1[4], time2[4];
  42        int retries = WM8350_GET_TIME_RETRIES, ret;
  43
  44        /*
  45         * Read the time twice and compare.
  46         * If time1 == time2, then time is valid else retry.
  47         */
  48        do {
  49                ret = wm8350_block_read(wm8350, WM8350_RTC_SECONDS_MINUTES,
  50                                        4, time1);
  51                if (ret < 0)
  52                        return ret;
  53                ret = wm8350_block_read(wm8350, WM8350_RTC_SECONDS_MINUTES,
  54                                        4, time2);
  55                if (ret < 0)
  56                        return ret;
  57
  58                if (memcmp(time1, time2, sizeof(time1)) == 0) {
  59                        tm->tm_sec = time1[0] & WM8350_RTC_SECS_MASK;
  60
  61                        tm->tm_min = (time1[0] & WM8350_RTC_MINS_MASK)
  62                            >> WM8350_RTC_MINS_SHIFT;
  63
  64                        tm->tm_hour = time1[1] & WM8350_RTC_HRS_MASK;
  65
  66                        tm->tm_wday = ((time1[1] >> WM8350_RTC_DAY_SHIFT)
  67                                       & 0x7) - 1;
  68
  69                        tm->tm_mon = ((time1[2] & WM8350_RTC_MTH_MASK)
  70                                      >> WM8350_RTC_MTH_SHIFT) - 1;
  71
  72                        tm->tm_mday = (time1[2] & WM8350_RTC_DATE_MASK);
  73
  74                        tm->tm_year = ((time1[3] & WM8350_RTC_YHUNDREDS_MASK)
  75                                       >> WM8350_RTC_YHUNDREDS_SHIFT) * 100;
  76                        tm->tm_year += time1[3] & WM8350_RTC_YUNITS_MASK;
  77
  78                        tm->tm_yday = rtc_year_days(tm->tm_mday, tm->tm_mon,
  79                                                    tm->tm_year);
  80                        tm->tm_year -= 1900;
  81
  82                        dev_dbg(dev, "Read (%d left): %04x %04x %04x %04x\n",
  83                                retries,
  84                                time1[0], time1[1], time1[2], time1[3]);
  85
  86                        return 0;
  87                }
  88        } while (retries--);
  89
  90        dev_err(dev, "timed out reading RTC time\n");
  91        return -EIO;
  92}
  93
  94/*
  95 * Set current time and date in RTC
  96 */
  97static int wm8350_rtc_settime(struct device *dev, struct rtc_time *tm)
  98{
  99        struct wm8350 *wm8350 = dev_get_drvdata(dev);
 100        u16 time[4];
 101        u16 rtc_ctrl;
 102        int ret, retries = WM8350_SET_TIME_RETRIES;
 103
 104        time[0] = tm->tm_sec;
 105        time[0] |= tm->tm_min << WM8350_RTC_MINS_SHIFT;
 106        time[1] = tm->tm_hour;
 107        time[1] |= (tm->tm_wday + 1) << WM8350_RTC_DAY_SHIFT;
 108        time[2] = tm->tm_mday;
 109        time[2] |= (tm->tm_mon + 1) << WM8350_RTC_MTH_SHIFT;
 110        time[3] = ((tm->tm_year + 1900) / 100) << WM8350_RTC_YHUNDREDS_SHIFT;
 111        time[3] |= (tm->tm_year + 1900) % 100;
 112
 113        dev_dbg(dev, "Setting: %04x %04x %04x %04x\n",
 114                time[0], time[1], time[2], time[3]);
 115
 116        /* Set RTC_SET to stop the clock */
 117        ret = wm8350_set_bits(wm8350, WM8350_RTC_TIME_CONTROL, WM8350_RTC_SET);
 118        if (ret < 0)
 119                return ret;
 120
 121        /* Wait until confirmation of stopping */
 122        do {
 123                rtc_ctrl = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL);
 124                schedule_timeout_uninterruptible(msecs_to_jiffies(1));
 125        } while (--retries && !(rtc_ctrl & WM8350_RTC_STS));
 126
 127        if (!retries) {
 128                dev_err(dev, "timed out on set confirmation\n");
 129                return -EIO;
 130        }
 131
 132        /* Write time to RTC */
 133        ret = wm8350_block_write(wm8350, WM8350_RTC_SECONDS_MINUTES, 4, time);
 134        if (ret < 0)
 135                return ret;
 136
 137        /* Clear RTC_SET to start the clock */
 138        ret = wm8350_clear_bits(wm8350, WM8350_RTC_TIME_CONTROL,
 139                                WM8350_RTC_SET);
 140        return ret;
 141}
 142
 143/*
 144 * Read alarm time and date in RTC
 145 */
 146static int wm8350_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm)
 147{
 148        struct wm8350 *wm8350 = dev_get_drvdata(dev);
 149        struct rtc_time *tm = &alrm->time;
 150        u16 time[4];
 151        int ret;
 152
 153        ret = wm8350_block_read(wm8350, WM8350_ALARM_SECONDS_MINUTES, 4, time);
 154        if (ret < 0)
 155                return ret;
 156
 157        tm->tm_sec = time[0] & WM8350_RTC_ALMSECS_MASK;
 158        if (tm->tm_sec == WM8350_RTC_ALMSECS_MASK)
 159                tm->tm_sec = -1;
 160
 161        tm->tm_min = time[0] & WM8350_RTC_ALMMINS_MASK;
 162        if (tm->tm_min == WM8350_RTC_ALMMINS_MASK)
 163                tm->tm_min = -1;
 164        else
 165                tm->tm_min >>= WM8350_RTC_ALMMINS_SHIFT;
 166
 167        tm->tm_hour = time[1] & WM8350_RTC_ALMHRS_MASK;
 168        if (tm->tm_hour == WM8350_RTC_ALMHRS_MASK)
 169                tm->tm_hour = -1;
 170
 171        tm->tm_wday = ((time[1] >> WM8350_RTC_ALMDAY_SHIFT) & 0x7) - 1;
 172        if (tm->tm_wday > 7)
 173                tm->tm_wday = -1;
 174
 175        tm->tm_mon = time[2] & WM8350_RTC_ALMMTH_MASK;
 176        if (tm->tm_mon == WM8350_RTC_ALMMTH_MASK)
 177                tm->tm_mon = -1;
 178        else
 179                tm->tm_mon = (tm->tm_mon >> WM8350_RTC_ALMMTH_SHIFT) - 1;
 180
 181        tm->tm_mday = (time[2] & WM8350_RTC_ALMDATE_MASK);
 182        if (tm->tm_mday == WM8350_RTC_ALMDATE_MASK)
 183                tm->tm_mday = -1;
 184
 185        tm->tm_year = -1;
 186
 187        alrm->enabled = !(time[3] & WM8350_RTC_ALMSTS);
 188
 189        return 0;
 190}
 191
 192static int wm8350_rtc_stop_alarm(struct wm8350 *wm8350)
 193{
 194        int retries = WM8350_SET_ALM_RETRIES;
 195        u16 rtc_ctrl;
 196        int ret;
 197
 198        /* Set RTC_SET to stop the clock */
 199        ret = wm8350_set_bits(wm8350, WM8350_RTC_TIME_CONTROL,
 200                              WM8350_RTC_ALMSET);
 201        if (ret < 0)
 202                return ret;
 203
 204        /* Wait until confirmation of stopping */
 205        do {
 206                rtc_ctrl = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL);
 207                schedule_timeout_uninterruptible(msecs_to_jiffies(1));
 208        } while (retries-- && !(rtc_ctrl & WM8350_RTC_ALMSTS));
 209
 210        if (!(rtc_ctrl & WM8350_RTC_ALMSTS))
 211                return -ETIMEDOUT;
 212
 213        return 0;
 214}
 215
 216static int wm8350_rtc_start_alarm(struct wm8350 *wm8350)
 217{
 218        int ret;
 219        int retries = WM8350_SET_ALM_RETRIES;
 220        u16 rtc_ctrl;
 221
 222        ret = wm8350_clear_bits(wm8350, WM8350_RTC_TIME_CONTROL,
 223                                WM8350_RTC_ALMSET);
 224        if (ret < 0)
 225                return ret;
 226
 227        /* Wait until confirmation */
 228        do {
 229                rtc_ctrl = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL);
 230                schedule_timeout_uninterruptible(msecs_to_jiffies(1));
 231        } while (retries-- && rtc_ctrl & WM8350_RTC_ALMSTS);
 232
 233        if (rtc_ctrl & WM8350_RTC_ALMSTS)
 234                return -ETIMEDOUT;
 235
 236        return 0;
 237}
 238
 239static int wm8350_rtc_alarm_irq_enable(struct device *dev,
 240                                       unsigned int enabled)
 241{
 242        struct wm8350 *wm8350 = dev_get_drvdata(dev);
 243
 244        if (enabled)
 245                return wm8350_rtc_start_alarm(wm8350);
 246        else
 247                return wm8350_rtc_stop_alarm(wm8350);
 248}
 249
 250static int wm8350_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
 251{
 252        struct wm8350 *wm8350 = dev_get_drvdata(dev);
 253        struct rtc_time *tm = &alrm->time;
 254        u16 time[3];
 255        int ret;
 256
 257        memset(time, 0, sizeof(time));
 258
 259        if (tm->tm_sec != -1)
 260                time[0] |= tm->tm_sec;
 261        else
 262                time[0] |= WM8350_RTC_ALMSECS_MASK;
 263
 264        if (tm->tm_min != -1)
 265                time[0] |= tm->tm_min << WM8350_RTC_ALMMINS_SHIFT;
 266        else
 267                time[0] |= WM8350_RTC_ALMMINS_MASK;
 268
 269        if (tm->tm_hour != -1)
 270                time[1] |= tm->tm_hour;
 271        else
 272                time[1] |= WM8350_RTC_ALMHRS_MASK;
 273
 274        if (tm->tm_wday != -1)
 275                time[1] |= (tm->tm_wday + 1) << WM8350_RTC_ALMDAY_SHIFT;
 276        else
 277                time[1] |= WM8350_RTC_ALMDAY_MASK;
 278
 279        if (tm->tm_mday != -1)
 280                time[2] |= tm->tm_mday;
 281        else
 282                time[2] |= WM8350_RTC_ALMDATE_MASK;
 283
 284        if (tm->tm_mon != -1)
 285                time[2] |= (tm->tm_mon + 1) << WM8350_RTC_ALMMTH_SHIFT;
 286        else
 287                time[2] |= WM8350_RTC_ALMMTH_MASK;
 288
 289        ret = wm8350_rtc_stop_alarm(wm8350);
 290        if (ret < 0)
 291                return ret;
 292
 293        /* Write time to RTC */
 294        ret = wm8350_block_write(wm8350, WM8350_ALARM_SECONDS_MINUTES,
 295                                 3, time);
 296        if (ret < 0)
 297                return ret;
 298
 299        if (alrm->enabled)
 300                ret = wm8350_rtc_start_alarm(wm8350);
 301
 302        return ret;
 303}
 304
 305static irqreturn_t wm8350_rtc_alarm_handler(int irq, void *data)
 306{
 307        struct wm8350 *wm8350 = data;
 308        struct rtc_device *rtc = wm8350->rtc.rtc;
 309        int ret;
 310
 311        rtc_update_irq(rtc, 1, RTC_IRQF | RTC_AF);
 312
 313        /* Make it one shot */
 314        ret = wm8350_set_bits(wm8350, WM8350_RTC_TIME_CONTROL,
 315                              WM8350_RTC_ALMSET);
 316        if (ret != 0) {
 317                dev_err(&(wm8350->rtc.pdev->dev),
 318                        "Failed to disable alarm: %d\n", ret);
 319        }
 320
 321        return IRQ_HANDLED;
 322}
 323
 324static irqreturn_t wm8350_rtc_update_handler(int irq, void *data)
 325{
 326        struct wm8350 *wm8350 = data;
 327        struct rtc_device *rtc = wm8350->rtc.rtc;
 328
 329        rtc_update_irq(rtc, 1, RTC_IRQF | RTC_UF);
 330
 331        return IRQ_HANDLED;
 332}
 333
 334static const struct rtc_class_ops wm8350_rtc_ops = {
 335        .read_time = wm8350_rtc_readtime,
 336        .set_time = wm8350_rtc_settime,
 337        .read_alarm = wm8350_rtc_readalarm,
 338        .set_alarm = wm8350_rtc_setalarm,
 339        .alarm_irq_enable = wm8350_rtc_alarm_irq_enable,
 340};
 341
 342#ifdef CONFIG_PM
 343static int wm8350_rtc_suspend(struct device *dev)
 344{
 345        struct platform_device *pdev = to_platform_device(dev);
 346        struct wm8350 *wm8350 = dev_get_drvdata(&pdev->dev);
 347        int ret = 0;
 348        u16 reg;
 349
 350        reg = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL);
 351
 352        if (device_may_wakeup(&wm8350->rtc.pdev->dev) &&
 353            reg & WM8350_RTC_ALMSTS) {
 354                ret = wm8350_rtc_stop_alarm(wm8350);
 355                if (ret != 0)
 356                        dev_err(&pdev->dev, "Failed to stop RTC alarm: %d\n",
 357                                ret);
 358        }
 359
 360        return ret;
 361}
 362
 363static int wm8350_rtc_resume(struct device *dev)
 364{
 365        struct platform_device *pdev = to_platform_device(dev);
 366        struct wm8350 *wm8350 = dev_get_drvdata(&pdev->dev);
 367        int ret;
 368
 369        if (wm8350->rtc.alarm_enabled) {
 370                ret = wm8350_rtc_start_alarm(wm8350);
 371                if (ret != 0)
 372                        dev_err(&pdev->dev,
 373                                "Failed to restart RTC alarm: %d\n", ret);
 374        }
 375
 376        return 0;
 377}
 378
 379#else
 380#define wm8350_rtc_suspend NULL
 381#define wm8350_rtc_resume NULL
 382#endif
 383
 384static int wm8350_rtc_probe(struct platform_device *pdev)
 385{
 386        struct wm8350 *wm8350 = platform_get_drvdata(pdev);
 387        struct wm8350_rtc *wm_rtc = &wm8350->rtc;
 388        int ret = 0;
 389        u16 timectl, power5;
 390
 391        timectl = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL);
 392        if (timectl & WM8350_RTC_BCD) {
 393                dev_err(&pdev->dev, "RTC BCD mode not supported\n");
 394                return -EINVAL;
 395        }
 396        if (timectl & WM8350_RTC_12HR) {
 397                dev_err(&pdev->dev, "RTC 12 hour mode not supported\n");
 398                return -EINVAL;
 399        }
 400
 401        /* enable the RTC if it's not already enabled */
 402        power5 = wm8350_reg_read(wm8350, WM8350_POWER_MGMT_5);
 403        if (!(power5 &  WM8350_RTC_TICK_ENA)) {
 404                dev_info(wm8350->dev, "Starting RTC\n");
 405
 406                wm8350_reg_unlock(wm8350);
 407
 408                ret = wm8350_set_bits(wm8350, WM8350_POWER_MGMT_5,
 409                                      WM8350_RTC_TICK_ENA);
 410                if (ret < 0) {
 411                        dev_err(&pdev->dev, "failed to enable RTC: %d\n", ret);
 412                        return ret;
 413                }
 414
 415                wm8350_reg_lock(wm8350);
 416        }
 417
 418        if (timectl & WM8350_RTC_STS) {
 419                int retries;
 420
 421                ret = wm8350_clear_bits(wm8350, WM8350_RTC_TIME_CONTROL,
 422                                        WM8350_RTC_SET);
 423                if (ret < 0) {
 424                        dev_err(&pdev->dev, "failed to start: %d\n", ret);
 425                        return ret;
 426                }
 427
 428                retries = WM8350_SET_TIME_RETRIES;
 429                do {
 430                        timectl = wm8350_reg_read(wm8350,
 431                                                  WM8350_RTC_TIME_CONTROL);
 432                } while (timectl & WM8350_RTC_STS && --retries);
 433
 434                if (retries == 0) {
 435                        dev_err(&pdev->dev, "failed to start: timeout\n");
 436                        return -ENODEV;
 437                }
 438        }
 439
 440        device_init_wakeup(&pdev->dev, 1);
 441
 442        wm_rtc->rtc = rtc_device_register("wm8350", &pdev->dev,
 443                                          &wm8350_rtc_ops, THIS_MODULE);
 444        if (IS_ERR(wm_rtc->rtc)) {
 445                ret = PTR_ERR(wm_rtc->rtc);
 446                dev_err(&pdev->dev, "failed to register RTC: %d\n", ret);
 447                return ret;
 448        }
 449
 450        wm8350_register_irq(wm8350, WM8350_IRQ_RTC_SEC,
 451                            wm8350_rtc_update_handler, 0,
 452                            "RTC Seconds", wm8350);
 453        wm8350_mask_irq(wm8350, WM8350_IRQ_RTC_SEC);
 454
 455        wm8350_register_irq(wm8350, WM8350_IRQ_RTC_ALM,
 456                            wm8350_rtc_alarm_handler, 0,
 457                            "RTC Alarm", wm8350);
 458
 459        return 0;
 460}
 461
 462static int __devexit wm8350_rtc_remove(struct platform_device *pdev)
 463{
 464        struct wm8350 *wm8350 = platform_get_drvdata(pdev);
 465        struct wm8350_rtc *wm_rtc = &wm8350->rtc;
 466
 467        wm8350_free_irq(wm8350, WM8350_IRQ_RTC_SEC, wm8350);
 468        wm8350_free_irq(wm8350, WM8350_IRQ_RTC_ALM, wm8350);
 469
 470        rtc_device_unregister(wm_rtc->rtc);
 471
 472        return 0;
 473}
 474
 475static struct dev_pm_ops wm8350_rtc_pm_ops = {
 476        .suspend = wm8350_rtc_suspend,
 477        .resume = wm8350_rtc_resume,
 478};
 479
 480static struct platform_driver wm8350_rtc_driver = {
 481        .probe = wm8350_rtc_probe,
 482        .remove = __devexit_p(wm8350_rtc_remove),
 483        .driver = {
 484                .name = "wm8350-rtc",
 485                .pm = &wm8350_rtc_pm_ops,
 486        },
 487};
 488
 489module_platform_driver(wm8350_rtc_driver);
 490
 491MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
 492MODULE_DESCRIPTION("RTC driver for the WM8350");
 493MODULE_LICENSE("GPL");
 494MODULE_ALIAS("platform:wm8350-rtc");
 495
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.