1 files changed, 20 insertions, 35 deletions

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,