blob: a9caf043b0ce8716f495d437f3d2be9857b03885 [file] [log] [blame]
Venu Byravarasu0e783982012-10-04 17:13:55 -07001/*
2 * rtc-tps65910.c -- TPS65910 Real Time Clock interface
3 *
4 * Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved.
5 * Author: Venu Byravarasu <vbyravarasu@nvidia.com>
6 *
7 * Based on original TI driver rtc-twl.c
8 * Copyright (C) 2007 MontaVista Software, Inc
9 * Author: Alexandre Rusev <source@mvista.com>
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License
13 * as published by the Free Software Foundation; either version
14 * 2 of the License, or (at your option) any later version.
15 */
16
17#include <linux/kernel.h>
18#include <linux/errno.h>
19#include <linux/init.h>
20#include <linux/module.h>
21#include <linux/types.h>
22#include <linux/rtc.h>
23#include <linux/bcd.h>
24#include <linux/platform_device.h>
Laxman Dewangan176a9f22013-02-21 16:44:37 -080025#include <linux/pm_runtime.h>
Venu Byravarasu0e783982012-10-04 17:13:55 -070026#include <linux/interrupt.h>
27#include <linux/mfd/tps65910.h>
28
29struct tps65910_rtc {
30 struct rtc_device *rtc;
Laxman Dewanganeb5eba42013-02-21 16:44:35 -080031 int irq;
Venu Byravarasu0e783982012-10-04 17:13:55 -070032};
33
34/* Total number of RTC registers needed to set time*/
35#define NUM_TIME_REGS (TPS65910_YEARS - TPS65910_SECONDS + 1)
36
37static int tps65910_rtc_alarm_irq_enable(struct device *dev, unsigned enabled)
38{
39 struct tps65910 *tps = dev_get_drvdata(dev->parent);
40 u8 val = 0;
41
42 if (enabled)
43 val = TPS65910_RTC_INTERRUPTS_IT_ALARM;
44
45 return regmap_write(tps->regmap, TPS65910_RTC_INTERRUPTS, val);
46}
47
48/*
49 * Gets current tps65910 RTC time and date parameters.
50 *
51 * The RTC's time/alarm representation is not what gmtime(3) requires
52 * Linux to use:
53 *
54 * - Months are 1..12 vs Linux 0-11
55 * - Years are 0..99 vs Linux 1900..N (we assume 21st century)
56 */
57static int tps65910_rtc_read_time(struct device *dev, struct rtc_time *tm)
58{
59 unsigned char rtc_data[NUM_TIME_REGS];
60 struct tps65910 *tps = dev_get_drvdata(dev->parent);
61 int ret;
62
63 /* Copy RTC counting registers to static registers or latches */
64 ret = regmap_update_bits(tps->regmap, TPS65910_RTC_CTRL,
65 TPS65910_RTC_CTRL_GET_TIME, TPS65910_RTC_CTRL_GET_TIME);
66 if (ret < 0) {
67 dev_err(dev, "RTC CTRL reg update failed with err:%d\n", ret);
68 return ret;
69 }
70
71 ret = regmap_bulk_read(tps->regmap, TPS65910_SECONDS, rtc_data,
72 NUM_TIME_REGS);
73 if (ret < 0) {
74 dev_err(dev, "reading from RTC failed with err:%d\n", ret);
75 return ret;
76 }
77
78 tm->tm_sec = bcd2bin(rtc_data[0]);
79 tm->tm_min = bcd2bin(rtc_data[1]);
80 tm->tm_hour = bcd2bin(rtc_data[2]);
81 tm->tm_mday = bcd2bin(rtc_data[3]);
82 tm->tm_mon = bcd2bin(rtc_data[4]) - 1;
83 tm->tm_year = bcd2bin(rtc_data[5]) + 100;
84
85 return ret;
86}
87
88static int tps65910_rtc_set_time(struct device *dev, struct rtc_time *tm)
89{
90 unsigned char rtc_data[NUM_TIME_REGS];
91 struct tps65910 *tps = dev_get_drvdata(dev->parent);
92 int ret;
93
94 rtc_data[0] = bin2bcd(tm->tm_sec);
95 rtc_data[1] = bin2bcd(tm->tm_min);
96 rtc_data[2] = bin2bcd(tm->tm_hour);
97 rtc_data[3] = bin2bcd(tm->tm_mday);
98 rtc_data[4] = bin2bcd(tm->tm_mon + 1);
99 rtc_data[5] = bin2bcd(tm->tm_year - 100);
100
101 /* Stop RTC while updating the RTC time registers */
102 ret = regmap_update_bits(tps->regmap, TPS65910_RTC_CTRL,
103 TPS65910_RTC_CTRL_STOP_RTC, 0);
104 if (ret < 0) {
105 dev_err(dev, "RTC stop failed with err:%d\n", ret);
106 return ret;
107 }
108
109 /* update all the time registers in one shot */
110 ret = regmap_bulk_write(tps->regmap, TPS65910_SECONDS, rtc_data,
111 NUM_TIME_REGS);
112 if (ret < 0) {
113 dev_err(dev, "rtc_set_time error %d\n", ret);
114 return ret;
115 }
116
117 /* Start back RTC */
118 ret = regmap_update_bits(tps->regmap, TPS65910_RTC_CTRL,
119 TPS65910_RTC_CTRL_STOP_RTC, 1);
120 if (ret < 0)
121 dev_err(dev, "RTC start failed with err:%d\n", ret);
122
123 return ret;
124}
125
126/*
127 * Gets current tps65910 RTC alarm time.
128 */
129static int tps65910_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
130{
131 unsigned char alarm_data[NUM_TIME_REGS];
132 u32 int_val;
133 struct tps65910 *tps = dev_get_drvdata(dev->parent);
134 int ret;
135
136 ret = regmap_bulk_read(tps->regmap, TPS65910_SECONDS, alarm_data,
137 NUM_TIME_REGS);
138 if (ret < 0) {
139 dev_err(dev, "rtc_read_alarm error %d\n", ret);
140 return ret;
141 }
142
143 alm->time.tm_sec = bcd2bin(alarm_data[0]);
144 alm->time.tm_min = bcd2bin(alarm_data[1]);
145 alm->time.tm_hour = bcd2bin(alarm_data[2]);
146 alm->time.tm_mday = bcd2bin(alarm_data[3]);
147 alm->time.tm_mon = bcd2bin(alarm_data[4]) - 1;
148 alm->time.tm_year = bcd2bin(alarm_data[5]) + 100;
149
150 ret = regmap_read(tps->regmap, TPS65910_RTC_INTERRUPTS, &int_val);
151 if (ret < 0)
152 return ret;
153
154 if (int_val & TPS65910_RTC_INTERRUPTS_IT_ALARM)
155 alm->enabled = 1;
156
157 return ret;
158}
159
160static int tps65910_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
161{
162 unsigned char alarm_data[NUM_TIME_REGS];
163 struct tps65910 *tps = dev_get_drvdata(dev->parent);
164 int ret;
165
166 ret = tps65910_rtc_alarm_irq_enable(dev, 0);
167 if (ret)
168 return ret;
169
170 alarm_data[0] = bin2bcd(alm->time.tm_sec);
171 alarm_data[1] = bin2bcd(alm->time.tm_min);
172 alarm_data[2] = bin2bcd(alm->time.tm_hour);
173 alarm_data[3] = bin2bcd(alm->time.tm_mday);
174 alarm_data[4] = bin2bcd(alm->time.tm_mon + 1);
175 alarm_data[5] = bin2bcd(alm->time.tm_year - 100);
176
177 /* update all the alarm registers in one shot */
178 ret = regmap_bulk_write(tps->regmap, TPS65910_ALARM_SECONDS,
179 alarm_data, NUM_TIME_REGS);
180 if (ret) {
181 dev_err(dev, "rtc_set_alarm error %d\n", ret);
182 return ret;
183 }
184
185 if (alm->enabled)
186 ret = tps65910_rtc_alarm_irq_enable(dev, 1);
187
188 return ret;
189}
190
191static irqreturn_t tps65910_rtc_interrupt(int irq, void *rtc)
192{
193 struct device *dev = rtc;
194 unsigned long events = 0;
195 struct tps65910 *tps = dev_get_drvdata(dev->parent);
196 struct tps65910_rtc *tps_rtc = dev_get_drvdata(dev);
197 int ret;
198 u32 rtc_reg;
199
200 ret = regmap_read(tps->regmap, TPS65910_RTC_STATUS, &rtc_reg);
201 if (ret)
202 return IRQ_NONE;
203
204 if (rtc_reg & TPS65910_RTC_STATUS_ALARM)
205 events = RTC_IRQF | RTC_AF;
206
207 ret = regmap_write(tps->regmap, TPS65910_RTC_STATUS, rtc_reg);
208 if (ret)
209 return IRQ_NONE;
210
211 /* Notify RTC core on event */
212 rtc_update_irq(tps_rtc->rtc, 1, events);
213
214 return IRQ_HANDLED;
215}
216
217static const struct rtc_class_ops tps65910_rtc_ops = {
218 .read_time = tps65910_rtc_read_time,
219 .set_time = tps65910_rtc_set_time,
220 .read_alarm = tps65910_rtc_read_alarm,
221 .set_alarm = tps65910_rtc_set_alarm,
222 .alarm_irq_enable = tps65910_rtc_alarm_irq_enable,
223};
224
Greg Kroah-Hartman5a167f42012-12-21 13:09:38 -0800225static int tps65910_rtc_probe(struct platform_device *pdev)
Venu Byravarasu0e783982012-10-04 17:13:55 -0700226{
227 struct tps65910 *tps65910 = NULL;
228 struct tps65910_rtc *tps_rtc = NULL;
Venu Byravarasu0e783982012-10-04 17:13:55 -0700229 int ret;
230 int irq;
231 u32 rtc_reg;
232
233 tps65910 = dev_get_drvdata(pdev->dev.parent);
234
235 tps_rtc = devm_kzalloc(&pdev->dev, sizeof(struct tps65910_rtc),
236 GFP_KERNEL);
237 if (!tps_rtc)
238 return -ENOMEM;
239
240 /* Clear pending interrupts */
241 ret = regmap_read(tps65910->regmap, TPS65910_RTC_STATUS, &rtc_reg);
242 if (ret < 0)
243 return ret;
244
245 ret = regmap_write(tps65910->regmap, TPS65910_RTC_STATUS, rtc_reg);
246 if (ret < 0)
247 return ret;
248
249 dev_dbg(&pdev->dev, "Enabling rtc-tps65910.\n");
Kim, Milo18c701a2012-12-17 16:02:51 -0800250
251 /* Enable RTC digital power domain */
252 ret = regmap_update_bits(tps65910->regmap, TPS65910_DEVCTRL,
253 DEVCTRL_RTC_PWDN_MASK, 0 << DEVCTRL_RTC_PWDN_SHIFT);
254 if (ret < 0)
255 return ret;
256
Venu Byravarasu0e783982012-10-04 17:13:55 -0700257 rtc_reg = TPS65910_RTC_CTRL_STOP_RTC;
258 ret = regmap_write(tps65910->regmap, TPS65910_RTC_CTRL, rtc_reg);
259 if (ret < 0)
260 return ret;
261
Venu Byravarasu06f77d12012-10-04 17:14:34 -0700262 irq = platform_get_irq(pdev, 0);
Venu Byravarasu0e783982012-10-04 17:13:55 -0700263 if (irq <= 0) {
264 dev_warn(&pdev->dev, "Wake up is not possible as irq = %d\n",
265 irq);
Sachin Kamatdbda1612013-04-29 16:20:10 -0700266 return -ENXIO;
Venu Byravarasu0e783982012-10-04 17:13:55 -0700267 }
268
Venu Byravarasu0e783982012-10-04 17:13:55 -0700269 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
Laxman Dewangan225ccc22013-02-21 16:44:38 -0800270 tps65910_rtc_interrupt, IRQF_TRIGGER_LOW | IRQF_EARLY_RESUME,
Sivaram Nair32c47462012-12-17 16:02:37 -0800271 dev_name(&pdev->dev), &pdev->dev);
Venu Byravarasu0e783982012-10-04 17:13:55 -0700272 if (ret < 0) {
273 dev_err(&pdev->dev, "IRQ is not free.\n");
274 return ret;
275 }
Laxman Dewanganeb5eba42013-02-21 16:44:35 -0800276 tps_rtc->irq = irq;
277 device_set_wakeup_capable(&pdev->dev, 1);
Venu Byravarasu0e783982012-10-04 17:13:55 -0700278
Jingoo Han97868b32013-04-29 16:19:16 -0700279 tps_rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
Venu Byravarasu0e783982012-10-04 17:13:55 -0700280 &tps65910_rtc_ops, THIS_MODULE);
281 if (IS_ERR(tps_rtc->rtc)) {
282 ret = PTR_ERR(tps_rtc->rtc);
283 dev_err(&pdev->dev, "RTC device register: err %d\n", ret);
284 return ret;
285 }
286
287 platform_set_drvdata(pdev, tps_rtc);
288
289 return 0;
290}
291
292/*
293 * Disable tps65910 RTC interrupts.
294 * Sets status flag to free.
295 */
Greg Kroah-Hartman5a167f42012-12-21 13:09:38 -0800296static int tps65910_rtc_remove(struct platform_device *pdev)
Venu Byravarasu0e783982012-10-04 17:13:55 -0700297{
Kim, Milo1430e172012-11-29 13:54:36 -0800298 tps65910_rtc_alarm_irq_enable(&pdev->dev, 0);
Venu Byravarasu0e783982012-10-04 17:13:55 -0700299
Venu Byravarasu0e783982012-10-04 17:13:55 -0700300 return 0;
301}
302
303#ifdef CONFIG_PM_SLEEP
Venu Byravarasu0e783982012-10-04 17:13:55 -0700304static int tps65910_rtc_suspend(struct device *dev)
305{
Laxman Dewanganeb5eba42013-02-21 16:44:35 -0800306 struct tps65910_rtc *tps_rtc = dev_get_drvdata(dev);
Venu Byravarasu0e783982012-10-04 17:13:55 -0700307
Laxman Dewanganeb5eba42013-02-21 16:44:35 -0800308 if (device_may_wakeup(dev))
309 enable_irq_wake(tps_rtc->irq);
Laxman Dewangandfaf09a2013-02-21 16:44:36 -0800310 return 0;
Venu Byravarasu0e783982012-10-04 17:13:55 -0700311}
312
313static int tps65910_rtc_resume(struct device *dev)
314{
Laxman Dewanganeb5eba42013-02-21 16:44:35 -0800315 struct tps65910_rtc *tps_rtc = dev_get_drvdata(dev);
316
317 if (device_may_wakeup(dev))
318 disable_irq_wake(tps_rtc->irq);
Laxman Dewangandfaf09a2013-02-21 16:44:36 -0800319 return 0;
Venu Byravarasu0e783982012-10-04 17:13:55 -0700320}
Laxman Dewangan176a9f22013-02-21 16:44:37 -0800321#endif
Venu Byravarasu0e783982012-10-04 17:13:55 -0700322
Jingoo Hane4ae9092013-04-29 16:20:03 -0700323static SIMPLE_DEV_PM_OPS(tps65910_rtc_pm_ops, tps65910_rtc_suspend,
324 tps65910_rtc_resume);
Venu Byravarasu0e783982012-10-04 17:13:55 -0700325
Venu Byravarasu0e783982012-10-04 17:13:55 -0700326static struct platform_driver tps65910_rtc_driver = {
327 .probe = tps65910_rtc_probe,
Greg Kroah-Hartman5a167f42012-12-21 13:09:38 -0800328 .remove = tps65910_rtc_remove,
Venu Byravarasu0e783982012-10-04 17:13:55 -0700329 .driver = {
330 .owner = THIS_MODULE,
331 .name = "tps65910-rtc",
Laxman Dewangan176a9f22013-02-21 16:44:37 -0800332 .pm = &tps65910_rtc_pm_ops,
Venu Byravarasu0e783982012-10-04 17:13:55 -0700333 },
334};
335
336module_platform_driver(tps65910_rtc_driver);
337MODULE_ALIAS("platform:rtc-tps65910");
338MODULE_AUTHOR("Venu Byravarasu <vbyravarasu@nvidia.com>");
339MODULE_LICENSE("GPL");