drivers/rtc/rtc-ds1374.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
ds1374_read_rtc
ds1374_write_rtc
ds1374_check_rtc_status
ds1374_read_time
ds1374_set_time
ds1374_read_alarm
ds1374_set_alarm
ds1374_irq
ds1374_work
ds1374_alarm_irq_enable
ds1374_wdt_settimeout
ds1374_wdt_ping
ds1374_wdt_disable
ds1374_wdt_open
ds1374_wdt_release
ds1374_wdt_write
ds1374_wdt_read
ds1374_wdt_ioctl
ds1374_wdt_unlocked_ioctl
ds1374_wdt_notify_sys
ds1374_probe
ds1374_remove
ds1374_suspend
ds1374_resume
   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 
  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 (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 
 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("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 stream_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                 /* the hardware's tick rate is 4096 Hz, so
 529                  * the counter value needs to be scaled accordingly
 530                  */
 531                 new_margin <<= 12;
 532                 if (new_margin < 1 || new_margin > 16777216)
 533                         return -EINVAL;
 534 
 535                 wdt_margin = new_margin;
 536                 ds1374_wdt_settimeout(new_margin);
 537                 ds1374_wdt_ping();
 538                 /* fallthrough */
 539         case WDIOC_GETTIMEOUT:
 540                 /* when returning ... inverse is true */
 541                 return put_user((wdt_margin >> 12), (int __user *)arg);
 542         case WDIOC_SETOPTIONS:
 543                 if (copy_from_user(&options, (int __user *)arg, sizeof(int)))
 544                         return -EFAULT;
 545 
 546                 if (options & WDIOS_DISABLECARD) {
 547                         pr_info("disable watchdog\n");
 548                         ds1374_wdt_disable();
 549                         return 0;
 550                 }
 551 
 552                 if (options & WDIOS_ENABLECARD) {
 553                         pr_info("enable watchdog\n");
 554                         ds1374_wdt_settimeout(wdt_margin);
 555                         ds1374_wdt_ping();
 556                         return 0;
 557                 }
 558                 return -EINVAL;
 559         }
 560         return -ENOTTY;
 561 }
 562 
 563 static long ds1374_wdt_unlocked_ioctl(struct file *file, unsigned int cmd,
 564                         unsigned long arg)
 565 {
 566         int ret;
 567         struct ds1374 *ds1374 = i2c_get_clientdata(save_client);
 568 
 569         mutex_lock(&ds1374->mutex);
 570         ret = ds1374_wdt_ioctl(file, cmd, arg);
 571         mutex_unlock(&ds1374->mutex);
 572 
 573         return ret;
 574 }
 575 
 576 static int ds1374_wdt_notify_sys(struct notifier_block *this,
 577                         unsigned long code, void *unused)
 578 {
 579         if (code == SYS_DOWN || code == SYS_HALT)
 580                 /* Disable Watchdog */
 581                 ds1374_wdt_disable();
 582         return NOTIFY_DONE;
 583 }
 584 
 585 static const struct file_operations ds1374_wdt_fops = {
 586         .owner                  = THIS_MODULE,
 587         .read                   = ds1374_wdt_read,
 588         .unlocked_ioctl         = ds1374_wdt_unlocked_ioctl,
 589         .write                  = ds1374_wdt_write,
 590         .open                   = ds1374_wdt_open,
 591         .release                = ds1374_wdt_release,
 592         .llseek                 = no_llseek,
 593 };
 594 
 595 static struct miscdevice ds1374_miscdev = {
 596         .minor          = WATCHDOG_MINOR,
 597         .name           = "watchdog",
 598         .fops           = &ds1374_wdt_fops,
 599 };
 600 
 601 static 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  */
 613 static 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 
 667 static 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
 689 static 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 
 698 static 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 
 708 static SIMPLE_DEV_PM_OPS(ds1374_pm, ds1374_suspend, ds1374_resume);
 709 
 710 static 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 
 721 module_i2c_driver(ds1374_driver);
 722 
 723 MODULE_AUTHOR("Scott Wood <scottwood@freescale.com>");
 724 MODULE_DESCRIPTION("Maxim/Dallas DS1374 RTC Driver");
 725 MODULE_LICENSE("GPL");
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/rtc/rtc-ds1374.c

DEFINITIONS
