13 files changed, 127 insertions, 181 deletions

diff --git a/drivers/rtc/class.c b/drivers/rtc/class.c
index 472a5adc4642..c29ba7e14304 100644
--- a/drivers/rtc/class.c
+++ b/drivers/rtc/class.c
@@ -55,7 +55,7 @@ static int rtc_suspend(struct device *dev)
         struct timespec64       delta, delta_delta;
         int err;
 
-        if (has_persistent_clock())
+        if (timekeeping_rtc_skipsuspend())
                 return 0;
 
         if (strcmp(dev_name(&rtc->dev), CONFIG_RTC_HCTOSYS_DEVICE) != 0)
@@ -102,7 +102,7 @@ static int rtc_resume(struct device *dev)
         struct timespec64       sleep_time;
         int err;
 
-        if (has_persistent_clock())
+        if (timekeeping_rtc_skipresume())
                 return 0;
 
         rtc_hctosys_ret = -ENODEV;
@@ -117,10 +117,6 @@ static int rtc_resume(struct device *dev)
                 return 0;
         }
 
-        if (rtc_valid_tm(&tm) != 0) {
-                pr_debug("%s:  bogus resume time\n", dev_name(&rtc->dev));
-                return 0;
-        }
         new_rtc.tv_sec = rtc_tm_to_time64(&tm);
         new_rtc.tv_nsec = 0;
 
diff --git a/drivers/rtc/interface.c b/drivers/rtc/interface.c
index 37215cf983e9..d43ee409a5f2 100644
--- a/drivers/rtc/interface.c
+++ b/drivers/rtc/interface.c
@@ -72,7 +72,11 @@ int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm)
                 err = -ENODEV;
         else if (rtc->ops->set_time)
                 err = rtc->ops->set_time(rtc->dev.parent, tm);
-        else if (rtc->ops->set_mmss) {
+        else if (rtc->ops->set_mmss64) {
+                time64_t secs64 = rtc_tm_to_time64(tm);
+
+                err = rtc->ops->set_mmss64(rtc->dev.parent, secs64);
+        } else if (rtc->ops->set_mmss) {
                 time64_t secs64 = rtc_tm_to_time64(tm);
                 err = rtc->ops->set_mmss(rtc->dev.parent, secs64);
         } else
@@ -96,6 +100,8 @@ int rtc_set_mmss(struct rtc_device *rtc, unsigned long secs)
 
         if (!rtc->ops)
                 err = -ENODEV;
+        else if (rtc->ops->set_mmss64)
+                err = rtc->ops->set_mmss64(rtc->dev.parent, secs);
         else if (rtc->ops->set_mmss)
                 err = rtc->ops->set_mmss(rtc->dev.parent, secs);
         else if (rtc->ops->read_time && rtc->ops->set_time) {
diff --git a/drivers/rtc/rtc-ab3100.c b/drivers/rtc/rtc-ab3100.c
index 1d0340fdb820..9b725c553058 100644
--- a/drivers/rtc/rtc-ab3100.c
+++ b/drivers/rtc/rtc-ab3100.c
@@ -43,21 +43,21 @@
 /*
  * RTC clock functions and device struct declaration
  */
-static int ab3100_rtc_set_mmss(struct device *dev, unsigned long secs)
+static int ab3100_rtc_set_mmss(struct device *dev, time64_t secs)
 {
         u8 regs[] = {AB3100_TI0, AB3100_TI1, AB3100_TI2,
                      AB3100_TI3, AB3100_TI4, AB3100_TI5};
         unsigned char buf[6];
-        u64 fat_time = (u64) secs * AB3100_RTC_CLOCK_RATE * 2;
+        u64 hw_counter = secs * AB3100_RTC_CLOCK_RATE * 2;
         int err = 0;
         int i;
 
-        buf[0] = (fat_time) & 0xFF;
-        buf[1] = (fat_time >> 8) & 0xFF;
-        buf[2] = (fat_time >> 16) & 0xFF;
-        buf[3] = (fat_time >> 24) & 0xFF;
-        buf[4] = (fat_time >> 32) & 0xFF;
-        buf[5] = (fat_time >> 40) & 0xFF;
+        buf[0] = (hw_counter) & 0xFF;
+        buf[1] = (hw_counter >> 8) & 0xFF;
+        buf[2] = (hw_counter >> 16) & 0xFF;
+        buf[3] = (hw_counter >> 24) & 0xFF;
+        buf[4] = (hw_counter >> 32) & 0xFF;
+        buf[5] = (hw_counter >> 40) & 0xFF;
 
         for (i = 0; i < 6; i++) {
                 err = abx500_set_register_interruptible(dev, 0,
@@ -75,7 +75,7 @@ static int ab3100_rtc_set_mmss(struct device *dev, unsigned long secs)
 
 static int ab3100_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
-        unsigned long time;
+        time64_t time;
         u8 rtcval;
         int err;
 
@@ -88,7 +88,7 @@ static int ab3100_rtc_read_time(struct device *dev, struct rtc_time *tm)
                 dev_info(dev, "clock not set (lost power)");
                 return -EINVAL;
         } else {
-                u64 fat_time;
+                u64 hw_counter;
                 u8 buf[6];
 
                 /* Read out time registers */
@@ -98,22 +98,21 @@ static int ab3100_rtc_read_time(struct device *dev, struct rtc_time *tm)
                 if (err != 0)
                         return err;
 
-                fat_time = ((u64) buf[5] << 40) | ((u64) buf[4] << 32) |
+                hw_counter = ((u64) buf[5] << 40) | ((u64) buf[4] << 32) |
                         ((u64) buf[3] << 24) | ((u64) buf[2] << 16) |
                         ((u64) buf[1] << 8) | (u64) buf[0];
-                time = (unsigned long) (fat_time /
-                                        (u64) (AB3100_RTC_CLOCK_RATE * 2));
+                time = hw_counter / (u64) (AB3100_RTC_CLOCK_RATE * 2);
         }
 
-        rtc_time_to_tm(time, tm);
+        rtc_time64_to_tm(time, tm);
 
         return rtc_valid_tm(tm);
 }
 
 static int ab3100_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 {
-        unsigned long time;
-        u64 fat_time;
+        time64_t time;
+        u64 hw_counter;
         u8 buf[6];
         u8 rtcval;
         int err;
@@ -134,11 +133,11 @@ static int ab3100_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
                                                      AB3100_AL0, buf, 4);
         if (err)
                 return err;
-        fat_time = ((u64) buf[3] << 40) | ((u64) buf[2] << 32) |
+        hw_counter = ((u64) buf[3] << 40) | ((u64) buf[2] << 32) |
                 ((u64) buf[1] << 24) | ((u64) buf[0] << 16);
-        time = (unsigned long) (fat_time / (u64) (AB3100_RTC_CLOCK_RATE * 2));
+        time = hw_counter / (u64) (AB3100_RTC_CLOCK_RATE * 2);
 
-        rtc_time_to_tm(time, &alarm->time);
+        rtc_time64_to_tm(time, &alarm->time);
 
         return rtc_valid_tm(&alarm->time);
 }
@@ -147,17 +146,17 @@ static int ab3100_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 {
         u8 regs[] = {AB3100_AL0, AB3100_AL1, AB3100_AL2, AB3100_AL3};
         unsigned char buf[4];
-        unsigned long secs;
-        u64 fat_time;
+        time64_t secs;
+        u64 hw_counter;
         int err;
         int i;
 
-        rtc_tm_to_time(&alarm->time, &secs);
-        fat_time = (u64) secs * AB3100_RTC_CLOCK_RATE * 2;
-        buf[0] = (fat_time >> 16) & 0xFF;
-        buf[1] = (fat_time >> 24) & 0xFF;
-        buf[2] = (fat_time >> 32) & 0xFF;
-        buf[3] = (fat_time >> 40) & 0xFF;
+        secs = rtc_tm_to_time64(&alarm->time);
+        hw_counter = secs * AB3100_RTC_CLOCK_RATE * 2;
+        buf[0] = (hw_counter >> 16) & 0xFF;
+        buf[1] = (hw_counter >> 24) & 0xFF;
+        buf[2] = (hw_counter >> 32) & 0xFF;
+        buf[3] = (hw_counter >> 40) & 0xFF;
 
         /* Set the alarm */
         for (i = 0; i < 4; i++) {
@@ -193,7 +192,7 @@ static int ab3100_rtc_irq_enable(struct device *dev, unsigned int enabled)
 
 static const struct rtc_class_ops ab3100_rtc_ops = {
         .read_time      = ab3100_rtc_read_time,
-        .set_mmss       = ab3100_rtc_set_mmss,
+        .set_mmss64     = ab3100_rtc_set_mmss,
         .read_alarm     = ab3100_rtc_read_alarm,
         .set_alarm      = ab3100_rtc_set_alarm,
         .alarm_irq_enable = ab3100_rtc_irq_enable,
diff --git a/drivers/rtc/rtc-cmos.c b/drivers/rtc/rtc-cmos.c
index 5b2e76159b41..87647f459198 100644
--- a/drivers/rtc/rtc-cmos.c
+++ b/drivers/rtc/rtc-cmos.c
@@ -459,23 +459,25 @@ static int cmos_procfs(struct device *dev, struct seq_file *seq)
         /* NOTE:  at least ICH6 reports battery status using a different
          * (non-RTC) bit; and SQWE is ignored on many current systems.
          */
-        return seq_printf(seq,
-                        "periodic_IRQ\t: %s\n"
-                        "update_IRQ\t: %s\n"
-                        "HPET_emulated\t: %s\n"
-                        // "square_wave\t: %s\n"
-                        "BCD\t\t: %s\n"
-                        "DST_enable\t: %s\n"
-                        "periodic_freq\t: %d\n"
-                        "batt_status\t: %s\n",
-                        (rtc_control & RTC_PIE) ? "yes" : "no",
-                        (rtc_control & RTC_UIE) ? "yes" : "no",
-                        is_hpet_enabled() ? "yes" : "no",
-                        // (rtc_control & RTC_SQWE) ? "yes" : "no",
-                        (rtc_control & RTC_DM_BINARY) ? "no" : "yes",
-                        (rtc_control & RTC_DST_EN) ? "yes" : "no",
-                        cmos->rtc->irq_freq,
-                        (valid & RTC_VRT) ? "okay" : "dead");
+        seq_printf(seq,
+                   "periodic_IRQ\t: %s\n"
+                   "update_IRQ\t: %s\n"
+                   "HPET_emulated\t: %s\n"
+                   // "square_wave\t: %s\n"
+                   "BCD\t\t: %s\n"
+                   "DST_enable\t: %s\n"
+                   "periodic_freq\t: %d\n"
+                   "batt_status\t: %s\n",
+                   (rtc_control & RTC_PIE) ? "yes" : "no",
+                   (rtc_control & RTC_UIE) ? "yes" : "no",
+                   is_hpet_enabled() ? "yes" : "no",
+                   // (rtc_control & RTC_SQWE) ? "yes" : "no",
+                   (rtc_control & RTC_DM_BINARY) ? "no" : "yes",
+                   (rtc_control & RTC_DST_EN) ? "yes" : "no",
+                   cmos->rtc->irq_freq,
+                   (valid & RTC_VRT) ? "okay" : "dead");
+
+        return 0;
 }
 
 #else
diff --git a/drivers/rtc/rtc-ds1305.c b/drivers/rtc/rtc-ds1305.c
index 129add77065d..12b07158a366 100644
--- a/drivers/rtc/rtc-ds1305.c
+++ b/drivers/rtc/rtc-ds1305.c
@@ -434,9 +434,9 @@ static int ds1305_proc(struct device *dev, struct seq_file *seq)
         }
 
 done:
-        return seq_printf(seq,
-                        "trickle_charge\t: %s%s\n",
-                        diodes, resistors);
+        seq_printf(seq, "trickle_charge\t: %s%s\n", diodes, resistors);
+
+        return 0;
 }
 
 #else
diff --git a/drivers/rtc/rtc-hid-sensor-time.c b/drivers/rtc/rtc-hid-sensor-time.c
index ae7c2ba440cf..af4f85a66b39 100644
--- a/drivers/rtc/rtc-hid-sensor-time.c
+++ b/drivers/rtc/rtc-hid-sensor-time.c
@@ -213,7 +213,7 @@ static int hid_rtc_read_time(struct device *dev, struct rtc_time *tm)
         /* get a report with all values through requesting one value */
         sensor_hub_input_attr_get_raw_value(time_state->common_attributes.hsdev,
                         HID_USAGE_SENSOR_TIME, hid_time_addresses[0],
-                        time_state->info[0].report_id);
+                        time_state->info[0].report_id, SENSOR_HUB_SYNC);
         /* wait for all values (event) */
         ret = wait_for_completion_killable_timeout(
                         &time_state->comp_last_time, HZ*6);
diff --git a/drivers/rtc/rtc-mc13xxx.c b/drivers/rtc/rtc-mc13xxx.c
index 5bce904b7ee6..32df1d812367 100644
--- a/drivers/rtc/rtc-mc13xxx.c
+++ b/drivers/rtc/rtc-mc13xxx.c
@@ -83,20 +83,19 @@ static int mc13xxx_rtc_read_time(struct device *dev, struct rtc_time *tm)
                         return ret;
         } while (days1 != days2);
 
-        rtc_time_to_tm(days1 * SEC_PER_DAY + seconds, tm);
+        rtc_time64_to_tm((time64_t)days1 * SEC_PER_DAY + seconds, tm);
 
         return rtc_valid_tm(tm);
 }
 
-static int mc13xxx_rtc_set_mmss(struct device *dev, unsigned long secs)
+static int mc13xxx_rtc_set_mmss(struct device *dev, time64_t secs)
 {
         struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
         unsigned int seconds, days;
         unsigned int alarmseconds;
         int ret;
 
-        seconds = secs % SEC_PER_DAY;
-        days = secs / SEC_PER_DAY;
+        days = div_s64_rem(secs, SEC_PER_DAY, &seconds);
 
         mc13xxx_lock(priv->mc13xxx);
 
@@ -159,7 +158,7 @@ static int mc13xxx_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 {
         struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
         unsigned seconds, days;
-        unsigned long s1970;
+        time64_t s1970;
         int enabled, pending;
         int ret;
 
@@ -189,10 +188,10 @@ out:
         alarm->enabled = enabled;
         alarm->pending = pending;
 
-        s1970 = days * SEC_PER_DAY + seconds;
+        s1970 = (time64_t)days * SEC_PER_DAY + seconds;
 
-        rtc_time_to_tm(s1970, &alarm->time);
-        dev_dbg(dev, "%s: %lu\n", __func__, s1970);
+        rtc_time64_to_tm(s1970, &alarm->time);
+        dev_dbg(dev, "%s: %lld\n", __func__, (long long)s1970);
 
         return 0;
 }
@@ -200,8 +199,8 @@ out:
 static int mc13xxx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 {
         struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
-        unsigned long s1970;
-        unsigned seconds, days;
+        time64_t s1970;
+        u32 seconds, days;
         int ret;
 
         mc13xxx_lock(priv->mc13xxx);
@@ -215,20 +214,17 @@ static int mc13xxx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
         if (unlikely(ret))
                 goto out;
 
-        ret = rtc_tm_to_time(&alarm->time, &s1970);
-        if (unlikely(ret))
-                goto out;
+        s1970 = rtc_tm_to_time64(&alarm->time);
 
-        dev_dbg(dev, "%s: o%2.s %lu\n", __func__, alarm->enabled ? "n" : "ff",
-                        s1970);
+        dev_dbg(dev, "%s: o%2.s %lld\n", __func__, alarm->enabled ? "n" : "ff",
+                        (long long)s1970);
 
         ret = mc13xxx_rtc_irq_enable_unlocked(dev, alarm->enabled,
                         MC13XXX_IRQ_TODA);
         if (unlikely(ret))
                 goto out;
 
-        seconds = s1970 % SEC_PER_DAY;
-        days = s1970 / SEC_PER_DAY;
+        days = div_s64_rem(s1970, SEC_PER_DAY, &seconds);
 
         ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCDAYA, days);
         if (unlikely(ret))
@@ -268,7 +264,7 @@ static irqreturn_t mc13xxx_rtc_update_handler(int irq, void *dev)
 
 static const struct rtc_class_ops mc13xxx_rtc_ops = {
         .read_time = mc13xxx_rtc_read_time,
-        .set_mmss = mc13xxx_rtc_set_mmss,
+        .set_mmss64 = mc13xxx_rtc_set_mmss,
         .read_alarm = mc13xxx_rtc_read_alarm,
         .set_alarm = mc13xxx_rtc_set_alarm,
         .alarm_irq_enable = mc13xxx_rtc_alarm_irq_enable,
diff --git a/drivers/rtc/rtc-mrst.c b/drivers/rtc/rtc-mrst.c
index 3a6fd3a8a2ec..548ea6f6f384 100644
--- a/drivers/rtc/rtc-mrst.c
+++ b/drivers/rtc/rtc-mrst.c
@@ -277,13 +277,15 @@ static int mrst_procfs(struct device *dev, struct seq_file *seq)
         valid = vrtc_cmos_read(RTC_VALID);
         spin_unlock_irq(&rtc_lock);
 
-        return seq_printf(seq,
-                        "periodic_IRQ\t: %s\n"
-                        "alarm\t\t: %s\n"
-                        "BCD\t\t: no\n"
-                        "periodic_freq\t: daily (not adjustable)\n",
-                        (rtc_control & RTC_PIE) ? "on" : "off",
-                        (rtc_control & RTC_AIE) ? "on" : "off");
+        seq_printf(seq,
+                   "periodic_IRQ\t: %s\n"
+                   "alarm\t\t: %s\n"
+                   "BCD\t\t: no\n"
+                   "periodic_freq\t: daily (not adjustable)\n",
+                   (rtc_control & RTC_PIE) ? "on" : "off",
+                   (rtc_control & RTC_AIE) ? "on" : "off");
+
+        return 0;
 }
 
 #else
diff --git a/drivers/rtc/rtc-mxc.c b/drivers/rtc/rtc-mxc.c
index 3c3f8d10ab43..09d422b9f7f7 100644
--- a/drivers/rtc/rtc-mxc.c
+++ b/drivers/rtc/rtc-mxc.c
@@ -106,7 +106,7 @@ static inline int is_imx1_rtc(struct rtc_plat_data *data)
  * This function is used to obtain the RTC time or the alarm value in
  * second.
  */
-static u32 get_alarm_or_time(struct device *dev, int time_alarm)
+static time64_t get_alarm_or_time(struct device *dev, int time_alarm)
 {
         struct platform_device *pdev = to_platform_device(dev);
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
@@ -129,29 +129,28 @@ static u32 get_alarm_or_time(struct device *dev, int time_alarm)
         hr = hr_min >> 8;
         min = hr_min & 0xff;
 
-        return (((day * 24 + hr) * 60) + min) * 60 + sec;
+        return ((((time64_t)day * 24 + hr) * 60) + min) * 60 + sec;
 }
 
 /*
  * This function sets the RTC alarm value or the time value.
  */
-static void set_alarm_or_time(struct device *dev, int time_alarm, u32 time)
+static void set_alarm_or_time(struct device *dev, int time_alarm, time64_t time)
 {
-        u32 day, hr, min, sec, temp;
+        u32 tod, day, hr, min, sec, temp;
         struct platform_device *pdev = to_platform_device(dev);
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
         void __iomem *ioaddr = pdata->ioaddr;
 
-        day = time / 86400;
-        time -= day * 86400;
+        day = div_s64_rem(time, 86400, &tod);
 
         /* time is within a day now */
-        hr = time / 3600;
-        time -= hr * 3600;
+        hr = tod / 3600;
+        tod -= hr * 3600;
 
         /* time is within an hour now */
-        min = time / 60;
-        sec = time - min * 60;
+        min = tod / 60;
+        sec = tod - min * 60;
 
         temp = (hr << 8) + min;
 
@@ -173,29 +172,18 @@ static void set_alarm_or_time(struct device *dev, int time_alarm, u32 time)
  * This function updates the RTC alarm registers and then clears all the
  * interrupt status bits.
  */
-static int rtc_update_alarm(struct device *dev, struct rtc_time *alrm)
+static void rtc_update_alarm(struct device *dev, struct rtc_time *alrm)
 {
-        struct rtc_time alarm_tm, now_tm;
-        unsigned long now, time;
+        time64_t time;
         struct platform_device *pdev = to_platform_device(dev);
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
         void __iomem *ioaddr = pdata->ioaddr;
 
-        now = get_alarm_or_time(dev, MXC_RTC_TIME);
-        rtc_time_to_tm(now, &now_tm);
-        alarm_tm.tm_year = now_tm.tm_year;
-        alarm_tm.tm_mon = now_tm.tm_mon;
-        alarm_tm.tm_mday = now_tm.tm_mday;
-        alarm_tm.tm_hour = alrm->tm_hour;
-        alarm_tm.tm_min = alrm->tm_min;
-        alarm_tm.tm_sec = alrm->tm_sec;
-        rtc_tm_to_time(&alarm_tm, &time);
+        time = rtc_tm_to_time64(alrm);
 
         /* clear all the interrupt status bits */
         writew(readw(ioaddr + RTC_RTCISR), ioaddr + RTC_RTCISR);
         set_alarm_or_time(dev, MXC_RTC_ALARM, time);
-
-        return 0;
 }
 
 static void mxc_rtc_irq_enable(struct device *dev, unsigned int bit,
@@ -283,14 +271,14 @@ static int mxc_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
  */
 static int mxc_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
-        u32 val;
+        time64_t val;
 
         /* Avoid roll-over from reading the different registers */
         do {
                 val = get_alarm_or_time(dev, MXC_RTC_TIME);
         } while (val != get_alarm_or_time(dev, MXC_RTC_TIME));
 
-        rtc_time_to_tm(val, tm);
+        rtc_time64_to_tm(val, tm);
 
         return 0;
 }
@@ -298,7 +286,7 @@ static int mxc_rtc_read_time(struct device *dev, struct rtc_time *tm)
 /*
  * This function sets the internal RTC time based on tm in Gregorian date.
  */
-static int mxc_rtc_set_mmss(struct device *dev, unsigned long time)
+static int mxc_rtc_set_mmss(struct device *dev, time64_t time)
 {
         struct platform_device *pdev = to_platform_device(dev);
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
@@ -309,9 +297,9 @@ static int mxc_rtc_set_mmss(struct device *dev, unsigned long time)
         if (is_imx1_rtc(pdata)) {
                 struct rtc_time tm;
 
-                rtc_time_to_tm(time, &tm);
+                rtc_time64_to_tm(time, &tm);
                 tm.tm_year = 70;
-                rtc_tm_to_time(&tm, &time);
+                time = rtc_tm_to_time64(&tm);
         }
 
         /* Avoid roll-over from reading the different registers */
@@ -333,7 +321,7 @@ static int mxc_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
         void __iomem *ioaddr = pdata->ioaddr;
 
-        rtc_time_to_tm(get_alarm_or_time(dev, MXC_RTC_ALARM), &alrm->time);
+        rtc_time64_to_tm(get_alarm_or_time(dev, MXC_RTC_ALARM), &alrm->time);
         alrm->pending = ((readw(ioaddr + RTC_RTCISR) & RTC_ALM_BIT)) ? 1 : 0;
 
         return 0;
@@ -346,11 +334,8 @@ static int mxc_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 {
         struct platform_device *pdev = to_platform_device(dev);
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
-        int ret;
 
-        ret = rtc_update_alarm(dev, &alrm->time);
-        if (ret)
-                return ret;
+        rtc_update_alarm(dev, &alrm->time);
 
         memcpy(&pdata->g_rtc_alarm, &alrm->time, sizeof(struct rtc_time));
         mxc_rtc_irq_enable(dev, RTC_ALM_BIT, alrm->enabled);
@@ -362,7 +347,7 @@ static int mxc_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 static struct rtc_class_ops mxc_rtc_ops = {
         .release                = mxc_rtc_release,
         .read_time              = mxc_rtc_read_time,
-        .set_mmss               = mxc_rtc_set_mmss,
+        .set_mmss64             = mxc_rtc_set_mmss,
         .read_alarm             = mxc_rtc_read_alarm,
         .set_alarm              = mxc_rtc_set_alarm,
         .alarm_irq_enable       = mxc_rtc_alarm_irq_enable,
diff --git a/drivers/rtc/rtc-s5m.c b/drivers/rtc/rtc-s5m.c
index 89ac1d5083c6..4008b84246ca 100644
--- a/drivers/rtc/rtc-s5m.c
+++ b/drivers/rtc/rtc-s5m.c
@@ -48,8 +48,6 @@ struct s5m_rtc_reg_config {
         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
@@ -67,7 +65,6 @@ static const struct s5m_rtc_reg_config s5m_rtc_regs = {
         .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,
 };
@@ -82,7 +79,6 @@ static const struct s5m_rtc_reg_config s2mps_rtc_regs = {
         .ctrl                   = S2MPS_RTC_CTRL,
         .alarm0                 = S2MPS_ALARM0_SEC,
         .alarm1                 = S2MPS_ALARM1_SEC,
-        .smpl_wtsr              = S2MPS_WTSR_SMPL_CNTL,
         .rtc_udr_update         = S2MPS_RTC_UDR_CON,
         .rtc_udr_mask           = S2MPS_RTC_WUDR_MASK,
 };
@@ -96,7 +92,6 @@ struct s5m_rtc_info {
         int irq;
         int device_type;
         int rtc_24hr_mode;
-        bool wtsr_smpl;
         const struct s5m_rtc_reg_config *regs;
 };
 
@@ -597,28 +592,6 @@ static const struct rtc_class_ops s5m_rtc_ops = {
         .alarm_irq_enable = s5m_rtc_alarm_irq_enable,
 };
 
-static void s5m_rtc_enable_wtsr(struct s5m_rtc_info *info, bool enable)
-{
-        int ret;
-        ret = regmap_update_bits(info->regmap, info->regs->smpl_wtsr,
-                                 WTSR_ENABLE_MASK,
-                                 enable ? WTSR_ENABLE_MASK : 0);
-        if (ret < 0)
-                dev_err(info->dev, "%s: fail to update WTSR reg(%d)\n",
-                        __func__, ret);
-}
-
-static void s5m_rtc_enable_smpl(struct s5m_rtc_info *info, bool enable)
-{
-        int ret;
-        ret = regmap_update_bits(info->regmap, info->regs->smpl_wtsr,
-                                 SMPL_ENABLE_MASK,
-                                 enable ? SMPL_ENABLE_MASK : 0);
-        if (ret < 0)
-                dev_err(info->dev, "%s: fail to update SMPL reg(%d)\n",
-                        __func__, ret);
-}
-
 static int s5m8767_rtc_init_reg(struct s5m_rtc_info *info)
 {
         u8 data[2];
@@ -715,7 +688,6 @@ static int s5m_rtc_probe(struct platform_device *pdev)
         info->dev = &pdev->dev;
         info->s5m87xx = s5m87xx;
         info->device_type = s5m87xx->device_type;
-        info->wtsr_smpl = s5m87xx->wtsr_smpl;
 
         if (s5m87xx->irq_data) {
                 info->irq = regmap_irq_get_virq(s5m87xx->irq_data, alarm_irq);
@@ -731,11 +703,6 @@ static int s5m_rtc_probe(struct platform_device *pdev)
 
         ret = s5m8767_rtc_init_reg(info);
 
-        if (info->wtsr_smpl) {
-                s5m_rtc_enable_wtsr(info, true);
-                s5m_rtc_enable_smpl(info, true);
-        }
-
         device_init_wakeup(&pdev->dev, 1);
 
         info->rtc_dev = devm_rtc_device_register(&pdev->dev, "s5m-rtc",
@@ -768,36 +735,10 @@ err:
         return ret;
 }
 
-static void s5m_rtc_shutdown(struct platform_device *pdev)
-{
-        struct s5m_rtc_info *info = platform_get_drvdata(pdev);
-        int i;
-        unsigned int val = 0;
-        if (info->wtsr_smpl) {
-                for (i = 0; i < 3; i++) {
-                        s5m_rtc_enable_wtsr(info, false);
-                        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",
-                                         __func__);
-                        else {
-                                pr_info("%s: success to disable WTSR\n",
-                                        __func__);
-                                break;
-                        }
-                }
-        }
-        /* Disable SMPL when power off */
-        s5m_rtc_enable_smpl(info, false);
-}
-
 static int s5m_rtc_remove(struct platform_device *pdev)
 {
         struct s5m_rtc_info *info = platform_get_drvdata(pdev);
 
-        /* Perform also all shutdown steps when removing */
-        s5m_rtc_shutdown(pdev);
         i2c_unregister_device(info->i2c);
 
         return 0;
@@ -842,7 +783,6 @@ static struct platform_driver s5m_rtc_driver = {
         },
         .probe          = s5m_rtc_probe,
         .remove         = s5m_rtc_remove,
-        .shutdown       = s5m_rtc_shutdown,
         .id_table       = s5m_rtc_id,
 };
 
diff --git a/drivers/rtc/rtc-tegra.c b/drivers/rtc/rtc-tegra.c
index d948277057d8..60232bd366ef 100644
--- a/drivers/rtc/rtc-tegra.c
+++ b/drivers/rtc/rtc-tegra.c
@@ -261,7 +261,9 @@ static int tegra_rtc_proc(struct device *dev, struct seq_file *seq)
         if (!dev || !dev->driver)
                 return 0;
 
-        return seq_printf(seq, "name\t\t: %s\n", dev_name(dev));
+        seq_printf(seq, "name\t\t: %s\n", dev_name(dev));
+
+        return 0;
 }
 
 static irqreturn_t tegra_rtc_irq_handler(int irq, void *data)
diff --git a/drivers/rtc/rtc-test.c b/drivers/rtc/rtc-test.c
index 8f86fa91de1a..3a2da4c892d6 100644
--- a/drivers/rtc/rtc-test.c
+++ b/drivers/rtc/rtc-test.c
@@ -13,6 +13,10 @@
 #include <linux/rtc.h>
 #include <linux/platform_device.h>
 
+static int test_mmss64;
+module_param(test_mmss64, int, 0644);
+MODULE_PARM_DESC(test_mmss64, "Test struct rtc_class_ops.set_mmss64().");
+
 static struct platform_device *test0 = NULL, *test1 = NULL;
 
 static int test_rtc_read_alarm(struct device *dev,
@@ -30,7 +34,13 @@ static int test_rtc_set_alarm(struct device *dev,
 static int test_rtc_read_time(struct device *dev,
         struct rtc_time *tm)
 {
-        rtc_time_to_tm(get_seconds(), tm);
+        rtc_time64_to_tm(ktime_get_real_seconds(), tm);
+        return 0;
+}
+
+static int test_rtc_set_mmss64(struct device *dev, time64_t secs)
+{
+        dev_info(dev, "%s, secs = %lld\n", __func__, (long long)secs);
         return 0;
 }
 
@@ -55,7 +65,7 @@ static int test_rtc_alarm_irq_enable(struct device *dev, unsigned int enable)
         return 0;
 }
 
-static const struct rtc_class_ops test_rtc_ops = {
+static struct rtc_class_ops test_rtc_ops = {
         .proc = test_rtc_proc,
         .read_time = test_rtc_read_time,
         .read_alarm = test_rtc_read_alarm,
@@ -101,6 +111,11 @@ static int test_probe(struct platform_device *plat_dev)
         int err;
         struct rtc_device *rtc;
 
+        if (test_mmss64) {
+                test_rtc_ops.set_mmss64 = test_rtc_set_mmss64;
+                test_rtc_ops.set_mmss = NULL;
+        }
+
         rtc = devm_rtc_device_register(&plat_dev->dev, "test",
                                 &test_rtc_ops, THIS_MODULE);
         if (IS_ERR(rtc)) {
diff --git a/drivers/rtc/systohc.c b/drivers/rtc/systohc.c
index eb71872d0361..7728d5e32bf4 100644
--- a/drivers/rtc/systohc.c
+++ b/drivers/rtc/systohc.c
@@ -11,7 +11,7 @@
  * rtc_set_ntp_time - Save NTP synchronized time to the RTC
  * @now: Current time of day
  *
- * Replacement for the NTP platform function update_persistent_clock
+ * Replacement for the NTP platform function update_persistent_clock64
  * that stores time for later retrieval by rtc_hctosys.
  *
  * Returns 0 on successful RTC update, -ENODEV if a RTC update is not
@@ -35,7 +35,10 @@ int rtc_set_ntp_time(struct timespec64 now)
         if (rtc) {
                 /* rtc_hctosys exclusively uses UTC, so we call set_time here,
                  * not set_mmss. */
-                if (rtc->ops && (rtc->ops->set_time || rtc->ops->set_mmss))
+                if (rtc->ops &&
+                    (rtc->ops->set_time ||
+                     rtc->ops->set_mmss64 ||
+                     rtc->ops->set_mmss))
                         err = rtc_set_time(rtc, &tm);
                 rtc_class_close(rtc);
         }