drivers/rtc/rtc-ftrtc010.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  Faraday Technology FTRTC010 driver
0004  *
0005  *  Copyright (C) 2009 Janos Laube <janos.dev@gmail.com>
0006  *
0007  * Original code for older kernel 2.6.15 are from Stormlinksemi
0008  * first update from Janos Laube for > 2.6.29 kernels
0009  *
0010  * checkpatch fixes and usage of rtc-lib code
0011  * Hans Ulli Kroll <ulli.kroll@googlemail.com>
0012  */
0013
0014 #include <linux/rtc.h>
0015 #include <linux/io.h>
0016 #include <linux/slab.h>
0017 #include <linux/platform_device.h>
0018 #include <linux/kernel.h>
0019 #include <linux/module.h>
0020 #include <linux/mod_devicetable.h>
0021 #include <linux/clk.h>
0022
0023 #define DRV_NAME        "rtc-ftrtc010"
0024
0025 MODULE_AUTHOR("Hans Ulli Kroll <ulli.kroll@googlemail.com>");
0026 MODULE_DESCRIPTION("RTC driver for Gemini SoC");
0027 MODULE_LICENSE("GPL");
0028 MODULE_ALIAS("platform:" DRV_NAME);
0029
0030 struct ftrtc010_rtc {
0031     struct rtc_device   *rtc_dev;
0032     void __iomem        *rtc_base;
0033     int         rtc_irq;
0034     struct clk      *pclk;
0035     struct clk      *extclk;
0036 };
0037
0038 enum ftrtc010_rtc_offsets {
0039     FTRTC010_RTC_SECOND     = 0x00,
0040     FTRTC010_RTC_MINUTE     = 0x04,
0041     FTRTC010_RTC_HOUR       = 0x08,
0042     FTRTC010_RTC_DAYS       = 0x0C,
0043     FTRTC010_RTC_ALARM_SECOND   = 0x10,
0044     FTRTC010_RTC_ALARM_MINUTE   = 0x14,
0045     FTRTC010_RTC_ALARM_HOUR     = 0x18,
0046     FTRTC010_RTC_RECORD     = 0x1C,
0047     FTRTC010_RTC_CR         = 0x20,
0048 };
0049
0050 static irqreturn_t ftrtc010_rtc_interrupt(int irq, void *dev)
0051 {
0052     return IRQ_HANDLED;
0053 }
0054
0055 /*
0056  * Looks like the RTC in the Gemini SoC is (totaly) broken
0057  * We can't read/write directly the time from RTC registers.
0058  * We must do some "offset" calculation to get the real time
0059  *
0060  * This FIX works pretty fine and Stormlinksemi aka Cortina-Networks does
0061  * the same thing, without the rtc-lib.c calls.
0062  */
0063
0064 static int ftrtc010_rtc_read_time(struct device *dev, struct rtc_time *tm)
0065 {
0066     struct ftrtc010_rtc *rtc = dev_get_drvdata(dev);
0067
0068     u32 days, hour, min, sec, offset;
0069     timeu64_t time;
0070
0071     sec  = readl(rtc->rtc_base + FTRTC010_RTC_SECOND);
0072     min  = readl(rtc->rtc_base + FTRTC010_RTC_MINUTE);
0073     hour = readl(rtc->rtc_base + FTRTC010_RTC_HOUR);
0074     days = readl(rtc->rtc_base + FTRTC010_RTC_DAYS);
0075     offset = readl(rtc->rtc_base + FTRTC010_RTC_RECORD);
0076
0077     time = offset + days * 86400 + hour * 3600 + min * 60 + sec;
0078
0079     rtc_time64_to_tm(time, tm);
0080
0081     return 0;
0082 }
0083
0084 static int ftrtc010_rtc_set_time(struct device *dev, struct rtc_time *tm)
0085 {
0086     struct ftrtc010_rtc *rtc = dev_get_drvdata(dev);
0087     u32 sec, min, hour, day, offset;
0088     timeu64_t time;
0089
0090     time = rtc_tm_to_time64(tm);
0091
0092     sec = readl(rtc->rtc_base + FTRTC010_RTC_SECOND);
0093     min = readl(rtc->rtc_base + FTRTC010_RTC_MINUTE);
0094     hour = readl(rtc->rtc_base + FTRTC010_RTC_HOUR);
0095     day = readl(rtc->rtc_base + FTRTC010_RTC_DAYS);
0096
0097     offset = time - (day * 86400 + hour * 3600 + min * 60 + sec);
0098
0099     writel(offset, rtc->rtc_base + FTRTC010_RTC_RECORD);
0100     writel(0x01, rtc->rtc_base + FTRTC010_RTC_CR);
0101
0102     return 0;
0103 }
0104
0105 static const struct rtc_class_ops ftrtc010_rtc_ops = {
0106     .read_time     = ftrtc010_rtc_read_time,
0107     .set_time      = ftrtc010_rtc_set_time,
0108 };
0109
0110 static int ftrtc010_rtc_probe(struct platform_device *pdev)
0111 {
0112     u32 days, hour, min, sec;
0113     struct ftrtc010_rtc *rtc;
0114     struct device *dev = &pdev->dev;
0115     struct resource *res;
0116     int ret;
0117
0118     rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
0119     if (unlikely(!rtc))
0120         return -ENOMEM;
0121     platform_set_drvdata(pdev, rtc);
0122
0123     rtc->pclk = devm_clk_get(dev, "PCLK");
0124     if (IS_ERR(rtc->pclk)) {
0125         dev_err(dev, "could not get PCLK\n");
0126     } else {
0127         ret = clk_prepare_enable(rtc->pclk);
0128         if (ret) {
0129             dev_err(dev, "failed to enable PCLK\n");
0130             return ret;
0131         }
0132     }
0133     rtc->extclk = devm_clk_get(dev, "EXTCLK");
0134     if (IS_ERR(rtc->extclk)) {
0135         dev_err(dev, "could not get EXTCLK\n");
0136     } else {
0137         ret = clk_prepare_enable(rtc->extclk);
0138         if (ret) {
0139             dev_err(dev, "failed to enable EXTCLK\n");
0140             goto err_disable_pclk;
0141         }
0142     }
0143
0144     rtc->rtc_irq = platform_get_irq(pdev, 0);
0145     if (rtc->rtc_irq < 0) {
0146         ret = rtc->rtc_irq;
0147         goto err_disable_extclk;
0148     }
0149
0150     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
0151     if (!res) {
0152         ret = -ENODEV;
0153         goto err_disable_extclk;
0154     }
0155
0156     rtc->rtc_base = devm_ioremap(dev, res->start,
0157                      resource_size(res));
0158     if (!rtc->rtc_base) {
0159         ret = -ENOMEM;
0160         goto err_disable_extclk;
0161     }
0162
0163     rtc->rtc_dev = devm_rtc_allocate_device(dev);
0164     if (IS_ERR(rtc->rtc_dev)) {
0165         ret = PTR_ERR(rtc->rtc_dev);
0166         goto err_disable_extclk;
0167     }
0168
0169     rtc->rtc_dev->ops = &ftrtc010_rtc_ops;
0170
0171     sec  = readl(rtc->rtc_base + FTRTC010_RTC_SECOND);
0172     min  = readl(rtc->rtc_base + FTRTC010_RTC_MINUTE);
0173     hour = readl(rtc->rtc_base + FTRTC010_RTC_HOUR);
0174     days = readl(rtc->rtc_base + FTRTC010_RTC_DAYS);
0175
0176     rtc->rtc_dev->range_min = (u64)days * 86400 + hour * 3600 +
0177                   min * 60 + sec;
0178     rtc->rtc_dev->range_max = U32_MAX + rtc->rtc_dev->range_min;
0179
0180     ret = devm_request_irq(dev, rtc->rtc_irq, ftrtc010_rtc_interrupt,
0181                    IRQF_SHARED, pdev->name, dev);
0182     if (unlikely(ret))
0183         goto err_disable_extclk;
0184
0185     return devm_rtc_register_device(rtc->rtc_dev);
0186
0187 err_disable_extclk:
0188     clk_disable_unprepare(rtc->extclk);
0189 err_disable_pclk:
0190     clk_disable_unprepare(rtc->pclk);
0191     return ret;
0192 }
0193
0194 static int ftrtc010_rtc_remove(struct platform_device *pdev)
0195 {
0196     struct ftrtc010_rtc *rtc = platform_get_drvdata(pdev);
0197
0198     if (!IS_ERR(rtc->extclk))
0199         clk_disable_unprepare(rtc->extclk);
0200     if (!IS_ERR(rtc->pclk))
0201         clk_disable_unprepare(rtc->pclk);
0202
0203     return 0;
0204 }
0205
0206 static const struct of_device_id ftrtc010_rtc_dt_match[] = {
0207     { .compatible = "cortina,gemini-rtc" },
0208     { .compatible = "faraday,ftrtc010" },
0209     { }
0210 };
0211 MODULE_DEVICE_TABLE(of, ftrtc010_rtc_dt_match);
0212
0213 static struct platform_driver ftrtc010_rtc_driver = {
0214     .driver     = {
0215         .name   = DRV_NAME,
0216         .of_match_table = ftrtc010_rtc_dt_match,
0217     },
0218     .probe      = ftrtc010_rtc_probe,
0219     .remove     = ftrtc010_rtc_remove,
0220 };
0221
0222 module_platform_driver_probe(ftrtc010_rtc_driver, ftrtc010_rtc_probe);