drivers/rtc/rtc-fm3130.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
fm3130_rtc_mode
fm3130_get_time
fm3130_set_time
fm3130_read_alarm
fm3130_set_alarm
fm3130_alarm_irq_enable
fm3130_probe
   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
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/rtc/rtc-fm3130.c

DEFINITIONS
