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