[GitHub/mt8127/android_kernel_alcatel_ttab.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;

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

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

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

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

	config->ioaddr = devm_ioremap_resource(&pdev->dev, res);
	if (IS_ERR(config->ioaddr))
		return PTR_ERR(config->ioaddr);

	config->clk = devm_clk_get(&pdev->dev, NULL);
	if (IS_ERR(config->clk))
		return PTR_ERR(config->clk);

	status = clk_prepare_enable(config->clk);
	if (status < 0)
		return status;

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

	config->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
					&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_disable_clock;
	}

	config->rtc->uie_unsupported = 1;

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

	return 0;

err_disable_clock:
	platform_set_drvdata(pdev, NULL);
	clk_disable_unprepare(config->clk);

	return status;
}

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

	spear_rtc_disable_interrupt(config);
	clk_disable_unprepare(config->clk);
	device_init_wakeup(&pdev->dev, 0);

	return 0;
}

#ifdef CONFIG_PM_SLEEP
static int spear_rtc_suspend(struct device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);
	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 device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);
	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;
}
#endif

static SIMPLE_DEV_PM_OPS(spear_rtc_pm_ops, spear_rtc_suspend, spear_rtc_resume);

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 = spear_rtc_remove,
	.shutdown = spear_rtc_shutdown,
	.driver = {
		.name = "rtc-spear",
		.pm = &spear_rtc_pm_ops,
		.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);
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	};
0942a71e RK	353
5a167f45	354	static int spear_rtc_probe(struct platform_device *pdev)
0942a71e RK	355	{
0942a71e RK	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	}
0942a71e	366
bdaa2c63	367	config = devm_kzalloc(&pdev->dev, sizeof(*config), GFP_KERNEL);
0942a71e RK	368	if (!config) {
0942a71e RK	369	dev_err(&pdev->dev, "out of memory\n");
bdaa2c63	370	return -ENOMEM;
0942a71e RK	371	}
0942a71e RK	372
bdaa2c63 VK	373	/* alarm irqs */
	374	irq = platform_get_irq(pdev, 0);
	375	if (irq < 0) {
	376	dev_err(&pdev->dev, "no update irq?\n");
	377	return irq;
0942a71e RK	378	}
0942a71e RK	379
bdaa2c63 VK	380	status = devm_request_irq(&pdev->dev, irq, spear_rtc_irq, 0, pdev->name,
	381	config);
	382	if (status) {
	383	dev_err(&pdev->dev, "Alarm interrupt IRQ%d already claimed\n",
	384	irq);
	385	return status;
	386	}
0942a71e	387
8cbce1e5 TR	388	config->ioaddr = devm_ioremap_resource(&pdev->dev, res);
	389	if (IS_ERR(config->ioaddr))
	390	return PTR_ERR(config->ioaddr);
0942a71e	391
bdaa2c63 VK	392	config->clk = devm_clk_get(&pdev->dev, NULL);
	393	if (IS_ERR(config->clk))
	394	return PTR_ERR(config->clk);
	395
93d78394	396	status = clk_prepare_enable(config->clk);
bdaa2c63 VK	397	if (status < 0)
	398	return status;
	399
0942a71e	400	spin_lock_init(&config->lock);
ee6c54ca	401	platform_set_drvdata(pdev, config);
0942a71e	402
246b1a99 JH	403	config->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
246b1a99 JH	404	&spear_rtc_ops, THIS_MODULE);
ee6c54ca	405	if (IS_ERR(config->rtc)) {
0942a71e	406	dev_err(&pdev->dev, "can't register RTC device, err %ld\n",
ee6c54ca VK	407	PTR_ERR(config->rtc));
ee6c54ca VK	408	status = PTR_ERR(config->rtc);
bdaa2c63	409	goto err_disable_clock;
0942a71e RK	410	}
0942a71e RK	411
c9f5c7e7 DS	412	config->rtc->uie_unsupported = 1;
c9f5c7e7 DS	413
0942a71e RK	414	if (!device_can_wakeup(&pdev->dev))
	415	device_init_wakeup(&pdev->dev, 1);
	416
	417	return 0;
	418
0942a71e	419	err_disable_clock:
bdaa2c63	420	platform_set_drvdata(pdev, NULL);
93d78394	421	clk_disable_unprepare(config->clk);
0942a71e RK	422
	423	return status;
	424	}
	425
5a167f45	426	static int spear_rtc_remove(struct platform_device *pdev)
0942a71e	427	{
ee6c54ca	428	struct spear_rtc_config *config = platform_get_drvdata(pdev);
0942a71e	429
0942a71e	430	spear_rtc_disable_interrupt(config);
93d78394	431	clk_disable_unprepare(config->clk);
bdaa2c63	432	device_init_wakeup(&pdev->dev, 0);
0942a71e RK	433
	434	return 0;
	435	}
	436
b086e392 JH	437	#ifdef CONFIG_PM_SLEEP
b086e392 JH	438	static int spear_rtc_suspend(struct device *dev)
0942a71e	439	{
b086e392	440	struct platform_device *pdev = to_platform_device(dev);
ee6c54ca	441	struct spear_rtc_config *config = platform_get_drvdata(pdev);
0942a71e RK	442	int irq;
	443
	444	irq = platform_get_irq(pdev, 0);
cd0e08a8 DS	445	if (device_may_wakeup(&pdev->dev)) {
	446	if (!enable_irq_wake(irq))
	447	config->irq_wake = 1;
	448	} else {
0942a71e RK	449	spear_rtc_disable_interrupt(config);
	450	clk_disable(config->clk);
	451	}
	452
	453	return 0;
	454	}
	455
b086e392	456	static int spear_rtc_resume(struct device *dev)
0942a71e	457	{
b086e392	458	struct platform_device *pdev = to_platform_device(dev);
ee6c54ca	459	struct spear_rtc_config *config = platform_get_drvdata(pdev);
0942a71e RK	460	int irq;
	461
	462	irq = platform_get_irq(pdev, 0);
	463
cd0e08a8 DS	464	if (device_may_wakeup(&pdev->dev)) {
	465	if (config->irq_wake) {
	466	disable_irq_wake(irq);
	467	config->irq_wake = 0;
	468	}
	469	} else {
0942a71e RK	470	clk_enable(config->clk);
	471	spear_rtc_enable_interrupt(config);
	472	}
	473
	474	return 0;
	475	}
0942a71e RK	476	#endif
0942a71e RK	477
b086e392 JH	478	static SIMPLE_DEV_PM_OPS(spear_rtc_pm_ops, spear_rtc_suspend, spear_rtc_resume);
b086e392 JH	479
0942a71e RK	480	static void spear_rtc_shutdown(struct platform_device *pdev)
0942a71e RK	481	{
ee6c54ca	482	struct spear_rtc_config *config = platform_get_drvdata(pdev);
0942a71e RK	483
	484	spear_rtc_disable_interrupt(config);
	485	clk_disable(config->clk);
	486	}
	487
0108c4ff VK	488	#ifdef CONFIG_OF
	489	static const struct of_device_id spear_rtc_id_table[] = {
	490	{ .compatible = "st,spear600-rtc" },
	491	{}
	492	};
	493	MODULE_DEVICE_TABLE(of, spear_rtc_id_table);
	494	#endif
	495
0942a71e RK	496	static struct platform_driver spear_rtc_driver = {
0942a71e RK	497	.probe = spear_rtc_probe,
5a167f45	498	.remove = spear_rtc_remove,
0942a71e RK	499	.shutdown = spear_rtc_shutdown,
	500	.driver = {
	501	.name = "rtc-spear",
b086e392	502	.pm = &spear_rtc_pm_ops,
0108c4ff	503	.of_match_table = of_match_ptr(spear_rtc_id_table),
0942a71e RK	504	},
	505	};
	506
0c4eae66	507	module_platform_driver(spear_rtc_driver);
0942a71e RK	508
	509	MODULE_ALIAS("platform:rtc-spear");
	510	MODULE_AUTHOR("Rajeev Kumar <rajeev-dlh.kumar@st.com>");
	511	MODULE_DESCRIPTION("ST SPEAr Realtime Clock Driver (RTC)");
	512	MODULE_LICENSE("GPL");