]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - drivers/rtc/rtc-tps65910.c
drivers/rtc/rtc-tps65910.c: enable RTC power domain on initialization
[~shefty/rdma-dev.git] / drivers / rtc / rtc-tps65910.c
1 /*
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>
25 #include <linux/interrupt.h>
26 #include <linux/mfd/tps65910.h>
27
28 struct tps65910_rtc {
29         struct rtc_device       *rtc;
30         /* To store the list of enabled interrupts */
31         u32 irqstat;
32 };
33
34 /* Total number of RTC registers needed to set time*/
35 #define NUM_TIME_REGS   (TPS65910_YEARS - TPS65910_SECONDS + 1)
36
37 static 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  */
57 static 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
88 static 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  */
129 static 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
160 static 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
191 static 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
217 static 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
225 static int __devinit tps65910_rtc_probe(struct platform_device *pdev)
226 {
227         struct tps65910 *tps65910 = NULL;
228         struct tps65910_rtc *tps_rtc = NULL;
229         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");
250
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
257         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
262         irq  = platform_get_irq(pdev, 0);
263         if (irq <= 0) {
264                 dev_warn(&pdev->dev, "Wake up is not possible as irq = %d\n",
265                         irq);
266                 return ret;
267         }
268
269         ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
270                 tps65910_rtc_interrupt, IRQF_TRIGGER_LOW,
271                 dev_name(&pdev->dev), &pdev->dev);
272         if (ret < 0) {
273                 dev_err(&pdev->dev, "IRQ is not free.\n");
274                 return ret;
275         }
276         device_init_wakeup(&pdev->dev, 1);
277
278         tps_rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
279                 &tps65910_rtc_ops, THIS_MODULE);
280         if (IS_ERR(tps_rtc->rtc)) {
281                 ret = PTR_ERR(tps_rtc->rtc);
282                 dev_err(&pdev->dev, "RTC device register: err %d\n", ret);
283                 return ret;
284         }
285
286         platform_set_drvdata(pdev, tps_rtc);
287
288         return 0;
289 }
290
291 /*
292  * Disable tps65910 RTC interrupts.
293  * Sets status flag to free.
294  */
295 static int __devexit tps65910_rtc_remove(struct platform_device *pdev)
296 {
297         /* leave rtc running, but disable irqs */
298         struct tps65910_rtc *tps_rtc = platform_get_drvdata(pdev);
299
300         tps65910_rtc_alarm_irq_enable(&pdev->dev, 0);
301
302         rtc_device_unregister(tps_rtc->rtc);
303         return 0;
304 }
305
306 #ifdef CONFIG_PM_SLEEP
307
308 static int tps65910_rtc_suspend(struct device *dev)
309 {
310         struct tps65910 *tps = dev_get_drvdata(dev->parent);
311         u8 alarm = TPS65910_RTC_INTERRUPTS_IT_ALARM;
312         int ret;
313
314         /* Store current list of enabled interrupts*/
315         ret = regmap_read(tps->regmap, TPS65910_RTC_INTERRUPTS,
316                 &tps->rtc->irqstat);
317         if (ret < 0)
318                 return ret;
319
320         /* Enable RTC ALARM interrupt only */
321         return regmap_write(tps->regmap, TPS65910_RTC_INTERRUPTS, alarm);
322 }
323
324 static int tps65910_rtc_resume(struct device *dev)
325 {
326         struct tps65910 *tps = dev_get_drvdata(dev->parent);
327
328         /* Restore list of enabled interrupts before suspend */
329         return regmap_write(tps->regmap, TPS65910_RTC_INTERRUPTS,
330                 tps->rtc->irqstat);
331 }
332
333 static const struct dev_pm_ops tps65910_rtc_pm_ops = {
334         .suspend        = tps65910_rtc_suspend,
335         .resume         = tps65910_rtc_resume,
336 };
337
338 #define DEV_PM_OPS     (&tps65910_rtc_pm_ops)
339 #else
340 #define DEV_PM_OPS     NULL
341 #endif
342
343 static struct platform_driver tps65910_rtc_driver = {
344         .probe          = tps65910_rtc_probe,
345         .remove         = __devexit_p(tps65910_rtc_remove),
346         .driver         = {
347                 .owner  = THIS_MODULE,
348                 .name   = "tps65910-rtc",
349                 .pm     = DEV_PM_OPS,
350         },
351 };
352
353 module_platform_driver(tps65910_rtc_driver);
354 MODULE_ALIAS("platform:rtc-tps65910");
355 MODULE_AUTHOR("Venu Byravarasu <vbyravarasu@nvidia.com>");
356 MODULE_LICENSE("GPL");