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 * recommended in .../Documentation/i2c/writing-clients.rst 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_WDSTR 0x08 /* 1=INT, 0=RST */ 50 #define DS1374_REG_CR_WDALM 0x20 /* 1=Watchdog, 0=Alarm */ 51 #define DS1374_REG_CR_WACE 0x40 /* WD/Alarm counter enable */ 52 #define DS1374_REG_SR 0x08 /* Status */ 53 #define DS1374_REG_SR_OSF 0x80 /* Oscillator Stop Flag */ 54 #define DS1374_REG_SR_AF 0x01 /* Alarm Flag */ 55 #define DS1374_REG_TCR 0x09 /* Trickle Charge */ 56 57 static const struct i2c_device_id ds1374_id[] = { 58 { "ds1374", 0 }, 59 { } 60 }; 61 MODULE_DEVICE_TABLE(i2c, ds1374_id); 62 63 #ifdef CONFIG_OF 64 static const struct of_device_id ds1374_of_match[] = { 65 { .compatible = "dallas,ds1374" }, 66 { } 67 }; 68 MODULE_DEVICE_TABLE(of, ds1374_of_match); 69 #endif 70 71 struct ds1374 { 72 struct i2c_client *client; 73 struct rtc_device *rtc; 74 struct work_struct work; 75 #ifdef CONFIG_RTC_DRV_DS1374_WDT 76 struct watchdog_device wdt; 77 #endif 78 /* The mutex protects alarm operations, and prevents a race 79 * between the enable_irq() in the workqueue and the free_irq() 80 * in the remove function. 81 */ 82 struct mutex mutex; 83 int exiting; 84 }; 85 86 static struct i2c_driver ds1374_driver; 87 88 static int ds1374_read_rtc(struct i2c_client *client, u32 *time, 89 int reg, int nbytes) 90 { 91 u8 buf[4]; 92 int ret; 93 int i; 94 95 if (WARN_ON(nbytes > 4)) 96 return -EINVAL; 97 98 ret = i2c_smbus_read_i2c_block_data(client, reg, nbytes, buf); 99 100 if (ret < 0) 101 return ret; 102 if (ret < nbytes) 103 return -EIO; 104 105 for (i = nbytes - 1, *time = 0; i >= 0; i--) 106 *time = (*time << 8) | buf[i]; 107 108 return 0; 109 } 110 111 static int ds1374_write_rtc(struct i2c_client *client, u32 time, 112 int reg, int nbytes) 113 { 114 u8 buf[4]; 115 int i; 116 117 if (nbytes > 4) { 118 WARN_ON(1); 119 return -EINVAL; 120 } 121 122 for (i = 0; i < nbytes; i++) { 123 buf[i] = time & 0xff; 124 time >>= 8; 125 } 126 127 return i2c_smbus_write_i2c_block_data(client, reg, nbytes, buf); 128 } 129 130 static int ds1374_check_rtc_status(struct i2c_client *client) 131 { 132 int ret = 0; 133 int control, stat; 134 135 stat = i2c_smbus_read_byte_data(client, DS1374_REG_SR); 136 if (stat < 0) 137 return stat; 138 139 if (stat & DS1374_REG_SR_OSF) 140 dev_warn(&client->dev, 141 "oscillator discontinuity flagged, time unreliable\n"); 142 143 stat &= ~(DS1374_REG_SR_OSF | DS1374_REG_SR_AF); 144 145 ret = i2c_smbus_write_byte_data(client, DS1374_REG_SR, stat); 146 if (ret < 0) 147 return ret; 148 149 /* If the alarm is pending, clear it before requesting 150 * the interrupt, so an interrupt event isn't reported 151 * before everything is initialized. 152 */ 153 154 control = i2c_smbus_read_byte_data(client, DS1374_REG_CR); 155 if (control < 0) 156 return control; 157 158 control &= ~(DS1374_REG_CR_WACE | DS1374_REG_CR_AIE); 159 return i2c_smbus_write_byte_data(client, DS1374_REG_CR, control); 160 } 161 162 static int ds1374_read_time(struct device *dev, struct rtc_time *time) 163 { 164 struct i2c_client *client = to_i2c_client(dev); 165 u32 itime; 166 int ret; 167 168 ret = ds1374_read_rtc(client, &itime, DS1374_REG_TOD0, 4); 169 if (!ret) 170 rtc_time64_to_tm(itime, time); 171 172 return ret; 173 } 174 175 static int ds1374_set_time(struct device *dev, struct rtc_time *time) 176 { 177 struct i2c_client *client = to_i2c_client(dev); 178 unsigned long itime = rtc_tm_to_time64(time); 179 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_time64_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 new_alarm = rtc_tm_to_time64(&alarm->time); 243 itime = rtc_tm_to_time64(&now); 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 /* Default margin */ 376 #define TIMER_MARGIN_DEFAULT 32 377 #define TIMER_MARGIN_MIN 1 378 #define TIMER_MARGIN_MAX 4095 /* 24-bit value */ 379 380 static int wdt_margin; 381 module_param(wdt_margin, int, 0); 382 MODULE_PARM_DESC(wdt_margin, "Watchdog timeout in seconds (default 32s)"); 383 384 static bool nowayout = WATCHDOG_NOWAYOUT; 385 module_param(nowayout, bool, 0); 386 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default =" 387 __MODULE_STRING(WATCHDOG_NOWAYOUT)")"); 388 389 static const struct watchdog_info ds1374_wdt_info = { 390 .identity = "DS1374 Watchdog", 391 .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | 392 WDIOF_MAGICCLOSE, 393 }; 394 395 static int ds1374_wdt_settimeout(struct watchdog_device *wdt, unsigned int timeout) 396 { 397 struct ds1374 *ds1374 = watchdog_get_drvdata(wdt); 398 struct i2c_client *client = ds1374->client; 399 int ret, cr; 400 401 wdt->timeout = timeout; 402 403 cr = i2c_smbus_read_byte_data(client, DS1374_REG_CR); 404 if (cr < 0) 405 return cr; 406 407 /* Disable any existing watchdog/alarm before setting the new one */ 408 cr &= ~DS1374_REG_CR_WACE; 409 410 ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, cr); 411 if (ret < 0) 412 return ret; 413 414 /* Set new watchdog time */ 415 timeout = timeout * 4096; 416 ret = ds1374_write_rtc(client, timeout, DS1374_REG_WDALM0, 3); 417 if (ret) 418 return ret; 419 420 /* Enable watchdog timer */ 421 cr |= DS1374_REG_CR_WACE | DS1374_REG_CR_WDALM; 422 cr &= ~DS1374_REG_CR_WDSTR;/* for RST PIN */ 423 cr &= ~DS1374_REG_CR_AIE; 424 425 ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, cr); 426 if (ret < 0) 427 return ret; 428 429 return 0; 430 } 431 432 /* 433 * Reload the watchdog timer. (ie, pat the watchdog) 434 */ 435 static int ds1374_wdt_start(struct watchdog_device *wdt) 436 { 437 struct ds1374 *ds1374 = watchdog_get_drvdata(wdt); 438 u32 val; 439 440 return ds1374_read_rtc(ds1374->client, &val, DS1374_REG_WDALM0, 3); 441 } 442 443 static int ds1374_wdt_stop(struct watchdog_device *wdt) 444 { 445 struct ds1374 *ds1374 = watchdog_get_drvdata(wdt); 446 struct i2c_client *client = ds1374->client; 447 int cr; 448 449 cr = i2c_smbus_read_byte_data(client, DS1374_REG_CR); 450 if (cr < 0) 451 return cr; 452 453 /* Disable watchdog timer */ 454 cr &= ~DS1374_REG_CR_WACE; 455 456 return i2c_smbus_write_byte_data(client, DS1374_REG_CR, cr); 457 } 458 459 static const struct watchdog_ops ds1374_wdt_ops = { 460 .owner = THIS_MODULE, 461 .start = ds1374_wdt_start, 462 .stop = ds1374_wdt_stop, 463 .set_timeout = ds1374_wdt_settimeout, 464 }; 465 #endif /*CONFIG_RTC_DRV_DS1374_WDT*/ 466 /* 467 ***************************************************************************** 468 * 469 * Driver Interface 470 * 471 ***************************************************************************** 472 */ 473 static int ds1374_probe(struct i2c_client *client, 474 const struct i2c_device_id *id) 475 { 476 struct ds1374 *ds1374; 477 int ret; 478 479 ds1374 = devm_kzalloc(&client->dev, sizeof(struct ds1374), GFP_KERNEL); 480 if (!ds1374) 481 return -ENOMEM; 482 483 ds1374->rtc = devm_rtc_allocate_device(&client->dev); 484 if (IS_ERR(ds1374->rtc)) 485 return PTR_ERR(ds1374->rtc); 486 487 ds1374->client = client; 488 i2c_set_clientdata(client, ds1374); 489 490 INIT_WORK(&ds1374->work, ds1374_work); 491 mutex_init(&ds1374->mutex); 492 493 ret = ds1374_check_rtc_status(client); 494 if (ret) 495 return ret; 496 497 if (client->irq > 0) { 498 ret = devm_request_irq(&client->dev, client->irq, ds1374_irq, 0, 499 "ds1374", client); 500 if (ret) { 501 dev_err(&client->dev, "unable to request IRQ\n"); 502 return ret; 503 } 504 505 device_set_wakeup_capable(&client->dev, 1); 506 } 507 508 ds1374->rtc->ops = &ds1374_rtc_ops; 509 ds1374->rtc->range_max = U32_MAX; 510 511 ret = devm_rtc_register_device(ds1374->rtc); 512 if (ret) 513 return ret; 514 515 #ifdef CONFIG_RTC_DRV_DS1374_WDT 516 ds1374->wdt.info = &ds1374_wdt_info; 517 ds1374->wdt.ops = &ds1374_wdt_ops; 518 ds1374->wdt.timeout = TIMER_MARGIN_DEFAULT; 519 ds1374->wdt.min_timeout = TIMER_MARGIN_MIN; 520 ds1374->wdt.max_timeout = TIMER_MARGIN_MAX; 521 522 watchdog_init_timeout(&ds1374->wdt, wdt_margin, &client->dev); 523 watchdog_set_nowayout(&ds1374->wdt, nowayout); 524 watchdog_stop_on_reboot(&ds1374->wdt); 525 watchdog_stop_on_unregister(&ds1374->wdt); 526 watchdog_set_drvdata(&ds1374->wdt, ds1374); 527 ds1374_wdt_settimeout(&ds1374->wdt, ds1374->wdt.timeout); 528 529 ret = devm_watchdog_register_device(&client->dev, &ds1374->wdt); 530 if (ret) 531 return ret; 532 #endif 533 534 return 0; 535 } 536 537 static int ds1374_remove(struct i2c_client *client) 538 { 539 struct ds1374 *ds1374 = i2c_get_clientdata(client); 540 541 if (client->irq > 0) { 542 mutex_lock(&ds1374->mutex); 543 ds1374->exiting = 1; 544 mutex_unlock(&ds1374->mutex); 545 546 devm_free_irq(&client->dev, client->irq, client); 547 cancel_work_sync(&ds1374->work); 548 } 549 550 return 0; 551 } 552 553 #ifdef CONFIG_PM_SLEEP 554 static int ds1374_suspend(struct device *dev) 555 { 556 struct i2c_client *client = to_i2c_client(dev); 557 558 if (client->irq > 0 && device_may_wakeup(&client->dev)) 559 enable_irq_wake(client->irq); 560 return 0; 561 } 562 563 static int ds1374_resume(struct device *dev) 564 { 565 struct i2c_client *client = to_i2c_client(dev); 566 567 if (client->irq > 0 && device_may_wakeup(&client->dev)) 568 disable_irq_wake(client->irq); 569 return 0; 570 } 571 #endif 572 573 static SIMPLE_DEV_PM_OPS(ds1374_pm, ds1374_suspend, ds1374_resume); 574 575 static struct i2c_driver ds1374_driver = { 576 .driver = { 577 .name = "rtc-ds1374", 578 .of_match_table = of_match_ptr(ds1374_of_match), 579 .pm = &ds1374_pm, 580 }, 581 .probe = ds1374_probe, 582 .remove = ds1374_remove, 583 .id_table = ds1374_id, 584 }; 585 586 module_i2c_driver(ds1374_driver); 587 588 MODULE_AUTHOR("Scott Wood <scottwood@freescale.com>"); 589 MODULE_DESCRIPTION("Maxim/Dallas DS1374 RTC Driver"); 590 MODULE_LICENSE("GPL"); 591