rtc: add support for Abracon AB-RTCMC-32.768kHz-B5ZE-S3 I2C RTC chip

This patch adds support for Abracon AB-RTCMC-32.768kHz-B5ZE-S3
RTC/Calendar module w/ I2C interface.

This support includes RTC time reading and setting, Alarm (1 minute
accuracy) reading and setting, and battery low detection.  The device also
supports frequency adjustment and two timers but those features are
currently not implemented in this driver.  Due to alarm accuracy
limitation (and current lack of timer support in the driver), UIE mode is
not supported.

Signed-off-by: Arnaud Ebalard <arno@natisbad.org>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Alessandro Zummo <a.zummo@towertech.it>
Cc: Peter Huewe <peter.huewe@infineon.com>
Cc: Linus Walleij <linus.walleij@linaro.org>
Cc: Thierry Reding <treding@nvidia.com>
Cc: Mark Brown <broonie@kernel.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Rob Herring <robherring2@gmail.com>
Cc: Pawel Moll <pawel.moll@arm.com>
Cc: Stephen Warren <swarren@wwwdotorg.org>
Cc: Ian Campbell <ijc+devicetree@hellion.org.uk>
Cc: Grant Likely <grant.likely@linaro.org>
Cc: Rob Landley <rob@landley.net>
Cc: Jason Cooper <jason@lakedaemon.net>
Cc: Guenter Roeck <linux@roeck-us.net>
Cc: Jason Gunthorpe <jgunthorpe@obsidianresearch.com>
Cc: Kumar Gala <galak@codeaurora.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

4 files changed, 815 insertions, 0 deletions

diff --git a/Documentation/devicetree/bindings/i2c/trivial-devices.txt b/Documentation/devicetree/bindings/i2c/trivial-devices.txt
index 9f41d05be3be..f9463b492f44 100644
--- a/Documentation/devicetree/bindings/i2c/trivial-devices.txt
+++ b/Documentation/devicetree/bindings/i2c/trivial-devices.txt
@@ -9,6 +9,7 @@ document for it just like any other devices.
 
 Compatible              Vendor / Chip
 ==========              =============
+abracon,abb5zes3                AB-RTCMC-32.768kHz-B5ZE-S3: Real Time Clock/Calendar Module with I2C Interface
 ad,ad7414               SMBus/I2C Digital Temperature Sensor in 6-Pin SOT with SMBus Alert and Over Temperature Pin
 ad,adm9240              ADM9240:  Complete System Hardware Monitor for uProcessor-Based Systems
 adi,adt7461             +/-1C TDM Extended Temp Range I.C
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index f15cddfeb897..1b19f327f35f 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -153,6 +153,17 @@ config RTC_DRV_88PM80X
           This driver can also be built as a module. If so, the module
           will be called rtc-88pm80x.
 
+config RTC_DRV_ABB5ZES3
+       depends on I2C
+       select REGMAP_I2C
+       tristate "Abracon AB-RTCMC-32.768kHz-B5ZE-S3"
+       help
+          If you say yes here you get support for the Abracon
+          AB-RTCMC-32.768kHz-B5ZE-S3 I2C RTC chip.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-ab-b5ze-s3.
+
 config RTC_DRV_AS3722
         tristate "ams AS3722 RTC driver"
         depends on MFD_AS3722
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index c8ef3e1e6ccd..855c4e364058 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -24,6 +24,7 @@ obj-$(CONFIG_RTC_DRV_88PM860X)  += rtc-88pm860x.o
 obj-$(CONFIG_RTC_DRV_88PM80X)   += rtc-88pm80x.o
 obj-$(CONFIG_RTC_DRV_AB3100)    += rtc-ab3100.o
 obj-$(CONFIG_RTC_DRV_AB8500)    += rtc-ab8500.o
+obj-$(CONFIG_RTC_DRV_ABB5ZES3)  += rtc-ab-b5ze-s3.o
 obj-$(CONFIG_RTC_DRV_AS3722)    += rtc-as3722.o
 obj-$(CONFIG_RTC_DRV_AT32AP700X)+= rtc-at32ap700x.o
 obj-$(CONFIG_RTC_DRV_AT91RM9200)+= rtc-at91rm9200.o
diff --git a/drivers/rtc/rtc-ab-b5ze-s3.c b/drivers/rtc/rtc-ab-b5ze-s3.c
new file mode 100644
index 000000000000..bbbf06f55e17
--- /dev/null
+++ b/drivers/rtc/rtc-ab-b5ze-s3.c
@@ -0,0 +1,802 @@
+/*
+ * rtc-ab-b5ze-s3 - Driver for Abracon AB-RTCMC-32.768Khz-B5ZE-S3
+ *                  I2C RTC / Alarm chip
+ *
+ * Copyright (C) 2014, Arnaud EBALARD <arno@natisbad.org>
+ *
+ * Detailed datasheet of the chip is available here:
+ *
+ *  http://www.abracon.com/realtimeclock/AB-RTCMC-32.768kHz-B5ZE-S3-Application-Manual.pdf
+ *
+ * This work is based on ISL12057 driver (drivers/rtc/rtc-isl12057.c).
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/rtc.h>
+#include <linux/i2c.h>
+#include <linux/bcd.h>
+#include <linux/of.h>
+#include <linux/regmap.h>
+#include <linux/interrupt.h>
+
+#define DRV_NAME "rtc-ab-b5ze-s3"
+
+/* Control section */
+#define ABB5ZES3_REG_CTRL1         0x00    /* Control 1 register */
+#define ABB5ZES3_REG_CTRL1_CIE     BIT(0)  /* Pulse interrupt enable */
+#define ABB5ZES3_REG_CTRL1_AIE     BIT(1)  /* Alarm interrupt enable */
+#define ABB5ZES3_REG_CTRL1_SIE     BIT(2)  /* Second interrupt enable */
+#define ABB5ZES3_REG_CTRL1_PM      BIT(3)  /* 24h/12h mode */
+#define ABB5ZES3_REG_CTRL1_SR      BIT(4)  /* Software reset */
+#define ABB5ZES3_REG_CTRL1_STOP    BIT(5)  /* RTC circuit enable */
+#define ABB5ZES3_REG_CTRL1_CAP     BIT(7)
+
+#define ABB5ZES3_REG_CTRL2         0x01    /* Control 2 register */
+#define ABB5ZES3_REG_CTRL2_CTBIE   BIT(0)  /* Countdown timer B int. enable */
+#define ABB5ZES3_REG_CTRL2_CTAIE   BIT(1)  /* Countdown timer A int. enable */
+#define ABB5ZES3_REG_CTRL2_WTAIE   BIT(2)  /* Watchdog timer A int. enable */
+#define ABB5ZES3_REG_CTRL2_AF      BIT(3)  /* Alarm interrupt status */
+#define ABB5ZES3_REG_CTRL2_SF      BIT(4)  /* Second interrupt status */
+#define ABB5ZES3_REG_CTRL2_CTBF    BIT(5)  /* Countdown timer B int. status */
+#define ABB5ZES3_REG_CTRL2_CTAF    BIT(6)  /* Countdown timer A int. status */
+#define ABB5ZES3_REG_CTRL2_WTAF    BIT(7)  /* Watchdog timer A int. status */
+
+#define ABB5ZES3_REG_CTRL3         0x02    /* Control 3 register */
+#define ABB5ZES3_REG_CTRL3_PM2     BIT(7)  /* Power Management bit 2 */
+#define ABB5ZES3_REG_CTRL3_PM1     BIT(6)  /* Power Management bit 1 */
+#define ABB5ZES3_REG_CTRL3_PM0     BIT(5)  /* Power Management bit 0 */
+#define ABB5ZES3_REG_CTRL3_BSF     BIT(3)  /* Battery switchover int. status */
+#define ABB5ZES3_REG_CTRL3_BLF     BIT(2)  /* Battery low int. status */
+#define ABB5ZES3_REG_CTRL3_BSIE    BIT(1)  /* Battery switchover int. enable */
+#define ABB5ZES3_REG_CTRL3_BLIE    BIT(0)  /* Battery low int. enable */
+
+#define ABB5ZES3_CTRL_SEC_LEN      3
+
+/* RTC section */
+#define ABB5ZES3_REG_RTC_SC        0x03    /* RTC Seconds register */
+#define ABB5ZES3_REG_RTC_SC_OSC    BIT(7)  /* Clock integrity status */
+#define ABB5ZES3_REG_RTC_MN        0x04    /* RTC Minutes register */
+#define ABB5ZES3_REG_RTC_HR        0x05    /* RTC Hours register */
+#define ABB5ZES3_REG_RTC_HR_PM     BIT(5)  /* RTC Hours PM bit */
+#define ABB5ZES3_REG_RTC_DT        0x06    /* RTC Date register */
+#define ABB5ZES3_REG_RTC_DW        0x07    /* RTC Day of the week register */
+#define ABB5ZES3_REG_RTC_MO        0x08    /* RTC Month register */
+#define ABB5ZES3_REG_RTC_YR        0x09    /* RTC Year register */
+
+#define ABB5ZES3_RTC_SEC_LEN       7
+
+/* Alarm section (enable bits are all active low) */
+#define ABB5ZES3_REG_ALRM_MN       0x0A    /* Alarm - minute register */
+#define ABB5ZES3_REG_ALRM_MN_AE    BIT(7)  /* Minute enable */
+#define ABB5ZES3_REG_ALRM_HR       0x0B    /* Alarm - hours register */
+#define ABB5ZES3_REG_ALRM_HR_AE    BIT(7)  /* Hour enable */
+#define ABB5ZES3_REG_ALRM_DT       0x0C    /* Alarm - date register */
+#define ABB5ZES3_REG_ALRM_DT_AE    BIT(7)  /* Date (day of the month) enable */
+#define ABB5ZES3_REG_ALRM_DW       0x0D    /* Alarm - day of the week reg. */
+#define ABB5ZES3_REG_ALRM_DW_AE    BIT(7)  /* Day of the week enable */
+
+#define ABB5ZES3_ALRM_SEC_LEN      4
+
+/* Frequency offset section */
+#define ABB5ZES3_REG_FREQ_OF       0x0E    /* Frequency offset register */
+#define ABB5ZES3_REG_FREQ_OF_MODE  0x0E    /* Offset mode: 2 hours / minute */
+
+/* CLOCKOUT section */
+#define ABB5ZES3_REG_TIM_CLK       0x0F    /* Timer & Clockout register */
+#define ABB5ZES3_REG_TIM_CLK_TAM   BIT(7)  /* Permanent/pulsed timer A/int. 2 */
+#define ABB5ZES3_REG_TIM_CLK_TBM   BIT(6)  /* Permanent/pulsed timer B */
+#define ABB5ZES3_REG_TIM_CLK_COF2  BIT(5)  /* Clkout Freq bit 2 */
+#define ABB5ZES3_REG_TIM_CLK_COF1  BIT(4)  /* Clkout Freq bit 1 */
+#define ABB5ZES3_REG_TIM_CLK_COF0  BIT(3)  /* Clkout Freq bit 0 */
+#define ABB5ZES3_REG_TIM_CLK_TAC1  BIT(2)  /* Timer A: - 01 : countdown */
+#define ABB5ZES3_REG_TIM_CLK_TAC0  BIT(1)  /*          - 10 : timer     */
+#define ABB5ZES3_REG_TIM_CLK_TBC   BIT(0)  /* Timer B enable */
+
+/* Timer A Section */
+#define ABB5ZES3_REG_TIMA_CLK      0x10    /* Timer A clock register */
+#define ABB5ZES3_REG_TIMA_CLK_TAQ2 BIT(2)  /* Freq bit 2 */
+#define ABB5ZES3_REG_TIMA_CLK_TAQ1 BIT(1)  /* Freq bit 1 */
+#define ABB5ZES3_REG_TIMA_CLK_TAQ0 BIT(0)  /* Freq bit 0 */
+#define ABB5ZES3_REG_TIMA          0x11    /* Timer A register */
+
+#define ABB5ZES3_TIMA_SEC_LEN      2
+
+/* Timer B Section */
+#define ABB5ZES3_REG_TIMB_CLK      0x12    /* Timer B clock register */
+#define ABB5ZES3_REG_TIMB_CLK_TBW2 BIT(6)
+#define ABB5ZES3_REG_TIMB_CLK_TBW1 BIT(5)
+#define ABB5ZES3_REG_TIMB_CLK_TBW0 BIT(4)
+#define ABB5ZES3_REG_TIMB_CLK_TAQ2 BIT(2)
+#define ABB5ZES3_REG_TIMB_CLK_TAQ1 BIT(1)
+#define ABB5ZES3_REG_TIMB_CLK_TAQ0 BIT(0)
+#define ABB5ZES3_REG_TIMB          0x13    /* Timer B register */
+#define ABB5ZES3_TIMB_SEC_LEN      2
+
+#define ABB5ZES3_MEM_MAP_LEN       0x14
+
+struct abb5zes3_rtc_data {
+        struct rtc_device *rtc;
+        struct regmap *regmap;
+        struct mutex lock;
+
+        int irq;
+
+        bool battery_low;
+};
+
+/*
+ * Try and match register bits w/ fixed null values to see whether we
+ * are dealing with an ABB5ZES3. Note: this function is called early
+ * during init and hence does need mutex protection.
+ */
+static int abb5zes3_i2c_validate_chip(struct regmap *regmap)
+{
+        u8 regs[ABB5ZES3_MEM_MAP_LEN];
+        static const u8 mask[ABB5ZES3_MEM_MAP_LEN] = { 0x00, 0x00, 0x10, 0x00,
+                                                       0x80, 0xc0, 0xc0, 0xf8,
+                                                       0xe0, 0x00, 0x00, 0x40,
+                                                       0x40, 0x78, 0x00, 0x00,
+                                                       0xf8, 0x00, 0x88, 0x00 };
+        int ret, i;
+
+        ret = regmap_bulk_read(regmap, 0, regs, ABB5ZES3_MEM_MAP_LEN);
+        if (ret)
+                return ret;
+
+        for (i = 0; i < ABB5ZES3_MEM_MAP_LEN; ++i) {
+                if (regs[i] & mask[i]) /* check if bits are cleared */
+                        return -ENODEV;
+        }
+
+        return 0;
+}
+
+/* Clear alarm status bit. */
+static int _abb5zes3_rtc_clear_alarm(struct device *dev)
+{
+        struct abb5zes3_rtc_data *data = dev_get_drvdata(dev);
+        int ret;
+
+        ret = regmap_update_bits(data->regmap, ABB5ZES3_REG_CTRL2,
+                                 ABB5ZES3_REG_CTRL2_AF, 0);
+        if (ret)
+                dev_err(dev, "%s: clearing alarm failed (%d)\n", __func__, ret);
+
+        return ret;
+}
+
+/* Enable or disable alarm (i.e. alarm interrupt generation) */
+static int _abb5zes3_rtc_update_alarm(struct device *dev, bool enable)
+{
+        struct abb5zes3_rtc_data *data = dev_get_drvdata(dev);
+        int ret;
+
+        ret = regmap_update_bits(data->regmap, ABB5ZES3_REG_CTRL1,
+                                 ABB5ZES3_REG_CTRL1_AIE,
+                                 enable ? ABB5ZES3_REG_CTRL1_AIE : 0);
+        if (ret)
+                dev_err(dev, "%s: writing alarm INT failed (%d)\n",
+                        __func__, ret);
+
+        return ret;
+}
+
+/*
+ * Note: we only read, so regmap inner lock protection is sufficient, i.e.
+ * we do not need driver's main lock protection.
+ */
+static int _abb5zes3_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct abb5zes3_rtc_data *data = dev_get_drvdata(dev);
+        u8 regs[ABB5ZES3_REG_RTC_SC + ABB5ZES3_RTC_SEC_LEN];
+        int ret;
+
+        /*
+         * As we need to read CTRL1 register anyway to access 24/12h
+         * mode bit, we do a single bulk read of both control and RTC
+         * sections (they are consecutive). This also ease indexing
+         * of register values after bulk read.
+         */
+        ret = regmap_bulk_read(data->regmap, ABB5ZES3_REG_CTRL1, regs,
+                               sizeof(regs));
+        if (ret) {
+                dev_err(dev, "%s: reading RTC time failed (%d)\n",
+                        __func__, ret);
+                goto err;
+        }
+
+        /* If clock integrity is not guaranteed, do not return a time value */
+        if (regs[ABB5ZES3_REG_RTC_SC] & ABB5ZES3_REG_RTC_SC_OSC) {
+                ret = -ENODATA;
+                goto err;
+        }
+
+        tm->tm_sec = bcd2bin(regs[ABB5ZES3_REG_RTC_SC] & 0x7F);
+        tm->tm_min = bcd2bin(regs[ABB5ZES3_REG_RTC_MN]);
+
+        if (regs[ABB5ZES3_REG_CTRL1] & ABB5ZES3_REG_CTRL1_PM) { /* 12hr mode */
+                tm->tm_hour = bcd2bin(regs[ABB5ZES3_REG_RTC_HR] & 0x1f);
+                if (regs[ABB5ZES3_REG_RTC_HR] & ABB5ZES3_REG_RTC_HR_PM) /* PM */
+                        tm->tm_hour += 12;
+        } else {                                                /* 24hr mode */
+                tm->tm_hour = bcd2bin(regs[ABB5ZES3_REG_RTC_HR]);
+        }
+
+        tm->tm_mday = bcd2bin(regs[ABB5ZES3_REG_RTC_DT]);
+        tm->tm_wday = bcd2bin(regs[ABB5ZES3_REG_RTC_DW]);
+        tm->tm_mon  = bcd2bin(regs[ABB5ZES3_REG_RTC_MO]) - 1; /* starts at 1 */
+        tm->tm_year = bcd2bin(regs[ABB5ZES3_REG_RTC_YR]) + 100;
+
+        ret = rtc_valid_tm(tm);
+
+err:
+        return ret;
+}
+
+static int abb5zes3_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct abb5zes3_rtc_data *data = dev_get_drvdata(dev);
+        u8 regs[ABB5ZES3_REG_RTC_SC + ABB5ZES3_RTC_SEC_LEN];
+        int ret;
+
+        /*
+         * Year register is 8-bit wide and bcd-coded, i.e records values
+         * between 0 and 99. tm_year is an offset from 1900 and we are
+         * interested in the 2000-2099 range, so any value less than 100
+         * is invalid.
+         */
+        if (tm->tm_year < 100)
+                return -EINVAL;
+
+        regs[ABB5ZES3_REG_RTC_SC] = bin2bcd(tm->tm_sec); /* MSB=0 clears OSC */
+        regs[ABB5ZES3_REG_RTC_MN] = bin2bcd(tm->tm_min);
+        regs[ABB5ZES3_REG_RTC_HR] = bin2bcd(tm->tm_hour); /* 24-hour format */
+        regs[ABB5ZES3_REG_RTC_DT] = bin2bcd(tm->tm_mday);
+        regs[ABB5ZES3_REG_RTC_DW] = bin2bcd(tm->tm_wday);
+        regs[ABB5ZES3_REG_RTC_MO] = bin2bcd(tm->tm_mon + 1);
+        regs[ABB5ZES3_REG_RTC_YR] = bin2bcd(tm->tm_year - 100);
+
+        mutex_lock(&data->lock);
+        ret = regmap_bulk_write(data->regmap, ABB5ZES3_REG_RTC_SC,
+                                regs + ABB5ZES3_REG_RTC_SC,
+                                ABB5ZES3_RTC_SEC_LEN);
+        mutex_unlock(&data->lock);
+
+
+        return ret;
+}
+
+static int abb5zes3_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct abb5zes3_rtc_data *data = dev_get_drvdata(dev);
+        struct rtc_time rtc_tm, *alarm_tm = &alarm->time;
+        unsigned long rtc_secs, alarm_secs;
+        u8 regs[ABB5ZES3_ALRM_SEC_LEN];
+        unsigned int reg;
+        int ret;
+
+        mutex_lock(&data->lock);
+        ret = regmap_bulk_read(data->regmap, ABB5ZES3_REG_ALRM_MN, regs,
+                               ABB5ZES3_ALRM_SEC_LEN);
+        if (ret) {
+                dev_err(dev, "%s: reading alarm section failed (%d)\n",
+                        __func__, ret);
+                goto err;
+        }
+
+        alarm_tm->tm_sec  = 0;
+        alarm_tm->tm_min  = bcd2bin(regs[0] & 0x7f);
+        alarm_tm->tm_hour = bcd2bin(regs[1] & 0x3f);
+        alarm_tm->tm_mday = bcd2bin(regs[2] & 0x3f);
+        alarm_tm->tm_wday = -1;
+
+        /*
+         * The alarm section does not store year/month. We use the ones in rtc
+         * section as a basis and increment month and then year if needed to get
+         * alarm after current time.
+         */
+        ret = _abb5zes3_rtc_read_time(dev, &rtc_tm);
+        if (ret)
+                goto err;
+
+        alarm_tm->tm_year = rtc_tm.tm_year;
+        alarm_tm->tm_mon = rtc_tm.tm_mon;
+
+        ret = rtc_tm_to_time(&rtc_tm, &rtc_secs);
+        if (ret)
+                goto err;
+
+        ret = rtc_tm_to_time(alarm_tm, &alarm_secs);
+        if (ret)
+                goto err;
+
+        if (alarm_secs < rtc_secs) {
+                if (alarm_tm->tm_mon == 11) {
+                        alarm_tm->tm_mon = 0;
+                        alarm_tm->tm_year += 1;
+                } else {
+                        alarm_tm->tm_mon += 1;
+                }
+        }
+
+        ret = regmap_read(data->regmap, ABB5ZES3_REG_CTRL1, &reg);
+        if (ret) {
+                dev_err(dev, "%s: reading ctrl reg failed (%d)\n",
+                        __func__, ret);
+                goto err;
+        }
+
+        alarm->enabled = !!(reg & ABB5ZES3_REG_CTRL1_AIE);
+
+err:
+        mutex_unlock(&data->lock);
+
+        return ret;
+}
+
+/* ALARM is only accurate to the minute (not the second) */
+static int abb5zes3_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct abb5zes3_rtc_data *data = dev_get_drvdata(dev);
+        struct rtc_time *alarm_tm = &alarm->time;
+        unsigned long rtc_secs, alarm_secs;
+        u8 regs[ABB5ZES3_ALRM_SEC_LEN];
+        struct rtc_time rtc_tm;
+        int ret, enable = 1;
+
+        mutex_lock(&data->lock);
+        ret = _abb5zes3_rtc_read_time(dev, &rtc_tm);
+        if (ret)
+                goto err;
+
+        ret = rtc_tm_to_time(&rtc_tm, &rtc_secs);
+        if (ret)
+                goto err;
+
+        ret = rtc_tm_to_time(alarm_tm, &alarm_secs);
+        if (ret)
+                goto err;
+
+        /* If alarm time is before current time, disable the alarm */
+        if (!alarm->enabled || alarm_secs <= rtc_secs) {
+                enable = 0;
+        } else {
+                /*
+                 * Chip only support alarms up to one month in the future. Let's
+                 * return an error if we get something after that limit.
+                 * Comparison is done by incrementing rtc_tm month field by one
+                 * and checking alarm value is still below.
+                 */
+                if (rtc_tm.tm_mon == 11) { /* handle year wrapping */
+                        rtc_tm.tm_mon = 0;
+                        rtc_tm.tm_year += 1;
+                } else {
+                        rtc_tm.tm_mon += 1;
+                }
+
+                ret = rtc_tm_to_time(&rtc_tm, &rtc_secs);
+                if (ret)
+                        goto err;
+
+                if (alarm_secs > rtc_secs) {
+                        dev_err(dev, "%s: alarm maximum is one month in the "
+                                "future (%d)\n", __func__, ret);
+                        ret = -EINVAL;
+                        goto err;
+                }
+        }
+
+        /* Disable the alarm before modifying it */
+        ret = _abb5zes3_rtc_update_alarm(dev, 0);
+        if (ret < 0) {
+                dev_err(dev, "%s: unable to disable the alarm (%d)\n",
+                        __func__, ret);
+                goto err;
+        }
+
+        /* Program alarm registers */
+        regs[0] = bin2bcd(alarm_tm->tm_min) & 0x7f;  /* minute */
+        regs[1] = bin2bcd(alarm_tm->tm_hour) & 0x3f; /* hour */
+        regs[2] = bin2bcd(alarm_tm->tm_mday) & 0x3f; /* day of the month */
+        regs[3] = ABB5ZES3_REG_ALRM_DW_AE; /* do not match day of the week */
+
+        ret = regmap_bulk_write(data->regmap, ABB5ZES3_REG_ALRM_MN, regs,
+                                ABB5ZES3_ALRM_SEC_LEN);
+        if (ret < 0) {
+                dev_err(dev, "%s: writing ALARM section failed (%d)\n",
+                        __func__, ret);
+                goto err;
+        }
+
+        /* Enable or disable alarm */
+        ret = _abb5zes3_rtc_update_alarm(dev, enable);
+
+err:
+        mutex_unlock(&data->lock);
+
+        return ret;
+}
+
+
+/* Enable or disable battery low irq generation */
+static inline int _abb5zes3_rtc_battery_low_irq_enable(struct regmap *regmap,
+                                                       bool enable)
+{
+        return regmap_update_bits(regmap, ABB5ZES3_REG_CTRL3,
+                                  ABB5ZES3_REG_CTRL3_BLIE,
+                                  enable ? ABB5ZES3_REG_CTRL3_BLIE : 0);
+}
+
+/*
+ * Check current RTC status and enable/disable what needs to be. Return 0 if
+ * everything went ok and a negative value upon error. Note: this function
+ * is called early during init and hence does need mutex protection.
+ */
+static int abb5zes3_rtc_check_setup(struct device *dev)
+{
+        struct abb5zes3_rtc_data *data = dev_get_drvdata(dev);
+        struct regmap *regmap =  data->regmap;
+        unsigned int reg;
+        int ret;
+        u8 mask;
+
+        /*
+         * By default, the devices generates a 32.768KHz signal on IRQ#1 pin. It
+         * is disabled here to prevent polluting the interrupt line and
+         * uselessly triggering the IRQ handler we install for alarm and battery
+         * low events. Note: this is done before clearing int. status below
+         * in this function.
+         * We also disable all timers and set timer interrupt to permanent (not
+         * pulsed).
+         */
+        mask = (ABB5ZES3_REG_TIM_CLK_TBC | ABB5ZES3_REG_TIM_CLK_TAC0 |
+                ABB5ZES3_REG_TIM_CLK_TAC1 | ABB5ZES3_REG_TIM_CLK_COF0 |
+                ABB5ZES3_REG_TIM_CLK_COF1 | ABB5ZES3_REG_TIM_CLK_COF2 |
+                ABB5ZES3_REG_TIM_CLK_TBM | ABB5ZES3_REG_TIM_CLK_TAM);
+        ret = regmap_update_bits(regmap, ABB5ZES3_REG_TIM_CLK, mask,
+                ABB5ZES3_REG_TIM_CLK_COF0 | ABB5ZES3_REG_TIM_CLK_COF1 |
+                ABB5ZES3_REG_TIM_CLK_COF2);
+        if (ret < 0) {
+                dev_err(dev, "%s: unable to initialize clkout register (%d)\n",
+                        __func__, ret);
+                return ret;
+        }
+
+        /*
+         * Each component of the alarm (MN, HR, DT, DW) can be enabled/disabled
+         * individually by clearing/setting MSB of each associated register. So,
+         * we set all alarm enable bits to disable current alarm setting.
+         */
+        mask = (ABB5ZES3_REG_ALRM_MN_AE | ABB5ZES3_REG_ALRM_HR_AE |
+                ABB5ZES3_REG_ALRM_DT_AE | ABB5ZES3_REG_ALRM_DW_AE);
+        ret = regmap_update_bits(regmap, ABB5ZES3_REG_CTRL2, mask, mask);
+        if (ret < 0) {
+                dev_err(dev, "%s: unable to disable alarm setting (%d)\n",
+                        __func__, ret);
+                return ret;
+        }
+
+        /* Set Control 1 register (RTC enabled, 24hr mode, all int. disabled) */
+        mask = (ABB5ZES3_REG_CTRL1_CIE | ABB5ZES3_REG_CTRL1_AIE |
+                ABB5ZES3_REG_CTRL1_SIE | ABB5ZES3_REG_CTRL1_PM |
+                ABB5ZES3_REG_CTRL1_CAP | ABB5ZES3_REG_CTRL1_STOP);
+        ret = regmap_update_bits(regmap, ABB5ZES3_REG_CTRL1, mask, 0);
+        if (ret < 0) {
+                dev_err(dev, "%s: unable to initialize CTRL1 register (%d)\n",
+                        __func__, ret);
+                return ret;
+        }
+
+        /*
+         * Set Control 2 register (timer int. disabled, alarm status cleared).
+         * WTAF is read-only and cleared automatically by reading the register.
+         */
+        mask = (ABB5ZES3_REG_CTRL2_CTBIE | ABB5ZES3_REG_CTRL2_CTAIE |
+                ABB5ZES3_REG_CTRL2_WTAIE | ABB5ZES3_REG_CTRL2_AF |
+                ABB5ZES3_REG_CTRL2_SF | ABB5ZES3_REG_CTRL2_CTBF |
+                ABB5ZES3_REG_CTRL2_CTAF);
+        ret = regmap_update_bits(regmap, ABB5ZES3_REG_CTRL2, mask, 0);
+        if (ret < 0) {
+                dev_err(dev, "%s: unable to initialize CTRL2 register (%d)\n",
+                        __func__, ret);
+                return ret;
+        }
+
+        /*
+         * Enable battery low detection function and battery switchover function
+         * (standard mode). Disable associated interrupts. Clear battery
+         * switchover flag but not battery low flag. The latter is checked
+         * later below.
+         */
+        mask = (ABB5ZES3_REG_CTRL3_PM0 | ABB5ZES3_REG_CTRL3_PM1 |
+                ABB5ZES3_REG_CTRL3_PM2 | ABB5ZES3_REG_CTRL3_BLIE |
+                ABB5ZES3_REG_CTRL3_BSIE| ABB5ZES3_REG_CTRL3_BSF);
+        ret = regmap_update_bits(regmap, ABB5ZES3_REG_CTRL3, mask, 0);
+        if (ret < 0) {
+                dev_err(dev, "%s: unable to initialize CTRL3 register (%d)\n",
+                        __func__, ret);
+                return ret;
+        }
+
+        /* Check oscillator integrity flag */
+        ret = regmap_read(regmap, ABB5ZES3_REG_RTC_SC, &reg);
+        if (ret < 0) {
+                dev_err(dev, "%s: unable to read osc. integrity flag (%d)\n",
+                        __func__, ret);
+                return ret;
+        }
+
+        if (reg & ABB5ZES3_REG_RTC_SC_OSC) {
+                dev_err(dev, "clock integrity not guaranteed. Osc. has stopped "
+                        "or has been interrupted.\n");
+                dev_err(dev, "change battery (if not already done) and  "
+                        "then set time to reset osc. failure flag.\n");
+        }
+
+        /*
+         * Check battery low flag at startup: this allows reporting battery
+         * is low at startup when IRQ line is not connected. Note: we record
+         * current status to avoid reenabling this interrupt later in probe
+         * function if battery is low.
+         */
+        ret = regmap_read(regmap, ABB5ZES3_REG_CTRL3, &reg);
+        if (ret < 0) {
+                dev_err(dev, "%s: unable to read battery low flag (%d)\n",
+                        __func__, ret);
+                return ret;
+        }
+
+        data->battery_low = reg & ABB5ZES3_REG_CTRL3_BLF;
+        if (data->battery_low) {
+                dev_err(dev, "RTC battery is low; please, consider "
+                        "changing it!\n");
+
+                ret = _abb5zes3_rtc_battery_low_irq_enable(regmap, false);
+                if (ret)
+                        dev_err(dev, "%s: disabling battery low interrupt "
+                                "generation failed (%d)\n", __func__, ret);
+        }
+
+        return ret;
+}
+
+static int abb5zes3_rtc_alarm_irq_enable(struct device *dev,
+                                         unsigned int enable)
+{
+        struct abb5zes3_rtc_data *rtc_data = dev_get_drvdata(dev);
+        int ret = 0;
+
+        if (rtc_data->irq) {
+                mutex_lock(&rtc_data->lock);
+                ret = _abb5zes3_rtc_update_alarm(dev, enable);
+                mutex_unlock(&rtc_data->lock);
+        }
+
+        return ret;
+}
+
+static irqreturn_t _abb5zes3_rtc_interrupt(int irq, void *data)
+{
+        struct i2c_client *client = data;
+        struct device *dev = &client->dev;
+        struct abb5zes3_rtc_data *rtc_data = dev_get_drvdata(dev);
+        struct rtc_device *rtc = rtc_data->rtc;
+        u8 regs[ABB5ZES3_CTRL_SEC_LEN];
+        int ret, handled = IRQ_NONE;
+
+        ret = regmap_bulk_read(rtc_data->regmap, 0, regs,
+                               ABB5ZES3_CTRL_SEC_LEN);
+        if (ret) {
+                dev_err(dev, "%s: unable to read control section (%d)!\n",
+                        __func__, ret);
+                return handled;
+        }
+
+        /*
+         * Check battery low detection flag and disable battery low interrupt
+         * generation if flag is set (interrupt can only be cleared when
+         * battery is replaced).
+         */
+        if (regs[ABB5ZES3_REG_CTRL3] & ABB5ZES3_REG_CTRL3_BLF) {
+                dev_err(dev, "RTC battery is low; please change it!\n");
+
+                _abb5zes3_rtc_battery_low_irq_enable(rtc_data->regmap, false);
+
+                handled = IRQ_HANDLED;
+        }
+
+        /* Check alarm flag */
+        if (regs[ABB5ZES3_REG_CTRL2] & ABB5ZES3_REG_CTRL2_AF) {
+                dev_dbg(dev, "RTC alarm!\n");
+
+                rtc_update_irq(rtc, 1, RTC_IRQF | RTC_AF);
+
+                /* Acknowledge and disable the alarm */
+                _abb5zes3_rtc_clear_alarm(dev);
+                _abb5zes3_rtc_update_alarm(dev, 0);
+
+                handled = IRQ_HANDLED;
+        }
+
+        return handled;
+}
+
+static const struct rtc_class_ops rtc_ops = {
+        .read_time = _abb5zes3_rtc_read_time,
+        .set_time = abb5zes3_rtc_set_time,
+        .read_alarm = abb5zes3_rtc_read_alarm,
+        .set_alarm = abb5zes3_rtc_set_alarm,
+        .alarm_irq_enable = abb5zes3_rtc_alarm_irq_enable,
+};
+
+static struct regmap_config abb5zes3_rtc_regmap_config = {
+        .reg_bits = 8,
+        .val_bits = 8,
+};
+
+static int abb5zes3_probe(struct i2c_client *client,
+                          const struct i2c_device_id *id)
+{
+        struct abb5zes3_rtc_data *data = NULL;
+        struct device *dev = &client->dev;
+        struct regmap *regmap;
+        int ret;
+
+        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C |
+                                     I2C_FUNC_SMBUS_BYTE_DATA |
+                                     I2C_FUNC_SMBUS_I2C_BLOCK)) {
+                ret = -ENODEV;
+                goto err;
+        }
+
+        regmap = devm_regmap_init_i2c(client, &abb5zes3_rtc_regmap_config);
+        if (IS_ERR(regmap)) {
+                ret = PTR_ERR(regmap);
+                dev_err(dev, "%s: regmap allocation failed: %d\n",
+                        __func__, ret);
+                goto err;
+        }
+
+        ret = abb5zes3_i2c_validate_chip(regmap);
+        if (ret)
+                goto err;
+
+        data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
+        if (!data) {
+                ret = -ENOMEM;
+                goto err;
+        }
+
+        mutex_init(&data->lock);
+        data->regmap = regmap;
+        dev_set_drvdata(dev, data);
+
+        ret = abb5zes3_rtc_check_setup(dev);
+        if (ret)
+                goto err;
+
+        if (client->irq > 0) {
+                ret = devm_request_threaded_irq(dev, client->irq, NULL,
+                                                _abb5zes3_rtc_interrupt,
+                                                IRQF_SHARED|IRQF_ONESHOT,
+                                                DRV_NAME, client);
+                if (!ret) {
+                        device_init_wakeup(dev, true);
+                        data->irq = client->irq;
+                        dev_dbg(dev, "%s: irq %d used by RTC\n", __func__,
+                                client->irq);
+                } else {
+                        dev_err(dev, "%s: irq %d unavailable (%d)\n",
+                                __func__, client->irq, ret);
+                        goto err;
+                }
+        }
+
+        data->rtc = devm_rtc_device_register(dev, DRV_NAME, &rtc_ops,
+                                             THIS_MODULE);
+        ret = PTR_ERR_OR_ZERO(data->rtc);
+        if (ret) {
+                dev_err(dev, "%s: unable to register RTC device (%d)\n",
+                        __func__, ret);
+                goto err;
+        }
+
+        /*
+         * AB-B5Z5E only supports a coarse granularity alarm (one minute
+         * resolution up to one month) so we cannot support UIE mode
+         * using the device's alarm. Note it should be feasible to support
+         * such a feature using one of the two timers the device provides.
+         */
+        data->rtc->uie_unsupported = 1;
+
+        /* Enable battery low detection interrupt if battery not already low */
+        if (!data->battery_low && data->irq) {
+                ret = _abb5zes3_rtc_battery_low_irq_enable(regmap, true);
+                if (ret) {
+                        dev_err(dev, "%s: enabling battery low interrupt "
+                                "generation failed (%d)\n", __func__, ret);
+                        goto err;
+                }
+        }
+
+err:
+        if (ret && data && data->irq)
+                device_init_wakeup(dev, false);
+        return ret;
+}
+
+static int abb5zes3_remove(struct i2c_client *client)
+{
+        struct abb5zes3_rtc_data *rtc_data = dev_get_drvdata(&client->dev);
+
+        if (rtc_data->irq > 0)
+                device_init_wakeup(&client->dev, false);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int abb5zes3_rtc_suspend(struct device *dev)
+{
+        struct abb5zes3_rtc_data *rtc_data = dev_get_drvdata(dev);
+
+        if (device_may_wakeup(dev))
+                return enable_irq_wake(rtc_data->irq);
+
+        return 0;
+}
+
+static int abb5zes3_rtc_resume(struct device *dev)
+{
+        struct abb5zes3_rtc_data *rtc_data = dev_get_drvdata(dev);
+
+        if (device_may_wakeup(dev))
+                return disable_irq_wake(rtc_data->irq);
+
+        return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(abb5zes3_rtc_pm_ops, abb5zes3_rtc_suspend,
+                         abb5zes3_rtc_resume);
+
+#ifdef CONFIG_OF
+static const struct of_device_id abb5zes3_dt_match[] = {
+        { .compatible = "abracon,abb5zes3" },
+        { },
+};
+#endif
+
+static const struct i2c_device_id abb5zes3_id[] = {
+        { "abb5zes3", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, abb5zes3_id);
+
+static struct i2c_driver abb5zes3_driver = {
+        .driver = {
+                .name = DRV_NAME,
+                .owner = THIS_MODULE,
+                .pm = &abb5zes3_rtc_pm_ops,
+                .of_match_table = of_match_ptr(abb5zes3_dt_match),
+        },
+        .probe    = abb5zes3_probe,
+        .remove   = abb5zes3_remove,
+        .id_table = abb5zes3_id,
+};
+module_i2c_driver(abb5zes3_driver);
+
+MODULE_AUTHOR("Arnaud EBALARD <arno@natisbad.org>");
+MODULE_DESCRIPTION("Abracon AB-RTCMC-32.768kHz-B5ZE-S3 RTC/Alarm driver");
+MODULE_LICENSE("GPL");