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