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