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_time64_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 secs = rtc_tm_to_time64(tm); 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_time64_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; 188 189 mins = (unsigned long)rtc_tm_to_time64(&alarm->time) / 60; 190 191 buf[2] = mins & 0xFF; 192 buf[1] = (mins >> 8) & 0xFF; 193 buf[0] = (mins >> 16) & 0xFF; 194 195 /* Set the alarm time */ 196 for (i = 0; i < ARRAY_SIZE(ab8500_rtc_alarm_regs); i++) { 197 retval = abx500_set_register_interruptible(dev, AB8500_RTC, 198 ab8500_rtc_alarm_regs[i], buf[i]); 199 if (retval < 0) 200 return retval; 201 } 202 203 return ab8500_rtc_irq_enable(dev, alarm->enabled); 204 } 205 206 static int ab8500_rtc_set_calibration(struct device *dev, int calibration) 207 { 208 int retval; 209 u8 rtccal = 0; 210 211 /* 212 * Check that the calibration value (which is in units of 0.5 213 * parts-per-million) is in the AB8500's range for RtcCalibration 214 * register. -128 (0x80) is not permitted because the AB8500 uses 215 * a sign-bit rather than two's complement, so 0x80 is just another 216 * representation of zero. 217 */ 218 if ((calibration < -127) || (calibration > 127)) { 219 dev_err(dev, "RtcCalibration value outside permitted range\n"); 220 return -EINVAL; 221 } 222 223 /* 224 * The AB8500 uses sign (in bit7) and magnitude (in bits0-7) 225 * so need to convert to this sort of representation before writing 226 * into RtcCalibration register... 227 */ 228 if (calibration >= 0) 229 rtccal = 0x7F & calibration; 230 else 231 rtccal = ~(calibration - 1) | 0x80; 232 233 retval = abx500_set_register_interruptible(dev, AB8500_RTC, 234 AB8500_RTC_CALIB_REG, rtccal); 235 236 return retval; 237 } 238 239 static int ab8500_rtc_get_calibration(struct device *dev, int *calibration) 240 { 241 int retval; 242 u8 rtccal = 0; 243 244 retval = abx500_get_register_interruptible(dev, AB8500_RTC, 245 AB8500_RTC_CALIB_REG, &rtccal); 246 if (retval >= 0) { 247 /* 248 * The AB8500 uses sign (in bit7) and magnitude (in bits0-7) 249 * so need to convert value from RtcCalibration register into 250 * a two's complement signed value... 251 */ 252 if (rtccal & 0x80) 253 *calibration = 0 - (rtccal & 0x7F); 254 else 255 *calibration = 0x7F & rtccal; 256 } 257 258 return retval; 259 } 260 261 static ssize_t ab8500_sysfs_store_rtc_calibration(struct device *dev, 262 struct device_attribute *attr, 263 const char *buf, size_t count) 264 { 265 int retval; 266 int calibration = 0; 267 268 if (sscanf(buf, " %i ", &calibration) != 1) { 269 dev_err(dev, "Failed to store RTC calibration attribute\n"); 270 return -EINVAL; 271 } 272 273 retval = ab8500_rtc_set_calibration(dev, calibration); 274 275 return retval ? retval : count; 276 } 277 278 static ssize_t ab8500_sysfs_show_rtc_calibration(struct device *dev, 279 struct device_attribute *attr, char *buf) 280 { 281 int retval = 0; 282 int calibration = 0; 283 284 retval = ab8500_rtc_get_calibration(dev, &calibration); 285 if (retval < 0) { 286 dev_err(dev, "Failed to read RTC calibration attribute\n"); 287 sprintf(buf, "0\n"); 288 return retval; 289 } 290 291 return sprintf(buf, "%d\n", calibration); 292 } 293 294 static DEVICE_ATTR(rtc_calibration, S_IRUGO | S_IWUSR, 295 ab8500_sysfs_show_rtc_calibration, 296 ab8500_sysfs_store_rtc_calibration); 297 298 static struct attribute *ab8500_rtc_attrs[] = { 299 &dev_attr_rtc_calibration.attr, 300 NULL 301 }; 302 303 static const struct attribute_group ab8500_rtc_sysfs_files = { 304 .attrs = ab8500_rtc_attrs, 305 }; 306 307 static irqreturn_t rtc_alarm_handler(int irq, void *data) 308 { 309 struct rtc_device *rtc = data; 310 unsigned long events = RTC_IRQF | RTC_AF; 311 312 dev_dbg(&rtc->dev, "%s\n", __func__); 313 rtc_update_irq(rtc, 1, events); 314 315 return IRQ_HANDLED; 316 } 317 318 static const struct rtc_class_ops ab8500_rtc_ops = { 319 .read_time = ab8500_rtc_read_time, 320 .set_time = ab8500_rtc_set_time, 321 .read_alarm = ab8500_rtc_read_alarm, 322 .set_alarm = ab8500_rtc_set_alarm, 323 .alarm_irq_enable = ab8500_rtc_irq_enable, 324 }; 325 326 static const struct platform_device_id ab85xx_rtc_ids[] = { 327 { "ab8500-rtc", (kernel_ulong_t)&ab8500_rtc_ops, }, 328 { /* sentinel */ } 329 }; 330 MODULE_DEVICE_TABLE(platform, ab85xx_rtc_ids); 331 332 static int ab8500_rtc_probe(struct platform_device *pdev) 333 { 334 const struct platform_device_id *platid = platform_get_device_id(pdev); 335 int err; 336 struct rtc_device *rtc; 337 u8 rtc_ctrl; 338 int irq; 339 340 irq = platform_get_irq_byname(pdev, "ALARM"); 341 if (irq < 0) 342 return irq; 343 344 /* For RTC supply test */ 345 err = abx500_mask_and_set_register_interruptible(&pdev->dev, AB8500_RTC, 346 AB8500_RTC_STAT_REG, RTC_STATUS_DATA, RTC_STATUS_DATA); 347 if (err < 0) 348 return err; 349 350 /* Wait for reset by the PorRtc */ 351 usleep_range(1000, 5000); 352 353 err = abx500_get_register_interruptible(&pdev->dev, AB8500_RTC, 354 AB8500_RTC_STAT_REG, &rtc_ctrl); 355 if (err < 0) 356 return err; 357 358 /* Check if the RTC Supply fails */ 359 if (!(rtc_ctrl & RTC_STATUS_DATA)) { 360 dev_err(&pdev->dev, "RTC supply failure\n"); 361 return -ENODEV; 362 } 363 364 device_init_wakeup(&pdev->dev, true); 365 366 rtc = devm_rtc_allocate_device(&pdev->dev); 367 if (IS_ERR(rtc)) 368 return PTR_ERR(rtc); 369 370 rtc->ops = (struct rtc_class_ops *)platid->driver_data; 371 372 err = devm_request_threaded_irq(&pdev->dev, irq, NULL, 373 rtc_alarm_handler, IRQF_ONESHOT, 374 "ab8500-rtc", rtc); 375 if (err < 0) 376 return err; 377 378 dev_pm_set_wake_irq(&pdev->dev, irq); 379 platform_set_drvdata(pdev, rtc); 380 381 set_bit(RTC_FEATURE_ALARM_RES_MINUTE, rtc->features); 382 clear_bit(RTC_FEATURE_UPDATE_INTERRUPT, rtc->features); 383 384 rtc->range_max = (1ULL << 24) * 60 - 1; // 24-bit minutes + 59 secs 385 rtc->start_secs = RTC_TIMESTAMP_BEGIN_2000; 386 rtc->set_start_time = true; 387 388 err = rtc_add_group(rtc, &ab8500_rtc_sysfs_files); 389 if (err) 390 return err; 391 392 return devm_rtc_register_device(rtc); 393 } 394 395 static int ab8500_rtc_remove(struct platform_device *pdev) 396 { 397 dev_pm_clear_wake_irq(&pdev->dev); 398 device_init_wakeup(&pdev->dev, false); 399 400 return 0; 401 } 402 403 static struct platform_driver ab8500_rtc_driver = { 404 .driver = { 405 .name = "ab8500-rtc", 406 }, 407 .probe = ab8500_rtc_probe, 408 .remove = ab8500_rtc_remove, 409 .id_table = ab85xx_rtc_ids, 410 }; 411 412 module_platform_driver(ab8500_rtc_driver); 413 414 MODULE_AUTHOR("Virupax Sadashivpetimath <virupax.sadashivpetimath@stericsson.com>"); 415 MODULE_DESCRIPTION("AB8500 RTC Driver"); 416 MODULE_LICENSE("GPL v2"); 417