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

/*
 * drivers/rtc/rtc-spear.c
 *
 * Copyright (C) 2010 ST Microelectronics
 * Rajeev Kumar<[email protected]>
 *
 * 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;

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

	return is_write_complete(config);
}

/*
 * 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;
	int err;

	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;
	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 <[email protected]>");
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<[email protected]>
	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);
a16e8393	238	unsigned int time, date;
0942a71e RK	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);
0942a71e	250
a16e8393	251	return is_write_complete(config);
0942a71e RK	252	}
	253
	254	/*
	255	* spear_rtc_read_alarm - read the alarm time
	256	* @dev: rtc device in use
	257	* @alm: holds alarm date and time
	258	*
	259	* This function read alarm time and date. On success it will return 0
	260	* otherwise -ve error is returned.
	261	*/
	262	static int spear_rtc_read_alarm(struct device dev, struct rtc_wkalrm alm)
	263	{
ee6c54ca	264	struct spear_rtc_config *config = dev_get_drvdata(dev);
0942a71e RK	265	unsigned int time, date;
	266
	267	rtc_wait_not_busy(config);
	268
	269	time = readl(config->ioaddr + ALARM_TIME_REG);
	270	date = readl(config->ioaddr + ALARM_DATE_REG);
	271	alm->time.tm_sec = (time >> SECOND_SHIFT) & SECOND_MASK;
	272	alm->time.tm_min = (time >> MINUTE_SHIFT) & MIN_MASK;
	273	alm->time.tm_hour = (time >> HOUR_SHIFT) & HOUR_MASK;
	274	alm->time.tm_mday = (date >> MDAY_SHIFT) & DAY_MASK;
	275	alm->time.tm_mon = (date >> MONTH_SHIFT) & MONTH_MASK;
	276	alm->time.tm_year = (date >> YEAR_SHIFT) & YEAR_MASK;
	277
	278	bcd2tm(&alm->time);
	279	alm->enabled = readl(config->ioaddr + CTRL_REG) & INT_ENABLE;
	280
	281	return 0;
	282	}
	283
	284	/*
	285	* spear_rtc_set_alarm - set the alarm time
	286	* @dev: rtc device in use
	287	* @alm: holds alarm date and time
	288	*
	289	* This function set alarm time and date. On success it will return 0
	290	* otherwise -ve error is returned.
	291	*/
	292	static int spear_rtc_set_alarm(struct device dev, struct rtc_wkalrm alm)
	293	{
ee6c54ca	294	struct spear_rtc_config *config = dev_get_drvdata(dev);
a16e8393 LPC	295	unsigned int time, date;
a16e8393 LPC	296	int err;
0942a71e RK	297
	298	if (tm2bcd(&alm->time) < 0)
	299	return -EINVAL;
	300
	301	rtc_wait_not_busy(config);
	302
	303	time = (alm->time.tm_sec << SECOND_SHIFT) \| (alm->time.tm_min <<
	304	MINUTE_SHIFT) \| (alm->time.tm_hour << HOUR_SHIFT);
	305	date = (alm->time.tm_mday << MDAY_SHIFT) \| (alm->time.tm_mon <<
	306	MONTH_SHIFT) \| (alm->time.tm_year << YEAR_SHIFT);
	307
	308	writel(time, config->ioaddr + ALARM_TIME_REG);
	309	writel(date, config->ioaddr + ALARM_DATE_REG);
	310	err = is_write_complete(config);
	311	if (err < 0)
	312	return err;
	313
	314	if (alm->enabled)
	315	spear_rtc_enable_interrupt(config);
	316	else
	317	spear_rtc_disable_interrupt(config);
	318
	319	return 0;
	320	}
131f8b75 SH	321
	322	static int spear_alarm_irq_enable(struct device *dev, unsigned int enabled)
	323	{
ee6c54ca	324	struct spear_rtc_config *config = dev_get_drvdata(dev);
131f8b75 SH	325	int ret = 0;
	326
	327	spear_rtc_clear_interrupt(config);
	328
	329	switch (enabled) {
	330	case 0:
	331	/* alarm off */
	332	spear_rtc_disable_interrupt(config);
	333	break;
	334	case 1:
	335	/* alarm on */
	336	spear_rtc_enable_interrupt(config);
	337	break;
	338	default:
	339	ret = -EINVAL;
	340	break;
	341	}
	342
	343	return ret;
	344	}
	345
0942a71e RK	346	static struct rtc_class_ops spear_rtc_ops = {
	347	.read_time = spear_rtc_read_time,
	348	.set_time = spear_rtc_set_time,
	349	.read_alarm = spear_rtc_read_alarm,
	350	.set_alarm = spear_rtc_set_alarm,
131f8b75	351	.alarm_irq_enable = spear_alarm_irq_enable,
0942a71e RK	352	};
	353
	354	static int __devinit spear_rtc_probe(struct platform_device *pdev)
	355	{
	356	struct resource *res;
0942a71e	357	struct spear_rtc_config *config;
a16e8393	358	int status = 0;
0942a71e RK	359	int irq;
	360
	361	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	362	if (!res) {
	363	dev_err(&pdev->dev, "no resource defined\n");
	364	return -EBUSY;
	365	}
	366	if (!request_mem_region(res->start, resource_size(res), pdev->name)) {
	367	dev_err(&pdev->dev, "rtc region already claimed\n");
	368	return -EBUSY;
	369	}
	370
	371	config = kzalloc(sizeof(*config), GFP_KERNEL);
	372	if (!config) {
	373	dev_err(&pdev->dev, "out of memory\n");
	374	status = -ENOMEM;
	375	goto err_release_region;
	376	}
	377
	378	config->clk = clk_get(&pdev->dev, NULL);
	379	if (IS_ERR(config->clk)) {
	380	status = PTR_ERR(config->clk);
	381	goto err_kfree;
	382	}
	383
	384	status = clk_enable(config->clk);
	385	if (status < 0)
	386	goto err_clk_put;
	387
	388	config->ioaddr = ioremap(res->start, resource_size(res));
	389	if (!config->ioaddr) {
	390	dev_err(&pdev->dev, "ioremap fail\n");
	391	status = -ENOMEM;
	392	goto err_disable_clock;
	393	}
	394
	395	spin_lock_init(&config->lock);
ee6c54ca	396	platform_set_drvdata(pdev, config);
0942a71e	397
ee6c54ca VK	398	config->rtc = rtc_device_register(pdev->name, &pdev->dev,
	399	&spear_rtc_ops, THIS_MODULE);
	400	if (IS_ERR(config->rtc)) {
0942a71e	401	dev_err(&pdev->dev, "can't register RTC device, err %ld\n",
ee6c54ca VK	402	PTR_ERR(config->rtc));
ee6c54ca VK	403	status = PTR_ERR(config->rtc);
0942a71e RK	404	goto err_iounmap;
	405	}
	406
0942a71e RK	407	/* alarm irqs */
	408	irq = platform_get_irq(pdev, 0);
	409	if (irq < 0) {
	410	dev_err(&pdev->dev, "no update irq?\n");
	411	status = irq;
	412	goto err_clear_platdata;
	413	}
	414
ee6c54ca	415	status = request_irq(irq, spear_rtc_irq, 0, pdev->name, config);
0942a71e RK	416	if (status) {
	417	dev_err(&pdev->dev, "Alarm interrupt IRQ%d already \
	418	claimed\n", irq);
	419	goto err_clear_platdata;
	420	}
	421
	422	if (!device_can_wakeup(&pdev->dev))
	423	device_init_wakeup(&pdev->dev, 1);
	424
	425	return 0;
	426
	427	err_clear_platdata:
	428	platform_set_drvdata(pdev, NULL);
ee6c54ca	429	rtc_device_unregister(config->rtc);
0942a71e RK	430	err_iounmap:
	431	iounmap(config->ioaddr);
	432	err_disable_clock:
	433	clk_disable(config->clk);
	434	err_clk_put:
	435	clk_put(config->clk);
	436	err_kfree:
	437	kfree(config);
	438	err_release_region:
	439	release_mem_region(res->start, resource_size(res));
	440
	441	return status;
	442	}
	443
	444	static int __devexit spear_rtc_remove(struct platform_device *pdev)
	445	{
ee6c54ca	446	struct spear_rtc_config *config = platform_get_drvdata(pdev);
0942a71e RK	447	int irq;
	448	struct resource *res;
	449
	450	/* leave rtc running, but disable irqs */
	451	spear_rtc_disable_interrupt(config);
	452	device_init_wakeup(&pdev->dev, 0);
	453	irq = platform_get_irq(pdev, 0);
	454	if (irq)
	455	free_irq(irq, pdev);
	456	clk_disable(config->clk);
	457	clk_put(config->clk);
	458	iounmap(config->ioaddr);
0942a71e RK	459	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	460	if (res)
	461	release_mem_region(res->start, resource_size(res));
	462	platform_set_drvdata(pdev, NULL);
ee6c54ca	463	rtc_device_unregister(config->rtc);
2a643893	464	kfree(config);
0942a71e RK	465
	466	return 0;
	467	}
	468
	469	#ifdef CONFIG_PM
	470
	471	static int spear_rtc_suspend(struct platform_device *pdev, pm_message_t state)
	472	{
ee6c54ca	473	struct spear_rtc_config *config = platform_get_drvdata(pdev);
0942a71e RK	474	int irq;
	475
	476	irq = platform_get_irq(pdev, 0);
cd0e08a8 DS	477	if (device_may_wakeup(&pdev->dev)) {
	478	if (!enable_irq_wake(irq))
	479	config->irq_wake = 1;
	480	} else {
0942a71e RK	481	spear_rtc_disable_interrupt(config);
	482	clk_disable(config->clk);
	483	}
	484
	485	return 0;
	486	}
	487
	488	static int spear_rtc_resume(struct platform_device *pdev)
	489	{
ee6c54ca	490	struct spear_rtc_config *config = platform_get_drvdata(pdev);
0942a71e RK	491	int irq;
	492
	493	irq = platform_get_irq(pdev, 0);
	494
cd0e08a8 DS	495	if (device_may_wakeup(&pdev->dev)) {
	496	if (config->irq_wake) {
	497	disable_irq_wake(irq);
	498	config->irq_wake = 0;
	499	}
	500	} else {
0942a71e RK	501	clk_enable(config->clk);
	502	spear_rtc_enable_interrupt(config);
	503	}
	504
	505	return 0;
	506	}
	507
	508	#else
	509	#define spear_rtc_suspend NULL
	510	#define spear_rtc_resume NULL
	511	#endif
	512
	513	static void spear_rtc_shutdown(struct platform_device *pdev)
	514	{
ee6c54ca	515	struct spear_rtc_config *config = platform_get_drvdata(pdev);
0942a71e RK	516
	517	spear_rtc_disable_interrupt(config);
	518	clk_disable(config->clk);
	519	}
	520
0108c4ff VK	521	#ifdef CONFIG_OF
	522	static const struct of_device_id spear_rtc_id_table[] = {
	523	{ .compatible = "st,spear600-rtc" },
	524	{}
	525	};
	526	MODULE_DEVICE_TABLE(of, spear_rtc_id_table);
	527	#endif
	528
0942a71e RK	529	static struct platform_driver spear_rtc_driver = {
	530	.probe = spear_rtc_probe,
	531	.remove = __devexit_p(spear_rtc_remove),
	532	.suspend = spear_rtc_suspend,
	533	.resume = spear_rtc_resume,
	534	.shutdown = spear_rtc_shutdown,
	535	.driver = {
	536	.name = "rtc-spear",
0108c4ff	537	.of_match_table = of_match_ptr(spear_rtc_id_table),
0942a71e RK	538	},
	539	};
	540
0c4eae66	541	module_platform_driver(spear_rtc_driver);
0942a71e RK	542
	543	MODULE_ALIAS("platform:rtc-spear");
	544	MODULE_AUTHOR("Rajeev Kumar <[email protected]>");
	545	MODULE_DESCRIPTION("ST SPEAr Realtime Clock Driver (RTC)");
	546	MODULE_LICENSE("GPL");