aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/rtc
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/rtc')
-rw-r--r--drivers/rtc/Kconfig30
-rw-r--r--drivers/rtc/Makefile2
-rw-r--r--drivers/rtc/interface.c13
-rw-r--r--drivers/rtc/rtc-88pm80x.c8
-rw-r--r--drivers/rtc/rtc-88pm860x.c2
-rw-r--r--drivers/rtc/rtc-as3722.c275
-rw-r--r--drivers/rtc/rtc-at91rm9200.c39
-rw-r--r--drivers/rtc/rtc-cmos.c3
-rw-r--r--drivers/rtc/rtc-da9055.c2
-rw-r--r--drivers/rtc/rtc-ds1305.c2
-rw-r--r--drivers/rtc/rtc-ds1307.c10
-rw-r--r--drivers/rtc/rtc-ds2404.c2
-rw-r--r--drivers/rtc/rtc-ep93xx.c6
-rw-r--r--drivers/rtc/rtc-hid-sensor-time.c28
-rw-r--r--drivers/rtc/rtc-isl1208.c42
-rw-r--r--drivers/rtc/rtc-m48t59.c20
-rw-r--r--drivers/rtc/rtc-m48t86.c8
-rw-r--r--drivers/rtc/rtc-max6900.c9
-rw-r--r--drivers/rtc/rtc-mpc5121.c2
-rw-r--r--drivers/rtc/rtc-mrst.c6
-rw-r--r--drivers/rtc/rtc-omap.c2
-rw-r--r--drivers/rtc/rtc-pcf2123.c2
-rw-r--r--drivers/rtc/rtc-pl030.c9
-rw-r--r--drivers/rtc/rtc-pl031.c5
-rw-r--r--drivers/rtc/rtc-puv3.c22
-rw-r--r--drivers/rtc/rtc-rs5c348.c4
-rw-r--r--drivers/rtc/rtc-s5m.c687
-rw-r--r--drivers/rtc/rtc-sh.c5
-rw-r--r--drivers/rtc/rtc-sirfsoc.c27
-rw-r--r--drivers/rtc/rtc-snvs.c2
-rw-r--r--drivers/rtc/rtc-stmp3xxx.c2
-rw-r--r--drivers/rtc/rtc-tps65910.c1
-rw-r--r--drivers/rtc/rtc-v3020.c2
-rw-r--r--drivers/rtc/rtc-vr41xx.c4
-rw-r--r--drivers/rtc/rtc-vt8500.c4
35 files changed, 1130 insertions, 157 deletions
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 9654aa3c05cb..007730222116 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -153,6 +153,16 @@ config RTC_DRV_88PM80X
153 This driver can also be built as a module. If so, the module 153 This driver can also be built as a module. If so, the module
154 will be called rtc-88pm80x. 154 will be called rtc-88pm80x.
155 155
156config RTC_DRV_AS3722
157 tristate "ams AS3722 RTC driver"
158 depends on MFD_AS3722
159 help
160 If you say yes here you get support for the RTC of ams AS3722 PMIC
161 chips.
162
163 This driver can also be built as a module. If so, the module
164 will be called rtc-as3722.
165
156config RTC_DRV_DS1307 166config RTC_DRV_DS1307
157 tristate "Dallas/Maxim DS1307/37/38/39/40, ST M41T00, EPSON RX-8025" 167 tristate "Dallas/Maxim DS1307/37/38/39/40, ST M41T00, EPSON RX-8025"
158 help 168 help
@@ -497,6 +507,16 @@ config RTC_DRV_RV3029C2
497 This driver can also be built as a module. If so, the module 507 This driver can also be built as a module. If so, the module
498 will be called rtc-rv3029c2. 508 will be called rtc-rv3029c2.
499 509
510config RTC_DRV_S5M
511 tristate "Samsung S5M series"
512 depends on MFD_SEC_CORE
513 help
514 If you say yes here you will get support for the
515 RTC of Samsung S5M PMIC series.
516
517 This driver can also be built as a module. If so, the module
518 will be called rtc-s5m.
519
500endif # I2C 520endif # I2C
501 521
502comment "SPI RTC drivers" 522comment "SPI RTC drivers"
@@ -606,7 +626,7 @@ comment "Platform RTC drivers"
606 626
607config RTC_DRV_CMOS 627config RTC_DRV_CMOS
608 tristate "PC-style 'CMOS'" 628 tristate "PC-style 'CMOS'"
609 depends on X86 || ALPHA || ARM || M32R || ATARI || PPC || MIPS || SPARC64 629 depends on X86 || ARM || M32R || ATARI || PPC || MIPS || SPARC64
610 default y if X86 630 default y if X86
611 help 631 help
612 Say "yes" here to get direct support for the real time clock 632 Say "yes" here to get direct support for the real time clock
@@ -623,6 +643,14 @@ config RTC_DRV_CMOS
623 This driver can also be built as a module. If so, the module 643 This driver can also be built as a module. If so, the module
624 will be called rtc-cmos. 644 will be called rtc-cmos.
625 645
646config RTC_DRV_ALPHA
647 bool "Alpha PC-style CMOS"
648 depends on ALPHA
649 default y
650 help
651 Direct support for the real-time clock found on every Alpha
652 system, specifically MC146818 compatibles. If in doubt, say Y.
653
626config RTC_DRV_VRTC 654config RTC_DRV_VRTC
627 tristate "Virtual RTC for Intel MID platforms" 655 tristate "Virtual RTC for Intel MID platforms"
628 depends on X86_INTEL_MID 656 depends on X86_INTEL_MID
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index 2dff3d2009b5..27b4bd884066 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -20,6 +20,7 @@ obj-$(CONFIG_RTC_DRV_88PM860X) += rtc-88pm860x.o
20obj-$(CONFIG_RTC_DRV_88PM80X) += rtc-88pm80x.o 20obj-$(CONFIG_RTC_DRV_88PM80X) += rtc-88pm80x.o
21obj-$(CONFIG_RTC_DRV_AB3100) += rtc-ab3100.o 21obj-$(CONFIG_RTC_DRV_AB3100) += rtc-ab3100.o
22obj-$(CONFIG_RTC_DRV_AB8500) += rtc-ab8500.o 22obj-$(CONFIG_RTC_DRV_AB8500) += rtc-ab8500.o
23obj-$(CONFIG_RTC_DRV_AS3722) += rtc-as3722.o
23obj-$(CONFIG_RTC_DRV_AT32AP700X)+= rtc-at32ap700x.o 24obj-$(CONFIG_RTC_DRV_AT32AP700X)+= rtc-at32ap700x.o
24obj-$(CONFIG_RTC_DRV_AT91RM9200)+= rtc-at91rm9200.o 25obj-$(CONFIG_RTC_DRV_AT91RM9200)+= rtc-at91rm9200.o
25obj-$(CONFIG_RTC_DRV_AT91SAM9) += rtc-at91sam9.o 26obj-$(CONFIG_RTC_DRV_AT91SAM9) += rtc-at91sam9.o
@@ -107,6 +108,7 @@ obj-$(CONFIG_RTC_DRV_RX8025) += rtc-rx8025.o
107obj-$(CONFIG_RTC_DRV_RX8581) += rtc-rx8581.o 108obj-$(CONFIG_RTC_DRV_RX8581) += rtc-rx8581.o
108obj-$(CONFIG_RTC_DRV_S35390A) += rtc-s35390a.o 109obj-$(CONFIG_RTC_DRV_S35390A) += rtc-s35390a.o
109obj-$(CONFIG_RTC_DRV_S3C) += rtc-s3c.o 110obj-$(CONFIG_RTC_DRV_S3C) += rtc-s3c.o
111obj-$(CONFIG_RTC_DRV_S5M) += rtc-s5m.o
110obj-$(CONFIG_RTC_DRV_SA1100) += rtc-sa1100.o 112obj-$(CONFIG_RTC_DRV_SA1100) += rtc-sa1100.o
111obj-$(CONFIG_RTC_DRV_SH) += rtc-sh.o 113obj-$(CONFIG_RTC_DRV_SH) += rtc-sh.o
112obj-$(CONFIG_RTC_DRV_SNVS) += rtc-snvs.o 114obj-$(CONFIG_RTC_DRV_SNVS) += rtc-snvs.o
diff --git a/drivers/rtc/interface.c b/drivers/rtc/interface.c
index 72c5cdbe0791..544be722937c 100644
--- a/drivers/rtc/interface.c
+++ b/drivers/rtc/interface.c
@@ -72,6 +72,7 @@ int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm)
72 } else 72 } else
73 err = -EINVAL; 73 err = -EINVAL;
74 74
75 pm_stay_awake(rtc->dev.parent);
75 mutex_unlock(&rtc->ops_lock); 76 mutex_unlock(&rtc->ops_lock);
76 /* A timer might have just expired */ 77 /* A timer might have just expired */
77 schedule_work(&rtc->irqwork); 78 schedule_work(&rtc->irqwork);
@@ -113,6 +114,7 @@ int rtc_set_mmss(struct rtc_device *rtc, unsigned long secs)
113 err = -EINVAL; 114 err = -EINVAL;
114 } 115 }
115 116
117 pm_stay_awake(rtc->dev.parent);
116 mutex_unlock(&rtc->ops_lock); 118 mutex_unlock(&rtc->ops_lock);
117 /* A timer might have just expired */ 119 /* A timer might have just expired */
118 schedule_work(&rtc->irqwork); 120 schedule_work(&rtc->irqwork);
@@ -771,9 +773,10 @@ static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer)
771 alarm.time = rtc_ktime_to_tm(timer->node.expires); 773 alarm.time = rtc_ktime_to_tm(timer->node.expires);
772 alarm.enabled = 1; 774 alarm.enabled = 1;
773 err = __rtc_set_alarm(rtc, &alarm); 775 err = __rtc_set_alarm(rtc, &alarm);
774 if (err == -ETIME) 776 if (err == -ETIME) {
777 pm_stay_awake(rtc->dev.parent);
775 schedule_work(&rtc->irqwork); 778 schedule_work(&rtc->irqwork);
776 else if (err) { 779 } else if (err) {
777 timerqueue_del(&rtc->timerqueue, &timer->node); 780 timerqueue_del(&rtc->timerqueue, &timer->node);
778 timer->enabled = 0; 781 timer->enabled = 0;
779 return err; 782 return err;
@@ -818,8 +821,10 @@ static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer)
818 alarm.time = rtc_ktime_to_tm(next->expires); 821 alarm.time = rtc_ktime_to_tm(next->expires);
819 alarm.enabled = 1; 822 alarm.enabled = 1;
820 err = __rtc_set_alarm(rtc, &alarm); 823 err = __rtc_set_alarm(rtc, &alarm);
821 if (err == -ETIME) 824 if (err == -ETIME) {
825 pm_stay_awake(rtc->dev.parent);
822 schedule_work(&rtc->irqwork); 826 schedule_work(&rtc->irqwork);
827 }
823 } 828 }
824} 829}
825 830
@@ -845,7 +850,6 @@ void rtc_timer_do_work(struct work_struct *work)
845 850
846 mutex_lock(&rtc->ops_lock); 851 mutex_lock(&rtc->ops_lock);
847again: 852again:
848 pm_relax(rtc->dev.parent);
849 __rtc_read_time(rtc, &tm); 853 __rtc_read_time(rtc, &tm);
850 now = rtc_tm_to_ktime(tm); 854 now = rtc_tm_to_ktime(tm);
851 while ((next = timerqueue_getnext(&rtc->timerqueue))) { 855 while ((next = timerqueue_getnext(&rtc->timerqueue))) {
@@ -880,6 +884,7 @@ again:
880 } else 884 } else
881 rtc_alarm_disable(rtc); 885 rtc_alarm_disable(rtc);
882 886
887 pm_relax(rtc->dev.parent);
883 mutex_unlock(&rtc->ops_lock); 888 mutex_unlock(&rtc->ops_lock);
884} 889}
885 890
diff --git a/drivers/rtc/rtc-88pm80x.c b/drivers/rtc/rtc-88pm80x.c
index 354c937a5866..0916089c7c3e 100644
--- a/drivers/rtc/rtc-88pm80x.c
+++ b/drivers/rtc/rtc-88pm80x.c
@@ -251,14 +251,15 @@ static SIMPLE_DEV_PM_OPS(pm80x_rtc_pm_ops, pm80x_rtc_suspend, pm80x_rtc_resume);
251static int pm80x_rtc_probe(struct platform_device *pdev) 251static int pm80x_rtc_probe(struct platform_device *pdev)
252{ 252{
253 struct pm80x_chip *chip = dev_get_drvdata(pdev->dev.parent); 253 struct pm80x_chip *chip = dev_get_drvdata(pdev->dev.parent);
254 struct pm80x_platform_data *pm80x_pdata; 254 struct pm80x_platform_data *pm80x_pdata =
255 dev_get_platdata(pdev->dev.parent);
255 struct pm80x_rtc_pdata *pdata = NULL; 256 struct pm80x_rtc_pdata *pdata = NULL;
256 struct pm80x_rtc_info *info; 257 struct pm80x_rtc_info *info;
257 struct rtc_time tm; 258 struct rtc_time tm;
258 unsigned long ticks = 0; 259 unsigned long ticks = 0;
259 int ret; 260 int ret;
260 261
261 pdata = pdev->dev.platform_data; 262 pdata = dev_get_platdata(&pdev->dev);
262 if (pdata == NULL) 263 if (pdata == NULL)
263 dev_warn(&pdev->dev, "No platform data!\n"); 264 dev_warn(&pdev->dev, "No platform data!\n");
264 265
@@ -326,8 +327,7 @@ static int pm80x_rtc_probe(struct platform_device *pdev)
326 regmap_update_bits(info->map, PM800_RTC_CONTROL, PM800_RTC1_USE_XO, 327 regmap_update_bits(info->map, PM800_RTC_CONTROL, PM800_RTC1_USE_XO,
327 PM800_RTC1_USE_XO); 328 PM800_RTC1_USE_XO);
328 329
329 if (pdev->dev.parent->platform_data) { 330 if (pm80x_pdata) {
330 pm80x_pdata = pdev->dev.parent->platform_data;
331 pdata = pm80x_pdata->rtc; 331 pdata = pm80x_pdata->rtc;
332 if (pdata) 332 if (pdata)
333 info->rtc_dev->dev.platform_data = &pdata->rtc_wakeup; 333 info->rtc_dev->dev.platform_data = &pdata->rtc_wakeup;
diff --git a/drivers/rtc/rtc-88pm860x.c b/drivers/rtc/rtc-88pm860x.c
index 4e30c85728e5..816504846cdd 100644
--- a/drivers/rtc/rtc-88pm860x.c
+++ b/drivers/rtc/rtc-88pm860x.c
@@ -316,7 +316,7 @@ static int pm860x_rtc_probe(struct platform_device *pdev)
316 unsigned long ticks = 0; 316 unsigned long ticks = 0;
317 int ret; 317 int ret;
318 318
319 pdata = pdev->dev.platform_data; 319 pdata = dev_get_platdata(&pdev->dev);
320 320
321 info = devm_kzalloc(&pdev->dev, sizeof(struct pm860x_rtc_info), 321 info = devm_kzalloc(&pdev->dev, sizeof(struct pm860x_rtc_info),
322 GFP_KERNEL); 322 GFP_KERNEL);
diff --git a/drivers/rtc/rtc-as3722.c b/drivers/rtc/rtc-as3722.c
new file mode 100644
index 000000000000..9cfa8170a2d6
--- /dev/null
+++ b/drivers/rtc/rtc-as3722.c
@@ -0,0 +1,275 @@
1/*
2 * rtc-as3722.c - Real Time Clock driver for ams AS3722 PMICs
3 *
4 * Copyright (C) 2013 ams AG
5 * Copyright (c) 2013, NVIDIA Corporation. All rights reserved.
6 *
7 * Author: Florian Lobmaier <florian.lobmaier@ams.com>
8 * Author: Laxman Dewangan <ldewangan@nvidia.com>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 */
20
21#include <linux/bcd.h>
22#include <linux/completion.h>
23#include <linux/delay.h>
24#include <linux/interrupt.h>
25#include <linux/ioctl.h>
26#include <linux/kernel.h>
27#include <linux/module.h>
28#include <linux/mfd/as3722.h>
29#include <linux/platform_device.h>
30#include <linux/rtc.h>
31#include <linux/time.h>
32
33#define AS3722_RTC_START_YEAR 2000
34struct as3722_rtc {
35 struct rtc_device *rtc;
36 struct device *dev;
37 struct as3722 *as3722;
38 int alarm_irq;
39 bool irq_enable;
40};
41
42static void as3722_time_to_reg(u8 *rbuff, struct rtc_time *tm)
43{
44 rbuff[0] = bin2bcd(tm->tm_sec);
45 rbuff[1] = bin2bcd(tm->tm_min);
46 rbuff[2] = bin2bcd(tm->tm_hour);
47 rbuff[3] = bin2bcd(tm->tm_mday);
48 rbuff[4] = bin2bcd(tm->tm_mon);
49 rbuff[5] = bin2bcd(tm->tm_year - (AS3722_RTC_START_YEAR - 1900));
50}
51
52static void as3722_reg_to_time(u8 *rbuff, struct rtc_time *tm)
53{
54 tm->tm_sec = bcd2bin(rbuff[0] & 0x7F);
55 tm->tm_min = bcd2bin(rbuff[1] & 0x7F);
56 tm->tm_hour = bcd2bin(rbuff[2] & 0x3F);
57 tm->tm_mday = bcd2bin(rbuff[3] & 0x3F);
58 tm->tm_mon = bcd2bin(rbuff[4] & 0x1F);
59 tm->tm_year = (AS3722_RTC_START_YEAR - 1900) + bcd2bin(rbuff[5] & 0x7F);
60 return;
61}
62
63static int as3722_rtc_read_time(struct device *dev, struct rtc_time *tm)
64{
65 struct as3722_rtc *as3722_rtc = dev_get_drvdata(dev);
66 struct as3722 *as3722 = as3722_rtc->as3722;
67 u8 as_time_array[6];
68 int ret;
69
70 ret = as3722_block_read(as3722, AS3722_RTC_SECOND_REG,
71 6, as_time_array);
72 if (ret < 0) {
73 dev_err(dev, "RTC_SECOND reg block read failed %d\n", ret);
74 return ret;
75 }
76 as3722_reg_to_time(as_time_array, tm);
77 return 0;
78}
79
80static int as3722_rtc_set_time(struct device *dev, struct rtc_time *tm)
81{
82 struct as3722_rtc *as3722_rtc = dev_get_drvdata(dev);
83 struct as3722 *as3722 = as3722_rtc->as3722;
84 u8 as_time_array[6];
85 int ret;
86
87 if (tm->tm_year < (AS3722_RTC_START_YEAR - 1900))
88 return -EINVAL;
89
90 as3722_time_to_reg(as_time_array, tm);
91 ret = as3722_block_write(as3722, AS3722_RTC_SECOND_REG, 6,
92 as_time_array);
93 if (ret < 0)
94 dev_err(dev, "RTC_SECOND reg block write failed %d\n", ret);
95 return ret;
96}
97
98static int as3722_rtc_alarm_irq_enable(struct device *dev,
99 unsigned int enabled)
100{
101 struct as3722_rtc *as3722_rtc = dev_get_drvdata(dev);
102
103 if (enabled && !as3722_rtc->irq_enable) {
104 enable_irq(as3722_rtc->alarm_irq);
105 as3722_rtc->irq_enable = true;
106 } else if (!enabled && as3722_rtc->irq_enable) {
107 disable_irq(as3722_rtc->alarm_irq);
108 as3722_rtc->irq_enable = false;
109 }
110 return 0;
111}
112
113static int as3722_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
114{
115 struct as3722_rtc *as3722_rtc = dev_get_drvdata(dev);
116 struct as3722 *as3722 = as3722_rtc->as3722;
117 u8 as_time_array[6];
118 int ret;
119
120 ret = as3722_block_read(as3722, AS3722_RTC_ALARM_SECOND_REG, 6,
121 as_time_array);
122 if (ret < 0) {
123 dev_err(dev, "RTC_ALARM_SECOND block read failed %d\n", ret);
124 return ret;
125 }
126
127 as3722_reg_to_time(as_time_array, &alrm->time);
128 return 0;
129}
130
131static int as3722_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
132{
133 struct as3722_rtc *as3722_rtc = dev_get_drvdata(dev);
134 struct as3722 *as3722 = as3722_rtc->as3722;
135 u8 as_time_array[6];
136 int ret;
137
138 if (alrm->time.tm_year < (AS3722_RTC_START_YEAR - 1900))
139 return -EINVAL;
140
141 ret = as3722_rtc_alarm_irq_enable(dev, 0);
142 if (ret < 0) {
143 dev_err(dev, "Disable RTC alarm failed\n");
144 return ret;
145 }
146
147 as3722_time_to_reg(as_time_array, &alrm->time);
148 ret = as3722_block_write(as3722, AS3722_RTC_ALARM_SECOND_REG, 6,
149 as_time_array);
150 if (ret < 0) {
151 dev_err(dev, "RTC_ALARM_SECOND block write failed %d\n", ret);
152 return ret;
153 }
154
155 if (alrm->enabled)
156 ret = as3722_rtc_alarm_irq_enable(dev, alrm->enabled);
157 return ret;
158}
159
160static irqreturn_t as3722_alarm_irq(int irq, void *data)
161{
162 struct as3722_rtc *as3722_rtc = data;
163
164 rtc_update_irq(as3722_rtc->rtc, 1, RTC_IRQF | RTC_AF);
165 return IRQ_HANDLED;
166}
167
168static const struct rtc_class_ops as3722_rtc_ops = {
169 .read_time = as3722_rtc_read_time,
170 .set_time = as3722_rtc_set_time,
171 .read_alarm = as3722_rtc_read_alarm,
172 .set_alarm = as3722_rtc_set_alarm,
173 .alarm_irq_enable = as3722_rtc_alarm_irq_enable,
174};
175
176static int as3722_rtc_probe(struct platform_device *pdev)
177{
178 struct as3722 *as3722 = dev_get_drvdata(pdev->dev.parent);
179 struct as3722_rtc *as3722_rtc;
180 int ret;
181
182 as3722_rtc = devm_kzalloc(&pdev->dev, sizeof(*as3722_rtc), GFP_KERNEL);
183 if (!as3722_rtc)
184 return -ENOMEM;
185
186 as3722_rtc->as3722 = as3722;
187 as3722_rtc->dev = &pdev->dev;
188 platform_set_drvdata(pdev, as3722_rtc);
189
190 /* Enable the RTC to make sure it is running. */
191 ret = as3722_update_bits(as3722, AS3722_RTC_CONTROL_REG,
192 AS3722_RTC_ON | AS3722_RTC_ALARM_WAKEUP_EN,
193 AS3722_RTC_ON | AS3722_RTC_ALARM_WAKEUP_EN);
194 if (ret < 0) {
195 dev_err(&pdev->dev, "RTC_CONTROL reg write failed: %d\n", ret);
196 return ret;
197 }
198
199 device_init_wakeup(&pdev->dev, 1);
200
201 as3722_rtc->rtc = rtc_device_register("as3722", &pdev->dev,
202 &as3722_rtc_ops, THIS_MODULE);
203 if (IS_ERR(as3722_rtc->rtc)) {
204 ret = PTR_ERR(as3722_rtc->rtc);
205 dev_err(&pdev->dev, "RTC register failed: %d\n", ret);
206 return ret;
207 }
208
209 as3722_rtc->alarm_irq = platform_get_irq(pdev, 0);
210 dev_info(&pdev->dev, "RTC interrupt %d\n", as3722_rtc->alarm_irq);
211
212 ret = request_threaded_irq(as3722_rtc->alarm_irq, NULL,
213 as3722_alarm_irq, IRQF_ONESHOT | IRQF_EARLY_RESUME,
214 "rtc-alarm", as3722_rtc);
215 if (ret < 0) {
216 dev_err(&pdev->dev, "Failed to request alarm IRQ %d: %d\n",
217 as3722_rtc->alarm_irq, ret);
218 goto scrub;
219 }
220 disable_irq(as3722_rtc->alarm_irq);
221 return 0;
222scrub:
223 rtc_device_unregister(as3722_rtc->rtc);
224 return ret;
225}
226
227static int as3722_rtc_remove(struct platform_device *pdev)
228{
229 struct as3722_rtc *as3722_rtc = platform_get_drvdata(pdev);
230
231 free_irq(as3722_rtc->alarm_irq, as3722_rtc);
232 rtc_device_unregister(as3722_rtc->rtc);
233 return 0;
234}
235
236#ifdef CONFIG_PM_SLEEP
237static int as3722_rtc_suspend(struct device *dev)
238{
239 struct as3722_rtc *as3722_rtc = dev_get_drvdata(dev);
240
241 if (device_may_wakeup(dev))
242 enable_irq_wake(as3722_rtc->alarm_irq);
243
244 return 0;
245}
246
247static int as3722_rtc_resume(struct device *dev)
248{
249 struct as3722_rtc *as3722_rtc = dev_get_drvdata(dev);
250
251 if (device_may_wakeup(dev))
252 disable_irq_wake(as3722_rtc->alarm_irq);
253 return 0;
254}
255#endif
256
257static const struct dev_pm_ops as3722_rtc_pm_ops = {
258 SET_SYSTEM_SLEEP_PM_OPS(as3722_rtc_suspend, as3722_rtc_resume)
259};
260
261static struct platform_driver as3722_rtc_driver = {
262 .probe = as3722_rtc_probe,
263 .remove = as3722_rtc_remove,
264 .driver = {
265 .name = "as3722-rtc",
266 .pm = &as3722_rtc_pm_ops,
267 },
268};
269module_platform_driver(as3722_rtc_driver);
270
271MODULE_DESCRIPTION("RTC driver for AS3722 PMICs");
272MODULE_ALIAS("platform:as3722-rtc");
273MODULE_AUTHOR("Florian Lobmaier <florian.lobmaier@ams.com>");
274MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
275MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-at91rm9200.c b/drivers/rtc/rtc-at91rm9200.c
index 741892632ae0..3281c90691c3 100644
--- a/drivers/rtc/rtc-at91rm9200.c
+++ b/drivers/rtc/rtc-at91rm9200.c
@@ -220,6 +220,8 @@ static int at91_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
220 220
221 at91_alarm_year = tm.tm_year; 221 at91_alarm_year = tm.tm_year;
222 222
223 tm.tm_mon = alrm->time.tm_mon;
224 tm.tm_mday = alrm->time.tm_mday;
223 tm.tm_hour = alrm->time.tm_hour; 225 tm.tm_hour = alrm->time.tm_hour;
224 tm.tm_min = alrm->time.tm_min; 226 tm.tm_min = alrm->time.tm_min;
225 tm.tm_sec = alrm->time.tm_sec; 227 tm.tm_sec = alrm->time.tm_sec;
@@ -376,7 +378,8 @@ static int __init at91_rtc_probe(struct platform_device *pdev)
376 return -ENXIO; 378 return -ENXIO;
377 } 379 }
378 380
379 at91_rtc_regs = ioremap(regs->start, resource_size(regs)); 381 at91_rtc_regs = devm_ioremap(&pdev->dev, regs->start,
382 resource_size(regs));
380 if (!at91_rtc_regs) { 383 if (!at91_rtc_regs) {
381 dev_err(&pdev->dev, "failed to map registers, aborting.\n"); 384 dev_err(&pdev->dev, "failed to map registers, aborting.\n");
382 return -ENOMEM; 385 return -ENOMEM;
@@ -390,12 +393,12 @@ static int __init at91_rtc_probe(struct platform_device *pdev)
390 AT91_RTC_SECEV | AT91_RTC_TIMEV | 393 AT91_RTC_SECEV | AT91_RTC_TIMEV |
391 AT91_RTC_CALEV); 394 AT91_RTC_CALEV);
392 395
393 ret = request_irq(irq, at91_rtc_interrupt, 396 ret = devm_request_irq(&pdev->dev, irq, at91_rtc_interrupt,
394 IRQF_SHARED, 397 IRQF_SHARED,
395 "at91_rtc", pdev); 398 "at91_rtc", pdev);
396 if (ret) { 399 if (ret) {
397 dev_err(&pdev->dev, "IRQ %d already in use.\n", irq); 400 dev_err(&pdev->dev, "IRQ %d already in use.\n", irq);
398 goto err_unmap; 401 return ret;
399 } 402 }
400 403
401 /* cpu init code should really have flagged this device as 404 /* cpu init code should really have flagged this device as
@@ -404,23 +407,14 @@ static int __init at91_rtc_probe(struct platform_device *pdev)
404 if (!device_can_wakeup(&pdev->dev)) 407 if (!device_can_wakeup(&pdev->dev))
405 device_init_wakeup(&pdev->dev, 1); 408 device_init_wakeup(&pdev->dev, 1);
406 409
407 rtc = rtc_device_register(pdev->name, &pdev->dev, 410 rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
408 &at91_rtc_ops, THIS_MODULE); 411 &at91_rtc_ops, THIS_MODULE);
409 if (IS_ERR(rtc)) { 412 if (IS_ERR(rtc))
410 ret = PTR_ERR(rtc); 413 return PTR_ERR(rtc);
411 goto err_free_irq;
412 }
413 platform_set_drvdata(pdev, rtc); 414 platform_set_drvdata(pdev, rtc);
414 415
415 dev_info(&pdev->dev, "AT91 Real Time Clock driver.\n"); 416 dev_info(&pdev->dev, "AT91 Real Time Clock driver.\n");
416 return 0; 417 return 0;
417
418err_free_irq:
419 free_irq(irq, pdev);
420err_unmap:
421 iounmap(at91_rtc_regs);
422
423 return ret;
424} 418}
425 419
426/* 420/*
@@ -428,20 +422,22 @@ err_unmap:
428 */ 422 */
429static int __exit at91_rtc_remove(struct platform_device *pdev) 423static int __exit at91_rtc_remove(struct platform_device *pdev)
430{ 424{
431 struct rtc_device *rtc = platform_get_drvdata(pdev);
432
433 /* Disable all interrupts */ 425 /* Disable all interrupts */
434 at91_rtc_write_idr(AT91_RTC_ACKUPD | AT91_RTC_ALARM | 426 at91_rtc_write_idr(AT91_RTC_ACKUPD | AT91_RTC_ALARM |
435 AT91_RTC_SECEV | AT91_RTC_TIMEV | 427 AT91_RTC_SECEV | AT91_RTC_TIMEV |
436 AT91_RTC_CALEV); 428 AT91_RTC_CALEV);
437 free_irq(irq, pdev);
438
439 rtc_device_unregister(rtc);
440 iounmap(at91_rtc_regs);
441 429
442 return 0; 430 return 0;
443} 431}
444 432
433static void at91_rtc_shutdown(struct platform_device *pdev)
434{
435 /* Disable all interrupts */
436 at91_rtc_write(AT91_RTC_IDR, AT91_RTC_ACKUPD | AT91_RTC_ALARM |
437 AT91_RTC_SECEV | AT91_RTC_TIMEV |
438 AT91_RTC_CALEV);
439}
440
445#ifdef CONFIG_PM_SLEEP 441#ifdef CONFIG_PM_SLEEP
446 442
447/* AT91RM9200 RTC Power management control */ 443/* AT91RM9200 RTC Power management control */
@@ -480,6 +476,7 @@ static SIMPLE_DEV_PM_OPS(at91_rtc_pm_ops, at91_rtc_suspend, at91_rtc_resume);
480 476
481static struct platform_driver at91_rtc_driver = { 477static struct platform_driver at91_rtc_driver = {
482 .remove = __exit_p(at91_rtc_remove), 478 .remove = __exit_p(at91_rtc_remove),
479 .shutdown = at91_rtc_shutdown,
483 .driver = { 480 .driver = {
484 .name = "at91_rtc", 481 .name = "at91_rtc",
485 .owner = THIS_MODULE, 482 .owner = THIS_MODULE,
diff --git a/drivers/rtc/rtc-cmos.c b/drivers/rtc/rtc-cmos.c
index 24e733c98f8b..f14876256a4a 100644
--- a/drivers/rtc/rtc-cmos.c
+++ b/drivers/rtc/rtc-cmos.c
@@ -595,7 +595,7 @@ static irqreturn_t cmos_interrupt(int irq, void *p)
595static int INITSECTION 595static int INITSECTION
596cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq) 596cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
597{ 597{
598 struct cmos_rtc_board_info *info = dev->platform_data; 598 struct cmos_rtc_board_info *info = dev_get_platdata(dev);
599 int retval = 0; 599 int retval = 0;
600 unsigned char rtc_control; 600 unsigned char rtc_control;
601 unsigned address_space; 601 unsigned address_space;
@@ -789,7 +789,6 @@ static void __exit cmos_do_remove(struct device *dev)
789 cmos->iomem = NULL; 789 cmos->iomem = NULL;
790 790
791 cmos->dev = NULL; 791 cmos->dev = NULL;
792 dev_set_drvdata(dev, NULL);
793} 792}
794 793
795#ifdef CONFIG_PM 794#ifdef CONFIG_PM
diff --git a/drivers/rtc/rtc-da9055.c b/drivers/rtc/rtc-da9055.c
index e00642b61076..48cb2ac3bd3e 100644
--- a/drivers/rtc/rtc-da9055.c
+++ b/drivers/rtc/rtc-da9055.c
@@ -278,7 +278,7 @@ static int da9055_rtc_probe(struct platform_device *pdev)
278 return -ENOMEM; 278 return -ENOMEM;
279 279
280 rtc->da9055 = dev_get_drvdata(pdev->dev.parent); 280 rtc->da9055 = dev_get_drvdata(pdev->dev.parent);
281 pdata = rtc->da9055->dev->platform_data; 281 pdata = dev_get_platdata(rtc->da9055->dev);
282 platform_set_drvdata(pdev, rtc); 282 platform_set_drvdata(pdev, rtc);
283 283
284 ret = da9055_rtc_device_init(rtc->da9055, pdata); 284 ret = da9055_rtc_device_init(rtc->da9055, pdata);
diff --git a/drivers/rtc/rtc-ds1305.c b/drivers/rtc/rtc-ds1305.c
index dd6170acde95..80f323731ee2 100644
--- a/drivers/rtc/rtc-ds1305.c
+++ b/drivers/rtc/rtc-ds1305.c
@@ -606,7 +606,7 @@ static int ds1305_probe(struct spi_device *spi)
606 struct ds1305 *ds1305; 606 struct ds1305 *ds1305;
607 int status; 607 int status;
608 u8 addr, value; 608 u8 addr, value;
609 struct ds1305_platform_data *pdata = spi->dev.platform_data; 609 struct ds1305_platform_data *pdata = dev_get_platdata(&spi->dev);
610 bool write_ctrl = false; 610 bool write_ctrl = false;
611 611
612 /* Sanity check board setup data. This may be hooked up 612 /* Sanity check board setup data. This may be hooked up
diff --git a/drivers/rtc/rtc-ds1307.c b/drivers/rtc/rtc-ds1307.c
index ca18fd1433b3..4e75345a559a 100644
--- a/drivers/rtc/rtc-ds1307.c
+++ b/drivers/rtc/rtc-ds1307.c
@@ -670,9 +670,9 @@ static int ds1307_probe(struct i2c_client *client,
670 int tmp; 670 int tmp;
671 const struct chip_desc *chip = &chips[id->driver_data]; 671 const struct chip_desc *chip = &chips[id->driver_data];
672 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); 672 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
673 int want_irq = false; 673 bool want_irq = false;
674 unsigned char *buf; 674 unsigned char *buf;
675 struct ds1307_platform_data *pdata = client->dev.platform_data; 675 struct ds1307_platform_data *pdata = dev_get_platdata(&client->dev);
676 static const int bbsqi_bitpos[] = { 676 static const int bbsqi_bitpos[] = {
677 [ds_1337] = 0, 677 [ds_1337] = 0,
678 [ds_1339] = DS1339_BIT_BBSQI, 678 [ds_1339] = DS1339_BIT_BBSQI,
@@ -956,7 +956,7 @@ read_rtc:
956 GFP_KERNEL); 956 GFP_KERNEL);
957 if (!ds1307->nvram) { 957 if (!ds1307->nvram) {
958 err = -ENOMEM; 958 err = -ENOMEM;
959 goto exit; 959 goto err_irq;
960 } 960 }
961 ds1307->nvram->attr.name = "nvram"; 961 ds1307->nvram->attr.name = "nvram";
962 ds1307->nvram->attr.mode = S_IRUGO | S_IWUSR; 962 ds1307->nvram->attr.mode = S_IRUGO | S_IWUSR;
@@ -967,13 +967,15 @@ read_rtc:
967 ds1307->nvram_offset = chip->nvram_offset; 967 ds1307->nvram_offset = chip->nvram_offset;
968 err = sysfs_create_bin_file(&client->dev.kobj, ds1307->nvram); 968 err = sysfs_create_bin_file(&client->dev.kobj, ds1307->nvram);
969 if (err) 969 if (err)
970 goto exit; 970 goto err_irq;
971 set_bit(HAS_NVRAM, &ds1307->flags); 971 set_bit(HAS_NVRAM, &ds1307->flags);
972 dev_info(&client->dev, "%zu bytes nvram\n", ds1307->nvram->size); 972 dev_info(&client->dev, "%zu bytes nvram\n", ds1307->nvram->size);
973 } 973 }
974 974
975 return 0; 975 return 0;
976 976
977err_irq:
978 free_irq(client->irq, client);
977exit: 979exit:
978 return err; 980 return err;
979} 981}
diff --git a/drivers/rtc/rtc-ds2404.c b/drivers/rtc/rtc-ds2404.c
index 2ca5a23aba8a..fc209dc4e245 100644
--- a/drivers/rtc/rtc-ds2404.c
+++ b/drivers/rtc/rtc-ds2404.c
@@ -224,7 +224,7 @@ static const struct rtc_class_ops ds2404_rtc_ops = {
224 224
225static int rtc_probe(struct platform_device *pdev) 225static int rtc_probe(struct platform_device *pdev)
226{ 226{
227 struct ds2404_platform_data *pdata = pdev->dev.platform_data; 227 struct ds2404_platform_data *pdata = dev_get_platdata(&pdev->dev);
228 struct ds2404 *chip; 228 struct ds2404 *chip;
229 int retval = -EBUSY; 229 int retval = -EBUSY;
230 230
diff --git a/drivers/rtc/rtc-ep93xx.c b/drivers/rtc/rtc-ep93xx.c
index 580e7b56bde8..5e4f5dc40ba5 100644
--- a/drivers/rtc/rtc-ep93xx.c
+++ b/drivers/rtc/rtc-ep93xx.c
@@ -42,7 +42,7 @@ struct ep93xx_rtc {
42static int ep93xx_rtc_get_swcomp(struct device *dev, unsigned short *preload, 42static int ep93xx_rtc_get_swcomp(struct device *dev, unsigned short *preload,
43 unsigned short *delete) 43 unsigned short *delete)
44{ 44{
45 struct ep93xx_rtc *ep93xx_rtc = dev->platform_data; 45 struct ep93xx_rtc *ep93xx_rtc = dev_get_platdata(dev);
46 unsigned long comp; 46 unsigned long comp;
47 47
48 comp = __raw_readl(ep93xx_rtc->mmio_base + EP93XX_RTC_SWCOMP); 48 comp = __raw_readl(ep93xx_rtc->mmio_base + EP93XX_RTC_SWCOMP);
@@ -60,7 +60,7 @@ static int ep93xx_rtc_get_swcomp(struct device *dev, unsigned short *preload,
60 60
61static int ep93xx_rtc_read_time(struct device *dev, struct rtc_time *tm) 61static int ep93xx_rtc_read_time(struct device *dev, struct rtc_time *tm)
62{ 62{
63 struct ep93xx_rtc *ep93xx_rtc = dev->platform_data; 63 struct ep93xx_rtc *ep93xx_rtc = dev_get_platdata(dev);
64 unsigned long time; 64 unsigned long time;
65 65
66 time = __raw_readl(ep93xx_rtc->mmio_base + EP93XX_RTC_DATA); 66 time = __raw_readl(ep93xx_rtc->mmio_base + EP93XX_RTC_DATA);
@@ -71,7 +71,7 @@ static int ep93xx_rtc_read_time(struct device *dev, struct rtc_time *tm)
71 71
72static int ep93xx_rtc_set_mmss(struct device *dev, unsigned long secs) 72static int ep93xx_rtc_set_mmss(struct device *dev, unsigned long secs)
73{ 73{
74 struct ep93xx_rtc *ep93xx_rtc = dev->platform_data; 74 struct ep93xx_rtc *ep93xx_rtc = dev_get_platdata(dev);
75 75
76 __raw_writel(secs + 1, ep93xx_rtc->mmio_base + EP93XX_RTC_LOAD); 76 __raw_writel(secs + 1, ep93xx_rtc->mmio_base + EP93XX_RTC_LOAD);
77 return 0; 77 return 0;
diff --git a/drivers/rtc/rtc-hid-sensor-time.c b/drivers/rtc/rtc-hid-sensor-time.c
index 4e2a81854f51..965a9da70867 100644
--- a/drivers/rtc/rtc-hid-sensor-time.c
+++ b/drivers/rtc/rtc-hid-sensor-time.c
@@ -209,7 +209,7 @@ static int hid_rtc_read_time(struct device *dev, struct rtc_time *tm)
209 platform_get_drvdata(to_platform_device(dev)); 209 platform_get_drvdata(to_platform_device(dev));
210 int ret; 210 int ret;
211 211
212 INIT_COMPLETION(time_state->comp_last_time); 212 reinit_completion(&time_state->comp_last_time);
213 /* get a report with all values through requesting one value */ 213 /* get a report with all values through requesting one value */
214 sensor_hub_input_attr_get_raw_value(time_state->common_attributes.hsdev, 214 sensor_hub_input_attr_get_raw_value(time_state->common_attributes.hsdev,
215 HID_USAGE_SENSOR_TIME, hid_time_addresses[0], 215 HID_USAGE_SENSOR_TIME, hid_time_addresses[0],
@@ -236,7 +236,7 @@ static const struct rtc_class_ops hid_time_rtc_ops = {
236static int hid_time_probe(struct platform_device *pdev) 236static int hid_time_probe(struct platform_device *pdev)
237{ 237{
238 int ret = 0; 238 int ret = 0;
239 struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data; 239 struct hid_sensor_hub_device *hsdev = dev_get_platdata(&pdev->dev);
240 struct hid_time_state *time_state = devm_kzalloc(&pdev->dev, 240 struct hid_time_state *time_state = devm_kzalloc(&pdev->dev,
241 sizeof(struct hid_time_state), GFP_KERNEL); 241 sizeof(struct hid_time_state), GFP_KERNEL);
242 242
@@ -275,24 +275,44 @@ static int hid_time_probe(struct platform_device *pdev)
275 return ret; 275 return ret;
276 } 276 }
277 277
278 ret = sensor_hub_device_open(hsdev);
279 if (ret) {
280 dev_err(&pdev->dev, "failed to open sensor hub device!\n");
281 goto err_open;
282 }
283
284 /*
285 * Enable HID input processing early in order to be able to read the
286 * clock already in devm_rtc_device_register().
287 */
288 hid_device_io_start(hsdev->hdev);
289
278 time_state->rtc = devm_rtc_device_register(&pdev->dev, 290 time_state->rtc = devm_rtc_device_register(&pdev->dev,
279 "hid-sensor-time", &hid_time_rtc_ops, 291 "hid-sensor-time", &hid_time_rtc_ops,
280 THIS_MODULE); 292 THIS_MODULE);
281 293
282 if (IS_ERR_OR_NULL(time_state->rtc)) { 294 if (IS_ERR_OR_NULL(time_state->rtc)) {
295 hid_device_io_stop(hsdev->hdev);
283 ret = time_state->rtc ? PTR_ERR(time_state->rtc) : -ENODEV; 296 ret = time_state->rtc ? PTR_ERR(time_state->rtc) : -ENODEV;
284 time_state->rtc = NULL; 297 time_state->rtc = NULL;
285 sensor_hub_remove_callback(hsdev, HID_USAGE_SENSOR_TIME);
286 dev_err(&pdev->dev, "rtc device register failed!\n"); 298 dev_err(&pdev->dev, "rtc device register failed!\n");
299 goto err_rtc;
287 } 300 }
288 301
289 return ret; 302 return ret;
303
304err_rtc:
305 sensor_hub_device_close(hsdev);
306err_open:
307 sensor_hub_remove_callback(hsdev, HID_USAGE_SENSOR_TIME);
308 return ret;
290} 309}
291 310
292static int hid_time_remove(struct platform_device *pdev) 311static int hid_time_remove(struct platform_device *pdev)
293{ 312{
294 struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data; 313 struct hid_sensor_hub_device *hsdev = dev_get_platdata(&pdev->dev);
295 314
315 sensor_hub_device_close(hsdev);
296 sensor_hub_remove_callback(hsdev, HID_USAGE_SENSOR_TIME); 316 sensor_hub_remove_callback(hsdev, HID_USAGE_SENSOR_TIME);
297 317
298 return 0; 318 return 0;
diff --git a/drivers/rtc/rtc-isl1208.c b/drivers/rtc/rtc-isl1208.c
index c016ad81767a..c3c549d511b9 100644
--- a/drivers/rtc/rtc-isl1208.c
+++ b/drivers/rtc/rtc-isl1208.c
@@ -144,11 +144,7 @@ isl1208_i2c_validate_client(struct i2c_client *client)
144static int 144static int
145isl1208_i2c_get_sr(struct i2c_client *client) 145isl1208_i2c_get_sr(struct i2c_client *client)
146{ 146{
147 int sr = i2c_smbus_read_byte_data(client, ISL1208_REG_SR); 147 return i2c_smbus_read_byte_data(client, ISL1208_REG_SR);
148 if (sr < 0)
149 return -EIO;
150
151 return sr;
152} 148}
153 149
154static int 150static int
@@ -647,10 +643,11 @@ isl1208_probe(struct i2c_client *client, const struct i2c_device_id *id)
647 "chip found, driver version " DRV_VERSION "\n"); 643 "chip found, driver version " DRV_VERSION "\n");
648 644
649 if (client->irq > 0) { 645 if (client->irq > 0) {
650 rc = request_threaded_irq(client->irq, NULL, 646 rc = devm_request_threaded_irq(&client->dev, client->irq, NULL,
651 isl1208_rtc_interrupt, 647 isl1208_rtc_interrupt,
652 IRQF_SHARED, 648 IRQF_SHARED,
653 isl1208_driver.driver.name, client); 649 isl1208_driver.driver.name,
650 client);
654 if (!rc) { 651 if (!rc) {
655 device_init_wakeup(&client->dev, 1); 652 device_init_wakeup(&client->dev, 1);
656 enable_irq_wake(client->irq); 653 enable_irq_wake(client->irq);
@@ -662,20 +659,18 @@ isl1208_probe(struct i2c_client *client, const struct i2c_device_id *id)
662 } 659 }
663 } 660 }
664 661
665 rtc = rtc_device_register(isl1208_driver.driver.name, 662 rtc = devm_rtc_device_register(&client->dev, isl1208_driver.driver.name,
666 &client->dev, &isl1208_rtc_ops, 663 &isl1208_rtc_ops,
667 THIS_MODULE); 664 THIS_MODULE);
668 if (IS_ERR(rtc)) { 665 if (IS_ERR(rtc))
669 rc = PTR_ERR(rtc); 666 return PTR_ERR(rtc);
670 goto exit_free_irq;
671 }
672 667
673 i2c_set_clientdata(client, rtc); 668 i2c_set_clientdata(client, rtc);
674 669
675 rc = isl1208_i2c_get_sr(client); 670 rc = isl1208_i2c_get_sr(client);
676 if (rc < 0) { 671 if (rc < 0) {
677 dev_err(&client->dev, "reading status failed\n"); 672 dev_err(&client->dev, "reading status failed\n");
678 goto exit_unregister; 673 return rc;
679 } 674 }
680 675
681 if (rc & ISL1208_REG_SR_RTCF) 676 if (rc & ISL1208_REG_SR_RTCF)
@@ -684,28 +679,15 @@ isl1208_probe(struct i2c_client *client, const struct i2c_device_id *id)
684 679
685 rc = sysfs_create_group(&client->dev.kobj, &isl1208_rtc_sysfs_files); 680 rc = sysfs_create_group(&client->dev.kobj, &isl1208_rtc_sysfs_files);
686 if (rc) 681 if (rc)
687 goto exit_unregister; 682 return rc;
688 683
689 return 0; 684 return 0;
690
691exit_unregister:
692 rtc_device_unregister(rtc);
693exit_free_irq:
694 if (client->irq)
695 free_irq(client->irq, client);
696
697 return rc;
698} 685}
699 686
700static int 687static int
701isl1208_remove(struct i2c_client *client) 688isl1208_remove(struct i2c_client *client)
702{ 689{
703 struct rtc_device *rtc = i2c_get_clientdata(client);
704
705 sysfs_remove_group(&client->dev.kobj, &isl1208_rtc_sysfs_files); 690 sysfs_remove_group(&client->dev.kobj, &isl1208_rtc_sysfs_files);
706 rtc_device_unregister(rtc);
707 if (client->irq)
708 free_irq(client->irq, client);
709 691
710 return 0; 692 return 0;
711} 693}
diff --git a/drivers/rtc/rtc-m48t59.c b/drivers/rtc/rtc-m48t59.c
index fcb03291f145..11880c1e9dac 100644
--- a/drivers/rtc/rtc-m48t59.c
+++ b/drivers/rtc/rtc-m48t59.c
@@ -68,7 +68,7 @@ m48t59_mem_readb(struct device *dev, u32 ofs)
68static int m48t59_rtc_read_time(struct device *dev, struct rtc_time *tm) 68static int m48t59_rtc_read_time(struct device *dev, struct rtc_time *tm)
69{ 69{
70 struct platform_device *pdev = to_platform_device(dev); 70 struct platform_device *pdev = to_platform_device(dev);
71 struct m48t59_plat_data *pdata = pdev->dev.platform_data; 71 struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
72 struct m48t59_private *m48t59 = platform_get_drvdata(pdev); 72 struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
73 unsigned long flags; 73 unsigned long flags;
74 u8 val; 74 u8 val;
@@ -111,7 +111,7 @@ static int m48t59_rtc_read_time(struct device *dev, struct rtc_time *tm)
111static int m48t59_rtc_set_time(struct device *dev, struct rtc_time *tm) 111static int m48t59_rtc_set_time(struct device *dev, struct rtc_time *tm)
112{ 112{
113 struct platform_device *pdev = to_platform_device(dev); 113 struct platform_device *pdev = to_platform_device(dev);
114 struct m48t59_plat_data *pdata = pdev->dev.platform_data; 114 struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
115 struct m48t59_private *m48t59 = platform_get_drvdata(pdev); 115 struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
116 unsigned long flags; 116 unsigned long flags;
117 u8 val = 0; 117 u8 val = 0;
@@ -158,7 +158,7 @@ static int m48t59_rtc_set_time(struct device *dev, struct rtc_time *tm)
158static int m48t59_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm) 158static int m48t59_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm)
159{ 159{
160 struct platform_device *pdev = to_platform_device(dev); 160 struct platform_device *pdev = to_platform_device(dev);
161 struct m48t59_plat_data *pdata = pdev->dev.platform_data; 161 struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
162 struct m48t59_private *m48t59 = platform_get_drvdata(pdev); 162 struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
163 struct rtc_time *tm = &alrm->time; 163 struct rtc_time *tm = &alrm->time;
164 unsigned long flags; 164 unsigned long flags;
@@ -205,7 +205,7 @@ static int m48t59_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm)
205static int m48t59_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm) 205static int m48t59_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
206{ 206{
207 struct platform_device *pdev = to_platform_device(dev); 207 struct platform_device *pdev = to_platform_device(dev);
208 struct m48t59_plat_data *pdata = pdev->dev.platform_data; 208 struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
209 struct m48t59_private *m48t59 = platform_get_drvdata(pdev); 209 struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
210 struct rtc_time *tm = &alrm->time; 210 struct rtc_time *tm = &alrm->time;
211 u8 mday, hour, min, sec; 211 u8 mday, hour, min, sec;
@@ -266,7 +266,7 @@ static int m48t59_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
266static int m48t59_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled) 266static int m48t59_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
267{ 267{
268 struct platform_device *pdev = to_platform_device(dev); 268 struct platform_device *pdev = to_platform_device(dev);
269 struct m48t59_plat_data *pdata = pdev->dev.platform_data; 269 struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
270 struct m48t59_private *m48t59 = platform_get_drvdata(pdev); 270 struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
271 unsigned long flags; 271 unsigned long flags;
272 272
@@ -283,7 +283,7 @@ static int m48t59_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
283static int m48t59_rtc_proc(struct device *dev, struct seq_file *seq) 283static int m48t59_rtc_proc(struct device *dev, struct seq_file *seq)
284{ 284{
285 struct platform_device *pdev = to_platform_device(dev); 285 struct platform_device *pdev = to_platform_device(dev);
286 struct m48t59_plat_data *pdata = pdev->dev.platform_data; 286 struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
287 struct m48t59_private *m48t59 = platform_get_drvdata(pdev); 287 struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
288 unsigned long flags; 288 unsigned long flags;
289 u8 val; 289 u8 val;
@@ -304,7 +304,7 @@ static irqreturn_t m48t59_rtc_interrupt(int irq, void *dev_id)
304{ 304{
305 struct device *dev = (struct device *)dev_id; 305 struct device *dev = (struct device *)dev_id;
306 struct platform_device *pdev = to_platform_device(dev); 306 struct platform_device *pdev = to_platform_device(dev);
307 struct m48t59_plat_data *pdata = pdev->dev.platform_data; 307 struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
308 struct m48t59_private *m48t59 = platform_get_drvdata(pdev); 308 struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
309 u8 event; 309 u8 event;
310 310
@@ -340,7 +340,7 @@ static ssize_t m48t59_nvram_read(struct file *filp, struct kobject *kobj,
340{ 340{
341 struct device *dev = container_of(kobj, struct device, kobj); 341 struct device *dev = container_of(kobj, struct device, kobj);
342 struct platform_device *pdev = to_platform_device(dev); 342 struct platform_device *pdev = to_platform_device(dev);
343 struct m48t59_plat_data *pdata = pdev->dev.platform_data; 343 struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
344 struct m48t59_private *m48t59 = platform_get_drvdata(pdev); 344 struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
345 ssize_t cnt = 0; 345 ssize_t cnt = 0;
346 unsigned long flags; 346 unsigned long flags;
@@ -360,7 +360,7 @@ static ssize_t m48t59_nvram_write(struct file *filp, struct kobject *kobj,
360{ 360{
361 struct device *dev = container_of(kobj, struct device, kobj); 361 struct device *dev = container_of(kobj, struct device, kobj);
362 struct platform_device *pdev = to_platform_device(dev); 362 struct platform_device *pdev = to_platform_device(dev);
363 struct m48t59_plat_data *pdata = pdev->dev.platform_data; 363 struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
364 struct m48t59_private *m48t59 = platform_get_drvdata(pdev); 364 struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
365 ssize_t cnt = 0; 365 ssize_t cnt = 0;
366 unsigned long flags; 366 unsigned long flags;
@@ -385,7 +385,7 @@ static struct bin_attribute m48t59_nvram_attr = {
385 385
386static int m48t59_rtc_probe(struct platform_device *pdev) 386static int m48t59_rtc_probe(struct platform_device *pdev)
387{ 387{
388 struct m48t59_plat_data *pdata = pdev->dev.platform_data; 388 struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
389 struct m48t59_private *m48t59 = NULL; 389 struct m48t59_private *m48t59 = NULL;
390 struct resource *res; 390 struct resource *res;
391 int ret = -ENOMEM; 391 int ret = -ENOMEM;
diff --git a/drivers/rtc/rtc-m48t86.c b/drivers/rtc/rtc-m48t86.c
index 2d30314fa07f..32f64c942621 100644
--- a/drivers/rtc/rtc-m48t86.c
+++ b/drivers/rtc/rtc-m48t86.c
@@ -46,7 +46,7 @@ static int m48t86_rtc_read_time(struct device *dev, struct rtc_time *tm)
46{ 46{
47 unsigned char reg; 47 unsigned char reg;
48 struct platform_device *pdev = to_platform_device(dev); 48 struct platform_device *pdev = to_platform_device(dev);
49 struct m48t86_ops *ops = pdev->dev.platform_data; 49 struct m48t86_ops *ops = dev_get_platdata(&pdev->dev);
50 50
51 reg = ops->readbyte(M48T86_REG_B); 51 reg = ops->readbyte(M48T86_REG_B);
52 52
@@ -84,7 +84,7 @@ static int m48t86_rtc_set_time(struct device *dev, struct rtc_time *tm)
84{ 84{
85 unsigned char reg; 85 unsigned char reg;
86 struct platform_device *pdev = to_platform_device(dev); 86 struct platform_device *pdev = to_platform_device(dev);
87 struct m48t86_ops *ops = pdev->dev.platform_data; 87 struct m48t86_ops *ops = dev_get_platdata(&pdev->dev);
88 88
89 reg = ops->readbyte(M48T86_REG_B); 89 reg = ops->readbyte(M48T86_REG_B);
90 90
@@ -123,7 +123,7 @@ static int m48t86_rtc_proc(struct device *dev, struct seq_file *seq)
123{ 123{
124 unsigned char reg; 124 unsigned char reg;
125 struct platform_device *pdev = to_platform_device(dev); 125 struct platform_device *pdev = to_platform_device(dev);
126 struct m48t86_ops *ops = pdev->dev.platform_data; 126 struct m48t86_ops *ops = dev_get_platdata(&pdev->dev);
127 127
128 reg = ops->readbyte(M48T86_REG_B); 128 reg = ops->readbyte(M48T86_REG_B);
129 129
@@ -147,7 +147,7 @@ static const struct rtc_class_ops m48t86_rtc_ops = {
147static int m48t86_rtc_probe(struct platform_device *dev) 147static int m48t86_rtc_probe(struct platform_device *dev)
148{ 148{
149 unsigned char reg; 149 unsigned char reg;
150 struct m48t86_ops *ops = dev->dev.platform_data; 150 struct m48t86_ops *ops = dev_get_platdata(&dev->dev);
151 struct rtc_device *rtc; 151 struct rtc_device *rtc;
152 152
153 rtc = devm_rtc_device_register(&dev->dev, "m48t86", 153 rtc = devm_rtc_device_register(&dev->dev, "m48t86",
diff --git a/drivers/rtc/rtc-max6900.c b/drivers/rtc/rtc-max6900.c
index 55969b1b771a..4804985b876e 100644
--- a/drivers/rtc/rtc-max6900.c
+++ b/drivers/rtc/rtc-max6900.c
@@ -164,14 +164,7 @@ static int max6900_i2c_read_time(struct i2c_client *client, struct rtc_time *tm)
164 164
165static int max6900_i2c_clear_write_protect(struct i2c_client *client) 165static int max6900_i2c_clear_write_protect(struct i2c_client *client)
166{ 166{
167 int rc; 167 return i2c_smbus_write_byte_data(client, MAX6900_REG_CONTROL_WRITE, 0);
168 rc = i2c_smbus_write_byte_data(client, MAX6900_REG_CONTROL_WRITE, 0);
169 if (rc < 0) {
170 dev_err(&client->dev, "%s: control register write failed\n",
171 __func__);
172 return -EIO;
173 }
174 return 0;
175} 168}
176 169
177static int 170static int
diff --git a/drivers/rtc/rtc-mpc5121.c b/drivers/rtc/rtc-mpc5121.c
index 9c8f60903799..dc4f14255cc3 100644
--- a/drivers/rtc/rtc-mpc5121.c
+++ b/drivers/rtc/rtc-mpc5121.c
@@ -14,7 +14,9 @@
14#include <linux/module.h> 14#include <linux/module.h>
15#include <linux/rtc.h> 15#include <linux/rtc.h>
16#include <linux/of.h> 16#include <linux/of.h>
17#include <linux/of_address.h>
17#include <linux/of_device.h> 18#include <linux/of_device.h>
19#include <linux/of_irq.h>
18#include <linux/of_platform.h> 20#include <linux/of_platform.h>
19#include <linux/io.h> 21#include <linux/io.h>
20#include <linux/slab.h> 22#include <linux/slab.h>
diff --git a/drivers/rtc/rtc-mrst.c b/drivers/rtc/rtc-mrst.c
index 578baf9d9725..e2436d140175 100644
--- a/drivers/rtc/rtc-mrst.c
+++ b/drivers/rtc/rtc-mrst.c
@@ -38,8 +38,8 @@
38 38
39#include <asm-generic/rtc.h> 39#include <asm-generic/rtc.h>
40#include <asm/intel_scu_ipc.h> 40#include <asm/intel_scu_ipc.h>
41#include <asm/mrst.h> 41#include <asm/intel-mid.h>
42#include <asm/mrst-vrtc.h> 42#include <asm/intel_mid_vrtc.h>
43 43
44struct mrst_rtc { 44struct mrst_rtc {
45 struct rtc_device *rtc; 45 struct rtc_device *rtc;
@@ -380,7 +380,6 @@ static int vrtc_mrst_do_probe(struct device *dev, struct resource *iomem,
380cleanup1: 380cleanup1:
381 rtc_device_unregister(mrst_rtc.rtc); 381 rtc_device_unregister(mrst_rtc.rtc);
382cleanup0: 382cleanup0:
383 dev_set_drvdata(dev, NULL);
384 mrst_rtc.dev = NULL; 383 mrst_rtc.dev = NULL;
385 release_mem_region(iomem->start, resource_size(iomem)); 384 release_mem_region(iomem->start, resource_size(iomem));
386 dev_err(dev, "rtc-mrst: unable to initialise\n"); 385 dev_err(dev, "rtc-mrst: unable to initialise\n");
@@ -412,7 +411,6 @@ static void rtc_mrst_do_remove(struct device *dev)
412 mrst->iomem = NULL; 411 mrst->iomem = NULL;
413 412
414 mrst->dev = NULL; 413 mrst->dev = NULL;
415 dev_set_drvdata(dev, NULL);
416} 414}
417 415
418#ifdef CONFIG_PM 416#ifdef CONFIG_PM
diff --git a/drivers/rtc/rtc-omap.c b/drivers/rtc/rtc-omap.c
index c7d97ee59327..26de5f8c2ae4 100644
--- a/drivers/rtc/rtc-omap.c
+++ b/drivers/rtc/rtc-omap.c
@@ -553,7 +553,7 @@ static struct platform_driver omap_rtc_driver = {
553 .name = DRIVER_NAME, 553 .name = DRIVER_NAME,
554 .owner = THIS_MODULE, 554 .owner = THIS_MODULE,
555 .pm = &omap_rtc_pm_ops, 555 .pm = &omap_rtc_pm_ops,
556 .of_match_table = of_match_ptr(omap_rtc_of_match), 556 .of_match_table = omap_rtc_of_match,
557 }, 557 },
558 .id_table = omap_rtc_devtype, 558 .id_table = omap_rtc_devtype,
559}; 559};
diff --git a/drivers/rtc/rtc-pcf2123.c b/drivers/rtc/rtc-pcf2123.c
index 1725b5090e33..d1953bb244c5 100644
--- a/drivers/rtc/rtc-pcf2123.c
+++ b/drivers/rtc/rtc-pcf2123.c
@@ -327,7 +327,7 @@ kfree_exit:
327 327
328static int pcf2123_remove(struct spi_device *spi) 328static int pcf2123_remove(struct spi_device *spi)
329{ 329{
330 struct pcf2123_plat_data *pdata = spi->dev.platform_data; 330 struct pcf2123_plat_data *pdata = dev_get_platdata(&spi->dev);
331 int i; 331 int i;
332 332
333 if (pdata) { 333 if (pdata) {
diff --git a/drivers/rtc/rtc-pl030.c b/drivers/rtc/rtc-pl030.c
index 22bacdbf9139..f85a1a93e669 100644
--- a/drivers/rtc/rtc-pl030.c
+++ b/drivers/rtc/rtc-pl030.c
@@ -106,7 +106,7 @@ static int pl030_probe(struct amba_device *dev, const struct amba_id *id)
106 if (ret) 106 if (ret)
107 goto err_req; 107 goto err_req;
108 108
109 rtc = kmalloc(sizeof(*rtc), GFP_KERNEL); 109 rtc = devm_kzalloc(&dev->dev, sizeof(*rtc), GFP_KERNEL);
110 if (!rtc) { 110 if (!rtc) {
111 ret = -ENOMEM; 111 ret = -ENOMEM;
112 goto err_rtc; 112 goto err_rtc;
@@ -115,7 +115,7 @@ static int pl030_probe(struct amba_device *dev, const struct amba_id *id)
115 rtc->base = ioremap(dev->res.start, resource_size(&dev->res)); 115 rtc->base = ioremap(dev->res.start, resource_size(&dev->res));
116 if (!rtc->base) { 116 if (!rtc->base) {
117 ret = -ENOMEM; 117 ret = -ENOMEM;
118 goto err_map; 118 goto err_rtc;
119 } 119 }
120 120
121 __raw_writel(0, rtc->base + RTC_CR); 121 __raw_writel(0, rtc->base + RTC_CR);
@@ -141,8 +141,6 @@ static int pl030_probe(struct amba_device *dev, const struct amba_id *id)
141 free_irq(dev->irq[0], rtc); 141 free_irq(dev->irq[0], rtc);
142 err_irq: 142 err_irq:
143 iounmap(rtc->base); 143 iounmap(rtc->base);
144 err_map:
145 kfree(rtc);
146 err_rtc: 144 err_rtc:
147 amba_release_regions(dev); 145 amba_release_regions(dev);
148 err_req: 146 err_req:
@@ -153,14 +151,11 @@ static int pl030_remove(struct amba_device *dev)
153{ 151{
154 struct pl030_rtc *rtc = amba_get_drvdata(dev); 152 struct pl030_rtc *rtc = amba_get_drvdata(dev);
155 153
156 amba_set_drvdata(dev, NULL);
157
158 writel(0, rtc->base + RTC_CR); 154 writel(0, rtc->base + RTC_CR);
159 155
160 free_irq(dev->irq[0], rtc); 156 free_irq(dev->irq[0], rtc);
161 rtc_device_unregister(rtc->rtc); 157 rtc_device_unregister(rtc->rtc);
162 iounmap(rtc->base); 158 iounmap(rtc->base);
163 kfree(rtc);
164 amba_release_regions(dev); 159 amba_release_regions(dev);
165 160
166 return 0; 161 return 0;
diff --git a/drivers/rtc/rtc-pl031.c b/drivers/rtc/rtc-pl031.c
index 0f0609b1aa2c..99181fff88fd 100644
--- a/drivers/rtc/rtc-pl031.c
+++ b/drivers/rtc/rtc-pl031.c
@@ -305,7 +305,6 @@ static int pl031_remove(struct amba_device *adev)
305{ 305{
306 struct pl031_local *ldata = dev_get_drvdata(&adev->dev); 306 struct pl031_local *ldata = dev_get_drvdata(&adev->dev);
307 307
308 amba_set_drvdata(adev, NULL);
309 free_irq(adev->irq[0], ldata); 308 free_irq(adev->irq[0], ldata);
310 rtc_device_unregister(ldata->rtc); 309 rtc_device_unregister(ldata->rtc);
311 iounmap(ldata->base); 310 iounmap(ldata->base);
@@ -371,6 +370,7 @@ static int pl031_probe(struct amba_device *adev, const struct amba_id *id)
371 } 370 }
372 } 371 }
373 372
373 device_init_wakeup(&adev->dev, 1);
374 ldata->rtc = rtc_device_register("pl031", &adev->dev, ops, 374 ldata->rtc = rtc_device_register("pl031", &adev->dev, ops,
375 THIS_MODULE); 375 THIS_MODULE);
376 if (IS_ERR(ldata->rtc)) { 376 if (IS_ERR(ldata->rtc)) {
@@ -384,15 +384,12 @@ static int pl031_probe(struct amba_device *adev, const struct amba_id *id)
384 goto out_no_irq; 384 goto out_no_irq;
385 } 385 }
386 386
387 device_init_wakeup(&adev->dev, 1);
388
389 return 0; 387 return 0;
390 388
391out_no_irq: 389out_no_irq:
392 rtc_device_unregister(ldata->rtc); 390 rtc_device_unregister(ldata->rtc);
393out_no_rtc: 391out_no_rtc:
394 iounmap(ldata->base); 392 iounmap(ldata->base);
395 amba_set_drvdata(adev, NULL);
396out_no_remap: 393out_no_remap:
397 kfree(ldata); 394 kfree(ldata);
398out: 395out:
diff --git a/drivers/rtc/rtc-puv3.c b/drivers/rtc/rtc-puv3.c
index 402732cfb32a..1ecfe3bd92ac 100644
--- a/drivers/rtc/rtc-puv3.c
+++ b/drivers/rtc/rtc-puv3.c
@@ -53,11 +53,11 @@ static irqreturn_t puv3_rtc_tickirq(int irq, void *id)
53} 53}
54 54
55/* Update control registers */ 55/* Update control registers */
56static void puv3_rtc_setaie(int to) 56static void puv3_rtc_setaie(struct device *dev, int to)
57{ 57{
58 unsigned int tmp; 58 unsigned int tmp;
59 59
60 pr_debug("%s: aie=%d\n", __func__, to); 60 dev_dbg(dev, "%s: aie=%d\n", __func__, to);
61 61
62 tmp = readl(RTC_RTSR) & ~RTC_RTSR_ALE; 62 tmp = readl(RTC_RTSR) & ~RTC_RTSR_ALE;
63 63
@@ -71,7 +71,7 @@ static int puv3_rtc_setpie(struct device *dev, int enabled)
71{ 71{
72 unsigned int tmp; 72 unsigned int tmp;
73 73
74 pr_debug("%s: pie=%d\n", __func__, enabled); 74 dev_debug(dev, "%s: pie=%d\n", __func__, enabled);
75 75
76 spin_lock_irq(&puv3_rtc_pie_lock); 76 spin_lock_irq(&puv3_rtc_pie_lock);
77 tmp = readl(RTC_RTSR) & ~RTC_RTSR_HZE; 77 tmp = readl(RTC_RTSR) & ~RTC_RTSR_HZE;
@@ -90,7 +90,7 @@ static int puv3_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm)
90{ 90{
91 rtc_time_to_tm(readl(RTC_RCNR), rtc_tm); 91 rtc_time_to_tm(readl(RTC_RCNR), rtc_tm);
92 92
93 pr_debug("read time %02x.%02x.%02x %02x/%02x/%02x\n", 93 dev_dbg(dev, "read time %02x.%02x.%02x %02x/%02x/%02x\n",
94 rtc_tm->tm_year, rtc_tm->tm_mon, rtc_tm->tm_mday, 94 rtc_tm->tm_year, rtc_tm->tm_mon, rtc_tm->tm_mday,
95 rtc_tm->tm_hour, rtc_tm->tm_min, rtc_tm->tm_sec); 95 rtc_tm->tm_hour, rtc_tm->tm_min, rtc_tm->tm_sec);
96 96
@@ -101,7 +101,7 @@ static int puv3_rtc_settime(struct device *dev, struct rtc_time *tm)
101{ 101{
102 unsigned long rtc_count = 0; 102 unsigned long rtc_count = 0;
103 103
104 pr_debug("set time %02d.%02d.%02d %02d/%02d/%02d\n", 104 dev_dbg(dev, "set time %02d.%02d.%02d %02d/%02d/%02d\n",
105 tm->tm_year, tm->tm_mon, tm->tm_mday, 105 tm->tm_year, tm->tm_mon, tm->tm_mday,
106 tm->tm_hour, tm->tm_min, tm->tm_sec); 106 tm->tm_hour, tm->tm_min, tm->tm_sec);
107 107
@@ -119,7 +119,7 @@ static int puv3_rtc_getalarm(struct device *dev, struct rtc_wkalrm *alrm)
119 119
120 alrm->enabled = readl(RTC_RTSR) & RTC_RTSR_ALE; 120 alrm->enabled = readl(RTC_RTSR) & RTC_RTSR_ALE;
121 121
122 pr_debug("read alarm %02x %02x.%02x.%02x %02x/%02x/%02x\n", 122 dev_dbg(dev, "read alarm %02x %02x.%02x.%02x %02x/%02x/%02x\n",
123 alrm->enabled, 123 alrm->enabled,
124 alm_tm->tm_year, alm_tm->tm_mon, alm_tm->tm_mday, 124 alm_tm->tm_year, alm_tm->tm_mon, alm_tm->tm_mday,
125 alm_tm->tm_hour, alm_tm->tm_min, alm_tm->tm_sec); 125 alm_tm->tm_hour, alm_tm->tm_min, alm_tm->tm_sec);
@@ -132,7 +132,7 @@ static int puv3_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
132 struct rtc_time *tm = &alrm->time; 132 struct rtc_time *tm = &alrm->time;
133 unsigned long rtcalarm_count = 0; 133 unsigned long rtcalarm_count = 0;
134 134
135 pr_debug("puv3_rtc_setalarm: %d, %02x/%02x/%02x %02x.%02x.%02x\n", 135 dev_dbg(dev, "puv3_rtc_setalarm: %d, %02x/%02x/%02x %02x.%02x.%02x\n",
136 alrm->enabled, 136 alrm->enabled,
137 tm->tm_mday & 0xff, tm->tm_mon & 0xff, tm->tm_year & 0xff, 137 tm->tm_mday & 0xff, tm->tm_mon & 0xff, tm->tm_year & 0xff,
138 tm->tm_hour & 0xff, tm->tm_min & 0xff, tm->tm_sec); 138 tm->tm_hour & 0xff, tm->tm_min & 0xff, tm->tm_sec);
@@ -140,7 +140,7 @@ static int puv3_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
140 rtc_tm_to_time(tm, &rtcalarm_count); 140 rtc_tm_to_time(tm, &rtcalarm_count);
141 writel(rtcalarm_count, RTC_RTAR); 141 writel(rtcalarm_count, RTC_RTAR);
142 142
143 puv3_rtc_setaie(alrm->enabled); 143 puv3_rtc_setaie(&dev->dev, alrm->enabled);
144 144
145 if (alrm->enabled) 145 if (alrm->enabled)
146 enable_irq_wake(puv3_rtc_alarmno); 146 enable_irq_wake(puv3_rtc_alarmno);
@@ -227,7 +227,7 @@ static int puv3_rtc_remove(struct platform_device *dev)
227 rtc_device_unregister(rtc); 227 rtc_device_unregister(rtc);
228 228
229 puv3_rtc_setpie(&dev->dev, 0); 229 puv3_rtc_setpie(&dev->dev, 0);
230 puv3_rtc_setaie(0); 230 puv3_rtc_setaie(&dev->dev, 0);
231 231
232 release_resource(puv3_rtc_mem); 232 release_resource(puv3_rtc_mem);
233 kfree(puv3_rtc_mem); 233 kfree(puv3_rtc_mem);
@@ -241,7 +241,7 @@ static int puv3_rtc_probe(struct platform_device *pdev)
241 struct resource *res; 241 struct resource *res;
242 int ret; 242 int ret;
243 243
244 pr_debug("%s: probe=%p\n", __func__, pdev); 244 dev_dbg(&pdev->dev, "%s: probe=%p\n", __func__, pdev);
245 245
246 /* find the IRQs */ 246 /* find the IRQs */
247 puv3_rtc_tickno = platform_get_irq(pdev, 1); 247 puv3_rtc_tickno = platform_get_irq(pdev, 1);
@@ -256,7 +256,7 @@ static int puv3_rtc_probe(struct platform_device *pdev)
256 return -ENOENT; 256 return -ENOENT;
257 } 257 }
258 258
259 pr_debug("PKUnity_rtc: tick irq %d, alarm irq %d\n", 259 dev_dbg(&pdev->dev, "PKUnity_rtc: tick irq %d, alarm irq %d\n",
260 puv3_rtc_tickno, puv3_rtc_alarmno); 260 puv3_rtc_tickno, puv3_rtc_alarmno);
261 261
262 /* get the memory region */ 262 /* get the memory region */
diff --git a/drivers/rtc/rtc-rs5c348.c b/drivers/rtc/rtc-rs5c348.c
index f7a90a116a39..090a101c1c81 100644
--- a/drivers/rtc/rtc-rs5c348.c
+++ b/drivers/rtc/rtc-rs5c348.c
@@ -64,7 +64,7 @@ static int
64rs5c348_rtc_set_time(struct device *dev, struct rtc_time *tm) 64rs5c348_rtc_set_time(struct device *dev, struct rtc_time *tm)
65{ 65{
66 struct spi_device *spi = to_spi_device(dev); 66 struct spi_device *spi = to_spi_device(dev);
67 struct rs5c348_plat_data *pdata = spi->dev.platform_data; 67 struct rs5c348_plat_data *pdata = dev_get_platdata(&spi->dev);
68 u8 txbuf[5+7], *txp; 68 u8 txbuf[5+7], *txp;
69 int ret; 69 int ret;
70 70
@@ -100,7 +100,7 @@ static int
100rs5c348_rtc_read_time(struct device *dev, struct rtc_time *tm) 100rs5c348_rtc_read_time(struct device *dev, struct rtc_time *tm)
101{ 101{
102 struct spi_device *spi = to_spi_device(dev); 102 struct spi_device *spi = to_spi_device(dev);
103 struct rs5c348_plat_data *pdata = spi->dev.platform_data; 103 struct rs5c348_plat_data *pdata = dev_get_platdata(&spi->dev);
104 u8 txbuf[5], rxbuf[7]; 104 u8 txbuf[5], rxbuf[7];
105 int ret; 105 int ret;
106 106
diff --git a/drivers/rtc/rtc-s5m.c b/drivers/rtc/rtc-s5m.c
new file mode 100644
index 000000000000..ae8119dc2846
--- /dev/null
+++ b/drivers/rtc/rtc-s5m.c
@@ -0,0 +1,687 @@
1/*
2 * Copyright (c) 2013 Samsung Electronics Co., Ltd
3 * http://www.samsung.com
4 *
5 * Copyright (C) 2013 Google, Inc
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 */
17
18#include <linux/module.h>
19#include <linux/i2c.h>
20#include <linux/slab.h>
21#include <linux/bcd.h>
22#include <linux/bitops.h>
23#include <linux/regmap.h>
24#include <linux/rtc.h>
25#include <linux/delay.h>
26#include <linux/platform_device.h>
27#include <linux/mfd/samsung/core.h>
28#include <linux/mfd/samsung/irq.h>
29#include <linux/mfd/samsung/rtc.h>
30
31/*
32 * Maximum number of retries for checking changes in UDR field
33 * of SEC_RTC_UDR_CON register (to limit possible endless loop).
34 *
35 * After writing to RTC registers (setting time or alarm) read the UDR field
36 * in SEC_RTC_UDR_CON register. UDR is auto-cleared when data have
37 * been transferred.
38 */
39#define UDR_READ_RETRY_CNT 5
40
41struct s5m_rtc_info {
42 struct device *dev;
43 struct sec_pmic_dev *s5m87xx;
44 struct regmap *regmap;
45 struct rtc_device *rtc_dev;
46 int irq;
47 int device_type;
48 int rtc_24hr_mode;
49 bool wtsr_smpl;
50};
51
52static void s5m8767_data_to_tm(u8 *data, struct rtc_time *tm,
53 int rtc_24hr_mode)
54{
55 tm->tm_sec = data[RTC_SEC] & 0x7f;
56 tm->tm_min = data[RTC_MIN] & 0x7f;
57 if (rtc_24hr_mode) {
58 tm->tm_hour = data[RTC_HOUR] & 0x1f;
59 } else {
60 tm->tm_hour = data[RTC_HOUR] & 0x0f;
61 if (data[RTC_HOUR] & HOUR_PM_MASK)
62 tm->tm_hour += 12;
63 }
64
65 tm->tm_wday = ffs(data[RTC_WEEKDAY] & 0x7f);
66 tm->tm_mday = data[RTC_DATE] & 0x1f;
67 tm->tm_mon = (data[RTC_MONTH] & 0x0f) - 1;
68 tm->tm_year = (data[RTC_YEAR1] & 0x7f) + 100;
69 tm->tm_yday = 0;
70 tm->tm_isdst = 0;
71}
72
73static int s5m8767_tm_to_data(struct rtc_time *tm, u8 *data)
74{
75 data[RTC_SEC] = tm->tm_sec;
76 data[RTC_MIN] = tm->tm_min;
77
78 if (tm->tm_hour >= 12)
79 data[RTC_HOUR] = tm->tm_hour | HOUR_PM_MASK;
80 else
81 data[RTC_HOUR] = tm->tm_hour & ~HOUR_PM_MASK;
82
83 data[RTC_WEEKDAY] = 1 << tm->tm_wday;
84 data[RTC_DATE] = tm->tm_mday;
85 data[RTC_MONTH] = tm->tm_mon + 1;
86 data[RTC_YEAR1] = tm->tm_year > 100 ? (tm->tm_year - 100) : 0;
87
88 if (tm->tm_year < 100) {
89 pr_err("s5m8767 RTC cannot handle the year %d.\n",
90 1900 + tm->tm_year);
91 return -EINVAL;
92 } else {
93 return 0;
94 }
95}
96
97/*
98 * Read RTC_UDR_CON register and wait till UDR field is cleared.
99 * This indicates that time/alarm update ended.
100 */
101static inline int s5m8767_wait_for_udr_update(struct s5m_rtc_info *info)
102{
103 int ret, retry = UDR_READ_RETRY_CNT;
104 unsigned int data;
105
106 do {
107 ret = regmap_read(info->regmap, SEC_RTC_UDR_CON, &data);
108 } while (--retry && (data & RTC_UDR_MASK) && !ret);
109
110 if (!retry)
111 dev_err(info->dev, "waiting for UDR update, reached max number of retries\n");
112
113 return ret;
114}
115
116static inline int s5m8767_rtc_set_time_reg(struct s5m_rtc_info *info)
117{
118 int ret;
119 unsigned int data;
120
121 ret = regmap_read(info->regmap, SEC_RTC_UDR_CON, &data);
122 if (ret < 0) {
123 dev_err(info->dev, "failed to read update reg(%d)\n", ret);
124 return ret;
125 }
126
127 data |= RTC_TIME_EN_MASK;
128 data |= RTC_UDR_MASK;
129
130 ret = regmap_write(info->regmap, SEC_RTC_UDR_CON, data);
131 if (ret < 0) {
132 dev_err(info->dev, "failed to write update reg(%d)\n", ret);
133 return ret;
134 }
135
136 ret = s5m8767_wait_for_udr_update(info);
137
138 return ret;
139}
140
141static inline int s5m8767_rtc_set_alarm_reg(struct s5m_rtc_info *info)
142{
143 int ret;
144 unsigned int data;
145
146 ret = regmap_read(info->regmap, SEC_RTC_UDR_CON, &data);
147 if (ret < 0) {
148 dev_err(info->dev, "%s: fail to read update reg(%d)\n",
149 __func__, ret);
150 return ret;
151 }
152
153 data &= ~RTC_TIME_EN_MASK;
154 data |= RTC_UDR_MASK;
155
156 ret = regmap_write(info->regmap, SEC_RTC_UDR_CON, data);
157 if (ret < 0) {
158 dev_err(info->dev, "%s: fail to write update reg(%d)\n",
159 __func__, ret);
160 return ret;
161 }
162
163 ret = s5m8767_wait_for_udr_update(info);
164
165 return ret;
166}
167
168static void s5m8763_data_to_tm(u8 *data, struct rtc_time *tm)
169{
170 tm->tm_sec = bcd2bin(data[RTC_SEC]);
171 tm->tm_min = bcd2bin(data[RTC_MIN]);
172
173 if (data[RTC_HOUR] & HOUR_12) {
174 tm->tm_hour = bcd2bin(data[RTC_HOUR] & 0x1f);
175 if (data[RTC_HOUR] & HOUR_PM)
176 tm->tm_hour += 12;
177 } else {
178 tm->tm_hour = bcd2bin(data[RTC_HOUR] & 0x3f);
179 }
180
181 tm->tm_wday = data[RTC_WEEKDAY] & 0x07;
182 tm->tm_mday = bcd2bin(data[RTC_DATE]);
183 tm->tm_mon = bcd2bin(data[RTC_MONTH]);
184 tm->tm_year = bcd2bin(data[RTC_YEAR1]) + bcd2bin(data[RTC_YEAR2]) * 100;
185 tm->tm_year -= 1900;
186}
187
188static void s5m8763_tm_to_data(struct rtc_time *tm, u8 *data)
189{
190 data[RTC_SEC] = bin2bcd(tm->tm_sec);
191 data[RTC_MIN] = bin2bcd(tm->tm_min);
192 data[RTC_HOUR] = bin2bcd(tm->tm_hour);
193 data[RTC_WEEKDAY] = tm->tm_wday;
194 data[RTC_DATE] = bin2bcd(tm->tm_mday);
195 data[RTC_MONTH] = bin2bcd(tm->tm_mon);
196 data[RTC_YEAR1] = bin2bcd(tm->tm_year % 100);
197 data[RTC_YEAR2] = bin2bcd((tm->tm_year + 1900) / 100);
198}
199
200static int s5m_rtc_read_time(struct device *dev, struct rtc_time *tm)
201{
202 struct s5m_rtc_info *info = dev_get_drvdata(dev);
203 u8 data[8];
204 int ret;
205
206 ret = regmap_bulk_read(info->regmap, SEC_RTC_SEC, data, 8);
207 if (ret < 0)
208 return ret;
209
210 switch (info->device_type) {
211 case S5M8763X:
212 s5m8763_data_to_tm(data, tm);
213 break;
214
215 case S5M8767X:
216 s5m8767_data_to_tm(data, tm, info->rtc_24hr_mode);
217 break;
218
219 default:
220 return -EINVAL;
221 }
222
223 dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
224 1900 + tm->tm_year, 1 + tm->tm_mon, tm->tm_mday,
225 tm->tm_hour, tm->tm_min, tm->tm_sec, tm->tm_wday);
226
227 return rtc_valid_tm(tm);
228}
229
230static int s5m_rtc_set_time(struct device *dev, struct rtc_time *tm)
231{
232 struct s5m_rtc_info *info = dev_get_drvdata(dev);
233 u8 data[8];
234 int ret = 0;
235
236 switch (info->device_type) {
237 case S5M8763X:
238 s5m8763_tm_to_data(tm, data);
239 break;
240 case S5M8767X:
241 ret = s5m8767_tm_to_data(tm, data);
242 break;
243 default:
244 return -EINVAL;
245 }
246
247 if (ret < 0)
248 return ret;
249
250 dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
251 1900 + tm->tm_year, 1 + tm->tm_mon, tm->tm_mday,
252 tm->tm_hour, tm->tm_min, tm->tm_sec, tm->tm_wday);
253
254 ret = regmap_raw_write(info->regmap, SEC_RTC_SEC, data, 8);
255 if (ret < 0)
256 return ret;
257
258 ret = s5m8767_rtc_set_time_reg(info);
259
260 return ret;
261}
262
263static int s5m_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
264{
265 struct s5m_rtc_info *info = dev_get_drvdata(dev);
266 u8 data[8];
267 unsigned int val;
268 int ret, i;
269
270 ret = regmap_bulk_read(info->regmap, SEC_ALARM0_SEC, data, 8);
271 if (ret < 0)
272 return ret;
273
274 switch (info->device_type) {
275 case S5M8763X:
276 s5m8763_data_to_tm(data, &alrm->time);
277 ret = regmap_read(info->regmap, SEC_ALARM0_CONF, &val);
278 if (ret < 0)
279 return ret;
280
281 alrm->enabled = !!val;
282
283 ret = regmap_read(info->regmap, SEC_RTC_STATUS, &val);
284 if (ret < 0)
285 return ret;
286
287 break;
288
289 case S5M8767X:
290 s5m8767_data_to_tm(data, &alrm->time, info->rtc_24hr_mode);
291 dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
292 1900 + alrm->time.tm_year, 1 + alrm->time.tm_mon,
293 alrm->time.tm_mday, alrm->time.tm_hour,
294 alrm->time.tm_min, alrm->time.tm_sec,
295 alrm->time.tm_wday);
296
297 alrm->enabled = 0;
298 for (i = 0; i < 7; i++) {
299 if (data[i] & ALARM_ENABLE_MASK) {
300 alrm->enabled = 1;
301 break;
302 }
303 }
304
305 alrm->pending = 0;
306 ret = regmap_read(info->regmap, SEC_RTC_STATUS, &val);
307 if (ret < 0)
308 return ret;
309 break;
310
311 default:
312 return -EINVAL;
313 }
314
315 if (val & ALARM0_STATUS)
316 alrm->pending = 1;
317 else
318 alrm->pending = 0;
319
320 return 0;
321}
322
323static int s5m_rtc_stop_alarm(struct s5m_rtc_info *info)
324{
325 u8 data[8];
326 int ret, i;
327 struct rtc_time tm;
328
329 ret = regmap_bulk_read(info->regmap, SEC_ALARM0_SEC, data, 8);
330 if (ret < 0)
331 return ret;
332
333 s5m8767_data_to_tm(data, &tm, info->rtc_24hr_mode);
334 dev_dbg(info->dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
335 1900 + tm.tm_year, 1 + tm.tm_mon, tm.tm_mday,
336 tm.tm_hour, tm.tm_min, tm.tm_sec, tm.tm_wday);
337
338 switch (info->device_type) {
339 case S5M8763X:
340 ret = regmap_write(info->regmap, SEC_ALARM0_CONF, 0);
341 break;
342
343 case S5M8767X:
344 for (i = 0; i < 7; i++)
345 data[i] &= ~ALARM_ENABLE_MASK;
346
347 ret = regmap_raw_write(info->regmap, SEC_ALARM0_SEC, data, 8);
348 if (ret < 0)
349 return ret;
350
351 ret = s5m8767_rtc_set_alarm_reg(info);
352
353 break;
354
355 default:
356 return -EINVAL;
357 }
358
359 return ret;
360}
361
362static int s5m_rtc_start_alarm(struct s5m_rtc_info *info)
363{
364 int ret;
365 u8 data[8];
366 u8 alarm0_conf;
367 struct rtc_time tm;
368
369 ret = regmap_bulk_read(info->regmap, SEC_ALARM0_SEC, data, 8);
370 if (ret < 0)
371 return ret;
372
373 s5m8767_data_to_tm(data, &tm, info->rtc_24hr_mode);
374 dev_dbg(info->dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
375 1900 + tm.tm_year, 1 + tm.tm_mon, tm.tm_mday,
376 tm.tm_hour, tm.tm_min, tm.tm_sec, tm.tm_wday);
377
378 switch (info->device_type) {
379 case S5M8763X:
380 alarm0_conf = 0x77;
381 ret = regmap_write(info->regmap, SEC_ALARM0_CONF, alarm0_conf);
382 break;
383
384 case S5M8767X:
385 data[RTC_SEC] |= ALARM_ENABLE_MASK;
386 data[RTC_MIN] |= ALARM_ENABLE_MASK;
387 data[RTC_HOUR] |= ALARM_ENABLE_MASK;
388 data[RTC_WEEKDAY] &= ~ALARM_ENABLE_MASK;
389 if (data[RTC_DATE] & 0x1f)
390 data[RTC_DATE] |= ALARM_ENABLE_MASK;
391 if (data[RTC_MONTH] & 0xf)
392 data[RTC_MONTH] |= ALARM_ENABLE_MASK;
393 if (data[RTC_YEAR1] & 0x7f)
394 data[RTC_YEAR1] |= ALARM_ENABLE_MASK;
395
396 ret = regmap_raw_write(info->regmap, SEC_ALARM0_SEC, data, 8);
397 if (ret < 0)
398 return ret;
399 ret = s5m8767_rtc_set_alarm_reg(info);
400
401 break;
402
403 default:
404 return -EINVAL;
405 }
406
407 return ret;
408}
409
410static int s5m_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
411{
412 struct s5m_rtc_info *info = dev_get_drvdata(dev);
413 u8 data[8];
414 int ret;
415
416 switch (info->device_type) {
417 case S5M8763X:
418 s5m8763_tm_to_data(&alrm->time, data);
419 break;
420
421 case S5M8767X:
422 s5m8767_tm_to_data(&alrm->time, data);
423 break;
424
425 default:
426 return -EINVAL;
427 }
428
429 dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
430 1900 + alrm->time.tm_year, 1 + alrm->time.tm_mon,
431 alrm->time.tm_mday, alrm->time.tm_hour, alrm->time.tm_min,
432 alrm->time.tm_sec, alrm->time.tm_wday);
433
434 ret = s5m_rtc_stop_alarm(info);
435 if (ret < 0)
436 return ret;
437
438 ret = regmap_raw_write(info->regmap, SEC_ALARM0_SEC, data, 8);
439 if (ret < 0)
440 return ret;
441
442 ret = s5m8767_rtc_set_alarm_reg(info);
443 if (ret < 0)
444 return ret;
445
446 if (alrm->enabled)
447 ret = s5m_rtc_start_alarm(info);
448
449 return ret;
450}
451
452static int s5m_rtc_alarm_irq_enable(struct device *dev,
453 unsigned int enabled)
454{
455 struct s5m_rtc_info *info = dev_get_drvdata(dev);
456
457 if (enabled)
458 return s5m_rtc_start_alarm(info);
459 else
460 return s5m_rtc_stop_alarm(info);
461}
462
463static irqreturn_t s5m_rtc_alarm_irq(int irq, void *data)
464{
465 struct s5m_rtc_info *info = data;
466
467 rtc_update_irq(info->rtc_dev, 1, RTC_IRQF | RTC_AF);
468
469 return IRQ_HANDLED;
470}
471
472static const struct rtc_class_ops s5m_rtc_ops = {
473 .read_time = s5m_rtc_read_time,
474 .set_time = s5m_rtc_set_time,
475 .read_alarm = s5m_rtc_read_alarm,
476 .set_alarm = s5m_rtc_set_alarm,
477 .alarm_irq_enable = s5m_rtc_alarm_irq_enable,
478};
479
480static void s5m_rtc_enable_wtsr(struct s5m_rtc_info *info, bool enable)
481{
482 int ret;
483 ret = regmap_update_bits(info->regmap, SEC_WTSR_SMPL_CNTL,
484 WTSR_ENABLE_MASK,
485 enable ? WTSR_ENABLE_MASK : 0);
486 if (ret < 0)
487 dev_err(info->dev, "%s: fail to update WTSR reg(%d)\n",
488 __func__, ret);
489}
490
491static void s5m_rtc_enable_smpl(struct s5m_rtc_info *info, bool enable)
492{
493 int ret;
494 ret = regmap_update_bits(info->regmap, SEC_WTSR_SMPL_CNTL,
495 SMPL_ENABLE_MASK,
496 enable ? SMPL_ENABLE_MASK : 0);
497 if (ret < 0)
498 dev_err(info->dev, "%s: fail to update SMPL reg(%d)\n",
499 __func__, ret);
500}
501
502static int s5m8767_rtc_init_reg(struct s5m_rtc_info *info)
503{
504 u8 data[2];
505 unsigned int tp_read;
506 int ret;
507 struct rtc_time tm;
508
509 ret = regmap_read(info->regmap, SEC_RTC_UDR_CON, &tp_read);
510 if (ret < 0) {
511 dev_err(info->dev, "%s: fail to read control reg(%d)\n",
512 __func__, ret);
513 return ret;
514 }
515
516 /* Set RTC control register : Binary mode, 24hour mode */
517 data[0] = (1 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
518 data[1] = (0 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
519
520 info->rtc_24hr_mode = 1;
521 ret = regmap_raw_write(info->regmap, SEC_ALARM0_CONF, data, 2);
522 if (ret < 0) {
523 dev_err(info->dev, "%s: fail to write controlm reg(%d)\n",
524 __func__, ret);
525 return ret;
526 }
527
528 /* In first boot time, Set rtc time to 1/1/2012 00:00:00(SUN) */
529 if ((tp_read & RTC_TCON_MASK) == 0) {
530 dev_dbg(info->dev, "rtc init\n");
531 tm.tm_sec = 0;
532 tm.tm_min = 0;
533 tm.tm_hour = 0;
534 tm.tm_wday = 0;
535 tm.tm_mday = 1;
536 tm.tm_mon = 0;
537 tm.tm_year = 112;
538 tm.tm_yday = 0;
539 tm.tm_isdst = 0;
540 ret = s5m_rtc_set_time(info->dev, &tm);
541 }
542
543 ret = regmap_update_bits(info->regmap, SEC_RTC_UDR_CON,
544 RTC_TCON_MASK, tp_read | RTC_TCON_MASK);
545 if (ret < 0)
546 dev_err(info->dev, "%s: fail to update TCON reg(%d)\n",
547 __func__, ret);
548
549 return ret;
550}
551
552static int s5m_rtc_probe(struct platform_device *pdev)
553{
554 struct sec_pmic_dev *s5m87xx = dev_get_drvdata(pdev->dev.parent);
555 struct sec_platform_data *pdata = s5m87xx->pdata;
556 struct s5m_rtc_info *info;
557 int ret;
558
559 if (!pdata) {
560 dev_err(pdev->dev.parent, "Platform data not supplied\n");
561 return -ENODEV;
562 }
563
564 info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
565 if (!info)
566 return -ENOMEM;
567
568 info->dev = &pdev->dev;
569 info->s5m87xx = s5m87xx;
570 info->regmap = s5m87xx->regmap_rtc;
571 info->device_type = s5m87xx->device_type;
572 info->wtsr_smpl = s5m87xx->wtsr_smpl;
573
574 switch (pdata->device_type) {
575 case S5M8763X:
576 info->irq = regmap_irq_get_virq(s5m87xx->irq_data,
577 S5M8763_IRQ_ALARM0);
578 break;
579
580 case S5M8767X:
581 info->irq = regmap_irq_get_virq(s5m87xx->irq_data,
582 S5M8767_IRQ_RTCA1);
583 break;
584
585 default:
586 ret = -EINVAL;
587 dev_err(&pdev->dev, "Unsupported device type: %d\n", ret);
588 return ret;
589 }
590
591 platform_set_drvdata(pdev, info);
592
593 ret = s5m8767_rtc_init_reg(info);
594
595 if (info->wtsr_smpl) {
596 s5m_rtc_enable_wtsr(info, true);
597 s5m_rtc_enable_smpl(info, true);
598 }
599
600 device_init_wakeup(&pdev->dev, 1);
601
602 info->rtc_dev = devm_rtc_device_register(&pdev->dev, "s5m-rtc",
603 &s5m_rtc_ops, THIS_MODULE);
604
605 if (IS_ERR(info->rtc_dev))
606 return PTR_ERR(info->rtc_dev);
607
608 ret = devm_request_threaded_irq(&pdev->dev, info->irq, NULL,
609 s5m_rtc_alarm_irq, 0, "rtc-alarm0",
610 info);
611 if (ret < 0)
612 dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
613 info->irq, ret);
614
615 return ret;
616}
617
618static void s5m_rtc_shutdown(struct platform_device *pdev)
619{
620 struct s5m_rtc_info *info = platform_get_drvdata(pdev);
621 int i;
622 unsigned int val = 0;
623 if (info->wtsr_smpl) {
624 for (i = 0; i < 3; i++) {
625 s5m_rtc_enable_wtsr(info, false);
626 regmap_read(info->regmap, SEC_WTSR_SMPL_CNTL, &val);
627 pr_debug("%s: WTSR_SMPL reg(0x%02x)\n", __func__, val);
628 if (val & WTSR_ENABLE_MASK)
629 pr_emerg("%s: fail to disable WTSR\n",
630 __func__);
631 else {
632 pr_info("%s: success to disable WTSR\n",
633 __func__);
634 break;
635 }
636 }
637 }
638 /* Disable SMPL when power off */
639 s5m_rtc_enable_smpl(info, false);
640}
641
642static int s5m_rtc_resume(struct device *dev)
643{
644 struct s5m_rtc_info *info = dev_get_drvdata(dev);
645 int ret = 0;
646
647 if (device_may_wakeup(dev))
648 ret = disable_irq_wake(info->irq);
649
650 return ret;
651}
652
653static int s5m_rtc_suspend(struct device *dev)
654{
655 struct s5m_rtc_info *info = dev_get_drvdata(dev);
656 int ret = 0;
657
658 if (device_may_wakeup(dev))
659 ret = enable_irq_wake(info->irq);
660
661 return ret;
662}
663
664static SIMPLE_DEV_PM_OPS(s5m_rtc_pm_ops, s5m_rtc_suspend, s5m_rtc_resume);
665
666static const struct platform_device_id s5m_rtc_id[] = {
667 { "s5m-rtc", 0 },
668};
669
670static struct platform_driver s5m_rtc_driver = {
671 .driver = {
672 .name = "s5m-rtc",
673 .owner = THIS_MODULE,
674 .pm = &s5m_rtc_pm_ops,
675 },
676 .probe = s5m_rtc_probe,
677 .shutdown = s5m_rtc_shutdown,
678 .id_table = s5m_rtc_id,
679};
680
681module_platform_driver(s5m_rtc_driver);
682
683/* Module information */
684MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
685MODULE_DESCRIPTION("Samsung S5M RTC driver");
686MODULE_LICENSE("GPL");
687MODULE_ALIAS("platform:s5m-rtc");
diff --git a/drivers/rtc/rtc-sh.c b/drivers/rtc/rtc-sh.c
index 6d87e26355a3..d0d2b047658b 100644
--- a/drivers/rtc/rtc-sh.c
+++ b/drivers/rtc/rtc-sh.c
@@ -649,8 +649,9 @@ static int __init sh_rtc_probe(struct platform_device *pdev)
649 clk_enable(rtc->clk); 649 clk_enable(rtc->clk);
650 650
651 rtc->capabilities = RTC_DEF_CAPABILITIES; 651 rtc->capabilities = RTC_DEF_CAPABILITIES;
652 if (pdev->dev.platform_data) { 652 if (dev_get_platdata(&pdev->dev)) {
653 struct sh_rtc_platform_info *pinfo = pdev->dev.platform_data; 653 struct sh_rtc_platform_info *pinfo =
654 dev_get_platdata(&pdev->dev);
654 655
655 /* 656 /*
656 * Some CPUs have special capabilities in addition to the 657 * Some CPUs have special capabilities in addition to the
diff --git a/drivers/rtc/rtc-sirfsoc.c b/drivers/rtc/rtc-sirfsoc.c
index 63460cf80f1b..3eb3642ae299 100644
--- a/drivers/rtc/rtc-sirfsoc.c
+++ b/drivers/rtc/rtc-sirfsoc.c
@@ -59,7 +59,7 @@ static int sirfsoc_rtc_read_alarm(struct device *dev,
59 unsigned long rtc_alarm, rtc_count; 59 unsigned long rtc_alarm, rtc_count;
60 struct sirfsoc_rtc_drv *rtcdrv; 60 struct sirfsoc_rtc_drv *rtcdrv;
61 61
62 rtcdrv = (struct sirfsoc_rtc_drv *)dev_get_drvdata(dev); 62 rtcdrv = dev_get_drvdata(dev);
63 63
64 local_irq_disable(); 64 local_irq_disable();
65 65
@@ -94,7 +94,7 @@ static int sirfsoc_rtc_set_alarm(struct device *dev,
94{ 94{
95 unsigned long rtc_status_reg, rtc_alarm; 95 unsigned long rtc_status_reg, rtc_alarm;
96 struct sirfsoc_rtc_drv *rtcdrv; 96 struct sirfsoc_rtc_drv *rtcdrv;
97 rtcdrv = (struct sirfsoc_rtc_drv *)dev_get_drvdata(dev); 97 rtcdrv = dev_get_drvdata(dev);
98 98
99 if (alrm->enabled) { 99 if (alrm->enabled) {
100 rtc_tm_to_time(&(alrm->time), &rtc_alarm); 100 rtc_tm_to_time(&(alrm->time), &rtc_alarm);
@@ -157,7 +157,7 @@ static int sirfsoc_rtc_read_time(struct device *dev,
157{ 157{
158 unsigned long tmp_rtc = 0; 158 unsigned long tmp_rtc = 0;
159 struct sirfsoc_rtc_drv *rtcdrv; 159 struct sirfsoc_rtc_drv *rtcdrv;
160 rtcdrv = (struct sirfsoc_rtc_drv *)dev_get_drvdata(dev); 160 rtcdrv = dev_get_drvdata(dev);
161 /* 161 /*
162 * This patch is taken from WinCE - Need to validate this for 162 * This patch is taken from WinCE - Need to validate this for
163 * correctness. To work around sirfsoc RTC counter double sync logic 163 * correctness. To work around sirfsoc RTC counter double sync logic
@@ -178,7 +178,7 @@ static int sirfsoc_rtc_set_time(struct device *dev,
178{ 178{
179 unsigned long rtc_time; 179 unsigned long rtc_time;
180 struct sirfsoc_rtc_drv *rtcdrv; 180 struct sirfsoc_rtc_drv *rtcdrv;
181 rtcdrv = (struct sirfsoc_rtc_drv *)dev_get_drvdata(dev); 181 rtcdrv = dev_get_drvdata(dev);
182 182
183 rtc_tm_to_time(tm, &rtc_time); 183 rtc_tm_to_time(tm, &rtc_time);
184 184
@@ -274,7 +274,7 @@ static int sirfsoc_rtc_probe(struct platform_device *pdev)
274 err = of_property_read_u32(np, "reg", &rtcdrv->rtc_base); 274 err = of_property_read_u32(np, "reg", &rtcdrv->rtc_base);
275 if (err) { 275 if (err) {
276 dev_err(&pdev->dev, "unable to find base address of rtc node in dtb\n"); 276 dev_err(&pdev->dev, "unable to find base address of rtc node in dtb\n");
277 goto error; 277 return err;
278 } 278 }
279 279
280 platform_set_drvdata(pdev, rtcdrv); 280 platform_set_drvdata(pdev, rtcdrv);
@@ -290,7 +290,7 @@ static int sirfsoc_rtc_probe(struct platform_device *pdev)
290 rtc_div = ((32768 / RTC_HZ) / 2) - 1; 290 rtc_div = ((32768 / RTC_HZ) / 2) - 1;
291 sirfsoc_rtc_iobrg_writel(rtc_div, rtcdrv->rtc_base + RTC_DIV); 291 sirfsoc_rtc_iobrg_writel(rtc_div, rtcdrv->rtc_base + RTC_DIV);
292 292
293 rtcdrv->rtc = rtc_device_register(pdev->name, &(pdev->dev), 293 rtcdrv->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
294 &sirfsoc_rtc_ops, THIS_MODULE); 294 &sirfsoc_rtc_ops, THIS_MODULE);
295 if (IS_ERR(rtcdrv->rtc)) { 295 if (IS_ERR(rtcdrv->rtc)) {
296 err = PTR_ERR(rtcdrv->rtc); 296 err = PTR_ERR(rtcdrv->rtc);
@@ -322,24 +322,15 @@ static int sirfsoc_rtc_probe(struct platform_device *pdev)
322 rtcdrv); 322 rtcdrv);
323 if (err) { 323 if (err) {
324 dev_err(&pdev->dev, "Unable to register for the SiRF SOC RTC IRQ\n"); 324 dev_err(&pdev->dev, "Unable to register for the SiRF SOC RTC IRQ\n");
325 goto error; 325 return err;
326 } 326 }
327 327
328 return 0; 328 return 0;
329
330error:
331 if (rtcdrv->rtc)
332 rtc_device_unregister(rtcdrv->rtc);
333
334 return err;
335} 329}
336 330
337static int sirfsoc_rtc_remove(struct platform_device *pdev) 331static int sirfsoc_rtc_remove(struct platform_device *pdev)
338{ 332{
339 struct sirfsoc_rtc_drv *rtcdrv = platform_get_drvdata(pdev);
340
341 device_init_wakeup(&pdev->dev, 0); 333 device_init_wakeup(&pdev->dev, 0);
342 rtc_device_unregister(rtcdrv->rtc);
343 334
344 return 0; 335 return 0;
345} 336}
@@ -373,7 +364,7 @@ static int sirfsoc_rtc_thaw(struct device *dev)
373{ 364{
374 u32 tmp; 365 u32 tmp;
375 struct sirfsoc_rtc_drv *rtcdrv; 366 struct sirfsoc_rtc_drv *rtcdrv;
376 rtcdrv = (struct sirfsoc_rtc_drv *)dev_get_drvdata(dev); 367 rtcdrv = dev_get_drvdata(dev);
377 368
378 /* 369 /*
379 * if resume from snapshot and the rtc power is losed, 370 * if resume from snapshot and the rtc power is losed,
@@ -467,7 +458,7 @@ static struct platform_driver sirfsoc_rtc_driver = {
467#ifdef CONFIG_PM 458#ifdef CONFIG_PM
468 .pm = &sirfsoc_rtc_pm_ops, 459 .pm = &sirfsoc_rtc_pm_ops,
469#endif 460#endif
470 .of_match_table = of_match_ptr(sirfsoc_rtc_of_match), 461 .of_match_table = sirfsoc_rtc_of_match,
471 }, 462 },
472 .probe = sirfsoc_rtc_probe, 463 .probe = sirfsoc_rtc_probe,
473 .remove = sirfsoc_rtc_remove, 464 .remove = sirfsoc_rtc_remove,
diff --git a/drivers/rtc/rtc-snvs.c b/drivers/rtc/rtc-snvs.c
index 316a342115b2..fa384fe28988 100644
--- a/drivers/rtc/rtc-snvs.c
+++ b/drivers/rtc/rtc-snvs.c
@@ -329,7 +329,7 @@ static struct platform_driver snvs_rtc_driver = {
329 .name = "snvs_rtc", 329 .name = "snvs_rtc",
330 .owner = THIS_MODULE, 330 .owner = THIS_MODULE,
331 .pm = &snvs_rtc_pm_ops, 331 .pm = &snvs_rtc_pm_ops,
332 .of_match_table = of_match_ptr(snvs_dt_ids), 332 .of_match_table = snvs_dt_ids,
333 }, 333 },
334 .probe = snvs_rtc_probe, 334 .probe = snvs_rtc_probe,
335}; 335};
diff --git a/drivers/rtc/rtc-stmp3xxx.c b/drivers/rtc/rtc-stmp3xxx.c
index 26019531db15..ea96492357b0 100644
--- a/drivers/rtc/rtc-stmp3xxx.c
+++ b/drivers/rtc/rtc-stmp3xxx.c
@@ -343,7 +343,7 @@ static struct platform_driver stmp3xxx_rtcdrv = {
343 .name = "stmp3xxx-rtc", 343 .name = "stmp3xxx-rtc",
344 .owner = THIS_MODULE, 344 .owner = THIS_MODULE,
345 .pm = &stmp3xxx_rtc_pm_ops, 345 .pm = &stmp3xxx_rtc_pm_ops,
346 .of_match_table = of_match_ptr(rtc_dt_ids), 346 .of_match_table = rtc_dt_ids,
347 }, 347 },
348}; 348};
349 349
diff --git a/drivers/rtc/rtc-tps65910.c b/drivers/rtc/rtc-tps65910.c
index a9caf043b0ce..7af00208d637 100644
--- a/drivers/rtc/rtc-tps65910.c
+++ b/drivers/rtc/rtc-tps65910.c
@@ -22,7 +22,6 @@
22#include <linux/rtc.h> 22#include <linux/rtc.h>
23#include <linux/bcd.h> 23#include <linux/bcd.h>
24#include <linux/platform_device.h> 24#include <linux/platform_device.h>
25#include <linux/pm_runtime.h>
26#include <linux/interrupt.h> 25#include <linux/interrupt.h>
27#include <linux/mfd/tps65910.h> 26#include <linux/mfd/tps65910.h>
28 27
diff --git a/drivers/rtc/rtc-v3020.c b/drivers/rtc/rtc-v3020.c
index d07d89823020..25222cdccdc6 100644
--- a/drivers/rtc/rtc-v3020.c
+++ b/drivers/rtc/rtc-v3020.c
@@ -303,7 +303,7 @@ static const struct rtc_class_ops v3020_rtc_ops = {
303 303
304static int rtc_probe(struct platform_device *pdev) 304static int rtc_probe(struct platform_device *pdev)
305{ 305{
306 struct v3020_platform_data *pdata = pdev->dev.platform_data; 306 struct v3020_platform_data *pdata = dev_get_platdata(&pdev->dev);
307 struct v3020 *chip; 307 struct v3020 *chip;
308 int retval = -EBUSY; 308 int retval = -EBUSY;
309 int i; 309 int i;
diff --git a/drivers/rtc/rtc-vr41xx.c b/drivers/rtc/rtc-vr41xx.c
index 54e104e197e3..aabc22c587fb 100644
--- a/drivers/rtc/rtc-vr41xx.c
+++ b/drivers/rtc/rtc-vr41xx.c
@@ -20,6 +20,7 @@
20#include <linux/err.h> 20#include <linux/err.h>
21#include <linux/fs.h> 21#include <linux/fs.h>
22#include <linux/init.h> 22#include <linux/init.h>
23#include <linux/io.h>
23#include <linux/ioport.h> 24#include <linux/ioport.h>
24#include <linux/interrupt.h> 25#include <linux/interrupt.h>
25#include <linux/module.h> 26#include <linux/module.h>
@@ -27,11 +28,10 @@
27#include <linux/rtc.h> 28#include <linux/rtc.h>
28#include <linux/spinlock.h> 29#include <linux/spinlock.h>
29#include <linux/types.h> 30#include <linux/types.h>
31#include <linux/uaccess.h>
30#include <linux/log2.h> 32#include <linux/log2.h>
31 33
32#include <asm/div64.h> 34#include <asm/div64.h>
33#include <asm/io.h>
34#include <asm/uaccess.h>
35 35
36MODULE_AUTHOR("Yoichi Yuasa <yuasa@linux-mips.org>"); 36MODULE_AUTHOR("Yoichi Yuasa <yuasa@linux-mips.org>");
37MODULE_DESCRIPTION("NEC VR4100 series RTC driver"); 37MODULE_DESCRIPTION("NEC VR4100 series RTC driver");
diff --git a/drivers/rtc/rtc-vt8500.c b/drivers/rtc/rtc-vt8500.c
index c2d6331fc712..df2ef3eba7cd 100644
--- a/drivers/rtc/rtc-vt8500.c
+++ b/drivers/rtc/rtc-vt8500.c
@@ -228,7 +228,7 @@ static int vt8500_rtc_probe(struct platform_device *pdev)
228 vt8500_rtc->irq_alarm = platform_get_irq(pdev, 0); 228 vt8500_rtc->irq_alarm = platform_get_irq(pdev, 0);
229 if (vt8500_rtc->irq_alarm < 0) { 229 if (vt8500_rtc->irq_alarm < 0) {
230 dev_err(&pdev->dev, "No alarm IRQ resource defined\n"); 230 dev_err(&pdev->dev, "No alarm IRQ resource defined\n");
231 return -ENXIO; 231 return vt8500_rtc->irq_alarm;
232 } 232 }
233 233
234 vt8500_rtc->res = devm_request_mem_region(&pdev->dev, 234 vt8500_rtc->res = devm_request_mem_region(&pdev->dev,
@@ -296,7 +296,7 @@ static struct platform_driver vt8500_rtc_driver = {
296 .driver = { 296 .driver = {
297 .name = "vt8500-rtc", 297 .name = "vt8500-rtc",
298 .owner = THIS_MODULE, 298 .owner = THIS_MODULE,
299 .of_match_table = of_match_ptr(wmt_dt_ids), 299 .of_match_table = wmt_dt_ids,
300 }, 300 },
301}; 301};
302 302
generated by cgit v1.2.2 (git 2.25.0) at 2025-10-02 02:25:51 -0400