rtc: don't use flush_scheduled_work()
[linux-2.6.git] / drivers / rtc / rtc-ds3232.c
1 /*
2  * RTC client/driver for the Maxim/Dallas DS3232 Real-Time Clock over I2C
3  *
4  * Copyright (C) 2009-2010 Freescale Semiconductor.
5  * Author: Jack Lan <jack.lan@freescale.com>
6  *
7  * This program is free software; you can redistribute  it and/or modify it
8  * under  the terms of  the GNU General  Public License as published by the
9  * Free Software Foundation;  either version 2 of the  License, or (at your
10  * option) any later version.
11  */
12 /*
13  * It would be more efficient to use i2c msgs/i2c_transfer directly but, as
14  * recommened in .../Documentation/i2c/writing-clients section
15  * "Sending and receiving", using SMBus level communication is preferred.
16  */
17
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/interrupt.h>
21 #include <linux/i2c.h>
22 #include <linux/rtc.h>
23 #include <linux/bcd.h>
24 #include <linux/workqueue.h>
25 #include <linux/slab.h>
26
27 #define DS3232_REG_SECONDS      0x00
28 #define DS3232_REG_MINUTES      0x01
29 #define DS3232_REG_HOURS        0x02
30 #define DS3232_REG_AMPM         0x02
31 #define DS3232_REG_DAY          0x03
32 #define DS3232_REG_DATE         0x04
33 #define DS3232_REG_MONTH        0x05
34 #define DS3232_REG_CENTURY      0x05
35 #define DS3232_REG_YEAR         0x06
36 #define DS3232_REG_ALARM1         0x07  /* Alarm 1 BASE */
37 #define DS3232_REG_ALARM2         0x0B  /* Alarm 2 BASE */
38 #define DS3232_REG_CR           0x0E    /* Control register */
39 #       define DS3232_REG_CR_nEOSC        0x80
40 #       define DS3232_REG_CR_INTCN        0x04
41 #       define DS3232_REG_CR_A2IE        0x02
42 #       define DS3232_REG_CR_A1IE        0x01
43
44 #define DS3232_REG_SR   0x0F    /* control/status register */
45 #       define DS3232_REG_SR_OSF   0x80
46 #       define DS3232_REG_SR_BSY   0x04
47 #       define DS3232_REG_SR_A2F   0x02
48 #       define DS3232_REG_SR_A1F   0x01
49
50 struct ds3232 {
51         struct i2c_client *client;
52         struct rtc_device *rtc;
53         struct work_struct work;
54
55         /* The mutex protects alarm operations, and prevents a race
56          * between the enable_irq() in the workqueue and the free_irq()
57          * in the remove function.
58          */
59         struct mutex mutex;
60         int exiting;
61 };
62
63 static struct i2c_driver ds3232_driver;
64
65 static int ds3232_check_rtc_status(struct i2c_client *client)
66 {
67         int ret = 0;
68         int control, stat;
69
70         stat = i2c_smbus_read_byte_data(client, DS3232_REG_SR);
71         if (stat < 0)
72                 return stat;
73
74         if (stat & DS3232_REG_SR_OSF)
75                 dev_warn(&client->dev,
76                                 "oscillator discontinuity flagged, "
77                                 "time unreliable\n");
78
79         stat &= ~(DS3232_REG_SR_OSF | DS3232_REG_SR_A1F | DS3232_REG_SR_A2F);
80
81         ret = i2c_smbus_write_byte_data(client, DS3232_REG_SR, stat);
82         if (ret < 0)
83                 return ret;
84
85         /* If the alarm is pending, clear it before requesting
86          * the interrupt, so an interrupt event isn't reported
87          * before everything is initialized.
88          */
89
90         control = i2c_smbus_read_byte_data(client, DS3232_REG_CR);
91         if (control < 0)
92                 return control;
93
94         control &= ~(DS3232_REG_CR_A1IE | DS3232_REG_CR_A2IE);
95         control |= DS3232_REG_CR_INTCN;
96
97         return i2c_smbus_write_byte_data(client, DS3232_REG_CR, control);
98 }
99
100 static int ds3232_read_time(struct device *dev, struct rtc_time *time)
101 {
102         struct i2c_client *client = to_i2c_client(dev);
103         int ret;
104         u8 buf[7];
105         unsigned int year, month, day, hour, minute, second;
106         unsigned int week, twelve_hr, am_pm;
107         unsigned int century, add_century = 0;
108
109         ret = i2c_smbus_read_i2c_block_data(client, DS3232_REG_SECONDS, 7, buf);
110
111         if (ret < 0)
112                 return ret;
113         if (ret < 7)
114                 return -EIO;
115
116         second = buf[0];
117         minute = buf[1];
118         hour = buf[2];
119         week = buf[3];
120         day = buf[4];
121         month = buf[5];
122         year = buf[6];
123
124         /* Extract additional information for AM/PM and century */
125
126         twelve_hr = hour & 0x40;
127         am_pm = hour & 0x20;
128         century = month & 0x80;
129
130         /* Write to rtc_time structure */
131
132         time->tm_sec = bcd2bin(second);
133         time->tm_min = bcd2bin(minute);
134         if (twelve_hr) {
135                 /* Convert to 24 hr */
136                 if (am_pm)
137                         time->tm_hour = bcd2bin(hour & 0x1F) + 12;
138                 else
139                         time->tm_hour = bcd2bin(hour & 0x1F);
140         } else {
141                 time->tm_hour = bcd2bin(hour);
142         }
143
144         time->tm_wday = bcd2bin(week);
145         time->tm_mday = bcd2bin(day);
146         time->tm_mon = bcd2bin(month & 0x7F);
147         if (century)
148                 add_century = 100;
149
150         time->tm_year = bcd2bin(year) + add_century;
151
152         return rtc_valid_tm(time);
153 }
154
155 static int ds3232_set_time(struct device *dev, struct rtc_time *time)
156 {
157         struct i2c_client *client = to_i2c_client(dev);
158         u8 buf[7];
159
160         /* Extract time from rtc_time and load into ds3232*/
161
162         buf[0] = bin2bcd(time->tm_sec);
163         buf[1] = bin2bcd(time->tm_min);
164         buf[2] = bin2bcd(time->tm_hour);
165         buf[3] = bin2bcd(time->tm_wday); /* Day of the week */
166         buf[4] = bin2bcd(time->tm_mday); /* Date */
167         buf[5] = bin2bcd(time->tm_mon);
168         if (time->tm_year >= 100) {
169                 buf[5] |= 0x80;
170                 buf[6] = bin2bcd(time->tm_year - 100);
171         } else {
172                 buf[6] = bin2bcd(time->tm_year);
173         }
174
175         return i2c_smbus_write_i2c_block_data(client,
176                                               DS3232_REG_SECONDS, 7, buf);
177 }
178
179 /*
180  * DS3232 has two alarm, we only use alarm1
181  * According to linux specification, only support one-shot alarm
182  * no periodic alarm mode
183  */
184 static int ds3232_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
185 {
186         struct i2c_client *client = to_i2c_client(dev);
187         struct ds3232 *ds3232 = i2c_get_clientdata(client);
188         int control, stat;
189         int ret;
190         u8 buf[4];
191
192         mutex_lock(&ds3232->mutex);
193
194         ret = i2c_smbus_read_byte_data(client, DS3232_REG_SR);
195         if (ret < 0)
196                 goto out;
197         stat = ret;
198         ret = i2c_smbus_read_byte_data(client, DS3232_REG_CR);
199         if (ret < 0)
200                 goto out;
201         control = ret;
202         ret = i2c_smbus_read_i2c_block_data(client, DS3232_REG_ALARM1, 4, buf);
203         if (ret < 0)
204                 goto out;
205
206         alarm->time.tm_sec = bcd2bin(buf[0] & 0x7F);
207         alarm->time.tm_min = bcd2bin(buf[1] & 0x7F);
208         alarm->time.tm_hour = bcd2bin(buf[2] & 0x7F);
209         alarm->time.tm_mday = bcd2bin(buf[3] & 0x7F);
210
211         alarm->time.tm_mon = -1;
212         alarm->time.tm_year = -1;
213         alarm->time.tm_wday = -1;
214         alarm->time.tm_yday = -1;
215         alarm->time.tm_isdst = -1;
216
217         alarm->enabled = !!(control & DS3232_REG_CR_A1IE);
218         alarm->pending = !!(stat & DS3232_REG_SR_A1F);
219
220         ret = 0;
221 out:
222         mutex_unlock(&ds3232->mutex);
223         return ret;
224 }
225
226 /*
227  * linux rtc-module does not support wday alarm
228  * and only 24h time mode supported indeed
229  */
230 static int ds3232_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
231 {
232         struct i2c_client *client = to_i2c_client(dev);
233         struct ds3232 *ds3232 = i2c_get_clientdata(client);
234         int control, stat;
235         int ret;
236         u8 buf[4];
237
238         if (client->irq <= 0)
239                 return -EINVAL;
240
241         mutex_lock(&ds3232->mutex);
242
243         buf[0] = bin2bcd(alarm->time.tm_sec);
244         buf[1] = bin2bcd(alarm->time.tm_min);
245         buf[2] = bin2bcd(alarm->time.tm_hour);
246         buf[3] = bin2bcd(alarm->time.tm_mday);
247
248         /* clear alarm interrupt enable bit */
249         ret = i2c_smbus_read_byte_data(client, DS3232_REG_CR);
250         if (ret < 0)
251                 goto out;
252         control = ret;
253         control &= ~(DS3232_REG_CR_A1IE | DS3232_REG_CR_A2IE);
254         ret = i2c_smbus_write_byte_data(client, DS3232_REG_CR, control);
255         if (ret < 0)
256                 goto out;
257
258         /* clear any pending alarm flag */
259         ret = i2c_smbus_read_byte_data(client, DS3232_REG_SR);
260         if (ret < 0)
261                 goto out;
262         stat = ret;
263         stat &= ~(DS3232_REG_SR_A1F | DS3232_REG_SR_A2F);
264         ret = i2c_smbus_write_byte_data(client, DS3232_REG_SR, stat);
265         if (ret < 0)
266                 goto out;
267
268         ret = i2c_smbus_write_i2c_block_data(client, DS3232_REG_ALARM1, 4, buf);
269
270         if (alarm->enabled) {
271                 control |= DS3232_REG_CR_A1IE;
272                 ret = i2c_smbus_write_byte_data(client, DS3232_REG_CR, control);
273         }
274 out:
275         mutex_unlock(&ds3232->mutex);
276         return ret;
277 }
278
279 static void ds3232_update_alarm(struct i2c_client *client)
280 {
281         struct ds3232 *ds3232 = i2c_get_clientdata(client);
282         int control;
283         int ret;
284         u8 buf[4];
285
286         mutex_lock(&ds3232->mutex);
287
288         ret = i2c_smbus_read_i2c_block_data(client, DS3232_REG_ALARM1, 4, buf);
289         if (ret < 0)
290                 goto unlock;
291
292         buf[0] = bcd2bin(buf[0]) < 0 || (ds3232->rtc->irq_data & RTC_UF) ?
293                                                                 0x80 : buf[0];
294         buf[1] = bcd2bin(buf[1]) < 0 || (ds3232->rtc->irq_data & RTC_UF) ?
295                                                                 0x80 : buf[1];
296         buf[2] = bcd2bin(buf[2]) < 0 || (ds3232->rtc->irq_data & RTC_UF) ?
297                                                                 0x80 : buf[2];
298         buf[3] = bcd2bin(buf[3]) < 0 || (ds3232->rtc->irq_data & RTC_UF) ?
299                                                                 0x80 : buf[3];
300
301         ret = i2c_smbus_write_i2c_block_data(client, DS3232_REG_ALARM1, 4, buf);
302         if (ret < 0)
303                 goto unlock;
304
305         control = i2c_smbus_read_byte_data(client, DS3232_REG_CR);
306         if (control < 0)
307                 goto unlock;
308
309         if (ds3232->rtc->irq_data & (RTC_AF | RTC_UF))
310                 /* enable alarm1 interrupt */
311                 control |= DS3232_REG_CR_A1IE;
312         else
313                 /* disable alarm1 interrupt */
314                 control &= ~(DS3232_REG_CR_A1IE);
315         i2c_smbus_write_byte_data(client, DS3232_REG_CR, control);
316
317 unlock:
318         mutex_unlock(&ds3232->mutex);
319 }
320
321 static int ds3232_alarm_irq_enable(struct device *dev, unsigned int enabled)
322 {
323         struct i2c_client *client = to_i2c_client(dev);
324         struct ds3232 *ds3232 = i2c_get_clientdata(client);
325
326         if (client->irq <= 0)
327                 return -EINVAL;
328
329         if (enabled)
330                 ds3232->rtc->irq_data |= RTC_AF;
331         else
332                 ds3232->rtc->irq_data &= ~RTC_AF;
333
334         ds3232_update_alarm(client);
335         return 0;
336 }
337
338 static int ds3232_update_irq_enable(struct device *dev, unsigned int enabled)
339 {
340         struct i2c_client *client = to_i2c_client(dev);
341         struct ds3232 *ds3232 = i2c_get_clientdata(client);
342
343         if (client->irq <= 0)
344                 return -EINVAL;
345
346         if (enabled)
347                 ds3232->rtc->irq_data |= RTC_UF;
348         else
349                 ds3232->rtc->irq_data &= ~RTC_UF;
350
351         ds3232_update_alarm(client);
352         return 0;
353 }
354
355 static irqreturn_t ds3232_irq(int irq, void *dev_id)
356 {
357         struct i2c_client *client = dev_id;
358         struct ds3232 *ds3232 = i2c_get_clientdata(client);
359
360         disable_irq_nosync(irq);
361         schedule_work(&ds3232->work);
362         return IRQ_HANDLED;
363 }
364
365 static void ds3232_work(struct work_struct *work)
366 {
367         struct ds3232 *ds3232 = container_of(work, struct ds3232, work);
368         struct i2c_client *client = ds3232->client;
369         int stat, control;
370
371         mutex_lock(&ds3232->mutex);
372
373         stat = i2c_smbus_read_byte_data(client, DS3232_REG_SR);
374         if (stat < 0)
375                 goto unlock;
376
377         if (stat & DS3232_REG_SR_A1F) {
378                 control = i2c_smbus_read_byte_data(client, DS3232_REG_CR);
379                 if (control < 0)
380                         goto out;
381                 /* disable alarm1 interrupt */
382                 control &= ~(DS3232_REG_CR_A1IE);
383                 i2c_smbus_write_byte_data(client, DS3232_REG_CR, control);
384
385                 /* clear the alarm pend flag */
386                 stat &= ~DS3232_REG_SR_A1F;
387                 i2c_smbus_write_byte_data(client, DS3232_REG_SR, stat);
388
389                 rtc_update_irq(ds3232->rtc, 1, RTC_AF | RTC_IRQF);
390         }
391
392 out:
393         if (!ds3232->exiting)
394                 enable_irq(client->irq);
395 unlock:
396         mutex_unlock(&ds3232->mutex);
397 }
398
399 static const struct rtc_class_ops ds3232_rtc_ops = {
400         .read_time = ds3232_read_time,
401         .set_time = ds3232_set_time,
402         .read_alarm = ds3232_read_alarm,
403         .set_alarm = ds3232_set_alarm,
404         .alarm_irq_enable = ds3232_alarm_irq_enable,
405         .update_irq_enable = ds3232_update_irq_enable,
406 };
407
408 static int __devinit ds3232_probe(struct i2c_client *client,
409                 const struct i2c_device_id *id)
410 {
411         struct ds3232 *ds3232;
412         int ret;
413
414         ds3232 = kzalloc(sizeof(struct ds3232), GFP_KERNEL);
415         if (!ds3232)
416                 return -ENOMEM;
417
418         ds3232->client = client;
419         i2c_set_clientdata(client, ds3232);
420
421         INIT_WORK(&ds3232->work, ds3232_work);
422         mutex_init(&ds3232->mutex);
423
424         ret = ds3232_check_rtc_status(client);
425         if (ret)
426                 goto out_free;
427
428         ds3232->rtc = rtc_device_register(client->name, &client->dev,
429                                           &ds3232_rtc_ops, THIS_MODULE);
430         if (IS_ERR(ds3232->rtc)) {
431                 ret = PTR_ERR(ds3232->rtc);
432                 dev_err(&client->dev, "unable to register the class device\n");
433                 goto out_irq;
434         }
435
436         if (client->irq >= 0) {
437                 ret = request_irq(client->irq, ds3232_irq, 0,
438                                  "ds3232", client);
439                 if (ret) {
440                         dev_err(&client->dev, "unable to request IRQ\n");
441                         goto out_free;
442                 }
443         }
444
445         return 0;
446
447 out_irq:
448         if (client->irq >= 0)
449                 free_irq(client->irq, client);
450
451 out_free:
452         kfree(ds3232);
453         return ret;
454 }
455
456 static int __devexit ds3232_remove(struct i2c_client *client)
457 {
458         struct ds3232 *ds3232 = i2c_get_clientdata(client);
459
460         if (client->irq >= 0) {
461                 mutex_lock(&ds3232->mutex);
462                 ds3232->exiting = 1;
463                 mutex_unlock(&ds3232->mutex);
464
465                 free_irq(client->irq, client);
466                 cancel_work_sync(&ds3232->work);
467         }
468
469         rtc_device_unregister(ds3232->rtc);
470         kfree(ds3232);
471         return 0;
472 }
473
474 static const struct i2c_device_id ds3232_id[] = {
475         { "ds3232", 0 },
476         { }
477 };
478 MODULE_DEVICE_TABLE(i2c, ds3232_id);
479
480 static struct i2c_driver ds3232_driver = {
481         .driver = {
482                 .name = "rtc-ds3232",
483                 .owner = THIS_MODULE,
484         },
485         .probe = ds3232_probe,
486         .remove = __devexit_p(ds3232_remove),
487         .id_table = ds3232_id,
488 };
489
490 static int __init ds3232_init(void)
491 {
492         return i2c_add_driver(&ds3232_driver);
493 }
494
495 static void __exit ds3232_exit(void)
496 {
497         i2c_del_driver(&ds3232_driver);
498 }
499
500 module_init(ds3232_init);
501 module_exit(ds3232_exit);
502
503 MODULE_AUTHOR("Srikanth Srinivasan <srikanth.srinivasan@freescale.com>");
504 MODULE_DESCRIPTION("Maxim/Dallas DS3232 RTC Driver");
505 MODULE_LICENSE("GPL");