1 /* 2 * DS1286 Real Time Clock interface for Linux 3 * 4 * Copyright (C) 1998, 1999, 2000 Ralf Baechle 5 * Copyright (C) 2008 Thomas Bogendoerfer 6 * 7 * Based on code written by Paul Gortmaker. 8 * 9 * This program is free software; you can redistribute it and/or modify it 10 * under the terms of the GNU General Public License as published by the 11 * Free Software Foundation; either version 2 of the License, or (at your 12 * option) any later version. 13 */ 14 15 #include <linux/module.h> 16 #include <linux/rtc.h> 17 #include <linux/platform_device.h> 18 #include <linux/bcd.h> 19 #include <linux/ds1286.h> 20 #include <linux/io.h> 21 22 #define DRV_VERSION "1.0" 23 24 struct ds1286_priv { 25 struct rtc_device *rtc; 26 u32 __iomem *rtcregs; 27 size_t size; 28 unsigned long baseaddr; 29 spinlock_t lock; 30 }; 31 32 static inline u8 ds1286_rtc_read(struct ds1286_priv *priv, int reg) 33 { 34 return __raw_readl(&priv->rtcregs[reg]) & 0xff; 35 } 36 37 static inline void ds1286_rtc_write(struct ds1286_priv *priv, u8 data, int reg) 38 { 39 __raw_writel(data, &priv->rtcregs[reg]); 40 } 41 42 #ifdef CONFIG_RTC_INTF_DEV 43 44 static int ds1286_ioctl(struct device *dev, unsigned int cmd, unsigned long arg) 45 { 46 struct ds1286_priv *priv = dev_get_drvdata(dev); 47 unsigned long flags; 48 unsigned char val; 49 50 switch (cmd) { 51 case RTC_AIE_OFF: 52 /* Mask alarm int. enab. bit */ 53 spin_lock_irqsave(&priv->lock, flags); 54 val = ds1286_rtc_read(priv, RTC_CMD); 55 val |= RTC_TDM; 56 ds1286_rtc_write(priv, val, RTC_CMD); 57 spin_unlock_irqrestore(&priv->lock, flags); 58 break; 59 case RTC_AIE_ON: 60 /* Allow alarm interrupts. */ 61 spin_lock_irqsave(&priv->lock, flags); 62 val = ds1286_rtc_read(priv, RTC_CMD); 63 val &= ~RTC_TDM; 64 ds1286_rtc_write(priv, val, RTC_CMD); 65 spin_unlock_irqrestore(&priv->lock, flags); 66 break; 67 case RTC_WIE_OFF: 68 /* Mask watchdog int. enab. bit */ 69 spin_lock_irqsave(&priv->lock, flags); 70 val = ds1286_rtc_read(priv, RTC_CMD); 71 val |= RTC_WAM; 72 ds1286_rtc_write(priv, val, RTC_CMD); 73 spin_unlock_irqrestore(&priv->lock, flags); 74 break; 75 case RTC_WIE_ON: 76 /* Allow watchdog interrupts. */ 77 spin_lock_irqsave(&priv->lock, flags); 78 val = ds1286_rtc_read(priv, RTC_CMD); 79 val &= ~RTC_WAM; 80 ds1286_rtc_write(priv, val, RTC_CMD); 81 spin_unlock_irqrestore(&priv->lock, flags); 82 break; 83 default: 84 return -ENOIOCTLCMD; 85 } 86 return 0; 87 } 88 89 #else 90 #define ds1286_ioctl NULL 91 #endif 92 93 #ifdef CONFIG_PROC_FS 94 95 static int ds1286_proc(struct device *dev, struct seq_file *seq) 96 { 97 struct ds1286_priv *priv = dev_get_drvdata(dev); 98 unsigned char month, cmd, amode; 99 const char *s; 100 101 month = ds1286_rtc_read(priv, RTC_MONTH); 102 seq_printf(seq, 103 "oscillator\t: %s\n" 104 "square_wave\t: %s\n", 105 (month & RTC_EOSC) ? "disabled" : "enabled", 106 (month & RTC_ESQW) ? "disabled" : "enabled"); 107 108 amode = ((ds1286_rtc_read(priv, RTC_MINUTES_ALARM) & 0x80) >> 5) | 109 ((ds1286_rtc_read(priv, RTC_HOURS_ALARM) & 0x80) >> 6) | 110 ((ds1286_rtc_read(priv, RTC_DAY_ALARM) & 0x80) >> 7); 111 switch (amode) { 112 case 7: 113 s = "each minute"; 114 break; 115 case 3: 116 s = "minutes match"; 117 break; 118 case 1: 119 s = "hours and minutes match"; 120 break; 121 case 0: 122 s = "days, hours and minutes match"; 123 break; 124 default: 125 s = "invalid"; 126 break; 127 } 128 seq_printf(seq, "alarm_mode\t: %s\n", s); 129 130 cmd = ds1286_rtc_read(priv, RTC_CMD); 131 seq_printf(seq, 132 "alarm_enable\t: %s\n" 133 "wdog_alarm\t: %s\n" 134 "alarm_mask\t: %s\n" 135 "wdog_alarm_mask\t: %s\n" 136 "interrupt_mode\t: %s\n" 137 "INTB_mode\t: %s_active\n" 138 "interrupt_pins\t: %s\n", 139 (cmd & RTC_TDF) ? "yes" : "no", 140 (cmd & RTC_WAF) ? "yes" : "no", 141 (cmd & RTC_TDM) ? "disabled" : "enabled", 142 (cmd & RTC_WAM) ? "disabled" : "enabled", 143 (cmd & RTC_PU_LVL) ? "pulse" : "level", 144 (cmd & RTC_IBH_LO) ? "low" : "high", 145 (cmd & RTC_IPSW) ? "unswapped" : "swapped"); 146 return 0; 147 } 148 149 #else 150 #define ds1286_proc NULL 151 #endif 152 153 static int ds1286_read_time(struct device *dev, struct rtc_time *tm) 154 { 155 struct ds1286_priv *priv = dev_get_drvdata(dev); 156 unsigned char save_control; 157 unsigned long flags; 158 unsigned long uip_watchdog = jiffies; 159 160 /* 161 * read RTC once any update in progress is done. The update 162 * can take just over 2ms. We wait 10 to 20ms. There is no need to 163 * to poll-wait (up to 1s - eeccch) for the falling edge of RTC_UIP. 164 * If you need to know *exactly* when a second has started, enable 165 * periodic update complete interrupts, (via ioctl) and then 166 * immediately read /dev/rtc which will block until you get the IRQ. 167 * Once the read clears, read the RTC time (again via ioctl). Easy. 168 */ 169 170 if (ds1286_rtc_read(priv, RTC_CMD) & RTC_TE) 171 while (time_before(jiffies, uip_watchdog + 2*HZ/100)) 172 barrier(); 173 174 /* 175 * Only the values that we read from the RTC are set. We leave 176 * tm_wday, tm_yday and tm_isdst untouched. Even though the 177 * RTC has RTC_DAY_OF_WEEK, we ignore it, as it is only updated 178 * by the RTC when initially set to a non-zero value. 179 */ 180 spin_lock_irqsave(&priv->lock, flags); 181 save_control = ds1286_rtc_read(priv, RTC_CMD); 182 ds1286_rtc_write(priv, (save_control|RTC_TE), RTC_CMD); 183 184 tm->tm_sec = ds1286_rtc_read(priv, RTC_SECONDS); 185 tm->tm_min = ds1286_rtc_read(priv, RTC_MINUTES); 186 tm->tm_hour = ds1286_rtc_read(priv, RTC_HOURS) & 0x3f; 187 tm->tm_mday = ds1286_rtc_read(priv, RTC_DATE); 188 tm->tm_mon = ds1286_rtc_read(priv, RTC_MONTH) & 0x1f; 189 tm->tm_year = ds1286_rtc_read(priv, RTC_YEAR); 190 191 ds1286_rtc_write(priv, save_control, RTC_CMD); 192 spin_unlock_irqrestore(&priv->lock, flags); 193 194 tm->tm_sec = bcd2bin(tm->tm_sec); 195 tm->tm_min = bcd2bin(tm->tm_min); 196 tm->tm_hour = bcd2bin(tm->tm_hour); 197 tm->tm_mday = bcd2bin(tm->tm_mday); 198 tm->tm_mon = bcd2bin(tm->tm_mon); 199 tm->tm_year = bcd2bin(tm->tm_year); 200 201 /* 202 * Account for differences between how the RTC uses the values 203 * and how they are defined in a struct rtc_time; 204 */ 205 if (tm->tm_year < 45) 206 tm->tm_year += 30; 207 tm->tm_year += 40; 208 if (tm->tm_year < 70) 209 tm->tm_year += 100; 210 211 tm->tm_mon--; 212 213 return rtc_valid_tm(tm); 214 } 215 216 static int ds1286_set_time(struct device *dev, struct rtc_time *tm) 217 { 218 struct ds1286_priv *priv = dev_get_drvdata(dev); 219 unsigned char mon, day, hrs, min, sec; 220 unsigned char save_control; 221 unsigned int yrs; 222 unsigned long flags; 223 224 yrs = tm->tm_year + 1900; 225 mon = tm->tm_mon + 1; /* tm_mon starts at zero */ 226 day = tm->tm_mday; 227 hrs = tm->tm_hour; 228 min = tm->tm_min; 229 sec = tm->tm_sec; 230 231 if (yrs < 1970) 232 return -EINVAL; 233 234 yrs -= 1940; 235 if (yrs > 255) /* They are unsigned */ 236 return -EINVAL; 237 238 if (yrs >= 100) 239 yrs -= 100; 240 241 sec = bin2bcd(sec); 242 min = bin2bcd(min); 243 hrs = bin2bcd(hrs); 244 day = bin2bcd(day); 245 mon = bin2bcd(mon); 246 yrs = bin2bcd(yrs); 247 248 spin_lock_irqsave(&priv->lock, flags); 249 save_control = ds1286_rtc_read(priv, RTC_CMD); 250 ds1286_rtc_write(priv, (save_control|RTC_TE), RTC_CMD); 251 252 ds1286_rtc_write(priv, yrs, RTC_YEAR); 253 ds1286_rtc_write(priv, mon, RTC_MONTH); 254 ds1286_rtc_write(priv, day, RTC_DATE); 255 ds1286_rtc_write(priv, hrs, RTC_HOURS); 256 ds1286_rtc_write(priv, min, RTC_MINUTES); 257 ds1286_rtc_write(priv, sec, RTC_SECONDS); 258 ds1286_rtc_write(priv, 0, RTC_HUNDREDTH_SECOND); 259 260 ds1286_rtc_write(priv, save_control, RTC_CMD); 261 spin_unlock_irqrestore(&priv->lock, flags); 262 return 0; 263 } 264 265 static int ds1286_read_alarm(struct device *dev, struct rtc_wkalrm *alm) 266 { 267 struct ds1286_priv *priv = dev_get_drvdata(dev); 268 unsigned char cmd; 269 unsigned long flags; 270 271 /* 272 * Only the values that we read from the RTC are set. That 273 * means only tm_wday, tm_hour, tm_min. 274 */ 275 spin_lock_irqsave(&priv->lock, flags); 276 alm->time.tm_min = ds1286_rtc_read(priv, RTC_MINUTES_ALARM) & 0x7f; 277 alm->time.tm_hour = ds1286_rtc_read(priv, RTC_HOURS_ALARM) & 0x1f; 278 alm->time.tm_wday = ds1286_rtc_read(priv, RTC_DAY_ALARM) & 0x07; 279 cmd = ds1286_rtc_read(priv, RTC_CMD); 280 spin_unlock_irqrestore(&priv->lock, flags); 281 282 alm->time.tm_min = bcd2bin(alm->time.tm_min); 283 alm->time.tm_hour = bcd2bin(alm->time.tm_hour); 284 alm->time.tm_sec = 0; 285 return 0; 286 } 287 288 static int ds1286_set_alarm(struct device *dev, struct rtc_wkalrm *alm) 289 { 290 struct ds1286_priv *priv = dev_get_drvdata(dev); 291 unsigned char hrs, min, sec; 292 293 hrs = alm->time.tm_hour; 294 min = alm->time.tm_min; 295 sec = alm->time.tm_sec; 296 297 if (hrs >= 24) 298 hrs = 0xff; 299 300 if (min >= 60) 301 min = 0xff; 302 303 if (sec != 0) 304 return -EINVAL; 305 306 min = bin2bcd(min); 307 hrs = bin2bcd(hrs); 308 309 spin_lock(&priv->lock); 310 ds1286_rtc_write(priv, hrs, RTC_HOURS_ALARM); 311 ds1286_rtc_write(priv, min, RTC_MINUTES_ALARM); 312 spin_unlock(&priv->lock); 313 314 return 0; 315 } 316 317 static const struct rtc_class_ops ds1286_ops = { 318 .ioctl = ds1286_ioctl, 319 .proc = ds1286_proc, 320 .read_time = ds1286_read_time, 321 .set_time = ds1286_set_time, 322 .read_alarm = ds1286_read_alarm, 323 .set_alarm = ds1286_set_alarm, 324 }; 325 326 static int __devinit ds1286_probe(struct platform_device *pdev) 327 { 328 struct rtc_device *rtc; 329 struct resource *res; 330 struct ds1286_priv *priv; 331 int ret = 0; 332 333 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 334 if (!res) 335 return -ENODEV; 336 priv = kzalloc(sizeof(struct ds1286_priv), GFP_KERNEL); 337 if (!priv) 338 return -ENOMEM; 339 340 priv->size = res->end - res->start + 1; 341 if (!request_mem_region(res->start, priv->size, pdev->name)) { 342 ret = -EBUSY; 343 goto out; 344 } 345 priv->baseaddr = res->start; 346 priv->rtcregs = ioremap(priv->baseaddr, priv->size); 347 if (!priv->rtcregs) { 348 ret = -ENOMEM; 349 goto out; 350 } 351 spin_lock_init(&priv->lock); 352 rtc = rtc_device_register("ds1286", &pdev->dev, 353 &ds1286_ops, THIS_MODULE); 354 if (IS_ERR(rtc)) { 355 ret = PTR_ERR(rtc); 356 goto out; 357 } 358 priv->rtc = rtc; 359 platform_set_drvdata(pdev, priv); 360 return 0; 361 362 out: 363 if (priv->rtc) 364 rtc_device_unregister(priv->rtc); 365 if (priv->rtcregs) 366 iounmap(priv->rtcregs); 367 if (priv->baseaddr) 368 release_mem_region(priv->baseaddr, priv->size); 369 kfree(priv); 370 return ret; 371 } 372 373 static int __devexit ds1286_remove(struct platform_device *pdev) 374 { 375 struct ds1286_priv *priv = platform_get_drvdata(pdev); 376 377 rtc_device_unregister(priv->rtc); 378 iounmap(priv->rtcregs); 379 release_mem_region(priv->baseaddr, priv->size); 380 kfree(priv); 381 return 0; 382 } 383 384 static struct platform_driver ds1286_platform_driver = { 385 .driver = { 386 .name = "rtc-ds1286", 387 .owner = THIS_MODULE, 388 }, 389 .probe = ds1286_probe, 390 .remove = __devexit_p(ds1286_remove), 391 }; 392 393 static int __init ds1286_init(void) 394 { 395 return platform_driver_register(&ds1286_platform_driver); 396 } 397 398 static void __exit ds1286_exit(void) 399 { 400 platform_driver_unregister(&ds1286_platform_driver); 401 } 402 403 MODULE_AUTHOR("Thomas Bogendoerfer <tsbogend@alpha.franken.de>"); 404 MODULE_DESCRIPTION("DS1286 RTC driver"); 405 MODULE_LICENSE("GPL"); 406 MODULE_VERSION(DRV_VERSION); 407 MODULE_ALIAS("platform:rtc-ds1286"); 408 409 module_init(ds1286_init); 410 module_exit(ds1286_exit); 411