drivers/rtc/rtc-ds3232.c

   1 /*
   2  * RTC client/driver for the Maxim/Dallas DS3232/DS3234 Real-Time Clock
   3  *
   4  * Copyright (C) 2009-2011 Freescale Semiconductor.
   5  * Author: Jack Lan <jack.lan@freescale.com>
   6  * Copyright (C) 2008 MIMOMax Wireless Ltd.
   7  *
   8  * This program is free software; you can redistribute  it and/or modify it
   9  * under  the terms of  the GNU General  Public License as published by the
  10  * Free Software Foundation;  either version 2 of the  License, or (at your
  11  * option) any later version.
  12  */
  13
  14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  15
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/i2c.h>
  20 #include <linux/spi/spi.h>
  21 #include <linux/rtc.h>
  22 #include <linux/bcd.h>
  23 #include <linux/workqueue.h>
  24 #include <linux/slab.h>
  25 #include <linux/regmap.h>
  26
  27 #define DS3232_REG_SECONDS      0x00
  28 #define DS3232_REG_MINUTES      0x01
  29 #define DS3232_REG_HOURS        0x02
  30 #define DS3232_REG_AMPM         0x02
  31 #define DS3232_REG_DAY          0x03
  32 #define DS3232_REG_DATE         0x04
  33 #define DS3232_REG_MONTH        0x05
  34 #define DS3232_REG_CENTURY      0x05
  35 #define DS3232_REG_YEAR         0x06
  36 #define DS3232_REG_ALARM1         0x07  /* Alarm 1 BASE */
  37 #define DS3232_REG_ALARM2         0x0B  /* Alarm 2 BASE */
  38 #define DS3232_REG_CR           0x0E    /* Control register */
  39 #       define DS3232_REG_CR_nEOSC        0x80
  40 #       define DS3232_REG_CR_INTCN        0x04
  41 #       define DS3232_REG_CR_A2IE        0x02
  42 #       define DS3232_REG_CR_A1IE        0x01
  43
  44 #define DS3232_REG_SR   0x0F    /* control/status register */
  45 #       define DS3232_REG_SR_OSF   0x80
  46 #       define DS3232_REG_SR_BSY   0x04
  47 #       define DS3232_REG_SR_A2F   0x02
  48 #       define DS3232_REG_SR_A1F   0x01
  49
  50 struct ds3232 {
  51         struct device *dev;
  52         struct regmap *regmap;
  53         int irq;
  54         struct rtc_device *rtc;
  55         struct work_struct work;
  56
  57         /* The mutex protects alarm operations, and prevents a race
  58          * between the enable_irq() in the workqueue and the free_irq()
  59          * in the remove function.
  60          */
  61         struct mutex mutex;
  62         bool suspended;
  63         int exiting;
  64 };
  65
  66 static int ds3232_check_rtc_status(struct device *dev)
  67 {
  68         struct ds3232 *ds3232 = dev_get_drvdata(dev);
  69         int ret = 0;
  70         int control, stat;
  71
  72         ret = regmap_read(ds3232->regmap, DS3232_REG_SR, &stat);
  73         if (ret)
  74                 return ret;
  75
  76         if (stat & DS3232_REG_SR_OSF)
  77                 dev_warn(dev,
  78                                 "oscillator discontinuity flagged, "
  79                                 "time unreliable\n");
  80
  81         stat &= ~(DS3232_REG_SR_OSF | DS3232_REG_SR_A1F | DS3232_REG_SR_A2F);
  82
  83         ret = regmap_write(ds3232->regmap, DS3232_REG_SR, stat);
  84         if (ret)
  85                 return ret;
  86
  87         /* If the alarm is pending, clear it before requesting
  88          * the interrupt, so an interrupt event isn't reported
  89          * before everything is initialized.
  90          */
  91
  92         ret = regmap_read(ds3232->regmap, DS3232_REG_CR, &control);
  93         if (ret)
  94                 return ret;
  95
  96         control &= ~(DS3232_REG_CR_A1IE | DS3232_REG_CR_A2IE);
  97         control |= DS3232_REG_CR_INTCN;
  98
  99         return regmap_write(ds3232->regmap, DS3232_REG_CR, control);
 100 }
 101
 102 static int ds3232_read_time(struct device *dev, struct rtc_time *time)
 103 {
 104         struct ds3232 *ds3232 = dev_get_drvdata(dev);
 105         int ret;
 106         u8 buf[7];
 107         unsigned int year, month, day, hour, minute, second;
 108         unsigned int week, twelve_hr, am_pm;
 109         unsigned int century, add_century = 0;
 110
 111         ret = regmap_bulk_read(ds3232->regmap, DS3232_REG_SECONDS, buf, 7);
 112         if (ret)
 113                 return ret;
 114
 115         second = buf[0];
 116         minute = buf[1];
 117         hour = buf[2];
 118         week = buf[3];
 119         day = buf[4];
 120         month = buf[5];
 121         year = buf[6];
 122
 123         /* Extract additional information for AM/PM and century */
 124
 125         twelve_hr = hour & 0x40;
 126         am_pm = hour & 0x20;
 127         century = month & 0x80;
 128
 129         /* Write to rtc_time structure */
 130
 131         time->tm_sec = bcd2bin(second);
 132         time->tm_min = bcd2bin(minute);
 133         if (twelve_hr) {
 134                 /* Convert to 24 hr */
 135                 if (am_pm)
 136                         time->tm_hour = bcd2bin(hour & 0x1F) + 12;
 137                 else
 138                         time->tm_hour = bcd2bin(hour & 0x1F);
 139         } else {
 140                 time->tm_hour = bcd2bin(hour);
 141         }
 142
 143         /* Day of the week in linux range is 0~6 while 1~7 in RTC chip */
 144         time->tm_wday = bcd2bin(week) - 1;
 145         time->tm_mday = bcd2bin(day);
 146         /* linux tm_mon range:0~11, while month range is 1~12 in RTC chip */
 147         time->tm_mon = bcd2bin(month & 0x7F) - 1;
 148         if (century)
 149                 add_century = 100;
 150
 151         time->tm_year = bcd2bin(year) + add_century;
 152
 153         return rtc_valid_tm(time);
 154 }
 155
 156 static int ds3232_set_time(struct device *dev, struct rtc_time *time)
 157 {
 158         struct ds3232 *ds3232 = dev_get_drvdata(dev);
 159         u8 buf[7];
 160
 161         /* Extract time from rtc_time and load into ds3232*/
 162
 163         buf[0] = bin2bcd(time->tm_sec);
 164         buf[1] = bin2bcd(time->tm_min);
 165         buf[2] = bin2bcd(time->tm_hour);
 166         /* Day of the week in linux range is 0~6 while 1~7 in RTC chip */
 167         buf[3] = bin2bcd(time->tm_wday + 1);
 168         buf[4] = bin2bcd(time->tm_mday); /* Date */
 169         /* linux tm_mon range:0~11, while month range is 1~12 in RTC chip */
 170         buf[5] = bin2bcd(time->tm_mon + 1);
 171         if (time->tm_year >= 100) {
 172                 buf[5] |= 0x80;
 173                 buf[6] = bin2bcd(time->tm_year - 100);
 174         } else {
 175                 buf[6] = bin2bcd(time->tm_year);
 176         }
 177
 178         return regmap_bulk_write(ds3232->regmap, DS3232_REG_SECONDS, buf, 7);
 179 }
 180
 181 /*
 182  * DS3232 has two alarm, we only use alarm1
 183  * According to linux specification, only support one-shot alarm
 184  * no periodic alarm mode
 185  */
 186 static int ds3232_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 187 {
 188         struct ds3232 *ds3232 = dev_get_drvdata(dev);
 189         int control, stat;
 190         int ret;
 191         u8 buf[4];
 192
 193         mutex_lock(&ds3232->mutex);
 194
 195         ret = regmap_read(ds3232->regmap, DS3232_REG_SR, &stat);
 196         if (ret)
 197                 goto out;
 198         ret = regmap_read(ds3232->regmap, DS3232_REG_CR, &control);
 199         if (ret)
 200                 goto out;
 201         ret = regmap_bulk_read(ds3232->regmap, DS3232_REG_ALARM1, buf, 4);
 202         if (ret)
 203                 goto out;
 204
 205         alarm->time.tm_sec = bcd2bin(buf[0] & 0x7F);
 206         alarm->time.tm_min = bcd2bin(buf[1] & 0x7F);
 207         alarm->time.tm_hour = bcd2bin(buf[2] & 0x7F);
 208         alarm->time.tm_mday = bcd2bin(buf[3] & 0x7F);
 209
 210         alarm->time.tm_mon = -1;
 211         alarm->time.tm_year = -1;
 212         alarm->time.tm_wday = -1;
 213         alarm->time.tm_yday = -1;
 214         alarm->time.tm_isdst = -1;
 215
 216         alarm->enabled = !!(control & DS3232_REG_CR_A1IE);
 217         alarm->pending = !!(stat & DS3232_REG_SR_A1F);
 218
 219         ret = 0;
 220 out:
 221         mutex_unlock(&ds3232->mutex);
 222         return ret;
 223 }
 224
 225 /*
 226  * linux rtc-module does not support wday alarm
 227  * and only 24h time mode supported indeed
 228  */
 229 static int ds3232_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 230 {
 231         struct ds3232 *ds3232 = dev_get_drvdata(dev);
 232         int control, stat;
 233         int ret;
 234         u8 buf[4];
 235
 236         if (ds3232->irq <= 0)
 237                 return -EINVAL;
 238
 239         mutex_lock(&ds3232->mutex);
 240
 241         buf[0] = bin2bcd(alarm->time.tm_sec);
 242         buf[1] = bin2bcd(alarm->time.tm_min);
 243         buf[2] = bin2bcd(alarm->time.tm_hour);
 244         buf[3] = bin2bcd(alarm->time.tm_mday);
 245
 246         /* clear alarm interrupt enable bit */
 247         ret = regmap_read(ds3232->regmap, DS3232_REG_CR, &control);
 248         if (ret)
 249                 goto out;
 250         control &= ~(DS3232_REG_CR_A1IE | DS3232_REG_CR_A2IE);
 251         ret = regmap_write(ds3232->regmap, DS3232_REG_CR, control);
 252         if (ret)
 253                 goto out;
 254
 255         /* clear any pending alarm flag */
 256         ret = regmap_read(ds3232->regmap, DS3232_REG_SR, &stat);
 257         if (ret)
 258                 goto out;
 259         stat &= ~(DS3232_REG_SR_A1F | DS3232_REG_SR_A2F);
 260         ret = regmap_write(ds3232->regmap, DS3232_REG_SR, stat);
 261         if (ret)
 262                 goto out;
 263
 264         ret = regmap_bulk_write(ds3232->regmap, DS3232_REG_ALARM1, buf, 4);
 265         if (ret)
 266                 goto out;
 267
 268         if (alarm->enabled) {
 269                 control |= DS3232_REG_CR_A1IE;
 270                 ret = regmap_write(ds3232->regmap, DS3232_REG_CR, control);
 271         }
 272 out:
 273         mutex_unlock(&ds3232->mutex);
 274         return ret;
 275 }
 276
 277 static int ds3232_update_alarm(struct device *dev, unsigned int enabled)
 278 {
 279         struct ds3232 *ds3232 = dev_get_drvdata(dev);
 280         int control;
 281         int ret;
 282         u8 buf[4];
 283
 284         mutex_lock(&ds3232->mutex);
 285
 286         ret = regmap_bulk_read(ds3232->regmap, DS3232_REG_ALARM1, buf, 4);
 287         if (ret)
 288                 goto unlock;
 289
 290         buf[0] = bcd2bin(buf[0]) < 0 || (ds3232->rtc->irq_data & RTC_UF) ?
 291                                                                 0x80 : buf[0];
 292         buf[1] = bcd2bin(buf[1]) < 0 || (ds3232->rtc->irq_data & RTC_UF) ?
 293                                                                 0x80 : buf[1];
 294         buf[2] = bcd2bin(buf[2]) < 0 || (ds3232->rtc->irq_data & RTC_UF) ?
 295                                                                 0x80 : buf[2];
 296         buf[3] = bcd2bin(buf[3]) < 0 || (ds3232->rtc->irq_data & RTC_UF) ?
 297                                                                 0x80 : buf[3];
 298
 299         ret = regmap_bulk_write(ds3232->regmap, DS3232_REG_ALARM1, buf, 4);
 300         if (ret)
 301                 goto unlock;
 302
 303         ret = regmap_read(ds3232->regmap, DS3232_REG_CR, &control);
 304         if (ret)
 305                 goto unlock;
 306
 307         if (enabled || (ds3232->rtc->irq_data & RTC_UF))
 308                 /* enable alarm1 interrupt */
 309                 control |= DS3232_REG_CR_A1IE;
 310         else
 311                 /* disable alarm1 interrupt */
 312                 control &= ~(DS3232_REG_CR_A1IE);
 313         ret = regmap_write(ds3232->regmap, DS3232_REG_CR, control);
 314
 315 unlock:
 316         mutex_unlock(&ds3232->mutex);
 317
 318         return ret;
 319 }
 320
 321 static int ds3232_alarm_irq_enable(struct device *dev, unsigned int enabled)
 322 {
 323         struct ds3232 *ds3232 = dev_get_drvdata(dev);
 324
 325         if (ds3232->irq <= 0)
 326                 return -EINVAL;
 327
 328         return ds3232_update_alarm(dev, enabled);
 329 }
 330
 331 static irqreturn_t ds3232_irq(int irq, void *dev_id)
 332 {
 333         struct device *dev = dev_id;
 334         struct ds3232 *ds3232 = dev_get_drvdata(dev);
 335
 336         disable_irq_nosync(irq);
 337
 338         /*
 339          * If rtc as a wakeup source, can't schedule the work
 340          * at system resume flow, because at this time the i2c bus
 341          * has not been resumed.
 342          */
 343         if (!ds3232->suspended)
 344                 schedule_work(&ds3232->work);
 345
 346         return IRQ_HANDLED;
 347 }
 348
 349 static void ds3232_work(struct work_struct *work)
 350 {
 351         struct ds3232 *ds3232 = container_of(work, struct ds3232, work);
 352         int ret;
 353         int stat, control;
 354
 355         mutex_lock(&ds3232->mutex);
 356
 357         ret = regmap_read(ds3232->regmap, DS3232_REG_SR, &stat);
 358         if (ret)
 359                 goto unlock;
 360
 361         if (stat & DS3232_REG_SR_A1F) {
 362                 ret = regmap_read(ds3232->regmap, DS3232_REG_CR, &control);
 363                 if (ret) {
 364                         pr_warn("Read Control Register error - Disable IRQ%d\n",
 365                                 ds3232->irq);
 366                 } else {
 367                         /* disable alarm1 interrupt */
 368                         control &= ~(DS3232_REG_CR_A1IE);
 369                         ret = regmap_write(ds3232->regmap, DS3232_REG_CR,
 370                                            control);
 371                         if (ret) {
 372                                 dev_warn(ds3232->dev,
 373                                          "Write Control Register error %d\n",
 374                                          ret);
 375                                 goto unlock;
 376                         }
 377
 378                         /* clear the alarm pend flag */
 379                         stat &= ~DS3232_REG_SR_A1F;
 380                         ret = regmap_write(ds3232->regmap, DS3232_REG_SR, stat);
 381                         if (ret) {
 382                                 dev_warn(ds3232->dev,
 383                                          "Write Status Register error %d\n",
 384                                          ret);
 385                                 goto unlock;
 386                         }
 387
 388                         rtc_update_irq(ds3232->rtc, 1, RTC_AF | RTC_IRQF);
 389
 390                         if (!ds3232->exiting)
 391                                 enable_irq(ds3232->irq);
 392                 }
 393         }
 394
 395 unlock:
 396         mutex_unlock(&ds3232->mutex);
 397 }
 398
 399 static const struct rtc_class_ops ds3232_rtc_ops = {
 400         .read_time = ds3232_read_time,
 401         .set_time = ds3232_set_time,
 402         .read_alarm = ds3232_read_alarm,
 403         .set_alarm = ds3232_set_alarm,
 404         .alarm_irq_enable = ds3232_alarm_irq_enable,
 405 };
 406
 407 static int ds3232_probe(struct device *dev, struct regmap *regmap, int irq,
 408                         const char *name)
 409 {
 410         struct ds3232 *ds3232;
 411         int ret;
 412
 413         ds3232 = devm_kzalloc(dev, sizeof(*ds3232), GFP_KERNEL);
 414         if (!ds3232)
 415                 return -ENOMEM;
 416
 417         ds3232->regmap = regmap;
 418         ds3232->irq = irq;
 419         ds3232->dev = dev;
 420         dev_set_drvdata(dev, ds3232);
 421
 422         INIT_WORK(&ds3232->work, ds3232_work);
 423         mutex_init(&ds3232->mutex);
 424
 425         ret = ds3232_check_rtc_status(dev);
 426         if (ret)
 427                 return ret;
 428
 429         if (ds3232->irq > 0) {
 430                 ret = devm_request_irq(dev, ds3232->irq, ds3232_irq,
 431                                        IRQF_SHARED, name, dev);
 432                 if (ret) {
 433                         ds3232->irq = 0;
 434                         dev_err(dev, "unable to request IRQ\n");
 435                 } else
 436                         device_init_wakeup(dev, 1);
 437         }
 438         ds3232->rtc = devm_rtc_device_register(dev, name, &ds3232_rtc_ops,
 439                                                 THIS_MODULE);
 440
 441         return PTR_ERR_OR_ZERO(ds3232->rtc);
 442 }
 443
 444 static int ds3232_remove(struct device *dev)
 445 {
 446         struct ds3232 *ds3232 = dev_get_drvdata(dev);
 447
 448         if (ds3232->irq > 0) {
 449                 mutex_lock(&ds3232->mutex);
 450                 ds3232->exiting = 1;
 451                 mutex_unlock(&ds3232->mutex);
 452
 453                 devm_free_irq(dev, ds3232->irq, dev);
 454                 cancel_work_sync(&ds3232->work);
 455         }
 456
 457         return 0;
 458 }
 459
 460 #ifdef CONFIG_PM_SLEEP
 461 static int ds3232_suspend(struct device *dev)
 462 {
 463         struct ds3232 *ds3232 = dev_get_drvdata(dev);
 464
 465         if (device_can_wakeup(dev)) {
 466                 ds3232->suspended = true;
 467                 if (irq_set_irq_wake(ds3232->irq, 1)) {
 468                         dev_warn_once(dev, "Cannot set wakeup source\n");
 469                         ds3232->suspended = false;
 470                 }
 471         }
 472
 473         return 0;
 474 }
 475
 476 static int ds3232_resume(struct device *dev)
 477 {
 478         struct ds3232 *ds3232 = dev_get_drvdata(dev);
 479
 480         if (ds3232->suspended) {
 481                 ds3232->suspended = false;
 482
 483                 /* Clear the hardware alarm pend flag */
 484                 schedule_work(&ds3232->work);
 485
 486                 irq_set_irq_wake(ds3232->irq, 0);
 487         }
 488
 489         return 0;
 490 }
 491 #endif
 492
 493 static const struct dev_pm_ops ds3232_pm_ops = {
 494         SET_SYSTEM_SLEEP_PM_OPS(ds3232_suspend, ds3232_resume)
 495 };
 496
 497 #if IS_ENABLED(CONFIG_I2C)
 498
 499 static int ds3232_i2c_probe(struct i2c_client *client,
 500                             const struct i2c_device_id *id)
 501 {
 502         struct regmap *regmap;
 503         static const struct regmap_config config = {
 504                 .reg_bits = 8,
 505                 .val_bits = 8,
 506         };
 507
 508         regmap = devm_regmap_init_i2c(client, &config);
 509         if (IS_ERR(regmap)) {
 510                 dev_err(&client->dev, "%s: regmap allocation failed: %ld\n",
 511                         __func__, PTR_ERR(regmap));
 512                 return PTR_ERR(regmap);
 513         }
 514
 515         return ds3232_probe(&client->dev, regmap, client->irq, client->name);
 516 }
 517
 518 static int ds3232_i2c_remove(struct i2c_client *client)
 519 {
 520         return ds3232_remove(&client->dev);
 521 }
 522
 523 static const struct i2c_device_id ds3232_id[] = {
 524         { "ds3232", 0 },
 525         { }
 526 };
 527 MODULE_DEVICE_TABLE(i2c, ds3232_id);
 528
 529 static struct i2c_driver ds3232_driver = {
 530         .driver = {
 531                 .name = "rtc-ds3232",
 532                 .pm     = &ds3232_pm_ops,
 533         },
 534         .probe = ds3232_i2c_probe,
 535         .remove = ds3232_i2c_remove,
 536         .id_table = ds3232_id,
 537 };
 538
 539 static int ds3232_register_driver(void)
 540 {
 541         return i2c_add_driver(&ds3232_driver);
 542 }
 543
 544 static void ds3232_unregister_driver(void)
 545 {
 546         i2c_del_driver(&ds3232_driver);
 547 }
 548
 549 #else
 550
 551 static int ds3232_register_driver(void)
 552 {
 553         return 0;
 554 }
 555
 556 static void ds3232_unregister_driver(void)
 557 {
 558 }
 559
 560 #endif
 561
 562 #if IS_ENABLED(CONFIG_SPI_MASTER)
 563
 564 static int ds3234_probe(struct spi_device *spi)
 565 {
 566         int res;
 567         unsigned int tmp;
 568         static const struct regmap_config config = {
 569                 .reg_bits = 8,
 570                 .val_bits = 8,
 571                 .write_flag_mask = 0x80,
 572         };
 573         struct regmap *regmap;
 574
 575         regmap = devm_regmap_init_spi(spi, &config);
 576         if (IS_ERR(regmap)) {
 577                 dev_err(&spi->dev, "%s: regmap allocation failed: %ld\n",
 578                         __func__, PTR_ERR(regmap));
 579                 return PTR_ERR(regmap);
 580         }
 581
 582         spi->mode = SPI_MODE_3;
 583         spi->bits_per_word = 8;
 584         spi_setup(spi);
 585
 586         res = regmap_read(regmap, DS3232_REG_SECONDS, &tmp);
 587         if (res)
 588                 return res;
 589
 590         /* Control settings
 591          *
 592          * CONTROL_REG
 593          * BIT 7        6       5       4       3       2       1       0
 594          *     EOSC     BBSQW   CONV    RS2     RS1     INTCN   A2IE    A1IE
 595          *
 596          *     0        0       0       1       1       1       0       0
 597          *
 598          * CONTROL_STAT_REG
 599          * BIT 7        6       5       4       3       2       1       0
 600          *     OSF      BB32kHz CRATE1  CRATE0  EN32kHz BSY     A2F     A1F
 601          *
 602          *     1        0       0       0       1       0       0       0
 603          */
 604         res = regmap_read(regmap, DS3232_REG_CR, &tmp);
 605         if (res)
 606                 return res;
 607         res = regmap_write(regmap, DS3232_REG_CR, tmp & 0x1c);
 608         if (res)
 609                 return res;
 610
 611         res = regmap_read(regmap, DS3232_REG_SR, &tmp);
 612         if (res)
 613                 return res;
 614         res = regmap_write(regmap, DS3232_REG_SR, tmp & 0x88);
 615         if (res)
 616                 return res;
 617
 618         /* Print our settings */
 619         res = regmap_read(regmap, DS3232_REG_CR, &tmp);
 620         if (res)
 621                 return res;
 622         dev_info(&spi->dev, "Control Reg: 0x%02x\n", tmp);
 623
 624         res = regmap_read(regmap, DS3232_REG_SR, &tmp);
 625         if (res)
 626                 return res;
 627         dev_info(&spi->dev, "Ctrl/Stat Reg: 0x%02x\n", tmp);
 628
 629         return ds3232_probe(&spi->dev, regmap, spi->irq, "ds3234");
 630 }
 631
 632 static int ds3234_remove(struct spi_device *spi)
 633 {
 634         return ds3232_remove(&spi->dev);
 635 }
 636
 637 static struct spi_driver ds3234_driver = {
 638         .driver = {
 639                 .name    = "ds3234",
 640         },
 641         .probe   = ds3234_probe,
 642         .remove = ds3234_remove,
 643 };
 644
 645 static int ds3234_register_driver(void)
 646 {
 647         return spi_register_driver(&ds3234_driver);
 648 }
 649
 650 static void ds3234_unregister_driver(void)
 651 {
 652         spi_unregister_driver(&ds3234_driver);
 653 }
 654
 655 #else
 656
 657 static int ds3234_register_driver(void)
 658 {
 659         return 0;
 660 }
 661
 662 static void ds3234_unregister_driver(void)
 663 {
 664 }
 665
 666 #endif
 667
 668 static int __init ds323x_init(void)
 669 {
 670         int ret;
 671
 672         ret = ds3232_register_driver();
 673         if (ret) {
 674                 pr_err("Failed to register ds3232 driver: %d\n", ret);
 675                 return ret;
 676         }
 677
 678         ret = ds3234_register_driver();
 679         if (ret) {
 680                 pr_err("Failed to register ds3234 driver: %d\n", ret);
 681                 ds3232_unregister_driver();
 682         }
 683
 684         return ret;
 685 }
 686 module_init(ds323x_init)
 687
 688 static void __exit ds323x_exit(void)
 689 {
 690         ds3234_unregister_driver();
 691         ds3232_unregister_driver();
 692 }
 693 module_exit(ds323x_exit)
 694
 695 MODULE_AUTHOR("Srikanth Srinivasan <srikanth.srinivasan@freescale.com>");
 696 MODULE_AUTHOR("Dennis Aberilla <denzzzhome@yahoo.com>");
 697 MODULE_DESCRIPTION("Maxim/Dallas DS3232/DS3234 RTC Driver");
 698 MODULE_LICENSE("GPL");
 699 MODULE_ALIAS("spi:ds3234");