Revert "Merge commit 'main-jb-2012.08.03-B4' into t114-0806"
[linux-2.6.git] / drivers / rtc / rtc-rv3029c2.c
1 /*
2  * Micro Crystal RV-3029C2 rtc class driver
3  *
4  * Author: Gregory Hermant <gregory.hermant@calao-systems.com>
5  *
6  * based on previously existing rtc class drivers
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  *
12  * NOTE: Currently this driver only supports the bare minimum for read
13  * and write the RTC and alarms. The extra features provided by this chip
14  * (trickle charger, eeprom, T° compensation) are unavailable.
15  */
16
17 #include <linux/module.h>
18 #include <linux/i2c.h>
19 #include <linux/bcd.h>
20 #include <linux/rtc.h>
21
22 /* Register map */
23 /* control section */
24 #define RV3029C2_ONOFF_CTRL             0x00
25 #define RV3029C2_IRQ_CTRL               0x01
26 #define RV3029C2_IRQ_CTRL_AIE           (1 << 0)
27 #define RV3029C2_IRQ_FLAGS              0x02
28 #define RV3029C2_IRQ_FLAGS_AF           (1 << 0)
29 #define RV3029C2_STATUS                 0x03
30 #define RV3029C2_STATUS_VLOW1           (1 << 2)
31 #define RV3029C2_STATUS_VLOW2           (1 << 3)
32 #define RV3029C2_STATUS_SR              (1 << 4)
33 #define RV3029C2_STATUS_PON             (1 << 5)
34 #define RV3029C2_STATUS_EEBUSY          (1 << 7)
35 #define RV3029C2_RST_CTRL               0x04
36 #define RV3029C2_CONTROL_SECTION_LEN    0x05
37
38 /* watch section */
39 #define RV3029C2_W_SEC                  0x08
40 #define RV3029C2_W_MINUTES              0x09
41 #define RV3029C2_W_HOURS                0x0A
42 #define RV3029C2_REG_HR_12_24           (1<<6)  /* 24h/12h mode */
43 #define RV3029C2_REG_HR_PM              (1<<5)  /* PM/AM bit in 12h mode */
44 #define RV3029C2_W_DATE                 0x0B
45 #define RV3029C2_W_DAYS                 0x0C
46 #define RV3029C2_W_MONTHS               0x0D
47 #define RV3029C2_W_YEARS                0x0E
48 #define RV3029C2_WATCH_SECTION_LEN      0x07
49
50 /* alarm section */
51 #define RV3029C2_A_SC                   0x10
52 #define RV3029C2_A_MN                   0x11
53 #define RV3029C2_A_HR                   0x12
54 #define RV3029C2_A_DT                   0x13
55 #define RV3029C2_A_DW                   0x14
56 #define RV3029C2_A_MO                   0x15
57 #define RV3029C2_A_YR                   0x16
58 #define RV3029C2_ALARM_SECTION_LEN      0x07
59
60 /* timer section */
61 #define RV3029C2_TIMER_LOW              0x18
62 #define RV3029C2_TIMER_HIGH             0x19
63
64 /* temperature section */
65 #define RV3029C2_TEMP_PAGE              0x20
66
67 /* eeprom data section */
68 #define RV3029C2_E2P_EEDATA1            0x28
69 #define RV3029C2_E2P_EEDATA2            0x29
70
71 /* eeprom control section */
72 #define RV3029C2_CONTROL_E2P_EECTRL     0x30
73 #define RV3029C2_TRICKLE_1K             (1<<0)  /*  1K resistance */
74 #define RV3029C2_TRICKLE_5K             (1<<1)  /*  5K resistance */
75 #define RV3029C2_TRICKLE_20K            (1<<2)  /* 20K resistance */
76 #define RV3029C2_TRICKLE_80K            (1<<3)  /* 80K resistance */
77 #define RV3029C2_CONTROL_E2P_XTALOFFSET 0x31
78 #define RV3029C2_CONTROL_E2P_QCOEF      0x32
79 #define RV3029C2_CONTROL_E2P_TURNOVER   0x33
80
81 /* user ram section */
82 #define RV3029C2_USR1_RAM_PAGE          0x38
83 #define RV3029C2_USR1_SECTION_LEN       0x04
84 #define RV3029C2_USR2_RAM_PAGE          0x3C
85 #define RV3029C2_USR2_SECTION_LEN       0x04
86
87 static int
88 rv3029c2_i2c_read_regs(struct i2c_client *client, u8 reg, u8 *buf,
89         unsigned len)
90 {
91         int ret;
92
93         if ((reg > RV3029C2_USR1_RAM_PAGE + 7) ||
94                 (reg + len > RV3029C2_USR1_RAM_PAGE + 8))
95                 return -EINVAL;
96
97         ret = i2c_smbus_read_i2c_block_data(client, reg, len, buf);
98         if (ret < 0)
99                 return ret;
100         if (ret < len)
101                 return -EIO;
102         return 0;
103 }
104
105 static int
106 rv3029c2_i2c_write_regs(struct i2c_client *client, u8 reg, u8 const buf[],
107                         unsigned len)
108 {
109         if ((reg > RV3029C2_USR1_RAM_PAGE + 7) ||
110                 (reg + len > RV3029C2_USR1_RAM_PAGE + 8))
111                 return -EINVAL;
112
113         return i2c_smbus_write_i2c_block_data(client, reg, len, buf);
114 }
115
116 static int
117 rv3029c2_i2c_get_sr(struct i2c_client *client, u8 *buf)
118 {
119         int ret = rv3029c2_i2c_read_regs(client, RV3029C2_STATUS, buf, 1);
120
121         if (ret < 0)
122                 return -EIO;
123         dev_dbg(&client->dev, "status = 0x%.2x (%d)\n", buf[0], buf[0]);
124         return 0;
125 }
126
127 static int
128 rv3029c2_i2c_set_sr(struct i2c_client *client, u8 val)
129 {
130         u8 buf[1];
131         int sr;
132
133         buf[0] = val;
134         sr = rv3029c2_i2c_write_regs(client, RV3029C2_STATUS, buf, 1);
135         dev_dbg(&client->dev, "status = 0x%.2x (%d)\n", buf[0], buf[0]);
136         if (sr < 0)
137                 return -EIO;
138         return 0;
139 }
140
141 static int
142 rv3029c2_i2c_read_time(struct i2c_client *client, struct rtc_time *tm)
143 {
144         u8 buf[1];
145         int ret;
146         u8 regs[RV3029C2_WATCH_SECTION_LEN] = { 0, };
147
148         ret = rv3029c2_i2c_get_sr(client, buf);
149         if (ret < 0) {
150                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
151                 return -EIO;
152         }
153
154         ret = rv3029c2_i2c_read_regs(client, RV3029C2_W_SEC , regs,
155                                         RV3029C2_WATCH_SECTION_LEN);
156         if (ret < 0) {
157                 dev_err(&client->dev, "%s: reading RTC section failed\n",
158                         __func__);
159                 return ret;
160         }
161
162         tm->tm_sec = bcd2bin(regs[RV3029C2_W_SEC-RV3029C2_W_SEC]);
163         tm->tm_min = bcd2bin(regs[RV3029C2_W_MINUTES-RV3029C2_W_SEC]);
164
165         /* HR field has a more complex interpretation */
166         {
167                 const u8 _hr = regs[RV3029C2_W_HOURS-RV3029C2_W_SEC];
168                 if (_hr & RV3029C2_REG_HR_12_24) {
169                         /* 12h format */
170                         tm->tm_hour = bcd2bin(_hr & 0x1f);
171                         if (_hr & RV3029C2_REG_HR_PM)   /* PM flag set */
172                                 tm->tm_hour += 12;
173                 } else /* 24h format */
174                         tm->tm_hour = bcd2bin(_hr & 0x3f);
175         }
176
177         tm->tm_mday = bcd2bin(regs[RV3029C2_W_DATE-RV3029C2_W_SEC]);
178         tm->tm_mon = bcd2bin(regs[RV3029C2_W_MONTHS-RV3029C2_W_SEC]) - 1;
179         tm->tm_year = bcd2bin(regs[RV3029C2_W_YEARS-RV3029C2_W_SEC]) + 100;
180         tm->tm_wday = bcd2bin(regs[RV3029C2_W_DAYS-RV3029C2_W_SEC]) - 1;
181
182         return 0;
183 }
184
185 static int rv3029c2_rtc_read_time(struct device *dev, struct rtc_time *tm)
186 {
187         return rv3029c2_i2c_read_time(to_i2c_client(dev), tm);
188 }
189
190 static int
191 rv3029c2_i2c_read_alarm(struct i2c_client *client, struct rtc_wkalrm *alarm)
192 {
193         struct rtc_time *const tm = &alarm->time;
194         int ret;
195         u8 regs[8];
196
197         ret = rv3029c2_i2c_get_sr(client, regs);
198         if (ret < 0) {
199                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
200                 return -EIO;
201         }
202
203         ret = rv3029c2_i2c_read_regs(client, RV3029C2_A_SC, regs,
204                                         RV3029C2_ALARM_SECTION_LEN);
205
206         if (ret < 0) {
207                 dev_err(&client->dev, "%s: reading alarm section failed\n",
208                         __func__);
209                 return ret;
210         }
211
212         tm->tm_sec = bcd2bin(regs[RV3029C2_A_SC-RV3029C2_A_SC] & 0x7f);
213         tm->tm_min = bcd2bin(regs[RV3029C2_A_MN-RV3029C2_A_SC] & 0x7f);
214         tm->tm_hour = bcd2bin(regs[RV3029C2_A_HR-RV3029C2_A_SC] & 0x3f);
215         tm->tm_mday = bcd2bin(regs[RV3029C2_A_DT-RV3029C2_A_SC] & 0x3f);
216         tm->tm_mon = bcd2bin(regs[RV3029C2_A_MO-RV3029C2_A_SC] & 0x1f) - 1;
217         tm->tm_year = bcd2bin(regs[RV3029C2_A_YR-RV3029C2_A_SC] & 0x7f) + 100;
218         tm->tm_wday = bcd2bin(regs[RV3029C2_A_DW-RV3029C2_A_SC] & 0x07) - 1;
219
220         return 0;
221 }
222
223 static int
224 rv3029c2_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
225 {
226         return rv3029c2_i2c_read_alarm(to_i2c_client(dev), alarm);
227 }
228
229 static int rv3029c2_rtc_i2c_alarm_set_irq(struct i2c_client *client,
230                                         int enable)
231 {
232         int ret;
233         u8 buf[1];
234
235         /* enable AIE irq */
236         ret = rv3029c2_i2c_read_regs(client, RV3029C2_IRQ_CTRL, buf, 1);
237         if (ret < 0) {
238                 dev_err(&client->dev, "can't read INT reg\n");
239                 return ret;
240         }
241         if (enable)
242                 buf[0] |= RV3029C2_IRQ_CTRL_AIE;
243         else
244                 buf[0] &= ~RV3029C2_IRQ_CTRL_AIE;
245
246         ret = rv3029c2_i2c_write_regs(client, RV3029C2_IRQ_CTRL, buf, 1);
247         if (ret < 0) {
248                 dev_err(&client->dev, "can't set INT reg\n");
249                 return ret;
250         }
251
252         return 0;
253 }
254
255 static int rv3029c2_rtc_i2c_set_alarm(struct i2c_client *client,
256                                         struct rtc_wkalrm *alarm)
257 {
258         struct rtc_time *const tm = &alarm->time;
259         int ret;
260         u8 regs[8];
261
262         /*
263          * The clock has an 8 bit wide bcd-coded register (they never learn)
264          * for the year. tm_year is an offset from 1900 and we are interested
265          * in the 2000-2099 range, so any value less than 100 is invalid.
266         */
267         if (tm->tm_year < 100)
268                 return -EINVAL;
269
270         ret = rv3029c2_i2c_get_sr(client, regs);
271         if (ret < 0) {
272                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
273                 return -EIO;
274         }
275         regs[RV3029C2_A_SC-RV3029C2_A_SC] = bin2bcd(tm->tm_sec & 0x7f);
276         regs[RV3029C2_A_MN-RV3029C2_A_SC] = bin2bcd(tm->tm_min & 0x7f);
277         regs[RV3029C2_A_HR-RV3029C2_A_SC] = bin2bcd(tm->tm_hour & 0x3f);
278         regs[RV3029C2_A_DT-RV3029C2_A_SC] = bin2bcd(tm->tm_mday & 0x3f);
279         regs[RV3029C2_A_MO-RV3029C2_A_SC] = bin2bcd((tm->tm_mon & 0x1f) - 1);
280         regs[RV3029C2_A_DW-RV3029C2_A_SC] = bin2bcd((tm->tm_wday & 7) - 1);
281         regs[RV3029C2_A_YR-RV3029C2_A_SC] = bin2bcd((tm->tm_year & 0x7f) - 100);
282
283         ret = rv3029c2_i2c_write_regs(client, RV3029C2_A_SC, regs,
284                                         RV3029C2_ALARM_SECTION_LEN);
285         if (ret < 0)
286                 return ret;
287
288         if (alarm->enabled) {
289                 u8 buf[1];
290
291                 /* clear AF flag */
292                 ret = rv3029c2_i2c_read_regs(client, RV3029C2_IRQ_FLAGS,
293                                                 buf, 1);
294                 if (ret < 0) {
295                         dev_err(&client->dev, "can't read alarm flag\n");
296                         return ret;
297                 }
298                 buf[0] &= ~RV3029C2_IRQ_FLAGS_AF;
299                 ret = rv3029c2_i2c_write_regs(client, RV3029C2_IRQ_FLAGS,
300                                                 buf, 1);
301                 if (ret < 0) {
302                         dev_err(&client->dev, "can't set alarm flag\n");
303                         return ret;
304                 }
305                 /* enable AIE irq */
306                 ret = rv3029c2_rtc_i2c_alarm_set_irq(client, 1);
307                 if (ret)
308                         return ret;
309
310                 dev_dbg(&client->dev, "alarm IRQ armed\n");
311         } else {
312                 /* disable AIE irq */
313                 ret = rv3029c2_rtc_i2c_alarm_set_irq(client, 1);
314                 if (ret)
315                         return ret;
316
317                 dev_dbg(&client->dev, "alarm IRQ disabled\n");
318         }
319
320         return 0;
321 }
322
323 static int rv3029c2_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
324 {
325         return rv3029c2_rtc_i2c_set_alarm(to_i2c_client(dev), alarm);
326 }
327
328 static int
329 rv3029c2_i2c_set_time(struct i2c_client *client, struct rtc_time const *tm)
330 {
331         u8 regs[8];
332         int ret;
333
334         /*
335          * The clock has an 8 bit wide bcd-coded register (they never learn)
336          * for the year. tm_year is an offset from 1900 and we are interested
337          * in the 2000-2099 range, so any value less than 100 is invalid.
338         */
339         if (tm->tm_year < 100)
340                 return -EINVAL;
341
342         regs[RV3029C2_W_SEC-RV3029C2_W_SEC] = bin2bcd(tm->tm_sec);
343         regs[RV3029C2_W_MINUTES-RV3029C2_W_SEC] = bin2bcd(tm->tm_min);
344         regs[RV3029C2_W_HOURS-RV3029C2_W_SEC] = bin2bcd(tm->tm_hour);
345         regs[RV3029C2_W_DATE-RV3029C2_W_SEC] = bin2bcd(tm->tm_mday);
346         regs[RV3029C2_W_MONTHS-RV3029C2_W_SEC] = bin2bcd(tm->tm_mon+1);
347         regs[RV3029C2_W_DAYS-RV3029C2_W_SEC] = bin2bcd((tm->tm_wday & 7)+1);
348         regs[RV3029C2_W_YEARS-RV3029C2_W_SEC] = bin2bcd(tm->tm_year - 100);
349
350         ret = rv3029c2_i2c_write_regs(client, RV3029C2_W_SEC, regs,
351                                         RV3029C2_WATCH_SECTION_LEN);
352         if (ret < 0)
353                 return ret;
354
355         ret = rv3029c2_i2c_get_sr(client, regs);
356         if (ret < 0) {
357                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
358                 return ret;
359         }
360         /* clear PON bit */
361         ret = rv3029c2_i2c_set_sr(client, (regs[0] & ~RV3029C2_STATUS_PON));
362         if (ret < 0) {
363                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
364                 return ret;
365         }
366
367         return 0;
368 }
369
370 static int rv3029c2_rtc_set_time(struct device *dev, struct rtc_time *tm)
371 {
372         return rv3029c2_i2c_set_time(to_i2c_client(dev), tm);
373 }
374
375 static const struct rtc_class_ops rv3029c2_rtc_ops = {
376         .read_time      = rv3029c2_rtc_read_time,
377         .set_time       = rv3029c2_rtc_set_time,
378         .read_alarm     = rv3029c2_rtc_read_alarm,
379         .set_alarm      = rv3029c2_rtc_set_alarm,
380 };
381
382 static struct i2c_device_id rv3029c2_id[] = {
383         { "rv3029c2", 0 },
384         { }
385 };
386 MODULE_DEVICE_TABLE(i2c, rv3029c2_id);
387
388 static int __devinit
389 rv3029c2_probe(struct i2c_client *client, const struct i2c_device_id *id)
390 {
391         struct rtc_device *rtc;
392         int rc = 0;
393         u8 buf[1];
394
395         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_EMUL))
396                 return -ENODEV;
397
398         rtc = rtc_device_register(client->name,
399                                 &client->dev, &rv3029c2_rtc_ops,
400                                 THIS_MODULE);
401
402         if (IS_ERR(rtc))
403                 return PTR_ERR(rtc);
404
405         i2c_set_clientdata(client, rtc);
406
407         rc = rv3029c2_i2c_get_sr(client, buf);
408         if (rc < 0) {
409                 dev_err(&client->dev, "reading status failed\n");
410                 goto exit_unregister;
411         }
412
413         return 0;
414
415 exit_unregister:
416         rtc_device_unregister(rtc);
417
418         return rc;
419 }
420
421 static int __devexit rv3029c2_remove(struct i2c_client *client)
422 {
423         struct rtc_device *rtc = i2c_get_clientdata(client);
424
425         rtc_device_unregister(rtc);
426
427         return 0;
428 }
429
430 static struct i2c_driver rv3029c2_driver = {
431         .driver = {
432                 .name = "rtc-rv3029c2",
433         },
434         .probe = rv3029c2_probe,
435         .remove = __devexit_p(rv3029c2_remove),
436         .id_table = rv3029c2_id,
437 };
438
439 module_i2c_driver(rv3029c2_driver);
440
441 MODULE_AUTHOR("Gregory Hermant <gregory.hermant@calao-systems.com>");
442 MODULE_DESCRIPTION("Micro Crystal RV3029C2 RTC driver");
443 MODULE_LICENSE("GPL");