[linux-2.6-block.git] / drivers / rtc / rtc-spear.c

/*
 * drivers/rtc/rtc-spear.c
 *
 * Copyright (C) 2010 ST Microelectronics
 * Rajeev Kumar<rajeev-dlh.kumar@st.com>
 *
 * This file is licensed under the terms of the GNU General Public
 * License version 2. This program is licensed "as is" without any
 * warranty of any kind, whether express or implied.
 */

#include <linux/bcd.h>
#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/irq.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/rtc.h>
#include <linux/slab.h>
#include <linux/spinlock.h>

/* RTC registers */
#define TIME_REG		0x00
#define DATE_REG		0x04
#define ALARM_TIME_REG		0x08
#define ALARM_DATE_REG		0x0C
#define CTRL_REG		0x10
#define STATUS_REG		0x14

/* TIME_REG & ALARM_TIME_REG */
#define SECONDS_UNITS		(0xf<<0)	/* seconds units position */
#define SECONDS_TENS		(0x7<<4)	/* seconds tens position */
#define MINUTES_UNITS		(0xf<<8)	/* minutes units position */
#define MINUTES_TENS		(0x7<<12)	/* minutes tens position */
#define HOURS_UNITS		(0xf<<16)	/* hours units position */
#define HOURS_TENS		(0x3<<20)	/* hours tens position */

/* DATE_REG & ALARM_DATE_REG */
#define DAYS_UNITS		(0xf<<0)	/* days units position */
#define DAYS_TENS		(0x3<<4)	/* days tens position */
#define MONTHS_UNITS		(0xf<<8)	/* months units position */
#define MONTHS_TENS		(0x1<<12)	/* months tens position */
#define YEARS_UNITS		(0xf<<16)	/* years units position */
#define YEARS_TENS		(0xf<<20)	/* years tens position */
#define YEARS_HUNDREDS		(0xf<<24)	/* years hundereds position */
#define YEARS_MILLENIUMS	(0xf<<28)	/* years millenium position */

/* MASK SHIFT TIME_REG & ALARM_TIME_REG*/
#define SECOND_SHIFT		0x00		/* seconds units */
#define MINUTE_SHIFT		0x08		/* minutes units position */
#define HOUR_SHIFT		0x10		/* hours units position */
#define MDAY_SHIFT		0x00		/* Month day shift */
#define MONTH_SHIFT		0x08		/* Month shift */
#define YEAR_SHIFT		0x10		/* Year shift */

#define SECOND_MASK		0x7F
#define MIN_MASK		0x7F
#define HOUR_MASK		0x3F
#define DAY_MASK		0x3F
#define MONTH_MASK		0x7F
#define YEAR_MASK		0xFFFF

/* date reg equal to time reg, for debug only */
#define TIME_BYP		(1<<9)
#define INT_ENABLE		(1<<31)		/* interrupt enable */

/* STATUS_REG */
#define CLK_UNCONNECTED		(1<<0)
#define PEND_WR_TIME		(1<<2)
#define PEND_WR_DATE		(1<<3)
#define LOST_WR_TIME		(1<<4)
#define LOST_WR_DATE		(1<<5)
#define RTC_INT_MASK		(1<<31)
#define STATUS_BUSY		(PEND_WR_TIME | PEND_WR_DATE)
#define STATUS_FAIL		(LOST_WR_TIME | LOST_WR_DATE)

struct spear_rtc_config {
	struct rtc_device *rtc;
	struct clk *clk;
	spinlock_t lock;
	void __iomem *ioaddr;
	unsigned int irq_wake;
};

static inline void spear_rtc_clear_interrupt(struct spear_rtc_config *config)
{
	unsigned int val;
	unsigned long flags;

	spin_lock_irqsave(&config->lock, flags);
	val = readl(config->ioaddr + STATUS_REG);
	val |= RTC_INT_MASK;
	writel(val, config->ioaddr + STATUS_REG);
	spin_unlock_irqrestore(&config->lock, flags);
}

static inline void spear_rtc_enable_interrupt(struct spear_rtc_config *config)
{
	unsigned int val;

	val = readl(config->ioaddr + CTRL_REG);
	if (!(val & INT_ENABLE)) {
		spear_rtc_clear_interrupt(config);
		val |= INT_ENABLE;
		writel(val, config->ioaddr + CTRL_REG);
	}
}

static inline void spear_rtc_disable_interrupt(struct spear_rtc_config *config)
{
	unsigned int val;

	val = readl(config->ioaddr + CTRL_REG);
	if (val & INT_ENABLE) {
		val &= ~INT_ENABLE;
		writel(val, config->ioaddr + CTRL_REG);
	}
}

static inline int is_write_complete(struct spear_rtc_config *config)
{
	int ret = 0;
	unsigned long flags;

	spin_lock_irqsave(&config->lock, flags);
	if ((readl(config->ioaddr + STATUS_REG)) & STATUS_FAIL)
		ret = -EIO;
	spin_unlock_irqrestore(&config->lock, flags);

	return ret;
}

static void rtc_wait_not_busy(struct spear_rtc_config *config)
{
	int status, count = 0;
	unsigned long flags;

	/* Assuming BUSY may stay active for 80 msec) */
	for (count = 0; count < 80; count++) {
		spin_lock_irqsave(&config->lock, flags);
		status = readl(config->ioaddr + STATUS_REG);
		spin_unlock_irqrestore(&config->lock, flags);
		if ((status & STATUS_BUSY) == 0)
			break;
		/* check status busy, after each msec */
		msleep(1);
	}
}

static irqreturn_t spear_rtc_irq(int irq, void *dev_id)
{
	struct spear_rtc_config *config = dev_id;
	unsigned long flags, events = 0;
	unsigned int irq_data;

	spin_lock_irqsave(&config->lock, flags);
	irq_data = readl(config->ioaddr + STATUS_REG);
	spin_unlock_irqrestore(&config->lock, flags);

	if ((irq_data & RTC_INT_MASK)) {
		spear_rtc_clear_interrupt(config);
		events = RTC_IRQF | RTC_AF;
		rtc_update_irq(config->rtc, 1, events);
		return IRQ_HANDLED;
	} else
		return IRQ_NONE;

}

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);
	tm->tm_year = bin2bcd(tm->tm_year);

	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);
}

/*
 * spear_rtc_read_time - set the time
 * @dev: rtc device in use
 * @tm: holds date and time
 *
 * This function read time and date. On success it will return 0
 * otherwise -ve error is returned.
 */
static int spear_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
	struct spear_rtc_config *config = dev_get_drvdata(dev);
	unsigned int time, date;

	/* we don't report wday/yday/isdst ... */
	rtc_wait_not_busy(config);

	time = readl(config->ioaddr + TIME_REG);
	date = readl(config->ioaddr + DATE_REG);
	tm->tm_sec = (time >> SECOND_SHIFT) & SECOND_MASK;
	tm->tm_min = (time >> MINUTE_SHIFT) & MIN_MASK;
	tm->tm_hour = (time >> HOUR_SHIFT) & HOUR_MASK;
	tm->tm_mday = (date >> MDAY_SHIFT) & DAY_MASK;
	tm->tm_mon = (date >> MONTH_SHIFT) & MONTH_MASK;
	tm->tm_year = (date >> YEAR_SHIFT) & YEAR_MASK;

	bcd2tm(tm);
	return 0;
}

/*
 * spear_rtc_set_time - set the time
 * @dev: rtc device in use
 * @tm: holds date and time
 *
 * This function set time and date. On success it will return 0
 * otherwise -ve error is returned.
 */
static int spear_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
	struct spear_rtc_config *config = dev_get_drvdata(dev);
	unsigned int time, date, err = 0;

	if (tm2bcd(tm) < 0)
		return -EINVAL;

	rtc_wait_not_busy(config);
	time = (tm->tm_sec << SECOND_SHIFT) | (tm->tm_min << MINUTE_SHIFT) |
		(tm->tm_hour << HOUR_SHIFT);
	date = (tm->tm_mday << MDAY_SHIFT) | (tm->tm_mon << MONTH_SHIFT) |
		(tm->tm_year << YEAR_SHIFT);
	writel(time, config->ioaddr + TIME_REG);
	writel(date, config->ioaddr + DATE_REG);
	err = is_write_complete(config);
	if (err < 0)
		return err;

	return 0;
}

/*
 * spear_rtc_read_alarm - read the alarm time
 * @dev: rtc device in use
 * @alm: holds alarm date and time
 *
 * This function read alarm time and date. On success it will return 0
 * otherwise -ve error is returned.
 */
static int spear_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
{
	struct spear_rtc_config *config = dev_get_drvdata(dev);
	unsigned int time, date;

	rtc_wait_not_busy(config);

	time = readl(config->ioaddr + ALARM_TIME_REG);
	date = readl(config->ioaddr + ALARM_DATE_REG);
	alm->time.tm_sec = (time >> SECOND_SHIFT) & SECOND_MASK;
	alm->time.tm_min = (time >> MINUTE_SHIFT) & MIN_MASK;
	alm->time.tm_hour = (time >> HOUR_SHIFT) & HOUR_MASK;
	alm->time.tm_mday = (date >> MDAY_SHIFT) & DAY_MASK;
	alm->time.tm_mon = (date >> MONTH_SHIFT) & MONTH_MASK;
	alm->time.tm_year = (date >> YEAR_SHIFT) & YEAR_MASK;

	bcd2tm(&alm->time);
	alm->enabled = readl(config->ioaddr + CTRL_REG) & INT_ENABLE;

	return 0;
}

/*
 * spear_rtc_set_alarm - set the alarm time
 * @dev: rtc device in use
 * @alm: holds alarm date and time
 *
 * This function set alarm time and date. On success it will return 0
 * otherwise -ve error is returned.
 */
static int spear_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
{
	struct spear_rtc_config *config = dev_get_drvdata(dev);
	unsigned int time, date, err = 0;

	if (tm2bcd(&alm->time) < 0)
		return -EINVAL;

	rtc_wait_not_busy(config);

	time = (alm->time.tm_sec << SECOND_SHIFT) | (alm->time.tm_min <<
			MINUTE_SHIFT) |	(alm->time.tm_hour << HOUR_SHIFT);
	date = (alm->time.tm_mday << MDAY_SHIFT) | (alm->time.tm_mon <<
			MONTH_SHIFT) | (alm->time.tm_year << YEAR_SHIFT);

	writel(time, config->ioaddr + ALARM_TIME_REG);
	writel(date, config->ioaddr + ALARM_DATE_REG);
	err = is_write_complete(config);
	if (err < 0)
		return err;

	if (alm->enabled)
		spear_rtc_enable_interrupt(config);
	else
		spear_rtc_disable_interrupt(config);

	return 0;
}

static int spear_alarm_irq_enable(struct device *dev, unsigned int enabled)
{
	struct spear_rtc_config *config = dev_get_drvdata(dev);
	int ret = 0;

	spear_rtc_clear_interrupt(config);

	switch (enabled) {
	case 0:
		/* alarm off */
		spear_rtc_disable_interrupt(config);
		break;
	case 1:
		/* alarm on */
		spear_rtc_enable_interrupt(config);
		break;
	default:
		ret = -EINVAL;
		break;
	}

	return ret;
}

static struct rtc_class_ops spear_rtc_ops = {
	.read_time = spear_rtc_read_time,
	.set_time = spear_rtc_set_time,
	.read_alarm = spear_rtc_read_alarm,
	.set_alarm = spear_rtc_set_alarm,
	.alarm_irq_enable = spear_alarm_irq_enable,
};

static int __devinit spear_rtc_probe(struct platform_device *pdev)
{
	struct resource *res;
	struct spear_rtc_config *config;
	unsigned int status = 0;
	int irq;

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res) {
		dev_err(&pdev->dev, "no resource defined\n");
		return -EBUSY;
	}
	if (!request_mem_region(res->start, resource_size(res), pdev->name)) {
		dev_err(&pdev->dev, "rtc region already claimed\n");
		return -EBUSY;
	}

	config = kzalloc(sizeof(*config), GFP_KERNEL);
	if (!config) {
		dev_err(&pdev->dev, "out of memory\n");
		status = -ENOMEM;
		goto err_release_region;
	}

	config->clk = clk_get(&pdev->dev, NULL);
	if (IS_ERR(config->clk)) {
		status = PTR_ERR(config->clk);
		goto err_kfree;
	}

	status = clk_enable(config->clk);
	if (status < 0)
		goto err_clk_put;

	config->ioaddr = ioremap(res->start, resource_size(res));
	if (!config->ioaddr) {
		dev_err(&pdev->dev, "ioremap fail\n");
		status = -ENOMEM;
		goto err_disable_clock;
	}

	spin_lock_init(&config->lock);
	platform_set_drvdata(pdev, config);

	config->rtc = rtc_device_register(pdev->name, &pdev->dev,
			&spear_rtc_ops, THIS_MODULE);
	if (IS_ERR(config->rtc)) {
		dev_err(&pdev->dev, "can't register RTC device, err %ld\n",
				PTR_ERR(config->rtc));
		status = PTR_ERR(config->rtc);
		goto err_iounmap;
	}

	/* alarm irqs */
	irq = platform_get_irq(pdev, 0);
	if (irq < 0) {
		dev_err(&pdev->dev, "no update irq?\n");
		status = irq;
		goto err_clear_platdata;
	}

	status = request_irq(irq, spear_rtc_irq, 0, pdev->name, config);
	if (status) {
		dev_err(&pdev->dev, "Alarm interrupt IRQ%d already \
				claimed\n", irq);
		goto err_clear_platdata;
	}

	if (!device_can_wakeup(&pdev->dev))
		device_init_wakeup(&pdev->dev, 1);

	return 0;

err_clear_platdata:
	platform_set_drvdata(pdev, NULL);
	rtc_device_unregister(config->rtc);
err_iounmap:
	iounmap(config->ioaddr);
err_disable_clock:
	clk_disable(config->clk);
err_clk_put:
	clk_put(config->clk);
err_kfree:
	kfree(config);
err_release_region:
	release_mem_region(res->start, resource_size(res));

	return status;
}

static int __devexit spear_rtc_remove(struct platform_device *pdev)
{
	struct spear_rtc_config *config = platform_get_drvdata(pdev);
	int irq;
	struct resource *res;

	/* leave rtc running, but disable irqs */
	spear_rtc_disable_interrupt(config);
	device_init_wakeup(&pdev->dev, 0);
	irq = platform_get_irq(pdev, 0);
	if (irq)
		free_irq(irq, pdev);
	clk_disable(config->clk);
	clk_put(config->clk);
	iounmap(config->ioaddr);
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (res)
		release_mem_region(res->start, resource_size(res));
	platform_set_drvdata(pdev, NULL);
	rtc_device_unregister(config->rtc);
	kfree(config);

	return 0;
}

#ifdef CONFIG_PM

static int spear_rtc_suspend(struct platform_device *pdev, pm_message_t state)
{
	struct spear_rtc_config *config = platform_get_drvdata(pdev);
	int irq;

	irq = platform_get_irq(pdev, 0);
	if (device_may_wakeup(&pdev->dev)) {
		if (!enable_irq_wake(irq))
			config->irq_wake = 1;
	} else {
		spear_rtc_disable_interrupt(config);
		clk_disable(config->clk);
	}

	return 0;
}

static int spear_rtc_resume(struct platform_device *pdev)
{
	struct spear_rtc_config *config = platform_get_drvdata(pdev);
	int irq;

	irq = platform_get_irq(pdev, 0);

	if (device_may_wakeup(&pdev->dev)) {
		if (config->irq_wake) {
			disable_irq_wake(irq);
			config->irq_wake = 0;
		}
	} else {
		clk_enable(config->clk);
		spear_rtc_enable_interrupt(config);
	}

	return 0;
}

#else
#define spear_rtc_suspend	NULL
#define spear_rtc_resume	NULL
#endif

static void spear_rtc_shutdown(struct platform_device *pdev)
{
	struct spear_rtc_config *config = platform_get_drvdata(pdev);

	spear_rtc_disable_interrupt(config);
	clk_disable(config->clk);
}

#ifdef CONFIG_OF
static const struct of_device_id spear_rtc_id_table[] = {
	{ .compatible = "st,spear600-rtc" },
	{}
};
MODULE_DEVICE_TABLE(of, spear_rtc_id_table);
#endif

static struct platform_driver spear_rtc_driver = {
	.probe = spear_rtc_probe,
	.remove = __devexit_p(spear_rtc_remove),
	.suspend = spear_rtc_suspend,
	.resume = spear_rtc_resume,
	.shutdown = spear_rtc_shutdown,
	.driver = {
		.name = "rtc-spear",
		.of_match_table = of_match_ptr(spear_rtc_id_table),
	},
};

module_platform_driver(spear_rtc_driver);

MODULE_ALIAS("platform:rtc-spear");
MODULE_AUTHOR("Rajeev Kumar <rajeev-dlh.kumar@st.com>");
MODULE_DESCRIPTION("ST SPEAr Realtime Clock Driver (RTC)");
MODULE_LICENSE("GPL");
Commit	Line	Data
0942a71e RK	1	/*
	2	* drivers/rtc/rtc-spear.c
	3	*
	4	* Copyright (C) 2010 ST Microelectronics
	5	* Rajeev Kumar<rajeev-dlh.kumar@st.com>
	6	*
	7	* This file is licensed under the terms of the GNU General Public
	8	* License version 2. This program is licensed "as is" without any
	9	* warranty of any kind, whether express or implied.
	10	*/
	11
	12	#include <linux/bcd.h>
	13	#include <linux/clk.h>
	14	#include <linux/delay.h>
	15	#include <linux/init.h>
	16	#include <linux/io.h>
	17	#include <linux/irq.h>
	18	#include <linux/module.h>
0108c4ff	19	#include <linux/of.h>
0942a71e RK	20	#include <linux/platform_device.h>
	21	#include <linux/rtc.h>
	22	#include <linux/slab.h>
	23	#include <linux/spinlock.h>
	24
	25	/* RTC registers */
	26	#define TIME_REG 0x00
	27	#define DATE_REG 0x04
	28	#define ALARM_TIME_REG 0x08
	29	#define ALARM_DATE_REG 0x0C
	30	#define CTRL_REG 0x10
	31	#define STATUS_REG 0x14
	32
	33	/* TIME_REG & ALARM_TIME_REG */
	34	#define SECONDS_UNITS (0xf<<0) /* seconds units position */
	35	#define SECONDS_TENS (0x7<<4) /* seconds tens position */
	36	#define MINUTES_UNITS (0xf<<8) /* minutes units position */
	37	#define MINUTES_TENS (0x7<<12) /* minutes tens position */
	38	#define HOURS_UNITS (0xf<<16) /* hours units position */
	39	#define HOURS_TENS (0x3<<20) /* hours tens position */
	40
	41	/* DATE_REG & ALARM_DATE_REG */
	42	#define DAYS_UNITS (0xf<<0) /* days units position */
	43	#define DAYS_TENS (0x3<<4) /* days tens position */
	44	#define MONTHS_UNITS (0xf<<8) /* months units position */
	45	#define MONTHS_TENS (0x1<<12) /* months tens position */
	46	#define YEARS_UNITS (0xf<<16) /* years units position */
	47	#define YEARS_TENS (0xf<<20) /* years tens position */
	48	#define YEARS_HUNDREDS (0xf<<24) /* years hundereds position */
	49	#define YEARS_MILLENIUMS (0xf<<28) /* years millenium position */
	50
	51	/* MASK SHIFT TIME_REG & ALARM_TIME_REG*/
	52	#define SECOND_SHIFT 0x00 /* seconds units */
	53	#define MINUTE_SHIFT 0x08 /* minutes units position */
	54	#define HOUR_SHIFT 0x10 /* hours units position */
	55	#define MDAY_SHIFT 0x00 /* Month day shift */
	56	#define MONTH_SHIFT 0x08 /* Month shift */
	57	#define YEAR_SHIFT 0x10 /* Year shift */
	58
	59	#define SECOND_MASK 0x7F
	60	#define MIN_MASK 0x7F
	61	#define HOUR_MASK 0x3F
	62	#define DAY_MASK 0x3F
	63	#define MONTH_MASK 0x7F
	64	#define YEAR_MASK 0xFFFF
	65
	66	/* date reg equal to time reg, for debug only */
	67	#define TIME_BYP (1<<9)
	68	#define INT_ENABLE (1<<31) /* interrupt enable */
	69
	70	/* STATUS_REG */
	71	#define CLK_UNCONNECTED (1<<0)
	72	#define PEND_WR_TIME (1<<2)
	73	#define PEND_WR_DATE (1<<3)
	74	#define LOST_WR_TIME (1<<4)
	75	#define LOST_WR_DATE (1<<5)
	76	#define RTC_INT_MASK (1<<31)
	77	#define STATUS_BUSY (PEND_WR_TIME \| PEND_WR_DATE)
	78	#define STATUS_FAIL (LOST_WR_TIME \| LOST_WR_DATE)
	79
	80	struct spear_rtc_config {
ee6c54ca	81	struct rtc_device *rtc;
0942a71e RK	82	struct clk *clk;
	83	spinlock_t lock;
	84	void __iomem *ioaddr;
cd0e08a8	85	unsigned int irq_wake;
0942a71e RK	86	};
	87
	88	static inline void spear_rtc_clear_interrupt(struct spear_rtc_config *config)
	89	{
	90	unsigned int val;
	91	unsigned long flags;
	92
	93	spin_lock_irqsave(&config->lock, flags);
	94	val = readl(config->ioaddr + STATUS_REG);
	95	val \|= RTC_INT_MASK;
	96	writel(val, config->ioaddr + STATUS_REG);
	97	spin_unlock_irqrestore(&config->lock, flags);
	98	}
	99
	100	static inline void spear_rtc_enable_interrupt(struct spear_rtc_config *config)
	101	{
	102	unsigned int val;
	103
	104	val = readl(config->ioaddr + CTRL_REG);
	105	if (!(val & INT_ENABLE)) {
	106	spear_rtc_clear_interrupt(config);
	107	val \|= INT_ENABLE;
	108	writel(val, config->ioaddr + CTRL_REG);
	109	}
	110	}
	111
	112	static inline void spear_rtc_disable_interrupt(struct spear_rtc_config *config)
	113	{
	114	unsigned int val;
	115
	116	val = readl(config->ioaddr + CTRL_REG);
	117	if (val & INT_ENABLE) {
	118	val &= ~INT_ENABLE;
	119	writel(val, config->ioaddr + CTRL_REG);
	120	}
	121	}
	122
	123	static inline int is_write_complete(struct spear_rtc_config *config)
	124	{
	125	int ret = 0;
	126	unsigned long flags;
	127
	128	spin_lock_irqsave(&config->lock, flags);
	129	if ((readl(config->ioaddr + STATUS_REG)) & STATUS_FAIL)
	130	ret = -EIO;
	131	spin_unlock_irqrestore(&config->lock, flags);
	132
	133	return ret;
	134	}
	135
	136	static void rtc_wait_not_busy(struct spear_rtc_config *config)
	137	{
	138	int status, count = 0;
	139	unsigned long flags;
	140
	141	/* Assuming BUSY may stay active for 80 msec) */
	142	for (count = 0; count < 80; count++) {
	143	spin_lock_irqsave(&config->lock, flags);
	144	status = readl(config->ioaddr + STATUS_REG);
	145	spin_unlock_irqrestore(&config->lock, flags);
	146	if ((status & STATUS_BUSY) == 0)
	147	break;
	148	/* check status busy, after each msec */
	149	msleep(1);
150	}
151	}
152
153	static irqreturn_t spear_rtc_irq(int irq, void *dev_id)
154	{
ee6c54ca	155	struct spear_rtc_config *config = dev_id;
0942a71e RK	156	unsigned long flags, events = 0;
	157	unsigned int irq_data;
	158
	159	spin_lock_irqsave(&config->lock, flags);
	160	irq_data = readl(config->ioaddr + STATUS_REG);
	161	spin_unlock_irqrestore(&config->lock, flags);
	162
	163	if ((irq_data & RTC_INT_MASK)) {
	164	spear_rtc_clear_interrupt(config);
	165	events = RTC_IRQF \| RTC_AF;
ee6c54ca	166	rtc_update_irq(config->rtc, 1, events);
0942a71e RK	167	return IRQ_HANDLED;
	168	} else
	169	return IRQ_NONE;
	170
	171	}
	172
	173	static int tm2bcd(struct rtc_time *tm)
	174	{
	175	if (rtc_valid_tm(tm) != 0)
	176	return -EINVAL;
	177	tm->tm_sec = bin2bcd(tm->tm_sec);
	178	tm->tm_min = bin2bcd(tm->tm_min);
	179	tm->tm_hour = bin2bcd(tm->tm_hour);
	180	tm->tm_mday = bin2bcd(tm->tm_mday);
	181	tm->tm_mon = bin2bcd(tm->tm_mon + 1);
	182	tm->tm_year = bin2bcd(tm->tm_year);
	183
	184	return 0;
	185	}
	186
	187	static void bcd2tm(struct rtc_time *tm)
	188	{
	189	tm->tm_sec = bcd2bin(tm->tm_sec);
	190	tm->tm_min = bcd2bin(tm->tm_min);
	191	tm->tm_hour = bcd2bin(tm->tm_hour);
	192	tm->tm_mday = bcd2bin(tm->tm_mday);
	193	tm->tm_mon = bcd2bin(tm->tm_mon) - 1;
	194	/* epoch == 1900 */
	195	tm->tm_year = bcd2bin(tm->tm_year);
	196	}
	197
	198	/*
	199	* spear_rtc_read_time - set the time
	200	* @dev: rtc device in use
	201	* @tm: holds date and time
	202	*
	203	* This function read time and date. On success it will return 0
	204	* otherwise -ve error is returned.
	205	*/
	206	static int spear_rtc_read_time(struct device dev, struct rtc_time tm)
	207	{
ee6c54ca	208	struct spear_rtc_config *config = dev_get_drvdata(dev);
0942a71e RK	209	unsigned int time, date;
	210
	211	/* we don't report wday/yday/isdst ... */
	212	rtc_wait_not_busy(config);
	213
	214	time = readl(config->ioaddr + TIME_REG);
	215	date = readl(config->ioaddr + DATE_REG);
	216	tm->tm_sec = (time >> SECOND_SHIFT) & SECOND_MASK;
	217	tm->tm_min = (time >> MINUTE_SHIFT) & MIN_MASK;
	218	tm->tm_hour = (time >> HOUR_SHIFT) & HOUR_MASK;
	219	tm->tm_mday = (date >> MDAY_SHIFT) & DAY_MASK;
	220	tm->tm_mon = (date >> MONTH_SHIFT) & MONTH_MASK;
	221	tm->tm_year = (date >> YEAR_SHIFT) & YEAR_MASK;
	222
	223	bcd2tm(tm);
	224	return 0;
	225	}
	226
	227	/*
	228	* spear_rtc_set_time - set the time
	229	* @dev: rtc device in use
	230	* @tm: holds date and time
	231	*
	232	* This function set time and date. On success it will return 0
	233	* otherwise -ve error is returned.
	234	*/
	235	static int spear_rtc_set_time(struct device dev, struct rtc_time tm)
	236	{
ee6c54ca	237	struct spear_rtc_config *config = dev_get_drvdata(dev);
0942a71e RK	238	unsigned int time, date, err = 0;
	239
	240	if (tm2bcd(tm) < 0)
	241	return -EINVAL;
	242
	243	rtc_wait_not_busy(config);
	244	time = (tm->tm_sec << SECOND_SHIFT) \| (tm->tm_min << MINUTE_SHIFT) \|
	245	(tm->tm_hour << HOUR_SHIFT);
	246	date = (tm->tm_mday << MDAY_SHIFT) \| (tm->tm_mon << MONTH_SHIFT) \|
	247	(tm->tm_year << YEAR_SHIFT);
	248	writel(time, config->ioaddr + TIME_REG);
	249	writel(date, config->ioaddr + DATE_REG);
	250	err = is_write_complete(config);
	251	if (err < 0)
	252	return err;
	253
	254	return 0;
	255	}
	256
	257	/*
	258	* spear_rtc_read_alarm - read the alarm time
	259	* @dev: rtc device in use
	260	* @alm: holds alarm date and time
	261	*
	262	* This function read alarm time and date. On success it will return 0
	263	* otherwise -ve error is returned.
	264	*/
	265	static int spear_rtc_read_alarm(struct device dev, struct rtc_wkalrm alm)
	266	{
ee6c54ca	267	struct spear_rtc_config *config = dev_get_drvdata(dev);
0942a71e RK	268	unsigned int time, date;
	269
	270	rtc_wait_not_busy(config);
	271
	272	time = readl(config->ioaddr + ALARM_TIME_REG);
	273	date = readl(config->ioaddr + ALARM_DATE_REG);
	274	alm->time.tm_sec = (time >> SECOND_SHIFT) & SECOND_MASK;
	275	alm->time.tm_min = (time >> MINUTE_SHIFT) & MIN_MASK;
	276	alm->time.tm_hour = (time >> HOUR_SHIFT) & HOUR_MASK;
	277	alm->time.tm_mday = (date >> MDAY_SHIFT) & DAY_MASK;
	278	alm->time.tm_mon = (date >> MONTH_SHIFT) & MONTH_MASK;
	279	alm->time.tm_year = (date >> YEAR_SHIFT) & YEAR_MASK;
	280
	281	bcd2tm(&alm->time);
	282	alm->enabled = readl(config->ioaddr + CTRL_REG) & INT_ENABLE;
	283
	284	return 0;
	285	}
	286
	287	/*
	288	* spear_rtc_set_alarm - set the alarm time
	289	* @dev: rtc device in use
	290	* @alm: holds alarm date and time
	291	*
	292	* This function set alarm time and date. On success it will return 0
	293	* otherwise -ve error is returned.
	294	*/
	295	static int spear_rtc_set_alarm(struct device dev, struct rtc_wkalrm alm)
	296	{
ee6c54ca	297	struct spear_rtc_config *config = dev_get_drvdata(dev);
0942a71e RK	298	unsigned int time, date, err = 0;
	299
	300	if (tm2bcd(&alm->time) < 0)
	301	return -EINVAL;
	302
	303	rtc_wait_not_busy(config);
	304
	305	time = (alm->time.tm_sec << SECOND_SHIFT) \| (alm->time.tm_min <<
	306	MINUTE_SHIFT) \| (alm->time.tm_hour << HOUR_SHIFT);
	307	date = (alm->time.tm_mday << MDAY_SHIFT) \| (alm->time.tm_mon <<
	308	MONTH_SHIFT) \| (alm->time.tm_year << YEAR_SHIFT);
	309
	310	writel(time, config->ioaddr + ALARM_TIME_REG);
	311	writel(date, config->ioaddr + ALARM_DATE_REG);
	312	err = is_write_complete(config);
	313	if (err < 0)
	314	return err;
	315
	316	if (alm->enabled)
	317	spear_rtc_enable_interrupt(config);
	318	else
	319	spear_rtc_disable_interrupt(config);
	320
	321	return 0;
	322	}
131f8b75 SH	323
	324	static int spear_alarm_irq_enable(struct device *dev, unsigned int enabled)
	325	{
ee6c54ca	326	struct spear_rtc_config *config = dev_get_drvdata(dev);
131f8b75 SH	327	int ret = 0;
	328
	329	spear_rtc_clear_interrupt(config);
	330
	331	switch (enabled) {
	332	case 0:
	333	/* alarm off */
	334	spear_rtc_disable_interrupt(config);
	335	break;
	336	case 1:
	337	/* alarm on */
	338	spear_rtc_enable_interrupt(config);
	339	break;
	340	default:
	341	ret = -EINVAL;
	342	break;
	343	}
	344
	345	return ret;
	346	}
	347
0942a71e RK	348	static struct rtc_class_ops spear_rtc_ops = {
	349	.read_time = spear_rtc_read_time,
	350	.set_time = spear_rtc_set_time,
	351	.read_alarm = spear_rtc_read_alarm,
	352	.set_alarm = spear_rtc_set_alarm,
131f8b75	353	.alarm_irq_enable = spear_alarm_irq_enable,
0942a71e RK	354	};
	355
	356	static int __devinit spear_rtc_probe(struct platform_device *pdev)
	357	{
	358	struct resource *res;
0942a71e RK	359	struct spear_rtc_config *config;
	360	unsigned int status = 0;
	361	int irq;
	362
	363	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	364	if (!res) {
	365	dev_err(&pdev->dev, "no resource defined\n");
	366	return -EBUSY;
	367	}
	368	if (!request_mem_region(res->start, resource_size(res), pdev->name)) {
	369	dev_err(&pdev->dev, "rtc region already claimed\n");
	370	return -EBUSY;
	371	}
	372
	373	config = kzalloc(sizeof(*config), GFP_KERNEL);
	374	if (!config) {
	375	dev_err(&pdev->dev, "out of memory\n");
	376	status = -ENOMEM;
	377	goto err_release_region;
	378	}
	379
	380	config->clk = clk_get(&pdev->dev, NULL);
	381	if (IS_ERR(config->clk)) {
	382	status = PTR_ERR(config->clk);
	383	goto err_kfree;
	384	}
	385
	386	status = clk_enable(config->clk);
	387	if (status < 0)
	388	goto err_clk_put;
	389
	390	config->ioaddr = ioremap(res->start, resource_size(res));
	391	if (!config->ioaddr) {
	392	dev_err(&pdev->dev, "ioremap fail\n");
	393	status = -ENOMEM;
	394	goto err_disable_clock;
	395	}
	396
	397	spin_lock_init(&config->lock);
ee6c54ca	398	platform_set_drvdata(pdev, config);
0942a71e	399
ee6c54ca VK	400	config->rtc = rtc_device_register(pdev->name, &pdev->dev,
	401	&spear_rtc_ops, THIS_MODULE);
	402	if (IS_ERR(config->rtc)) {
0942a71e	403	dev_err(&pdev->dev, "can't register RTC device, err %ld\n",
ee6c54ca VK	404	PTR_ERR(config->rtc));
ee6c54ca VK	405	status = PTR_ERR(config->rtc);
0942a71e RK	406	goto err_iounmap;
	407	}
	408
0942a71e RK	409	/* alarm irqs */
	410	irq = platform_get_irq(pdev, 0);
	411	if (irq < 0) {
	412	dev_err(&pdev->dev, "no update irq?\n");
	413	status = irq;
	414	goto err_clear_platdata;
	415	}
	416
ee6c54ca	417	status = request_irq(irq, spear_rtc_irq, 0, pdev->name, config);
0942a71e RK	418	if (status) {
	419	dev_err(&pdev->dev, "Alarm interrupt IRQ%d already \
	420	claimed\n", irq);
	421	goto err_clear_platdata;
	422	}
	423
	424	if (!device_can_wakeup(&pdev->dev))
	425	device_init_wakeup(&pdev->dev, 1);
	426
	427	return 0;
	428
	429	err_clear_platdata:
	430	platform_set_drvdata(pdev, NULL);
ee6c54ca	431	rtc_device_unregister(config->rtc);
0942a71e RK	432	err_iounmap:
	433	iounmap(config->ioaddr);
	434	err_disable_clock:
	435	clk_disable(config->clk);
	436	err_clk_put:
	437	clk_put(config->clk);
	438	err_kfree:
	439	kfree(config);
	440	err_release_region:
	441	release_mem_region(res->start, resource_size(res));
	442
	443	return status;
	444	}
	445
	446	static int __devexit spear_rtc_remove(struct platform_device *pdev)
	447	{
ee6c54ca	448	struct spear_rtc_config *config = platform_get_drvdata(pdev);
0942a71e RK	449	int irq;
	450	struct resource *res;
	451
	452	/* leave rtc running, but disable irqs */
	453	spear_rtc_disable_interrupt(config);
	454	device_init_wakeup(&pdev->dev, 0);
	455	irq = platform_get_irq(pdev, 0);
	456	if (irq)
	457	free_irq(irq, pdev);
	458	clk_disable(config->clk);
	459	clk_put(config->clk);
	460	iounmap(config->ioaddr);
0942a71e RK	461	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	462	if (res)
	463	release_mem_region(res->start, resource_size(res));
	464	platform_set_drvdata(pdev, NULL);
ee6c54ca	465	rtc_device_unregister(config->rtc);
2a643893	466	kfree(config);
0942a71e RK	467
	468	return 0;
	469	}
	470
	471	#ifdef CONFIG_PM
	472
	473	static int spear_rtc_suspend(struct platform_device *pdev, pm_message_t state)
	474	{
ee6c54ca	475	struct spear_rtc_config *config = platform_get_drvdata(pdev);
0942a71e RK	476	int irq;
	477
	478	irq = platform_get_irq(pdev, 0);
cd0e08a8 DS	479	if (device_may_wakeup(&pdev->dev)) {
	480	if (!enable_irq_wake(irq))
	481	config->irq_wake = 1;
	482	} else {
0942a71e RK	483	spear_rtc_disable_interrupt(config);
	484	clk_disable(config->clk);
	485	}
	486
	487	return 0;
	488	}
	489
	490	static int spear_rtc_resume(struct platform_device *pdev)
	491	{
ee6c54ca	492	struct spear_rtc_config *config = platform_get_drvdata(pdev);
0942a71e RK	493	int irq;
	494
	495	irq = platform_get_irq(pdev, 0);
	496
cd0e08a8 DS	497	if (device_may_wakeup(&pdev->dev)) {
	498	if (config->irq_wake) {
	499	disable_irq_wake(irq);
	500	config->irq_wake = 0;
	501	}
	502	} else {
0942a71e RK	503	clk_enable(config->clk);
	504	spear_rtc_enable_interrupt(config);
	505	}
	506
	507	return 0;
	508	}
	509
	510	#else
	511	#define spear_rtc_suspend NULL
	512	#define spear_rtc_resume NULL
	513	#endif
	514
	515	static void spear_rtc_shutdown(struct platform_device *pdev)
	516	{
ee6c54ca	517	struct spear_rtc_config *config = platform_get_drvdata(pdev);
0942a71e RK	518
	519	spear_rtc_disable_interrupt(config);
	520	clk_disable(config->clk);
	521	}
	522
0108c4ff VK	523	#ifdef CONFIG_OF
	524	static const struct of_device_id spear_rtc_id_table[] = {
	525	{ .compatible = "st,spear600-rtc" },
	526	{}
	527	};
	528	MODULE_DEVICE_TABLE(of, spear_rtc_id_table);
	529	#endif
	530
0942a71e RK	531	static struct platform_driver spear_rtc_driver = {
	532	.probe = spear_rtc_probe,
	533	.remove = __devexit_p(spear_rtc_remove),
	534	.suspend = spear_rtc_suspend,
	535	.resume = spear_rtc_resume,
	536	.shutdown = spear_rtc_shutdown,
	537	.driver = {
	538	.name = "rtc-spear",
0108c4ff	539	.of_match_table = of_match_ptr(spear_rtc_id_table),
0942a71e RK	540	},
	541	};
	542
0c4eae66	543	module_platform_driver(spear_rtc_driver);
0942a71e RK	544
	545	MODULE_ALIAS("platform:rtc-spear");
	546	MODULE_AUTHOR("Rajeev Kumar <rajeev-dlh.kumar@st.com>");
	547	MODULE_DESCRIPTION("ST SPEAr Realtime Clock Driver (RTC)");
	548	MODULE_LICENSE("GPL");