rtc-bfin.c 13.8 KB
Newer Older
1 2
/*
 * Blackfin On-Chip Real Time Clock Driver
3
 *  Supports BF51x/BF52x/BF53[123]/BF53[467]/BF54x
4
 *
5
 * Copyright 2004-2010 Analog Devices Inc.
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
 *
 * Enter bugs at http://blackfin.uclinux.org/
 *
 * Licensed under the GPL-2 or later.
 */

/* The biggest issue we deal with in this driver is that register writes are
 * synced to the RTC frequency of 1Hz.  So if you write to a register and
 * attempt to write again before the first write has completed, the new write
 * is simply discarded.  This can easily be troublesome if userspace disables
 * one event (say periodic) and then right after enables an event (say alarm).
 * Since all events are maintained in the same interrupt mask register, if
 * we wrote to it to disable the first event and then wrote to it again to
 * enable the second event, that second event would not be enabled as the
 * write would be discarded and things quickly fall apart.
 *
 * To keep this delay from significantly degrading performance (we, in theory,
 * would have to sleep for up to 1 second everytime we wanted to write a
 * register), we only check the write pending status before we start to issue
 * a new write.  We bank on the idea that it doesnt matter when the sync
 * happens so long as we don't attempt another write before it does.  The only
 * time userspace would take this penalty is when they try and do multiple
 * operations right after another ... but in this case, they need to take the
 * sync penalty, so we should be OK.
 *
 * Also note that the RTC_ISTAT register does not suffer this penalty; its
 * writes to clear status registers complete immediately.
 */

35 36 37 38 39 40 41 42 43
/* It may seem odd that there is no SWCNT code in here (which would be exposed
 * via the periodic interrupt event, or PIE).  Since the Blackfin RTC peripheral
 * runs in units of seconds (N/HZ) but the Linux framework runs in units of HZ
 * (2^N HZ), there is no point in keeping code that only provides 1 HZ PIEs.
 * The same exact behavior can be accomplished by using the update interrupt
 * event (UIE).  Maybe down the line the RTC peripheral will suck less in which
 * case we can re-introduce PIE support.
 */

44
#include <linux/bcd.h>
45 46
#include <linux/completion.h>
#include <linux/delay.h>
47
#include <linux/init.h>
48 49 50
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/module.h>
51
#include <linux/platform_device.h>
52
#include <linux/rtc.h>
53
#include <linux/seq_file.h>
54
#include <linux/slab.h>
55 56 57

#include <asm/blackfin.h>

58
#define dev_dbg_stamp(dev) dev_dbg(dev, "%s:%i: here i am\n", __func__, __LINE__)
59 60 61 62

struct bfin_rtc {
	struct rtc_device *rtc_dev;
	struct rtc_time rtc_alarm;
63
	u16 rtc_wrote_regs;
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83
};

/* Bit values for the ISTAT / ICTL registers */
#define RTC_ISTAT_WRITE_COMPLETE  0x8000
#define RTC_ISTAT_WRITE_PENDING   0x4000
#define RTC_ISTAT_ALARM_DAY       0x0040
#define RTC_ISTAT_24HR            0x0020
#define RTC_ISTAT_HOUR            0x0010
#define RTC_ISTAT_MIN             0x0008
#define RTC_ISTAT_SEC             0x0004
#define RTC_ISTAT_ALARM           0x0002
#define RTC_ISTAT_STOPWATCH       0x0001

/* Shift values for RTC_STAT register */
#define DAY_BITS_OFF    17
#define HOUR_BITS_OFF   12
#define MIN_BITS_OFF    6
#define SEC_BITS_OFF    0

/* Some helper functions to convert between the common RTC notion of time
84
 * and the internal Blackfin notion that is encoded in 32bits.
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108
 */
static inline u32 rtc_time_to_bfin(unsigned long now)
{
	u32 sec  = (now % 60);
	u32 min  = (now % (60 * 60)) / 60;
	u32 hour = (now % (60 * 60 * 24)) / (60 * 60);
	u32 days = (now / (60 * 60 * 24));
	return (sec  << SEC_BITS_OFF) +
	       (min  << MIN_BITS_OFF) +
	       (hour << HOUR_BITS_OFF) +
	       (days << DAY_BITS_OFF);
}
static inline unsigned long rtc_bfin_to_time(u32 rtc_bfin)
{
	return (((rtc_bfin >> SEC_BITS_OFF)  & 0x003F)) +
	       (((rtc_bfin >> MIN_BITS_OFF)  & 0x003F) * 60) +
	       (((rtc_bfin >> HOUR_BITS_OFF) & 0x001F) * 60 * 60) +
	       (((rtc_bfin >> DAY_BITS_OFF)  & 0x7FFF) * 60 * 60 * 24);
}
static inline void rtc_bfin_to_tm(u32 rtc_bfin, struct rtc_time *tm)
{
	rtc_time_to_tm(rtc_bfin_to_time(rtc_bfin), tm);
}

109 110 111 112
/**
 *	bfin_rtc_sync_pending - make sure pending writes have complete
 *
 * Wait for the previous write to a RTC register to complete.
113 114 115 116 117 118 119 120 121 122 123 124 125 126
 * Unfortunately, we can't sleep here as that introduces a race condition when
 * turning on interrupt events.  Consider this:
 *  - process sets alarm
 *  - process enables alarm
 *  - process sleeps while waiting for rtc write to sync
 *  - interrupt fires while process is sleeping
 *  - interrupt acks the event by writing to ISTAT
 *  - interrupt sets the WRITE PENDING bit
 *  - interrupt handler finishes
 *  - process wakes up, sees WRITE PENDING bit set, goes to sleep
 *  - interrupt fires while process is sleeping
 * If anyone can point out the obvious solution here, i'm listening :).  This
 * shouldn't be an issue on an SMP or preempt system as this function should
 * only be called with the rtc lock held.
127 128 129 130 131
 *
 * Other options:
 *  - disable PREN so the sync happens at 32.768kHZ ... but this changes the
 *    inc rate for all RTC registers from 1HZ to 32.768kHZ ...
 *  - use the write complete IRQ
132
 */
133 134
/*
static void bfin_rtc_sync_pending_polled(void)
135
{
136
	while (!(bfin_read_RTC_ISTAT() & RTC_ISTAT_WRITE_COMPLETE))
137 138 139 140
		if (!(bfin_read_RTC_ISTAT() & RTC_ISTAT_WRITE_PENDING))
			break;
	bfin_write_RTC_ISTAT(RTC_ISTAT_WRITE_COMPLETE);
}
141 142 143 144 145 146 147 148 149
*/
static DECLARE_COMPLETION(bfin_write_complete);
static void bfin_rtc_sync_pending(struct device *dev)
{
	dev_dbg_stamp(dev);
	while (bfin_read_RTC_ISTAT() & RTC_ISTAT_WRITE_PENDING)
		wait_for_completion_timeout(&bfin_write_complete, HZ * 5);
	dev_dbg_stamp(dev);
}
150

151 152 153 154 155 156
/**
 *	bfin_rtc_reset - set RTC to sane/known state
 *
 * Initialize the RTC.  Enable pre-scaler to scale RTC clock
 * to 1Hz and clear interrupt/status registers.
 */
157
static void bfin_rtc_reset(struct device *dev, u16 rtc_ictl)
158
{
159
	struct bfin_rtc *rtc = dev_get_drvdata(dev);
160 161
	dev_dbg_stamp(dev);
	bfin_rtc_sync_pending(dev);
162
	bfin_write_RTC_PREN(0x1);
163
	bfin_write_RTC_ICTL(rtc_ictl);
164 165
	bfin_write_RTC_ALARM(0);
	bfin_write_RTC_ISTAT(0xFFFF);
166
	rtc->rtc_wrote_regs = 0;
167 168
}

169 170 171 172 173 174 175 176 177 178 179
/**
 *	bfin_rtc_interrupt - handle interrupt from RTC
 *
 * Since we handle all RTC events here, we have to make sure the requested
 * interrupt is enabled (in RTC_ICTL) as the event status register (RTC_ISTAT)
 * always gets updated regardless of the interrupt being enabled.  So when one
 * even we care about (e.g. stopwatch) goes off, we don't want to turn around
 * and say that other events have happened as well (e.g. second).  We do not
 * have to worry about pending writes to the RTC_ICTL register as interrupts
 * only fire if they are enabled in the RTC_ICTL register.
 */
180 181
static irqreturn_t bfin_rtc_interrupt(int irq, void *dev_id)
{
182 183
	struct device *dev = dev_id;
	struct bfin_rtc *rtc = dev_get_drvdata(dev);
184
	unsigned long events = 0;
185
	bool write_complete = false;
186
	u16 rtc_istat, rtc_istat_clear, rtc_ictl, bits;
187

188
	dev_dbg_stamp(dev);
189 190

	rtc_istat = bfin_read_RTC_ISTAT();
191
	rtc_ictl = bfin_read_RTC_ICTL();
192
	rtc_istat_clear = 0;
193

194 195 196
	bits = RTC_ISTAT_WRITE_COMPLETE;
	if (rtc_istat & bits) {
		rtc_istat_clear |= bits;
197 198
		write_complete = true;
		complete(&bfin_write_complete);
199 200
	}

201 202 203 204
	bits = (RTC_ISTAT_ALARM | RTC_ISTAT_ALARM_DAY);
	if (rtc_ictl & bits) {
		if (rtc_istat & bits) {
			rtc_istat_clear |= bits;
205 206
			events |= RTC_AF | RTC_IRQF;
		}
207 208
	}

209 210 211 212
	bits = RTC_ISTAT_SEC;
	if (rtc_ictl & bits) {
		if (rtc_istat & bits) {
			rtc_istat_clear |= bits;
213 214 215
			events |= RTC_UF | RTC_IRQF;
		}
	}
216

217 218
	if (events)
		rtc_update_irq(rtc->rtc_dev, 1, events);
219

220 221
	if (write_complete || events) {
		bfin_write_RTC_ISTAT(rtc_istat_clear);
222
		return IRQ_HANDLED;
223
	} else
224
		return IRQ_NONE;
225 226
}

227
static void bfin_rtc_int_set(u16 rtc_int)
228 229 230 231
{
	bfin_write_RTC_ISTAT(rtc_int);
	bfin_write_RTC_ICTL(bfin_read_RTC_ICTL() | rtc_int);
}
232
static void bfin_rtc_int_clear(u16 rtc_int)
233 234 235 236 237 238 239 240
{
	bfin_write_RTC_ICTL(bfin_read_RTC_ICTL() & rtc_int);
}
static void bfin_rtc_int_set_alarm(struct bfin_rtc *rtc)
{
	/* Blackfin has different bits for whether the alarm is
	 * more than 24 hours away.
	 */
241
	bfin_rtc_int_set(rtc->rtc_alarm.tm_yday == -1 ? RTC_ISTAT_ALARM : RTC_ISTAT_ALARM_DAY);
242
}
243 244 245
static int bfin_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
{
	struct bfin_rtc *rtc = dev_get_drvdata(dev);
246
	int ret = 0;
247

248
	dev_dbg_stamp(dev);
249

250 251
	bfin_rtc_sync_pending(dev);

252 253
	switch (cmd) {
	case RTC_UIE_ON:
254
		dev_dbg_stamp(dev);
255
		bfin_rtc_int_set(RTC_ISTAT_SEC);
256
		break;
257
	case RTC_UIE_OFF:
258
		dev_dbg_stamp(dev);
259
		bfin_rtc_int_clear(~RTC_ISTAT_SEC);
260
		break;
261

262 263 264
	default:
		dev_dbg_stamp(dev);
		ret = -ENOIOCTLCMD;
265 266
	}

267
	return ret;
268 269
}

270 271 272 273 274 275 276 277 278 279 280
static int bfin_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
{
	struct bfin_rtc *rtc = dev_get_drvdata(dev);

	dev_dbg_stamp(dev);
	if (enabled)
		bfin_rtc_int_set_alarm(rtc);
	else
		bfin_rtc_int_clear(~(RTC_ISTAT_ALARM | RTC_ISTAT_ALARM_DAY));
}

281 282 283 284
static int bfin_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
	struct bfin_rtc *rtc = dev_get_drvdata(dev);

285
	dev_dbg_stamp(dev);
286

287 288 289
	if (rtc->rtc_wrote_regs & 0x1)
		bfin_rtc_sync_pending(dev);

290 291 292 293 294 295 296 297 298 299 300
	rtc_bfin_to_tm(bfin_read_RTC_STAT(), tm);

	return 0;
}

static int bfin_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
	struct bfin_rtc *rtc = dev_get_drvdata(dev);
	int ret;
	unsigned long now;

301
	dev_dbg_stamp(dev);
302 303 304

	ret = rtc_tm_to_time(tm, &now);
	if (ret == 0) {
305 306
		if (rtc->rtc_wrote_regs & 0x1)
			bfin_rtc_sync_pending(dev);
307
		bfin_write_RTC_STAT(rtc_time_to_bfin(now));
308
		rtc->rtc_wrote_regs = 0x1;
309 310 311 312 313 314 315 316
	}

	return ret;
}

static int bfin_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	struct bfin_rtc *rtc = dev_get_drvdata(dev);
317
	dev_dbg_stamp(dev);
318
	alrm->time = rtc->rtc_alarm;
319
	bfin_rtc_sync_pending(dev);
320
	alrm->enabled = !!(bfin_read_RTC_ICTL() & (RTC_ISTAT_ALARM | RTC_ISTAT_ALARM_DAY));
321 322 323 324 325 326
	return 0;
}

static int bfin_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	struct bfin_rtc *rtc = dev_get_drvdata(dev);
327 328
	unsigned long rtc_alarm;

329
	dev_dbg_stamp(dev);
330 331 332 333

	if (rtc_tm_to_time(&alrm->time, &rtc_alarm))
		return -EINVAL;

334
	rtc->rtc_alarm = alrm->time;
335 336 337 338 339 340

	bfin_rtc_sync_pending(dev);
	bfin_write_RTC_ALARM(rtc_time_to_bfin(rtc_alarm));
	if (alrm->enabled)
		bfin_rtc_int_set_alarm(rtc);

341 342 343 344 345
	return 0;
}

static int bfin_rtc_proc(struct device *dev, struct seq_file *seq)
{
346
#define yesno(x) ((x) ? "yes" : "no")
347
	u16 ictl = bfin_read_RTC_ICTL();
348
	dev_dbg_stamp(dev);
349 350 351
	seq_printf(seq,
		"alarm_IRQ\t: %s\n"
		"wkalarm_IRQ\t: %s\n"
352
		"seconds_IRQ\t: %s\n",
353 354
		yesno(ictl & RTC_ISTAT_ALARM),
		yesno(ictl & RTC_ISTAT_ALARM_DAY),
355
		yesno(ictl & RTC_ISTAT_SEC));
356
	return 0;
357
#undef yesno
358 359 360 361 362 363 364 365 366
}

static struct rtc_class_ops bfin_rtc_ops = {
	.ioctl         = bfin_rtc_ioctl,
	.read_time     = bfin_rtc_read_time,
	.set_time      = bfin_rtc_set_time,
	.read_alarm    = bfin_rtc_read_alarm,
	.set_alarm     = bfin_rtc_set_alarm,
	.proc          = bfin_rtc_proc,
367
	.alarm_irq_enable = bfin_rtc_alarm_irq_enable,
368 369 370 371 372
};

static int __devinit bfin_rtc_probe(struct platform_device *pdev)
{
	struct bfin_rtc *rtc;
373
	struct device *dev = &pdev->dev;
374
	int ret = 0;
375
	unsigned long timeout = jiffies + HZ;
376

377
	dev_dbg_stamp(dev);
378

379
	/* Allocate memory for our RTC struct */
380 381 382
	rtc = kzalloc(sizeof(*rtc), GFP_KERNEL);
	if (unlikely(!rtc))
		return -ENOMEM;
383
	platform_set_drvdata(pdev, rtc);
384
	device_init_wakeup(dev, 1);
385

386 387 388 389 390 391 392 393
	/* Register our RTC with the RTC framework */
	rtc->rtc_dev = rtc_device_register(pdev->name, dev, &bfin_rtc_ops,
						THIS_MODULE);
	if (unlikely(IS_ERR(rtc->rtc_dev))) {
		ret = PTR_ERR(rtc->rtc_dev);
		goto err;
	}

394
	/* Grab the IRQ and init the hardware */
395
	ret = request_irq(IRQ_RTC, bfin_rtc_interrupt, 0, pdev->name, dev);
396
	if (unlikely(ret))
397
		goto err_reg;
398 399 400 401 402 403
	/* sometimes the bootloader touched things, but the write complete was not
	 * enabled, so let's just do a quick timeout here since the IRQ will not fire ...
	 */
	while (bfin_read_RTC_ISTAT() & RTC_ISTAT_WRITE_PENDING)
		if (time_after(jiffies, timeout))
			break;
404
	bfin_rtc_reset(dev, RTC_ISTAT_WRITE_COMPLETE);
405
	bfin_write_RTC_SWCNT(0);
406 407 408

	return 0;

409 410 411
err_reg:
	rtc_device_unregister(rtc->rtc_dev);
err:
412 413 414 415 416 417 418
	kfree(rtc);
	return ret;
}

static int __devexit bfin_rtc_remove(struct platform_device *pdev)
{
	struct bfin_rtc *rtc = platform_get_drvdata(pdev);
419
	struct device *dev = &pdev->dev;
420

421 422
	bfin_rtc_reset(dev, 0);
	free_irq(IRQ_RTC, dev);
423 424 425 426 427 428 429
	rtc_device_unregister(rtc->rtc_dev);
	platform_set_drvdata(pdev, NULL);
	kfree(rtc);

	return 0;
}

430 431 432
#ifdef CONFIG_PM
static int bfin_rtc_suspend(struct platform_device *pdev, pm_message_t state)
{
433 434 435 436 437
	struct device *dev = &pdev->dev;

	dev_dbg_stamp(dev);

	if (device_may_wakeup(dev)) {
438
		enable_irq_wake(IRQ_RTC);
439
		bfin_rtc_sync_pending(dev);
440
	} else
441
		bfin_rtc_int_clear(0);
442

443 444 445 446 447
	return 0;
}

static int bfin_rtc_resume(struct platform_device *pdev)
{
448 449 450 451 452
	struct device *dev = &pdev->dev;

	dev_dbg_stamp(dev);

	if (device_may_wakeup(dev))
453
		disable_irq_wake(IRQ_RTC);
454 455 456 457 458 459 460 461 462 463 464

	/*
	 * Since only some of the RTC bits are maintained externally in the
	 * Vbat domain, we need to wait for the RTC MMRs to be synced into
	 * the core after waking up.  This happens every RTC 1HZ.  Once that
	 * has happened, we can go ahead and re-enable the important write
	 * complete interrupt event.
	 */
	while (!(bfin_read_RTC_ISTAT() & RTC_ISTAT_SEC))
		continue;
	bfin_rtc_int_set(RTC_ISTAT_WRITE_COMPLETE);
465

466 467
	return 0;
}
468 469 470
#else
# define bfin_rtc_suspend NULL
# define bfin_rtc_resume  NULL
471 472
#endif

473 474 475 476 477 478 479
static struct platform_driver bfin_rtc_driver = {
	.driver		= {
		.name	= "rtc-bfin",
		.owner	= THIS_MODULE,
	},
	.probe		= bfin_rtc_probe,
	.remove		= __devexit_p(bfin_rtc_remove),
480 481
	.suspend	= bfin_rtc_suspend,
	.resume		= bfin_rtc_resume,
482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499
};

static int __init bfin_rtc_init(void)
{
	return platform_driver_register(&bfin_rtc_driver);
}

static void __exit bfin_rtc_exit(void)
{
	platform_driver_unregister(&bfin_rtc_driver);
}

module_init(bfin_rtc_init);
module_exit(bfin_rtc_exit);

MODULE_DESCRIPTION("Blackfin On-Chip Real Time Clock Driver");
MODULE_AUTHOR("Mike Frysinger <vapier@gentoo.org>");
MODULE_LICENSE("GPL");
500
MODULE_ALIAS("platform:rtc-bfin");