drivers/rtc/rtc-isl12026.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * An I2C driver for the Intersil ISL 12026
   4  *
   5  * Copyright (c) 2018 Cavium, Inc.
   6  */
   7 #include <linux/bcd.h>
   8 #include <linux/delay.h>
   9 #include <linux/i2c.h>
  10 #include <linux/module.h>
  11 #include <linux/mutex.h>
  12 #include <linux/nvmem-provider.h>
  13 #include <linux/of.h>
  14 #include <linux/rtc.h>
  15 #include <linux/slab.h>
  16
  17 /* register offsets */
  18 #define ISL12026_REG_PWR        0x14
  19 # define ISL12026_REG_PWR_BSW   BIT(6)
  20 # define ISL12026_REG_PWR_SBIB  BIT(7)
  21 #define ISL12026_REG_SC         0x30
  22 #define ISL12026_REG_HR         0x32
  23 # define ISL12026_REG_HR_MIL    BIT(7)  /* military or 24 hour time */
  24 #define ISL12026_REG_SR         0x3f
  25 # define ISL12026_REG_SR_RTCF   BIT(0)
  26 # define ISL12026_REG_SR_WEL    BIT(1)
  27 # define ISL12026_REG_SR_RWEL   BIT(2)
  28 # define ISL12026_REG_SR_MBZ    BIT(3)
  29 # define ISL12026_REG_SR_OSCF   BIT(4)
  30
  31 /* The EEPROM array responds at i2c address 0x57 */
  32 #define ISL12026_EEPROM_ADDR    0x57
  33
  34 #define ISL12026_PAGESIZE 16
  35 #define ISL12026_NVMEM_WRITE_TIME 20
  36
  37 struct isl12026 {
  38         struct rtc_device *rtc;
  39         struct i2c_client *nvm_client;
  40 };
  41
  42 static int isl12026_read_reg(struct i2c_client *client, int reg)
  43 {
  44         u8 addr[] = {0, reg};
  45         u8 val;
  46         int ret;
  47
  48         struct i2c_msg msgs[] = {
  49                 {
  50                         .addr   = client->addr,
  51                         .flags  = 0,
  52                         .len    = sizeof(addr),
  53                         .buf    = addr
  54                 }, {
  55                         .addr   = client->addr,
  56                         .flags  = I2C_M_RD,
  57                         .len    = 1,
  58                         .buf    = &val
  59                 }
  60         };
  61
  62         ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
  63         if (ret != ARRAY_SIZE(msgs)) {
  64                 dev_err(&client->dev, "read reg error, ret=%d\n", ret);
  65                 ret = ret < 0 ? ret : -EIO;
  66         } else {
  67                 ret = val;
  68         }
  69
  70         return ret;
  71 }
  72
  73 static int isl12026_arm_write(struct i2c_client *client)
  74 {
  75         int ret;
  76         u8 op[3];
  77         struct i2c_msg msg = {
  78                 .addr   = client->addr,
  79                 .flags  = 0,
  80                 .len    = 1,
  81                 .buf    = op
  82         };
  83
  84         /* Set SR.WEL */
  85         op[0] = 0;
  86         op[1] = ISL12026_REG_SR;
  87         op[2] = ISL12026_REG_SR_WEL;
  88         msg.len = 3;
  89         ret = i2c_transfer(client->adapter, &msg, 1);
  90         if (ret != 1) {
  91                 dev_err(&client->dev, "write error SR.WEL, ret=%d\n", ret);
  92                 ret = ret < 0 ? ret : -EIO;
  93                 goto out;
  94         }
  95
  96         /* Set SR.WEL and SR.RWEL */
  97         op[2] = ISL12026_REG_SR_WEL | ISL12026_REG_SR_RWEL;
  98         msg.len = 3;
  99         ret = i2c_transfer(client->adapter, &msg, 1);
 100         if (ret != 1) {
 101                 dev_err(&client->dev,
 102                         "write error SR.WEL|SR.RWEL, ret=%d\n", ret);
 103                 ret = ret < 0 ? ret : -EIO;
 104                 goto out;
 105         } else {
 106                 ret = 0;
 107         }
 108 out:
 109         return ret;
 110 }
 111
 112 static int isl12026_disarm_write(struct i2c_client *client)
 113 {
 114         int ret;
 115         u8 op[3] = {0, ISL12026_REG_SR, 0};
 116         struct i2c_msg msg = {
 117                 .addr   = client->addr,
 118                 .flags  = 0,
 119                 .len    = sizeof(op),
 120                 .buf    = op
 121         };
 122
 123         ret = i2c_transfer(client->adapter, &msg, 1);
 124         if (ret != 1) {
 125                 dev_err(&client->dev,
 126                         "write error SR, ret=%d\n", ret);
 127                 ret = ret < 0 ? ret : -EIO;
 128         } else {
 129                 ret = 0;
 130         }
 131
 132         return ret;
 133 }
 134
 135 static int isl12026_write_reg(struct i2c_client *client, int reg, u8 val)
 136 {
 137         int ret;
 138         u8 op[3] = {0, reg, val};
 139         struct i2c_msg msg = {
 140                 .addr   = client->addr,
 141                 .flags  = 0,
 142                 .len    = sizeof(op),
 143                 .buf    = op
 144         };
 145
 146         ret = isl12026_arm_write(client);
 147         if (ret)
 148                 return ret;
 149
 150         ret = i2c_transfer(client->adapter, &msg, 1);
 151         if (ret != 1) {
 152                 dev_err(&client->dev, "write error CCR, ret=%d\n", ret);
 153                 ret = ret < 0 ? ret : -EIO;
 154                 goto out;
 155         }
 156
 157         msleep(ISL12026_NVMEM_WRITE_TIME);
 158
 159         ret = isl12026_disarm_write(client);
 160 out:
 161         return ret;
 162 }
 163
 164 static int isl12026_rtc_set_time(struct device *dev, struct rtc_time *tm)
 165 {
 166         struct i2c_client *client = to_i2c_client(dev);
 167         int ret;
 168         u8 op[10];
 169         struct i2c_msg msg = {
 170                 .addr   = client->addr,
 171                 .flags  = 0,
 172                 .len    = sizeof(op),
 173                 .buf    = op
 174         };
 175
 176         ret = isl12026_arm_write(client);
 177         if (ret)
 178                 return ret;
 179
 180         /* Set the CCR registers */
 181         op[0] = 0;
 182         op[1] = ISL12026_REG_SC;
 183         op[2] = bin2bcd(tm->tm_sec); /* SC */
 184         op[3] = bin2bcd(tm->tm_min); /* MN */
 185         op[4] = bin2bcd(tm->tm_hour) | ISL12026_REG_HR_MIL; /* HR */
 186         op[5] = bin2bcd(tm->tm_mday); /* DT */
 187         op[6] = bin2bcd(tm->tm_mon + 1); /* MO */
 188         op[7] = bin2bcd(tm->tm_year % 100); /* YR */
 189         op[8] = bin2bcd(tm->tm_wday & 7); /* DW */
 190         op[9] = bin2bcd(tm->tm_year >= 100 ? 20 : 19); /* Y2K */
 191         ret = i2c_transfer(client->adapter, &msg, 1);
 192         if (ret != 1) {
 193                 dev_err(&client->dev, "write error CCR, ret=%d\n", ret);
 194                 ret = ret < 0 ? ret : -EIO;
 195                 goto out;
 196         }
 197
 198         ret = isl12026_disarm_write(client);
 199 out:
 200         return ret;
 201 }
 202
 203 static int isl12026_rtc_read_time(struct device *dev, struct rtc_time *tm)
 204 {
 205         struct i2c_client *client = to_i2c_client(dev);
 206         u8 ccr[8];
 207         u8 addr[2];
 208         u8 sr;
 209         int ret;
 210         struct i2c_msg msgs[] = {
 211                 {
 212                         .addr   = client->addr,
 213                         .flags  = 0,
 214                         .len    = sizeof(addr),
 215                         .buf    = addr
 216                 }, {
 217                         .addr   = client->addr,
 218                         .flags  = I2C_M_RD,
 219                 }
 220         };
 221
 222         /* First, read SR */
 223         addr[0] = 0;
 224         addr[1] = ISL12026_REG_SR;
 225         msgs[1].len = 1;
 226         msgs[1].buf = &sr;
 227
 228         ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
 229         if (ret != ARRAY_SIZE(msgs)) {
 230                 dev_err(&client->dev, "read error, ret=%d\n", ret);
 231                 ret = ret < 0 ? ret : -EIO;
 232                 goto out;
 233         }
 234
 235         if (sr & ISL12026_REG_SR_RTCF)
 236                 dev_warn(&client->dev, "Real-Time Clock Failure on read\n");
 237         if (sr & ISL12026_REG_SR_OSCF)
 238                 dev_warn(&client->dev, "Oscillator Failure on read\n");
 239
 240         /* Second, CCR regs */
 241         addr[0] = 0;
 242         addr[1] = ISL12026_REG_SC;
 243         msgs[1].len = sizeof(ccr);
 244         msgs[1].buf = ccr;
 245
 246         ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
 247         if (ret != ARRAY_SIZE(msgs)) {
 248                 dev_err(&client->dev, "read error, ret=%d\n", ret);
 249                 ret = ret < 0 ? ret : -EIO;
 250                 goto out;
 251         }
 252
 253         tm->tm_sec = bcd2bin(ccr[0] & 0x7F);
 254         tm->tm_min = bcd2bin(ccr[1] & 0x7F);
 255         if (ccr[2] & ISL12026_REG_HR_MIL)
 256                 tm->tm_hour = bcd2bin(ccr[2] & 0x3F);
 257         else
 258                 tm->tm_hour = bcd2bin(ccr[2] & 0x1F) +
 259                         ((ccr[2] & 0x20) ? 12 : 0);
 260         tm->tm_mday = bcd2bin(ccr[3] & 0x3F);
 261         tm->tm_mon = bcd2bin(ccr[4] & 0x1F) - 1;
 262         tm->tm_year = bcd2bin(ccr[5]);
 263         if (bcd2bin(ccr[7]) == 20)
 264                 tm->tm_year += 100;
 265         tm->tm_wday = ccr[6] & 0x07;
 266
 267         ret = 0;
 268 out:
 269         return ret;
 270 }
 271
 272 static const struct rtc_class_ops isl12026_rtc_ops = {
 273         .read_time      = isl12026_rtc_read_time,
 274         .set_time       = isl12026_rtc_set_time,
 275 };
 276
 277 static int isl12026_nvm_read(void *p, unsigned int offset,
 278                              void *val, size_t bytes)
 279 {
 280         struct isl12026 *priv = p;
 281         int ret;
 282         u8 addr[2];
 283         struct i2c_msg msgs[] = {
 284                 {
 285                         .addr   = priv->nvm_client->addr,
 286                         .flags  = 0,
 287                         .len    = sizeof(addr),
 288                         .buf    = addr
 289                 }, {
 290                         .addr   = priv->nvm_client->addr,
 291                         .flags  = I2C_M_RD,
 292                         .buf    = val
 293                 }
 294         };
 295
 296         /*
 297          * offset and bytes checked and limited by nvmem core, so
 298          * proceed without further checks.
 299          */
 300         ret = mutex_lock_interruptible(&priv->rtc->ops_lock);
 301         if (ret)
 302                 return ret;
 303
 304         /* 2 bytes of address, most significant first */
 305         addr[0] = offset >> 8;
 306         addr[1] = offset;
 307         msgs[1].len = bytes;
 308         ret = i2c_transfer(priv->nvm_client->adapter, msgs, ARRAY_SIZE(msgs));
 309
 310         mutex_unlock(&priv->rtc->ops_lock);
 311
 312         if (ret != ARRAY_SIZE(msgs)) {
 313                 dev_err(&priv->nvm_client->dev,
 314                         "nvmem read error, ret=%d\n", ret);
 315                 return ret < 0 ? ret : -EIO;
 316         }
 317
 318         return 0;
 319 }
 320
 321 static int isl12026_nvm_write(void *p, unsigned int offset,
 322                               void *val, size_t bytes)
 323 {
 324         struct isl12026 *priv = p;
 325         int ret;
 326         u8 *v = val;
 327         size_t chunk_size, num_written;
 328         u8 payload[ISL12026_PAGESIZE + 2]; /* page + 2 address bytes */
 329         struct i2c_msg msgs[] = {
 330                 {
 331                         .addr   = priv->nvm_client->addr,
 332                         .flags  = 0,
 333                         .buf    = payload
 334                 }
 335         };
 336
 337         /*
 338          * offset and bytes checked and limited by nvmem core, so
 339          * proceed without further checks.
 340          */
 341         ret = mutex_lock_interruptible(&priv->rtc->ops_lock);
 342         if (ret)
 343                 return ret;
 344
 345         num_written = 0;
 346         while (bytes) {
 347                 chunk_size = round_down(offset, ISL12026_PAGESIZE) +
 348                         ISL12026_PAGESIZE - offset;
 349                 chunk_size = min(bytes, chunk_size);
 350                 /*
 351                  * 2 bytes of address, most significant first, followed
 352                  * by page data bytes
 353                  */
 354                 memcpy(payload + 2, v + num_written, chunk_size);
 355                 payload[0] = offset >> 8;
 356                 payload[1] = offset;
 357                 msgs[0].len = chunk_size + 2;
 358                 ret = i2c_transfer(priv->nvm_client->adapter,
 359                                    msgs, ARRAY_SIZE(msgs));
 360                 if (ret != ARRAY_SIZE(msgs)) {
 361                         dev_err(&priv->nvm_client->dev,
 362                                 "nvmem write error, ret=%d\n", ret);
 363                         ret = ret < 0 ? ret : -EIO;
 364                         break;
 365                 }
 366                 ret = 0;
 367                 bytes -= chunk_size;
 368                 offset += chunk_size;
 369                 num_written += chunk_size;
 370                 msleep(ISL12026_NVMEM_WRITE_TIME);
 371         }
 372
 373         mutex_unlock(&priv->rtc->ops_lock);
 374
 375         return ret;
 376 }
 377
 378 static void isl12026_force_power_modes(struct i2c_client *client)
 379 {
 380         int ret;
 381         int pwr, requested_pwr;
 382         u32 bsw_val, sbib_val;
 383         bool set_bsw, set_sbib;
 384
 385         /*
 386          * If we can read the of_property, set the specified value.
 387          * If there is an error reading the of_property (likely
 388          * because it does not exist), keep the current value.
 389          */
 390         ret = of_property_read_u32(client->dev.of_node,
 391                                    "isil,pwr-bsw", &bsw_val);
 392         set_bsw = (ret == 0);
 393
 394         ret = of_property_read_u32(client->dev.of_node,
 395                                    "isil,pwr-sbib", &sbib_val);
 396         set_sbib = (ret == 0);
 397
 398         /* Check if PWR.BSW and/or PWR.SBIB need specified values */
 399         if (!set_bsw && !set_sbib)
 400                 return;
 401
 402         pwr = isl12026_read_reg(client, ISL12026_REG_PWR);
 403         if (pwr < 0) {
 404                 dev_warn(&client->dev, "Error: Failed to read PWR %d\n", pwr);
 405                 return;
 406         }
 407
 408         requested_pwr = pwr;
 409
 410         if (set_bsw) {
 411                 if (bsw_val)
 412                         requested_pwr |= ISL12026_REG_PWR_BSW;
 413                 else
 414                         requested_pwr &= ~ISL12026_REG_PWR_BSW;
 415         } /* else keep current BSW */
 416
 417         if (set_sbib) {
 418                 if (sbib_val)
 419                         requested_pwr |= ISL12026_REG_PWR_SBIB;
 420                 else
 421                         requested_pwr &= ~ISL12026_REG_PWR_SBIB;
 422         } /* else keep current SBIB */
 423
 424         if (pwr >= 0 && pwr != requested_pwr) {
 425                 dev_dbg(&client->dev, "PWR: %02x\n", pwr);
 426                 dev_dbg(&client->dev, "Updating PWR to: %02x\n", requested_pwr);
 427                 isl12026_write_reg(client, ISL12026_REG_PWR, requested_pwr);
 428         }
 429 }
 430
 431 static int isl12026_probe(struct i2c_client *client)
 432 {
 433         struct isl12026 *priv;
 434         int ret;
 435         struct nvmem_config nvm_cfg = {
 436                 .name = "isl12026-",
 437                 .base_dev = &client->dev,
 438                 .stride = 1,
 439                 .word_size = 1,
 440                 .size = 512,
 441                 .reg_read = isl12026_nvm_read,
 442                 .reg_write = isl12026_nvm_write,
 443         };
 444
 445         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
 446                 return -ENODEV;
 447
 448         priv = devm_kzalloc(&client->dev, sizeof(*priv), GFP_KERNEL);
 449         if (!priv)
 450                 return -ENOMEM;
 451
 452         i2c_set_clientdata(client, priv);
 453
 454         isl12026_force_power_modes(client);
 455
 456         priv->nvm_client = i2c_new_dummy_device(client->adapter, ISL12026_EEPROM_ADDR);
 457         if (IS_ERR(priv->nvm_client))
 458                 return PTR_ERR(priv->nvm_client);
 459
 460         priv->rtc = devm_rtc_allocate_device(&client->dev);
 461         ret = PTR_ERR_OR_ZERO(priv->rtc);
 462         if (ret)
 463                 return ret;
 464
 465         priv->rtc->ops = &isl12026_rtc_ops;
 466         nvm_cfg.priv = priv;
 467         ret = devm_rtc_nvmem_register(priv->rtc, &nvm_cfg);
 468         if (ret)
 469                 return ret;
 470
 471         return devm_rtc_register_device(priv->rtc);
 472 }
 473
 474 static void isl12026_remove(struct i2c_client *client)
 475 {
 476         struct isl12026 *priv = i2c_get_clientdata(client);
 477
 478         i2c_unregister_device(priv->nvm_client);
 479 }
 480
 481 static const struct of_device_id isl12026_dt_match[] = {
 482         { .compatible = "isil,isl12026" },
 483         { }
 484 };
 485 MODULE_DEVICE_TABLE(of, isl12026_dt_match);
 486
 487 static struct i2c_driver isl12026_driver = {
 488         .driver         = {
 489                 .name   = "rtc-isl12026",
 490                 .of_match_table = isl12026_dt_match,
 491         },
 492         .probe          = isl12026_probe,
 493         .remove         = isl12026_remove,
 494 };
 495
 496 module_i2c_driver(isl12026_driver);
 497
 498 MODULE_DESCRIPTION("ISL 12026 RTC driver");
 499 MODULE_LICENSE("GPL");