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 /* 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; 229 230 if (alarm->time.tm_year < (AB8500_RTC_EPOCH - 1900)) { 231 dev_dbg(dev, "year should be equal to or greater than %d\n", 232 AB8500_RTC_EPOCH); 233 return -EINVAL; 234 } 235 236 /* Get the number of seconds since 1970 */ 237 rtc_tm_to_time(&alarm->time, &secs); 238 239 /* 240 * Convert it to the number of seconds since 01-01-2000 00:00:00, since 241 * we only have a small counter in the RTC. 242 */ 243 secs -= get_elapsed_seconds(AB8500_RTC_EPOCH); 244 245 mins = secs / 60; 246 247 buf[2] = mins & 0xFF; 248 buf[1] = (mins >> 8) & 0xFF; 249 buf[0] = (mins >> 16) & 0xFF; 250 251 /* Set the alarm time */ 252 for (i = 0; i < ARRAY_SIZE(ab8500_rtc_alarm_regs); i++) { 253 retval = abx500_set_register_interruptible(dev, AB8500_RTC, 254 ab8500_rtc_alarm_regs[i], buf[i]); 255 if (retval < 0) 256 return retval; 257 } 258 259 return ab8500_rtc_irq_enable(dev, alarm->enabled); 260 } 261 262 263 static int ab8500_rtc_set_calibration(struct device *dev, int calibration) 264 { 265 int retval; 266 u8 rtccal = 0; 267 268 /* 269 * Check that the calibration value (which is in units of 0.5 270 * parts-per-million) is in the AB8500's range for RtcCalibration 271 * register. -128 (0x80) is not permitted because the AB8500 uses 272 * a sign-bit rather than two's complement, so 0x80 is just another 273 * representation of zero. 274 */ 275 if ((calibration < -127) || (calibration > 127)) { 276 dev_err(dev, "RtcCalibration value outside permitted range\n"); 277 return -EINVAL; 278 } 279 280 /* 281 * The AB8500 uses sign (in bit7) and magnitude (in bits0-7) 282 * so need to convert to this sort of representation before writing 283 * into RtcCalibration register... 284 */ 285 if (calibration >= 0) 286 rtccal = 0x7F & calibration; 287 else 288 rtccal = ~(calibration - 1) | 0x80; 289 290 retval = abx500_set_register_interruptible(dev, AB8500_RTC, 291 AB8500_RTC_CALIB_REG, rtccal); 292 293 return retval; 294 } 295 296 static int ab8500_rtc_get_calibration(struct device *dev, int *calibration) 297 { 298 int retval; 299 u8 rtccal = 0; 300 301 retval = abx500_get_register_interruptible(dev, AB8500_RTC, 302 AB8500_RTC_CALIB_REG, &rtccal); 303 if (retval >= 0) { 304 /* 305 * The AB8500 uses sign (in bit7) and magnitude (in bits0-7) 306 * so need to convert value from RtcCalibration register into 307 * a two's complement signed value... 308 */ 309 if (rtccal & 0x80) 310 *calibration = 0 - (rtccal & 0x7F); 311 else 312 *calibration = 0x7F & rtccal; 313 } 314 315 return retval; 316 } 317 318 static ssize_t ab8500_sysfs_store_rtc_calibration(struct device *dev, 319 struct device_attribute *attr, 320 const char *buf, size_t count) 321 { 322 int retval; 323 int calibration = 0; 324 325 if (sscanf(buf, " %i ", &calibration) != 1) { 326 dev_err(dev, "Failed to store RTC calibration attribute\n"); 327 return -EINVAL; 328 } 329 330 retval = ab8500_rtc_set_calibration(dev, calibration); 331 332 return retval ? retval : count; 333 } 334 335 static ssize_t ab8500_sysfs_show_rtc_calibration(struct device *dev, 336 struct device_attribute *attr, char *buf) 337 { 338 int retval = 0; 339 int calibration = 0; 340 341 retval = ab8500_rtc_get_calibration(dev, &calibration); 342 if (retval < 0) { 343 dev_err(dev, "Failed to read RTC calibration attribute\n"); 344 sprintf(buf, "0\n"); 345 return retval; 346 } 347 348 return sprintf(buf, "%d\n", calibration); 349 } 350 351 static DEVICE_ATTR(rtc_calibration, S_IRUGO | S_IWUSR, 352 ab8500_sysfs_show_rtc_calibration, 353 ab8500_sysfs_store_rtc_calibration); 354 355 static int ab8500_sysfs_rtc_register(struct device *dev) 356 { 357 return device_create_file(dev, &dev_attr_rtc_calibration); 358 } 359 360 static void ab8500_sysfs_rtc_unregister(struct device *dev) 361 { 362 device_remove_file(dev, &dev_attr_rtc_calibration); 363 } 364 365 static irqreturn_t rtc_alarm_handler(int irq, void *data) 366 { 367 struct rtc_device *rtc = data; 368 unsigned long events = RTC_IRQF | RTC_AF; 369 370 dev_dbg(&rtc->dev, "%s\n", __func__); 371 rtc_update_irq(rtc, 1, events); 372 373 return IRQ_HANDLED; 374 } 375 376 static const struct rtc_class_ops ab8500_rtc_ops = { 377 .read_time = ab8500_rtc_read_time, 378 .set_time = ab8500_rtc_set_time, 379 .read_alarm = ab8500_rtc_read_alarm, 380 .set_alarm = ab8500_rtc_set_alarm, 381 .alarm_irq_enable = ab8500_rtc_irq_enable, 382 }; 383 384 static int __devinit ab8500_rtc_probe(struct platform_device *pdev) 385 { 386 int err; 387 struct rtc_device *rtc; 388 u8 rtc_ctrl; 389 int irq; 390 391 irq = platform_get_irq_byname(pdev, "ALARM"); 392 if (irq < 0) 393 return irq; 394 395 /* For RTC supply test */ 396 err = abx500_mask_and_set_register_interruptible(&pdev->dev, AB8500_RTC, 397 AB8500_RTC_STAT_REG, RTC_STATUS_DATA, RTC_STATUS_DATA); 398 if (err < 0) 399 return err; 400 401 /* Wait for reset by the PorRtc */ 402 usleep_range(1000, 5000); 403 404 err = abx500_get_register_interruptible(&pdev->dev, AB8500_RTC, 405 AB8500_RTC_STAT_REG, &rtc_ctrl); 406 if (err < 0) 407 return err; 408 409 /* Check if the RTC Supply fails */ 410 if (!(rtc_ctrl & RTC_STATUS_DATA)) { 411 dev_err(&pdev->dev, "RTC supply failure\n"); 412 return -ENODEV; 413 } 414 415 device_init_wakeup(&pdev->dev, true); 416 417 rtc = rtc_device_register("ab8500-rtc", &pdev->dev, &ab8500_rtc_ops, 418 THIS_MODULE); 419 if (IS_ERR(rtc)) { 420 dev_err(&pdev->dev, "Registration failed\n"); 421 err = PTR_ERR(rtc); 422 return err; 423 } 424 425 err = request_threaded_irq(irq, NULL, rtc_alarm_handler, 426 IRQF_NO_SUSPEND | IRQF_ONESHOT, "ab8500-rtc", rtc); 427 if (err < 0) { 428 rtc_device_unregister(rtc); 429 return err; 430 } 431 432 platform_set_drvdata(pdev, rtc); 433 434 err = ab8500_sysfs_rtc_register(&pdev->dev); 435 if (err) { 436 dev_err(&pdev->dev, "sysfs RTC failed to register\n"); 437 return err; 438 } 439 440 return 0; 441 } 442 443 static int __devexit ab8500_rtc_remove(struct platform_device *pdev) 444 { 445 struct rtc_device *rtc = platform_get_drvdata(pdev); 446 int irq = platform_get_irq_byname(pdev, "ALARM"); 447 448 ab8500_sysfs_rtc_unregister(&pdev->dev); 449 450 free_irq(irq, rtc); 451 rtc_device_unregister(rtc); 452 platform_set_drvdata(pdev, NULL); 453 454 return 0; 455 } 456 457 static const struct of_device_id ab8500_rtc_match[] = { 458 { .compatible = "stericsson,ab8500-rtc", }, 459 {} 460 }; 461 462 static struct platform_driver ab8500_rtc_driver = { 463 .driver = { 464 .name = "ab8500-rtc", 465 .owner = THIS_MODULE, 466 .of_match_table = ab8500_rtc_match, 467 }, 468 .probe = ab8500_rtc_probe, 469 .remove = __devexit_p(ab8500_rtc_remove), 470 }; 471 472 module_platform_driver(ab8500_rtc_driver); 473 474 MODULE_AUTHOR("Virupax Sadashivpetimath <virupax.sadashivpetimath@stericsson.com>"); 475 MODULE_DESCRIPTION("AB8500 RTC Driver"); 476 MODULE_LICENSE("GPL v2"); 477