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