1 /* 2 * Real Time Clock driver for Freescale MC13XXX PMIC 3 * 4 * (C) 2009 Sascha Hauer, Pengutronix 5 * (C) 2009 Uwe Kleine-Koenig, Pengutronix 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 */ 11 12 #include <linux/mfd/mc13xxx.h> 13 #include <linux/platform_device.h> 14 #include <linux/kernel.h> 15 #include <linux/module.h> 16 #include <linux/slab.h> 17 #include <linux/rtc.h> 18 19 #define DRIVER_NAME "mc13xxx-rtc" 20 21 #define MC13XXX_RTCTOD 20 22 #define MC13XXX_RTCTODA 21 23 #define MC13XXX_RTCDAY 22 24 #define MC13XXX_RTCDAYA 23 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_irq_enable(struct device *dev, 46 unsigned int enabled, int irq) 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, irq); 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 unsigned long s1970; 65 int ret; 66 67 mc13xxx_lock(priv->mc13xxx); 68 69 if (!priv->valid) { 70 ret = -ENODATA; 71 goto out; 72 } 73 74 ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days1); 75 if (unlikely(ret)) 76 goto out; 77 78 ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTOD, &seconds); 79 if (unlikely(ret)) 80 goto out; 81 82 ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days2); 83 out: 84 mc13xxx_unlock(priv->mc13xxx); 85 86 if (ret) 87 return ret; 88 89 if (days2 == days1 + 1) { 90 if (seconds >= 86400 / 2) 91 days2 = days1; 92 else 93 days1 = days2; 94 } 95 96 if (days1 != days2) 97 return -EIO; 98 99 s1970 = days1 * 86400 + seconds; 100 101 rtc_time_to_tm(s1970, tm); 102 103 return rtc_valid_tm(tm); 104 } 105 106 static int mc13xxx_rtc_set_mmss(struct device *dev, unsigned long secs) 107 { 108 struct mc13xxx_rtc *priv = dev_get_drvdata(dev); 109 unsigned int seconds, days; 110 unsigned int alarmseconds; 111 int ret; 112 113 seconds = secs % 86400; 114 days = secs / 86400; 115 116 mc13xxx_lock(priv->mc13xxx); 117 118 /* 119 * temporarily invalidate alarm to prevent triggering it when the day is 120 * already updated while the time isn't yet. 121 */ 122 ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTODA, &alarmseconds); 123 if (unlikely(ret)) 124 goto out; 125 126 if (alarmseconds < 86400) { 127 ret = mc13xxx_reg_write(priv->mc13xxx, 128 MC13XXX_RTCTODA, 0x1ffff); 129 if (unlikely(ret)) 130 goto out; 131 } 132 133 /* 134 * write seconds=0 to prevent a day switch between writing days 135 * and seconds below 136 */ 137 ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTOD, 0); 138 if (unlikely(ret)) 139 goto out; 140 141 ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCDAY, days); 142 if (unlikely(ret)) 143 goto out; 144 145 ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTOD, seconds); 146 if (unlikely(ret)) 147 goto out; 148 149 /* restore alarm */ 150 if (alarmseconds < 86400) { 151 ret = mc13xxx_reg_write(priv->mc13xxx, 152 MC13XXX_RTCTODA, alarmseconds); 153 if (unlikely(ret)) 154 goto out; 155 } 156 157 ret = mc13xxx_irq_ack(priv->mc13xxx, MC13XXX_IRQ_RTCRST); 158 if (unlikely(ret)) 159 goto out; 160 161 ret = mc13xxx_irq_unmask(priv->mc13xxx, MC13XXX_IRQ_RTCRST); 162 out: 163 priv->valid = !ret; 164 165 mc13xxx_unlock(priv->mc13xxx); 166 167 return ret; 168 } 169 170 static int mc13xxx_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm) 171 { 172 struct mc13xxx_rtc *priv = dev_get_drvdata(dev); 173 unsigned seconds, days; 174 unsigned long s1970; 175 int enabled, pending; 176 int ret; 177 178 mc13xxx_lock(priv->mc13xxx); 179 180 ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTODA, &seconds); 181 if (unlikely(ret)) 182 goto out; 183 if (seconds >= 86400) { 184 ret = -ENODATA; 185 goto out; 186 } 187 188 ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days); 189 if (unlikely(ret)) 190 goto out; 191 192 ret = mc13xxx_irq_status(priv->mc13xxx, MC13XXX_IRQ_TODA, 193 &enabled, &pending); 194 195 out: 196 mc13xxx_unlock(priv->mc13xxx); 197 198 if (ret) 199 return ret; 200 201 alarm->enabled = enabled; 202 alarm->pending = pending; 203 204 s1970 = days * 86400 + seconds; 205 206 rtc_time_to_tm(s1970, &alarm->time); 207 dev_dbg(dev, "%s: %lu\n", __func__, s1970); 208 209 return 0; 210 } 211 212 static int mc13xxx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm) 213 { 214 struct mc13xxx_rtc *priv = dev_get_drvdata(dev); 215 unsigned long s1970; 216 unsigned seconds, days; 217 int ret; 218 219 mc13xxx_lock(priv->mc13xxx); 220 221 /* disable alarm to prevent false triggering */ 222 ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTODA, 0x1ffff); 223 if (unlikely(ret)) 224 goto out; 225 226 ret = mc13xxx_irq_ack(priv->mc13xxx, MC13XXX_IRQ_TODA); 227 if (unlikely(ret)) 228 goto out; 229 230 ret = rtc_tm_to_time(&alarm->time, &s1970); 231 if (unlikely(ret)) 232 goto out; 233 234 dev_dbg(dev, "%s: o%2.s %lu\n", __func__, alarm->enabled ? "n" : "ff", 235 s1970); 236 237 ret = mc13xxx_rtc_irq_enable_unlocked(dev, alarm->enabled, 238 MC13XXX_IRQ_TODA); 239 if (unlikely(ret)) 240 goto out; 241 242 seconds = s1970 % 86400; 243 days = s1970 / 86400; 244 245 ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCDAYA, days); 246 if (unlikely(ret)) 247 goto out; 248 249 ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTODA, seconds); 250 251 out: 252 mc13xxx_unlock(priv->mc13xxx); 253 254 return ret; 255 } 256 257 static irqreturn_t mc13xxx_rtc_alarm_handler(int irq, void *dev) 258 { 259 struct mc13xxx_rtc *priv = dev; 260 struct mc13xxx *mc13xxx = priv->mc13xxx; 261 262 dev_dbg(&priv->rtc->dev, "Alarm\n"); 263 264 rtc_update_irq(priv->rtc, 1, RTC_IRQF | RTC_AF); 265 266 mc13xxx_irq_ack(mc13xxx, irq); 267 268 return IRQ_HANDLED; 269 } 270 271 static irqreturn_t mc13xxx_rtc_update_handler(int irq, void *dev) 272 { 273 struct mc13xxx_rtc *priv = dev; 274 struct mc13xxx *mc13xxx = priv->mc13xxx; 275 276 dev_dbg(&priv->rtc->dev, "1HZ\n"); 277 278 rtc_update_irq(priv->rtc, 1, RTC_IRQF | RTC_UF); 279 280 mc13xxx_irq_ack(mc13xxx, irq); 281 282 return IRQ_HANDLED; 283 } 284 285 static int mc13xxx_rtc_update_irq_enable(struct device *dev, 286 unsigned int enabled) 287 { 288 return mc13xxx_rtc_irq_enable(dev, enabled, MC13XXX_IRQ_1HZ); 289 } 290 291 static int mc13xxx_rtc_alarm_irq_enable(struct device *dev, 292 unsigned int enabled) 293 { 294 return mc13xxx_rtc_irq_enable(dev, enabled, MC13XXX_IRQ_TODA); 295 } 296 297 static const struct rtc_class_ops mc13xxx_rtc_ops = { 298 .read_time = mc13xxx_rtc_read_time, 299 .set_mmss = mc13xxx_rtc_set_mmss, 300 .read_alarm = mc13xxx_rtc_read_alarm, 301 .set_alarm = mc13xxx_rtc_set_alarm, 302 .alarm_irq_enable = mc13xxx_rtc_alarm_irq_enable, 303 .update_irq_enable = mc13xxx_rtc_update_irq_enable, 304 }; 305 306 static irqreturn_t mc13xxx_rtc_reset_handler(int irq, void *dev) 307 { 308 struct mc13xxx_rtc *priv = dev; 309 struct mc13xxx *mc13xxx = priv->mc13xxx; 310 311 dev_dbg(&priv->rtc->dev, "RTCRST\n"); 312 priv->valid = 0; 313 314 mc13xxx_irq_mask(mc13xxx, irq); 315 316 return IRQ_HANDLED; 317 } 318 319 static int __devinit mc13xxx_rtc_probe(struct platform_device *pdev) 320 { 321 int ret; 322 struct mc13xxx_rtc *priv; 323 struct mc13xxx *mc13xxx; 324 int rtcrst_pending; 325 326 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 327 if (!priv) 328 return -ENOMEM; 329 330 mc13xxx = dev_get_drvdata(pdev->dev.parent); 331 priv->mc13xxx = mc13xxx; 332 333 platform_set_drvdata(pdev, priv); 334 335 mc13xxx_lock(mc13xxx); 336 337 ret = mc13xxx_irq_request(mc13xxx, MC13XXX_IRQ_RTCRST, 338 mc13xxx_rtc_reset_handler, DRIVER_NAME, priv); 339 if (ret) 340 goto err_reset_irq_request; 341 342 ret = mc13xxx_irq_status(mc13xxx, MC13XXX_IRQ_RTCRST, 343 NULL, &rtcrst_pending); 344 if (ret) 345 goto err_reset_irq_status; 346 347 priv->valid = !rtcrst_pending; 348 349 ret = mc13xxx_irq_request_nounmask(mc13xxx, MC13XXX_IRQ_1HZ, 350 mc13xxx_rtc_update_handler, DRIVER_NAME, priv); 351 if (ret) 352 goto err_update_irq_request; 353 354 ret = mc13xxx_irq_request_nounmask(mc13xxx, MC13XXX_IRQ_TODA, 355 mc13xxx_rtc_alarm_handler, DRIVER_NAME, priv); 356 if (ret) 357 goto err_alarm_irq_request; 358 359 priv->rtc = rtc_device_register(pdev->name, 360 &pdev->dev, &mc13xxx_rtc_ops, THIS_MODULE); 361 if (IS_ERR(priv->rtc)) { 362 ret = PTR_ERR(priv->rtc); 363 364 mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_TODA, priv); 365 err_alarm_irq_request: 366 367 mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_1HZ, priv); 368 err_update_irq_request: 369 370 err_reset_irq_status: 371 372 mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_RTCRST, priv); 373 err_reset_irq_request: 374 375 platform_set_drvdata(pdev, NULL); 376 kfree(priv); 377 } 378 379 mc13xxx_unlock(mc13xxx); 380 381 return ret; 382 } 383 384 static int __devexit mc13xxx_rtc_remove(struct platform_device *pdev) 385 { 386 struct mc13xxx_rtc *priv = platform_get_drvdata(pdev); 387 388 mc13xxx_lock(priv->mc13xxx); 389 390 rtc_device_unregister(priv->rtc); 391 392 mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_TODA, priv); 393 mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_1HZ, priv); 394 mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_RTCRST, priv); 395 396 mc13xxx_unlock(priv->mc13xxx); 397 398 platform_set_drvdata(pdev, NULL); 399 400 kfree(priv); 401 402 return 0; 403 } 404 405 const struct platform_device_id mc13xxx_rtc_idtable[] = { 406 { 407 .name = "mc13783-rtc", 408 }, { 409 .name = "mc13892-rtc", 410 }, 411 }; 412 413 static struct platform_driver mc13xxx_rtc_driver = { 414 .id_table = mc13xxx_rtc_idtable, 415 .remove = __devexit_p(mc13xxx_rtc_remove), 416 .driver = { 417 .name = DRIVER_NAME, 418 .owner = THIS_MODULE, 419 }, 420 }; 421 422 static int __init mc13xxx_rtc_init(void) 423 { 424 return platform_driver_probe(&mc13xxx_rtc_driver, &mc13xxx_rtc_probe); 425 } 426 module_init(mc13xxx_rtc_init); 427 428 static void __exit mc13xxx_rtc_exit(void) 429 { 430 platform_driver_unregister(&mc13xxx_rtc_driver); 431 } 432 module_exit(mc13xxx_rtc_exit); 433 434 MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>"); 435 MODULE_DESCRIPTION("RTC driver for Freescale MC13XXX PMIC"); 436 MODULE_LICENSE("GPL v2"); 437 MODULE_ALIAS("platform:" DRIVER_NAME); 438