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