rtc: s5m: support different register layout

Prepare for adding support for S2MPS14 RTC device to the rtc-s5m driver:

1. Add a map of registers used by the driver which differ between
   the chipsets (S5M876X and S2MPS14).

2. Move code of checking for alarm pending to separate function.

Signed-off-by: Krzysztof Kozlowski <k.kozlowski@samsung.com>
Cc: Kyungmin Park <kyungmin.park@samsung.com>
Cc: Lee Jones <lee.jones@linaro.org>
Cc: Alessandro Zummo <a.zummo@towertech.it>
Cc: Sangbeom Kim <sbkim73@samsung.com>
Cc: Samuel Ortiz <sameo@linux.intel.com>
Cc: Marek Szyprowski <m.szyprowski@samsung.com>
Cc: Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 109 insertions, 48 deletions

diff --git a/drivers/rtc/rtc-s5m.c b/drivers/rtc/rtc-s5m.c
index 3751ef90f93c..59860128a221 100644
--- a/drivers/rtc/rtc-s5m.c
+++ b/drivers/rtc/rtc-s5m.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013 Samsung Electronics Co., Ltd
+ * Copyright (c) 2013-2014 Samsung Electronics Co., Ltd
  *      http://www.samsung.com
  *
  *  Copyright (C) 2013 Google, Inc
@@ -38,6 +38,42 @@
  */
 #define UDR_READ_RETRY_CNT      5
 
+/* Registers used by the driver which are different between chipsets. */
+struct s5m_rtc_reg_config {
+        /* Number of registers used for setting time/alarm0/alarm1 */
+        unsigned int regs_count;
+        /* First register for time, seconds */
+        unsigned int time;
+        /* RTC control register */
+        unsigned int ctrl;
+        /* First register for alarm 0, seconds */
+        unsigned int alarm0;
+        /* First register for alarm 1, seconds */
+        unsigned int alarm1;
+        /* SMPL/WTSR register */
+        unsigned int smpl_wtsr;
+        /*
+         * Register for update flag (UDR). Typically setting UDR field to 1
+         * will enable update of time or alarm register. Then it will be
+         * auto-cleared after successful update.
+         */
+        unsigned int rtc_udr_update;
+        /* Mask for UDR field in 'rtc_udr_update' register */
+        unsigned int rtc_udr_mask;
+};
+
+/* Register map for S5M8763 and S5M8767 */
+static const struct s5m_rtc_reg_config s5m_rtc_regs = {
+        .regs_count             = 8,
+        .time                   = S5M_RTC_SEC,
+        .ctrl                   = S5M_ALARM1_CONF,
+        .alarm0                 = S5M_ALARM0_SEC,
+        .alarm1                 = S5M_ALARM1_SEC,
+        .smpl_wtsr              = S5M_WTSR_SMPL_CNTL,
+        .rtc_udr_update         = S5M_RTC_UDR_CON,
+        .rtc_udr_mask           = S5M_RTC_UDR_MASK,
+};
+
 struct s5m_rtc_info {
         struct device *dev;
         struct i2c_client *i2c;
@@ -48,6 +84,7 @@ struct s5m_rtc_info {
         int device_type;
         int rtc_24hr_mode;
         bool wtsr_smpl;
+        const struct s5m_rtc_reg_config *regs;
 };
 
 static const struct regmap_config s5m_rtc_regmap_config = {
@@ -119,8 +156,9 @@ static inline int s5m8767_wait_for_udr_update(struct s5m_rtc_info *info)
         unsigned int data;
 
         do {
-                ret = regmap_read(info->regmap, S5M_RTC_UDR_CON, &data);
-        } while (--retry && (data & S5M_RTC_UDR_MASK) && !ret);
+                ret = regmap_read(info->regmap, info->regs->rtc_udr_update,
+                                &data);
+        } while (--retry && (data & info->regs->rtc_udr_mask) && !ret);
 
         if (!retry)
                 dev_err(info->dev, "waiting for UDR update, reached max number of retries\n");
@@ -128,21 +166,47 @@ static inline int s5m8767_wait_for_udr_update(struct s5m_rtc_info *info)
         return ret;
 }
 
+static inline int s5m_check_peding_alarm_interrupt(struct s5m_rtc_info *info,
+                struct rtc_wkalrm *alarm)
+{
+        int ret;
+        unsigned int val;
+
+        switch (info->device_type) {
+        case S5M8767X:
+        case S5M8763X:
+                ret = regmap_read(info->regmap, S5M_RTC_STATUS, &val);
+                val &= S5M_ALARM0_STATUS;
+                break;
+        default:
+                return -EINVAL;
+        }
+        if (ret < 0)
+                return ret;
+
+        if (val)
+                alarm->pending = 1;
+        else
+                alarm->pending = 0;
+
+        return 0;
+}
+
 static inline int s5m8767_rtc_set_time_reg(struct s5m_rtc_info *info)
 {
         int ret;
         unsigned int data;
 
-        ret = regmap_read(info->regmap, S5M_RTC_UDR_CON, &data);
+        ret = regmap_read(info->regmap, info->regs->rtc_udr_update, &data);
         if (ret < 0) {
                 dev_err(info->dev, "failed to read update reg(%d)\n", ret);
                 return ret;
         }
 
         data |= S5M_RTC_TIME_EN_MASK;
-        data |= S5M_RTC_UDR_MASK;
+        data |= info->regs->rtc_udr_mask;
 
-        ret = regmap_write(info->regmap, S5M_RTC_UDR_CON, data);
+        ret = regmap_write(info->regmap, info->regs->rtc_udr_update, data);
         if (ret < 0) {
                 dev_err(info->dev, "failed to write update reg(%d)\n", ret);
                 return ret;
@@ -158,7 +222,7 @@ static inline int s5m8767_rtc_set_alarm_reg(struct s5m_rtc_info *info)
         int ret;
         unsigned int data;
 
-        ret = regmap_read(info->regmap, S5M_RTC_UDR_CON, &data);
+        ret = regmap_read(info->regmap, info->regs->rtc_udr_update, &data);
         if (ret < 0) {
                 dev_err(info->dev, "%s: fail to read update reg(%d)\n",
                         __func__, ret);
@@ -166,9 +230,9 @@ static inline int s5m8767_rtc_set_alarm_reg(struct s5m_rtc_info *info)
         }
 
         data &= ~S5M_RTC_TIME_EN_MASK;
-        data |= S5M_RTC_UDR_MASK;
+        data |= info->regs->rtc_udr_mask;
 
-        ret = regmap_write(info->regmap, S5M_RTC_UDR_CON, data);
+        ret = regmap_write(info->regmap, info->regs->rtc_udr_update, data);
         if (ret < 0) {
                 dev_err(info->dev, "%s: fail to write update reg(%d)\n",
                         __func__, ret);
@@ -215,10 +279,11 @@ static void s5m8763_tm_to_data(struct rtc_time *tm, u8 *data)
 static int s5m_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
         struct s5m_rtc_info *info = dev_get_drvdata(dev);
-        u8 data[8];
+        u8 data[info->regs->regs_count];
         int ret;
 
-        ret = regmap_bulk_read(info->regmap, S5M_RTC_SEC, data, 8);
+        ret = regmap_bulk_read(info->regmap, info->regs->time, data,
+                        info->regs->regs_count);
         if (ret < 0)
                 return ret;
 
@@ -245,7 +310,7 @@ static int s5m_rtc_read_time(struct device *dev, struct rtc_time *tm)
 static int s5m_rtc_set_time(struct device *dev, struct rtc_time *tm)
 {
         struct s5m_rtc_info *info = dev_get_drvdata(dev);
-        u8 data[8];
+        u8 data[info->regs->regs_count];
         int ret = 0;
 
         switch (info->device_type) {
@@ -266,7 +331,8 @@ static int s5m_rtc_set_time(struct device *dev, struct rtc_time *tm)
                 1900 + tm->tm_year, 1 + tm->tm_mon, tm->tm_mday,
                 tm->tm_hour, tm->tm_min, tm->tm_sec, tm->tm_wday);
 
-        ret = regmap_raw_write(info->regmap, S5M_RTC_SEC, data, 8);
+        ret = regmap_raw_write(info->regmap, info->regs->time, data,
+                        info->regs->regs_count);
         if (ret < 0)
                 return ret;
 
@@ -278,11 +344,12 @@ static int s5m_rtc_set_time(struct device *dev, struct rtc_time *tm)
 static int s5m_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 {
         struct s5m_rtc_info *info = dev_get_drvdata(dev);
-        u8 data[8];
+        u8 data[info->regs->regs_count];
         unsigned int val;
         int ret, i;
 
-        ret = regmap_bulk_read(info->regmap, S5M_ALARM0_SEC, data, 8);
+        ret = regmap_bulk_read(info->regmap, info->regs->alarm0, data,
+                        info->regs->regs_count);
         if (ret < 0)
                 return ret;
 
@@ -294,54 +361,42 @@ static int s5m_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
                         return ret;
 
                 alrm->enabled = !!val;
-
-                ret = regmap_read(info->regmap, S5M_RTC_STATUS, &val);
-                if (ret < 0)
-                        return ret;
-
                 break;
 
         case S5M8767X:
                 s5m8767_data_to_tm(data, &alrm->time, info->rtc_24hr_mode);
-                dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
-                        1900 + alrm->time.tm_year, 1 + alrm->time.tm_mon,
-                        alrm->time.tm_mday, alrm->time.tm_hour,
-                        alrm->time.tm_min, alrm->time.tm_sec,
-                        alrm->time.tm_wday);
-
                 alrm->enabled = 0;
-                for (i = 0; i < 7; i++) {
+                for (i = 0; i < info->regs->regs_count; i++) {
                         if (data[i] & ALARM_ENABLE_MASK) {
                                 alrm->enabled = 1;
                                 break;
                         }
                 }
-
-                alrm->pending = 0;
-                ret = regmap_read(info->regmap, S5M_RTC_STATUS, &val);
-                if (ret < 0)
-                        return ret;
                 break;
 
         default:
                 return -EINVAL;
         }
 
-        if (val & S5M_ALARM0_STATUS)
-                alrm->pending = 1;
-        else
-                alrm->pending = 0;
+        dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
+                1900 + alrm->time.tm_year, 1 + alrm->time.tm_mon,
+                alrm->time.tm_mday, alrm->time.tm_hour,
+                alrm->time.tm_min, alrm->time.tm_sec,
+                alrm->time.tm_wday);
+
+        ret = s5m_check_peding_alarm_interrupt(info, alrm);
 
         return 0;
 }
 
 static int s5m_rtc_stop_alarm(struct s5m_rtc_info *info)
 {
-        u8 data[8];
+        u8 data[info->regs->regs_count];
         int ret, i;
         struct rtc_time tm;
 
-        ret = regmap_bulk_read(info->regmap, S5M_ALARM0_SEC, data, 8);
+        ret = regmap_bulk_read(info->regmap, info->regs->alarm0, data,
+                        info->regs->regs_count);
         if (ret < 0)
                 return ret;
 
@@ -356,10 +411,11 @@ static int s5m_rtc_stop_alarm(struct s5m_rtc_info *info)
                 break;
 
         case S5M8767X:
-                for (i = 0; i < 7; i++)
+                for (i = 0; i < info->regs->regs_count; i++)
                         data[i] &= ~ALARM_ENABLE_MASK;
 
-                ret = regmap_raw_write(info->regmap, S5M_ALARM0_SEC, data, 8);
+                ret = regmap_raw_write(info->regmap, info->regs->alarm0, data,
+                                info->regs->regs_count);
                 if (ret < 0)
                         return ret;
 
@@ -377,11 +433,12 @@ static int s5m_rtc_stop_alarm(struct s5m_rtc_info *info)
 static int s5m_rtc_start_alarm(struct s5m_rtc_info *info)
 {
         int ret;
-        u8 data[8];
+        u8 data[info->regs->regs_count];
         u8 alarm0_conf;
         struct rtc_time tm;
 
-        ret = regmap_bulk_read(info->regmap, S5M_ALARM0_SEC, data, 8);
+        ret = regmap_bulk_read(info->regmap, info->regs->alarm0, data,
+                        info->regs->regs_count);
         if (ret < 0)
                 return ret;
 
@@ -408,7 +465,8 @@ static int s5m_rtc_start_alarm(struct s5m_rtc_info *info)
                 if (data[RTC_YEAR1] & 0x7f)
                         data[RTC_YEAR1] |= ALARM_ENABLE_MASK;
 
-                ret = regmap_raw_write(info->regmap, S5M_ALARM0_SEC, data, 8);
+                ret = regmap_raw_write(info->regmap, info->regs->alarm0, data,
+                                info->regs->regs_count);
                 if (ret < 0)
                         return ret;
                 ret = s5m8767_rtc_set_alarm_reg(info);
@@ -425,7 +483,7 @@ static int s5m_rtc_start_alarm(struct s5m_rtc_info *info)
 static int s5m_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 {
         struct s5m_rtc_info *info = dev_get_drvdata(dev);
-        u8 data[8];
+        u8 data[info->regs->regs_count];
         int ret;
 
         switch (info->device_type) {
@@ -450,7 +508,8 @@ static int s5m_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
         if (ret < 0)
                 return ret;
 
-        ret = regmap_raw_write(info->regmap, S5M_ALARM0_SEC, data, 8);
+        ret = regmap_raw_write(info->regmap, info->regs->alarm0, data,
+                        info->regs->regs_count);
         if (ret < 0)
                 return ret;
 
@@ -495,7 +554,7 @@ static const struct rtc_class_ops s5m_rtc_ops = {
 static void s5m_rtc_enable_wtsr(struct s5m_rtc_info *info, bool enable)
 {
         int ret;
-        ret = regmap_update_bits(info->regmap, S5M_WTSR_SMPL_CNTL,
+        ret = regmap_update_bits(info->regmap, info->regs->smpl_wtsr,
                                  WTSR_ENABLE_MASK,
                                  enable ? WTSR_ENABLE_MASK : 0);
         if (ret < 0)
@@ -506,7 +565,7 @@ static void s5m_rtc_enable_wtsr(struct s5m_rtc_info *info, bool enable)
 static void s5m_rtc_enable_smpl(struct s5m_rtc_info *info, bool enable)
 {
         int ret;
-        ret = regmap_update_bits(info->regmap, S5M_WTSR_SMPL_CNTL,
+        ret = regmap_update_bits(info->regmap, info->regs->smpl_wtsr,
                                  SMPL_ENABLE_MASK,
                                  enable ? SMPL_ENABLE_MASK : 0);
         if (ret < 0)
@@ -564,9 +623,11 @@ static int s5m_rtc_probe(struct platform_device *pdev)
                 break;
         case S5M8763X:
                 regmap_cfg = &s5m_rtc_regmap_config;
+                info->regs = &s5m_rtc_regs;
                 break;
         case S5M8767X:
                 regmap_cfg = &s5m_rtc_regmap_config;
+                info->regs = &s5m_rtc_regs;
                 break;
         default:
                 dev_err(&pdev->dev, "Device type is not supported by RTC driver\n");
@@ -653,7 +714,7 @@ static void s5m_rtc_shutdown(struct platform_device *pdev)
         if (info->wtsr_smpl) {
                 for (i = 0; i < 3; i++) {
                         s5m_rtc_enable_wtsr(info, false);
-                        regmap_read(info->regmap, S5M_WTSR_SMPL_CNTL, &val);
+                        regmap_read(info->regmap, info->regs->smpl_wtsr, &val);
                         pr_debug("%s: WTSR_SMPL reg(0x%02x)\n", __func__, val);
                         if (val & WTSR_ENABLE_MASK)
                                 pr_emerg("%s: fail to disable WTSR\n",