drivers/rtc/rtc-mc13xxx.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Real Time Clock driver for Freescale MC13XXX PMIC
0004  *
0005  * (C) 2009 Sascha Hauer, Pengutronix
0006  * (C) 2009 Uwe Kleine-Koenig, Pengutronix
0007  */
0008
0009 #include <linux/mfd/mc13xxx.h>
0010 #include <linux/platform_device.h>
0011 #include <linux/kernel.h>
0012 #include <linux/module.h>
0013 #include <linux/mod_devicetable.h>
0014 #include <linux/slab.h>
0015 #include <linux/rtc.h>
0016
0017 #define DRIVER_NAME "mc13xxx-rtc"
0018
0019 #define MC13XXX_RTCTOD  20
0020 #define MC13XXX_RTCTODA 21
0021 #define MC13XXX_RTCDAY  22
0022 #define MC13XXX_RTCDAYA 23
0023
0024 #define SEC_PER_DAY (24 * 60 * 60)
0025
0026 struct mc13xxx_rtc {
0027     struct rtc_device *rtc;
0028     struct mc13xxx *mc13xxx;
0029     int valid;
0030 };
0031
0032 static int mc13xxx_rtc_irq_enable_unlocked(struct device *dev,
0033         unsigned int enabled, int irq)
0034 {
0035     struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
0036     int (*func)(struct mc13xxx *mc13xxx, int irq);
0037
0038     if (!priv->valid)
0039         return -ENODATA;
0040
0041     func = enabled ? mc13xxx_irq_unmask : mc13xxx_irq_mask;
0042     return func(priv->mc13xxx, irq);
0043 }
0044
0045 static int mc13xxx_rtc_alarm_irq_enable(struct device *dev,
0046                     unsigned int enabled)
0047 {
0048     struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
0049     int ret;
0050
0051     mc13xxx_lock(priv->mc13xxx);
0052
0053     ret = mc13xxx_rtc_irq_enable_unlocked(dev, enabled, MC13XXX_IRQ_TODA);
0054
0055     mc13xxx_unlock(priv->mc13xxx);
0056
0057     return ret;
0058 }
0059
0060 static int mc13xxx_rtc_read_time(struct device *dev, struct rtc_time *tm)
0061 {
0062     struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
0063     unsigned int seconds, days1, days2;
0064
0065     if (!priv->valid)
0066         return -ENODATA;
0067
0068     do {
0069         int ret;
0070
0071         ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days1);
0072         if (ret)
0073             return ret;
0074
0075         ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTOD, &seconds);
0076         if (ret)
0077             return ret;
0078
0079         ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days2);
0080         if (ret)
0081             return ret;
0082     } while (days1 != days2);
0083
0084     rtc_time64_to_tm((time64_t)days1 * SEC_PER_DAY + seconds, tm);
0085
0086     return 0;
0087 }
0088
0089 static int mc13xxx_rtc_set_time(struct device *dev, struct rtc_time *tm)
0090 {
0091     struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
0092     unsigned int seconds, days;
0093     unsigned int alarmseconds;
0094     int ret;
0095
0096     days = div_s64_rem(rtc_tm_to_time64(tm), SEC_PER_DAY, &seconds);
0097
0098     mc13xxx_lock(priv->mc13xxx);
0099
0100     /*
0101      * temporarily invalidate alarm to prevent triggering it when the day is
0102      * already updated while the time isn't yet.
0103      */
0104     ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTODA, &alarmseconds);
0105     if (unlikely(ret))
0106         goto out;
0107
0108     if (alarmseconds < SEC_PER_DAY) {
0109         ret = mc13xxx_reg_write(priv->mc13xxx,
0110                 MC13XXX_RTCTODA, 0x1ffff);
0111         if (unlikely(ret))
0112             goto out;
0113     }
0114
0115     /*
0116      * write seconds=0 to prevent a day switch between writing days
0117      * and seconds below
0118      */
0119     ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTOD, 0);
0120     if (unlikely(ret))
0121         goto out;
0122
0123     ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCDAY, days);
0124     if (unlikely(ret))
0125         goto out;
0126
0127     ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTOD, seconds);
0128     if (unlikely(ret))
0129         goto out;
0130
0131     /* restore alarm */
0132     if (alarmseconds < SEC_PER_DAY) {
0133         ret = mc13xxx_reg_write(priv->mc13xxx,
0134                 MC13XXX_RTCTODA, alarmseconds);
0135         if (unlikely(ret))
0136             goto out;
0137     }
0138
0139     if (!priv->valid) {
0140         ret = mc13xxx_irq_ack(priv->mc13xxx, MC13XXX_IRQ_RTCRST);
0141         if (unlikely(ret))
0142             goto out;
0143
0144         ret = mc13xxx_irq_unmask(priv->mc13xxx, MC13XXX_IRQ_RTCRST);
0145     }
0146
0147 out:
0148     priv->valid = !ret;
0149
0150     mc13xxx_unlock(priv->mc13xxx);
0151
0152     return ret;
0153 }
0154
0155 static int mc13xxx_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
0156 {
0157     struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
0158     unsigned int seconds, days;
0159     time64_t s1970;
0160     int enabled, pending;
0161     int ret;
0162
0163     mc13xxx_lock(priv->mc13xxx);
0164
0165     ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTODA, &seconds);
0166     if (unlikely(ret))
0167         goto out;
0168     if (seconds >= SEC_PER_DAY) {
0169         ret = -ENODATA;
0170         goto out;
0171     }
0172
0173     ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days);
0174     if (unlikely(ret))
0175         goto out;
0176
0177     ret = mc13xxx_irq_status(priv->mc13xxx, MC13XXX_IRQ_TODA,
0178             &enabled, &pending);
0179
0180 out:
0181     mc13xxx_unlock(priv->mc13xxx);
0182
0183     if (ret)
0184         return ret;
0185
0186     alarm->enabled = enabled;
0187     alarm->pending = pending;
0188
0189     s1970 = (time64_t)days * SEC_PER_DAY + seconds;
0190
0191     rtc_time64_to_tm(s1970, &alarm->time);
0192     dev_dbg(dev, "%s: %lld\n", __func__, (long long)s1970);
0193
0194     return 0;
0195 }
0196
0197 static int mc13xxx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
0198 {
0199     struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
0200     time64_t s1970;
0201     u32 seconds, days;
0202     int ret;
0203
0204     mc13xxx_lock(priv->mc13xxx);
0205
0206     /* disable alarm to prevent false triggering */
0207     ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTODA, 0x1ffff);
0208     if (unlikely(ret))
0209         goto out;
0210
0211     ret = mc13xxx_irq_ack(priv->mc13xxx, MC13XXX_IRQ_TODA);
0212     if (unlikely(ret))
0213         goto out;
0214
0215     s1970 = rtc_tm_to_time64(&alarm->time);
0216
0217     dev_dbg(dev, "%s: %s %lld\n", __func__, alarm->enabled ? "on" : "off",
0218             (long long)s1970);
0219
0220     ret = mc13xxx_rtc_irq_enable_unlocked(dev, alarm->enabled,
0221             MC13XXX_IRQ_TODA);
0222     if (unlikely(ret))
0223         goto out;
0224
0225     days = div_s64_rem(s1970, SEC_PER_DAY, &seconds);
0226
0227     ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCDAYA, days);
0228     if (unlikely(ret))
0229         goto out;
0230
0231     ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTODA, seconds);
0232
0233 out:
0234     mc13xxx_unlock(priv->mc13xxx);
0235
0236     return ret;
0237 }
0238
0239 static irqreturn_t mc13xxx_rtc_alarm_handler(int irq, void *dev)
0240 {
0241     struct mc13xxx_rtc *priv = dev;
0242     struct mc13xxx *mc13xxx = priv->mc13xxx;
0243
0244     rtc_update_irq(priv->rtc, 1, RTC_IRQF | RTC_AF);
0245
0246     mc13xxx_irq_ack(mc13xxx, irq);
0247
0248     return IRQ_HANDLED;
0249 }
0250
0251 static const struct rtc_class_ops mc13xxx_rtc_ops = {
0252     .read_time = mc13xxx_rtc_read_time,
0253     .set_time = mc13xxx_rtc_set_time,
0254     .read_alarm = mc13xxx_rtc_read_alarm,
0255     .set_alarm = mc13xxx_rtc_set_alarm,
0256     .alarm_irq_enable = mc13xxx_rtc_alarm_irq_enable,
0257 };
0258
0259 static irqreturn_t mc13xxx_rtc_reset_handler(int irq, void *dev)
0260 {
0261     struct mc13xxx_rtc *priv = dev;
0262     struct mc13xxx *mc13xxx = priv->mc13xxx;
0263
0264     priv->valid = 0;
0265
0266     mc13xxx_irq_mask(mc13xxx, irq);
0267
0268     return IRQ_HANDLED;
0269 }
0270
0271 static int __init mc13xxx_rtc_probe(struct platform_device *pdev)
0272 {
0273     int ret;
0274     struct mc13xxx_rtc *priv;
0275     struct mc13xxx *mc13xxx;
0276
0277     priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
0278     if (!priv)
0279         return -ENOMEM;
0280
0281     mc13xxx = dev_get_drvdata(pdev->dev.parent);
0282     priv->mc13xxx = mc13xxx;
0283     priv->valid = 1;
0284
0285     priv->rtc = devm_rtc_allocate_device(&pdev->dev);
0286     if (IS_ERR(priv->rtc))
0287         return PTR_ERR(priv->rtc);
0288     platform_set_drvdata(pdev, priv);
0289
0290     priv->rtc->ops = &mc13xxx_rtc_ops;
0291     /* 15bit days + hours, minutes, seconds */
0292     priv->rtc->range_max = (timeu64_t)(1 << 15) * SEC_PER_DAY - 1;
0293
0294     mc13xxx_lock(mc13xxx);
0295
0296     mc13xxx_irq_ack(mc13xxx, MC13XXX_IRQ_RTCRST);
0297
0298     ret = mc13xxx_irq_request(mc13xxx, MC13XXX_IRQ_RTCRST,
0299             mc13xxx_rtc_reset_handler, DRIVER_NAME, priv);
0300     if (ret)
0301         goto err_irq_request;
0302
0303     ret = mc13xxx_irq_request_nounmask(mc13xxx, MC13XXX_IRQ_TODA,
0304             mc13xxx_rtc_alarm_handler, DRIVER_NAME, priv);
0305     if (ret)
0306         goto err_irq_request;
0307
0308     mc13xxx_unlock(mc13xxx);
0309
0310     ret = devm_rtc_register_device(priv->rtc);
0311     if (ret) {
0312         mc13xxx_lock(mc13xxx);
0313         goto err_irq_request;
0314     }
0315
0316     return 0;
0317
0318 err_irq_request:
0319     mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_TODA, priv);
0320     mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_RTCRST, priv);
0321
0322     mc13xxx_unlock(mc13xxx);
0323
0324     return ret;
0325 }
0326
0327 static int mc13xxx_rtc_remove(struct platform_device *pdev)
0328 {
0329     struct mc13xxx_rtc *priv = platform_get_drvdata(pdev);
0330
0331     mc13xxx_lock(priv->mc13xxx);
0332
0333     mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_TODA, priv);
0334     mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_RTCRST, priv);
0335
0336     mc13xxx_unlock(priv->mc13xxx);
0337
0338     return 0;
0339 }
0340
0341 static const struct platform_device_id mc13xxx_rtc_idtable[] = {
0342     {
0343         .name = "mc13783-rtc",
0344     }, {
0345         .name = "mc13892-rtc",
0346     }, {
0347         .name = "mc34708-rtc",
0348     },
0349     { /* sentinel */ }
0350 };
0351 MODULE_DEVICE_TABLE(platform, mc13xxx_rtc_idtable);
0352
0353 static struct platform_driver mc13xxx_rtc_driver = {
0354     .id_table = mc13xxx_rtc_idtable,
0355     .remove = mc13xxx_rtc_remove,
0356     .driver = {
0357         .name = DRIVER_NAME,
0358     },
0359 };
0360
0361 module_platform_driver_probe(mc13xxx_rtc_driver, &mc13xxx_rtc_probe);
0362
0363 MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");
0364 MODULE_DESCRIPTION("RTC driver for Freescale MC13XXX PMIC");
0365 MODULE_LICENSE("GPL v2");