1 /* 2 * drivers/rtc/rtc-spear.c 3 * 4 * Copyright (C) 2010 ST Microelectronics 5 * Rajeev Kumar<rajeev-dlh.kumar@st.com> 6 * 7 * This file is licensed under the terms of the GNU General Public 8 * License version 2. This program is licensed "as is" without any 9 * warranty of any kind, whether express or implied. 10 */ 11 12 #include <linux/bcd.h> 13 #include <linux/clk.h> 14 #include <linux/delay.h> 15 #include <linux/init.h> 16 #include <linux/io.h> 17 #include <linux/irq.h> 18 #include <linux/module.h> 19 #include <linux/of.h> 20 #include <linux/platform_device.h> 21 #include <linux/rtc.h> 22 #include <linux/slab.h> 23 #include <linux/spinlock.h> 24 25 /* RTC registers */ 26 #define TIME_REG 0x00 27 #define DATE_REG 0x04 28 #define ALARM_TIME_REG 0x08 29 #define ALARM_DATE_REG 0x0C 30 #define CTRL_REG 0x10 31 #define STATUS_REG 0x14 32 33 /* TIME_REG & ALARM_TIME_REG */ 34 #define SECONDS_UNITS (0xf<<0) /* seconds units position */ 35 #define SECONDS_TENS (0x7<<4) /* seconds tens position */ 36 #define MINUTES_UNITS (0xf<<8) /* minutes units position */ 37 #define MINUTES_TENS (0x7<<12) /* minutes tens position */ 38 #define HOURS_UNITS (0xf<<16) /* hours units position */ 39 #define HOURS_TENS (0x3<<20) /* hours tens position */ 40 41 /* DATE_REG & ALARM_DATE_REG */ 42 #define DAYS_UNITS (0xf<<0) /* days units position */ 43 #define DAYS_TENS (0x3<<4) /* days tens position */ 44 #define MONTHS_UNITS (0xf<<8) /* months units position */ 45 #define MONTHS_TENS (0x1<<12) /* months tens position */ 46 #define YEARS_UNITS (0xf<<16) /* years units position */ 47 #define YEARS_TENS (0xf<<20) /* years tens position */ 48 #define YEARS_HUNDREDS (0xf<<24) /* years hundereds position */ 49 #define YEARS_MILLENIUMS (0xf<<28) /* years millenium position */ 50 51 /* MASK SHIFT TIME_REG & ALARM_TIME_REG*/ 52 #define SECOND_SHIFT 0x00 /* seconds units */ 53 #define MINUTE_SHIFT 0x08 /* minutes units position */ 54 #define HOUR_SHIFT 0x10 /* hours units position */ 55 #define MDAY_SHIFT 0x00 /* Month day shift */ 56 #define MONTH_SHIFT 0x08 /* Month shift */ 57 #define YEAR_SHIFT 0x10 /* Year shift */ 58 59 #define SECOND_MASK 0x7F 60 #define MIN_MASK 0x7F 61 #define HOUR_MASK 0x3F 62 #define DAY_MASK 0x3F 63 #define MONTH_MASK 0x7F 64 #define YEAR_MASK 0xFFFF 65 66 /* date reg equal to time reg, for debug only */ 67 #define TIME_BYP (1<<9) 68 #define INT_ENABLE (1<<31) /* interrupt enable */ 69 70 /* STATUS_REG */ 71 #define CLK_UNCONNECTED (1<<0) 72 #define PEND_WR_TIME (1<<2) 73 #define PEND_WR_DATE (1<<3) 74 #define LOST_WR_TIME (1<<4) 75 #define LOST_WR_DATE (1<<5) 76 #define RTC_INT_MASK (1<<31) 77 #define STATUS_BUSY (PEND_WR_TIME | PEND_WR_DATE) 78 #define STATUS_FAIL (LOST_WR_TIME | LOST_WR_DATE) 79 80 struct spear_rtc_config { 81 struct rtc_device *rtc; 82 struct clk *clk; 83 spinlock_t lock; 84 void __iomem *ioaddr; 85 unsigned int irq_wake; 86 }; 87 88 static inline void spear_rtc_clear_interrupt(struct spear_rtc_config *config) 89 { 90 unsigned int val; 91 unsigned long flags; 92 93 spin_lock_irqsave(&config->lock, flags); 94 val = readl(config->ioaddr + STATUS_REG); 95 val |= RTC_INT_MASK; 96 writel(val, config->ioaddr + STATUS_REG); 97 spin_unlock_irqrestore(&config->lock, flags); 98 } 99 100 static inline void spear_rtc_enable_interrupt(struct spear_rtc_config *config) 101 { 102 unsigned int val; 103 104 val = readl(config->ioaddr + CTRL_REG); 105 if (!(val & INT_ENABLE)) { 106 spear_rtc_clear_interrupt(config); 107 val |= INT_ENABLE; 108 writel(val, config->ioaddr + CTRL_REG); 109 } 110 } 111 112 static inline void spear_rtc_disable_interrupt(struct spear_rtc_config *config) 113 { 114 unsigned int val; 115 116 val = readl(config->ioaddr + CTRL_REG); 117 if (val & INT_ENABLE) { 118 val &= ~INT_ENABLE; 119 writel(val, config->ioaddr + CTRL_REG); 120 } 121 } 122 123 static inline int is_write_complete(struct spear_rtc_config *config) 124 { 125 int ret = 0; 126 unsigned long flags; 127 128 spin_lock_irqsave(&config->lock, flags); 129 if ((readl(config->ioaddr + STATUS_REG)) & STATUS_FAIL) 130 ret = -EIO; 131 spin_unlock_irqrestore(&config->lock, flags); 132 133 return ret; 134 } 135 136 static void rtc_wait_not_busy(struct spear_rtc_config *config) 137 { 138 int status, count = 0; 139 unsigned long flags; 140 141 /* Assuming BUSY may stay active for 80 msec) */ 142 for (count = 0; count < 80; count++) { 143 spin_lock_irqsave(&config->lock, flags); 144 status = readl(config->ioaddr + STATUS_REG); 145 spin_unlock_irqrestore(&config->lock, flags); 146 if ((status & STATUS_BUSY) == 0) 147 break; 148 /* check status busy, after each msec */ 149 msleep(1); 150 } 151 } 152 153 static irqreturn_t spear_rtc_irq(int irq, void *dev_id) 154 { 155 struct spear_rtc_config *config = dev_id; 156 unsigned long flags, events = 0; 157 unsigned int irq_data; 158 159 spin_lock_irqsave(&config->lock, flags); 160 irq_data = readl(config->ioaddr + STATUS_REG); 161 spin_unlock_irqrestore(&config->lock, flags); 162 163 if ((irq_data & RTC_INT_MASK)) { 164 spear_rtc_clear_interrupt(config); 165 events = RTC_IRQF | RTC_AF; 166 rtc_update_irq(config->rtc, 1, events); 167 return IRQ_HANDLED; 168 } else 169 return IRQ_NONE; 170 171 } 172 173 static int tm2bcd(struct rtc_time *tm) 174 { 175 if (rtc_valid_tm(tm) != 0) 176 return -EINVAL; 177 tm->tm_sec = bin2bcd(tm->tm_sec); 178 tm->tm_min = bin2bcd(tm->tm_min); 179 tm->tm_hour = bin2bcd(tm->tm_hour); 180 tm->tm_mday = bin2bcd(tm->tm_mday); 181 tm->tm_mon = bin2bcd(tm->tm_mon + 1); 182 tm->tm_year = bin2bcd(tm->tm_year); 183 184 return 0; 185 } 186 187 static void bcd2tm(struct rtc_time *tm) 188 { 189 tm->tm_sec = bcd2bin(tm->tm_sec); 190 tm->tm_min = bcd2bin(tm->tm_min); 191 tm->tm_hour = bcd2bin(tm->tm_hour); 192 tm->tm_mday = bcd2bin(tm->tm_mday); 193 tm->tm_mon = bcd2bin(tm->tm_mon) - 1; 194 /* epoch == 1900 */ 195 tm->tm_year = bcd2bin(tm->tm_year); 196 } 197 198 /* 199 * spear_rtc_read_time - set the time 200 * @dev: rtc device in use 201 * @tm: holds date and time 202 * 203 * This function read time and date. On success it will return 0 204 * otherwise -ve error is returned. 205 */ 206 static int spear_rtc_read_time(struct device *dev, struct rtc_time *tm) 207 { 208 struct spear_rtc_config *config = dev_get_drvdata(dev); 209 unsigned int time, date; 210 211 /* we don't report wday/yday/isdst ... */ 212 rtc_wait_not_busy(config); 213 214 time = readl(config->ioaddr + TIME_REG); 215 date = readl(config->ioaddr + DATE_REG); 216 tm->tm_sec = (time >> SECOND_SHIFT) & SECOND_MASK; 217 tm->tm_min = (time >> MINUTE_SHIFT) & MIN_MASK; 218 tm->tm_hour = (time >> HOUR_SHIFT) & HOUR_MASK; 219 tm->tm_mday = (date >> MDAY_SHIFT) & DAY_MASK; 220 tm->tm_mon = (date >> MONTH_SHIFT) & MONTH_MASK; 221 tm->tm_year = (date >> YEAR_SHIFT) & YEAR_MASK; 222 223 bcd2tm(tm); 224 return 0; 225 } 226 227 /* 228 * spear_rtc_set_time - set the time 229 * @dev: rtc device in use 230 * @tm: holds date and time 231 * 232 * This function set time and date. On success it will return 0 233 * otherwise -ve error is returned. 234 */ 235 static int spear_rtc_set_time(struct device *dev, struct rtc_time *tm) 236 { 237 struct spear_rtc_config *config = dev_get_drvdata(dev); 238 unsigned int time, date; 239 240 if (tm2bcd(tm) < 0) 241 return -EINVAL; 242 243 rtc_wait_not_busy(config); 244 time = (tm->tm_sec << SECOND_SHIFT) | (tm->tm_min << MINUTE_SHIFT) | 245 (tm->tm_hour << HOUR_SHIFT); 246 date = (tm->tm_mday << MDAY_SHIFT) | (tm->tm_mon << MONTH_SHIFT) | 247 (tm->tm_year << YEAR_SHIFT); 248 writel(time, config->ioaddr + TIME_REG); 249 writel(date, config->ioaddr + DATE_REG); 250 251 return is_write_complete(config); 252 } 253 254 /* 255 * spear_rtc_read_alarm - read the alarm time 256 * @dev: rtc device in use 257 * @alm: holds alarm date and time 258 * 259 * This function read alarm time and date. On success it will return 0 260 * otherwise -ve error is returned. 261 */ 262 static int spear_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm) 263 { 264 struct spear_rtc_config *config = dev_get_drvdata(dev); 265 unsigned int time, date; 266 267 rtc_wait_not_busy(config); 268 269 time = readl(config->ioaddr + ALARM_TIME_REG); 270 date = readl(config->ioaddr + ALARM_DATE_REG); 271 alm->time.tm_sec = (time >> SECOND_SHIFT) & SECOND_MASK; 272 alm->time.tm_min = (time >> MINUTE_SHIFT) & MIN_MASK; 273 alm->time.tm_hour = (time >> HOUR_SHIFT) & HOUR_MASK; 274 alm->time.tm_mday = (date >> MDAY_SHIFT) & DAY_MASK; 275 alm->time.tm_mon = (date >> MONTH_SHIFT) & MONTH_MASK; 276 alm->time.tm_year = (date >> YEAR_SHIFT) & YEAR_MASK; 277 278 bcd2tm(&alm->time); 279 alm->enabled = readl(config->ioaddr + CTRL_REG) & INT_ENABLE; 280 281 return 0; 282 } 283 284 /* 285 * spear_rtc_set_alarm - set the alarm time 286 * @dev: rtc device in use 287 * @alm: holds alarm date and time 288 * 289 * This function set alarm time and date. On success it will return 0 290 * otherwise -ve error is returned. 291 */ 292 static int spear_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm) 293 { 294 struct spear_rtc_config *config = dev_get_drvdata(dev); 295 unsigned int time, date; 296 int err; 297 298 if (tm2bcd(&alm->time) < 0) 299 return -EINVAL; 300 301 rtc_wait_not_busy(config); 302 303 time = (alm->time.tm_sec << SECOND_SHIFT) | (alm->time.tm_min << 304 MINUTE_SHIFT) | (alm->time.tm_hour << HOUR_SHIFT); 305 date = (alm->time.tm_mday << MDAY_SHIFT) | (alm->time.tm_mon << 306 MONTH_SHIFT) | (alm->time.tm_year << YEAR_SHIFT); 307 308 writel(time, config->ioaddr + ALARM_TIME_REG); 309 writel(date, config->ioaddr + ALARM_DATE_REG); 310 err = is_write_complete(config); 311 if (err < 0) 312 return err; 313 314 if (alm->enabled) 315 spear_rtc_enable_interrupt(config); 316 else 317 spear_rtc_disable_interrupt(config); 318 319 return 0; 320 } 321 322 static int spear_alarm_irq_enable(struct device *dev, unsigned int enabled) 323 { 324 struct spear_rtc_config *config = dev_get_drvdata(dev); 325 int ret = 0; 326 327 spear_rtc_clear_interrupt(config); 328 329 switch (enabled) { 330 case 0: 331 /* alarm off */ 332 spear_rtc_disable_interrupt(config); 333 break; 334 case 1: 335 /* alarm on */ 336 spear_rtc_enable_interrupt(config); 337 break; 338 default: 339 ret = -EINVAL; 340 break; 341 } 342 343 return ret; 344 } 345 346 static struct rtc_class_ops spear_rtc_ops = { 347 .read_time = spear_rtc_read_time, 348 .set_time = spear_rtc_set_time, 349 .read_alarm = spear_rtc_read_alarm, 350 .set_alarm = spear_rtc_set_alarm, 351 .alarm_irq_enable = spear_alarm_irq_enable, 352 }; 353 354 static int spear_rtc_probe(struct platform_device *pdev) 355 { 356 struct resource *res; 357 struct spear_rtc_config *config; 358 int status = 0; 359 int irq; 360 361 config = devm_kzalloc(&pdev->dev, sizeof(*config), GFP_KERNEL); 362 if (!config) 363 return -ENOMEM; 364 365 /* alarm irqs */ 366 irq = platform_get_irq(pdev, 0); 367 if (irq < 0) { 368 dev_err(&pdev->dev, "no update irq?\n"); 369 return irq; 370 } 371 372 status = devm_request_irq(&pdev->dev, irq, spear_rtc_irq, 0, pdev->name, 373 config); 374 if (status) { 375 dev_err(&pdev->dev, "Alarm interrupt IRQ%d already claimed\n", 376 irq); 377 return status; 378 } 379 380 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 381 config->ioaddr = devm_ioremap_resource(&pdev->dev, res); 382 if (IS_ERR(config->ioaddr)) 383 return PTR_ERR(config->ioaddr); 384 385 config->clk = devm_clk_get(&pdev->dev, NULL); 386 if (IS_ERR(config->clk)) 387 return PTR_ERR(config->clk); 388 389 status = clk_prepare_enable(config->clk); 390 if (status < 0) 391 return status; 392 393 spin_lock_init(&config->lock); 394 platform_set_drvdata(pdev, config); 395 396 config->rtc = devm_rtc_device_register(&pdev->dev, pdev->name, 397 &spear_rtc_ops, THIS_MODULE); 398 if (IS_ERR(config->rtc)) { 399 dev_err(&pdev->dev, "can't register RTC device, err %ld\n", 400 PTR_ERR(config->rtc)); 401 status = PTR_ERR(config->rtc); 402 goto err_disable_clock; 403 } 404 405 config->rtc->uie_unsupported = 1; 406 407 if (!device_can_wakeup(&pdev->dev)) 408 device_init_wakeup(&pdev->dev, 1); 409 410 return 0; 411 412 err_disable_clock: 413 clk_disable_unprepare(config->clk); 414 415 return status; 416 } 417 418 static int spear_rtc_remove(struct platform_device *pdev) 419 { 420 struct spear_rtc_config *config = platform_get_drvdata(pdev); 421 422 spear_rtc_disable_interrupt(config); 423 clk_disable_unprepare(config->clk); 424 device_init_wakeup(&pdev->dev, 0); 425 426 return 0; 427 } 428 429 #ifdef CONFIG_PM_SLEEP 430 static int spear_rtc_suspend(struct device *dev) 431 { 432 struct platform_device *pdev = to_platform_device(dev); 433 struct spear_rtc_config *config = platform_get_drvdata(pdev); 434 int irq; 435 436 irq = platform_get_irq(pdev, 0); 437 if (device_may_wakeup(&pdev->dev)) { 438 if (!enable_irq_wake(irq)) 439 config->irq_wake = 1; 440 } else { 441 spear_rtc_disable_interrupt(config); 442 clk_disable(config->clk); 443 } 444 445 return 0; 446 } 447 448 static int spear_rtc_resume(struct device *dev) 449 { 450 struct platform_device *pdev = to_platform_device(dev); 451 struct spear_rtc_config *config = platform_get_drvdata(pdev); 452 int irq; 453 454 irq = platform_get_irq(pdev, 0); 455 456 if (device_may_wakeup(&pdev->dev)) { 457 if (config->irq_wake) { 458 disable_irq_wake(irq); 459 config->irq_wake = 0; 460 } 461 } else { 462 clk_enable(config->clk); 463 spear_rtc_enable_interrupt(config); 464 } 465 466 return 0; 467 } 468 #endif 469 470 static SIMPLE_DEV_PM_OPS(spear_rtc_pm_ops, spear_rtc_suspend, spear_rtc_resume); 471 472 static void spear_rtc_shutdown(struct platform_device *pdev) 473 { 474 struct spear_rtc_config *config = platform_get_drvdata(pdev); 475 476 spear_rtc_disable_interrupt(config); 477 clk_disable(config->clk); 478 } 479 480 #ifdef CONFIG_OF 481 static const struct of_device_id spear_rtc_id_table[] = { 482 { .compatible = "st,spear600-rtc" }, 483 {} 484 }; 485 MODULE_DEVICE_TABLE(of, spear_rtc_id_table); 486 #endif 487 488 static struct platform_driver spear_rtc_driver = { 489 .probe = spear_rtc_probe, 490 .remove = spear_rtc_remove, 491 .shutdown = spear_rtc_shutdown, 492 .driver = { 493 .name = "rtc-spear", 494 .pm = &spear_rtc_pm_ops, 495 .of_match_table = of_match_ptr(spear_rtc_id_table), 496 }, 497 }; 498 499 module_platform_driver(spear_rtc_driver); 500 501 MODULE_ALIAS("platform:rtc-spear"); 502 MODULE_AUTHOR("Rajeev Kumar <rajeev-dlh.kumar@st.com>"); 503 MODULE_DESCRIPTION("ST SPEAr Realtime Clock Driver (RTC)"); 504 MODULE_LICENSE("GPL"); 505