1 /* 2 * Real Time Clock interface for StrongARM SA1x00 and XScale PXA2xx 3 * 4 * Copyright (c) 2000 Nils Faerber 5 * 6 * Based on rtc.c by Paul Gortmaker 7 * 8 * Original Driver by Nils Faerber <nils@kernelconcepts.de> 9 * 10 * Modifications from: 11 * CIH <cih@coventive.com> 12 * Nicolas Pitre <nico@fluxnic.net> 13 * Andrew Christian <andrew.christian@hp.com> 14 * 15 * Converted to the RTC subsystem and Driver Model 16 * by Richard Purdie <rpurdie@rpsys.net> 17 * 18 * This program is free software; you can redistribute it and/or 19 * modify it under the terms of the GNU General Public License 20 * as published by the Free Software Foundation; either version 21 * 2 of the License, or (at your option) any later version. 22 */ 23 24 #include <linux/platform_device.h> 25 #include <linux/module.h> 26 #include <linux/rtc.h> 27 #include <linux/init.h> 28 #include <linux/fs.h> 29 #include <linux/interrupt.h> 30 #include <linux/string.h> 31 #include <linux/pm.h> 32 #include <linux/bitops.h> 33 34 #include <mach/hardware.h> 35 #include <asm/irq.h> 36 37 #ifdef CONFIG_ARCH_PXA 38 #include <mach/regs-rtc.h> 39 #include <mach/regs-ost.h> 40 #endif 41 42 #define RTC_DEF_DIVIDER (32768 - 1) 43 #define RTC_DEF_TRIM 0 44 45 static const unsigned long RTC_FREQ = 1024; 46 static struct rtc_time rtc_alarm; 47 static DEFINE_SPINLOCK(sa1100_rtc_lock); 48 49 static inline int rtc_periodic_alarm(struct rtc_time *tm) 50 { 51 return (tm->tm_year == -1) || 52 ((unsigned)tm->tm_mon >= 12) || 53 ((unsigned)(tm->tm_mday - 1) >= 31) || 54 ((unsigned)tm->tm_hour > 23) || 55 ((unsigned)tm->tm_min > 59) || 56 ((unsigned)tm->tm_sec > 59); 57 } 58 59 /* 60 * Calculate the next alarm time given the requested alarm time mask 61 * and the current time. 62 */ 63 static void rtc_next_alarm_time(struct rtc_time *next, struct rtc_time *now, 64 struct rtc_time *alrm) 65 { 66 unsigned long next_time; 67 unsigned long now_time; 68 69 next->tm_year = now->tm_year; 70 next->tm_mon = now->tm_mon; 71 next->tm_mday = now->tm_mday; 72 next->tm_hour = alrm->tm_hour; 73 next->tm_min = alrm->tm_min; 74 next->tm_sec = alrm->tm_sec; 75 76 rtc_tm_to_time(now, &now_time); 77 rtc_tm_to_time(next, &next_time); 78 79 if (next_time < now_time) { 80 /* Advance one day */ 81 next_time += 60 * 60 * 24; 82 rtc_time_to_tm(next_time, next); 83 } 84 } 85 86 static int rtc_update_alarm(struct rtc_time *alrm) 87 { 88 struct rtc_time alarm_tm, now_tm; 89 unsigned long now, time; 90 int ret; 91 92 do { 93 now = RCNR; 94 rtc_time_to_tm(now, &now_tm); 95 rtc_next_alarm_time(&alarm_tm, &now_tm, alrm); 96 ret = rtc_tm_to_time(&alarm_tm, &time); 97 if (ret != 0) 98 break; 99 100 RTSR = RTSR & (RTSR_HZE|RTSR_ALE|RTSR_AL); 101 RTAR = time; 102 } while (now != RCNR); 103 104 return ret; 105 } 106 107 static irqreturn_t sa1100_rtc_interrupt(int irq, void *dev_id) 108 { 109 struct platform_device *pdev = to_platform_device(dev_id); 110 struct rtc_device *rtc = platform_get_drvdata(pdev); 111 unsigned int rtsr; 112 unsigned long events = 0; 113 114 spin_lock(&sa1100_rtc_lock); 115 116 rtsr = RTSR; 117 /* clear interrupt sources */ 118 RTSR = 0; 119 /* Fix for a nasty initialization problem the in SA11xx RTSR register. 120 * See also the comments in sa1100_rtc_probe(). */ 121 if (rtsr & (RTSR_ALE | RTSR_HZE)) { 122 /* This is the original code, before there was the if test 123 * above. This code does not clear interrupts that were not 124 * enabled. */ 125 RTSR = (RTSR_AL | RTSR_HZ) & (rtsr >> 2); 126 } else { 127 /* For some reason, it is possible to enter this routine 128 * without interruptions enabled, it has been tested with 129 * several units (Bug in SA11xx chip?). 130 * 131 * This situation leads to an infinite "loop" of interrupt 132 * routine calling and as a result the processor seems to 133 * lock on its first call to open(). */ 134 RTSR = RTSR_AL | RTSR_HZ; 135 } 136 137 /* clear alarm interrupt if it has occurred */ 138 if (rtsr & RTSR_AL) 139 rtsr &= ~RTSR_ALE; 140 RTSR = rtsr & (RTSR_ALE | RTSR_HZE); 141 142 /* update irq data & counter */ 143 if (rtsr & RTSR_AL) 144 events |= RTC_AF | RTC_IRQF; 145 if (rtsr & RTSR_HZ) 146 events |= RTC_UF | RTC_IRQF; 147 148 rtc_update_irq(rtc, 1, events); 149 150 if (rtsr & RTSR_AL && rtc_periodic_alarm(&rtc_alarm)) 151 rtc_update_alarm(&rtc_alarm); 152 153 spin_unlock(&sa1100_rtc_lock); 154 155 return IRQ_HANDLED; 156 } 157 158 static int sa1100_rtc_open(struct device *dev) 159 { 160 int ret; 161 struct platform_device *plat_dev = to_platform_device(dev); 162 struct rtc_device *rtc = platform_get_drvdata(plat_dev); 163 164 ret = request_irq(IRQ_RTC1Hz, sa1100_rtc_interrupt, IRQF_DISABLED, 165 "rtc 1Hz", dev); 166 if (ret) { 167 dev_err(dev, "IRQ %d already in use.\n", IRQ_RTC1Hz); 168 goto fail_ui; 169 } 170 ret = request_irq(IRQ_RTCAlrm, sa1100_rtc_interrupt, IRQF_DISABLED, 171 "rtc Alrm", dev); 172 if (ret) { 173 dev_err(dev, "IRQ %d already in use.\n", IRQ_RTCAlrm); 174 goto fail_ai; 175 } 176 rtc->max_user_freq = RTC_FREQ; 177 rtc_irq_set_freq(rtc, NULL, RTC_FREQ); 178 179 return 0; 180 181 fail_ai: 182 free_irq(IRQ_RTC1Hz, dev); 183 fail_ui: 184 return ret; 185 } 186 187 static void sa1100_rtc_release(struct device *dev) 188 { 189 spin_lock_irq(&sa1100_rtc_lock); 190 RTSR = 0; 191 OIER &= ~OIER_E1; 192 OSSR = OSSR_M1; 193 spin_unlock_irq(&sa1100_rtc_lock); 194 195 free_irq(IRQ_RTCAlrm, dev); 196 free_irq(IRQ_RTC1Hz, dev); 197 } 198 199 static int sa1100_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled) 200 { 201 spin_lock_irq(&sa1100_rtc_lock); 202 if (enabled) 203 RTSR |= RTSR_ALE; 204 else 205 RTSR &= ~RTSR_ALE; 206 spin_unlock_irq(&sa1100_rtc_lock); 207 return 0; 208 } 209 210 static int sa1100_rtc_read_time(struct device *dev, struct rtc_time *tm) 211 { 212 rtc_time_to_tm(RCNR, tm); 213 return 0; 214 } 215 216 static int sa1100_rtc_set_time(struct device *dev, struct rtc_time *tm) 217 { 218 unsigned long time; 219 int ret; 220 221 ret = rtc_tm_to_time(tm, &time); 222 if (ret == 0) 223 RCNR = time; 224 return ret; 225 } 226 227 static int sa1100_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm) 228 { 229 u32 rtsr; 230 231 memcpy(&alrm->time, &rtc_alarm, sizeof(struct rtc_time)); 232 rtsr = RTSR; 233 alrm->enabled = (rtsr & RTSR_ALE) ? 1 : 0; 234 alrm->pending = (rtsr & RTSR_AL) ? 1 : 0; 235 return 0; 236 } 237 238 static int sa1100_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm) 239 { 240 int ret; 241 242 spin_lock_irq(&sa1100_rtc_lock); 243 ret = rtc_update_alarm(&alrm->time); 244 if (ret == 0) { 245 if (alrm->enabled) 246 RTSR |= RTSR_ALE; 247 else 248 RTSR &= ~RTSR_ALE; 249 } 250 spin_unlock_irq(&sa1100_rtc_lock); 251 252 return ret; 253 } 254 255 static int sa1100_rtc_proc(struct device *dev, struct seq_file *seq) 256 { 257 seq_printf(seq, "trim/divider\t\t: 0x%08x\n", (u32) RTTR); 258 seq_printf(seq, "RTSR\t\t\t: 0x%08x\n", (u32)RTSR); 259 260 return 0; 261 } 262 263 static const struct rtc_class_ops sa1100_rtc_ops = { 264 .open = sa1100_rtc_open, 265 .release = sa1100_rtc_release, 266 .read_time = sa1100_rtc_read_time, 267 .set_time = sa1100_rtc_set_time, 268 .read_alarm = sa1100_rtc_read_alarm, 269 .set_alarm = sa1100_rtc_set_alarm, 270 .proc = sa1100_rtc_proc, 271 .alarm_irq_enable = sa1100_rtc_alarm_irq_enable, 272 }; 273 274 static int sa1100_rtc_probe(struct platform_device *pdev) 275 { 276 struct rtc_device *rtc; 277 278 /* 279 * According to the manual we should be able to let RTTR be zero 280 * and then a default diviser for a 32.768KHz clock is used. 281 * Apparently this doesn't work, at least for my SA1110 rev 5. 282 * If the clock divider is uninitialized then reset it to the 283 * default value to get the 1Hz clock. 284 */ 285 if (RTTR == 0) { 286 RTTR = RTC_DEF_DIVIDER + (RTC_DEF_TRIM << 16); 287 dev_warn(&pdev->dev, "warning: " 288 "initializing default clock divider/trim value\n"); 289 /* The current RTC value probably doesn't make sense either */ 290 RCNR = 0; 291 } 292 293 device_init_wakeup(&pdev->dev, 1); 294 295 rtc = rtc_device_register(pdev->name, &pdev->dev, &sa1100_rtc_ops, 296 THIS_MODULE); 297 298 if (IS_ERR(rtc)) 299 return PTR_ERR(rtc); 300 301 platform_set_drvdata(pdev, rtc); 302 303 /* Fix for a nasty initialization problem the in SA11xx RTSR register. 304 * See also the comments in sa1100_rtc_interrupt(). 305 * 306 * Sometimes bit 1 of the RTSR (RTSR_HZ) will wake up 1, which means an 307 * interrupt pending, even though interrupts were never enabled. 308 * In this case, this bit it must be reset before enabling 309 * interruptions to avoid a nonexistent interrupt to occur. 310 * 311 * In principle, the same problem would apply to bit 0, although it has 312 * never been observed to happen. 313 * 314 * This issue is addressed both here and in sa1100_rtc_interrupt(). 315 * If the issue is not addressed here, in the times when the processor 316 * wakes up with the bit set there will be one spurious interrupt. 317 * 318 * The issue is also dealt with in sa1100_rtc_interrupt() to be on the 319 * safe side, once the condition that lead to this strange 320 * initialization is unknown and could in principle happen during 321 * normal processing. 322 * 323 * Notice that clearing bit 1 and 0 is accomplished by writting ONES to 324 * the corresponding bits in RTSR. */ 325 RTSR = RTSR_AL | RTSR_HZ; 326 327 return 0; 328 } 329 330 static int sa1100_rtc_remove(struct platform_device *pdev) 331 { 332 struct rtc_device *rtc = platform_get_drvdata(pdev); 333 334 if (rtc) 335 rtc_device_unregister(rtc); 336 337 return 0; 338 } 339 340 #ifdef CONFIG_PM 341 static int sa1100_rtc_suspend(struct device *dev) 342 { 343 if (device_may_wakeup(dev)) 344 enable_irq_wake(IRQ_RTCAlrm); 345 return 0; 346 } 347 348 static int sa1100_rtc_resume(struct device *dev) 349 { 350 if (device_may_wakeup(dev)) 351 disable_irq_wake(IRQ_RTCAlrm); 352 return 0; 353 } 354 355 static const struct dev_pm_ops sa1100_rtc_pm_ops = { 356 .suspend = sa1100_rtc_suspend, 357 .resume = sa1100_rtc_resume, 358 }; 359 #endif 360 361 static struct platform_driver sa1100_rtc_driver = { 362 .probe = sa1100_rtc_probe, 363 .remove = sa1100_rtc_remove, 364 .driver = { 365 .name = "sa1100-rtc", 366 #ifdef CONFIG_PM 367 .pm = &sa1100_rtc_pm_ops, 368 #endif 369 }, 370 }; 371 372 static int __init sa1100_rtc_init(void) 373 { 374 return platform_driver_register(&sa1100_rtc_driver); 375 } 376 377 static void __exit sa1100_rtc_exit(void) 378 { 379 platform_driver_unregister(&sa1100_rtc_driver); 380 } 381 382 module_init(sa1100_rtc_init); 383 module_exit(sa1100_rtc_exit); 384 385 MODULE_AUTHOR("Richard Purdie <rpurdie@rpsys.net>"); 386 MODULE_DESCRIPTION("SA11x0/PXA2xx Realtime Clock Driver (RTC)"); 387 MODULE_LICENSE("GPL"); 388 MODULE_ALIAS("platform:sa1100-rtc"); 389