[net-next-2.6.git] / drivers / rtc / rtc-ds3232.c

/*
 * RTC client/driver for the Maxim/Dallas DS3232 Real-Time Clock over I2C
 *
 * Copyright (C) 2009-2010 Freescale Semiconductor.
 *
 * This program is free software; you can redistribute  it and/or modify it
 * under  the terms of  the GNU General  Public License as published by the
 * Free Software Foundation;  either version 2 of the  License, or (at your
 * option) any later version.
 */
/*
 * It would be more efficient to use i2c msgs/i2c_transfer directly but, as
 * recommened in .../Documentation/i2c/writing-clients section
 * "Sending and receiving", using SMBus level communication is preferred.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/i2c.h>
#include <linux/rtc.h>
#include <linux/bcd.h>
#include <linux/workqueue.h>
#include <linux/slab.h>

#define DS3232_REG_SECONDS	0x00
#define DS3232_REG_MINUTES	0x01
#define DS3232_REG_HOURS	0x02
#define DS3232_REG_AMPM		0x02
#define DS3232_REG_DAY		0x03
#define DS3232_REG_DATE		0x04
#define DS3232_REG_MONTH	0x05
#define DS3232_REG_CENTURY	0x05
#define DS3232_REG_YEAR		0x06
#define DS3232_REG_ALARM1         0x07	/* Alarm 1 BASE */
#define DS3232_REG_ALARM2         0x0B	/* Alarm 2 BASE */
#define DS3232_REG_CR		0x0E	/* Control register */
#	define DS3232_REG_CR_nEOSC        0x80
#       define DS3232_REG_CR_INTCN        0x04
#       define DS3232_REG_CR_A2IE        0x02
#       define DS3232_REG_CR_A1IE        0x01

#define DS3232_REG_SR	0x0F	/* control/status register */
#	define DS3232_REG_SR_OSF   0x80
#       define DS3232_REG_SR_BSY   0x04
#       define DS3232_REG_SR_A2F   0x02
#       define DS3232_REG_SR_A1F   0x01

struct ds3232 {
	struct i2c_client *client;
	struct rtc_device *rtc;
	struct work_struct work;

	/* The mutex protects alarm operations, and prevents a race
	 * between the enable_irq() in the workqueue and the free_irq()
	 * in the remove function.
	 */
	struct mutex mutex;
	int exiting;
};

static struct i2c_driver ds3232_driver;

static int ds3232_check_rtc_status(struct i2c_client *client)
{
	int ret = 0;
	int control, stat;

	stat = i2c_smbus_read_byte_data(client, DS3232_REG_SR);
	if (stat < 0)
		return stat;

	if (stat & DS3232_REG_SR_OSF)
		dev_warn(&client->dev,
				"oscillator discontinuity flagged, "
				"time unreliable\n");

	stat &= ~(DS3232_REG_SR_OSF | DS3232_REG_SR_A1F | DS3232_REG_SR_A2F);

	ret = i2c_smbus_write_byte_data(client, DS3232_REG_SR, stat);
	if (ret < 0)
		return ret;

	/* If the alarm is pending, clear it before requesting
	 * the interrupt, so an interrupt event isn't reported
	 * before everything is initialized.
	 */

	control = i2c_smbus_read_byte_data(client, DS3232_REG_CR);
	if (control < 0)
		return control;

	control &= ~(DS3232_REG_CR_A1IE | DS3232_REG_CR_A2IE);
	control |= DS3232_REG_CR_INTCN;

	return i2c_smbus_write_byte_data(client, DS3232_REG_CR, control);
}

static int ds3232_read_time(struct device *dev, struct rtc_time *time)
{
	struct i2c_client *client = to_i2c_client(dev);
	int ret;
	u8 buf[7];
	unsigned int year, month, day, hour, minute, second;
	unsigned int week, twelve_hr, am_pm;
	unsigned int century, add_century = 0;

	ret = i2c_smbus_read_i2c_block_data(client, DS3232_REG_SECONDS, 7, buf);

	if (ret < 0)
		return ret;
	if (ret < 7)
		return -EIO;

	second = buf[0];
	minute = buf[1];
	hour = buf[2];
	week = buf[3];
	day = buf[4];
	month = buf[5];
	year = buf[6];

	/* Extract additional information for AM/PM and century */

	twelve_hr = hour & 0x40;
	am_pm = hour & 0x20;
	century = month & 0x80;

	/* Write to rtc_time structure */

	time->tm_sec = bcd2bin(second);
	time->tm_min = bcd2bin(minute);
	if (twelve_hr) {
		/* Convert to 24 hr */
		if (am_pm)
			time->tm_hour = bcd2bin(hour & 0x1F) + 12;
		else
			time->tm_hour = bcd2bin(hour & 0x1F);
	} else {
		time->tm_hour = bcd2bin(hour);
	}

	time->tm_wday = bcd2bin(week);
	time->tm_mday = bcd2bin(day);
	time->tm_mon = bcd2bin(month & 0x7F);
	if (century)
		add_century = 100;

	time->tm_year = bcd2bin(year) + add_century;

	return rtc_valid_tm(time);
}

static int ds3232_set_time(struct device *dev, struct rtc_time *time)
{
	struct i2c_client *client = to_i2c_client(dev);
	u8 buf[7];

	/* Extract time from rtc_time and load into ds3232*/

	buf[0] = bin2bcd(time->tm_sec);
	buf[1] = bin2bcd(time->tm_min);
	buf[2] = bin2bcd(time->tm_hour);
	buf[3] = bin2bcd(time->tm_wday); /* Day of the week */
	buf[4] = bin2bcd(time->tm_mday); /* Date */
	buf[5] = bin2bcd(time->tm_mon);
	if (time->tm_year >= 100) {
		buf[5] |= 0x80;
		buf[6] = bin2bcd(time->tm_year - 100);
	} else {
		buf[6] = bin2bcd(time->tm_year);
	}

	return i2c_smbus_write_i2c_block_data(client,
					      DS3232_REG_SECONDS, 7, buf);
}

static irqreturn_t ds3232_irq(int irq, void *dev_id)
{
	struct i2c_client *client = dev_id;
	struct ds3232 *ds3232 = i2c_get_clientdata(client);

	disable_irq_nosync(irq);
	schedule_work(&ds3232->work);
	return IRQ_HANDLED;
}

static void ds3232_work(struct work_struct *work)
{
	struct ds3232 *ds3232 = container_of(work, struct ds3232, work);
	struct i2c_client *client = ds3232->client;
	int stat, control;

	mutex_lock(&ds3232->mutex);

	stat = i2c_smbus_read_byte_data(client, DS3232_REG_SR);
	if (stat < 0)
		goto unlock;

	if (stat & DS3232_REG_SR_A1F) {
		control = i2c_smbus_read_byte_data(client, DS3232_REG_CR);
		if (control < 0)
			goto out;
		/* disable alarm1 interrupt */
		control &= ~(DS3232_REG_CR_A1IE);
		i2c_smbus_write_byte_data(client, DS3232_REG_CR, control);

		/* clear the alarm pend flag */
		stat &= ~DS3232_REG_SR_A1F;
		i2c_smbus_write_byte_data(client, DS3232_REG_SR, stat);

		rtc_update_irq(ds3232->rtc, 1, RTC_AF | RTC_IRQF);
	}

out:
	if (!ds3232->exiting)
		enable_irq(client->irq);
unlock:
	mutex_unlock(&ds3232->mutex);
}

static const struct rtc_class_ops ds3232_rtc_ops = {
	.read_time = ds3232_read_time,
	.set_time = ds3232_set_time,
};

static int __devinit ds3232_probe(struct i2c_client *client,
		const struct i2c_device_id *id)
{
	struct ds3232 *ds3232;
	int ret;

	ds3232 = kzalloc(sizeof(struct ds3232), GFP_KERNEL);
	if (!ds3232)
		return -ENOMEM;

	ds3232->client = client;
	i2c_set_clientdata(client, ds3232);

	INIT_WORK(&ds3232->work, ds3232_work);
	mutex_init(&ds3232->mutex);

	ret = ds3232_check_rtc_status(client);
	if (ret)
		goto out_free;

	ds3232->rtc = rtc_device_register(client->name, &client->dev,
					  &ds3232_rtc_ops, THIS_MODULE);
	if (IS_ERR(ds3232->rtc)) {
		ret = PTR_ERR(ds3232->rtc);
		dev_err(&client->dev, "unable to register the class device\n");
		goto out_irq;
	}

	if (client->irq >= 0) {
		ret = request_irq(client->irq, ds3232_irq, 0,
				 "ds3232", client);
		if (ret) {
			dev_err(&client->dev, "unable to request IRQ\n");
			goto out_free;
		}
	}

	return 0;

out_irq:
	if (client->irq >= 0)
		free_irq(client->irq, client);

out_free:
	kfree(ds3232);
	return ret;
}

static int __devexit ds3232_remove(struct i2c_client *client)
{
	struct ds3232 *ds3232 = i2c_get_clientdata(client);

	if (client->irq >= 0) {
		mutex_lock(&ds3232->mutex);
		ds3232->exiting = 1;
		mutex_unlock(&ds3232->mutex);

		free_irq(client->irq, client);
		flush_scheduled_work();
	}

	rtc_device_unregister(ds3232->rtc);
	kfree(ds3232);
	return 0;
}

static const struct i2c_device_id ds3232_id[] = {
	{ "ds3232", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, ds3232_id);

static struct i2c_driver ds3232_driver = {
	.driver = {
		.name = "rtc-ds3232",
		.owner = THIS_MODULE,
	},
	.probe = ds3232_probe,
	.remove = __devexit_p(ds3232_remove),
	.id_table = ds3232_id,
};

static int __init ds3232_init(void)
{
	return i2c_add_driver(&ds3232_driver);
}

static void __exit ds3232_exit(void)
{
	i2c_del_driver(&ds3232_driver);
}

module_init(ds3232_init);
module_exit(ds3232_exit);

MODULE_AUTHOR("Srikanth Srinivasan <srikanth.srinivasan@freescale.com>");
MODULE_DESCRIPTION("Maxim/Dallas DS3232 RTC Driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
c03675f0 RZ	1	/*
	2	* RTC client/driver for the Maxim/Dallas DS3232 Real-Time Clock over I2C
	3	*
	4	* Copyright (C) 2009-2010 Freescale Semiconductor.
	5	*
	6	* This program is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License as published by the
	8	* Free Software Foundation; either version 2 of the License, or (at your
	9	* option) any later version.
	10	*/
	11	/*
	12	* It would be more efficient to use i2c msgs/i2c_transfer directly but, as
	13	* recommened in .../Documentation/i2c/writing-clients section
	14	* "Sending and receiving", using SMBus level communication is preferred.
	15	*/
	16
	17	#include <linux/kernel.h>
	18	#include <linux/module.h>
	19	#include <linux/interrupt.h>
	20	#include <linux/i2c.h>
	21	#include <linux/rtc.h>
	22	#include <linux/bcd.h>
	23	#include <linux/workqueue.h>
	24	#include <linux/slab.h>
	25
	26	#define DS3232_REG_SECONDS 0x00
	27	#define DS3232_REG_MINUTES 0x01
	28	#define DS3232_REG_HOURS 0x02
	29	#define DS3232_REG_AMPM 0x02
	30	#define DS3232_REG_DAY 0x03
	31	#define DS3232_REG_DATE 0x04
	32	#define DS3232_REG_MONTH 0x05
	33	#define DS3232_REG_CENTURY 0x05
	34	#define DS3232_REG_YEAR 0x06
	35	#define DS3232_REG_ALARM1 0x07 /* Alarm 1 BASE */
	36	#define DS3232_REG_ALARM2 0x0B /* Alarm 2 BASE */
	37	#define DS3232_REG_CR 0x0E /* Control register */
	38	# define DS3232_REG_CR_nEOSC 0x80
	39	# define DS3232_REG_CR_INTCN 0x04
	40	# define DS3232_REG_CR_A2IE 0x02
	41	# define DS3232_REG_CR_A1IE 0x01
	42
	43	#define DS3232_REG_SR 0x0F /* control/status register */
	44	# define DS3232_REG_SR_OSF 0x80
	45	# define DS3232_REG_SR_BSY 0x04
	46	# define DS3232_REG_SR_A2F 0x02
	47	# define DS3232_REG_SR_A1F 0x01
	48
	49	struct ds3232 {
	50	struct i2c_client *client;
	51	struct rtc_device *rtc;
	52	struct work_struct work;
	53
	54	/* The mutex protects alarm operations, and prevents a race
	55	* between the enable_irq() in the workqueue and the free_irq()
	56	* in the remove function.
	57	*/
	58	struct mutex mutex;
	59	int exiting;
	60	};
	61
	62	static struct i2c_driver ds3232_driver;
	63
	64	static int ds3232_check_rtc_status(struct i2c_client *client)
65	{
66	int ret = 0;
67	int control, stat;
68
69	stat = i2c_smbus_read_byte_data(client, DS3232_REG_SR);
70	if (stat < 0)
71	return stat;
72
73	if (stat & DS3232_REG_SR_OSF)
74	dev_warn(&client->dev,
75	"oscillator discontinuity flagged, "
76	"time unreliable\n");
77
78	stat &= ~(DS3232_REG_SR_OSF \| DS3232_REG_SR_A1F \| DS3232_REG_SR_A2F);
79
80	ret = i2c_smbus_write_byte_data(client, DS3232_REG_SR, stat);
81	if (ret < 0)
82	return ret;
83
84	/* If the alarm is pending, clear it before requesting
85	* the interrupt, so an interrupt event isn't reported
86	* before everything is initialized.
87	*/
88
89	control = i2c_smbus_read_byte_data(client, DS3232_REG_CR);
90	if (control < 0)
91	return control;
92
93	control &= ~(DS3232_REG_CR_A1IE \| DS3232_REG_CR_A2IE);
94	control \|= DS3232_REG_CR_INTCN;
95
96	return i2c_smbus_write_byte_data(client, DS3232_REG_CR, control);
97	}
98
99	static int ds3232_read_time(struct device dev, struct rtc_time time)
100	{
101	struct i2c_client *client = to_i2c_client(dev);
102	int ret;
103	u8 buf[7];
104	unsigned int year, month, day, hour, minute, second;
105	unsigned int week, twelve_hr, am_pm;
106	unsigned int century, add_century = 0;
107
108	ret = i2c_smbus_read_i2c_block_data(client, DS3232_REG_SECONDS, 7, buf);
109
110	if (ret < 0)
111	return ret;
112	if (ret < 7)
113	return -EIO;
114
115	second = buf[0];
116	minute = buf[1];
117	hour = buf[2];
118	week = buf[3];
119	day = buf[4];
120	month = buf[5];
121	year = buf[6];
122
123	/* Extract additional information for AM/PM and century */
124
125	twelve_hr = hour & 0x40;
126	am_pm = hour & 0x20;
127	century = month & 0x80;
128
129	/* Write to rtc_time structure */
130
131	time->tm_sec = bcd2bin(second);
132	time->tm_min = bcd2bin(minute);
133	if (twelve_hr) {
134	/* Convert to 24 hr */
135	if (am_pm)
136	time->tm_hour = bcd2bin(hour & 0x1F) + 12;
137	else
138	time->tm_hour = bcd2bin(hour & 0x1F);
139	} else {
140	time->tm_hour = bcd2bin(hour);
141	}
142
143	time->tm_wday = bcd2bin(week);
144	time->tm_mday = bcd2bin(day);
145	time->tm_mon = bcd2bin(month & 0x7F);
146	if (century)
147	add_century = 100;
148
149	time->tm_year = bcd2bin(year) + add_century;
150
151	return rtc_valid_tm(time);
152	}
153
154	static int ds3232_set_time(struct device dev, struct rtc_time time)
155	{
156	struct i2c_client *client = to_i2c_client(dev);
157	u8 buf[7];
158
159	/* Extract time from rtc_time and load into ds3232*/
160
161	buf[0] = bin2bcd(time->tm_sec);
162	buf[1] = bin2bcd(time->tm_min);
163	buf[2] = bin2bcd(time->tm_hour);
164	buf[3] = bin2bcd(time->tm_wday); /* Day of the week */
165	buf[4] = bin2bcd(time->tm_mday); /* Date */
166	buf[5] = bin2bcd(time->tm_mon);
167	if (time->tm_year >= 100) {
168	buf[5] \|= 0x80;
169	buf[6] = bin2bcd(time->tm_year - 100);
170	} else {
171	buf[6] = bin2bcd(time->tm_year);
172	}
173
174	return i2c_smbus_write_i2c_block_data(client,
175	DS3232_REG_SECONDS, 7, buf);
176	}
177
178	static irqreturn_t ds3232_irq(int irq, void *dev_id)
179	{
180	struct i2c_client *client = dev_id;
181	struct ds3232 *ds3232 = i2c_get_clientdata(client);
182
183	disable_irq_nosync(irq);
184	schedule_work(&ds3232->work);
185	return IRQ_HANDLED;
186	}
187
188	static void ds3232_work(struct work_struct *work)
189	{
190	struct ds3232 *ds3232 = container_of(work, struct ds3232, work);
191	struct i2c_client *client = ds3232->client;
192	int stat, control;
193
194	mutex_lock(&ds3232->mutex);
195
196	stat = i2c_smbus_read_byte_data(client, DS3232_REG_SR);
197	if (stat < 0)
198	goto unlock;
199
200	if (stat & DS3232_REG_SR_A1F) {
201	control = i2c_smbus_read_byte_data(client, DS3232_REG_CR);
202	if (control < 0)
203	goto out;
204	/* disable alarm1 interrupt */
205	control &= ~(DS3232_REG_CR_A1IE);
206	i2c_smbus_write_byte_data(client, DS3232_REG_CR, control);
207
208	/* clear the alarm pend flag */
209	stat &= ~DS3232_REG_SR_A1F;
210	i2c_smbus_write_byte_data(client, DS3232_REG_SR, stat);
211
212	rtc_update_irq(ds3232->rtc, 1, RTC_AF \| RTC_IRQF);
213	}
214
215	out:
216	if (!ds3232->exiting)
217	enable_irq(client->irq);
218	unlock:
219	mutex_unlock(&ds3232->mutex);
220	}
221
222	static const struct rtc_class_ops ds3232_rtc_ops = {
223	.read_time = ds3232_read_time,
224	.set_time = ds3232_set_time,
225	};
226
227	static int __devinit ds3232_probe(struct i2c_client *client,
228	const struct i2c_device_id *id)
229	{
230	struct ds3232 *ds3232;
231	int ret;
232
233	ds3232 = kzalloc(sizeof(struct ds3232), GFP_KERNEL);
234	if (!ds3232)
235	return -ENOMEM;
236
237	ds3232->client = client;
238	i2c_set_clientdata(client, ds3232);
239
240	INIT_WORK(&ds3232->work, ds3232_work);
241	mutex_init(&ds3232->mutex);
242
243	ret = ds3232_check_rtc_status(client);
244	if (ret)
245	goto out_free;
246
247	ds3232->rtc = rtc_device_register(client->name, &client->dev,
248	&ds3232_rtc_ops, THIS_MODULE);
249	if (IS_ERR(ds3232->rtc)) {
250	ret = PTR_ERR(ds3232->rtc);
251	dev_err(&client->dev, "unable to register the class device\n");
252	goto out_irq;
253	}
254
255	if (client->irq >= 0) {
256	ret = request_irq(client->irq, ds3232_irq, 0,
257	"ds3232", client);
258	if (ret) {
259	dev_err(&client->dev, "unable to request IRQ\n");
260	goto out_free;
261	}
262	}
263
264	return 0;
265
266	out_irq:
267	if (client->irq >= 0)
268	free_irq(client->irq, client);
269
270	out_free:
c03675f0 RZ	271	kfree(ds3232);
	272	return ret;
	273	}
	274
	275	static int __devexit ds3232_remove(struct i2c_client *client)
	276	{
	277	struct ds3232 *ds3232 = i2c_get_clientdata(client);
	278
	279	if (client->irq >= 0) {
	280	mutex_lock(&ds3232->mutex);
	281	ds3232->exiting = 1;
	282	mutex_unlock(&ds3232->mutex);
	283
	284	free_irq(client->irq, client);
	285	flush_scheduled_work();
	286	}
	287
	288	rtc_device_unregister(ds3232->rtc);
c03675f0 RZ	289	kfree(ds3232);
	290	return 0;
	291	}
	292
	293	static const struct i2c_device_id ds3232_id[] = {
	294	{ "ds3232", 0 },
	295	{ }
	296	};
	297	MODULE_DEVICE_TABLE(i2c, ds3232_id);
	298
	299	static struct i2c_driver ds3232_driver = {
	300	.driver = {
	301	.name = "rtc-ds3232",
	302	.owner = THIS_MODULE,
	303	},
	304	.probe = ds3232_probe,
	305	.remove = __devexit_p(ds3232_remove),
	306	.id_table = ds3232_id,
	307	};
	308
	309	static int __init ds3232_init(void)
	310	{
	311	return i2c_add_driver(&ds3232_driver);
	312	}
	313
	314	static void __exit ds3232_exit(void)
	315	{
	316	i2c_del_driver(&ds3232_driver);
	317	}
	318
	319	module_init(ds3232_init);
	320	module_exit(ds3232_exit);
	321
	322	MODULE_AUTHOR("Srikanth Srinivasan <srikanth.srinivasan@freescale.com>");
	323	MODULE_DESCRIPTION("Maxim/Dallas DS3232 RTC Driver");
	324	MODULE_LICENSE("GPL");