1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Driver for Epson's RTC module RX-8025 SA/NB 4 * 5 * Copyright (C) 2009 Wolfgang Grandegger <wg@grandegger.com> 6 * 7 * Copyright (C) 2005 by Digi International Inc. 8 * All rights reserved. 9 * 10 * Modified by fengjh at rising.com.cn 11 * <lm-sensors@lm-sensors.org> 12 * 2006.11 13 * 14 * Code cleanup by Sergei Poselenov, <sposelenov@emcraft.com> 15 * Converted to new style by Wolfgang Grandegger <wg@grandegger.com> 16 * Alarm and periodic interrupt added by Dmitry Rakhchev <rda@emcraft.com> 17 */ 18 #include <linux/bcd.h> 19 #include <linux/bitops.h> 20 #include <linux/i2c.h> 21 #include <linux/kernel.h> 22 #include <linux/kstrtox.h> 23 #include <linux/module.h> 24 #include <linux/rtc.h> 25 26 /* Register definitions */ 27 #define RX8025_REG_SEC 0x00 28 #define RX8025_REG_MIN 0x01 29 #define RX8025_REG_HOUR 0x02 30 #define RX8025_REG_WDAY 0x03 31 #define RX8025_REG_MDAY 0x04 32 #define RX8025_REG_MONTH 0x05 33 #define RX8025_REG_YEAR 0x06 34 #define RX8025_REG_DIGOFF 0x07 35 #define RX8025_REG_ALWMIN 0x08 36 #define RX8025_REG_ALWHOUR 0x09 37 #define RX8025_REG_ALWWDAY 0x0a 38 #define RX8025_REG_ALDMIN 0x0b 39 #define RX8025_REG_ALDHOUR 0x0c 40 /* 0x0d is reserved */ 41 #define RX8025_REG_CTRL1 0x0e 42 #define RX8025_REG_CTRL2 0x0f 43 44 #define RX8025_BIT_CTRL1_CT (7 << 0) 45 /* 1 Hz periodic level irq */ 46 #define RX8025_BIT_CTRL1_CT_1HZ 4 47 #define RX8025_BIT_CTRL1_TEST BIT(3) 48 #define RX8025_BIT_CTRL1_1224 BIT(5) 49 #define RX8025_BIT_CTRL1_DALE BIT(6) 50 #define RX8025_BIT_CTRL1_WALE BIT(7) 51 52 #define RX8025_BIT_CTRL2_DAFG BIT(0) 53 #define RX8025_BIT_CTRL2_WAFG BIT(1) 54 #define RX8025_BIT_CTRL2_CTFG BIT(2) 55 #define RX8025_BIT_CTRL2_PON BIT(4) 56 #define RX8025_BIT_CTRL2_XST BIT(5) 57 #define RX8025_BIT_CTRL2_VDET BIT(6) 58 59 #define RX8035_BIT_HOUR_1224 BIT(7) 60 61 /* Clock precision adjustment */ 62 #define RX8025_ADJ_RESOLUTION 3050 /* in ppb */ 63 #define RX8025_ADJ_DATA_MAX 62 64 #define RX8025_ADJ_DATA_MIN -62 65 66 enum rx_model { 67 model_rx_unknown, 68 model_rx_8025, 69 model_rx_8035, 70 model_last 71 }; 72 73 static const struct i2c_device_id rx8025_id[] = { 74 { "rx8025", model_rx_8025 }, 75 { "rx8035", model_rx_8035 }, 76 { } 77 }; 78 MODULE_DEVICE_TABLE(i2c, rx8025_id); 79 80 struct rx8025_data { 81 struct rtc_device *rtc; 82 enum rx_model model; 83 u8 ctrl1; 84 int is_24; 85 }; 86 87 static s32 rx8025_read_reg(const struct i2c_client *client, u8 number) 88 { 89 return i2c_smbus_read_byte_data(client, number << 4); 90 } 91 92 static int rx8025_read_regs(const struct i2c_client *client, 93 u8 number, u8 length, u8 *values) 94 { 95 int ret = i2c_smbus_read_i2c_block_data(client, number << 4, length, 96 values); 97 if (ret != length) 98 return ret < 0 ? ret : -EIO; 99 100 return 0; 101 } 102 103 static s32 rx8025_write_reg(const struct i2c_client *client, u8 number, 104 u8 value) 105 { 106 return i2c_smbus_write_byte_data(client, number << 4, value); 107 } 108 109 static s32 rx8025_write_regs(const struct i2c_client *client, 110 u8 number, u8 length, const u8 *values) 111 { 112 return i2c_smbus_write_i2c_block_data(client, number << 4, 113 length, values); 114 } 115 116 static int rx8025_is_osc_stopped(enum rx_model model, int ctrl2) 117 { 118 int xstp = ctrl2 & RX8025_BIT_CTRL2_XST; 119 /* XSTP bit has different polarity on RX-8025 vs RX-8035. 120 * RX-8025: 0 == oscillator stopped 121 * RX-8035: 1 == oscillator stopped 122 */ 123 124 if (model == model_rx_8025) 125 xstp = !xstp; 126 127 return xstp; 128 } 129 130 static int rx8025_check_validity(struct device *dev) 131 { 132 struct i2c_client *client = to_i2c_client(dev); 133 struct rx8025_data *drvdata = dev_get_drvdata(dev); 134 int ctrl2; 135 int xstp; 136 137 ctrl2 = rx8025_read_reg(client, RX8025_REG_CTRL2); 138 if (ctrl2 < 0) 139 return ctrl2; 140 141 if (ctrl2 & RX8025_BIT_CTRL2_VDET) 142 dev_warn(dev, "power voltage drop detected\n"); 143 144 if (ctrl2 & RX8025_BIT_CTRL2_PON) { 145 dev_warn(dev, "power-on reset detected, date is invalid\n"); 146 return -EINVAL; 147 } 148 149 xstp = rx8025_is_osc_stopped(drvdata->model, ctrl2); 150 if (xstp) { 151 dev_warn(dev, "crystal stopped, date is invalid\n"); 152 return -EINVAL; 153 } 154 155 return 0; 156 } 157 158 static int rx8025_reset_validity(struct i2c_client *client) 159 { 160 struct rx8025_data *drvdata = i2c_get_clientdata(client); 161 int ctrl2 = rx8025_read_reg(client, RX8025_REG_CTRL2); 162 163 if (ctrl2 < 0) 164 return ctrl2; 165 166 ctrl2 &= ~(RX8025_BIT_CTRL2_PON | RX8025_BIT_CTRL2_VDET); 167 168 if (drvdata->model == model_rx_8025) 169 ctrl2 |= RX8025_BIT_CTRL2_XST; 170 else 171 ctrl2 &= ~(RX8025_BIT_CTRL2_XST); 172 173 return rx8025_write_reg(client, RX8025_REG_CTRL2, 174 ctrl2); 175 } 176 177 static irqreturn_t rx8025_handle_irq(int irq, void *dev_id) 178 { 179 struct i2c_client *client = dev_id; 180 struct rx8025_data *rx8025 = i2c_get_clientdata(client); 181 int status, xstp; 182 183 rtc_lock(rx8025->rtc); 184 status = rx8025_read_reg(client, RX8025_REG_CTRL2); 185 if (status < 0) 186 goto out; 187 188 xstp = rx8025_is_osc_stopped(rx8025->model, status); 189 if (xstp) 190 dev_warn(&client->dev, "Oscillation stop was detected," 191 "you may have to readjust the clock\n"); 192 193 if (status & RX8025_BIT_CTRL2_CTFG) { 194 /* periodic */ 195 status &= ~RX8025_BIT_CTRL2_CTFG; 196 rtc_update_irq(rx8025->rtc, 1, RTC_PF | RTC_IRQF); 197 } 198 199 if (status & RX8025_BIT_CTRL2_DAFG) { 200 /* alarm */ 201 status &= RX8025_BIT_CTRL2_DAFG; 202 if (rx8025_write_reg(client, RX8025_REG_CTRL1, 203 rx8025->ctrl1 & ~RX8025_BIT_CTRL1_DALE)) 204 goto out; 205 rtc_update_irq(rx8025->rtc, 1, RTC_AF | RTC_IRQF); 206 } 207 208 out: 209 rtc_unlock(rx8025->rtc); 210 211 return IRQ_HANDLED; 212 } 213 214 static int rx8025_get_time(struct device *dev, struct rtc_time *dt) 215 { 216 struct i2c_client *client = to_i2c_client(dev); 217 struct rx8025_data *rx8025 = dev_get_drvdata(dev); 218 u8 date[7]; 219 int err; 220 221 err = rx8025_check_validity(dev); 222 if (err) 223 return err; 224 225 err = rx8025_read_regs(client, RX8025_REG_SEC, 7, date); 226 if (err) 227 return err; 228 229 dev_dbg(dev, "%s: read %7ph\n", __func__, date); 230 231 dt->tm_sec = bcd2bin(date[RX8025_REG_SEC] & 0x7f); 232 dt->tm_min = bcd2bin(date[RX8025_REG_MIN] & 0x7f); 233 if (rx8025->is_24) 234 dt->tm_hour = bcd2bin(date[RX8025_REG_HOUR] & 0x3f); 235 else 236 dt->tm_hour = bcd2bin(date[RX8025_REG_HOUR] & 0x1f) % 12 237 + (date[RX8025_REG_HOUR] & 0x20 ? 12 : 0); 238 239 dt->tm_mday = bcd2bin(date[RX8025_REG_MDAY] & 0x3f); 240 dt->tm_mon = bcd2bin(date[RX8025_REG_MONTH] & 0x1f) - 1; 241 dt->tm_year = bcd2bin(date[RX8025_REG_YEAR]) + 100; 242 243 dev_dbg(dev, "%s: date %ptRr\n", __func__, dt); 244 245 return 0; 246 } 247 248 static int rx8025_set_time(struct device *dev, struct rtc_time *dt) 249 { 250 struct i2c_client *client = to_i2c_client(dev); 251 struct rx8025_data *rx8025 = dev_get_drvdata(dev); 252 u8 date[7]; 253 int ret; 254 255 /* 256 * Here the read-only bits are written as "0". I'm not sure if that 257 * is sound. 258 */ 259 date[RX8025_REG_SEC] = bin2bcd(dt->tm_sec); 260 date[RX8025_REG_MIN] = bin2bcd(dt->tm_min); 261 if (rx8025->is_24) 262 date[RX8025_REG_HOUR] = bin2bcd(dt->tm_hour); 263 else 264 date[RX8025_REG_HOUR] = (dt->tm_hour >= 12 ? 0x20 : 0) 265 | bin2bcd((dt->tm_hour + 11) % 12 + 1); 266 267 date[RX8025_REG_WDAY] = bin2bcd(dt->tm_wday); 268 date[RX8025_REG_MDAY] = bin2bcd(dt->tm_mday); 269 date[RX8025_REG_MONTH] = bin2bcd(dt->tm_mon + 1); 270 date[RX8025_REG_YEAR] = bin2bcd(dt->tm_year - 100); 271 272 dev_dbg(dev, "%s: write %7ph\n", __func__, date); 273 274 ret = rx8025_write_regs(client, RX8025_REG_SEC, 7, date); 275 if (ret < 0) 276 return ret; 277 278 return rx8025_reset_validity(client); 279 } 280 281 static int rx8025_init_client(struct i2c_client *client) 282 { 283 struct rx8025_data *rx8025 = i2c_get_clientdata(client); 284 u8 ctrl[2], ctrl2; 285 int need_clear = 0; 286 int hour_reg; 287 int err; 288 289 err = rx8025_read_regs(client, RX8025_REG_CTRL1, 2, ctrl); 290 if (err) 291 goto out; 292 293 /* Keep test bit zero ! */ 294 rx8025->ctrl1 = ctrl[0] & ~RX8025_BIT_CTRL1_TEST; 295 296 if (ctrl[1] & (RX8025_BIT_CTRL2_DAFG | RX8025_BIT_CTRL2_WAFG)) { 297 dev_warn(&client->dev, "Alarm was detected\n"); 298 need_clear = 1; 299 } 300 301 if (ctrl[1] & RX8025_BIT_CTRL2_CTFG) 302 need_clear = 1; 303 304 if (need_clear) { 305 ctrl2 = ctrl[1]; 306 ctrl2 &= ~(RX8025_BIT_CTRL2_CTFG | RX8025_BIT_CTRL2_WAFG | 307 RX8025_BIT_CTRL2_DAFG); 308 309 err = rx8025_write_reg(client, RX8025_REG_CTRL2, ctrl2); 310 } 311 312 if (rx8025->model == model_rx_8035) { 313 /* In RX-8035, 12/24 flag is in the hour register */ 314 hour_reg = rx8025_read_reg(client, RX8025_REG_HOUR); 315 if (hour_reg < 0) 316 return hour_reg; 317 rx8025->is_24 = (hour_reg & RX8035_BIT_HOUR_1224); 318 } else { 319 rx8025->is_24 = (ctrl[1] & RX8025_BIT_CTRL1_1224); 320 } 321 out: 322 return err; 323 } 324 325 /* Alarm support */ 326 static int rx8025_read_alarm(struct device *dev, struct rtc_wkalrm *t) 327 { 328 struct i2c_client *client = to_i2c_client(dev); 329 struct rx8025_data *rx8025 = dev_get_drvdata(dev); 330 u8 ald[2]; 331 int ctrl2, err; 332 333 err = rx8025_read_regs(client, RX8025_REG_ALDMIN, 2, ald); 334 if (err) 335 return err; 336 337 ctrl2 = rx8025_read_reg(client, RX8025_REG_CTRL2); 338 if (ctrl2 < 0) 339 return ctrl2; 340 341 dev_dbg(dev, "%s: read alarm 0x%02x 0x%02x ctrl2 %02x\n", 342 __func__, ald[0], ald[1], ctrl2); 343 344 /* Hardware alarms precision is 1 minute! */ 345 t->time.tm_sec = 0; 346 t->time.tm_min = bcd2bin(ald[0] & 0x7f); 347 if (rx8025->is_24) 348 t->time.tm_hour = bcd2bin(ald[1] & 0x3f); 349 else 350 t->time.tm_hour = bcd2bin(ald[1] & 0x1f) % 12 351 + (ald[1] & 0x20 ? 12 : 0); 352 353 dev_dbg(dev, "%s: date: %ptRr\n", __func__, &t->time); 354 t->enabled = !!(rx8025->ctrl1 & RX8025_BIT_CTRL1_DALE); 355 t->pending = (ctrl2 & RX8025_BIT_CTRL2_DAFG) && t->enabled; 356 357 return err; 358 } 359 360 static int rx8025_set_alarm(struct device *dev, struct rtc_wkalrm *t) 361 { 362 struct i2c_client *client = to_i2c_client(dev); 363 struct rx8025_data *rx8025 = dev_get_drvdata(dev); 364 u8 ald[2]; 365 int err; 366 367 ald[0] = bin2bcd(t->time.tm_min); 368 if (rx8025->is_24) 369 ald[1] = bin2bcd(t->time.tm_hour); 370 else 371 ald[1] = (t->time.tm_hour >= 12 ? 0x20 : 0) 372 | bin2bcd((t->time.tm_hour + 11) % 12 + 1); 373 374 dev_dbg(dev, "%s: write 0x%02x 0x%02x\n", __func__, ald[0], ald[1]); 375 376 if (rx8025->ctrl1 & RX8025_BIT_CTRL1_DALE) { 377 rx8025->ctrl1 &= ~RX8025_BIT_CTRL1_DALE; 378 err = rx8025_write_reg(client, RX8025_REG_CTRL1, 379 rx8025->ctrl1); 380 if (err) 381 return err; 382 } 383 err = rx8025_write_regs(client, RX8025_REG_ALDMIN, 2, ald); 384 if (err) 385 return err; 386 387 if (t->enabled) { 388 rx8025->ctrl1 |= RX8025_BIT_CTRL1_DALE; 389 err = rx8025_write_reg(client, RX8025_REG_CTRL1, 390 rx8025->ctrl1); 391 if (err) 392 return err; 393 } 394 395 return 0; 396 } 397 398 static int rx8025_alarm_irq_enable(struct device *dev, unsigned int enabled) 399 { 400 struct i2c_client *client = to_i2c_client(dev); 401 struct rx8025_data *rx8025 = dev_get_drvdata(dev); 402 u8 ctrl1; 403 int err; 404 405 ctrl1 = rx8025->ctrl1; 406 if (enabled) 407 ctrl1 |= RX8025_BIT_CTRL1_DALE; 408 else 409 ctrl1 &= ~RX8025_BIT_CTRL1_DALE; 410 411 if (ctrl1 != rx8025->ctrl1) { 412 rx8025->ctrl1 = ctrl1; 413 err = rx8025_write_reg(client, RX8025_REG_CTRL1, 414 rx8025->ctrl1); 415 if (err) 416 return err; 417 } 418 return 0; 419 } 420 421 /* 422 * According to the RX8025 SA/NB application manual the frequency and 423 * temperature characteristics can be approximated using the following 424 * equation: 425 * 426 * df = a * (ut - t)**2 427 * 428 * df: Frequency deviation in any temperature 429 * a : Coefficient = (-35 +-5) * 10**-9 430 * ut: Ultimate temperature in degree = +25 +-5 degree 431 * t : Any temperature in degree 432 */ 433 static int rx8025_read_offset(struct device *dev, long *offset) 434 { 435 struct i2c_client *client = to_i2c_client(dev); 436 int digoff; 437 438 digoff = rx8025_read_reg(client, RX8025_REG_DIGOFF); 439 if (digoff < 0) 440 return digoff; 441 442 *offset = digoff >= 64 ? digoff - 128 : digoff; 443 if (*offset > 0) 444 (*offset)--; 445 *offset *= RX8025_ADJ_RESOLUTION; 446 447 return 0; 448 } 449 450 static int rx8025_set_offset(struct device *dev, long offset) 451 { 452 struct i2c_client *client = to_i2c_client(dev); 453 u8 digoff; 454 455 offset /= RX8025_ADJ_RESOLUTION; 456 if (offset > RX8025_ADJ_DATA_MAX) 457 offset = RX8025_ADJ_DATA_MAX; 458 else if (offset < RX8025_ADJ_DATA_MIN) 459 offset = RX8025_ADJ_DATA_MIN; 460 else if (offset > 0) 461 offset++; 462 else if (offset < 0) 463 offset += 128; 464 digoff = offset; 465 466 return rx8025_write_reg(client, RX8025_REG_DIGOFF, digoff); 467 } 468 469 static const struct rtc_class_ops rx8025_rtc_ops = { 470 .read_time = rx8025_get_time, 471 .set_time = rx8025_set_time, 472 .read_alarm = rx8025_read_alarm, 473 .set_alarm = rx8025_set_alarm, 474 .alarm_irq_enable = rx8025_alarm_irq_enable, 475 .read_offset = rx8025_read_offset, 476 .set_offset = rx8025_set_offset, 477 }; 478 479 static ssize_t rx8025_sysfs_show_clock_adjust(struct device *dev, 480 struct device_attribute *attr, 481 char *buf) 482 { 483 long adj; 484 int err; 485 486 dev_warn_once(dev, "clock_adjust_ppb is deprecated, use offset\n"); 487 err = rx8025_read_offset(dev, &adj); 488 if (err) 489 return err; 490 491 return sprintf(buf, "%ld\n", -adj); 492 } 493 494 static ssize_t rx8025_sysfs_store_clock_adjust(struct device *dev, 495 struct device_attribute *attr, 496 const char *buf, size_t count) 497 { 498 long adj; 499 int err; 500 501 dev_warn_once(dev, "clock_adjust_ppb is deprecated, use offset\n"); 502 if (kstrtol(buf, 10, &adj) != 0) 503 return -EINVAL; 504 505 err = rx8025_set_offset(dev, -adj); 506 507 return err ? err : count; 508 } 509 510 static DEVICE_ATTR(clock_adjust_ppb, S_IRUGO | S_IWUSR, 511 rx8025_sysfs_show_clock_adjust, 512 rx8025_sysfs_store_clock_adjust); 513 514 static struct attribute *rx8025_attrs[] = { 515 &dev_attr_clock_adjust_ppb.attr, 516 NULL 517 }; 518 519 static const struct attribute_group rx8025_attr_group = { 520 .attrs = rx8025_attrs, 521 }; 522 523 static int rx8025_probe(struct i2c_client *client) 524 { 525 const struct i2c_device_id *id = i2c_match_id(rx8025_id, client); 526 struct i2c_adapter *adapter = client->adapter; 527 struct rx8025_data *rx8025; 528 int err = 0; 529 530 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA 531 | I2C_FUNC_SMBUS_I2C_BLOCK)) { 532 dev_err(&adapter->dev, 533 "doesn't support required functionality\n"); 534 return -EIO; 535 } 536 537 rx8025 = devm_kzalloc(&client->dev, sizeof(*rx8025), GFP_KERNEL); 538 if (!rx8025) 539 return -ENOMEM; 540 541 i2c_set_clientdata(client, rx8025); 542 543 if (id) 544 rx8025->model = id->driver_data; 545 546 err = rx8025_init_client(client); 547 if (err) 548 return err; 549 550 rx8025->rtc = devm_rtc_allocate_device(&client->dev); 551 if (IS_ERR(rx8025->rtc)) 552 return PTR_ERR(rx8025->rtc); 553 554 rx8025->rtc->ops = &rx8025_rtc_ops; 555 rx8025->rtc->range_min = RTC_TIMESTAMP_BEGIN_1900; 556 rx8025->rtc->range_max = RTC_TIMESTAMP_END_2099; 557 558 if (client->irq > 0) { 559 dev_info(&client->dev, "IRQ %d supplied\n", client->irq); 560 err = devm_request_threaded_irq(&client->dev, client->irq, NULL, 561 rx8025_handle_irq, 562 IRQF_ONESHOT, 563 "rx8025", client); 564 if (err) 565 clear_bit(RTC_FEATURE_ALARM, rx8025->rtc->features); 566 } 567 568 rx8025->rtc->max_user_freq = 1; 569 570 set_bit(RTC_FEATURE_ALARM_RES_MINUTE, rx8025->rtc->features); 571 clear_bit(RTC_FEATURE_UPDATE_INTERRUPT, rx8025->rtc->features); 572 573 err = rtc_add_group(rx8025->rtc, &rx8025_attr_group); 574 if (err) 575 return err; 576 577 return devm_rtc_register_device(rx8025->rtc); 578 } 579 580 static struct i2c_driver rx8025_driver = { 581 .driver = { 582 .name = "rtc-rx8025", 583 }, 584 .probe_new = rx8025_probe, 585 .id_table = rx8025_id, 586 }; 587 588 module_i2c_driver(rx8025_driver); 589 590 MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>"); 591 MODULE_DESCRIPTION("RX-8025 SA/NB RTC driver"); 592 MODULE_LICENSE("GPL"); 593