1 /* 2 * Copyright (C) ST-Ericsson SA 2010 3 * 4 * License terms: GNU General Public License (GPL) version 2 5 * Author: Virupax Sadashivpetimath <virupax.sadashivpetimath@stericsson.com> 6 * 7 * RTC clock driver for the RTC part of the AB8500 Power management chip. 8 * Based on RTC clock driver for the AB3100 Analog Baseband Chip by 9 * Linus Walleij <linus.walleij@stericsson.com> 10 */ 11 12 #include <linux/module.h> 13 #include <linux/kernel.h> 14 #include <linux/init.h> 15 #include <linux/platform_device.h> 16 #include <linux/rtc.h> 17 #include <linux/mfd/abx500.h> 18 #include <linux/mfd/abx500/ab8500.h> 19 #include <linux/delay.h> 20 #include <linux/of.h> 21 22 #define AB8500_RTC_SOFF_STAT_REG 0x00 23 #define AB8500_RTC_CC_CONF_REG 0x01 24 #define AB8500_RTC_READ_REQ_REG 0x02 25 #define AB8500_RTC_WATCH_TSECMID_REG 0x03 26 #define AB8500_RTC_WATCH_TSECHI_REG 0x04 27 #define AB8500_RTC_WATCH_TMIN_LOW_REG 0x05 28 #define AB8500_RTC_WATCH_TMIN_MID_REG 0x06 29 #define AB8500_RTC_WATCH_TMIN_HI_REG 0x07 30 #define AB8500_RTC_ALRM_MIN_LOW_REG 0x08 31 #define AB8500_RTC_ALRM_MIN_MID_REG 0x09 32 #define AB8500_RTC_ALRM_MIN_HI_REG 0x0A 33 #define AB8500_RTC_STAT_REG 0x0B 34 #define AB8500_RTC_BKUP_CHG_REG 0x0C 35 #define AB8500_RTC_FORCE_BKUP_REG 0x0D 36 #define AB8500_RTC_CALIB_REG 0x0E 37 #define AB8500_RTC_SWITCH_STAT_REG 0x0F 38 #define AB8540_RTC_ALRM_SEC 0x22 39 #define AB8540_RTC_ALRM_MIN_LOW_REG 0x23 40 #define AB8540_RTC_ALRM_MIN_MID_REG 0x24 41 #define AB8540_RTC_ALRM_MIN_HI_REG 0x25 42 43 /* RtcReadRequest bits */ 44 #define RTC_READ_REQUEST 0x01 45 #define RTC_WRITE_REQUEST 0x02 46 47 /* RtcCtrl bits */ 48 #define RTC_ALARM_ENA 0x04 49 #define RTC_STATUS_DATA 0x01 50 51 #define COUNTS_PER_SEC (0xF000 / 60) 52 #define AB8500_RTC_EPOCH 2000 53 54 static const u8 ab8500_rtc_time_regs[] = { 55 AB8500_RTC_WATCH_TMIN_HI_REG, AB8500_RTC_WATCH_TMIN_MID_REG, 56 AB8500_RTC_WATCH_TMIN_LOW_REG, AB8500_RTC_WATCH_TSECHI_REG, 57 AB8500_RTC_WATCH_TSECMID_REG 58 }; 59 60 static const u8 ab8500_rtc_alarm_regs[] = { 61 AB8500_RTC_ALRM_MIN_HI_REG, AB8500_RTC_ALRM_MIN_MID_REG, 62 AB8500_RTC_ALRM_MIN_LOW_REG 63 }; 64 65 static const u8 ab8540_rtc_alarm_regs[] = { 66 AB8540_RTC_ALRM_MIN_HI_REG, AB8540_RTC_ALRM_MIN_MID_REG, 67 AB8540_RTC_ALRM_MIN_LOW_REG, AB8540_RTC_ALRM_SEC 68 }; 69 70 /* Calculate the seconds from 1970 to 01-01-2000 00:00:00 */ 71 static unsigned long get_elapsed_seconds(int year) 72 { 73 unsigned long secs; 74 struct rtc_time tm = { 75 .tm_year = year - 1900, 76 .tm_mday = 1, 77 }; 78 79 /* 80 * This function calculates secs from 1970 and not from 81 * 1900, even if we supply the offset from year 1900. 82 */ 83 rtc_tm_to_time(&tm, &secs); 84 return secs; 85 } 86 87 static int ab8500_rtc_read_time(struct device *dev, struct rtc_time *tm) 88 { 89 unsigned long timeout = jiffies + HZ; 90 int retval, i; 91 unsigned long mins, secs; 92 unsigned char buf[ARRAY_SIZE(ab8500_rtc_time_regs)]; 93 u8 value; 94 95 /* Request a data read */ 96 retval = abx500_set_register_interruptible(dev, 97 AB8500_RTC, AB8500_RTC_READ_REQ_REG, RTC_READ_REQUEST); 98 if (retval < 0) 99 return retval; 100 101 /* Wait for some cycles after enabling the rtc read in ab8500 */ 102 while (time_before(jiffies, timeout)) { 103 retval = abx500_get_register_interruptible(dev, 104 AB8500_RTC, AB8500_RTC_READ_REQ_REG, &value); 105 if (retval < 0) 106 return retval; 107 108 if (!(value & RTC_READ_REQUEST)) 109 break; 110 111 usleep_range(1000, 5000); 112 } 113 114 /* Read the Watchtime registers */ 115 for (i = 0; i < ARRAY_SIZE(ab8500_rtc_time_regs); i++) { 116 retval = abx500_get_register_interruptible(dev, 117 AB8500_RTC, ab8500_rtc_time_regs[i], &value); 118 if (retval < 0) 119 return retval; 120 buf[i] = value; 121 } 122 123 mins = (buf[0] << 16) | (buf[1] << 8) | buf[2]; 124 125 secs = (buf[3] << 8) | buf[4]; 126 secs = secs / COUNTS_PER_SEC; 127 secs = secs + (mins * 60); 128 129 /* Add back the initially subtracted number of seconds */ 130 secs += get_elapsed_seconds(AB8500_RTC_EPOCH); 131 132 rtc_time_to_tm(secs, tm); 133 return rtc_valid_tm(tm); 134 } 135 136 static int ab8500_rtc_set_time(struct device *dev, struct rtc_time *tm) 137 { 138 int retval, i; 139 unsigned char buf[ARRAY_SIZE(ab8500_rtc_time_regs)]; 140 unsigned long no_secs, no_mins, secs = 0; 141 142 if (tm->tm_year < (AB8500_RTC_EPOCH - 1900)) { 143 dev_dbg(dev, "year should be equal to or greater than %d\n", 144 AB8500_RTC_EPOCH); 145 return -EINVAL; 146 } 147 148 /* Get the number of seconds since 1970 */ 149 rtc_tm_to_time(tm, &secs); 150 151 /* 152 * Convert it to the number of seconds since 01-01-2000 00:00:00, since 153 * we only have a small counter in the RTC. 154 */ 155 secs -= get_elapsed_seconds(AB8500_RTC_EPOCH); 156 157 no_mins = secs / 60; 158 159 no_secs = secs % 60; 160 /* Make the seconds count as per the RTC resolution */ 161 no_secs = no_secs * COUNTS_PER_SEC; 162 163 buf[4] = no_secs & 0xFF; 164 buf[3] = (no_secs >> 8) & 0xFF; 165 166 buf[2] = no_mins & 0xFF; 167 buf[1] = (no_mins >> 8) & 0xFF; 168 buf[0] = (no_mins >> 16) & 0xFF; 169 170 for (i = 0; i < ARRAY_SIZE(ab8500_rtc_time_regs); i++) { 171 retval = abx500_set_register_interruptible(dev, AB8500_RTC, 172 ab8500_rtc_time_regs[i], buf[i]); 173 if (retval < 0) 174 return retval; 175 } 176 177 /* Request a data write */ 178 return abx500_set_register_interruptible(dev, AB8500_RTC, 179 AB8500_RTC_READ_REQ_REG, RTC_WRITE_REQUEST); 180 } 181 182 static int ab8500_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm) 183 { 184 int retval, i; 185 u8 rtc_ctrl, value; 186 unsigned char buf[ARRAY_SIZE(ab8500_rtc_alarm_regs)]; 187 unsigned long secs, mins; 188 189 /* Check if the alarm is enabled or not */ 190 retval = abx500_get_register_interruptible(dev, AB8500_RTC, 191 AB8500_RTC_STAT_REG, &rtc_ctrl); 192 if (retval < 0) 193 return retval; 194 195 if (rtc_ctrl & RTC_ALARM_ENA) 196 alarm->enabled = 1; 197 else 198 alarm->enabled = 0; 199 200 alarm->pending = 0; 201 202 for (i = 0; i < ARRAY_SIZE(ab8500_rtc_alarm_regs); i++) { 203 retval = abx500_get_register_interruptible(dev, AB8500_RTC, 204 ab8500_rtc_alarm_regs[i], &value); 205 if (retval < 0) 206 return retval; 207 buf[i] = value; 208 } 209 210 mins = (buf[0] << 16) | (buf[1] << 8) | (buf[2]); 211 secs = mins * 60; 212 213 /* Add back the initially subtracted number of seconds */ 214 secs += get_elapsed_seconds(AB8500_RTC_EPOCH); 215 216 rtc_time_to_tm(secs, &alarm->time); 217 218 return rtc_valid_tm(&alarm->time); 219 } 220 221 static int ab8500_rtc_irq_enable(struct device *dev, unsigned int enabled) 222 { 223 return abx500_mask_and_set_register_interruptible(dev, AB8500_RTC, 224 AB8500_RTC_STAT_REG, RTC_ALARM_ENA, 225 enabled ? RTC_ALARM_ENA : 0); 226 } 227 228 static int ab8500_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm) 229 { 230 int retval, i; 231 unsigned char buf[ARRAY_SIZE(ab8500_rtc_alarm_regs)]; 232 unsigned long mins, secs = 0, cursec = 0; 233 struct rtc_time curtm; 234 235 if (alarm->time.tm_year < (AB8500_RTC_EPOCH - 1900)) { 236 dev_dbg(dev, "year should be equal to or greater than %d\n", 237 AB8500_RTC_EPOCH); 238 return -EINVAL; 239 } 240 241 /* Get the number of seconds since 1970 */ 242 rtc_tm_to_time(&alarm->time, &secs); 243 244 /* 245 * Check whether alarm is set less than 1min. 246 * Since our RTC doesn't support alarm resolution less than 1min, 247 * return -EINVAL, so UIE EMUL can take it up, incase of UIE_ON 248 */ 249 ab8500_rtc_read_time(dev, &curtm); /* Read current time */ 250 rtc_tm_to_time(&curtm, &cursec); 251 if ((secs - cursec) < 59) { 252 dev_dbg(dev, "Alarm less than 1 minute not supported\r\n"); 253 return -EINVAL; 254 } 255 256 /* 257 * Convert it to the number of seconds since 01-01-2000 00:00:00, since 258 * we only have a small counter in the RTC. 259 */ 260 secs -= get_elapsed_seconds(AB8500_RTC_EPOCH); 261 262 mins = secs / 60; 263 264 buf[2] = mins & 0xFF; 265 buf[1] = (mins >> 8) & 0xFF; 266 buf[0] = (mins >> 16) & 0xFF; 267 268 /* Set the alarm time */ 269 for (i = 0; i < ARRAY_SIZE(ab8500_rtc_alarm_regs); i++) { 270 retval = abx500_set_register_interruptible(dev, AB8500_RTC, 271 ab8500_rtc_alarm_regs[i], buf[i]); 272 if (retval < 0) 273 return retval; 274 } 275 276 return ab8500_rtc_irq_enable(dev, alarm->enabled); 277 } 278 279 static int ab8540_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm) 280 { 281 int retval, i; 282 unsigned char buf[ARRAY_SIZE(ab8540_rtc_alarm_regs)]; 283 unsigned long mins, secs = 0; 284 285 if (alarm->time.tm_year < (AB8500_RTC_EPOCH - 1900)) { 286 dev_dbg(dev, "year should be equal to or greater than %d\n", 287 AB8500_RTC_EPOCH); 288 return -EINVAL; 289 } 290 291 /* Get the number of seconds since 1970 */ 292 rtc_tm_to_time(&alarm->time, &secs); 293 294 /* 295 * Convert it to the number of seconds since 01-01-2000 00:00:00 296 */ 297 secs -= get_elapsed_seconds(AB8500_RTC_EPOCH); 298 mins = secs / 60; 299 300 buf[3] = secs % 60; 301 buf[2] = mins & 0xFF; 302 buf[1] = (mins >> 8) & 0xFF; 303 buf[0] = (mins >> 16) & 0xFF; 304 305 /* Set the alarm time */ 306 for (i = 0; i < ARRAY_SIZE(ab8540_rtc_alarm_regs); i++) { 307 retval = abx500_set_register_interruptible(dev, AB8500_RTC, 308 ab8540_rtc_alarm_regs[i], buf[i]); 309 if (retval < 0) 310 return retval; 311 } 312 313 return ab8500_rtc_irq_enable(dev, alarm->enabled); 314 } 315 316 static int ab8500_rtc_set_calibration(struct device *dev, int calibration) 317 { 318 int retval; 319 u8 rtccal = 0; 320 321 /* 322 * Check that the calibration value (which is in units of 0.5 323 * parts-per-million) is in the AB8500's range for RtcCalibration 324 * register. -128 (0x80) is not permitted because the AB8500 uses 325 * a sign-bit rather than two's complement, so 0x80 is just another 326 * representation of zero. 327 */ 328 if ((calibration < -127) || (calibration > 127)) { 329 dev_err(dev, "RtcCalibration value outside permitted range\n"); 330 return -EINVAL; 331 } 332 333 /* 334 * The AB8500 uses sign (in bit7) and magnitude (in bits0-7) 335 * so need to convert to this sort of representation before writing 336 * into RtcCalibration register... 337 */ 338 if (calibration >= 0) 339 rtccal = 0x7F & calibration; 340 else 341 rtccal = ~(calibration - 1) | 0x80; 342 343 retval = abx500_set_register_interruptible(dev, AB8500_RTC, 344 AB8500_RTC_CALIB_REG, rtccal); 345 346 return retval; 347 } 348 349 static int ab8500_rtc_get_calibration(struct device *dev, int *calibration) 350 { 351 int retval; 352 u8 rtccal = 0; 353 354 retval = abx500_get_register_interruptible(dev, AB8500_RTC, 355 AB8500_RTC_CALIB_REG, &rtccal); 356 if (retval >= 0) { 357 /* 358 * The AB8500 uses sign (in bit7) and magnitude (in bits0-7) 359 * so need to convert value from RtcCalibration register into 360 * a two's complement signed value... 361 */ 362 if (rtccal & 0x80) 363 *calibration = 0 - (rtccal & 0x7F); 364 else 365 *calibration = 0x7F & rtccal; 366 } 367 368 return retval; 369 } 370 371 static ssize_t ab8500_sysfs_store_rtc_calibration(struct device *dev, 372 struct device_attribute *attr, 373 const char *buf, size_t count) 374 { 375 int retval; 376 int calibration = 0; 377 378 if (sscanf(buf, " %i ", &calibration) != 1) { 379 dev_err(dev, "Failed to store RTC calibration attribute\n"); 380 return -EINVAL; 381 } 382 383 retval = ab8500_rtc_set_calibration(dev, calibration); 384 385 return retval ? retval : count; 386 } 387 388 static ssize_t ab8500_sysfs_show_rtc_calibration(struct device *dev, 389 struct device_attribute *attr, char *buf) 390 { 391 int retval = 0; 392 int calibration = 0; 393 394 retval = ab8500_rtc_get_calibration(dev, &calibration); 395 if (retval < 0) { 396 dev_err(dev, "Failed to read RTC calibration attribute\n"); 397 sprintf(buf, "0\n"); 398 return retval; 399 } 400 401 return sprintf(buf, "%d\n", calibration); 402 } 403 404 static DEVICE_ATTR(rtc_calibration, S_IRUGO | S_IWUSR, 405 ab8500_sysfs_show_rtc_calibration, 406 ab8500_sysfs_store_rtc_calibration); 407 408 static int ab8500_sysfs_rtc_register(struct device *dev) 409 { 410 return device_create_file(dev, &dev_attr_rtc_calibration); 411 } 412 413 static void ab8500_sysfs_rtc_unregister(struct device *dev) 414 { 415 device_remove_file(dev, &dev_attr_rtc_calibration); 416 } 417 418 static irqreturn_t rtc_alarm_handler(int irq, void *data) 419 { 420 struct rtc_device *rtc = data; 421 unsigned long events = RTC_IRQF | RTC_AF; 422 423 dev_dbg(&rtc->dev, "%s\n", __func__); 424 rtc_update_irq(rtc, 1, events); 425 426 return IRQ_HANDLED; 427 } 428 429 static const struct rtc_class_ops ab8500_rtc_ops = { 430 .read_time = ab8500_rtc_read_time, 431 .set_time = ab8500_rtc_set_time, 432 .read_alarm = ab8500_rtc_read_alarm, 433 .set_alarm = ab8500_rtc_set_alarm, 434 .alarm_irq_enable = ab8500_rtc_irq_enable, 435 }; 436 437 static const struct rtc_class_ops ab8540_rtc_ops = { 438 .read_time = ab8500_rtc_read_time, 439 .set_time = ab8500_rtc_set_time, 440 .read_alarm = ab8500_rtc_read_alarm, 441 .set_alarm = ab8540_rtc_set_alarm, 442 .alarm_irq_enable = ab8500_rtc_irq_enable, 443 }; 444 445 static struct platform_device_id ab85xx_rtc_ids[] = { 446 { "ab8500-rtc", (kernel_ulong_t)&ab8500_rtc_ops, }, 447 { "ab8540-rtc", (kernel_ulong_t)&ab8540_rtc_ops, }, 448 }; 449 450 static int ab8500_rtc_probe(struct platform_device *pdev) 451 { 452 const struct platform_device_id *platid = platform_get_device_id(pdev); 453 int err; 454 struct rtc_device *rtc; 455 u8 rtc_ctrl; 456 int irq; 457 458 irq = platform_get_irq_byname(pdev, "ALARM"); 459 if (irq < 0) 460 return irq; 461 462 /* For RTC supply test */ 463 err = abx500_mask_and_set_register_interruptible(&pdev->dev, AB8500_RTC, 464 AB8500_RTC_STAT_REG, RTC_STATUS_DATA, RTC_STATUS_DATA); 465 if (err < 0) 466 return err; 467 468 /* Wait for reset by the PorRtc */ 469 usleep_range(1000, 5000); 470 471 err = abx500_get_register_interruptible(&pdev->dev, AB8500_RTC, 472 AB8500_RTC_STAT_REG, &rtc_ctrl); 473 if (err < 0) 474 return err; 475 476 /* Check if the RTC Supply fails */ 477 if (!(rtc_ctrl & RTC_STATUS_DATA)) { 478 dev_err(&pdev->dev, "RTC supply failure\n"); 479 return -ENODEV; 480 } 481 482 device_init_wakeup(&pdev->dev, true); 483 484 rtc = devm_rtc_device_register(&pdev->dev, "ab8500-rtc", 485 (struct rtc_class_ops *)platid->driver_data, 486 THIS_MODULE); 487 if (IS_ERR(rtc)) { 488 dev_err(&pdev->dev, "Registration failed\n"); 489 err = PTR_ERR(rtc); 490 return err; 491 } 492 493 err = devm_request_threaded_irq(&pdev->dev, irq, NULL, 494 rtc_alarm_handler, IRQF_NO_SUSPEND | IRQF_ONESHOT, 495 "ab8500-rtc", rtc); 496 if (err < 0) 497 return err; 498 499 platform_set_drvdata(pdev, rtc); 500 501 err = ab8500_sysfs_rtc_register(&pdev->dev); 502 if (err) { 503 dev_err(&pdev->dev, "sysfs RTC failed to register\n"); 504 return err; 505 } 506 507 rtc->uie_unsupported = 1; 508 509 return 0; 510 } 511 512 static int ab8500_rtc_remove(struct platform_device *pdev) 513 { 514 ab8500_sysfs_rtc_unregister(&pdev->dev); 515 516 return 0; 517 } 518 519 static struct platform_driver ab8500_rtc_driver = { 520 .driver = { 521 .name = "ab8500-rtc", 522 }, 523 .probe = ab8500_rtc_probe, 524 .remove = ab8500_rtc_remove, 525 .id_table = ab85xx_rtc_ids, 526 }; 527 528 module_platform_driver(ab8500_rtc_driver); 529 530 MODULE_AUTHOR("Virupax Sadashivpetimath <virupax.sadashivpetimath@stericsson.com>"); 531 MODULE_DESCRIPTION("AB8500 RTC Driver"); 532 MODULE_LICENSE("GPL v2"); 533