xref: /openbmc/linux/drivers/rtc/rtc-mv.c (revision b0d42def)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Driver for the RTC in Marvell SoCs.
4  */
5 
6 #include <linux/init.h>
7 #include <linux/kernel.h>
8 #include <linux/rtc.h>
9 #include <linux/bcd.h>
10 #include <linux/bitops.h>
11 #include <linux/io.h>
12 #include <linux/platform_device.h>
13 #include <linux/of.h>
14 #include <linux/delay.h>
15 #include <linux/clk.h>
16 #include <linux/gfp.h>
17 #include <linux/module.h>
18 
19 
20 #define RTC_TIME_REG_OFFS	0
21 #define RTC_SECONDS_OFFS	0
22 #define RTC_MINUTES_OFFS	8
23 #define RTC_HOURS_OFFS		16
24 #define RTC_WDAY_OFFS		24
25 #define RTC_HOURS_12H_MODE	BIT(22) /* 12 hour mode */
26 
27 #define RTC_DATE_REG_OFFS	4
28 #define RTC_MDAY_OFFS		0
29 #define RTC_MONTH_OFFS		8
30 #define RTC_YEAR_OFFS		16
31 
32 #define RTC_ALARM_TIME_REG_OFFS	8
33 #define RTC_ALARM_DATE_REG_OFFS	0xc
34 #define RTC_ALARM_VALID		BIT(7)
35 
36 #define RTC_ALARM_INTERRUPT_MASK_REG_OFFS	0x10
37 #define RTC_ALARM_INTERRUPT_CASUE_REG_OFFS	0x14
38 
39 struct rtc_plat_data {
40 	struct rtc_device *rtc;
41 	void __iomem *ioaddr;
42 	int		irq;
43 	struct clk	*clk;
44 };
45 
mv_rtc_set_time(struct device * dev,struct rtc_time * tm)46 static int mv_rtc_set_time(struct device *dev, struct rtc_time *tm)
47 {
48 	struct rtc_plat_data *pdata = dev_get_drvdata(dev);
49 	void __iomem *ioaddr = pdata->ioaddr;
50 	u32	rtc_reg;
51 
52 	rtc_reg = (bin2bcd(tm->tm_sec) << RTC_SECONDS_OFFS) |
53 		(bin2bcd(tm->tm_min) << RTC_MINUTES_OFFS) |
54 		(bin2bcd(tm->tm_hour) << RTC_HOURS_OFFS) |
55 		(bin2bcd(tm->tm_wday) << RTC_WDAY_OFFS);
56 	writel(rtc_reg, ioaddr + RTC_TIME_REG_OFFS);
57 
58 	rtc_reg = (bin2bcd(tm->tm_mday) << RTC_MDAY_OFFS) |
59 		(bin2bcd(tm->tm_mon + 1) << RTC_MONTH_OFFS) |
60 		(bin2bcd(tm->tm_year - 100) << RTC_YEAR_OFFS);
61 	writel(rtc_reg, ioaddr + RTC_DATE_REG_OFFS);
62 
63 	return 0;
64 }
65 
mv_rtc_read_time(struct device * dev,struct rtc_time * tm)66 static int mv_rtc_read_time(struct device *dev, struct rtc_time *tm)
67 {
68 	struct rtc_plat_data *pdata = dev_get_drvdata(dev);
69 	void __iomem *ioaddr = pdata->ioaddr;
70 	u32	rtc_time, rtc_date;
71 	unsigned int year, month, day, hour, minute, second, wday;
72 
73 	rtc_time = readl(ioaddr + RTC_TIME_REG_OFFS);
74 	rtc_date = readl(ioaddr + RTC_DATE_REG_OFFS);
75 
76 	second = rtc_time & 0x7f;
77 	minute = (rtc_time >> RTC_MINUTES_OFFS) & 0x7f;
78 	hour = (rtc_time >> RTC_HOURS_OFFS) & 0x3f; /* assume 24 hour mode */
79 	wday = (rtc_time >> RTC_WDAY_OFFS) & 0x7;
80 
81 	day = rtc_date & 0x3f;
82 	month = (rtc_date >> RTC_MONTH_OFFS) & 0x3f;
83 	year = (rtc_date >> RTC_YEAR_OFFS) & 0xff;
84 
85 	tm->tm_sec = bcd2bin(second);
86 	tm->tm_min = bcd2bin(minute);
87 	tm->tm_hour = bcd2bin(hour);
88 	tm->tm_mday = bcd2bin(day);
89 	tm->tm_wday = bcd2bin(wday);
90 	tm->tm_mon = bcd2bin(month) - 1;
91 	/* hw counts from year 2000, but tm_year is relative to 1900 */
92 	tm->tm_year = bcd2bin(year) + 100;
93 
94 	return 0;
95 }
96 
mv_rtc_read_alarm(struct device * dev,struct rtc_wkalrm * alm)97 static int mv_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
98 {
99 	struct rtc_plat_data *pdata = dev_get_drvdata(dev);
100 	void __iomem *ioaddr = pdata->ioaddr;
101 	u32	rtc_time, rtc_date;
102 	unsigned int year, month, day, hour, minute, second, wday;
103 
104 	rtc_time = readl(ioaddr + RTC_ALARM_TIME_REG_OFFS);
105 	rtc_date = readl(ioaddr + RTC_ALARM_DATE_REG_OFFS);
106 
107 	second = rtc_time & 0x7f;
108 	minute = (rtc_time >> RTC_MINUTES_OFFS) & 0x7f;
109 	hour = (rtc_time >> RTC_HOURS_OFFS) & 0x3f; /* assume 24 hour mode */
110 	wday = (rtc_time >> RTC_WDAY_OFFS) & 0x7;
111 
112 	day = rtc_date & 0x3f;
113 	month = (rtc_date >> RTC_MONTH_OFFS) & 0x3f;
114 	year = (rtc_date >> RTC_YEAR_OFFS) & 0xff;
115 
116 	alm->time.tm_sec = bcd2bin(second);
117 	alm->time.tm_min = bcd2bin(minute);
118 	alm->time.tm_hour = bcd2bin(hour);
119 	alm->time.tm_mday = bcd2bin(day);
120 	alm->time.tm_wday = bcd2bin(wday);
121 	alm->time.tm_mon = bcd2bin(month) - 1;
122 	/* hw counts from year 2000, but tm_year is relative to 1900 */
123 	alm->time.tm_year = bcd2bin(year) + 100;
124 
125 	alm->enabled = !!readl(ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS);
126 
127 	return rtc_valid_tm(&alm->time);
128 }
129 
mv_rtc_set_alarm(struct device * dev,struct rtc_wkalrm * alm)130 static int mv_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
131 {
132 	struct rtc_plat_data *pdata = dev_get_drvdata(dev);
133 	void __iomem *ioaddr = pdata->ioaddr;
134 	u32 rtc_reg = 0;
135 
136 	if (alm->time.tm_sec >= 0)
137 		rtc_reg |= (RTC_ALARM_VALID | bin2bcd(alm->time.tm_sec))
138 			<< RTC_SECONDS_OFFS;
139 	if (alm->time.tm_min >= 0)
140 		rtc_reg |= (RTC_ALARM_VALID | bin2bcd(alm->time.tm_min))
141 			<< RTC_MINUTES_OFFS;
142 	if (alm->time.tm_hour >= 0)
143 		rtc_reg |= (RTC_ALARM_VALID | bin2bcd(alm->time.tm_hour))
144 			<< RTC_HOURS_OFFS;
145 
146 	writel(rtc_reg, ioaddr + RTC_ALARM_TIME_REG_OFFS);
147 
148 	if (alm->time.tm_mday >= 0)
149 		rtc_reg = (RTC_ALARM_VALID | bin2bcd(alm->time.tm_mday))
150 			<< RTC_MDAY_OFFS;
151 	else
152 		rtc_reg = 0;
153 
154 	if (alm->time.tm_mon >= 0)
155 		rtc_reg |= (RTC_ALARM_VALID | bin2bcd(alm->time.tm_mon + 1))
156 			<< RTC_MONTH_OFFS;
157 
158 	if (alm->time.tm_year >= 0)
159 		rtc_reg |= (RTC_ALARM_VALID | bin2bcd(alm->time.tm_year - 100))
160 			<< RTC_YEAR_OFFS;
161 
162 	writel(rtc_reg, ioaddr + RTC_ALARM_DATE_REG_OFFS);
163 	writel(0, ioaddr + RTC_ALARM_INTERRUPT_CASUE_REG_OFFS);
164 	writel(alm->enabled ? 1 : 0,
165 	       ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS);
166 
167 	return 0;
168 }
169 
mv_rtc_alarm_irq_enable(struct device * dev,unsigned int enabled)170 static int mv_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
171 {
172 	struct rtc_plat_data *pdata = dev_get_drvdata(dev);
173 	void __iomem *ioaddr = pdata->ioaddr;
174 
175 	if (pdata->irq < 0)
176 		return -EINVAL; /* fall back into rtc-dev's emulation */
177 
178 	if (enabled)
179 		writel(1, ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS);
180 	else
181 		writel(0, ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS);
182 	return 0;
183 }
184 
mv_rtc_interrupt(int irq,void * data)185 static irqreturn_t mv_rtc_interrupt(int irq, void *data)
186 {
187 	struct rtc_plat_data *pdata = data;
188 	void __iomem *ioaddr = pdata->ioaddr;
189 
190 	/* alarm irq? */
191 	if (!readl(ioaddr + RTC_ALARM_INTERRUPT_CASUE_REG_OFFS))
192 		return IRQ_NONE;
193 
194 	/* clear interrupt */
195 	writel(0, ioaddr + RTC_ALARM_INTERRUPT_CASUE_REG_OFFS);
196 	rtc_update_irq(pdata->rtc, 1, RTC_IRQF | RTC_AF);
197 	return IRQ_HANDLED;
198 }
199 
200 static const struct rtc_class_ops mv_rtc_ops = {
201 	.read_time	= mv_rtc_read_time,
202 	.set_time	= mv_rtc_set_time,
203 	.read_alarm	= mv_rtc_read_alarm,
204 	.set_alarm	= mv_rtc_set_alarm,
205 	.alarm_irq_enable = mv_rtc_alarm_irq_enable,
206 };
207 
mv_rtc_probe(struct platform_device * pdev)208 static int __init mv_rtc_probe(struct platform_device *pdev)
209 {
210 	struct rtc_plat_data *pdata;
211 	u32 rtc_time;
212 	int ret = 0;
213 
214 	pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
215 	if (!pdata)
216 		return -ENOMEM;
217 
218 	pdata->ioaddr = devm_platform_ioremap_resource(pdev, 0);
219 	if (IS_ERR(pdata->ioaddr))
220 		return PTR_ERR(pdata->ioaddr);
221 
222 	pdata->clk = devm_clk_get(&pdev->dev, NULL);
223 	/* Not all SoCs require a clock.*/
224 	if (!IS_ERR(pdata->clk))
225 		clk_prepare_enable(pdata->clk);
226 
227 	/* make sure the 24 hour mode is enabled */
228 	rtc_time = readl(pdata->ioaddr + RTC_TIME_REG_OFFS);
229 	if (rtc_time & RTC_HOURS_12H_MODE) {
230 		dev_err(&pdev->dev, "12 Hour mode is enabled but not supported.\n");
231 		ret = -EINVAL;
232 		goto out;
233 	}
234 
235 	/* make sure it is actually functional */
236 	if (rtc_time == 0x01000000) {
237 		ssleep(1);
238 		rtc_time = readl(pdata->ioaddr + RTC_TIME_REG_OFFS);
239 		if (rtc_time == 0x01000000) {
240 			dev_err(&pdev->dev, "internal RTC not ticking\n");
241 			ret = -ENODEV;
242 			goto out;
243 		}
244 	}
245 
246 	pdata->irq = platform_get_irq(pdev, 0);
247 
248 	platform_set_drvdata(pdev, pdata);
249 
250 	pdata->rtc = devm_rtc_allocate_device(&pdev->dev);
251 	if (IS_ERR(pdata->rtc)) {
252 		ret = PTR_ERR(pdata->rtc);
253 		goto out;
254 	}
255 
256 	if (pdata->irq >= 0) {
257 		writel(0, pdata->ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS);
258 		if (devm_request_irq(&pdev->dev, pdata->irq, mv_rtc_interrupt,
259 				     IRQF_SHARED,
260 				     pdev->name, pdata) < 0) {
261 			dev_warn(&pdev->dev, "interrupt not available.\n");
262 			pdata->irq = -1;
263 		}
264 	}
265 
266 	if (pdata->irq >= 0)
267 		device_init_wakeup(&pdev->dev, 1);
268 	else
269 		clear_bit(RTC_FEATURE_ALARM, pdata->rtc->features);
270 
271 	pdata->rtc->ops = &mv_rtc_ops;
272 	pdata->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
273 	pdata->rtc->range_max = RTC_TIMESTAMP_END_2099;
274 
275 	ret = devm_rtc_register_device(pdata->rtc);
276 	if (!ret)
277 		return 0;
278 out:
279 	if (!IS_ERR(pdata->clk))
280 		clk_disable_unprepare(pdata->clk);
281 
282 	return ret;
283 }
284 
mv_rtc_remove(struct platform_device * pdev)285 static int __exit mv_rtc_remove(struct platform_device *pdev)
286 {
287 	struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
288 
289 	if (pdata->irq >= 0)
290 		device_init_wakeup(&pdev->dev, 0);
291 
292 	if (!IS_ERR(pdata->clk))
293 		clk_disable_unprepare(pdata->clk);
294 
295 	return 0;
296 }
297 
298 #ifdef CONFIG_OF
299 static const struct of_device_id rtc_mv_of_match_table[] = {
300 	{ .compatible = "marvell,orion-rtc", },
301 	{}
302 };
303 MODULE_DEVICE_TABLE(of, rtc_mv_of_match_table);
304 #endif
305 
306 static struct platform_driver mv_rtc_driver = {
307 	.remove		= __exit_p(mv_rtc_remove),
308 	.driver		= {
309 		.name	= "rtc-mv",
310 		.of_match_table = of_match_ptr(rtc_mv_of_match_table),
311 	},
312 };
313 
314 module_platform_driver_probe(mv_rtc_driver, mv_rtc_probe);
315 
316 MODULE_AUTHOR("Saeed Bishara <saeed@marvell.com>");
317 MODULE_DESCRIPTION("Marvell RTC driver");
318 MODULE_LICENSE("GPL");
319 MODULE_ALIAS("platform:rtc-mv");
320