rtc-rv3029c2.c (22876B)
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 115struct rv3029_data { 116 struct device *dev; 117 struct rtc_device *rtc; 118 struct regmap *regmap; 119 int irq; 120}; 121 122static 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 143static 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 151static 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 195static 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 213static 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 246static 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 264static 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 unsigned int flags, controls; 269 unsigned long events = 0; 270 int ret; 271 272 rtc_lock(rv3029->rtc); 273 274 ret = regmap_read(rv3029->regmap, RV3029_IRQ_CTRL, &controls); 275 if (ret) { 276 dev_warn(dev, "Read IRQ Control Register error %d\n", ret); 277 rtc_unlock(rv3029->rtc); 278 return IRQ_NONE; 279 } 280 281 ret = regmap_read(rv3029->regmap, RV3029_IRQ_FLAGS, &flags); 282 if (ret) { 283 dev_warn(dev, "Read IRQ Flags Register error %d\n", ret); 284 rtc_unlock(rv3029->rtc); 285 return IRQ_NONE; 286 } 287 288 if (flags & RV3029_IRQ_FLAGS_AF) { 289 flags &= ~RV3029_IRQ_FLAGS_AF; 290 controls &= ~RV3029_IRQ_CTRL_AIE; 291 events |= RTC_AF; 292 } 293 294 if (events) { 295 rtc_update_irq(rv3029->rtc, 1, events); 296 regmap_write(rv3029->regmap, RV3029_IRQ_FLAGS, flags); 297 regmap_write(rv3029->regmap, RV3029_IRQ_CTRL, controls); 298 } 299 rtc_unlock(rv3029->rtc); 300 301 return IRQ_HANDLED; 302} 303 304static int rv3029_read_time(struct device *dev, struct rtc_time *tm) 305{ 306 struct rv3029_data *rv3029 = dev_get_drvdata(dev); 307 unsigned int sr; 308 int ret; 309 u8 regs[RV3029_WATCH_SECTION_LEN] = { 0, }; 310 311 ret = regmap_read(rv3029->regmap, RV3029_STATUS, &sr); 312 if (ret < 0) 313 return ret; 314 315 if (sr & (RV3029_STATUS_VLOW2 | RV3029_STATUS_PON)) 316 return -EINVAL; 317 318 ret = regmap_bulk_read(rv3029->regmap, RV3029_W_SEC, regs, 319 RV3029_WATCH_SECTION_LEN); 320 if (ret < 0) 321 return ret; 322 323 tm->tm_sec = bcd2bin(regs[RV3029_W_SEC - RV3029_W_SEC]); 324 tm->tm_min = bcd2bin(regs[RV3029_W_MINUTES - RV3029_W_SEC]); 325 326 /* HR field has a more complex interpretation */ 327 { 328 const u8 _hr = regs[RV3029_W_HOURS - RV3029_W_SEC]; 329 330 if (_hr & RV3029_REG_HR_12_24) { 331 /* 12h format */ 332 tm->tm_hour = bcd2bin(_hr & 0x1f); 333 if (_hr & RV3029_REG_HR_PM) /* PM flag set */ 334 tm->tm_hour += 12; 335 } else /* 24h format */ 336 tm->tm_hour = bcd2bin(_hr & 0x3f); 337 } 338 339 tm->tm_mday = bcd2bin(regs[RV3029_W_DATE - RV3029_W_SEC]); 340 tm->tm_mon = bcd2bin(regs[RV3029_W_MONTHS - RV3029_W_SEC]) - 1; 341 tm->tm_year = bcd2bin(regs[RV3029_W_YEARS - RV3029_W_SEC]) + 100; 342 tm->tm_wday = bcd2bin(regs[RV3029_W_DAYS - RV3029_W_SEC]) - 1; 343 344 return 0; 345} 346 347static int rv3029_read_alarm(struct device *dev, struct rtc_wkalrm *alarm) 348{ 349 struct rv3029_data *rv3029 = dev_get_drvdata(dev); 350 struct rtc_time *const tm = &alarm->time; 351 unsigned int controls, flags; 352 int ret; 353 u8 regs[8]; 354 355 ret = regmap_bulk_read(rv3029->regmap, RV3029_A_SC, regs, 356 RV3029_ALARM_SECTION_LEN); 357 if (ret < 0) 358 return ret; 359 360 ret = regmap_read(rv3029->regmap, RV3029_IRQ_CTRL, &controls); 361 if (ret) 362 return ret; 363 364 ret = regmap_read(rv3029->regmap, RV3029_IRQ_FLAGS, &flags); 365 if (ret < 0) 366 return ret; 367 368 tm->tm_sec = bcd2bin(regs[RV3029_A_SC - RV3029_A_SC] & 0x7f); 369 tm->tm_min = bcd2bin(regs[RV3029_A_MN - RV3029_A_SC] & 0x7f); 370 tm->tm_hour = bcd2bin(regs[RV3029_A_HR - RV3029_A_SC] & 0x3f); 371 tm->tm_mday = bcd2bin(regs[RV3029_A_DT - RV3029_A_SC] & 0x3f); 372 tm->tm_mon = bcd2bin(regs[RV3029_A_MO - RV3029_A_SC] & 0x1f) - 1; 373 tm->tm_year = bcd2bin(regs[RV3029_A_YR - RV3029_A_SC] & 0x7f) + 100; 374 tm->tm_wday = bcd2bin(regs[RV3029_A_DW - RV3029_A_SC] & 0x07) - 1; 375 376 alarm->enabled = !!(controls & RV3029_IRQ_CTRL_AIE); 377 alarm->pending = (flags & RV3029_IRQ_FLAGS_AF) && alarm->enabled; 378 379 return 0; 380} 381 382static int rv3029_alarm_irq_enable(struct device *dev, unsigned int enable) 383{ 384 struct rv3029_data *rv3029 = dev_get_drvdata(dev); 385 386 return regmap_update_bits(rv3029->regmap, RV3029_IRQ_CTRL, 387 RV3029_IRQ_CTRL_AIE, 388 enable ? RV3029_IRQ_CTRL_AIE : 0); 389} 390 391static int rv3029_set_alarm(struct device *dev, struct rtc_wkalrm *alarm) 392{ 393 struct rv3029_data *rv3029 = dev_get_drvdata(dev); 394 struct rtc_time *const tm = &alarm->time; 395 int ret; 396 u8 regs[8]; 397 398 /* Activate all the alarms with AE_x bit */ 399 regs[RV3029_A_SC - RV3029_A_SC] = bin2bcd(tm->tm_sec) | RV3029_A_AE_X; 400 regs[RV3029_A_MN - RV3029_A_SC] = bin2bcd(tm->tm_min) | RV3029_A_AE_X; 401 regs[RV3029_A_HR - RV3029_A_SC] = (bin2bcd(tm->tm_hour) & 0x3f) 402 | RV3029_A_AE_X; 403 regs[RV3029_A_DT - RV3029_A_SC] = (bin2bcd(tm->tm_mday) & 0x3f) 404 | RV3029_A_AE_X; 405 regs[RV3029_A_MO - RV3029_A_SC] = (bin2bcd(tm->tm_mon + 1) & 0x1f) 406 | RV3029_A_AE_X; 407 regs[RV3029_A_DW - RV3029_A_SC] = (bin2bcd(tm->tm_wday + 1) & 0x7) 408 | RV3029_A_AE_X; 409 regs[RV3029_A_YR - RV3029_A_SC] = (bin2bcd(tm->tm_year - 100)) 410 | RV3029_A_AE_X; 411 412 /* Write the alarm */ 413 ret = regmap_bulk_write(rv3029->regmap, RV3029_A_SC, regs, 414 RV3029_ALARM_SECTION_LEN); 415 if (ret < 0) 416 return ret; 417 418 return rv3029_alarm_irq_enable(dev, alarm->enabled); 419} 420 421static int rv3029_set_time(struct device *dev, struct rtc_time *tm) 422{ 423 struct rv3029_data *rv3029 = dev_get_drvdata(dev); 424 u8 regs[8]; 425 int ret; 426 427 regs[RV3029_W_SEC - RV3029_W_SEC] = bin2bcd(tm->tm_sec); 428 regs[RV3029_W_MINUTES - RV3029_W_SEC] = bin2bcd(tm->tm_min); 429 regs[RV3029_W_HOURS - RV3029_W_SEC] = bin2bcd(tm->tm_hour); 430 regs[RV3029_W_DATE - RV3029_W_SEC] = bin2bcd(tm->tm_mday); 431 regs[RV3029_W_MONTHS - RV3029_W_SEC] = bin2bcd(tm->tm_mon + 1); 432 regs[RV3029_W_DAYS - RV3029_W_SEC] = bin2bcd(tm->tm_wday + 1) & 0x7; 433 regs[RV3029_W_YEARS - RV3029_W_SEC] = bin2bcd(tm->tm_year - 100); 434 435 ret = regmap_bulk_write(rv3029->regmap, RV3029_W_SEC, regs, 436 RV3029_WATCH_SECTION_LEN); 437 if (ret < 0) 438 return ret; 439 440 /* clear PON and VLOW2 bits */ 441 return regmap_update_bits(rv3029->regmap, RV3029_STATUS, 442 RV3029_STATUS_PON | RV3029_STATUS_VLOW2, 0); 443} 444 445static int rv3029_ioctl(struct device *dev, unsigned int cmd, unsigned long arg) 446{ 447 struct rv3029_data *rv3029 = dev_get_drvdata(dev); 448 unsigned long vl = 0; 449 int sr, ret = 0; 450 451 switch (cmd) { 452 case RTC_VL_READ: 453 ret = regmap_read(rv3029->regmap, RV3029_STATUS, &sr); 454 if (ret < 0) 455 return ret; 456 457 if (sr & RV3029_STATUS_VLOW1) 458 vl = RTC_VL_ACCURACY_LOW; 459 460 if (sr & (RV3029_STATUS_VLOW2 | RV3029_STATUS_PON)) 461 vl |= RTC_VL_DATA_INVALID; 462 463 return put_user(vl, (unsigned int __user *)arg); 464 465 case RTC_VL_CLR: 466 return regmap_update_bits(rv3029->regmap, RV3029_STATUS, 467 RV3029_STATUS_VLOW1, 0); 468 469 default: 470 return -ENOIOCTLCMD; 471 } 472} 473 474static int rv3029_nvram_write(void *priv, unsigned int offset, void *val, 475 size_t bytes) 476{ 477 return regmap_bulk_write(priv, RV3029_RAM_PAGE + offset, val, bytes); 478} 479 480static int rv3029_nvram_read(void *priv, unsigned int offset, void *val, 481 size_t bytes) 482{ 483 return regmap_bulk_read(priv, RV3029_RAM_PAGE + offset, val, bytes); 484} 485 486static const struct rv3029_trickle_tab_elem { 487 u32 r; /* resistance in ohms */ 488 u8 conf; /* trickle config bits */ 489} rv3029_trickle_tab[] = { 490 { 491 .r = 1076, 492 .conf = RV3029_TRICKLE_1K | RV3029_TRICKLE_5K | 493 RV3029_TRICKLE_20K | RV3029_TRICKLE_80K, 494 }, { 495 .r = 1091, 496 .conf = RV3029_TRICKLE_1K | RV3029_TRICKLE_5K | 497 RV3029_TRICKLE_20K, 498 }, { 499 .r = 1137, 500 .conf = RV3029_TRICKLE_1K | RV3029_TRICKLE_5K | 501 RV3029_TRICKLE_80K, 502 }, { 503 .r = 1154, 504 .conf = RV3029_TRICKLE_1K | RV3029_TRICKLE_5K, 505 }, { 506 .r = 1371, 507 .conf = RV3029_TRICKLE_1K | RV3029_TRICKLE_20K | 508 RV3029_TRICKLE_80K, 509 }, { 510 .r = 1395, 511 .conf = RV3029_TRICKLE_1K | RV3029_TRICKLE_20K, 512 }, { 513 .r = 1472, 514 .conf = RV3029_TRICKLE_1K | RV3029_TRICKLE_80K, 515 }, { 516 .r = 1500, 517 .conf = RV3029_TRICKLE_1K, 518 }, { 519 .r = 3810, 520 .conf = RV3029_TRICKLE_5K | RV3029_TRICKLE_20K | 521 RV3029_TRICKLE_80K, 522 }, { 523 .r = 4000, 524 .conf = RV3029_TRICKLE_5K | RV3029_TRICKLE_20K, 525 }, { 526 .r = 4706, 527 .conf = RV3029_TRICKLE_5K | RV3029_TRICKLE_80K, 528 }, { 529 .r = 5000, 530 .conf = RV3029_TRICKLE_5K, 531 }, { 532 .r = 16000, 533 .conf = RV3029_TRICKLE_20K | RV3029_TRICKLE_80K, 534 }, { 535 .r = 20000, 536 .conf = RV3029_TRICKLE_20K, 537 }, { 538 .r = 80000, 539 .conf = RV3029_TRICKLE_80K, 540 }, 541}; 542 543static void rv3029_trickle_config(struct device *dev) 544{ 545 struct rv3029_data *rv3029 = dev_get_drvdata(dev); 546 struct device_node *of_node = dev->of_node; 547 const struct rv3029_trickle_tab_elem *elem; 548 int i, err; 549 u32 ohms; 550 u8 trickle_set_bits; 551 552 if (!of_node) 553 return; 554 555 /* Configure the trickle charger. */ 556 err = of_property_read_u32(of_node, "trickle-resistor-ohms", &ohms); 557 if (err) { 558 /* Disable trickle charger. */ 559 trickle_set_bits = 0; 560 } else { 561 /* Enable trickle charger. */ 562 for (i = 0; i < ARRAY_SIZE(rv3029_trickle_tab); i++) { 563 elem = &rv3029_trickle_tab[i]; 564 if (elem->r >= ohms) 565 break; 566 } 567 trickle_set_bits = elem->conf; 568 dev_info(dev, 569 "Trickle charger enabled at %d ohms resistance.\n", 570 elem->r); 571 } 572 err = rv3029_eeprom_update_bits(rv3029, RV3029_CONTROL_E2P_EECTRL, 573 RV3029_TRICKLE_MASK, 574 trickle_set_bits); 575 if (err < 0) 576 dev_err(dev, "Failed to update trickle charger config\n"); 577} 578 579#ifdef CONFIG_RTC_DRV_RV3029_HWMON 580 581static int rv3029_read_temp(struct rv3029_data *rv3029, int *temp_mC) 582{ 583 unsigned int temp; 584 int ret; 585 586 ret = regmap_read(rv3029->regmap, RV3029_TEMP_PAGE, &temp); 587 if (ret < 0) 588 return ret; 589 590 *temp_mC = ((int)temp - 60) * 1000; 591 592 return 0; 593} 594 595static ssize_t rv3029_hwmon_show_temp(struct device *dev, 596 struct device_attribute *attr, 597 char *buf) 598{ 599 struct rv3029_data *rv3029 = dev_get_drvdata(dev); 600 int ret, temp_mC; 601 602 ret = rv3029_read_temp(rv3029, &temp_mC); 603 if (ret < 0) 604 return ret; 605 606 return sprintf(buf, "%d\n", temp_mC); 607} 608 609static ssize_t rv3029_hwmon_set_update_interval(struct device *dev, 610 struct device_attribute *attr, 611 const char *buf, 612 size_t count) 613{ 614 struct rv3029_data *rv3029 = dev_get_drvdata(dev); 615 unsigned int th_set_bits = 0; 616 unsigned long interval_ms; 617 int ret; 618 619 ret = kstrtoul(buf, 10, &interval_ms); 620 if (ret < 0) 621 return ret; 622 623 if (interval_ms != 0) { 624 th_set_bits |= RV3029_EECTRL_THE; 625 if (interval_ms >= 16000) 626 th_set_bits |= RV3029_EECTRL_THP; 627 } 628 ret = rv3029_eeprom_update_bits(rv3029, RV3029_CONTROL_E2P_EECTRL, 629 RV3029_EECTRL_THE | RV3029_EECTRL_THP, 630 th_set_bits); 631 if (ret < 0) 632 return ret; 633 634 return count; 635} 636 637static ssize_t rv3029_hwmon_show_update_interval(struct device *dev, 638 struct device_attribute *attr, 639 char *buf) 640{ 641 struct rv3029_data *rv3029 = dev_get_drvdata(dev); 642 int ret, interval_ms; 643 u8 eectrl; 644 645 ret = rv3029_eeprom_read(rv3029, RV3029_CONTROL_E2P_EECTRL, 646 &eectrl, 1); 647 if (ret < 0) 648 return ret; 649 650 if (eectrl & RV3029_EECTRL_THE) { 651 if (eectrl & RV3029_EECTRL_THP) 652 interval_ms = 16000; 653 else 654 interval_ms = 1000; 655 } else { 656 interval_ms = 0; 657 } 658 659 return sprintf(buf, "%d\n", interval_ms); 660} 661 662static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, rv3029_hwmon_show_temp, 663 NULL, 0); 664static SENSOR_DEVICE_ATTR(update_interval, S_IWUSR | S_IRUGO, 665 rv3029_hwmon_show_update_interval, 666 rv3029_hwmon_set_update_interval, 0); 667 668static struct attribute *rv3029_hwmon_attrs[] = { 669 &sensor_dev_attr_temp1_input.dev_attr.attr, 670 &sensor_dev_attr_update_interval.dev_attr.attr, 671 NULL, 672}; 673ATTRIBUTE_GROUPS(rv3029_hwmon); 674 675static void rv3029_hwmon_register(struct device *dev, const char *name) 676{ 677 struct rv3029_data *rv3029 = dev_get_drvdata(dev); 678 struct device *hwmon_dev; 679 680 hwmon_dev = devm_hwmon_device_register_with_groups(dev, name, rv3029, 681 rv3029_hwmon_groups); 682 if (IS_ERR(hwmon_dev)) { 683 dev_warn(dev, "unable to register hwmon device %ld\n", 684 PTR_ERR(hwmon_dev)); 685 } 686} 687 688#else /* CONFIG_RTC_DRV_RV3029_HWMON */ 689 690static void rv3029_hwmon_register(struct device *dev, const char *name) 691{ 692} 693 694#endif /* CONFIG_RTC_DRV_RV3029_HWMON */ 695 696static const struct rtc_class_ops rv3029_rtc_ops = { 697 .read_time = rv3029_read_time, 698 .set_time = rv3029_set_time, 699 .ioctl = rv3029_ioctl, 700 .read_alarm = rv3029_read_alarm, 701 .set_alarm = rv3029_set_alarm, 702 .alarm_irq_enable = rv3029_alarm_irq_enable, 703}; 704 705static int rv3029_probe(struct device *dev, struct regmap *regmap, int irq, 706 const char *name) 707{ 708 struct rv3029_data *rv3029; 709 struct nvmem_config nvmem_cfg = { 710 .name = "rv3029_nvram", 711 .word_size = 1, 712 .stride = 1, 713 .size = RV3029_RAM_SECTION_LEN, 714 .type = NVMEM_TYPE_BATTERY_BACKED, 715 .reg_read = rv3029_nvram_read, 716 .reg_write = rv3029_nvram_write, 717 }; 718 int rc = 0; 719 720 rv3029 = devm_kzalloc(dev, sizeof(*rv3029), GFP_KERNEL); 721 if (!rv3029) 722 return -ENOMEM; 723 724 rv3029->regmap = regmap; 725 rv3029->irq = irq; 726 rv3029->dev = dev; 727 dev_set_drvdata(dev, rv3029); 728 729 rv3029_trickle_config(dev); 730 rv3029_hwmon_register(dev, name); 731 732 rv3029->rtc = devm_rtc_allocate_device(dev); 733 if (IS_ERR(rv3029->rtc)) 734 return PTR_ERR(rv3029->rtc); 735 736 if (rv3029->irq > 0) { 737 rc = devm_request_threaded_irq(dev, rv3029->irq, 738 NULL, rv3029_handle_irq, 739 IRQF_TRIGGER_LOW | IRQF_ONESHOT, 740 "rv3029", dev); 741 if (rc) { 742 dev_warn(dev, "unable to request IRQ, alarms disabled\n"); 743 rv3029->irq = 0; 744 } 745 } 746 if (!rv3029->irq) 747 clear_bit(RTC_FEATURE_ALARM, rv3029->rtc->features); 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 763static 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 772static const struct regmap_access_table rv3029_regs = { 773 .no_ranges = rv3029_holes_range, 774 .n_no_ranges = ARRAY_SIZE(rv3029_holes_range), 775}; 776 777static 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 787static 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 804static const struct i2c_device_id rv3029_id[] = { 805 { "rv3029", 0 }, 806 { "rv3029c2", 0 }, 807 { } 808}; 809MODULE_DEVICE_TABLE(i2c, rv3029_id); 810 811static const __maybe_unused struct of_device_id rv3029_of_match[] = { 812 { .compatible = "microcrystal,rv3029" }, 813 { } 814}; 815MODULE_DEVICE_TABLE(of, rv3029_of_match); 816 817static 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 826static int __init rv3029_register_driver(void) 827{ 828 return i2c_add_driver(&rv3029_driver); 829} 830 831static void rv3029_unregister_driver(void) 832{ 833 i2c_del_driver(&rv3029_driver); 834} 835 836#else 837 838static int __init rv3029_register_driver(void) 839{ 840 return 0; 841} 842 843static void rv3029_unregister_driver(void) 844{ 845} 846 847#endif 848 849#if IS_ENABLED(CONFIG_SPI_MASTER) 850 851static 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 862static struct spi_driver rv3049_driver = { 863 .driver = { 864 .name = "rv3049", 865 }, 866 .probe = rv3049_probe, 867}; 868 869static int __init rv3049_register_driver(void) 870{ 871 return spi_register_driver(&rv3049_driver); 872} 873 874static void __exit rv3049_unregister_driver(void) 875{ 876 spi_unregister_driver(&rv3049_driver); 877} 878 879#else 880 881static int __init rv3049_register_driver(void) 882{ 883 return 0; 884} 885 886static void __exit rv3049_unregister_driver(void) 887{ 888} 889 890#endif 891 892static 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} 906module_init(rv30x9_init) 907 908static void __exit rv30x9_exit(void) 909{ 910 rv3049_unregister_driver(); 911 rv3029_unregister_driver(); 912} 913module_exit(rv30x9_exit) 914 915MODULE_AUTHOR("Gregory Hermant <gregory.hermant@calao-systems.com>"); 916MODULE_AUTHOR("Michael Buesch <m@bues.ch>"); 917MODULE_DESCRIPTION("Micro Crystal RV3029/RV3049 RTC driver"); 918MODULE_LICENSE("GPL"); 919MODULE_ALIAS("spi:rv3049");