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[7]; 103 int err; 104 105 err = regmap_bulk_read(pcf8523->regmap, PCF8523_REG_SECONDS, regs, 106 sizeof(regs)); 107 if (err < 0) 108 return err; 109 110 if (regs[0] & PCF8523_SECONDS_OS) 111 return -EINVAL; 112 113 tm->tm_sec = bcd2bin(regs[0] & 0x7f); 114 tm->tm_min = bcd2bin(regs[1] & 0x7f); 115 tm->tm_hour = bcd2bin(regs[2] & 0x3f); 116 tm->tm_mday = bcd2bin(regs[3] & 0x3f); 117 tm->tm_wday = regs[4] & 0x7; 118 tm->tm_mon = bcd2bin(regs[5] & 0x1f) - 1; 119 tm->tm_year = bcd2bin(regs[6]) + 100; 120 121 return 0; 122 } 123 124 static int pcf8523_rtc_set_time(struct device *dev, struct rtc_time *tm) 125 { 126 struct pcf8523 *pcf8523 = dev_get_drvdata(dev); 127 u8 regs[7]; 128 int err; 129 130 err = regmap_update_bits(pcf8523->regmap, PCF8523_REG_CONTROL1, 131 PCF8523_CONTROL1_STOP, PCF8523_CONTROL1_STOP); 132 if (err < 0) 133 return err; 134 135 /* This will purposely overwrite PCF8523_SECONDS_OS */ 136 regs[0] = bin2bcd(tm->tm_sec); 137 regs[1] = bin2bcd(tm->tm_min); 138 regs[2] = bin2bcd(tm->tm_hour); 139 regs[3] = bin2bcd(tm->tm_mday); 140 regs[4] = tm->tm_wday; 141 regs[5] = bin2bcd(tm->tm_mon + 1); 142 regs[6] = bin2bcd(tm->tm_year - 100); 143 144 err = regmap_bulk_write(pcf8523->regmap, PCF8523_REG_SECONDS, regs, 145 sizeof(regs)); 146 if (err < 0) { 147 /* 148 * If the time cannot be set, restart the RTC anyway. Note 149 * that errors are ignored if the RTC cannot be started so 150 * that we have a chance to propagate the original error. 151 */ 152 regmap_update_bits(pcf8523->regmap, PCF8523_REG_CONTROL1, 153 PCF8523_CONTROL1_STOP, 0); 154 return err; 155 } 156 157 return regmap_update_bits(pcf8523->regmap, PCF8523_REG_CONTROL1, 158 PCF8523_CONTROL1_STOP, 0); 159 } 160 161 static int pcf8523_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *tm) 162 { 163 struct pcf8523 *pcf8523 = dev_get_drvdata(dev); 164 u8 regs[4]; 165 u32 value; 166 int err; 167 168 err = regmap_bulk_read(pcf8523->regmap, PCF8523_REG_MINUTE_ALARM, regs, 169 sizeof(regs)); 170 if (err < 0) 171 return err; 172 173 tm->time.tm_sec = 0; 174 tm->time.tm_min = bcd2bin(regs[0] & 0x7F); 175 tm->time.tm_hour = bcd2bin(regs[1] & 0x3F); 176 tm->time.tm_mday = bcd2bin(regs[2] & 0x3F); 177 tm->time.tm_wday = bcd2bin(regs[3] & 0x7); 178 179 err = regmap_read(pcf8523->regmap, PCF8523_REG_CONTROL1, &value); 180 if (err < 0) 181 return err; 182 tm->enabled = !!(value & PCF8523_CONTROL1_AIE); 183 184 err = regmap_read(pcf8523->regmap, PCF8523_REG_CONTROL2, &value); 185 if (err < 0) 186 return err; 187 tm->pending = !!(value & PCF8523_CONTROL2_AF); 188 189 return 0; 190 } 191 192 static int pcf8523_irq_enable(struct device *dev, unsigned int enabled) 193 { 194 struct pcf8523 *pcf8523 = dev_get_drvdata(dev); 195 196 return regmap_update_bits(pcf8523->regmap, PCF8523_REG_CONTROL1, 197 PCF8523_CONTROL1_AIE, enabled ? 198 PCF8523_CONTROL1_AIE : 0); 199 } 200 201 static int pcf8523_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *tm) 202 { 203 struct pcf8523 *pcf8523 = dev_get_drvdata(dev); 204 u8 regs[5]; 205 int err; 206 207 err = pcf8523_irq_enable(dev, 0); 208 if (err) 209 return err; 210 211 err = regmap_write(pcf8523->regmap, PCF8523_REG_CONTROL2, 0); 212 if (err < 0) 213 return err; 214 215 /* The alarm has no seconds, round up to nearest minute */ 216 if (tm->time.tm_sec) { 217 time64_t alarm_time = rtc_tm_to_time64(&tm->time); 218 219 alarm_time += 60 - tm->time.tm_sec; 220 rtc_time64_to_tm(alarm_time, &tm->time); 221 } 222 223 regs[0] = bin2bcd(tm->time.tm_min); 224 regs[1] = bin2bcd(tm->time.tm_hour); 225 regs[2] = bin2bcd(tm->time.tm_mday); 226 regs[3] = ALARM_DIS; 227 228 err = regmap_bulk_write(pcf8523->regmap, PCF8523_REG_MINUTE_ALARM, regs, 229 sizeof(regs)); 230 if (err < 0) 231 return err; 232 233 if (tm->enabled) 234 return pcf8523_irq_enable(dev, tm->enabled); 235 236 return 0; 237 } 238 239 static int pcf8523_param_get(struct device *dev, struct rtc_param *param) 240 { 241 struct pcf8523 *pcf8523 = dev_get_drvdata(dev); 242 int ret; 243 244 switch(param->param) { 245 u32 value; 246 247 case RTC_PARAM_BACKUP_SWITCH_MODE: 248 ret = regmap_read(pcf8523->regmap, PCF8523_REG_CONTROL3, &value); 249 if (ret < 0) 250 return ret; 251 252 value = FIELD_GET(PCF8523_CONTROL3_PM, value); 253 254 switch(value) { 255 case 0x0: 256 case 0x4: 257 param->uvalue = RTC_BSM_LEVEL; 258 break; 259 case 0x1: 260 case 0x5: 261 param->uvalue = RTC_BSM_DIRECT; 262 break; 263 case PCF8523_PM_STANDBY: 264 param->uvalue = RTC_BSM_STANDBY; 265 break; 266 default: 267 param->uvalue = RTC_BSM_DISABLED; 268 } 269 270 break; 271 272 default: 273 return -EINVAL; 274 } 275 276 return 0; 277 } 278 279 static int pcf8523_param_set(struct device *dev, struct rtc_param *param) 280 { 281 struct pcf8523 *pcf8523 = dev_get_drvdata(dev); 282 283 switch(param->param) { 284 u8 mode; 285 case RTC_PARAM_BACKUP_SWITCH_MODE: 286 switch (param->uvalue) { 287 case RTC_BSM_DISABLED: 288 mode = 0x2; 289 break; 290 case RTC_BSM_DIRECT: 291 mode = 0x1; 292 break; 293 case RTC_BSM_LEVEL: 294 mode = 0x0; 295 break; 296 case RTC_BSM_STANDBY: 297 mode = PCF8523_PM_STANDBY; 298 break; 299 default: 300 return -EINVAL; 301 } 302 303 return regmap_update_bits(pcf8523->regmap, PCF8523_REG_CONTROL3, 304 PCF8523_CONTROL3_PM, 305 FIELD_PREP(PCF8523_CONTROL3_PM, mode)); 306 307 break; 308 309 default: 310 return -EINVAL; 311 } 312 313 return 0; 314 } 315 316 static int pcf8523_rtc_ioctl(struct device *dev, unsigned int cmd, 317 unsigned long arg) 318 { 319 struct pcf8523 *pcf8523 = dev_get_drvdata(dev); 320 unsigned int flags = 0; 321 u32 value; 322 int ret; 323 324 switch (cmd) { 325 case RTC_VL_READ: 326 ret = regmap_read(pcf8523->regmap, PCF8523_REG_CONTROL3, &value); 327 if (ret < 0) 328 return ret; 329 330 if (value & PCF8523_CONTROL3_BLF) 331 flags |= RTC_VL_BACKUP_LOW; 332 333 ret = regmap_read(pcf8523->regmap, PCF8523_REG_SECONDS, &value); 334 if (ret < 0) 335 return ret; 336 337 if (value & PCF8523_SECONDS_OS) 338 flags |= RTC_VL_DATA_INVALID; 339 340 return put_user(flags, (unsigned int __user *)arg); 341 342 default: 343 return -ENOIOCTLCMD; 344 } 345 } 346 347 static int pcf8523_rtc_read_offset(struct device *dev, long *offset) 348 { 349 struct pcf8523 *pcf8523 = dev_get_drvdata(dev); 350 int err; 351 u32 value; 352 s8 val; 353 354 err = regmap_read(pcf8523->regmap, PCF8523_REG_OFFSET, &value); 355 if (err < 0) 356 return err; 357 358 /* sign extend the 7-bit offset value */ 359 val = value << 1; 360 *offset = (value & PCF8523_OFFSET_MODE ? 4069 : 4340) * (val >> 1); 361 362 return 0; 363 } 364 365 static int pcf8523_rtc_set_offset(struct device *dev, long offset) 366 { 367 struct pcf8523 *pcf8523 = dev_get_drvdata(dev); 368 long reg_m0, reg_m1; 369 u32 value; 370 371 reg_m0 = clamp(DIV_ROUND_CLOSEST(offset, 4340), -64L, 63L); 372 reg_m1 = clamp(DIV_ROUND_CLOSEST(offset, 4069), -64L, 63L); 373 374 if (abs(reg_m0 * 4340 - offset) < abs(reg_m1 * 4069 - offset)) 375 value = reg_m0 & 0x7f; 376 else 377 value = (reg_m1 & 0x7f) | PCF8523_OFFSET_MODE; 378 379 return regmap_write(pcf8523->regmap, PCF8523_REG_OFFSET, value); 380 } 381 382 static const struct rtc_class_ops pcf8523_rtc_ops = { 383 .read_time = pcf8523_rtc_read_time, 384 .set_time = pcf8523_rtc_set_time, 385 .read_alarm = pcf8523_rtc_read_alarm, 386 .set_alarm = pcf8523_rtc_set_alarm, 387 .alarm_irq_enable = pcf8523_irq_enable, 388 .ioctl = pcf8523_rtc_ioctl, 389 .read_offset = pcf8523_rtc_read_offset, 390 .set_offset = pcf8523_rtc_set_offset, 391 .param_get = pcf8523_param_get, 392 .param_set = pcf8523_param_set, 393 }; 394 395 static const struct regmap_config regmap_config = { 396 .reg_bits = 8, 397 .val_bits = 8, 398 .max_register = 0x13, 399 }; 400 401 static int pcf8523_probe(struct i2c_client *client, 402 const struct i2c_device_id *id) 403 { 404 struct pcf8523 *pcf8523; 405 struct rtc_device *rtc; 406 bool wakeup_source = false; 407 u32 value; 408 int err; 409 410 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) 411 return -ENODEV; 412 413 pcf8523 = devm_kzalloc(&client->dev, sizeof(struct pcf8523), GFP_KERNEL); 414 if (!pcf8523) 415 return -ENOMEM; 416 417 pcf8523->regmap = devm_regmap_init_i2c(client, ®map_config); 418 if (IS_ERR(pcf8523->regmap)) 419 return PTR_ERR(pcf8523->regmap); 420 421 i2c_set_clientdata(client, pcf8523); 422 423 rtc = devm_rtc_allocate_device(&client->dev); 424 if (IS_ERR(rtc)) 425 return PTR_ERR(rtc); 426 pcf8523->rtc = rtc; 427 428 err = pcf8523_load_capacitance(pcf8523, client->dev.of_node); 429 if (err < 0) 430 dev_warn(&client->dev, "failed to set xtal load capacitance: %d", 431 err); 432 433 err = regmap_read(pcf8523->regmap, PCF8523_REG_SECONDS, &value); 434 if (err < 0) 435 return err; 436 437 if (value & PCF8523_SECONDS_OS) { 438 err = regmap_read(pcf8523->regmap, PCF8523_REG_CONTROL3, &value); 439 if (err < 0) 440 return err; 441 442 if (FIELD_GET(PCF8523_CONTROL3_PM, value) == PCF8523_PM_STANDBY) { 443 err = regmap_write(pcf8523->regmap, PCF8523_REG_CONTROL3, 444 value & ~PCF8523_CONTROL3_PM); 445 if (err < 0) 446 return err; 447 } 448 } 449 450 rtc->ops = &pcf8523_rtc_ops; 451 rtc->range_min = RTC_TIMESTAMP_BEGIN_2000; 452 rtc->range_max = RTC_TIMESTAMP_END_2099; 453 rtc->uie_unsupported = 1; 454 455 if (client->irq > 0) { 456 err = regmap_write(pcf8523->regmap, PCF8523_TMR_CLKOUT_CTRL, 0x38); 457 if (err < 0) 458 return err; 459 460 err = devm_request_threaded_irq(&client->dev, client->irq, 461 NULL, pcf8523_irq, 462 IRQF_SHARED | IRQF_ONESHOT | IRQF_TRIGGER_LOW, 463 dev_name(&rtc->dev), pcf8523); 464 if (err) 465 return err; 466 467 dev_pm_set_wake_irq(&client->dev, client->irq); 468 } 469 470 wakeup_source = of_property_read_bool(client->dev.of_node, "wakeup-source"); 471 if (client->irq > 0 || wakeup_source) 472 device_init_wakeup(&client->dev, true); 473 474 return devm_rtc_register_device(rtc); 475 } 476 477 static const struct i2c_device_id pcf8523_id[] = { 478 { "pcf8523", 0 }, 479 { } 480 }; 481 MODULE_DEVICE_TABLE(i2c, pcf8523_id); 482 483 static const struct of_device_id pcf8523_of_match[] = { 484 { .compatible = "nxp,pcf8523" }, 485 { .compatible = "microcrystal,rv8523" }, 486 { } 487 }; 488 MODULE_DEVICE_TABLE(of, pcf8523_of_match); 489 490 static struct i2c_driver pcf8523_driver = { 491 .driver = { 492 .name = "rtc-pcf8523", 493 .of_match_table = pcf8523_of_match, 494 }, 495 .probe = pcf8523_probe, 496 .id_table = pcf8523_id, 497 }; 498 module_i2c_driver(pcf8523_driver); 499 500 MODULE_AUTHOR("Thierry Reding <thierry.reding@avionic-design.de>"); 501 MODULE_DESCRIPTION("NXP PCF8523 RTC driver"); 502 MODULE_LICENSE("GPL v2"); 503