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 #include <linux/pm_wakeirq.h> 22 23 #define AB8500_RTC_SOFF_STAT_REG 0x00 24 #define AB8500_RTC_CC_CONF_REG 0x01 25 #define AB8500_RTC_READ_REQ_REG 0x02 26 #define AB8500_RTC_WATCH_TSECMID_REG 0x03 27 #define AB8500_RTC_WATCH_TSECHI_REG 0x04 28 #define AB8500_RTC_WATCH_TMIN_LOW_REG 0x05 29 #define AB8500_RTC_WATCH_TMIN_MID_REG 0x06 30 #define AB8500_RTC_WATCH_TMIN_HI_REG 0x07 31 #define AB8500_RTC_ALRM_MIN_LOW_REG 0x08 32 #define AB8500_RTC_ALRM_MIN_MID_REG 0x09 33 #define AB8500_RTC_ALRM_MIN_HI_REG 0x0A 34 #define AB8500_RTC_STAT_REG 0x0B 35 #define AB8500_RTC_BKUP_CHG_REG 0x0C 36 #define AB8500_RTC_FORCE_BKUP_REG 0x0D 37 #define AB8500_RTC_CALIB_REG 0x0E 38 #define AB8500_RTC_SWITCH_STAT_REG 0x0F 39 40 /* RtcReadRequest bits */ 41 #define RTC_READ_REQUEST 0x01 42 #define RTC_WRITE_REQUEST 0x02 43 44 /* RtcCtrl bits */ 45 #define RTC_ALARM_ENA 0x04 46 #define RTC_STATUS_DATA 0x01 47 48 #define COUNTS_PER_SEC (0xF000 / 60) 49 #define AB8500_RTC_EPOCH 2000 50 51 static const u8 ab8500_rtc_time_regs[] = { 52 AB8500_RTC_WATCH_TMIN_HI_REG, AB8500_RTC_WATCH_TMIN_MID_REG, 53 AB8500_RTC_WATCH_TMIN_LOW_REG, AB8500_RTC_WATCH_TSECHI_REG, 54 AB8500_RTC_WATCH_TSECMID_REG 55 }; 56 57 static const u8 ab8500_rtc_alarm_regs[] = { 58 AB8500_RTC_ALRM_MIN_HI_REG, AB8500_RTC_ALRM_MIN_MID_REG, 59 AB8500_RTC_ALRM_MIN_LOW_REG 60 }; 61 62 /* Calculate the seconds from 1970 to 01-01-2000 00:00:00 */ 63 static unsigned long get_elapsed_seconds(int year) 64 { 65 unsigned long secs; 66 struct rtc_time tm = { 67 .tm_year = year - 1900, 68 .tm_mday = 1, 69 }; 70 71 /* 72 * This function calculates secs from 1970 and not from 73 * 1900, even if we supply the offset from year 1900. 74 */ 75 rtc_tm_to_time(&tm, &secs); 76 return secs; 77 } 78 79 static int ab8500_rtc_read_time(struct device *dev, struct rtc_time *tm) 80 { 81 unsigned long timeout = jiffies + HZ; 82 int retval, i; 83 unsigned long mins, secs; 84 unsigned char buf[ARRAY_SIZE(ab8500_rtc_time_regs)]; 85 u8 value; 86 87 /* Request a data read */ 88 retval = abx500_set_register_interruptible(dev, 89 AB8500_RTC, AB8500_RTC_READ_REQ_REG, RTC_READ_REQUEST); 90 if (retval < 0) 91 return retval; 92 93 /* Wait for some cycles after enabling the rtc read in ab8500 */ 94 while (time_before(jiffies, timeout)) { 95 retval = abx500_get_register_interruptible(dev, 96 AB8500_RTC, AB8500_RTC_READ_REQ_REG, &value); 97 if (retval < 0) 98 return retval; 99 100 if (!(value & RTC_READ_REQUEST)) 101 break; 102 103 usleep_range(1000, 5000); 104 } 105 106 /* Read the Watchtime registers */ 107 for (i = 0; i < ARRAY_SIZE(ab8500_rtc_time_regs); i++) { 108 retval = abx500_get_register_interruptible(dev, 109 AB8500_RTC, ab8500_rtc_time_regs[i], &value); 110 if (retval < 0) 111 return retval; 112 buf[i] = value; 113 } 114 115 mins = (buf[0] << 16) | (buf[1] << 8) | buf[2]; 116 117 secs = (buf[3] << 8) | buf[4]; 118 secs = secs / COUNTS_PER_SEC; 119 secs = secs + (mins * 60); 120 121 /* Add back the initially subtracted number of seconds */ 122 secs += get_elapsed_seconds(AB8500_RTC_EPOCH); 123 124 rtc_time_to_tm(secs, tm); 125 return 0; 126 } 127 128 static int ab8500_rtc_set_time(struct device *dev, struct rtc_time *tm) 129 { 130 int retval, i; 131 unsigned char buf[ARRAY_SIZE(ab8500_rtc_time_regs)]; 132 unsigned long no_secs, no_mins, secs = 0; 133 134 if (tm->tm_year < (AB8500_RTC_EPOCH - 1900)) { 135 dev_dbg(dev, "year should be equal to or greater than %d\n", 136 AB8500_RTC_EPOCH); 137 return -EINVAL; 138 } 139 140 /* Get the number of seconds since 1970 */ 141 rtc_tm_to_time(tm, &secs); 142 143 /* 144 * Convert it to the number of seconds since 01-01-2000 00:00:00, since 145 * we only have a small counter in the RTC. 146 */ 147 secs -= get_elapsed_seconds(AB8500_RTC_EPOCH); 148 149 no_mins = secs / 60; 150 151 no_secs = secs % 60; 152 /* Make the seconds count as per the RTC resolution */ 153 no_secs = no_secs * COUNTS_PER_SEC; 154 155 buf[4] = no_secs & 0xFF; 156 buf[3] = (no_secs >> 8) & 0xFF; 157 158 buf[2] = no_mins & 0xFF; 159 buf[1] = (no_mins >> 8) & 0xFF; 160 buf[0] = (no_mins >> 16) & 0xFF; 161 162 for (i = 0; i < ARRAY_SIZE(ab8500_rtc_time_regs); i++) { 163 retval = abx500_set_register_interruptible(dev, AB8500_RTC, 164 ab8500_rtc_time_regs[i], buf[i]); 165 if (retval < 0) 166 return retval; 167 } 168 169 /* Request a data write */ 170 return abx500_set_register_interruptible(dev, AB8500_RTC, 171 AB8500_RTC_READ_REQ_REG, RTC_WRITE_REQUEST); 172 } 173 174 static int ab8500_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm) 175 { 176 int retval, i; 177 u8 rtc_ctrl, value; 178 unsigned char buf[ARRAY_SIZE(ab8500_rtc_alarm_regs)]; 179 unsigned long secs, mins; 180 181 /* Check if the alarm is enabled or not */ 182 retval = abx500_get_register_interruptible(dev, AB8500_RTC, 183 AB8500_RTC_STAT_REG, &rtc_ctrl); 184 if (retval < 0) 185 return retval; 186 187 if (rtc_ctrl & RTC_ALARM_ENA) 188 alarm->enabled = 1; 189 else 190 alarm->enabled = 0; 191 192 alarm->pending = 0; 193 194 for (i = 0; i < ARRAY_SIZE(ab8500_rtc_alarm_regs); i++) { 195 retval = abx500_get_register_interruptible(dev, AB8500_RTC, 196 ab8500_rtc_alarm_regs[i], &value); 197 if (retval < 0) 198 return retval; 199 buf[i] = value; 200 } 201 202 mins = (buf[0] << 16) | (buf[1] << 8) | (buf[2]); 203 secs = mins * 60; 204 205 /* Add back the initially subtracted number of seconds */ 206 secs += get_elapsed_seconds(AB8500_RTC_EPOCH); 207 208 rtc_time_to_tm(secs, &alarm->time); 209 210 return rtc_valid_tm(&alarm->time); 211 } 212 213 static int ab8500_rtc_irq_enable(struct device *dev, unsigned int enabled) 214 { 215 return abx500_mask_and_set_register_interruptible(dev, AB8500_RTC, 216 AB8500_RTC_STAT_REG, RTC_ALARM_ENA, 217 enabled ? RTC_ALARM_ENA : 0); 218 } 219 220 static int ab8500_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm) 221 { 222 int retval, i; 223 unsigned char buf[ARRAY_SIZE(ab8500_rtc_alarm_regs)]; 224 unsigned long mins, secs = 0, cursec = 0; 225 struct rtc_time curtm; 226 227 if (alarm->time.tm_year < (AB8500_RTC_EPOCH - 1900)) { 228 dev_dbg(dev, "year should be equal to or greater than %d\n", 229 AB8500_RTC_EPOCH); 230 return -EINVAL; 231 } 232 233 /* Get the number of seconds since 1970 */ 234 rtc_tm_to_time(&alarm->time, &secs); 235 236 /* 237 * Check whether alarm is set less than 1min. 238 * Since our RTC doesn't support alarm resolution less than 1min, 239 * return -EINVAL, so UIE EMUL can take it up, incase of UIE_ON 240 */ 241 ab8500_rtc_read_time(dev, &curtm); /* Read current time */ 242 rtc_tm_to_time(&curtm, &cursec); 243 if ((secs - cursec) < 59) { 244 dev_dbg(dev, "Alarm less than 1 minute not supported\r\n"); 245 return -EINVAL; 246 } 247 248 /* 249 * Convert it to the number of seconds since 01-01-2000 00:00:00, since 250 * we only have a small counter in the RTC. 251 */ 252 secs -= get_elapsed_seconds(AB8500_RTC_EPOCH); 253 254 mins = secs / 60; 255 256 buf[2] = mins & 0xFF; 257 buf[1] = (mins >> 8) & 0xFF; 258 buf[0] = (mins >> 16) & 0xFF; 259 260 /* Set the alarm time */ 261 for (i = 0; i < ARRAY_SIZE(ab8500_rtc_alarm_regs); i++) { 262 retval = abx500_set_register_interruptible(dev, AB8500_RTC, 263 ab8500_rtc_alarm_regs[i], buf[i]); 264 if (retval < 0) 265 return retval; 266 } 267 268 return ab8500_rtc_irq_enable(dev, alarm->enabled); 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 const struct platform_device_id ab85xx_rtc_ids[] = { 393 { "ab8500-rtc", (kernel_ulong_t)&ab8500_rtc_ops, }, 394 { /* sentinel */ } 395 }; 396 MODULE_DEVICE_TABLE(platform, ab85xx_rtc_ids); 397 398 static int ab8500_rtc_probe(struct platform_device *pdev) 399 { 400 const struct platform_device_id *platid = platform_get_device_id(pdev); 401 int err; 402 struct rtc_device *rtc; 403 u8 rtc_ctrl; 404 int irq; 405 406 irq = platform_get_irq_byname(pdev, "ALARM"); 407 if (irq < 0) 408 return irq; 409 410 /* For RTC supply test */ 411 err = abx500_mask_and_set_register_interruptible(&pdev->dev, AB8500_RTC, 412 AB8500_RTC_STAT_REG, RTC_STATUS_DATA, RTC_STATUS_DATA); 413 if (err < 0) 414 return err; 415 416 /* Wait for reset by the PorRtc */ 417 usleep_range(1000, 5000); 418 419 err = abx500_get_register_interruptible(&pdev->dev, AB8500_RTC, 420 AB8500_RTC_STAT_REG, &rtc_ctrl); 421 if (err < 0) 422 return err; 423 424 /* Check if the RTC Supply fails */ 425 if (!(rtc_ctrl & RTC_STATUS_DATA)) { 426 dev_err(&pdev->dev, "RTC supply failure\n"); 427 return -ENODEV; 428 } 429 430 device_init_wakeup(&pdev->dev, true); 431 432 rtc = devm_rtc_device_register(&pdev->dev, "ab8500-rtc", 433 (struct rtc_class_ops *)platid->driver_data, 434 THIS_MODULE); 435 if (IS_ERR(rtc)) { 436 dev_err(&pdev->dev, "Registration failed\n"); 437 err = PTR_ERR(rtc); 438 return err; 439 } 440 441 err = devm_request_threaded_irq(&pdev->dev, irq, NULL, 442 rtc_alarm_handler, IRQF_ONESHOT, 443 "ab8500-rtc", rtc); 444 if (err < 0) 445 return err; 446 447 dev_pm_set_wake_irq(&pdev->dev, irq); 448 platform_set_drvdata(pdev, rtc); 449 450 err = ab8500_sysfs_rtc_register(&pdev->dev); 451 if (err) { 452 dev_err(&pdev->dev, "sysfs RTC failed to register\n"); 453 return err; 454 } 455 456 rtc->uie_unsupported = 1; 457 458 return 0; 459 } 460 461 static int ab8500_rtc_remove(struct platform_device *pdev) 462 { 463 dev_pm_clear_wake_irq(&pdev->dev); 464 device_init_wakeup(&pdev->dev, false); 465 ab8500_sysfs_rtc_unregister(&pdev->dev); 466 467 return 0; 468 } 469 470 static struct platform_driver ab8500_rtc_driver = { 471 .driver = { 472 .name = "ab8500-rtc", 473 }, 474 .probe = ab8500_rtc_probe, 475 .remove = ab8500_rtc_remove, 476 .id_table = ab85xx_rtc_ids, 477 }; 478 479 module_platform_driver(ab8500_rtc_driver); 480 481 MODULE_AUTHOR("Virupax Sadashivpetimath <virupax.sadashivpetimath@stericsson.com>"); 482 MODULE_DESCRIPTION("AB8500 RTC Driver"); 483 MODULE_LICENSE("GPL v2"); 484