aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/rtc
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/rtc')
-rw-r--r--drivers/rtc/Kconfig20
-rw-r--r--drivers/rtc/Makefile2
-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.c28
-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-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-mrst.c2
-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.c2
-rw-r--r--drivers/rtc/rtc-puv3.c22
-rw-r--r--drivers/rtc/rtc-rs5c348.c4
-rw-r--r--drivers/rtc/rtc-s5m.c635
-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
32 files changed, 1020 insertions, 144 deletions
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 9654aa3c05cb..15f166a470a7 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"
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/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..8b2cd8a5a2ff 100644
--- a/drivers/rtc/rtc-at91rm9200.c
+++ b/drivers/rtc/rtc-at91rm9200.c
@@ -376,7 +376,8 @@ static int __init at91_rtc_probe(struct platform_device *pdev)
376 return -ENXIO; 376 return -ENXIO;
377 } 377 }
378 378
379 at91_rtc_regs = ioremap(regs->start, resource_size(regs)); 379 at91_rtc_regs = devm_ioremap(&pdev->dev, regs->start,
380 resource_size(regs));
380 if (!at91_rtc_regs) { 381 if (!at91_rtc_regs) {
381 dev_err(&pdev->dev, "failed to map registers, aborting.\n"); 382 dev_err(&pdev->dev, "failed to map registers, aborting.\n");
382 return -ENOMEM; 383 return -ENOMEM;
@@ -390,12 +391,12 @@ static int __init at91_rtc_probe(struct platform_device *pdev)
390 AT91_RTC_SECEV | AT91_RTC_TIMEV | 391 AT91_RTC_SECEV | AT91_RTC_TIMEV |
391 AT91_RTC_CALEV); 392 AT91_RTC_CALEV);
392 393
393 ret = request_irq(irq, at91_rtc_interrupt, 394 ret = devm_request_irq(&pdev->dev, irq, at91_rtc_interrupt,
394 IRQF_SHARED, 395 IRQF_SHARED,
395 "at91_rtc", pdev); 396 "at91_rtc", pdev);
396 if (ret) { 397 if (ret) {
397 dev_err(&pdev->dev, "IRQ %d already in use.\n", irq); 398 dev_err(&pdev->dev, "IRQ %d already in use.\n", irq);
398 goto err_unmap; 399 return ret;
399 } 400 }
400 401
401 /* cpu init code should really have flagged this device as 402 /* cpu init code should really have flagged this device as
@@ -404,23 +405,14 @@ static int __init at91_rtc_probe(struct platform_device *pdev)
404 if (!device_can_wakeup(&pdev->dev)) 405 if (!device_can_wakeup(&pdev->dev))
405 device_init_wakeup(&pdev->dev, 1); 406 device_init_wakeup(&pdev->dev, 1);
406 407
407 rtc = rtc_device_register(pdev->name, &pdev->dev, 408 rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
408 &at91_rtc_ops, THIS_MODULE); 409 &at91_rtc_ops, THIS_MODULE);
409 if (IS_ERR(rtc)) { 410 if (IS_ERR(rtc))
410 ret = PTR_ERR(rtc); 411 return PTR_ERR(rtc);
411 goto err_free_irq;
412 }
413 platform_set_drvdata(pdev, rtc); 412 platform_set_drvdata(pdev, rtc);
414 413
415 dev_info(&pdev->dev, "AT91 Real Time Clock driver.\n"); 414 dev_info(&pdev->dev, "AT91 Real Time Clock driver.\n");
416 return 0; 415 return 0;
417
418err_free_irq:
419 free_irq(irq, pdev);
420err_unmap:
421 iounmap(at91_rtc_regs);
422
423 return ret;
424} 416}
425 417
426/* 418/*
@@ -428,16 +420,10 @@ err_unmap:
428 */ 420 */
429static int __exit at91_rtc_remove(struct platform_device *pdev) 421static int __exit at91_rtc_remove(struct platform_device *pdev)
430{ 422{
431 struct rtc_device *rtc = platform_get_drvdata(pdev);
432
433 /* Disable all interrupts */ 423 /* Disable all interrupts */
434 at91_rtc_write_idr(AT91_RTC_ACKUPD | AT91_RTC_ALARM | 424 at91_rtc_write_idr(AT91_RTC_ACKUPD | AT91_RTC_ALARM |
435 AT91_RTC_SECEV | AT91_RTC_TIMEV | 425 AT91_RTC_SECEV | AT91_RTC_TIMEV |
436 AT91_RTC_CALEV); 426 AT91_RTC_CALEV);
437 free_irq(irq, pdev);
438
439 rtc_device_unregister(rtc);
440 iounmap(at91_rtc_regs);
441 427
442 return 0; 428 return 0;
443} 429}
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-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-mrst.c b/drivers/rtc/rtc-mrst.c
index 315209d9b407..e2436d140175 100644
--- a/drivers/rtc/rtc-mrst.c
+++ b/drivers/rtc/rtc-mrst.c
@@ -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 e3b25712b659..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);
@@ -391,7 +390,6 @@ out_no_irq:
391 rtc_device_unregister(ldata->rtc); 390 rtc_device_unregister(ldata->rtc);
392out_no_rtc: 391out_no_rtc:
393 iounmap(ldata->base); 392 iounmap(ldata->base);
394 amba_set_drvdata(adev, NULL);
395out_no_remap: 393out_no_remap:
396 kfree(ldata); 394 kfree(ldata);
397out: 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..b7fd02bc0a14
--- /dev/null
+++ b/drivers/rtc/rtc-s5m.c
@@ -0,0 +1,635 @@
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
31struct s5m_rtc_info {
32 struct device *dev;
33 struct sec_pmic_dev *s5m87xx;
34 struct regmap *rtc;
35 struct rtc_device *rtc_dev;
36 int irq;
37 int device_type;
38 int rtc_24hr_mode;
39 bool wtsr_smpl;
40};
41
42static void s5m8767_data_to_tm(u8 *data, struct rtc_time *tm,
43 int rtc_24hr_mode)
44{
45 tm->tm_sec = data[RTC_SEC] & 0x7f;
46 tm->tm_min = data[RTC_MIN] & 0x7f;
47 if (rtc_24hr_mode) {
48 tm->tm_hour = data[RTC_HOUR] & 0x1f;
49 } else {
50 tm->tm_hour = data[RTC_HOUR] & 0x0f;
51 if (data[RTC_HOUR] & HOUR_PM_MASK)
52 tm->tm_hour += 12;
53 }
54
55 tm->tm_wday = ffs(data[RTC_WEEKDAY] & 0x7f);
56 tm->tm_mday = data[RTC_DATE] & 0x1f;
57 tm->tm_mon = (data[RTC_MONTH] & 0x0f) - 1;
58 tm->tm_year = (data[RTC_YEAR1] & 0x7f) + 100;
59 tm->tm_yday = 0;
60 tm->tm_isdst = 0;
61}
62
63static int s5m8767_tm_to_data(struct rtc_time *tm, u8 *data)
64{
65 data[RTC_SEC] = tm->tm_sec;
66 data[RTC_MIN] = tm->tm_min;
67
68 if (tm->tm_hour >= 12)
69 data[RTC_HOUR] = tm->tm_hour | HOUR_PM_MASK;
70 else
71 data[RTC_HOUR] = tm->tm_hour & ~HOUR_PM_MASK;
72
73 data[RTC_WEEKDAY] = 1 << tm->tm_wday;
74 data[RTC_DATE] = tm->tm_mday;
75 data[RTC_MONTH] = tm->tm_mon + 1;
76 data[RTC_YEAR1] = tm->tm_year > 100 ? (tm->tm_year - 100) : 0;
77
78 if (tm->tm_year < 100) {
79 pr_err("s5m8767 RTC cannot handle the year %d.\n",
80 1900 + tm->tm_year);
81 return -EINVAL;
82 } else {
83 return 0;
84 }
85}
86
87static inline int s5m8767_rtc_set_time_reg(struct s5m_rtc_info *info)
88{
89 int ret;
90 unsigned int data;
91
92 ret = regmap_read(info->rtc, SEC_RTC_UDR_CON, &data);
93 if (ret < 0) {
94 dev_err(info->dev, "failed to read update reg(%d)\n", ret);
95 return ret;
96 }
97
98 data |= RTC_TIME_EN_MASK;
99 data |= RTC_UDR_MASK;
100
101 ret = regmap_write(info->rtc, SEC_RTC_UDR_CON, data);
102 if (ret < 0) {
103 dev_err(info->dev, "failed to write update reg(%d)\n", ret);
104 return ret;
105 }
106
107 do {
108 ret = regmap_read(info->rtc, SEC_RTC_UDR_CON, &data);
109 } while ((data & RTC_UDR_MASK) && !ret);
110
111 return ret;
112}
113
114static inline int s5m8767_rtc_set_alarm_reg(struct s5m_rtc_info *info)
115{
116 int ret;
117 unsigned int data;
118
119 ret = regmap_read(info->rtc, SEC_RTC_UDR_CON, &data);
120 if (ret < 0) {
121 dev_err(info->dev, "%s: fail to read update reg(%d)\n",
122 __func__, ret);
123 return ret;
124 }
125
126 data &= ~RTC_TIME_EN_MASK;
127 data |= RTC_UDR_MASK;
128
129 ret = regmap_write(info->rtc, SEC_RTC_UDR_CON, data);
130 if (ret < 0) {
131 dev_err(info->dev, "%s: fail to write update reg(%d)\n",
132 __func__, ret);
133 return ret;
134 }
135
136 do {
137 ret = regmap_read(info->rtc, SEC_RTC_UDR_CON, &data);
138 } while ((data & RTC_UDR_MASK) && !ret);
139
140 return ret;
141}
142
143static void s5m8763_data_to_tm(u8 *data, struct rtc_time *tm)
144{
145 tm->tm_sec = bcd2bin(data[RTC_SEC]);
146 tm->tm_min = bcd2bin(data[RTC_MIN]);
147
148 if (data[RTC_HOUR] & HOUR_12) {
149 tm->tm_hour = bcd2bin(data[RTC_HOUR] & 0x1f);
150 if (data[RTC_HOUR] & HOUR_PM)
151 tm->tm_hour += 12;
152 } else {
153 tm->tm_hour = bcd2bin(data[RTC_HOUR] & 0x3f);
154 }
155
156 tm->tm_wday = data[RTC_WEEKDAY] & 0x07;
157 tm->tm_mday = bcd2bin(data[RTC_DATE]);
158 tm->tm_mon = bcd2bin(data[RTC_MONTH]);
159 tm->tm_year = bcd2bin(data[RTC_YEAR1]) + bcd2bin(data[RTC_YEAR2]) * 100;
160 tm->tm_year -= 1900;
161}
162
163static void s5m8763_tm_to_data(struct rtc_time *tm, u8 *data)
164{
165 data[RTC_SEC] = bin2bcd(tm->tm_sec);
166 data[RTC_MIN] = bin2bcd(tm->tm_min);
167 data[RTC_HOUR] = bin2bcd(tm->tm_hour);
168 data[RTC_WEEKDAY] = tm->tm_wday;
169 data[RTC_DATE] = bin2bcd(tm->tm_mday);
170 data[RTC_MONTH] = bin2bcd(tm->tm_mon);
171 data[RTC_YEAR1] = bin2bcd(tm->tm_year % 100);
172 data[RTC_YEAR2] = bin2bcd((tm->tm_year + 1900) / 100);
173}
174
175static int s5m_rtc_read_time(struct device *dev, struct rtc_time *tm)
176{
177 struct s5m_rtc_info *info = dev_get_drvdata(dev);
178 u8 data[8];
179 int ret;
180
181 ret = regmap_bulk_read(info->rtc, SEC_RTC_SEC, data, 8);
182 if (ret < 0)
183 return ret;
184
185 switch (info->device_type) {
186 case S5M8763X:
187 s5m8763_data_to_tm(data, tm);
188 break;
189
190 case S5M8767X:
191 s5m8767_data_to_tm(data, tm, info->rtc_24hr_mode);
192 break;
193
194 default:
195 return -EINVAL;
196 }
197
198 dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
199 1900 + tm->tm_year, 1 + tm->tm_mon, tm->tm_mday,
200 tm->tm_hour, tm->tm_min, tm->tm_sec, tm->tm_wday);
201
202 return rtc_valid_tm(tm);
203}
204
205static int s5m_rtc_set_time(struct device *dev, struct rtc_time *tm)
206{
207 struct s5m_rtc_info *info = dev_get_drvdata(dev);
208 u8 data[8];
209 int ret = 0;
210
211 switch (info->device_type) {
212 case S5M8763X:
213 s5m8763_tm_to_data(tm, data);
214 break;
215 case S5M8767X:
216 ret = s5m8767_tm_to_data(tm, data);
217 break;
218 default:
219 return -EINVAL;
220 }
221
222 if (ret < 0)
223 return ret;
224
225 dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
226 1900 + tm->tm_year, 1 + tm->tm_mon, tm->tm_mday,
227 tm->tm_hour, tm->tm_min, tm->tm_sec, tm->tm_wday);
228
229 ret = regmap_raw_write(info->rtc, SEC_RTC_SEC, data, 8);
230 if (ret < 0)
231 return ret;
232
233 ret = s5m8767_rtc_set_time_reg(info);
234
235 return ret;
236}
237
238static int s5m_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
239{
240 struct s5m_rtc_info *info = dev_get_drvdata(dev);
241 u8 data[8];
242 unsigned int val;
243 int ret, i;
244
245 ret = regmap_bulk_read(info->rtc, SEC_ALARM0_SEC, data, 8);
246 if (ret < 0)
247 return ret;
248
249 switch (info->device_type) {
250 case S5M8763X:
251 s5m8763_data_to_tm(data, &alrm->time);
252 ret = regmap_read(info->rtc, SEC_ALARM0_CONF, &val);
253 if (ret < 0)
254 return ret;
255
256 alrm->enabled = !!val;
257
258 ret = regmap_read(info->rtc, SEC_RTC_STATUS, &val);
259 if (ret < 0)
260 return ret;
261
262 break;
263
264 case S5M8767X:
265 s5m8767_data_to_tm(data, &alrm->time, info->rtc_24hr_mode);
266 dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
267 1900 + alrm->time.tm_year, 1 + alrm->time.tm_mon,
268 alrm->time.tm_mday, alrm->time.tm_hour,
269 alrm->time.tm_min, alrm->time.tm_sec,
270 alrm->time.tm_wday);
271
272 alrm->enabled = 0;
273 for (i = 0; i < 7; i++) {
274 if (data[i] & ALARM_ENABLE_MASK) {
275 alrm->enabled = 1;
276 break;
277 }
278 }
279
280 alrm->pending = 0;
281 ret = regmap_read(info->rtc, SEC_RTC_STATUS, &val);
282 if (ret < 0)
283 return ret;
284 break;
285
286 default:
287 return -EINVAL;
288 }
289
290 if (val & ALARM0_STATUS)
291 alrm->pending = 1;
292 else
293 alrm->pending = 0;
294
295 return 0;
296}
297
298static int s5m_rtc_stop_alarm(struct s5m_rtc_info *info)
299{
300 u8 data[8];
301 int ret, i;
302 struct rtc_time tm;
303
304 ret = regmap_bulk_read(info->rtc, SEC_ALARM0_SEC, data, 8);
305 if (ret < 0)
306 return ret;
307
308 s5m8767_data_to_tm(data, &tm, info->rtc_24hr_mode);
309 dev_dbg(info->dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
310 1900 + tm.tm_year, 1 + tm.tm_mon, tm.tm_mday,
311 tm.tm_hour, tm.tm_min, tm.tm_sec, tm.tm_wday);
312
313 switch (info->device_type) {
314 case S5M8763X:
315 ret = regmap_write(info->rtc, SEC_ALARM0_CONF, 0);
316 break;
317
318 case S5M8767X:
319 for (i = 0; i < 7; i++)
320 data[i] &= ~ALARM_ENABLE_MASK;
321
322 ret = regmap_raw_write(info->rtc, SEC_ALARM0_SEC, data, 8);
323 if (ret < 0)
324 return ret;
325
326 ret = s5m8767_rtc_set_alarm_reg(info);
327
328 break;
329
330 default:
331 return -EINVAL;
332 }
333
334 return ret;
335}
336
337static int s5m_rtc_start_alarm(struct s5m_rtc_info *info)
338{
339 int ret;
340 u8 data[8];
341 u8 alarm0_conf;
342 struct rtc_time tm;
343
344 ret = regmap_bulk_read(info->rtc, SEC_ALARM0_SEC, data, 8);
345 if (ret < 0)
346 return ret;
347
348 s5m8767_data_to_tm(data, &tm, info->rtc_24hr_mode);
349 dev_dbg(info->dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
350 1900 + tm.tm_year, 1 + tm.tm_mon, tm.tm_mday,
351 tm.tm_hour, tm.tm_min, tm.tm_sec, tm.tm_wday);
352
353 switch (info->device_type) {
354 case S5M8763X:
355 alarm0_conf = 0x77;
356 ret = regmap_write(info->rtc, SEC_ALARM0_CONF, alarm0_conf);
357 break;
358
359 case S5M8767X:
360 data[RTC_SEC] |= ALARM_ENABLE_MASK;
361 data[RTC_MIN] |= ALARM_ENABLE_MASK;
362 data[RTC_HOUR] |= ALARM_ENABLE_MASK;
363 data[RTC_WEEKDAY] &= ~ALARM_ENABLE_MASK;
364 if (data[RTC_DATE] & 0x1f)
365 data[RTC_DATE] |= ALARM_ENABLE_MASK;
366 if (data[RTC_MONTH] & 0xf)
367 data[RTC_MONTH] |= ALARM_ENABLE_MASK;
368 if (data[RTC_YEAR1] & 0x7f)
369 data[RTC_YEAR1] |= ALARM_ENABLE_MASK;
370
371 ret = regmap_raw_write(info->rtc, SEC_ALARM0_SEC, data, 8);
372 if (ret < 0)
373 return ret;
374 ret = s5m8767_rtc_set_alarm_reg(info);
375
376 break;
377
378 default:
379 return -EINVAL;
380 }
381
382 return ret;
383}
384
385static int s5m_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
386{
387 struct s5m_rtc_info *info = dev_get_drvdata(dev);
388 u8 data[8];
389 int ret;
390
391 switch (info->device_type) {
392 case S5M8763X:
393 s5m8763_tm_to_data(&alrm->time, data);
394 break;
395
396 case S5M8767X:
397 s5m8767_tm_to_data(&alrm->time, data);
398 break;
399
400 default:
401 return -EINVAL;
402 }
403
404 dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
405 1900 + alrm->time.tm_year, 1 + alrm->time.tm_mon,
406 alrm->time.tm_mday, alrm->time.tm_hour, alrm->time.tm_min,
407 alrm->time.tm_sec, alrm->time.tm_wday);
408
409 ret = s5m_rtc_stop_alarm(info);
410 if (ret < 0)
411 return ret;
412
413 ret = regmap_raw_write(info->rtc, SEC_ALARM0_SEC, data, 8);
414 if (ret < 0)
415 return ret;
416
417 ret = s5m8767_rtc_set_alarm_reg(info);
418 if (ret < 0)
419 return ret;
420
421 if (alrm->enabled)
422 ret = s5m_rtc_start_alarm(info);
423
424 return ret;
425}
426
427static int s5m_rtc_alarm_irq_enable(struct device *dev,
428 unsigned int enabled)
429{
430 struct s5m_rtc_info *info = dev_get_drvdata(dev);
431
432 if (enabled)
433 return s5m_rtc_start_alarm(info);
434 else
435 return s5m_rtc_stop_alarm(info);
436}
437
438static irqreturn_t s5m_rtc_alarm_irq(int irq, void *data)
439{
440 struct s5m_rtc_info *info = data;
441
442 rtc_update_irq(info->rtc_dev, 1, RTC_IRQF | RTC_AF);
443
444 return IRQ_HANDLED;
445}
446
447static const struct rtc_class_ops s5m_rtc_ops = {
448 .read_time = s5m_rtc_read_time,
449 .set_time = s5m_rtc_set_time,
450 .read_alarm = s5m_rtc_read_alarm,
451 .set_alarm = s5m_rtc_set_alarm,
452 .alarm_irq_enable = s5m_rtc_alarm_irq_enable,
453};
454
455static void s5m_rtc_enable_wtsr(struct s5m_rtc_info *info, bool enable)
456{
457 int ret;
458 ret = regmap_update_bits(info->rtc, SEC_WTSR_SMPL_CNTL,
459 WTSR_ENABLE_MASK,
460 enable ? WTSR_ENABLE_MASK : 0);
461 if (ret < 0)
462 dev_err(info->dev, "%s: fail to update WTSR reg(%d)\n",
463 __func__, ret);
464}
465
466static void s5m_rtc_enable_smpl(struct s5m_rtc_info *info, bool enable)
467{
468 int ret;
469 ret = regmap_update_bits(info->rtc, SEC_WTSR_SMPL_CNTL,
470 SMPL_ENABLE_MASK,
471 enable ? SMPL_ENABLE_MASK : 0);
472 if (ret < 0)
473 dev_err(info->dev, "%s: fail to update SMPL reg(%d)\n",
474 __func__, ret);
475}
476
477static int s5m8767_rtc_init_reg(struct s5m_rtc_info *info)
478{
479 u8 data[2];
480 unsigned int tp_read;
481 int ret;
482 struct rtc_time tm;
483
484 ret = regmap_read(info->rtc, SEC_RTC_UDR_CON, &tp_read);
485 if (ret < 0) {
486 dev_err(info->dev, "%s: fail to read control reg(%d)\n",
487 __func__, ret);
488 return ret;
489 }
490
491 /* Set RTC control register : Binary mode, 24hour mode */
492 data[0] = (1 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
493 data[1] = (0 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
494
495 info->rtc_24hr_mode = 1;
496 ret = regmap_raw_write(info->rtc, SEC_ALARM0_CONF, data, 2);
497 if (ret < 0) {
498 dev_err(info->dev, "%s: fail to write controlm reg(%d)\n",
499 __func__, ret);
500 return ret;
501 }
502
503 /* In first boot time, Set rtc time to 1/1/2012 00:00:00(SUN) */
504 if ((tp_read & RTC_TCON_MASK) == 0) {
505 dev_dbg(info->dev, "rtc init\n");
506 tm.tm_sec = 0;
507 tm.tm_min = 0;
508 tm.tm_hour = 0;
509 tm.tm_wday = 0;
510 tm.tm_mday = 1;
511 tm.tm_mon = 0;
512 tm.tm_year = 112;
513 tm.tm_yday = 0;
514 tm.tm_isdst = 0;
515 ret = s5m_rtc_set_time(info->dev, &tm);
516 }
517
518 ret = regmap_update_bits(info->rtc, SEC_RTC_UDR_CON,
519 RTC_TCON_MASK, tp_read | RTC_TCON_MASK);
520 if (ret < 0)
521 dev_err(info->dev, "%s: fail to update TCON reg(%d)\n",
522 __func__, ret);
523
524 return ret;
525}
526
527static int s5m_rtc_probe(struct platform_device *pdev)
528{
529 struct sec_pmic_dev *s5m87xx = dev_get_drvdata(pdev->dev.parent);
530 struct sec_platform_data *pdata = s5m87xx->pdata;
531 struct s5m_rtc_info *info;
532 int ret;
533
534 if (!pdata) {
535 dev_err(pdev->dev.parent, "Platform data not supplied\n");
536 return -ENODEV;
537 }
538
539 info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
540 if (!info)
541 return -ENOMEM;
542
543 info->dev = &pdev->dev;
544 info->s5m87xx = s5m87xx;
545 info->rtc = s5m87xx->rtc;
546 info->device_type = s5m87xx->device_type;
547 info->wtsr_smpl = s5m87xx->wtsr_smpl;
548
549 switch (pdata->device_type) {
550 case S5M8763X:
551 info->irq = s5m87xx->irq_base + S5M8763_IRQ_ALARM0;
552 break;
553
554 case S5M8767X:
555 info->irq = s5m87xx->irq_base + S5M8767_IRQ_RTCA1;
556 break;
557
558 default:
559 ret = -EINVAL;
560 dev_err(&pdev->dev, "Unsupported device type: %d\n", ret);
561 return ret;
562 }
563
564 platform_set_drvdata(pdev, info);
565
566 ret = s5m8767_rtc_init_reg(info);
567
568 if (info->wtsr_smpl) {
569 s5m_rtc_enable_wtsr(info, true);
570 s5m_rtc_enable_smpl(info, true);
571 }
572
573 device_init_wakeup(&pdev->dev, 1);
574
575 info->rtc_dev = devm_rtc_device_register(&pdev->dev, "s5m-rtc",
576 &s5m_rtc_ops, THIS_MODULE);
577
578 if (IS_ERR(info->rtc_dev))
579 return PTR_ERR(info->rtc_dev);
580
581 ret = devm_request_threaded_irq(&pdev->dev, info->irq, NULL,
582 s5m_rtc_alarm_irq, 0, "rtc-alarm0",
583 info);
584 if (ret < 0)
585 dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
586 info->irq, ret);
587
588 return ret;
589}
590
591static void s5m_rtc_shutdown(struct platform_device *pdev)
592{
593 struct s5m_rtc_info *info = platform_get_drvdata(pdev);
594 int i;
595 unsigned int val = 0;
596 if (info->wtsr_smpl) {
597 for (i = 0; i < 3; i++) {
598 s5m_rtc_enable_wtsr(info, false);
599 regmap_read(info->rtc, SEC_WTSR_SMPL_CNTL, &val);
600 pr_debug("%s: WTSR_SMPL reg(0x%02x)\n", __func__, val);
601 if (val & WTSR_ENABLE_MASK)
602 pr_emerg("%s: fail to disable WTSR\n",
603 __func__);
604 else {
605 pr_info("%s: success to disable WTSR\n",
606 __func__);
607 break;
608 }
609 }
610 }
611 /* Disable SMPL when power off */
612 s5m_rtc_enable_smpl(info, false);
613}
614
615static const struct platform_device_id s5m_rtc_id[] = {
616 { "s5m-rtc", 0 },
617};
618
619static struct platform_driver s5m_rtc_driver = {
620 .driver = {
621 .name = "s5m-rtc",
622 .owner = THIS_MODULE,
623 },
624 .probe = s5m_rtc_probe,
625 .shutdown = s5m_rtc_shutdown,
626 .id_table = s5m_rtc_id,
627};
628
629module_platform_driver(s5m_rtc_driver);
630
631/* Module information */
632MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
633MODULE_DESCRIPTION("Samsung S5M RTC driver");
634MODULE_LICENSE("GPL");
635MODULE_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-09-11 23:24:48 -0400