1/* 2 * RTC driver for Rockchip RK808 3 * 4 * Copyright (c) 2014, Fuzhou Rockchip Electronics Co., Ltd 5 * 6 * Author: Chris Zhong <zyw@rock-chips.com> 7 * Author: Zhang Qing <zhangqing@rock-chips.com> 8 * 9 * This program is free software; you can redistribute it and/or modify it 10 * under the terms and conditions of the GNU General Public License, 11 * version 2, as published by the Free Software Foundation. 12 * 13 * This program is distributed in the hope it will be useful, but WITHOUT 14 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 15 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 16 * more details. 17 */ 18 19#include <linux/module.h> 20#include <linux/kernel.h> 21#include <linux/rtc.h> 22#include <linux/bcd.h> 23#include <linux/mfd/rk808.h> 24#include <linux/platform_device.h> 25#include <linux/i2c.h> 26 27/* RTC_CTRL_REG bitfields */ 28#define BIT_RTC_CTRL_REG_STOP_RTC_M BIT(0) 29 30/* RK808 has a shadowed register for saving a "frozen" RTC time. 31 * When user setting "GET_TIME" to 1, the time will save in this shadowed 32 * register. If set "READSEL" to 1, user read rtc time register, actually 33 * get the time of that moment. If we need the real time, clr this bit. 34 */ 35#define BIT_RTC_CTRL_REG_RTC_GET_TIME BIT(6) 36#define BIT_RTC_CTRL_REG_RTC_READSEL_M BIT(7) 37#define BIT_RTC_INTERRUPTS_REG_IT_ALARM_M BIT(3) 38#define RTC_STATUS_MASK 0xFE 39 40#define SECONDS_REG_MSK 0x7F 41#define MINUTES_REG_MAK 0x7F 42#define HOURS_REG_MSK 0x3F 43#define DAYS_REG_MSK 0x3F 44#define MONTHS_REG_MSK 0x1F 45#define YEARS_REG_MSK 0xFF 46#define WEEKS_REG_MSK 0x7 47 48/* REG_SECONDS_REG through REG_YEARS_REG is how many registers? */ 49 50#define NUM_TIME_REGS (RK808_WEEKS_REG - RK808_SECONDS_REG + 1) 51#define NUM_ALARM_REGS (RK808_ALARM_YEARS_REG - RK808_ALARM_SECONDS_REG + 1) 52 53struct rk808_rtc { 54 struct rk808 *rk808; 55 struct rtc_device *rtc; 56 int irq; 57}; 58 59/* Read current time and date in RTC */ 60static int rk808_rtc_readtime(struct device *dev, struct rtc_time *tm) 61{ 62 struct rk808_rtc *rk808_rtc = dev_get_drvdata(dev); 63 struct rk808 *rk808 = rk808_rtc->rk808; 64 u8 rtc_data[NUM_TIME_REGS]; 65 int ret; 66 67 /* Force an update of the shadowed registers right now */ 68 ret = regmap_update_bits(rk808->regmap, RK808_RTC_CTRL_REG, 69 BIT_RTC_CTRL_REG_RTC_GET_TIME, 70 0); 71 if (ret) { 72 dev_err(dev, "Failed to update bits rtc_ctrl: %d\n", ret); 73 return ret; 74 } 75 76 ret = regmap_update_bits(rk808->regmap, RK808_RTC_CTRL_REG, 77 BIT_RTC_CTRL_REG_RTC_GET_TIME, 78 BIT_RTC_CTRL_REG_RTC_GET_TIME); 79 if (ret) { 80 dev_err(dev, "Failed to update bits rtc_ctrl: %d\n", ret); 81 return ret; 82 } 83 84 ret = regmap_bulk_read(rk808->regmap, RK808_SECONDS_REG, 85 rtc_data, NUM_TIME_REGS); 86 if (ret) { 87 dev_err(dev, "Failed to bulk read rtc_data: %d\n", ret); 88 return ret; 89 } 90 91 tm->tm_sec = bcd2bin(rtc_data[0] & SECONDS_REG_MSK); 92 tm->tm_min = bcd2bin(rtc_data[1] & MINUTES_REG_MAK); 93 tm->tm_hour = bcd2bin(rtc_data[2] & HOURS_REG_MSK); 94 tm->tm_mday = bcd2bin(rtc_data[3] & DAYS_REG_MSK); 95 tm->tm_mon = (bcd2bin(rtc_data[4] & MONTHS_REG_MSK)) - 1; 96 tm->tm_year = (bcd2bin(rtc_data[5] & YEARS_REG_MSK)) + 100; 97 tm->tm_wday = bcd2bin(rtc_data[6] & WEEKS_REG_MSK); 98 dev_dbg(dev, "RTC date/time %4d-%02d-%02d(%d) %02d:%02d:%02d\n", 99 1900 + tm->tm_year, tm->tm_mon + 1, tm->tm_mday, 100 tm->tm_wday, tm->tm_hour , tm->tm_min, tm->tm_sec); 101 102 return ret; 103} 104 105/* Set current time and date in RTC */ 106static int rk808_rtc_set_time(struct device *dev, struct rtc_time *tm) 107{ 108 struct rk808_rtc *rk808_rtc = dev_get_drvdata(dev); 109 struct rk808 *rk808 = rk808_rtc->rk808; 110 u8 rtc_data[NUM_TIME_REGS]; 111 int ret; 112 113 rtc_data[0] = bin2bcd(tm->tm_sec); 114 rtc_data[1] = bin2bcd(tm->tm_min); 115 rtc_data[2] = bin2bcd(tm->tm_hour); 116 rtc_data[3] = bin2bcd(tm->tm_mday); 117 rtc_data[4] = bin2bcd(tm->tm_mon + 1); 118 rtc_data[5] = bin2bcd(tm->tm_year - 100); 119 rtc_data[6] = bin2bcd(tm->tm_wday); 120 dev_dbg(dev, "set RTC date/time %4d-%02d-%02d(%d) %02d:%02d:%02d\n", 121 1900 + tm->tm_year, tm->tm_mon + 1, tm->tm_mday, 122 tm->tm_wday, tm->tm_hour , tm->tm_min, tm->tm_sec); 123 124 /* Stop RTC while updating the RTC registers */ 125 ret = regmap_update_bits(rk808->regmap, RK808_RTC_CTRL_REG, 126 BIT_RTC_CTRL_REG_STOP_RTC_M, 127 BIT_RTC_CTRL_REG_STOP_RTC_M); 128 if (ret) { 129 dev_err(dev, "Failed to update RTC control: %d\n", ret); 130 return ret; 131 } 132 133 ret = regmap_bulk_write(rk808->regmap, RK808_SECONDS_REG, 134 rtc_data, NUM_TIME_REGS); 135 if (ret) { 136 dev_err(dev, "Failed to bull write rtc_data: %d\n", ret); 137 return ret; 138 } 139 /* Start RTC again */ 140 ret = regmap_update_bits(rk808->regmap, RK808_RTC_CTRL_REG, 141 BIT_RTC_CTRL_REG_STOP_RTC_M, 0); 142 if (ret) { 143 dev_err(dev, "Failed to update RTC control: %d\n", ret); 144 return ret; 145 } 146 return 0; 147} 148 149/* Read alarm time and date in RTC */ 150static int rk808_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm) 151{ 152 struct rk808_rtc *rk808_rtc = dev_get_drvdata(dev); 153 struct rk808 *rk808 = rk808_rtc->rk808; 154 u8 alrm_data[NUM_ALARM_REGS]; 155 uint32_t int_reg; 156 int ret; 157 158 ret = regmap_bulk_read(rk808->regmap, RK808_ALARM_SECONDS_REG, 159 alrm_data, NUM_ALARM_REGS); 160 161 alrm->time.tm_sec = bcd2bin(alrm_data[0] & SECONDS_REG_MSK); 162 alrm->time.tm_min = bcd2bin(alrm_data[1] & MINUTES_REG_MAK); 163 alrm->time.tm_hour = bcd2bin(alrm_data[2] & HOURS_REG_MSK); 164 alrm->time.tm_mday = bcd2bin(alrm_data[3] & DAYS_REG_MSK); 165 alrm->time.tm_mon = (bcd2bin(alrm_data[4] & MONTHS_REG_MSK)) - 1; 166 alrm->time.tm_year = (bcd2bin(alrm_data[5] & YEARS_REG_MSK)) + 100; 167 168 ret = regmap_read(rk808->regmap, RK808_RTC_INT_REG, &int_reg); 169 if (ret) { 170 dev_err(dev, "Failed to read RTC INT REG: %d\n", ret); 171 return ret; 172 } 173 174 dev_dbg(dev, "alrm read RTC date/time %4d-%02d-%02d(%d) %02d:%02d:%02d\n", 175 1900 + alrm->time.tm_year, alrm->time.tm_mon + 1, 176 alrm->time.tm_mday, alrm->time.tm_wday, alrm->time.tm_hour, 177 alrm->time.tm_min, alrm->time.tm_sec); 178 179 alrm->enabled = (int_reg & BIT_RTC_INTERRUPTS_REG_IT_ALARM_M) ? 1 : 0; 180 181 return 0; 182} 183 184static int rk808_rtc_stop_alarm(struct rk808_rtc *rk808_rtc) 185{ 186 struct rk808 *rk808 = rk808_rtc->rk808; 187 int ret; 188 189 ret = regmap_update_bits(rk808->regmap, RK808_RTC_INT_REG, 190 BIT_RTC_INTERRUPTS_REG_IT_ALARM_M, 0); 191 192 return ret; 193} 194 195static int rk808_rtc_start_alarm(struct rk808_rtc *rk808_rtc) 196{ 197 struct rk808 *rk808 = rk808_rtc->rk808; 198 int ret; 199 200 ret = regmap_update_bits(rk808->regmap, RK808_RTC_INT_REG, 201 BIT_RTC_INTERRUPTS_REG_IT_ALARM_M, 202 BIT_RTC_INTERRUPTS_REG_IT_ALARM_M); 203 204 return ret; 205} 206 207static int rk808_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm) 208{ 209 struct rk808_rtc *rk808_rtc = dev_get_drvdata(dev); 210 struct rk808 *rk808 = rk808_rtc->rk808; 211 u8 alrm_data[NUM_ALARM_REGS]; 212 int ret; 213 214 ret = rk808_rtc_stop_alarm(rk808_rtc); 215 if (ret) { 216 dev_err(dev, "Failed to stop alarm: %d\n", ret); 217 return ret; 218 } 219 dev_dbg(dev, "alrm set RTC date/time %4d-%02d-%02d(%d) %02d:%02d:%02d\n", 220 1900 + alrm->time.tm_year, alrm->time.tm_mon + 1, 221 alrm->time.tm_mday, alrm->time.tm_wday, alrm->time.tm_hour, 222 alrm->time.tm_min, alrm->time.tm_sec); 223 224 alrm_data[0] = bin2bcd(alrm->time.tm_sec); 225 alrm_data[1] = bin2bcd(alrm->time.tm_min); 226 alrm_data[2] = bin2bcd(alrm->time.tm_hour); 227 alrm_data[3] = bin2bcd(alrm->time.tm_mday); 228 alrm_data[4] = bin2bcd(alrm->time.tm_mon + 1); 229 alrm_data[5] = bin2bcd(alrm->time.tm_year - 100); 230 231 ret = regmap_bulk_write(rk808->regmap, RK808_ALARM_SECONDS_REG, 232 alrm_data, NUM_ALARM_REGS); 233 if (ret) { 234 dev_err(dev, "Failed to bulk write: %d\n", ret); 235 return ret; 236 } 237 if (alrm->enabled) { 238 ret = rk808_rtc_start_alarm(rk808_rtc); 239 if (ret) { 240 dev_err(dev, "Failed to start alarm: %d\n", ret); 241 return ret; 242 } 243 } 244 return 0; 245} 246 247static int rk808_rtc_alarm_irq_enable(struct device *dev, 248 unsigned int enabled) 249{ 250 struct rk808_rtc *rk808_rtc = dev_get_drvdata(dev); 251 252 if (enabled) 253 return rk808_rtc_start_alarm(rk808_rtc); 254 255 return rk808_rtc_stop_alarm(rk808_rtc); 256} 257 258/* 259 * We will just handle setting the frequency and make use the framework for 260 * reading the periodic interupts. 261 * 262 * @freq: Current periodic IRQ freq: 263 * bit 0: every second 264 * bit 1: every minute 265 * bit 2: every hour 266 * bit 3: every day 267 */ 268static irqreturn_t rk808_alarm_irq(int irq, void *data) 269{ 270 struct rk808_rtc *rk808_rtc = data; 271 struct rk808 *rk808 = rk808_rtc->rk808; 272 struct i2c_client *client = rk808->i2c; 273 int ret; 274 275 ret = regmap_write(rk808->regmap, RK808_RTC_STATUS_REG, 276 RTC_STATUS_MASK); 277 if (ret) { 278 dev_err(&client->dev, 279 "%s:Failed to update RTC status: %d\n", __func__, ret); 280 return ret; 281 } 282 283 rtc_update_irq(rk808_rtc->rtc, 1, RTC_IRQF | RTC_AF); 284 dev_dbg(&client->dev, 285 "%s:irq=%d\n", __func__, irq); 286 return IRQ_HANDLED; 287} 288 289static const struct rtc_class_ops rk808_rtc_ops = { 290 .read_time = rk808_rtc_readtime, 291 .set_time = rk808_rtc_set_time, 292 .read_alarm = rk808_rtc_readalarm, 293 .set_alarm = rk808_rtc_setalarm, 294 .alarm_irq_enable = rk808_rtc_alarm_irq_enable, 295}; 296 297#ifdef CONFIG_PM_SLEEP 298/* Turn off the alarm if it should not be a wake source. */ 299static int rk808_rtc_suspend(struct device *dev) 300{ 301 struct platform_device *pdev = to_platform_device(dev); 302 struct rk808_rtc *rk808_rtc = dev_get_drvdata(&pdev->dev); 303 304 if (device_may_wakeup(dev)) 305 enable_irq_wake(rk808_rtc->irq); 306 307 return 0; 308} 309 310/* Enable the alarm if it should be enabled (in case it was disabled to 311 * prevent use as a wake source). 312 */ 313static int rk808_rtc_resume(struct device *dev) 314{ 315 struct platform_device *pdev = to_platform_device(dev); 316 struct rk808_rtc *rk808_rtc = dev_get_drvdata(&pdev->dev); 317 318 if (device_may_wakeup(dev)) 319 disable_irq_wake(rk808_rtc->irq); 320 321 return 0; 322} 323#endif 324 325static SIMPLE_DEV_PM_OPS(rk808_rtc_pm_ops, 326 rk808_rtc_suspend, rk808_rtc_resume); 327 328static int rk808_rtc_probe(struct platform_device *pdev) 329{ 330 struct rk808 *rk808 = dev_get_drvdata(pdev->dev.parent); 331 struct rk808_rtc *rk808_rtc; 332 struct rtc_time tm; 333 int ret; 334 335 rk808_rtc = devm_kzalloc(&pdev->dev, sizeof(*rk808_rtc), GFP_KERNEL); 336 if (rk808_rtc == NULL) 337 return -ENOMEM; 338 339 platform_set_drvdata(pdev, rk808_rtc); 340 rk808_rtc->rk808 = rk808; 341 342 /* start rtc running by default, and use shadowed timer. */ 343 ret = regmap_update_bits(rk808->regmap, RK808_RTC_CTRL_REG, 344 BIT_RTC_CTRL_REG_STOP_RTC_M | 345 BIT_RTC_CTRL_REG_RTC_READSEL_M, 346 BIT_RTC_CTRL_REG_RTC_READSEL_M); 347 if (ret) { 348 dev_err(&pdev->dev, 349 "Failed to update RTC control: %d\n", ret); 350 return ret; 351 } 352 353 ret = regmap_write(rk808->regmap, RK808_RTC_STATUS_REG, 354 RTC_STATUS_MASK); 355 if (ret) { 356 dev_err(&pdev->dev, 357 "Failed to write RTC status: %d\n", ret); 358 return ret; 359 } 360 361 /* set init time */ 362 ret = rk808_rtc_readtime(&pdev->dev, &tm); 363 if (ret) { 364 dev_err(&pdev->dev, "Failed to read RTC time\n"); 365 return ret; 366 } 367 ret = rtc_valid_tm(&tm); 368 if (ret) 369 dev_warn(&pdev->dev, "invalid date/time\n"); 370 371 device_init_wakeup(&pdev->dev, 1); 372 373 rk808_rtc->rtc = devm_rtc_device_register(&pdev->dev, "rk808-rtc", 374 &rk808_rtc_ops, THIS_MODULE); 375 if (IS_ERR(rk808_rtc->rtc)) { 376 ret = PTR_ERR(rk808_rtc->rtc); 377 return ret; 378 } 379 380 rk808_rtc->irq = platform_get_irq(pdev, 0); 381 if (rk808_rtc->irq < 0) { 382 if (rk808_rtc->irq != -EPROBE_DEFER) 383 dev_err(&pdev->dev, "Wake up is not possible as irq = %d\n", 384 rk808_rtc->irq); 385 return rk808_rtc->irq; 386 } 387 388 /* request alarm irq of rk808 */ 389 ret = devm_request_threaded_irq(&pdev->dev, rk808_rtc->irq, NULL, 390 rk808_alarm_irq, 0, 391 "RTC alarm", rk808_rtc); 392 if (ret) { 393 dev_err(&pdev->dev, "Failed to request alarm IRQ %d: %d\n", 394 rk808_rtc->irq, ret); 395 } 396 397 return ret; 398} 399 400static struct platform_driver rk808_rtc_driver = { 401 .probe = rk808_rtc_probe, 402 .driver = { 403 .name = "rk808-rtc", 404 .pm = &rk808_rtc_pm_ops, 405 }, 406}; 407 408module_platform_driver(rk808_rtc_driver); 409 410MODULE_DESCRIPTION("RTC driver for the rk808 series PMICs"); 411MODULE_AUTHOR("Chris Zhong <zyw@rock-chips.com>"); 412MODULE_AUTHOR("Zhang Qing <zhangqing@rock-chips.com>"); 413MODULE_LICENSE("GPL"); 414MODULE_ALIAS("platform:rk808-rtc"); 415