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 i2c_client *client; 71 struct rtc_device *rtc; 72 u8 ctrl1; 73 }; 74 75 static s32 rx8025_read_reg(const struct i2c_client *client, u8 number) 76 { 77 return i2c_smbus_read_byte_data(client, number << 4); 78 } 79 80 static int rx8025_read_regs(const struct i2c_client *client, 81 u8 number, u8 length, u8 *values) 82 { 83 int ret = i2c_smbus_read_i2c_block_data(client, number << 4, length, 84 values); 85 if (ret != length) 86 return ret < 0 ? ret : -EIO; 87 88 return 0; 89 } 90 91 static s32 rx8025_write_reg(const struct i2c_client *client, u8 number, 92 u8 value) 93 { 94 return i2c_smbus_write_byte_data(client, number << 4, value); 95 } 96 97 static s32 rx8025_write_regs(const struct i2c_client *client, 98 u8 number, u8 length, const u8 *values) 99 { 100 return i2c_smbus_write_i2c_block_data(client, number << 4, 101 length, values); 102 } 103 104 static int rx8025_check_validity(struct device *dev) 105 { 106 struct rx8025_data *rx8025 = dev_get_drvdata(dev); 107 int ctrl2; 108 109 ctrl2 = rx8025_read_reg(rx8025->client, RX8025_REG_CTRL2); 110 if (ctrl2 < 0) 111 return ctrl2; 112 113 if (ctrl2 & RX8025_BIT_CTRL2_VDET) 114 dev_warn(dev, "power voltage drop detected\n"); 115 116 if (ctrl2 & RX8025_BIT_CTRL2_PON) { 117 dev_warn(dev, "power-on reset detected, date is invalid\n"); 118 return -EINVAL; 119 } 120 121 if (!(ctrl2 & RX8025_BIT_CTRL2_XST)) { 122 dev_warn(dev, "crystal stopped, date is invalid\n"); 123 return -EINVAL; 124 } 125 126 return 0; 127 } 128 129 static int rx8025_reset_validity(struct i2c_client *client) 130 { 131 int ctrl2 = rx8025_read_reg(client, RX8025_REG_CTRL2); 132 133 if (ctrl2 < 0) 134 return ctrl2; 135 136 ctrl2 &= ~(RX8025_BIT_CTRL2_PON | RX8025_BIT_CTRL2_VDET); 137 138 return rx8025_write_reg(client, RX8025_REG_CTRL2, 139 ctrl2 | RX8025_BIT_CTRL2_XST); 140 } 141 142 static irqreturn_t rx8025_handle_irq(int irq, void *dev_id) 143 { 144 struct i2c_client *client = dev_id; 145 struct rx8025_data *rx8025 = i2c_get_clientdata(client); 146 struct mutex *lock = &rx8025->rtc->ops_lock; 147 int status; 148 149 mutex_lock(lock); 150 status = rx8025_read_reg(client, RX8025_REG_CTRL2); 151 if (status < 0) 152 goto out; 153 154 if (!(status & RX8025_BIT_CTRL2_XST)) 155 dev_warn(&client->dev, "Oscillation stop was detected," 156 "you may have to readjust the clock\n"); 157 158 if (status & RX8025_BIT_CTRL2_CTFG) { 159 /* periodic */ 160 status &= ~RX8025_BIT_CTRL2_CTFG; 161 rtc_update_irq(rx8025->rtc, 1, RTC_PF | RTC_IRQF); 162 } 163 164 if (status & RX8025_BIT_CTRL2_DAFG) { 165 /* alarm */ 166 status &= RX8025_BIT_CTRL2_DAFG; 167 if (rx8025_write_reg(client, RX8025_REG_CTRL1, 168 rx8025->ctrl1 & ~RX8025_BIT_CTRL1_DALE)) 169 goto out; 170 rtc_update_irq(rx8025->rtc, 1, RTC_AF | RTC_IRQF); 171 } 172 173 out: 174 mutex_unlock(lock); 175 176 return IRQ_HANDLED; 177 } 178 179 static int rx8025_get_time(struct device *dev, struct rtc_time *dt) 180 { 181 struct rx8025_data *rx8025 = dev_get_drvdata(dev); 182 u8 date[7]; 183 int err; 184 185 err = rx8025_check_validity(dev); 186 if (err) 187 return err; 188 189 err = rx8025_read_regs(rx8025->client, RX8025_REG_SEC, 7, date); 190 if (err) 191 return err; 192 193 dev_dbg(dev, "%s: read %7ph\n", __func__, date); 194 195 dt->tm_sec = bcd2bin(date[RX8025_REG_SEC] & 0x7f); 196 dt->tm_min = bcd2bin(date[RX8025_REG_MIN] & 0x7f); 197 if (rx8025->ctrl1 & RX8025_BIT_CTRL1_1224) 198 dt->tm_hour = bcd2bin(date[RX8025_REG_HOUR] & 0x3f); 199 else 200 dt->tm_hour = bcd2bin(date[RX8025_REG_HOUR] & 0x1f) % 12 201 + (date[RX8025_REG_HOUR] & 0x20 ? 12 : 0); 202 203 dt->tm_mday = bcd2bin(date[RX8025_REG_MDAY] & 0x3f); 204 dt->tm_mon = bcd2bin(date[RX8025_REG_MONTH] & 0x1f) - 1; 205 dt->tm_year = bcd2bin(date[RX8025_REG_YEAR]) + 100; 206 207 dev_dbg(dev, "%s: date %ptRr\n", __func__, dt); 208 209 return 0; 210 } 211 212 static int rx8025_set_time(struct device *dev, struct rtc_time *dt) 213 { 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(rx8025->client, RX8025_REG_SEC, 7, date); 241 if (ret < 0) 242 return ret; 243 244 return rx8025_reset_validity(rx8025->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(rx8025->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 rx8025_data *rx8025 = dev_get_drvdata(dev); 284 struct i2c_client *client = rx8025->client; 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(rx8025->client, RX8025_REG_CTRL1, 351 rx8025->ctrl1); 352 if (err) 353 return err; 354 } 355 err = rx8025_write_regs(rx8025->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(rx8025->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 rx8025_data *rx8025 = dev_get_drvdata(dev); 373 u8 ctrl1; 374 int err; 375 376 ctrl1 = rx8025->ctrl1; 377 if (enabled) 378 ctrl1 |= RX8025_BIT_CTRL1_DALE; 379 else 380 ctrl1 &= ~RX8025_BIT_CTRL1_DALE; 381 382 if (ctrl1 != rx8025->ctrl1) { 383 rx8025->ctrl1 = ctrl1; 384 err = rx8025_write_reg(rx8025->client, RX8025_REG_CTRL1, 385 rx8025->ctrl1); 386 if (err) 387 return err; 388 } 389 return 0; 390 } 391 392 static const struct rtc_class_ops rx8025_rtc_ops = { 393 .read_time = rx8025_get_time, 394 .set_time = rx8025_set_time, 395 .read_alarm = rx8025_read_alarm, 396 .set_alarm = rx8025_set_alarm, 397 .alarm_irq_enable = rx8025_alarm_irq_enable, 398 }; 399 400 /* 401 * Clock precision adjustment support 402 * 403 * According to the RX8025 SA/NB application manual the frequency and 404 * temperature characteristics can be approximated using the following 405 * equation: 406 * 407 * df = a * (ut - t)**2 408 * 409 * df: Frequency deviation in any temperature 410 * a : Coefficient = (-35 +-5) * 10**-9 411 * ut: Ultimate temperature in degree = +25 +-5 degree 412 * t : Any temperature in degree 413 * 414 * Note that the clock adjustment in ppb must be entered (which is 415 * the negative value of the deviation). 416 */ 417 static int rx8025_get_clock_adjust(struct device *dev, int *adj) 418 { 419 struct i2c_client *client = to_i2c_client(dev); 420 int digoff; 421 422 digoff = rx8025_read_reg(client, RX8025_REG_DIGOFF); 423 if (digoff < 0) 424 return digoff; 425 426 *adj = digoff >= 64 ? digoff - 128 : digoff; 427 if (*adj > 0) 428 (*adj)--; 429 *adj *= -RX8025_ADJ_RESOLUTION; 430 431 return 0; 432 } 433 434 static int rx8025_set_clock_adjust(struct device *dev, int adj) 435 { 436 struct i2c_client *client = to_i2c_client(dev); 437 u8 digoff; 438 int err; 439 440 adj /= -RX8025_ADJ_RESOLUTION; 441 if (adj > RX8025_ADJ_DATA_MAX) 442 adj = RX8025_ADJ_DATA_MAX; 443 else if (adj < RX8025_ADJ_DATA_MIN) 444 adj = RX8025_ADJ_DATA_MIN; 445 else if (adj > 0) 446 adj++; 447 else if (adj < 0) 448 adj += 128; 449 digoff = adj; 450 451 err = rx8025_write_reg(client, RX8025_REG_DIGOFF, digoff); 452 if (err) 453 return err; 454 455 dev_dbg(dev, "%s: write 0x%02x\n", __func__, digoff); 456 457 return 0; 458 } 459 460 static ssize_t rx8025_sysfs_show_clock_adjust(struct device *dev, 461 struct device_attribute *attr, 462 char *buf) 463 { 464 int err, adj; 465 466 err = rx8025_get_clock_adjust(dev, &adj); 467 if (err) 468 return err; 469 470 return sprintf(buf, "%d\n", adj); 471 } 472 473 static ssize_t rx8025_sysfs_store_clock_adjust(struct device *dev, 474 struct device_attribute *attr, 475 const char *buf, size_t count) 476 { 477 int adj, err; 478 479 if (sscanf(buf, "%i", &adj) != 1) 480 return -EINVAL; 481 482 err = rx8025_set_clock_adjust(dev, adj); 483 484 return err ? err : count; 485 } 486 487 static DEVICE_ATTR(clock_adjust_ppb, S_IRUGO | S_IWUSR, 488 rx8025_sysfs_show_clock_adjust, 489 rx8025_sysfs_store_clock_adjust); 490 491 static int rx8025_sysfs_register(struct device *dev) 492 { 493 return device_create_file(dev, &dev_attr_clock_adjust_ppb); 494 } 495 496 static void rx8025_sysfs_unregister(struct device *dev) 497 { 498 device_remove_file(dev, &dev_attr_clock_adjust_ppb); 499 } 500 501 static int rx8025_probe(struct i2c_client *client, 502 const struct i2c_device_id *id) 503 { 504 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); 505 struct rx8025_data *rx8025; 506 int err = 0; 507 508 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA 509 | I2C_FUNC_SMBUS_I2C_BLOCK)) { 510 dev_err(&adapter->dev, 511 "doesn't support required functionality\n"); 512 return -EIO; 513 } 514 515 rx8025 = devm_kzalloc(&client->dev, sizeof(*rx8025), GFP_KERNEL); 516 if (!rx8025) 517 return -ENOMEM; 518 519 rx8025->client = client; 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