324 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Driver for the RTC in Marvell SoCs.4 */5 6#include <linux/init.h>7#include <linux/kernel.h>8#include <linux/rtc.h>9#include <linux/bcd.h>10#include <linux/bitops.h>11#include <linux/io.h>12#include <linux/platform_device.h>13#include <linux/of.h>14#include <linux/delay.h>15#include <linux/clk.h>16#include <linux/gfp.h>17#include <linux/module.h>18 19 20#define RTC_TIME_REG_OFFS 021#define RTC_SECONDS_OFFS 022#define RTC_MINUTES_OFFS 823#define RTC_HOURS_OFFS 1624#define RTC_WDAY_OFFS 2425#define RTC_HOURS_12H_MODE BIT(22) /* 12 hour mode */26 27#define RTC_DATE_REG_OFFS 428#define RTC_MDAY_OFFS 029#define RTC_MONTH_OFFS 830#define RTC_YEAR_OFFS 1631 32#define RTC_ALARM_TIME_REG_OFFS 833#define RTC_ALARM_DATE_REG_OFFS 0xc34#define RTC_ALARM_VALID BIT(7)35 36#define RTC_ALARM_INTERRUPT_MASK_REG_OFFS 0x1037#define RTC_ALARM_INTERRUPT_CASUE_REG_OFFS 0x1438 39struct rtc_plat_data {40 struct rtc_device *rtc;41 void __iomem *ioaddr;42 int irq;43 struct clk *clk;44};45 46static int mv_rtc_set_time(struct device *dev, struct rtc_time *tm)47{48 struct rtc_plat_data *pdata = dev_get_drvdata(dev);49 void __iomem *ioaddr = pdata->ioaddr;50 u32 rtc_reg;51 52 rtc_reg = (bin2bcd(tm->tm_sec) << RTC_SECONDS_OFFS) |53 (bin2bcd(tm->tm_min) << RTC_MINUTES_OFFS) |54 (bin2bcd(tm->tm_hour) << RTC_HOURS_OFFS) |55 (bin2bcd(tm->tm_wday) << RTC_WDAY_OFFS);56 writel(rtc_reg, ioaddr + RTC_TIME_REG_OFFS);57 58 rtc_reg = (bin2bcd(tm->tm_mday) << RTC_MDAY_OFFS) |59 (bin2bcd(tm->tm_mon + 1) << RTC_MONTH_OFFS) |60 (bin2bcd(tm->tm_year - 100) << RTC_YEAR_OFFS);61 writel(rtc_reg, ioaddr + RTC_DATE_REG_OFFS);62 63 return 0;64}65 66static int mv_rtc_read_time(struct device *dev, struct rtc_time *tm)67{68 struct rtc_plat_data *pdata = dev_get_drvdata(dev);69 void __iomem *ioaddr = pdata->ioaddr;70 u32 rtc_time, rtc_date;71 unsigned int year, month, day, hour, minute, second, wday;72 73 rtc_time = readl(ioaddr + RTC_TIME_REG_OFFS);74 rtc_date = readl(ioaddr + RTC_DATE_REG_OFFS);75 76 second = rtc_time & 0x7f;77 minute = (rtc_time >> RTC_MINUTES_OFFS) & 0x7f;78 hour = (rtc_time >> RTC_HOURS_OFFS) & 0x3f; /* assume 24 hour mode */79 wday = (rtc_time >> RTC_WDAY_OFFS) & 0x7;80 81 day = rtc_date & 0x3f;82 month = (rtc_date >> RTC_MONTH_OFFS) & 0x3f;83 year = (rtc_date >> RTC_YEAR_OFFS) & 0xff;84 85 tm->tm_sec = bcd2bin(second);86 tm->tm_min = bcd2bin(minute);87 tm->tm_hour = bcd2bin(hour);88 tm->tm_mday = bcd2bin(day);89 tm->tm_wday = bcd2bin(wday);90 tm->tm_mon = bcd2bin(month) - 1;91 /* hw counts from year 2000, but tm_year is relative to 1900 */92 tm->tm_year = bcd2bin(year) + 100;93 94 return 0;95}96 97static int mv_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)98{99 struct rtc_plat_data *pdata = dev_get_drvdata(dev);100 void __iomem *ioaddr = pdata->ioaddr;101 u32 rtc_time, rtc_date;102 unsigned int year, month, day, hour, minute, second, wday;103 104 rtc_time = readl(ioaddr + RTC_ALARM_TIME_REG_OFFS);105 rtc_date = readl(ioaddr + RTC_ALARM_DATE_REG_OFFS);106 107 second = rtc_time & 0x7f;108 minute = (rtc_time >> RTC_MINUTES_OFFS) & 0x7f;109 hour = (rtc_time >> RTC_HOURS_OFFS) & 0x3f; /* assume 24 hour mode */110 wday = (rtc_time >> RTC_WDAY_OFFS) & 0x7;111 112 day = rtc_date & 0x3f;113 month = (rtc_date >> RTC_MONTH_OFFS) & 0x3f;114 year = (rtc_date >> RTC_YEAR_OFFS) & 0xff;115 116 alm->time.tm_sec = bcd2bin(second);117 alm->time.tm_min = bcd2bin(minute);118 alm->time.tm_hour = bcd2bin(hour);119 alm->time.tm_mday = bcd2bin(day);120 alm->time.tm_wday = bcd2bin(wday);121 alm->time.tm_mon = bcd2bin(month) - 1;122 /* hw counts from year 2000, but tm_year is relative to 1900 */123 alm->time.tm_year = bcd2bin(year) + 100;124 125 alm->enabled = !!readl(ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS);126 127 return rtc_valid_tm(&alm->time);128}129 130static int mv_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)131{132 struct rtc_plat_data *pdata = dev_get_drvdata(dev);133 void __iomem *ioaddr = pdata->ioaddr;134 u32 rtc_reg = 0;135 136 if (alm->time.tm_sec >= 0)137 rtc_reg |= (RTC_ALARM_VALID | bin2bcd(alm->time.tm_sec))138 << RTC_SECONDS_OFFS;139 if (alm->time.tm_min >= 0)140 rtc_reg |= (RTC_ALARM_VALID | bin2bcd(alm->time.tm_min))141 << RTC_MINUTES_OFFS;142 if (alm->time.tm_hour >= 0)143 rtc_reg |= (RTC_ALARM_VALID | bin2bcd(alm->time.tm_hour))144 << RTC_HOURS_OFFS;145 146 writel(rtc_reg, ioaddr + RTC_ALARM_TIME_REG_OFFS);147 148 if (alm->time.tm_mday >= 0)149 rtc_reg = (RTC_ALARM_VALID | bin2bcd(alm->time.tm_mday))150 << RTC_MDAY_OFFS;151 else152 rtc_reg = 0;153 154 if (alm->time.tm_mon >= 0)155 rtc_reg |= (RTC_ALARM_VALID | bin2bcd(alm->time.tm_mon + 1))156 << RTC_MONTH_OFFS;157 158 if (alm->time.tm_year >= 0)159 rtc_reg |= (RTC_ALARM_VALID | bin2bcd(alm->time.tm_year - 100))160 << RTC_YEAR_OFFS;161 162 writel(rtc_reg, ioaddr + RTC_ALARM_DATE_REG_OFFS);163 writel(0, ioaddr + RTC_ALARM_INTERRUPT_CASUE_REG_OFFS);164 writel(alm->enabled ? 1 : 0,165 ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS);166 167 return 0;168}169 170static int mv_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)171{172 struct rtc_plat_data *pdata = dev_get_drvdata(dev);173 void __iomem *ioaddr = pdata->ioaddr;174 175 if (pdata->irq < 0)176 return -EINVAL; /* fall back into rtc-dev's emulation */177 178 if (enabled)179 writel(1, ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS);180 else181 writel(0, ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS);182 return 0;183}184 185static irqreturn_t mv_rtc_interrupt(int irq, void *data)186{187 struct rtc_plat_data *pdata = data;188 void __iomem *ioaddr = pdata->ioaddr;189 190 /* alarm irq? */191 if (!readl(ioaddr + RTC_ALARM_INTERRUPT_CASUE_REG_OFFS))192 return IRQ_NONE;193 194 /* clear interrupt */195 writel(0, ioaddr + RTC_ALARM_INTERRUPT_CASUE_REG_OFFS);196 rtc_update_irq(pdata->rtc, 1, RTC_IRQF | RTC_AF);197 return IRQ_HANDLED;198}199 200static const struct rtc_class_ops mv_rtc_ops = {201 .read_time = mv_rtc_read_time,202 .set_time = mv_rtc_set_time,203 .read_alarm = mv_rtc_read_alarm,204 .set_alarm = mv_rtc_set_alarm,205 .alarm_irq_enable = mv_rtc_alarm_irq_enable,206};207 208static int __init mv_rtc_probe(struct platform_device *pdev)209{210 struct rtc_plat_data *pdata;211 u32 rtc_time;212 int ret = 0;213 214 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);215 if (!pdata)216 return -ENOMEM;217 218 pdata->ioaddr = devm_platform_ioremap_resource(pdev, 0);219 if (IS_ERR(pdata->ioaddr))220 return PTR_ERR(pdata->ioaddr);221 222 pdata->clk = devm_clk_get(&pdev->dev, NULL);223 /* Not all SoCs require a clock.*/224 if (!IS_ERR(pdata->clk))225 clk_prepare_enable(pdata->clk);226 227 /* make sure the 24 hour mode is enabled */228 rtc_time = readl(pdata->ioaddr + RTC_TIME_REG_OFFS);229 if (rtc_time & RTC_HOURS_12H_MODE) {230 dev_err(&pdev->dev, "12 Hour mode is enabled but not supported.\n");231 ret = -EINVAL;232 goto out;233 }234 235 /* make sure it is actually functional */236 if (rtc_time == 0x01000000) {237 ssleep(1);238 rtc_time = readl(pdata->ioaddr + RTC_TIME_REG_OFFS);239 if (rtc_time == 0x01000000) {240 dev_err(&pdev->dev, "internal RTC not ticking\n");241 ret = -ENODEV;242 goto out;243 }244 }245 246 pdata->irq = platform_get_irq(pdev, 0);247 248 platform_set_drvdata(pdev, pdata);249 250 pdata->rtc = devm_rtc_allocate_device(&pdev->dev);251 if (IS_ERR(pdata->rtc)) {252 ret = PTR_ERR(pdata->rtc);253 goto out;254 }255 256 if (pdata->irq >= 0) {257 writel(0, pdata->ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS);258 if (devm_request_irq(&pdev->dev, pdata->irq, mv_rtc_interrupt,259 IRQF_SHARED,260 pdev->name, pdata) < 0) {261 dev_warn(&pdev->dev, "interrupt not available.\n");262 pdata->irq = -1;263 }264 }265 266 if (pdata->irq >= 0)267 device_init_wakeup(&pdev->dev, 1);268 else269 clear_bit(RTC_FEATURE_ALARM, pdata->rtc->features);270 271 pdata->rtc->ops = &mv_rtc_ops;272 pdata->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;273 pdata->rtc->range_max = RTC_TIMESTAMP_END_2099;274 275 ret = devm_rtc_register_device(pdata->rtc);276 if (!ret)277 return 0;278out:279 if (!IS_ERR(pdata->clk))280 clk_disable_unprepare(pdata->clk);281 282 return ret;283}284 285static void __exit mv_rtc_remove(struct platform_device *pdev)286{287 struct rtc_plat_data *pdata = platform_get_drvdata(pdev);288 289 if (pdata->irq >= 0)290 device_init_wakeup(&pdev->dev, 0);291 292 if (!IS_ERR(pdata->clk))293 clk_disable_unprepare(pdata->clk);294}295 296#ifdef CONFIG_OF297static const struct of_device_id rtc_mv_of_match_table[] = {298 { .compatible = "marvell,orion-rtc", },299 {}300};301MODULE_DEVICE_TABLE(of, rtc_mv_of_match_table);302#endif303 304/*305 * mv_rtc_remove() lives in .exit.text. For drivers registered via306 * module_platform_driver_probe() this is ok because they cannot get unbound at307 * runtime. So mark the driver struct with __refdata to prevent modpost308 * triggering a section mismatch warning.309 */310static struct platform_driver mv_rtc_driver __refdata = {311 .remove_new = __exit_p(mv_rtc_remove),312 .driver = {313 .name = "rtc-mv",314 .of_match_table = of_match_ptr(rtc_mv_of_match_table),315 },316};317 318module_platform_driver_probe(mv_rtc_driver, mv_rtc_probe);319 320MODULE_AUTHOR("Saeed Bishara <saeed@marvell.com>");321MODULE_DESCRIPTION("Marvell RTC driver");322MODULE_LICENSE("GPL");323MODULE_ALIAS("platform:rtc-mv");324