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