linux/drivers/rtc/rtc-ds1374.c
<<
>>
Prefs
   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_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
  56static const struct i2c_device_id ds1374_id[] = {
  57        { "ds1374", 0 },
  58        { }
  59};
  60MODULE_DEVICE_TABLE(i2c, ds1374_id);
  61
  62#ifdef CONFIG_OF
  63static const struct of_device_id ds1374_of_match[] = {
  64        { .compatible = "dallas,ds1374" },
  65        { }
  66};
  67MODULE_DEVICE_TABLE(of, ds1374_of_match);
  68#endif
  69
  70struct 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
  83static struct i2c_driver ds1374_driver;
  84
  85static 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 (WARN_ON(nbytes > 4))
  93                return -EINVAL;
  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
 108static 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
 127static 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
 159static 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
 172static 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 */
 186static 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
 219out:
 220        mutex_unlock(&ds1374->mutex);
 221        return ret;
 222}
 223
 224static 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
 279out:
 280        mutex_unlock(&ds1374->mutex);
 281        return ret;
 282}
 283#endif
 284
 285static 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
 295static 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
 321out:
 322        if (!ds1374->exiting)
 323                enable_irq(client->irq);
 324unlock:
 325        mutex_unlock(&ds1374->mutex);
 326}
 327
 328#ifndef CONFIG_RTC_DRV_DS1374_WDT
 329static 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
 349out:
 350        mutex_unlock(&ds1374->mutex);
 351        return ret;
 352}
 353#endif
 354
 355static 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 */
 373static struct i2c_client *save_client;
 374/* Default margin */
 375#define WD_TIMO 131762
 376
 377#define DRV_NAME "DS1374 Watchdog"
 378
 379static int wdt_margin = WD_TIMO;
 380static unsigned long wdt_is_open;
 381module_param(wdt_margin, int, 0);
 382MODULE_PARM_DESC(wdt_margin, "Watchdog timeout in seconds (default 32s)");
 383
 384static const struct watchdog_info ds1374_wdt_info = {
 385        .identity       = "DS1374 WTD",
 386        .options        = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING |
 387                                                WDIOF_MAGICCLOSE,
 388};
 389
 390static 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("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;
 422out:
 423        return ret;
 424}
 425
 426
 427/*
 428 * Reload the watchdog timer.  (ie, pat the watchdog)
 429 */
 430static 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
 440static void ds1374_wdt_disable(void)
 441{
 442        int cr;
 443
 444        cr = i2c_smbus_read_byte_data(save_client, DS1374_REG_CR);
 445        /* Disable watchdog timer */
 446        cr &= ~DS1374_REG_CR_WACE;
 447
 448        i2c_smbus_write_byte_data(save_client, DS1374_REG_CR, cr);
 449}
 450
 451/*
 452 * Watchdog device is opened, and watchdog starts running.
 453 */
 454static int ds1374_wdt_open(struct inode *inode, struct file *file)
 455{
 456        struct ds1374 *ds1374 = i2c_get_clientdata(save_client);
 457
 458        if (MINOR(inode->i_rdev) == WATCHDOG_MINOR) {
 459                mutex_lock(&ds1374->mutex);
 460                if (test_and_set_bit(0, &wdt_is_open)) {
 461                        mutex_unlock(&ds1374->mutex);
 462                        return -EBUSY;
 463                }
 464                /*
 465                 *      Activate
 466                 */
 467                wdt_is_open = 1;
 468                mutex_unlock(&ds1374->mutex);
 469                return stream_open(inode, file);
 470        }
 471        return -ENODEV;
 472}
 473
 474/*
 475 * Close the watchdog device.
 476 */
 477static int ds1374_wdt_release(struct inode *inode, struct file *file)
 478{
 479        if (MINOR(inode->i_rdev) == WATCHDOG_MINOR)
 480                clear_bit(0, &wdt_is_open);
 481
 482        return 0;
 483}
 484
 485/*
 486 * Pat the watchdog whenever device is written to.
 487 */
 488static ssize_t ds1374_wdt_write(struct file *file, const char __user *data,
 489                                size_t len, loff_t *ppos)
 490{
 491        if (len) {
 492                ds1374_wdt_ping();
 493                return 1;
 494        }
 495        return 0;
 496}
 497
 498static ssize_t ds1374_wdt_read(struct file *file, char __user *data,
 499                                size_t len, loff_t *ppos)
 500{
 501        return 0;
 502}
 503
 504/*
 505 * Handle commands from user-space.
 506 */
 507static long ds1374_wdt_ioctl(struct file *file, unsigned int cmd,
 508                                                        unsigned long arg)
 509{
 510        int new_margin, options;
 511
 512        switch (cmd) {
 513        case WDIOC_GETSUPPORT:
 514                return copy_to_user((struct watchdog_info __user *)arg,
 515                &ds1374_wdt_info, sizeof(ds1374_wdt_info)) ? -EFAULT : 0;
 516
 517        case WDIOC_GETSTATUS:
 518        case WDIOC_GETBOOTSTATUS:
 519                return put_user(0, (int __user *)arg);
 520        case WDIOC_KEEPALIVE:
 521                ds1374_wdt_ping();
 522                return 0;
 523        case WDIOC_SETTIMEOUT:
 524                if (get_user(new_margin, (int __user *)arg))
 525                        return -EFAULT;
 526
 527                /* the hardware's tick rate is 4096 Hz, so
 528                 * the counter value needs to be scaled accordingly
 529                 */
 530                new_margin <<= 12;
 531                if (new_margin < 1 || new_margin > 16777216)
 532                        return -EINVAL;
 533
 534                wdt_margin = new_margin;
 535                ds1374_wdt_settimeout(new_margin);
 536                ds1374_wdt_ping();
 537                /* fallthrough */
 538        case WDIOC_GETTIMEOUT:
 539                /* when returning ... inverse is true */
 540                return put_user((wdt_margin >> 12), (int __user *)arg);
 541        case WDIOC_SETOPTIONS:
 542                if (copy_from_user(&options, (int __user *)arg, sizeof(int)))
 543                        return -EFAULT;
 544
 545                if (options & WDIOS_DISABLECARD) {
 546                        pr_info("disable watchdog\n");
 547                        ds1374_wdt_disable();
 548                        return 0;
 549                }
 550
 551                if (options & WDIOS_ENABLECARD) {
 552                        pr_info("enable watchdog\n");
 553                        ds1374_wdt_settimeout(wdt_margin);
 554                        ds1374_wdt_ping();
 555                        return 0;
 556                }
 557                return -EINVAL;
 558        }
 559        return -ENOTTY;
 560}
 561
 562static long ds1374_wdt_unlocked_ioctl(struct file *file, unsigned int cmd,
 563                        unsigned long arg)
 564{
 565        int ret;
 566        struct ds1374 *ds1374 = i2c_get_clientdata(save_client);
 567
 568        mutex_lock(&ds1374->mutex);
 569        ret = ds1374_wdt_ioctl(file, cmd, arg);
 570        mutex_unlock(&ds1374->mutex);
 571
 572        return ret;
 573}
 574
 575static int ds1374_wdt_notify_sys(struct notifier_block *this,
 576                        unsigned long code, void *unused)
 577{
 578        if (code == SYS_DOWN || code == SYS_HALT)
 579                /* Disable Watchdog */
 580                ds1374_wdt_disable();
 581        return NOTIFY_DONE;
 582}
 583
 584static const struct file_operations ds1374_wdt_fops = {
 585        .owner                  = THIS_MODULE,
 586        .read                   = ds1374_wdt_read,
 587        .unlocked_ioctl         = ds1374_wdt_unlocked_ioctl,
 588        .compat_ioctl           = compat_ptr_ioctl,
 589        .write                  = ds1374_wdt_write,
 590        .open                   = ds1374_wdt_open,
 591        .release                = ds1374_wdt_release,
 592        .llseek                 = no_llseek,
 593};
 594
 595static struct miscdevice ds1374_miscdev = {
 596        .minor          = WATCHDOG_MINOR,
 597        .name           = "watchdog",
 598        .fops           = &ds1374_wdt_fops,
 599};
 600
 601static struct notifier_block ds1374_wdt_notifier = {
 602        .notifier_call = ds1374_wdt_notify_sys,
 603};
 604
 605#endif /*CONFIG_RTC_DRV_DS1374_WDT*/
 606/*
 607 *****************************************************************************
 608 *
 609 *      Driver Interface
 610 *
 611 *****************************************************************************
 612 */
 613static int ds1374_probe(struct i2c_client *client,
 614                        const struct i2c_device_id *id)
 615{
 616        struct ds1374 *ds1374;
 617        int ret;
 618
 619        ds1374 = devm_kzalloc(&client->dev, sizeof(struct ds1374), GFP_KERNEL);
 620        if (!ds1374)
 621                return -ENOMEM;
 622
 623        ds1374->client = client;
 624        i2c_set_clientdata(client, ds1374);
 625
 626        INIT_WORK(&ds1374->work, ds1374_work);
 627        mutex_init(&ds1374->mutex);
 628
 629        ret = ds1374_check_rtc_status(client);
 630        if (ret)
 631                return ret;
 632
 633        if (client->irq > 0) {
 634                ret = devm_request_irq(&client->dev, client->irq, ds1374_irq, 0,
 635                                        "ds1374", client);
 636                if (ret) {
 637                        dev_err(&client->dev, "unable to request IRQ\n");
 638                        return ret;
 639                }
 640
 641                device_set_wakeup_capable(&client->dev, 1);
 642        }
 643
 644        ds1374->rtc = devm_rtc_device_register(&client->dev, client->name,
 645                                                &ds1374_rtc_ops, THIS_MODULE);
 646        if (IS_ERR(ds1374->rtc)) {
 647                dev_err(&client->dev, "unable to register the class device\n");
 648                return PTR_ERR(ds1374->rtc);
 649        }
 650
 651#ifdef CONFIG_RTC_DRV_DS1374_WDT
 652        save_client = client;
 653        ret = misc_register(&ds1374_miscdev);
 654        if (ret)
 655                return ret;
 656        ret = register_reboot_notifier(&ds1374_wdt_notifier);
 657        if (ret) {
 658                misc_deregister(&ds1374_miscdev);
 659                return ret;
 660        }
 661        ds1374_wdt_settimeout(131072);
 662#endif
 663
 664        return 0;
 665}
 666
 667static int ds1374_remove(struct i2c_client *client)
 668{
 669        struct ds1374 *ds1374 = i2c_get_clientdata(client);
 670#ifdef CONFIG_RTC_DRV_DS1374_WDT
 671        misc_deregister(&ds1374_miscdev);
 672        ds1374_miscdev.parent = NULL;
 673        unregister_reboot_notifier(&ds1374_wdt_notifier);
 674#endif
 675
 676        if (client->irq > 0) {
 677                mutex_lock(&ds1374->mutex);
 678                ds1374->exiting = 1;
 679                mutex_unlock(&ds1374->mutex);
 680
 681                devm_free_irq(&client->dev, client->irq, client);
 682                cancel_work_sync(&ds1374->work);
 683        }
 684
 685        return 0;
 686}
 687
 688#ifdef CONFIG_PM_SLEEP
 689static int ds1374_suspend(struct device *dev)
 690{
 691        struct i2c_client *client = to_i2c_client(dev);
 692
 693        if (client->irq > 0 && device_may_wakeup(&client->dev))
 694                enable_irq_wake(client->irq);
 695        return 0;
 696}
 697
 698static int ds1374_resume(struct device *dev)
 699{
 700        struct i2c_client *client = to_i2c_client(dev);
 701
 702        if (client->irq > 0 && device_may_wakeup(&client->dev))
 703                disable_irq_wake(client->irq);
 704        return 0;
 705}
 706#endif
 707
 708static SIMPLE_DEV_PM_OPS(ds1374_pm, ds1374_suspend, ds1374_resume);
 709
 710static struct i2c_driver ds1374_driver = {
 711        .driver = {
 712                .name = "rtc-ds1374",
 713                .of_match_table = of_match_ptr(ds1374_of_match),
 714                .pm = &ds1374_pm,
 715        },
 716        .probe = ds1374_probe,
 717        .remove = ds1374_remove,
 718        .id_table = ds1374_id,
 719};
 720
 721module_i2c_driver(ds1374_driver);
 722
 723MODULE_AUTHOR("Scott Wood <scottwood@freescale.com>");
 724MODULE_DESCRIPTION("Maxim/Dallas DS1374 RTC Driver");
 725MODULE_LICENSE("GPL");
 726