1 /* rtc-ds1343.c 2 * 3 * Driver for Dallas Semiconductor DS1343 Low Current, SPI Compatible 4 * Real Time Clock 5 * 6 * Author : Raghavendra Chandra Ganiga <ravi23ganiga@gmail.com> 7 * Ankur Srivastava <sankurece@gmail.com> : DS1343 Nvram Support 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 as 11 * published by the Free Software Foundation. 12 * 13 */ 14 15 #include <linux/init.h> 16 #include <linux/module.h> 17 #include <linux/interrupt.h> 18 #include <linux/device.h> 19 #include <linux/spi/spi.h> 20 #include <linux/regmap.h> 21 #include <linux/rtc.h> 22 #include <linux/bcd.h> 23 #include <linux/pm.h> 24 #include <linux/pm_wakeirq.h> 25 #include <linux/slab.h> 26 27 #define DS1343_DRV_VERSION "01.00" 28 #define DALLAS_MAXIM_DS1343 0 29 #define DALLAS_MAXIM_DS1344 1 30 31 /* RTC DS1343 Registers */ 32 #define DS1343_SECONDS_REG 0x00 33 #define DS1343_MINUTES_REG 0x01 34 #define DS1343_HOURS_REG 0x02 35 #define DS1343_DAY_REG 0x03 36 #define DS1343_DATE_REG 0x04 37 #define DS1343_MONTH_REG 0x05 38 #define DS1343_YEAR_REG 0x06 39 #define DS1343_ALM0_SEC_REG 0x07 40 #define DS1343_ALM0_MIN_REG 0x08 41 #define DS1343_ALM0_HOUR_REG 0x09 42 #define DS1343_ALM0_DAY_REG 0x0A 43 #define DS1343_ALM1_SEC_REG 0x0B 44 #define DS1343_ALM1_MIN_REG 0x0C 45 #define DS1343_ALM1_HOUR_REG 0x0D 46 #define DS1343_ALM1_DAY_REG 0x0E 47 #define DS1343_CONTROL_REG 0x0F 48 #define DS1343_STATUS_REG 0x10 49 #define DS1343_TRICKLE_REG 0x11 50 #define DS1343_NVRAM 0x20 51 52 #define DS1343_NVRAM_LEN 96 53 54 /* DS1343 Control Registers bits */ 55 #define DS1343_EOSC 0x80 56 #define DS1343_DOSF 0x20 57 #define DS1343_EGFIL 0x10 58 #define DS1343_SQW 0x08 59 #define DS1343_INTCN 0x04 60 #define DS1343_A1IE 0x02 61 #define DS1343_A0IE 0x01 62 63 /* DS1343 Status Registers bits */ 64 #define DS1343_OSF 0x80 65 #define DS1343_IRQF1 0x02 66 #define DS1343_IRQF0 0x01 67 68 /* DS1343 Trickle Charger Registers bits */ 69 #define DS1343_TRICKLE_MAGIC 0xa0 70 #define DS1343_TRICKLE_DS1 0x08 71 #define DS1343_TRICKLE_1K 0x01 72 #define DS1343_TRICKLE_2K 0x02 73 #define DS1343_TRICKLE_4K 0x03 74 75 static const struct spi_device_id ds1343_id[] = { 76 { "ds1343", DALLAS_MAXIM_DS1343 }, 77 { "ds1344", DALLAS_MAXIM_DS1344 }, 78 { } 79 }; 80 MODULE_DEVICE_TABLE(spi, ds1343_id); 81 82 struct ds1343_priv { 83 struct spi_device *spi; 84 struct rtc_device *rtc; 85 struct regmap *map; 86 struct mutex mutex; 87 unsigned int irqen; 88 int irq; 89 int alarm_sec; 90 int alarm_min; 91 int alarm_hour; 92 int alarm_mday; 93 }; 94 95 static int ds1343_ioctl(struct device *dev, unsigned int cmd, unsigned long arg) 96 { 97 switch (cmd) { 98 #ifdef RTC_SET_CHARGE 99 case RTC_SET_CHARGE: 100 { 101 int val; 102 103 if (copy_from_user(&val, (int __user *)arg, sizeof(int))) 104 return -EFAULT; 105 106 return regmap_write(priv->map, DS1343_TRICKLE_REG, val); 107 } 108 break; 109 #endif 110 } 111 112 return -ENOIOCTLCMD; 113 } 114 115 static ssize_t ds1343_show_glitchfilter(struct device *dev, 116 struct device_attribute *attr, char *buf) 117 { 118 struct ds1343_priv *priv = dev_get_drvdata(dev); 119 int glitch_filt_status, data; 120 121 regmap_read(priv->map, DS1343_CONTROL_REG, &data); 122 123 glitch_filt_status = !!(data & DS1343_EGFIL); 124 125 if (glitch_filt_status) 126 return sprintf(buf, "enabled\n"); 127 else 128 return sprintf(buf, "disabled\n"); 129 } 130 131 static ssize_t ds1343_store_glitchfilter(struct device *dev, 132 struct device_attribute *attr, 133 const char *buf, size_t count) 134 { 135 struct ds1343_priv *priv = dev_get_drvdata(dev); 136 int data; 137 138 regmap_read(priv->map, DS1343_CONTROL_REG, &data); 139 140 if (strncmp(buf, "enabled", 7) == 0) 141 data |= DS1343_EGFIL; 142 143 else if (strncmp(buf, "disabled", 8) == 0) 144 data &= ~(DS1343_EGFIL); 145 146 else 147 return -EINVAL; 148 149 regmap_write(priv->map, DS1343_CONTROL_REG, data); 150 151 return count; 152 } 153 154 static DEVICE_ATTR(glitch_filter, S_IRUGO | S_IWUSR, ds1343_show_glitchfilter, 155 ds1343_store_glitchfilter); 156 157 static ssize_t ds1343_nvram_write(struct file *filp, struct kobject *kobj, 158 struct bin_attribute *attr, 159 char *buf, loff_t off, size_t count) 160 { 161 int ret; 162 unsigned char address; 163 struct device *dev = kobj_to_dev(kobj); 164 struct ds1343_priv *priv = dev_get_drvdata(dev); 165 166 address = DS1343_NVRAM + off; 167 168 ret = regmap_bulk_write(priv->map, address, buf, count); 169 if (ret < 0) 170 dev_err(&priv->spi->dev, "Error in nvram write %d", ret); 171 172 return (ret < 0) ? ret : count; 173 } 174 175 176 static ssize_t ds1343_nvram_read(struct file *filp, struct kobject *kobj, 177 struct bin_attribute *attr, 178 char *buf, loff_t off, size_t count) 179 { 180 int ret; 181 unsigned char address; 182 struct device *dev = kobj_to_dev(kobj); 183 struct ds1343_priv *priv = dev_get_drvdata(dev); 184 185 address = DS1343_NVRAM + off; 186 187 ret = regmap_bulk_read(priv->map, address, buf, count); 188 if (ret < 0) 189 dev_err(&priv->spi->dev, "Error in nvram read %d\n", ret); 190 191 return (ret < 0) ? ret : count; 192 } 193 194 195 static struct bin_attribute nvram_attr = { 196 .attr.name = "nvram", 197 .attr.mode = S_IRUGO | S_IWUSR, 198 .read = ds1343_nvram_read, 199 .write = ds1343_nvram_write, 200 .size = DS1343_NVRAM_LEN, 201 }; 202 203 static ssize_t ds1343_show_alarmstatus(struct device *dev, 204 struct device_attribute *attr, char *buf) 205 { 206 struct ds1343_priv *priv = dev_get_drvdata(dev); 207 int alarmstatus, data; 208 209 regmap_read(priv->map, DS1343_CONTROL_REG, &data); 210 211 alarmstatus = !!(data & DS1343_A0IE); 212 213 if (alarmstatus) 214 return sprintf(buf, "enabled\n"); 215 else 216 return sprintf(buf, "disabled\n"); 217 } 218 219 static DEVICE_ATTR(alarm_status, S_IRUGO, ds1343_show_alarmstatus, NULL); 220 221 static ssize_t ds1343_show_alarmmode(struct device *dev, 222 struct device_attribute *attr, char *buf) 223 { 224 struct ds1343_priv *priv = dev_get_drvdata(dev); 225 int alarm_mode, data; 226 char *alarm_str; 227 228 regmap_read(priv->map, DS1343_ALM0_SEC_REG, &data); 229 alarm_mode = (data & 0x80) >> 4; 230 231 regmap_read(priv->map, DS1343_ALM0_MIN_REG, &data); 232 alarm_mode |= (data & 0x80) >> 5; 233 234 regmap_read(priv->map, DS1343_ALM0_HOUR_REG, &data); 235 alarm_mode |= (data & 0x80) >> 6; 236 237 regmap_read(priv->map, DS1343_ALM0_DAY_REG, &data); 238 alarm_mode |= (data & 0x80) >> 7; 239 240 switch (alarm_mode) { 241 case 15: 242 alarm_str = "each second"; 243 break; 244 245 case 7: 246 alarm_str = "seconds match"; 247 break; 248 249 case 3: 250 alarm_str = "minutes and seconds match"; 251 break; 252 253 case 1: 254 alarm_str = "hours, minutes and seconds match"; 255 break; 256 257 case 0: 258 alarm_str = "day, hours, minutes and seconds match"; 259 break; 260 261 default: 262 alarm_str = "invalid"; 263 break; 264 } 265 266 return sprintf(buf, "%s\n", alarm_str); 267 } 268 269 static DEVICE_ATTR(alarm_mode, S_IRUGO, ds1343_show_alarmmode, NULL); 270 271 static ssize_t ds1343_show_tricklecharger(struct device *dev, 272 struct device_attribute *attr, char *buf) 273 { 274 struct ds1343_priv *priv = dev_get_drvdata(dev); 275 int data; 276 char *diodes = "disabled", *resistors = " "; 277 278 regmap_read(priv->map, DS1343_TRICKLE_REG, &data); 279 280 if ((data & 0xf0) == DS1343_TRICKLE_MAGIC) { 281 switch (data & 0x0c) { 282 case DS1343_TRICKLE_DS1: 283 diodes = "one diode,"; 284 break; 285 286 default: 287 diodes = "no diode,"; 288 break; 289 } 290 291 switch (data & 0x03) { 292 case DS1343_TRICKLE_1K: 293 resistors = "1k Ohm"; 294 break; 295 296 case DS1343_TRICKLE_2K: 297 resistors = "2k Ohm"; 298 break; 299 300 case DS1343_TRICKLE_4K: 301 resistors = "4k Ohm"; 302 break; 303 304 default: 305 diodes = "disabled"; 306 break; 307 } 308 } 309 310 return sprintf(buf, "%s %s\n", diodes, resistors); 311 } 312 313 static DEVICE_ATTR(trickle_charger, S_IRUGO, ds1343_show_tricklecharger, NULL); 314 315 static int ds1343_sysfs_register(struct device *dev) 316 { 317 struct ds1343_priv *priv = dev_get_drvdata(dev); 318 int err; 319 320 err = device_create_file(dev, &dev_attr_glitch_filter); 321 if (err) 322 return err; 323 324 err = device_create_file(dev, &dev_attr_trickle_charger); 325 if (err) 326 goto error1; 327 328 err = device_create_bin_file(dev, &nvram_attr); 329 if (err) 330 goto error2; 331 332 if (priv->irq <= 0) 333 return err; 334 335 err = device_create_file(dev, &dev_attr_alarm_mode); 336 if (err) 337 goto error3; 338 339 err = device_create_file(dev, &dev_attr_alarm_status); 340 if (!err) 341 return err; 342 343 device_remove_file(dev, &dev_attr_alarm_mode); 344 345 error3: 346 device_remove_bin_file(dev, &nvram_attr); 347 348 error2: 349 device_remove_file(dev, &dev_attr_trickle_charger); 350 351 error1: 352 device_remove_file(dev, &dev_attr_glitch_filter); 353 354 return err; 355 } 356 357 static void ds1343_sysfs_unregister(struct device *dev) 358 { 359 struct ds1343_priv *priv = dev_get_drvdata(dev); 360 361 device_remove_file(dev, &dev_attr_glitch_filter); 362 device_remove_file(dev, &dev_attr_trickle_charger); 363 device_remove_bin_file(dev, &nvram_attr); 364 365 if (priv->irq <= 0) 366 return; 367 368 device_remove_file(dev, &dev_attr_alarm_status); 369 device_remove_file(dev, &dev_attr_alarm_mode); 370 } 371 372 static int ds1343_read_time(struct device *dev, struct rtc_time *dt) 373 { 374 struct ds1343_priv *priv = dev_get_drvdata(dev); 375 unsigned char buf[7]; 376 int res; 377 378 res = regmap_bulk_read(priv->map, DS1343_SECONDS_REG, buf, 7); 379 if (res) 380 return res; 381 382 dt->tm_sec = bcd2bin(buf[0]); 383 dt->tm_min = bcd2bin(buf[1]); 384 dt->tm_hour = bcd2bin(buf[2] & 0x3F); 385 dt->tm_wday = bcd2bin(buf[3]) - 1; 386 dt->tm_mday = bcd2bin(buf[4]); 387 dt->tm_mon = bcd2bin(buf[5] & 0x1F) - 1; 388 dt->tm_year = bcd2bin(buf[6]) + 100; /* year offset from 1900 */ 389 390 return rtc_valid_tm(dt); 391 } 392 393 static int ds1343_set_time(struct device *dev, struct rtc_time *dt) 394 { 395 struct ds1343_priv *priv = dev_get_drvdata(dev); 396 int res; 397 398 res = regmap_write(priv->map, DS1343_SECONDS_REG, 399 bin2bcd(dt->tm_sec)); 400 if (res) 401 return res; 402 403 res = regmap_write(priv->map, DS1343_MINUTES_REG, 404 bin2bcd(dt->tm_min)); 405 if (res) 406 return res; 407 408 res = regmap_write(priv->map, DS1343_HOURS_REG, 409 bin2bcd(dt->tm_hour) & 0x3F); 410 if (res) 411 return res; 412 413 res = regmap_write(priv->map, DS1343_DAY_REG, 414 bin2bcd(dt->tm_wday + 1)); 415 if (res) 416 return res; 417 418 res = regmap_write(priv->map, DS1343_DATE_REG, 419 bin2bcd(dt->tm_mday)); 420 if (res) 421 return res; 422 423 res = regmap_write(priv->map, DS1343_MONTH_REG, 424 bin2bcd(dt->tm_mon + 1)); 425 if (res) 426 return res; 427 428 dt->tm_year %= 100; 429 430 res = regmap_write(priv->map, DS1343_YEAR_REG, 431 bin2bcd(dt->tm_year)); 432 if (res) 433 return res; 434 435 return 0; 436 } 437 438 static int ds1343_update_alarm(struct device *dev) 439 { 440 struct ds1343_priv *priv = dev_get_drvdata(dev); 441 unsigned int control, stat; 442 unsigned char buf[4]; 443 int res = 0; 444 445 res = regmap_read(priv->map, DS1343_CONTROL_REG, &control); 446 if (res) 447 return res; 448 449 res = regmap_read(priv->map, DS1343_STATUS_REG, &stat); 450 if (res) 451 return res; 452 453 control &= ~(DS1343_A0IE); 454 stat &= ~(DS1343_IRQF0); 455 456 res = regmap_write(priv->map, DS1343_CONTROL_REG, control); 457 if (res) 458 return res; 459 460 res = regmap_write(priv->map, DS1343_STATUS_REG, stat); 461 if (res) 462 return res; 463 464 buf[0] = priv->alarm_sec < 0 || (priv->irqen & RTC_UF) ? 465 0x80 : bin2bcd(priv->alarm_sec) & 0x7F; 466 buf[1] = priv->alarm_min < 0 || (priv->irqen & RTC_UF) ? 467 0x80 : bin2bcd(priv->alarm_min) & 0x7F; 468 buf[2] = priv->alarm_hour < 0 || (priv->irqen & RTC_UF) ? 469 0x80 : bin2bcd(priv->alarm_hour) & 0x3F; 470 buf[3] = priv->alarm_mday < 0 || (priv->irqen & RTC_UF) ? 471 0x80 : bin2bcd(priv->alarm_mday) & 0x7F; 472 473 res = regmap_bulk_write(priv->map, DS1343_ALM0_SEC_REG, buf, 4); 474 if (res) 475 return res; 476 477 if (priv->irqen) { 478 control |= DS1343_A0IE; 479 res = regmap_write(priv->map, DS1343_CONTROL_REG, control); 480 } 481 482 return res; 483 } 484 485 static int ds1343_read_alarm(struct device *dev, struct rtc_wkalrm *alarm) 486 { 487 struct ds1343_priv *priv = dev_get_drvdata(dev); 488 int res = 0; 489 unsigned int stat; 490 491 if (priv->irq <= 0) 492 return -EINVAL; 493 494 mutex_lock(&priv->mutex); 495 496 res = regmap_read(priv->map, DS1343_STATUS_REG, &stat); 497 if (res) 498 goto out; 499 500 alarm->enabled = !!(priv->irqen & RTC_AF); 501 alarm->pending = !!(stat & DS1343_IRQF0); 502 503 alarm->time.tm_sec = priv->alarm_sec < 0 ? 0 : priv->alarm_sec; 504 alarm->time.tm_min = priv->alarm_min < 0 ? 0 : priv->alarm_min; 505 alarm->time.tm_hour = priv->alarm_hour < 0 ? 0 : priv->alarm_hour; 506 alarm->time.tm_mday = priv->alarm_mday < 0 ? 0 : priv->alarm_mday; 507 508 alarm->time.tm_mon = -1; 509 alarm->time.tm_year = -1; 510 alarm->time.tm_wday = -1; 511 alarm->time.tm_yday = -1; 512 alarm->time.tm_isdst = -1; 513 514 out: 515 mutex_unlock(&priv->mutex); 516 return res; 517 } 518 519 static int ds1343_set_alarm(struct device *dev, struct rtc_wkalrm *alarm) 520 { 521 struct ds1343_priv *priv = dev_get_drvdata(dev); 522 int res = 0; 523 524 if (priv->irq <= 0) 525 return -EINVAL; 526 527 mutex_lock(&priv->mutex); 528 529 priv->alarm_sec = alarm->time.tm_sec; 530 priv->alarm_min = alarm->time.tm_min; 531 priv->alarm_hour = alarm->time.tm_hour; 532 priv->alarm_mday = alarm->time.tm_mday; 533 534 if (alarm->enabled) 535 priv->irqen |= RTC_AF; 536 537 res = ds1343_update_alarm(dev); 538 539 mutex_unlock(&priv->mutex); 540 541 return res; 542 } 543 544 static int ds1343_alarm_irq_enable(struct device *dev, unsigned int enabled) 545 { 546 struct ds1343_priv *priv = dev_get_drvdata(dev); 547 int res = 0; 548 549 if (priv->irq <= 0) 550 return -EINVAL; 551 552 mutex_lock(&priv->mutex); 553 554 if (enabled) 555 priv->irqen |= RTC_AF; 556 else 557 priv->irqen &= ~RTC_AF; 558 559 res = ds1343_update_alarm(dev); 560 561 mutex_unlock(&priv->mutex); 562 563 return res; 564 } 565 566 static irqreturn_t ds1343_thread(int irq, void *dev_id) 567 { 568 struct ds1343_priv *priv = dev_id; 569 unsigned int stat, control; 570 int res = 0; 571 572 mutex_lock(&priv->mutex); 573 574 res = regmap_read(priv->map, DS1343_STATUS_REG, &stat); 575 if (res) 576 goto out; 577 578 if (stat & DS1343_IRQF0) { 579 stat &= ~DS1343_IRQF0; 580 regmap_write(priv->map, DS1343_STATUS_REG, stat); 581 582 res = regmap_read(priv->map, DS1343_CONTROL_REG, &control); 583 if (res) 584 goto out; 585 586 control &= ~DS1343_A0IE; 587 regmap_write(priv->map, DS1343_CONTROL_REG, control); 588 589 rtc_update_irq(priv->rtc, 1, RTC_AF | RTC_IRQF); 590 } 591 592 out: 593 mutex_unlock(&priv->mutex); 594 return IRQ_HANDLED; 595 } 596 597 static const struct rtc_class_ops ds1343_rtc_ops = { 598 .ioctl = ds1343_ioctl, 599 .read_time = ds1343_read_time, 600 .set_time = ds1343_set_time, 601 .read_alarm = ds1343_read_alarm, 602 .set_alarm = ds1343_set_alarm, 603 .alarm_irq_enable = ds1343_alarm_irq_enable, 604 }; 605 606 static int ds1343_probe(struct spi_device *spi) 607 { 608 struct ds1343_priv *priv; 609 struct regmap_config config; 610 unsigned int data; 611 int res; 612 613 memset(&config, 0, sizeof(config)); 614 config.reg_bits = 8; 615 config.val_bits = 8; 616 config.write_flag_mask = 0x80; 617 618 priv = devm_kzalloc(&spi->dev, sizeof(struct ds1343_priv), GFP_KERNEL); 619 if (!priv) 620 return -ENOMEM; 621 622 priv->spi = spi; 623 mutex_init(&priv->mutex); 624 625 /* RTC DS1347 works in spi mode 3 and 626 * its chip select is active high 627 */ 628 spi->mode = SPI_MODE_3 | SPI_CS_HIGH; 629 spi->bits_per_word = 8; 630 res = spi_setup(spi); 631 if (res) 632 return res; 633 634 spi_set_drvdata(spi, priv); 635 636 priv->map = devm_regmap_init_spi(spi, &config); 637 638 if (IS_ERR(priv->map)) { 639 dev_err(&spi->dev, "spi regmap init failed for rtc ds1343\n"); 640 return PTR_ERR(priv->map); 641 } 642 643 res = regmap_read(priv->map, DS1343_SECONDS_REG, &data); 644 if (res) 645 return res; 646 647 regmap_read(priv->map, DS1343_CONTROL_REG, &data); 648 data |= DS1343_INTCN; 649 data &= ~(DS1343_EOSC | DS1343_A1IE | DS1343_A0IE); 650 regmap_write(priv->map, DS1343_CONTROL_REG, data); 651 652 regmap_read(priv->map, DS1343_STATUS_REG, &data); 653 data &= ~(DS1343_OSF | DS1343_IRQF1 | DS1343_IRQF0); 654 regmap_write(priv->map, DS1343_STATUS_REG, data); 655 656 priv->rtc = devm_rtc_device_register(&spi->dev, "ds1343", 657 &ds1343_rtc_ops, THIS_MODULE); 658 if (IS_ERR(priv->rtc)) { 659 dev_err(&spi->dev, "unable to register rtc ds1343\n"); 660 return PTR_ERR(priv->rtc); 661 } 662 663 priv->irq = spi->irq; 664 665 if (priv->irq >= 0) { 666 res = devm_request_threaded_irq(&spi->dev, spi->irq, NULL, 667 ds1343_thread, IRQF_ONESHOT, 668 "ds1343", priv); 669 if (res) { 670 priv->irq = -1; 671 dev_err(&spi->dev, 672 "unable to request irq for rtc ds1343\n"); 673 } else { 674 device_init_wakeup(&spi->dev, true); 675 dev_pm_set_wake_irq(&spi->dev, spi->irq); 676 } 677 } 678 679 res = ds1343_sysfs_register(&spi->dev); 680 if (res) 681 dev_err(&spi->dev, 682 "unable to create sysfs entries for rtc ds1343\n"); 683 684 return 0; 685 } 686 687 static int ds1343_remove(struct spi_device *spi) 688 { 689 struct ds1343_priv *priv = spi_get_drvdata(spi); 690 691 if (spi->irq) { 692 mutex_lock(&priv->mutex); 693 priv->irqen &= ~RTC_AF; 694 mutex_unlock(&priv->mutex); 695 696 dev_pm_clear_wake_irq(&spi->dev); 697 device_init_wakeup(&spi->dev, false); 698 devm_free_irq(&spi->dev, spi->irq, priv); 699 } 700 701 spi_set_drvdata(spi, NULL); 702 703 ds1343_sysfs_unregister(&spi->dev); 704 705 return 0; 706 } 707 708 #ifdef CONFIG_PM_SLEEP 709 710 static int ds1343_suspend(struct device *dev) 711 { 712 struct spi_device *spi = to_spi_device(dev); 713 714 if (spi->irq >= 0 && device_may_wakeup(dev)) 715 enable_irq_wake(spi->irq); 716 717 return 0; 718 } 719 720 static int ds1343_resume(struct device *dev) 721 { 722 struct spi_device *spi = to_spi_device(dev); 723 724 if (spi->irq >= 0 && device_may_wakeup(dev)) 725 disable_irq_wake(spi->irq); 726 727 return 0; 728 } 729 730 #endif 731 732 static SIMPLE_DEV_PM_OPS(ds1343_pm, ds1343_suspend, ds1343_resume); 733 734 static struct spi_driver ds1343_driver = { 735 .driver = { 736 .name = "ds1343", 737 .pm = &ds1343_pm, 738 }, 739 .probe = ds1343_probe, 740 .remove = ds1343_remove, 741 .id_table = ds1343_id, 742 }; 743 744 module_spi_driver(ds1343_driver); 745 746 MODULE_DESCRIPTION("DS1343 RTC SPI Driver"); 747 MODULE_AUTHOR("Raghavendra Chandra Ganiga <ravi23ganiga@gmail.com>," 748 "Ankur Srivastava <sankurece@gmail.com>"); 749 MODULE_LICENSE("GPL v2"); 750 MODULE_VERSION(DS1343_DRV_VERSION); 751