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 }; 204 205 static const struct rtc_class_ops mv_rtc_alarm_ops = { 206 .read_time = mv_rtc_read_time, 207 .set_time = mv_rtc_set_time, 208 .read_alarm = mv_rtc_read_alarm, 209 .set_alarm = mv_rtc_set_alarm, 210 .alarm_irq_enable = mv_rtc_alarm_irq_enable, 211 }; 212 213 static int __init mv_rtc_probe(struct platform_device *pdev) 214 { 215 struct rtc_plat_data *pdata; 216 u32 rtc_time; 217 int ret = 0; 218 219 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); 220 if (!pdata) 221 return -ENOMEM; 222 223 pdata->ioaddr = devm_platform_ioremap_resource(pdev, 0); 224 if (IS_ERR(pdata->ioaddr)) 225 return PTR_ERR(pdata->ioaddr); 226 227 pdata->clk = devm_clk_get(&pdev->dev, NULL); 228 /* Not all SoCs require a clock.*/ 229 if (!IS_ERR(pdata->clk)) 230 clk_prepare_enable(pdata->clk); 231 232 /* make sure the 24 hour mode is enabled */ 233 rtc_time = readl(pdata->ioaddr + RTC_TIME_REG_OFFS); 234 if (rtc_time & RTC_HOURS_12H_MODE) { 235 dev_err(&pdev->dev, "12 Hour mode is enabled but not supported.\n"); 236 ret = -EINVAL; 237 goto out; 238 } 239 240 /* make sure it is actually functional */ 241 if (rtc_time == 0x01000000) { 242 ssleep(1); 243 rtc_time = readl(pdata->ioaddr + RTC_TIME_REG_OFFS); 244 if (rtc_time == 0x01000000) { 245 dev_err(&pdev->dev, "internal RTC not ticking\n"); 246 ret = -ENODEV; 247 goto out; 248 } 249 } 250 251 pdata->irq = platform_get_irq(pdev, 0); 252 253 platform_set_drvdata(pdev, pdata); 254 255 pdata->rtc = devm_rtc_allocate_device(&pdev->dev); 256 if (IS_ERR(pdata->rtc)) { 257 ret = PTR_ERR(pdata->rtc); 258 goto out; 259 } 260 261 if (pdata->irq >= 0) { 262 writel(0, pdata->ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS); 263 if (devm_request_irq(&pdev->dev, pdata->irq, mv_rtc_interrupt, 264 IRQF_SHARED, 265 pdev->name, pdata) < 0) { 266 dev_warn(&pdev->dev, "interrupt not available.\n"); 267 pdata->irq = -1; 268 } 269 } 270 271 if (pdata->irq >= 0) { 272 device_init_wakeup(&pdev->dev, 1); 273 pdata->rtc->ops = &mv_rtc_alarm_ops; 274 } else { 275 pdata->rtc->ops = &mv_rtc_ops; 276 } 277 278 pdata->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000; 279 pdata->rtc->range_max = RTC_TIMESTAMP_END_2099; 280 281 ret = devm_rtc_register_device(pdata->rtc); 282 if (!ret) 283 return 0; 284 out: 285 if (!IS_ERR(pdata->clk)) 286 clk_disable_unprepare(pdata->clk); 287 288 return ret; 289 } 290 291 static int __exit mv_rtc_remove(struct platform_device *pdev) 292 { 293 struct rtc_plat_data *pdata = platform_get_drvdata(pdev); 294 295 if (pdata->irq >= 0) 296 device_init_wakeup(&pdev->dev, 0); 297 298 if (!IS_ERR(pdata->clk)) 299 clk_disable_unprepare(pdata->clk); 300 301 return 0; 302 } 303 304 #ifdef CONFIG_OF 305 static const struct of_device_id rtc_mv_of_match_table[] = { 306 { .compatible = "marvell,orion-rtc", }, 307 {} 308 }; 309 MODULE_DEVICE_TABLE(of, rtc_mv_of_match_table); 310 #endif 311 312 static struct platform_driver mv_rtc_driver = { 313 .remove = __exit_p(mv_rtc_remove), 314 .driver = { 315 .name = "rtc-mv", 316 .of_match_table = of_match_ptr(rtc_mv_of_match_table), 317 }, 318 }; 319 320 module_platform_driver_probe(mv_rtc_driver, mv_rtc_probe); 321 322 MODULE_AUTHOR("Saeed Bishara <saeed@marvell.com>"); 323 MODULE_DESCRIPTION("Marvell RTC driver"); 324 MODULE_LICENSE("GPL"); 325 MODULE_ALIAS("platform:rtc-mv"); 326