Linux Audio

Check our new training course

Loading...
v5.9
  1// SPDX-License-Identifier: GPL-2.0-only
  2/* drivers/rtc/rtc-s3c.c
  3 *
  4 * Copyright (c) 2010 Samsung Electronics Co., Ltd.
  5 *		http://www.samsung.com/
  6 *
  7 * Copyright (c) 2004,2006 Simtec Electronics
  8 *	Ben Dooks, <ben@simtec.co.uk>
  9 *	http://armlinux.simtec.co.uk/
 10 *
 11 * S3C2410/S3C2440/S3C24XX Internal RTC Driver
 12*/
 13
 14#include <linux/module.h>
 15#include <linux/fs.h>
 16#include <linux/string.h>
 17#include <linux/init.h>
 18#include <linux/platform_device.h>
 19#include <linux/interrupt.h>
 20#include <linux/rtc.h>
 21#include <linux/bcd.h>
 22#include <linux/clk.h>
 23#include <linux/log2.h>
 24#include <linux/slab.h>
 25#include <linux/of.h>
 26#include <linux/of_device.h>
 27#include <linux/uaccess.h>
 28#include <linux/io.h>
 29
 30#include <asm/irq.h>
 31#include "rtc-s3c.h"
 32
 33struct s3c_rtc {
 34	struct device *dev;
 35	struct rtc_device *rtc;
 36
 37	void __iomem *base;
 38	struct clk *rtc_clk;
 39	struct clk *rtc_src_clk;
 40	bool alarm_enabled;
 41
 42	const struct s3c_rtc_data *data;
 43
 44	int irq_alarm;
 45	int irq_tick;
 46
 47	spinlock_t pie_lock;
 48	spinlock_t alarm_lock;
 49
 50	int ticnt_save;
 51	int ticnt_en_save;
 52	bool wake_en;
 53};
 54
 55struct s3c_rtc_data {
 56	int max_user_freq;
 57	bool needs_src_clk;
 58
 59	void (*irq_handler) (struct s3c_rtc *info, int mask);
 60	void (*set_freq) (struct s3c_rtc *info, int freq);
 61	void (*enable_tick) (struct s3c_rtc *info, struct seq_file *seq);
 62	void (*select_tick_clk) (struct s3c_rtc *info);
 63	void (*save_tick_cnt) (struct s3c_rtc *info);
 64	void (*restore_tick_cnt) (struct s3c_rtc *info);
 65	void (*enable) (struct s3c_rtc *info);
 66	void (*disable) (struct s3c_rtc *info);
 67};
 68
 69static int s3c_rtc_enable_clk(struct s3c_rtc *info)
 70{
 71	int ret;
 72
 73	ret = clk_enable(info->rtc_clk);
 74	if (ret)
 75		return ret;
 76
 77	if (info->data->needs_src_clk) {
 78		ret = clk_enable(info->rtc_src_clk);
 79		if (ret) {
 80			clk_disable(info->rtc_clk);
 81			return ret;
 82		}
 83	}
 84	return 0;
 85}
 86
 87static void s3c_rtc_disable_clk(struct s3c_rtc *info)
 88{
 89	if (info->data->needs_src_clk)
 90		clk_disable(info->rtc_src_clk);
 91	clk_disable(info->rtc_clk);
 92}
 93
 94/* IRQ Handlers */
 95static irqreturn_t s3c_rtc_tickirq(int irq, void *id)
 96{
 97	struct s3c_rtc *info = (struct s3c_rtc *)id;
 98
 99	if (info->data->irq_handler)
100		info->data->irq_handler(info, S3C2410_INTP_TIC);
101
102	return IRQ_HANDLED;
103}
104
105static irqreturn_t s3c_rtc_alarmirq(int irq, void *id)
106{
107	struct s3c_rtc *info = (struct s3c_rtc *)id;
108
109	if (info->data->irq_handler)
110		info->data->irq_handler(info, S3C2410_INTP_ALM);
111
112	return IRQ_HANDLED;
113}
114
115/* Update control registers */
116static int s3c_rtc_setaie(struct device *dev, unsigned int enabled)
117{
118	struct s3c_rtc *info = dev_get_drvdata(dev);
119	unsigned long flags;
120	unsigned int tmp;
121	int ret;
122
123	dev_dbg(info->dev, "%s: aie=%d\n", __func__, enabled);
124
125	ret = s3c_rtc_enable_clk(info);
126	if (ret)
127		return ret;
128
129	tmp = readb(info->base + S3C2410_RTCALM) & ~S3C2410_RTCALM_ALMEN;
130
131	if (enabled)
132		tmp |= S3C2410_RTCALM_ALMEN;
133
134	writeb(tmp, info->base + S3C2410_RTCALM);
135
136	spin_lock_irqsave(&info->alarm_lock, flags);
137
138	if (info->alarm_enabled && !enabled)
139		s3c_rtc_disable_clk(info);
140	else if (!info->alarm_enabled && enabled)
141		ret = s3c_rtc_enable_clk(info);
142
143	info->alarm_enabled = enabled;
144	spin_unlock_irqrestore(&info->alarm_lock, flags);
145
146	s3c_rtc_disable_clk(info);
147
148	return ret;
149}
150
151/* Set RTC frequency */
152static int s3c_rtc_setfreq(struct s3c_rtc *info, int freq)
153{
154	int ret;
155
156	if (!is_power_of_2(freq))
157		return -EINVAL;
158
159	ret = s3c_rtc_enable_clk(info);
160	if (ret)
161		return ret;
162	spin_lock_irq(&info->pie_lock);
163
164	if (info->data->set_freq)
165		info->data->set_freq(info, freq);
166
167	spin_unlock_irq(&info->pie_lock);
168	s3c_rtc_disable_clk(info);
169
170	return 0;
171}
172
173/* Time read/write */
174static int s3c_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm)
175{
176	struct s3c_rtc *info = dev_get_drvdata(dev);
177	unsigned int have_retried = 0;
178	int ret;
179
180	ret = s3c_rtc_enable_clk(info);
181	if (ret)
182		return ret;
183
184retry_get_time:
185	rtc_tm->tm_min  = readb(info->base + S3C2410_RTCMIN);
186	rtc_tm->tm_hour = readb(info->base + S3C2410_RTCHOUR);
187	rtc_tm->tm_mday = readb(info->base + S3C2410_RTCDATE);
188	rtc_tm->tm_mon  = readb(info->base + S3C2410_RTCMON);
189	rtc_tm->tm_year = readb(info->base + S3C2410_RTCYEAR);
190	rtc_tm->tm_sec  = readb(info->base + S3C2410_RTCSEC);
191
192	/* the only way to work out whether the system was mid-update
193	 * when we read it is to check the second counter, and if it
194	 * is zero, then we re-try the entire read
195	 */
196
197	if (rtc_tm->tm_sec == 0 && !have_retried) {
198		have_retried = 1;
199		goto retry_get_time;
200	}
201
202	rtc_tm->tm_sec = bcd2bin(rtc_tm->tm_sec);
203	rtc_tm->tm_min = bcd2bin(rtc_tm->tm_min);
204	rtc_tm->tm_hour = bcd2bin(rtc_tm->tm_hour);
205	rtc_tm->tm_mday = bcd2bin(rtc_tm->tm_mday);
206	rtc_tm->tm_mon = bcd2bin(rtc_tm->tm_mon);
207	rtc_tm->tm_year = bcd2bin(rtc_tm->tm_year);
208
209	s3c_rtc_disable_clk(info);
210
211	rtc_tm->tm_year += 100;
212	rtc_tm->tm_mon -= 1;
213
214	dev_dbg(dev, "read time %ptR\n", rtc_tm);
215	return 0;
216}
217
218static int s3c_rtc_settime(struct device *dev, struct rtc_time *tm)
219{
220	struct s3c_rtc *info = dev_get_drvdata(dev);
221	int year = tm->tm_year - 100;
222	int ret;
223
224	dev_dbg(dev, "set time %ptR\n", tm);
225
226	/* we get around y2k by simply not supporting it */
227
228	if (year < 0 || year >= 100) {
229		dev_err(dev, "rtc only supports 100 years\n");
230		return -EINVAL;
231	}
232
233	ret = s3c_rtc_enable_clk(info);
234	if (ret)
235		return ret;
236
237	writeb(bin2bcd(tm->tm_sec),  info->base + S3C2410_RTCSEC);
238	writeb(bin2bcd(tm->tm_min),  info->base + S3C2410_RTCMIN);
239	writeb(bin2bcd(tm->tm_hour), info->base + S3C2410_RTCHOUR);
240	writeb(bin2bcd(tm->tm_mday), info->base + S3C2410_RTCDATE);
241	writeb(bin2bcd(tm->tm_mon + 1), info->base + S3C2410_RTCMON);
242	writeb(bin2bcd(year), info->base + S3C2410_RTCYEAR);
243
244	s3c_rtc_disable_clk(info);
245
246	return 0;
247}
248
249static int s3c_rtc_getalarm(struct device *dev, struct rtc_wkalrm *alrm)
250{
251	struct s3c_rtc *info = dev_get_drvdata(dev);
252	struct rtc_time *alm_tm = &alrm->time;
253	unsigned int alm_en;
254	int ret;
255
256	ret = s3c_rtc_enable_clk(info);
257	if (ret)
258		return ret;
259
260	alm_tm->tm_sec  = readb(info->base + S3C2410_ALMSEC);
261	alm_tm->tm_min  = readb(info->base + S3C2410_ALMMIN);
262	alm_tm->tm_hour = readb(info->base + S3C2410_ALMHOUR);
263	alm_tm->tm_mon  = readb(info->base + S3C2410_ALMMON);
264	alm_tm->tm_mday = readb(info->base + S3C2410_ALMDATE);
265	alm_tm->tm_year = readb(info->base + S3C2410_ALMYEAR);
266
267	alm_en = readb(info->base + S3C2410_RTCALM);
268
269	s3c_rtc_disable_clk(info);
270
271	alrm->enabled = (alm_en & S3C2410_RTCALM_ALMEN) ? 1 : 0;
272
273	dev_dbg(dev, "read alarm %d, %ptR\n", alm_en, alm_tm);
274
275	/* decode the alarm enable field */
276	if (alm_en & S3C2410_RTCALM_SECEN)
277		alm_tm->tm_sec = bcd2bin(alm_tm->tm_sec);
278
279	if (alm_en & S3C2410_RTCALM_MINEN)
280		alm_tm->tm_min = bcd2bin(alm_tm->tm_min);
281
282	if (alm_en & S3C2410_RTCALM_HOUREN)
283		alm_tm->tm_hour = bcd2bin(alm_tm->tm_hour);
284
285	if (alm_en & S3C2410_RTCALM_DAYEN)
286		alm_tm->tm_mday = bcd2bin(alm_tm->tm_mday);
287
288	if (alm_en & S3C2410_RTCALM_MONEN) {
289		alm_tm->tm_mon = bcd2bin(alm_tm->tm_mon);
290		alm_tm->tm_mon -= 1;
291	}
292
293	if (alm_en & S3C2410_RTCALM_YEAREN)
294		alm_tm->tm_year = bcd2bin(alm_tm->tm_year);
295
296	return 0;
297}
298
299static int s3c_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
300{
301	struct s3c_rtc *info = dev_get_drvdata(dev);
302	struct rtc_time *tm = &alrm->time;
303	unsigned int alrm_en;
304	int ret;
305
306	dev_dbg(dev, "s3c_rtc_setalarm: %d, %ptR\n", alrm->enabled, tm);
307
308	ret = s3c_rtc_enable_clk(info);
309	if (ret)
310		return ret;
311
312	alrm_en = readb(info->base + S3C2410_RTCALM) & S3C2410_RTCALM_ALMEN;
313	writeb(0x00, info->base + S3C2410_RTCALM);
314
315	if (tm->tm_sec < 60 && tm->tm_sec >= 0) {
316		alrm_en |= S3C2410_RTCALM_SECEN;
317		writeb(bin2bcd(tm->tm_sec), info->base + S3C2410_ALMSEC);
318	}
319
320	if (tm->tm_min < 60 && tm->tm_min >= 0) {
321		alrm_en |= S3C2410_RTCALM_MINEN;
322		writeb(bin2bcd(tm->tm_min), info->base + S3C2410_ALMMIN);
323	}
324
325	if (tm->tm_hour < 24 && tm->tm_hour >= 0) {
326		alrm_en |= S3C2410_RTCALM_HOUREN;
327		writeb(bin2bcd(tm->tm_hour), info->base + S3C2410_ALMHOUR);
328	}
329
330	if (tm->tm_mon < 12 && tm->tm_mon >= 0) {
331		alrm_en |= S3C2410_RTCALM_MONEN;
332		writeb(bin2bcd(tm->tm_mon + 1), info->base + S3C2410_ALMMON);
333	}
334
335	if (tm->tm_mday <= 31 && tm->tm_mday >= 1) {
336		alrm_en |= S3C2410_RTCALM_DAYEN;
337		writeb(bin2bcd(tm->tm_mday), info->base + S3C2410_ALMDATE);
338	}
339
340	dev_dbg(dev, "setting S3C2410_RTCALM to %08x\n", alrm_en);
341
342	writeb(alrm_en, info->base + S3C2410_RTCALM);
343
344	s3c_rtc_setaie(dev, alrm->enabled);
345
346	s3c_rtc_disable_clk(info);
347
348	return 0;
349}
350
351static int s3c_rtc_proc(struct device *dev, struct seq_file *seq)
352{
353	struct s3c_rtc *info = dev_get_drvdata(dev);
354	int ret;
355
356	ret = s3c_rtc_enable_clk(info);
357	if (ret)
358		return ret;
359
360	if (info->data->enable_tick)
361		info->data->enable_tick(info, seq);
362
363	s3c_rtc_disable_clk(info);
364
365	return 0;
366}
367
368static const struct rtc_class_ops s3c_rtcops = {
369	.read_time	= s3c_rtc_gettime,
370	.set_time	= s3c_rtc_settime,
371	.read_alarm	= s3c_rtc_getalarm,
372	.set_alarm	= s3c_rtc_setalarm,
373	.proc		= s3c_rtc_proc,
374	.alarm_irq_enable = s3c_rtc_setaie,
375};
376
377static void s3c24xx_rtc_enable(struct s3c_rtc *info)
378{
379	unsigned int con, tmp;
380
381	con = readw(info->base + S3C2410_RTCCON);
382	/* re-enable the device, and check it is ok */
383	if ((con & S3C2410_RTCCON_RTCEN) == 0) {
384		dev_info(info->dev, "rtc disabled, re-enabling\n");
385
386		tmp = readw(info->base + S3C2410_RTCCON);
387		writew(tmp | S3C2410_RTCCON_RTCEN, info->base + S3C2410_RTCCON);
388	}
389
390	if (con & S3C2410_RTCCON_CNTSEL) {
391		dev_info(info->dev, "removing RTCCON_CNTSEL\n");
392
393		tmp = readw(info->base + S3C2410_RTCCON);
394		writew(tmp & ~S3C2410_RTCCON_CNTSEL,
395		       info->base + S3C2410_RTCCON);
396	}
397
398	if (con & S3C2410_RTCCON_CLKRST) {
399		dev_info(info->dev, "removing RTCCON_CLKRST\n");
400
401		tmp = readw(info->base + S3C2410_RTCCON);
402		writew(tmp & ~S3C2410_RTCCON_CLKRST,
403		       info->base + S3C2410_RTCCON);
404	}
405}
406
407static void s3c24xx_rtc_disable(struct s3c_rtc *info)
408{
409	unsigned int con;
410
411	con = readw(info->base + S3C2410_RTCCON);
412	con &= ~S3C2410_RTCCON_RTCEN;
413	writew(con, info->base + S3C2410_RTCCON);
414
415	con = readb(info->base + S3C2410_TICNT);
416	con &= ~S3C2410_TICNT_ENABLE;
417	writeb(con, info->base + S3C2410_TICNT);
418}
419
420static void s3c6410_rtc_disable(struct s3c_rtc *info)
421{
422	unsigned int con;
423
424	con = readw(info->base + S3C2410_RTCCON);
425	con &= ~S3C64XX_RTCCON_TICEN;
426	con &= ~S3C2410_RTCCON_RTCEN;
427	writew(con, info->base + S3C2410_RTCCON);
428}
429
430static int s3c_rtc_remove(struct platform_device *pdev)
431{
432	struct s3c_rtc *info = platform_get_drvdata(pdev);
433
434	s3c_rtc_setaie(info->dev, 0);
435
436	if (info->data->needs_src_clk)
437		clk_unprepare(info->rtc_src_clk);
438	clk_unprepare(info->rtc_clk);
439
440	return 0;
441}
442
443static int s3c_rtc_probe(struct platform_device *pdev)
444{
445	struct s3c_rtc *info = NULL;
446	struct rtc_time rtc_tm;
447	int ret;
448
449	info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
450	if (!info)
451		return -ENOMEM;
452
453	/* find the IRQs */
454	info->irq_tick = platform_get_irq(pdev, 1);
455	if (info->irq_tick < 0)
456		return info->irq_tick;
457
458	info->dev = &pdev->dev;
459	info->data = of_device_get_match_data(&pdev->dev);
460	if (!info->data) {
461		dev_err(&pdev->dev, "failed getting s3c_rtc_data\n");
462		return -EINVAL;
463	}
464	spin_lock_init(&info->pie_lock);
465	spin_lock_init(&info->alarm_lock);
466
467	platform_set_drvdata(pdev, info);
468
469	info->irq_alarm = platform_get_irq(pdev, 0);
470	if (info->irq_alarm < 0)
471		return info->irq_alarm;
472
473	dev_dbg(&pdev->dev, "s3c2410_rtc: tick irq %d, alarm irq %d\n",
474		info->irq_tick, info->irq_alarm);
475
476	/* get the memory region */
477	info->base = devm_platform_ioremap_resource(pdev, 0);
478	if (IS_ERR(info->base))
479		return PTR_ERR(info->base);
480
481	info->rtc_clk = devm_clk_get(&pdev->dev, "rtc");
482	if (IS_ERR(info->rtc_clk)) {
483		ret = PTR_ERR(info->rtc_clk);
484		if (ret != -EPROBE_DEFER)
485			dev_err(&pdev->dev, "failed to find rtc clock\n");
486		else
487			dev_dbg(&pdev->dev, "probe deferred due to missing rtc clk\n");
488		return ret;
489	}
490	ret = clk_prepare_enable(info->rtc_clk);
491	if (ret)
492		return ret;
493
494	if (info->data->needs_src_clk) {
495		info->rtc_src_clk = devm_clk_get(&pdev->dev, "rtc_src");
496		if (IS_ERR(info->rtc_src_clk)) {
497			ret = PTR_ERR(info->rtc_src_clk);
498			if (ret != -EPROBE_DEFER)
499				dev_err(&pdev->dev,
500					"failed to find rtc source clock\n");
501			else
502				dev_dbg(&pdev->dev,
503					"probe deferred due to missing rtc src clk\n");
504			goto err_src_clk;
505		}
506		ret = clk_prepare_enable(info->rtc_src_clk);
507		if (ret)
508			goto err_src_clk;
509	}
510
 
 
 
 
511	/* check to see if everything is setup correctly */
512	if (info->data->enable)
513		info->data->enable(info);
514
515	dev_dbg(&pdev->dev, "s3c2410_rtc: RTCCON=%02x\n",
516		readw(info->base + S3C2410_RTCCON));
517
518	device_init_wakeup(&pdev->dev, 1);
519
520	/* Check RTC Time */
521	if (s3c_rtc_gettime(&pdev->dev, &rtc_tm)) {
522		rtc_tm.tm_year	= 100;
523		rtc_tm.tm_mon	= 0;
524		rtc_tm.tm_mday	= 1;
525		rtc_tm.tm_hour	= 0;
526		rtc_tm.tm_min	= 0;
527		rtc_tm.tm_sec	= 0;
528
529		s3c_rtc_settime(&pdev->dev, &rtc_tm);
530
531		dev_warn(&pdev->dev, "warning: invalid RTC value so initializing it\n");
532	}
533
534	/* register RTC and exit */
535	info->rtc = devm_rtc_device_register(&pdev->dev, "s3c", &s3c_rtcops,
536					     THIS_MODULE);
537	if (IS_ERR(info->rtc)) {
538		dev_err(&pdev->dev, "cannot attach rtc\n");
539		ret = PTR_ERR(info->rtc);
540		goto err_nortc;
541	}
542
543	ret = devm_request_irq(&pdev->dev, info->irq_alarm, s3c_rtc_alarmirq,
544			       0, "s3c2410-rtc alarm", info);
545	if (ret) {
546		dev_err(&pdev->dev, "IRQ%d error %d\n", info->irq_alarm, ret);
547		goto err_nortc;
548	}
549
550	ret = devm_request_irq(&pdev->dev, info->irq_tick, s3c_rtc_tickirq,
551			       0, "s3c2410-rtc tick", info);
552	if (ret) {
553		dev_err(&pdev->dev, "IRQ%d error %d\n", info->irq_tick, ret);
554		goto err_nortc;
555	}
556
557	if (info->data->select_tick_clk)
558		info->data->select_tick_clk(info);
559
560	s3c_rtc_setfreq(info, 1);
561
562	s3c_rtc_disable_clk(info);
563
564	return 0;
565
566err_nortc:
567	if (info->data->disable)
568		info->data->disable(info);
569
570	if (info->data->needs_src_clk)
571		clk_disable_unprepare(info->rtc_src_clk);
572err_src_clk:
573	clk_disable_unprepare(info->rtc_clk);
574
575	return ret;
576}
577
578#ifdef CONFIG_PM_SLEEP
579
580static int s3c_rtc_suspend(struct device *dev)
581{
582	struct s3c_rtc *info = dev_get_drvdata(dev);
583	int ret;
584
585	ret = s3c_rtc_enable_clk(info);
586	if (ret)
587		return ret;
588
589	/* save TICNT for anyone using periodic interrupts */
590	if (info->data->save_tick_cnt)
591		info->data->save_tick_cnt(info);
592
593	if (info->data->disable)
594		info->data->disable(info);
595
596	if (device_may_wakeup(dev) && !info->wake_en) {
597		if (enable_irq_wake(info->irq_alarm) == 0)
598			info->wake_en = true;
599		else
600			dev_err(dev, "enable_irq_wake failed\n");
601	}
602
603	return 0;
604}
605
606static int s3c_rtc_resume(struct device *dev)
607{
608	struct s3c_rtc *info = dev_get_drvdata(dev);
609
610	if (info->data->enable)
611		info->data->enable(info);
612
613	if (info->data->restore_tick_cnt)
614		info->data->restore_tick_cnt(info);
615
616	s3c_rtc_disable_clk(info);
617
618	if (device_may_wakeup(dev) && info->wake_en) {
619		disable_irq_wake(info->irq_alarm);
620		info->wake_en = false;
621	}
622
623	return 0;
624}
625#endif
626static SIMPLE_DEV_PM_OPS(s3c_rtc_pm_ops, s3c_rtc_suspend, s3c_rtc_resume);
627
628static void s3c24xx_rtc_irq(struct s3c_rtc *info, int mask)
629{
630	rtc_update_irq(info->rtc, 1, RTC_AF | RTC_IRQF);
631}
632
633static void s3c6410_rtc_irq(struct s3c_rtc *info, int mask)
634{
635	rtc_update_irq(info->rtc, 1, RTC_AF | RTC_IRQF);
636	writeb(mask, info->base + S3C2410_INTP);
637}
638
639static void s3c2410_rtc_setfreq(struct s3c_rtc *info, int freq)
640{
641	unsigned int tmp = 0;
642	int val;
643
644	tmp = readb(info->base + S3C2410_TICNT);
645	tmp &= S3C2410_TICNT_ENABLE;
646
647	val = (info->rtc->max_user_freq / freq) - 1;
648	tmp |= val;
649
650	writel(tmp, info->base + S3C2410_TICNT);
651}
652
653static void s3c2416_rtc_setfreq(struct s3c_rtc *info, int freq)
654{
655	unsigned int tmp = 0;
656	int val;
657
658	tmp = readb(info->base + S3C2410_TICNT);
659	tmp &= S3C2410_TICNT_ENABLE;
660
661	val = (info->rtc->max_user_freq / freq) - 1;
662
663	tmp |= S3C2443_TICNT_PART(val);
664	writel(S3C2443_TICNT1_PART(val), info->base + S3C2443_TICNT1);
665
666	writel(S3C2416_TICNT2_PART(val), info->base + S3C2416_TICNT2);
667
668	writel(tmp, info->base + S3C2410_TICNT);
669}
670
671static void s3c2443_rtc_setfreq(struct s3c_rtc *info, int freq)
672{
673	unsigned int tmp = 0;
674	int val;
675
676	tmp = readb(info->base + S3C2410_TICNT);
677	tmp &= S3C2410_TICNT_ENABLE;
678
679	val = (info->rtc->max_user_freq / freq) - 1;
680
681	tmp |= S3C2443_TICNT_PART(val);
682	writel(S3C2443_TICNT1_PART(val), info->base + S3C2443_TICNT1);
683
684	writel(tmp, info->base + S3C2410_TICNT);
685}
686
687static void s3c6410_rtc_setfreq(struct s3c_rtc *info, int freq)
688{
689	int val;
690
691	val = (info->rtc->max_user_freq / freq) - 1;
692	writel(val, info->base + S3C2410_TICNT);
693}
694
695static void s3c24xx_rtc_enable_tick(struct s3c_rtc *info, struct seq_file *seq)
696{
697	unsigned int ticnt;
698
699	ticnt = readb(info->base + S3C2410_TICNT);
700	ticnt &= S3C2410_TICNT_ENABLE;
701
702	seq_printf(seq, "periodic_IRQ\t: %s\n", ticnt  ? "yes" : "no");
703}
704
705static void s3c2416_rtc_select_tick_clk(struct s3c_rtc *info)
706{
707	unsigned int con;
708
709	con = readw(info->base + S3C2410_RTCCON);
710	con |= S3C2443_RTCCON_TICSEL;
711	writew(con, info->base + S3C2410_RTCCON);
712}
713
714static void s3c6410_rtc_enable_tick(struct s3c_rtc *info, struct seq_file *seq)
715{
716	unsigned int ticnt;
717
718	ticnt = readw(info->base + S3C2410_RTCCON);
719	ticnt &= S3C64XX_RTCCON_TICEN;
720
721	seq_printf(seq, "periodic_IRQ\t: %s\n", ticnt  ? "yes" : "no");
722}
723
724static void s3c24xx_rtc_save_tick_cnt(struct s3c_rtc *info)
725{
726	info->ticnt_save = readb(info->base + S3C2410_TICNT);
727}
728
729static void s3c24xx_rtc_restore_tick_cnt(struct s3c_rtc *info)
730{
731	writeb(info->ticnt_save, info->base + S3C2410_TICNT);
732}
733
734static void s3c6410_rtc_save_tick_cnt(struct s3c_rtc *info)
735{
736	info->ticnt_en_save = readw(info->base + S3C2410_RTCCON);
737	info->ticnt_en_save &= S3C64XX_RTCCON_TICEN;
738	info->ticnt_save = readl(info->base + S3C2410_TICNT);
739}
740
741static void s3c6410_rtc_restore_tick_cnt(struct s3c_rtc *info)
742{
743	unsigned int con;
744
745	writel(info->ticnt_save, info->base + S3C2410_TICNT);
746	if (info->ticnt_en_save) {
747		con = readw(info->base + S3C2410_RTCCON);
748		writew(con | info->ticnt_en_save, info->base + S3C2410_RTCCON);
749	}
750}
751
752static struct s3c_rtc_data const s3c2410_rtc_data = {
753	.max_user_freq		= 128,
754	.irq_handler		= s3c24xx_rtc_irq,
755	.set_freq		= s3c2410_rtc_setfreq,
756	.enable_tick		= s3c24xx_rtc_enable_tick,
757	.save_tick_cnt		= s3c24xx_rtc_save_tick_cnt,
758	.restore_tick_cnt	= s3c24xx_rtc_restore_tick_cnt,
759	.enable			= s3c24xx_rtc_enable,
760	.disable		= s3c24xx_rtc_disable,
761};
762
763static struct s3c_rtc_data const s3c2416_rtc_data = {
764	.max_user_freq		= 32768,
765	.irq_handler		= s3c24xx_rtc_irq,
766	.set_freq		= s3c2416_rtc_setfreq,
767	.enable_tick		= s3c24xx_rtc_enable_tick,
768	.select_tick_clk	= s3c2416_rtc_select_tick_clk,
769	.save_tick_cnt		= s3c24xx_rtc_save_tick_cnt,
770	.restore_tick_cnt	= s3c24xx_rtc_restore_tick_cnt,
771	.enable			= s3c24xx_rtc_enable,
772	.disable		= s3c24xx_rtc_disable,
773};
774
775static struct s3c_rtc_data const s3c2443_rtc_data = {
776	.max_user_freq		= 32768,
777	.irq_handler		= s3c24xx_rtc_irq,
778	.set_freq		= s3c2443_rtc_setfreq,
779	.enable_tick		= s3c24xx_rtc_enable_tick,
780	.select_tick_clk	= s3c2416_rtc_select_tick_clk,
781	.save_tick_cnt		= s3c24xx_rtc_save_tick_cnt,
782	.restore_tick_cnt	= s3c24xx_rtc_restore_tick_cnt,
783	.enable			= s3c24xx_rtc_enable,
784	.disable		= s3c24xx_rtc_disable,
785};
786
787static struct s3c_rtc_data const s3c6410_rtc_data = {
788	.max_user_freq		= 32768,
789	.needs_src_clk		= true,
790	.irq_handler		= s3c6410_rtc_irq,
791	.set_freq		= s3c6410_rtc_setfreq,
792	.enable_tick		= s3c6410_rtc_enable_tick,
793	.save_tick_cnt		= s3c6410_rtc_save_tick_cnt,
794	.restore_tick_cnt	= s3c6410_rtc_restore_tick_cnt,
795	.enable			= s3c24xx_rtc_enable,
796	.disable		= s3c6410_rtc_disable,
797};
798
799static const struct of_device_id s3c_rtc_dt_match[] = {
800	{
801		.compatible = "samsung,s3c2410-rtc",
802		.data = &s3c2410_rtc_data,
803	}, {
804		.compatible = "samsung,s3c2416-rtc",
805		.data = &s3c2416_rtc_data,
806	}, {
807		.compatible = "samsung,s3c2443-rtc",
808		.data = &s3c2443_rtc_data,
809	}, {
810		.compatible = "samsung,s3c6410-rtc",
811		.data = &s3c6410_rtc_data,
812	}, {
813		.compatible = "samsung,exynos3250-rtc",
814		.data = &s3c6410_rtc_data,
815	},
816	{ /* sentinel */ },
817};
818MODULE_DEVICE_TABLE(of, s3c_rtc_dt_match);
819
820static struct platform_driver s3c_rtc_driver = {
821	.probe		= s3c_rtc_probe,
822	.remove		= s3c_rtc_remove,
823	.driver		= {
824		.name	= "s3c-rtc",
825		.pm	= &s3c_rtc_pm_ops,
826		.of_match_table	= of_match_ptr(s3c_rtc_dt_match),
827	},
828};
829module_platform_driver(s3c_rtc_driver);
830
831MODULE_DESCRIPTION("Samsung S3C RTC Driver");
832MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
833MODULE_LICENSE("GPL");
834MODULE_ALIAS("platform:s3c2410-rtc");
v5.14.15
  1// SPDX-License-Identifier: GPL-2.0-only
  2/* drivers/rtc/rtc-s3c.c
  3 *
  4 * Copyright (c) 2010 Samsung Electronics Co., Ltd.
  5 *		http://www.samsung.com/
  6 *
  7 * Copyright (c) 2004,2006 Simtec Electronics
  8 *	Ben Dooks, <ben@simtec.co.uk>
  9 *	http://armlinux.simtec.co.uk/
 10 *
 11 * S3C2410/S3C2440/S3C24XX Internal RTC Driver
 12*/
 13
 14#include <linux/module.h>
 15#include <linux/fs.h>
 16#include <linux/string.h>
 17#include <linux/init.h>
 18#include <linux/platform_device.h>
 19#include <linux/interrupt.h>
 20#include <linux/rtc.h>
 21#include <linux/bcd.h>
 22#include <linux/clk.h>
 23#include <linux/log2.h>
 24#include <linux/slab.h>
 25#include <linux/of.h>
 26#include <linux/of_device.h>
 27#include <linux/uaccess.h>
 28#include <linux/io.h>
 29
 30#include <asm/irq.h>
 31#include "rtc-s3c.h"
 32
 33struct s3c_rtc {
 34	struct device *dev;
 35	struct rtc_device *rtc;
 36
 37	void __iomem *base;
 38	struct clk *rtc_clk;
 39	struct clk *rtc_src_clk;
 40	bool alarm_enabled;
 41
 42	const struct s3c_rtc_data *data;
 43
 44	int irq_alarm;
 
 
 
 45	spinlock_t alarm_lock;
 46
 
 
 47	bool wake_en;
 48};
 49
 50struct s3c_rtc_data {
 
 51	bool needs_src_clk;
 52
 53	void (*irq_handler) (struct s3c_rtc *info, int mask);
 
 
 
 
 
 54	void (*enable) (struct s3c_rtc *info);
 55	void (*disable) (struct s3c_rtc *info);
 56};
 57
 58static int s3c_rtc_enable_clk(struct s3c_rtc *info)
 59{
 60	int ret;
 61
 62	ret = clk_enable(info->rtc_clk);
 63	if (ret)
 64		return ret;
 65
 66	if (info->data->needs_src_clk) {
 67		ret = clk_enable(info->rtc_src_clk);
 68		if (ret) {
 69			clk_disable(info->rtc_clk);
 70			return ret;
 71		}
 72	}
 73	return 0;
 74}
 75
 76static void s3c_rtc_disable_clk(struct s3c_rtc *info)
 77{
 78	if (info->data->needs_src_clk)
 79		clk_disable(info->rtc_src_clk);
 80	clk_disable(info->rtc_clk);
 81}
 82
 83/* IRQ Handler */
 
 
 
 
 
 
 
 
 
 
 84static irqreturn_t s3c_rtc_alarmirq(int irq, void *id)
 85{
 86	struct s3c_rtc *info = (struct s3c_rtc *)id;
 87
 88	if (info->data->irq_handler)
 89		info->data->irq_handler(info, S3C2410_INTP_ALM);
 90
 91	return IRQ_HANDLED;
 92}
 93
 94/* Update control registers */
 95static int s3c_rtc_setaie(struct device *dev, unsigned int enabled)
 96{
 97	struct s3c_rtc *info = dev_get_drvdata(dev);
 98	unsigned long flags;
 99	unsigned int tmp;
100	int ret;
101
102	dev_dbg(info->dev, "%s: aie=%d\n", __func__, enabled);
103
104	ret = s3c_rtc_enable_clk(info);
105	if (ret)
106		return ret;
107
108	tmp = readb(info->base + S3C2410_RTCALM) & ~S3C2410_RTCALM_ALMEN;
109
110	if (enabled)
111		tmp |= S3C2410_RTCALM_ALMEN;
112
113	writeb(tmp, info->base + S3C2410_RTCALM);
114
115	spin_lock_irqsave(&info->alarm_lock, flags);
116
117	if (info->alarm_enabled && !enabled)
118		s3c_rtc_disable_clk(info);
119	else if (!info->alarm_enabled && enabled)
120		ret = s3c_rtc_enable_clk(info);
121
122	info->alarm_enabled = enabled;
123	spin_unlock_irqrestore(&info->alarm_lock, flags);
124
125	s3c_rtc_disable_clk(info);
126
127	return ret;
128}
129
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
130/* Time read/write */
131static int s3c_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm)
132{
133	struct s3c_rtc *info = dev_get_drvdata(dev);
134	unsigned int have_retried = 0;
135	int ret;
136
137	ret = s3c_rtc_enable_clk(info);
138	if (ret)
139		return ret;
140
141retry_get_time:
142	rtc_tm->tm_min  = readb(info->base + S3C2410_RTCMIN);
143	rtc_tm->tm_hour = readb(info->base + S3C2410_RTCHOUR);
144	rtc_tm->tm_mday = readb(info->base + S3C2410_RTCDATE);
145	rtc_tm->tm_mon  = readb(info->base + S3C2410_RTCMON);
146	rtc_tm->tm_year = readb(info->base + S3C2410_RTCYEAR);
147	rtc_tm->tm_sec  = readb(info->base + S3C2410_RTCSEC);
148
149	/* the only way to work out whether the system was mid-update
150	 * when we read it is to check the second counter, and if it
151	 * is zero, then we re-try the entire read
152	 */
153
154	if (rtc_tm->tm_sec == 0 && !have_retried) {
155		have_retried = 1;
156		goto retry_get_time;
157	}
158
159	rtc_tm->tm_sec = bcd2bin(rtc_tm->tm_sec);
160	rtc_tm->tm_min = bcd2bin(rtc_tm->tm_min);
161	rtc_tm->tm_hour = bcd2bin(rtc_tm->tm_hour);
162	rtc_tm->tm_mday = bcd2bin(rtc_tm->tm_mday);
163	rtc_tm->tm_mon = bcd2bin(rtc_tm->tm_mon);
164	rtc_tm->tm_year = bcd2bin(rtc_tm->tm_year);
165
166	s3c_rtc_disable_clk(info);
167
168	rtc_tm->tm_year += 100;
169	rtc_tm->tm_mon -= 1;
170
171	dev_dbg(dev, "read time %ptR\n", rtc_tm);
172	return 0;
173}
174
175static int s3c_rtc_settime(struct device *dev, struct rtc_time *tm)
176{
177	struct s3c_rtc *info = dev_get_drvdata(dev);
178	int year = tm->tm_year - 100;
179	int ret;
180
181	dev_dbg(dev, "set time %ptR\n", tm);
182
183	/* we get around y2k by simply not supporting it */
184
185	if (year < 0 || year >= 100) {
186		dev_err(dev, "rtc only supports 100 years\n");
187		return -EINVAL;
188	}
189
190	ret = s3c_rtc_enable_clk(info);
191	if (ret)
192		return ret;
193
194	writeb(bin2bcd(tm->tm_sec),  info->base + S3C2410_RTCSEC);
195	writeb(bin2bcd(tm->tm_min),  info->base + S3C2410_RTCMIN);
196	writeb(bin2bcd(tm->tm_hour), info->base + S3C2410_RTCHOUR);
197	writeb(bin2bcd(tm->tm_mday), info->base + S3C2410_RTCDATE);
198	writeb(bin2bcd(tm->tm_mon + 1), info->base + S3C2410_RTCMON);
199	writeb(bin2bcd(year), info->base + S3C2410_RTCYEAR);
200
201	s3c_rtc_disable_clk(info);
202
203	return 0;
204}
205
206static int s3c_rtc_getalarm(struct device *dev, struct rtc_wkalrm *alrm)
207{
208	struct s3c_rtc *info = dev_get_drvdata(dev);
209	struct rtc_time *alm_tm = &alrm->time;
210	unsigned int alm_en;
211	int ret;
212
213	ret = s3c_rtc_enable_clk(info);
214	if (ret)
215		return ret;
216
217	alm_tm->tm_sec  = readb(info->base + S3C2410_ALMSEC);
218	alm_tm->tm_min  = readb(info->base + S3C2410_ALMMIN);
219	alm_tm->tm_hour = readb(info->base + S3C2410_ALMHOUR);
220	alm_tm->tm_mon  = readb(info->base + S3C2410_ALMMON);
221	alm_tm->tm_mday = readb(info->base + S3C2410_ALMDATE);
222	alm_tm->tm_year = readb(info->base + S3C2410_ALMYEAR);
223
224	alm_en = readb(info->base + S3C2410_RTCALM);
225
226	s3c_rtc_disable_clk(info);
227
228	alrm->enabled = (alm_en & S3C2410_RTCALM_ALMEN) ? 1 : 0;
229
230	dev_dbg(dev, "read alarm %d, %ptR\n", alm_en, alm_tm);
231
232	/* decode the alarm enable field */
233	if (alm_en & S3C2410_RTCALM_SECEN)
234		alm_tm->tm_sec = bcd2bin(alm_tm->tm_sec);
235
236	if (alm_en & S3C2410_RTCALM_MINEN)
237		alm_tm->tm_min = bcd2bin(alm_tm->tm_min);
238
239	if (alm_en & S3C2410_RTCALM_HOUREN)
240		alm_tm->tm_hour = bcd2bin(alm_tm->tm_hour);
241
242	if (alm_en & S3C2410_RTCALM_DAYEN)
243		alm_tm->tm_mday = bcd2bin(alm_tm->tm_mday);
244
245	if (alm_en & S3C2410_RTCALM_MONEN) {
246		alm_tm->tm_mon = bcd2bin(alm_tm->tm_mon);
247		alm_tm->tm_mon -= 1;
248	}
249
250	if (alm_en & S3C2410_RTCALM_YEAREN)
251		alm_tm->tm_year = bcd2bin(alm_tm->tm_year);
252
253	return 0;
254}
255
256static int s3c_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
257{
258	struct s3c_rtc *info = dev_get_drvdata(dev);
259	struct rtc_time *tm = &alrm->time;
260	unsigned int alrm_en;
261	int ret;
262
263	dev_dbg(dev, "s3c_rtc_setalarm: %d, %ptR\n", alrm->enabled, tm);
264
265	ret = s3c_rtc_enable_clk(info);
266	if (ret)
267		return ret;
268
269	alrm_en = readb(info->base + S3C2410_RTCALM) & S3C2410_RTCALM_ALMEN;
270	writeb(0x00, info->base + S3C2410_RTCALM);
271
272	if (tm->tm_sec < 60 && tm->tm_sec >= 0) {
273		alrm_en |= S3C2410_RTCALM_SECEN;
274		writeb(bin2bcd(tm->tm_sec), info->base + S3C2410_ALMSEC);
275	}
276
277	if (tm->tm_min < 60 && tm->tm_min >= 0) {
278		alrm_en |= S3C2410_RTCALM_MINEN;
279		writeb(bin2bcd(tm->tm_min), info->base + S3C2410_ALMMIN);
280	}
281
282	if (tm->tm_hour < 24 && tm->tm_hour >= 0) {
283		alrm_en |= S3C2410_RTCALM_HOUREN;
284		writeb(bin2bcd(tm->tm_hour), info->base + S3C2410_ALMHOUR);
285	}
286
287	if (tm->tm_mon < 12 && tm->tm_mon >= 0) {
288		alrm_en |= S3C2410_RTCALM_MONEN;
289		writeb(bin2bcd(tm->tm_mon + 1), info->base + S3C2410_ALMMON);
290	}
291
292	if (tm->tm_mday <= 31 && tm->tm_mday >= 1) {
293		alrm_en |= S3C2410_RTCALM_DAYEN;
294		writeb(bin2bcd(tm->tm_mday), info->base + S3C2410_ALMDATE);
295	}
296
297	dev_dbg(dev, "setting S3C2410_RTCALM to %08x\n", alrm_en);
298
299	writeb(alrm_en, info->base + S3C2410_RTCALM);
300
301	s3c_rtc_setaie(dev, alrm->enabled);
302
303	s3c_rtc_disable_clk(info);
304
305	return 0;
306}
307
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
308static const struct rtc_class_ops s3c_rtcops = {
309	.read_time	= s3c_rtc_gettime,
310	.set_time	= s3c_rtc_settime,
311	.read_alarm	= s3c_rtc_getalarm,
312	.set_alarm	= s3c_rtc_setalarm,
 
313	.alarm_irq_enable = s3c_rtc_setaie,
314};
315
316static void s3c24xx_rtc_enable(struct s3c_rtc *info)
317{
318	unsigned int con, tmp;
319
320	con = readw(info->base + S3C2410_RTCCON);
321	/* re-enable the device, and check it is ok */
322	if ((con & S3C2410_RTCCON_RTCEN) == 0) {
323		dev_info(info->dev, "rtc disabled, re-enabling\n");
324
325		tmp = readw(info->base + S3C2410_RTCCON);
326		writew(tmp | S3C2410_RTCCON_RTCEN, info->base + S3C2410_RTCCON);
327	}
328
329	if (con & S3C2410_RTCCON_CNTSEL) {
330		dev_info(info->dev, "removing RTCCON_CNTSEL\n");
331
332		tmp = readw(info->base + S3C2410_RTCCON);
333		writew(tmp & ~S3C2410_RTCCON_CNTSEL,
334		       info->base + S3C2410_RTCCON);
335	}
336
337	if (con & S3C2410_RTCCON_CLKRST) {
338		dev_info(info->dev, "removing RTCCON_CLKRST\n");
339
340		tmp = readw(info->base + S3C2410_RTCCON);
341		writew(tmp & ~S3C2410_RTCCON_CLKRST,
342		       info->base + S3C2410_RTCCON);
343	}
344}
345
346static void s3c24xx_rtc_disable(struct s3c_rtc *info)
347{
348	unsigned int con;
349
350	con = readw(info->base + S3C2410_RTCCON);
351	con &= ~S3C2410_RTCCON_RTCEN;
352	writew(con, info->base + S3C2410_RTCCON);
353
354	con = readb(info->base + S3C2410_TICNT);
355	con &= ~S3C2410_TICNT_ENABLE;
356	writeb(con, info->base + S3C2410_TICNT);
357}
358
359static void s3c6410_rtc_disable(struct s3c_rtc *info)
360{
361	unsigned int con;
362
363	con = readw(info->base + S3C2410_RTCCON);
364	con &= ~S3C64XX_RTCCON_TICEN;
365	con &= ~S3C2410_RTCCON_RTCEN;
366	writew(con, info->base + S3C2410_RTCCON);
367}
368
369static int s3c_rtc_remove(struct platform_device *pdev)
370{
371	struct s3c_rtc *info = platform_get_drvdata(pdev);
372
373	s3c_rtc_setaie(info->dev, 0);
374
375	if (info->data->needs_src_clk)
376		clk_unprepare(info->rtc_src_clk);
377	clk_unprepare(info->rtc_clk);
378
379	return 0;
380}
381
382static int s3c_rtc_probe(struct platform_device *pdev)
383{
384	struct s3c_rtc *info = NULL;
 
385	int ret;
386
387	info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
388	if (!info)
389		return -ENOMEM;
390
 
 
 
 
 
391	info->dev = &pdev->dev;
392	info->data = of_device_get_match_data(&pdev->dev);
393	if (!info->data) {
394		dev_err(&pdev->dev, "failed getting s3c_rtc_data\n");
395		return -EINVAL;
396	}
 
397	spin_lock_init(&info->alarm_lock);
398
399	platform_set_drvdata(pdev, info);
400
401	info->irq_alarm = platform_get_irq(pdev, 0);
402	if (info->irq_alarm < 0)
403		return info->irq_alarm;
404
405	dev_dbg(&pdev->dev, "s3c2410_rtc: alarm irq %d\n", info->irq_alarm);
 
406
407	/* get the memory region */
408	info->base = devm_platform_ioremap_resource(pdev, 0);
409	if (IS_ERR(info->base))
410		return PTR_ERR(info->base);
411
412	info->rtc_clk = devm_clk_get(&pdev->dev, "rtc");
413	if (IS_ERR(info->rtc_clk)) {
414		ret = PTR_ERR(info->rtc_clk);
415		if (ret != -EPROBE_DEFER)
416			dev_err(&pdev->dev, "failed to find rtc clock\n");
417		else
418			dev_dbg(&pdev->dev, "probe deferred due to missing rtc clk\n");
419		return ret;
420	}
421	ret = clk_prepare_enable(info->rtc_clk);
422	if (ret)
423		return ret;
424
425	if (info->data->needs_src_clk) {
426		info->rtc_src_clk = devm_clk_get(&pdev->dev, "rtc_src");
427		if (IS_ERR(info->rtc_src_clk)) {
428			ret = dev_err_probe(&pdev->dev, PTR_ERR(info->rtc_src_clk),
429					    "failed to find rtc source clock\n");
 
 
 
 
 
430			goto err_src_clk;
431		}
432		ret = clk_prepare_enable(info->rtc_src_clk);
433		if (ret)
434			goto err_src_clk;
435	}
436
437	/* disable RTC enable bits potentially set by the bootloader */
438	if (info->data->disable)
439		info->data->disable(info);
440
441	/* check to see if everything is setup correctly */
442	if (info->data->enable)
443		info->data->enable(info);
444
445	dev_dbg(&pdev->dev, "s3c2410_rtc: RTCCON=%02x\n",
446		readw(info->base + S3C2410_RTCCON));
447
448	device_init_wakeup(&pdev->dev, 1);
449
 
 
 
 
 
 
 
 
 
 
 
 
 
 
450	/* register RTC and exit */
451	info->rtc = devm_rtc_device_register(&pdev->dev, "s3c", &s3c_rtcops,
452					     THIS_MODULE);
453	if (IS_ERR(info->rtc)) {
454		dev_err(&pdev->dev, "cannot attach rtc\n");
455		ret = PTR_ERR(info->rtc);
456		goto err_nortc;
457	}
458
459	ret = devm_request_irq(&pdev->dev, info->irq_alarm, s3c_rtc_alarmirq,
460			       0, "s3c2410-rtc alarm", info);
461	if (ret) {
462		dev_err(&pdev->dev, "IRQ%d error %d\n", info->irq_alarm, ret);
463		goto err_nortc;
464	}
465
 
 
 
 
 
 
 
 
 
 
 
 
466	s3c_rtc_disable_clk(info);
467
468	return 0;
469
470err_nortc:
471	if (info->data->disable)
472		info->data->disable(info);
473
474	if (info->data->needs_src_clk)
475		clk_disable_unprepare(info->rtc_src_clk);
476err_src_clk:
477	clk_disable_unprepare(info->rtc_clk);
478
479	return ret;
480}
481
482#ifdef CONFIG_PM_SLEEP
483
484static int s3c_rtc_suspend(struct device *dev)
485{
486	struct s3c_rtc *info = dev_get_drvdata(dev);
487	int ret;
488
489	ret = s3c_rtc_enable_clk(info);
490	if (ret)
491		return ret;
492
 
 
 
 
493	if (info->data->disable)
494		info->data->disable(info);
495
496	if (device_may_wakeup(dev) && !info->wake_en) {
497		if (enable_irq_wake(info->irq_alarm) == 0)
498			info->wake_en = true;
499		else
500			dev_err(dev, "enable_irq_wake failed\n");
501	}
502
503	return 0;
504}
505
506static int s3c_rtc_resume(struct device *dev)
507{
508	struct s3c_rtc *info = dev_get_drvdata(dev);
509
510	if (info->data->enable)
511		info->data->enable(info);
512
 
 
 
513	s3c_rtc_disable_clk(info);
514
515	if (device_may_wakeup(dev) && info->wake_en) {
516		disable_irq_wake(info->irq_alarm);
517		info->wake_en = false;
518	}
519
520	return 0;
521}
522#endif
523static SIMPLE_DEV_PM_OPS(s3c_rtc_pm_ops, s3c_rtc_suspend, s3c_rtc_resume);
524
525static void s3c24xx_rtc_irq(struct s3c_rtc *info, int mask)
526{
527	rtc_update_irq(info->rtc, 1, RTC_AF | RTC_IRQF);
528}
529
530static void s3c6410_rtc_irq(struct s3c_rtc *info, int mask)
531{
532	rtc_update_irq(info->rtc, 1, RTC_AF | RTC_IRQF);
533	writeb(mask, info->base + S3C2410_INTP);
534}
535
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
536static struct s3c_rtc_data const s3c2410_rtc_data = {
 
537	.irq_handler		= s3c24xx_rtc_irq,
 
 
 
 
538	.enable			= s3c24xx_rtc_enable,
539	.disable		= s3c24xx_rtc_disable,
540};
541
542static struct s3c_rtc_data const s3c2416_rtc_data = {
 
543	.irq_handler		= s3c24xx_rtc_irq,
 
 
 
 
 
544	.enable			= s3c24xx_rtc_enable,
545	.disable		= s3c24xx_rtc_disable,
546};
547
548static struct s3c_rtc_data const s3c2443_rtc_data = {
 
549	.irq_handler		= s3c24xx_rtc_irq,
 
 
 
 
 
550	.enable			= s3c24xx_rtc_enable,
551	.disable		= s3c24xx_rtc_disable,
552};
553
554static struct s3c_rtc_data const s3c6410_rtc_data = {
 
555	.needs_src_clk		= true,
556	.irq_handler		= s3c6410_rtc_irq,
 
 
 
 
557	.enable			= s3c24xx_rtc_enable,
558	.disable		= s3c6410_rtc_disable,
559};
560
561static const __maybe_unused struct of_device_id s3c_rtc_dt_match[] = {
562	{
563		.compatible = "samsung,s3c2410-rtc",
564		.data = &s3c2410_rtc_data,
565	}, {
566		.compatible = "samsung,s3c2416-rtc",
567		.data = &s3c2416_rtc_data,
568	}, {
569		.compatible = "samsung,s3c2443-rtc",
570		.data = &s3c2443_rtc_data,
571	}, {
572		.compatible = "samsung,s3c6410-rtc",
573		.data = &s3c6410_rtc_data,
574	}, {
575		.compatible = "samsung,exynos3250-rtc",
576		.data = &s3c6410_rtc_data,
577	},
578	{ /* sentinel */ },
579};
580MODULE_DEVICE_TABLE(of, s3c_rtc_dt_match);
581
582static struct platform_driver s3c_rtc_driver = {
583	.probe		= s3c_rtc_probe,
584	.remove		= s3c_rtc_remove,
585	.driver		= {
586		.name	= "s3c-rtc",
587		.pm	= &s3c_rtc_pm_ops,
588		.of_match_table	= of_match_ptr(s3c_rtc_dt_match),
589	},
590};
591module_platform_driver(s3c_rtc_driver);
592
593MODULE_DESCRIPTION("Samsung S3C RTC Driver");
594MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
595MODULE_LICENSE("GPL");
596MODULE_ALIAS("platform:s3c2410-rtc");