drivers/rtc/rtc-pcf8523.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2012 Avionic Design GmbH
   4  */
   5
   6 #include <linux/bcd.h>
   7 #include <linux/i2c.h>
   8 #include <linux/module.h>
   9 #include <linux/rtc.h>
  10 #include <linux/of.h>
  11 #include <linux/pm_wakeirq.h>
  12
  13 #define PCF8523_REG_CONTROL1 0x00
  14 #define PCF8523_CONTROL1_CAP_SEL BIT(7)
  15 #define PCF8523_CONTROL1_STOP    BIT(5)
  16 #define PCF8523_CONTROL1_AIE    BIT(1)
  17
  18 #define PCF8523_REG_CONTROL2 0x01
  19 #define PCF8523_CONTROL2_AF BIT(3)
  20
  21 #define PCF8523_REG_CONTROL3 0x02
  22 #define PCF8523_CONTROL3_PM_BLD BIT(7) /* battery low detection disabled */
  23 #define PCF8523_CONTROL3_PM_VDD BIT(6) /* switch-over disabled */
  24 #define PCF8523_CONTROL3_PM_DSM BIT(5) /* direct switching mode */
  25 #define PCF8523_CONTROL3_PM_MASK 0xe0
  26 #define PCF8523_CONTROL3_BLF BIT(2) /* battery low bit, read-only */
  27
  28 #define PCF8523_REG_SECONDS  0x03
  29 #define PCF8523_SECONDS_OS BIT(7)
  30
  31 #define PCF8523_REG_MINUTES  0x04
  32 #define PCF8523_REG_HOURS    0x05
  33 #define PCF8523_REG_DAYS     0x06
  34 #define PCF8523_REG_WEEKDAYS 0x07
  35 #define PCF8523_REG_MONTHS   0x08
  36 #define PCF8523_REG_YEARS    0x09
  37
  38 #define PCF8523_REG_MINUTE_ALARM        0x0a
  39 #define PCF8523_REG_HOUR_ALARM          0x0b
  40 #define PCF8523_REG_DAY_ALARM           0x0c
  41 #define PCF8523_REG_WEEKDAY_ALARM       0x0d
  42 #define ALARM_DIS BIT(7)
  43
  44 #define PCF8523_REG_OFFSET   0x0e
  45 #define PCF8523_OFFSET_MODE BIT(7)
  46
  47 #define PCF8523_TMR_CLKOUT_CTRL 0x0f
  48
  49 struct pcf8523 {
  50         struct rtc_device *rtc;
  51         struct i2c_client *client;
  52 };
  53
  54 static int pcf8523_read(struct i2c_client *client, u8 reg, u8 *valuep)
  55 {
  56         struct i2c_msg msgs[2];
  57         u8 value = 0;
  58         int err;
  59
  60         msgs[0].addr = client->addr;
  61         msgs[0].flags = 0;
  62         msgs[0].len = sizeof(reg);
  63         msgs[0].buf = &reg;
  64
  65         msgs[1].addr = client->addr;
  66         msgs[1].flags = I2C_M_RD;
  67         msgs[1].len = sizeof(value);
  68         msgs[1].buf = &value;
  69
  70         err = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
  71         if (err < 0)
  72                 return err;
  73
  74         *valuep = value;
  75
  76         return 0;
  77 }
  78
  79 static int pcf8523_write(struct i2c_client *client, u8 reg, u8 value)
  80 {
  81         u8 buffer[2] = { reg, value };
  82         struct i2c_msg msg;
  83         int err;
  84
  85         msg.addr = client->addr;
  86         msg.flags = 0;
  87         msg.len = sizeof(buffer);
  88         msg.buf = buffer;
  89
  90         err = i2c_transfer(client->adapter, &msg, 1);
  91         if (err < 0)
  92                 return err;
  93
  94         return 0;
  95 }
  96
  97 static int pcf8523_voltage_low(struct i2c_client *client)
  98 {
  99         u8 value;
 100         int err;
 101
 102         err = pcf8523_read(client, PCF8523_REG_CONTROL3, &value);
 103         if (err < 0)
 104                 return err;
 105
 106         return !!(value & PCF8523_CONTROL3_BLF);
 107 }
 108
 109 static int pcf8523_load_capacitance(struct i2c_client *client)
 110 {
 111         u32 load;
 112         u8 value;
 113         int err;
 114
 115         err = pcf8523_read(client, PCF8523_REG_CONTROL1, &value);
 116         if (err < 0)
 117                 return err;
 118
 119         load = 12500;
 120         of_property_read_u32(client->dev.of_node, "quartz-load-femtofarads",
 121                              &load);
 122
 123         switch (load) {
 124         default:
 125                 dev_warn(&client->dev, "Unknown quartz-load-femtofarads value: %d. Assuming 12500",
 126                          load);
 127                 fallthrough;
 128         case 12500:
 129                 value |= PCF8523_CONTROL1_CAP_SEL;
 130                 break;
 131         case 7000:
 132                 value &= ~PCF8523_CONTROL1_CAP_SEL;
 133                 break;
 134         }
 135
 136         err = pcf8523_write(client, PCF8523_REG_CONTROL1, value);
 137
 138         return err;
 139 }
 140
 141 static int pcf8523_set_pm(struct i2c_client *client, u8 pm)
 142 {
 143         u8 value;
 144         int err;
 145
 146         err = pcf8523_read(client, PCF8523_REG_CONTROL3, &value);
 147         if (err < 0)
 148                 return err;
 149
 150         value = (value & ~PCF8523_CONTROL3_PM_MASK) | pm;
 151
 152         err = pcf8523_write(client, PCF8523_REG_CONTROL3, value);
 153         if (err < 0)
 154                 return err;
 155
 156         return 0;
 157 }
 158
 159 static irqreturn_t pcf8523_irq(int irq, void *dev_id)
 160 {
 161         struct pcf8523 *pcf8523 = i2c_get_clientdata(dev_id);
 162         u8 value;
 163         int err;
 164
 165         err = pcf8523_read(pcf8523->client, PCF8523_REG_CONTROL2, &value);
 166         if (err < 0)
 167                 return IRQ_HANDLED;
 168
 169         if (value & PCF8523_CONTROL2_AF) {
 170                 value &= ~PCF8523_CONTROL2_AF;
 171                 pcf8523_write(pcf8523->client, PCF8523_REG_CONTROL2, value);
 172                 rtc_update_irq(pcf8523->rtc, 1, RTC_IRQF | RTC_AF);
 173
 174                 return IRQ_HANDLED;
 175         }
 176
 177         return IRQ_NONE;
 178 }
 179
 180 static int pcf8523_stop_rtc(struct i2c_client *client)
 181 {
 182         u8 value;
 183         int err;
 184
 185         err = pcf8523_read(client, PCF8523_REG_CONTROL1, &value);
 186         if (err < 0)
 187                 return err;
 188
 189         value |= PCF8523_CONTROL1_STOP;
 190
 191         err = pcf8523_write(client, PCF8523_REG_CONTROL1, value);
 192         if (err < 0)
 193                 return err;
 194
 195         return 0;
 196 }
 197
 198 static int pcf8523_start_rtc(struct i2c_client *client)
 199 {
 200         u8 value;
 201         int err;
 202
 203         err = pcf8523_read(client, PCF8523_REG_CONTROL1, &value);
 204         if (err < 0)
 205                 return err;
 206
 207         value &= ~PCF8523_CONTROL1_STOP;
 208
 209         err = pcf8523_write(client, PCF8523_REG_CONTROL1, value);
 210         if (err < 0)
 211                 return err;
 212
 213         return 0;
 214 }
 215
 216 static int pcf8523_rtc_read_time(struct device *dev, struct rtc_time *tm)
 217 {
 218         struct i2c_client *client = to_i2c_client(dev);
 219         u8 start = PCF8523_REG_SECONDS, regs[7];
 220         struct i2c_msg msgs[2];
 221         int err;
 222
 223         err = pcf8523_voltage_low(client);
 224         if (err < 0) {
 225                 return err;
 226         } else if (err > 0) {
 227                 dev_err(dev, "low voltage detected, time is unreliable\n");
 228                 return -EINVAL;
 229         }
 230
 231         msgs[0].addr = client->addr;
 232         msgs[0].flags = 0;
 233         msgs[0].len = 1;
 234         msgs[0].buf = &start;
 235
 236         msgs[1].addr = client->addr;
 237         msgs[1].flags = I2C_M_RD;
 238         msgs[1].len = sizeof(regs);
 239         msgs[1].buf = regs;
 240
 241         err = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
 242         if (err < 0)
 243                 return err;
 244
 245         if (regs[0] & PCF8523_SECONDS_OS) {
 246                 /*
 247                  * If the oscillator was stopped, try to clear the flag. Upon
 248                  * power-up the flag is always set, but if we cannot clear it
 249                  * the oscillator isn't running properly for some reason. The
 250                  * sensible thing therefore is to return an error, signalling
 251                  * that the clock cannot be assumed to be correct.
 252                  */
 253
 254                 regs[0] &= ~PCF8523_SECONDS_OS;
 255
 256                 err = pcf8523_write(client, PCF8523_REG_SECONDS, regs[0]);
 257                 if (err < 0)
 258                         return err;
 259
 260                 err = pcf8523_read(client, PCF8523_REG_SECONDS, &regs[0]);
 261                 if (err < 0)
 262                         return err;
 263
 264                 if (regs[0] & PCF8523_SECONDS_OS)
 265                         return -EAGAIN;
 266         }
 267
 268         tm->tm_sec = bcd2bin(regs[0] & 0x7f);
 269         tm->tm_min = bcd2bin(regs[1] & 0x7f);
 270         tm->tm_hour = bcd2bin(regs[2] & 0x3f);
 271         tm->tm_mday = bcd2bin(regs[3] & 0x3f);
 272         tm->tm_wday = regs[4] & 0x7;
 273         tm->tm_mon = bcd2bin(regs[5] & 0x1f) - 1;
 274         tm->tm_year = bcd2bin(regs[6]) + 100;
 275
 276         return 0;
 277 }
 278
 279 static int pcf8523_rtc_set_time(struct device *dev, struct rtc_time *tm)
 280 {
 281         struct i2c_client *client = to_i2c_client(dev);
 282         struct i2c_msg msg;
 283         u8 regs[8];
 284         int err;
 285
 286         err = pcf8523_stop_rtc(client);
 287         if (err < 0)
 288                 return err;
 289
 290         regs[0] = PCF8523_REG_SECONDS;
 291         /* This will purposely overwrite PCF8523_SECONDS_OS */
 292         regs[1] = bin2bcd(tm->tm_sec);
 293         regs[2] = bin2bcd(tm->tm_min);
 294         regs[3] = bin2bcd(tm->tm_hour);
 295         regs[4] = bin2bcd(tm->tm_mday);
 296         regs[5] = tm->tm_wday;
 297         regs[6] = bin2bcd(tm->tm_mon + 1);
 298         regs[7] = bin2bcd(tm->tm_year - 100);
 299
 300         msg.addr = client->addr;
 301         msg.flags = 0;
 302         msg.len = sizeof(regs);
 303         msg.buf = regs;
 304
 305         err = i2c_transfer(client->adapter, &msg, 1);
 306         if (err < 0) {
 307                 /*
 308                  * If the time cannot be set, restart the RTC anyway. Note
 309                  * that errors are ignored if the RTC cannot be started so
 310                  * that we have a chance to propagate the original error.
 311                  */
 312                 pcf8523_start_rtc(client);
 313                 return err;
 314         }
 315
 316         return pcf8523_start_rtc(client);
 317 }
 318
 319 static int pcf8523_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *tm)
 320 {
 321         struct i2c_client *client = to_i2c_client(dev);
 322         u8 start = PCF8523_REG_MINUTE_ALARM, regs[4];
 323         struct i2c_msg msgs[2];
 324         u8 value;
 325         int err;
 326
 327         msgs[0].addr = client->addr;
 328         msgs[0].flags = 0;
 329         msgs[0].len = 1;
 330         msgs[0].buf = &start;
 331
 332         msgs[1].addr = client->addr;
 333         msgs[1].flags = I2C_M_RD;
 334         msgs[1].len = sizeof(regs);
 335         msgs[1].buf = regs;
 336
 337         err = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
 338         if (err < 0)
 339                 return err;
 340
 341         tm->time.tm_sec = 0;
 342         tm->time.tm_min = bcd2bin(regs[0] & 0x7F);
 343         tm->time.tm_hour = bcd2bin(regs[1] & 0x3F);
 344         tm->time.tm_mday = bcd2bin(regs[2] & 0x3F);
 345         tm->time.tm_wday = bcd2bin(regs[3] & 0x7);
 346
 347         err = pcf8523_read(client, PCF8523_REG_CONTROL1, &value);
 348         if (err < 0)
 349                 return err;
 350         tm->enabled = !!(value & PCF8523_CONTROL1_AIE);
 351
 352         err = pcf8523_read(client, PCF8523_REG_CONTROL2, &value);
 353         if (err < 0)
 354                 return err;
 355         tm->pending = !!(value & PCF8523_CONTROL2_AF);
 356
 357         return 0;
 358 }
 359
 360 static int pcf8523_irq_enable(struct device *dev, unsigned int enabled)
 361 {
 362         struct i2c_client *client = to_i2c_client(dev);
 363         u8 value;
 364         int err;
 365
 366         err = pcf8523_read(client, PCF8523_REG_CONTROL1, &value);
 367         if (err < 0)
 368                 return err;
 369
 370         value &= PCF8523_CONTROL1_AIE;
 371
 372         if (enabled)
 373                 value |= PCF8523_CONTROL1_AIE;
 374
 375         err = pcf8523_write(client, PCF8523_REG_CONTROL1, value);
 376         if (err < 0)
 377                 return err;
 378
 379         return 0;
 380 }
 381
 382 static int pcf8523_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *tm)
 383 {
 384         struct i2c_client *client = to_i2c_client(dev);
 385         struct i2c_msg msg;
 386         u8 regs[5];
 387         int err;
 388
 389         err = pcf8523_irq_enable(dev, 0);
 390         if (err)
 391                 return err;
 392
 393         err = pcf8523_write(client, PCF8523_REG_CONTROL2, 0);
 394         if (err < 0)
 395                 return err;
 396
 397         /* The alarm has no seconds, round up to nearest minute */
 398         if (tm->time.tm_sec) {
 399                 time64_t alarm_time = rtc_tm_to_time64(&tm->time);
 400
 401                 alarm_time += 60 - tm->time.tm_sec;
 402                 rtc_time64_to_tm(alarm_time, &tm->time);
 403         }
 404
 405         regs[0] = PCF8523_REG_MINUTE_ALARM;
 406         regs[1] = bin2bcd(tm->time.tm_min);
 407         regs[2] = bin2bcd(tm->time.tm_hour);
 408         regs[3] = bin2bcd(tm->time.tm_mday);
 409         regs[4] = ALARM_DIS;
 410         msg.addr = client->addr;
 411         msg.flags = 0;
 412         msg.len = sizeof(regs);
 413         msg.buf = regs;
 414         err = i2c_transfer(client->adapter, &msg, 1);
 415         if (err < 0)
 416                 return err;
 417
 418         if (tm->enabled)
 419                 return pcf8523_irq_enable(dev, tm->enabled);
 420
 421         return 0;
 422 }
 423
 424 #ifdef CONFIG_RTC_INTF_DEV
 425 static int pcf8523_rtc_ioctl(struct device *dev, unsigned int cmd,
 426                              unsigned long arg)
 427 {
 428         struct i2c_client *client = to_i2c_client(dev);
 429         unsigned int flags = 0;
 430         u8 value;
 431         int ret;
 432
 433         switch (cmd) {
 434         case RTC_VL_READ:
 435                 ret = pcf8523_voltage_low(client);
 436                 if (ret < 0)
 437                         return ret;
 438                 if (ret)
 439                         flags |= RTC_VL_BACKUP_LOW;
 440
 441                 ret = pcf8523_read(client, PCF8523_REG_SECONDS, &value);
 442                 if (ret < 0)
 443                         return ret;
 444
 445                 if (value & PCF8523_SECONDS_OS)
 446                         flags |= RTC_VL_DATA_INVALID;
 447
 448                 return put_user(flags, (unsigned int __user *)arg);
 449
 450         default:
 451                 return -ENOIOCTLCMD;
 452         }
 453 }
 454 #else
 455 #define pcf8523_rtc_ioctl NULL
 456 #endif
 457
 458 static int pcf8523_rtc_read_offset(struct device *dev, long *offset)
 459 {
 460         struct i2c_client *client = to_i2c_client(dev);
 461         int err;
 462         u8 value;
 463         s8 val;
 464
 465         err = pcf8523_read(client, PCF8523_REG_OFFSET, &value);
 466         if (err < 0)
 467                 return err;
 468
 469         /* sign extend the 7-bit offset value */
 470         val = value << 1;
 471         *offset = (value & PCF8523_OFFSET_MODE ? 4069 : 4340) * (val >> 1);
 472
 473         return 0;
 474 }
 475
 476 static int pcf8523_rtc_set_offset(struct device *dev, long offset)
 477 {
 478         struct i2c_client *client = to_i2c_client(dev);
 479         long reg_m0, reg_m1;
 480         u8 value;
 481
 482         reg_m0 = clamp(DIV_ROUND_CLOSEST(offset, 4340), -64L, 63L);
 483         reg_m1 = clamp(DIV_ROUND_CLOSEST(offset, 4069), -64L, 63L);
 484
 485         if (abs(reg_m0 * 4340 - offset) < abs(reg_m1 * 4069 - offset))
 486                 value = reg_m0 & 0x7f;
 487         else
 488                 value = (reg_m1 & 0x7f) | PCF8523_OFFSET_MODE;
 489
 490         return pcf8523_write(client, PCF8523_REG_OFFSET, value);
 491 }
 492
 493 static const struct rtc_class_ops pcf8523_rtc_ops = {
 494         .read_time = pcf8523_rtc_read_time,
 495         .set_time = pcf8523_rtc_set_time,
 496         .read_alarm = pcf8523_rtc_read_alarm,
 497         .set_alarm = pcf8523_rtc_set_alarm,
 498         .alarm_irq_enable = pcf8523_irq_enable,
 499         .ioctl = pcf8523_rtc_ioctl,
 500         .read_offset = pcf8523_rtc_read_offset,
 501         .set_offset = pcf8523_rtc_set_offset,
 502 };
 503
 504 static int pcf8523_probe(struct i2c_client *client,
 505                          const struct i2c_device_id *id)
 506 {
 507         struct pcf8523 *pcf8523;
 508         struct rtc_device *rtc;
 509         bool wakeup_source = false;
 510         int err;
 511
 512         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
 513                 return -ENODEV;
 514
 515         pcf8523 = devm_kzalloc(&client->dev, sizeof(struct pcf8523), GFP_KERNEL);
 516         if (!pcf8523)
 517                 return -ENOMEM;
 518
 519         i2c_set_clientdata(client, pcf8523);
 520         pcf8523->client = client;
 521
 522         err = pcf8523_load_capacitance(client);
 523         if (err < 0)
 524                 dev_warn(&client->dev, "failed to set xtal load capacitance: %d",
 525                          err);
 526
 527         err = pcf8523_set_pm(client, 0);
 528         if (err < 0)
 529                 return err;
 530
 531         rtc = devm_rtc_allocate_device(&client->dev);
 532         if (IS_ERR(rtc))
 533                 return PTR_ERR(rtc);
 534
 535         pcf8523->rtc = rtc;
 536         rtc->ops = &pcf8523_rtc_ops;
 537         rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
 538         rtc->range_max = RTC_TIMESTAMP_END_2099;
 539         rtc->uie_unsupported = 1;
 540
 541         if (client->irq > 0) {
 542                 err = pcf8523_write(client, PCF8523_TMR_CLKOUT_CTRL, 0x38);
 543                 if (err < 0)
 544                         return err;
 545
 546                 err = devm_request_threaded_irq(&client->dev, client->irq,
 547                                                 NULL, pcf8523_irq,
 548                                                 IRQF_SHARED | IRQF_ONESHOT | IRQF_TRIGGER_LOW,
 549                                                 dev_name(&rtc->dev), client);
 550                 if (err)
 551                         return err;
 552
 553                 dev_pm_set_wake_irq(&client->dev, client->irq);
 554         }
 555
 556 #ifdef CONFIG_OF
 557         wakeup_source = of_property_read_bool(client->dev.of_node, "wakeup-source");
 558 #endif
 559         if (client->irq > 0 || wakeup_source)
 560                 device_init_wakeup(&client->dev, true);
 561
 562         return devm_rtc_register_device(rtc);
 563 }
 564
 565 static const struct i2c_device_id pcf8523_id[] = {
 566         { "pcf8523", 0 },
 567         { }
 568 };
 569 MODULE_DEVICE_TABLE(i2c, pcf8523_id);
 570
 571 #ifdef CONFIG_OF
 572 static const struct of_device_id pcf8523_of_match[] = {
 573         { .compatible = "nxp,pcf8523" },
 574         { .compatible = "microcrystal,rv8523" },
 575         { }
 576 };
 577 MODULE_DEVICE_TABLE(of, pcf8523_of_match);
 578 #endif
 579
 580 static struct i2c_driver pcf8523_driver = {
 581         .driver = {
 582                 .name = "rtc-pcf8523",
 583                 .of_match_table = of_match_ptr(pcf8523_of_match),
 584         },
 585         .probe = pcf8523_probe,
 586         .id_table = pcf8523_id,
 587 };
 588 module_i2c_driver(pcf8523_driver);
 589
 590 MODULE_AUTHOR("Thierry Reding <thierry.reding@avionic-design.de>");
 591 MODULE_DESCRIPTION("NXP PCF8523 RTC driver");
 592 MODULE_LICENSE("GPL v2");