linux/drivers/rtc/rtc-da9055.c
<<
>>
Prefs
   1/*
   2 * Real time clock driver for DA9055
   3 *
   4 * Copyright(c) 2012 Dialog Semiconductor Ltd.
   5 *
   6 * Author: Dajun Dajun Chen <dajun.chen@diasemi.com>
   7 *
   8 * This program is free software; you can redistribute it and/or modify
   9 * it under the terms of the GNU General Public License as published by
  10 * the Free Software Foundation; either version 2 of the License, or
  11 * (at your option) any later version.
  12 *
  13 */
  14
  15#include <linux/module.h>
  16#include <linux/platform_device.h>
  17#include <linux/rtc.h>
  18
  19#include <linux/mfd/da9055/core.h>
  20#include <linux/mfd/da9055/reg.h>
  21#include <linux/mfd/da9055/pdata.h>
  22
  23struct da9055_rtc {
  24        struct rtc_device *rtc;
  25        struct da9055 *da9055;
  26        int alarm_enable;
  27};
  28
  29static int da9055_rtc_enable_alarm(struct da9055_rtc *rtc, bool enable)
  30{
  31        int ret;
  32        if (enable) {
  33                ret = da9055_reg_update(rtc->da9055, DA9055_REG_ALARM_Y,
  34                                        DA9055_RTC_ALM_EN,
  35                                        DA9055_RTC_ALM_EN);
  36                if (ret != 0)
  37                        dev_err(rtc->da9055->dev, "Failed to enable ALM: %d\n",
  38                                ret);
  39                rtc->alarm_enable = 1;
  40        } else {
  41                ret = da9055_reg_update(rtc->da9055, DA9055_REG_ALARM_Y,
  42                                        DA9055_RTC_ALM_EN, 0);
  43                if (ret != 0)
  44                        dev_err(rtc->da9055->dev,
  45                                "Failed to disable ALM: %d\n", ret);
  46                rtc->alarm_enable = 0;
  47        }
  48        return ret;
  49}
  50
  51static irqreturn_t da9055_rtc_alm_irq(int irq, void *data)
  52{
  53        struct da9055_rtc *rtc = data;
  54
  55        da9055_rtc_enable_alarm(rtc, 0);
  56        rtc_update_irq(rtc->rtc, 1, RTC_IRQF | RTC_AF);
  57
  58        return IRQ_HANDLED;
  59}
  60
  61static int da9055_read_alarm(struct da9055 *da9055, struct rtc_time *rtc_tm)
  62{
  63        int ret;
  64        uint8_t v[5];
  65
  66        ret = da9055_group_read(da9055, DA9055_REG_ALARM_MI, 5, v);
  67        if (ret != 0) {
  68                dev_err(da9055->dev, "Failed to group read ALM: %d\n", ret);
  69                return ret;
  70        }
  71
  72        rtc_tm->tm_year = (v[4] & DA9055_RTC_ALM_YEAR) + 100;
  73        rtc_tm->tm_mon  = (v[3] & DA9055_RTC_ALM_MONTH) - 1;
  74        rtc_tm->tm_mday = v[2] & DA9055_RTC_ALM_DAY;
  75        rtc_tm->tm_hour = v[1] & DA9055_RTC_ALM_HOUR;
  76        rtc_tm->tm_min  = v[0] & DA9055_RTC_ALM_MIN;
  77
  78        return rtc_valid_tm(rtc_tm);
  79}
  80
  81static int da9055_set_alarm(struct da9055 *da9055, struct rtc_time *rtc_tm)
  82{
  83        int ret;
  84        uint8_t v[2];
  85
  86        rtc_tm->tm_year -= 100;
  87        rtc_tm->tm_mon += 1;
  88
  89        ret = da9055_reg_update(da9055, DA9055_REG_ALARM_MI,
  90                                DA9055_RTC_ALM_MIN, rtc_tm->tm_min);
  91        if (ret != 0) {
  92                dev_err(da9055->dev, "Failed to write ALRM MIN: %d\n", ret);
  93                return ret;
  94        }
  95
  96        v[0] = rtc_tm->tm_hour;
  97        v[1] = rtc_tm->tm_mday;
  98
  99        ret = da9055_group_write(da9055, DA9055_REG_ALARM_H, 2, v);
 100        if (ret < 0)
 101                return ret;
 102
 103        ret = da9055_reg_update(da9055, DA9055_REG_ALARM_MO,
 104                                DA9055_RTC_ALM_MONTH, rtc_tm->tm_mon);
 105        if (ret < 0)
 106                dev_err(da9055->dev, "Failed to write ALM Month:%d\n", ret);
 107
 108        ret = da9055_reg_update(da9055, DA9055_REG_ALARM_Y,
 109                                DA9055_RTC_ALM_YEAR, rtc_tm->tm_year);
 110        if (ret < 0)
 111                dev_err(da9055->dev, "Failed to write ALM Year:%d\n", ret);
 112
 113        return ret;
 114}
 115
 116static int da9055_rtc_get_alarm_status(struct da9055 *da9055)
 117{
 118        int ret;
 119
 120        ret = da9055_reg_read(da9055, DA9055_REG_ALARM_Y);
 121        if (ret < 0) {
 122                dev_err(da9055->dev, "Failed to read ALM: %d\n", ret);
 123                return ret;
 124        }
 125        ret &= DA9055_RTC_ALM_EN;
 126        return (ret > 0) ? 1 : 0;
 127}
 128
 129static int da9055_rtc_read_time(struct device *dev, struct rtc_time *rtc_tm)
 130{
 131        struct da9055_rtc *rtc = dev_get_drvdata(dev);
 132        uint8_t v[6];
 133        int ret;
 134
 135        ret = da9055_reg_read(rtc->da9055, DA9055_REG_COUNT_S);
 136        if (ret < 0)
 137                return ret;
 138
 139        /*
 140         * Registers are only valid when RTC_READ
 141         * status bit is asserted
 142         */
 143        if (!(ret & DA9055_RTC_READ))
 144                return -EBUSY;
 145
 146        ret = da9055_group_read(rtc->da9055, DA9055_REG_COUNT_S, 6, v);
 147        if (ret < 0) {
 148                dev_err(rtc->da9055->dev, "Failed to read RTC time : %d\n",
 149                        ret);
 150                return ret;
 151        }
 152
 153        rtc_tm->tm_year = (v[5] & DA9055_RTC_YEAR) + 100;
 154        rtc_tm->tm_mon  = (v[4] & DA9055_RTC_MONTH) - 1;
 155        rtc_tm->tm_mday = v[3] & DA9055_RTC_DAY;
 156        rtc_tm->tm_hour = v[2] & DA9055_RTC_HOUR;
 157        rtc_tm->tm_min  = v[1] & DA9055_RTC_MIN;
 158        rtc_tm->tm_sec  = v[0] & DA9055_RTC_SEC;
 159
 160        return rtc_valid_tm(rtc_tm);
 161}
 162
 163static int da9055_rtc_set_time(struct device *dev, struct rtc_time *tm)
 164{
 165        struct da9055_rtc *rtc;
 166        uint8_t v[6];
 167
 168        rtc = dev_get_drvdata(dev);
 169
 170        v[0] = tm->tm_sec;
 171        v[1] = tm->tm_min;
 172        v[2] = tm->tm_hour;
 173        v[3] = tm->tm_mday;
 174        v[4] = tm->tm_mon + 1;
 175        v[5] = tm->tm_year - 100;
 176
 177        return da9055_group_write(rtc->da9055, DA9055_REG_COUNT_S, 6, v);
 178}
 179
 180static int da9055_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 181{
 182        int ret;
 183        struct rtc_time *tm = &alrm->time;
 184        struct da9055_rtc *rtc = dev_get_drvdata(dev);
 185
 186        ret = da9055_read_alarm(rtc->da9055, tm);
 187
 188        if (ret)
 189                return ret;
 190
 191        alrm->enabled = da9055_rtc_get_alarm_status(rtc->da9055);
 192
 193        return 0;
 194}
 195
 196static int da9055_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 197{
 198        int ret;
 199        struct rtc_time *tm = &alrm->time;
 200        struct da9055_rtc *rtc = dev_get_drvdata(dev);
 201
 202        ret = da9055_rtc_enable_alarm(rtc, 0);
 203        if (ret < 0)
 204                return ret;
 205
 206        ret = da9055_set_alarm(rtc->da9055, tm);
 207        if (ret)
 208                return ret;
 209
 210        ret = da9055_rtc_enable_alarm(rtc, 1);
 211
 212        return ret;
 213}
 214
 215static int da9055_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
 216{
 217        struct da9055_rtc *rtc = dev_get_drvdata(dev);
 218
 219        return da9055_rtc_enable_alarm(rtc, enabled);
 220}
 221
 222static const struct rtc_class_ops da9055_rtc_ops = {
 223        .read_time      = da9055_rtc_read_time,
 224        .set_time       = da9055_rtc_set_time,
 225        .read_alarm     = da9055_rtc_read_alarm,
 226        .set_alarm      = da9055_rtc_set_alarm,
 227        .alarm_irq_enable = da9055_rtc_alarm_irq_enable,
 228};
 229
 230static int da9055_rtc_device_init(struct da9055 *da9055,
 231                                        struct da9055_pdata *pdata)
 232{
 233        int ret;
 234
 235        /* Enable RTC and the internal Crystal */
 236        ret = da9055_reg_update(da9055, DA9055_REG_CONTROL_B,
 237                                DA9055_RTC_EN, DA9055_RTC_EN);
 238        if (ret < 0)
 239                return ret;
 240        ret = da9055_reg_update(da9055, DA9055_REG_EN_32K,
 241                                DA9055_CRYSTAL_EN, DA9055_CRYSTAL_EN);
 242        if (ret < 0)
 243                return ret;
 244
 245        /* Enable RTC in Power Down mode */
 246        ret = da9055_reg_update(da9055, DA9055_REG_CONTROL_B,
 247                                DA9055_RTC_MODE_PD, DA9055_RTC_MODE_PD);
 248        if (ret < 0)
 249                return ret;
 250
 251        /* Enable RTC in Reset mode */
 252        if (pdata && pdata->reset_enable) {
 253                ret = da9055_reg_update(da9055, DA9055_REG_CONTROL_B,
 254                                        DA9055_RTC_MODE_SD,
 255                                        DA9055_RTC_MODE_SD <<
 256                                        DA9055_RTC_MODE_SD_SHIFT);
 257                if (ret < 0)
 258                        return ret;
 259        }
 260
 261        /* Disable the RTC TICK ALM */
 262        ret = da9055_reg_update(da9055, DA9055_REG_ALARM_MO,
 263                                DA9055_RTC_TICK_WAKE_MASK, 0);
 264        if (ret < 0)
 265                return ret;
 266
 267        return 0;
 268}
 269
 270static int da9055_rtc_probe(struct platform_device *pdev)
 271{
 272        struct da9055_rtc *rtc;
 273        struct da9055_pdata *pdata = NULL;
 274        int ret, alm_irq;
 275
 276        rtc = devm_kzalloc(&pdev->dev, sizeof(struct da9055_rtc), GFP_KERNEL);
 277        if (!rtc)
 278                return -ENOMEM;
 279
 280        rtc->da9055 = dev_get_drvdata(pdev->dev.parent);
 281        pdata = rtc->da9055->dev->platform_data;
 282        platform_set_drvdata(pdev, rtc);
 283
 284        ret = da9055_rtc_device_init(rtc->da9055, pdata);
 285        if (ret < 0)
 286                goto err_rtc;
 287
 288        ret = da9055_reg_read(rtc->da9055, DA9055_REG_ALARM_Y);
 289        if (ret < 0)
 290                goto err_rtc;
 291
 292        if (ret & DA9055_RTC_ALM_EN)
 293                rtc->alarm_enable = 1;
 294
 295        device_init_wakeup(&pdev->dev, 1);
 296
 297        rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
 298                                        &da9055_rtc_ops, THIS_MODULE);
 299        if (IS_ERR(rtc->rtc)) {
 300                ret = PTR_ERR(rtc->rtc);
 301                goto err_rtc;
 302        }
 303
 304        alm_irq = platform_get_irq_byname(pdev, "ALM");
 305        alm_irq = regmap_irq_get_virq(rtc->da9055->irq_data, alm_irq);
 306        ret = devm_request_threaded_irq(&pdev->dev, alm_irq, NULL,
 307                                        da9055_rtc_alm_irq,
 308                                        IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
 309                                        "ALM", rtc);
 310        if (ret != 0)
 311                dev_err(rtc->da9055->dev, "irq registration failed: %d\n", ret);
 312
 313err_rtc:
 314        return ret;
 315
 316}
 317
 318static int da9055_rtc_remove(struct platform_device *pdev)
 319{
 320        platform_set_drvdata(pdev, NULL);
 321
 322        return 0;
 323}
 324
 325#ifdef CONFIG_PM
 326/* Turn off the alarm if it should not be a wake source. */
 327static int da9055_rtc_suspend(struct device *dev)
 328{
 329        struct platform_device *pdev = to_platform_device(dev);
 330        struct da9055_rtc *rtc = dev_get_drvdata(&pdev->dev);
 331        int ret;
 332
 333        if (!device_may_wakeup(&pdev->dev)) {
 334                /* Disable the ALM IRQ */
 335                ret = da9055_rtc_enable_alarm(rtc, 0);
 336                if (ret < 0)
 337                        dev_err(&pdev->dev, "Failed to disable RTC ALM\n");
 338        }
 339
 340        return 0;
 341}
 342
 343/* Enable the alarm if it should be enabled (in case it was disabled to
 344 * prevent use as a wake source).
 345 */
 346static int da9055_rtc_resume(struct device *dev)
 347{
 348        struct platform_device *pdev = to_platform_device(dev);
 349        struct da9055_rtc *rtc = dev_get_drvdata(&pdev->dev);
 350        int ret;
 351
 352        if (!device_may_wakeup(&pdev->dev)) {
 353                if (rtc->alarm_enable) {
 354                        ret = da9055_rtc_enable_alarm(rtc, 1);
 355                        if (ret < 0)
 356                                dev_err(&pdev->dev,
 357                                        "Failed to restart RTC ALM\n");
 358                }
 359        }
 360
 361        return 0;
 362}
 363
 364/* Unconditionally disable the alarm */
 365static int da9055_rtc_freeze(struct device *dev)
 366{
 367        struct platform_device *pdev = to_platform_device(dev);
 368        struct da9055_rtc *rtc = dev_get_drvdata(&pdev->dev);
 369        int ret;
 370
 371        ret = da9055_rtc_enable_alarm(rtc, 0);
 372        if (ret < 0)
 373                dev_err(&pdev->dev, "Failed to freeze RTC ALMs\n");
 374
 375        return 0;
 376
 377}
 378#else
 379#define da9055_rtc_suspend NULL
 380#define da9055_rtc_resume NULL
 381#define da9055_rtc_freeze NULL
 382#endif
 383
 384static const struct dev_pm_ops da9055_rtc_pm_ops = {
 385        .suspend = da9055_rtc_suspend,
 386        .resume = da9055_rtc_resume,
 387
 388        .freeze = da9055_rtc_freeze,
 389        .thaw = da9055_rtc_resume,
 390        .restore = da9055_rtc_resume,
 391
 392        .poweroff = da9055_rtc_suspend,
 393};
 394
 395static struct platform_driver da9055_rtc_driver = {
 396        .probe  = da9055_rtc_probe,
 397        .remove = da9055_rtc_remove,
 398        .driver = {
 399                .name   = "da9055-rtc",
 400                .owner  = THIS_MODULE,
 401                .pm = &da9055_rtc_pm_ops,
 402        },
 403};
 404
 405module_platform_driver(da9055_rtc_driver);
 406
 407MODULE_AUTHOR("David Dajun Chen <dchen@diasemi.com>");
 408MODULE_DESCRIPTION("RTC driver for Dialog DA9055 PMIC");
 409MODULE_LICENSE("GPL");
 410MODULE_ALIAS("platform:da9055-rtc");
 411
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.