1 // SPDX-License-Identifier: GPL-2.0 2 /* 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 0 21 #define RTC_SECONDS_OFFS 0 22 #define RTC_MINUTES_OFFS 8 23 #define RTC_HOURS_OFFS 16 24 #define RTC_WDAY_OFFS 24 25 #define RTC_HOURS_12H_MODE BIT(22) /* 12 hour mode */ 26 27 #define RTC_DATE_REG_OFFS 4 28 #define RTC_MDAY_OFFS 0 29 #define RTC_MONTH_OFFS 8 30 #define RTC_YEAR_OFFS 16 31 32 #define RTC_ALARM_TIME_REG_OFFS 8 33 #define RTC_ALARM_DATE_REG_OFFS 0xc 34 #define RTC_ALARM_VALID BIT(7) 35 36 #define RTC_ALARM_INTERRUPT_MASK_REG_OFFS 0x10 37 #define RTC_ALARM_INTERRUPT_CASUE_REG_OFFS 0x14 38 39 struct rtc_plat_data { 40 struct rtc_device *rtc; 41 void __iomem *ioaddr; 42 int irq; 43 struct clk *clk; 44 }; 45 46 static 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 66 static 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 97 static 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 130 static 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 else 152 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 170 static 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 else 181 writel(0, ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS); 182 return 0; 183 } 184 185 static 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 200 static 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 208 static 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 else 269 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; 278 out: 279 if (!IS_ERR(pdata->clk)) 280 clk_disable_unprepare(pdata->clk); 281 282 return ret; 283 } 284 285 static int __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 return 0; 296 } 297 298 #ifdef CONFIG_OF 299 static const struct of_device_id rtc_mv_of_match_table[] = { 300 { .compatible = "marvell,orion-rtc", }, 301 {} 302 }; 303 MODULE_DEVICE_TABLE(of, rtc_mv_of_match_table); 304 #endif 305 306 static struct platform_driver mv_rtc_driver = { 307 .remove = __exit_p(mv_rtc_remove), 308 .driver = { 309 .name = "rtc-mv", 310 .of_match_table = of_match_ptr(rtc_mv_of_match_table), 311 }, 312 }; 313 314 module_platform_driver_probe(mv_rtc_driver, mv_rtc_probe); 315 316 MODULE_AUTHOR("Saeed Bishara <saeed@marvell.com>"); 317 MODULE_DESCRIPTION("Marvell RTC driver"); 318 MODULE_LICENSE("GPL"); 319 MODULE_ALIAS("platform:rtc-mv"); 320