1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * An rtc driver for the Dallas DS1553 4 * 5 * Copyright (C) 2006 Atsushi Nemoto <anemo@mba.ocn.ne.jp> 6 */ 7 8 #include <linux/bcd.h> 9 #include <linux/init.h> 10 #include <linux/kernel.h> 11 #include <linux/gfp.h> 12 #include <linux/delay.h> 13 #include <linux/jiffies.h> 14 #include <linux/interrupt.h> 15 #include <linux/rtc.h> 16 #include <linux/platform_device.h> 17 #include <linux/io.h> 18 #include <linux/module.h> 19 20 #define RTC_REG_SIZE 0x2000 21 #define RTC_OFFSET 0x1ff0 22 23 #define RTC_FLAGS (RTC_OFFSET + 0) 24 #define RTC_SECONDS_ALARM (RTC_OFFSET + 2) 25 #define RTC_MINUTES_ALARM (RTC_OFFSET + 3) 26 #define RTC_HOURS_ALARM (RTC_OFFSET + 4) 27 #define RTC_DATE_ALARM (RTC_OFFSET + 5) 28 #define RTC_INTERRUPTS (RTC_OFFSET + 6) 29 #define RTC_WATCHDOG (RTC_OFFSET + 7) 30 #define RTC_CONTROL (RTC_OFFSET + 8) 31 #define RTC_CENTURY (RTC_OFFSET + 8) 32 #define RTC_SECONDS (RTC_OFFSET + 9) 33 #define RTC_MINUTES (RTC_OFFSET + 10) 34 #define RTC_HOURS (RTC_OFFSET + 11) 35 #define RTC_DAY (RTC_OFFSET + 12) 36 #define RTC_DATE (RTC_OFFSET + 13) 37 #define RTC_MONTH (RTC_OFFSET + 14) 38 #define RTC_YEAR (RTC_OFFSET + 15) 39 40 #define RTC_CENTURY_MASK 0x3f 41 #define RTC_SECONDS_MASK 0x7f 42 #define RTC_DAY_MASK 0x07 43 44 /* Bits in the Control/Century register */ 45 #define RTC_WRITE 0x80 46 #define RTC_READ 0x40 47 48 /* Bits in the Seconds register */ 49 #define RTC_STOP 0x80 50 51 /* Bits in the Flags register */ 52 #define RTC_FLAGS_AF 0x40 53 #define RTC_FLAGS_BLF 0x10 54 55 /* Bits in the Interrupts register */ 56 #define RTC_INTS_AE 0x80 57 58 struct rtc_plat_data { 59 struct rtc_device *rtc; 60 void __iomem *ioaddr; 61 unsigned long last_jiffies; 62 int irq; 63 unsigned int irqen; 64 int alrm_sec; 65 int alrm_min; 66 int alrm_hour; 67 int alrm_mday; 68 spinlock_t lock; 69 }; 70 71 static int ds1553_rtc_set_time(struct device *dev, struct rtc_time *tm) 72 { 73 struct rtc_plat_data *pdata = dev_get_drvdata(dev); 74 void __iomem *ioaddr = pdata->ioaddr; 75 u8 century; 76 77 century = bin2bcd((tm->tm_year + 1900) / 100); 78 79 writeb(RTC_WRITE, pdata->ioaddr + RTC_CONTROL); 80 81 writeb(bin2bcd(tm->tm_year % 100), ioaddr + RTC_YEAR); 82 writeb(bin2bcd(tm->tm_mon + 1), ioaddr + RTC_MONTH); 83 writeb(bin2bcd(tm->tm_wday) & RTC_DAY_MASK, ioaddr + RTC_DAY); 84 writeb(bin2bcd(tm->tm_mday), ioaddr + RTC_DATE); 85 writeb(bin2bcd(tm->tm_hour), ioaddr + RTC_HOURS); 86 writeb(bin2bcd(tm->tm_min), ioaddr + RTC_MINUTES); 87 writeb(bin2bcd(tm->tm_sec) & RTC_SECONDS_MASK, ioaddr + RTC_SECONDS); 88 89 /* RTC_CENTURY and RTC_CONTROL share same register */ 90 writeb(RTC_WRITE | (century & RTC_CENTURY_MASK), ioaddr + RTC_CENTURY); 91 writeb(century & RTC_CENTURY_MASK, ioaddr + RTC_CONTROL); 92 return 0; 93 } 94 95 static int ds1553_rtc_read_time(struct device *dev, struct rtc_time *tm) 96 { 97 struct rtc_plat_data *pdata = dev_get_drvdata(dev); 98 void __iomem *ioaddr = pdata->ioaddr; 99 unsigned int year, month, day, hour, minute, second, week; 100 unsigned int century; 101 102 /* give enough time to update RTC in case of continuous read */ 103 if (pdata->last_jiffies == jiffies) 104 msleep(1); 105 pdata->last_jiffies = jiffies; 106 writeb(RTC_READ, ioaddr + RTC_CONTROL); 107 second = readb(ioaddr + RTC_SECONDS) & RTC_SECONDS_MASK; 108 minute = readb(ioaddr + RTC_MINUTES); 109 hour = readb(ioaddr + RTC_HOURS); 110 day = readb(ioaddr + RTC_DATE); 111 week = readb(ioaddr + RTC_DAY) & RTC_DAY_MASK; 112 month = readb(ioaddr + RTC_MONTH); 113 year = readb(ioaddr + RTC_YEAR); 114 century = readb(ioaddr + RTC_CENTURY) & RTC_CENTURY_MASK; 115 writeb(0, ioaddr + RTC_CONTROL); 116 tm->tm_sec = bcd2bin(second); 117 tm->tm_min = bcd2bin(minute); 118 tm->tm_hour = bcd2bin(hour); 119 tm->tm_mday = bcd2bin(day); 120 tm->tm_wday = bcd2bin(week); 121 tm->tm_mon = bcd2bin(month) - 1; 122 /* year is 1900 + tm->tm_year */ 123 tm->tm_year = bcd2bin(year) + bcd2bin(century) * 100 - 1900; 124 125 return 0; 126 } 127 128 static void ds1553_rtc_update_alarm(struct rtc_plat_data *pdata) 129 { 130 void __iomem *ioaddr = pdata->ioaddr; 131 unsigned long flags; 132 133 spin_lock_irqsave(&pdata->lock, flags); 134 writeb(pdata->alrm_mday < 0 || (pdata->irqen & RTC_UF) ? 135 0x80 : bin2bcd(pdata->alrm_mday), 136 ioaddr + RTC_DATE_ALARM); 137 writeb(pdata->alrm_hour < 0 || (pdata->irqen & RTC_UF) ? 138 0x80 : bin2bcd(pdata->alrm_hour), 139 ioaddr + RTC_HOURS_ALARM); 140 writeb(pdata->alrm_min < 0 || (pdata->irqen & RTC_UF) ? 141 0x80 : bin2bcd(pdata->alrm_min), 142 ioaddr + RTC_MINUTES_ALARM); 143 writeb(pdata->alrm_sec < 0 || (pdata->irqen & RTC_UF) ? 144 0x80 : bin2bcd(pdata->alrm_sec), 145 ioaddr + RTC_SECONDS_ALARM); 146 writeb(pdata->irqen ? RTC_INTS_AE : 0, ioaddr + RTC_INTERRUPTS); 147 readb(ioaddr + RTC_FLAGS); /* clear interrupts */ 148 spin_unlock_irqrestore(&pdata->lock, flags); 149 } 150 151 static int ds1553_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm) 152 { 153 struct rtc_plat_data *pdata = dev_get_drvdata(dev); 154 155 if (pdata->irq <= 0) 156 return -EINVAL; 157 pdata->alrm_mday = alrm->time.tm_mday; 158 pdata->alrm_hour = alrm->time.tm_hour; 159 pdata->alrm_min = alrm->time.tm_min; 160 pdata->alrm_sec = alrm->time.tm_sec; 161 if (alrm->enabled) 162 pdata->irqen |= RTC_AF; 163 ds1553_rtc_update_alarm(pdata); 164 return 0; 165 } 166 167 static int ds1553_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm) 168 { 169 struct rtc_plat_data *pdata = dev_get_drvdata(dev); 170 171 if (pdata->irq <= 0) 172 return -EINVAL; 173 alrm->time.tm_mday = pdata->alrm_mday < 0 ? 0 : pdata->alrm_mday; 174 alrm->time.tm_hour = pdata->alrm_hour < 0 ? 0 : pdata->alrm_hour; 175 alrm->time.tm_min = pdata->alrm_min < 0 ? 0 : pdata->alrm_min; 176 alrm->time.tm_sec = pdata->alrm_sec < 0 ? 0 : pdata->alrm_sec; 177 alrm->enabled = (pdata->irqen & RTC_AF) ? 1 : 0; 178 return 0; 179 } 180 181 static irqreturn_t ds1553_rtc_interrupt(int irq, void *dev_id) 182 { 183 struct platform_device *pdev = dev_id; 184 struct rtc_plat_data *pdata = platform_get_drvdata(pdev); 185 void __iomem *ioaddr = pdata->ioaddr; 186 unsigned long events = 0; 187 188 spin_lock(&pdata->lock); 189 /* read and clear interrupt */ 190 if (readb(ioaddr + RTC_FLAGS) & RTC_FLAGS_AF) { 191 events = RTC_IRQF; 192 if (readb(ioaddr + RTC_SECONDS_ALARM) & 0x80) 193 events |= RTC_UF; 194 else 195 events |= RTC_AF; 196 rtc_update_irq(pdata->rtc, 1, events); 197 } 198 spin_unlock(&pdata->lock); 199 return events ? IRQ_HANDLED : IRQ_NONE; 200 } 201 202 static int ds1553_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled) 203 { 204 struct rtc_plat_data *pdata = dev_get_drvdata(dev); 205 206 if (pdata->irq <= 0) 207 return -EINVAL; 208 if (enabled) 209 pdata->irqen |= RTC_AF; 210 else 211 pdata->irqen &= ~RTC_AF; 212 ds1553_rtc_update_alarm(pdata); 213 return 0; 214 } 215 216 static const struct rtc_class_ops ds1553_rtc_ops = { 217 .read_time = ds1553_rtc_read_time, 218 .set_time = ds1553_rtc_set_time, 219 .read_alarm = ds1553_rtc_read_alarm, 220 .set_alarm = ds1553_rtc_set_alarm, 221 .alarm_irq_enable = ds1553_rtc_alarm_irq_enable, 222 }; 223 224 static int ds1553_nvram_read(void *priv, unsigned int pos, void *val, 225 size_t bytes) 226 { 227 struct platform_device *pdev = priv; 228 struct rtc_plat_data *pdata = platform_get_drvdata(pdev); 229 void __iomem *ioaddr = pdata->ioaddr; 230 u8 *buf = val; 231 232 for (; bytes; bytes--) 233 *buf++ = readb(ioaddr + pos++); 234 return 0; 235 } 236 237 static int ds1553_nvram_write(void *priv, unsigned int pos, void *val, 238 size_t bytes) 239 { 240 struct platform_device *pdev = priv; 241 struct rtc_plat_data *pdata = platform_get_drvdata(pdev); 242 void __iomem *ioaddr = pdata->ioaddr; 243 u8 *buf = val; 244 245 for (; bytes; bytes--) 246 writeb(*buf++, ioaddr + pos++); 247 return 0; 248 } 249 250 static int ds1553_rtc_probe(struct platform_device *pdev) 251 { 252 unsigned int cen, sec; 253 struct rtc_plat_data *pdata; 254 void __iomem *ioaddr; 255 int ret = 0; 256 struct nvmem_config nvmem_cfg = { 257 .name = "ds1553_nvram", 258 .word_size = 1, 259 .stride = 1, 260 .size = RTC_OFFSET, 261 .reg_read = ds1553_nvram_read, 262 .reg_write = ds1553_nvram_write, 263 .priv = pdev, 264 }; 265 266 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); 267 if (!pdata) 268 return -ENOMEM; 269 270 ioaddr = devm_platform_ioremap_resource(pdev, 0); 271 if (IS_ERR(ioaddr)) 272 return PTR_ERR(ioaddr); 273 pdata->ioaddr = ioaddr; 274 pdata->irq = platform_get_irq(pdev, 0); 275 276 /* turn RTC on if it was not on */ 277 sec = readb(ioaddr + RTC_SECONDS); 278 if (sec & RTC_STOP) { 279 sec &= RTC_SECONDS_MASK; 280 cen = readb(ioaddr + RTC_CENTURY) & RTC_CENTURY_MASK; 281 writeb(RTC_WRITE, ioaddr + RTC_CONTROL); 282 writeb(sec, ioaddr + RTC_SECONDS); 283 writeb(cen & RTC_CENTURY_MASK, ioaddr + RTC_CONTROL); 284 } 285 if (readb(ioaddr + RTC_FLAGS) & RTC_FLAGS_BLF) 286 dev_warn(&pdev->dev, "voltage-low detected.\n"); 287 288 spin_lock_init(&pdata->lock); 289 pdata->last_jiffies = jiffies; 290 platform_set_drvdata(pdev, pdata); 291 292 pdata->rtc = devm_rtc_allocate_device(&pdev->dev); 293 if (IS_ERR(pdata->rtc)) 294 return PTR_ERR(pdata->rtc); 295 296 pdata->rtc->ops = &ds1553_rtc_ops; 297 pdata->rtc->nvram_old_abi = true; 298 299 ret = rtc_register_device(pdata->rtc); 300 if (ret) 301 return ret; 302 303 if (pdata->irq > 0) { 304 writeb(0, ioaddr + RTC_INTERRUPTS); 305 if (devm_request_irq(&pdev->dev, pdata->irq, 306 ds1553_rtc_interrupt, 307 0, pdev->name, pdev) < 0) { 308 dev_warn(&pdev->dev, "interrupt not available.\n"); 309 pdata->irq = 0; 310 } 311 } 312 313 if (rtc_nvmem_register(pdata->rtc, &nvmem_cfg)) 314 dev_err(&pdev->dev, "unable to register nvmem\n"); 315 316 return 0; 317 } 318 319 /* work with hotplug and coldplug */ 320 MODULE_ALIAS("platform:rtc-ds1553"); 321 322 static struct platform_driver ds1553_rtc_driver = { 323 .probe = ds1553_rtc_probe, 324 .driver = { 325 .name = "rtc-ds1553", 326 }, 327 }; 328 329 module_platform_driver(ds1553_rtc_driver); 330 331 MODULE_AUTHOR("Atsushi Nemoto <anemo@mba.ocn.ne.jp>"); 332 MODULE_DESCRIPTION("Dallas DS1553 RTC driver"); 333 MODULE_LICENSE("GPL"); 334