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 { .name = "rx8025", .driver_data = model_rx_8025 }, 75 { .name = "rx8035", .driver_data = 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 guard(rtc_ops)(rx8025->rtc); 184 185 status = rx8025_read_reg(client, RX8025_REG_CTRL2); 186 if (status < 0) 187 return IRQ_HANDLED; 188 189 xstp = rx8025_is_osc_stopped(rx8025->model, status); 190 if (xstp) 191 dev_warn(&client->dev, "Oscillation stop was detected," 192 "you may have to readjust the clock\n"); 193 194 if (status & RX8025_BIT_CTRL2_CTFG) { 195 /* periodic */ 196 status &= ~RX8025_BIT_CTRL2_CTFG; 197 rtc_update_irq(rx8025->rtc, 1, RTC_PF | RTC_IRQF); 198 } 199 200 if (status & RX8025_BIT_CTRL2_DAFG) { 201 /* alarm */ 202 status &= RX8025_BIT_CTRL2_DAFG; 203 if (rx8025_write_reg(client, RX8025_REG_CTRL1, 204 rx8025->ctrl1 & ~RX8025_BIT_CTRL1_DALE)) 205 return IRQ_HANDLED; 206 rtc_update_irq(rx8025->rtc, 1, RTC_AF | RTC_IRQF); 207 } 208 209 return IRQ_HANDLED; 210 } 211 212 static int rx8025_get_time(struct device *dev, struct rtc_time *dt) 213 { 214 struct i2c_client *client = to_i2c_client(dev); 215 struct rx8025_data *rx8025 = dev_get_drvdata(dev); 216 u8 date[7]; 217 int err; 218 219 err = rx8025_check_validity(dev); 220 if (err) 221 return err; 222 223 err = rx8025_read_regs(client, RX8025_REG_SEC, 7, date); 224 if (err) 225 return err; 226 227 dev_dbg(dev, "%s: read %7ph\n", __func__, date); 228 229 dt->tm_sec = bcd2bin(date[RX8025_REG_SEC] & 0x7f); 230 dt->tm_min = bcd2bin(date[RX8025_REG_MIN] & 0x7f); 231 if (rx8025->is_24) 232 dt->tm_hour = bcd2bin(date[RX8025_REG_HOUR] & 0x3f); 233 else 234 dt->tm_hour = bcd2bin(date[RX8025_REG_HOUR] & 0x1f) % 12 235 + (date[RX8025_REG_HOUR] & 0x20 ? 12 : 0); 236 237 dt->tm_mday = bcd2bin(date[RX8025_REG_MDAY] & 0x3f); 238 dt->tm_mon = bcd2bin(date[RX8025_REG_MONTH] & 0x1f) - 1; 239 dt->tm_year = bcd2bin(date[RX8025_REG_YEAR]) + 100; 240 241 dev_dbg(dev, "%s: date %ptRr\n", __func__, dt); 242 243 return 0; 244 } 245 246 static int rx8025_set_time(struct device *dev, struct rtc_time *dt) 247 { 248 struct i2c_client *client = to_i2c_client(dev); 249 struct rx8025_data *rx8025 = dev_get_drvdata(dev); 250 u8 date[7]; 251 int ret; 252 253 /* 254 * Here the read-only bits are written as "0". I'm not sure if that 255 * is sound. 256 */ 257 date[RX8025_REG_SEC] = bin2bcd(dt->tm_sec); 258 date[RX8025_REG_MIN] = bin2bcd(dt->tm_min); 259 if (rx8025->is_24) 260 date[RX8025_REG_HOUR] = bin2bcd(dt->tm_hour); 261 else 262 date[RX8025_REG_HOUR] = (dt->tm_hour >= 12 ? 0x20 : 0) 263 | bin2bcd((dt->tm_hour + 11) % 12 + 1); 264 265 date[RX8025_REG_WDAY] = bin2bcd(dt->tm_wday); 266 date[RX8025_REG_MDAY] = bin2bcd(dt->tm_mday); 267 date[RX8025_REG_MONTH] = bin2bcd(dt->tm_mon + 1); 268 date[RX8025_REG_YEAR] = bin2bcd(dt->tm_year - 100); 269 270 dev_dbg(dev, "%s: write %7ph\n", __func__, date); 271 272 ret = rx8025_write_regs(client, RX8025_REG_SEC, 7, date); 273 if (ret < 0) 274 return ret; 275 276 return rx8025_reset_validity(client); 277 } 278 279 static int rx8025_init_client(struct i2c_client *client) 280 { 281 struct rx8025_data *rx8025 = i2c_get_clientdata(client); 282 u8 ctrl[2], ctrl2; 283 int need_clear = 0; 284 int hour_reg; 285 int err; 286 287 err = rx8025_read_regs(client, RX8025_REG_CTRL1, 2, ctrl); 288 if (err) 289 goto out; 290 291 /* Keep test bit zero ! */ 292 rx8025->ctrl1 = ctrl[0] & ~RX8025_BIT_CTRL1_TEST; 293 294 if (ctrl[1] & (RX8025_BIT_CTRL2_DAFG | RX8025_BIT_CTRL2_WAFG)) { 295 dev_warn(&client->dev, "Alarm was detected\n"); 296 need_clear = 1; 297 } 298 299 if (ctrl[1] & RX8025_BIT_CTRL2_CTFG) 300 need_clear = 1; 301 302 if (need_clear) { 303 ctrl2 = ctrl[1]; 304 ctrl2 &= ~(RX8025_BIT_CTRL2_CTFG | RX8025_BIT_CTRL2_WAFG | 305 RX8025_BIT_CTRL2_DAFG); 306 307 err = rx8025_write_reg(client, RX8025_REG_CTRL2, ctrl2); 308 } 309 310 if (rx8025->model == model_rx_8035) { 311 /* In RX-8035, 12/24 flag is in the hour register */ 312 hour_reg = rx8025_read_reg(client, RX8025_REG_HOUR); 313 if (hour_reg < 0) 314 return hour_reg; 315 rx8025->is_24 = (hour_reg & RX8035_BIT_HOUR_1224); 316 } else { 317 rx8025->is_24 = (ctrl[0] & RX8025_BIT_CTRL1_1224); 318 } 319 out: 320 return err; 321 } 322 323 /* Alarm support */ 324 static int rx8025_read_alarm(struct device *dev, struct rtc_wkalrm *t) 325 { 326 struct i2c_client *client = to_i2c_client(dev); 327 struct rx8025_data *rx8025 = dev_get_drvdata(dev); 328 u8 ald[2]; 329 int ctrl2, err; 330 331 err = rx8025_read_regs(client, RX8025_REG_ALDMIN, 2, ald); 332 if (err) 333 return err; 334 335 ctrl2 = rx8025_read_reg(client, RX8025_REG_CTRL2); 336 if (ctrl2 < 0) 337 return ctrl2; 338 339 dev_dbg(dev, "%s: read alarm 0x%02x 0x%02x ctrl2 %02x\n", 340 __func__, ald[0], ald[1], ctrl2); 341 342 /* Hardware alarms precision is 1 minute! */ 343 t->time.tm_sec = 0; 344 t->time.tm_min = bcd2bin(ald[0] & 0x7f); 345 if (rx8025->is_24) 346 t->time.tm_hour = bcd2bin(ald[1] & 0x3f); 347 else 348 t->time.tm_hour = bcd2bin(ald[1] & 0x1f) % 12 349 + (ald[1] & 0x20 ? 12 : 0); 350 351 dev_dbg(dev, "%s: date: %ptRr\n", __func__, &t->time); 352 t->enabled = !!(rx8025->ctrl1 & RX8025_BIT_CTRL1_DALE); 353 t->pending = (ctrl2 & RX8025_BIT_CTRL2_DAFG) && t->enabled; 354 355 return err; 356 } 357 358 static int rx8025_set_alarm(struct device *dev, struct rtc_wkalrm *t) 359 { 360 struct i2c_client *client = to_i2c_client(dev); 361 struct rx8025_data *rx8025 = dev_get_drvdata(dev); 362 u8 ald[2]; 363 int err; 364 365 ald[0] = bin2bcd(t->time.tm_min); 366 if (rx8025->is_24) 367 ald[1] = bin2bcd(t->time.tm_hour); 368 else 369 ald[1] = (t->time.tm_hour >= 12 ? 0x20 : 0) 370 | bin2bcd((t->time.tm_hour + 11) % 12 + 1); 371 372 dev_dbg(dev, "%s: write 0x%02x 0x%02x\n", __func__, ald[0], ald[1]); 373 374 if (rx8025->ctrl1 & RX8025_BIT_CTRL1_DALE) { 375 rx8025->ctrl1 &= ~RX8025_BIT_CTRL1_DALE; 376 err = rx8025_write_reg(client, RX8025_REG_CTRL1, 377 rx8025->ctrl1); 378 if (err) 379 return err; 380 } 381 err = rx8025_write_regs(client, RX8025_REG_ALDMIN, 2, ald); 382 if (err) 383 return err; 384 385 if (t->enabled) { 386 rx8025->ctrl1 |= RX8025_BIT_CTRL1_DALE; 387 err = rx8025_write_reg(client, RX8025_REG_CTRL1, 388 rx8025->ctrl1); 389 if (err) 390 return err; 391 } 392 393 return 0; 394 } 395 396 static int rx8025_alarm_irq_enable(struct device *dev, unsigned int enabled) 397 { 398 struct i2c_client *client = to_i2c_client(dev); 399 struct rx8025_data *rx8025 = dev_get_drvdata(dev); 400 u8 ctrl1; 401 int err; 402 403 ctrl1 = rx8025->ctrl1; 404 if (enabled) 405 ctrl1 |= RX8025_BIT_CTRL1_DALE; 406 else 407 ctrl1 &= ~RX8025_BIT_CTRL1_DALE; 408 409 if (ctrl1 != rx8025->ctrl1) { 410 rx8025->ctrl1 = ctrl1; 411 err = rx8025_write_reg(client, RX8025_REG_CTRL1, 412 rx8025->ctrl1); 413 if (err) 414 return err; 415 } 416 return 0; 417 } 418 419 /* 420 * According to the RX8025 SA/NB application manual the frequency and 421 * temperature characteristics can be approximated using the following 422 * equation: 423 * 424 * df = a * (ut - t)**2 425 * 426 * df: Frequency deviation in any temperature 427 * a : Coefficient = (-35 +-5) * 10**-9 428 * ut: Ultimate temperature in degree = +25 +-5 degree 429 * t : Any temperature in degree 430 */ 431 static int rx8025_read_offset(struct device *dev, long *offset) 432 { 433 struct i2c_client *client = to_i2c_client(dev); 434 int digoff; 435 436 digoff = rx8025_read_reg(client, RX8025_REG_DIGOFF); 437 if (digoff < 0) 438 return digoff; 439 440 *offset = digoff >= 64 ? digoff - 128 : digoff; 441 if (*offset > 0) 442 (*offset)--; 443 *offset *= RX8025_ADJ_RESOLUTION; 444 445 return 0; 446 } 447 448 static int rx8025_set_offset(struct device *dev, long offset) 449 { 450 struct i2c_client *client = to_i2c_client(dev); 451 u8 digoff; 452 453 offset /= RX8025_ADJ_RESOLUTION; 454 if (offset > RX8025_ADJ_DATA_MAX) 455 offset = RX8025_ADJ_DATA_MAX; 456 else if (offset < RX8025_ADJ_DATA_MIN) 457 offset = RX8025_ADJ_DATA_MIN; 458 else if (offset > 0) 459 offset++; 460 else if (offset < 0) 461 offset += 128; 462 digoff = offset; 463 464 return rx8025_write_reg(client, RX8025_REG_DIGOFF, digoff); 465 } 466 467 static const struct rtc_class_ops rx8025_rtc_ops = { 468 .read_time = rx8025_get_time, 469 .set_time = rx8025_set_time, 470 .read_alarm = rx8025_read_alarm, 471 .set_alarm = rx8025_set_alarm, 472 .alarm_irq_enable = rx8025_alarm_irq_enable, 473 .read_offset = rx8025_read_offset, 474 .set_offset = rx8025_set_offset, 475 }; 476 477 static ssize_t rx8025_sysfs_show_clock_adjust(struct device *dev, 478 struct device_attribute *attr, 479 char *buf) 480 { 481 long adj; 482 int err; 483 484 dev_warn_once(dev, "clock_adjust_ppb is deprecated, use offset\n"); 485 err = rx8025_read_offset(dev, &adj); 486 if (err) 487 return err; 488 489 return sysfs_emit(buf, "%ld\n", -adj); 490 } 491 492 static ssize_t rx8025_sysfs_store_clock_adjust(struct device *dev, 493 struct device_attribute *attr, 494 const char *buf, size_t count) 495 { 496 long adj; 497 int err; 498 499 dev_warn_once(dev, "clock_adjust_ppb is deprecated, use offset\n"); 500 if (kstrtol(buf, 10, &adj) != 0) 501 return -EINVAL; 502 503 err = rx8025_set_offset(dev, -adj); 504 505 return err ? err : count; 506 } 507 508 static DEVICE_ATTR(clock_adjust_ppb, S_IRUGO | S_IWUSR, 509 rx8025_sysfs_show_clock_adjust, 510 rx8025_sysfs_store_clock_adjust); 511 512 static struct attribute *rx8025_attrs[] = { 513 &dev_attr_clock_adjust_ppb.attr, 514 NULL 515 }; 516 517 static const struct attribute_group rx8025_attr_group = { 518 .attrs = rx8025_attrs, 519 }; 520 521 static int rx8025_probe(struct i2c_client *client) 522 { 523 struct i2c_adapter *adapter = client->adapter; 524 struct rx8025_data *rx8025; 525 int err = 0; 526 527 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA 528 | I2C_FUNC_SMBUS_I2C_BLOCK)) { 529 dev_err(&adapter->dev, 530 "doesn't support required functionality\n"); 531 return -EIO; 532 } 533 534 rx8025 = devm_kzalloc_obj(&client->dev, *rx8025); 535 if (!rx8025) 536 return -ENOMEM; 537 538 i2c_set_clientdata(client, rx8025); 539 540 rx8025->model = (uintptr_t)i2c_get_match_data(client); 541 542 err = rx8025_init_client(client); 543 if (err) 544 return err; 545 546 rx8025->rtc = devm_rtc_allocate_device(&client->dev); 547 if (IS_ERR(rx8025->rtc)) 548 return PTR_ERR(rx8025->rtc); 549 550 rx8025->rtc->ops = &rx8025_rtc_ops; 551 rx8025->rtc->range_min = RTC_TIMESTAMP_BEGIN_1900; 552 rx8025->rtc->range_max = RTC_TIMESTAMP_END_2099; 553 554 if (client->irq > 0) { 555 dev_info(&client->dev, "IRQ %d supplied\n", client->irq); 556 err = devm_request_threaded_irq(&client->dev, client->irq, NULL, 557 rx8025_handle_irq, 558 IRQF_ONESHOT, 559 "rx8025", client); 560 if (err) 561 clear_bit(RTC_FEATURE_ALARM, rx8025->rtc->features); 562 } 563 564 set_bit(RTC_FEATURE_ALARM_RES_MINUTE, rx8025->rtc->features); 565 clear_bit(RTC_FEATURE_UPDATE_INTERRUPT, rx8025->rtc->features); 566 567 err = rtc_add_group(rx8025->rtc, &rx8025_attr_group); 568 if (err) 569 return err; 570 571 return devm_rtc_register_device(rx8025->rtc); 572 } 573 574 static struct i2c_driver rx8025_driver = { 575 .driver = { 576 .name = "rtc-rx8025", 577 }, 578 .probe = rx8025_probe, 579 .id_table = rx8025_id, 580 }; 581 582 module_i2c_driver(rx8025_driver); 583 584 MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>"); 585 MODULE_DESCRIPTION("RX-8025 SA/NB RTC driver"); 586 MODULE_LICENSE("GPL"); 587