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

/*
 * RTC driver for Maxim MAX8925
 *
 * Copyright (C) 2009-2010 Marvell International Ltd.
 *	Haojian Zhuang <[email protected]>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/slab.h>
#include <linux/rtc.h>
#include <linux/platform_device.h>
#include <linux/mfd/max8925.h>

enum {
	RTC_SEC = 0,
	RTC_MIN,
	RTC_HOUR,
	RTC_WEEKDAY,
	RTC_DATE,
	RTC_MONTH,
	RTC_YEAR1,
	RTC_YEAR2,
};

#define MAX8925_RTC_SEC			0x00
#define MAX8925_RTC_MIN			0x01
#define MAX8925_RTC_HOUR		0x02
#define MAX8925_RTC_WEEKDAY		0x03
#define MAX8925_RTC_DATE		0x04
#define MAX8925_RTC_MONTH		0x05
#define MAX8925_RTC_YEAR1		0x06
#define MAX8925_RTC_YEAR2		0x07
#define MAX8925_ALARM0_SEC		0x08
#define MAX8925_ALARM0_MIN		0x09
#define MAX8925_ALARM0_HOUR		0x0a
#define MAX8925_ALARM0_WEEKDAY		0x0b
#define MAX8925_ALARM0_DATE		0x0c
#define MAX8925_ALARM0_MON		0x0d
#define MAX8925_ALARM0_YEAR1		0x0e
#define MAX8925_ALARM0_YEAR2		0x0f
#define MAX8925_ALARM1_SEC		0x10
#define MAX8925_ALARM1_MIN		0x11
#define MAX8925_ALARM1_HOUR		0x12
#define MAX8925_ALARM1_WEEKDAY		0x13
#define MAX8925_ALARM1_DATE		0x14
#define MAX8925_ALARM1_MON		0x15
#define MAX8925_ALARM1_YEAR1		0x16
#define MAX8925_ALARM1_YEAR2		0x17
#define MAX8925_RTC_CNTL		0x1b
#define MAX8925_RTC_STATUS		0x20

#define TIME_NUM			8
#define ALARM_1SEC			(1 << 7)
#define HOUR_12				(1 << 7)
#define HOUR_AM_PM			(1 << 5)
#define ALARM0_IRQ			(1 << 3)
#define ALARM1_IRQ			(1 << 2)
#define ALARM0_STATUS			(1 << 2)
#define ALARM1_STATUS			(1 << 1)


struct max8925_rtc_info {
	struct rtc_device	*rtc_dev;
	struct max8925_chip	*chip;
	struct i2c_client	*rtc;
	struct device		*dev;
};

static irqreturn_t rtc_update_handler(int irq, void *data)
{
	struct max8925_rtc_info *info = (struct max8925_rtc_info *)data;

	/* disable ALARM0 except for 1SEC alarm */
	max8925_set_bits(info->rtc, MAX8925_ALARM0_CNTL, 0x7f, 0);
	rtc_update_irq(info->rtc_dev, 1, RTC_IRQF | RTC_AF);
	return IRQ_HANDLED;
}

static int tm_calc(struct rtc_time *tm, unsigned char *buf, int len)
{
	if (len < TIME_NUM)
		return -EINVAL;
	tm->tm_year = (buf[RTC_YEAR2] >> 4) * 1000
			+ (buf[RTC_YEAR2] & 0xf) * 100
			+ (buf[RTC_YEAR1] >> 4) * 10
			+ (buf[RTC_YEAR1] & 0xf);
	tm->tm_year -= 1900;
	tm->tm_mon = ((buf[RTC_MONTH] >> 4) & 0x01) * 10
			+ (buf[RTC_MONTH] & 0x0f);
	tm->tm_mday = ((buf[RTC_DATE] >> 4) & 0x03) * 10
			+ (buf[RTC_DATE] & 0x0f);
	tm->tm_wday = buf[RTC_WEEKDAY] & 0x07;
	if (buf[RTC_HOUR] & HOUR_12) {
		tm->tm_hour = ((buf[RTC_HOUR] >> 4) & 0x1) * 10
				+ (buf[RTC_HOUR] & 0x0f);
		if (buf[RTC_HOUR] & HOUR_AM_PM)
			tm->tm_hour += 12;
	} else
		tm->tm_hour = ((buf[RTC_HOUR] >> 4) & 0x03) * 10
				+ (buf[RTC_HOUR] & 0x0f);
	tm->tm_min = ((buf[RTC_MIN] >> 4) & 0x7) * 10
			+ (buf[RTC_MIN] & 0x0f);
	tm->tm_sec = ((buf[RTC_SEC] >> 4) & 0x7) * 10
			+ (buf[RTC_SEC] & 0x0f);
	return 0;
}

static int data_calc(unsigned char *buf, struct rtc_time *tm, int len)
{
	unsigned char high, low;

	if (len < TIME_NUM)
		return -EINVAL;

	high = (tm->tm_year + 1900) / 1000;
	low = (tm->tm_year + 1900) / 100;
	low = low - high * 10;
	buf[RTC_YEAR2] = (high << 4) + low;
	high = (tm->tm_year + 1900) / 10;
	low = tm->tm_year + 1900;
	low = low - high * 10;
	high = high - (high / 10) * 10;
	buf[RTC_YEAR1] = (high << 4) + low;
	high = tm->tm_mon / 10;
	low = tm->tm_mon;
	low = low - high * 10;
	buf[RTC_MONTH] = (high << 4) + low;
	high = tm->tm_mday / 10;
	low = tm->tm_mday;
	low = low - high * 10;
	buf[RTC_DATE] = (high << 4) + low;
	buf[RTC_WEEKDAY] = tm->tm_wday;
	high = tm->tm_hour / 10;
	low = tm->tm_hour;
	low = low - high * 10;
	buf[RTC_HOUR] = (high << 4) + low;
	high = tm->tm_min / 10;
	low = tm->tm_min;
	low = low - high * 10;
	buf[RTC_MIN] = (high << 4) + low;
	high = tm->tm_sec / 10;
	low = tm->tm_sec;
	low = low - high * 10;
	buf[RTC_SEC] = (high << 4) + low;
	return 0;
}

static int max8925_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
	struct max8925_rtc_info *info = dev_get_drvdata(dev);
	unsigned char buf[TIME_NUM];
	int ret;

	ret = max8925_bulk_read(info->rtc, MAX8925_RTC_SEC, TIME_NUM, buf);
	if (ret < 0)
		goto out;
	ret = tm_calc(tm, buf, TIME_NUM);
out:
	return ret;
}

static int max8925_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
	struct max8925_rtc_info *info = dev_get_drvdata(dev);
	unsigned char buf[TIME_NUM];
	int ret;

	ret = data_calc(buf, tm, TIME_NUM);
	if (ret < 0)
		goto out;
	ret = max8925_bulk_write(info->rtc, MAX8925_RTC_SEC, TIME_NUM, buf);
out:
	return ret;
}

static int max8925_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	struct max8925_rtc_info *info = dev_get_drvdata(dev);
	unsigned char buf[TIME_NUM];
	int ret;

	ret = max8925_bulk_read(info->rtc, MAX8925_ALARM0_SEC, TIME_NUM, buf);
	if (ret < 0)
		goto out;
	ret = tm_calc(&alrm->time, buf, TIME_NUM);
	if (ret < 0)
		goto out;
	ret = max8925_reg_read(info->rtc, MAX8925_RTC_IRQ_MASK);
	if (ret < 0)
		goto out;
	if ((ret & ALARM0_IRQ) == 0)
		alrm->enabled = 1;
	else
		alrm->enabled = 0;
	ret = max8925_reg_read(info->rtc, MAX8925_RTC_STATUS);
	if (ret < 0)
		goto out;
	if (ret & ALARM0_STATUS)
		alrm->pending = 1;
	else
		alrm->pending = 0;
out:
	return ret;
}

static int max8925_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	struct max8925_rtc_info *info = dev_get_drvdata(dev);
	unsigned char buf[TIME_NUM];
	int ret;

	ret = data_calc(buf, &alrm->time, TIME_NUM);
	if (ret < 0)
		goto out;
	ret = max8925_bulk_write(info->rtc, MAX8925_ALARM0_SEC, TIME_NUM, buf);
	if (ret < 0)
		goto out;
	/* only enable alarm on year/month/day/hour/min/sec */
	ret = max8925_reg_write(info->rtc, MAX8925_ALARM0_CNTL, 0x77);
	if (ret < 0)
		goto out;
out:
	return ret;
}

static const struct rtc_class_ops max8925_rtc_ops = {
	.read_time	= max8925_rtc_read_time,
	.set_time	= max8925_rtc_set_time,
	.read_alarm	= max8925_rtc_read_alarm,
	.set_alarm	= max8925_rtc_set_alarm,
};

static int __devinit max8925_rtc_probe(struct platform_device *pdev)
{
	struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
	struct max8925_rtc_info *info;
	int irq, ret;

	info = kzalloc(sizeof(struct max8925_rtc_info), GFP_KERNEL);
	if (!info)
		return -ENOMEM;
	info->chip = chip;
	info->rtc = chip->rtc;
	info->dev = &pdev->dev;
	irq = chip->irq_base + MAX8925_IRQ_RTC_ALARM0;

	ret = request_threaded_irq(irq, NULL, rtc_update_handler,
				   IRQF_ONESHOT, "rtc-alarm0", info);
	if (ret < 0) {
		dev_err(chip->dev, "Failed to request IRQ: #%d: %d\n",
			irq, ret);
		goto out_irq;
	}

	info->rtc_dev = rtc_device_register("max8925-rtc", &pdev->dev,
					&max8925_rtc_ops, THIS_MODULE);
	ret = PTR_ERR(info->rtc_dev);
	if (IS_ERR(info->rtc_dev)) {
		dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
		goto out_rtc;
	}

	dev_set_drvdata(&pdev->dev, info);
	platform_set_drvdata(pdev, info);

	return 0;
out_rtc:
	free_irq(chip->irq_base + MAX8925_IRQ_RTC_ALARM0, info);
out_irq:
	kfree(info);
	return ret;
}

static int __devexit max8925_rtc_remove(struct platform_device *pdev)
{
	struct max8925_rtc_info *info = platform_get_drvdata(pdev);

	if (info) {
		free_irq(info->chip->irq_base + MAX8925_IRQ_RTC_ALARM0, info);
		rtc_device_unregister(info->rtc_dev);
		kfree(info);
	}
	return 0;
}

static struct platform_driver max8925_rtc_driver = {
	.driver		= {
		.name	= "max8925-rtc",
		.owner	= THIS_MODULE,
	},
	.probe		= max8925_rtc_probe,
	.remove		= __devexit_p(max8925_rtc_remove),
};

static int __init max8925_rtc_init(void)
{
	return platform_driver_register(&max8925_rtc_driver);
}
module_init(max8925_rtc_init);

static void __exit max8925_rtc_exit(void)
{
	platform_driver_unregister(&max8925_rtc_driver);
}
module_exit(max8925_rtc_exit);

MODULE_DESCRIPTION("Maxim MAX8925 RTC driver");
MODULE_AUTHOR("Haojian Zhuang <[email protected]>");
MODULE_LICENSE("GPL");
Commit	Line	Data
a39069f6 HZ	1	/*
	2	* RTC driver for Maxim MAX8925
	3	*
	4	* Copyright (C) 2009-2010 Marvell International Ltd.
	5	* Haojian Zhuang <[email protected]>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*/
	11
	12	#include <linux/module.h>
	13	#include <linux/i2c.h>
5a0e3ad6	14	#include <linux/slab.h>
a39069f6 HZ	15	#include <linux/rtc.h>
	16	#include <linux/platform_device.h>
	17	#include <linux/mfd/max8925.h>
	18
	19	enum {
	20	RTC_SEC = 0,
	21	RTC_MIN,
	22	RTC_HOUR,
	23	RTC_WEEKDAY,
	24	RTC_DATE,
	25	RTC_MONTH,
	26	RTC_YEAR1,
	27	RTC_YEAR2,
	28	};
	29
	30	#define MAX8925_RTC_SEC 0x00
	31	#define MAX8925_RTC_MIN 0x01
	32	#define MAX8925_RTC_HOUR 0x02
	33	#define MAX8925_RTC_WEEKDAY 0x03
	34	#define MAX8925_RTC_DATE 0x04
	35	#define MAX8925_RTC_MONTH 0x05
	36	#define MAX8925_RTC_YEAR1 0x06
	37	#define MAX8925_RTC_YEAR2 0x07
	38	#define MAX8925_ALARM0_SEC 0x08
	39	#define MAX8925_ALARM0_MIN 0x09
	40	#define MAX8925_ALARM0_HOUR 0x0a
	41	#define MAX8925_ALARM0_WEEKDAY 0x0b
	42	#define MAX8925_ALARM0_DATE 0x0c
	43	#define MAX8925_ALARM0_MON 0x0d
	44	#define MAX8925_ALARM0_YEAR1 0x0e
	45	#define MAX8925_ALARM0_YEAR2 0x0f
	46	#define MAX8925_ALARM1_SEC 0x10
	47	#define MAX8925_ALARM1_MIN 0x11
	48	#define MAX8925_ALARM1_HOUR 0x12
	49	#define MAX8925_ALARM1_WEEKDAY 0x13
	50	#define MAX8925_ALARM1_DATE 0x14
	51	#define MAX8925_ALARM1_MON 0x15
	52	#define MAX8925_ALARM1_YEAR1 0x16
	53	#define MAX8925_ALARM1_YEAR2 0x17
	54	#define MAX8925_RTC_CNTL 0x1b
	55	#define MAX8925_RTC_STATUS 0x20
	56
	57	#define TIME_NUM 8
	58	#define ALARM_1SEC (1 << 7)
	59	#define HOUR_12 (1 << 7)
	60	#define HOUR_AM_PM (1 << 5)
	61	#define ALARM0_IRQ (1 << 3)
	62	#define ALARM1_IRQ (1 << 2)
	63	#define ALARM0_STATUS (1 << 2)
	64	#define ALARM1_STATUS (1 << 1)
	65
	66
	67	struct max8925_rtc_info {
	68	struct rtc_device *rtc_dev;
	69	struct max8925_chip *chip;
	70	struct i2c_client *rtc;
	71	struct device *dev;
	72	};
	73
	74	static irqreturn_t rtc_update_handler(int irq, void *data)
	75	{
	76	struct max8925_rtc_info info = (struct max8925_rtc_info )data;
	77
	78	/* disable ALARM0 except for 1SEC alarm */
79	max8925_set_bits(info->rtc, MAX8925_ALARM0_CNTL, 0x7f, 0);
80	rtc_update_irq(info->rtc_dev, 1, RTC_IRQF \| RTC_AF);
81	return IRQ_HANDLED;
82	}
83
84	static int tm_calc(struct rtc_time tm, unsigned char buf, int len)
85	{
86	if (len < TIME_NUM)
87	return -EINVAL;
88	tm->tm_year = (buf[RTC_YEAR2] >> 4) * 1000
89	+ (buf[RTC_YEAR2] & 0xf) * 100
90	+ (buf[RTC_YEAR1] >> 4) * 10
91	+ (buf[RTC_YEAR1] & 0xf);
92	tm->tm_year -= 1900;
93	tm->tm_mon = ((buf[RTC_MONTH] >> 4) & 0x01) * 10
94	+ (buf[RTC_MONTH] & 0x0f);
95	tm->tm_mday = ((buf[RTC_DATE] >> 4) & 0x03) * 10
96	+ (buf[RTC_DATE] & 0x0f);
97	tm->tm_wday = buf[RTC_WEEKDAY] & 0x07;
98	if (buf[RTC_HOUR] & HOUR_12) {
99	tm->tm_hour = ((buf[RTC_HOUR] >> 4) & 0x1) * 10
100	+ (buf[RTC_HOUR] & 0x0f);
101	if (buf[RTC_HOUR] & HOUR_AM_PM)
102	tm->tm_hour += 12;
103	} else
104	tm->tm_hour = ((buf[RTC_HOUR] >> 4) & 0x03) * 10
105	+ (buf[RTC_HOUR] & 0x0f);
106	tm->tm_min = ((buf[RTC_MIN] >> 4) & 0x7) * 10
107	+ (buf[RTC_MIN] & 0x0f);
108	tm->tm_sec = ((buf[RTC_SEC] >> 4) & 0x7) * 10
109	+ (buf[RTC_SEC] & 0x0f);
110	return 0;
111	}
112
113	static int data_calc(unsigned char buf, struct rtc_time tm, int len)
114	{
115	unsigned char high, low;
116
117	if (len < TIME_NUM)
118	return -EINVAL;
119
120	high = (tm->tm_year + 1900) / 1000;
121	low = (tm->tm_year + 1900) / 100;
122	low = low - high * 10;
123	buf[RTC_YEAR2] = (high << 4) + low;
124	high = (tm->tm_year + 1900) / 10;
125	low = tm->tm_year + 1900;
126	low = low - high * 10;
127	high = high - (high / 10) * 10;
128	buf[RTC_YEAR1] = (high << 4) + low;
129	high = tm->tm_mon / 10;
130	low = tm->tm_mon;
131	low = low - high * 10;
132	buf[RTC_MONTH] = (high << 4) + low;
133	high = tm->tm_mday / 10;
134	low = tm->tm_mday;
135	low = low - high * 10;
136	buf[RTC_DATE] = (high << 4) + low;
137	buf[RTC_WEEKDAY] = tm->tm_wday;
138	high = tm->tm_hour / 10;
139	low = tm->tm_hour;
140	low = low - high * 10;
141	buf[RTC_HOUR] = (high << 4) + low;
142	high = tm->tm_min / 10;
143	low = tm->tm_min;
144	low = low - high * 10;
145	buf[RTC_MIN] = (high << 4) + low;
146	high = tm->tm_sec / 10;
147	low = tm->tm_sec;
148	low = low - high * 10;
149	buf[RTC_SEC] = (high << 4) + low;
150	return 0;
151	}
152
153	static int max8925_rtc_read_time(struct device dev, struct rtc_time tm)
154	{
155	struct max8925_rtc_info *info = dev_get_drvdata(dev);
156	unsigned char buf[TIME_NUM];
157	int ret;
158
159	ret = max8925_bulk_read(info->rtc, MAX8925_RTC_SEC, TIME_NUM, buf);
160	if (ret < 0)
161	goto out;
162	ret = tm_calc(tm, buf, TIME_NUM);
163	out:
164	return ret;
165	}
166
167	static int max8925_rtc_set_time(struct device dev, struct rtc_time tm)
168	{
169	struct max8925_rtc_info *info = dev_get_drvdata(dev);
170	unsigned char buf[TIME_NUM];
171	int ret;
172
173	ret = data_calc(buf, tm, TIME_NUM);
174	if (ret < 0)
175	goto out;
176	ret = max8925_bulk_write(info->rtc, MAX8925_RTC_SEC, TIME_NUM, buf);
177	out:
178	return ret;
179	}
180
181	static int max8925_rtc_read_alarm(struct device dev, struct rtc_wkalrm alrm)
182	{
183	struct max8925_rtc_info *info = dev_get_drvdata(dev);
184	unsigned char buf[TIME_NUM];
185	int ret;
186
187	ret = max8925_bulk_read(info->rtc, MAX8925_ALARM0_SEC, TIME_NUM, buf);
188	if (ret < 0)
189	goto out;
190	ret = tm_calc(&alrm->time, buf, TIME_NUM);
191	if (ret < 0)
192	goto out;
193	ret = max8925_reg_read(info->rtc, MAX8925_RTC_IRQ_MASK);
194	if (ret < 0)
195	goto out;
196	if ((ret & ALARM0_IRQ) == 0)
197	alrm->enabled = 1;
198	else
199	alrm->enabled = 0;
200	ret = max8925_reg_read(info->rtc, MAX8925_RTC_STATUS);
201	if (ret < 0)
202	goto out;
203	if (ret & ALARM0_STATUS)
204	alrm->pending = 1;
205	else
206	alrm->pending = 0;
207	out:
208	return ret;
209	}
210
211	static int max8925_rtc_set_alarm(struct device dev, struct rtc_wkalrm alrm)
212	{
213	struct max8925_rtc_info *info = dev_get_drvdata(dev);
214	unsigned char buf[TIME_NUM];
215	int ret;
216
217	ret = data_calc(buf, &alrm->time, TIME_NUM);
218	if (ret < 0)
219	goto out;
220	ret = max8925_bulk_write(info->rtc, MAX8925_ALARM0_SEC, TIME_NUM, buf);
221	if (ret < 0)
222	goto out;
223	/* only enable alarm on year/month/day/hour/min/sec */
224	ret = max8925_reg_write(info->rtc, MAX8925_ALARM0_CNTL, 0x77);
225	if (ret < 0)
226	goto out;
227	out:
228	return ret;
229	}
230
231	static const struct rtc_class_ops max8925_rtc_ops = {
232	.read_time = max8925_rtc_read_time,
233	.set_time = max8925_rtc_set_time,
234	.read_alarm = max8925_rtc_read_alarm,
235	.set_alarm = max8925_rtc_set_alarm,
236	};
237
238	static int __devinit max8925_rtc_probe(struct platform_device *pdev)
239	{
240	struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
241	struct max8925_rtc_info *info;
242	int irq, ret;
243
244	info = kzalloc(sizeof(struct max8925_rtc_info), GFP_KERNEL);
245	if (!info)
246	return -ENOMEM;
247	info->chip = chip;
248	info->rtc = chip->rtc;
249	info->dev = &pdev->dev;
250	irq = chip->irq_base + MAX8925_IRQ_RTC_ALARM0;
251
252	ret = request_threaded_irq(irq, NULL, rtc_update_handler,
253	IRQF_ONESHOT, "rtc-alarm0", info);
254	if (ret < 0) {
255	dev_err(chip->dev, "Failed to request IRQ: #%d: %d\n",
256	irq, ret);
257	goto out_irq;
258	}
259
260	info->rtc_dev = rtc_device_register("max8925-rtc", &pdev->dev,
261	&max8925_rtc_ops, THIS_MODULE);
262	ret = PTR_ERR(info->rtc_dev);
263	if (IS_ERR(info->rtc_dev)) {
264	dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
265	goto out_rtc;
266	}
267
268	dev_set_drvdata(&pdev->dev, info);
269	platform_set_drvdata(pdev, info);
270
271	return 0;
272	out_rtc:
273	free_irq(chip->irq_base + MAX8925_IRQ_RTC_ALARM0, info);
274	out_irq:
275	kfree(info);
276	return ret;
277	}
278
279	static int __devexit max8925_rtc_remove(struct platform_device *pdev)
280	{
281	struct max8925_rtc_info *info = platform_get_drvdata(pdev);
282
283	if (info) {
284	free_irq(info->chip->irq_base + MAX8925_IRQ_RTC_ALARM0, info);
285	rtc_device_unregister(info->rtc_dev);
286	kfree(info);
287	}
288	return 0;
289	}
290
291	static struct platform_driver max8925_rtc_driver = {
292	.driver = {
293	.name = "max8925-rtc",
294	.owner = THIS_MODULE,
295	},
296	.probe = max8925_rtc_probe,
297	.remove = __devexit_p(max8925_rtc_remove),
298	};
299
300	static int __init max8925_rtc_init(void)
301	{
302	return platform_driver_register(&max8925_rtc_driver);
303	}
304	module_init(max8925_rtc_init);
305
306	static void __exit max8925_rtc_exit(void)
307	{
308	platform_driver_unregister(&max8925_rtc_driver);
309	}
310	module_exit(max8925_rtc_exit);
311
312	MODULE_DESCRIPTION("Maxim MAX8925 RTC driver");
313	MODULE_AUTHOR("Haojian Zhuang <[email protected]>");
314	MODULE_LICENSE("GPL");
315