1 /* 2 * RTC client/driver for the Maxim/Dallas DS1374 Real-Time Clock over I2C 3 * 4 * Based on code by Randy Vinson <rvinson@mvista.com>, 5 * which was based on the m41t00.c by Mark Greer <mgreer@mvista.com>. 6 * 7 * Copyright (C) 2014 Rose Technology 8 * Copyright (C) 2006-2007 Freescale Semiconductor 9 * 10 * 2005 (c) MontaVista Software, Inc. This file is licensed under 11 * the terms of the GNU General Public License version 2. This program 12 * is licensed "as is" without any warranty of any kind, whether express 13 * or implied. 14 */ 15 /* 16 * It would be more efficient to use i2c msgs/i2c_transfer directly but, as 17 * recommened in .../Documentation/i2c/writing-clients section 18 * "Sending and receiving", using SMBus level communication is preferred. 19 */ 20 21 #include <linux/kernel.h> 22 #include <linux/module.h> 23 #include <linux/interrupt.h> 24 #include <linux/i2c.h> 25 #include <linux/rtc.h> 26 #include <linux/bcd.h> 27 #include <linux/workqueue.h> 28 #include <linux/slab.h> 29 #include <linux/pm.h> 30 #ifdef CONFIG_RTC_DRV_DS1374_WDT 31 #include <linux/fs.h> 32 #include <linux/ioctl.h> 33 #include <linux/miscdevice.h> 34 #include <linux/reboot.h> 35 #include <linux/watchdog.h> 36 #endif 37 38 #define DS1374_REG_TOD0 0x00 /* Time of Day */ 39 #define DS1374_REG_TOD1 0x01 40 #define DS1374_REG_TOD2 0x02 41 #define DS1374_REG_TOD3 0x03 42 #define DS1374_REG_WDALM0 0x04 /* Watchdog/Alarm */ 43 #define DS1374_REG_WDALM1 0x05 44 #define DS1374_REG_WDALM2 0x06 45 #define DS1374_REG_CR 0x07 /* Control */ 46 #define DS1374_REG_CR_AIE 0x01 /* Alarm Int. Enable */ 47 #define DS1374_REG_CR_WDALM 0x20 /* 1=Watchdog, 0=Alarm */ 48 #define DS1374_REG_CR_WACE 0x40 /* WD/Alarm counter enable */ 49 #define DS1374_REG_SR 0x08 /* Status */ 50 #define DS1374_REG_SR_OSF 0x80 /* Oscillator Stop Flag */ 51 #define DS1374_REG_SR_AF 0x01 /* Alarm Flag */ 52 #define DS1374_REG_TCR 0x09 /* Trickle Charge */ 53 54 static const struct i2c_device_id ds1374_id[] = { 55 { "ds1374", 0 }, 56 { } 57 }; 58 MODULE_DEVICE_TABLE(i2c, ds1374_id); 59 60 #ifdef CONFIG_OF 61 static const struct of_device_id ds1374_of_match[] = { 62 { .compatible = "dallas,ds1374" }, 63 { } 64 }; 65 MODULE_DEVICE_TABLE(of, ds1374_of_match); 66 #endif 67 68 struct ds1374 { 69 struct i2c_client *client; 70 struct rtc_device *rtc; 71 struct work_struct work; 72 73 /* The mutex protects alarm operations, and prevents a race 74 * between the enable_irq() in the workqueue and the free_irq() 75 * in the remove function. 76 */ 77 struct mutex mutex; 78 int exiting; 79 }; 80 81 static struct i2c_driver ds1374_driver; 82 83 static int ds1374_read_rtc(struct i2c_client *client, u32 *time, 84 int reg, int nbytes) 85 { 86 u8 buf[4]; 87 int ret; 88 int i; 89 90 if (nbytes > 4) { 91 WARN_ON(1); 92 return -EINVAL; 93 } 94 95 ret = i2c_smbus_read_i2c_block_data(client, reg, nbytes, buf); 96 97 if (ret < 0) 98 return ret; 99 if (ret < nbytes) 100 return -EIO; 101 102 for (i = nbytes - 1, *time = 0; i >= 0; i--) 103 *time = (*time << 8) | buf[i]; 104 105 return 0; 106 } 107 108 static int ds1374_write_rtc(struct i2c_client *client, u32 time, 109 int reg, int nbytes) 110 { 111 u8 buf[4]; 112 int i; 113 114 if (nbytes > 4) { 115 WARN_ON(1); 116 return -EINVAL; 117 } 118 119 for (i = 0; i < nbytes; i++) { 120 buf[i] = time & 0xff; 121 time >>= 8; 122 } 123 124 return i2c_smbus_write_i2c_block_data(client, reg, nbytes, buf); 125 } 126 127 static int ds1374_check_rtc_status(struct i2c_client *client) 128 { 129 int ret = 0; 130 int control, stat; 131 132 stat = i2c_smbus_read_byte_data(client, DS1374_REG_SR); 133 if (stat < 0) 134 return stat; 135 136 if (stat & DS1374_REG_SR_OSF) 137 dev_warn(&client->dev, 138 "oscillator discontinuity flagged, time unreliable\n"); 139 140 stat &= ~(DS1374_REG_SR_OSF | DS1374_REG_SR_AF); 141 142 ret = i2c_smbus_write_byte_data(client, DS1374_REG_SR, stat); 143 if (ret < 0) 144 return ret; 145 146 /* If the alarm is pending, clear it before requesting 147 * the interrupt, so an interrupt event isn't reported 148 * before everything is initialized. 149 */ 150 151 control = i2c_smbus_read_byte_data(client, DS1374_REG_CR); 152 if (control < 0) 153 return control; 154 155 control &= ~(DS1374_REG_CR_WACE | DS1374_REG_CR_AIE); 156 return i2c_smbus_write_byte_data(client, DS1374_REG_CR, control); 157 } 158 159 static int ds1374_read_time(struct device *dev, struct rtc_time *time) 160 { 161 struct i2c_client *client = to_i2c_client(dev); 162 u32 itime; 163 int ret; 164 165 ret = ds1374_read_rtc(client, &itime, DS1374_REG_TOD0, 4); 166 if (!ret) 167 rtc_time_to_tm(itime, time); 168 169 return ret; 170 } 171 172 static int ds1374_set_time(struct device *dev, struct rtc_time *time) 173 { 174 struct i2c_client *client = to_i2c_client(dev); 175 unsigned long itime; 176 177 rtc_tm_to_time(time, &itime); 178 return ds1374_write_rtc(client, itime, DS1374_REG_TOD0, 4); 179 } 180 181 #ifndef CONFIG_RTC_DRV_DS1374_WDT 182 /* The ds1374 has a decrementer for an alarm, rather than a comparator. 183 * If the time of day is changed, then the alarm will need to be 184 * reset. 185 */ 186 static int ds1374_read_alarm(struct device *dev, struct rtc_wkalrm *alarm) 187 { 188 struct i2c_client *client = to_i2c_client(dev); 189 struct ds1374 *ds1374 = i2c_get_clientdata(client); 190 u32 now, cur_alarm; 191 int cr, sr; 192 int ret = 0; 193 194 if (client->irq <= 0) 195 return -EINVAL; 196 197 mutex_lock(&ds1374->mutex); 198 199 cr = ret = i2c_smbus_read_byte_data(client, DS1374_REG_CR); 200 if (ret < 0) 201 goto out; 202 203 sr = ret = i2c_smbus_read_byte_data(client, DS1374_REG_SR); 204 if (ret < 0) 205 goto out; 206 207 ret = ds1374_read_rtc(client, &now, DS1374_REG_TOD0, 4); 208 if (ret) 209 goto out; 210 211 ret = ds1374_read_rtc(client, &cur_alarm, DS1374_REG_WDALM0, 3); 212 if (ret) 213 goto out; 214 215 rtc_time_to_tm(now + cur_alarm, &alarm->time); 216 alarm->enabled = !!(cr & DS1374_REG_CR_WACE); 217 alarm->pending = !!(sr & DS1374_REG_SR_AF); 218 219 out: 220 mutex_unlock(&ds1374->mutex); 221 return ret; 222 } 223 224 static int ds1374_set_alarm(struct device *dev, struct rtc_wkalrm *alarm) 225 { 226 struct i2c_client *client = to_i2c_client(dev); 227 struct ds1374 *ds1374 = i2c_get_clientdata(client); 228 struct rtc_time now; 229 unsigned long new_alarm, itime; 230 int cr; 231 int ret = 0; 232 233 if (client->irq <= 0) 234 return -EINVAL; 235 236 ret = ds1374_read_time(dev, &now); 237 if (ret < 0) 238 return ret; 239 240 rtc_tm_to_time(&alarm->time, &new_alarm); 241 rtc_tm_to_time(&now, &itime); 242 243 /* This can happen due to races, in addition to dates that are 244 * truly in the past. To avoid requiring the caller to check for 245 * races, dates in the past are assumed to be in the recent past 246 * (i.e. not something that we'd rather the caller know about via 247 * an error), and the alarm is set to go off as soon as possible. 248 */ 249 if (time_before_eq(new_alarm, itime)) 250 new_alarm = 1; 251 else 252 new_alarm -= itime; 253 254 mutex_lock(&ds1374->mutex); 255 256 ret = cr = i2c_smbus_read_byte_data(client, DS1374_REG_CR); 257 if (ret < 0) 258 goto out; 259 260 /* Disable any existing alarm before setting the new one 261 * (or lack thereof). */ 262 cr &= ~DS1374_REG_CR_WACE; 263 264 ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, cr); 265 if (ret < 0) 266 goto out; 267 268 ret = ds1374_write_rtc(client, new_alarm, DS1374_REG_WDALM0, 3); 269 if (ret) 270 goto out; 271 272 if (alarm->enabled) { 273 cr |= DS1374_REG_CR_WACE | DS1374_REG_CR_AIE; 274 cr &= ~DS1374_REG_CR_WDALM; 275 276 ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, cr); 277 } 278 279 out: 280 mutex_unlock(&ds1374->mutex); 281 return ret; 282 } 283 #endif 284 285 static irqreturn_t ds1374_irq(int irq, void *dev_id) 286 { 287 struct i2c_client *client = dev_id; 288 struct ds1374 *ds1374 = i2c_get_clientdata(client); 289 290 disable_irq_nosync(irq); 291 schedule_work(&ds1374->work); 292 return IRQ_HANDLED; 293 } 294 295 static void ds1374_work(struct work_struct *work) 296 { 297 struct ds1374 *ds1374 = container_of(work, struct ds1374, work); 298 struct i2c_client *client = ds1374->client; 299 int stat, control; 300 301 mutex_lock(&ds1374->mutex); 302 303 stat = i2c_smbus_read_byte_data(client, DS1374_REG_SR); 304 if (stat < 0) 305 goto unlock; 306 307 if (stat & DS1374_REG_SR_AF) { 308 stat &= ~DS1374_REG_SR_AF; 309 i2c_smbus_write_byte_data(client, DS1374_REG_SR, stat); 310 311 control = i2c_smbus_read_byte_data(client, DS1374_REG_CR); 312 if (control < 0) 313 goto out; 314 315 control &= ~(DS1374_REG_CR_WACE | DS1374_REG_CR_AIE); 316 i2c_smbus_write_byte_data(client, DS1374_REG_CR, control); 317 318 rtc_update_irq(ds1374->rtc, 1, RTC_AF | RTC_IRQF); 319 } 320 321 out: 322 if (!ds1374->exiting) 323 enable_irq(client->irq); 324 unlock: 325 mutex_unlock(&ds1374->mutex); 326 } 327 328 #ifndef CONFIG_RTC_DRV_DS1374_WDT 329 static int ds1374_alarm_irq_enable(struct device *dev, unsigned int enabled) 330 { 331 struct i2c_client *client = to_i2c_client(dev); 332 struct ds1374 *ds1374 = i2c_get_clientdata(client); 333 int ret; 334 335 mutex_lock(&ds1374->mutex); 336 337 ret = i2c_smbus_read_byte_data(client, DS1374_REG_CR); 338 if (ret < 0) 339 goto out; 340 341 if (enabled) { 342 ret |= DS1374_REG_CR_WACE | DS1374_REG_CR_AIE; 343 ret &= ~DS1374_REG_CR_WDALM; 344 } else { 345 ret &= ~DS1374_REG_CR_WACE; 346 } 347 ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, ret); 348 349 out: 350 mutex_unlock(&ds1374->mutex); 351 return ret; 352 } 353 #endif 354 355 static const struct rtc_class_ops ds1374_rtc_ops = { 356 .read_time = ds1374_read_time, 357 .set_time = ds1374_set_time, 358 #ifndef CONFIG_RTC_DRV_DS1374_WDT 359 .read_alarm = ds1374_read_alarm, 360 .set_alarm = ds1374_set_alarm, 361 .alarm_irq_enable = ds1374_alarm_irq_enable, 362 #endif 363 }; 364 365 #ifdef CONFIG_RTC_DRV_DS1374_WDT 366 /* 367 ***************************************************************************** 368 * 369 * Watchdog Driver 370 * 371 ***************************************************************************** 372 */ 373 static struct i2c_client *save_client; 374 /* Default margin */ 375 #define WD_TIMO 131762 376 377 #define DRV_NAME "DS1374 Watchdog" 378 379 static int wdt_margin = WD_TIMO; 380 static unsigned long wdt_is_open; 381 module_param(wdt_margin, int, 0); 382 MODULE_PARM_DESC(wdt_margin, "Watchdog timeout in seconds (default 32s)"); 383 384 static const struct watchdog_info ds1374_wdt_info = { 385 .identity = "DS1374 WTD", 386 .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | 387 WDIOF_MAGICCLOSE, 388 }; 389 390 static int ds1374_wdt_settimeout(unsigned int timeout) 391 { 392 int ret = -ENOIOCTLCMD; 393 int cr; 394 395 ret = cr = i2c_smbus_read_byte_data(save_client, DS1374_REG_CR); 396 if (ret < 0) 397 goto out; 398 399 /* Disable any existing watchdog/alarm before setting the new one */ 400 cr &= ~DS1374_REG_CR_WACE; 401 402 ret = i2c_smbus_write_byte_data(save_client, DS1374_REG_CR, cr); 403 if (ret < 0) 404 goto out; 405 406 /* Set new watchdog time */ 407 ret = ds1374_write_rtc(save_client, timeout, DS1374_REG_WDALM0, 3); 408 if (ret) { 409 pr_info("rtc-ds1374 - couldn't set new watchdog time\n"); 410 goto out; 411 } 412 413 /* Enable watchdog timer */ 414 cr |= DS1374_REG_CR_WACE | DS1374_REG_CR_WDALM; 415 cr &= ~DS1374_REG_CR_AIE; 416 417 ret = i2c_smbus_write_byte_data(save_client, DS1374_REG_CR, cr); 418 if (ret < 0) 419 goto out; 420 421 return 0; 422 out: 423 return ret; 424 } 425 426 427 /* 428 * Reload the watchdog timer. (ie, pat the watchdog) 429 */ 430 static void ds1374_wdt_ping(void) 431 { 432 u32 val; 433 int ret = 0; 434 435 ret = ds1374_read_rtc(save_client, &val, DS1374_REG_WDALM0, 3); 436 if (ret) 437 pr_info("WD TICK FAIL!!!!!!!!!! %i\n", ret); 438 } 439 440 static void ds1374_wdt_disable(void) 441 { 442 int ret = -ENOIOCTLCMD; 443 int cr; 444 445 cr = i2c_smbus_read_byte_data(save_client, DS1374_REG_CR); 446 /* Disable watchdog timer */ 447 cr &= ~DS1374_REG_CR_WACE; 448 449 ret = i2c_smbus_write_byte_data(save_client, DS1374_REG_CR, cr); 450 } 451 452 /* 453 * Watchdog device is opened, and watchdog starts running. 454 */ 455 static int ds1374_wdt_open(struct inode *inode, struct file *file) 456 { 457 struct ds1374 *ds1374 = i2c_get_clientdata(save_client); 458 459 if (MINOR(inode->i_rdev) == WATCHDOG_MINOR) { 460 mutex_lock(&ds1374->mutex); 461 if (test_and_set_bit(0, &wdt_is_open)) { 462 mutex_unlock(&ds1374->mutex); 463 return -EBUSY; 464 } 465 /* 466 * Activate 467 */ 468 wdt_is_open = 1; 469 mutex_unlock(&ds1374->mutex); 470 return nonseekable_open(inode, file); 471 } 472 return -ENODEV; 473 } 474 475 /* 476 * Close the watchdog device. 477 */ 478 static int ds1374_wdt_release(struct inode *inode, struct file *file) 479 { 480 if (MINOR(inode->i_rdev) == WATCHDOG_MINOR) 481 clear_bit(0, &wdt_is_open); 482 483 return 0; 484 } 485 486 /* 487 * Pat the watchdog whenever device is written to. 488 */ 489 static ssize_t ds1374_wdt_write(struct file *file, const char __user *data, 490 size_t len, loff_t *ppos) 491 { 492 if (len) { 493 ds1374_wdt_ping(); 494 return 1; 495 } 496 return 0; 497 } 498 499 static ssize_t ds1374_wdt_read(struct file *file, char __user *data, 500 size_t len, loff_t *ppos) 501 { 502 return 0; 503 } 504 505 /* 506 * Handle commands from user-space. 507 */ 508 static long ds1374_wdt_ioctl(struct file *file, unsigned int cmd, 509 unsigned long arg) 510 { 511 int new_margin, options; 512 513 switch (cmd) { 514 case WDIOC_GETSUPPORT: 515 return copy_to_user((struct watchdog_info __user *)arg, 516 &ds1374_wdt_info, sizeof(ds1374_wdt_info)) ? -EFAULT : 0; 517 518 case WDIOC_GETSTATUS: 519 case WDIOC_GETBOOTSTATUS: 520 return put_user(0, (int __user *)arg); 521 case WDIOC_KEEPALIVE: 522 ds1374_wdt_ping(); 523 return 0; 524 case WDIOC_SETTIMEOUT: 525 if (get_user(new_margin, (int __user *)arg)) 526 return -EFAULT; 527 528 if (new_margin < 1 || new_margin > 16777216) 529 return -EINVAL; 530 531 wdt_margin = new_margin; 532 ds1374_wdt_settimeout(new_margin); 533 ds1374_wdt_ping(); 534 /* fallthrough */ 535 case WDIOC_GETTIMEOUT: 536 return put_user(wdt_margin, (int __user *)arg); 537 case WDIOC_SETOPTIONS: 538 if (copy_from_user(&options, (int __user *)arg, sizeof(int))) 539 return -EFAULT; 540 541 if (options & WDIOS_DISABLECARD) { 542 pr_info("rtc-ds1374: disable watchdog\n"); 543 ds1374_wdt_disable(); 544 } 545 546 if (options & WDIOS_ENABLECARD) { 547 pr_info("rtc-ds1374: enable watchdog\n"); 548 ds1374_wdt_settimeout(wdt_margin); 549 ds1374_wdt_ping(); 550 } 551 552 return -EINVAL; 553 } 554 return -ENOTTY; 555 } 556 557 static long ds1374_wdt_unlocked_ioctl(struct file *file, unsigned int cmd, 558 unsigned long arg) 559 { 560 int ret; 561 struct ds1374 *ds1374 = i2c_get_clientdata(save_client); 562 563 mutex_lock(&ds1374->mutex); 564 ret = ds1374_wdt_ioctl(file, cmd, arg); 565 mutex_unlock(&ds1374->mutex); 566 567 return ret; 568 } 569 570 static int ds1374_wdt_notify_sys(struct notifier_block *this, 571 unsigned long code, void *unused) 572 { 573 if (code == SYS_DOWN || code == SYS_HALT) 574 /* Disable Watchdog */ 575 ds1374_wdt_disable(); 576 return NOTIFY_DONE; 577 } 578 579 static const struct file_operations ds1374_wdt_fops = { 580 .owner = THIS_MODULE, 581 .read = ds1374_wdt_read, 582 .unlocked_ioctl = ds1374_wdt_unlocked_ioctl, 583 .write = ds1374_wdt_write, 584 .open = ds1374_wdt_open, 585 .release = ds1374_wdt_release, 586 .llseek = no_llseek, 587 }; 588 589 static struct miscdevice ds1374_miscdev = { 590 .minor = WATCHDOG_MINOR, 591 .name = "watchdog", 592 .fops = &ds1374_wdt_fops, 593 }; 594 595 static struct notifier_block ds1374_wdt_notifier = { 596 .notifier_call = ds1374_wdt_notify_sys, 597 }; 598 599 #endif /*CONFIG_RTC_DRV_DS1374_WDT*/ 600 /* 601 ***************************************************************************** 602 * 603 * Driver Interface 604 * 605 ***************************************************************************** 606 */ 607 static int ds1374_probe(struct i2c_client *client, 608 const struct i2c_device_id *id) 609 { 610 struct ds1374 *ds1374; 611 int ret; 612 613 ds1374 = devm_kzalloc(&client->dev, sizeof(struct ds1374), GFP_KERNEL); 614 if (!ds1374) 615 return -ENOMEM; 616 617 ds1374->client = client; 618 i2c_set_clientdata(client, ds1374); 619 620 INIT_WORK(&ds1374->work, ds1374_work); 621 mutex_init(&ds1374->mutex); 622 623 ret = ds1374_check_rtc_status(client); 624 if (ret) 625 return ret; 626 627 if (client->irq > 0) { 628 ret = devm_request_irq(&client->dev, client->irq, ds1374_irq, 0, 629 "ds1374", client); 630 if (ret) { 631 dev_err(&client->dev, "unable to request IRQ\n"); 632 return ret; 633 } 634 635 device_set_wakeup_capable(&client->dev, 1); 636 } 637 638 ds1374->rtc = devm_rtc_device_register(&client->dev, client->name, 639 &ds1374_rtc_ops, THIS_MODULE); 640 if (IS_ERR(ds1374->rtc)) { 641 dev_err(&client->dev, "unable to register the class device\n"); 642 return PTR_ERR(ds1374->rtc); 643 } 644 645 #ifdef CONFIG_RTC_DRV_DS1374_WDT 646 save_client = client; 647 ret = misc_register(&ds1374_miscdev); 648 if (ret) 649 return ret; 650 ret = register_reboot_notifier(&ds1374_wdt_notifier); 651 if (ret) { 652 misc_deregister(&ds1374_miscdev); 653 return ret; 654 } 655 ds1374_wdt_settimeout(131072); 656 #endif 657 658 return 0; 659 } 660 661 static int ds1374_remove(struct i2c_client *client) 662 { 663 struct ds1374 *ds1374 = i2c_get_clientdata(client); 664 #ifdef CONFIG_RTC_DRV_DS1374_WDT 665 int res; 666 667 res = misc_deregister(&ds1374_miscdev); 668 if (!res) 669 ds1374_miscdev.parent = NULL; 670 unregister_reboot_notifier(&ds1374_wdt_notifier); 671 #endif 672 673 if (client->irq > 0) { 674 mutex_lock(&ds1374->mutex); 675 ds1374->exiting = 1; 676 mutex_unlock(&ds1374->mutex); 677 678 devm_free_irq(&client->dev, client->irq, client); 679 cancel_work_sync(&ds1374->work); 680 } 681 682 return 0; 683 } 684 685 #ifdef CONFIG_PM_SLEEP 686 static int ds1374_suspend(struct device *dev) 687 { 688 struct i2c_client *client = to_i2c_client(dev); 689 690 if (client->irq >= 0 && device_may_wakeup(&client->dev)) 691 enable_irq_wake(client->irq); 692 return 0; 693 } 694 695 static int ds1374_resume(struct device *dev) 696 { 697 struct i2c_client *client = to_i2c_client(dev); 698 699 if (client->irq >= 0 && device_may_wakeup(&client->dev)) 700 disable_irq_wake(client->irq); 701 return 0; 702 } 703 #endif 704 705 static SIMPLE_DEV_PM_OPS(ds1374_pm, ds1374_suspend, ds1374_resume); 706 707 static struct i2c_driver ds1374_driver = { 708 .driver = { 709 .name = "rtc-ds1374", 710 .owner = THIS_MODULE, 711 .pm = &ds1374_pm, 712 }, 713 .probe = ds1374_probe, 714 .remove = ds1374_remove, 715 .id_table = ds1374_id, 716 }; 717 718 module_i2c_driver(ds1374_driver); 719 720 MODULE_AUTHOR("Scott Wood <scottwood@freescale.com>"); 721 MODULE_DESCRIPTION("Maxim/Dallas DS1374 RTC Driver"); 722 MODULE_LICENSE("GPL"); 723