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