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