[net-next-2.6.git] / drivers / rtc / rtc-sh.c

/*
 * SuperH On-Chip RTC Support
 *
 * Copyright (C) 2006  Paul Mundt
 * Copyright (C) 2006  Jamie Lenehan
 *
 * Based on the old arch/sh/kernel/cpu/rtc.c by:
 *
 *  Copyright (C) 2000  Philipp Rumpf <prumpf@tux.org>
 *  Copyright (C) 1999  Tetsuya Okada & Niibe Yutaka
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/bcd.h>
#include <linux/rtc.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/seq_file.h>
#include <linux/interrupt.h>
#include <linux/spinlock.h>
#include <linux/io.h>

#define DRV_NAME	"sh-rtc"
#define DRV_VERSION	"0.1.2"

#ifdef CONFIG_CPU_SH3
#define rtc_reg_size		sizeof(u16)
#define RTC_BIT_INVERTED	0	/* No bug on SH7708, SH7709A */
#elif defined(CONFIG_CPU_SH4)
#define rtc_reg_size		sizeof(u32)
#define RTC_BIT_INVERTED	0x40	/* bug on SH7750, SH7750S */
#endif

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

#define R64CNT		RTC_REG(0)

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

/* ALARM Bits - or with BCD encoded value */
#define AR_ENB		0x80	/* Enable for alarm cmp   */

/* RCR1 Bits */
#define RCR1_CF		0x80	/* Carry Flag             */
#define RCR1_CIE	0x10	/* Carry Interrupt Enable */
#define RCR1_AIE	0x08	/* Alarm Interrupt Enable */
#define RCR1_AF		0x01	/* Alarm Flag             */

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

struct sh_rtc {
	void __iomem *regbase;
	unsigned long regsize;
	struct resource *res;
	unsigned int alarm_irq, periodic_irq, carry_irq;
	struct rtc_device *rtc_dev;
	spinlock_t lock;
	int rearm_aie;
};

static irqreturn_t sh_rtc_interrupt(int irq, void *dev_id)
{
	struct platform_device *pdev = to_platform_device(dev_id);
	struct sh_rtc *rtc = platform_get_drvdata(pdev);
	unsigned int tmp, events = 0;

	spin_lock(&rtc->lock);

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

	if (rtc->rearm_aie) {
		if (tmp & RCR1_AF)
			tmp &= ~RCR1_AF;	/* try to clear AF again */
		else {
			tmp |= RCR1_AIE;	/* AF has cleared, rearm IRQ */
			rtc->rearm_aie = 0;
		}
	}

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

	rtc_update_irq(&rtc->rtc_dev->class_dev, 1, events);

	spin_unlock(&rtc->lock);

	return IRQ_HANDLED;
}

static irqreturn_t sh_rtc_alarm(int irq, void *dev_id)
{
	struct platform_device *pdev = to_platform_device(dev_id);
	struct sh_rtc *rtc = platform_get_drvdata(pdev);
	unsigned int tmp, events = 0;

	spin_lock(&rtc->lock);

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

	/*
	 * If AF is set then the alarm has triggered. If we clear AF while
	 * the alarm time still matches the RTC time then AF will
	 * immediately be set again, and if AIE is enabled then the alarm
	 * interrupt will immediately be retrigger. So we clear AIE here
	 * and use rtc->rearm_aie so that the carry interrupt will keep
	 * trying to clear AF and once it stays cleared it'll re-enable
	 * AIE.
	 */
	if (tmp & RCR1_AF) {
		events |= RTC_AF | RTC_IRQF;

		tmp &= ~(RCR1_AF|RCR1_AIE);

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

		rtc->rearm_aie = 1;

		rtc_update_irq(&rtc->rtc_dev->class_dev, 1, events);
	}

	spin_unlock(&rtc->lock);
	return IRQ_HANDLED;
}

static irqreturn_t sh_rtc_periodic(int irq, void *dev_id)
{
	struct platform_device *pdev = to_platform_device(dev_id);
	struct sh_rtc *rtc = platform_get_drvdata(pdev);

	spin_lock(&rtc->lock);

	rtc_update_irq(&rtc->rtc_dev->class_dev, 1, RTC_PF | RTC_IRQF);

	spin_unlock(&rtc->lock);

	return IRQ_HANDLED;
}

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

	spin_lock_irq(&rtc->lock);

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

	if (enable) {
		tmp &= ~RCR2_PESMASK;
		tmp |= RCR2_PEF | (2 << 4);
	} else
		tmp &= ~(RCR2_PESMASK | RCR2_PEF);

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

	spin_unlock_irq(&rtc->lock);
}

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

	spin_lock_irq(&rtc->lock);

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

	if (!enable) {
		tmp &= ~RCR1_AIE;
		rtc->rearm_aie = 0;
	} else if (rtc->rearm_aie == 0)
		tmp |= RCR1_AIE;

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

	spin_unlock_irq(&rtc->lock);
}

static int sh_rtc_open(struct device *dev)
{
	struct sh_rtc *rtc = dev_get_drvdata(dev);
	unsigned int tmp;
	int ret;

	tmp = readb(rtc->regbase + RCR1);
	tmp &= ~RCR1_CF;
	tmp |= RCR1_CIE;
	writeb(tmp, rtc->regbase + RCR1);

	ret = request_irq(rtc->periodic_irq, sh_rtc_periodic, IRQF_DISABLED,
			  "sh-rtc period", dev);
	if (unlikely(ret)) {
		dev_err(dev, "request period IRQ failed with %d, IRQ %d\n",
			ret, rtc->periodic_irq);
		return ret;
	}

	ret = request_irq(rtc->carry_irq, sh_rtc_interrupt, IRQF_DISABLED,
			  "sh-rtc carry", dev);
	if (unlikely(ret)) {
		dev_err(dev, "request carry IRQ failed with %d, IRQ %d\n",
			ret, rtc->carry_irq);
		free_irq(rtc->periodic_irq, dev);
		goto err_bad_carry;
	}

	ret = request_irq(rtc->alarm_irq, sh_rtc_alarm, IRQF_DISABLED,
			  "sh-rtc alarm", dev);
	if (unlikely(ret)) {
		dev_err(dev, "request alarm IRQ failed with %d, IRQ %d\n",
			ret, rtc->alarm_irq);
		goto err_bad_alarm;
	}

	return 0;

err_bad_alarm:
	free_irq(rtc->carry_irq, dev);
err_bad_carry:
	free_irq(rtc->periodic_irq, dev);

	return ret;
}

static void sh_rtc_release(struct device *dev)
{
	struct sh_rtc *rtc = dev_get_drvdata(dev);

	sh_rtc_setpie(dev, 0);
	sh_rtc_setaie(dev, 0);

	free_irq(rtc->periodic_irq, dev);
	free_irq(rtc->carry_irq, dev);
	free_irq(rtc->alarm_irq, dev);
}

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

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

	tmp = readb(rtc->regbase + RCR2);
	seq_printf(seq, "periodic_IRQ\t: %s\n",
		   (tmp & RCR2_PEF) ? "yes" : "no");

	return 0;
}

static int sh_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
{
	unsigned int ret = -ENOIOCTLCMD;

	switch (cmd) {
	case RTC_PIE_OFF:
	case RTC_PIE_ON:
		sh_rtc_setpie(dev, cmd == RTC_PIE_ON);
		ret = 0;
		break;
	case RTC_AIE_OFF:
	case RTC_AIE_ON:
		sh_rtc_setaie(dev, cmd == RTC_AIE_ON);
		ret = 0;
		break;
	}

	return ret;
}

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

	do {
		unsigned int tmp;

		spin_lock_irq(&rtc->lock);

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

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

		tm->tm_sec	= BCD2BIN(readb(rtc->regbase + RSECCNT));
		tm->tm_min	= BCD2BIN(readb(rtc->regbase + RMINCNT));
		tm->tm_hour	= BCD2BIN(readb(rtc->regbase + RHRCNT));
		tm->tm_wday	= BCD2BIN(readb(rtc->regbase + RWKCNT));
		tm->tm_mday	= BCD2BIN(readb(rtc->regbase + RDAYCNT));
		tm->tm_mon	= BCD2BIN(readb(rtc->regbase + RMONCNT)) - 1;

#if defined(CONFIG_CPU_SH4)
		yr  = readw(rtc->regbase + RYRCNT);
		yr100 = BCD2BIN(yr >> 8);
		yr &= 0xff;
#else
		yr  = readb(rtc->regbase + RYRCNT);
		yr100 = BCD2BIN((yr == 0x99) ? 0x19 : 0x20);
#endif

		tm->tm_year = (yr100 * 100 + BCD2BIN(yr)) - 1900;

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

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

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

	dev_dbg(&dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
		"mday=%d, mon=%d, year=%d, wday=%d\n",
		__FUNCTION__,
		tm->tm_sec, tm->tm_min, tm->tm_hour,
		tm->tm_mday, tm->tm_mon + 1, tm->tm_year, tm->tm_wday);

	if (rtc_valid_tm(tm) < 0)
		dev_err(dev, "invalid date\n");

	return 0;
}

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

	spin_lock_irq(&rtc->lock);

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

	writeb(BIN2BCD(tm->tm_sec),  rtc->regbase + RSECCNT);
	writeb(BIN2BCD(tm->tm_min),  rtc->regbase + RMINCNT);
	writeb(BIN2BCD(tm->tm_hour), rtc->regbase + RHRCNT);
	writeb(BIN2BCD(tm->tm_wday), rtc->regbase + RWKCNT);
	writeb(BIN2BCD(tm->tm_mday), rtc->regbase + RDAYCNT);
	writeb(BIN2BCD(tm->tm_mon + 1), rtc->regbase + RMONCNT);

#ifdef CONFIG_CPU_SH3
	year = tm->tm_year % 100;
	writeb(BIN2BCD(year), rtc->regbase + RYRCNT);
#else
	year = (BIN2BCD((tm->tm_year + 1900) / 100) << 8) |
		BIN2BCD(tm->tm_year % 100);
	writew(year, rtc->regbase + RYRCNT);
#endif

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

	spin_unlock_irq(&rtc->lock);

	return 0;
}

static inline int sh_rtc_read_alarm_value(struct sh_rtc *rtc, int reg_off)
{
	unsigned int byte;
	int value = 0xff;	/* return 0xff for ignored values */

	byte = readb(rtc->regbase + reg_off);
	if (byte & AR_ENB) {
		byte &= ~AR_ENB;	/* strip the enable bit */
		value = BCD2BIN(byte);
	}

	return value;
}

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

	spin_lock_irq(&rtc->lock);

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

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

	spin_unlock_irq(&rtc->lock);

	return 0;
}

static inline void sh_rtc_write_alarm_value(struct sh_rtc *rtc,
					    int value, int reg_off)
{
	/* < 0 for a value that is ignored */
	if (value < 0)
		writeb(0, rtc->regbase + reg_off);
	else
		writeb(BIN2BCD(value) | AR_ENB,  rtc->regbase + reg_off);
}

static int sh_rtc_check_alarm(struct rtc_time* tm)
{
	/*
	 * The original rtc says anything > 0xc0 is "don't care" or "match
	 * all" - most users use 0xff but rtc-dev uses -1 for the same thing.
	 * The original rtc doesn't support years - some things use -1 and
	 * some 0xffff. We use -1 to make out tests easier.
	 */
	if (tm->tm_year == 0xffff)
		tm->tm_year = -1;
	if (tm->tm_mon >= 0xff)
		tm->tm_mon = -1;
	if (tm->tm_mday >= 0xff)
		tm->tm_mday = -1;
	if (tm->tm_wday >= 0xff)
		tm->tm_wday = -1;
	if (tm->tm_hour >= 0xff)
		tm->tm_hour = -1;
	if (tm->tm_min >= 0xff)
		tm->tm_min = -1;
	if (tm->tm_sec >= 0xff)
		tm->tm_sec = -1;

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

	return 0;
}

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

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

	spin_lock_irq(&rtc->lock);

	/* disable alarm interrupt and clear flag */
	rcr1 = readb(rtc->regbase + RCR1);
	rcr1 &= ~RCR1_AF;
	writeb(rcr1 & ~RCR1_AIE, rtc->regbase + RCR1);

	rtc->rearm_aie = 0;

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

	/* Restore interrupt activation status */
	writeb(rcr1, rtc->regbase + RCR1);

	spin_unlock_irq(&rtc->lock);

	return 0;
}

static struct rtc_class_ops sh_rtc_ops = {
	.open		= sh_rtc_open,
	.release	= sh_rtc_release,
	.ioctl		= sh_rtc_ioctl,
	.read_time	= sh_rtc_read_time,
	.set_time	= sh_rtc_set_time,
	.read_alarm	= sh_rtc_read_alarm,
	.set_alarm	= sh_rtc_set_alarm,
	.proc		= sh_rtc_proc,
};

static int __devinit sh_rtc_probe(struct platform_device *pdev)
{
	struct sh_rtc *rtc;
	struct resource *res;
	int ret = -ENOENT;

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

	spin_lock_init(&rtc->lock);

	rtc->periodic_irq = platform_get_irq(pdev, 0);
	if (unlikely(rtc->periodic_irq < 0)) {
		dev_err(&pdev->dev, "No IRQ for period\n");
		goto err_badres;
	}

	rtc->carry_irq = platform_get_irq(pdev, 1);
	if (unlikely(rtc->carry_irq < 0)) {
		dev_err(&pdev->dev, "No IRQ for carry\n");
		goto err_badres;
	}

	rtc->alarm_irq = platform_get_irq(pdev, 2);
	if (unlikely(rtc->alarm_irq < 0)) {
		dev_err(&pdev->dev, "No IRQ for alarm\n");
		goto err_badres;
	}

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

	rtc->regsize = res->end - res->start + 1;

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

	rtc->regbase = (void __iomem *)rtc->res->start;
	if (unlikely(!rtc->regbase)) {
		ret = -EINVAL;
		goto err_badmap;
	}

	rtc->rtc_dev = rtc_device_register("sh", &pdev->dev,
					   &sh_rtc_ops, THIS_MODULE);
	if (IS_ERR(rtc)) {
		ret = PTR_ERR(rtc->rtc_dev);
		goto err_badmap;
	}

	platform_set_drvdata(pdev, rtc);

	return 0;

err_badmap:
	release_resource(rtc->res);
err_badres:
	kfree(rtc);

	return ret;
}

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

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

	sh_rtc_setpie(&pdev->dev, 0);
	sh_rtc_setaie(&pdev->dev, 0);

	release_resource(rtc->res);

	platform_set_drvdata(pdev, NULL);

	kfree(rtc);

	return 0;
}
static struct platform_driver sh_rtc_platform_driver = {
	.driver		= {
		.name	= DRV_NAME,
		.owner	= THIS_MODULE,
	},
	.probe		= sh_rtc_probe,
	.remove		= __devexit_p(sh_rtc_remove),
};

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

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

module_init(sh_rtc_init);
module_exit(sh_rtc_exit);

MODULE_DESCRIPTION("SuperH on-chip RTC driver");
MODULE_VERSION(DRV_VERSION);
MODULE_AUTHOR("Paul Mundt <lethal@linux-sh.org>, Jamie Lenehan <lenehan@twibble.org>");
MODULE_LICENSE("GPL");
Commit	Line	Data
317a6104 PM	1	/*
	2	* SuperH On-Chip RTC Support
	3	*
	4	* Copyright (C) 2006 Paul Mundt
1b73e6ae	5	* Copyright (C) 2006 Jamie Lenehan
317a6104 PM	6	*
	7	* Based on the old arch/sh/kernel/cpu/rtc.c by:
	8	*
	9	* Copyright (C) 2000 Philipp Rumpf <prumpf@tux.org>
	10	* Copyright (C) 1999 Tetsuya Okada & Niibe Yutaka
	11	*
	12	* This file is subject to the terms and conditions of the GNU General Public
	13	* License. See the file "COPYING" in the main directory of this archive
	14	* for more details.
	15	*/
	16	#include <linux/module.h>
	17	#include <linux/kernel.h>
	18	#include <linux/bcd.h>
	19	#include <linux/rtc.h>
	20	#include <linux/init.h>
	21	#include <linux/platform_device.h>
	22	#include <linux/seq_file.h>
	23	#include <linux/interrupt.h>
	24	#include <linux/spinlock.h>
31ccb081	25	#include <linux/io.h>
317a6104	26
1b73e6ae JL	27	#define DRV_NAME "sh-rtc"
	28	#define DRV_VERSION "0.1.2"
	29
317a6104 PM	30	#ifdef CONFIG_CPU_SH3
	31	#define rtc_reg_size sizeof(u16)
	32	#define RTC_BIT_INVERTED 0 /* No bug on SH7708, SH7709A */
	33	#elif defined(CONFIG_CPU_SH4)
	34	#define rtc_reg_size sizeof(u32)
	35	#define RTC_BIT_INVERTED 0x40 /* bug on SH7750, SH7750S */
	36	#endif
	37
	38	#define RTC_REG(r) ((r) * rtc_reg_size)
	39
31ccb081	40	#define R64CNT RTC_REG(0)
1b73e6ae JL	41
	42	#define RSECCNT RTC_REG(1) /* RTC sec */
	43	#define RMINCNT RTC_REG(2) /* RTC min */
	44	#define RHRCNT RTC_REG(3) /* RTC hour */
	45	#define RWKCNT RTC_REG(4) /* RTC week */
	46	#define RDAYCNT RTC_REG(5) /* RTC day */
	47	#define RMONCNT RTC_REG(6) /* RTC month */
	48	#define RYRCNT RTC_REG(7) /* RTC year */
	49	#define RSECAR RTC_REG(8) /* ALARM sec */
	50	#define RMINAR RTC_REG(9) /* ALARM min */
	51	#define RHRAR RTC_REG(10) /* ALARM hour */
	52	#define RWKAR RTC_REG(11) /* ALARM week */
	53	#define RDAYAR RTC_REG(12) /* ALARM day */
	54	#define RMONAR RTC_REG(13) /* ALARM month */
	55	#define RCR1 RTC_REG(14) /* Control */
	56	#define RCR2 RTC_REG(15) /* Control */
	57
	58	/* ALARM Bits - or with BCD encoded value */
	59	#define AR_ENB 0x80 /* Enable for alarm cmp */
317a6104 PM	60
	61	/* RCR1 Bits */
	62	#define RCR1_CF 0x80 /* Carry Flag */
	63	#define RCR1_CIE 0x10 /* Carry Interrupt Enable */
	64	#define RCR1_AIE 0x08 /* Alarm Interrupt Enable */
	65	#define RCR1_AF 0x01 /* Alarm Flag */
	66
	67	/* RCR2 Bits */
	68	#define RCR2_PEF 0x80 /* PEriodic interrupt Flag */
	69	#define RCR2_PESMASK 0x70 /* Periodic interrupt Set */
	70	#define RCR2_RTCEN 0x08 /* ENable RTC */
	71	#define RCR2_ADJ 0x04 /* ADJustment (30-second) */
	72	#define RCR2_RESET 0x02 /* Reset bit */
	73	#define RCR2_START 0x01 /* Start bit */
	74
	75	struct sh_rtc {
	76	void __iomem *regbase;
	77	unsigned long regsize;
	78	struct resource *res;
	79	unsigned int alarm_irq, periodic_irq, carry_irq;
	80	struct rtc_device *rtc_dev;
	81	spinlock_t lock;
1b73e6ae	82	int rearm_aie;
317a6104 PM	83	};
317a6104 PM	84
31ccb081	85	static irqreturn_t sh_rtc_interrupt(int irq, void *dev_id)
317a6104	86	{
31ccb081	87	struct platform_device *pdev = to_platform_device(dev_id);
317a6104 PM	88	struct sh_rtc *rtc = platform_get_drvdata(pdev);
	89	unsigned int tmp, events = 0;
	90
	91	spin_lock(&rtc->lock);
	92
	93	tmp = readb(rtc->regbase + RCR1);
1b73e6ae	94	tmp &= ~RCR1_CF;
317a6104	95
1b73e6ae JL	96	if (rtc->rearm_aie) {
	97	if (tmp & RCR1_AF)
	98	tmp &= ~RCR1_AF; /* try to clear AF again */
	99	else {
	100	tmp \|= RCR1_AIE; /* AF has cleared, rearm IRQ */
	101	rtc->rearm_aie = 0;
	102	}
	103	}
317a6104 PM	104
	105	writeb(tmp, rtc->regbase + RCR1);
	106
	107	rtc_update_irq(&rtc->rtc_dev->class_dev, 1, events);
	108
	109	spin_unlock(&rtc->lock);
	110
	111	return IRQ_HANDLED;
	112	}
	113
1b73e6ae JL	114	static irqreturn_t sh_rtc_alarm(int irq, void *dev_id)
	115	{
	116	struct platform_device *pdev = to_platform_device(dev_id);
	117	struct sh_rtc *rtc = platform_get_drvdata(pdev);
	118	unsigned int tmp, events = 0;
	119
	120	spin_lock(&rtc->lock);
	121
	122	tmp = readb(rtc->regbase + RCR1);
	123
	124	/*
	125	* If AF is set then the alarm has triggered. If we clear AF while
	126	* the alarm time still matches the RTC time then AF will
	127	* immediately be set again, and if AIE is enabled then the alarm
	128	* interrupt will immediately be retrigger. So we clear AIE here
	129	* and use rtc->rearm_aie so that the carry interrupt will keep
	130	* trying to clear AF and once it stays cleared it'll re-enable
	131	* AIE.
	132	*/
	133	if (tmp & RCR1_AF) {
	134	events \|= RTC_AF \| RTC_IRQF;
	135
	136	tmp &= ~(RCR1_AF\|RCR1_AIE);
	137
	138	writeb(tmp, rtc->regbase + RCR1);
	139
	140	rtc->rearm_aie = 1;
	141
	142	rtc_update_irq(&rtc->rtc_dev->class_dev, 1, events);
	143	}
	144
	145	spin_unlock(&rtc->lock);
	146	return IRQ_HANDLED;
	147	}
	148
31ccb081	149	static irqreturn_t sh_rtc_periodic(int irq, void *dev_id)
317a6104	150	{
31ccb081 JL	151	struct platform_device *pdev = to_platform_device(dev_id);
31ccb081 JL	152	struct sh_rtc *rtc = platform_get_drvdata(pdev);
317a6104 PM	153
	154	spin_lock(&rtc->lock);
	155
	156	rtc_update_irq(&rtc->rtc_dev->class_dev, 1, RTC_PF \| RTC_IRQF);
	157
	158	spin_unlock(&rtc->lock);
	159
	160	return IRQ_HANDLED;
	161	}
	162
	163	static inline void sh_rtc_setpie(struct device *dev, unsigned int enable)
	164	{
	165	struct sh_rtc *rtc = dev_get_drvdata(dev);
	166	unsigned int tmp;
	167
	168	spin_lock_irq(&rtc->lock);
	169
	170	tmp = readb(rtc->regbase + RCR2);
	171
	172	if (enable) {
	173	tmp &= ~RCR2_PESMASK;
	174	tmp \|= RCR2_PEF \| (2 << 4);
	175	} else
	176	tmp &= ~(RCR2_PESMASK \| RCR2_PEF);
	177
	178	writeb(tmp, rtc->regbase + RCR2);
	179
	180	spin_unlock_irq(&rtc->lock);
	181	}
	182
	183	static inline void sh_rtc_setaie(struct device *dev, unsigned int enable)
	184	{
	185	struct sh_rtc *rtc = dev_get_drvdata(dev);
	186	unsigned int tmp;
	187
	188	spin_lock_irq(&rtc->lock);
	189
	190	tmp = readb(rtc->regbase + RCR1);
	191
1b73e6ae	192	if (!enable) {
317a6104	193	tmp &= ~RCR1_AIE;
1b73e6ae JL	194	rtc->rearm_aie = 0;
	195	} else if (rtc->rearm_aie == 0)
	196	tmp \|= RCR1_AIE;
317a6104 PM	197
	198	writeb(tmp, rtc->regbase + RCR1);
	199
	200	spin_unlock_irq(&rtc->lock);
	201	}
	202
	203	static int sh_rtc_open(struct device *dev)
	204	{
	205	struct sh_rtc *rtc = dev_get_drvdata(dev);
	206	unsigned int tmp;
	207	int ret;
	208
	209	tmp = readb(rtc->regbase + RCR1);
	210	tmp &= ~RCR1_CF;
	211	tmp \|= RCR1_CIE;
	212	writeb(tmp, rtc->regbase + RCR1);
	213
35f3c518	214	ret = request_irq(rtc->periodic_irq, sh_rtc_periodic, IRQF_DISABLED,
317a6104 PM	215	"sh-rtc period", dev);
	216	if (unlikely(ret)) {
	217	dev_err(dev, "request period IRQ failed with %d, IRQ %d\n",
	218	ret, rtc->periodic_irq);
	219	return ret;
	220	}
	221
35f3c518	222	ret = request_irq(rtc->carry_irq, sh_rtc_interrupt, IRQF_DISABLED,
317a6104 PM	223	"sh-rtc carry", dev);
	224	if (unlikely(ret)) {
	225	dev_err(dev, "request carry IRQ failed with %d, IRQ %d\n",
	226	ret, rtc->carry_irq);
	227	free_irq(rtc->periodic_irq, dev);
	228	goto err_bad_carry;
	229	}
	230
1b73e6ae	231	ret = request_irq(rtc->alarm_irq, sh_rtc_alarm, IRQF_DISABLED,
317a6104 PM	232	"sh-rtc alarm", dev);
	233	if (unlikely(ret)) {
	234	dev_err(dev, "request alarm IRQ failed with %d, IRQ %d\n",
	235	ret, rtc->alarm_irq);
	236	goto err_bad_alarm;
	237	}
	238
	239	return 0;
	240
	241	err_bad_alarm:
	242	free_irq(rtc->carry_irq, dev);
	243	err_bad_carry:
	244	free_irq(rtc->periodic_irq, dev);
	245
	246	return ret;
	247	}
	248
	249	static void sh_rtc_release(struct device *dev)
	250	{
	251	struct sh_rtc *rtc = dev_get_drvdata(dev);
	252
	253	sh_rtc_setpie(dev, 0);
1b73e6ae	254	sh_rtc_setaie(dev, 0);
317a6104 PM	255
	256	free_irq(rtc->periodic_irq, dev);
	257	free_irq(rtc->carry_irq, dev);
	258	free_irq(rtc->alarm_irq, dev);
	259	}
	260
	261	static int sh_rtc_proc(struct device dev, struct seq_file seq)
	262	{
	263	struct sh_rtc *rtc = dev_get_drvdata(dev);
	264	unsigned int tmp;
	265
	266	tmp = readb(rtc->regbase + RCR1);
317a6104 PM	267	seq_printf(seq, "carry_IRQ\t: %s\n",
	268	(tmp & RCR1_CIE) ? "yes" : "no");
	269
	270	tmp = readb(rtc->regbase + RCR2);
	271	seq_printf(seq, "periodic_IRQ\t: %s\n",
	272	(tmp & RCR2_PEF) ? "yes" : "no");
	273
	274	return 0;
	275	}
	276
	277	static int sh_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
	278	{
	279	unsigned int ret = -ENOIOCTLCMD;
	280
	281	switch (cmd) {
	282	case RTC_PIE_OFF:
	283	case RTC_PIE_ON:
	284	sh_rtc_setpie(dev, cmd == RTC_PIE_ON);
	285	ret = 0;
	286	break;
	287	case RTC_AIE_OFF:
	288	case RTC_AIE_ON:
	289	sh_rtc_setaie(dev, cmd == RTC_AIE_ON);
	290	ret = 0;
	291	break;
	292	}
	293
	294	return ret;
	295	}
	296
	297	static int sh_rtc_read_time(struct device dev, struct rtc_time tm)
	298	{
	299	struct platform_device *pdev = to_platform_device(dev);
	300	struct sh_rtc *rtc = platform_get_drvdata(pdev);
	301	unsigned int sec128, sec2, yr, yr100, cf_bit;
	302
	303	do {
	304	unsigned int tmp;
	305
	306	spin_lock_irq(&rtc->lock);
	307
	308	tmp = readb(rtc->regbase + RCR1);
	309	tmp &= ~RCR1_CF; /* Clear CF-bit */
	310	tmp \|= RCR1_CIE;
	311	writeb(tmp, rtc->regbase + RCR1);
	312
	313	sec128 = readb(rtc->regbase + R64CNT);
	314
	315	tm->tm_sec = BCD2BIN(readb(rtc->regbase + RSECCNT));
	316	tm->tm_min = BCD2BIN(readb(rtc->regbase + RMINCNT));
	317	tm->tm_hour = BCD2BIN(readb(rtc->regbase + RHRCNT));
	318	tm->tm_wday = BCD2BIN(readb(rtc->regbase + RWKCNT));
	319	tm->tm_mday = BCD2BIN(readb(rtc->regbase + RDAYCNT));
a1614796	320	tm->tm_mon = BCD2BIN(readb(rtc->regbase + RMONCNT)) - 1;
317a6104 PM	321
	322	#if defined(CONFIG_CPU_SH4)
	323	yr = readw(rtc->regbase + RYRCNT);
	324	yr100 = BCD2BIN(yr >> 8);
	325	yr &= 0xff;
	326	#else
	327	yr = readb(rtc->regbase + RYRCNT);
	328	yr100 = BCD2BIN((yr == 0x99) ? 0x19 : 0x20);
	329	#endif
	330
	331	tm->tm_year = (yr100 * 100 + BCD2BIN(yr)) - 1900;
	332
	333	sec2 = readb(rtc->regbase + R64CNT);
	334	cf_bit = readb(rtc->regbase + RCR1) & RCR1_CF;
	335
	336	spin_unlock_irq(&rtc->lock);
	337	} while (cf_bit != 0 \|\| ((sec128 ^ sec2) & RTC_BIT_INVERTED) != 0);
	338
	339	#if RTC_BIT_INVERTED != 0
	340	if ((sec128 & RTC_BIT_INVERTED))
	341	tm->tm_sec--;
	342	#endif
	343
	344	dev_dbg(&dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
	345	"mday=%d, mon=%d, year=%d, wday=%d\n",
	346	__FUNCTION__,
	347	tm->tm_sec, tm->tm_min, tm->tm_hour,
a1614796	348	tm->tm_mday, tm->tm_mon + 1, tm->tm_year, tm->tm_wday);
317a6104 PM	349
	350	if (rtc_valid_tm(tm) < 0)
	351	dev_err(dev, "invalid date\n");
	352
	353	return 0;
	354	}
	355
	356	static int sh_rtc_set_time(struct device dev, struct rtc_time tm)
	357	{
	358	struct platform_device *pdev = to_platform_device(dev);
	359	struct sh_rtc *rtc = platform_get_drvdata(pdev);
	360	unsigned int tmp;
	361	int year;
	362
	363	spin_lock_irq(&rtc->lock);
	364
	365	/* Reset pre-scaler & stop RTC */
	366	tmp = readb(rtc->regbase + RCR2);
	367	tmp \|= RCR2_RESET;
	368	writeb(tmp, rtc->regbase + RCR2);
	369
	370	writeb(BIN2BCD(tm->tm_sec), rtc->regbase + RSECCNT);
	371	writeb(BIN2BCD(tm->tm_min), rtc->regbase + RMINCNT);
	372	writeb(BIN2BCD(tm->tm_hour), rtc->regbase + RHRCNT);
	373	writeb(BIN2BCD(tm->tm_wday), rtc->regbase + RWKCNT);
	374	writeb(BIN2BCD(tm->tm_mday), rtc->regbase + RDAYCNT);
a1614796	375	writeb(BIN2BCD(tm->tm_mon + 1), rtc->regbase + RMONCNT);
317a6104 PM	376
	377	#ifdef CONFIG_CPU_SH3
	378	year = tm->tm_year % 100;
	379	writeb(BIN2BCD(year), rtc->regbase + RYRCNT);
	380	#else
	381	year = (BIN2BCD((tm->tm_year + 1900) / 100) << 8) \|
	382	BIN2BCD(tm->tm_year % 100);
	383	writew(year, rtc->regbase + RYRCNT);
	384	#endif
	385
	386	/* Start RTC */
	387	tmp = readb(rtc->regbase + RCR2);
	388	tmp &= ~RCR2_RESET;
	389	tmp \|= RCR2_RTCEN \| RCR2_START;
	390	writeb(tmp, rtc->regbase + RCR2);
	391
	392	spin_unlock_irq(&rtc->lock);
	393
	394	return 0;
	395	}
	396
1b73e6ae JL	397	static inline int sh_rtc_read_alarm_value(struct sh_rtc *rtc, int reg_off)
	398	{
	399	unsigned int byte;
	400	int value = 0xff; /* return 0xff for ignored values */
	401
	402	byte = readb(rtc->regbase + reg_off);
	403	if (byte & AR_ENB) {
	404	byte &= ~AR_ENB; /* strip the enable bit */
	405	value = BCD2BIN(byte);
	406	}
	407
	408	return value;
	409	}
	410
	411	static int sh_rtc_read_alarm(struct device dev, struct rtc_wkalrm wkalrm)
	412	{
	413	struct platform_device *pdev = to_platform_device(dev);
	414	struct sh_rtc *rtc = platform_get_drvdata(pdev);
	415	struct rtc_time* tm = &wkalrm->time;
	416
	417	spin_lock_irq(&rtc->lock);
	418
	419	tm->tm_sec = sh_rtc_read_alarm_value(rtc, RSECAR);
	420	tm->tm_min = sh_rtc_read_alarm_value(rtc, RMINAR);
	421	tm->tm_hour = sh_rtc_read_alarm_value(rtc, RHRAR);
	422	tm->tm_wday = sh_rtc_read_alarm_value(rtc, RWKAR);
	423	tm->tm_mday = sh_rtc_read_alarm_value(rtc, RDAYAR);
	424	tm->tm_mon = sh_rtc_read_alarm_value(rtc, RMONAR);
	425	if (tm->tm_mon > 0)
	426	tm->tm_mon -= 1; /* RTC is 1-12, tm_mon is 0-11 */
	427	tm->tm_year = 0xffff;
	428
0d103e90 DB	429	wkalrm->enabled = (readb(rtc->regbase + RCR1) & RCR1_AIE) ? 1 : 0;
0d103e90 DB	430
1b73e6ae JL	431	spin_unlock_irq(&rtc->lock);
	432
	433	return 0;
	434	}
	435
	436	static inline void sh_rtc_write_alarm_value(struct sh_rtc *rtc,
	437	int value, int reg_off)
	438	{
	439	/* < 0 for a value that is ignored */
	440	if (value < 0)
	441	writeb(0, rtc->regbase + reg_off);
	442	else
	443	writeb(BIN2BCD(value) \| AR_ENB, rtc->regbase + reg_off);
	444	}
	445
	446	static int sh_rtc_check_alarm(struct rtc_time* tm)
	447	{
	448	/*
	449	* The original rtc says anything > 0xc0 is "don't care" or "match
	450	* all" - most users use 0xff but rtc-dev uses -1 for the same thing.
	451	* The original rtc doesn't support years - some things use -1 and
	452	* some 0xffff. We use -1 to make out tests easier.
	453	*/
	454	if (tm->tm_year == 0xffff)
	455	tm->tm_year = -1;
	456	if (tm->tm_mon >= 0xff)
	457	tm->tm_mon = -1;
	458	if (tm->tm_mday >= 0xff)
	459	tm->tm_mday = -1;
	460	if (tm->tm_wday >= 0xff)
	461	tm->tm_wday = -1;
	462	if (tm->tm_hour >= 0xff)
	463	tm->tm_hour = -1;
	464	if (tm->tm_min >= 0xff)
	465	tm->tm_min = -1;
	466	if (tm->tm_sec >= 0xff)
	467	tm->tm_sec = -1;
	468
	469	if (tm->tm_year > 9999 \|\|
	470	tm->tm_mon >= 12 \|\|
	471	tm->tm_mday == 0 \|\| tm->tm_mday >= 32 \|\|
	472	tm->tm_wday >= 7 \|\|
	473	tm->tm_hour >= 24 \|\|
	474	tm->tm_min >= 60 \|\|
	475	tm->tm_sec >= 60)
	476	return -EINVAL;
	477
	478	return 0;
	479	}
	480
	481	static int sh_rtc_set_alarm(struct device dev, struct rtc_wkalrm wkalrm)
	482	{
	483	struct platform_device *pdev = to_platform_device(dev);
	484	struct sh_rtc *rtc = platform_get_drvdata(pdev);
	485	unsigned int rcr1;
	486	struct rtc_time *tm = &wkalrm->time;
	487	int mon, err;
	488
	489	err = sh_rtc_check_alarm(tm);
	490	if (unlikely(err < 0))
	491	return err;
	492
	493	spin_lock_irq(&rtc->lock);
	494
495	/* disable alarm interrupt and clear flag */
496	rcr1 = readb(rtc->regbase + RCR1);
497	rcr1 &= ~RCR1_AF;
498	writeb(rcr1 & ~RCR1_AIE, rtc->regbase + RCR1);
499
500	rtc->rearm_aie = 0;
501
502	/* set alarm time */
503	sh_rtc_write_alarm_value(rtc, tm->tm_sec, RSECAR);
504	sh_rtc_write_alarm_value(rtc, tm->tm_min, RMINAR);
505	sh_rtc_write_alarm_value(rtc, tm->tm_hour, RHRAR);
506	sh_rtc_write_alarm_value(rtc, tm->tm_wday, RWKAR);
507	sh_rtc_write_alarm_value(rtc, tm->tm_mday, RDAYAR);
508	mon = tm->tm_mon;
509	if (mon >= 0)
510	mon += 1;
511	sh_rtc_write_alarm_value(rtc, mon, RMONAR);
512
513	/* Restore interrupt activation status */
514	writeb(rcr1, rtc->regbase + RCR1);
515
516	spin_unlock_irq(&rtc->lock);
517
518	return 0;
519	}
520
317a6104 PM	521	static struct rtc_class_ops sh_rtc_ops = {
	522	.open = sh_rtc_open,
	523	.release = sh_rtc_release,
	524	.ioctl = sh_rtc_ioctl,
	525	.read_time = sh_rtc_read_time,
	526	.set_time = sh_rtc_set_time,
1b73e6ae JL	527	.read_alarm = sh_rtc_read_alarm,
1b73e6ae JL	528	.set_alarm = sh_rtc_set_alarm,
317a6104 PM	529	.proc = sh_rtc_proc,
	530	};
	531
	532	static int __devinit sh_rtc_probe(struct platform_device *pdev)
	533	{
	534	struct sh_rtc *rtc;
	535	struct resource *res;
	536	int ret = -ENOENT;
	537
	538	rtc = kzalloc(sizeof(struct sh_rtc), GFP_KERNEL);
	539	if (unlikely(!rtc))
	540	return -ENOMEM;
	541
	542	spin_lock_init(&rtc->lock);
	543
	544	rtc->periodic_irq = platform_get_irq(pdev, 0);
	545	if (unlikely(rtc->periodic_irq < 0)) {
	546	dev_err(&pdev->dev, "No IRQ for period\n");
	547	goto err_badres;
	548	}
	549
	550	rtc->carry_irq = platform_get_irq(pdev, 1);
	551	if (unlikely(rtc->carry_irq < 0)) {
	552	dev_err(&pdev->dev, "No IRQ for carry\n");
	553	goto err_badres;
	554	}
	555
	556	rtc->alarm_irq = platform_get_irq(pdev, 2);
	557	if (unlikely(rtc->alarm_irq < 0)) {
	558	dev_err(&pdev->dev, "No IRQ for alarm\n");
	559	goto err_badres;
	560	}
	561
	562	res = platform_get_resource(pdev, IORESOURCE_IO, 0);
	563	if (unlikely(res == NULL)) {
	564	dev_err(&pdev->dev, "No IO resource\n");
	565	goto err_badres;
	566	}
	567
	568	rtc->regsize = res->end - res->start + 1;
	569
	570	rtc->res = request_mem_region(res->start, rtc->regsize, pdev->name);
	571	if (unlikely(!rtc->res)) {
	572	ret = -EBUSY;
	573	goto err_badres;
	574	}
	575
	576	rtc->regbase = (void __iomem *)rtc->res->start;
	577	if (unlikely(!rtc->regbase)) {
	578	ret = -EINVAL;
	579	goto err_badmap;
	580	}
	581
	582	rtc->rtc_dev = rtc_device_register("sh", &pdev->dev,
	583	&sh_rtc_ops, THIS_MODULE);
	584	if (IS_ERR(rtc)) {
	585	ret = PTR_ERR(rtc->rtc_dev);
	586	goto err_badmap;
	587	}
	588
	589	platform_set_drvdata(pdev, rtc);
	590
	591	return 0;
	592
593	err_badmap:
594	release_resource(rtc->res);
595	err_badres:
596	kfree(rtc);
597
598	return ret;
599	}
600
601	static int __devexit sh_rtc_remove(struct platform_device *pdev)
602	{
603	struct sh_rtc *rtc = platform_get_drvdata(pdev);
604
605	if (likely(rtc->rtc_dev))
606	rtc_device_unregister(rtc->rtc_dev);
607
608	sh_rtc_setpie(&pdev->dev, 0);
609	sh_rtc_setaie(&pdev->dev, 0);
610
611	release_resource(rtc->res);
612
613	platform_set_drvdata(pdev, NULL);
614
615	kfree(rtc);
616
617	return 0;
618	}
619	static struct platform_driver sh_rtc_platform_driver = {
620	.driver = {
1b73e6ae	621	.name = DRV_NAME,
317a6104 PM	622	.owner = THIS_MODULE,
	623	},
	624	.probe = sh_rtc_probe,
	625	.remove = __devexit_p(sh_rtc_remove),
	626	};
	627
	628	static int __init sh_rtc_init(void)
	629	{
	630	return platform_driver_register(&sh_rtc_platform_driver);
	631	}
	632
	633	static void __exit sh_rtc_exit(void)
	634	{
	635	platform_driver_unregister(&sh_rtc_platform_driver);
	636	}
	637
	638	module_init(sh_rtc_init);
	639	module_exit(sh_rtc_exit);
	640
	641	MODULE_DESCRIPTION("SuperH on-chip RTC driver");
1b73e6ae JL	642	MODULE_VERSION(DRV_VERSION);
1b73e6ae JL	643	MODULE_AUTHOR("Paul Mundt <lethal@linux-sh.org>, Jamie Lenehan <lenehan@twibble.org>");
317a6104	644	MODULE_LICENSE("GPL");