rtc: Add max77660 rtc driver
[linux-3.10.git] / drivers / rtc / rtc-palmas.c
1 /*
2  * rtc-palmas.c -- Palmas Real Time Clock interface
3  *
4  * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
5  * Author: Kasoju Mallikarjun <mkasoju@nvidia.com>
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License as
9  * published by the Free Software Foundation version 2.
10  *
11  * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
12  * whether express or implied; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19  * 02111-1307, USA
20  */
21
22 #include <linux/kernel.h>
23 #include <linux/errno.h>
24 #include <linux/init.h>
25 #include <linux/module.h>
26 #include <linux/types.h>
27 #include <linux/rtc.h>
28 #include <linux/bcd.h>
29 #include <linux/platform_device.h>
30 #include <linux/interrupt.h>
31 #include <linux/mfd/palmas.h>
32
33 struct palmas_rtc {
34         struct rtc_device       *rtc;
35         /* To store the list of enabled interrupts */
36         unsigned int irqstat;
37         unsigned int irq;
38 };
39
40 /* Total number of RTC registers needed to set time*/
41 #define NUM_TIME_REGS   (PALMAS_YEARS_REG - PALMAS_SECONDS_REG + 1)
42
43 int palmas_rtc_read(struct palmas *palmas, unsigned int reg,
44                                 unsigned int *dest)
45 {
46         unsigned int addr;
47         addr = PALMAS_BASE_TO_REG(PALMAS_RTC_BASE, reg);
48
49         return regmap_read(palmas->regmap[RTC_SLAVE], addr, dest);
50 }
51
52 int palmas_rtc_write(struct palmas *palmas, unsigned int reg,
53                                 unsigned int value)
54 {
55         unsigned int addr;
56         addr = PALMAS_BASE_TO_REG(PALMAS_RTC_BASE, reg);
57
58         return regmap_write(palmas->regmap[RTC_SLAVE], addr, value);
59 }
60
61 int palmas_rtc_bulk_read(struct palmas *palmas, unsigned int reg,
62                                 void *val, size_t val_count)
63 {
64         unsigned int addr;
65         addr = PALMAS_BASE_TO_REG(PALMAS_RTC_BASE, reg);
66
67         return regmap_bulk_read(palmas->regmap[RTC_SLAVE], addr,
68                 val, val_count);
69 }
70
71 int palmas_rtc_bulk_write(struct palmas *palmas, unsigned int reg,
72         const void *val, size_t val_count)
73 {
74         unsigned int addr;
75         addr = PALMAS_BASE_TO_REG(PALMAS_RTC_BASE, reg);
76
77         return regmap_bulk_write(palmas->regmap[RTC_SLAVE], addr,
78                 val, val_count);
79 }
80
81 int palmas_rtc_update_bits(struct palmas *palmas, unsigned int reg,
82                                 unsigned int mask, unsigned int val)
83 {
84         unsigned int addr;
85         addr = PALMAS_BASE_TO_REG(PALMAS_RTC_BASE, reg);
86
87         return regmap_update_bits(palmas->regmap[RTC_SLAVE], addr, mask, val);
88 }
89
90 static int palmas_rtc_alarm_irq_enable(struct device *dev, unsigned enabled)
91 {
92         struct palmas *palmas = dev_get_drvdata(dev->parent);
93         u8 val = 0;
94
95         if (enabled)
96                 val = PALMAS_RTC_INTERRUPTS_REG_IT_ALARM;
97
98         return palmas_rtc_write(palmas,
99                 PALMAS_RTC_INTERRUPTS_REG, val);
100 }
101
102 /*
103  * Gets current palmas RTC time and date parameters.
104  *
105  * The RTC's time/alarm representation is not what gmtime(3) requires
106  * Linux to use:
107  *
108  *  - Months are 1..12 vs Linux 0-11
109  *  - Years are 0..99 vs Linux 1900..N (we assume 21st century)
110  */
111 static int palmas_rtc_read_time(struct device *dev, struct rtc_time *tm)
112 {
113         unsigned char rtc_data[NUM_TIME_REGS];
114         struct palmas *palmas = dev_get_drvdata(dev->parent);
115         int ret;
116
117         /* Copy RTC counting registers to static registers or latches */
118         ret = palmas_rtc_update_bits(palmas, PALMAS_RTC_CTRL_REG,
119                 PALMAS_RTC_CTRL_REG_GET_TIME, PALMAS_RTC_CTRL_REG_GET_TIME);
120         if (ret < 0) {
121                 dev_err(dev, "RTC CTRL reg update failed with err:%d\n", ret);
122                 return ret;
123         }
124
125         ret = palmas_rtc_bulk_read(palmas, PALMAS_SECONDS_REG,
126                 rtc_data, NUM_TIME_REGS);
127         if (ret < 0) {
128                 dev_err(dev, "reading from RTC failed with err:%d\n", ret);
129                 return ret;
130         }
131
132         tm->tm_sec = bcd2bin(rtc_data[0]);
133         tm->tm_min = bcd2bin(rtc_data[1]);
134         tm->tm_hour = bcd2bin(rtc_data[2]);
135         tm->tm_mday = bcd2bin(rtc_data[3]);
136         tm->tm_mon = bcd2bin(rtc_data[4]) - 1;
137         tm->tm_year = bcd2bin(rtc_data[5]) + 100;
138
139         return ret;
140 }
141
142 static int palmas_rtc_set_time(struct device *dev, struct rtc_time *tm)
143 {
144         unsigned char rtc_data[NUM_TIME_REGS];
145         struct palmas *palmas = dev_get_drvdata(dev->parent);
146         int ret;
147
148         rtc_data[0] = bin2bcd(tm->tm_sec);
149         rtc_data[1] = bin2bcd(tm->tm_min);
150         rtc_data[2] = bin2bcd(tm->tm_hour);
151         rtc_data[3] = bin2bcd(tm->tm_mday);
152         rtc_data[4] = bin2bcd(tm->tm_mon + 1);
153         rtc_data[5] = bin2bcd(tm->tm_year - 100);
154
155         /* Stop RTC while updating the RTC time registers */
156         ret = palmas_rtc_update_bits(palmas, PALMAS_RTC_CTRL_REG,
157                 PALMAS_RTC_CTRL_REG_STOP_RTC, 0);
158         if (ret < 0) {
159                 dev_err(dev, "RTC stop failed with err:%d\n", ret);
160                 return ret;
161         }
162
163         /* update all the time registers in one shot */
164         ret = palmas_rtc_bulk_write(palmas, PALMAS_SECONDS_REG,
165                 rtc_data, NUM_TIME_REGS);
166         if (ret < 0) {
167                 dev_err(dev, "rtc_set_time error %d\n", ret);
168                 return ret;
169         }
170
171         /* Start back RTC */
172         ret = palmas_rtc_update_bits(palmas, PALMAS_RTC_CTRL_REG,
173                 PALMAS_RTC_CTRL_REG_STOP_RTC, 1);
174         if (ret < 0)
175                 dev_err(dev, "RTC start failed with err:%d\n", ret);
176
177         return ret;
178 }
179
180 /*
181  * Gets current palmas RTC alarm time.
182  */
183 static int palmas_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
184 {
185         unsigned char alarm_data[NUM_TIME_REGS];
186         u32 int_val;
187         struct palmas *palmas = dev_get_drvdata(dev->parent);
188         int ret;
189
190         ret = palmas_rtc_bulk_read(palmas, PALMAS_SECONDS_REG,
191                 alarm_data, NUM_TIME_REGS);
192         if (ret < 0) {
193                 dev_err(dev, "rtc_read_alarm error %d\n", ret);
194                 return ret;
195         }
196
197         alm->time.tm_sec = bcd2bin(alarm_data[0]);
198         alm->time.tm_min = bcd2bin(alarm_data[1]);
199         alm->time.tm_hour = bcd2bin(alarm_data[2]);
200         alm->time.tm_mday = bcd2bin(alarm_data[3]);
201         alm->time.tm_mon = bcd2bin(alarm_data[4]) - 1;
202         alm->time.tm_year = bcd2bin(alarm_data[5]) + 100;
203
204         ret = palmas_rtc_read(palmas, PALMAS_RTC_INTERRUPTS_REG,
205                 &int_val);
206         if (ret < 0)
207                 return ret;
208
209         if (int_val & PALMAS_RTC_INTERRUPTS_REG_IT_ALARM)
210                 alm->enabled = 1;
211
212         return ret;
213 }
214
215 static int palmas_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
216 {
217         unsigned char alarm_data[NUM_TIME_REGS];
218         struct palmas *palmas = dev_get_drvdata(dev->parent);
219         int ret;
220
221         ret = palmas_rtc_alarm_irq_enable(dev, 0);
222         if (ret)
223                 return ret;
224
225         alarm_data[0] = bin2bcd(alm->time.tm_sec);
226         alarm_data[1] = bin2bcd(alm->time.tm_min);
227         alarm_data[2] = bin2bcd(alm->time.tm_hour);
228         alarm_data[3] = bin2bcd(alm->time.tm_mday);
229         alarm_data[4] = bin2bcd(alm->time.tm_mon + 1);
230         alarm_data[5] = bin2bcd(alm->time.tm_year - 100);
231
232         /* update all the alarm registers in one shot */
233         ret = palmas_rtc_bulk_write(palmas,
234                 PALMAS_ALARM_SECONDS_REG, alarm_data, NUM_TIME_REGS);
235         if (ret) {
236                 dev_err(dev, "rtc_set_alarm error %d\n", ret);
237                 return ret;
238         }
239
240         if (alm->enabled)
241                 ret = palmas_rtc_alarm_irq_enable(dev, 1);
242
243         return ret;
244 }
245
246 static irqreturn_t palmas_rtc_interrupt(int irq, void *rtc)
247 {
248         struct device *dev = rtc;
249         unsigned long events = 0;
250         struct palmas *palmas = dev_get_drvdata(dev->parent);
251         struct palmas_rtc *palmas_rtc = dev_get_drvdata(dev);
252         int ret;
253         u32 rtc_reg;
254
255         ret = palmas_rtc_read(palmas, PALMAS_RTC_STATUS_REG,
256                 &rtc_reg);
257         if (ret)
258                 return IRQ_NONE;
259
260         if (rtc_reg & PALMAS_RTC_STATUS_REG_ALARM)
261                 events = RTC_IRQF | RTC_AF;
262
263         ret = palmas_rtc_write(palmas, PALMAS_RTC_STATUS_REG,
264                 rtc_reg);
265         if (ret)
266                 return IRQ_NONE;
267
268         /* Notify RTC core on event */
269         rtc_update_irq(palmas_rtc->rtc, 1, events);
270
271         return IRQ_HANDLED;
272 }
273
274 static struct rtc_class_ops palmas_rtc_ops = {
275         .read_time      = palmas_rtc_read_time,
276         .set_time       = palmas_rtc_set_time,
277         .read_alarm     = palmas_rtc_read_alarm,
278         .set_alarm      = palmas_rtc_set_alarm,
279         .alarm_irq_enable = palmas_rtc_alarm_irq_enable,
280 };
281
282 static int __devinit palmas_rtc_probe(struct platform_device *pdev)
283 {
284         struct palmas *palmas = NULL;
285         struct palmas_rtc *palmas_rtc = NULL;
286         struct palmas_platform_data *palmas_pdata;
287         struct palmas_rtc_platform_data *rtc_pdata = NULL;
288         int ret;
289         u32 rtc_reg;
290
291         palmas = dev_get_drvdata(pdev->dev.parent);
292
293         palmas_rtc = devm_kzalloc(&pdev->dev, sizeof(struct palmas_rtc),
294                         GFP_KERNEL);
295         if (!palmas_rtc) {
296                 dev_err(&pdev->dev, "Memory allocation failed.\n");
297                 return -ENOMEM;
298         }
299
300         palmas_pdata = dev_get_platdata(pdev->dev.parent);
301         if (palmas_pdata)
302                 rtc_pdata = palmas_pdata->rtc_pdata;
303
304         palmas->rtc = palmas_rtc;
305         if (rtc_pdata && rtc_pdata->enable_charging) {
306                 int slave;
307                 unsigned int addr;
308                 int reg = 0;
309
310                 addr = PALMAS_BASE_TO_REG(PALMAS_PMU_CONTROL_BASE,
311                                 PALMAS_BACKUP_BATTERY_CTRL);
312                 slave = PALMAS_BASE_TO_SLAVE(PALMAS_PMU_CONTROL_BASE);
313
314                 if (rtc_pdata->charging_current_ua < 100)
315                         reg = PALMAS_BACKUP_BATTERY_CTRL_BBS_BBC_LOW_ICHRG;
316
317                 ret = regmap_update_bits(palmas->regmap[slave], addr,
318                                 PALMAS_BACKUP_BATTERY_CTRL_BBS_BBC_LOW_ICHRG,
319                                 reg);
320                 if (ret < 0) {
321                         dev_err(&pdev->dev,
322                                 "Battery backup control failed, e %d\n", ret);
323                         return ret;
324                 };
325
326                 ret = regmap_update_bits(palmas->regmap[slave], addr,
327                                 PALMAS_BACKUP_BATTERY_CTRL_BB_CHG_EN,
328                                 PALMAS_BACKUP_BATTERY_CTRL_BB_CHG_EN);
329                 if (ret < 0) {
330                         dev_err(&pdev->dev,
331                                 "Battery backup charging enable failed, e %d\n",
332                                 ret);
333                         return ret;
334                 }
335         }
336
337         /* Clear pending interrupts */
338         ret = palmas_rtc_read(palmas, PALMAS_RTC_STATUS_REG,
339                 &rtc_reg);
340         if (ret < 0) {
341                 dev_err(&pdev->dev, "rtc_read_status error %d\n", ret);
342                 return ret;
343         }
344
345         ret = palmas_rtc_write(palmas, PALMAS_RTC_STATUS_REG,
346                 rtc_reg);
347         if (ret < 0) {
348                 dev_err(&pdev->dev, "rtc_clear_interupt error %d\n", ret);
349                 return ret;
350         }
351
352         dev_dbg(&pdev->dev, "Enabling palmas-RTC.\n");
353         rtc_reg = PALMAS_RTC_CTRL_REG_STOP_RTC;
354         ret = palmas_rtc_write(palmas, PALMAS_RTC_CTRL_REG,
355                 rtc_reg);
356         if (ret < 0) {
357                 dev_err(&pdev->dev, "rtc_enable error %d\n", ret);
358                 return ret;
359         }
360
361         if (!regmap_irq_chip_get_base(palmas->irq_data))
362                 return -EINVAL;
363
364         palmas_rtc->irq = regmap_irq_chip_get_base(palmas->irq_data);
365         if (palmas_rtc->irq <= 0) {
366                 dev_err(&pdev->dev, "Wake up is not possible as irq = %d\n",
367                         palmas_rtc->irq);
368                 return ret;
369         }
370
371         palmas_rtc->irq += PALMAS_RTC_ALARM_IRQ;
372
373         ret = request_threaded_irq(palmas_rtc->irq, NULL,
374                 palmas_rtc_interrupt, IRQF_TRIGGER_LOW,
375                 "palmas-rtc", &pdev->dev);
376         if (ret < 0) {
377                 dev_err(&pdev->dev, "IRQ is not free.\n");
378                 return ret;
379         }
380         device_init_wakeup(&pdev->dev, 1);
381
382         palmas_rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
383                 &palmas_rtc_ops, THIS_MODULE);
384         if (IS_ERR(palmas_rtc->rtc)) {
385                 ret = PTR_ERR(palmas_rtc->rtc);
386                 free_irq(palmas_rtc->irq, &pdev->dev);
387                 dev_err(&pdev->dev, "RTC device register: err %d\n", ret);
388                 return ret;
389         }
390
391         platform_set_drvdata(pdev, palmas_rtc);
392
393         return 0;
394 }
395
396 /*
397  * Disable all palmas RTC module interrupts.
398  * Sets status flag to free.
399  */
400 static int __devexit palmas_rtc_remove(struct platform_device *pdev)
401 {
402         /* leave rtc running, but disable irqs */
403         struct palmas *palmas = dev_get_drvdata(pdev->dev.parent);
404
405         palmas_rtc_alarm_irq_enable(&palmas->rtc->rtc->dev, 0);
406         free_irq(palmas->irq, &pdev->dev);
407         rtc_device_unregister(palmas->rtc->rtc);
408         return 0;
409 }
410
411 #ifdef CONFIG_PM_SLEEP
412 static int palmas_rtc_suspend(struct device *dev)
413 {
414         struct platform_device *pdev = to_platform_device(dev);
415         struct palmas *palmas = dev_get_drvdata(pdev->dev.parent);
416         u8 alarm = PALMAS_RTC_INTERRUPTS_REG_IT_ALARM;
417         int ret;
418
419         if (device_may_wakeup(dev))
420                 enable_irq_wake(palmas->rtc->irq);
421
422         /* Store current list of enabled interrupts*/
423         ret = palmas_rtc_read(palmas, PALMAS_RTC_INTERRUPTS_REG,
424                 &palmas->rtc->irqstat);
425         if (ret < 0)
426                 return ret;
427
428         /* Enable RTC ALARM interrupt only */
429         return palmas_rtc_write(palmas,
430                 PALMAS_RTC_INTERRUPTS_REG, alarm);
431 }
432
433 static int palmas_rtc_resume(struct device *dev)
434 {
435         struct platform_device *pdev = to_platform_device(dev);
436         struct palmas *palmas = dev_get_drvdata(pdev->dev.parent);
437
438         if (device_may_wakeup(dev))
439                 disable_irq_wake(palmas->rtc->irq);
440
441         /* Restore list of enabled interrupts before suspend */
442         return palmas_rtc_write(palmas,
443                 PALMAS_RTC_INTERRUPTS_REG, palmas->rtc->irqstat);
444 }
445
446 static const struct dev_pm_ops palmas_rtc_pm_ops = {
447         .suspend        = palmas_rtc_suspend,
448         .resume         = palmas_rtc_resume,
449 };
450
451 #define DEV_PM_OPS     (&palmas_rtc_pm_ops)
452 #else
453 #define DEV_PM_OPS     NULL
454 #endif
455
456 static struct platform_driver palmas_rtc_driver = {
457         .probe          = palmas_rtc_probe,
458         .remove         = __devexit_p(palmas_rtc_remove),
459         .driver         = {
460                 .owner  = THIS_MODULE,
461                 .name   = "palmas-rtc",
462                 .pm     = DEV_PM_OPS,
463         },
464 };
465
466 module_platform_driver(palmas_rtc_driver);
467 MODULE_ALIAS("platform:palmas_rtc");
468 MODULE_AUTHOR("Kasoju Mallikarjun <mkasoju@nvidia.com>");
469 MODULE_LICENSE("GPL v2");