drivers/rtc/rtc-ds1553.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * An rtc driver for the Dallas DS1553
0004  *
0005  * Copyright (C) 2006 Atsushi Nemoto <anemo@mba.ocn.ne.jp>
0006  */
0007
0008 #include <linux/bcd.h>
0009 #include <linux/init.h>
0010 #include <linux/kernel.h>
0011 #include <linux/gfp.h>
0012 #include <linux/delay.h>
0013 #include <linux/jiffies.h>
0014 #include <linux/interrupt.h>
0015 #include <linux/rtc.h>
0016 #include <linux/platform_device.h>
0017 #include <linux/io.h>
0018 #include <linux/module.h>
0019
0020 #define RTC_REG_SIZE        0x2000
0021 #define RTC_OFFSET      0x1ff0
0022
0023 #define RTC_FLAGS       (RTC_OFFSET + 0)
0024 #define RTC_SECONDS_ALARM   (RTC_OFFSET + 2)
0025 #define RTC_MINUTES_ALARM   (RTC_OFFSET + 3)
0026 #define RTC_HOURS_ALARM     (RTC_OFFSET + 4)
0027 #define RTC_DATE_ALARM      (RTC_OFFSET + 5)
0028 #define RTC_INTERRUPTS      (RTC_OFFSET + 6)
0029 #define RTC_WATCHDOG        (RTC_OFFSET + 7)
0030 #define RTC_CONTROL     (RTC_OFFSET + 8)
0031 #define RTC_CENTURY     (RTC_OFFSET + 8)
0032 #define RTC_SECONDS     (RTC_OFFSET + 9)
0033 #define RTC_MINUTES     (RTC_OFFSET + 10)
0034 #define RTC_HOURS       (RTC_OFFSET + 11)
0035 #define RTC_DAY         (RTC_OFFSET + 12)
0036 #define RTC_DATE        (RTC_OFFSET + 13)
0037 #define RTC_MONTH       (RTC_OFFSET + 14)
0038 #define RTC_YEAR        (RTC_OFFSET + 15)
0039
0040 #define RTC_CENTURY_MASK    0x3f
0041 #define RTC_SECONDS_MASK    0x7f
0042 #define RTC_DAY_MASK        0x07
0043
0044 /* Bits in the Control/Century register */
0045 #define RTC_WRITE       0x80
0046 #define RTC_READ        0x40
0047
0048 /* Bits in the Seconds register */
0049 #define RTC_STOP        0x80
0050
0051 /* Bits in the Flags register */
0052 #define RTC_FLAGS_AF        0x40
0053 #define RTC_FLAGS_BLF       0x10
0054
0055 /* Bits in the Interrupts register */
0056 #define RTC_INTS_AE     0x80
0057
0058 struct rtc_plat_data {
0059     struct rtc_device *rtc;
0060     void __iomem *ioaddr;
0061     unsigned long last_jiffies;
0062     int irq;
0063     unsigned int irqen;
0064     int alrm_sec;
0065     int alrm_min;
0066     int alrm_hour;
0067     int alrm_mday;
0068     spinlock_t lock;
0069 };
0070
0071 static int ds1553_rtc_set_time(struct device *dev, struct rtc_time *tm)
0072 {
0073     struct rtc_plat_data *pdata = dev_get_drvdata(dev);
0074     void __iomem *ioaddr = pdata->ioaddr;
0075     u8 century;
0076
0077     century = bin2bcd((tm->tm_year + 1900) / 100);
0078
0079     writeb(RTC_WRITE, pdata->ioaddr + RTC_CONTROL);
0080
0081     writeb(bin2bcd(tm->tm_year % 100), ioaddr + RTC_YEAR);
0082     writeb(bin2bcd(tm->tm_mon + 1), ioaddr + RTC_MONTH);
0083     writeb(bin2bcd(tm->tm_wday) & RTC_DAY_MASK, ioaddr + RTC_DAY);
0084     writeb(bin2bcd(tm->tm_mday), ioaddr + RTC_DATE);
0085     writeb(bin2bcd(tm->tm_hour), ioaddr + RTC_HOURS);
0086     writeb(bin2bcd(tm->tm_min), ioaddr + RTC_MINUTES);
0087     writeb(bin2bcd(tm->tm_sec) & RTC_SECONDS_MASK, ioaddr + RTC_SECONDS);
0088
0089     /* RTC_CENTURY and RTC_CONTROL share same register */
0090     writeb(RTC_WRITE | (century & RTC_CENTURY_MASK), ioaddr + RTC_CENTURY);
0091     writeb(century & RTC_CENTURY_MASK, ioaddr + RTC_CONTROL);
0092     return 0;
0093 }
0094
0095 static int ds1553_rtc_read_time(struct device *dev, struct rtc_time *tm)
0096 {
0097     struct rtc_plat_data *pdata = dev_get_drvdata(dev);
0098     void __iomem *ioaddr = pdata->ioaddr;
0099     unsigned int year, month, day, hour, minute, second, week;
0100     unsigned int century;
0101
0102     /* give enough time to update RTC in case of continuous read */
0103     if (pdata->last_jiffies == jiffies)
0104         msleep(1);
0105     pdata->last_jiffies = jiffies;
0106     writeb(RTC_READ, ioaddr + RTC_CONTROL);
0107     second = readb(ioaddr + RTC_SECONDS) & RTC_SECONDS_MASK;
0108     minute = readb(ioaddr + RTC_MINUTES);
0109     hour = readb(ioaddr + RTC_HOURS);
0110     day = readb(ioaddr + RTC_DATE);
0111     week = readb(ioaddr + RTC_DAY) & RTC_DAY_MASK;
0112     month = readb(ioaddr + RTC_MONTH);
0113     year = readb(ioaddr + RTC_YEAR);
0114     century = readb(ioaddr + RTC_CENTURY) & RTC_CENTURY_MASK;
0115     writeb(0, ioaddr + RTC_CONTROL);
0116     tm->tm_sec = bcd2bin(second);
0117     tm->tm_min = bcd2bin(minute);
0118     tm->tm_hour = bcd2bin(hour);
0119     tm->tm_mday = bcd2bin(day);
0120     tm->tm_wday = bcd2bin(week);
0121     tm->tm_mon = bcd2bin(month) - 1;
0122     /* year is 1900 + tm->tm_year */
0123     tm->tm_year = bcd2bin(year) + bcd2bin(century) * 100 - 1900;
0124
0125     return 0;
0126 }
0127
0128 static void ds1553_rtc_update_alarm(struct rtc_plat_data *pdata)
0129 {
0130     void __iomem *ioaddr = pdata->ioaddr;
0131     unsigned long flags;
0132
0133     spin_lock_irqsave(&pdata->lock, flags);
0134     writeb(pdata->alrm_mday < 0 || (pdata->irqen & RTC_UF) ?
0135            0x80 : bin2bcd(pdata->alrm_mday),
0136            ioaddr + RTC_DATE_ALARM);
0137     writeb(pdata->alrm_hour < 0 || (pdata->irqen & RTC_UF) ?
0138            0x80 : bin2bcd(pdata->alrm_hour),
0139            ioaddr + RTC_HOURS_ALARM);
0140     writeb(pdata->alrm_min < 0 || (pdata->irqen & RTC_UF) ?
0141            0x80 : bin2bcd(pdata->alrm_min),
0142            ioaddr + RTC_MINUTES_ALARM);
0143     writeb(pdata->alrm_sec < 0 || (pdata->irqen & RTC_UF) ?
0144            0x80 : bin2bcd(pdata->alrm_sec),
0145            ioaddr + RTC_SECONDS_ALARM);
0146     writeb(pdata->irqen ? RTC_INTS_AE : 0, ioaddr + RTC_INTERRUPTS);
0147     readb(ioaddr + RTC_FLAGS);  /* clear interrupts */
0148     spin_unlock_irqrestore(&pdata->lock, flags);
0149 }
0150
0151 static int ds1553_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
0152 {
0153     struct rtc_plat_data *pdata = dev_get_drvdata(dev);
0154
0155     if (pdata->irq <= 0)
0156         return -EINVAL;
0157     pdata->alrm_mday = alrm->time.tm_mday;
0158     pdata->alrm_hour = alrm->time.tm_hour;
0159     pdata->alrm_min = alrm->time.tm_min;
0160     pdata->alrm_sec = alrm->time.tm_sec;
0161     if (alrm->enabled)
0162         pdata->irqen |= RTC_AF;
0163     ds1553_rtc_update_alarm(pdata);
0164     return 0;
0165 }
0166
0167 static int ds1553_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
0168 {
0169     struct rtc_plat_data *pdata = dev_get_drvdata(dev);
0170
0171     if (pdata->irq <= 0)
0172         return -EINVAL;
0173     alrm->time.tm_mday = pdata->alrm_mday < 0 ? 0 : pdata->alrm_mday;
0174     alrm->time.tm_hour = pdata->alrm_hour < 0 ? 0 : pdata->alrm_hour;
0175     alrm->time.tm_min = pdata->alrm_min < 0 ? 0 : pdata->alrm_min;
0176     alrm->time.tm_sec = pdata->alrm_sec < 0 ? 0 : pdata->alrm_sec;
0177     alrm->enabled = (pdata->irqen & RTC_AF) ? 1 : 0;
0178     return 0;
0179 }
0180
0181 static irqreturn_t ds1553_rtc_interrupt(int irq, void *dev_id)
0182 {
0183     struct platform_device *pdev = dev_id;
0184     struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
0185     void __iomem *ioaddr = pdata->ioaddr;
0186     unsigned long events = 0;
0187
0188     spin_lock(&pdata->lock);
0189     /* read and clear interrupt */
0190     if (readb(ioaddr + RTC_FLAGS) & RTC_FLAGS_AF) {
0191         events = RTC_IRQF;
0192         if (readb(ioaddr + RTC_SECONDS_ALARM) & 0x80)
0193             events |= RTC_UF;
0194         else
0195             events |= RTC_AF;
0196         rtc_update_irq(pdata->rtc, 1, events);
0197     }
0198     spin_unlock(&pdata->lock);
0199     return events ? IRQ_HANDLED : IRQ_NONE;
0200 }
0201
0202 static int ds1553_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
0203 {
0204     struct rtc_plat_data *pdata = dev_get_drvdata(dev);
0205
0206     if (pdata->irq <= 0)
0207         return -EINVAL;
0208     if (enabled)
0209         pdata->irqen |= RTC_AF;
0210     else
0211         pdata->irqen &= ~RTC_AF;
0212     ds1553_rtc_update_alarm(pdata);
0213     return 0;
0214 }
0215
0216 static const struct rtc_class_ops ds1553_rtc_ops = {
0217     .read_time      = ds1553_rtc_read_time,
0218     .set_time       = ds1553_rtc_set_time,
0219     .read_alarm     = ds1553_rtc_read_alarm,
0220     .set_alarm      = ds1553_rtc_set_alarm,
0221     .alarm_irq_enable   = ds1553_rtc_alarm_irq_enable,
0222 };
0223
0224 static int ds1553_nvram_read(void *priv, unsigned int pos, void *val,
0225                  size_t bytes)
0226 {
0227     struct platform_device *pdev = priv;
0228     struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
0229     void __iomem *ioaddr = pdata->ioaddr;
0230     u8 *buf = val;
0231
0232     for (; bytes; bytes--)
0233         *buf++ = readb(ioaddr + pos++);
0234     return 0;
0235 }
0236
0237 static int ds1553_nvram_write(void *priv, unsigned int pos, void *val,
0238                   size_t bytes)
0239 {
0240     struct platform_device *pdev = priv;
0241     struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
0242     void __iomem *ioaddr = pdata->ioaddr;
0243     u8 *buf = val;
0244
0245     for (; bytes; bytes--)
0246         writeb(*buf++, ioaddr + pos++);
0247     return 0;
0248 }
0249
0250 static int ds1553_rtc_probe(struct platform_device *pdev)
0251 {
0252     unsigned int cen, sec;
0253     struct rtc_plat_data *pdata;
0254     void __iomem *ioaddr;
0255     int ret = 0;
0256     struct nvmem_config nvmem_cfg = {
0257         .name = "ds1553_nvram",
0258         .word_size = 1,
0259         .stride = 1,
0260         .size = RTC_OFFSET,
0261         .reg_read = ds1553_nvram_read,
0262         .reg_write = ds1553_nvram_write,
0263         .priv = pdev,
0264     };
0265
0266     pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
0267     if (!pdata)
0268         return -ENOMEM;
0269
0270     ioaddr = devm_platform_ioremap_resource(pdev, 0);
0271     if (IS_ERR(ioaddr))
0272         return PTR_ERR(ioaddr);
0273     pdata->ioaddr = ioaddr;
0274     pdata->irq = platform_get_irq(pdev, 0);
0275
0276     /* turn RTC on if it was not on */
0277     sec = readb(ioaddr + RTC_SECONDS);
0278     if (sec & RTC_STOP) {
0279         sec &= RTC_SECONDS_MASK;
0280         cen = readb(ioaddr + RTC_CENTURY) & RTC_CENTURY_MASK;
0281         writeb(RTC_WRITE, ioaddr + RTC_CONTROL);
0282         writeb(sec, ioaddr + RTC_SECONDS);
0283         writeb(cen & RTC_CENTURY_MASK, ioaddr + RTC_CONTROL);
0284     }
0285     if (readb(ioaddr + RTC_FLAGS) & RTC_FLAGS_BLF)
0286         dev_warn(&pdev->dev, "voltage-low detected.\n");
0287
0288     spin_lock_init(&pdata->lock);
0289     pdata->last_jiffies = jiffies;
0290     platform_set_drvdata(pdev, pdata);
0291
0292     pdata->rtc = devm_rtc_allocate_device(&pdev->dev);
0293     if (IS_ERR(pdata->rtc))
0294         return PTR_ERR(pdata->rtc);
0295
0296     pdata->rtc->ops = &ds1553_rtc_ops;
0297
0298     ret = devm_rtc_register_device(pdata->rtc);
0299     if (ret)
0300         return ret;
0301
0302     if (pdata->irq > 0) {
0303         writeb(0, ioaddr + RTC_INTERRUPTS);
0304         if (devm_request_irq(&pdev->dev, pdata->irq,
0305                 ds1553_rtc_interrupt,
0306                 0, pdev->name, pdev) < 0) {
0307             dev_warn(&pdev->dev, "interrupt not available.\n");
0308             pdata->irq = 0;
0309         }
0310     }
0311
0312     devm_rtc_nvmem_register(pdata->rtc, &nvmem_cfg);
0313
0314     return 0;
0315 }
0316
0317 /* work with hotplug and coldplug */
0318 MODULE_ALIAS("platform:rtc-ds1553");
0319
0320 static struct platform_driver ds1553_rtc_driver = {
0321     .probe      = ds1553_rtc_probe,
0322     .driver     = {
0323         .name   = "rtc-ds1553",
0324     },
0325 };
0326
0327 module_platform_driver(ds1553_rtc_driver);
0328
0329 MODULE_AUTHOR("Atsushi Nemoto <anemo@mba.ocn.ne.jp>");
0330 MODULE_DESCRIPTION("Dallas DS1553 RTC driver");
0331 MODULE_LICENSE("GPL");