drivers/rtc/rtc-fm3130.c

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