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