drivers/rtc/rtc-vt8500.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * drivers/rtc/rtc-vt8500.c
0004  *
0005  *  Copyright (C) 2010 Alexey Charkov <alchark@gmail.com>
0006  *
0007  * Based on rtc-pxa.c
0008  */
0009
0010 #include <linux/module.h>
0011 #include <linux/rtc.h>
0012 #include <linux/init.h>
0013 #include <linux/interrupt.h>
0014 #include <linux/io.h>
0015 #include <linux/bcd.h>
0016 #include <linux/platform_device.h>
0017 #include <linux/slab.h>
0018 #include <linux/of.h>
0019
0020 /*
0021  * Register definitions
0022  */
0023 #define VT8500_RTC_TS       0x00    /* Time set */
0024 #define VT8500_RTC_DS       0x04    /* Date set */
0025 #define VT8500_RTC_AS       0x08    /* Alarm set */
0026 #define VT8500_RTC_CR       0x0c    /* Control */
0027 #define VT8500_RTC_TR       0x10    /* Time read */
0028 #define VT8500_RTC_DR       0x14    /* Date read */
0029 #define VT8500_RTC_WS       0x18    /* Write status */
0030 #define VT8500_RTC_CL       0x20    /* Calibration */
0031 #define VT8500_RTC_IS       0x24    /* Interrupt status */
0032 #define VT8500_RTC_ST       0x28    /* Status */
0033
0034 #define INVALID_TIME_BIT    (1 << 31)
0035
0036 #define DATE_CENTURY_S      19
0037 #define DATE_YEAR_S     11
0038 #define DATE_YEAR_MASK      (0xff << DATE_YEAR_S)
0039 #define DATE_MONTH_S        6
0040 #define DATE_MONTH_MASK     (0x1f << DATE_MONTH_S)
0041 #define DATE_DAY_MASK       0x3f
0042
0043 #define TIME_DOW_S      20
0044 #define TIME_DOW_MASK       (0x07 << TIME_DOW_S)
0045 #define TIME_HOUR_S     14
0046 #define TIME_HOUR_MASK      (0x3f << TIME_HOUR_S)
0047 #define TIME_MIN_S      7
0048 #define TIME_MIN_MASK       (0x7f << TIME_MIN_S)
0049 #define TIME_SEC_MASK       0x7f
0050
0051 #define ALARM_DAY_S     20
0052 #define ALARM_DAY_MASK      (0x3f << ALARM_DAY_S)
0053
0054 #define ALARM_DAY_BIT       (1 << 29)
0055 #define ALARM_HOUR_BIT      (1 << 28)
0056 #define ALARM_MIN_BIT       (1 << 27)
0057 #define ALARM_SEC_BIT       (1 << 26)
0058
0059 #define ALARM_ENABLE_MASK   (ALARM_DAY_BIT \
0060                 | ALARM_HOUR_BIT \
0061                 | ALARM_MIN_BIT \
0062                 | ALARM_SEC_BIT)
0063
0064 #define VT8500_RTC_CR_ENABLE    (1 << 0)    /* Enable RTC */
0065 #define VT8500_RTC_CR_12H   (1 << 1)    /* 12h time format */
0066 #define VT8500_RTC_CR_SM_ENABLE (1 << 2)    /* Enable periodic irqs */
0067 #define VT8500_RTC_CR_SM_SEC    (1 << 3)    /* 0: 1Hz/60, 1: 1Hz */
0068 #define VT8500_RTC_CR_CALIB (1 << 4)    /* Enable calibration */
0069
0070 #define VT8500_RTC_IS_ALARM (1 << 0)    /* Alarm interrupt status */
0071
0072 struct vt8500_rtc {
0073     void __iomem        *regbase;
0074     int         irq_alarm;
0075     struct rtc_device   *rtc;
0076     spinlock_t      lock;       /* Protects this structure */
0077 };
0078
0079 static irqreturn_t vt8500_rtc_irq(int irq, void *dev_id)
0080 {
0081     struct vt8500_rtc *vt8500_rtc = dev_id;
0082     u32 isr;
0083     unsigned long events = 0;
0084
0085     spin_lock(&vt8500_rtc->lock);
0086
0087     /* clear interrupt sources */
0088     isr = readl(vt8500_rtc->regbase + VT8500_RTC_IS);
0089     writel(isr, vt8500_rtc->regbase + VT8500_RTC_IS);
0090
0091     spin_unlock(&vt8500_rtc->lock);
0092
0093     if (isr & VT8500_RTC_IS_ALARM)
0094         events |= RTC_AF | RTC_IRQF;
0095
0096     rtc_update_irq(vt8500_rtc->rtc, 1, events);
0097
0098     return IRQ_HANDLED;
0099 }
0100
0101 static int vt8500_rtc_read_time(struct device *dev, struct rtc_time *tm)
0102 {
0103     struct vt8500_rtc *vt8500_rtc = dev_get_drvdata(dev);
0104     u32 date, time;
0105
0106     date = readl(vt8500_rtc->regbase + VT8500_RTC_DR);
0107     time = readl(vt8500_rtc->regbase + VT8500_RTC_TR);
0108
0109     tm->tm_sec = bcd2bin(time & TIME_SEC_MASK);
0110     tm->tm_min = bcd2bin((time & TIME_MIN_MASK) >> TIME_MIN_S);
0111     tm->tm_hour = bcd2bin((time & TIME_HOUR_MASK) >> TIME_HOUR_S);
0112     tm->tm_mday = bcd2bin(date & DATE_DAY_MASK);
0113     tm->tm_mon = bcd2bin((date & DATE_MONTH_MASK) >> DATE_MONTH_S) - 1;
0114     tm->tm_year = bcd2bin((date & DATE_YEAR_MASK) >> DATE_YEAR_S)
0115             + ((date >> DATE_CENTURY_S) & 1 ? 200 : 100);
0116     tm->tm_wday = (time & TIME_DOW_MASK) >> TIME_DOW_S;
0117
0118     return 0;
0119 }
0120
0121 static int vt8500_rtc_set_time(struct device *dev, struct rtc_time *tm)
0122 {
0123     struct vt8500_rtc *vt8500_rtc = dev_get_drvdata(dev);
0124
0125     writel((bin2bcd(tm->tm_year % 100) << DATE_YEAR_S)
0126         | (bin2bcd(tm->tm_mon + 1) << DATE_MONTH_S)
0127         | (bin2bcd(tm->tm_mday))
0128         | ((tm->tm_year >= 200) << DATE_CENTURY_S),
0129         vt8500_rtc->regbase + VT8500_RTC_DS);
0130     writel((bin2bcd(tm->tm_wday) << TIME_DOW_S)
0131         | (bin2bcd(tm->tm_hour) << TIME_HOUR_S)
0132         | (bin2bcd(tm->tm_min) << TIME_MIN_S)
0133         | (bin2bcd(tm->tm_sec)),
0134         vt8500_rtc->regbase + VT8500_RTC_TS);
0135
0136     return 0;
0137 }
0138
0139 static int vt8500_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
0140 {
0141     struct vt8500_rtc *vt8500_rtc = dev_get_drvdata(dev);
0142     u32 isr, alarm;
0143
0144     alarm = readl(vt8500_rtc->regbase + VT8500_RTC_AS);
0145     isr = readl(vt8500_rtc->regbase + VT8500_RTC_IS);
0146
0147     alrm->time.tm_mday = bcd2bin((alarm & ALARM_DAY_MASK) >> ALARM_DAY_S);
0148     alrm->time.tm_hour = bcd2bin((alarm & TIME_HOUR_MASK) >> TIME_HOUR_S);
0149     alrm->time.tm_min = bcd2bin((alarm & TIME_MIN_MASK) >> TIME_MIN_S);
0150     alrm->time.tm_sec = bcd2bin((alarm & TIME_SEC_MASK));
0151
0152     alrm->enabled = (alarm & ALARM_ENABLE_MASK) ? 1 : 0;
0153     alrm->pending = (isr & VT8500_RTC_IS_ALARM) ? 1 : 0;
0154
0155     return rtc_valid_tm(&alrm->time);
0156 }
0157
0158 static int vt8500_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
0159 {
0160     struct vt8500_rtc *vt8500_rtc = dev_get_drvdata(dev);
0161
0162     writel((alrm->enabled ? ALARM_ENABLE_MASK : 0)
0163         | (bin2bcd(alrm->time.tm_mday) << ALARM_DAY_S)
0164         | (bin2bcd(alrm->time.tm_hour) << TIME_HOUR_S)
0165         | (bin2bcd(alrm->time.tm_min) << TIME_MIN_S)
0166         | (bin2bcd(alrm->time.tm_sec)),
0167         vt8500_rtc->regbase + VT8500_RTC_AS);
0168
0169     return 0;
0170 }
0171
0172 static int vt8500_alarm_irq_enable(struct device *dev, unsigned int enabled)
0173 {
0174     struct vt8500_rtc *vt8500_rtc = dev_get_drvdata(dev);
0175     unsigned long tmp = readl(vt8500_rtc->regbase + VT8500_RTC_AS);
0176
0177     if (enabled)
0178         tmp |= ALARM_ENABLE_MASK;
0179     else
0180         tmp &= ~ALARM_ENABLE_MASK;
0181
0182     writel(tmp, vt8500_rtc->regbase + VT8500_RTC_AS);
0183     return 0;
0184 }
0185
0186 static const struct rtc_class_ops vt8500_rtc_ops = {
0187     .read_time = vt8500_rtc_read_time,
0188     .set_time = vt8500_rtc_set_time,
0189     .read_alarm = vt8500_rtc_read_alarm,
0190     .set_alarm = vt8500_rtc_set_alarm,
0191     .alarm_irq_enable = vt8500_alarm_irq_enable,
0192 };
0193
0194 static int vt8500_rtc_probe(struct platform_device *pdev)
0195 {
0196     struct vt8500_rtc *vt8500_rtc;
0197     int ret;
0198
0199     vt8500_rtc = devm_kzalloc(&pdev->dev,
0200                sizeof(struct vt8500_rtc), GFP_KERNEL);
0201     if (!vt8500_rtc)
0202         return -ENOMEM;
0203
0204     spin_lock_init(&vt8500_rtc->lock);
0205     platform_set_drvdata(pdev, vt8500_rtc);
0206
0207     vt8500_rtc->irq_alarm = platform_get_irq(pdev, 0);
0208     if (vt8500_rtc->irq_alarm < 0)
0209         return vt8500_rtc->irq_alarm;
0210
0211     vt8500_rtc->regbase = devm_platform_ioremap_resource(pdev, 0);
0212     if (IS_ERR(vt8500_rtc->regbase))
0213         return PTR_ERR(vt8500_rtc->regbase);
0214
0215     /* Enable RTC and set it to 24-hour mode */
0216     writel(VT8500_RTC_CR_ENABLE,
0217            vt8500_rtc->regbase + VT8500_RTC_CR);
0218
0219     vt8500_rtc->rtc = devm_rtc_allocate_device(&pdev->dev);
0220     if (IS_ERR(vt8500_rtc->rtc))
0221         return PTR_ERR(vt8500_rtc->rtc);
0222
0223     vt8500_rtc->rtc->ops = &vt8500_rtc_ops;
0224     vt8500_rtc->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
0225     vt8500_rtc->rtc->range_max = RTC_TIMESTAMP_END_2199;
0226
0227     ret = devm_request_irq(&pdev->dev, vt8500_rtc->irq_alarm,
0228                 vt8500_rtc_irq, 0, "rtc alarm", vt8500_rtc);
0229     if (ret < 0) {
0230         dev_err(&pdev->dev, "can't get irq %i, err %d\n",
0231             vt8500_rtc->irq_alarm, ret);
0232         return ret;
0233     }
0234
0235     return devm_rtc_register_device(vt8500_rtc->rtc);
0236 }
0237
0238 static int vt8500_rtc_remove(struct platform_device *pdev)
0239 {
0240     struct vt8500_rtc *vt8500_rtc = platform_get_drvdata(pdev);
0241
0242     /* Disable alarm matching */
0243     writel(0, vt8500_rtc->regbase + VT8500_RTC_IS);
0244
0245     return 0;
0246 }
0247
0248 static const struct of_device_id wmt_dt_ids[] = {
0249     { .compatible = "via,vt8500-rtc", },
0250     {}
0251 };
0252 MODULE_DEVICE_TABLE(of, wmt_dt_ids);
0253
0254 static struct platform_driver vt8500_rtc_driver = {
0255     .probe      = vt8500_rtc_probe,
0256     .remove     = vt8500_rtc_remove,
0257     .driver     = {
0258         .name   = "vt8500-rtc",
0259         .of_match_table = wmt_dt_ids,
0260     },
0261 };
0262
0263 module_platform_driver(vt8500_rtc_driver);
0264
0265 MODULE_AUTHOR("Alexey Charkov <alchark@gmail.com>");
0266 MODULE_DESCRIPTION("VIA VT8500 SoC Realtime Clock Driver (RTC)");
0267 MODULE_LICENSE("GPL v2");
0268 MODULE_ALIAS("platform:vt8500-rtc");