drivers/rtc/rtc-rtd119x.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * Realtek RTD129x RTC
0004  *
0005  * Copyright (c) 2017 Andreas Färber
0006  */
0007
0008 #include <linux/clk.h>
0009 #include <linux/io.h>
0010 #include <linux/module.h>
0011 #include <linux/of.h>
0012 #include <linux/of_address.h>
0013 #include <linux/platform_device.h>
0014 #include <linux/rtc.h>
0015 #include <linux/spinlock.h>
0016
0017 #define RTD_RTCSEC      0x00
0018 #define RTD_RTCMIN      0x04
0019 #define RTD_RTCHR       0x08
0020 #define RTD_RTCDATE1        0x0c
0021 #define RTD_RTCDATE2        0x10
0022 #define RTD_RTCACR      0x28
0023 #define RTD_RTCEN       0x2c
0024 #define RTD_RTCCR       0x30
0025
0026 #define RTD_RTCSEC_RTCSEC_MASK      0x7f
0027
0028 #define RTD_RTCMIN_RTCMIN_MASK      0x3f
0029
0030 #define RTD_RTCHR_RTCHR_MASK        0x1f
0031
0032 #define RTD_RTCDATE1_RTCDATE1_MASK  0xff
0033
0034 #define RTD_RTCDATE2_RTCDATE2_MASK  0x7f
0035
0036 #define RTD_RTCACR_RTCPWR       BIT(7)
0037
0038 #define RTD_RTCEN_RTCEN_MASK        0xff
0039
0040 #define RTD_RTCCR_RTCRST        BIT(6)
0041
0042 struct rtd119x_rtc {
0043     void __iomem *base;
0044     struct clk *clk;
0045     struct rtc_device *rtcdev;
0046     unsigned int base_year;
0047 };
0048
0049 static inline int rtd119x_rtc_days_in_year(int year)
0050 {
0051     return 365 + (is_leap_year(year) ? 1 : 0);
0052 }
0053
0054 static void rtd119x_rtc_reset(struct device *dev)
0055 {
0056     struct rtd119x_rtc *data = dev_get_drvdata(dev);
0057     u32 val;
0058
0059     val = readl_relaxed(data->base + RTD_RTCCR);
0060     val |= RTD_RTCCR_RTCRST;
0061     writel_relaxed(val, data->base + RTD_RTCCR);
0062
0063     val &= ~RTD_RTCCR_RTCRST;
0064     writel(val, data->base + RTD_RTCCR);
0065 }
0066
0067 static void rtd119x_rtc_set_enabled(struct device *dev, bool enable)
0068 {
0069     struct rtd119x_rtc *data = dev_get_drvdata(dev);
0070     u32 val;
0071
0072     val = readl_relaxed(data->base + RTD_RTCEN);
0073     if (enable) {
0074         if ((val & RTD_RTCEN_RTCEN_MASK) == 0x5a)
0075             return;
0076         writel_relaxed(0x5a, data->base + RTD_RTCEN);
0077     } else {
0078         writel_relaxed(0, data->base + RTD_RTCEN);
0079     }
0080 }
0081
0082 static int rtd119x_rtc_read_time(struct device *dev, struct rtc_time *tm)
0083 {
0084     struct rtd119x_rtc *data = dev_get_drvdata(dev);
0085     s32 day;
0086     u32 sec;
0087     unsigned int year;
0088     int tries = 0;
0089
0090     while (true) {
0091         tm->tm_sec = (readl_relaxed(data->base + RTD_RTCSEC) & RTD_RTCSEC_RTCSEC_MASK) >> 1;
0092         tm->tm_min  = readl_relaxed(data->base + RTD_RTCMIN) & RTD_RTCMIN_RTCMIN_MASK;
0093         tm->tm_hour = readl_relaxed(data->base + RTD_RTCHR) & RTD_RTCHR_RTCHR_MASK;
0094         day  =  readl_relaxed(data->base + RTD_RTCDATE1) & RTD_RTCDATE1_RTCDATE1_MASK;
0095         day |= (readl_relaxed(data->base + RTD_RTCDATE2) & RTD_RTCDATE2_RTCDATE2_MASK) << 8;
0096         sec  = (readl_relaxed(data->base + RTD_RTCSEC) & RTD_RTCSEC_RTCSEC_MASK) >> 1;
0097         tries++;
0098
0099         if (sec == tm->tm_sec)
0100             break;
0101
0102         if (tries >= 3)
0103             return -EINVAL;
0104     }
0105     if (tries > 1)
0106         dev_dbg(dev, "%s: needed %i tries\n", __func__, tries);
0107
0108     year = data->base_year;
0109     while (day >= rtd119x_rtc_days_in_year(year)) {
0110         day -= rtd119x_rtc_days_in_year(year);
0111         year++;
0112     }
0113     tm->tm_year = year - 1900;
0114     tm->tm_yday = day;
0115
0116     tm->tm_mon = 0;
0117     while (day >= rtc_month_days(tm->tm_mon, year)) {
0118         day -= rtc_month_days(tm->tm_mon, year);
0119         tm->tm_mon++;
0120     }
0121     tm->tm_mday = day + 1;
0122
0123     return 0;
0124 }
0125
0126 static int rtd119x_rtc_set_time(struct device *dev, struct rtc_time *tm)
0127 {
0128     struct rtd119x_rtc *data = dev_get_drvdata(dev);
0129     unsigned int day;
0130     int i;
0131
0132     if (1900 + tm->tm_year < data->base_year)
0133         return -EINVAL;
0134
0135     day = 0;
0136     for (i = data->base_year; i < 1900 + tm->tm_year; i++)
0137         day += rtd119x_rtc_days_in_year(i);
0138
0139     day += tm->tm_yday;
0140     if (day > 0x7fff)
0141         return -EINVAL;
0142
0143     rtd119x_rtc_set_enabled(dev, false);
0144
0145     writel_relaxed((tm->tm_sec << 1) & RTD_RTCSEC_RTCSEC_MASK, data->base + RTD_RTCSEC);
0146     writel_relaxed(tm->tm_min & RTD_RTCMIN_RTCMIN_MASK, data->base + RTD_RTCMIN);
0147     writel_relaxed(tm->tm_hour & RTD_RTCHR_RTCHR_MASK, data->base + RTD_RTCHR);
0148     writel_relaxed(day & RTD_RTCDATE1_RTCDATE1_MASK, data->base + RTD_RTCDATE1);
0149     writel_relaxed((day >> 8) & RTD_RTCDATE2_RTCDATE2_MASK, data->base + RTD_RTCDATE2);
0150
0151     rtd119x_rtc_set_enabled(dev, true);
0152
0153     return 0;
0154 }
0155
0156 static const struct rtc_class_ops rtd119x_rtc_ops = {
0157     .read_time  = rtd119x_rtc_read_time,
0158     .set_time   = rtd119x_rtc_set_time,
0159 };
0160
0161 static const struct of_device_id rtd119x_rtc_dt_ids[] = {
0162      { .compatible = "realtek,rtd1295-rtc" },
0163      { }
0164 };
0165
0166 static int rtd119x_rtc_probe(struct platform_device *pdev)
0167 {
0168     struct rtd119x_rtc *data;
0169     u32 val;
0170     int ret;
0171
0172     data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
0173     if (!data)
0174         return -ENOMEM;
0175
0176     platform_set_drvdata(pdev, data);
0177     data->base_year = 2014;
0178
0179     data->base = devm_platform_ioremap_resource(pdev, 0);
0180     if (IS_ERR(data->base))
0181         return PTR_ERR(data->base);
0182
0183     data->clk = of_clk_get(pdev->dev.of_node, 0);
0184     if (IS_ERR(data->clk))
0185         return PTR_ERR(data->clk);
0186
0187     ret = clk_prepare_enable(data->clk);
0188     if (ret) {
0189         clk_put(data->clk);
0190         return ret;
0191     }
0192
0193     val = readl_relaxed(data->base + RTD_RTCACR);
0194     if (!(val & RTD_RTCACR_RTCPWR)) {
0195         writel_relaxed(RTD_RTCACR_RTCPWR, data->base + RTD_RTCACR);
0196
0197         rtd119x_rtc_reset(&pdev->dev);
0198
0199         writel_relaxed(0, data->base + RTD_RTCMIN);
0200         writel_relaxed(0, data->base + RTD_RTCHR);
0201         writel_relaxed(0, data->base + RTD_RTCDATE1);
0202         writel_relaxed(0, data->base + RTD_RTCDATE2);
0203     }
0204
0205     rtd119x_rtc_set_enabled(&pdev->dev, true);
0206
0207     data->rtcdev = devm_rtc_device_register(&pdev->dev, "rtc",
0208                         &rtd119x_rtc_ops, THIS_MODULE);
0209     if (IS_ERR(data->rtcdev)) {
0210         dev_err(&pdev->dev, "failed to register rtc device");
0211         clk_disable_unprepare(data->clk);
0212         clk_put(data->clk);
0213         return PTR_ERR(data->rtcdev);
0214     }
0215
0216     return 0;
0217 }
0218
0219 static int rtd119x_rtc_remove(struct platform_device *pdev)
0220 {
0221     struct rtd119x_rtc *data = platform_get_drvdata(pdev);
0222
0223     rtd119x_rtc_set_enabled(&pdev->dev, false);
0224
0225     clk_disable_unprepare(data->clk);
0226     clk_put(data->clk);
0227
0228     return 0;
0229 }
0230
0231 static struct platform_driver rtd119x_rtc_driver = {
0232     .probe = rtd119x_rtc_probe,
0233     .remove = rtd119x_rtc_remove,
0234     .driver = {
0235         .name = "rtd1295-rtc",
0236         .of_match_table = rtd119x_rtc_dt_ids,
0237     },
0238 };
0239 builtin_platform_driver(rtd119x_rtc_driver);