[linux-block.git] / drivers / rtc / rtc-stk17ta8.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * A RTC driver for the Simtek STK17TA8
 *
 * By Thomas Hommel <thomas.hommel@ge.com>
 *
 * Based on the DS1553 driver from
 * Atsushi Nemoto <anemo@mba.ocn.ne.jp>
 */

#include <linux/bcd.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/gfp.h>
#include <linux/delay.h>
#include <linux/jiffies.h>
#include <linux/interrupt.h>
#include <linux/rtc.h>
#include <linux/platform_device.h>
#include <linux/io.h>
#include <linux/module.h>

#define RTC_REG_SIZE		0x20000
#define RTC_OFFSET		0x1fff0

#define RTC_FLAGS		(RTC_OFFSET + 0)
#define RTC_CENTURY		(RTC_OFFSET + 1)
#define RTC_SECONDS_ALARM	(RTC_OFFSET + 2)
#define RTC_MINUTES_ALARM	(RTC_OFFSET + 3)
#define RTC_HOURS_ALARM		(RTC_OFFSET + 4)
#define RTC_DATE_ALARM		(RTC_OFFSET + 5)
#define RTC_INTERRUPTS		(RTC_OFFSET + 6)
#define RTC_WATCHDOG		(RTC_OFFSET + 7)
#define RTC_CALIBRATION		(RTC_OFFSET + 8)
#define RTC_SECONDS		(RTC_OFFSET + 9)
#define RTC_MINUTES		(RTC_OFFSET + 10)
#define RTC_HOURS		(RTC_OFFSET + 11)
#define RTC_DAY			(RTC_OFFSET + 12)
#define RTC_DATE		(RTC_OFFSET + 13)
#define RTC_MONTH		(RTC_OFFSET + 14)
#define RTC_YEAR		(RTC_OFFSET + 15)

#define RTC_SECONDS_MASK	0x7f
#define RTC_DAY_MASK		0x07
#define RTC_CAL_MASK		0x3f

/* Bits in the Calibration register */
#define RTC_STOP		0x80

/* Bits in the Flags register */
#define RTC_FLAGS_AF		0x40
#define RTC_FLAGS_PF		0x20
#define RTC_WRITE		0x02
#define RTC_READ		0x01

/* Bits in the Interrupts register */
#define RTC_INTS_AIE		0x40

struct rtc_plat_data {
	struct rtc_device *rtc;
	void __iomem *ioaddr;
	unsigned long last_jiffies;
	int irq;
	unsigned int irqen;
	int alrm_sec;
	int alrm_min;
	int alrm_hour;
	int alrm_mday;
	spinlock_t lock;
};

static int stk17ta8_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
	struct rtc_plat_data *pdata = dev_get_drvdata(dev);
	void __iomem *ioaddr = pdata->ioaddr;
	u8 flags;

	flags = readb(pdata->ioaddr + RTC_FLAGS);
	writeb(flags | RTC_WRITE, pdata->ioaddr + RTC_FLAGS);

	writeb(bin2bcd(tm->tm_year % 100), ioaddr + RTC_YEAR);
	writeb(bin2bcd(tm->tm_mon + 1), ioaddr + RTC_MONTH);
	writeb(bin2bcd(tm->tm_wday) & RTC_DAY_MASK, ioaddr + RTC_DAY);
	writeb(bin2bcd(tm->tm_mday), ioaddr + RTC_DATE);
	writeb(bin2bcd(tm->tm_hour), ioaddr + RTC_HOURS);
	writeb(bin2bcd(tm->tm_min), ioaddr + RTC_MINUTES);
	writeb(bin2bcd(tm->tm_sec) & RTC_SECONDS_MASK, ioaddr + RTC_SECONDS);
	writeb(bin2bcd((tm->tm_year + 1900) / 100), ioaddr + RTC_CENTURY);

	writeb(flags & ~RTC_WRITE, pdata->ioaddr + RTC_FLAGS);
	return 0;
}

static int stk17ta8_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
	struct rtc_plat_data *pdata = dev_get_drvdata(dev);
	void __iomem *ioaddr = pdata->ioaddr;
	unsigned int year, month, day, hour, minute, second, week;
	unsigned int century;
	u8 flags;

	/* give enough time to update RTC in case of continuous read */
	if (pdata->last_jiffies == jiffies)
		msleep(1);
	pdata->last_jiffies = jiffies;

	flags = readb(pdata->ioaddr + RTC_FLAGS);
	writeb(flags | RTC_READ, ioaddr + RTC_FLAGS);
	second = readb(ioaddr + RTC_SECONDS) & RTC_SECONDS_MASK;
	minute = readb(ioaddr + RTC_MINUTES);
	hour = readb(ioaddr + RTC_HOURS);
	day = readb(ioaddr + RTC_DATE);
	week = readb(ioaddr + RTC_DAY) & RTC_DAY_MASK;
	month = readb(ioaddr + RTC_MONTH);
	year = readb(ioaddr + RTC_YEAR);
	century = readb(ioaddr + RTC_CENTURY);
	writeb(flags & ~RTC_READ, ioaddr + RTC_FLAGS);
	tm->tm_sec = bcd2bin(second);
	tm->tm_min = bcd2bin(minute);
	tm->tm_hour = bcd2bin(hour);
	tm->tm_mday = bcd2bin(day);
	tm->tm_wday = bcd2bin(week);
	tm->tm_mon = bcd2bin(month) - 1;
	/* year is 1900 + tm->tm_year */
	tm->tm_year = bcd2bin(year) + bcd2bin(century) * 100 - 1900;

	return 0;
}

static void stk17ta8_rtc_update_alarm(struct rtc_plat_data *pdata)
{
	void __iomem *ioaddr = pdata->ioaddr;
	unsigned long irqflags;
	u8 flags;

	spin_lock_irqsave(&pdata->lock, irqflags);

	flags = readb(ioaddr + RTC_FLAGS);
	writeb(flags | RTC_WRITE, ioaddr + RTC_FLAGS);

	writeb(pdata->alrm_mday < 0 || (pdata->irqen & RTC_UF) ?
	       0x80 : bin2bcd(pdata->alrm_mday),
	       ioaddr + RTC_DATE_ALARM);
	writeb(pdata->alrm_hour < 0 || (pdata->irqen & RTC_UF) ?
	       0x80 : bin2bcd(pdata->alrm_hour),
	       ioaddr + RTC_HOURS_ALARM);
	writeb(pdata->alrm_min < 0 || (pdata->irqen & RTC_UF) ?
	       0x80 : bin2bcd(pdata->alrm_min),
	       ioaddr + RTC_MINUTES_ALARM);
	writeb(pdata->alrm_sec < 0 || (pdata->irqen & RTC_UF) ?
	       0x80 : bin2bcd(pdata->alrm_sec),
	       ioaddr + RTC_SECONDS_ALARM);
	writeb(pdata->irqen ? RTC_INTS_AIE : 0, ioaddr + RTC_INTERRUPTS);
	readb(ioaddr + RTC_FLAGS);	/* clear interrupts */
	writeb(flags & ~RTC_WRITE, ioaddr + RTC_FLAGS);
	spin_unlock_irqrestore(&pdata->lock, irqflags);
}

static int stk17ta8_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	struct rtc_plat_data *pdata = dev_get_drvdata(dev);

	if (pdata->irq <= 0)
		return -EINVAL;
	pdata->alrm_mday = alrm->time.tm_mday;
	pdata->alrm_hour = alrm->time.tm_hour;
	pdata->alrm_min = alrm->time.tm_min;
	pdata->alrm_sec = alrm->time.tm_sec;
	if (alrm->enabled)
		pdata->irqen |= RTC_AF;
	stk17ta8_rtc_update_alarm(pdata);
	return 0;
}

static int stk17ta8_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	struct rtc_plat_data *pdata = dev_get_drvdata(dev);

	if (pdata->irq <= 0)
		return -EINVAL;
	alrm->time.tm_mday = pdata->alrm_mday < 0 ? 0 : pdata->alrm_mday;
	alrm->time.tm_hour = pdata->alrm_hour < 0 ? 0 : pdata->alrm_hour;
	alrm->time.tm_min = pdata->alrm_min < 0 ? 0 : pdata->alrm_min;
	alrm->time.tm_sec = pdata->alrm_sec < 0 ? 0 : pdata->alrm_sec;
	alrm->enabled = (pdata->irqen & RTC_AF) ? 1 : 0;
	return 0;
}

static irqreturn_t stk17ta8_rtc_interrupt(int irq, void *dev_id)
{
	struct platform_device *pdev = dev_id;
	struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
	void __iomem *ioaddr = pdata->ioaddr;
	unsigned long events = 0;

	spin_lock(&pdata->lock);
	/* read and clear interrupt */
	if (readb(ioaddr + RTC_FLAGS) & RTC_FLAGS_AF) {
		events = RTC_IRQF;
		if (readb(ioaddr + RTC_SECONDS_ALARM) & 0x80)
			events |= RTC_UF;
		else
			events |= RTC_AF;
		rtc_update_irq(pdata->rtc, 1, events);
	}
	spin_unlock(&pdata->lock);
	return events ? IRQ_HANDLED : IRQ_NONE;
}

static int stk17ta8_rtc_alarm_irq_enable(struct device *dev,
	unsigned int enabled)
{
	struct rtc_plat_data *pdata = dev_get_drvdata(dev);

	if (pdata->irq <= 0)
		return -EINVAL;
	if (enabled)
		pdata->irqen |= RTC_AF;
	else
		pdata->irqen &= ~RTC_AF;
	stk17ta8_rtc_update_alarm(pdata);
	return 0;
}

static const struct rtc_class_ops stk17ta8_rtc_ops = {
	.read_time		= stk17ta8_rtc_read_time,
	.set_time		= stk17ta8_rtc_set_time,
	.read_alarm		= stk17ta8_rtc_read_alarm,
	.set_alarm		= stk17ta8_rtc_set_alarm,
	.alarm_irq_enable	= stk17ta8_rtc_alarm_irq_enable,
};

static int stk17ta8_nvram_read(void *priv, unsigned int pos, void *val,
			       size_t bytes)
{
	struct rtc_plat_data *pdata = priv;
	void __iomem *ioaddr = pdata->ioaddr;
	u8 *buf = val;

	for (; bytes; bytes--)
		*buf++ = readb(ioaddr + pos++);
	return 0;
}

static int stk17ta8_nvram_write(void *priv, unsigned int pos, void *val,
				size_t bytes)
{
	struct rtc_plat_data *pdata = priv;
	void __iomem *ioaddr = pdata->ioaddr;
	u8 *buf = val;

	for (; bytes; bytes--)
		writeb(*buf++, ioaddr + pos++);
	return 0;
}

static int stk17ta8_rtc_probe(struct platform_device *pdev)
{
	unsigned int cal;
	unsigned int flags;
	struct rtc_plat_data *pdata;
	void __iomem *ioaddr;
	int ret = 0;
	struct nvmem_config nvmem_cfg = {
		.name = "stk17ta8_nvram",
		.word_size = 1,
		.stride = 1,
		.size = RTC_OFFSET,
		.reg_read = stk17ta8_nvram_read,
		.reg_write = stk17ta8_nvram_write,
	};

	pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
	if (!pdata)
		return -ENOMEM;

	ioaddr = devm_platform_ioremap_resource(pdev, 0);
	if (IS_ERR(ioaddr))
		return PTR_ERR(ioaddr);
	pdata->ioaddr = ioaddr;
	pdata->irq = platform_get_irq(pdev, 0);

	/* turn RTC on if it was not on */
	cal = readb(ioaddr + RTC_CALIBRATION);
	if (cal & RTC_STOP) {
		cal &= RTC_CAL_MASK;
		flags = readb(ioaddr + RTC_FLAGS);
		writeb(flags | RTC_WRITE, ioaddr + RTC_FLAGS);
		writeb(cal, ioaddr + RTC_CALIBRATION);
		writeb(flags & ~RTC_WRITE, ioaddr + RTC_FLAGS);
	}
	if (readb(ioaddr + RTC_FLAGS) & RTC_FLAGS_PF)
		dev_warn(&pdev->dev, "voltage-low detected.\n");

	spin_lock_init(&pdata->lock);
	pdata->last_jiffies = jiffies;
	platform_set_drvdata(pdev, pdata);
	if (pdata->irq > 0) {
		writeb(0, ioaddr + RTC_INTERRUPTS);
		if (devm_request_irq(&pdev->dev, pdata->irq,
				stk17ta8_rtc_interrupt,
				IRQF_SHARED,
				pdev->name, pdev) < 0) {
			dev_warn(&pdev->dev, "interrupt not available.\n");
			pdata->irq = 0;
		}
	}

	pdata->rtc = devm_rtc_allocate_device(&pdev->dev);
	if (IS_ERR(pdata->rtc))
		return PTR_ERR(pdata->rtc);

	pdata->rtc->ops = &stk17ta8_rtc_ops;

	nvmem_cfg.priv = pdata;
	ret = devm_rtc_nvmem_register(pdata->rtc, &nvmem_cfg);
	if (ret)
		return ret;

	return devm_rtc_register_device(pdata->rtc);
}

/* work with hotplug and coldplug */
MODULE_ALIAS("platform:stk17ta8");

static struct platform_driver stk17ta8_rtc_driver = {
	.probe		= stk17ta8_rtc_probe,
	.driver		= {
		.name	= "stk17ta8",
	},
};

module_platform_driver(stk17ta8_rtc_driver);

MODULE_AUTHOR("Thomas Hommel <thomas.hommel@ge.com>");
MODULE_DESCRIPTION("Simtek STK17TA8 RTC driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
02964115 TH	2	/*
	3	* A RTC driver for the Simtek STK17TA8
	4	*
ab4364d3	5	* By Thomas Hommel <thomas.hommel@ge.com>
02964115 TH	6	*
	7	* Based on the DS1553 driver from
	8	* Atsushi Nemoto <anemo@mba.ocn.ne.jp>
02964115 TH	9	*/
	10
	11	#include <linux/bcd.h>
	12	#include <linux/init.h>
	13	#include <linux/kernel.h>
5a0e3ad6	14	#include <linux/gfp.h>
02964115 TH	15	#include <linux/delay.h>
	16	#include <linux/jiffies.h>
	17	#include <linux/interrupt.h>
	18	#include <linux/rtc.h>
	19	#include <linux/platform_device.h>
	20	#include <linux/io.h>
2113852b	21	#include <linux/module.h>
02964115	22
02964115 TH	23	#define RTC_REG_SIZE 0x20000
	24	#define RTC_OFFSET 0x1fff0
	25
	26	#define RTC_FLAGS (RTC_OFFSET + 0)
	27	#define RTC_CENTURY (RTC_OFFSET + 1)
	28	#define RTC_SECONDS_ALARM (RTC_OFFSET + 2)
	29	#define RTC_MINUTES_ALARM (RTC_OFFSET + 3)
	30	#define RTC_HOURS_ALARM (RTC_OFFSET + 4)
	31	#define RTC_DATE_ALARM (RTC_OFFSET + 5)
	32	#define RTC_INTERRUPTS (RTC_OFFSET + 6)
	33	#define RTC_WATCHDOG (RTC_OFFSET + 7)
	34	#define RTC_CALIBRATION (RTC_OFFSET + 8)
	35	#define RTC_SECONDS (RTC_OFFSET + 9)
	36	#define RTC_MINUTES (RTC_OFFSET + 10)
	37	#define RTC_HOURS (RTC_OFFSET + 11)
	38	#define RTC_DAY (RTC_OFFSET + 12)
	39	#define RTC_DATE (RTC_OFFSET + 13)
	40	#define RTC_MONTH (RTC_OFFSET + 14)
	41	#define RTC_YEAR (RTC_OFFSET + 15)
	42
	43	#define RTC_SECONDS_MASK 0x7f
	44	#define RTC_DAY_MASK 0x07
	45	#define RTC_CAL_MASK 0x3f
	46
	47	/* Bits in the Calibration register */
	48	#define RTC_STOP 0x80
	49
	50	/* Bits in the Flags register */
	51	#define RTC_FLAGS_AF 0x40
	52	#define RTC_FLAGS_PF 0x20
	53	#define RTC_WRITE 0x02
	54	#define RTC_READ 0x01
	55
	56	/* Bits in the Interrupts register */
	57	#define RTC_INTS_AIE 0x40
	58
	59	struct rtc_plat_data {
	60	struct rtc_device *rtc;
	61	void __iomem *ioaddr;
02964115 TH	62	unsigned long last_jiffies;
	63	int irq;
	64	unsigned int irqen;
	65	int alrm_sec;
	66	int alrm_min;
	67	int alrm_hour;
	68	int alrm_mday;
3151520d	69	spinlock_t lock;
02964115 TH	70	};
	71
	72	static int stk17ta8_rtc_set_time(struct device dev, struct rtc_time tm)
	73	{
85368bb9	74	struct rtc_plat_data *pdata = dev_get_drvdata(dev);
02964115 TH	75	void __iomem *ioaddr = pdata->ioaddr;
	76	u8 flags;
	77
	78	flags = readb(pdata->ioaddr + RTC_FLAGS);
	79	writeb(flags \| RTC_WRITE, pdata->ioaddr + RTC_FLAGS);
	80
fe20ba70 AB	81	writeb(bin2bcd(tm->tm_year % 100), ioaddr + RTC_YEAR);
	82	writeb(bin2bcd(tm->tm_mon + 1), ioaddr + RTC_MONTH);
	83	writeb(bin2bcd(tm->tm_wday) & RTC_DAY_MASK, ioaddr + RTC_DAY);
	84	writeb(bin2bcd(tm->tm_mday), ioaddr + RTC_DATE);
	85	writeb(bin2bcd(tm->tm_hour), ioaddr + RTC_HOURS);
	86	writeb(bin2bcd(tm->tm_min), ioaddr + RTC_MINUTES);
	87	writeb(bin2bcd(tm->tm_sec) & RTC_SECONDS_MASK, ioaddr + RTC_SECONDS);
	88	writeb(bin2bcd((tm->tm_year + 1900) / 100), ioaddr + RTC_CENTURY);
02964115 TH	89
	90	writeb(flags & ~RTC_WRITE, pdata->ioaddr + RTC_FLAGS);
	91	return 0;
	92	}
	93
	94	static int stk17ta8_rtc_read_time(struct device dev, struct rtc_time tm)
	95	{
85368bb9	96	struct rtc_plat_data *pdata = dev_get_drvdata(dev);
02964115 TH	97	void __iomem *ioaddr = pdata->ioaddr;
	98	unsigned int year, month, day, hour, minute, second, week;
	99	unsigned int century;
	100	u8 flags;
	101
	102	/* give enough time to update RTC in case of continuous read */
	103	if (pdata->last_jiffies == jiffies)
	104	msleep(1);
	105	pdata->last_jiffies = jiffies;
	106
	107	flags = readb(pdata->ioaddr + RTC_FLAGS);
	108	writeb(flags \| RTC_READ, ioaddr + RTC_FLAGS);
	109	second = readb(ioaddr + RTC_SECONDS) & RTC_SECONDS_MASK;
	110	minute = readb(ioaddr + RTC_MINUTES);
	111	hour = readb(ioaddr + RTC_HOURS);
	112	day = readb(ioaddr + RTC_DATE);
	113	week = readb(ioaddr + RTC_DAY) & RTC_DAY_MASK;
	114	month = readb(ioaddr + RTC_MONTH);
	115	year = readb(ioaddr + RTC_YEAR);
	116	century = readb(ioaddr + RTC_CENTURY);
	117	writeb(flags & ~RTC_READ, ioaddr + RTC_FLAGS);
fe20ba70 AB	118	tm->tm_sec = bcd2bin(second);
	119	tm->tm_min = bcd2bin(minute);
	120	tm->tm_hour = bcd2bin(hour);
	121	tm->tm_mday = bcd2bin(day);
	122	tm->tm_wday = bcd2bin(week);
	123	tm->tm_mon = bcd2bin(month) - 1;
02964115	124	/* year is 1900 + tm->tm_year */
fe20ba70	125	tm->tm_year = bcd2bin(year) + bcd2bin(century) * 100 - 1900;
02964115	126
02964115 TH	127	return 0;
	128	}
	129
	130	static void stk17ta8_rtc_update_alarm(struct rtc_plat_data *pdata)
	131	{
	132	void __iomem *ioaddr = pdata->ioaddr;
	133	unsigned long irqflags;
	134	u8 flags;
	135
3151520d	136	spin_lock_irqsave(&pdata->lock, irqflags);
02964115 TH	137
	138	flags = readb(ioaddr + RTC_FLAGS);
	139	writeb(flags \| RTC_WRITE, ioaddr + RTC_FLAGS);
	140
	141	writeb(pdata->alrm_mday < 0 \|\| (pdata->irqen & RTC_UF) ?
fe20ba70	142	0x80 : bin2bcd(pdata->alrm_mday),
02964115 TH	143	ioaddr + RTC_DATE_ALARM);
02964115 TH	144	writeb(pdata->alrm_hour < 0 \|\| (pdata->irqen & RTC_UF) ?
fe20ba70	145	0x80 : bin2bcd(pdata->alrm_hour),
02964115 TH	146	ioaddr + RTC_HOURS_ALARM);
02964115 TH	147	writeb(pdata->alrm_min < 0 \|\| (pdata->irqen & RTC_UF) ?
fe20ba70	148	0x80 : bin2bcd(pdata->alrm_min),
02964115 TH	149	ioaddr + RTC_MINUTES_ALARM);
02964115 TH	150	writeb(pdata->alrm_sec < 0 \|\| (pdata->irqen & RTC_UF) ?
fe20ba70	151	0x80 : bin2bcd(pdata->alrm_sec),
02964115 TH	152	ioaddr + RTC_SECONDS_ALARM);
	153	writeb(pdata->irqen ? RTC_INTS_AIE : 0, ioaddr + RTC_INTERRUPTS);
	154	readb(ioaddr + RTC_FLAGS); /* clear interrupts */
	155	writeb(flags & ~RTC_WRITE, ioaddr + RTC_FLAGS);
3151520d	156	spin_unlock_irqrestore(&pdata->lock, irqflags);
02964115 TH	157	}
	158
	159	static int stk17ta8_rtc_set_alarm(struct device dev, struct rtc_wkalrm alrm)
	160	{
85368bb9	161	struct rtc_plat_data *pdata = dev_get_drvdata(dev);
02964115	162
2fac6674	163	if (pdata->irq <= 0)
02964115 TH	164	return -EINVAL;
	165	pdata->alrm_mday = alrm->time.tm_mday;
	166	pdata->alrm_hour = alrm->time.tm_hour;
	167	pdata->alrm_min = alrm->time.tm_min;
	168	pdata->alrm_sec = alrm->time.tm_sec;
	169	if (alrm->enabled)
	170	pdata->irqen \|= RTC_AF;
	171	stk17ta8_rtc_update_alarm(pdata);
	172	return 0;
	173	}
	174
	175	static int stk17ta8_rtc_read_alarm(struct device dev, struct rtc_wkalrm alrm)
	176	{
85368bb9	177	struct rtc_plat_data *pdata = dev_get_drvdata(dev);
02964115	178
2fac6674	179	if (pdata->irq <= 0)
02964115 TH	180	return -EINVAL;
	181	alrm->time.tm_mday = pdata->alrm_mday < 0 ? 0 : pdata->alrm_mday;
	182	alrm->time.tm_hour = pdata->alrm_hour < 0 ? 0 : pdata->alrm_hour;
	183	alrm->time.tm_min = pdata->alrm_min < 0 ? 0 : pdata->alrm_min;
	184	alrm->time.tm_sec = pdata->alrm_sec < 0 ? 0 : pdata->alrm_sec;
	185	alrm->enabled = (pdata->irqen & RTC_AF) ? 1 : 0;
	186	return 0;
	187	}
	188
	189	static irqreturn_t stk17ta8_rtc_interrupt(int irq, void *dev_id)
	190	{
	191	struct platform_device *pdev = dev_id;
	192	struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
	193	void __iomem *ioaddr = pdata->ioaddr;
3151520d	194	unsigned long events = 0;
02964115	195
3151520d	196	spin_lock(&pdata->lock);
02964115	197	/* read and clear interrupt */
3151520d AN	198	if (readb(ioaddr + RTC_FLAGS) & RTC_FLAGS_AF) {
	199	events = RTC_IRQF;
	200	if (readb(ioaddr + RTC_SECONDS_ALARM) & 0x80)
	201	events \|= RTC_UF;
	202	else
	203	events \|= RTC_AF;
0d71915d	204	rtc_update_irq(pdata->rtc, 1, events);
3151520d AN	205	}
	206	spin_unlock(&pdata->lock);
	207	return events ? IRQ_HANDLED : IRQ_NONE;
02964115 TH	208	}
02964115 TH	209
3151520d AN	210	static int stk17ta8_rtc_alarm_irq_enable(struct device *dev,
3151520d AN	211	unsigned int enabled)
02964115	212	{
85368bb9	213	struct rtc_plat_data *pdata = dev_get_drvdata(dev);
02964115	214
2fac6674	215	if (pdata->irq <= 0)
3151520d AN	216	return -EINVAL;
3151520d AN	217	if (enabled)
02964115	218	pdata->irqen \|= RTC_AF;
3151520d AN	219	else
	220	pdata->irqen &= ~RTC_AF;
	221	stk17ta8_rtc_update_alarm(pdata);
02964115 TH	222	return 0;
	223	}
	224
	225	static const struct rtc_class_ops stk17ta8_rtc_ops = {
3151520d AN	226	.read_time = stk17ta8_rtc_read_time,
	227	.set_time = stk17ta8_rtc_set_time,
	228	.read_alarm = stk17ta8_rtc_read_alarm,
	229	.set_alarm = stk17ta8_rtc_set_alarm,
	230	.alarm_irq_enable = stk17ta8_rtc_alarm_irq_enable,
02964115 TH	231	};
02964115 TH	232
d7ca4299 AB	233	static int stk17ta8_nvram_read(void priv, unsigned int pos, void val,
d7ca4299 AB	234	size_t bytes)
02964115	235	{
d7ca4299	236	struct rtc_plat_data *pdata = priv;
02964115	237	void __iomem *ioaddr = pdata->ioaddr;
d7ca4299	238	u8 *buf = val;
02964115	239
d7ca4299	240	for (; bytes; bytes--)
02964115	241	*buf++ = readb(ioaddr + pos++);
d7ca4299	242	return 0;
02964115 TH	243	}
02964115 TH	244
d7ca4299 AB	245	static int stk17ta8_nvram_write(void priv, unsigned int pos, void val,
d7ca4299 AB	246	size_t bytes)
02964115	247	{
d7ca4299	248	struct rtc_plat_data *pdata = priv;
02964115	249	void __iomem *ioaddr = pdata->ioaddr;
d7ca4299	250	u8 *buf = val;
02964115	251
d7ca4299	252	for (; bytes; bytes--)
02964115	253	writeb(*buf++, ioaddr + pos++);
d7ca4299	254	return 0;
02964115 TH	255	}
02964115 TH	256
5a167f45	257	static int stk17ta8_rtc_probe(struct platform_device *pdev)
02964115	258	{
02964115 TH	259	unsigned int cal;
	260	unsigned int flags;
	261	struct rtc_plat_data *pdata;
3151520d	262	void __iomem *ioaddr;
02964115	263	int ret = 0;
d7ca4299 AB	264	struct nvmem_config nvmem_cfg = {
	265	.name = "stk17ta8_nvram",
	266	.word_size = 1,
	267	.stride = 1,
	268	.size = RTC_OFFSET,
	269	.reg_read = stk17ta8_nvram_read,
	270	.reg_write = stk17ta8_nvram_write,
	271	};
02964115	272
3151520d	273	pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
02964115 TH	274	if (!pdata)
02964115 TH	275	return -ENOMEM;
7c1d69ee	276
09ef18bc	277	ioaddr = devm_platform_ioremap_resource(pdev, 0);
7c1d69ee JL	278	if (IS_ERR(ioaddr))
7c1d69ee JL	279	return PTR_ERR(ioaddr);
02964115 TH	280	pdata->ioaddr = ioaddr;
	281	pdata->irq = platform_get_irq(pdev, 0);
	282
	283	/* turn RTC on if it was not on */
	284	cal = readb(ioaddr + RTC_CALIBRATION);
	285	if (cal & RTC_STOP) {
	286	cal &= RTC_CAL_MASK;
	287	flags = readb(ioaddr + RTC_FLAGS);
	288	writeb(flags \| RTC_WRITE, ioaddr + RTC_FLAGS);
	289	writeb(cal, ioaddr + RTC_CALIBRATION);
	290	writeb(flags & ~RTC_WRITE, ioaddr + RTC_FLAGS);
	291	}
	292	if (readb(ioaddr + RTC_FLAGS) & RTC_FLAGS_PF)
	293	dev_warn(&pdev->dev, "voltage-low detected.\n");
	294
3151520d AN	295	spin_lock_init(&pdata->lock);
	296	pdata->last_jiffies = jiffies;
	297	platform_set_drvdata(pdev, pdata);
2fac6674	298	if (pdata->irq > 0) {
02964115	299	writeb(0, ioaddr + RTC_INTERRUPTS);
3151520d AN	300	if (devm_request_irq(&pdev->dev, pdata->irq,
3151520d AN	301	stk17ta8_rtc_interrupt,
2f6e5f94	302	IRQF_SHARED,
02964115 TH	303	pdev->name, pdev) < 0) {
02964115 TH	304	dev_warn(&pdev->dev, "interrupt not available.\n");
2fac6674	305	pdata->irq = 0;
02964115 TH	306	}
	307	}
	308
91cb6774	309	pdata->rtc = devm_rtc_allocate_device(&pdev->dev);
3151520d AN	310	if (IS_ERR(pdata->rtc))
3151520d AN	311	return PTR_ERR(pdata->rtc);
b74d2caa	312
91cb6774 AB	313	pdata->rtc->ops = &stk17ta8_rtc_ops;
91cb6774 AB	314
d7ca4299	315	nvmem_cfg.priv = pdata;
3a905c2d	316	ret = devm_rtc_nvmem_register(pdata->rtc, &nvmem_cfg);
91cb6774 AB	317	if (ret)
	318	return ret;
	319
fdcfd854	320	return devm_rtc_register_device(pdata->rtc);
02964115 TH	321	}
02964115 TH	322
ad28a07b KS	323	/* work with hotplug and coldplug */
	324	MODULE_ALIAS("platform:stk17ta8");
	325
02964115 TH	326	static struct platform_driver stk17ta8_rtc_driver = {
02964115 TH	327	.probe = stk17ta8_rtc_probe,
02964115 TH	328	.driver = {
02964115 TH	329	.name = "stk17ta8",
02964115 TH	330	},
	331	};
	332
0c4eae66	333	module_platform_driver(stk17ta8_rtc_driver);
02964115	334
ab4364d3	335	MODULE_AUTHOR("Thomas Hommel <thomas.hommel@ge.com>");
02964115 TH	336	MODULE_DESCRIPTION("Simtek STK17TA8 RTC driver");
02964115 TH	337	MODULE_LICENSE("GPL");