1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Micro Crystal RV-3029 / RV-3049 rtc class driver 4 * 5 * Author: Gregory Hermant <gregory.hermant@calao-systems.com> 6 * Michael Buesch <m@bues.ch> 7 * 8 * based on previously existing rtc class drivers 9 */ 10 11 #include <linux/module.h> 12 #include <linux/i2c.h> 13 #include <linux/spi/spi.h> 14 #include <linux/bcd.h> 15 #include <linux/rtc.h> 16 #include <linux/delay.h> 17 #include <linux/of.h> 18 #include <linux/hwmon.h> 19 #include <linux/hwmon-sysfs.h> 20 #include <linux/regmap.h> 21 22 /* Register map */ 23 /* control section */ 24 #define RV3029_ONOFF_CTRL 0x00 25 #define RV3029_ONOFF_CTRL_WE BIT(0) 26 #define RV3029_ONOFF_CTRL_TE BIT(1) 27 #define RV3029_ONOFF_CTRL_TAR BIT(2) 28 #define RV3029_ONOFF_CTRL_EERE BIT(3) 29 #define RV3029_ONOFF_CTRL_SRON BIT(4) 30 #define RV3029_ONOFF_CTRL_TD0 BIT(5) 31 #define RV3029_ONOFF_CTRL_TD1 BIT(6) 32 #define RV3029_ONOFF_CTRL_CLKINT BIT(7) 33 #define RV3029_IRQ_CTRL 0x01 34 #define RV3029_IRQ_CTRL_AIE BIT(0) 35 #define RV3029_IRQ_CTRL_TIE BIT(1) 36 #define RV3029_IRQ_CTRL_V1IE BIT(2) 37 #define RV3029_IRQ_CTRL_V2IE BIT(3) 38 #define RV3029_IRQ_CTRL_SRIE BIT(4) 39 #define RV3029_IRQ_FLAGS 0x02 40 #define RV3029_IRQ_FLAGS_AF BIT(0) 41 #define RV3029_IRQ_FLAGS_TF BIT(1) 42 #define RV3029_IRQ_FLAGS_V1IF BIT(2) 43 #define RV3029_IRQ_FLAGS_V2IF BIT(3) 44 #define RV3029_IRQ_FLAGS_SRF BIT(4) 45 #define RV3029_STATUS 0x03 46 #define RV3029_STATUS_VLOW1 BIT(2) 47 #define RV3029_STATUS_VLOW2 BIT(3) 48 #define RV3029_STATUS_SR BIT(4) 49 #define RV3029_STATUS_PON BIT(5) 50 #define RV3029_STATUS_EEBUSY BIT(7) 51 #define RV3029_RST_CTRL 0x04 52 #define RV3029_RST_CTRL_SYSR BIT(4) 53 #define RV3029_CONTROL_SECTION_LEN 0x05 54 55 /* watch section */ 56 #define RV3029_W_SEC 0x08 57 #define RV3029_W_MINUTES 0x09 58 #define RV3029_W_HOURS 0x0A 59 #define RV3029_REG_HR_12_24 BIT(6) /* 24h/12h mode */ 60 #define RV3029_REG_HR_PM BIT(5) /* PM/AM bit in 12h mode */ 61 #define RV3029_W_DATE 0x0B 62 #define RV3029_W_DAYS 0x0C 63 #define RV3029_W_MONTHS 0x0D 64 #define RV3029_W_YEARS 0x0E 65 #define RV3029_WATCH_SECTION_LEN 0x07 66 67 /* alarm section */ 68 #define RV3029_A_SC 0x10 69 #define RV3029_A_MN 0x11 70 #define RV3029_A_HR 0x12 71 #define RV3029_A_DT 0x13 72 #define RV3029_A_DW 0x14 73 #define RV3029_A_MO 0x15 74 #define RV3029_A_YR 0x16 75 #define RV3029_A_AE_X BIT(7) 76 #define RV3029_ALARM_SECTION_LEN 0x07 77 78 /* timer section */ 79 #define RV3029_TIMER_LOW 0x18 80 #define RV3029_TIMER_HIGH 0x19 81 82 /* temperature section */ 83 #define RV3029_TEMP_PAGE 0x20 84 85 /* eeprom data section */ 86 #define RV3029_E2P_EEDATA1 0x28 87 #define RV3029_E2P_EEDATA2 0x29 88 #define RV3029_E2PDATA_SECTION_LEN 0x02 89 90 /* eeprom control section */ 91 #define RV3029_CONTROL_E2P_EECTRL 0x30 92 #define RV3029_EECTRL_THP BIT(0) /* temp scan interval */ 93 #define RV3029_EECTRL_THE BIT(1) /* thermometer enable */ 94 #define RV3029_EECTRL_FD0 BIT(2) /* CLKOUT */ 95 #define RV3029_EECTRL_FD1 BIT(3) /* CLKOUT */ 96 #define RV3029_TRICKLE_1K BIT(4) /* 1.5K resistance */ 97 #define RV3029_TRICKLE_5K BIT(5) /* 5K resistance */ 98 #define RV3029_TRICKLE_20K BIT(6) /* 20K resistance */ 99 #define RV3029_TRICKLE_80K BIT(7) /* 80K resistance */ 100 #define RV3029_TRICKLE_MASK (RV3029_TRICKLE_1K |\ 101 RV3029_TRICKLE_5K |\ 102 RV3029_TRICKLE_20K |\ 103 RV3029_TRICKLE_80K) 104 #define RV3029_TRICKLE_SHIFT 4 105 #define RV3029_CONTROL_E2P_XOFFS 0x31 /* XTAL offset */ 106 #define RV3029_CONTROL_E2P_XOFFS_SIGN BIT(7) /* Sign: 1->pos, 0->neg */ 107 #define RV3029_CONTROL_E2P_QCOEF 0x32 /* XTAL temp drift coef */ 108 #define RV3029_CONTROL_E2P_TURNOVER 0x33 /* XTAL turnover temp (in *C) */ 109 #define RV3029_CONTROL_E2P_TOV_MASK 0x3F /* XTAL turnover temp mask */ 110 111 /* user ram section */ 112 #define RV3029_RAM_PAGE 0x38 113 #define RV3029_RAM_SECTION_LEN 8 114 115 struct rv3029_data { 116 struct device *dev; 117 struct rtc_device *rtc; 118 struct regmap *regmap; 119 int irq; 120 }; 121 122 static int rv3029_eeprom_busywait(struct rv3029_data *rv3029) 123 { 124 unsigned int sr; 125 int i, ret; 126 127 for (i = 100; i > 0; i--) { 128 ret = regmap_read(rv3029->regmap, RV3029_STATUS, &sr); 129 if (ret < 0) 130 break; 131 if (!(sr & RV3029_STATUS_EEBUSY)) 132 break; 133 usleep_range(1000, 10000); 134 } 135 if (i <= 0) { 136 dev_err(rv3029->dev, "EEPROM busy wait timeout.\n"); 137 return -ETIMEDOUT; 138 } 139 140 return ret; 141 } 142 143 static int rv3029_eeprom_exit(struct rv3029_data *rv3029) 144 { 145 /* Re-enable eeprom refresh */ 146 return regmap_update_bits(rv3029->regmap, RV3029_ONOFF_CTRL, 147 RV3029_ONOFF_CTRL_EERE, 148 RV3029_ONOFF_CTRL_EERE); 149 } 150 151 static int rv3029_eeprom_enter(struct rv3029_data *rv3029) 152 { 153 unsigned int sr; 154 int ret; 155 156 /* Check whether we are in the allowed voltage range. */ 157 ret = regmap_read(rv3029->regmap, RV3029_STATUS, &sr); 158 if (ret < 0) 159 return ret; 160 if (sr & RV3029_STATUS_VLOW2) 161 return -ENODEV; 162 if (sr & RV3029_STATUS_VLOW1) { 163 /* We clear the bits and retry once just in case 164 * we had a brown out in early startup. 165 */ 166 ret = regmap_update_bits(rv3029->regmap, RV3029_STATUS, 167 RV3029_STATUS_VLOW1, 0); 168 if (ret < 0) 169 return ret; 170 usleep_range(1000, 10000); 171 ret = regmap_read(rv3029->regmap, RV3029_STATUS, &sr); 172 if (ret < 0) 173 return ret; 174 if (sr & RV3029_STATUS_VLOW1) { 175 dev_err(rv3029->dev, 176 "Supply voltage is too low to safely access the EEPROM.\n"); 177 return -ENODEV; 178 } 179 } 180 181 /* Disable eeprom refresh. */ 182 ret = regmap_update_bits(rv3029->regmap, RV3029_ONOFF_CTRL, 183 RV3029_ONOFF_CTRL_EERE, 0); 184 if (ret < 0) 185 return ret; 186 187 /* Wait for any previous eeprom accesses to finish. */ 188 ret = rv3029_eeprom_busywait(rv3029); 189 if (ret < 0) 190 rv3029_eeprom_exit(rv3029); 191 192 return ret; 193 } 194 195 static int rv3029_eeprom_read(struct rv3029_data *rv3029, u8 reg, 196 u8 buf[], size_t len) 197 { 198 int ret, err; 199 200 err = rv3029_eeprom_enter(rv3029); 201 if (err < 0) 202 return err; 203 204 ret = regmap_bulk_read(rv3029->regmap, reg, buf, len); 205 206 err = rv3029_eeprom_exit(rv3029); 207 if (err < 0) 208 return err; 209 210 return ret; 211 } 212 213 static int rv3029_eeprom_write(struct rv3029_data *rv3029, u8 reg, 214 u8 const buf[], size_t len) 215 { 216 unsigned int tmp; 217 int ret, err; 218 size_t i; 219 220 err = rv3029_eeprom_enter(rv3029); 221 if (err < 0) 222 return err; 223 224 for (i = 0; i < len; i++, reg++) { 225 ret = regmap_read(rv3029->regmap, reg, &tmp); 226 if (ret < 0) 227 break; 228 if (tmp != buf[i]) { 229 tmp = buf[i]; 230 ret = regmap_write(rv3029->regmap, reg, tmp); 231 if (ret < 0) 232 break; 233 } 234 ret = rv3029_eeprom_busywait(rv3029); 235 if (ret < 0) 236 break; 237 } 238 239 err = rv3029_eeprom_exit(rv3029); 240 if (err < 0) 241 return err; 242 243 return ret; 244 } 245 246 static int rv3029_eeprom_update_bits(struct rv3029_data *rv3029, 247 u8 reg, u8 mask, u8 set) 248 { 249 u8 buf; 250 int ret; 251 252 ret = rv3029_eeprom_read(rv3029, reg, &buf, 1); 253 if (ret < 0) 254 return ret; 255 buf &= ~mask; 256 buf |= set & mask; 257 ret = rv3029_eeprom_write(rv3029, reg, &buf, 1); 258 if (ret < 0) 259 return ret; 260 261 return 0; 262 } 263 264 static irqreturn_t rv3029_handle_irq(int irq, void *dev_id) 265 { 266 struct device *dev = dev_id; 267 struct rv3029_data *rv3029 = dev_get_drvdata(dev); 268 struct mutex *lock = &rv3029->rtc->ops_lock; 269 unsigned int flags, controls; 270 unsigned long events = 0; 271 int ret; 272 273 mutex_lock(lock); 274 275 ret = regmap_read(rv3029->regmap, RV3029_IRQ_CTRL, &controls); 276 if (ret) { 277 dev_warn(dev, "Read IRQ Control Register error %d\n", ret); 278 mutex_unlock(lock); 279 return IRQ_NONE; 280 } 281 282 ret = regmap_read(rv3029->regmap, RV3029_IRQ_FLAGS, &flags); 283 if (ret) { 284 dev_warn(dev, "Read IRQ Flags Register error %d\n", ret); 285 mutex_unlock(lock); 286 return IRQ_NONE; 287 } 288 289 if (flags & RV3029_IRQ_FLAGS_AF) { 290 flags &= ~RV3029_IRQ_FLAGS_AF; 291 controls &= ~RV3029_IRQ_CTRL_AIE; 292 events |= RTC_AF; 293 } 294 295 if (events) { 296 rtc_update_irq(rv3029->rtc, 1, events); 297 regmap_write(rv3029->regmap, RV3029_IRQ_FLAGS, flags); 298 regmap_write(rv3029->regmap, RV3029_IRQ_CTRL, controls); 299 } 300 mutex_unlock(lock); 301 302 return IRQ_HANDLED; 303 } 304 305 static int rv3029_read_time(struct device *dev, struct rtc_time *tm) 306 { 307 struct rv3029_data *rv3029 = dev_get_drvdata(dev); 308 unsigned int sr; 309 int ret; 310 u8 regs[RV3029_WATCH_SECTION_LEN] = { 0, }; 311 312 ret = regmap_read(rv3029->regmap, RV3029_STATUS, &sr); 313 if (ret < 0) 314 return ret; 315 316 if (sr & (RV3029_STATUS_VLOW2 | RV3029_STATUS_PON)) 317 return -EINVAL; 318 319 ret = regmap_bulk_read(rv3029->regmap, RV3029_W_SEC, regs, 320 RV3029_WATCH_SECTION_LEN); 321 if (ret < 0) 322 return ret; 323 324 tm->tm_sec = bcd2bin(regs[RV3029_W_SEC - RV3029_W_SEC]); 325 tm->tm_min = bcd2bin(regs[RV3029_W_MINUTES - RV3029_W_SEC]); 326 327 /* HR field has a more complex interpretation */ 328 { 329 const u8 _hr = regs[RV3029_W_HOURS - RV3029_W_SEC]; 330 331 if (_hr & RV3029_REG_HR_12_24) { 332 /* 12h format */ 333 tm->tm_hour = bcd2bin(_hr & 0x1f); 334 if (_hr & RV3029_REG_HR_PM) /* PM flag set */ 335 tm->tm_hour += 12; 336 } else /* 24h format */ 337 tm->tm_hour = bcd2bin(_hr & 0x3f); 338 } 339 340 tm->tm_mday = bcd2bin(regs[RV3029_W_DATE - RV3029_W_SEC]); 341 tm->tm_mon = bcd2bin(regs[RV3029_W_MONTHS - RV3029_W_SEC]) - 1; 342 tm->tm_year = bcd2bin(regs[RV3029_W_YEARS - RV3029_W_SEC]) + 100; 343 tm->tm_wday = bcd2bin(regs[RV3029_W_DAYS - RV3029_W_SEC]) - 1; 344 345 return 0; 346 } 347 348 static int rv3029_read_alarm(struct device *dev, struct rtc_wkalrm *alarm) 349 { 350 struct rv3029_data *rv3029 = dev_get_drvdata(dev); 351 struct rtc_time *const tm = &alarm->time; 352 unsigned int controls, flags; 353 int ret; 354 u8 regs[8]; 355 356 ret = regmap_bulk_read(rv3029->regmap, RV3029_A_SC, regs, 357 RV3029_ALARM_SECTION_LEN); 358 if (ret < 0) 359 return ret; 360 361 ret = regmap_read(rv3029->regmap, RV3029_IRQ_CTRL, &controls); 362 if (ret) 363 return ret; 364 365 ret = regmap_read(rv3029->regmap, RV3029_IRQ_FLAGS, &flags); 366 if (ret < 0) 367 return ret; 368 369 tm->tm_sec = bcd2bin(regs[RV3029_A_SC - RV3029_A_SC] & 0x7f); 370 tm->tm_min = bcd2bin(regs[RV3029_A_MN - RV3029_A_SC] & 0x7f); 371 tm->tm_hour = bcd2bin(regs[RV3029_A_HR - RV3029_A_SC] & 0x3f); 372 tm->tm_mday = bcd2bin(regs[RV3029_A_DT - RV3029_A_SC] & 0x3f); 373 tm->tm_mon = bcd2bin(regs[RV3029_A_MO - RV3029_A_SC] & 0x1f) - 1; 374 tm->tm_year = bcd2bin(regs[RV3029_A_YR - RV3029_A_SC] & 0x7f) + 100; 375 tm->tm_wday = bcd2bin(regs[RV3029_A_DW - RV3029_A_SC] & 0x07) - 1; 376 377 alarm->enabled = !!(controls & RV3029_IRQ_CTRL_AIE); 378 alarm->pending = (flags & RV3029_IRQ_FLAGS_AF) && alarm->enabled; 379 380 return 0; 381 } 382 383 static int rv3029_alarm_irq_enable(struct device *dev, unsigned int enable) 384 { 385 struct rv3029_data *rv3029 = dev_get_drvdata(dev); 386 387 return regmap_update_bits(rv3029->regmap, RV3029_IRQ_CTRL, 388 RV3029_IRQ_CTRL_AIE, 389 enable ? RV3029_IRQ_CTRL_AIE : 0); 390 } 391 392 static int rv3029_set_alarm(struct device *dev, struct rtc_wkalrm *alarm) 393 { 394 struct rv3029_data *rv3029 = dev_get_drvdata(dev); 395 struct rtc_time *const tm = &alarm->time; 396 int ret; 397 u8 regs[8]; 398 399 /* Activate all the alarms with AE_x bit */ 400 regs[RV3029_A_SC - RV3029_A_SC] = bin2bcd(tm->tm_sec) | RV3029_A_AE_X; 401 regs[RV3029_A_MN - RV3029_A_SC] = bin2bcd(tm->tm_min) | RV3029_A_AE_X; 402 regs[RV3029_A_HR - RV3029_A_SC] = (bin2bcd(tm->tm_hour) & 0x3f) 403 | RV3029_A_AE_X; 404 regs[RV3029_A_DT - RV3029_A_SC] = (bin2bcd(tm->tm_mday) & 0x3f) 405 | RV3029_A_AE_X; 406 regs[RV3029_A_MO - RV3029_A_SC] = (bin2bcd(tm->tm_mon + 1) & 0x1f) 407 | RV3029_A_AE_X; 408 regs[RV3029_A_DW - RV3029_A_SC] = (bin2bcd(tm->tm_wday + 1) & 0x7) 409 | RV3029_A_AE_X; 410 regs[RV3029_A_YR - RV3029_A_SC] = (bin2bcd(tm->tm_year - 100)) 411 | RV3029_A_AE_X; 412 413 /* Write the alarm */ 414 ret = regmap_bulk_write(rv3029->regmap, RV3029_A_SC, regs, 415 RV3029_ALARM_SECTION_LEN); 416 if (ret < 0) 417 return ret; 418 419 return rv3029_alarm_irq_enable(dev, alarm->enabled); 420 } 421 422 static int rv3029_set_time(struct device *dev, struct rtc_time *tm) 423 { 424 struct rv3029_data *rv3029 = dev_get_drvdata(dev); 425 u8 regs[8]; 426 int ret; 427 428 regs[RV3029_W_SEC - RV3029_W_SEC] = bin2bcd(tm->tm_sec); 429 regs[RV3029_W_MINUTES - RV3029_W_SEC] = bin2bcd(tm->tm_min); 430 regs[RV3029_W_HOURS - RV3029_W_SEC] = bin2bcd(tm->tm_hour); 431 regs[RV3029_W_DATE - RV3029_W_SEC] = bin2bcd(tm->tm_mday); 432 regs[RV3029_W_MONTHS - RV3029_W_SEC] = bin2bcd(tm->tm_mon + 1); 433 regs[RV3029_W_DAYS - RV3029_W_SEC] = bin2bcd(tm->tm_wday + 1) & 0x7; 434 regs[RV3029_W_YEARS - RV3029_W_SEC] = bin2bcd(tm->tm_year - 100); 435 436 ret = regmap_bulk_write(rv3029->regmap, RV3029_W_SEC, regs, 437 RV3029_WATCH_SECTION_LEN); 438 if (ret < 0) 439 return ret; 440 441 /* clear PON and VLOW2 bits */ 442 return regmap_update_bits(rv3029->regmap, RV3029_STATUS, 443 RV3029_STATUS_PON | RV3029_STATUS_VLOW2, 0); 444 } 445 446 static int rv3029_ioctl(struct device *dev, unsigned int cmd, unsigned long arg) 447 { 448 struct rv3029_data *rv3029 = dev_get_drvdata(dev); 449 unsigned long vl = 0; 450 int sr, ret = 0; 451 452 switch (cmd) { 453 case RTC_VL_READ: 454 ret = regmap_read(rv3029->regmap, RV3029_STATUS, &sr); 455 if (ret < 0) 456 return ret; 457 458 if (sr & RV3029_STATUS_VLOW1) 459 vl = RTC_VL_ACCURACY_LOW; 460 461 if (sr & (RV3029_STATUS_VLOW2 | RV3029_STATUS_PON)) 462 vl |= RTC_VL_DATA_INVALID; 463 464 return put_user(vl, (unsigned int __user *)arg); 465 466 case RTC_VL_CLR: 467 return regmap_update_bits(rv3029->regmap, RV3029_STATUS, 468 RV3029_STATUS_VLOW1, 0); 469 470 default: 471 return -ENOIOCTLCMD; 472 } 473 } 474 475 static int rv3029_nvram_write(void *priv, unsigned int offset, void *val, 476 size_t bytes) 477 { 478 return regmap_bulk_write(priv, RV3029_RAM_PAGE + offset, val, bytes); 479 } 480 481 static int rv3029_nvram_read(void *priv, unsigned int offset, void *val, 482 size_t bytes) 483 { 484 return regmap_bulk_read(priv, RV3029_RAM_PAGE + offset, val, bytes); 485 } 486 487 static const struct rv3029_trickle_tab_elem { 488 u32 r; /* resistance in ohms */ 489 u8 conf; /* trickle config bits */ 490 } rv3029_trickle_tab[] = { 491 { 492 .r = 1076, 493 .conf = RV3029_TRICKLE_1K | RV3029_TRICKLE_5K | 494 RV3029_TRICKLE_20K | RV3029_TRICKLE_80K, 495 }, { 496 .r = 1091, 497 .conf = RV3029_TRICKLE_1K | RV3029_TRICKLE_5K | 498 RV3029_TRICKLE_20K, 499 }, { 500 .r = 1137, 501 .conf = RV3029_TRICKLE_1K | RV3029_TRICKLE_5K | 502 RV3029_TRICKLE_80K, 503 }, { 504 .r = 1154, 505 .conf = RV3029_TRICKLE_1K | RV3029_TRICKLE_5K, 506 }, { 507 .r = 1371, 508 .conf = RV3029_TRICKLE_1K | RV3029_TRICKLE_20K | 509 RV3029_TRICKLE_80K, 510 }, { 511 .r = 1395, 512 .conf = RV3029_TRICKLE_1K | RV3029_TRICKLE_20K, 513 }, { 514 .r = 1472, 515 .conf = RV3029_TRICKLE_1K | RV3029_TRICKLE_80K, 516 }, { 517 .r = 1500, 518 .conf = RV3029_TRICKLE_1K, 519 }, { 520 .r = 3810, 521 .conf = RV3029_TRICKLE_5K | RV3029_TRICKLE_20K | 522 RV3029_TRICKLE_80K, 523 }, { 524 .r = 4000, 525 .conf = RV3029_TRICKLE_5K | RV3029_TRICKLE_20K, 526 }, { 527 .r = 4706, 528 .conf = RV3029_TRICKLE_5K | RV3029_TRICKLE_80K, 529 }, { 530 .r = 5000, 531 .conf = RV3029_TRICKLE_5K, 532 }, { 533 .r = 16000, 534 .conf = RV3029_TRICKLE_20K | RV3029_TRICKLE_80K, 535 }, { 536 .r = 20000, 537 .conf = RV3029_TRICKLE_20K, 538 }, { 539 .r = 80000, 540 .conf = RV3029_TRICKLE_80K, 541 }, 542 }; 543 544 static void rv3029_trickle_config(struct device *dev) 545 { 546 struct rv3029_data *rv3029 = dev_get_drvdata(dev); 547 struct device_node *of_node = dev->of_node; 548 const struct rv3029_trickle_tab_elem *elem; 549 int i, err; 550 u32 ohms; 551 u8 trickle_set_bits; 552 553 if (!of_node) 554 return; 555 556 /* Configure the trickle charger. */ 557 err = of_property_read_u32(of_node, "trickle-resistor-ohms", &ohms); 558 if (err) { 559 /* Disable trickle charger. */ 560 trickle_set_bits = 0; 561 } else { 562 /* Enable trickle charger. */ 563 for (i = 0; i < ARRAY_SIZE(rv3029_trickle_tab); i++) { 564 elem = &rv3029_trickle_tab[i]; 565 if (elem->r >= ohms) 566 break; 567 } 568 trickle_set_bits = elem->conf; 569 dev_info(dev, 570 "Trickle charger enabled at %d ohms resistance.\n", 571 elem->r); 572 } 573 err = rv3029_eeprom_update_bits(rv3029, RV3029_CONTROL_E2P_EECTRL, 574 RV3029_TRICKLE_MASK, 575 trickle_set_bits); 576 if (err < 0) 577 dev_err(dev, "Failed to update trickle charger config\n"); 578 } 579 580 #ifdef CONFIG_RTC_DRV_RV3029_HWMON 581 582 static int rv3029_read_temp(struct rv3029_data *rv3029, int *temp_mC) 583 { 584 unsigned int temp; 585 int ret; 586 587 ret = regmap_read(rv3029->regmap, RV3029_TEMP_PAGE, &temp); 588 if (ret < 0) 589 return ret; 590 591 *temp_mC = ((int)temp - 60) * 1000; 592 593 return 0; 594 } 595 596 static ssize_t rv3029_hwmon_show_temp(struct device *dev, 597 struct device_attribute *attr, 598 char *buf) 599 { 600 struct rv3029_data *rv3029 = dev_get_drvdata(dev); 601 int ret, temp_mC; 602 603 ret = rv3029_read_temp(rv3029, &temp_mC); 604 if (ret < 0) 605 return ret; 606 607 return sprintf(buf, "%d\n", temp_mC); 608 } 609 610 static ssize_t rv3029_hwmon_set_update_interval(struct device *dev, 611 struct device_attribute *attr, 612 const char *buf, 613 size_t count) 614 { 615 struct rv3029_data *rv3029 = dev_get_drvdata(dev); 616 unsigned int th_set_bits = 0; 617 unsigned long interval_ms; 618 int ret; 619 620 ret = kstrtoul(buf, 10, &interval_ms); 621 if (ret < 0) 622 return ret; 623 624 if (interval_ms != 0) { 625 th_set_bits |= RV3029_EECTRL_THE; 626 if (interval_ms >= 16000) 627 th_set_bits |= RV3029_EECTRL_THP; 628 } 629 ret = rv3029_eeprom_update_bits(rv3029, RV3029_CONTROL_E2P_EECTRL, 630 RV3029_EECTRL_THE | RV3029_EECTRL_THP, 631 th_set_bits); 632 if (ret < 0) 633 return ret; 634 635 return count; 636 } 637 638 static ssize_t rv3029_hwmon_show_update_interval(struct device *dev, 639 struct device_attribute *attr, 640 char *buf) 641 { 642 struct rv3029_data *rv3029 = dev_get_drvdata(dev); 643 int ret, interval_ms; 644 u8 eectrl; 645 646 ret = rv3029_eeprom_read(rv3029, RV3029_CONTROL_E2P_EECTRL, 647 &eectrl, 1); 648 if (ret < 0) 649 return ret; 650 651 if (eectrl & RV3029_EECTRL_THE) { 652 if (eectrl & RV3029_EECTRL_THP) 653 interval_ms = 16000; 654 else 655 interval_ms = 1000; 656 } else { 657 interval_ms = 0; 658 } 659 660 return sprintf(buf, "%d\n", interval_ms); 661 } 662 663 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, rv3029_hwmon_show_temp, 664 NULL, 0); 665 static SENSOR_DEVICE_ATTR(update_interval, S_IWUSR | S_IRUGO, 666 rv3029_hwmon_show_update_interval, 667 rv3029_hwmon_set_update_interval, 0); 668 669 static struct attribute *rv3029_hwmon_attrs[] = { 670 &sensor_dev_attr_temp1_input.dev_attr.attr, 671 &sensor_dev_attr_update_interval.dev_attr.attr, 672 NULL, 673 }; 674 ATTRIBUTE_GROUPS(rv3029_hwmon); 675 676 static void rv3029_hwmon_register(struct device *dev, const char *name) 677 { 678 struct rv3029_data *rv3029 = dev_get_drvdata(dev); 679 struct device *hwmon_dev; 680 681 hwmon_dev = devm_hwmon_device_register_with_groups(dev, name, rv3029, 682 rv3029_hwmon_groups); 683 if (IS_ERR(hwmon_dev)) { 684 dev_warn(dev, "unable to register hwmon device %ld\n", 685 PTR_ERR(hwmon_dev)); 686 } 687 } 688 689 #else /* CONFIG_RTC_DRV_RV3029_HWMON */ 690 691 static void rv3029_hwmon_register(struct device *dev, const char *name) 692 { 693 } 694 695 #endif /* CONFIG_RTC_DRV_RV3029_HWMON */ 696 697 static struct rtc_class_ops rv3029_rtc_ops = { 698 .read_time = rv3029_read_time, 699 .set_time = rv3029_set_time, 700 .ioctl = rv3029_ioctl, 701 }; 702 703 static int rv3029_probe(struct device *dev, struct regmap *regmap, int irq, 704 const char *name) 705 { 706 struct rv3029_data *rv3029; 707 struct nvmem_config nvmem_cfg = { 708 .name = "rv3029_nvram", 709 .word_size = 1, 710 .stride = 1, 711 .size = RV3029_RAM_SECTION_LEN, 712 .type = NVMEM_TYPE_BATTERY_BACKED, 713 .reg_read = rv3029_nvram_read, 714 .reg_write = rv3029_nvram_write, 715 }; 716 int rc = 0; 717 718 rv3029 = devm_kzalloc(dev, sizeof(*rv3029), GFP_KERNEL); 719 if (!rv3029) 720 return -ENOMEM; 721 722 rv3029->regmap = regmap; 723 rv3029->irq = irq; 724 rv3029->dev = dev; 725 dev_set_drvdata(dev, rv3029); 726 727 rv3029_trickle_config(dev); 728 rv3029_hwmon_register(dev, name); 729 730 rv3029->rtc = devm_rtc_allocate_device(dev); 731 if (IS_ERR(rv3029->rtc)) 732 return PTR_ERR(rv3029->rtc); 733 734 if (rv3029->irq > 0) { 735 rc = devm_request_threaded_irq(dev, rv3029->irq, 736 NULL, rv3029_handle_irq, 737 IRQF_TRIGGER_LOW | IRQF_ONESHOT, 738 "rv3029", dev); 739 if (rc) { 740 dev_warn(dev, "unable to request IRQ, alarms disabled\n"); 741 rv3029->irq = 0; 742 } else { 743 rv3029_rtc_ops.read_alarm = rv3029_read_alarm; 744 rv3029_rtc_ops.set_alarm = rv3029_set_alarm; 745 rv3029_rtc_ops.alarm_irq_enable = rv3029_alarm_irq_enable; 746 } 747 } 748 749 rv3029->rtc->ops = &rv3029_rtc_ops; 750 rv3029->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000; 751 rv3029->rtc->range_max = RTC_TIMESTAMP_END_2079; 752 753 rc = devm_rtc_register_device(rv3029->rtc); 754 if (rc) 755 return rc; 756 757 nvmem_cfg.priv = rv3029->regmap; 758 devm_rtc_nvmem_register(rv3029->rtc, &nvmem_cfg); 759 760 return 0; 761 } 762 763 static const struct regmap_range rv3029_holes_range[] = { 764 regmap_reg_range(0x05, 0x07), 765 regmap_reg_range(0x0f, 0x0f), 766 regmap_reg_range(0x17, 0x17), 767 regmap_reg_range(0x1a, 0x1f), 768 regmap_reg_range(0x21, 0x27), 769 regmap_reg_range(0x34, 0x37), 770 }; 771 772 static const struct regmap_access_table rv3029_regs = { 773 .no_ranges = rv3029_holes_range, 774 .n_no_ranges = ARRAY_SIZE(rv3029_holes_range), 775 }; 776 777 static const struct regmap_config config = { 778 .reg_bits = 8, 779 .val_bits = 8, 780 .rd_table = &rv3029_regs, 781 .wr_table = &rv3029_regs, 782 .max_register = 0x3f, 783 }; 784 785 #if IS_ENABLED(CONFIG_I2C) 786 787 static int rv3029_i2c_probe(struct i2c_client *client, 788 const struct i2c_device_id *id) 789 { 790 struct regmap *regmap; 791 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_I2C_BLOCK | 792 I2C_FUNC_SMBUS_BYTE)) { 793 dev_err(&client->dev, "Adapter does not support SMBUS_I2C_BLOCK or SMBUS_I2C_BYTE\n"); 794 return -ENODEV; 795 } 796 797 regmap = devm_regmap_init_i2c(client, &config); 798 if (IS_ERR(regmap)) 799 return PTR_ERR(regmap); 800 801 return rv3029_probe(&client->dev, regmap, client->irq, client->name); 802 } 803 804 static const struct i2c_device_id rv3029_id[] = { 805 { "rv3029", 0 }, 806 { "rv3029c2", 0 }, 807 { } 808 }; 809 MODULE_DEVICE_TABLE(i2c, rv3029_id); 810 811 static const struct of_device_id rv3029_of_match[] = { 812 { .compatible = "microcrystal,rv3029" }, 813 { } 814 }; 815 MODULE_DEVICE_TABLE(of, rv3029_of_match); 816 817 static struct i2c_driver rv3029_driver = { 818 .driver = { 819 .name = "rv3029", 820 .of_match_table = of_match_ptr(rv3029_of_match), 821 }, 822 .probe = rv3029_i2c_probe, 823 .id_table = rv3029_id, 824 }; 825 826 static int __init rv3029_register_driver(void) 827 { 828 return i2c_add_driver(&rv3029_driver); 829 } 830 831 static void rv3029_unregister_driver(void) 832 { 833 i2c_del_driver(&rv3029_driver); 834 } 835 836 #else 837 838 static int __init rv3029_register_driver(void) 839 { 840 return 0; 841 } 842 843 static void rv3029_unregister_driver(void) 844 { 845 } 846 847 #endif 848 849 #if IS_ENABLED(CONFIG_SPI_MASTER) 850 851 static int rv3049_probe(struct spi_device *spi) 852 { 853 struct regmap *regmap; 854 855 regmap = devm_regmap_init_spi(spi, &config); 856 if (IS_ERR(regmap)) 857 return PTR_ERR(regmap); 858 859 return rv3029_probe(&spi->dev, regmap, spi->irq, "rv3049"); 860 } 861 862 static struct spi_driver rv3049_driver = { 863 .driver = { 864 .name = "rv3049", 865 }, 866 .probe = rv3049_probe, 867 }; 868 869 static int __init rv3049_register_driver(void) 870 { 871 return spi_register_driver(&rv3049_driver); 872 } 873 874 static void __exit rv3049_unregister_driver(void) 875 { 876 spi_unregister_driver(&rv3049_driver); 877 } 878 879 #else 880 881 static int __init rv3049_register_driver(void) 882 { 883 return 0; 884 } 885 886 static void __exit rv3049_unregister_driver(void) 887 { 888 } 889 890 #endif 891 892 static int __init rv30x9_init(void) 893 { 894 int ret; 895 896 ret = rv3029_register_driver(); 897 if (ret) 898 return ret; 899 900 ret = rv3049_register_driver(); 901 if (ret) 902 rv3029_unregister_driver(); 903 904 return ret; 905 } 906 module_init(rv30x9_init) 907 908 static void __exit rv30x9_exit(void) 909 { 910 rv3049_unregister_driver(); 911 rv3029_unregister_driver(); 912 } 913 module_exit(rv30x9_exit) 914 915 MODULE_AUTHOR("Gregory Hermant <gregory.hermant@calao-systems.com>"); 916 MODULE_AUTHOR("Michael Buesch <m@bues.ch>"); 917 MODULE_DESCRIPTION("Micro Crystal RV3029/RV3049 RTC driver"); 918 MODULE_LICENSE("GPL"); 919 MODULE_ALIAS("spi:rv3049"); 920