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