[patch 2.6.17-rc4-omap-git] rtc-omap, rtc framework driver

[patch 2.6.17-rc4-omap-git] rtc-omap, rtc framework driver

[David Brownell]

Cleaning out my patch queue ... here's an "rtc class" driver.  Much
more suitable for upstream merging than the previous version, even
though that code has gotten much cleaner over time.

Could someone confirm that this RTC can't actually do system wakeups
without external hardware support?  My documentation isn't at all
clear on that issue.  There's certainly an external wakeup signal
available, but text also says that the alarm irq should work the
normal way ... but I don't see that happening.  It could easily be
just a bug in enable_irq_wakeup(INT_RTC_ALARM) handling, which ISTR
looked like a big NOP last I checked (for almost all IRQs).

Also, someone with an OMAP2 setup should confirm that the Kconfig is
right, and this particular controller isn't provided on OMAP2.  That
certainly matches the lack of RTC in the .../mach-omap2 directory,
but the TI website says 2420 (but not {2,3}430) has an RTC.  Maybe the
OMAP 2420 support is just missing, and it's really the same RTC...

- Dave


This creates a new RTC-framework driver for the RTC/calendar module
found in various OMAP chips, giving a more correct/standard replacement
for the older drivers/char/omap-rtc.c driver.  Differences include:

 - much smaller/simpler, because it reuses shared infrastructure
 - the RTC name will normally be "rtc0" not "rtc"
 - the /dev node has a different major and minor numbers
 - RTC_ALM_SET handled as on PCs (alarm within 24 hours)
 - RTC_WKALM_SET handled as on PCs (alarm within this century)
 - epoch not changeable (why bother)
 - rtc alarm may optionally be a system wakeup event (board-specific)
 
If you use udev and statically link this, some init script can just create
a symbolic link (rtc -> rtc0) so tools like "hwclock" will work as usual.
Or, updates to hwclock (and busybox) are available which teach it to use
the /dev/rtc0 path as a backup, and to support "hwclock --file=/dev/rtc0". 

Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>

----
Presumably an upstream merge should remove the devices.c support for
the older non-framework driver.

 arch/arm/mach-omap1/devices.c |    2 
 drivers/rtc/Kconfig           |    8 
 drivers/rtc/Makefile          |    1 
 drivers/rtc/rtc-omap.c        |  573 ++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 583 insertions(+), 1 deletion(-)

Index: omap-2.6/drivers/rtc/Kconfig
===================================================================
--- omap-2.6.orig/drivers/rtc/Kconfig	2006-08-07 20:53:03.000000000 -0700
+++ omap-2.6/drivers/rtc/Kconfig	2006-08-15 08:40:06.000000000 -0700
@@ -151,6 +151,14 @@ config RTC_DRV_DS1742
 	  This driver can also be built as a module. If so, the module
 	  will be called rtc-ds1742.
 
+config RTC_DRV_OMAP
+	tristate "TI OMAP1"
+	depends on RTC_CLASS && ( \
+		ARCH_OMAP15XX || ARCH_OMAP16XX || ARCH_OMAP730 )
+	help
+	  Say "yes" here to support the real time clock on TI OMAP1 chips.
+	  This driver can also be built as a module called rtc-omap.
+
 config RTC_DRV_PCF8563
 	tristate "Philips PCF8563/Epson RTC8564"
 	depends on RTC_CLASS && I2C
Index: omap-2.6/arch/arm/mach-omap1/devices.c
===================================================================
--- omap-2.6.orig/arch/arm/mach-omap1/devices.c	2006-08-07 20:50:44.000000000 -0700
+++ omap-2.6/arch/arm/mach-omap1/devices.c	2006-08-15 08:40:06.000000000 -0700
@@ -26,7 +26,7 @@
 
 /*-------------------------------------------------------------------------*/
 
-#if	defined(CONFIG_OMAP_RTC) || defined(CONFIG_OMAP_RTC)
+#if defined(CONFIG_OMAP_RTC) || defined(CONFIG_RTC_DRV_OMAP) || defined(CONFIG_RTC_DRV_OMAP_MODULE)
 
 #define	OMAP_RTC_BASE		0xfffb4800
 
Index: omap-2.6/drivers/rtc/Makefile
===================================================================
--- omap-2.6.orig/drivers/rtc/Makefile	2006-08-07 20:53:03.000000000 -0700
+++ omap-2.6/drivers/rtc/Makefile	2006-08-15 08:40:49.000000000 -0700
@@ -17,6 +17,7 @@ obj-$(CONFIG_RTC_DRV_TEST)	+= rtc-test.o
 obj-$(CONFIG_RTC_DRV_DS1307)	+= rtc-ds1307.o
 obj-$(CONFIG_RTC_DRV_DS1672)	+= rtc-ds1672.o
 obj-$(CONFIG_RTC_DRV_DS1742)	+= rtc-ds1742.o
+obj-$(CONFIG_RTC_DRV_OMAP)	+= rtc-omap.o
 obj-$(CONFIG_RTC_DRV_PCF8563)	+= rtc-pcf8563.o
 obj-$(CONFIG_RTC_DRV_PCF8583)	+= rtc-pcf8583.o
 obj-$(CONFIG_RTC_DRV_RS5C372)	+= rtc-rs5c372.o
Index: omap-2.6/drivers/rtc/rtc-omap.c
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ omap-2.6/drivers/rtc/rtc-omap.c	2006-08-15 08:40:06.000000000 -0700
@@ -0,0 +1,573 @@
+/*
+ * TI OMAP1 Real Time Clock interface for Linux
+ *
+ * Copyright (C) 2003 MontaVista Software, Inc.
+ * Author: George G. Davis <gdavis@mvista.com> or <source@mvista.com>
+ *
+ * Copyright (C) 2006 David Brownell (new RTC framework)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/ioport.h>
+#include <linux/delay.h>
+#include <linux/rtc.h>
+#include <linux/bcd.h>
+#include <linux/platform_device.h>
+
+#include <asm/io.h>
+#include <asm/mach/time.h>
+
+
+/* The OMAP1 RTC is a year/month/day/hours/minutes/seconds BCD clock
+ * with century-range alarm matching, driven by the 32kHz clock.
+ *
+ * The main user-visible ways it differs from PC RTCs are by omitting
+ * "don't care" alarm fields and sub-second periodic IRQs, and having
+ * an autoadjust mechanism to calibrate to the true oscillator rate.
+ *
+ * Board-specific wiring options include using split power mode with
+ * RTC_OFF_NOFF used as the reset signal (so the RTC won't be reset),
+ * and wiring RTC_WAKE_INT (so the RTC alarm can wake the system from
+ * low power modes).  See the BOARD-SPECIFIC CUSTOMIZATION comment.
+ */
+
+#define OMAP_RTC_BASE			0xfffb4800
+
+/* RTC registers */
+#define OMAP_RTC_SECONDS_REG		0x00
+#define OMAP_RTC_MINUTES_REG		0x04
+#define OMAP_RTC_HOURS_REG		0x08
+#define OMAP_RTC_DAYS_REG		0x0C
+#define OMAP_RTC_MONTHS_REG		0x10
+#define OMAP_RTC_YEARS_REG		0x14
+#define OMAP_RTC_WEEKS_REG		0x18
+
+#define OMAP_RTC_ALARM_SECONDS_REG	0x20
+#define OMAP_RTC_ALARM_MINUTES_REG	0x24
+#define OMAP_RTC_ALARM_HOURS_REG	0x28
+#define OMAP_RTC_ALARM_DAYS_REG		0x2c
+#define OMAP_RTC_ALARM_MONTHS_REG	0x30
+#define OMAP_RTC_ALARM_YEARS_REG	0x34
+
+#define OMAP_RTC_CTRL_REG		0x40
+#define OMAP_RTC_STATUS_REG		0x44
+#define OMAP_RTC_INTERRUPTS_REG		0x48
+
+#define OMAP_RTC_COMP_LSB_REG		0x4c
+#define OMAP_RTC_COMP_MSB_REG		0x50
+#define OMAP_RTC_OSC_REG		0x54
+
+/* OMAP_RTC_CTRL_REG bit fields: */
+#define OMAP_RTC_CTRL_SPLIT		(1<<7)
+#define OMAP_RTC_CTRL_DISABLE		(1<<6)
+#define OMAP_RTC_CTRL_SET_32_COUNTER	(1<<5)
+#define OMAP_RTC_CTRL_TEST		(1<<4)
+#define OMAP_RTC_CTRL_MODE_12_24	(1<<3)
+#define OMAP_RTC_CTRL_AUTO_COMP		(1<<2)
+#define OMAP_RTC_CTRL_ROUND_30S		(1<<1)
+#define OMAP_RTC_CTRL_STOP		(1<<0)
+
+/* OMAP_RTC_STATUS_REG bit fields: */
+#define OMAP_RTC_STATUS_POWER_UP        (1<<7)
+#define OMAP_RTC_STATUS_ALARM           (1<<6)
+#define OMAP_RTC_STATUS_1D_EVENT        (1<<5)
+#define OMAP_RTC_STATUS_1H_EVENT        (1<<4)
+#define OMAP_RTC_STATUS_1M_EVENT        (1<<3)
+#define OMAP_RTC_STATUS_1S_EVENT        (1<<2)
+#define OMAP_RTC_STATUS_RUN             (1<<1)
+#define OMAP_RTC_STATUS_BUSY            (1<<0)
+
+/* OMAP_RTC_INTERRUPTS_REG bit fields: */
+#define OMAP_RTC_INTERRUPTS_IT_ALARM    (1<<3)
+#define OMAP_RTC_INTERRUPTS_IT_TIMER    (1<<2)
+
+
+#define rtc_read(addr)		omap_readb(OMAP_RTC_BASE + (addr))
+#define rtc_write(val, addr)	omap_writeb(val, OMAP_RTC_BASE + (addr))
+
+
+/* platform_bus isn't hotpluggable, so for static linkage it'd be safe
+ * to get rid of probe() and remove() code ... too bad the driver struct
+ * remembers probe(), that's about 25% of the runtime footprint!!
+ */
+#ifndef	MODULE
+#undef	__devexit
+#undef	__devexit_p
+#define	__devexit	__exit
+#define	__devexit_p	__exit_p
+#endif
+
+
+/* we rely on the rtc framework to handle locking (rtc->ops_lock),
+ * so the only other requirement is that register accesses which
+ * require BUSY to be clear are made with IRQs locally disabled
+ */
+static void rtc_wait_not_busy(void)
+{
+	int	count = 0;
+	u8	status;
+
+	/* BUSY may stay active for 1/32768 second (~30 usec) */
+	for (count = 0; count < 50; count++) {
+		status = rtc_read(OMAP_RTC_STATUS_REG);
+		if ((status & (u8)OMAP_RTC_STATUS_BUSY) == 0)
+			break;
+		udelay(1);
+	}
+	/* now we have ~15 usec to read/write various registers */
+}
+
+static irqreturn_t rtc_irq(int irq, void *class_dev, struct pt_regs *regs)
+{
+	unsigned long		events = 0;
+	u8			irq_data;
+
+	irq_data = rtc_read(OMAP_RTC_STATUS_REG);
+
+	/* alarm irq? */
+	if (irq_data & OMAP_RTC_STATUS_ALARM) {
+		rtc_write(OMAP_RTC_STATUS_ALARM, OMAP_RTC_STATUS_REG);
+		events |= RTC_IRQF | RTC_AF;
+	}
+
+	/* 1/sec periodic/update irq? */
+	if (irq_data & OMAP_RTC_STATUS_1S_EVENT)
+		events |= RTC_IRQF | RTC_UF;
+
+	rtc_update_irq(class_dev, 1, events);
+
+	return IRQ_HANDLED;
+}
+
+#ifdef	CONFIG_RTC_INTF_DEV
+
+static int
+omap_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
+{
+	u8 reg;
+
+	switch (cmd) {
+	case RTC_AIE_OFF:
+	case RTC_AIE_ON:
+	case RTC_UIE_OFF:
+	case RTC_UIE_ON:
+		break;
+	default:
+		return -ENOIOCTLCMD;
+	}
+
+	local_irq_disable();
+	rtc_wait_not_busy();
+	reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);
+	switch (cmd) {
+	/* AIE = Alarm Interrupt Enable */
+	case RTC_AIE_OFF:
+		reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
+		break;
+	case RTC_AIE_ON:
+		reg |= OMAP_RTC_INTERRUPTS_IT_ALARM;
+		break;
+	/* UIE = Update Interrupt Enable (1/second) */
+	case RTC_UIE_OFF:
+		reg &= ~OMAP_RTC_INTERRUPTS_IT_TIMER;
+		break;
+	case RTC_UIE_ON:
+		reg |= OMAP_RTC_INTERRUPTS_IT_TIMER;
+		break;
+	}
+	rtc_wait_not_busy();
+	rtc_write(reg, OMAP_RTC_INTERRUPTS_REG);
+	local_irq_enable();
+
+	return 0;
+}
+
+#else
+#define	omap_rtc_ioctl	NULL
+#endif
+
+/* this hardware doesn't support "don't care" alarm fields */
+static int tm2bcd(struct rtc_time *tm)
+{
+	if (rtc_valid_tm(tm) != 0)
+		return -EINVAL;
+
+	tm->tm_sec = BIN2BCD(tm->tm_sec);
+	tm->tm_min = BIN2BCD(tm->tm_min);
+	tm->tm_hour = BIN2BCD(tm->tm_hour);
+	tm->tm_mday = BIN2BCD(tm->tm_mday);
+
+	tm->tm_mon = BIN2BCD(tm->tm_mon + 1);
+
+	/* epoch == 1900 */
+	if (tm->tm_year < 100 || tm->tm_year > 199)
+		return -EINVAL;
+	tm->tm_year = BIN2BCD(tm->tm_year - 100);
+
+	return 0;
+}
+
+static void bcd2tm(struct rtc_time *tm)
+{
+	tm->tm_sec = BCD2BIN(tm->tm_sec);
+	tm->tm_min = BCD2BIN(tm->tm_min);
+	tm->tm_hour = BCD2BIN(tm->tm_hour);
+	tm->tm_mday = BCD2BIN(tm->tm_mday);
+	tm->tm_mon = BCD2BIN(tm->tm_mon) - 1;
+	/* epoch == 1900 */
+	tm->tm_year = BCD2BIN(tm->tm_year) + 100;
+}
+
+
+static int omap_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+	/* we don't report wday/yday/isdst ... */
+	local_irq_disable();
+	rtc_wait_not_busy();
+
+	tm->tm_sec = rtc_read(OMAP_RTC_SECONDS_REG);
+	tm->tm_min = rtc_read(OMAP_RTC_MINUTES_REG);
+	tm->tm_hour = rtc_read(OMAP_RTC_HOURS_REG);
+	tm->tm_mday = rtc_read(OMAP_RTC_DAYS_REG);
+	tm->tm_mon = rtc_read(OMAP_RTC_MONTHS_REG);
+	tm->tm_year = rtc_read(OMAP_RTC_YEARS_REG);
+
+	local_irq_enable();
+
+	bcd2tm(tm);
+	return 0;
+}
+
+static int omap_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+	if (tm2bcd(tm) < 0)
+		return -EINVAL;
+	local_irq_disable();
+	rtc_wait_not_busy();
+
+	rtc_write(tm->tm_year, OMAP_RTC_YEARS_REG);
+	rtc_write(tm->tm_mon, OMAP_RTC_MONTHS_REG);
+	rtc_write(tm->tm_mday, OMAP_RTC_DAYS_REG);
+	rtc_write(tm->tm_hour, OMAP_RTC_HOURS_REG);
+	rtc_write(tm->tm_min, OMAP_RTC_MINUTES_REG);
+	rtc_write(tm->tm_sec, OMAP_RTC_SECONDS_REG);
+
+	local_irq_enable();
+
+	return 0;
+}
+
+static int omap_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
+{
+	local_irq_disable();
+	rtc_wait_not_busy();
+
+	alm->time.tm_sec = rtc_read(OMAP_RTC_ALARM_SECONDS_REG);
+	alm->time.tm_min = rtc_read(OMAP_RTC_ALARM_MINUTES_REG);
+	alm->time.tm_hour = rtc_read(OMAP_RTC_ALARM_HOURS_REG);
+	alm->time.tm_mday = rtc_read(OMAP_RTC_ALARM_DAYS_REG);
+	alm->time.tm_mon = rtc_read(OMAP_RTC_ALARM_MONTHS_REG);
+	alm->time.tm_year = rtc_read(OMAP_RTC_ALARM_YEARS_REG);
+
+	local_irq_enable();
+
+	bcd2tm(&alm->time);
+	alm->pending = !!(rtc_read(OMAP_RTC_INTERRUPTS_REG)
+			& OMAP_RTC_INTERRUPTS_IT_ALARM);
+	alm->enabled = alm->pending && device_may_wakeup(dev);
+
+	return 0;
+}
+
+static int omap_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
+{
+	u8 reg;
+
+	/* Much userspace code uses RTC_ALM_SET, thus "don't care" for
+	 * day/month/year specifies alarms up to 24 hours in the future.
+	 * So we need to handle that ... but let's ignore the "don't care"
+	 * values for hours/minutes/seconds.
+	 */
+	if (alm->time.tm_mday <= 0
+			&& alm->time.tm_mon < 0
+			&& alm->time.tm_year < 0) {
+		struct rtc_time tm;
+		unsigned long now, then;
+
+		omap_rtc_read_time(dev, &tm);
+		rtc_tm_to_time(&tm, &now);
+
+		alm->time.tm_mday = tm.tm_mday;
+		alm->time.tm_mon = tm.tm_mon;
+		alm->time.tm_year = tm.tm_year;
+		rtc_tm_to_time(&alm->time, &then);
+
+		/* sometimes the alarm wraps into tomorrow */
+		if (then < now) {
+			rtc_time_to_tm(now + 24 * 60 * 60, &tm);
+			alm->time.tm_mday = tm.tm_mday;
+			alm->time.tm_mon = tm.tm_mon;
+			alm->time.tm_year = tm.tm_year;
+		}
+	}
+
+	if (tm2bcd(&alm->time) < 0)
+		return -EINVAL;
+
+	local_irq_disable();
+	rtc_wait_not_busy();
+
+	rtc_write(alm->time.tm_year, OMAP_RTC_ALARM_YEARS_REG);
+	rtc_write(alm->time.tm_mon, OMAP_RTC_ALARM_MONTHS_REG);
+	rtc_write(alm->time.tm_mday, OMAP_RTC_ALARM_DAYS_REG);
+	rtc_write(alm->time.tm_hour, OMAP_RTC_ALARM_HOURS_REG);
+	rtc_write(alm->time.tm_min, OMAP_RTC_ALARM_MINUTES_REG);
+	rtc_write(alm->time.tm_sec, OMAP_RTC_ALARM_SECONDS_REG);
+
+	reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);
+	if (alm->enabled)
+		reg |= OMAP_RTC_INTERRUPTS_IT_ALARM;
+	else
+		reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
+	rtc_write(reg, OMAP_RTC_INTERRUPTS_REG);
+
+	local_irq_enable();
+
+	return 0;
+}
+
+static struct rtc_class_ops omap_rtc_ops = {
+	.ioctl		= omap_rtc_ioctl,
+	.read_time	= omap_rtc_read_time,
+	.set_time	= omap_rtc_set_time,
+	.read_alarm	= omap_rtc_read_alarm,
+	.set_alarm	= omap_rtc_set_alarm,
+};
+
+static int omap_rtc_alarm;
+static int omap_rtc_timer;
+
+static int __devinit omap_rtc_probe(struct platform_device *pdev)
+{
+	struct resource		*res, *mem;
+	struct rtc_device	*rtc;
+	u8			reg, new_ctrl;
+
+	omap_rtc_timer = platform_get_irq(pdev, 0);
+	if (omap_rtc_timer <= 0) {
+		pr_debug("%s: no update irq?\n", pdev->name);
+		return -ENOENT;
+	}
+
+	omap_rtc_alarm = platform_get_irq(pdev, 1);
+	if (omap_rtc_alarm <= 0) {
+		pr_debug("%s: no alarm irq?\n", pdev->name);
+		return -ENOENT;
+	}
+
+	/* NOTE:  using static mapping for RTC registers */
+	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	if (res && res->start != OMAP_RTC_BASE) {
+		pr_debug("%s: RTC registers at %08x, expected %08x\n",
+			pdev->name, (unsigned) res->start, OMAP_RTC_BASE);
+		return -ENOENT;
+	}
+
+	if (res)
+		mem = request_mem_region(res->start,
+				res->end - res->start + 1,
+				pdev->name);
+	else
+		mem = NULL;
+	if (!mem) {
+		pr_debug("%s: RTC registers at %08x are not free\n",
+			pdev->name, OMAP_RTC_BASE);
+		return -EBUSY;
+	}
+
+	rtc = rtc_device_register(pdev->name, &pdev->dev,
+			&omap_rtc_ops, THIS_MODULE);
+	if (IS_ERR(rtc)) {
+		pr_debug("%s: can't register RTC device, err %ld\n",
+			pdev->name, PTR_ERR(rtc));
+		goto fail;
+	}
+	platform_set_drvdata(pdev, rtc);
+	class_set_devdata(&rtc->class_dev, mem);
+
+	/* clear pending irqs, and set 1/second periodic,
+	 * which we'll use instead of update irqs
+	 */
+	rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
+
+	/* clear old status */
+	reg = rtc_read(OMAP_RTC_STATUS_REG);
+	if (reg & (u8) OMAP_RTC_STATUS_POWER_UP) {
+		pr_info("%s: RTC power up reset detected\n",
+			pdev->name);
+		rtc_write(OMAP_RTC_STATUS_POWER_UP, OMAP_RTC_STATUS_REG);
+	}
+	if (reg & (u8) OMAP_RTC_STATUS_ALARM)
+		rtc_write(OMAP_RTC_STATUS_ALARM, OMAP_RTC_STATUS_REG);
+
+	/* handle periodic and alarm irqs */
+	if (request_irq(omap_rtc_timer, rtc_irq, SA_INTERRUPT,
+			rtc->class_dev.class_id, &rtc->class_dev)) {
+		pr_debug("%s: RTC timer interrupt IRQ%d already claimed\n",
+			pdev->name, omap_rtc_timer);
+		goto fail0;
+	}
+	if (request_irq(omap_rtc_alarm, rtc_irq, SA_INTERRUPT,
+			rtc->class_dev.class_id, &rtc->class_dev)) {
+		pr_debug("%s: RTC alarm interrupt IRQ%d already claimed\n",
+			pdev->name, omap_rtc_alarm);
+		goto fail1;
+	}
+
+	/* On boards with split power, RTC_ON_NOFF won't reset the RTC */
+	reg = rtc_read(OMAP_RTC_CTRL_REG);
+	if (reg & (u8) OMAP_RTC_CTRL_STOP)
+		pr_info("%s: already running\n", pdev->name);
+
+	/* force to 24 hour mode */
+	new_ctrl = reg & ~(OMAP_RTC_CTRL_SPLIT|OMAP_RTC_CTRL_AUTO_COMP);
+	new_ctrl |= OMAP_RTC_CTRL_STOP;
+
+	/* BOARD-SPECIFIC CUSTOMIZATION CAN GO HERE:
+	 *
+	 *  - Boards wired so that RTC_WAKE_INT does something, and muxed
+	 *    right (W13_1610_RTC_WAKE_INT is the default after chip reset),
+	 *    should initialize the device wakeup flag appropriately.
+	 *
+	 *  - Boards wired so RTC_ON_nOFF is used as the reset signal,
+	 *    rather than nPWRON_RESET, should forcibly enable split
+	 *    power mode.  (Some chip errata report that RTC_CTRL_SPLIT
+	 *    is write-only, and always reads as zero...)
+	 */
+	device_init_wakeup(&pdev->dev, 0);
+
+	if (new_ctrl & (u8) OMAP_RTC_CTRL_SPLIT)
+		pr_info("%s: split power mode\n", pdev->name);
+
+	if (reg != new_ctrl)
+		rtc_write(new_ctrl, OMAP_RTC_CTRL_REG);
+
+	return 0;
+
+fail1:
+	free_irq(omap_rtc_timer, NULL);
+fail0:
+	rtc_device_unregister(rtc);
+fail:
+	release_resource(mem);
+	return -EIO;
+}
+
+static int __devexit omap_rtc_remove(struct platform_device *pdev)
+{
+	struct rtc_device	*rtc = platform_get_drvdata(pdev);;
+
+	device_init_wakeup(&pdev->dev, 0);
+
+	/* leave rtc running, but disable irqs */
+	rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
+
+	free_irq(omap_rtc_timer, rtc);
+	free_irq(omap_rtc_alarm, rtc);
+
+	release_resource(class_get_devdata(&rtc->class_dev));
+	rtc_device_unregister(rtc);
+	return 0;
+}
+
+#ifdef CONFIG_PM
+
+static struct timespec rtc_delta;
+static u8 irqstat;
+
+static int omap_rtc_suspend(struct platform_device *pdev, pm_message_t state)
+{
+	struct rtc_time rtc_tm;
+	struct timespec time;
+
+	time.tv_nsec = 0;
+	omap_rtc_read_time(NULL, &rtc_tm);
+	rtc_tm_to_time(&rtc_tm, &time.tv_sec);
+
+	save_time_delta(&rtc_delta, &time);
+	irqstat = rtc_read(OMAP_RTC_INTERRUPTS_REG);
+
+	/* FIXME the RTC alarm is not currently acting as a wakeup event
+	 * source, and in fact this enable() call is just saving a flag
+	 * that's never used...
+	 */
+	if (device_may_wakeup(&pdev->dev))
+		enable_irq_wake(omap_rtc_alarm);
+	else
+		rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
+
+	return 0;
+}
+
+static int omap_rtc_resume(struct platform_device *pdev)
+{
+	struct rtc_time rtc_tm;
+	struct timespec time;
+
+	time.tv_nsec = 0;
+	omap_rtc_read_time(NULL, &rtc_tm);
+	rtc_tm_to_time(&rtc_tm, &time.tv_sec);
+
+	restore_time_delta(&rtc_delta, &time);
+	if (device_may_wakeup(&pdev->dev))
+		disable_irq_wake(omap_rtc_alarm);
+	else
+		rtc_write(irqstat, OMAP_RTC_INTERRUPTS_REG);
+	return 0;
+}
+
+#else
+#define omap_rtc_suspend NULL
+#define omap_rtc_resume  NULL
+#endif
+
+static void omap_rtc_shutdown(struct platform_device *pdev)
+{
+	rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
+}
+
+MODULE_ALIAS("omap_rtc");
+static struct platform_driver omap_rtc_driver = {
+	.probe		= omap_rtc_probe,
+	.remove		= __devexit_p(omap_rtc_remove),
+	.suspend	= omap_rtc_suspend,
+	.resume		= omap_rtc_resume,
+	.shutdown	= omap_rtc_shutdown,
+	.driver		= {
+		.name	= "omap_rtc",
+		.owner	= THIS_MODULE,
+	},
+};
+
+static int __init rtc_init(void)
+{
+	return platform_driver_register(&omap_rtc_driver);
+}
+
+static void __exit rtc_exit(void)
+{
+	platform_driver_unregister(&omap_rtc_driver);
+}
+
+module_init(rtc_init);
+module_exit(rtc_exit);
+
+MODULE_AUTHOR("George G. Davis (and others)");
+MODULE_LICENSE("GPL");

RE: [patch 2.6.17-rc4-omap-git] rtc-omap, rtc framework driver

[Johnson, Steve-OMAP]

Hi Dave,

For OMAP2 and OMAP3, the RTC is in the Power Management companion chip
(TWL92230 and TWL4030).

Where do you see an RTC on the web site for OMAP2420?  The only picture
I see shows the RTC in the companion chip.

http://focus.ti.com/general/docs/wtbu/wtbuproductcontent.tsp?templateId=
6123&navigationId=11990&contentId=4671

Regards,

Steve
 

> -----Original Message-----
> From: linux-omap-open-source-bounces@linux.omap.com 
> [mailto:linux-omap-open-source-bounces@linux.omap.com] On 
> Behalf Of David Brownell
> Sent: Tuesday, August 15, 2006 12:04 PM
> To: linux-omap-open-source@linux.omap.com
> Subject: [patch 2.6.17-rc4-omap-git] rtc-omap, rtc framework driver
> 
> Cleaning out my patch queue ... here's an "rtc class" driver. 
>  Much more suitable for upstream merging than the previous 
> version, even though that code has gotten much cleaner over time.
> 
> Could someone confirm that this RTC can't actually do system 
> wakeups without external hardware support?  My documentation 
> isn't at all clear on that issue.  There's certainly an 
> external wakeup signal available, but text also says that the 
> alarm irq should work the normal way ... but I don't see that 
> happening.  It could easily be just a bug in 
> enable_irq_wakeup(INT_RTC_ALARM) handling, which ISTR looked 
> like a big NOP last I checked (for almost all IRQs).
> 
> Also, someone with an OMAP2 setup should confirm that the 
> Kconfig is right, and this particular controller isn't 
> provided on OMAP2.  That certainly matches the lack of RTC in 
> the .../mach-omap2 directory, but the TI website says 2420 
> (but not {2,3}430) has an RTC.  Maybe the OMAP 2420 support 
> is just missing, and it's really the same RTC...
> 
> - Dave
> 
> 
> This creates a new RTC-framework driver for the RTC/calendar 
> module found in various OMAP chips, giving a more 
> correct/standard replacement for the older 
> drivers/char/omap-rtc.c driver.  Differences include:
> 
>  - much smaller/simpler, because it reuses shared infrastructure
>  - the RTC name will normally be "rtc0" not "rtc"
>  - the /dev node has a different major and minor numbers
>  - RTC_ALM_SET handled as on PCs (alarm within 24 hours)
>  - RTC_WKALM_SET handled as on PCs (alarm within this century)
>  - epoch not changeable (why bother)
>  - rtc alarm may optionally be a system wakeup event (board-specific)
>  
> If you use udev and statically link this, some init script 
> can just create a symbolic link (rtc -> rtc0) so tools like 
> "hwclock" will work as usual.
> Or, updates to hwclock (and busybox) are available which 
> teach it to use the /dev/rtc0 path as a backup, and to 
> support "hwclock --file=/dev/rtc0". 
> 
> Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
> 
> ----
> Presumably an upstream merge should remove the devices.c 
> support for the older non-framework driver.
> 
>  arch/arm/mach-omap1/devices.c |    2 
>  drivers/rtc/Kconfig           |    8 
>  drivers/rtc/Makefile          |    1 
>  drivers/rtc/rtc-omap.c        |  573 
> ++++++++++++++++++++++++++++++++++++++++++
>  4 files changed, 583 insertions(+), 1 deletion(-)
> 
> Index: omap-2.6/drivers/rtc/Kconfig
> ===================================================================
> --- omap-2.6.orig/drivers/rtc/Kconfig	2006-08-07 
> 20:53:03.000000000 -0700
> +++ omap-2.6/drivers/rtc/Kconfig	2006-08-15 
> 08:40:06.000000000 -0700
> @@ -151,6 +151,14 @@ config RTC_DRV_DS1742
>  	  This driver can also be built as a module. If so, the module
>  	  will be called rtc-ds1742.
>  
> +config RTC_DRV_OMAP
> +	tristate "TI OMAP1"
> +	depends on RTC_CLASS && ( \
> +		ARCH_OMAP15XX || ARCH_OMAP16XX || ARCH_OMAP730 )
> +	help
> +	  Say "yes" here to support the real time clock on TI 
> OMAP1 chips.
> +	  This driver can also be built as a module called rtc-omap.
> +
>  config RTC_DRV_PCF8563
>  	tristate "Philips PCF8563/Epson RTC8564"
>  	depends on RTC_CLASS && I2C
> Index: omap-2.6/arch/arm/mach-omap1/devices.c
> ===================================================================
> --- omap-2.6.orig/arch/arm/mach-omap1/devices.c	
> 2006-08-07 20:50:44.000000000 -0700
> +++ omap-2.6/arch/arm/mach-omap1/devices.c	2006-08-15 
> 08:40:06.000000000 -0700
> @@ -26,7 +26,7 @@
>  
>  
> /*------------------------------------------------------------
> -------------*/
>  
> -#if	defined(CONFIG_OMAP_RTC) || defined(CONFIG_OMAP_RTC)
> +#if defined(CONFIG_OMAP_RTC) || defined(CONFIG_RTC_DRV_OMAP) || 
> +defined(CONFIG_RTC_DRV_OMAP_MODULE)
>  
>  #define	OMAP_RTC_BASE		0xfffb4800
>  
> Index: omap-2.6/drivers/rtc/Makefile
> ===================================================================
> --- omap-2.6.orig/drivers/rtc/Makefile	2006-08-07 
> 20:53:03.000000000 -0700
> +++ omap-2.6/drivers/rtc/Makefile	2006-08-15 
> 08:40:49.000000000 -0700
> @@ -17,6 +17,7 @@ obj-$(CONFIG_RTC_DRV_TEST)	+= rtc-test.o
>  obj-$(CONFIG_RTC_DRV_DS1307)	+= rtc-ds1307.o
>  obj-$(CONFIG_RTC_DRV_DS1672)	+= rtc-ds1672.o
>  obj-$(CONFIG_RTC_DRV_DS1742)	+= rtc-ds1742.o
> +obj-$(CONFIG_RTC_DRV_OMAP)	+= rtc-omap.o
>  obj-$(CONFIG_RTC_DRV_PCF8563)	+= rtc-pcf8563.o
>  obj-$(CONFIG_RTC_DRV_PCF8583)	+= rtc-pcf8583.o
>  obj-$(CONFIG_RTC_DRV_RS5C372)	+= rtc-rs5c372.o
> Index: omap-2.6/drivers/rtc/rtc-omap.c
> ===================================================================
> --- /dev/null	1970-01-01 00:00:00.000000000 +0000
> +++ omap-2.6/drivers/rtc/rtc-omap.c	2006-08-15 
> 08:40:06.000000000 -0700
> @@ -0,0 +1,573 @@
> +/*
> + * TI OMAP1 Real Time Clock interface for Linux
> + *
> + * Copyright (C) 2003 MontaVista Software, Inc.
> + * Author: George G. Davis <gdavis@mvista.com> or <source@mvista.com>
> + *
> + * Copyright (C) 2006 David Brownell (new RTC framework)
> + *
> + * This program is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU General Public License
> + * as published by the Free Software Foundation; either version
> + * 2 of the License, or (at your option) any later version.
> + */
> +
> +#include <linux/kernel.h>
> +#include <linux/init.h>
> +#include <linux/module.h>
> +#include <linux/ioport.h>
> +#include <linux/delay.h>
> +#include <linux/rtc.h>
> +#include <linux/bcd.h>
> +#include <linux/platform_device.h>
> +
> +#include <asm/io.h>
> +#include <asm/mach/time.h>
> +
> +
> +/* The OMAP1 RTC is a year/month/day/hours/minutes/seconds BCD clock
> + * with century-range alarm matching, driven by the 32kHz clock.
> + *
> + * The main user-visible ways it differs from PC RTCs are by omitting
> + * "don't care" alarm fields and sub-second periodic IRQs, and having
> + * an autoadjust mechanism to calibrate to the true oscillator rate.
> + *
> + * Board-specific wiring options include using split power mode with
> + * RTC_OFF_NOFF used as the reset signal (so the RTC won't be reset),
> + * and wiring RTC_WAKE_INT (so the RTC alarm can wake the system from
> + * low power modes).  See the BOARD-SPECIFIC CUSTOMIZATION comment.
> + */
> +
> +#define OMAP_RTC_BASE			0xfffb4800
> +
> +/* RTC registers */
> +#define OMAP_RTC_SECONDS_REG		0x00
> +#define OMAP_RTC_MINUTES_REG		0x04
> +#define OMAP_RTC_HOURS_REG		0x08
> +#define OMAP_RTC_DAYS_REG		0x0C
> +#define OMAP_RTC_MONTHS_REG		0x10
> +#define OMAP_RTC_YEARS_REG		0x14
> +#define OMAP_RTC_WEEKS_REG		0x18
> +
> +#define OMAP_RTC_ALARM_SECONDS_REG	0x20
> +#define OMAP_RTC_ALARM_MINUTES_REG	0x24
> +#define OMAP_RTC_ALARM_HOURS_REG	0x28
> +#define OMAP_RTC_ALARM_DAYS_REG		0x2c
> +#define OMAP_RTC_ALARM_MONTHS_REG	0x30
> +#define OMAP_RTC_ALARM_YEARS_REG	0x34
> +
> +#define OMAP_RTC_CTRL_REG		0x40
> +#define OMAP_RTC_STATUS_REG		0x44
> +#define OMAP_RTC_INTERRUPTS_REG		0x48
> +
> +#define OMAP_RTC_COMP_LSB_REG		0x4c
> +#define OMAP_RTC_COMP_MSB_REG		0x50
> +#define OMAP_RTC_OSC_REG		0x54
> +
> +/* OMAP_RTC_CTRL_REG bit fields: */
> +#define OMAP_RTC_CTRL_SPLIT		(1<<7)
> +#define OMAP_RTC_CTRL_DISABLE		(1<<6)
> +#define OMAP_RTC_CTRL_SET_32_COUNTER	(1<<5)
> +#define OMAP_RTC_CTRL_TEST		(1<<4)
> +#define OMAP_RTC_CTRL_MODE_12_24	(1<<3)
> +#define OMAP_RTC_CTRL_AUTO_COMP		(1<<2)
> +#define OMAP_RTC_CTRL_ROUND_30S		(1<<1)
> +#define OMAP_RTC_CTRL_STOP		(1<<0)
> +
> +/* OMAP_RTC_STATUS_REG bit fields: */
> +#define OMAP_RTC_STATUS_POWER_UP        (1<<7)
> +#define OMAP_RTC_STATUS_ALARM           (1<<6)
> +#define OMAP_RTC_STATUS_1D_EVENT        (1<<5)
> +#define OMAP_RTC_STATUS_1H_EVENT        (1<<4)
> +#define OMAP_RTC_STATUS_1M_EVENT        (1<<3)
> +#define OMAP_RTC_STATUS_1S_EVENT        (1<<2)
> +#define OMAP_RTC_STATUS_RUN             (1<<1)
> +#define OMAP_RTC_STATUS_BUSY            (1<<0)
> +
> +/* OMAP_RTC_INTERRUPTS_REG bit fields: */
> +#define OMAP_RTC_INTERRUPTS_IT_ALARM    (1<<3)
> +#define OMAP_RTC_INTERRUPTS_IT_TIMER    (1<<2)
> +
> +
> +#define rtc_read(addr)		
> omap_readb(OMAP_RTC_BASE + (addr))
> +#define rtc_write(val, addr)	omap_writeb(val, OMAP_RTC_BASE + (addr))
> +
> +
> +/* platform_bus isn't hotpluggable, so for static linkage 
> it'd be safe
> + * to get rid of probe() and remove() code ... too bad the driver 
> +struct
> + * remembers probe(), that's about 25% of the runtime footprint!!
> + */
> +#ifndef	MODULE
> +#undef	__devexit
> +#undef	__devexit_p
> +#define	__devexit	__exit
> +#define	__devexit_p	__exit_p
> +#endif
> +
> +
> +/* we rely on the rtc framework to handle locking (rtc->ops_lock),
> + * so the only other requirement is that register accesses which
> + * require BUSY to be clear are made with IRQs locally disabled  */ 
> +static void rtc_wait_not_busy(void) {
> +	int	count = 0;
> +	u8	status;
> +
> +	/* BUSY may stay active for 1/32768 second (~30 usec) */
> +	for (count = 0; count < 50; count++) {
> +		status = rtc_read(OMAP_RTC_STATUS_REG);
> +		if ((status & (u8)OMAP_RTC_STATUS_BUSY) == 0)
> +			break;
> +		udelay(1);
> +	}
> +	/* now we have ~15 usec to read/write various registers */ }
> +
> +static irqreturn_t rtc_irq(int irq, void *class_dev, struct pt_regs 
> +*regs) {
> +	unsigned long		events = 0;
> +	u8			irq_data;
> +
> +	irq_data = rtc_read(OMAP_RTC_STATUS_REG);
> +
> +	/* alarm irq? */
> +	if (irq_data & OMAP_RTC_STATUS_ALARM) {
> +		rtc_write(OMAP_RTC_STATUS_ALARM, OMAP_RTC_STATUS_REG);
> +		events |= RTC_IRQF | RTC_AF;
> +	}
> +
> +	/* 1/sec periodic/update irq? */
> +	if (irq_data & OMAP_RTC_STATUS_1S_EVENT)
> +		events |= RTC_IRQF | RTC_UF;
> +
> +	rtc_update_irq(class_dev, 1, events);
> +
> +	return IRQ_HANDLED;
> +}
> +
> +#ifdef	CONFIG_RTC_INTF_DEV
> +
> +static int
> +omap_rtc_ioctl(struct device *dev, unsigned int cmd, 
> unsigned long arg) 
> +{
> +	u8 reg;
> +
> +	switch (cmd) {
> +	case RTC_AIE_OFF:
> +	case RTC_AIE_ON:
> +	case RTC_UIE_OFF:
> +	case RTC_UIE_ON:
> +		break;
> +	default:
> +		return -ENOIOCTLCMD;
> +	}
> +
> +	local_irq_disable();
> +	rtc_wait_not_busy();
> +	reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);
> +	switch (cmd) {
> +	/* AIE = Alarm Interrupt Enable */
> +	case RTC_AIE_OFF:
> +		reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
> +		break;
> +	case RTC_AIE_ON:
> +		reg |= OMAP_RTC_INTERRUPTS_IT_ALARM;
> +		break;
> +	/* UIE = Update Interrupt Enable (1/second) */
> +	case RTC_UIE_OFF:
> +		reg &= ~OMAP_RTC_INTERRUPTS_IT_TIMER;
> +		break;
> +	case RTC_UIE_ON:
> +		reg |= OMAP_RTC_INTERRUPTS_IT_TIMER;
> +		break;
> +	}
> +	rtc_wait_not_busy();
> +	rtc_write(reg, OMAP_RTC_INTERRUPTS_REG);
> +	local_irq_enable();
> +
> +	return 0;
> +}
> +
> +#else
> +#define	omap_rtc_ioctl	NULL
> +#endif
> +
> +/* this hardware doesn't support "don't care" alarm fields */ static 
> +int tm2bcd(struct rtc_time *tm) {
> +	if (rtc_valid_tm(tm) != 0)
> +		return -EINVAL;
> +
> +	tm->tm_sec = BIN2BCD(tm->tm_sec);
> +	tm->tm_min = BIN2BCD(tm->tm_min);
> +	tm->tm_hour = BIN2BCD(tm->tm_hour);
> +	tm->tm_mday = BIN2BCD(tm->tm_mday);
> +
> +	tm->tm_mon = BIN2BCD(tm->tm_mon + 1);
> +
> +	/* epoch == 1900 */
> +	if (tm->tm_year < 100 || tm->tm_year > 199)
> +		return -EINVAL;
> +	tm->tm_year = BIN2BCD(tm->tm_year - 100);
> +
> +	return 0;
> +}
> +
> +static void bcd2tm(struct rtc_time *tm) {
> +	tm->tm_sec = BCD2BIN(tm->tm_sec);
> +	tm->tm_min = BCD2BIN(tm->tm_min);
> +	tm->tm_hour = BCD2BIN(tm->tm_hour);
> +	tm->tm_mday = BCD2BIN(tm->tm_mday);
> +	tm->tm_mon = BCD2BIN(tm->tm_mon) - 1;
> +	/* epoch == 1900 */
> +	tm->tm_year = BCD2BIN(tm->tm_year) + 100; }
> +
> +
> +static int omap_rtc_read_time(struct device *dev, struct 
> rtc_time *tm)
> +{
> +	/* we don't report wday/yday/isdst ... */
> +	local_irq_disable();
> +	rtc_wait_not_busy();
> +
> +	tm->tm_sec = rtc_read(OMAP_RTC_SECONDS_REG);
> +	tm->tm_min = rtc_read(OMAP_RTC_MINUTES_REG);
> +	tm->tm_hour = rtc_read(OMAP_RTC_HOURS_REG);
> +	tm->tm_mday = rtc_read(OMAP_RTC_DAYS_REG);
> +	tm->tm_mon = rtc_read(OMAP_RTC_MONTHS_REG);
> +	tm->tm_year = rtc_read(OMAP_RTC_YEARS_REG);
> +
> +	local_irq_enable();
> +
> +	bcd2tm(tm);
> +	return 0;
> +}
> +
> +static int omap_rtc_set_time(struct device *dev, struct rtc_time *tm)
> +{
> +	if (tm2bcd(tm) < 0)
> +		return -EINVAL;
> +	local_irq_disable();
> +	rtc_wait_not_busy();
> +
> +	rtc_write(tm->tm_year, OMAP_RTC_YEARS_REG);
> +	rtc_write(tm->tm_mon, OMAP_RTC_MONTHS_REG);
> +	rtc_write(tm->tm_mday, OMAP_RTC_DAYS_REG);
> +	rtc_write(tm->tm_hour, OMAP_RTC_HOURS_REG);
> +	rtc_write(tm->tm_min, OMAP_RTC_MINUTES_REG);
> +	rtc_write(tm->tm_sec, OMAP_RTC_SECONDS_REG);
> +
> +	local_irq_enable();
> +
> +	return 0;
> +}
> +
> +static int omap_rtc_read_alarm(struct device *dev, struct 
> rtc_wkalrm *alm)
> +{
> +	local_irq_disable();
> +	rtc_wait_not_busy();
> +
> +	alm->time.tm_sec = rtc_read(OMAP_RTC_ALARM_SECONDS_REG);
> +	alm->time.tm_min = rtc_read(OMAP_RTC_ALARM_MINUTES_REG);
> +	alm->time.tm_hour = rtc_read(OMAP_RTC_ALARM_HOURS_REG);
> +	alm->time.tm_mday = rtc_read(OMAP_RTC_ALARM_DAYS_REG);
> +	alm->time.tm_mon = rtc_read(OMAP_RTC_ALARM_MONTHS_REG);
> +	alm->time.tm_year = rtc_read(OMAP_RTC_ALARM_YEARS_REG);
> +
> +	local_irq_enable();
> +
> +	bcd2tm(&alm->time);
> +	alm->pending = !!(rtc_read(OMAP_RTC_INTERRUPTS_REG)
> +			& OMAP_RTC_INTERRUPTS_IT_ALARM);
> +	alm->enabled = alm->pending && device_may_wakeup(dev);
> +
> +	return 0;
> +}
> +
> +static int omap_rtc_set_alarm(struct device *dev, struct 
> rtc_wkalrm *alm)
> +{
> +	u8 reg;
> +
> +	/* Much userspace code uses RTC_ALM_SET, thus "don't care" for
> +	 * day/month/year specifies alarms up to 24 hours in the future.
> +	 * So we need to handle that ... but let's ignore the 
> "don't care"
> +	 * values for hours/minutes/seconds.
> +	 */
> +	if (alm->time.tm_mday <= 0
> +			&& alm->time.tm_mon < 0
> +			&& alm->time.tm_year < 0) {
> +		struct rtc_time tm;
> +		unsigned long now, then;
> +
> +		omap_rtc_read_time(dev, &tm);
> +		rtc_tm_to_time(&tm, &now);
> +
> +		alm->time.tm_mday = tm.tm_mday;
> +		alm->time.tm_mon = tm.tm_mon;
> +		alm->time.tm_year = tm.tm_year;
> +		rtc_tm_to_time(&alm->time, &then);
> +
> +		/* sometimes the alarm wraps into tomorrow */
> +		if (then < now) {
> +			rtc_time_to_tm(now + 24 * 60 * 60, &tm);
> +			alm->time.tm_mday = tm.tm_mday;
> +			alm->time.tm_mon = tm.tm_mon;
> +			alm->time.tm_year = tm.tm_year;
> +		}
> +	}
> +
> +	if (tm2bcd(&alm->time) < 0)
> +		return -EINVAL;
> +
> +	local_irq_disable();
> +	rtc_wait_not_busy();
> +
> +	rtc_write(alm->time.tm_year, OMAP_RTC_ALARM_YEARS_REG);
> +	rtc_write(alm->time.tm_mon, OMAP_RTC_ALARM_MONTHS_REG);
> +	rtc_write(alm->time.tm_mday, OMAP_RTC_ALARM_DAYS_REG);
> +	rtc_write(alm->time.tm_hour, OMAP_RTC_ALARM_HOURS_REG);
> +	rtc_write(alm->time.tm_min, OMAP_RTC_ALARM_MINUTES_REG);
> +	rtc_write(alm->time.tm_sec, OMAP_RTC_ALARM_SECONDS_REG);
> +
> +	reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);
> +	if (alm->enabled)
> +		reg |= OMAP_RTC_INTERRUPTS_IT_ALARM;
> +	else
> +		reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
> +	rtc_write(reg, OMAP_RTC_INTERRUPTS_REG);
> +
> +	local_irq_enable();
> +
> +	return 0;
> +}
> +
> +static struct rtc_class_ops omap_rtc_ops = {
> +	.ioctl		= omap_rtc_ioctl,
> +	.read_time	= omap_rtc_read_time,
> +	.set_time	= omap_rtc_set_time,
> +	.read_alarm	= omap_rtc_read_alarm,
> +	.set_alarm	= omap_rtc_set_alarm,
> +};
> +
> +static int omap_rtc_alarm;
> +static int omap_rtc_timer;
> +
> +static int __devinit omap_rtc_probe(struct platform_device *pdev)
> +{
> +	struct resource		*res, *mem;
> +	struct rtc_device	*rtc;
> +	u8			reg, new_ctrl;
> +
> +	omap_rtc_timer = platform_get_irq(pdev, 0);
> +	if (omap_rtc_timer <= 0) {
> +		pr_debug("%s: no update irq?\n", pdev->name);
> +		return -ENOENT;
> +	}
> +
> +	omap_rtc_alarm = platform_get_irq(pdev, 1);
> +	if (omap_rtc_alarm <= 0) {
> +		pr_debug("%s: no alarm irq?\n", pdev->name);
> +		return -ENOENT;
> +	}
> +
> +	/* NOTE:  using static mapping for RTC registers */
> +	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> +	if (res && res->start != OMAP_RTC_BASE) {
> +		pr_debug("%s: RTC registers at %08x, expected %08x\n",
> +			pdev->name, (unsigned) res->start, 
> OMAP_RTC_BASE);
> +		return -ENOENT;
> +	}
> +
> +	if (res)
> +		mem = request_mem_region(res->start,
> +				res->end - res->start + 1,
> +				pdev->name);
> +	else
> +		mem = NULL;
> +	if (!mem) {
> +		pr_debug("%s: RTC registers at %08x are not free\n",
> +			pdev->name, OMAP_RTC_BASE);
> +		return -EBUSY;
> +	}
> +
> +	rtc = rtc_device_register(pdev->name, &pdev->dev,
> +			&omap_rtc_ops, THIS_MODULE);
> +	if (IS_ERR(rtc)) {
> +		pr_debug("%s: can't register RTC device, err %ld\n",
> +			pdev->name, PTR_ERR(rtc));
> +		goto fail;
> +	}
> +	platform_set_drvdata(pdev, rtc);
> +	class_set_devdata(&rtc->class_dev, mem);
> +
> +	/* clear pending irqs, and set 1/second periodic,
> +	 * which we'll use instead of update irqs
> +	 */
> +	rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
> +
> +	/* clear old status */
> +	reg = rtc_read(OMAP_RTC_STATUS_REG);
> +	if (reg & (u8) OMAP_RTC_STATUS_POWER_UP) {
> +		pr_info("%s: RTC power up reset detected\n",
> +			pdev->name);
> +		rtc_write(OMAP_RTC_STATUS_POWER_UP, 
> OMAP_RTC_STATUS_REG);
> +	}
> +	if (reg & (u8) OMAP_RTC_STATUS_ALARM)
> +		rtc_write(OMAP_RTC_STATUS_ALARM, OMAP_RTC_STATUS_REG);
> +
> +	/* handle periodic and alarm irqs */
> +	if (request_irq(omap_rtc_timer, rtc_irq, SA_INTERRUPT,
> +			rtc->class_dev.class_id, &rtc->class_dev)) {
> +		pr_debug("%s: RTC timer interrupt IRQ%d already 
> claimed\n",
> +			pdev->name, omap_rtc_timer);
> +		goto fail0;
> +	}
> +	if (request_irq(omap_rtc_alarm, rtc_irq, SA_INTERRUPT,
> +			rtc->class_dev.class_id, &rtc->class_dev)) {
> +		pr_debug("%s: RTC alarm interrupt IRQ%d already 
> claimed\n",
> +			pdev->name, omap_rtc_alarm);
> +		goto fail1;
> +	}
> +
> +	/* On boards with split power, RTC_ON_NOFF won't reset 
> the RTC */
> +	reg = rtc_read(OMAP_RTC_CTRL_REG);
> +	if (reg & (u8) OMAP_RTC_CTRL_STOP)
> +		pr_info("%s: already running\n", pdev->name);
> +
> +	/* force to 24 hour mode */
> +	new_ctrl = reg & ~(OMAP_RTC_CTRL_SPLIT|OMAP_RTC_CTRL_AUTO_COMP);
> +	new_ctrl |= OMAP_RTC_CTRL_STOP;
> +
> +	/* BOARD-SPECIFIC CUSTOMIZATION CAN GO HERE:
> +	 *
> +	 *  - Boards wired so that RTC_WAKE_INT does something, 
> and muxed
> +	 *    right (W13_1610_RTC_WAKE_INT is the default after 
> chip reset),
> +	 *    should initialize the device wakeup flag appropriately.
> +	 *
> +	 *  - Boards wired so RTC_ON_nOFF is used as the reset signal,
> +	 *    rather than nPWRON_RESET, should forcibly enable split
> +	 *    power mode.  (Some chip errata report that RTC_CTRL_SPLIT
> +	 *    is write-only, and always reads as zero...)
> +	 */
> +	device_init_wakeup(&pdev->dev, 0);
> +
> +	if (new_ctrl & (u8) OMAP_RTC_CTRL_SPLIT)
> +		pr_info("%s: split power mode\n", pdev->name);
> +
> +	if (reg != new_ctrl)
> +		rtc_write(new_ctrl, OMAP_RTC_CTRL_REG);
> +
> +	return 0;
> +
> +fail1:
> +	free_irq(omap_rtc_timer, NULL);
> +fail0:
> +	rtc_device_unregister(rtc);
> +fail:
> +	release_resource(mem);
> +	return -EIO;
> +}
> +
> +static int __devexit omap_rtc_remove(struct platform_device *pdev)
> +{
> +	struct rtc_device	*rtc = platform_get_drvdata(pdev);;
> +
> +	device_init_wakeup(&pdev->dev, 0);
> +
> +	/* leave rtc running, but disable irqs */
> +	rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
> +
> +	free_irq(omap_rtc_timer, rtc);
> +	free_irq(omap_rtc_alarm, rtc);
> +
> +	release_resource(class_get_devdata(&rtc->class_dev));
> +	rtc_device_unregister(rtc);
> +	return 0;
> +}
> +
> +#ifdef CONFIG_PM
> +
> +static struct timespec rtc_delta;
> +static u8 irqstat;
> +
> +static int omap_rtc_suspend(struct platform_device *pdev, 
> pm_message_t state)
> +{
> +	struct rtc_time rtc_tm;
> +	struct timespec time;
> +
> +	time.tv_nsec = 0;
> +	omap_rtc_read_time(NULL, &rtc_tm);
> +	rtc_tm_to_time(&rtc_tm, &time.tv_sec);
> +
> +	save_time_delta(&rtc_delta, &time);
> +	irqstat = rtc_read(OMAP_RTC_INTERRUPTS_REG);
> +
> +	/* FIXME the RTC alarm is not currently acting as a wakeup event
> +	 * source, and in fact this enable() call is just saving a flag
> +	 * that's never used...
> +	 */
> +	if (device_may_wakeup(&pdev->dev))
> +		enable_irq_wake(omap_rtc_alarm);
> +	else
> +		rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
> +
> +	return 0;
> +}
> +
> +static int omap_rtc_resume(struct platform_device *pdev)
> +{
> +	struct rtc_time rtc_tm;
> +	struct timespec time;
> +
> +	time.tv_nsec = 0;
> +	omap_rtc_read_time(NULL, &rtc_tm);
> +	rtc_tm_to_time(&rtc_tm, &time.tv_sec);
> +
> +	restore_time_delta(&rtc_delta, &time);
> +	if (device_may_wakeup(&pdev->dev))
> +		disable_irq_wake(omap_rtc_alarm);
> +	else
> +		rtc_write(irqstat, OMAP_RTC_INTERRUPTS_REG);
> +	return 0;
> +}
> +
> +#else
> +#define omap_rtc_suspend NULL
> +#define omap_rtc_resume  NULL
> +#endif
> +
> +static void omap_rtc_shutdown(struct platform_device *pdev)
> +{
> +	rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
> +}
> +
> +MODULE_ALIAS("omap_rtc");
> +static struct platform_driver omap_rtc_driver = {
> +	.probe		= omap_rtc_probe,
> +	.remove		= __devexit_p(omap_rtc_remove),
> +	.suspend	= omap_rtc_suspend,
> +	.resume		= omap_rtc_resume,
> +	.shutdown	= omap_rtc_shutdown,
> +	.driver		= {
> +		.name	= "omap_rtc",
> +		.owner	= THIS_MODULE,
> +	},
> +};
> +
> +static int __init rtc_init(void)
> +{
> +	return platform_driver_register(&omap_rtc_driver);
> +}
> +
> +static void __exit rtc_exit(void)
> +{
> +	platform_driver_unregister(&omap_rtc_driver);
> +}
> +
> +module_init(rtc_init);
> +module_exit(rtc_exit);
> +
> +MODULE_AUTHOR("George G. Davis (and others)");
> +MODULE_LICENSE("GPL");
> _______________________________________________
> Linux-omap-open-source mailing list
> Linux-omap-open-source@linux.omap.com
> http://linux.omap.com/mailman/listinfo/linux-omap-open-source
> 

RE: [patch 2.6.17-rc4-omap-git] rtc-omap, rtc framework driver

[Woodruff, Richard]

Like Steve indicated RTC is in the companion chip.

The GP-Timers (especially the one in the wake up domain) are capable of
generated a wake up interrupt.

The timer can be used somewhat like an RTC if desired.  We do something
like this for test. Before going to sleep select max divider and set the
wake up timer source to 32KHz.  You can now be woken up by a match
register (timed wake) or by roll over.

The power chip's RTC is easier in some regards and harder in others.  As
the power chip requires I2C to talk there is a bit of extra activity in
the programming of it as compared to the internally memory mapped
timers.

Regards,
Richard W.

> -----Original Message-----
> From: linux-omap-open-source-bounces@linux.omap.com
[mailto:linux-omap-
> open-source-bounces@linux.omap.com] On Behalf Of Johnson, Steve-OMAP
> Sent: Tuesday, August 15, 2006 12:25 PM
> To: David Brownell; linux-omap-open-source@linux.omap.com
> Subject: RE: [patch 2.6.17-rc4-omap-git] rtc-omap, rtc framework
driver
> 
> Hi Dave,
> 
> For OMAP2 and OMAP3, the RTC is in the Power Management companion chip
> (TWL92230 and TWL4030).
> 
> Where do you see an RTC on the web site for OMAP2420?  The only
picture
> I see shows the RTC in the companion chip.
> 
>
http://focus.ti.com/general/docs/wtbu/wtbuproductcontent.tsp?templateId=
> 6123&navigationId=11990&contentId=4671
> 
> Regards,
> 
> Steve
> 
> 
> > -----Original Message-----
> > From: linux-omap-open-source-bounces@linux.omap.com
> > [mailto:linux-omap-open-source-bounces@linux.omap.com] On
> > Behalf Of David Brownell
> > Sent: Tuesday, August 15, 2006 12:04 PM
> > To: linux-omap-open-source@linux.omap.com
> > Subject: [patch 2.6.17-rc4-omap-git] rtc-omap, rtc framework driver
> >
> > Cleaning out my patch queue ... here's an "rtc class" driver.
> >  Much more suitable for upstream merging than the previous
> > version, even though that code has gotten much cleaner over time.
> >
> > Could someone confirm that this RTC can't actually do system
> > wakeups without external hardware support?  My documentation
> > isn't at all clear on that issue.  There's certainly an
> > external wakeup signal available, but text also says that the
> > alarm irq should work the normal way ... but I don't see that
> > happening.  It could easily be just a bug in
> > enable_irq_wakeup(INT_RTC_ALARM) handling, which ISTR looked
> > like a big NOP last I checked (for almost all IRQs).
> >
> > Also, someone with an OMAP2 setup should confirm that the
> > Kconfig is right, and this particular controller isn't
> > provided on OMAP2.  That certainly matches the lack of RTC in
> > the .../mach-omap2 directory, but the TI website says 2420
> > (but not {2,3}430) has an RTC.  Maybe the OMAP 2420 support
> > is just missing, and it's really the same RTC...
> >
> > - Dave
> >
> >
> > This creates a new RTC-framework driver for the RTC/calendar
> > module found in various OMAP chips, giving a more
> > correct/standard replacement for the older
> > drivers/char/omap-rtc.c driver.  Differences include:
> >
> >  - much smaller/simpler, because it reuses shared infrastructure
> >  - the RTC name will normally be "rtc0" not "rtc"
> >  - the /dev node has a different major and minor numbers
> >  - RTC_ALM_SET handled as on PCs (alarm within 24 hours)
> >  - RTC_WKALM_SET handled as on PCs (alarm within this century)
> >  - epoch not changeable (why bother)
> >  - rtc alarm may optionally be a system wakeup event
(board-specific)
> >
> > If you use udev and statically link this, some init script
> > can just create a symbolic link (rtc -> rtc0) so tools like
> > "hwclock" will work as usual.
> > Or, updates to hwclock (and busybox) are available which
> > teach it to use the /dev/rtc0 path as a backup, and to
> > support "hwclock --file=/dev/rtc0".
> >
> > Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
> >
> > ----
> > Presumably an upstream merge should remove the devices.c
> > support for the older non-framework driver.
> >
> >  arch/arm/mach-omap1/devices.c |    2
> >  drivers/rtc/Kconfig           |    8
> >  drivers/rtc/Makefile          |    1
> >  drivers/rtc/rtc-omap.c        |  573
> > ++++++++++++++++++++++++++++++++++++++++++
> >  4 files changed, 583 insertions(+), 1 deletion(-)
> >
> > Index: omap-2.6/drivers/rtc/Kconfig
> > ===================================================================
> > --- omap-2.6.orig/drivers/rtc/Kconfig	2006-08-07
> > 20:53:03.000000000 -0700
> > +++ omap-2.6/drivers/rtc/Kconfig	2006-08-15
> > 08:40:06.000000000 -0700
> > @@ -151,6 +151,14 @@ config RTC_DRV_DS1742
> >  	  This driver can also be built as a module. If so, the module
> >  	  will be called rtc-ds1742.
> >
> > +config RTC_DRV_OMAP
> > +	tristate "TI OMAP1"
> > +	depends on RTC_CLASS && ( \
> > +		ARCH_OMAP15XX || ARCH_OMAP16XX || ARCH_OMAP730 )
> > +	help
> > +	  Say "yes" here to support the real time clock on TI
> > OMAP1 chips.
> > +	  This driver can also be built as a module called rtc-omap.
> > +
> >  config RTC_DRV_PCF8563
> >  	tristate "Philips PCF8563/Epson RTC8564"
> >  	depends on RTC_CLASS && I2C
> > Index: omap-2.6/arch/arm/mach-omap1/devices.c
> > ===================================================================
> > --- omap-2.6.orig/arch/arm/mach-omap1/devices.c
> > 2006-08-07 20:50:44.000000000 -0700
> > +++ omap-2.6/arch/arm/mach-omap1/devices.c	2006-08-15
> > 08:40:06.000000000 -0700
> > @@ -26,7 +26,7 @@
> >
> >
> > /*------------------------------------------------------------
> > -------------*/
> >
> > -#if	defined(CONFIG_OMAP_RTC) || defined(CONFIG_OMAP_RTC)
> > +#if defined(CONFIG_OMAP_RTC) || defined(CONFIG_RTC_DRV_OMAP) ||
> > +defined(CONFIG_RTC_DRV_OMAP_MODULE)
> >
> >  #define	OMAP_RTC_BASE		0xfffb4800
> >
> > Index: omap-2.6/drivers/rtc/Makefile
> > ===================================================================
> > --- omap-2.6.orig/drivers/rtc/Makefile	2006-08-07
> > 20:53:03.000000000 -0700
> > +++ omap-2.6/drivers/rtc/Makefile	2006-08-15
> > 08:40:49.000000000 -0700
> > @@ -17,6 +17,7 @@ obj-$(CONFIG_RTC_DRV_TEST)	+= rtc-test.o
> >  obj-$(CONFIG_RTC_DRV_DS1307)	+= rtc-ds1307.o
> >  obj-$(CONFIG_RTC_DRV_DS1672)	+= rtc-ds1672.o
> >  obj-$(CONFIG_RTC_DRV_DS1742)	+= rtc-ds1742.o
> > +obj-$(CONFIG_RTC_DRV_OMAP)	+= rtc-omap.o
> >  obj-$(CONFIG_RTC_DRV_PCF8563)	+= rtc-pcf8563.o
> >  obj-$(CONFIG_RTC_DRV_PCF8583)	+= rtc-pcf8583.o
> >  obj-$(CONFIG_RTC_DRV_RS5C372)	+= rtc-rs5c372.o
> > Index: omap-2.6/drivers/rtc/rtc-omap.c
> > ===================================================================
> > --- /dev/null	1970-01-01 00:00:00.000000000 +0000
> > +++ omap-2.6/drivers/rtc/rtc-omap.c	2006-08-15
> > 08:40:06.000000000 -0700
> > @@ -0,0 +1,573 @@
> > +/*
> > + * TI OMAP1 Real Time Clock interface for Linux
> > + *
> > + * Copyright (C) 2003 MontaVista Software, Inc.
> > + * Author: George G. Davis <gdavis@mvista.com> or
<source@mvista.com>
> > + *
> > + * Copyright (C) 2006 David Brownell (new RTC framework)
> > + *
> > + * This program is free software; you can redistribute it and/or
> > + * modify it under the terms of the GNU General Public License
> > + * as published by the Free Software Foundation; either version
> > + * 2 of the License, or (at your option) any later version.
> > + */
> > +
> > +#include <linux/kernel.h>
> > +#include <linux/init.h>
> > +#include <linux/module.h>
> > +#include <linux/ioport.h>
> > +#include <linux/delay.h>
> > +#include <linux/rtc.h>
> > +#include <linux/bcd.h>
> > +#include <linux/platform_device.h>
> > +
> > +#include <asm/io.h>
> > +#include <asm/mach/time.h>
> > +
> > +
> > +/* The OMAP1 RTC is a year/month/day/hours/minutes/seconds BCD
clock
> > + * with century-range alarm matching, driven by the 32kHz clock.
> > + *
> > + * The main user-visible ways it differs from PC RTCs are by
omitting
> > + * "don't care" alarm fields and sub-second periodic IRQs, and
having
> > + * an autoadjust mechanism to calibrate to the true oscillator
rate.
> > + *
> > + * Board-specific wiring options include using split power mode
with
> > + * RTC_OFF_NOFF used as the reset signal (so the RTC won't be
reset),
> > + * and wiring RTC_WAKE_INT (so the RTC alarm can wake the system
from
> > + * low power modes).  See the BOARD-SPECIFIC CUSTOMIZATION comment.
> > + */
> > +
> > +#define OMAP_RTC_BASE			0xfffb4800
> > +
> > +/* RTC registers */
> > +#define OMAP_RTC_SECONDS_REG		0x00
> > +#define OMAP_RTC_MINUTES_REG		0x04
> > +#define OMAP_RTC_HOURS_REG		0x08
> > +#define OMAP_RTC_DAYS_REG		0x0C
> > +#define OMAP_RTC_MONTHS_REG		0x10
> > +#define OMAP_RTC_YEARS_REG		0x14
> > +#define OMAP_RTC_WEEKS_REG		0x18
> > +
> > +#define OMAP_RTC_ALARM_SECONDS_REG	0x20
> > +#define OMAP_RTC_ALARM_MINUTES_REG	0x24
> > +#define OMAP_RTC_ALARM_HOURS_REG	0x28
> > +#define OMAP_RTC_ALARM_DAYS_REG		0x2c
> > +#define OMAP_RTC_ALARM_MONTHS_REG	0x30
> > +#define OMAP_RTC_ALARM_YEARS_REG	0x34
> > +
> > +#define OMAP_RTC_CTRL_REG		0x40
> > +#define OMAP_RTC_STATUS_REG		0x44
> > +#define OMAP_RTC_INTERRUPTS_REG		0x48
> > +
> > +#define OMAP_RTC_COMP_LSB_REG		0x4c
> > +#define OMAP_RTC_COMP_MSB_REG		0x50
> > +#define OMAP_RTC_OSC_REG		0x54
> > +
> > +/* OMAP_RTC_CTRL_REG bit fields: */
> > +#define OMAP_RTC_CTRL_SPLIT		(1<<7)
> > +#define OMAP_RTC_CTRL_DISABLE		(1<<6)
> > +#define OMAP_RTC_CTRL_SET_32_COUNTER	(1<<5)
> > +#define OMAP_RTC_CTRL_TEST		(1<<4)
> > +#define OMAP_RTC_CTRL_MODE_12_24	(1<<3)
> > +#define OMAP_RTC_CTRL_AUTO_COMP		(1<<2)
> > +#define OMAP_RTC_CTRL_ROUND_30S		(1<<1)
> > +#define OMAP_RTC_CTRL_STOP		(1<<0)
> > +
> > +/* OMAP_RTC_STATUS_REG bit fields: */
> > +#define OMAP_RTC_STATUS_POWER_UP        (1<<7)
> > +#define OMAP_RTC_STATUS_ALARM           (1<<6)
> > +#define OMAP_RTC_STATUS_1D_EVENT        (1<<5)
> > +#define OMAP_RTC_STATUS_1H_EVENT        (1<<4)
> > +#define OMAP_RTC_STATUS_1M_EVENT        (1<<3)
> > +#define OMAP_RTC_STATUS_1S_EVENT        (1<<2)
> > +#define OMAP_RTC_STATUS_RUN             (1<<1)
> > +#define OMAP_RTC_STATUS_BUSY            (1<<0)
> > +
> > +/* OMAP_RTC_INTERRUPTS_REG bit fields: */
> > +#define OMAP_RTC_INTERRUPTS_IT_ALARM    (1<<3)
> > +#define OMAP_RTC_INTERRUPTS_IT_TIMER    (1<<2)
> > +
> > +
> > +#define rtc_read(addr)
> > omap_readb(OMAP_RTC_BASE + (addr))
> > +#define rtc_write(val, addr)	omap_writeb(val, OMAP_RTC_BASE +
> (addr))
> > +
> > +
> > +/* platform_bus isn't hotpluggable, so for static linkage
> > it'd be safe
> > + * to get rid of probe() and remove() code ... too bad the driver
> > +struct
> > + * remembers probe(), that's about 25% of the runtime footprint!!
> > + */
> > +#ifndef	MODULE
> > +#undef	__devexit
> > +#undef	__devexit_p
> > +#define	__devexit	__exit
> > +#define	__devexit_p	__exit_p
> > +#endif
> > +
> > +
> > +/* we rely on the rtc framework to handle locking (rtc->ops_lock),
> > + * so the only other requirement is that register accesses which
> > + * require BUSY to be clear are made with IRQs locally disabled  */
> > +static void rtc_wait_not_busy(void) {
> > +	int	count = 0;
> > +	u8	status;
> > +
> > +	/* BUSY may stay active for 1/32768 second (~30 usec) */
> > +	for (count = 0; count < 50; count++) {
> > +		status = rtc_read(OMAP_RTC_STATUS_REG);
> > +		if ((status & (u8)OMAP_RTC_STATUS_BUSY) == 0)
> > +			break;
> > +		udelay(1);
> > +	}
> > +	/* now we have ~15 usec to read/write various registers */ }
> > +
> > +static irqreturn_t rtc_irq(int irq, void *class_dev, struct pt_regs
> > +*regs) {
> > +	unsigned long		events = 0;
> > +	u8			irq_data;
> > +
> > +	irq_data = rtc_read(OMAP_RTC_STATUS_REG);
> > +
> > +	/* alarm irq? */
> > +	if (irq_data & OMAP_RTC_STATUS_ALARM) {
> > +		rtc_write(OMAP_RTC_STATUS_ALARM, OMAP_RTC_STATUS_REG);
> > +		events |= RTC_IRQF | RTC_AF;
> > +	}
> > +
> > +	/* 1/sec periodic/update irq? */
> > +	if (irq_data & OMAP_RTC_STATUS_1S_EVENT)
> > +		events |= RTC_IRQF | RTC_UF;
> > +
> > +	rtc_update_irq(class_dev, 1, events);
> > +
> > +	return IRQ_HANDLED;
> > +}
> > +
> > +#ifdef	CONFIG_RTC_INTF_DEV
> > +
> > +static int
> > +omap_rtc_ioctl(struct device *dev, unsigned int cmd,
> > unsigned long arg)
> > +{
> > +	u8 reg;
> > +
> > +	switch (cmd) {
> > +	case RTC_AIE_OFF:
> > +	case RTC_AIE_ON:
> > +	case RTC_UIE_OFF:
> > +	case RTC_UIE_ON:
> > +		break;
> > +	default:
> > +		return -ENOIOCTLCMD;
> > +	}
> > +
> > +	local_irq_disable();
> > +	rtc_wait_not_busy();
> > +	reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);
> > +	switch (cmd) {
> > +	/* AIE = Alarm Interrupt Enable */
> > +	case RTC_AIE_OFF:
> > +		reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
> > +		break;
> > +	case RTC_AIE_ON:
> > +		reg |= OMAP_RTC_INTERRUPTS_IT_ALARM;
> > +		break;
> > +	/* UIE = Update Interrupt Enable (1/second) */
> > +	case RTC_UIE_OFF:
> > +		reg &= ~OMAP_RTC_INTERRUPTS_IT_TIMER;
> > +		break;
> > +	case RTC_UIE_ON:
> > +		reg |= OMAP_RTC_INTERRUPTS_IT_TIMER;
> > +		break;
> > +	}
> > +	rtc_wait_not_busy();
> > +	rtc_write(reg, OMAP_RTC_INTERRUPTS_REG);
> > +	local_irq_enable();
> > +
> > +	return 0;
> > +}
> > +
> > +#else
> > +#define	omap_rtc_ioctl	NULL
> > +#endif
> > +
> > +/* this hardware doesn't support "don't care" alarm fields */
static
> > +int tm2bcd(struct rtc_time *tm) {
> > +	if (rtc_valid_tm(tm) != 0)
> > +		return -EINVAL;
> > +
> > +	tm->tm_sec = BIN2BCD(tm->tm_sec);
> > +	tm->tm_min = BIN2BCD(tm->tm_min);
> > +	tm->tm_hour = BIN2BCD(tm->tm_hour);
> > +	tm->tm_mday = BIN2BCD(tm->tm_mday);
> > +
> > +	tm->tm_mon = BIN2BCD(tm->tm_mon + 1);
> > +
> > +	/* epoch == 1900 */
> > +	if (tm->tm_year < 100 || tm->tm_year > 199)
> > +		return -EINVAL;
> > +	tm->tm_year = BIN2BCD(tm->tm_year - 100);
> > +
> > +	return 0;
> > +}
> > +
> > +static void bcd2tm(struct rtc_time *tm) {
> > +	tm->tm_sec = BCD2BIN(tm->tm_sec);
> > +	tm->tm_min = BCD2BIN(tm->tm_min);
> > +	tm->tm_hour = BCD2BIN(tm->tm_hour);
> > +	tm->tm_mday = BCD2BIN(tm->tm_mday);
> > +	tm->tm_mon = BCD2BIN(tm->tm_mon) - 1;
> > +	/* epoch == 1900 */
> > +	tm->tm_year = BCD2BIN(tm->tm_year) + 100; }
> > +
> > +
> > +static int omap_rtc_read_time(struct device *dev, struct
> > rtc_time *tm)
> > +{
> > +	/* we don't report wday/yday/isdst ... */
> > +	local_irq_disable();
> > +	rtc_wait_not_busy();
> > +
> > +	tm->tm_sec = rtc_read(OMAP_RTC_SECONDS_REG);
> > +	tm->tm_min = rtc_read(OMAP_RTC_MINUTES_REG);
> > +	tm->tm_hour = rtc_read(OMAP_RTC_HOURS_REG);
> > +	tm->tm_mday = rtc_read(OMAP_RTC_DAYS_REG);
> > +	tm->tm_mon = rtc_read(OMAP_RTC_MONTHS_REG);
> > +	tm->tm_year = rtc_read(OMAP_RTC_YEARS_REG);
> > +
> > +	local_irq_enable();
> > +
> > +	bcd2tm(tm);
> > +	return 0;
> > +}
> > +
> > +static int omap_rtc_set_time(struct device *dev, struct rtc_time
*tm)
> > +{
> > +	if (tm2bcd(tm) < 0)
> > +		return -EINVAL;
> > +	local_irq_disable();
> > +	rtc_wait_not_busy();
> > +
> > +	rtc_write(tm->tm_year, OMAP_RTC_YEARS_REG);
> > +	rtc_write(tm->tm_mon, OMAP_RTC_MONTHS_REG);
> > +	rtc_write(tm->tm_mday, OMAP_RTC_DAYS_REG);
> > +	rtc_write(tm->tm_hour, OMAP_RTC_HOURS_REG);
> > +	rtc_write(tm->tm_min, OMAP_RTC_MINUTES_REG);
> > +	rtc_write(tm->tm_sec, OMAP_RTC_SECONDS_REG);
> > +
> > +	local_irq_enable();
> > +
> > +	return 0;
> > +}
> > +
> > +static int omap_rtc_read_alarm(struct device *dev, struct
> > rtc_wkalrm *alm)
> > +{
> > +	local_irq_disable();
> > +	rtc_wait_not_busy();
> > +
> > +	alm->time.tm_sec = rtc_read(OMAP_RTC_ALARM_SECONDS_REG);
> > +	alm->time.tm_min = rtc_read(OMAP_RTC_ALARM_MINUTES_REG);
> > +	alm->time.tm_hour = rtc_read(OMAP_RTC_ALARM_HOURS_REG);
> > +	alm->time.tm_mday = rtc_read(OMAP_RTC_ALARM_DAYS_REG);
> > +	alm->time.tm_mon = rtc_read(OMAP_RTC_ALARM_MONTHS_REG);
> > +	alm->time.tm_year = rtc_read(OMAP_RTC_ALARM_YEARS_REG);
> > +
> > +	local_irq_enable();
> > +
> > +	bcd2tm(&alm->time);
> > +	alm->pending = !!(rtc_read(OMAP_RTC_INTERRUPTS_REG)
> > +			& OMAP_RTC_INTERRUPTS_IT_ALARM);
> > +	alm->enabled = alm->pending && device_may_wakeup(dev);
> > +
> > +	return 0;
> > +}
> > +
> > +static int omap_rtc_set_alarm(struct device *dev, struct
> > rtc_wkalrm *alm)
> > +{
> > +	u8 reg;
> > +
> > +	/* Much userspace code uses RTC_ALM_SET, thus "don't care" for
> > +	 * day/month/year specifies alarms up to 24 hours in the future.
> > +	 * So we need to handle that ... but let's ignore the
> > "don't care"
> > +	 * values for hours/minutes/seconds.
> > +	 */
> > +	if (alm->time.tm_mday <= 0
> > +			&& alm->time.tm_mon < 0
> > +			&& alm->time.tm_year < 0) {
> > +		struct rtc_time tm;
> > +		unsigned long now, then;
> > +
> > +		omap_rtc_read_time(dev, &tm);
> > +		rtc_tm_to_time(&tm, &now);
> > +
> > +		alm->time.tm_mday = tm.tm_mday;
> > +		alm->time.tm_mon = tm.tm_mon;
> > +		alm->time.tm_year = tm.tm_year;
> > +		rtc_tm_to_time(&alm->time, &then);
> > +
> > +		/* sometimes the alarm wraps into tomorrow */
> > +		if (then < now) {
> > +			rtc_time_to_tm(now + 24 * 60 * 60, &tm);
> > +			alm->time.tm_mday = tm.tm_mday;
> > +			alm->time.tm_mon = tm.tm_mon;
> > +			alm->time.tm_year = tm.tm_year;
> > +		}
> > +	}
> > +
> > +	if (tm2bcd(&alm->time) < 0)
> > +		return -EINVAL;
> > +
> > +	local_irq_disable();
> > +	rtc_wait_not_busy();
> > +
> > +	rtc_write(alm->time.tm_year, OMAP_RTC_ALARM_YEARS_REG);
> > +	rtc_write(alm->time.tm_mon, OMAP_RTC_ALARM_MONTHS_REG);
> > +	rtc_write(alm->time.tm_mday, OMAP_RTC_ALARM_DAYS_REG);
> > +	rtc_write(alm->time.tm_hour, OMAP_RTC_ALARM_HOURS_REG);
> > +	rtc_write(alm->time.tm_min, OMAP_RTC_ALARM_MINUTES_REG);
> > +	rtc_write(alm->time.tm_sec, OMAP_RTC_ALARM_SECONDS_REG);
> > +
> > +	reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);
> > +	if (alm->enabled)
> > +		reg |= OMAP_RTC_INTERRUPTS_IT_ALARM;
> > +	else
> > +		reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
> > +	rtc_write(reg, OMAP_RTC_INTERRUPTS_REG);
> > +
> > +	local_irq_enable();
> > +
> > +	return 0;
> > +}
> > +
> > +static struct rtc_class_ops omap_rtc_ops = {
> > +	.ioctl		= omap_rtc_ioctl,
> > +	.read_time	= omap_rtc_read_time,
> > +	.set_time	= omap_rtc_set_time,
> > +	.read_alarm	= omap_rtc_read_alarm,
> > +	.set_alarm	= omap_rtc_set_alarm,
> > +};
> > +
> > +static int omap_rtc_alarm;
> > +static int omap_rtc_timer;
> > +
> > +static int __devinit omap_rtc_probe(struct platform_device *pdev)
> > +{
> > +	struct resource		*res, *mem;
> > +	struct rtc_device	*rtc;
> > +	u8			reg, new_ctrl;
> > +
> > +	omap_rtc_timer = platform_get_irq(pdev, 0);
> > +	if (omap_rtc_timer <= 0) {
> > +		pr_debug("%s: no update irq?\n", pdev->name);
> > +		return -ENOENT;
> > +	}
> > +
> > +	omap_rtc_alarm = platform_get_irq(pdev, 1);
> > +	if (omap_rtc_alarm <= 0) {
> > +		pr_debug("%s: no alarm irq?\n", pdev->name);
> > +		return -ENOENT;
> > +	}
> > +
> > +	/* NOTE:  using static mapping for RTC registers */
> > +	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> > +	if (res && res->start != OMAP_RTC_BASE) {
> > +		pr_debug("%s: RTC registers at %08x, expected %08x\n",
> > +			pdev->name, (unsigned) res->start,
> > OMAP_RTC_BASE);
> > +		return -ENOENT;
> > +	}
> > +
> > +	if (res)
> > +		mem = request_mem_region(res->start,
> > +				res->end - res->start + 1,
> > +				pdev->name);
> > +	else
> > +		mem = NULL;
> > +	if (!mem) {
> > +		pr_debug("%s: RTC registers at %08x are not free\n",
> > +			pdev->name, OMAP_RTC_BASE);
> > +		return -EBUSY;
> > +	}
> > +
> > +	rtc = rtc_device_register(pdev->name, &pdev->dev,
> > +			&omap_rtc_ops, THIS_MODULE);
> > +	if (IS_ERR(rtc)) {
> > +		pr_debug("%s: can't register RTC device, err %ld\n",
> > +			pdev->name, PTR_ERR(rtc));
> > +		goto fail;
> > +	}
> > +	platform_set_drvdata(pdev, rtc);
> > +	class_set_devdata(&rtc->class_dev, mem);
> > +
> > +	/* clear pending irqs, and set 1/second periodic,
> > +	 * which we'll use instead of update irqs
> > +	 */
> > +	rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
> > +
> > +	/* clear old status */
> > +	reg = rtc_read(OMAP_RTC_STATUS_REG);
> > +	if (reg & (u8) OMAP_RTC_STATUS_POWER_UP) {
> > +		pr_info("%s: RTC power up reset detected\n",
> > +			pdev->name);
> > +		rtc_write(OMAP_RTC_STATUS_POWER_UP,
> > OMAP_RTC_STATUS_REG);
> > +	}
> > +	if (reg & (u8) OMAP_RTC_STATUS_ALARM)
> > +		rtc_write(OMAP_RTC_STATUS_ALARM, OMAP_RTC_STATUS_REG);
> > +
> > +	/* handle periodic and alarm irqs */
> > +	if (request_irq(omap_rtc_timer, rtc_irq, SA_INTERRUPT,
> > +			rtc->class_dev.class_id, &rtc->class_dev)) {
> > +		pr_debug("%s: RTC timer interrupt IRQ%d already
> > claimed\n",
> > +			pdev->name, omap_rtc_timer);
> > +		goto fail0;
> > +	}
> > +	if (request_irq(omap_rtc_alarm, rtc_irq, SA_INTERRUPT,
> > +			rtc->class_dev.class_id, &rtc->class_dev)) {
> > +		pr_debug("%s: RTC alarm interrupt IRQ%d already
> > claimed\n",
> > +			pdev->name, omap_rtc_alarm);
> > +		goto fail1;
> > +	}
> > +
> > +	/* On boards with split power, RTC_ON_NOFF won't reset
> > the RTC */
> > +	reg = rtc_read(OMAP_RTC_CTRL_REG);
> > +	if (reg & (u8) OMAP_RTC_CTRL_STOP)
> > +		pr_info("%s: already running\n", pdev->name);
> > +
> > +	/* force to 24 hour mode */
> > +	new_ctrl = reg & ~(OMAP_RTC_CTRL_SPLIT|OMAP_RTC_CTRL_AUTO_COMP);
> > +	new_ctrl |= OMAP_RTC_CTRL_STOP;
> > +
> > +	/* BOARD-SPECIFIC CUSTOMIZATION CAN GO HERE:
> > +	 *
> > +	 *  - Boards wired so that RTC_WAKE_INT does something,
> > and muxed
> > +	 *    right (W13_1610_RTC_WAKE_INT is the default after
> > chip reset),
> > +	 *    should initialize the device wakeup flag appropriately.
> > +	 *
> > +	 *  - Boards wired so RTC_ON_nOFF is used as the reset signal,
> > +	 *    rather than nPWRON_RESET, should forcibly enable split
> > +	 *    power mode.  (Some chip errata report that RTC_CTRL_SPLIT
> > +	 *    is write-only, and always reads as zero...)
> > +	 */
> > +	device_init_wakeup(&pdev->dev, 0);
> > +
> > +	if (new_ctrl & (u8) OMAP_RTC_CTRL_SPLIT)
> > +		pr_info("%s: split power mode\n", pdev->name);
> > +
> > +	if (reg != new_ctrl)
> > +		rtc_write(new_ctrl, OMAP_RTC_CTRL_REG);
> > +
> > +	return 0;
> > +
> > +fail1:
> > +	free_irq(omap_rtc_timer, NULL);
> > +fail0:
> > +	rtc_device_unregister(rtc);
> > +fail:
> > +	release_resource(mem);
> > +	return -EIO;
> > +}
> > +
> > +static int __devexit omap_rtc_remove(struct platform_device *pdev)
> > +{
> > +	struct rtc_device	*rtc = platform_get_drvdata(pdev);;
> > +
> > +	device_init_wakeup(&pdev->dev, 0);
> > +
> > +	/* leave rtc running, but disable irqs */
> > +	rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
> > +
> > +	free_irq(omap_rtc_timer, rtc);
> > +	free_irq(omap_rtc_alarm, rtc);
> > +
> > +	release_resource(class_get_devdata(&rtc->class_dev));
> > +	rtc_device_unregister(rtc);
> > +	return 0;
> > +}
> > +
> > +#ifdef CONFIG_PM
> > +
> > +static struct timespec rtc_delta;
> > +static u8 irqstat;
> > +
> > +static int omap_rtc_suspend(struct platform_device *pdev,
> > pm_message_t state)
> > +{
> > +	struct rtc_time rtc_tm;
> > +	struct timespec time;
> > +
> > +	time.tv_nsec = 0;
> > +	omap_rtc_read_time(NULL, &rtc_tm);
> > +	rtc_tm_to_time(&rtc_tm, &time.tv_sec);
> > +
> > +	save_time_delta(&rtc_delta, &time);
> > +	irqstat = rtc_read(OMAP_RTC_INTERRUPTS_REG);
> > +
> > +	/* FIXME the RTC alarm is not currently acting as a wakeup event
> > +	 * source, and in fact this enable() call is just saving a flag
> > +	 * that's never used...
> > +	 */
> > +	if (device_may_wakeup(&pdev->dev))
> > +		enable_irq_wake(omap_rtc_alarm);
> > +	else
> > +		rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
> > +
> > +	return 0;
> > +}
> > +
> > +static int omap_rtc_resume(struct platform_device *pdev)
> > +{
> > +	struct rtc_time rtc_tm;
> > +	struct timespec time;
> > +
> > +	time.tv_nsec = 0;
> > +	omap_rtc_read_time(NULL, &rtc_tm);
> > +	rtc_tm_to_time(&rtc_tm, &time.tv_sec);
> > +
> > +	restore_time_delta(&rtc_delta, &time);
> > +	if (device_may_wakeup(&pdev->dev))
> > +		disable_irq_wake(omap_rtc_alarm);
> > +	else
> > +		rtc_write(irqstat, OMAP_RTC_INTERRUPTS_REG);
> > +	return 0;
> > +}
> > +
> > +#else
> > +#define omap_rtc_suspend NULL
> > +#define omap_rtc_resume  NULL
> > +#endif
> > +
> > +static void omap_rtc_shutdown(struct platform_device *pdev)
> > +{
> > +	rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
> > +}
> > +
> > +MODULE_ALIAS("omap_rtc");
> > +static struct platform_driver omap_rtc_driver = {
> > +	.probe		= omap_rtc_probe,
> > +	.remove		= __devexit_p(omap_rtc_remove),
> > +	.suspend	= omap_rtc_suspend,
> > +	.resume		= omap_rtc_resume,
> > +	.shutdown	= omap_rtc_shutdown,
> > +	.driver		= {
> > +		.name	= "omap_rtc",
> > +		.owner	= THIS_MODULE,
> > +	},
> > +};
> > +
> > +static int __init rtc_init(void)
> > +{
> > +	return platform_driver_register(&omap_rtc_driver);
> > +}
> > +
> > +static void __exit rtc_exit(void)
> > +{
> > +	platform_driver_unregister(&omap_rtc_driver);
> > +}
> > +
> > +module_init(rtc_init);
> > +module_exit(rtc_exit);
> > +
> > +MODULE_AUTHOR("George G. Davis (and others)");
> > +MODULE_LICENSE("GPL");
> > _______________________________________________
> > Linux-omap-open-source mailing list
> > Linux-omap-open-source@linux.omap.com
> > http://linux.omap.com/mailman/listinfo/linux-omap-open-source
> >
> _______________________________________________
> Linux-omap-open-source mailing list
> Linux-omap-open-source@linux.omap.com
> http://linux.omap.com/mailman/listinfo/linux-omap-open-source

Re: [patch 2.6.17-rc4-omap-git] rtc-omap, rtc framework driver

[David Brownell]

On Tuesday 15 August 2006 10:25 am, Johnson, Steve-OMAP wrote:
> Hi Dave,
> 
> For OMAP2 and OMAP3, the RTC is in the Power Management companion chip
> (TWL92230 and TWL4030).
> 
> Where do you see an RTC on the web site for OMAP2420?  The only picture
> I see shows the RTC in the companion chip.

From www.omap.com, click the left hand option then the JavaScript omap2420
link to reach what I suspect is the same page you list (despite linewrap
manglage) and includes this graphic:

http://focus.ti.com/graphics/wtbu/blockdiagrams/l4_omap2420.gif

which is a GIF that shows an RTC on the omap2420 chip, in the block
labeled "Timers, Interrupt Controllers, RTC".  The product overview
link on that page gives a PDF document which agrees.  (Agreed that the
2420 gif shows another RTC, on the PM chip ... but not for 2430/3430.)

- Dave


> 
> http://focus.ti.com/general/docs/wtbu/wtbuproductcontent.tsp?templateId=
> 6123&navigationId=11990&contentId=4671
> 
> Regards,
> 
> Steve
>  
> 
> > -----Original Message-----
> > From: linux-omap-open-source-bounces@linux.omap.com 
> > [mailto:linux-omap-open-source-bounces@linux.omap.com] On 
> > Behalf Of David Brownell
> > Sent: Tuesday, August 15, 2006 12:04 PM
> > To: linux-omap-open-source@linux.omap.com
> > Subject: [patch 2.6.17-rc4-omap-git] rtc-omap, rtc framework driver
> > 
> > Cleaning out my patch queue ... here's an "rtc class" driver. 
> >  Much more suitable for upstream merging than the previous 
> > version, even though that code has gotten much cleaner over time.
> > 
> > Could someone confirm that this RTC can't actually do system 
> > wakeups without external hardware support?  My documentation 
> > isn't at all clear on that issue.  There's certainly an 
> > external wakeup signal available, but text also says that the 
> > alarm irq should work the normal way ... but I don't see that 
> > happening.  It could easily be just a bug in 
> > enable_irq_wakeup(INT_RTC_ALARM) handling, which ISTR looked 
> > like a big NOP last I checked (for almost all IRQs).
> > 
> > Also, someone with an OMAP2 setup should confirm that the 
> > Kconfig is right, and this particular controller isn't 
> > provided on OMAP2.  That certainly matches the lack of RTC in 
> > the .../mach-omap2 directory, but the TI website says 2420 
> > (but not {2,3}430) has an RTC.  Maybe the OMAP 2420 support 
> > is just missing, and it's really the same RTC...
> > 
> > - Dave
> > 
> > 
> > This creates a new RTC-framework driver for the RTC/calendar 
> > module found in various OMAP chips, giving a more 
> > correct/standard replacement for the older 
> > drivers/char/omap-rtc.c driver.  Differences include:
> > 
> >  - much smaller/simpler, because it reuses shared infrastructure
> >  - the RTC name will normally be "rtc0" not "rtc"
> >  - the /dev node has a different major and minor numbers
> >  - RTC_ALM_SET handled as on PCs (alarm within 24 hours)
> >  - RTC_WKALM_SET handled as on PCs (alarm within this century)
> >  - epoch not changeable (why bother)
> >  - rtc alarm may optionally be a system wakeup event (board-specific)
> >  
> > If you use udev and statically link this, some init script 
> > can just create a symbolic link (rtc -> rtc0) so tools like 
> > "hwclock" will work as usual.
> > Or, updates to hwclock (and busybox) are available which 
> > teach it to use the /dev/rtc0 path as a backup, and to 
> > support "hwclock --file=/dev/rtc0". 
> > 
> > Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
> > 
> > ----
> > Presumably an upstream merge should remove the devices.c 
> > support for the older non-framework driver.
> > 
> >  arch/arm/mach-omap1/devices.c |    2 
> >  drivers/rtc/Kconfig           |    8 
> >  drivers/rtc/Makefile          |    1 
> >  drivers/rtc/rtc-omap.c        |  573 
> > ++++++++++++++++++++++++++++++++++++++++++
> >  4 files changed, 583 insertions(+), 1 deletion(-)
> > 
> > ... deletia ...

RE: [patch 2.6.17-rc4-omap-git] rtc-omap, rtc framework driver

[Johnson, Steve-OMAP]

David,

Thanks.  I'll let marketing know and ask them to fix the graphic.

Regards,

Steve
 

> -----Original Message-----
> From: David Brownell [mailto:david-b@pacbell.net] 
> Sent: Tuesday, August 15, 2006 5:01 PM
> To: Johnson, Steve-OMAP
> Cc: linux-omap-open-source@linux.omap.com
> Subject: Re: [patch 2.6.17-rc4-omap-git] rtc-omap, rtc 
> framework driver
> 
> On Tuesday 15 August 2006 10:25 am, Johnson, Steve-OMAP wrote:
> > Hi Dave,
> > 
> > For OMAP2 and OMAP3, the RTC is in the Power Management 
> companion chip 
> > (TWL92230 and TWL4030).
> > 
> > Where do you see an RTC on the web site for OMAP2420?  The only 
> > picture I see shows the RTC in the companion chip.
> 
> From www.omap.com, click the left hand option then the 
> JavaScript omap2420 link to reach what I suspect is the same 
> page you list (despite linewrap
> manglage) and includes this graphic:
> 
> http://focus.ti.com/graphics/wtbu/blockdiagrams/l4_omap2420.gif
> 
> which is a GIF that shows an RTC on the omap2420 chip, in the 
> block labeled "Timers, Interrupt Controllers, RTC".  The 
> product overview link on that page gives a PDF document which 
> agrees.  (Agreed that the 2420 gif shows another RTC, on the 
> PM chip ... but not for 2430/3430.)
> 
> - Dave
> 
> 
> > 
> > 
> http://focus.ti.com/general/docs/wtbu/wtbuproductcontent.tsp?templateI
> > d=
> > 6123&navigationId=11990&contentId=4671
> > 
> > Regards,
> > 
> > Steve
> >  
> > 
> > > -----Original Message-----
> > > From: linux-omap-open-source-bounces@linux.omap.com
> > > [mailto:linux-omap-open-source-bounces@linux.omap.com] On 
> Behalf Of 
> > > David Brownell
> > > Sent: Tuesday, August 15, 2006 12:04 PM
> > > To: linux-omap-open-source@linux.omap.com
> > > Subject: [patch 2.6.17-rc4-omap-git] rtc-omap, rtc 
> framework driver
> > > 
> > > Cleaning out my patch queue ... here's an "rtc class" driver. 
> > >  Much more suitable for upstream merging than the 
> previous version, 
> > > even though that code has gotten much cleaner over time.
> > > 
> > > Could someone confirm that this RTC can't actually do 
> system wakeups 
> > > without external hardware support?  My documentation isn't at all 
> > > clear on that issue.  There's certainly an external wakeup signal 
> > > available, but text also says that the alarm irq should work the 
> > > normal way ... but I don't see that happening.  It could 
> easily be 
> > > just a bug in
> > > enable_irq_wakeup(INT_RTC_ALARM) handling, which ISTR 
> looked like a 
> > > big NOP last I checked (for almost all IRQs).
> > > 
> > > Also, someone with an OMAP2 setup should confirm that the 
> Kconfig is 
> > > right, and this particular controller isn't provided on 
> OMAP2.  That 
> > > certainly matches the lack of RTC in the .../mach-omap2 
> directory, 
> > > but the TI website says 2420 (but not {2,3}430) has an 
> RTC.  Maybe 
> > > the OMAP 2420 support is just missing, and it's really the same 
> > > RTC...
> > > 
> > > - Dave
> > > 
> > > 
> > > This creates a new RTC-framework driver for the 
> RTC/calendar module 
> > > found in various OMAP chips, giving a more correct/standard 
> > > replacement for the older drivers/char/omap-rtc.c driver.  
> > > Differences include:
> > > 
> > >  - much smaller/simpler, because it reuses shared infrastructure
> > >  - the RTC name will normally be "rtc0" not "rtc"
> > >  - the /dev node has a different major and minor numbers
> > >  - RTC_ALM_SET handled as on PCs (alarm within 24 hours)
> > >  - RTC_WKALM_SET handled as on PCs (alarm within this century)
> > >  - epoch not changeable (why bother)
> > >  - rtc alarm may optionally be a system wakeup event 
> > > (board-specific)
> > >  
> > > If you use udev and statically link this, some init 
> script can just 
> > > create a symbolic link (rtc -> rtc0) so tools like "hwclock" will 
> > > work as usual.
> > > Or, updates to hwclock (and busybox) are available which 
> teach it to 
> > > use the /dev/rtc0 path as a backup, and to support "hwclock 
> > > --file=/dev/rtc0".
> > > 
> > > Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
> > > 
> > > ----
> > > Presumably an upstream merge should remove the devices.c 
> support for 
> > > the older non-framework driver.
> > > 
> > >  arch/arm/mach-omap1/devices.c |    2 
> > >  drivers/rtc/Kconfig           |    8 
> > >  drivers/rtc/Makefile          |    1 
> > >  drivers/rtc/rtc-omap.c        |  573 
> > > ++++++++++++++++++++++++++++++++++++++++++
> > >  4 files changed, 583 insertions(+), 1 deletion(-)
> > > 
> > > ... deletia ...
> 
> 

Re: [patch 2.6.17-rc4-omap-git] rtc-omap, rtc framework driver

[David Brownell]

On Tuesday 15 August 2006 3:03 pm, Johnson, Steve-OMAP wrote:
> David,
> 
> Thanks.  I'll let marketing know and ask them to fix the graphic.

Good, so issue #2 is resolved ... this _is_ OMAP1-only, the Kconfig is right.

How about #1?  Likely it's too late to resolve that doc ambiguity, but it'd
be good to know the answer anyway. :)

- Dave


> > > > Could someone confirm that this RTC can't actually do 
> > > > system wakeups 
> > > > without external hardware support?  My documentation isn't at all 
> > > > clear on that issue.  There's certainly an external wakeup signal 
> > > > available, but text also says that the alarm irq should work the 
> > > > normal way ... but I don't see that happening.  It could 
> > > > easily be just a bug in
> > > > enable_irq_wakeup(INT_RTC_ALARM) handling, which ISTR 
> > > > looked like a 
> > > > big NOP last I checked (for almost all IRQs).

Interrupts on Omap5912

[OJ Ravadilla]

Hi All,

Is there anyone who knows about interrupts on OMAP?
How are interrupts implemented in omap5912? interrupt
priorities? How do you check what interrupt occured?
Do you have to check the status register or can you
just use omap_get_datain to check if the value have
changed? Do you have to clear the pin after the
interrupt occured? Hope to hear from anyone you guys. 





__________________________________________________
Do You Yahoo!?
Tired of spam?  Yahoo! Mail has the best spam protection around 
http://mail.yahoo.com 

Re: Interrupts on Omap5912

[Arnold]

Hi OJ,

> Is there anyone who knows about interrupts on OMAP?
> How are interrupts implemented in omap5912?

I have made an example on howto request interrupt
using a gpio. (take note that this example is for
gpio)

Interrupt input by gpio pin#3
#include <asm/arch/gpio.h>

omap_request_gpio(3);    /* Request for gpio pin */
omap_set_gpio_direction(3,0);

*Setting up pin for interrupt */
set_irq_type(OMAP_GPIO_IRQ(3),IRQT_RISING); 

request_irq(OMAP_GPIO_IRQ(3), (void *)&my_int_handler,
SA_SHIRQ,....);

* Do stuff, handle interrupts in 
my_int_handler */
                
free_irq(OMAP_GPIO_IRQ(3),&id); /*  Freeing interrupt
and gpio pin */
omap_free_gpio(3); 

> Do you have to check the status register 

Dirk Behme answered me this before:
There are level and edge triggered GPIO interrupts,
depends 
on your HW configuration. If you have edge, you
normally 
don't need to acknowledge anything. If you have level,
you 
have to check if you have to acknowledge the interrupt
in 
the external unit issuing the irq on GPIO pin to make
the 
level go away before exiting the ISR.

But this is with regards to gpio. You can see
Documentation/arm/interrupts for more info. Just need
some readings.



__________________________________________________
Do You Yahoo!?
Tired of spam?  Yahoo! Mail has the best spam protection around 
http://mail.yahoo.com 

Re: [patch 2.6.17-rc4-omap-git] rtc-omap, rtc framework driver

[Tony Lindgren]

* David Brownell <david-b@pacbell.net> [060816 01:17]:
> On Tuesday 15 August 2006 3:03 pm, Johnson, Steve-OMAP wrote:
> > David,
> > 
> > Thanks.  I'll let marketing know and ask them to fix the graphic.
> 
> Good, so issue #2 is resolved ... this _is_ OMAP1-only, the Kconfig is right.
> 
> How about #1?  Likely it's too late to resolve that doc ambiguity, but it'd
> be good to know the answer anyway. :)

Sounds like it should be capable of waking up the system if 32KHz clock
is on and the wake-up events are configured properly.

Anyways, pushing today. Let's also plan on removing the old driver then.

Regards,

Tony

Re: [patch 2.6.17-rc4-omap-git] rtc-omap, rtc framework driver

[David Brownell]

On Tuesday 29 August 2006 7:34 am, Tony Lindgren wrote:
> 
> Sounds like it should be capable of waking up the system if 32KHz clock
> is on and the wake-up events are configured properly.

Yes.  I had more of a look at things, and have a patch (yet to be tested)
that should let many more things be wakeup event sources.  MPUIO irqs,
GPIOs not in the first bank, non-MPUI/GPIO irqs (like RTC), etc.


> Anyways, pushing today. Let's also plan on removing the old driver then.

Let's get the wakeup thing fixed, then I'll forward rtc-omap upstream if
nobody reports any significant problems.

Might as well leave the old version in the OMAP tree until the new one
gets pulled down.

- Dave

Re: [patch 2.6.17-rc4-omap-git] rtc-omap, rtc framework driver

[Tony Lindgren]

* David Brownell <david-b@pacbell.net> [060829 22:52]:
> On Tuesday 29 August 2006 7:34 am, Tony Lindgren wrote:
> > 
> > Sounds like it should be capable of waking up the system if 32KHz clock
> > is on and the wake-up events are configured properly.
> 
> Yes.  I had more of a look at things, and have a patch (yet to be tested)
> that should let many more things be wakeup event sources.  MPUIO irqs,
> GPIOs not in the first bank, non-MPUI/GPIO irqs (like RTC), etc.

Cool. 
 
> > Anyways, pushing today. Let's also plan on removing the old driver then.
> 
> Let's get the wakeup thing fixed, then I'll forward rtc-omap upstream if
> nobody reports any significant problems.

OK
 
> Might as well leave the old version in the OMAP tree until the new one
> gets pulled down.

OK

Tony

Re: [patch 2.6.17-rc4-omap-git] rtc-omap, rtc framework driver

[David Brownell]

[-- Attachment #1: Type: text/plain, Size: 628 bytes --]

On Wednesday 30 August 2006 12:57 am, Tony Lindgren wrote:
> * David Brownell <david-b@pacbell.net> [060829 22:52]:
> > On Tuesday 29 August 2006 7:34 am, Tony Lindgren wrote:
> > > 
> > > Sounds like it should be capable of waking up the system if 32KHz clock
> > > is on and the wake-up events are configured properly.
> > 
> > Yes.  I had more of a look at things, and have a patch (yet to be tested)
> > that should let many more things be wakeup event sources.  MPUIO irqs,
> > GPIOs not in the first bank, non-MPUI/GPIO irqs (like RTC), etc.
> 
> Cool. 

hmm, not sure when I'll have a chance to test it, so here it is...

[-- Attachment #2: wake.patch --]
[-- Type: text/x-diff, Size: 8747 bytes --]

Handle wakeup irqs more correctly and completely ... the set of wakeup
events is dynmically specified, not statically, and any IRQ is eligible.

 - (PLATFORM) Add/use MPUIO/ARMIO wakeup event handling, as for GPIO.

 - (PLATFORM) Enabling a GPIO or MPUIO irq as a wakeup event source
   automatically enables its parent MPU L1 or L2 IRQ; this is easy
   now that wakeup enables/disables are properly refcounted.

 - (OMAP1) Move pm wakeup event setup from pm.c into irq.c so that it can
   obey driver {en,dis}able_irq_wake() calls ... so now any L1 or L2
   IRQ source can be a wakeup event, not just a small static group.
   
 - (OMAP1) Only L1->L2 cascades are always marked as wakeup sources.

This means that drivers can now use /sys/devices/.../power/wakeup userspace
configuration for board-specific policies about activating wakeup sources.

UNTESTED.

TODO:  Various drivers, notably the keypad driver, need to learn about
being device_can_wakeup() and {en,dis}able_irq_wake().



Index: osk2/arch/arm/plat-omap/gpio.c
===================================================================
--- osk2.orig/arch/arm/plat-omap/gpio.c	2006-08-29 09:02:28.000000000 -0700
+++ osk2/arch/arm/plat-omap/gpio.c	2006-08-29 09:15:37.000000000 -0700
@@ -646,13 +646,17 @@ static inline void _set_gpio_irqenable(s
 static int _set_gpio_wakeup(struct gpio_bank *bank, int gpio, int enable)
 {
 	switch (bank->method) {
+	case METHOD_MPUIO:
 	case METHOD_GPIO_1610:
 	case METHOD_GPIO_24XX:
 		spin_lock(&bank->lock);
-		if (enable)
+		if (enable) {
 			bank->suspend_wakeup |= (1 << gpio);
-		else
+			enable_irq_wake(bank->irq);
+		} else {
 			bank->suspend_wakeup &= ~(1 << gpio);
+			disable_irq_wake(bank->irq);
+		}
 		spin_unlock(&bank->lock);
 		return 0;
 	default:
@@ -945,6 +949,21 @@ static void gpio_unmask_irq(unsigned int
 	_set_gpio_irqenable(bank, gpio_idx, 1);
 }
 
+static struct irq_chip gpio_irq_chip = {
+	.name		= "GPIO",
+	.startup	= gpio_irq_startup,
+	.shutdown	= gpio_irq_shutdown,
+	.ack		= gpio_ack_irq,
+	.mask		= gpio_mask_irq,
+	.unmask		= gpio_unmask_irq,
+	.set_type	= gpio_irq_type,
+	.set_wake	= gpio_wake_enable,
+};
+
+/*---------------------------------------------------------------------*/
+
+#ifndef	CONFIG_ARCH_OMAP24XX
+
 static void mpuio_ack_irq(unsigned int irq)
 {
 	/* The ISR is reset automatically, so do nothing here. */
@@ -966,24 +985,46 @@ static void mpuio_unmask_irq(unsigned in
 	_set_gpio_irqenable(bank, gpio, 1);
 }
 
-static struct irq_chip gpio_irq_chip = {
-	.name		= "GPIO",
-	.startup	= gpio_irq_startup,
-	.shutdown	= gpio_irq_shutdown,
-	.ack		= gpio_ack_irq,
-	.mask		= gpio_mask_irq,
-	.unmask		= gpio_unmask_irq,
-	.set_type	= gpio_irq_type,
+static struct irq_chip mpuio_irq_chip = {
+	.name		= "MPUIO",
+	.ack		= mpuio_ack_irq,
+	.mask		= mpuio_mask_irq,
+	.unmask		= mpuio_unmask_irq,
 	.set_wake	= gpio_wake_enable,
 };
 
-static struct irq_chip mpuio_irq_chip = {
-	.name	= "MPUIO",
-	.ack	= mpuio_ack_irq,
-	.mask	= mpuio_mask_irq,
-	.unmask	= mpuio_unmask_irq
+static int omap_mpuio_suspend(struct sys_device *dev, pm_message_t mesg)
+{
+	void __iomem	*reg = gpio_bank[0].base + OMAP_MPUIO_GPIO_MASKIT;
+
+	gpio_bank[0].saved_wakeup = __raw_readw(reg);
+	__raw_writew(~gpio_bank[0].suspend_wakeup, reg);
+	return 0;
+}
+
+static int omap_mpuio_resume(struct sys_device *dev)
+{
+	void __iomem	*reg = gpio_bank[0].base + OMAP_MPUIO_GPIO_MASKIT;
+
+	__raw_writew(gpio_bank[0].saved_wakeup, reg);
+	return 0;
+}
+
+static struct sysdev_class omap_mpuio_sysclass = {
+	set_kset_name("mpuio"),
+	.suspend	= omap_mpuio_suspend,
+	.resume		= omap_mpuio_resume,
+};
+
+static struct sys_device omap_mpuio_device = {
+	.id		= 0,
+	.cls		= &omap_mpuio_sysclass,
 };
 
+#endif
+
+/*---------------------------------------------------------------------*/
+
 static int initialized;
 static struct clk * gpio_ick;
 static struct clk * gpio_fck;
@@ -1215,6 +1256,14 @@ static int __init omap_gpio_sysinit(void
 	if (!initialized)
 		ret = _omap_gpio_init();
 
+#ifndef	CONFIG_ARCH_OMAP24XX
+	if (ret == 0) {
+		ret = sysdev_class_register(&omap_mpuio_sysclass);
+		if (ret == 0)
+			ret = sysdev_register(&omap_mpuio_device);
+	}
+#endif
+
 #if defined(CONFIG_ARCH_OMAP16XX) || defined(CONFIG_ARCH_OMAP24XX)
 	if (cpu_is_omap16xx() || cpu_is_omap24xx()) {
 		if (ret == 0) {
Index: osk2/arch/arm/mach-omap1/irq.c
===================================================================
--- osk2.orig/arch/arm/mach-omap1/irq.c	2006-08-29 09:02:27.000000000 -0700
+++ osk2/arch/arm/mach-omap1/irq.c	2006-08-29 09:08:38.000000000 -0700
@@ -118,6 +118,39 @@ static int omap_wake_irq(unsigned int ir
 	return 0;
 }
 
+#ifdef	CONFIG_PM
+
+/* enable_irq_wake() calls from drivers will normally be configured
+ * based on /sys/devices/.../power/wakeup settings, for drivers that
+ * that support wakeup events.
+ */
+void omap_pm_wakeup_setup(void)
+{
+	/* MPU level 1 controller ... take driver settings, plus
+	 * L1->L2 cascade ... GPIO and MPUIO handled via sysdev
+	 */
+	omap_writel(~irq_banks[0].wake_enable, OMAP_IH1_MIR);
+
+	/* MPU level 2 controller ... take driver settings, plus for
+	 * omap730 and omap16xx peripheral wakeup (enabled by irq setup)
+	 */
+	omap_writel(~irq_banks[1].wake_enable, OMAP_IH2_0_MIR);
+
+	if (cpu_is_omap730()) {
+		omap_writel(~irq_banks[1].wake_enable, OMAP_IH2_1_MIR);
+	}
+	if (cpu_is_omap16xx()) {
+		omap_writel(~irq_banks[1].wake_enable, OMAP_IH2_1_MIR);
+		omap_writel(~irq_banks[3].wake_enable, OMAP_IH2_2_MIR);
+		omap_writel(~irq_banks[4].wake_enable, OMAP_IH2_3_MIR);
+	}
+
+	/* New IRQ agreement, recalculate in cascade order */
+	omap_writel(1, OMAP_IH2_CONTROL);
+	omap_writel(1, OMAP_IH1_CONTROL);
+}
+
+#endif	/* PM */
 
 /*
  * Allows tuning the IRQ type and priority
@@ -184,12 +217,17 @@ void __init omap_init_irq(void)
 	if (cpu_is_omap730()) {
 		irq_banks = omap730_irq_banks;
 		irq_bank_count = ARRAY_SIZE(omap730_irq_banks);
+
+		omap_wake_irq(INT_730_IH2_IRQ, 1);
+		omap_wake_irq(INT_730_WAKE_UP_REQ, 1);
 	}
 #endif
 #ifdef CONFIG_ARCH_OMAP15XX
 	if (cpu_is_omap1510()) {
 		irq_banks = omap1510_irq_banks;
 		irq_bank_count = ARRAY_SIZE(omap1510_irq_banks);
+
+		omap_wake_irq(INT_1510_IH2_IRQ, 1);
 	}
 	if (cpu_is_omap310()) {
 		irq_banks = omap310_irq_banks;
@@ -200,6 +238,9 @@ void __init omap_init_irq(void)
 	if (cpu_is_omap16xx()) {
 		irq_banks = omap1610_irq_banks;
 		irq_bank_count = ARRAY_SIZE(omap1610_irq_banks);
+
+		omap_wake_irq(INT_1610_IH2_IRQ, 1);
+		omap_wake_irq(INT_1610_WAKE_UP_REQ, 1);
 	}
 #endif
 	printk("Total of %i interrupts in %i interrupt banks\n",
Index: osk2/arch/arm/mach-omap1/pm.c
===================================================================
--- osk2.orig/arch/arm/mach-omap1/pm.c	2006-08-29 09:02:27.000000000 -0700
+++ osk2/arch/arm/mach-omap1/pm.c	2006-08-29 09:08:38.000000000 -0700
@@ -187,57 +187,8 @@ void omap_pm_idle(void)
 	local_irq_enable();
 }
 
-/*
- * Configuration of the wakeup event is board specific. For the
- * moment we put it into this helper function. Later it may move
- * to board specific files.
- */
-static void omap_pm_wakeup_setup(void)
-{
-	u32 level1_wake = 0;
-	u32 level2_wake = OMAP_IRQ_BIT(INT_UART2);
-
-	/*
-	 * Turn off all interrupts except GPIO bank 1, L1-2nd level cascade,
-	 * and the L2 wakeup interrupts: keypad and UART2. Note that the
-	 * drivers must still separately call omap_set_gpio_wakeup() to
-	 * wake up to a GPIO interrupt.
-	 */
-	if (cpu_is_omap730())
-		level1_wake = OMAP_IRQ_BIT(INT_730_GPIO_BANK1) |
-			OMAP_IRQ_BIT(INT_730_IH2_IRQ);
-	else if (cpu_is_omap15xx())
-		level1_wake = OMAP_IRQ_BIT(INT_GPIO_BANK1) |
-			OMAP_IRQ_BIT(INT_1510_IH2_IRQ);
-	else if (cpu_is_omap16xx())
-		level1_wake = OMAP_IRQ_BIT(INT_GPIO_BANK1) |
-			OMAP_IRQ_BIT(INT_1610_IH2_IRQ);
-
-	omap_writel(~level1_wake, OMAP_IH1_MIR);
-
-	if (cpu_is_omap730()) {
-		omap_writel(~level2_wake, OMAP_IH2_0_MIR);
-		omap_writel(~(OMAP_IRQ_BIT(INT_730_WAKE_UP_REQ) |
-				OMAP_IRQ_BIT(INT_730_MPUIO_KEYPAD)),
-				OMAP_IH2_1_MIR);
-	} else if (cpu_is_omap15xx()) {
-		level2_wake |= OMAP_IRQ_BIT(INT_KEYBOARD);
-		omap_writel(~level2_wake,  OMAP_IH2_MIR);
-	} else if (cpu_is_omap16xx()) {
-		level2_wake |= OMAP_IRQ_BIT(INT_KEYBOARD);
-		omap_writel(~level2_wake, OMAP_IH2_0_MIR);
-
-		/* INT_1610_WAKE_UP_REQ is needed for GPIO wakeup... */
-		omap_writel(~OMAP_IRQ_BIT(INT_1610_WAKE_UP_REQ),
-			    OMAP_IH2_1_MIR);
-		omap_writel(~0x0, OMAP_IH2_2_MIR);
-		omap_writel(~0x0, OMAP_IH2_3_MIR);
-	}
+extern void omap_pm_wakeup_setup(void);
 
-	/*  New IRQ agreement, recalculate in cascade order */
-	omap_writel(1, OMAP_IH2_CONTROL);
-	omap_writel(1, OMAP_IH1_CONTROL);
-}
 
 #define EN_DSPCK	13	/* ARM_CKCTL */
 #define EN_APICK	6	/* ARM_IDLECT2 */

[-- Attachment #3: Type: text/plain, Size: 0 bytes --]