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