rtc: Add max77660 rtc driver
[linux-3.10.git] / drivers / rtc / rtc-fm3130.c
1 /*
2  * rtc-fm3130.c - RTC driver for Ramtron FM3130 I2C chip.
3  *
4  *  Copyright (C) 2008 Sergey Lapin
5  *  Based on ds1307 driver by James Chapman and David Brownell
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>
14 #include <linux/rtc.h>
15 #include <linux/bcd.h>
16 #include <linux/slab.h>
17
18 #define FM3130_RTC_CONTROL      (0x0)
19 #define FM3130_CAL_CONTROL      (0x1)
20 #define FM3130_RTC_SECONDS      (0x2)
21 #define FM3130_RTC_MINUTES      (0x3)
22 #define FM3130_RTC_HOURS        (0x4)
23 #define FM3130_RTC_DAY          (0x5)
24 #define FM3130_RTC_DATE         (0x6)
25 #define FM3130_RTC_MONTHS       (0x7)
26 #define FM3130_RTC_YEARS        (0x8)
27
28 #define FM3130_ALARM_SECONDS    (0x9)
29 #define FM3130_ALARM_MINUTES    (0xa)
30 #define FM3130_ALARM_HOURS      (0xb)
31 #define FM3130_ALARM_DATE       (0xc)
32 #define FM3130_ALARM_MONTHS     (0xd)
33 #define FM3130_ALARM_WP_CONTROL (0xe)
34
35 #define FM3130_CAL_CONTROL_BIT_nOSCEN (1 << 7) /* Osciallator enabled */
36 #define FM3130_RTC_CONTROL_BIT_LB (1 << 7) /* Low battery */
37 #define FM3130_RTC_CONTROL_BIT_AF (1 << 6) /* Alarm flag */
38 #define FM3130_RTC_CONTROL_BIT_CF (1 << 5) /* Century overflow */
39 #define FM3130_RTC_CONTROL_BIT_POR (1 << 4) /* Power on reset */
40 #define FM3130_RTC_CONTROL_BIT_AEN (1 << 3) /* Alarm enable */
41 #define FM3130_RTC_CONTROL_BIT_CAL (1 << 2) /* Calibration mode */
42 #define FM3130_RTC_CONTROL_BIT_WRITE (1 << 1) /* W=1 -> write mode W=0 normal */
43 #define FM3130_RTC_CONTROL_BIT_READ (1 << 0) /* R=1 -> read mode R=0 normal */
44
45 #define FM3130_CLOCK_REGS 7
46 #define FM3130_ALARM_REGS 5
47
48 struct fm3130 {
49         u8                      reg_addr_time;
50         u8                      reg_addr_alarm;
51         u8                      regs[15];
52         struct i2c_msg          msg[4];
53         struct i2c_client       *client;
54         struct rtc_device       *rtc;
55         int                     alarm_valid;
56         int                     data_valid;
57 };
58 static const struct i2c_device_id fm3130_id[] = {
59         { "fm3130", 0 },
60         { }
61 };
62 MODULE_DEVICE_TABLE(i2c, fm3130_id);
63
64 #define FM3130_MODE_NORMAL              0
65 #define FM3130_MODE_WRITE               1
66 #define FM3130_MODE_READ                2
67
68 static void fm3130_rtc_mode(struct device *dev, int mode)
69 {
70         struct fm3130 *fm3130 = dev_get_drvdata(dev);
71
72         fm3130->regs[FM3130_RTC_CONTROL] =
73                 i2c_smbus_read_byte_data(fm3130->client, FM3130_RTC_CONTROL);
74         switch (mode) {
75         case FM3130_MODE_NORMAL:
76                 fm3130->regs[FM3130_RTC_CONTROL] &=
77                         ~(FM3130_RTC_CONTROL_BIT_WRITE |
78                         FM3130_RTC_CONTROL_BIT_READ);
79                 break;
80         case FM3130_MODE_WRITE:
81                 fm3130->regs[FM3130_RTC_CONTROL] |= FM3130_RTC_CONTROL_BIT_WRITE;
82                 break;
83         case FM3130_MODE_READ:
84                 fm3130->regs[FM3130_RTC_CONTROL] |= FM3130_RTC_CONTROL_BIT_READ;
85                 break;
86         default:
87                 dev_dbg(dev, "invalid mode %d\n", mode);
88                 break;
89         }
90
91         i2c_smbus_write_byte_data(fm3130->client,
92                  FM3130_RTC_CONTROL, fm3130->regs[FM3130_RTC_CONTROL]);
93 }
94
95 static int fm3130_get_time(struct device *dev, struct rtc_time *t)
96 {
97         struct fm3130 *fm3130 = dev_get_drvdata(dev);
98         int             tmp;
99
100         if (!fm3130->data_valid) {
101                 /* We have invalid data in RTC, probably due
102                 to battery faults or other problems. Return EIO
103                 for now, it will allow us to set data later instead
104                 of error during probing which disables device */
105                 return -EIO;
106         }
107         fm3130_rtc_mode(dev, FM3130_MODE_READ);
108
109         /* read the RTC date and time registers all at once */
110         tmp = i2c_transfer(to_i2c_adapter(fm3130->client->dev.parent),
111                         fm3130->msg, 2);
112         if (tmp != 2) {
113                 dev_err(dev, "%s error %d\n", "read", tmp);
114                 return -EIO;
115         }
116
117         fm3130_rtc_mode(dev, FM3130_MODE_NORMAL);
118
119         dev_dbg(dev, "%s: %15ph\n", "read", fm3130->regs);
120
121         t->tm_sec = bcd2bin(fm3130->regs[FM3130_RTC_SECONDS] & 0x7f);
122         t->tm_min = bcd2bin(fm3130->regs[FM3130_RTC_MINUTES] & 0x7f);
123         tmp = fm3130->regs[FM3130_RTC_HOURS] & 0x3f;
124         t->tm_hour = bcd2bin(tmp);
125         t->tm_wday = bcd2bin(fm3130->regs[FM3130_RTC_DAY] & 0x07) - 1;
126         t->tm_mday = bcd2bin(fm3130->regs[FM3130_RTC_DATE] & 0x3f);
127         tmp = fm3130->regs[FM3130_RTC_MONTHS] & 0x1f;
128         t->tm_mon = bcd2bin(tmp) - 1;
129
130         /* assume 20YY not 19YY, and ignore CF bit */
131         t->tm_year = bcd2bin(fm3130->regs[FM3130_RTC_YEARS]) + 100;
132
133         dev_dbg(dev, "%s secs=%d, mins=%d, "
134                 "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
135                 "read", t->tm_sec, t->tm_min,
136                 t->tm_hour, t->tm_mday,
137                 t->tm_mon, t->tm_year, t->tm_wday);
138
139         /* initial clock setting can be undefined */
140         return rtc_valid_tm(t);
141 }
142
143
144 static int fm3130_set_time(struct device *dev, struct rtc_time *t)
145 {
146         struct fm3130 *fm3130 = dev_get_drvdata(dev);
147         int             tmp, i;
148         u8              *buf = fm3130->regs;
149
150         dev_dbg(dev, "%s secs=%d, mins=%d, "
151                 "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
152                 "write", t->tm_sec, t->tm_min,
153                 t->tm_hour, t->tm_mday,
154                 t->tm_mon, t->tm_year, t->tm_wday);
155
156         /* first register addr */
157         buf[FM3130_RTC_SECONDS] = bin2bcd(t->tm_sec);
158         buf[FM3130_RTC_MINUTES] = bin2bcd(t->tm_min);
159         buf[FM3130_RTC_HOURS] = bin2bcd(t->tm_hour);
160         buf[FM3130_RTC_DAY] = bin2bcd(t->tm_wday + 1);
161         buf[FM3130_RTC_DATE] = bin2bcd(t->tm_mday);
162         buf[FM3130_RTC_MONTHS] = bin2bcd(t->tm_mon + 1);
163
164         /* assume 20YY not 19YY */
165         tmp = t->tm_year - 100;
166         buf[FM3130_RTC_YEARS] = bin2bcd(tmp);
167
168         dev_dbg(dev, "%s: %15ph\n", "write", buf);
169
170         fm3130_rtc_mode(dev, FM3130_MODE_WRITE);
171
172         /* Writing time registers, we don't support multibyte transfers */
173         for (i = 0; i < FM3130_CLOCK_REGS; i++) {
174                 i2c_smbus_write_byte_data(fm3130->client,
175                                         FM3130_RTC_SECONDS + i,
176                                         fm3130->regs[FM3130_RTC_SECONDS + i]);
177         }
178
179         fm3130_rtc_mode(dev, FM3130_MODE_NORMAL);
180
181         /* We assume here that data are valid once written */
182         if (!fm3130->data_valid)
183                 fm3130->data_valid = 1;
184         return 0;
185 }
186
187 static int fm3130_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
188 {
189         struct fm3130 *fm3130 = dev_get_drvdata(dev);
190         int tmp;
191         struct rtc_time *tm = &alrm->time;
192
193         if (!fm3130->alarm_valid) {
194                 /*
195                  * We have invalid alarm in RTC, probably due to battery faults
196                  * or other problems. Return EIO for now, it will allow us to
197                  * set alarm value later instead of error during probing which
198                  * disables device
199                  */
200                 return -EIO;
201         }
202
203         /* read the RTC alarm registers all at once */
204         tmp = i2c_transfer(to_i2c_adapter(fm3130->client->dev.parent),
205                         &fm3130->msg[2], 2);
206         if (tmp != 2) {
207                 dev_err(dev, "%s error %d\n", "read", tmp);
208                 return -EIO;
209         }
210         dev_dbg(dev, "alarm read %02x %02x %02x %02x %02x\n",
211                         fm3130->regs[FM3130_ALARM_SECONDS],
212                         fm3130->regs[FM3130_ALARM_MINUTES],
213                         fm3130->regs[FM3130_ALARM_HOURS],
214                         fm3130->regs[FM3130_ALARM_DATE],
215                         fm3130->regs[FM3130_ALARM_MONTHS]);
216
217         tm->tm_sec      = bcd2bin(fm3130->regs[FM3130_ALARM_SECONDS] & 0x7F);
218         tm->tm_min      = bcd2bin(fm3130->regs[FM3130_ALARM_MINUTES] & 0x7F);
219         tm->tm_hour     = bcd2bin(fm3130->regs[FM3130_ALARM_HOURS] & 0x3F);
220         tm->tm_mday     = bcd2bin(fm3130->regs[FM3130_ALARM_DATE] & 0x3F);
221         tm->tm_mon      = bcd2bin(fm3130->regs[FM3130_ALARM_MONTHS] & 0x1F);
222
223         if (tm->tm_mon > 0)
224                 tm->tm_mon -= 1; /* RTC is 1-12, tm_mon is 0-11 */
225
226         dev_dbg(dev, "%s secs=%d, mins=%d, "
227                 "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
228                 "read alarm", tm->tm_sec, tm->tm_min,
229                 tm->tm_hour, tm->tm_mday,
230                 tm->tm_mon, tm->tm_year, tm->tm_wday);
231
232         /* check if alarm enabled */
233         fm3130->regs[FM3130_RTC_CONTROL] =
234                 i2c_smbus_read_byte_data(fm3130->client, FM3130_RTC_CONTROL);
235
236         if ((fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_AEN) &&
237                 (~fm3130->regs[FM3130_RTC_CONTROL] &
238                         FM3130_RTC_CONTROL_BIT_CAL)) {
239                 alrm->enabled = 1;
240         }
241
242         return 0;
243 }
244
245 static int fm3130_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
246 {
247         struct fm3130 *fm3130 = dev_get_drvdata(dev);
248         struct rtc_time *tm = &alrm->time;
249         int i;
250
251         dev_dbg(dev, "%s secs=%d, mins=%d, "
252                 "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
253                 "write alarm", tm->tm_sec, tm->tm_min,
254                 tm->tm_hour, tm->tm_mday,
255                 tm->tm_mon, tm->tm_year, tm->tm_wday);
256
257         fm3130->regs[FM3130_ALARM_SECONDS] =
258                 (tm->tm_sec != -1) ? bin2bcd(tm->tm_sec) : 0x80;
259
260         fm3130->regs[FM3130_ALARM_MINUTES] =
261                 (tm->tm_min != -1) ? bin2bcd(tm->tm_min) : 0x80;
262
263         fm3130->regs[FM3130_ALARM_HOURS] =
264                 (tm->tm_hour != -1) ? bin2bcd(tm->tm_hour) : 0x80;
265
266         fm3130->regs[FM3130_ALARM_DATE] =
267                 (tm->tm_mday != -1) ? bin2bcd(tm->tm_mday) : 0x80;
268
269         fm3130->regs[FM3130_ALARM_MONTHS] =
270                 (tm->tm_mon != -1) ? bin2bcd(tm->tm_mon + 1) : 0x80;
271
272         dev_dbg(dev, "alarm write %02x %02x %02x %02x %02x\n",
273                         fm3130->regs[FM3130_ALARM_SECONDS],
274                         fm3130->regs[FM3130_ALARM_MINUTES],
275                         fm3130->regs[FM3130_ALARM_HOURS],
276                         fm3130->regs[FM3130_ALARM_DATE],
277                         fm3130->regs[FM3130_ALARM_MONTHS]);
278         /* Writing time registers, we don't support multibyte transfers */
279         for (i = 0; i < FM3130_ALARM_REGS; i++) {
280                 i2c_smbus_write_byte_data(fm3130->client,
281                                         FM3130_ALARM_SECONDS + i,
282                                         fm3130->regs[FM3130_ALARM_SECONDS + i]);
283         }
284         fm3130->regs[FM3130_RTC_CONTROL] =
285                 i2c_smbus_read_byte_data(fm3130->client, FM3130_RTC_CONTROL);
286
287         /* enable or disable alarm */
288         if (alrm->enabled) {
289                 i2c_smbus_write_byte_data(fm3130->client, FM3130_RTC_CONTROL,
290                         (fm3130->regs[FM3130_RTC_CONTROL] &
291                                 ~(FM3130_RTC_CONTROL_BIT_CAL)) |
292                                         FM3130_RTC_CONTROL_BIT_AEN);
293         } else {
294                 i2c_smbus_write_byte_data(fm3130->client, FM3130_RTC_CONTROL,
295                         fm3130->regs[FM3130_RTC_CONTROL] &
296                                 ~(FM3130_RTC_CONTROL_BIT_CAL) &
297                                         ~(FM3130_RTC_CONTROL_BIT_AEN));
298         }
299
300         /* We assume here that data is valid once written */
301         if (!fm3130->alarm_valid)
302                 fm3130->alarm_valid = 1;
303
304         return 0;
305 }
306
307 static int fm3130_alarm_irq_enable(struct device *dev, unsigned int enabled)
308 {
309         struct fm3130 *fm3130 = dev_get_drvdata(dev);
310         int ret = 0;
311
312         fm3130->regs[FM3130_RTC_CONTROL] =
313                 i2c_smbus_read_byte_data(fm3130->client, FM3130_RTC_CONTROL);
314
315         dev_dbg(dev, "alarm_irq_enable: enable=%d, FM3130_RTC_CONTROL=%02x\n",
316                 enabled, fm3130->regs[FM3130_RTC_CONTROL]);
317
318         switch (enabled) {
319         case 0:         /* alarm off */
320                 ret = i2c_smbus_write_byte_data(fm3130->client,
321                         FM3130_RTC_CONTROL, fm3130->regs[FM3130_RTC_CONTROL] &
322                                 ~(FM3130_RTC_CONTROL_BIT_CAL) &
323                                         ~(FM3130_RTC_CONTROL_BIT_AEN));
324                 break;
325         case 1:         /* alarm on */
326                 ret = i2c_smbus_write_byte_data(fm3130->client,
327                         FM3130_RTC_CONTROL, (fm3130->regs[FM3130_RTC_CONTROL] &
328                                 ~(FM3130_RTC_CONTROL_BIT_CAL)) |
329                                         FM3130_RTC_CONTROL_BIT_AEN);
330                 break;
331         default:
332                 ret = -EINVAL;
333                 break;
334         }
335
336         return ret;
337 }
338
339 static const struct rtc_class_ops fm3130_rtc_ops = {
340         .read_time      = fm3130_get_time,
341         .set_time       = fm3130_set_time,
342         .read_alarm     = fm3130_read_alarm,
343         .set_alarm      = fm3130_set_alarm,
344         .alarm_irq_enable = fm3130_alarm_irq_enable,
345 };
346
347 static struct i2c_driver fm3130_driver;
348
349 static int fm3130_probe(struct i2c_client *client,
350                         const struct i2c_device_id *id)
351 {
352         struct fm3130           *fm3130;
353         int                     err = -ENODEV;
354         int                     tmp;
355         struct i2c_adapter      *adapter = to_i2c_adapter(client->dev.parent);
356
357         if (!i2c_check_functionality(adapter,
358                         I2C_FUNC_I2C | I2C_FUNC_SMBUS_WRITE_BYTE_DATA))
359                 return -EIO;
360
361         fm3130 = devm_kzalloc(&client->dev, sizeof(struct fm3130), GFP_KERNEL);
362
363         if (!fm3130)
364                 return -ENOMEM;
365
366         fm3130->client = client;
367         i2c_set_clientdata(client, fm3130);
368         fm3130->reg_addr_time = FM3130_RTC_SECONDS;
369         fm3130->reg_addr_alarm = FM3130_ALARM_SECONDS;
370
371         /* Messages to read time */
372         fm3130->msg[0].addr = client->addr;
373         fm3130->msg[0].flags = 0;
374         fm3130->msg[0].len = 1;
375         fm3130->msg[0].buf = &fm3130->reg_addr_time;
376
377         fm3130->msg[1].addr = client->addr;
378         fm3130->msg[1].flags = I2C_M_RD;
379         fm3130->msg[1].len = FM3130_CLOCK_REGS;
380         fm3130->msg[1].buf = &fm3130->regs[FM3130_RTC_SECONDS];
381
382         /* Messages to read alarm */
383         fm3130->msg[2].addr = client->addr;
384         fm3130->msg[2].flags = 0;
385         fm3130->msg[2].len = 1;
386         fm3130->msg[2].buf = &fm3130->reg_addr_alarm;
387
388         fm3130->msg[3].addr = client->addr;
389         fm3130->msg[3].flags = I2C_M_RD;
390         fm3130->msg[3].len = FM3130_ALARM_REGS;
391         fm3130->msg[3].buf = &fm3130->regs[FM3130_ALARM_SECONDS];
392
393         fm3130->alarm_valid = 0;
394         fm3130->data_valid = 0;
395
396         tmp = i2c_transfer(adapter, fm3130->msg, 4);
397         if (tmp != 4) {
398                 dev_dbg(&client->dev, "read error %d\n", tmp);
399                 err = -EIO;
400                 goto exit_free;
401         }
402
403         fm3130->regs[FM3130_RTC_CONTROL] =
404                 i2c_smbus_read_byte_data(client, FM3130_RTC_CONTROL);
405         fm3130->regs[FM3130_CAL_CONTROL] =
406                 i2c_smbus_read_byte_data(client, FM3130_CAL_CONTROL);
407
408         /* Disabling calibration mode */
409         if (fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_CAL) {
410                 i2c_smbus_write_byte_data(client, FM3130_RTC_CONTROL,
411                         fm3130->regs[FM3130_RTC_CONTROL] &
412                                 ~(FM3130_RTC_CONTROL_BIT_CAL));
413                 dev_warn(&client->dev, "Disabling calibration mode!\n");
414         }
415
416         /* Disabling read and write modes */
417         if (fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_WRITE ||
418             fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_READ) {
419                 i2c_smbus_write_byte_data(client, FM3130_RTC_CONTROL,
420                         fm3130->regs[FM3130_RTC_CONTROL] &
421                                 ~(FM3130_RTC_CONTROL_BIT_READ |
422                                         FM3130_RTC_CONTROL_BIT_WRITE));
423                 dev_warn(&client->dev, "Disabling READ or WRITE mode!\n");
424         }
425
426         /* oscillator off?  turn it on, so clock can tick. */
427         if (fm3130->regs[FM3130_CAL_CONTROL] & FM3130_CAL_CONTROL_BIT_nOSCEN)
428                 i2c_smbus_write_byte_data(client, FM3130_CAL_CONTROL,
429                         fm3130->regs[FM3130_CAL_CONTROL] &
430                                 ~(FM3130_CAL_CONTROL_BIT_nOSCEN));
431
432         /* low battery?  clear flag, and warn */
433         if (fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_LB) {
434                 i2c_smbus_write_byte_data(client, FM3130_RTC_CONTROL,
435                         fm3130->regs[FM3130_RTC_CONTROL] &
436                                 ~(FM3130_RTC_CONTROL_BIT_LB));
437                 dev_warn(&client->dev, "Low battery!\n");
438         }
439
440         /* check if Power On Reset bit is set */
441         if (fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_POR) {
442                 i2c_smbus_write_byte_data(client, FM3130_RTC_CONTROL,
443                         fm3130->regs[FM3130_RTC_CONTROL] &
444                                 ~FM3130_RTC_CONTROL_BIT_POR);
445                 dev_dbg(&client->dev, "POR bit is set\n");
446         }
447         /* ACS is controlled by alarm */
448         i2c_smbus_write_byte_data(client, FM3130_ALARM_WP_CONTROL, 0x80);
449
450         /* alarm registers sanity check */
451         tmp = bcd2bin(fm3130->regs[FM3130_RTC_SECONDS] & 0x7f);
452         if (tmp > 59)
453                 goto bad_alarm;
454
455         tmp = bcd2bin(fm3130->regs[FM3130_RTC_MINUTES] & 0x7f);
456         if (tmp > 59)
457                 goto bad_alarm;
458
459         tmp = bcd2bin(fm3130->regs[FM3130_RTC_HOURS] & 0x3f);
460         if (tmp > 23)
461                 goto bad_alarm;
462
463         tmp = bcd2bin(fm3130->regs[FM3130_RTC_DATE] & 0x3f);
464         if (tmp == 0 || tmp > 31)
465                 goto bad_alarm;
466
467         tmp = bcd2bin(fm3130->regs[FM3130_RTC_MONTHS] & 0x1f);
468         if (tmp == 0 || tmp > 12)
469                 goto bad_alarm;
470
471         fm3130->alarm_valid = 1;
472
473 bad_alarm:
474
475         /* clock registers sanity chek */
476         tmp = bcd2bin(fm3130->regs[FM3130_RTC_SECONDS] & 0x7f);
477         if (tmp > 59)
478                 goto bad_clock;
479
480         tmp = bcd2bin(fm3130->regs[FM3130_RTC_MINUTES] & 0x7f);
481         if (tmp > 59)
482                 goto bad_clock;
483
484         tmp = bcd2bin(fm3130->regs[FM3130_RTC_HOURS] & 0x3f);
485         if (tmp > 23)
486                 goto bad_clock;
487
488         tmp = bcd2bin(fm3130->regs[FM3130_RTC_DAY] & 0x7);
489         if (tmp == 0 || tmp > 7)
490                 goto bad_clock;
491
492         tmp = bcd2bin(fm3130->regs[FM3130_RTC_DATE] & 0x3f);
493         if (tmp == 0 || tmp > 31)
494                 goto bad_clock;
495
496         tmp = bcd2bin(fm3130->regs[FM3130_RTC_MONTHS] & 0x1f);
497         if (tmp == 0 || tmp > 12)
498                 goto bad_clock;
499
500         fm3130->data_valid = 1;
501
502 bad_clock:
503
504         if (!fm3130->data_valid || !fm3130->alarm_valid)
505                 dev_dbg(&client->dev, "%s: %15ph\n", "bogus registers",
506                         fm3130->regs);
507
508         /* We won't bail out here because we just got invalid data.
509            Time setting from u-boot doesn't work anyway */
510         fm3130->rtc = devm_rtc_device_register(&client->dev, client->name,
511                                 &fm3130_rtc_ops, THIS_MODULE);
512         if (IS_ERR(fm3130->rtc)) {
513                 err = PTR_ERR(fm3130->rtc);
514                 dev_err(&client->dev,
515                         "unable to register the class device\n");
516                 goto exit_free;
517         }
518         return 0;
519 exit_free:
520         return err;
521 }
522
523 static int fm3130_remove(struct i2c_client *client)
524 {
525         return 0;
526 }
527
528 static struct i2c_driver fm3130_driver = {
529         .driver = {
530                 .name   = "rtc-fm3130",
531                 .owner  = THIS_MODULE,
532         },
533         .probe          = fm3130_probe,
534         .remove         = fm3130_remove,
535         .id_table       = fm3130_id,
536 };
537
538 module_i2c_driver(fm3130_driver);
539
540 MODULE_DESCRIPTION("RTC driver for FM3130");
541 MODULE_AUTHOR("Sergey Lapin <slapin@ossfans.org>");
542 MODULE_LICENSE("GPL");
543