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