rtc-ds1374.c revision bc96ba7414ca4456661d0873856e0f363d32ba67 
1/*
2 * RTC client/driver for the Maxim/Dallas DS1374 Real-Time Clock over I2C
3 *
4 * Based on code by Randy Vinson <rvinson@mvista.com>,
5 * which was based on the m41t00.c by Mark Greer <mgreer@mvista.com>.
6 *
7 * Copyright (C) 2006-2007 Freescale Semiconductor
8 *
9 * 2005 (c) MontaVista Software, Inc. This file is licensed under
10 * the terms of the GNU General Public License version 2. This program
11 * is licensed "as is" without any warranty of any kind, whether express
12 * or implied.
13 */
14/*
15 * It would be more efficient to use i2c msgs/i2c_transfer directly but, as
16 * recommened in .../Documentation/i2c/writing-clients section
17 * "Sending and receiving", using SMBus level communication is preferred.
18 */
19
20#include <linux/kernel.h>
21#include <linux/module.h>
22#include <linux/interrupt.h>
23#include <linux/i2c.h>
24#include <linux/rtc.h>
25#include <linux/bcd.h>
26#include <linux/workqueue.h>
27#include <linux/slab.h>
28#include <linux/pm.h>
29
30#define DS1374_REG_TOD0		0x00 /* Time of Day */
31#define DS1374_REG_TOD1		0x01
32#define DS1374_REG_TOD2		0x02
33#define DS1374_REG_TOD3		0x03
34#define DS1374_REG_WDALM0	0x04 /* Watchdog/Alarm */
35#define DS1374_REG_WDALM1	0x05
36#define DS1374_REG_WDALM2	0x06
37#define DS1374_REG_CR		0x07 /* Control */
38#define DS1374_REG_CR_AIE	0x01 /* Alarm Int. Enable */
39#define DS1374_REG_CR_WDALM	0x20 /* 1=Watchdog, 0=Alarm */
40#define DS1374_REG_CR_WACE	0x40 /* WD/Alarm counter enable */
41#define DS1374_REG_SR		0x08 /* Status */
42#define DS1374_REG_SR_OSF	0x80 /* Oscillator Stop Flag */
43#define DS1374_REG_SR_AF	0x01 /* Alarm Flag */
44#define DS1374_REG_TCR		0x09 /* Trickle Charge */
45
46static const struct i2c_device_id ds1374_id[] = {
47	{ "ds1374", 0 },
48	{ }
49};
50MODULE_DEVICE_TABLE(i2c, ds1374_id);
51
52struct ds1374 {
53	struct i2c_client *client;
54	struct rtc_device *rtc;
55	struct work_struct work;
56
57	/* The mutex protects alarm operations, and prevents a race
58	 * between the enable_irq() in the workqueue and the free_irq()
59	 * in the remove function.
60	 */
61	struct mutex mutex;
62	int exiting;
63};
64
65static struct i2c_driver ds1374_driver;
66
67static int ds1374_read_rtc(struct i2c_client *client, u32 *time,
68                           int reg, int nbytes)
69{
70	u8 buf[4];
71	int ret;
72	int i;
73
74	if (nbytes > 4) {
75		WARN_ON(1);
76		return -EINVAL;
77	}
78
79	ret = i2c_smbus_read_i2c_block_data(client, reg, nbytes, buf);
80
81	if (ret < 0)
82		return ret;
83	if (ret < nbytes)
84		return -EIO;
85
86	for (i = nbytes - 1, *time = 0; i >= 0; i--)
87		*time = (*time << 8) | buf[i];
88
89	return 0;
90}
91
92static int ds1374_write_rtc(struct i2c_client *client, u32 time,
93                            int reg, int nbytes)
94{
95	u8 buf[4];
96	int i;
97
98	if (nbytes > 4) {
99		WARN_ON(1);
100		return -EINVAL;
101	}
102
103	for (i = 0; i < nbytes; i++) {
104		buf[i] = time & 0xff;
105		time >>= 8;
106	}
107
108	return i2c_smbus_write_i2c_block_data(client, reg, nbytes, buf);
109}
110
111static int ds1374_check_rtc_status(struct i2c_client *client)
112{
113	int ret = 0;
114	int control, stat;
115
116	stat = i2c_smbus_read_byte_data(client, DS1374_REG_SR);
117	if (stat < 0)
118		return stat;
119
120	if (stat & DS1374_REG_SR_OSF)
121		dev_warn(&client->dev,
122		         "oscillator discontinuity flagged, "
123		         "time unreliable\n");
124
125	stat &= ~(DS1374_REG_SR_OSF | DS1374_REG_SR_AF);
126
127	ret = i2c_smbus_write_byte_data(client, DS1374_REG_SR, stat);
128	if (ret < 0)
129		return ret;
130
131	/* If the alarm is pending, clear it before requesting
132	 * the interrupt, so an interrupt event isn't reported
133	 * before everything is initialized.
134	 */
135
136	control = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
137	if (control < 0)
138		return control;
139
140	control &= ~(DS1374_REG_CR_WACE | DS1374_REG_CR_AIE);
141	return i2c_smbus_write_byte_data(client, DS1374_REG_CR, control);
142}
143
144static int ds1374_read_time(struct device *dev, struct rtc_time *time)
145{
146	struct i2c_client *client = to_i2c_client(dev);
147	u32 itime;
148	int ret;
149
150	ret = ds1374_read_rtc(client, &itime, DS1374_REG_TOD0, 4);
151	if (!ret)
152		rtc_time_to_tm(itime, time);
153
154	return ret;
155}
156
157static int ds1374_set_time(struct device *dev, struct rtc_time *time)
158{
159	struct i2c_client *client = to_i2c_client(dev);
160	unsigned long itime;
161
162	rtc_tm_to_time(time, &itime);
163	return ds1374_write_rtc(client, itime, DS1374_REG_TOD0, 4);
164}
165
166/* The ds1374 has a decrementer for an alarm, rather than a comparator.
167 * If the time of day is changed, then the alarm will need to be
168 * reset.
169 */
170static int ds1374_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
171{
172	struct i2c_client *client = to_i2c_client(dev);
173	struct ds1374 *ds1374 = i2c_get_clientdata(client);
174	u32 now, cur_alarm;
175	int cr, sr;
176	int ret = 0;
177
178	if (client->irq <= 0)
179		return -EINVAL;
180
181	mutex_lock(&ds1374->mutex);
182
183	cr = ret = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
184	if (ret < 0)
185		goto out;
186
187	sr = ret = i2c_smbus_read_byte_data(client, DS1374_REG_SR);
188	if (ret < 0)
189		goto out;
190
191	ret = ds1374_read_rtc(client, &now, DS1374_REG_TOD0, 4);
192	if (ret)
193		goto out;
194
195	ret = ds1374_read_rtc(client, &cur_alarm, DS1374_REG_WDALM0, 3);
196	if (ret)
197		goto out;
198
199	rtc_time_to_tm(now + cur_alarm, &alarm->time);
200	alarm->enabled = !!(cr & DS1374_REG_CR_WACE);
201	alarm->pending = !!(sr & DS1374_REG_SR_AF);
202
203out:
204	mutex_unlock(&ds1374->mutex);
205	return ret;
206}
207
208static int ds1374_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
209{
210	struct i2c_client *client = to_i2c_client(dev);
211	struct ds1374 *ds1374 = i2c_get_clientdata(client);
212	struct rtc_time now;
213	unsigned long new_alarm, itime;
214	int cr;
215	int ret = 0;
216
217	if (client->irq <= 0)
218		return -EINVAL;
219
220	ret = ds1374_read_time(dev, &now);
221	if (ret < 0)
222		return ret;
223
224	rtc_tm_to_time(&alarm->time, &new_alarm);
225	rtc_tm_to_time(&now, &itime);
226
227	/* This can happen due to races, in addition to dates that are
228	 * truly in the past.  To avoid requiring the caller to check for
229	 * races, dates in the past are assumed to be in the recent past
230	 * (i.e. not something that we'd rather the caller know about via
231	 * an error), and the alarm is set to go off as soon as possible.
232	 */
233	if (time_before_eq(new_alarm, itime))
234		new_alarm = 1;
235	else
236		new_alarm -= itime;
237
238	mutex_lock(&ds1374->mutex);
239
240	ret = cr = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
241	if (ret < 0)
242		goto out;
243
244	/* Disable any existing alarm before setting the new one
245	 * (or lack thereof). */
246	cr &= ~DS1374_REG_CR_WACE;
247
248	ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, cr);
249	if (ret < 0)
250		goto out;
251
252	ret = ds1374_write_rtc(client, new_alarm, DS1374_REG_WDALM0, 3);
253	if (ret)
254		goto out;
255
256	if (alarm->enabled) {
257		cr |= DS1374_REG_CR_WACE | DS1374_REG_CR_AIE;
258		cr &= ~DS1374_REG_CR_WDALM;
259
260		ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, cr);
261	}
262
263out:
264	mutex_unlock(&ds1374->mutex);
265	return ret;
266}
267
268static irqreturn_t ds1374_irq(int irq, void *dev_id)
269{
270	struct i2c_client *client = dev_id;
271	struct ds1374 *ds1374 = i2c_get_clientdata(client);
272
273	disable_irq_nosync(irq);
274	schedule_work(&ds1374->work);
275	return IRQ_HANDLED;
276}
277
278static void ds1374_work(struct work_struct *work)
279{
280	struct ds1374 *ds1374 = container_of(work, struct ds1374, work);
281	struct i2c_client *client = ds1374->client;
282	int stat, control;
283
284	mutex_lock(&ds1374->mutex);
285
286	stat = i2c_smbus_read_byte_data(client, DS1374_REG_SR);
287	if (stat < 0)
288		goto unlock;
289
290	if (stat & DS1374_REG_SR_AF) {
291		stat &= ~DS1374_REG_SR_AF;
292		i2c_smbus_write_byte_data(client, DS1374_REG_SR, stat);
293
294		control = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
295		if (control < 0)
296			goto out;
297
298		control &= ~(DS1374_REG_CR_WACE | DS1374_REG_CR_AIE);
299		i2c_smbus_write_byte_data(client, DS1374_REG_CR, control);
300
301		rtc_update_irq(ds1374->rtc, 1, RTC_AF | RTC_IRQF);
302	}
303
304out:
305	if (!ds1374->exiting)
306		enable_irq(client->irq);
307unlock:
308	mutex_unlock(&ds1374->mutex);
309}
310
311static int ds1374_alarm_irq_enable(struct device *dev, unsigned int enabled)
312{
313	struct i2c_client *client = to_i2c_client(dev);
314	struct ds1374 *ds1374 = i2c_get_clientdata(client);
315	int ret;
316
317	mutex_lock(&ds1374->mutex);
318
319	ret = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
320	if (ret < 0)
321		goto out;
322
323	if (enabled) {
324		ret |= DS1374_REG_CR_WACE | DS1374_REG_CR_AIE;
325		ret &= ~DS1374_REG_CR_WDALM;
326	} else {
327		ret &= ~DS1374_REG_CR_WACE;
328	}
329	ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, ret);
330
331out:
332	mutex_unlock(&ds1374->mutex);
333	return ret;
334}
335
336static const struct rtc_class_ops ds1374_rtc_ops = {
337	.read_time = ds1374_read_time,
338	.set_time = ds1374_set_time,
339	.read_alarm = ds1374_read_alarm,
340	.set_alarm = ds1374_set_alarm,
341	.alarm_irq_enable = ds1374_alarm_irq_enable,
342};
343
344static int ds1374_probe(struct i2c_client *client,
345			const struct i2c_device_id *id)
346{
347	struct ds1374 *ds1374;
348	int ret;
349
350	ds1374 = kzalloc(sizeof(struct ds1374), GFP_KERNEL);
351	if (!ds1374)
352		return -ENOMEM;
353
354	ds1374->client = client;
355	i2c_set_clientdata(client, ds1374);
356
357	INIT_WORK(&ds1374->work, ds1374_work);
358	mutex_init(&ds1374->mutex);
359
360	ret = ds1374_check_rtc_status(client);
361	if (ret)
362		goto out_free;
363
364	if (client->irq > 0) {
365		ret = request_irq(client->irq, ds1374_irq, 0,
366		                  "ds1374", client);
367		if (ret) {
368			dev_err(&client->dev, "unable to request IRQ\n");
369			goto out_free;
370		}
371
372		device_set_wakeup_capable(&client->dev, 1);
373	}
374
375	ds1374->rtc = rtc_device_register(client->name, &client->dev,
376	                                  &ds1374_rtc_ops, THIS_MODULE);
377	if (IS_ERR(ds1374->rtc)) {
378		ret = PTR_ERR(ds1374->rtc);
379		dev_err(&client->dev, "unable to register the class device\n");
380		goto out_irq;
381	}
382
383	return 0;
384
385out_irq:
386	if (client->irq > 0)
387		free_irq(client->irq, client);
388
389out_free:
390	kfree(ds1374);
391	return ret;
392}
393
394static int __devexit ds1374_remove(struct i2c_client *client)
395{
396	struct ds1374 *ds1374 = i2c_get_clientdata(client);
397
398	if (client->irq > 0) {
399		mutex_lock(&ds1374->mutex);
400		ds1374->exiting = 1;
401		mutex_unlock(&ds1374->mutex);
402
403		free_irq(client->irq, client);
404		cancel_work_sync(&ds1374->work);
405	}
406
407	rtc_device_unregister(ds1374->rtc);
408	kfree(ds1374);
409	return 0;
410}
411
412#ifdef CONFIG_PM
413static int ds1374_suspend(struct device *dev)
414{
415	struct i2c_client *client = to_i2c_client(dev);
416
417	if (client->irq >= 0 && device_may_wakeup(&client->dev))
418		enable_irq_wake(client->irq);
419	return 0;
420}
421
422static int ds1374_resume(struct device *dev)
423{
424	struct i2c_client *client = to_i2c_client(dev);
425
426	if (client->irq >= 0 && device_may_wakeup(&client->dev))
427		disable_irq_wake(client->irq);
428	return 0;
429}
430
431static SIMPLE_DEV_PM_OPS(ds1374_pm, ds1374_suspend, ds1374_resume);
432
433#define DS1374_PM (&ds1374_pm)
434#else
435#define DS1374_PM NULL
436#endif
437
438static struct i2c_driver ds1374_driver = {
439	.driver = {
440		.name = "rtc-ds1374",
441		.owner = THIS_MODULE,
442		.pm = DS1374_PM,
443	},
444	.probe = ds1374_probe,
445	.remove = __devexit_p(ds1374_remove),
446	.id_table = ds1374_id,
447};
448
449static int __init ds1374_init(void)
450{
451	return i2c_add_driver(&ds1374_driver);
452}
453
454static void __exit ds1374_exit(void)
455{
456	i2c_del_driver(&ds1374_driver);
457}
458
459module_init(ds1374_init);
460module_exit(ds1374_exit);
461
462MODULE_AUTHOR("Scott Wood <scottwood@freescale.com>");
463MODULE_DESCRIPTION("Maxim/Dallas DS1374 RTC Driver");
464MODULE_LICENSE("GPL");
465