1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Real Time Clock driver for Freescale MC13XXX PMIC 4 * 5 * (C) 2009 Sascha Hauer, Pengutronix 6 * (C) 2009 Uwe Kleine-Koenig, Pengutronix 7 */ 8 9 #include <linux/mfd/mc13xxx.h> 10 #include <linux/platform_device.h> 11 #include <linux/kernel.h> 12 #include <linux/module.h> 13 #include <linux/slab.h> 14 #include <linux/rtc.h> 15 16 #define DRIVER_NAME "mc13xxx-rtc" 17 18 #define MC13XXX_RTCTOD 20 19 #define MC13XXX_RTCTODA 21 20 #define MC13XXX_RTCDAY 22 21 #define MC13XXX_RTCDAYA 23 22 23 #define SEC_PER_DAY (24 * 60 * 60) 24 25 struct mc13xxx_rtc { 26 struct rtc_device *rtc; 27 struct mc13xxx *mc13xxx; 28 int valid; 29 }; 30 31 static int mc13xxx_rtc_irq_enable_unlocked(struct device *dev, 32 unsigned int enabled, int irq) 33 { 34 struct mc13xxx_rtc *priv = dev_get_drvdata(dev); 35 int (*func)(struct mc13xxx *mc13xxx, int irq); 36 37 if (!priv->valid) 38 return -ENODATA; 39 40 func = enabled ? mc13xxx_irq_unmask : mc13xxx_irq_mask; 41 return func(priv->mc13xxx, irq); 42 } 43 44 static int mc13xxx_rtc_alarm_irq_enable(struct device *dev, 45 unsigned int enabled) 46 { 47 struct mc13xxx_rtc *priv = dev_get_drvdata(dev); 48 int ret; 49 50 mc13xxx_lock(priv->mc13xxx); 51 52 ret = mc13xxx_rtc_irq_enable_unlocked(dev, enabled, MC13XXX_IRQ_TODA); 53 54 mc13xxx_unlock(priv->mc13xxx); 55 56 return ret; 57 } 58 59 static int mc13xxx_rtc_read_time(struct device *dev, struct rtc_time *tm) 60 { 61 struct mc13xxx_rtc *priv = dev_get_drvdata(dev); 62 unsigned int seconds, days1, days2; 63 64 if (!priv->valid) 65 return -ENODATA; 66 67 do { 68 int ret; 69 70 ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days1); 71 if (ret) 72 return ret; 73 74 ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTOD, &seconds); 75 if (ret) 76 return ret; 77 78 ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days2); 79 if (ret) 80 return ret; 81 } while (days1 != days2); 82 83 rtc_time64_to_tm((time64_t)days1 * SEC_PER_DAY + seconds, tm); 84 85 return 0; 86 } 87 88 static int mc13xxx_rtc_set_time(struct device *dev, struct rtc_time *tm) 89 { 90 struct mc13xxx_rtc *priv = dev_get_drvdata(dev); 91 unsigned int seconds, days; 92 unsigned int alarmseconds; 93 int ret; 94 95 days = div_s64_rem(rtc_tm_to_time64(tm), SEC_PER_DAY, &seconds); 96 97 mc13xxx_lock(priv->mc13xxx); 98 99 /* 100 * temporarily invalidate alarm to prevent triggering it when the day is 101 * already updated while the time isn't yet. 102 */ 103 ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTODA, &alarmseconds); 104 if (unlikely(ret)) 105 goto out; 106 107 if (alarmseconds < SEC_PER_DAY) { 108 ret = mc13xxx_reg_write(priv->mc13xxx, 109 MC13XXX_RTCTODA, 0x1ffff); 110 if (unlikely(ret)) 111 goto out; 112 } 113 114 /* 115 * write seconds=0 to prevent a day switch between writing days 116 * and seconds below 117 */ 118 ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTOD, 0); 119 if (unlikely(ret)) 120 goto out; 121 122 ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCDAY, days); 123 if (unlikely(ret)) 124 goto out; 125 126 ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTOD, seconds); 127 if (unlikely(ret)) 128 goto out; 129 130 /* restore alarm */ 131 if (alarmseconds < SEC_PER_DAY) { 132 ret = mc13xxx_reg_write(priv->mc13xxx, 133 MC13XXX_RTCTODA, alarmseconds); 134 if (unlikely(ret)) 135 goto out; 136 } 137 138 if (!priv->valid) { 139 ret = mc13xxx_irq_unmask(priv->mc13xxx, MC13XXX_IRQ_RTCRST); 140 } 141 142 out: 143 priv->valid = !ret; 144 145 mc13xxx_unlock(priv->mc13xxx); 146 147 return ret; 148 } 149 150 static int mc13xxx_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm) 151 { 152 struct mc13xxx_rtc *priv = dev_get_drvdata(dev); 153 unsigned int seconds, days; 154 time64_t s1970; 155 int enabled, pending; 156 int ret; 157 158 mc13xxx_lock(priv->mc13xxx); 159 160 ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTODA, &seconds); 161 if (unlikely(ret)) 162 goto out; 163 if (seconds >= SEC_PER_DAY) { 164 ret = -ENODATA; 165 goto out; 166 } 167 168 ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days); 169 if (unlikely(ret)) 170 goto out; 171 172 ret = mc13xxx_irq_status(priv->mc13xxx, MC13XXX_IRQ_TODA, 173 &enabled, &pending); 174 175 out: 176 mc13xxx_unlock(priv->mc13xxx); 177 178 if (ret) 179 return ret; 180 181 alarm->enabled = enabled; 182 alarm->pending = pending; 183 184 s1970 = (time64_t)days * SEC_PER_DAY + seconds; 185 186 rtc_time64_to_tm(s1970, &alarm->time); 187 dev_dbg(dev, "%s: %lld\n", __func__, (long long)s1970); 188 189 return 0; 190 } 191 192 static int mc13xxx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm) 193 { 194 struct mc13xxx_rtc *priv = dev_get_drvdata(dev); 195 time64_t s1970; 196 u32 seconds, days; 197 int ret; 198 199 mc13xxx_lock(priv->mc13xxx); 200 201 /* disable alarm to prevent false triggering */ 202 ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTODA, 0x1ffff); 203 if (unlikely(ret)) 204 goto out; 205 206 s1970 = rtc_tm_to_time64(&alarm->time); 207 208 dev_dbg(dev, "%s: %s %lld\n", __func__, alarm->enabled ? "on" : "off", 209 (long long)s1970); 210 211 ret = mc13xxx_rtc_irq_enable_unlocked(dev, alarm->enabled, 212 MC13XXX_IRQ_TODA); 213 if (unlikely(ret)) 214 goto out; 215 216 days = div_s64_rem(s1970, SEC_PER_DAY, &seconds); 217 218 ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCDAYA, days); 219 if (unlikely(ret)) 220 goto out; 221 222 ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTODA, seconds); 223 224 out: 225 mc13xxx_unlock(priv->mc13xxx); 226 227 return ret; 228 } 229 230 static irqreturn_t mc13xxx_rtc_alarm_handler(int irq, void *dev) 231 { 232 struct mc13xxx_rtc *priv = dev; 233 234 rtc_update_irq(priv->rtc, 1, RTC_IRQF | RTC_AF); 235 236 return IRQ_HANDLED; 237 } 238 239 static const struct rtc_class_ops mc13xxx_rtc_ops = { 240 .read_time = mc13xxx_rtc_read_time, 241 .set_time = mc13xxx_rtc_set_time, 242 .read_alarm = mc13xxx_rtc_read_alarm, 243 .set_alarm = mc13xxx_rtc_set_alarm, 244 .alarm_irq_enable = mc13xxx_rtc_alarm_irq_enable, 245 }; 246 247 static irqreturn_t mc13xxx_rtc_reset_handler(int irq, void *dev) 248 { 249 struct mc13xxx_rtc *priv = dev; 250 struct mc13xxx *mc13xxx = priv->mc13xxx; 251 252 priv->valid = 0; 253 254 mc13xxx_irq_mask(mc13xxx, irq); 255 256 return IRQ_HANDLED; 257 } 258 259 static int __init mc13xxx_rtc_probe(struct platform_device *pdev) 260 { 261 int ret; 262 struct mc13xxx_rtc *priv; 263 struct mc13xxx *mc13xxx; 264 265 priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); 266 if (!priv) 267 return -ENOMEM; 268 269 mc13xxx = dev_get_drvdata(pdev->dev.parent); 270 priv->mc13xxx = mc13xxx; 271 priv->valid = 1; 272 273 priv->rtc = devm_rtc_allocate_device(&pdev->dev); 274 if (IS_ERR(priv->rtc)) 275 return PTR_ERR(priv->rtc); 276 platform_set_drvdata(pdev, priv); 277 278 priv->rtc->ops = &mc13xxx_rtc_ops; 279 /* 15bit days + hours, minutes, seconds */ 280 priv->rtc->range_max = (timeu64_t)(1 << 15) * SEC_PER_DAY - 1; 281 282 mc13xxx_lock(mc13xxx); 283 284 ret = mc13xxx_irq_request(mc13xxx, MC13XXX_IRQ_RTCRST, 285 mc13xxx_rtc_reset_handler, DRIVER_NAME, priv); 286 if (ret) 287 goto err_irq_request; 288 289 ret = mc13xxx_irq_request_nounmask(mc13xxx, MC13XXX_IRQ_TODA, 290 mc13xxx_rtc_alarm_handler, DRIVER_NAME, priv); 291 if (ret) 292 goto err_irq_request; 293 294 mc13xxx_unlock(mc13xxx); 295 296 ret = devm_rtc_register_device(priv->rtc); 297 if (ret) { 298 mc13xxx_lock(mc13xxx); 299 goto err_irq_request; 300 } 301 302 return 0; 303 304 err_irq_request: 305 mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_TODA, priv); 306 mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_RTCRST, priv); 307 308 mc13xxx_unlock(mc13xxx); 309 310 return ret; 311 } 312 313 static void mc13xxx_rtc_remove(struct platform_device *pdev) 314 { 315 struct mc13xxx_rtc *priv = platform_get_drvdata(pdev); 316 317 mc13xxx_lock(priv->mc13xxx); 318 319 mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_TODA, priv); 320 mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_RTCRST, priv); 321 322 mc13xxx_unlock(priv->mc13xxx); 323 } 324 325 static const struct platform_device_id mc13xxx_rtc_idtable[] = { 326 { 327 .name = "mc13783-rtc", 328 }, { 329 .name = "mc13892-rtc", 330 }, { 331 .name = "mc34708-rtc", 332 }, 333 { /* sentinel */ } 334 }; 335 MODULE_DEVICE_TABLE(platform, mc13xxx_rtc_idtable); 336 337 static struct platform_driver mc13xxx_rtc_driver = { 338 .id_table = mc13xxx_rtc_idtable, 339 .remove = mc13xxx_rtc_remove, 340 .driver = { 341 .name = DRIVER_NAME, 342 }, 343 }; 344 345 module_platform_driver_probe(mc13xxx_rtc_driver, &mc13xxx_rtc_probe); 346 347 MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>"); 348 MODULE_DESCRIPTION("RTC driver for Freescale MC13XXX PMIC"); 349 MODULE_LICENSE("GPL v2"); 350