aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/rtc
diff options
context:
space:
mode:
authorRussell King <rmk+kernel@arm.linux.org.uk>2010-03-08 15:21:04 -0500
committerRussell King <rmk+kernel@arm.linux.org.uk>2010-03-08 15:21:04 -0500
commit988addf82e4c03739375279de73929580a2d4a6a (patch)
tree989ae1cd4e264bbad80c65f04480486246e7b9f3 /drivers/rtc
parent004c1c7096659d352b83047a7593e91d8a30e3c5 (diff)
parent25cf84cf377c0aae5dbcf937ea89bc7893db5176 (diff)
Merge branch 'origin' into devel-stable
Conflicts: arch/arm/mach-mx2/devices.c arch/arm/mach-mx2/devices.h sound/soc/pxa/pxa-ssp.c
Diffstat (limited to 'drivers/rtc')
-rw-r--r--drivers/rtc/Kconfig20
-rw-r--r--drivers/rtc/Makefile2
-rw-r--r--drivers/rtc/class.c1
-rw-r--r--drivers/rtc/rtc-at91sam9.c2
-rw-r--r--drivers/rtc/rtc-coh901331.c5
-rw-r--r--drivers/rtc/rtc-ep93xx.c71
-rw-r--r--drivers/rtc/rtc-max8925.c314
-rw-r--r--drivers/rtc/rtc-mc13783.c214
-rw-r--r--drivers/rtc/rtc-mpc5121.c387
-rw-r--r--drivers/rtc/rtc-mxc.c7
-rw-r--r--drivers/rtc/rtc-pcf2123.c2
-rw-r--r--drivers/rtc/rtc-pl031.c365
-rw-r--r--drivers/rtc/rtc-twl.c4
-rw-r--r--drivers/rtc/rtc-wm8350.c11
14 files changed, 1288 insertions, 117 deletions
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 8167e9e6827a..6a1303759432 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -175,6 +175,16 @@ config RTC_DRV_MAX6900
175 This driver can also be built as a module. If so, the module 175 This driver can also be built as a module. If so, the module
176 will be called rtc-max6900. 176 will be called rtc-max6900.
177 177
178config RTC_DRV_MAX8925
179 tristate "Maxim MAX8925"
180 depends on MFD_MAX8925
181 help
182 If you say yes here you will get support for the
183 RTC of Maxim MAX8925 PMIC.
184
185 This driver can also be built as a module. If so, the module
186 will be called rtc-max8925.
187
178config RTC_DRV_RS5C372 188config RTC_DRV_RS5C372
179 tristate "Ricoh R2025S/D, RS5C372A/B, RV5C386, RV5C387A" 189 tristate "Ricoh R2025S/D, RS5C372A/B, RV5C386, RV5C387A"
180 help 190 help
@@ -868,4 +878,14 @@ config RTC_DRV_MC13783
868 help 878 help
869 This enables support for the Freescale MC13783 PMIC RTC 879 This enables support for the Freescale MC13783 PMIC RTC
870 880
881config RTC_DRV_MPC5121
882 tristate "Freescale MPC5121 built-in RTC"
883 depends on PPC_MPC512x && RTC_CLASS
884 help
885 If you say yes here you will get support for the
886 built-in RTC MPC5121.
887
888 This driver can also be built as a module. If so, the module
889 will be called rtc-mpc5121.
890
871endif # RTC_CLASS 891endif # RTC_CLASS
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index e5160fddc446..44ef194a9573 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -52,9 +52,11 @@ obj-$(CONFIG_RTC_DRV_M48T59) += rtc-m48t59.o
52obj-$(CONFIG_RTC_DRV_M48T86) += rtc-m48t86.o 52obj-$(CONFIG_RTC_DRV_M48T86) += rtc-m48t86.o
53obj-$(CONFIG_RTC_MXC) += rtc-mxc.o 53obj-$(CONFIG_RTC_MXC) += rtc-mxc.o
54obj-$(CONFIG_RTC_DRV_MAX6900) += rtc-max6900.o 54obj-$(CONFIG_RTC_DRV_MAX6900) += rtc-max6900.o
55obj-$(CONFIG_RTC_DRV_MAX8925) += rtc-max8925.o
55obj-$(CONFIG_RTC_DRV_MAX6902) += rtc-max6902.o 56obj-$(CONFIG_RTC_DRV_MAX6902) += rtc-max6902.o
56obj-$(CONFIG_RTC_DRV_MC13783) += rtc-mc13783.o 57obj-$(CONFIG_RTC_DRV_MC13783) += rtc-mc13783.o
57obj-$(CONFIG_RTC_DRV_MSM6242) += rtc-msm6242.o 58obj-$(CONFIG_RTC_DRV_MSM6242) += rtc-msm6242.o
59obj-$(CONFIG_RTC_DRV_MPC5121) += rtc-mpc5121.o
58obj-$(CONFIG_RTC_DRV_MV) += rtc-mv.o 60obj-$(CONFIG_RTC_DRV_MV) += rtc-mv.o
59obj-$(CONFIG_RTC_DRV_NUC900) += rtc-nuc900.o 61obj-$(CONFIG_RTC_DRV_NUC900) += rtc-nuc900.o
60obj-$(CONFIG_RTC_DRV_OMAP) += rtc-omap.o 62obj-$(CONFIG_RTC_DRV_OMAP) += rtc-omap.o
diff --git a/drivers/rtc/class.c b/drivers/rtc/class.c
index be5a6b73e601..40845c7e9322 100644
--- a/drivers/rtc/class.c
+++ b/drivers/rtc/class.c
@@ -226,6 +226,7 @@ static void __exit rtc_exit(void)
226{ 226{
227 rtc_dev_exit(); 227 rtc_dev_exit();
228 class_destroy(rtc_class); 228 class_destroy(rtc_class);
229 idr_destroy(&rtc_idr);
229} 230}
230 231
231subsys_initcall(rtc_init); 232subsys_initcall(rtc_init);
diff --git a/drivers/rtc/rtc-at91sam9.c b/drivers/rtc/rtc-at91sam9.c
index 86c61f143515..78a018b5c941 100644
--- a/drivers/rtc/rtc-at91sam9.c
+++ b/drivers/rtc/rtc-at91sam9.c
@@ -161,7 +161,7 @@ static int at91_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm)
161 if (offset == 0) 161 if (offset == 0)
162 return -EILSEQ; 162 return -EILSEQ;
163 163
164 memset(alrm, 0, sizeof(alrm)); 164 memset(alrm, 0, sizeof(*alrm));
165 if (alarm != ALARM_DISABLED && offset != 0) { 165 if (alarm != ALARM_DISABLED && offset != 0) {
166 rtc_time_to_tm(offset + alarm, tm); 166 rtc_time_to_tm(offset + alarm, tm);
167 167
diff --git a/drivers/rtc/rtc-coh901331.c b/drivers/rtc/rtc-coh901331.c
index 03ea530981d1..44c4399ee714 100644
--- a/drivers/rtc/rtc-coh901331.c
+++ b/drivers/rtc/rtc-coh901331.c
@@ -271,12 +271,13 @@ static int coh901331_resume(struct platform_device *pdev)
271{ 271{
272 struct coh901331_port *rtap = dev_get_drvdata(&pdev->dev); 272 struct coh901331_port *rtap = dev_get_drvdata(&pdev->dev);
273 273
274 if (device_may_wakeup(&pdev->dev)) 274 if (device_may_wakeup(&pdev->dev)) {
275 disable_irq_wake(rtap->irq); 275 disable_irq_wake(rtap->irq);
276 else 276 } else {
277 clk_enable(rtap->clk); 277 clk_enable(rtap->clk);
278 writel(rtap->irqmaskstore, rtap->virtbase + COH901331_IRQ_MASK); 278 writel(rtap->irqmaskstore, rtap->virtbase + COH901331_IRQ_MASK);
279 clk_disable(rtap->clk); 279 clk_disable(rtap->clk);
280 }
280 return 0; 281 return 0;
281} 282}
282#else 283#else
diff --git a/drivers/rtc/rtc-ep93xx.c b/drivers/rtc/rtc-ep93xx.c
index 9da02d108b73..91bde976bc0f 100644
--- a/drivers/rtc/rtc-ep93xx.c
+++ b/drivers/rtc/rtc-ep93xx.c
@@ -115,6 +115,15 @@ static ssize_t ep93xx_rtc_show_comp_delete(struct device *dev,
115} 115}
116static DEVICE_ATTR(comp_delete, S_IRUGO, ep93xx_rtc_show_comp_delete, NULL); 116static DEVICE_ATTR(comp_delete, S_IRUGO, ep93xx_rtc_show_comp_delete, NULL);
117 117
118static struct attribute *ep93xx_rtc_attrs[] = {
119 &dev_attr_comp_preload.attr,
120 &dev_attr_comp_delete.attr,
121 NULL
122};
123
124static const struct attribute_group ep93xx_rtc_sysfs_files = {
125 .attrs = ep93xx_rtc_attrs,
126};
118 127
119static int __init ep93xx_rtc_probe(struct platform_device *pdev) 128static int __init ep93xx_rtc_probe(struct platform_device *pdev)
120{ 129{
@@ -123,27 +132,22 @@ static int __init ep93xx_rtc_probe(struct platform_device *pdev)
123 struct rtc_device *rtc; 132 struct rtc_device *rtc;
124 int err; 133 int err;
125 134
126 ep93xx_rtc = kzalloc(sizeof(struct ep93xx_rtc), GFP_KERNEL); 135 ep93xx_rtc = devm_kzalloc(&pdev->dev, sizeof(*ep93xx_rtc), GFP_KERNEL);
127 if (ep93xx_rtc == NULL) 136 if (!ep93xx_rtc)
128 return -ENOMEM; 137 return -ENOMEM;
129 138
130 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 139 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
131 if (res == NULL) { 140 if (!res)
132 err = -ENXIO; 141 return -ENXIO;
133 goto fail_free;
134 }
135 142
136 res = request_mem_region(res->start, resource_size(res), pdev->name); 143 if (!devm_request_mem_region(&pdev->dev, res->start,
137 if (res == NULL) { 144 resource_size(res), pdev->name))
138 err = -EBUSY; 145 return -EBUSY;
139 goto fail_free;
140 }
141 146
142 ep93xx_rtc->mmio_base = ioremap(res->start, resource_size(res)); 147 ep93xx_rtc->mmio_base = devm_ioremap(&pdev->dev, res->start,
143 if (ep93xx_rtc->mmio_base == NULL) { 148 resource_size(res));
144 err = -ENXIO; 149 if (!ep93xx_rtc->mmio_base)
145 goto fail; 150 return -ENXIO;
146 }
147 151
148 pdev->dev.platform_data = ep93xx_rtc; 152 pdev->dev.platform_data = ep93xx_rtc;
149 153
@@ -151,53 +155,34 @@ static int __init ep93xx_rtc_probe(struct platform_device *pdev)
151 &pdev->dev, &ep93xx_rtc_ops, THIS_MODULE); 155 &pdev->dev, &ep93xx_rtc_ops, THIS_MODULE);
152 if (IS_ERR(rtc)) { 156 if (IS_ERR(rtc)) {
153 err = PTR_ERR(rtc); 157 err = PTR_ERR(rtc);
154 goto fail; 158 goto exit;
155 } 159 }
156 160
157 platform_set_drvdata(pdev, rtc); 161 platform_set_drvdata(pdev, rtc);
158 162
159 err = device_create_file(&pdev->dev, &dev_attr_comp_preload); 163 err = sysfs_create_group(&pdev->dev.kobj, &ep93xx_rtc_sysfs_files);
160 if (err) 164 if (err)
161 goto fail; 165 goto fail;
162 err = device_create_file(&pdev->dev, &dev_attr_comp_delete);
163 if (err) {
164 device_remove_file(&pdev->dev, &dev_attr_comp_preload);
165 goto fail;
166 }
167 166
168 return 0; 167 return 0;
169 168
170fail: 169fail:
171 if (ep93xx_rtc->mmio_base) { 170 platform_set_drvdata(pdev, NULL);
172 iounmap(ep93xx_rtc->mmio_base); 171 rtc_device_unregister(rtc);
173 pdev->dev.platform_data = NULL; 172exit:
174 } 173 pdev->dev.platform_data = NULL;
175 release_mem_region(res->start, resource_size(res));
176fail_free:
177 kfree(ep93xx_rtc);
178 return err; 174 return err;
179} 175}
180 176
181static int __exit ep93xx_rtc_remove(struct platform_device *pdev) 177static int __exit ep93xx_rtc_remove(struct platform_device *pdev)
182{ 178{
183 struct rtc_device *rtc = platform_get_drvdata(pdev); 179 struct rtc_device *rtc = platform_get_drvdata(pdev);
184 struct ep93xx_rtc *ep93xx_rtc = pdev->dev.platform_data;
185 struct resource *res;
186
187 /* cleanup sysfs */
188 device_remove_file(&pdev->dev, &dev_attr_comp_delete);
189 device_remove_file(&pdev->dev, &dev_attr_comp_preload);
190 180
181 sysfs_remove_group(&pdev->dev.kobj, &ep93xx_rtc_sysfs_files);
182 platform_set_drvdata(pdev, NULL);
191 rtc_device_unregister(rtc); 183 rtc_device_unregister(rtc);
192
193 iounmap(ep93xx_rtc->mmio_base);
194 pdev->dev.platform_data = NULL; 184 pdev->dev.platform_data = NULL;
195 185
196 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
197 release_mem_region(res->start, resource_size(res));
198
199 platform_set_drvdata(pdev, NULL);
200
201 return 0; 186 return 0;
202} 187}
203 188
diff --git a/drivers/rtc/rtc-max8925.c b/drivers/rtc/rtc-max8925.c
new file mode 100644
index 000000000000..acdbb1760187
--- /dev/null
+++ b/drivers/rtc/rtc-max8925.c
@@ -0,0 +1,314 @@
1/*
2 * RTC driver for Maxim MAX8925
3 *
4 * Copyright (C) 2009-2010 Marvell International Ltd.
5 * Haojian Zhuang <haojian.zhuang@marvell.com>
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 version 2 as
9 * published by the Free Software Foundation.
10 */
11
12#include <linux/module.h>
13#include <linux/i2c.h>
14#include <linux/rtc.h>
15#include <linux/platform_device.h>
16#include <linux/mfd/max8925.h>
17
18enum {
19 RTC_SEC = 0,
20 RTC_MIN,
21 RTC_HOUR,
22 RTC_WEEKDAY,
23 RTC_DATE,
24 RTC_MONTH,
25 RTC_YEAR1,
26 RTC_YEAR2,
27};
28
29#define MAX8925_RTC_SEC 0x00
30#define MAX8925_RTC_MIN 0x01
31#define MAX8925_RTC_HOUR 0x02
32#define MAX8925_RTC_WEEKDAY 0x03
33#define MAX8925_RTC_DATE 0x04
34#define MAX8925_RTC_MONTH 0x05
35#define MAX8925_RTC_YEAR1 0x06
36#define MAX8925_RTC_YEAR2 0x07
37#define MAX8925_ALARM0_SEC 0x08
38#define MAX8925_ALARM0_MIN 0x09
39#define MAX8925_ALARM0_HOUR 0x0a
40#define MAX8925_ALARM0_WEEKDAY 0x0b
41#define MAX8925_ALARM0_DATE 0x0c
42#define MAX8925_ALARM0_MON 0x0d
43#define MAX8925_ALARM0_YEAR1 0x0e
44#define MAX8925_ALARM0_YEAR2 0x0f
45#define MAX8925_ALARM1_SEC 0x10
46#define MAX8925_ALARM1_MIN 0x11
47#define MAX8925_ALARM1_HOUR 0x12
48#define MAX8925_ALARM1_WEEKDAY 0x13
49#define MAX8925_ALARM1_DATE 0x14
50#define MAX8925_ALARM1_MON 0x15
51#define MAX8925_ALARM1_YEAR1 0x16
52#define MAX8925_ALARM1_YEAR2 0x17
53#define MAX8925_RTC_CNTL 0x1b
54#define MAX8925_RTC_STATUS 0x20
55
56#define TIME_NUM 8
57#define ALARM_1SEC (1 << 7)
58#define HOUR_12 (1 << 7)
59#define HOUR_AM_PM (1 << 5)
60#define ALARM0_IRQ (1 << 3)
61#define ALARM1_IRQ (1 << 2)
62#define ALARM0_STATUS (1 << 2)
63#define ALARM1_STATUS (1 << 1)
64
65
66struct max8925_rtc_info {
67 struct rtc_device *rtc_dev;
68 struct max8925_chip *chip;
69 struct i2c_client *rtc;
70 struct device *dev;
71};
72
73static irqreturn_t rtc_update_handler(int irq, void *data)
74{
75 struct max8925_rtc_info *info = (struct max8925_rtc_info *)data;
76
77 /* disable ALARM0 except for 1SEC alarm */
78 max8925_set_bits(info->rtc, MAX8925_ALARM0_CNTL, 0x7f, 0);
79 rtc_update_irq(info->rtc_dev, 1, RTC_IRQF | RTC_AF);
80 return IRQ_HANDLED;
81}
82
83static int tm_calc(struct rtc_time *tm, unsigned char *buf, int len)
84{
85 if (len < TIME_NUM)
86 return -EINVAL;
87 tm->tm_year = (buf[RTC_YEAR2] >> 4) * 1000
88 + (buf[RTC_YEAR2] & 0xf) * 100
89 + (buf[RTC_YEAR1] >> 4) * 10
90 + (buf[RTC_YEAR1] & 0xf);
91 tm->tm_year -= 1900;
92 tm->tm_mon = ((buf[RTC_MONTH] >> 4) & 0x01) * 10
93 + (buf[RTC_MONTH] & 0x0f);
94 tm->tm_mday = ((buf[RTC_DATE] >> 4) & 0x03) * 10
95 + (buf[RTC_DATE] & 0x0f);
96 tm->tm_wday = buf[RTC_WEEKDAY] & 0x07;
97 if (buf[RTC_HOUR] & HOUR_12) {
98 tm->tm_hour = ((buf[RTC_HOUR] >> 4) & 0x1) * 10
99 + (buf[RTC_HOUR] & 0x0f);
100 if (buf[RTC_HOUR] & HOUR_AM_PM)
101 tm->tm_hour += 12;
102 } else
103 tm->tm_hour = ((buf[RTC_HOUR] >> 4) & 0x03) * 10
104 + (buf[RTC_HOUR] & 0x0f);
105 tm->tm_min = ((buf[RTC_MIN] >> 4) & 0x7) * 10
106 + (buf[RTC_MIN] & 0x0f);
107 tm->tm_sec = ((buf[RTC_SEC] >> 4) & 0x7) * 10
108 + (buf[RTC_SEC] & 0x0f);
109 return 0;
110}
111
112static int data_calc(unsigned char *buf, struct rtc_time *tm, int len)
113{
114 unsigned char high, low;
115
116 if (len < TIME_NUM)
117 return -EINVAL;
118
119 high = (tm->tm_year + 1900) / 1000;
120 low = (tm->tm_year + 1900) / 100;
121 low = low - high * 10;
122 buf[RTC_YEAR2] = (high << 4) + low;
123 high = (tm->tm_year + 1900) / 10;
124 low = tm->tm_year + 1900;
125 low = low - high * 10;
126 high = high - (high / 10) * 10;
127 buf[RTC_YEAR1] = (high << 4) + low;
128 high = tm->tm_mon / 10;
129 low = tm->tm_mon;
130 low = low - high * 10;
131 buf[RTC_MONTH] = (high << 4) + low;
132 high = tm->tm_mday / 10;
133 low = tm->tm_mday;
134 low = low - high * 10;
135 buf[RTC_DATE] = (high << 4) + low;
136 buf[RTC_WEEKDAY] = tm->tm_wday;
137 high = tm->tm_hour / 10;
138 low = tm->tm_hour;
139 low = low - high * 10;
140 buf[RTC_HOUR] = (high << 4) + low;
141 high = tm->tm_min / 10;
142 low = tm->tm_min;
143 low = low - high * 10;
144 buf[RTC_MIN] = (high << 4) + low;
145 high = tm->tm_sec / 10;
146 low = tm->tm_sec;
147 low = low - high * 10;
148 buf[RTC_SEC] = (high << 4) + low;
149 return 0;
150}
151
152static int max8925_rtc_read_time(struct device *dev, struct rtc_time *tm)
153{
154 struct max8925_rtc_info *info = dev_get_drvdata(dev);
155 unsigned char buf[TIME_NUM];
156 int ret;
157
158 ret = max8925_bulk_read(info->rtc, MAX8925_RTC_SEC, TIME_NUM, buf);
159 if (ret < 0)
160 goto out;
161 ret = tm_calc(tm, buf, TIME_NUM);
162out:
163 return ret;
164}
165
166static int max8925_rtc_set_time(struct device *dev, struct rtc_time *tm)
167{
168 struct max8925_rtc_info *info = dev_get_drvdata(dev);
169 unsigned char buf[TIME_NUM];
170 int ret;
171
172 ret = data_calc(buf, tm, TIME_NUM);
173 if (ret < 0)
174 goto out;
175 ret = max8925_bulk_write(info->rtc, MAX8925_RTC_SEC, TIME_NUM, buf);
176out:
177 return ret;
178}
179
180static int max8925_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
181{
182 struct max8925_rtc_info *info = dev_get_drvdata(dev);
183 unsigned char buf[TIME_NUM];
184 int ret;
185
186 ret = max8925_bulk_read(info->rtc, MAX8925_ALARM0_SEC, TIME_NUM, buf);
187 if (ret < 0)
188 goto out;
189 ret = tm_calc(&alrm->time, buf, TIME_NUM);
190 if (ret < 0)
191 goto out;
192 ret = max8925_reg_read(info->rtc, MAX8925_RTC_IRQ_MASK);
193 if (ret < 0)
194 goto out;
195 if ((ret & ALARM0_IRQ) == 0)
196 alrm->enabled = 1;
197 else
198 alrm->enabled = 0;
199 ret = max8925_reg_read(info->rtc, MAX8925_RTC_STATUS);
200 if (ret < 0)
201 goto out;
202 if (ret & ALARM0_STATUS)
203 alrm->pending = 1;
204 else
205 alrm->pending = 0;
206out:
207 return ret;
208}
209
210static int max8925_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
211{
212 struct max8925_rtc_info *info = dev_get_drvdata(dev);
213 unsigned char buf[TIME_NUM];
214 int ret;
215
216 ret = data_calc(buf, &alrm->time, TIME_NUM);
217 if (ret < 0)
218 goto out;
219 ret = max8925_bulk_write(info->rtc, MAX8925_ALARM0_SEC, TIME_NUM, buf);
220 if (ret < 0)
221 goto out;
222 /* only enable alarm on year/month/day/hour/min/sec */
223 ret = max8925_reg_write(info->rtc, MAX8925_ALARM0_CNTL, 0x77);
224 if (ret < 0)
225 goto out;
226out:
227 return ret;
228}
229
230static const struct rtc_class_ops max8925_rtc_ops = {
231 .read_time = max8925_rtc_read_time,
232 .set_time = max8925_rtc_set_time,
233 .read_alarm = max8925_rtc_read_alarm,
234 .set_alarm = max8925_rtc_set_alarm,
235};
236
237static int __devinit max8925_rtc_probe(struct platform_device *pdev)
238{
239 struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
240 struct max8925_rtc_info *info;
241 int irq, ret;
242
243 info = kzalloc(sizeof(struct max8925_rtc_info), GFP_KERNEL);
244 if (!info)
245 return -ENOMEM;
246 info->chip = chip;
247 info->rtc = chip->rtc;
248 info->dev = &pdev->dev;
249 irq = chip->irq_base + MAX8925_IRQ_RTC_ALARM0;
250
251 ret = request_threaded_irq(irq, NULL, rtc_update_handler,
252 IRQF_ONESHOT, "rtc-alarm0", info);
253 if (ret < 0) {
254 dev_err(chip->dev, "Failed to request IRQ: #%d: %d\n",
255 irq, ret);
256 goto out_irq;
257 }
258
259 info->rtc_dev = rtc_device_register("max8925-rtc", &pdev->dev,
260 &max8925_rtc_ops, THIS_MODULE);
261 ret = PTR_ERR(info->rtc_dev);
262 if (IS_ERR(info->rtc_dev)) {
263 dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
264 goto out_rtc;
265 }
266
267 dev_set_drvdata(&pdev->dev, info);
268 platform_set_drvdata(pdev, info);
269
270 return 0;
271out_rtc:
272 free_irq(chip->irq_base + MAX8925_IRQ_RTC_ALARM0, info);
273out_irq:
274 kfree(info);
275 return ret;
276}
277
278static int __devexit max8925_rtc_remove(struct platform_device *pdev)
279{
280 struct max8925_rtc_info *info = platform_get_drvdata(pdev);
281
282 if (info) {
283 free_irq(info->chip->irq_base + MAX8925_IRQ_RTC_ALARM0, info);
284 rtc_device_unregister(info->rtc_dev);
285 kfree(info);
286 }
287 return 0;
288}
289
290static struct platform_driver max8925_rtc_driver = {
291 .driver = {
292 .name = "max8925-rtc",
293 .owner = THIS_MODULE,
294 },
295 .probe = max8925_rtc_probe,
296 .remove = __devexit_p(max8925_rtc_remove),
297};
298
299static int __init max8925_rtc_init(void)
300{
301 return platform_driver_register(&max8925_rtc_driver);
302}
303module_init(max8925_rtc_init);
304
305static void __exit max8925_rtc_exit(void)
306{
307 platform_driver_unregister(&max8925_rtc_driver);
308}
309module_exit(max8925_rtc_exit);
310
311MODULE_DESCRIPTION("Maxim MAX8925 RTC driver");
312MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
313MODULE_LICENSE("GPL");
314
diff --git a/drivers/rtc/rtc-mc13783.c b/drivers/rtc/rtc-mc13783.c
index 850f983c039c..d60c81b7b693 100644
--- a/drivers/rtc/rtc-mc13783.c
+++ b/drivers/rtc/rtc-mc13783.c
@@ -28,6 +28,34 @@ struct mc13783_rtc {
28 int valid; 28 int valid;
29}; 29};
30 30
31static int mc13783_rtc_irq_enable_unlocked(struct device *dev,
32 unsigned int enabled, int irq)
33{
34 struct mc13783_rtc *priv = dev_get_drvdata(dev);
35 int (*func)(struct mc13783 *mc13783, int irq);
36
37 if (!priv->valid)
38 return -ENODATA;
39
40 func = enabled ? mc13783_irq_unmask : mc13783_irq_mask;
41 return func(priv->mc13783, irq);
42}
43
44static int mc13783_rtc_irq_enable(struct device *dev,
45 unsigned int enabled, int irq)
46{
47 struct mc13783_rtc *priv = dev_get_drvdata(dev);
48 int ret;
49
50 mc13783_lock(priv->mc13783);
51
52 ret = mc13783_rtc_irq_enable_unlocked(dev, enabled, irq);
53
54 mc13783_unlock(priv->mc13783);
55
56 return ret;
57}
58
31static int mc13783_rtc_read_time(struct device *dev, struct rtc_time *tm) 59static int mc13783_rtc_read_time(struct device *dev, struct rtc_time *tm)
32{ 60{
33 struct mc13783_rtc *priv = dev_get_drvdata(dev); 61 struct mc13783_rtc *priv = dev_get_drvdata(dev);
@@ -78,6 +106,7 @@ static int mc13783_rtc_set_mmss(struct device *dev, unsigned long secs)
78{ 106{
79 struct mc13783_rtc *priv = dev_get_drvdata(dev); 107 struct mc13783_rtc *priv = dev_get_drvdata(dev);
80 unsigned int seconds, days; 108 unsigned int seconds, days;
109 unsigned int alarmseconds;
81 int ret; 110 int ret;
82 111
83 seconds = secs % 86400; 112 seconds = secs % 86400;
@@ -86,7 +115,22 @@ static int mc13783_rtc_set_mmss(struct device *dev, unsigned long secs)
86 mc13783_lock(priv->mc13783); 115 mc13783_lock(priv->mc13783);
87 116
88 /* 117 /*
89 * first write seconds=0 to prevent a day switch between writing days 118 * temporarily invalidate alarm to prevent triggering it when the day is
119 * already updated while the time isn't yet.
120 */
121 ret = mc13783_reg_read(priv->mc13783, MC13783_RTCTODA, &alarmseconds);
122 if (unlikely(ret))
123 goto out;
124
125 if (alarmseconds < 86400) {
126 ret = mc13783_reg_write(priv->mc13783,
127 MC13783_RTCTODA, 0x1ffff);
128 if (unlikely(ret))
129 goto out;
130 }
131
132 /*
133 * write seconds=0 to prevent a day switch between writing days
90 * and seconds below 134 * and seconds below
91 */ 135 */
92 ret = mc13783_reg_write(priv->mc13783, MC13783_RTCTOD, 0); 136 ret = mc13783_reg_write(priv->mc13783, MC13783_RTCTOD, 0);
@@ -101,11 +145,19 @@ static int mc13783_rtc_set_mmss(struct device *dev, unsigned long secs)
101 if (unlikely(ret)) 145 if (unlikely(ret))
102 goto out; 146 goto out;
103 147
104 ret = mc13783_ackirq(priv->mc13783, MC13783_IRQ_RTCRST); 148 /* restore alarm */
149 if (alarmseconds < 86400) {
150 ret = mc13783_reg_write(priv->mc13783,
151 MC13783_RTCTODA, alarmseconds);
152 if (unlikely(ret))
153 goto out;
154 }
155
156 ret = mc13783_irq_ack(priv->mc13783, MC13783_IRQ_RTCRST);
105 if (unlikely(ret)) 157 if (unlikely(ret))
106 goto out; 158 goto out;
107 159
108 ret = mc13783_unmask(priv->mc13783, MC13783_IRQ_RTCRST); 160 ret = mc13783_irq_unmask(priv->mc13783, MC13783_IRQ_RTCRST);
109out: 161out:
110 priv->valid = !ret; 162 priv->valid = !ret;
111 163
@@ -114,41 +166,139 @@ out:
114 return ret; 166 return ret;
115} 167}
116 168
117static irqreturn_t mc13783_rtc_update_handler(int irq, void *dev) 169static int mc13783_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
118{ 170{
119 struct mc13783_rtc *priv = dev; 171 struct mc13783_rtc *priv = dev_get_drvdata(dev);
120 struct mc13783 *mc13783 = priv->mc13783; 172 unsigned seconds, days;
173 unsigned long s1970;
174 int enabled, pending;
175 int ret;
121 176
122 dev_dbg(&priv->rtc->dev, "1HZ\n"); 177 mc13783_lock(priv->mc13783);
123 178
124 rtc_update_irq(priv->rtc, 1, RTC_IRQF | RTC_UF); 179 ret = mc13783_reg_read(priv->mc13783, MC13783_RTCTODA, &seconds);
180 if (unlikely(ret))
181 goto out;
182 if (seconds >= 86400) {
183 ret = -ENODATA;
184 goto out;
185 }
186
187 ret = mc13783_reg_read(priv->mc13783, MC13783_RTCDAY, &days);
188 if (unlikely(ret))
189 goto out;
125 190
126 mc13783_ackirq(mc13783, irq); 191 ret = mc13783_irq_status(priv->mc13783, MC13783_IRQ_TODA,
192 &enabled, &pending);
127 193
128 return IRQ_HANDLED; 194out:
195 mc13783_unlock(priv->mc13783);
196
197 if (ret)
198 return ret;
199
200 alarm->enabled = enabled;
201 alarm->pending = pending;
202
203 s1970 = days * 86400 + seconds;
204
205 rtc_time_to_tm(s1970, &alarm->time);
206 dev_dbg(dev, "%s: %lu\n", __func__, s1970);
207
208 return 0;
129} 209}
130 210
131static int mc13783_rtc_update_irq_enable(struct device *dev, 211static int mc13783_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
132 unsigned int enabled)
133{ 212{
134 struct mc13783_rtc *priv = dev_get_drvdata(dev); 213 struct mc13783_rtc *priv = dev_get_drvdata(dev);
135 int ret = -ENODATA; 214 unsigned long s1970;
215 unsigned seconds, days;
216 int ret;
136 217
137 mc13783_lock(priv->mc13783); 218 mc13783_lock(priv->mc13783);
138 if (!priv->valid) 219
220 /* disable alarm to prevent false triggering */
221 ret = mc13783_reg_write(priv->mc13783, MC13783_RTCTODA, 0x1ffff);
222 if (unlikely(ret))
139 goto out; 223 goto out;
140 224
141 ret = (enabled ? mc13783_unmask : mc13783_mask)(priv->mc13783, 225 ret = mc13783_irq_ack(priv->mc13783, MC13783_IRQ_TODA);
142 MC13783_IRQ_1HZ); 226 if (unlikely(ret))
227 goto out;
228
229 ret = rtc_tm_to_time(&alarm->time, &s1970);
230 if (unlikely(ret))
231 goto out;
232
233 dev_dbg(dev, "%s: o%2.s %lu\n", __func__, alarm->enabled ? "n" : "ff",
234 s1970);
235
236 ret = mc13783_rtc_irq_enable_unlocked(dev, alarm->enabled,
237 MC13783_IRQ_TODA);
238 if (unlikely(ret))
239 goto out;
240
241 seconds = s1970 % 86400;
242 days = s1970 / 86400;
243
244 ret = mc13783_reg_write(priv->mc13783, MC13783_RTCDAYA, days);
245 if (unlikely(ret))
246 goto out;
247
248 ret = mc13783_reg_write(priv->mc13783, MC13783_RTCTODA, seconds);
249
143out: 250out:
144 mc13783_unlock(priv->mc13783); 251 mc13783_unlock(priv->mc13783);
145 252
146 return ret; 253 return ret;
147} 254}
148 255
256static irqreturn_t mc13783_rtc_alarm_handler(int irq, void *dev)
257{
258 struct mc13783_rtc *priv = dev;
259 struct mc13783 *mc13783 = priv->mc13783;
260
261 dev_dbg(&priv->rtc->dev, "Alarm\n");
262
263 rtc_update_irq(priv->rtc, 1, RTC_IRQF | RTC_AF);
264
265 mc13783_irq_ack(mc13783, irq);
266
267 return IRQ_HANDLED;
268}
269
270static irqreturn_t mc13783_rtc_update_handler(int irq, void *dev)
271{
272 struct mc13783_rtc *priv = dev;
273 struct mc13783 *mc13783 = priv->mc13783;
274
275 dev_dbg(&priv->rtc->dev, "1HZ\n");
276
277 rtc_update_irq(priv->rtc, 1, RTC_IRQF | RTC_UF);
278
279 mc13783_irq_ack(mc13783, irq);
280
281 return IRQ_HANDLED;
282}
283
284static int mc13783_rtc_update_irq_enable(struct device *dev,
285 unsigned int enabled)
286{
287 return mc13783_rtc_irq_enable(dev, enabled, MC13783_IRQ_1HZ);
288}
289
290static int mc13783_rtc_alarm_irq_enable(struct device *dev,
291 unsigned int enabled)
292{
293 return mc13783_rtc_irq_enable(dev, enabled, MC13783_IRQ_TODA);
294}
295
149static const struct rtc_class_ops mc13783_rtc_ops = { 296static const struct rtc_class_ops mc13783_rtc_ops = {
150 .read_time = mc13783_rtc_read_time, 297 .read_time = mc13783_rtc_read_time,
151 .set_mmss = mc13783_rtc_set_mmss, 298 .set_mmss = mc13783_rtc_set_mmss,
299 .read_alarm = mc13783_rtc_read_alarm,
300 .set_alarm = mc13783_rtc_set_alarm,
301 .alarm_irq_enable = mc13783_rtc_alarm_irq_enable,
152 .update_irq_enable = mc13783_rtc_update_irq_enable, 302 .update_irq_enable = mc13783_rtc_update_irq_enable,
153}; 303};
154 304
@@ -160,7 +310,7 @@ static irqreturn_t mc13783_rtc_reset_handler(int irq, void *dev)
160 dev_dbg(&priv->rtc->dev, "RTCRST\n"); 310 dev_dbg(&priv->rtc->dev, "RTCRST\n");
161 priv->valid = 0; 311 priv->valid = 0;
162 312
163 mc13783_mask(mc13783, irq); 313 mc13783_irq_mask(mc13783, irq);
164 314
165 return IRQ_HANDLED; 315 return IRQ_HANDLED;
166} 316}
@@ -169,6 +319,7 @@ static int __devinit mc13783_rtc_probe(struct platform_device *pdev)
169{ 319{
170 int ret; 320 int ret;
171 struct mc13783_rtc *priv; 321 struct mc13783_rtc *priv;
322 int rtcrst_pending;
172 323
173 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 324 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
174 if (!priv) 325 if (!priv)
@@ -177,8 +328,6 @@ static int __devinit mc13783_rtc_probe(struct platform_device *pdev)
177 priv->mc13783 = dev_get_drvdata(pdev->dev.parent); 328 priv->mc13783 = dev_get_drvdata(pdev->dev.parent);
178 platform_set_drvdata(pdev, priv); 329 platform_set_drvdata(pdev, priv);
179 330
180 priv->valid = 1;
181
182 mc13783_lock(priv->mc13783); 331 mc13783_lock(priv->mc13783);
183 332
184 ret = mc13783_irq_request(priv->mc13783, MC13783_IRQ_RTCRST, 333 ret = mc13783_irq_request(priv->mc13783, MC13783_IRQ_RTCRST,
@@ -186,33 +335,45 @@ static int __devinit mc13783_rtc_probe(struct platform_device *pdev)
186 if (ret) 335 if (ret)
187 goto err_reset_irq_request; 336 goto err_reset_irq_request;
188 337
338 ret = mc13783_irq_status(priv->mc13783, MC13783_IRQ_RTCRST,
339 NULL, &rtcrst_pending);
340 if (ret)
341 goto err_reset_irq_status;
342
343 priv->valid = !rtcrst_pending;
344
189 ret = mc13783_irq_request_nounmask(priv->mc13783, MC13783_IRQ_1HZ, 345 ret = mc13783_irq_request_nounmask(priv->mc13783, MC13783_IRQ_1HZ,
190 mc13783_rtc_update_handler, DRIVER_NAME, priv); 346 mc13783_rtc_update_handler, DRIVER_NAME, priv);
191 if (ret) 347 if (ret)
192 goto err_update_irq_request; 348 goto err_update_irq_request;
193 349
194 mc13783_unlock(priv->mc13783); 350 ret = mc13783_irq_request_nounmask(priv->mc13783, MC13783_IRQ_TODA,
351 mc13783_rtc_alarm_handler, DRIVER_NAME, priv);
352 if (ret)
353 goto err_alarm_irq_request;
195 354
196 priv->rtc = rtc_device_register(pdev->name, 355 priv->rtc = rtc_device_register(pdev->name,
197 &pdev->dev, &mc13783_rtc_ops, THIS_MODULE); 356 &pdev->dev, &mc13783_rtc_ops, THIS_MODULE);
198
199 if (IS_ERR(priv->rtc)) { 357 if (IS_ERR(priv->rtc)) {
200 ret = PTR_ERR(priv->rtc); 358 ret = PTR_ERR(priv->rtc);
201 359
202 mc13783_lock(priv->mc13783); 360 mc13783_irq_free(priv->mc13783, MC13783_IRQ_TODA, priv);
361err_alarm_irq_request:
203 362
204 mc13783_irq_free(priv->mc13783, MC13783_IRQ_1HZ, priv); 363 mc13783_irq_free(priv->mc13783, MC13783_IRQ_1HZ, priv);
205err_update_irq_request: 364err_update_irq_request:
206 365
366err_reset_irq_status:
367
207 mc13783_irq_free(priv->mc13783, MC13783_IRQ_RTCRST, priv); 368 mc13783_irq_free(priv->mc13783, MC13783_IRQ_RTCRST, priv);
208err_reset_irq_request: 369err_reset_irq_request:
209 370
210 mc13783_unlock(priv->mc13783);
211
212 platform_set_drvdata(pdev, NULL); 371 platform_set_drvdata(pdev, NULL);
213 kfree(priv); 372 kfree(priv);
214 } 373 }
215 374
375 mc13783_unlock(priv->mc13783);
376
216 return ret; 377 return ret;
217} 378}
218 379
@@ -220,10 +381,11 @@ static int __devexit mc13783_rtc_remove(struct platform_device *pdev)
220{ 381{
221 struct mc13783_rtc *priv = platform_get_drvdata(pdev); 382 struct mc13783_rtc *priv = platform_get_drvdata(pdev);
222 383
223 rtc_device_unregister(priv->rtc);
224
225 mc13783_lock(priv->mc13783); 384 mc13783_lock(priv->mc13783);
226 385
386 rtc_device_unregister(priv->rtc);
387
388 mc13783_irq_free(priv->mc13783, MC13783_IRQ_TODA, priv);
227 mc13783_irq_free(priv->mc13783, MC13783_IRQ_1HZ, priv); 389 mc13783_irq_free(priv->mc13783, MC13783_IRQ_1HZ, priv);
228 mc13783_irq_free(priv->mc13783, MC13783_IRQ_RTCRST, priv); 390 mc13783_irq_free(priv->mc13783, MC13783_IRQ_RTCRST, priv);
229 391
diff --git a/drivers/rtc/rtc-mpc5121.c b/drivers/rtc/rtc-mpc5121.c
new file mode 100644
index 000000000000..4313ca03a96d
--- /dev/null
+++ b/drivers/rtc/rtc-mpc5121.c
@@ -0,0 +1,387 @@
1/*
2 * Real-time clock driver for MPC5121
3 *
4 * Copyright 2007, Domen Puncer <domen.puncer@telargo.com>
5 * Copyright 2008, Freescale Semiconductor, Inc. All rights reserved.
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 version 2 as
9 * published by the Free Software Foundation.
10 */
11
12#include <linux/init.h>
13#include <linux/module.h>
14#include <linux/rtc.h>
15#include <linux/of_device.h>
16#include <linux/of_platform.h>
17#include <linux/io.h>
18
19struct mpc5121_rtc_regs {
20 u8 set_time; /* RTC + 0x00 */
21 u8 hour_set; /* RTC + 0x01 */
22 u8 minute_set; /* RTC + 0x02 */
23 u8 second_set; /* RTC + 0x03 */
24
25 u8 set_date; /* RTC + 0x04 */
26 u8 month_set; /* RTC + 0x05 */
27 u8 weekday_set; /* RTC + 0x06 */
28 u8 date_set; /* RTC + 0x07 */
29
30 u8 write_sw; /* RTC + 0x08 */
31 u8 sw_set; /* RTC + 0x09 */
32 u16 year_set; /* RTC + 0x0a */
33
34 u8 alm_enable; /* RTC + 0x0c */
35 u8 alm_hour_set; /* RTC + 0x0d */
36 u8 alm_min_set; /* RTC + 0x0e */
37 u8 int_enable; /* RTC + 0x0f */
38
39 u8 reserved1;
40 u8 hour; /* RTC + 0x11 */
41 u8 minute; /* RTC + 0x12 */
42 u8 second; /* RTC + 0x13 */
43
44 u8 month; /* RTC + 0x14 */
45 u8 wday_mday; /* RTC + 0x15 */
46 u16 year; /* RTC + 0x16 */
47
48 u8 int_alm; /* RTC + 0x18 */
49 u8 int_sw; /* RTC + 0x19 */
50 u8 alm_status; /* RTC + 0x1a */
51 u8 sw_minute; /* RTC + 0x1b */
52
53 u8 bus_error_1; /* RTC + 0x1c */
54 u8 int_day; /* RTC + 0x1d */
55 u8 int_min; /* RTC + 0x1e */
56 u8 int_sec; /* RTC + 0x1f */
57
58 /*
59 * target_time:
60 * intended to be used for hibernation but hibernation
61 * does not work on silicon rev 1.5 so use it for non-volatile
62 * storage of offset between the actual_time register and linux
63 * time
64 */
65 u32 target_time; /* RTC + 0x20 */
66 /*
67 * actual_time:
68 * readonly time since VBAT_RTC was last connected
69 */
70 u32 actual_time; /* RTC + 0x24 */
71 u32 keep_alive; /* RTC + 0x28 */
72};
73
74struct mpc5121_rtc_data {
75 unsigned irq;
76 unsigned irq_periodic;
77 struct mpc5121_rtc_regs __iomem *regs;
78 struct rtc_device *rtc;
79 struct rtc_wkalrm wkalarm;
80};
81
82/*
83 * Update second/minute/hour registers.
84 *
85 * This is just so alarm will work.
86 */
87static void mpc5121_rtc_update_smh(struct mpc5121_rtc_regs __iomem *regs,
88 struct rtc_time *tm)
89{
90 out_8(&regs->second_set, tm->tm_sec);
91 out_8(&regs->minute_set, tm->tm_min);
92 out_8(&regs->hour_set, tm->tm_hour);
93
94 /* set time sequence */
95 out_8(&regs->set_time, 0x1);
96 out_8(&regs->set_time, 0x3);
97 out_8(&regs->set_time, 0x1);
98 out_8(&regs->set_time, 0x0);
99}
100
101static int mpc5121_rtc_read_time(struct device *dev, struct rtc_time *tm)
102{
103 struct mpc5121_rtc_data *rtc = dev_get_drvdata(dev);
104 struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
105 unsigned long now;
106
107 /*
108 * linux time is actual_time plus the offset saved in target_time
109 */
110 now = in_be32(&regs->actual_time) + in_be32(&regs->target_time);
111
112 rtc_time_to_tm(now, tm);
113
114 /*
115 * update second minute hour registers
116 * so alarms will work
117 */
118 mpc5121_rtc_update_smh(regs, tm);
119
120 return rtc_valid_tm(tm);
121}
122
123static int mpc5121_rtc_set_time(struct device *dev, struct rtc_time *tm)
124{
125 struct mpc5121_rtc_data *rtc = dev_get_drvdata(dev);
126 struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
127 int ret;
128 unsigned long now;
129
130 /*
131 * The actual_time register is read only so we write the offset
132 * between it and linux time to the target_time register.
133 */
134 ret = rtc_tm_to_time(tm, &now);
135 if (ret == 0)
136 out_be32(&regs->target_time, now - in_be32(&regs->actual_time));
137
138 /*
139 * update second minute hour registers
140 * so alarms will work
141 */
142 mpc5121_rtc_update_smh(regs, tm);
143
144 return 0;
145}
146
147static int mpc5121_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
148{
149 struct mpc5121_rtc_data *rtc = dev_get_drvdata(dev);
150 struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
151
152 *alarm = rtc->wkalarm;
153
154 alarm->pending = in_8(&regs->alm_status);
155
156 return 0;
157}
158
159static int mpc5121_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
160{
161 struct mpc5121_rtc_data *rtc = dev_get_drvdata(dev);
162 struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
163
164 /*
165 * the alarm has no seconds so deal with it
166 */
167 if (alarm->time.tm_sec) {
168 alarm->time.tm_sec = 0;
169 alarm->time.tm_min++;
170 if (alarm->time.tm_min >= 60) {
171 alarm->time.tm_min = 0;
172 alarm->time.tm_hour++;
173 if (alarm->time.tm_hour >= 24)
174 alarm->time.tm_hour = 0;
175 }
176 }
177
178 alarm->time.tm_mday = -1;
179 alarm->time.tm_mon = -1;
180 alarm->time.tm_year = -1;
181
182 out_8(&regs->alm_min_set, alarm->time.tm_min);
183 out_8(&regs->alm_hour_set, alarm->time.tm_hour);
184
185 out_8(&regs->alm_enable, alarm->enabled);
186
187 rtc->wkalarm = *alarm;
188 return 0;
189}
190
191static irqreturn_t mpc5121_rtc_handler(int irq, void *dev)
192{
193 struct mpc5121_rtc_data *rtc = dev_get_drvdata((struct device *)dev);
194 struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
195
196 if (in_8(&regs->int_alm)) {
197 /* acknowledge and clear status */
198 out_8(&regs->int_alm, 1);
199 out_8(&regs->alm_status, 1);
200
201 rtc_update_irq(rtc->rtc, 1, RTC_IRQF | RTC_AF);
202 return IRQ_HANDLED;
203 }
204
205 return IRQ_NONE;
206}
207
208static irqreturn_t mpc5121_rtc_handler_upd(int irq, void *dev)
209{
210 struct mpc5121_rtc_data *rtc = dev_get_drvdata((struct device *)dev);
211 struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
212
213 if (in_8(&regs->int_sec) && (in_8(&regs->int_enable) & 0x1)) {
214 /* acknowledge */
215 out_8(&regs->int_sec, 1);
216
217 rtc_update_irq(rtc->rtc, 1, RTC_IRQF | RTC_UF);
218 return IRQ_HANDLED;
219 }
220
221 return IRQ_NONE;
222}
223
224static int mpc5121_rtc_alarm_irq_enable(struct device *dev,
225 unsigned int enabled)
226{
227 struct mpc5121_rtc_data *rtc = dev_get_drvdata(dev);
228 struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
229 int val;
230
231 if (enabled)
232 val = 1;
233 else
234 val = 0;
235
236 out_8(&regs->alm_enable, val);
237 rtc->wkalarm.enabled = val;
238
239 return 0;
240}
241
242static int mpc5121_rtc_update_irq_enable(struct device *dev,
243 unsigned int enabled)
244{
245 struct mpc5121_rtc_data *rtc = dev_get_drvdata(dev);
246 struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
247 int val;
248
249 val = in_8(&regs->int_enable);
250
251 if (enabled)
252 val = (val & ~0x8) | 0x1;
253 else
254 val &= ~0x1;
255
256 out_8(&regs->int_enable, val);
257
258 return 0;
259}
260
261static const struct rtc_class_ops mpc5121_rtc_ops = {
262 .read_time = mpc5121_rtc_read_time,
263 .set_time = mpc5121_rtc_set_time,
264 .read_alarm = mpc5121_rtc_read_alarm,
265 .set_alarm = mpc5121_rtc_set_alarm,
266 .alarm_irq_enable = mpc5121_rtc_alarm_irq_enable,
267 .update_irq_enable = mpc5121_rtc_update_irq_enable,
268};
269
270static int __devinit mpc5121_rtc_probe(struct of_device *op,
271 const struct of_device_id *match)
272{
273 struct mpc5121_rtc_data *rtc;
274 int err = 0;
275 u32 ka;
276
277 rtc = kzalloc(sizeof(*rtc), GFP_KERNEL);
278 if (!rtc)
279 return -ENOMEM;
280
281 rtc->regs = of_iomap(op->node, 0);
282 if (!rtc->regs) {
283 dev_err(&op->dev, "%s: couldn't map io space\n", __func__);
284 err = -ENOSYS;
285 goto out_free;
286 }
287
288 device_init_wakeup(&op->dev, 1);
289
290 dev_set_drvdata(&op->dev, rtc);
291
292 rtc->irq = irq_of_parse_and_map(op->node, 1);
293 err = request_irq(rtc->irq, mpc5121_rtc_handler, IRQF_DISABLED,
294 "mpc5121-rtc", &op->dev);
295 if (err) {
296 dev_err(&op->dev, "%s: could not request irq: %i\n",
297 __func__, rtc->irq);
298 goto out_dispose;
299 }
300
301 rtc->irq_periodic = irq_of_parse_and_map(op->node, 0);
302 err = request_irq(rtc->irq_periodic, mpc5121_rtc_handler_upd,
303 IRQF_DISABLED, "mpc5121-rtc_upd", &op->dev);
304 if (err) {
305 dev_err(&op->dev, "%s: could not request irq: %i\n",
306 __func__, rtc->irq_periodic);
307 goto out_dispose2;
308 }
309
310 ka = in_be32(&rtc->regs->keep_alive);
311 if (ka & 0x02) {
312 dev_warn(&op->dev,
313 "mpc5121-rtc: Battery or oscillator failure!\n");
314 out_be32(&rtc->regs->keep_alive, ka);
315 }
316
317 rtc->rtc = rtc_device_register("mpc5121-rtc", &op->dev,
318 &mpc5121_rtc_ops, THIS_MODULE);
319 if (IS_ERR(rtc->rtc)) {
320 err = PTR_ERR(rtc->rtc);
321 goto out_free_irq;
322 }
323
324 return 0;
325
326out_free_irq:
327 free_irq(rtc->irq_periodic, &op->dev);
328out_dispose2:
329 irq_dispose_mapping(rtc->irq_periodic);
330 free_irq(rtc->irq, &op->dev);
331out_dispose:
332 irq_dispose_mapping(rtc->irq);
333 iounmap(rtc->regs);
334out_free:
335 kfree(rtc);
336
337 return err;
338}
339
340static int __devexit mpc5121_rtc_remove(struct of_device *op)
341{
342 struct mpc5121_rtc_data *rtc = dev_get_drvdata(&op->dev);
343 struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
344
345 /* disable interrupt, so there are no nasty surprises */
346 out_8(&regs->alm_enable, 0);
347 out_8(&regs->int_enable, in_8(&regs->int_enable) & ~0x1);
348
349 rtc_device_unregister(rtc->rtc);
350 iounmap(rtc->regs);
351 free_irq(rtc->irq, &op->dev);
352 free_irq(rtc->irq_periodic, &op->dev);
353 irq_dispose_mapping(rtc->irq);
354 irq_dispose_mapping(rtc->irq_periodic);
355 dev_set_drvdata(&op->dev, NULL);
356 kfree(rtc);
357
358 return 0;
359}
360
361static struct of_device_id mpc5121_rtc_match[] __devinitdata = {
362 { .compatible = "fsl,mpc5121-rtc", },
363 {},
364};
365
366static struct of_platform_driver mpc5121_rtc_driver = {
367 .owner = THIS_MODULE,
368 .name = "mpc5121-rtc",
369 .match_table = mpc5121_rtc_match,
370 .probe = mpc5121_rtc_probe,
371 .remove = __devexit_p(mpc5121_rtc_remove),
372};
373
374static int __init mpc5121_rtc_init(void)
375{
376 return of_register_platform_driver(&mpc5121_rtc_driver);
377}
378module_init(mpc5121_rtc_init);
379
380static void __exit mpc5121_rtc_exit(void)
381{
382 of_unregister_platform_driver(&mpc5121_rtc_driver);
383}
384module_exit(mpc5121_rtc_exit);
385
386MODULE_LICENSE("GPL");
387MODULE_AUTHOR("John Rigby <jcrigby@gmail.com>");
diff --git a/drivers/rtc/rtc-mxc.c b/drivers/rtc/rtc-mxc.c
index 6bd5072d4eb7..8710f9415d98 100644
--- a/drivers/rtc/rtc-mxc.c
+++ b/drivers/rtc/rtc-mxc.c
@@ -396,8 +396,11 @@ static int __init mxc_rtc_probe(struct platform_device *pdev)
396 pdata->ioaddr = ioremap(res->start, resource_size(res)); 396 pdata->ioaddr = ioremap(res->start, resource_size(res));
397 397
398 clk = clk_get(&pdev->dev, "ckil"); 398 clk = clk_get(&pdev->dev, "ckil");
399 if (IS_ERR(clk)) 399 if (IS_ERR(clk)) {
400 return PTR_ERR(clk); 400 iounmap(pdata->ioaddr);
401 ret = PTR_ERR(clk);
402 goto exit_free_pdata;
403 }
401 404
402 rate = clk_get_rate(clk); 405 rate = clk_get_rate(clk);
403 clk_put(clk); 406 clk_put(clk);
diff --git a/drivers/rtc/rtc-pcf2123.c b/drivers/rtc/rtc-pcf2123.c
index e75df9d50e27..2ceb365533b2 100644
--- a/drivers/rtc/rtc-pcf2123.c
+++ b/drivers/rtc/rtc-pcf2123.c
@@ -315,7 +315,7 @@ kfree_exit:
315 return ret; 315 return ret;
316} 316}
317 317
318static int pcf2123_remove(struct spi_device *spi) 318static int __devexit pcf2123_remove(struct spi_device *spi)
319{ 319{
320 struct pcf2123_plat_data *pdata = spi->dev.platform_data; 320 struct pcf2123_plat_data *pdata = spi->dev.platform_data;
321 int i; 321 int i;
diff --git a/drivers/rtc/rtc-pl031.c b/drivers/rtc/rtc-pl031.c
index 0264b117893b..c256aacfa954 100644
--- a/drivers/rtc/rtc-pl031.c
+++ b/drivers/rtc/rtc-pl031.c
@@ -7,6 +7,9 @@
7 * 7 *
8 * Copyright 2006 (c) MontaVista Software, Inc. 8 * Copyright 2006 (c) MontaVista Software, Inc.
9 * 9 *
10 * Author: Mian Yousaf Kaukab <mian.yousaf.kaukab@stericsson.com>
11 * Copyright 2010 (c) ST-Ericsson AB
12 *
10 * This program is free software; you can redistribute it and/or 13 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License 14 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version 15 * as published by the Free Software Foundation; either version
@@ -18,6 +21,9 @@
18#include <linux/interrupt.h> 21#include <linux/interrupt.h>
19#include <linux/amba/bus.h> 22#include <linux/amba/bus.h>
20#include <linux/io.h> 23#include <linux/io.h>
24#include <linux/bcd.h>
25#include <linux/delay.h>
26#include <linux/version.h>
21 27
22/* 28/*
23 * Register definitions 29 * Register definitions
@@ -30,35 +36,207 @@
30#define RTC_RIS 0x14 /* Raw interrupt status register */ 36#define RTC_RIS 0x14 /* Raw interrupt status register */
31#define RTC_MIS 0x18 /* Masked interrupt status register */ 37#define RTC_MIS 0x18 /* Masked interrupt status register */
32#define RTC_ICR 0x1c /* Interrupt clear register */ 38#define RTC_ICR 0x1c /* Interrupt clear register */
39/* ST variants have additional timer functionality */
40#define RTC_TDR 0x20 /* Timer data read register */
41#define RTC_TLR 0x24 /* Timer data load register */
42#define RTC_TCR 0x28 /* Timer control register */
43#define RTC_YDR 0x30 /* Year data read register */
44#define RTC_YMR 0x34 /* Year match register */
45#define RTC_YLR 0x38 /* Year data load register */
46
47#define RTC_CR_CWEN (1 << 26) /* Clockwatch enable bit */
48
49#define RTC_TCR_EN (1 << 1) /* Periodic timer enable bit */
50
51/* Common bit definitions for Interrupt status and control registers */
52#define RTC_BIT_AI (1 << 0) /* Alarm interrupt bit */
53#define RTC_BIT_PI (1 << 1) /* Periodic interrupt bit. ST variants only. */
54
55/* Common bit definations for ST v2 for reading/writing time */
56#define RTC_SEC_SHIFT 0
57#define RTC_SEC_MASK (0x3F << RTC_SEC_SHIFT) /* Second [0-59] */
58#define RTC_MIN_SHIFT 6
59#define RTC_MIN_MASK (0x3F << RTC_MIN_SHIFT) /* Minute [0-59] */
60#define RTC_HOUR_SHIFT 12
61#define RTC_HOUR_MASK (0x1F << RTC_HOUR_SHIFT) /* Hour [0-23] */
62#define RTC_WDAY_SHIFT 17
63#define RTC_WDAY_MASK (0x7 << RTC_WDAY_SHIFT) /* Day of Week [1-7] 1=Sunday */
64#define RTC_MDAY_SHIFT 20
65#define RTC_MDAY_MASK (0x1F << RTC_MDAY_SHIFT) /* Day of Month [1-31] */
66#define RTC_MON_SHIFT 25
67#define RTC_MON_MASK (0xF << RTC_MON_SHIFT) /* Month [1-12] 1=January */
68
69#define RTC_TIMER_FREQ 32768
33 70
34struct pl031_local { 71struct pl031_local {
35 struct rtc_device *rtc; 72 struct rtc_device *rtc;
36 void __iomem *base; 73 void __iomem *base;
74 u8 hw_designer;
75 u8 hw_revision:4;
37}; 76};
38 77
39static irqreturn_t pl031_interrupt(int irq, void *dev_id) 78static int pl031_alarm_irq_enable(struct device *dev,
79 unsigned int enabled)
80{
81 struct pl031_local *ldata = dev_get_drvdata(dev);
82 unsigned long imsc;
83
84 /* Clear any pending alarm interrupts. */
85 writel(RTC_BIT_AI, ldata->base + RTC_ICR);
86
87 imsc = readl(ldata->base + RTC_IMSC);
88
89 if (enabled == 1)
90 writel(imsc | RTC_BIT_AI, ldata->base + RTC_IMSC);
91 else
92 writel(imsc & ~RTC_BIT_AI, ldata->base + RTC_IMSC);
93
94 return 0;
95}
96
97/*
98 * Convert Gregorian date to ST v2 RTC format.
99 */
100static int pl031_stv2_tm_to_time(struct device *dev,
101 struct rtc_time *tm, unsigned long *st_time,
102 unsigned long *bcd_year)
103{
104 int year = tm->tm_year + 1900;
105 int wday = tm->tm_wday;
106
107 /* wday masking is not working in hardware so wday must be valid */
108 if (wday < -1 || wday > 6) {
109 dev_err(dev, "invalid wday value %d\n", tm->tm_wday);
110 return -EINVAL;
111 } else if (wday == -1) {
112 /* wday is not provided, calculate it here */
113 unsigned long time;
114 struct rtc_time calc_tm;
115
116 rtc_tm_to_time(tm, &time);
117 rtc_time_to_tm(time, &calc_tm);
118 wday = calc_tm.tm_wday;
119 }
120
121 *bcd_year = (bin2bcd(year % 100) | bin2bcd(year / 100) << 8);
122
123 *st_time = ((tm->tm_mon + 1) << RTC_MON_SHIFT)
124 | (tm->tm_mday << RTC_MDAY_SHIFT)
125 | ((wday + 1) << RTC_WDAY_SHIFT)
126 | (tm->tm_hour << RTC_HOUR_SHIFT)
127 | (tm->tm_min << RTC_MIN_SHIFT)
128 | (tm->tm_sec << RTC_SEC_SHIFT);
129
130 return 0;
131}
132
133/*
134 * Convert ST v2 RTC format to Gregorian date.
135 */
136static int pl031_stv2_time_to_tm(unsigned long st_time, unsigned long bcd_year,
137 struct rtc_time *tm)
138{
139 tm->tm_year = bcd2bin(bcd_year) + (bcd2bin(bcd_year >> 8) * 100);
140 tm->tm_mon = ((st_time & RTC_MON_MASK) >> RTC_MON_SHIFT) - 1;
141 tm->tm_mday = ((st_time & RTC_MDAY_MASK) >> RTC_MDAY_SHIFT);
142 tm->tm_wday = ((st_time & RTC_WDAY_MASK) >> RTC_WDAY_SHIFT) - 1;
143 tm->tm_hour = ((st_time & RTC_HOUR_MASK) >> RTC_HOUR_SHIFT);
144 tm->tm_min = ((st_time & RTC_MIN_MASK) >> RTC_MIN_SHIFT);
145 tm->tm_sec = ((st_time & RTC_SEC_MASK) >> RTC_SEC_SHIFT);
146
147 tm->tm_yday = rtc_year_days(tm->tm_mday, tm->tm_mon, tm->tm_year);
148 tm->tm_year -= 1900;
149
150 return 0;
151}
152
153static int pl031_stv2_read_time(struct device *dev, struct rtc_time *tm)
154{
155 struct pl031_local *ldata = dev_get_drvdata(dev);
156
157 pl031_stv2_time_to_tm(readl(ldata->base + RTC_DR),
158 readl(ldata->base + RTC_YDR), tm);
159
160 return 0;
161}
162
163static int pl031_stv2_set_time(struct device *dev, struct rtc_time *tm)
164{
165 unsigned long time;
166 unsigned long bcd_year;
167 struct pl031_local *ldata = dev_get_drvdata(dev);
168 int ret;
169
170 ret = pl031_stv2_tm_to_time(dev, tm, &time, &bcd_year);
171 if (ret == 0) {
172 writel(bcd_year, ldata->base + RTC_YLR);
173 writel(time, ldata->base + RTC_LR);
174 }
175
176 return ret;
177}
178
179static int pl031_stv2_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
40{ 180{
41 struct rtc_device *rtc = dev_id; 181 struct pl031_local *ldata = dev_get_drvdata(dev);
182 int ret;
42 183
43 rtc_update_irq(rtc, 1, RTC_AF); 184 ret = pl031_stv2_time_to_tm(readl(ldata->base + RTC_MR),
185 readl(ldata->base + RTC_YMR), &alarm->time);
44 186
45 return IRQ_HANDLED; 187 alarm->pending = readl(ldata->base + RTC_RIS) & RTC_BIT_AI;
188 alarm->enabled = readl(ldata->base + RTC_IMSC) & RTC_BIT_AI;
189
190 return ret;
46} 191}
47 192
48static int pl031_ioctl(struct device *dev, unsigned int cmd, unsigned long arg) 193static int pl031_stv2_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
49{ 194{
50 struct pl031_local *ldata = dev_get_drvdata(dev); 195 struct pl031_local *ldata = dev_get_drvdata(dev);
196 unsigned long time;
197 unsigned long bcd_year;
198 int ret;
199
200 /* At the moment, we can only deal with non-wildcarded alarm times. */
201 ret = rtc_valid_tm(&alarm->time);
202 if (ret == 0) {
203 ret = pl031_stv2_tm_to_time(dev, &alarm->time,
204 &time, &bcd_year);
205 if (ret == 0) {
206 writel(bcd_year, ldata->base + RTC_YMR);
207 writel(time, ldata->base + RTC_MR);
208
209 pl031_alarm_irq_enable(dev, alarm->enabled);
210 }
211 }
212
213 return ret;
214}
215
216static irqreturn_t pl031_interrupt(int irq, void *dev_id)
217{
218 struct pl031_local *ldata = dev_id;
219 unsigned long rtcmis;
220 unsigned long events = 0;
221
222 rtcmis = readl(ldata->base + RTC_MIS);
223 if (rtcmis) {
224 writel(rtcmis, ldata->base + RTC_ICR);
225
226 if (rtcmis & RTC_BIT_AI)
227 events |= (RTC_AF | RTC_IRQF);
228
229 /* Timer interrupt is only available in ST variants */
230 if ((rtcmis & RTC_BIT_PI) &&
231 (ldata->hw_designer == AMBA_VENDOR_ST))
232 events |= (RTC_PF | RTC_IRQF);
233
234 rtc_update_irq(ldata->rtc, 1, events);
51 235
52 switch (cmd) { 236 return IRQ_HANDLED;
53 case RTC_AIE_OFF:
54 writel(1, ldata->base + RTC_MIS);
55 return 0;
56 case RTC_AIE_ON:
57 writel(0, ldata->base + RTC_MIS);
58 return 0;
59 } 237 }
60 238
61 return -ENOIOCTLCMD; 239 return IRQ_NONE;
62} 240}
63 241
64static int pl031_read_time(struct device *dev, struct rtc_time *tm) 242static int pl031_read_time(struct device *dev, struct rtc_time *tm)
@@ -74,11 +252,14 @@ static int pl031_set_time(struct device *dev, struct rtc_time *tm)
74{ 252{
75 unsigned long time; 253 unsigned long time;
76 struct pl031_local *ldata = dev_get_drvdata(dev); 254 struct pl031_local *ldata = dev_get_drvdata(dev);
255 int ret;
77 256
78 rtc_tm_to_time(tm, &time); 257 ret = rtc_tm_to_time(tm, &time);
79 writel(time, ldata->base + RTC_LR);
80 258
81 return 0; 259 if (ret == 0)
260 writel(time, ldata->base + RTC_LR);
261
262 return ret;
82} 263}
83 264
84static int pl031_read_alarm(struct device *dev, struct rtc_wkalrm *alarm) 265static int pl031_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
@@ -86,8 +267,9 @@ static int pl031_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
86 struct pl031_local *ldata = dev_get_drvdata(dev); 267 struct pl031_local *ldata = dev_get_drvdata(dev);
87 268
88 rtc_time_to_tm(readl(ldata->base + RTC_MR), &alarm->time); 269 rtc_time_to_tm(readl(ldata->base + RTC_MR), &alarm->time);
89 alarm->pending = readl(ldata->base + RTC_RIS); 270
90 alarm->enabled = readl(ldata->base + RTC_IMSC); 271 alarm->pending = readl(ldata->base + RTC_RIS) & RTC_BIT_AI;
272 alarm->enabled = readl(ldata->base + RTC_IMSC) & RTC_BIT_AI;
91 273
92 return 0; 274 return 0;
93} 275}
@@ -96,22 +278,71 @@ static int pl031_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
96{ 278{
97 struct pl031_local *ldata = dev_get_drvdata(dev); 279 struct pl031_local *ldata = dev_get_drvdata(dev);
98 unsigned long time; 280 unsigned long time;
281 int ret;
282
283 /* At the moment, we can only deal with non-wildcarded alarm times. */
284 ret = rtc_valid_tm(&alarm->time);
285 if (ret == 0) {
286 ret = rtc_tm_to_time(&alarm->time, &time);
287 if (ret == 0) {
288 writel(time, ldata->base + RTC_MR);
289 pl031_alarm_irq_enable(dev, alarm->enabled);
290 }
291 }
292
293 return ret;
294}
295
296/* Periodic interrupt is only available in ST variants. */
297static int pl031_irq_set_state(struct device *dev, int enabled)
298{
299 struct pl031_local *ldata = dev_get_drvdata(dev);
300
301 if (enabled == 1) {
302 /* Clear any pending timer interrupt. */
303 writel(RTC_BIT_PI, ldata->base + RTC_ICR);
304
305 writel(readl(ldata->base + RTC_IMSC) | RTC_BIT_PI,
306 ldata->base + RTC_IMSC);
99 307
100 rtc_tm_to_time(&alarm->time, &time); 308 /* Now start the timer */
309 writel(readl(ldata->base + RTC_TCR) | RTC_TCR_EN,
310 ldata->base + RTC_TCR);
101 311
102 writel(time, ldata->base + RTC_MR); 312 } else {
103 writel(!alarm->enabled, ldata->base + RTC_MIS); 313 writel(readl(ldata->base + RTC_IMSC) & (~RTC_BIT_PI),
314 ldata->base + RTC_IMSC);
315
316 /* Also stop the timer */
317 writel(readl(ldata->base + RTC_TCR) & (~RTC_TCR_EN),
318 ldata->base + RTC_TCR);
319 }
320 /* Wait at least 1 RTC32 clock cycle to ensure next access
321 * to RTC_TCR will succeed.
322 */
323 udelay(40);
104 324
105 return 0; 325 return 0;
106} 326}
107 327
108static const struct rtc_class_ops pl031_ops = { 328static int pl031_irq_set_freq(struct device *dev, int freq)
109 .ioctl = pl031_ioctl, 329{
110 .read_time = pl031_read_time, 330 struct pl031_local *ldata = dev_get_drvdata(dev);
111 .set_time = pl031_set_time, 331
112 .read_alarm = pl031_read_alarm, 332 /* Cant set timer if it is already enabled */
113 .set_alarm = pl031_set_alarm, 333 if (readl(ldata->base + RTC_TCR) & RTC_TCR_EN) {
114}; 334 dev_err(dev, "can't change frequency while timer enabled\n");
335 return -EINVAL;
336 }
337
338 /* If self start bit in RTC_TCR is set timer will start here,
339 * but we never set that bit. Instead we start the timer when
340 * set_state is called with enabled == 1.
341 */
342 writel(RTC_TIMER_FREQ / freq, ldata->base + RTC_TLR);
343
344 return 0;
345}
115 346
116static int pl031_remove(struct amba_device *adev) 347static int pl031_remove(struct amba_device *adev)
117{ 348{
@@ -131,18 +362,20 @@ static int pl031_probe(struct amba_device *adev, struct amba_id *id)
131{ 362{
132 int ret; 363 int ret;
133 struct pl031_local *ldata; 364 struct pl031_local *ldata;
365 struct rtc_class_ops *ops = id->data;
134 366
135 ret = amba_request_regions(adev, NULL); 367 ret = amba_request_regions(adev, NULL);
136 if (ret) 368 if (ret)
137 goto err_req; 369 goto err_req;
138 370
139 ldata = kmalloc(sizeof(struct pl031_local), GFP_KERNEL); 371 ldata = kzalloc(sizeof(struct pl031_local), GFP_KERNEL);
140 if (!ldata) { 372 if (!ldata) {
141 ret = -ENOMEM; 373 ret = -ENOMEM;
142 goto out; 374 goto out;
143 } 375 }
144 376
145 ldata->base = ioremap(adev->res.start, resource_size(&adev->res)); 377 ldata->base = ioremap(adev->res.start, resource_size(&adev->res));
378
146 if (!ldata->base) { 379 if (!ldata->base) {
147 ret = -ENOMEM; 380 ret = -ENOMEM;
148 goto out_no_remap; 381 goto out_no_remap;
@@ -150,24 +383,36 @@ static int pl031_probe(struct amba_device *adev, struct amba_id *id)
150 383
151 amba_set_drvdata(adev, ldata); 384 amba_set_drvdata(adev, ldata);
152 385
153 if (request_irq(adev->irq[0], pl031_interrupt, IRQF_DISABLED, 386 ldata->hw_designer = amba_manf(adev);
154 "rtc-pl031", ldata->rtc)) { 387 ldata->hw_revision = amba_rev(adev);
155 ret = -EIO; 388
156 goto out_no_irq; 389 dev_dbg(&adev->dev, "designer ID = 0x%02x\n", ldata->hw_designer);
157 } 390 dev_dbg(&adev->dev, "revision = 0x%01x\n", ldata->hw_revision);
158 391
159 ldata->rtc = rtc_device_register("pl031", &adev->dev, &pl031_ops, 392 /* Enable the clockwatch on ST Variants */
160 THIS_MODULE); 393 if ((ldata->hw_designer == AMBA_VENDOR_ST) &&
394 (ldata->hw_revision > 1))
395 writel(readl(ldata->base + RTC_CR) | RTC_CR_CWEN,
396 ldata->base + RTC_CR);
397
398 ldata->rtc = rtc_device_register("pl031", &adev->dev, ops,
399 THIS_MODULE);
161 if (IS_ERR(ldata->rtc)) { 400 if (IS_ERR(ldata->rtc)) {
162 ret = PTR_ERR(ldata->rtc); 401 ret = PTR_ERR(ldata->rtc);
163 goto out_no_rtc; 402 goto out_no_rtc;
164 } 403 }
165 404
405 if (request_irq(adev->irq[0], pl031_interrupt,
406 IRQF_DISABLED | IRQF_SHARED, "rtc-pl031", ldata)) {
407 ret = -EIO;
408 goto out_no_irq;
409 }
410
166 return 0; 411 return 0;
167 412
168out_no_rtc:
169 free_irq(adev->irq[0], ldata->rtc);
170out_no_irq: 413out_no_irq:
414 rtc_device_unregister(ldata->rtc);
415out_no_rtc:
171 iounmap(ldata->base); 416 iounmap(ldata->base);
172 amba_set_drvdata(adev, NULL); 417 amba_set_drvdata(adev, NULL);
173out_no_remap: 418out_no_remap:
@@ -175,13 +420,57 @@ out_no_remap:
175out: 420out:
176 amba_release_regions(adev); 421 amba_release_regions(adev);
177err_req: 422err_req:
423
178 return ret; 424 return ret;
179} 425}
180 426
427/* Operations for the original ARM version */
428static struct rtc_class_ops arm_pl031_ops = {
429 .read_time = pl031_read_time,
430 .set_time = pl031_set_time,
431 .read_alarm = pl031_read_alarm,
432 .set_alarm = pl031_set_alarm,
433 .alarm_irq_enable = pl031_alarm_irq_enable,
434};
435
436/* The First ST derivative */
437static struct rtc_class_ops stv1_pl031_ops = {
438 .read_time = pl031_read_time,
439 .set_time = pl031_set_time,
440 .read_alarm = pl031_read_alarm,
441 .set_alarm = pl031_set_alarm,
442 .alarm_irq_enable = pl031_alarm_irq_enable,
443 .irq_set_state = pl031_irq_set_state,
444 .irq_set_freq = pl031_irq_set_freq,
445};
446
447/* And the second ST derivative */
448static struct rtc_class_ops stv2_pl031_ops = {
449 .read_time = pl031_stv2_read_time,
450 .set_time = pl031_stv2_set_time,
451 .read_alarm = pl031_stv2_read_alarm,
452 .set_alarm = pl031_stv2_set_alarm,
453 .alarm_irq_enable = pl031_alarm_irq_enable,
454 .irq_set_state = pl031_irq_set_state,
455 .irq_set_freq = pl031_irq_set_freq,
456};
457
181static struct amba_id pl031_ids[] __initdata = { 458static struct amba_id pl031_ids[] __initdata = {
182 { 459 {
183 .id = 0x00041031, 460 .id = 0x00041031,
184 .mask = 0x000fffff, 461 .mask = 0x000fffff,
462 .data = &arm_pl031_ops,
463 },
464 /* ST Micro variants */
465 {
466 .id = 0x00180031,
467 .mask = 0x00ffffff,
468 .data = &stv1_pl031_ops,
469 },
470 {
471 .id = 0x00280031,
472 .mask = 0x00ffffff,
473 .data = &stv2_pl031_ops,
185 }, 474 },
186 {0, 0}, 475 {0, 0},
187}; 476};
diff --git a/drivers/rtc/rtc-twl.c b/drivers/rtc/rtc-twl.c
index c6a83a2a722c..ed1b86828124 100644
--- a/drivers/rtc/rtc-twl.c
+++ b/drivers/rtc/rtc-twl.c
@@ -57,7 +57,7 @@ enum {
57 REG_RTC_COMP_LSB_REG, 57 REG_RTC_COMP_LSB_REG,
58 REG_RTC_COMP_MSB_REG, 58 REG_RTC_COMP_MSB_REG,
59}; 59};
60const static u8 twl4030_rtc_reg_map[] = { 60static const u8 twl4030_rtc_reg_map[] = {
61 [REG_SECONDS_REG] = 0x00, 61 [REG_SECONDS_REG] = 0x00,
62 [REG_MINUTES_REG] = 0x01, 62 [REG_MINUTES_REG] = 0x01,
63 [REG_HOURS_REG] = 0x02, 63 [REG_HOURS_REG] = 0x02,
@@ -80,7 +80,7 @@ const static u8 twl4030_rtc_reg_map[] = {
80 [REG_RTC_COMP_LSB_REG] = 0x10, 80 [REG_RTC_COMP_LSB_REG] = 0x10,
81 [REG_RTC_COMP_MSB_REG] = 0x11, 81 [REG_RTC_COMP_MSB_REG] = 0x11,
82}; 82};
83const static u8 twl6030_rtc_reg_map[] = { 83static const u8 twl6030_rtc_reg_map[] = {
84 [REG_SECONDS_REG] = 0x00, 84 [REG_SECONDS_REG] = 0x00,
85 [REG_MINUTES_REG] = 0x01, 85 [REG_MINUTES_REG] = 0x01,
86 [REG_HOURS_REG] = 0x02, 86 [REG_HOURS_REG] = 0x02,
diff --git a/drivers/rtc/rtc-wm8350.c b/drivers/rtc/rtc-wm8350.c
index f1e440521c54..3d0dc76b38af 100644
--- a/drivers/rtc/rtc-wm8350.c
+++ b/drivers/rtc/rtc-wm8350.c
@@ -307,11 +307,18 @@ static int wm8350_rtc_update_irq_enable(struct device *dev,
307{ 307{
308 struct wm8350 *wm8350 = dev_get_drvdata(dev); 308 struct wm8350 *wm8350 = dev_get_drvdata(dev);
309 309
310 /* Suppress duplicate changes since genirq nests enable and
311 * disable calls. */
312 if (enabled == wm8350->rtc.update_enabled)
313 return 0;
314
310 if (enabled) 315 if (enabled)
311 wm8350_unmask_irq(wm8350, WM8350_IRQ_RTC_SEC); 316 wm8350_unmask_irq(wm8350, WM8350_IRQ_RTC_SEC);
312 else 317 else
313 wm8350_mask_irq(wm8350, WM8350_IRQ_RTC_SEC); 318 wm8350_mask_irq(wm8350, WM8350_IRQ_RTC_SEC);
314 319
320 wm8350->rtc.update_enabled = enabled;
321
315 return 0; 322 return 0;
316} 323}
317 324
@@ -478,8 +485,8 @@ static int __devexit wm8350_rtc_remove(struct platform_device *pdev)
478 struct wm8350 *wm8350 = platform_get_drvdata(pdev); 485 struct wm8350 *wm8350 = platform_get_drvdata(pdev);
479 struct wm8350_rtc *wm_rtc = &wm8350->rtc; 486 struct wm8350_rtc *wm_rtc = &wm8350->rtc;
480 487
481 wm8350_free_irq(wm8350, WM8350_IRQ_RTC_SEC); 488 wm8350_free_irq(wm8350, WM8350_IRQ_RTC_SEC, wm8350);
482 wm8350_free_irq(wm8350, WM8350_IRQ_RTC_ALM); 489 wm8350_free_irq(wm8350, WM8350_IRQ_RTC_ALM, wm8350);
483 490
484 rtc_device_unregister(wm_rtc->rtc); 491 rtc_device_unregister(wm_rtc->rtc);
485 492
generated by cgit v1.2.2 (git 2.25.0) at 2025-03-13 08:03:13 -0400