rtc-sh.c 21.2 KB
Newer Older
1 2 3
/*
 * SuperH On-Chip RTC Support
 *
4
 * Copyright (C) 2006 - 2009  Paul Mundt
J
Jamie Lenehan 已提交
5
 * Copyright (C) 2006  Jamie Lenehan
6
 * Copyright (C) 2008  Angelo Castello
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
 *
 * Based on the old arch/sh/kernel/cpu/rtc.c by:
 *
 *  Copyright (C) 2000  Philipp Rumpf <prumpf@tux.org>
 *  Copyright (C) 1999  Tetsuya Okada & Niibe Yutaka
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/bcd.h>
#include <linux/rtc.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/seq_file.h>
#include <linux/interrupt.h>
#include <linux/spinlock.h>
26
#include <linux/io.h>
27
#include <linux/log2.h>
28
#include <linux/clk.h>
29
#include <asm/rtc.h>
30

J
Jamie Lenehan 已提交
31
#define DRV_NAME	"sh-rtc"
32
#define DRV_VERSION	"0.2.2"
33 34 35

#define RTC_REG(r)	((r) * rtc_reg_size)

36
#define R64CNT		RTC_REG(0)
J
Jamie Lenehan 已提交
37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

#define RSECCNT		RTC_REG(1)	/* RTC sec */
#define RMINCNT		RTC_REG(2)	/* RTC min */
#define RHRCNT		RTC_REG(3)	/* RTC hour */
#define RWKCNT		RTC_REG(4)	/* RTC week */
#define RDAYCNT		RTC_REG(5)	/* RTC day */
#define RMONCNT		RTC_REG(6)	/* RTC month */
#define RYRCNT		RTC_REG(7)	/* RTC year */
#define RSECAR		RTC_REG(8)	/* ALARM sec */
#define RMINAR		RTC_REG(9)	/* ALARM min */
#define RHRAR		RTC_REG(10)	/* ALARM hour */
#define RWKAR		RTC_REG(11)	/* ALARM week */
#define RDAYAR		RTC_REG(12)	/* ALARM day */
#define RMONAR		RTC_REG(13)	/* ALARM month */
#define RCR1		RTC_REG(14)	/* Control */
#define RCR2		RTC_REG(15)	/* Control */

P
Paul Mundt 已提交
54 55 56 57 58 59 60 61 62 63 64 65
/*
 * Note on RYRAR and RCR3: Up until this point most of the register
 * definitions are consistent across all of the available parts. However,
 * the placement of the optional RYRAR and RCR3 (the RYRAR control
 * register used to control RYRCNT/RYRAR compare) varies considerably
 * across various parts, occasionally being mapped in to a completely
 * unrelated address space. For proper RYRAR support a separate resource
 * would have to be handed off, but as this is purely optional in
 * practice, we simply opt not to support it, thereby keeping the code
 * quite a bit more simplified.
 */

J
Jamie Lenehan 已提交
66 67
/* ALARM Bits - or with BCD encoded value */
#define AR_ENB		0x80	/* Enable for alarm cmp   */
68

69 70 71 72 73 74 75
/* Period Bits */
#define PF_HP		0x100	/* Enable Half Period to support 8,32,128Hz */
#define PF_COUNT	0x200	/* Half periodic counter */
#define PF_OXS		0x400	/* Periodic One x Second */
#define PF_KOU		0x800	/* Kernel or User periodic request 1=kernel */
#define PF_MASK		0xf00

76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
/* RCR1 Bits */
#define RCR1_CF		0x80	/* Carry Flag             */
#define RCR1_CIE	0x10	/* Carry Interrupt Enable */
#define RCR1_AIE	0x08	/* Alarm Interrupt Enable */
#define RCR1_AF		0x01	/* Alarm Flag             */

/* RCR2 Bits */
#define RCR2_PEF	0x80	/* PEriodic interrupt Flag */
#define RCR2_PESMASK	0x70	/* Periodic interrupt Set  */
#define RCR2_RTCEN	0x08	/* ENable RTC              */
#define RCR2_ADJ	0x04	/* ADJustment (30-second)  */
#define RCR2_RESET	0x02	/* Reset bit               */
#define RCR2_START	0x01	/* Start bit               */

struct sh_rtc {
91 92 93 94 95 96 97 98 99 100 101
	void __iomem		*regbase;
	unsigned long		regsize;
	struct resource		*res;
	int			alarm_irq;
	int			periodic_irq;
	int			carry_irq;
	struct clk		*clk;
	struct rtc_device	*rtc_dev;
	spinlock_t		lock;
	unsigned long		capabilities;	/* See asm/rtc.h for cap bits */
	unsigned short		periodic_freq;
102 103
};

104
static int __sh_rtc_interrupt(struct sh_rtc *rtc)
105
{
106
	unsigned int tmp, pending;
107 108

	tmp = readb(rtc->regbase + RCR1);
109
	pending = tmp & RCR1_CF;
J
Jamie Lenehan 已提交
110
	tmp &= ~RCR1_CF;
111 112
	writeb(tmp, rtc->regbase + RCR1);

113
	/* Users have requested One x Second IRQ */
114
	if (pending && rtc->periodic_freq & PF_OXS)
115
		rtc_update_irq(rtc->rtc_dev, 1, RTC_UF | RTC_IRQF);
116

117
	return pending;
118 119
}

120
static int __sh_rtc_alarm(struct sh_rtc *rtc)
J
Jamie Lenehan 已提交
121
{
122
	unsigned int tmp, pending;
J
Jamie Lenehan 已提交
123 124

	tmp = readb(rtc->regbase + RCR1);
125
	pending = tmp & RCR1_AF;
126
	tmp &= ~(RCR1_AF | RCR1_AIE);
127
	writeb(tmp, rtc->regbase + RCR1);
J
Jamie Lenehan 已提交
128

129 130
	if (pending)
		rtc_update_irq(rtc->rtc_dev, 1, RTC_AF | RTC_IRQF);
131

132
	return pending;
J
Jamie Lenehan 已提交
133 134
}

135
static int __sh_rtc_periodic(struct sh_rtc *rtc)
136
{
137
	struct rtc_device *rtc_dev = rtc->rtc_dev;
138 139
	struct rtc_task *irq_task;
	unsigned int tmp, pending;
140

141
	tmp = readb(rtc->regbase + RCR2);
142
	pending = tmp & RCR2_PEF;
143 144 145
	tmp &= ~RCR2_PEF;
	writeb(tmp, rtc->regbase + RCR2);

146 147 148
	if (!pending)
		return 0;

149 150 151 152 153 154 155 156
	/* Half period enabled than one skipped and the next notified */
	if ((rtc->periodic_freq & PF_HP) && (rtc->periodic_freq & PF_COUNT))
		rtc->periodic_freq &= ~PF_COUNT;
	else {
		if (rtc->periodic_freq & PF_HP)
			rtc->periodic_freq |= PF_COUNT;
		if (rtc->periodic_freq & PF_KOU) {
			spin_lock(&rtc_dev->irq_task_lock);
157 158 159
			irq_task = rtc_dev->irq_task;
			if (irq_task)
				irq_task->func(irq_task->private_data);
160 161 162 163
			spin_unlock(&rtc_dev->irq_task_lock);
		} else
			rtc_update_irq(rtc->rtc_dev, 1, RTC_PF | RTC_IRQF);
	}
164

165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198
	return pending;
}

static irqreturn_t sh_rtc_interrupt(int irq, void *dev_id)
{
	struct sh_rtc *rtc = dev_id;
	int ret;

	spin_lock(&rtc->lock);
	ret = __sh_rtc_interrupt(rtc);
	spin_unlock(&rtc->lock);

	return IRQ_RETVAL(ret);
}

static irqreturn_t sh_rtc_alarm(int irq, void *dev_id)
{
	struct sh_rtc *rtc = dev_id;
	int ret;

	spin_lock(&rtc->lock);
	ret = __sh_rtc_alarm(rtc);
	spin_unlock(&rtc->lock);

	return IRQ_RETVAL(ret);
}

static irqreturn_t sh_rtc_periodic(int irq, void *dev_id)
{
	struct sh_rtc *rtc = dev_id;
	int ret;

	spin_lock(&rtc->lock);
	ret = __sh_rtc_periodic(rtc);
199 200
	spin_unlock(&rtc->lock);

201 202 203 204 205 206 207 208 209 210 211 212 213 214 215
	return IRQ_RETVAL(ret);
}

static irqreturn_t sh_rtc_shared(int irq, void *dev_id)
{
	struct sh_rtc *rtc = dev_id;
	int ret;

	spin_lock(&rtc->lock);
	ret = __sh_rtc_interrupt(rtc);
	ret |= __sh_rtc_alarm(rtc);
	ret |= __sh_rtc_periodic(rtc);
	spin_unlock(&rtc->lock);

	return IRQ_RETVAL(ret);
216 217 218 219 220 221 222 223 224 225 226 227
}

static inline void sh_rtc_setpie(struct device *dev, unsigned int enable)
{
	struct sh_rtc *rtc = dev_get_drvdata(dev);
	unsigned int tmp;

	spin_lock_irq(&rtc->lock);

	tmp = readb(rtc->regbase + RCR2);

	if (enable) {
228 229
		tmp &= ~RCR2_PEF;	/* Clear PES bit */
		tmp |= (rtc->periodic_freq & ~PF_HP);	/* Set PES2-0 */
230 231 232 233 234 235 236 237
	} else
		tmp &= ~(RCR2_PESMASK | RCR2_PEF);

	writeb(tmp, rtc->regbase + RCR2);

	spin_unlock_irq(&rtc->lock);
}

238
static inline int sh_rtc_setfreq(struct device *dev, unsigned int freq)
239 240
{
	struct sh_rtc *rtc = dev_get_drvdata(dev);
241
	int tmp, ret = 0;
242 243

	spin_lock_irq(&rtc->lock);
244
	tmp = rtc->periodic_freq & PF_MASK;
245

246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
	switch (freq) {
	case 0:
		rtc->periodic_freq = 0x00;
		break;
	case 1:
		rtc->periodic_freq = 0x60;
		break;
	case 2:
		rtc->periodic_freq = 0x50;
		break;
	case 4:
		rtc->periodic_freq = 0x40;
		break;
	case 8:
		rtc->periodic_freq = 0x30 | PF_HP;
		break;
	case 16:
		rtc->periodic_freq = 0x30;
		break;
	case 32:
		rtc->periodic_freq = 0x20 | PF_HP;
		break;
	case 64:
		rtc->periodic_freq = 0x20;
		break;
	case 128:
		rtc->periodic_freq = 0x10 | PF_HP;
		break;
	case 256:
		rtc->periodic_freq = 0x10;
		break;
	default:
		ret = -ENOTSUPP;
	}
280

281 282 283 284
	if (ret == 0) {
		rtc->periodic_freq |= tmp;
		rtc->rtc_dev->irq_freq = freq;
	}
285 286

	spin_unlock_irq(&rtc->lock);
287
	return ret;
288 289
}

290
static inline void sh_rtc_setaie(struct device *dev, unsigned int enable)
291 292 293 294
{
	struct sh_rtc *rtc = dev_get_drvdata(dev);
	unsigned int tmp;

295
	spin_lock_irq(&rtc->lock);
296

297
	tmp = readb(rtc->regbase + RCR1);
298

299
	if (enable)
300
		tmp |= RCR1_AIE;
301 302
	else
		tmp &= ~RCR1_AIE;
303

304
	writeb(tmp, rtc->regbase + RCR1);
305

306
	spin_unlock_irq(&rtc->lock);
307 308 309 310 311 312 313 314
}

static int sh_rtc_proc(struct device *dev, struct seq_file *seq)
{
	struct sh_rtc *rtc = dev_get_drvdata(dev);
	unsigned int tmp;

	tmp = readb(rtc->regbase + RCR1);
315
	seq_printf(seq, "carry_IRQ\t: %s\n", (tmp & RCR1_CIE) ? "yes" : "no");
316 317 318

	tmp = readb(rtc->regbase + RCR2);
	seq_printf(seq, "periodic_IRQ\t: %s\n",
319
		   (tmp & RCR2_PESMASK) ? "yes" : "no");
320 321 322 323

	return 0;
}

M
Magnus Damm 已提交
324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342
static inline void sh_rtc_setcie(struct device *dev, unsigned int enable)
{
	struct sh_rtc *rtc = dev_get_drvdata(dev);
	unsigned int tmp;

	spin_lock_irq(&rtc->lock);

	tmp = readb(rtc->regbase + RCR1);

	if (!enable)
		tmp &= ~RCR1_CIE;
	else
		tmp |= RCR1_CIE;

	writeb(tmp, rtc->regbase + RCR1);

	spin_unlock_irq(&rtc->lock);
}

343 344
static int sh_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
{
345 346
	struct sh_rtc *rtc = dev_get_drvdata(dev);
	unsigned int ret = 0;
347 348 349 350 351 352 353 354 355 356

	switch (cmd) {
	case RTC_PIE_OFF:
	case RTC_PIE_ON:
		sh_rtc_setpie(dev, cmd == RTC_PIE_ON);
		break;
	case RTC_AIE_OFF:
	case RTC_AIE_ON:
		sh_rtc_setaie(dev, cmd == RTC_AIE_ON);
		break;
357 358
	case RTC_UIE_OFF:
		rtc->periodic_freq &= ~PF_OXS;
M
Magnus Damm 已提交
359
		sh_rtc_setcie(dev, 0);
360 361 362
		break;
	case RTC_UIE_ON:
		rtc->periodic_freq |= PF_OXS;
M
Magnus Damm 已提交
363
		sh_rtc_setcie(dev, 1);
364 365 366 367 368 369 370 371 372 373
		break;
	case RTC_IRQP_READ:
		ret = put_user(rtc->rtc_dev->irq_freq,
			       (unsigned long __user *)arg);
		break;
	case RTC_IRQP_SET:
		ret = sh_rtc_setfreq(dev, arg);
		break;
	default:
		ret = -ENOIOCTLCMD;
374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396
	}

	return ret;
}

static int sh_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct sh_rtc *rtc = platform_get_drvdata(pdev);
	unsigned int sec128, sec2, yr, yr100, cf_bit;

	do {
		unsigned int tmp;

		spin_lock_irq(&rtc->lock);

		tmp = readb(rtc->regbase + RCR1);
		tmp &= ~RCR1_CF; /* Clear CF-bit */
		tmp |= RCR1_CIE;
		writeb(tmp, rtc->regbase + RCR1);

		sec128 = readb(rtc->regbase + R64CNT);

A
Adrian Bunk 已提交
397 398 399 400 401 402
		tm->tm_sec	= bcd2bin(readb(rtc->regbase + RSECCNT));
		tm->tm_min	= bcd2bin(readb(rtc->regbase + RMINCNT));
		tm->tm_hour	= bcd2bin(readb(rtc->regbase + RHRCNT));
		tm->tm_wday	= bcd2bin(readb(rtc->regbase + RWKCNT));
		tm->tm_mday	= bcd2bin(readb(rtc->regbase + RDAYCNT));
		tm->tm_mon	= bcd2bin(readb(rtc->regbase + RMONCNT)) - 1;
403

404 405
		if (rtc->capabilities & RTC_CAP_4_DIGIT_YEAR) {
			yr  = readw(rtc->regbase + RYRCNT);
A
Adrian Bunk 已提交
406
			yr100 = bcd2bin(yr >> 8);
407 408 409
			yr &= 0xff;
		} else {
			yr  = readb(rtc->regbase + RYRCNT);
A
Adrian Bunk 已提交
410
			yr100 = bcd2bin((yr == 0x99) ? 0x19 : 0x20);
411
		}
412

A
Adrian Bunk 已提交
413
		tm->tm_year = (yr100 * 100 + bcd2bin(yr)) - 1900;
414 415 416 417 418 419 420 421 422 423 424 425

		sec2 = readb(rtc->regbase + R64CNT);
		cf_bit = readb(rtc->regbase + RCR1) & RCR1_CF;

		spin_unlock_irq(&rtc->lock);
	} while (cf_bit != 0 || ((sec128 ^ sec2) & RTC_BIT_INVERTED) != 0);

#if RTC_BIT_INVERTED != 0
	if ((sec128 & RTC_BIT_INVERTED))
		tm->tm_sec--;
#endif

M
Magnus Damm 已提交
426 427 428 429
	/* only keep the carry interrupt enabled if UIE is on */
	if (!(rtc->periodic_freq & PF_OXS))
		sh_rtc_setcie(dev, 0);

430
	dev_dbg(dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
431
		"mday=%d, mon=%d, year=%d, wday=%d\n",
432
		__func__,
433
		tm->tm_sec, tm->tm_min, tm->tm_hour,
434
		tm->tm_mday, tm->tm_mon + 1, tm->tm_year, tm->tm_wday);
435

M
Magnus Damm 已提交
436
	return rtc_valid_tm(tm);
437 438 439 440 441 442 443 444 445 446 447 448 449 450
}

static int sh_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct sh_rtc *rtc = platform_get_drvdata(pdev);
	unsigned int tmp;
	int year;

	spin_lock_irq(&rtc->lock);

	/* Reset pre-scaler & stop RTC */
	tmp = readb(rtc->regbase + RCR2);
	tmp |= RCR2_RESET;
451
	tmp &= ~RCR2_START;
452 453
	writeb(tmp, rtc->regbase + RCR2);

A
Adrian Bunk 已提交
454 455 456 457 458 459
	writeb(bin2bcd(tm->tm_sec),  rtc->regbase + RSECCNT);
	writeb(bin2bcd(tm->tm_min),  rtc->regbase + RMINCNT);
	writeb(bin2bcd(tm->tm_hour), rtc->regbase + RHRCNT);
	writeb(bin2bcd(tm->tm_wday), rtc->regbase + RWKCNT);
	writeb(bin2bcd(tm->tm_mday), rtc->regbase + RDAYCNT);
	writeb(bin2bcd(tm->tm_mon + 1), rtc->regbase + RMONCNT);
460

461
	if (rtc->capabilities & RTC_CAP_4_DIGIT_YEAR) {
A
Adrian Bunk 已提交
462 463
		year = (bin2bcd((tm->tm_year + 1900) / 100) << 8) |
			bin2bcd(tm->tm_year % 100);
464 465 466
		writew(year, rtc->regbase + RYRCNT);
	} else {
		year = tm->tm_year % 100;
A
Adrian Bunk 已提交
467
		writeb(bin2bcd(year), rtc->regbase + RYRCNT);
468
	}
469 470 471 472 473 474 475 476 477 478 479 480

	/* Start RTC */
	tmp = readb(rtc->regbase + RCR2);
	tmp &= ~RCR2_RESET;
	tmp |= RCR2_RTCEN | RCR2_START;
	writeb(tmp, rtc->regbase + RCR2);

	spin_unlock_irq(&rtc->lock);

	return 0;
}

J
Jamie Lenehan 已提交
481 482 483 484 485 486 487 488
static inline int sh_rtc_read_alarm_value(struct sh_rtc *rtc, int reg_off)
{
	unsigned int byte;
	int value = 0xff;	/* return 0xff for ignored values */

	byte = readb(rtc->regbase + reg_off);
	if (byte & AR_ENB) {
		byte &= ~AR_ENB;	/* strip the enable bit */
A
Adrian Bunk 已提交
489
		value = bcd2bin(byte);
J
Jamie Lenehan 已提交
490 491 492 493 494 495 496 497 498
	}

	return value;
}

static int sh_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *wkalrm)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct sh_rtc *rtc = platform_get_drvdata(pdev);
499
	struct rtc_time *tm = &wkalrm->time;
J
Jamie Lenehan 已提交
500 501 502 503 504 505 506 507 508 509 510 511 512

	spin_lock_irq(&rtc->lock);

	tm->tm_sec	= sh_rtc_read_alarm_value(rtc, RSECAR);
	tm->tm_min	= sh_rtc_read_alarm_value(rtc, RMINAR);
	tm->tm_hour	= sh_rtc_read_alarm_value(rtc, RHRAR);
	tm->tm_wday	= sh_rtc_read_alarm_value(rtc, RWKAR);
	tm->tm_mday	= sh_rtc_read_alarm_value(rtc, RDAYAR);
	tm->tm_mon	= sh_rtc_read_alarm_value(rtc, RMONAR);
	if (tm->tm_mon > 0)
		tm->tm_mon -= 1; /* RTC is 1-12, tm_mon is 0-11 */
	tm->tm_year     = 0xffff;

513 514
	wkalrm->enabled = (readb(rtc->regbase + RCR1) & RCR1_AIE) ? 1 : 0;

J
Jamie Lenehan 已提交
515 516 517 518 519 520 521 522 523 524 525 526
	spin_unlock_irq(&rtc->lock);

	return 0;
}

static inline void sh_rtc_write_alarm_value(struct sh_rtc *rtc,
					    int value, int reg_off)
{
	/* < 0 for a value that is ignored */
	if (value < 0)
		writeb(0, rtc->regbase + reg_off);
	else
A
Adrian Bunk 已提交
527
		writeb(bin2bcd(value) | AR_ENB,  rtc->regbase + reg_off);
J
Jamie Lenehan 已提交
528 529
}

530
static int sh_rtc_check_alarm(struct rtc_time *tm)
J
Jamie Lenehan 已提交
531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578
{
	/*
	 * The original rtc says anything > 0xc0 is "don't care" or "match
	 * all" - most users use 0xff but rtc-dev uses -1 for the same thing.
	 * The original rtc doesn't support years - some things use -1 and
	 * some 0xffff. We use -1 to make out tests easier.
	 */
	if (tm->tm_year == 0xffff)
		tm->tm_year = -1;
	if (tm->tm_mon >= 0xff)
		tm->tm_mon = -1;
	if (tm->tm_mday >= 0xff)
		tm->tm_mday = -1;
	if (tm->tm_wday >= 0xff)
		tm->tm_wday = -1;
	if (tm->tm_hour >= 0xff)
		tm->tm_hour = -1;
	if (tm->tm_min >= 0xff)
		tm->tm_min = -1;
	if (tm->tm_sec >= 0xff)
		tm->tm_sec = -1;

	if (tm->tm_year > 9999 ||
		tm->tm_mon >= 12 ||
		tm->tm_mday == 0 || tm->tm_mday >= 32 ||
		tm->tm_wday >= 7 ||
		tm->tm_hour >= 24 ||
		tm->tm_min >= 60 ||
		tm->tm_sec >= 60)
		return -EINVAL;

	return 0;
}

static int sh_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *wkalrm)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct sh_rtc *rtc = platform_get_drvdata(pdev);
	unsigned int rcr1;
	struct rtc_time *tm = &wkalrm->time;
	int mon, err;

	err = sh_rtc_check_alarm(tm);
	if (unlikely(err < 0))
		return err;

	spin_lock_irq(&rtc->lock);

579
	/* disable alarm interrupt and clear the alarm flag */
J
Jamie Lenehan 已提交
580
	rcr1 = readb(rtc->regbase + RCR1);
581
	rcr1 &= ~(RCR1_AF | RCR1_AIE);
582
	writeb(rcr1, rtc->regbase + RCR1);
J
Jamie Lenehan 已提交
583 584 585 586 587 588 589 590 591 592 593 594

	/* set alarm time */
	sh_rtc_write_alarm_value(rtc, tm->tm_sec,  RSECAR);
	sh_rtc_write_alarm_value(rtc, tm->tm_min,  RMINAR);
	sh_rtc_write_alarm_value(rtc, tm->tm_hour, RHRAR);
	sh_rtc_write_alarm_value(rtc, tm->tm_wday, RWKAR);
	sh_rtc_write_alarm_value(rtc, tm->tm_mday, RDAYAR);
	mon = tm->tm_mon;
	if (mon >= 0)
		mon += 1;
	sh_rtc_write_alarm_value(rtc, mon, RMONAR);

595 596 597 598
	if (wkalrm->enabled) {
		rcr1 |= RCR1_AIE;
		writeb(rcr1, rtc->regbase + RCR1);
	}
J
Jamie Lenehan 已提交
599 600 601 602 603 604

	spin_unlock_irq(&rtc->lock);

	return 0;
}

605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620
static int sh_rtc_irq_set_state(struct device *dev, int enabled)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct sh_rtc *rtc = platform_get_drvdata(pdev);

	if (enabled) {
		rtc->periodic_freq |= PF_KOU;
		return sh_rtc_ioctl(dev, RTC_PIE_ON, 0);
	} else {
		rtc->periodic_freq &= ~PF_KOU;
		return sh_rtc_ioctl(dev, RTC_PIE_OFF, 0);
	}
}

static int sh_rtc_irq_set_freq(struct device *dev, int freq)
{
621 622
	if (!is_power_of_2(freq))
		return -EINVAL;
623

624 625 626
	return sh_rtc_ioctl(dev, RTC_IRQP_SET, freq);
}

627 628 629 630
static struct rtc_class_ops sh_rtc_ops = {
	.ioctl		= sh_rtc_ioctl,
	.read_time	= sh_rtc_read_time,
	.set_time	= sh_rtc_set_time,
J
Jamie Lenehan 已提交
631 632
	.read_alarm	= sh_rtc_read_alarm,
	.set_alarm	= sh_rtc_set_alarm,
633 634
	.irq_set_state	= sh_rtc_irq_set_state,
	.irq_set_freq	= sh_rtc_irq_set_freq,
635 636 637 638 639 640 641
	.proc		= sh_rtc_proc,
};

static int __devinit sh_rtc_probe(struct platform_device *pdev)
{
	struct sh_rtc *rtc;
	struct resource *res;
M
Magnus Damm 已提交
642
	struct rtc_time r;
643 644
	char clk_name[6];
	int clk_id, ret;
645 646 647 648 649 650 651

	rtc = kzalloc(sizeof(struct sh_rtc), GFP_KERNEL);
	if (unlikely(!rtc))
		return -ENOMEM;

	spin_lock_init(&rtc->lock);

652
	/* get periodic/carry/alarm irqs */
653
	ret = platform_get_irq(pdev, 0);
654
	if (unlikely(ret <= 0)) {
655
		ret = -ENOENT;
656
		dev_err(&pdev->dev, "No IRQ resource\n");
657 658
		goto err_badres;
	}
659

660
	rtc->periodic_irq = ret;
661 662
	rtc->carry_irq = platform_get_irq(pdev, 1);
	rtc->alarm_irq = platform_get_irq(pdev, 2);
663 664 665

	res = platform_get_resource(pdev, IORESOURCE_IO, 0);
	if (unlikely(res == NULL)) {
666
		ret = -ENOENT;
667 668 669 670
		dev_err(&pdev->dev, "No IO resource\n");
		goto err_badres;
	}

671
	rtc->regsize = resource_size(res);
672 673 674 675 676 677 678

	rtc->res = request_mem_region(res->start, rtc->regsize, pdev->name);
	if (unlikely(!rtc->res)) {
		ret = -EBUSY;
		goto err_badres;
	}

679
	rtc->regbase = ioremap_nocache(rtc->res->start, rtc->regsize);
680 681 682 683 684
	if (unlikely(!rtc->regbase)) {
		ret = -EINVAL;
		goto err_badmap;
	}

685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704
	clk_id = pdev->id;
	/* With a single device, the clock id is still "rtc0" */
	if (clk_id < 0)
		clk_id = 0;

	snprintf(clk_name, sizeof(clk_name), "rtc%d", clk_id);

	rtc->clk = clk_get(&pdev->dev, clk_name);
	if (IS_ERR(rtc->clk)) {
		/*
		 * No error handling for rtc->clk intentionally, not all
		 * platforms will have a unique clock for the RTC, and
		 * the clk API can handle the struct clk pointer being
		 * NULL.
		 */
		rtc->clk = NULL;
	}

	clk_enable(rtc->clk);

705 706
	rtc->rtc_dev = rtc_device_register("sh", &pdev->dev,
					   &sh_rtc_ops, THIS_MODULE);
707
	if (IS_ERR(rtc->rtc_dev)) {
708
		ret = PTR_ERR(rtc->rtc_dev);
709
		goto err_unmap;
710 711
	}

712 713 714 715 716 717 718 719 720 721 722
	rtc->capabilities = RTC_DEF_CAPABILITIES;
	if (pdev->dev.platform_data) {
		struct sh_rtc_platform_info *pinfo = pdev->dev.platform_data;

		/*
		 * Some CPUs have special capabilities in addition to the
		 * default set. Add those in here.
		 */
		rtc->capabilities |= pinfo->capabilities;
	}

723 724
	rtc->rtc_dev->max_user_freq = 256;

725 726
	platform_set_drvdata(pdev, rtc);

727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746
	if (rtc->carry_irq <= 0) {
		/* register shared periodic/carry/alarm irq */
		ret = request_irq(rtc->periodic_irq, sh_rtc_shared,
				  IRQF_DISABLED, "sh-rtc", rtc);
		if (unlikely(ret)) {
			dev_err(&pdev->dev,
				"request IRQ failed with %d, IRQ %d\n", ret,
				rtc->periodic_irq);
			goto err_unmap;
		}
	} else {
		/* register periodic/carry/alarm irqs */
		ret = request_irq(rtc->periodic_irq, sh_rtc_periodic,
				  IRQF_DISABLED, "sh-rtc period", rtc);
		if (unlikely(ret)) {
			dev_err(&pdev->dev,
				"request period IRQ failed with %d, IRQ %d\n",
				ret, rtc->periodic_irq);
			goto err_unmap;
		}
747

748 749 750 751 752 753 754 755 756
		ret = request_irq(rtc->carry_irq, sh_rtc_interrupt,
				  IRQF_DISABLED, "sh-rtc carry", rtc);
		if (unlikely(ret)) {
			dev_err(&pdev->dev,
				"request carry IRQ failed with %d, IRQ %d\n",
				ret, rtc->carry_irq);
			free_irq(rtc->periodic_irq, rtc);
			goto err_unmap;
		}
757

758 759 760 761 762 763 764 765 766 767
		ret = request_irq(rtc->alarm_irq, sh_rtc_alarm,
				  IRQF_DISABLED, "sh-rtc alarm", rtc);
		if (unlikely(ret)) {
			dev_err(&pdev->dev,
				"request alarm IRQ failed with %d, IRQ %d\n",
				ret, rtc->alarm_irq);
			free_irq(rtc->carry_irq, rtc);
			free_irq(rtc->periodic_irq, rtc);
			goto err_unmap;
		}
768 769
	}

M
Magnus Damm 已提交
770 771 772 773 774 775
	/* everything disabled by default */
	rtc->periodic_freq = 0;
	rtc->rtc_dev->irq_freq = 0;
	sh_rtc_setpie(&pdev->dev, 0);
	sh_rtc_setaie(&pdev->dev, 0);
	sh_rtc_setcie(&pdev->dev, 0);
M
Magnus Damm 已提交
776 777 778 779 780 781 782

	/* reset rtc to epoch 0 if time is invalid */
	if (rtc_read_time(rtc->rtc_dev, &r) < 0) {
		rtc_time_to_tm(0, &r);
		rtc_set_time(rtc->rtc_dev, &r);
	}

M
Magnus Damm 已提交
783
	device_init_wakeup(&pdev->dev, 1);
784 785
	return 0;

786
err_unmap:
787 788
	clk_disable(rtc->clk);
	clk_put(rtc->clk);
789
	iounmap(rtc->regbase);
790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806
err_badmap:
	release_resource(rtc->res);
err_badres:
	kfree(rtc);

	return ret;
}

static int __devexit sh_rtc_remove(struct platform_device *pdev)
{
	struct sh_rtc *rtc = platform_get_drvdata(pdev);

	if (likely(rtc->rtc_dev))
		rtc_device_unregister(rtc->rtc_dev);

	sh_rtc_setpie(&pdev->dev, 0);
	sh_rtc_setaie(&pdev->dev, 0);
M
Magnus Damm 已提交
807
	sh_rtc_setcie(&pdev->dev, 0);
808

809
	free_irq(rtc->periodic_irq, rtc);
810

811 812 813 814
	if (rtc->carry_irq > 0) {
		free_irq(rtc->carry_irq, rtc);
		free_irq(rtc->alarm_irq, rtc);
	}
815

816 817
	release_resource(rtc->res);

818 819
	iounmap(rtc->regbase);

820 821 822
	clk_disable(rtc->clk);
	clk_put(rtc->clk);

823 824 825 826 827 828
	platform_set_drvdata(pdev, NULL);

	kfree(rtc);

	return 0;
}
M
Magnus Damm 已提交
829 830 831 832 833 834 835

static void sh_rtc_set_irq_wake(struct device *dev, int enabled)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct sh_rtc *rtc = platform_get_drvdata(pdev);

	set_irq_wake(rtc->periodic_irq, enabled);
836

M
Magnus Damm 已提交
837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863
	if (rtc->carry_irq > 0) {
		set_irq_wake(rtc->carry_irq, enabled);
		set_irq_wake(rtc->alarm_irq, enabled);
	}
}

static int sh_rtc_suspend(struct device *dev)
{
	if (device_may_wakeup(dev))
		sh_rtc_set_irq_wake(dev, 1);

	return 0;
}

static int sh_rtc_resume(struct device *dev)
{
	if (device_may_wakeup(dev))
		sh_rtc_set_irq_wake(dev, 0);

	return 0;
}

static struct dev_pm_ops sh_rtc_dev_pm_ops = {
	.suspend = sh_rtc_suspend,
	.resume = sh_rtc_resume,
};

864 865
static struct platform_driver sh_rtc_platform_driver = {
	.driver		= {
J
Jamie Lenehan 已提交
866
		.name	= DRV_NAME,
867
		.owner	= THIS_MODULE,
M
Magnus Damm 已提交
868
		.pm	= &sh_rtc_dev_pm_ops,
869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887
	},
	.probe		= sh_rtc_probe,
	.remove		= __devexit_p(sh_rtc_remove),
};

static int __init sh_rtc_init(void)
{
	return platform_driver_register(&sh_rtc_platform_driver);
}

static void __exit sh_rtc_exit(void)
{
	platform_driver_unregister(&sh_rtc_platform_driver);
}

module_init(sh_rtc_init);
module_exit(sh_rtc_exit);

MODULE_DESCRIPTION("SuperH on-chip RTC driver");
J
Jamie Lenehan 已提交
888
MODULE_VERSION(DRV_VERSION);
889 890 891
MODULE_AUTHOR("Paul Mundt <lethal@linux-sh.org>, "
	      "Jamie Lenehan <lenehan@twibble.org>, "
	      "Angelo Castello <angelo.castello@st.com>");
892
MODULE_LICENSE("GPL");
893
MODULE_ALIAS("platform:" DRV_NAME);