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

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * DS1286 Real Time Clock interface for Linux
 *
 * Copyright (C) 1998, 1999, 2000 Ralf Baechle
 * Copyright (C) 2008 Thomas Bogendoerfer
 *
 * Based on code written by Paul Gortmaker.
 */

#include <linux/module.h>
#include <linux/rtc.h>
#include <linux/platform_device.h>
#include <linux/bcd.h>
#include <linux/rtc/ds1286.h>
#include <linux/io.h>
#include <linux/slab.h>

struct ds1286_priv {
	struct rtc_device *rtc;
	u32 __iomem *rtcregs;
	spinlock_t lock;
};

static inline u8 ds1286_rtc_read(struct ds1286_priv *priv, int reg)
{
	return __raw_readl(&priv->rtcregs[reg]) & 0xff;
}

static inline void ds1286_rtc_write(struct ds1286_priv *priv, u8 data, int reg)
{
	__raw_writel(data, &priv->rtcregs[reg]);
}


static int ds1286_alarm_irq_enable(struct device *dev, unsigned int enabled)
{
	struct ds1286_priv *priv = dev_get_drvdata(dev);
	unsigned long flags;
	unsigned char val;

	/* Allow or mask alarm interrupts */
	spin_lock_irqsave(&priv->lock, flags);
	val = ds1286_rtc_read(priv, RTC_CMD);
	if (enabled)
		val &=  ~RTC_TDM;
	else
		val |=  RTC_TDM;
	ds1286_rtc_write(priv, val, RTC_CMD);
	spin_unlock_irqrestore(&priv->lock, flags);

	return 0;
}

#ifdef CONFIG_RTC_INTF_DEV

static int ds1286_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
{
	struct ds1286_priv *priv = dev_get_drvdata(dev);
	unsigned long flags;
	unsigned char val;

	switch (cmd) {
	case RTC_WIE_OFF:
		/* Mask watchdog int. enab. bit	*/
		spin_lock_irqsave(&priv->lock, flags);
		val = ds1286_rtc_read(priv, RTC_CMD);
		val |= RTC_WAM;
		ds1286_rtc_write(priv, val, RTC_CMD);
		spin_unlock_irqrestore(&priv->lock, flags);
		break;
	case RTC_WIE_ON:
		/* Allow watchdog interrupts.	*/
		spin_lock_irqsave(&priv->lock, flags);
		val = ds1286_rtc_read(priv, RTC_CMD);
		val &= ~RTC_WAM;
		ds1286_rtc_write(priv, val, RTC_CMD);
		spin_unlock_irqrestore(&priv->lock, flags);
		break;
	default:
		return -ENOIOCTLCMD;
	}
	return 0;
}

#else
#define ds1286_ioctl    NULL
#endif

#ifdef CONFIG_PROC_FS

static int ds1286_proc(struct device *dev, struct seq_file *seq)
{
	struct ds1286_priv *priv = dev_get_drvdata(dev);
	unsigned char month, cmd, amode;
	const char *s;

	month = ds1286_rtc_read(priv, RTC_MONTH);
	seq_printf(seq,
		   "oscillator\t: %s\n"
		   "square_wave\t: %s\n",
		   (month & RTC_EOSC) ? "disabled" : "enabled",
		   (month & RTC_ESQW) ? "disabled" : "enabled");

	amode = ((ds1286_rtc_read(priv, RTC_MINUTES_ALARM) & 0x80) >> 5) |
		((ds1286_rtc_read(priv, RTC_HOURS_ALARM) & 0x80) >> 6) |
		((ds1286_rtc_read(priv, RTC_DAY_ALARM) & 0x80) >> 7);
	switch (amode) {
	case 7:
		s = "each minute";
		break;
	case 3:
		s = "minutes match";
		break;
	case 1:
		s = "hours and minutes match";
		break;
	case 0:
		s = "days, hours and minutes match";
		break;
	default:
		s = "invalid";
		break;
	}
	seq_printf(seq, "alarm_mode\t: %s\n", s);

	cmd = ds1286_rtc_read(priv, RTC_CMD);
	seq_printf(seq,
		   "alarm_enable\t: %s\n"
		   "wdog_alarm\t: %s\n"
		   "alarm_mask\t: %s\n"
		   "wdog_alarm_mask\t: %s\n"
		   "interrupt_mode\t: %s\n"
		   "INTB_mode\t: %s_active\n"
		   "interrupt_pins\t: %s\n",
		   (cmd & RTC_TDF) ? "yes" : "no",
		   (cmd & RTC_WAF) ? "yes" : "no",
		   (cmd & RTC_TDM) ? "disabled" : "enabled",
		   (cmd & RTC_WAM) ? "disabled" : "enabled",
		   (cmd & RTC_PU_LVL) ? "pulse" : "level",
		   (cmd & RTC_IBH_LO) ? "low" : "high",
		   (cmd & RTC_IPSW) ? "unswapped" : "swapped");
	return 0;
}

#else
#define ds1286_proc     NULL
#endif

static int ds1286_read_time(struct device *dev, struct rtc_time *tm)
{
	struct ds1286_priv *priv = dev_get_drvdata(dev);
	unsigned char save_control;
	unsigned long flags;
	unsigned long uip_watchdog = jiffies;

	/*
	 * read RTC once any update in progress is done. The update
	 * can take just over 2ms. We wait 10 to 20ms. There is no need to
	 * to poll-wait (up to 1s - eeccch) for the falling edge of RTC_UIP.
	 * If you need to know *exactly* when a second has started, enable
	 * periodic update complete interrupts, (via ioctl) and then
	 * immediately read /dev/rtc which will block until you get the IRQ.
	 * Once the read clears, read the RTC time (again via ioctl). Easy.
	 */

	if (ds1286_rtc_read(priv, RTC_CMD) & RTC_TE)
		while (time_before(jiffies, uip_watchdog + 2*HZ/100))
			barrier();

	/*
	 * Only the values that we read from the RTC are set. We leave
	 * tm_wday, tm_yday and tm_isdst untouched. Even though the
	 * RTC has RTC_DAY_OF_WEEK, we ignore it, as it is only updated
	 * by the RTC when initially set to a non-zero value.
	 */
	spin_lock_irqsave(&priv->lock, flags);
	save_control = ds1286_rtc_read(priv, RTC_CMD);
	ds1286_rtc_write(priv, (save_control|RTC_TE), RTC_CMD);

	tm->tm_sec = ds1286_rtc_read(priv, RTC_SECONDS);
	tm->tm_min = ds1286_rtc_read(priv, RTC_MINUTES);
	tm->tm_hour = ds1286_rtc_read(priv, RTC_HOURS) & 0x3f;
	tm->tm_mday = ds1286_rtc_read(priv, RTC_DATE);
	tm->tm_mon = ds1286_rtc_read(priv, RTC_MONTH) & 0x1f;
	tm->tm_year = ds1286_rtc_read(priv, RTC_YEAR);

	ds1286_rtc_write(priv, save_control, RTC_CMD);
	spin_unlock_irqrestore(&priv->lock, flags);

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

	/*
	 * Account for differences between how the RTC uses the values
	 * and how they are defined in a struct rtc_time;
	 */
	if (tm->tm_year < 45)
		tm->tm_year += 30;
	tm->tm_year += 40;
	if (tm->tm_year < 70)
		tm->tm_year += 100;

	tm->tm_mon--;

	return 0;
}

static int ds1286_set_time(struct device *dev, struct rtc_time *tm)
{
	struct ds1286_priv *priv = dev_get_drvdata(dev);
	unsigned char mon, day, hrs, min, sec;
	unsigned char save_control;
	unsigned int yrs;
	unsigned long flags;

	yrs = tm->tm_year + 1900;
	mon = tm->tm_mon + 1;   /* tm_mon starts at zero */
	day = tm->tm_mday;
	hrs = tm->tm_hour;
	min = tm->tm_min;
	sec = tm->tm_sec;

	if (yrs < 1970)
		return -EINVAL;

	yrs -= 1940;
	if (yrs > 255)    /* They are unsigned */
		return -EINVAL;

	if (yrs >= 100)
		yrs -= 100;

	sec = bin2bcd(sec);
	min = bin2bcd(min);
	hrs = bin2bcd(hrs);
	day = bin2bcd(day);
	mon = bin2bcd(mon);
	yrs = bin2bcd(yrs);

	spin_lock_irqsave(&priv->lock, flags);
	save_control = ds1286_rtc_read(priv, RTC_CMD);
	ds1286_rtc_write(priv, (save_control|RTC_TE), RTC_CMD);

	ds1286_rtc_write(priv, yrs, RTC_YEAR);
	ds1286_rtc_write(priv, mon, RTC_MONTH);
	ds1286_rtc_write(priv, day, RTC_DATE);
	ds1286_rtc_write(priv, hrs, RTC_HOURS);
	ds1286_rtc_write(priv, min, RTC_MINUTES);
	ds1286_rtc_write(priv, sec, RTC_SECONDS);
	ds1286_rtc_write(priv, 0, RTC_HUNDREDTH_SECOND);

	ds1286_rtc_write(priv, save_control, RTC_CMD);
	spin_unlock_irqrestore(&priv->lock, flags);
	return 0;
}

static int ds1286_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
{
	struct ds1286_priv *priv = dev_get_drvdata(dev);
	unsigned long flags;

	/*
	 * Only the values that we read from the RTC are set. That
	 * means only tm_wday, tm_hour, tm_min.
	 */
	spin_lock_irqsave(&priv->lock, flags);
	alm->time.tm_min = ds1286_rtc_read(priv, RTC_MINUTES_ALARM) & 0x7f;
	alm->time.tm_hour = ds1286_rtc_read(priv, RTC_HOURS_ALARM)  & 0x1f;
	alm->time.tm_wday = ds1286_rtc_read(priv, RTC_DAY_ALARM)    & 0x07;
	ds1286_rtc_read(priv, RTC_CMD);
	spin_unlock_irqrestore(&priv->lock, flags);

	alm->time.tm_min = bcd2bin(alm->time.tm_min);
	alm->time.tm_hour = bcd2bin(alm->time.tm_hour);
	alm->time.tm_sec = 0;
	return 0;
}

static int ds1286_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
{
	struct ds1286_priv *priv = dev_get_drvdata(dev);
	unsigned char hrs, min, sec;

	hrs = alm->time.tm_hour;
	min = alm->time.tm_min;
	sec = alm->time.tm_sec;

	if (hrs >= 24)
		hrs = 0xff;

	if (min >= 60)
		min = 0xff;

	if (sec != 0)
		return -EINVAL;

	min = bin2bcd(min);
	hrs = bin2bcd(hrs);

	spin_lock(&priv->lock);
	ds1286_rtc_write(priv, hrs, RTC_HOURS_ALARM);
	ds1286_rtc_write(priv, min, RTC_MINUTES_ALARM);
	spin_unlock(&priv->lock);

	return 0;
}

static const struct rtc_class_ops ds1286_ops = {
	.ioctl		= ds1286_ioctl,
	.proc		= ds1286_proc,
	.read_time	= ds1286_read_time,
	.set_time	= ds1286_set_time,
	.read_alarm	= ds1286_read_alarm,
	.set_alarm	= ds1286_set_alarm,
	.alarm_irq_enable = ds1286_alarm_irq_enable,
};

static int ds1286_probe(struct platform_device *pdev)
{
	struct rtc_device *rtc;
	struct ds1286_priv *priv;

	priv = devm_kzalloc(&pdev->dev, sizeof(struct ds1286_priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	priv->rtcregs = devm_platform_ioremap_resource(pdev, 0);
	if (IS_ERR(priv->rtcregs))
		return PTR_ERR(priv->rtcregs);

	spin_lock_init(&priv->lock);
	platform_set_drvdata(pdev, priv);
	rtc = devm_rtc_device_register(&pdev->dev, "ds1286", &ds1286_ops,
					THIS_MODULE);
	if (IS_ERR(rtc))
		return PTR_ERR(rtc);
	priv->rtc = rtc;
	return 0;
}

static struct platform_driver ds1286_platform_driver = {
	.driver		= {
		.name	= "rtc-ds1286",
	},
	.probe		= ds1286_probe,
};

module_platform_driver(ds1286_platform_driver);

MODULE_AUTHOR("Thomas Bogendoerfer <tsbogend@alpha.franken.de>");
MODULE_DESCRIPTION("DS1286 RTC driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:rtc-ds1286");
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
5f119f29 TB	2	/*
	3	* DS1286 Real Time Clock interface for Linux
	4	*
	5	* Copyright (C) 1998, 1999, 2000 Ralf Baechle
	6	* Copyright (C) 2008 Thomas Bogendoerfer
	7	*
	8	* Based on code written by Paul Gortmaker.
5f119f29 TB	9	*/
	10
	11	#include <linux/module.h>
	12	#include <linux/rtc.h>
	13	#include <linux/platform_device.h>
	14	#include <linux/bcd.h>
d4a5f6d7	15	#include <linux/rtc/ds1286.h>
d7a6119f	16	#include <linux/io.h>
5a0e3ad6	17	#include <linux/slab.h>
5f119f29	18
5f119f29 TB	19	struct ds1286_priv {
	20	struct rtc_device *rtc;
	21	u32 __iomem *rtcregs;
5f119f29 TB	22	spinlock_t lock;
	23	};
	24
	25	static inline u8 ds1286_rtc_read(struct ds1286_priv *priv, int reg)
	26	{
	27	return __raw_readl(&priv->rtcregs[reg]) & 0xff;
	28	}
	29
	30	static inline void ds1286_rtc_write(struct ds1286_priv *priv, u8 data, int reg)
	31	{
	32	__raw_writel(data, &priv->rtcregs[reg]);
	33	}
	34
16380c15 JS	35
	36	static int ds1286_alarm_irq_enable(struct device *dev, unsigned int enabled)
	37	{
	38	struct ds1286_priv *priv = dev_get_drvdata(dev);
	39	unsigned long flags;
	40	unsigned char val;
	41
	42	/* Allow or mask alarm interrupts */
	43	spin_lock_irqsave(&priv->lock, flags);
	44	val = ds1286_rtc_read(priv, RTC_CMD);
	45	if (enabled)
	46	val &= ~RTC_TDM;
	47	else
	48	val \|= RTC_TDM;
	49	ds1286_rtc_write(priv, val, RTC_CMD);
	50	spin_unlock_irqrestore(&priv->lock, flags);
	51
	52	return 0;
	53	}
	54
5f119f29 TB	55	#ifdef CONFIG_RTC_INTF_DEV
	56
	57	static int ds1286_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
	58	{
	59	struct ds1286_priv *priv = dev_get_drvdata(dev);
	60	unsigned long flags;
	61	unsigned char val;
	62
	63	switch (cmd) {
5f119f29 TB	64	case RTC_WIE_OFF:
	65	/* Mask watchdog int. enab. bit */
	66	spin_lock_irqsave(&priv->lock, flags);
	67	val = ds1286_rtc_read(priv, RTC_CMD);
	68	val \|= RTC_WAM;
	69	ds1286_rtc_write(priv, val, RTC_CMD);
	70	spin_unlock_irqrestore(&priv->lock, flags);
	71	break;
	72	case RTC_WIE_ON:
	73	/* Allow watchdog interrupts. */
	74	spin_lock_irqsave(&priv->lock, flags);
	75	val = ds1286_rtc_read(priv, RTC_CMD);
	76	val &= ~RTC_WAM;
	77	ds1286_rtc_write(priv, val, RTC_CMD);
	78	spin_unlock_irqrestore(&priv->lock, flags);
	79	break;
	80	default:
	81	return -ENOIOCTLCMD;
	82	}
	83	return 0;
	84	}
	85
	86	#else
	87	#define ds1286_ioctl NULL
	88	#endif
	89
	90	#ifdef CONFIG_PROC_FS
	91
	92	static int ds1286_proc(struct device dev, struct seq_file seq)
	93	{
	94	struct ds1286_priv *priv = dev_get_drvdata(dev);
	95	unsigned char month, cmd, amode;
	96	const char *s;
	97
	98	month = ds1286_rtc_read(priv, RTC_MONTH);
	99	seq_printf(seq,
	100	"oscillator\t: %s\n"
	101	"square_wave\t: %s\n",
	102	(month & RTC_EOSC) ? "disabled" : "enabled",
	103	(month & RTC_ESQW) ? "disabled" : "enabled");
	104
	105	amode = ((ds1286_rtc_read(priv, RTC_MINUTES_ALARM) & 0x80) >> 5) \|
	106	((ds1286_rtc_read(priv, RTC_HOURS_ALARM) & 0x80) >> 6) \|
	107	((ds1286_rtc_read(priv, RTC_DAY_ALARM) & 0x80) >> 7);
	108	switch (amode) {
	109	case 7:
	110	s = "each minute";
	111	break;
	112	case 3:
	113	s = "minutes match";
	114	break;
	115	case 1:
	116	s = "hours and minutes match";
	117	break;
	118	case 0:
	119	s = "days, hours and minutes match";
	120	break;
	121	default:
	122	s = "invalid";
	123	break;
	124	}
	125	seq_printf(seq, "alarm_mode\t: %s\n", s);
	126
	127	cmd = ds1286_rtc_read(priv, RTC_CMD);
128	seq_printf(seq,
129	"alarm_enable\t: %s\n"
130	"wdog_alarm\t: %s\n"
131	"alarm_mask\t: %s\n"
132	"wdog_alarm_mask\t: %s\n"
133	"interrupt_mode\t: %s\n"
134	"INTB_mode\t: %s_active\n"
135	"interrupt_pins\t: %s\n",
136	(cmd & RTC_TDF) ? "yes" : "no",
137	(cmd & RTC_WAF) ? "yes" : "no",
138	(cmd & RTC_TDM) ? "disabled" : "enabled",
139	(cmd & RTC_WAM) ? "disabled" : "enabled",
140	(cmd & RTC_PU_LVL) ? "pulse" : "level",
141	(cmd & RTC_IBH_LO) ? "low" : "high",
142	(cmd & RTC_IPSW) ? "unswapped" : "swapped");
143	return 0;
144	}
145
146	#else
147	#define ds1286_proc NULL
148	#endif
149
150	static int ds1286_read_time(struct device dev, struct rtc_time tm)
151	{
152	struct ds1286_priv *priv = dev_get_drvdata(dev);
153	unsigned char save_control;
154	unsigned long flags;
155	unsigned long uip_watchdog = jiffies;
156
157	/*
158	* read RTC once any update in progress is done. The update
159	* can take just over 2ms. We wait 10 to 20ms. There is no need to
160	* to poll-wait (up to 1s - eeccch) for the falling edge of RTC_UIP.
161	* If you need to know exactly when a second has started, enable
162	* periodic update complete interrupts, (via ioctl) and then
163	* immediately read /dev/rtc which will block until you get the IRQ.
164	* Once the read clears, read the RTC time (again via ioctl). Easy.
165	*/
166
167	if (ds1286_rtc_read(priv, RTC_CMD) & RTC_TE)
168	while (time_before(jiffies, uip_watchdog + 2*HZ/100))
169	barrier();
170
171	/*
172	* Only the values that we read from the RTC are set. We leave
173	* tm_wday, tm_yday and tm_isdst untouched. Even though the
174	* RTC has RTC_DAY_OF_WEEK, we ignore it, as it is only updated
175	* by the RTC when initially set to a non-zero value.
176	*/
177	spin_lock_irqsave(&priv->lock, flags);
178	save_control = ds1286_rtc_read(priv, RTC_CMD);
179	ds1286_rtc_write(priv, (save_control\|RTC_TE), RTC_CMD);
180
181	tm->tm_sec = ds1286_rtc_read(priv, RTC_SECONDS);
182	tm->tm_min = ds1286_rtc_read(priv, RTC_MINUTES);
183	tm->tm_hour = ds1286_rtc_read(priv, RTC_HOURS) & 0x3f;
184	tm->tm_mday = ds1286_rtc_read(priv, RTC_DATE);
185	tm->tm_mon = ds1286_rtc_read(priv, RTC_MONTH) & 0x1f;
186	tm->tm_year = ds1286_rtc_read(priv, RTC_YEAR);
187
188	ds1286_rtc_write(priv, save_control, RTC_CMD);
189	spin_unlock_irqrestore(&priv->lock, flags);
190
191	tm->tm_sec = bcd2bin(tm->tm_sec);
192	tm->tm_min = bcd2bin(tm->tm_min);
193	tm->tm_hour = bcd2bin(tm->tm_hour);
194	tm->tm_mday = bcd2bin(tm->tm_mday);
195	tm->tm_mon = bcd2bin(tm->tm_mon);
196	tm->tm_year = bcd2bin(tm->tm_year);
197
198	/*
199	* Account for differences between how the RTC uses the values
200	* and how they are defined in a struct rtc_time;
201	*/
202	if (tm->tm_year < 45)
203	tm->tm_year += 30;
204	tm->tm_year += 40;
205	if (tm->tm_year < 70)
206	tm->tm_year += 100;
207
208	tm->tm_mon--;
209
22652ba7	210	return 0;
5f119f29 TB	211	}
	212
	213	static int ds1286_set_time(struct device dev, struct rtc_time tm)
	214	{
	215	struct ds1286_priv *priv = dev_get_drvdata(dev);
	216	unsigned char mon, day, hrs, min, sec;
	217	unsigned char save_control;
	218	unsigned int yrs;
	219	unsigned long flags;
	220
	221	yrs = tm->tm_year + 1900;
	222	mon = tm->tm_mon + 1; /* tm_mon starts at zero */
	223	day = tm->tm_mday;
	224	hrs = tm->tm_hour;
	225	min = tm->tm_min;
	226	sec = tm->tm_sec;
	227
	228	if (yrs < 1970)
	229	return -EINVAL;
	230
	231	yrs -= 1940;
	232	if (yrs > 255) /* They are unsigned */
	233	return -EINVAL;
	234
	235	if (yrs >= 100)
	236	yrs -= 100;
	237
	238	sec = bin2bcd(sec);
	239	min = bin2bcd(min);
	240	hrs = bin2bcd(hrs);
	241	day = bin2bcd(day);
	242	mon = bin2bcd(mon);
	243	yrs = bin2bcd(yrs);
	244
	245	spin_lock_irqsave(&priv->lock, flags);
	246	save_control = ds1286_rtc_read(priv, RTC_CMD);
	247	ds1286_rtc_write(priv, (save_control\|RTC_TE), RTC_CMD);
	248
	249	ds1286_rtc_write(priv, yrs, RTC_YEAR);
	250	ds1286_rtc_write(priv, mon, RTC_MONTH);
	251	ds1286_rtc_write(priv, day, RTC_DATE);
	252	ds1286_rtc_write(priv, hrs, RTC_HOURS);
	253	ds1286_rtc_write(priv, min, RTC_MINUTES);
	254	ds1286_rtc_write(priv, sec, RTC_SECONDS);
	255	ds1286_rtc_write(priv, 0, RTC_HUNDREDTH_SECOND);
	256
	257	ds1286_rtc_write(priv, save_control, RTC_CMD);
	258	spin_unlock_irqrestore(&priv->lock, flags);
	259	return 0;
	260	}
	261
	262	static int ds1286_read_alarm(struct device dev, struct rtc_wkalrm alm)
	263	{
	264	struct ds1286_priv *priv = dev_get_drvdata(dev);
5f119f29 TB	265	unsigned long flags;
	266
	267	/*
	268	* Only the values that we read from the RTC are set. That
	269	* means only tm_wday, tm_hour, tm_min.
	270	*/
	271	spin_lock_irqsave(&priv->lock, flags);
	272	alm->time.tm_min = ds1286_rtc_read(priv, RTC_MINUTES_ALARM) & 0x7f;
	273	alm->time.tm_hour = ds1286_rtc_read(priv, RTC_HOURS_ALARM) & 0x1f;
	274	alm->time.tm_wday = ds1286_rtc_read(priv, RTC_DAY_ALARM) & 0x07;
cb72f60c	275	ds1286_rtc_read(priv, RTC_CMD);
5f119f29 TB	276	spin_unlock_irqrestore(&priv->lock, flags);
	277
	278	alm->time.tm_min = bcd2bin(alm->time.tm_min);
	279	alm->time.tm_hour = bcd2bin(alm->time.tm_hour);
	280	alm->time.tm_sec = 0;
	281	return 0;
	282	}
	283
	284	static int ds1286_set_alarm(struct device dev, struct rtc_wkalrm alm)
	285	{
	286	struct ds1286_priv *priv = dev_get_drvdata(dev);
	287	unsigned char hrs, min, sec;
	288
	289	hrs = alm->time.tm_hour;
	290	min = alm->time.tm_min;
	291	sec = alm->time.tm_sec;
	292
	293	if (hrs >= 24)
	294	hrs = 0xff;
	295
	296	if (min >= 60)
	297	min = 0xff;
	298
	299	if (sec != 0)
	300	return -EINVAL;
	301
	302	min = bin2bcd(min);
	303	hrs = bin2bcd(hrs);
	304
	305	spin_lock(&priv->lock);
	306	ds1286_rtc_write(priv, hrs, RTC_HOURS_ALARM);
	307	ds1286_rtc_write(priv, min, RTC_MINUTES_ALARM);
	308	spin_unlock(&priv->lock);
	309
	310	return 0;
	311	}
	312
	313	static const struct rtc_class_ops ds1286_ops = {
16380c15 JS	314	.ioctl = ds1286_ioctl,
16380c15 JS	315	.proc = ds1286_proc,
5f119f29 TB	316	.read_time = ds1286_read_time,
	317	.set_time = ds1286_set_time,
	318	.read_alarm = ds1286_read_alarm,
	319	.set_alarm = ds1286_set_alarm,
16380c15	320	.alarm_irq_enable = ds1286_alarm_irq_enable,
5f119f29 TB	321	};
5f119f29 TB	322
5a167f45	323	static int ds1286_probe(struct platform_device *pdev)
5f119f29 TB	324	{
5f119f29 TB	325	struct rtc_device *rtc;
5f119f29	326	struct ds1286_priv *priv;
5f119f29	327
061d698e	328	priv = devm_kzalloc(&pdev->dev, sizeof(struct ds1286_priv), GFP_KERNEL);
5f119f29 TB	329	if (!priv)
	330	return -ENOMEM;
	331
09ef18bc	332	priv->rtcregs = devm_platform_ioremap_resource(pdev, 0);
061d698e JH	333	if (IS_ERR(priv->rtcregs))
	334	return PTR_ERR(priv->rtcregs);
	335
5f119f29	336	spin_lock_init(&priv->lock);
9a281a67	337	platform_set_drvdata(pdev, priv);
061d698e JH	338	rtc = devm_rtc_device_register(&pdev->dev, "ds1286", &ds1286_ops,
	339	THIS_MODULE);
	340	if (IS_ERR(rtc))
	341	return PTR_ERR(rtc);
5f119f29	342	priv->rtc = rtc;
5f119f29	343	return 0;
5f119f29 TB	344	}
5f119f29 TB	345
5f119f29 TB	346	static struct platform_driver ds1286_platform_driver = {
	347	.driver = {
	348	.name = "rtc-ds1286",
5f119f29 TB	349	},
5f119f29 TB	350	.probe = ds1286_probe,
5f119f29 TB	351	};
5f119f29 TB	352
0c4eae66	353	module_platform_driver(ds1286_platform_driver);
5f119f29 TB	354
	355	MODULE_AUTHOR("Thomas Bogendoerfer <tsbogend@alpha.franken.de>");
	356	MODULE_DESCRIPTION("DS1286 RTC driver");
	357	MODULE_LICENSE("GPL");
5f119f29	358	MODULE_ALIAS("platform:rtc-ds1286");