2 * rtc-palmas.c -- Palmas Real Time Clock driver.
4 * RTC driver for TI Palma series devices like TPS65913,
5 * TPS65914 power management IC.
7 * Copyright (c) 2012, NVIDIA Corporation.
9 * Author: Laxman Dewangan <ldewangan@nvidia.com>
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License as
13 * published by the Free Software Foundation version 2.
15 * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
16 * whether express or implied; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
26 #include <linux/bcd.h>
27 #include <linux/errno.h>
28 #include <linux/init.h>
29 #include <linux/interrupt.h>
30 #include <linux/kernel.h>
31 #include <linux/mfd/palmas.h>
32 #include <linux/module.h>
34 #include <linux/rtc.h>
35 #include <linux/types.h>
36 #include <linux/platform_device.h>
40 struct rtc_device *rtc;
45 /* Total number of RTC registers needed to set time*/
46 #define PALMAS_NUM_TIME_REGS (PALMAS_YEARS_REG - PALMAS_SECONDS_REG + 1)
49 * Special bin2bcd mapping to deal with bcd storage of year.
52 * 70-99 (1970 - 1999) -> 0xD0 - 0xF9 (correctly rolls to 0x00)
53 * 100-199 (2000 - 2099) -> 0x00 - 0x99 (does not roll to 0xA0 :-( )
54 * 200-229 (2100 - 2129) -> 0xA0 - 0xC9 (really for completeness)
57 * Confirmed: the only transition that does not work correctly for this rtc
58 * clock is the transition from 2099 to 2100, it proceeds to 2000. We will
59 * accept this issue since the clock retains and transitions the year correctly
60 * in all other conditions.
62 static unsigned char year_bin2bcd(int val)
67 return bin2bcd(val - 20) | 0x80; /* KISS leverage of bin2bcd */
71 return bin2bcd(val - 180) | 0x80;
72 return bin2bcd(val - 100);
75 static int year_bcd2bin(unsigned char val)
78 return bcd2bin(val & 0x7F) + 20;
80 return bcd2bin(val & 0x7F) + 180;
81 return bcd2bin(val) + 100;
84 static int palmas_rtc_read_time(struct device *dev, struct rtc_time *tm)
86 unsigned char rtc_data[PALMAS_NUM_TIME_REGS];
87 struct palmas *palmas = dev_get_drvdata(dev->parent);
90 /* Copy RTC counting registers to static registers or latches */
91 ret = palmas_update_bits(palmas, PALMAS_RTC_BASE, PALMAS_RTC_CTRL_REG,
92 PALMAS_RTC_CTRL_REG_GET_TIME, PALMAS_RTC_CTRL_REG_GET_TIME);
94 dev_err(dev, "RTC CTRL reg update failed, err: %d\n", ret);
98 ret = palmas_bulk_read(palmas, PALMAS_RTC_BASE, PALMAS_SECONDS_REG,
99 rtc_data, PALMAS_NUM_TIME_REGS);
101 dev_err(dev, "RTC_SECONDS reg read failed, err = %d\n", ret);
105 tm->tm_sec = bcd2bin(rtc_data[0]);
106 tm->tm_min = bcd2bin(rtc_data[1]);
107 tm->tm_hour = bcd2bin(rtc_data[2]);
108 tm->tm_mday = bcd2bin(rtc_data[3]);
109 tm->tm_mon = bcd2bin(rtc_data[4]) - 1;
110 tm->tm_year = year_bcd2bin(rtc_data[5]);
115 static int palmas_rtc_set_time(struct device *dev, struct rtc_time *tm)
117 unsigned char rtc_data[PALMAS_NUM_TIME_REGS];
118 struct palmas *palmas = dev_get_drvdata(dev->parent);
121 rtc_data[0] = bin2bcd(tm->tm_sec);
122 rtc_data[1] = bin2bcd(tm->tm_min);
123 rtc_data[2] = bin2bcd(tm->tm_hour);
124 rtc_data[3] = bin2bcd(tm->tm_mday);
125 rtc_data[4] = bin2bcd(tm->tm_mon + 1);
126 rtc_data[5] = year_bin2bcd(tm->tm_year);
128 /* Stop RTC while updating the RTC time registers */
129 ret = palmas_update_bits(palmas, PALMAS_RTC_BASE, PALMAS_RTC_CTRL_REG,
130 PALMAS_RTC_CTRL_REG_STOP_RTC, 0);
132 dev_err(dev, "RTC stop failed, err = %d\n", ret);
136 ret = palmas_bulk_write(palmas, PALMAS_RTC_BASE, PALMAS_SECONDS_REG,
137 rtc_data, PALMAS_NUM_TIME_REGS);
139 dev_err(dev, "RTC_SECONDS reg write failed, err = %d\n", ret);
144 ret = palmas_update_bits(palmas, PALMAS_RTC_BASE, PALMAS_RTC_CTRL_REG,
145 PALMAS_RTC_CTRL_REG_STOP_RTC, PALMAS_RTC_CTRL_REG_STOP_RTC);
147 dev_err(dev, "RTC start failed, err = %d\n", ret);
151 static int palmas_rtc_alarm_irq_enable(struct device *dev, unsigned enabled)
153 struct palmas *palmas = dev_get_drvdata(dev->parent);
156 val = enabled ? PALMAS_RTC_INTERRUPTS_REG_IT_ALARM : 0;
157 return palmas_write(palmas, PALMAS_RTC_BASE,
158 PALMAS_RTC_INTERRUPTS_REG, val);
161 static int palmas_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
163 unsigned char alarm_data[PALMAS_NUM_TIME_REGS];
165 struct palmas *palmas = dev_get_drvdata(dev->parent);
168 ret = palmas_bulk_read(palmas, PALMAS_RTC_BASE,
169 PALMAS_ALARM_SECONDS_REG,
170 alarm_data, PALMAS_NUM_TIME_REGS);
172 dev_err(dev, "RTC_ALARM_SECONDS read failed, err = %d\n", ret);
176 alm->time.tm_sec = bcd2bin(alarm_data[0]);
177 alm->time.tm_min = bcd2bin(alarm_data[1]);
178 alm->time.tm_hour = bcd2bin(alarm_data[2]);
179 alm->time.tm_mday = bcd2bin(alarm_data[3]);
180 alm->time.tm_mon = bcd2bin(alarm_data[4]) - 1;
181 alm->time.tm_year = year_bcd2bin(alarm_data[5]);
183 ret = palmas_read(palmas, PALMAS_RTC_BASE, PALMAS_RTC_INTERRUPTS_REG,
186 dev_err(dev, "RTC_INTERRUPTS reg read failed, err = %d\n", ret);
190 if (int_val & PALMAS_RTC_INTERRUPTS_REG_IT_ALARM)
195 static int palmas_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
197 unsigned char alarm_data[PALMAS_NUM_TIME_REGS];
198 struct palmas *palmas = dev_get_drvdata(dev->parent);
201 ret = palmas_rtc_alarm_irq_enable(dev, 0);
203 dev_err(dev, "Disable RTC alarm failed\n");
207 alarm_data[0] = bin2bcd(alm->time.tm_sec);
208 alarm_data[1] = bin2bcd(alm->time.tm_min);
209 alarm_data[2] = bin2bcd(alm->time.tm_hour);
210 alarm_data[3] = bin2bcd(alm->time.tm_mday);
211 alarm_data[4] = bin2bcd(alm->time.tm_mon + 1);
212 alarm_data[5] = year_bin2bcd(alm->time.tm_year);
214 ret = palmas_bulk_write(palmas, PALMAS_RTC_BASE,
215 PALMAS_ALARM_SECONDS_REG, alarm_data, PALMAS_NUM_TIME_REGS);
217 dev_err(dev, "ALARM_SECONDS_REG write failed, err = %d\n", ret);
222 ret = palmas_rtc_alarm_irq_enable(dev, 1);
226 static int palmas_clear_interrupts(struct device *dev)
228 struct palmas *palmas = dev_get_drvdata(dev->parent);
229 unsigned int rtc_reg;
232 ret = palmas_read(palmas, PALMAS_RTC_BASE, PALMAS_RTC_STATUS_REG,
235 dev_err(dev, "RTC_STATUS read failed, err = %d\n", ret);
239 ret = palmas_write(palmas, PALMAS_RTC_BASE, PALMAS_RTC_STATUS_REG,
242 dev_err(dev, "RTC_STATUS write failed, err = %d\n", ret);
248 static irqreturn_t palmas_rtc_interrupt(int irq, void *context)
250 struct palmas_rtc *palmas_rtc = context;
251 struct device *dev = palmas_rtc->dev;
254 ret = palmas_clear_interrupts(dev);
256 dev_err(dev, "RTC interrupt clear failed, err = %d\n", ret);
260 rtc_update_irq(palmas_rtc->rtc, 1, RTC_IRQF | RTC_AF);
264 static struct rtc_class_ops palmas_rtc_ops = {
265 .read_time = palmas_rtc_read_time,
266 .set_time = palmas_rtc_set_time,
267 .read_alarm = palmas_rtc_read_alarm,
268 .set_alarm = palmas_rtc_set_alarm,
269 .alarm_irq_enable = palmas_rtc_alarm_irq_enable,
272 static int palmas_rtc_probe(struct platform_device *pdev)
274 struct palmas *palmas = dev_get_drvdata(pdev->dev.parent);
275 struct palmas_rtc *palmas_rtc = NULL;
277 bool enable_bb_charging = false;
278 bool high_bb_charging = false;
280 if (pdev->dev.of_node) {
281 enable_bb_charging = of_property_read_bool(pdev->dev.of_node,
282 "ti,backup-battery-chargeable");
283 high_bb_charging = of_property_read_bool(pdev->dev.of_node,
284 "ti,backup-battery-charge-high-current");
287 palmas_rtc = devm_kzalloc(&pdev->dev, sizeof(struct palmas_rtc),
292 /* Clear pending interrupts */
293 ret = palmas_clear_interrupts(&pdev->dev);
295 dev_err(&pdev->dev, "clear RTC int failed, err = %d\n", ret);
299 palmas_rtc->dev = &pdev->dev;
300 platform_set_drvdata(pdev, palmas_rtc);
302 if (enable_bb_charging) {
303 unsigned reg = PALMAS_BACKUP_BATTERY_CTRL_BBS_BBC_LOW_ICHRG;
305 if (high_bb_charging)
308 ret = palmas_update_bits(palmas, PALMAS_PMU_CONTROL_BASE,
309 PALMAS_BACKUP_BATTERY_CTRL,
310 PALMAS_BACKUP_BATTERY_CTRL_BBS_BBC_LOW_ICHRG, reg);
313 "BACKUP_BATTERY_CTRL update failed, %d\n", ret);
317 ret = palmas_update_bits(palmas, PALMAS_PMU_CONTROL_BASE,
318 PALMAS_BACKUP_BATTERY_CTRL,
319 PALMAS_BACKUP_BATTERY_CTRL_BB_CHG_EN,
320 PALMAS_BACKUP_BATTERY_CTRL_BB_CHG_EN);
323 "BACKUP_BATTERY_CTRL update failed, %d\n", ret);
329 ret = palmas_update_bits(palmas, PALMAS_RTC_BASE, PALMAS_RTC_CTRL_REG,
330 PALMAS_RTC_CTRL_REG_STOP_RTC,
331 PALMAS_RTC_CTRL_REG_STOP_RTC);
333 dev_err(&pdev->dev, "RTC_CTRL write failed, err = %d\n", ret);
337 palmas_rtc->irq = platform_get_irq(pdev, 0);
339 device_init_wakeup(&pdev->dev, 1);
340 palmas_rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
341 &palmas_rtc_ops, THIS_MODULE);
342 if (IS_ERR(palmas_rtc->rtc)) {
343 ret = PTR_ERR(palmas_rtc->rtc);
344 dev_err(&pdev->dev, "RTC register failed, err = %d\n", ret);
348 ret = devm_request_threaded_irq(&pdev->dev, palmas_rtc->irq, NULL,
349 palmas_rtc_interrupt,
350 IRQF_TRIGGER_LOW | IRQF_ONESHOT |
352 dev_name(&pdev->dev), palmas_rtc);
354 dev_err(&pdev->dev, "IRQ request failed, err = %d\n", ret);
361 static int palmas_rtc_remove(struct platform_device *pdev)
363 palmas_rtc_alarm_irq_enable(&pdev->dev, 0);
367 #ifdef CONFIG_PM_SLEEP
368 static int palmas_rtc_suspend(struct device *dev)
370 struct palmas_rtc *palmas_rtc = dev_get_drvdata(dev);
372 if (device_may_wakeup(dev))
373 enable_irq_wake(palmas_rtc->irq);
377 static int palmas_rtc_resume(struct device *dev)
379 struct palmas_rtc *palmas_rtc = dev_get_drvdata(dev);
381 if (device_may_wakeup(dev))
382 disable_irq_wake(palmas_rtc->irq);
387 static SIMPLE_DEV_PM_OPS(palmas_rtc_pm_ops, palmas_rtc_suspend,
391 static const struct of_device_id of_palmas_rtc_match[] = {
392 { .compatible = "ti,palmas-rtc"},
395 MODULE_DEVICE_TABLE(of, of_palmas_rtc_match);
398 static struct platform_driver palmas_rtc_driver = {
399 .probe = palmas_rtc_probe,
400 .remove = palmas_rtc_remove,
402 .name = "palmas-rtc",
403 .pm = &palmas_rtc_pm_ops,
404 .of_match_table = of_match_ptr(of_palmas_rtc_match),
408 module_platform_driver(palmas_rtc_driver);
410 MODULE_ALIAS("platform:palmas_rtc");
411 MODULE_DESCRIPTION("TI PALMAS series RTC driver");
412 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
413 MODULE_LICENSE("GPL v2");