rtc-s3c.c 12.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/* drivers/rtc/rtc-s3c.c
 *
 * Copyright (c) 2004,2006 Simtec Electronics
 *	Ben Dooks, <ben@simtec.co.uk>
 *	http://armlinux.simtec.co.uk/
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * S3C2410/S3C2440/S3C24XX Internal RTC Driver
*/

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/string.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/rtc.h>
#include <linux/bcd.h>
#include <linux/clk.h>
23
#include <linux/log2.h>
24 25 26 27 28

#include <asm/hardware.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <asm/irq.h>
B
Ben Dooks 已提交
29
#include <asm/plat-s3c/regs-rtc.h>
30 31 32 33 34 35 36 37 38 39 40 41 42 43

/* I have yet to find an S3C implementation with more than one
 * of these rtc blocks in */

static struct resource *s3c_rtc_mem;

static void __iomem *s3c_rtc_base;
static int s3c_rtc_alarmno = NO_IRQ;
static int s3c_rtc_tickno  = NO_IRQ;

static DEFINE_SPINLOCK(s3c_rtc_pie_lock);

/* IRQ Handlers */

44
static irqreturn_t s3c_rtc_alarmirq(int irq, void *id)
45 46 47
{
	struct rtc_device *rdev = id;

48
	rtc_update_irq(rdev, 1, RTC_AF | RTC_IRQF);
49 50 51
	return IRQ_HANDLED;
}

52
static irqreturn_t s3c_rtc_tickirq(int irq, void *id)
53 54 55
{
	struct rtc_device *rdev = id;

B
Ben Dooks 已提交
56
	rtc_update_irq(rdev, 1, RTC_PF | RTC_IRQF);
57 58 59 60 61 62 63 64
	return IRQ_HANDLED;
}

/* Update control registers */
static void s3c_rtc_setaie(int to)
{
	unsigned int tmp;

65
	pr_debug("%s: aie=%d\n", __func__, to);
66

B
Ben Dooks 已提交
67
	tmp = readb(s3c_rtc_base + S3C2410_RTCALM) & ~S3C2410_RTCALM_ALMEN;
68 69 70 71

	if (to)
		tmp |= S3C2410_RTCALM_ALMEN;

B
Ben Dooks 已提交
72
	writeb(tmp, s3c_rtc_base + S3C2410_RTCALM);
73 74
}

B
Ben Dooks 已提交
75
static int s3c_rtc_setpie(struct device *dev, int enabled)
76 77 78
{
	unsigned int tmp;

B
Ben Dooks 已提交
79
	pr_debug("%s: pie=%d\n", __func__, enabled);
80 81

	spin_lock_irq(&s3c_rtc_pie_lock);
B
Ben Dooks 已提交
82
	tmp = readb(s3c_rtc_base + S3C2410_TICNT) & ~S3C2410_TICNT_ENABLE;
83

B
Ben Dooks 已提交
84
	if (enabled)
85 86
		tmp |= S3C2410_TICNT_ENABLE;

B
Ben Dooks 已提交
87
	writeb(tmp, s3c_rtc_base + S3C2410_TICNT);
88
	spin_unlock_irq(&s3c_rtc_pie_lock);
B
Ben Dooks 已提交
89 90

	return 0;
91 92
}

B
Ben Dooks 已提交
93
static int s3c_rtc_setfreq(struct device *dev, int freq)
94 95 96 97 98
{
	unsigned int tmp;

	spin_lock_irq(&s3c_rtc_pie_lock);

B
Ben Dooks 已提交
99
	tmp = readb(s3c_rtc_base + S3C2410_TICNT) & S3C2410_TICNT_ENABLE;
100 101
	tmp |= (128 / freq)-1;

B
Ben Dooks 已提交
102
	writeb(tmp, s3c_rtc_base + S3C2410_TICNT);
103
	spin_unlock_irq(&s3c_rtc_pie_lock);
B
Ben Dooks 已提交
104 105

	return 0;
106 107 108 109 110 111 112
}

/* Time read/write */

static int s3c_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm)
{
	unsigned int have_retried = 0;
B
Ben Dooks 已提交
113
	void __iomem *base = s3c_rtc_base;
114 115

 retry_get_time:
B
Ben Dooks 已提交
116 117 118 119 120 121
	rtc_tm->tm_min  = readb(base + S3C2410_RTCMIN);
	rtc_tm->tm_hour = readb(base + S3C2410_RTCHOUR);
	rtc_tm->tm_mday = readb(base + S3C2410_RTCDATE);
	rtc_tm->tm_mon  = readb(base + S3C2410_RTCMON);
	rtc_tm->tm_year = readb(base + S3C2410_RTCYEAR);
	rtc_tm->tm_sec  = readb(base + S3C2410_RTCSEC);
122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151

	/* the only way to work out wether the system was mid-update
	 * when we read it is to check the second counter, and if it
	 * is zero, then we re-try the entire read
	 */

	if (rtc_tm->tm_sec == 0 && !have_retried) {
		have_retried = 1;
		goto retry_get_time;
	}

	pr_debug("read time %02x.%02x.%02x %02x/%02x/%02x\n",
		 rtc_tm->tm_year, rtc_tm->tm_mon, rtc_tm->tm_mday,
		 rtc_tm->tm_hour, rtc_tm->tm_min, rtc_tm->tm_sec);

	BCD_TO_BIN(rtc_tm->tm_sec);
	BCD_TO_BIN(rtc_tm->tm_min);
	BCD_TO_BIN(rtc_tm->tm_hour);
	BCD_TO_BIN(rtc_tm->tm_mday);
	BCD_TO_BIN(rtc_tm->tm_mon);
	BCD_TO_BIN(rtc_tm->tm_year);

	rtc_tm->tm_year += 100;
	rtc_tm->tm_mon -= 1;

	return 0;
}

static int s3c_rtc_settime(struct device *dev, struct rtc_time *tm)
{
B
Ben Dooks 已提交
152
	void __iomem *base = s3c_rtc_base;
153
	int year = tm->tm_year - 100;
B
Ben Dooks 已提交
154

155 156 157 158 159
	pr_debug("set time %02d.%02d.%02d %02d/%02d/%02d\n",
		 tm->tm_year, tm->tm_mon, tm->tm_mday,
		 tm->tm_hour, tm->tm_min, tm->tm_sec);

	/* we get around y2k by simply not supporting it */
160

161
	if (year < 0 || year >= 100) {
B
Ben Dooks 已提交
162
		dev_err(dev, "rtc only supports 100 years\n");
163
		return -EINVAL;
B
Ben Dooks 已提交
164 165 166 167 168 169 170
	}

	writeb(BIN2BCD(tm->tm_sec),  base + S3C2410_RTCSEC);
	writeb(BIN2BCD(tm->tm_min),  base + S3C2410_RTCMIN);
	writeb(BIN2BCD(tm->tm_hour), base + S3C2410_RTCHOUR);
	writeb(BIN2BCD(tm->tm_mday), base + S3C2410_RTCDATE);
	writeb(BIN2BCD(tm->tm_mon + 1), base + S3C2410_RTCMON);
171
	writeb(BIN2BCD(year), base + S3C2410_RTCYEAR);
172 173 174 175 176 177 178

	return 0;
}

static int s3c_rtc_getalarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	struct rtc_time *alm_tm = &alrm->time;
B
Ben Dooks 已提交
179
	void __iomem *base = s3c_rtc_base;
180 181
	unsigned int alm_en;

B
Ben Dooks 已提交
182 183 184 185 186 187
	alm_tm->tm_sec  = readb(base + S3C2410_ALMSEC);
	alm_tm->tm_min  = readb(base + S3C2410_ALMMIN);
	alm_tm->tm_hour = readb(base + S3C2410_ALMHOUR);
	alm_tm->tm_mon  = readb(base + S3C2410_ALMMON);
	alm_tm->tm_mday = readb(base + S3C2410_ALMDATE);
	alm_tm->tm_year = readb(base + S3C2410_ALMYEAR);
188

B
Ben Dooks 已提交
189
	alm_en = readb(base + S3C2410_RTCALM);
190

191 192
	alrm->enabled = (alm_en & S3C2410_RTCALM_ALMEN) ? 1 : 0;

193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238
	pr_debug("read alarm %02x %02x.%02x.%02x %02x/%02x/%02x\n",
		 alm_en,
		 alm_tm->tm_year, alm_tm->tm_mon, alm_tm->tm_mday,
		 alm_tm->tm_hour, alm_tm->tm_min, alm_tm->tm_sec);


	/* decode the alarm enable field */

	if (alm_en & S3C2410_RTCALM_SECEN)
		BCD_TO_BIN(alm_tm->tm_sec);
	else
		alm_tm->tm_sec = 0xff;

	if (alm_en & S3C2410_RTCALM_MINEN)
		BCD_TO_BIN(alm_tm->tm_min);
	else
		alm_tm->tm_min = 0xff;

	if (alm_en & S3C2410_RTCALM_HOUREN)
		BCD_TO_BIN(alm_tm->tm_hour);
	else
		alm_tm->tm_hour = 0xff;

	if (alm_en & S3C2410_RTCALM_DAYEN)
		BCD_TO_BIN(alm_tm->tm_mday);
	else
		alm_tm->tm_mday = 0xff;

	if (alm_en & S3C2410_RTCALM_MONEN) {
		BCD_TO_BIN(alm_tm->tm_mon);
		alm_tm->tm_mon -= 1;
	} else {
		alm_tm->tm_mon = 0xff;
	}

	if (alm_en & S3C2410_RTCALM_YEAREN)
		BCD_TO_BIN(alm_tm->tm_year);
	else
		alm_tm->tm_year = 0xffff;

	return 0;
}

static int s3c_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	struct rtc_time *tm = &alrm->time;
B
Ben Dooks 已提交
239
	void __iomem *base = s3c_rtc_base;
240 241 242 243 244 245 246 247
	unsigned int alrm_en;

	pr_debug("s3c_rtc_setalarm: %d, %02x/%02x/%02x %02x.%02x.%02x\n",
		 alrm->enabled,
		 tm->tm_mday & 0xff, tm->tm_mon & 0xff, tm->tm_year & 0xff,
		 tm->tm_hour & 0xff, tm->tm_min & 0xff, tm->tm_sec);


B
Ben Dooks 已提交
248 249
	alrm_en = readb(base + S3C2410_RTCALM) & S3C2410_RTCALM_ALMEN;
	writeb(0x00, base + S3C2410_RTCALM);
250 251 252

	if (tm->tm_sec < 60 && tm->tm_sec >= 0) {
		alrm_en |= S3C2410_RTCALM_SECEN;
B
Ben Dooks 已提交
253
		writeb(BIN2BCD(tm->tm_sec), base + S3C2410_ALMSEC);
254 255 256 257
	}

	if (tm->tm_min < 60 && tm->tm_min >= 0) {
		alrm_en |= S3C2410_RTCALM_MINEN;
B
Ben Dooks 已提交
258
		writeb(BIN2BCD(tm->tm_min), base + S3C2410_ALMMIN);
259 260 261 262
	}

	if (tm->tm_hour < 24 && tm->tm_hour >= 0) {
		alrm_en |= S3C2410_RTCALM_HOUREN;
B
Ben Dooks 已提交
263
		writeb(BIN2BCD(tm->tm_hour), base + S3C2410_ALMHOUR);
264 265 266 267
	}

	pr_debug("setting S3C2410_RTCALM to %08x\n", alrm_en);

B
Ben Dooks 已提交
268
	writeb(alrm_en, base + S3C2410_RTCALM);
269

B
Ben Dooks 已提交
270
	s3c_rtc_setaie(alrm->enabled);
271 272 273 274 275 276 277 278 279 280 281

	if (alrm->enabled)
		enable_irq_wake(s3c_rtc_alarmno);
	else
		disable_irq_wake(s3c_rtc_alarmno);

	return 0;
}

static int s3c_rtc_proc(struct device *dev, struct seq_file *seq)
{
B
Ben Dooks 已提交
282
	unsigned int ticnt = readb(s3c_rtc_base + S3C2410_TICNT);
283 284 285 286 287 288 289 290 291 292 293 294 295

	seq_printf(seq, "periodic_IRQ\t: %s\n",
		     (ticnt & S3C2410_TICNT_ENABLE) ? "yes" : "no" );
	return 0;
}

static int s3c_rtc_open(struct device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct rtc_device *rtc_dev = platform_get_drvdata(pdev);
	int ret;

	ret = request_irq(s3c_rtc_alarmno, s3c_rtc_alarmirq,
296
			  IRQF_DISABLED,  "s3c2410-rtc alarm", rtc_dev);
297 298 299 300 301 302 303

	if (ret) {
		dev_err(dev, "IRQ%d error %d\n", s3c_rtc_alarmno, ret);
		return ret;
	}

	ret = request_irq(s3c_rtc_tickno, s3c_rtc_tickirq,
304
			  IRQF_DISABLED,  "s3c2410-rtc tick", rtc_dev);
305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324

	if (ret) {
		dev_err(dev, "IRQ%d error %d\n", s3c_rtc_tickno, ret);
		goto tick_err;
	}

	return ret;

 tick_err:
	free_irq(s3c_rtc_alarmno, rtc_dev);
	return ret;
}

static void s3c_rtc_release(struct device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct rtc_device *rtc_dev = platform_get_drvdata(pdev);

	/* do not clear AIE here, it may be needed for wake */

B
Ben Dooks 已提交
325
	s3c_rtc_setpie(dev, 0);
326 327 328 329
	free_irq(s3c_rtc_alarmno, rtc_dev);
	free_irq(s3c_rtc_tickno, rtc_dev);
}

330
static const struct rtc_class_ops s3c_rtcops = {
331 332 333 334 335 336
	.open		= s3c_rtc_open,
	.release	= s3c_rtc_release,
	.read_time	= s3c_rtc_gettime,
	.set_time	= s3c_rtc_settime,
	.read_alarm	= s3c_rtc_getalarm,
	.set_alarm	= s3c_rtc_setalarm,
B
Ben Dooks 已提交
337 338
	.irq_set_freq	= s3c_rtc_setfreq,
	.irq_set_state	= s3c_rtc_setpie,
339 340 341 342 343
	.proc	        = s3c_rtc_proc,
};

static void s3c_rtc_enable(struct platform_device *pdev, int en)
{
B
Ben Dooks 已提交
344
	void __iomem *base = s3c_rtc_base;
345 346 347 348 349 350
	unsigned int tmp;

	if (s3c_rtc_base == NULL)
		return;

	if (!en) {
B
Ben Dooks 已提交
351 352
		tmp = readb(base + S3C2410_RTCCON);
		writeb(tmp & ~S3C2410_RTCCON_RTCEN, base + S3C2410_RTCCON);
353

B
Ben Dooks 已提交
354 355
		tmp = readb(base + S3C2410_TICNT);
		writeb(tmp & ~S3C2410_TICNT_ENABLE, base + S3C2410_TICNT);
356 357 358
	} else {
		/* re-enable the device, and check it is ok */

B
Ben Dooks 已提交
359
		if ((readb(base+S3C2410_RTCCON) & S3C2410_RTCCON_RTCEN) == 0){
360 361
			dev_info(&pdev->dev, "rtc disabled, re-enabling\n");

B
Ben Dooks 已提交
362 363
			tmp = readb(base + S3C2410_RTCCON);
			writeb(tmp|S3C2410_RTCCON_RTCEN, base+S3C2410_RTCCON);
364 365
		}

B
Ben Dooks 已提交
366
		if ((readb(base + S3C2410_RTCCON) & S3C2410_RTCCON_CNTSEL)){
367 368
			dev_info(&pdev->dev, "removing RTCCON_CNTSEL\n");

B
Ben Dooks 已提交
369 370
			tmp = readb(base + S3C2410_RTCCON);
			writeb(tmp& ~S3C2410_RTCCON_CNTSEL, base+S3C2410_RTCCON);
371 372
		}

B
Ben Dooks 已提交
373
		if ((readb(base + S3C2410_RTCCON) & S3C2410_RTCCON_CLKRST)){
374 375
			dev_info(&pdev->dev, "removing RTCCON_CLKRST\n");

B
Ben Dooks 已提交
376 377
			tmp = readb(base + S3C2410_RTCCON);
			writeb(tmp & ~S3C2410_RTCCON_CLKRST, base+S3C2410_RTCCON);
378 379 380 381
		}
	}
}

382
static int __devexit s3c_rtc_remove(struct platform_device *dev)
383 384 385 386 387 388
{
	struct rtc_device *rtc = platform_get_drvdata(dev);

	platform_set_drvdata(dev, NULL);
	rtc_device_unregister(rtc);

B
Ben Dooks 已提交
389
	s3c_rtc_setpie(&dev->dev, 0);
390 391 392 393 394 395 396 397 398
	s3c_rtc_setaie(0);

	iounmap(s3c_rtc_base);
	release_resource(s3c_rtc_mem);
	kfree(s3c_rtc_mem);

	return 0;
}

399
static int __devinit s3c_rtc_probe(struct platform_device *pdev)
400 401 402 403 404
{
	struct rtc_device *rtc;
	struct resource *res;
	int ret;

405
	pr_debug("%s: probe=%p\n", __func__, pdev);
406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432

	/* find the IRQs */

	s3c_rtc_tickno = platform_get_irq(pdev, 1);
	if (s3c_rtc_tickno < 0) {
		dev_err(&pdev->dev, "no irq for rtc tick\n");
		return -ENOENT;
	}

	s3c_rtc_alarmno = platform_get_irq(pdev, 0);
	if (s3c_rtc_alarmno < 0) {
		dev_err(&pdev->dev, "no irq for alarm\n");
		return -ENOENT;
	}

	pr_debug("s3c2410_rtc: tick irq %d, alarm irq %d\n",
		 s3c_rtc_tickno, s3c_rtc_alarmno);

	/* get the memory region */

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (res == NULL) {
		dev_err(&pdev->dev, "failed to get memory region resource\n");
		return -ENOENT;
	}

	s3c_rtc_mem = request_mem_region(res->start,
B
Ben Dooks 已提交
433 434
					 res->end-res->start+1,
					 pdev->name);
435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452

	if (s3c_rtc_mem == NULL) {
		dev_err(&pdev->dev, "failed to reserve memory region\n");
		ret = -ENOENT;
		goto err_nores;
	}

	s3c_rtc_base = ioremap(res->start, res->end - res->start + 1);
	if (s3c_rtc_base == NULL) {
		dev_err(&pdev->dev, "failed ioremap()\n");
		ret = -EINVAL;
		goto err_nomap;
	}

	/* check to see if everything is setup correctly */

	s3c_rtc_enable(pdev, 1);

B
Ben Dooks 已提交
453 454
 	pr_debug("s3c2410_rtc: RTCCON=%02x\n",
		 readb(s3c_rtc_base + S3C2410_RTCCON));
455

B
Ben Dooks 已提交
456
	s3c_rtc_setfreq(&pdev->dev, 1);
457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493

	/* register RTC and exit */

	rtc = rtc_device_register("s3c", &pdev->dev, &s3c_rtcops,
				  THIS_MODULE);

	if (IS_ERR(rtc)) {
		dev_err(&pdev->dev, "cannot attach rtc\n");
		ret = PTR_ERR(rtc);
		goto err_nortc;
	}

	rtc->max_user_freq = 128;

	platform_set_drvdata(pdev, rtc);
	return 0;

 err_nortc:
	s3c_rtc_enable(pdev, 0);
	iounmap(s3c_rtc_base);

 err_nomap:
	release_resource(s3c_rtc_mem);

 err_nores:
	return ret;
}

#ifdef CONFIG_PM

/* RTC Power management control */

static int ticnt_save;

static int s3c_rtc_suspend(struct platform_device *pdev, pm_message_t state)
{
	/* save TICNT for anyone using periodic interrupts */
B
Ben Dooks 已提交
494
	ticnt_save = readb(s3c_rtc_base + S3C2410_TICNT);
495 496 497 498 499 500 501
	s3c_rtc_enable(pdev, 0);
	return 0;
}

static int s3c_rtc_resume(struct platform_device *pdev)
{
	s3c_rtc_enable(pdev, 1);
B
Ben Dooks 已提交
502
	writeb(ticnt_save, s3c_rtc_base + S3C2410_TICNT);
503 504 505 506 507 508 509 510 511
	return 0;
}
#else
#define s3c_rtc_suspend NULL
#define s3c_rtc_resume  NULL
#endif

static struct platform_driver s3c2410_rtcdrv = {
	.probe		= s3c_rtc_probe,
512
	.remove		= __devexit_p(s3c_rtc_remove),
513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539
	.suspend	= s3c_rtc_suspend,
	.resume		= s3c_rtc_resume,
	.driver		= {
		.name	= "s3c2410-rtc",
		.owner	= THIS_MODULE,
	},
};

static char __initdata banner[] = "S3C24XX RTC, (c) 2004,2006 Simtec Electronics\n";

static int __init s3c_rtc_init(void)
{
	printk(banner);
	return platform_driver_register(&s3c2410_rtcdrv);
}

static void __exit s3c_rtc_exit(void)
{
	platform_driver_unregister(&s3c2410_rtcdrv);
}

module_init(s3c_rtc_init);
module_exit(s3c_rtc_exit);

MODULE_DESCRIPTION("Samsung S3C RTC Driver");
MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
MODULE_LICENSE("GPL");
540
MODULE_ALIAS("platform:s3c2410-rtc");