Nobuhiro Iwamatsu | 9734a1a | 2021-07-07 16:58:04 +0900 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0-only |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 2 | /* |
| 3 | * drivers/rtc/rtc-spear.c |
| 4 | * |
| 5 | * Copyright (C) 2010 ST Microelectronics |
| 6 | * Rajeev Kumar<rajeev-dlh.kumar@st.com> |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 7 | */ |
| 8 | |
| 9 | #include <linux/bcd.h> |
| 10 | #include <linux/clk.h> |
| 11 | #include <linux/delay.h> |
| 12 | #include <linux/init.h> |
| 13 | #include <linux/io.h> |
| 14 | #include <linux/irq.h> |
| 15 | #include <linux/module.h> |
Viresh Kumar | 0108c4f | 2012-05-29 15:07:35 -0700 | [diff] [blame] | 16 | #include <linux/of.h> |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 17 | #include <linux/platform_device.h> |
| 18 | #include <linux/rtc.h> |
| 19 | #include <linux/slab.h> |
| 20 | #include <linux/spinlock.h> |
| 21 | |
| 22 | /* RTC registers */ |
| 23 | #define TIME_REG 0x00 |
| 24 | #define DATE_REG 0x04 |
| 25 | #define ALARM_TIME_REG 0x08 |
| 26 | #define ALARM_DATE_REG 0x0C |
| 27 | #define CTRL_REG 0x10 |
| 28 | #define STATUS_REG 0x14 |
| 29 | |
| 30 | /* TIME_REG & ALARM_TIME_REG */ |
| 31 | #define SECONDS_UNITS (0xf<<0) /* seconds units position */ |
| 32 | #define SECONDS_TENS (0x7<<4) /* seconds tens position */ |
| 33 | #define MINUTES_UNITS (0xf<<8) /* minutes units position */ |
| 34 | #define MINUTES_TENS (0x7<<12) /* minutes tens position */ |
| 35 | #define HOURS_UNITS (0xf<<16) /* hours units position */ |
| 36 | #define HOURS_TENS (0x3<<20) /* hours tens position */ |
| 37 | |
| 38 | /* DATE_REG & ALARM_DATE_REG */ |
| 39 | #define DAYS_UNITS (0xf<<0) /* days units position */ |
| 40 | #define DAYS_TENS (0x3<<4) /* days tens position */ |
| 41 | #define MONTHS_UNITS (0xf<<8) /* months units position */ |
| 42 | #define MONTHS_TENS (0x1<<12) /* months tens position */ |
| 43 | #define YEARS_UNITS (0xf<<16) /* years units position */ |
| 44 | #define YEARS_TENS (0xf<<20) /* years tens position */ |
| 45 | #define YEARS_HUNDREDS (0xf<<24) /* years hundereds position */ |
| 46 | #define YEARS_MILLENIUMS (0xf<<28) /* years millenium position */ |
| 47 | |
| 48 | /* MASK SHIFT TIME_REG & ALARM_TIME_REG*/ |
| 49 | #define SECOND_SHIFT 0x00 /* seconds units */ |
| 50 | #define MINUTE_SHIFT 0x08 /* minutes units position */ |
| 51 | #define HOUR_SHIFT 0x10 /* hours units position */ |
| 52 | #define MDAY_SHIFT 0x00 /* Month day shift */ |
| 53 | #define MONTH_SHIFT 0x08 /* Month shift */ |
| 54 | #define YEAR_SHIFT 0x10 /* Year shift */ |
| 55 | |
| 56 | #define SECOND_MASK 0x7F |
| 57 | #define MIN_MASK 0x7F |
| 58 | #define HOUR_MASK 0x3F |
| 59 | #define DAY_MASK 0x3F |
| 60 | #define MONTH_MASK 0x7F |
| 61 | #define YEAR_MASK 0xFFFF |
| 62 | |
| 63 | /* date reg equal to time reg, for debug only */ |
| 64 | #define TIME_BYP (1<<9) |
| 65 | #define INT_ENABLE (1<<31) /* interrupt enable */ |
| 66 | |
| 67 | /* STATUS_REG */ |
| 68 | #define CLK_UNCONNECTED (1<<0) |
| 69 | #define PEND_WR_TIME (1<<2) |
| 70 | #define PEND_WR_DATE (1<<3) |
| 71 | #define LOST_WR_TIME (1<<4) |
| 72 | #define LOST_WR_DATE (1<<5) |
| 73 | #define RTC_INT_MASK (1<<31) |
| 74 | #define STATUS_BUSY (PEND_WR_TIME | PEND_WR_DATE) |
| 75 | #define STATUS_FAIL (LOST_WR_TIME | LOST_WR_DATE) |
| 76 | |
| 77 | struct spear_rtc_config { |
Viresh Kumar | ee6c54c | 2012-03-23 15:02:30 -0700 | [diff] [blame] | 78 | struct rtc_device *rtc; |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 79 | struct clk *clk; |
| 80 | spinlock_t lock; |
| 81 | void __iomem *ioaddr; |
Deepak Sikri | cd0e08a | 2012-03-23 15:02:29 -0700 | [diff] [blame] | 82 | unsigned int irq_wake; |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 83 | }; |
| 84 | |
| 85 | static inline void spear_rtc_clear_interrupt(struct spear_rtc_config *config) |
| 86 | { |
| 87 | unsigned int val; |
| 88 | unsigned long flags; |
| 89 | |
| 90 | spin_lock_irqsave(&config->lock, flags); |
| 91 | val = readl(config->ioaddr + STATUS_REG); |
| 92 | val |= RTC_INT_MASK; |
| 93 | writel(val, config->ioaddr + STATUS_REG); |
| 94 | spin_unlock_irqrestore(&config->lock, flags); |
| 95 | } |
| 96 | |
| 97 | static inline void spear_rtc_enable_interrupt(struct spear_rtc_config *config) |
| 98 | { |
| 99 | unsigned int val; |
| 100 | |
| 101 | val = readl(config->ioaddr + CTRL_REG); |
| 102 | if (!(val & INT_ENABLE)) { |
| 103 | spear_rtc_clear_interrupt(config); |
| 104 | val |= INT_ENABLE; |
| 105 | writel(val, config->ioaddr + CTRL_REG); |
| 106 | } |
| 107 | } |
| 108 | |
| 109 | static inline void spear_rtc_disable_interrupt(struct spear_rtc_config *config) |
| 110 | { |
| 111 | unsigned int val; |
| 112 | |
| 113 | val = readl(config->ioaddr + CTRL_REG); |
| 114 | if (val & INT_ENABLE) { |
| 115 | val &= ~INT_ENABLE; |
| 116 | writel(val, config->ioaddr + CTRL_REG); |
| 117 | } |
| 118 | } |
| 119 | |
| 120 | static inline int is_write_complete(struct spear_rtc_config *config) |
| 121 | { |
| 122 | int ret = 0; |
| 123 | unsigned long flags; |
| 124 | |
| 125 | spin_lock_irqsave(&config->lock, flags); |
| 126 | if ((readl(config->ioaddr + STATUS_REG)) & STATUS_FAIL) |
| 127 | ret = -EIO; |
| 128 | spin_unlock_irqrestore(&config->lock, flags); |
| 129 | |
| 130 | return ret; |
| 131 | } |
| 132 | |
| 133 | static void rtc_wait_not_busy(struct spear_rtc_config *config) |
| 134 | { |
| 135 | int status, count = 0; |
| 136 | unsigned long flags; |
| 137 | |
| 138 | /* Assuming BUSY may stay active for 80 msec) */ |
| 139 | for (count = 0; count < 80; count++) { |
| 140 | spin_lock_irqsave(&config->lock, flags); |
| 141 | status = readl(config->ioaddr + STATUS_REG); |
| 142 | spin_unlock_irqrestore(&config->lock, flags); |
| 143 | if ((status & STATUS_BUSY) == 0) |
| 144 | break; |
| 145 | /* check status busy, after each msec */ |
| 146 | msleep(1); |
| 147 | } |
| 148 | } |
| 149 | |
| 150 | static irqreturn_t spear_rtc_irq(int irq, void *dev_id) |
| 151 | { |
Viresh Kumar | ee6c54c | 2012-03-23 15:02:30 -0700 | [diff] [blame] | 152 | struct spear_rtc_config *config = dev_id; |
Tian Tao | 880f25d | 2021-03-15 10:39:30 +0800 | [diff] [blame] | 153 | unsigned long events = 0; |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 154 | unsigned int irq_data; |
| 155 | |
Tian Tao | 880f25d | 2021-03-15 10:39:30 +0800 | [diff] [blame] | 156 | spin_lock(&config->lock); |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 157 | irq_data = readl(config->ioaddr + STATUS_REG); |
Tian Tao | 880f25d | 2021-03-15 10:39:30 +0800 | [diff] [blame] | 158 | spin_unlock(&config->lock); |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 159 | |
| 160 | if ((irq_data & RTC_INT_MASK)) { |
| 161 | spear_rtc_clear_interrupt(config); |
| 162 | events = RTC_IRQF | RTC_AF; |
Viresh Kumar | ee6c54c | 2012-03-23 15:02:30 -0700 | [diff] [blame] | 163 | rtc_update_irq(config->rtc, 1, events); |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 164 | return IRQ_HANDLED; |
| 165 | } else |
| 166 | return IRQ_NONE; |
| 167 | |
| 168 | } |
| 169 | |
Alexandre Belloni | 9fb7aa7 | 2018-02-21 11:23:19 +0100 | [diff] [blame] | 170 | static void tm2bcd(struct rtc_time *tm) |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 171 | { |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 172 | tm->tm_sec = bin2bcd(tm->tm_sec); |
| 173 | tm->tm_min = bin2bcd(tm->tm_min); |
| 174 | tm->tm_hour = bin2bcd(tm->tm_hour); |
| 175 | tm->tm_mday = bin2bcd(tm->tm_mday); |
| 176 | tm->tm_mon = bin2bcd(tm->tm_mon + 1); |
| 177 | tm->tm_year = bin2bcd(tm->tm_year); |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 178 | } |
| 179 | |
| 180 | static void bcd2tm(struct rtc_time *tm) |
| 181 | { |
| 182 | tm->tm_sec = bcd2bin(tm->tm_sec); |
| 183 | tm->tm_min = bcd2bin(tm->tm_min); |
| 184 | tm->tm_hour = bcd2bin(tm->tm_hour); |
| 185 | tm->tm_mday = bcd2bin(tm->tm_mday); |
| 186 | tm->tm_mon = bcd2bin(tm->tm_mon) - 1; |
| 187 | /* epoch == 1900 */ |
| 188 | tm->tm_year = bcd2bin(tm->tm_year); |
| 189 | } |
| 190 | |
| 191 | /* |
| 192 | * spear_rtc_read_time - set the time |
| 193 | * @dev: rtc device in use |
| 194 | * @tm: holds date and time |
| 195 | * |
| 196 | * This function read time and date. On success it will return 0 |
| 197 | * otherwise -ve error is returned. |
| 198 | */ |
| 199 | static int spear_rtc_read_time(struct device *dev, struct rtc_time *tm) |
| 200 | { |
Viresh Kumar | ee6c54c | 2012-03-23 15:02:30 -0700 | [diff] [blame] | 201 | struct spear_rtc_config *config = dev_get_drvdata(dev); |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 202 | unsigned int time, date; |
| 203 | |
| 204 | /* we don't report wday/yday/isdst ... */ |
| 205 | rtc_wait_not_busy(config); |
| 206 | |
Alexandre Belloni | a87a07a | 2022-03-09 17:22:52 +0100 | [diff] [blame] | 207 | do { |
| 208 | time = readl(config->ioaddr + TIME_REG); |
| 209 | date = readl(config->ioaddr + DATE_REG); |
| 210 | } while (time == readl(config->ioaddr + TIME_REG)); |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 211 | tm->tm_sec = (time >> SECOND_SHIFT) & SECOND_MASK; |
| 212 | tm->tm_min = (time >> MINUTE_SHIFT) & MIN_MASK; |
| 213 | tm->tm_hour = (time >> HOUR_SHIFT) & HOUR_MASK; |
| 214 | tm->tm_mday = (date >> MDAY_SHIFT) & DAY_MASK; |
| 215 | tm->tm_mon = (date >> MONTH_SHIFT) & MONTH_MASK; |
| 216 | tm->tm_year = (date >> YEAR_SHIFT) & YEAR_MASK; |
| 217 | |
| 218 | bcd2tm(tm); |
| 219 | return 0; |
| 220 | } |
| 221 | |
| 222 | /* |
| 223 | * spear_rtc_set_time - set the time |
| 224 | * @dev: rtc device in use |
| 225 | * @tm: holds date and time |
| 226 | * |
| 227 | * This function set time and date. On success it will return 0 |
| 228 | * otherwise -ve error is returned. |
| 229 | */ |
| 230 | static int spear_rtc_set_time(struct device *dev, struct rtc_time *tm) |
| 231 | { |
Viresh Kumar | ee6c54c | 2012-03-23 15:02:30 -0700 | [diff] [blame] | 232 | struct spear_rtc_config *config = dev_get_drvdata(dev); |
Lars-Peter Clausen | a16e839 | 2012-10-04 17:14:01 -0700 | [diff] [blame] | 233 | unsigned int time, date; |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 234 | |
Alexandre Belloni | 9fb7aa7 | 2018-02-21 11:23:19 +0100 | [diff] [blame] | 235 | tm2bcd(tm); |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 236 | |
| 237 | rtc_wait_not_busy(config); |
| 238 | time = (tm->tm_sec << SECOND_SHIFT) | (tm->tm_min << MINUTE_SHIFT) | |
| 239 | (tm->tm_hour << HOUR_SHIFT); |
| 240 | date = (tm->tm_mday << MDAY_SHIFT) | (tm->tm_mon << MONTH_SHIFT) | |
| 241 | (tm->tm_year << YEAR_SHIFT); |
| 242 | writel(time, config->ioaddr + TIME_REG); |
| 243 | writel(date, config->ioaddr + DATE_REG); |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 244 | |
Lars-Peter Clausen | a16e839 | 2012-10-04 17:14:01 -0700 | [diff] [blame] | 245 | return is_write_complete(config); |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 246 | } |
| 247 | |
| 248 | /* |
| 249 | * spear_rtc_read_alarm - read the alarm time |
| 250 | * @dev: rtc device in use |
| 251 | * @alm: holds alarm date and time |
| 252 | * |
| 253 | * This function read alarm time and date. On success it will return 0 |
| 254 | * otherwise -ve error is returned. |
| 255 | */ |
| 256 | static int spear_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm) |
| 257 | { |
Viresh Kumar | ee6c54c | 2012-03-23 15:02:30 -0700 | [diff] [blame] | 258 | struct spear_rtc_config *config = dev_get_drvdata(dev); |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 259 | unsigned int time, date; |
| 260 | |
| 261 | rtc_wait_not_busy(config); |
| 262 | |
| 263 | time = readl(config->ioaddr + ALARM_TIME_REG); |
| 264 | date = readl(config->ioaddr + ALARM_DATE_REG); |
| 265 | alm->time.tm_sec = (time >> SECOND_SHIFT) & SECOND_MASK; |
| 266 | alm->time.tm_min = (time >> MINUTE_SHIFT) & MIN_MASK; |
| 267 | alm->time.tm_hour = (time >> HOUR_SHIFT) & HOUR_MASK; |
| 268 | alm->time.tm_mday = (date >> MDAY_SHIFT) & DAY_MASK; |
| 269 | alm->time.tm_mon = (date >> MONTH_SHIFT) & MONTH_MASK; |
| 270 | alm->time.tm_year = (date >> YEAR_SHIFT) & YEAR_MASK; |
| 271 | |
| 272 | bcd2tm(&alm->time); |
| 273 | alm->enabled = readl(config->ioaddr + CTRL_REG) & INT_ENABLE; |
| 274 | |
| 275 | return 0; |
| 276 | } |
| 277 | |
| 278 | /* |
| 279 | * spear_rtc_set_alarm - set the alarm time |
| 280 | * @dev: rtc device in use |
| 281 | * @alm: holds alarm date and time |
| 282 | * |
| 283 | * This function set alarm time and date. On success it will return 0 |
| 284 | * otherwise -ve error is returned. |
| 285 | */ |
| 286 | static int spear_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm) |
| 287 | { |
Viresh Kumar | ee6c54c | 2012-03-23 15:02:30 -0700 | [diff] [blame] | 288 | struct spear_rtc_config *config = dev_get_drvdata(dev); |
Lars-Peter Clausen | a16e839 | 2012-10-04 17:14:01 -0700 | [diff] [blame] | 289 | unsigned int time, date; |
| 290 | int err; |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 291 | |
Alexandre Belloni | 9fb7aa7 | 2018-02-21 11:23:19 +0100 | [diff] [blame] | 292 | tm2bcd(&alm->time); |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 293 | |
| 294 | rtc_wait_not_busy(config); |
| 295 | |
| 296 | time = (alm->time.tm_sec << SECOND_SHIFT) | (alm->time.tm_min << |
| 297 | MINUTE_SHIFT) | (alm->time.tm_hour << HOUR_SHIFT); |
| 298 | date = (alm->time.tm_mday << MDAY_SHIFT) | (alm->time.tm_mon << |
| 299 | MONTH_SHIFT) | (alm->time.tm_year << YEAR_SHIFT); |
| 300 | |
| 301 | writel(time, config->ioaddr + ALARM_TIME_REG); |
| 302 | writel(date, config->ioaddr + ALARM_DATE_REG); |
| 303 | err = is_write_complete(config); |
| 304 | if (err < 0) |
| 305 | return err; |
| 306 | |
| 307 | if (alm->enabled) |
| 308 | spear_rtc_enable_interrupt(config); |
| 309 | else |
| 310 | spear_rtc_disable_interrupt(config); |
| 311 | |
| 312 | return 0; |
| 313 | } |
Shiraz Hashim | 131f8b7 | 2012-03-23 15:02:29 -0700 | [diff] [blame] | 314 | |
| 315 | static int spear_alarm_irq_enable(struct device *dev, unsigned int enabled) |
| 316 | { |
Viresh Kumar | ee6c54c | 2012-03-23 15:02:30 -0700 | [diff] [blame] | 317 | struct spear_rtc_config *config = dev_get_drvdata(dev); |
Shiraz Hashim | 131f8b7 | 2012-03-23 15:02:29 -0700 | [diff] [blame] | 318 | int ret = 0; |
| 319 | |
| 320 | spear_rtc_clear_interrupt(config); |
| 321 | |
| 322 | switch (enabled) { |
| 323 | case 0: |
| 324 | /* alarm off */ |
| 325 | spear_rtc_disable_interrupt(config); |
| 326 | break; |
| 327 | case 1: |
| 328 | /* alarm on */ |
| 329 | spear_rtc_enable_interrupt(config); |
| 330 | break; |
| 331 | default: |
| 332 | ret = -EINVAL; |
| 333 | break; |
| 334 | } |
| 335 | |
| 336 | return ret; |
| 337 | } |
| 338 | |
Julia Lawall | 34c7b3a | 2016-08-31 10:05:25 +0200 | [diff] [blame] | 339 | static const struct rtc_class_ops spear_rtc_ops = { |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 340 | .read_time = spear_rtc_read_time, |
| 341 | .set_time = spear_rtc_set_time, |
| 342 | .read_alarm = spear_rtc_read_alarm, |
| 343 | .set_alarm = spear_rtc_set_alarm, |
Shiraz Hashim | 131f8b7 | 2012-03-23 15:02:29 -0700 | [diff] [blame] | 344 | .alarm_irq_enable = spear_alarm_irq_enable, |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 345 | }; |
| 346 | |
Greg Kroah-Hartman | 5a167f4 | 2012-12-21 13:09:38 -0800 | [diff] [blame] | 347 | static int spear_rtc_probe(struct platform_device *pdev) |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 348 | { |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 349 | struct spear_rtc_config *config; |
Lars-Peter Clausen | a16e839 | 2012-10-04 17:14:01 -0700 | [diff] [blame] | 350 | int status = 0; |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 351 | int irq; |
| 352 | |
Viresh Kumar | bdaa2c6 | 2012-12-17 16:02:29 -0800 | [diff] [blame] | 353 | config = devm_kzalloc(&pdev->dev, sizeof(*config), GFP_KERNEL); |
Jingoo Han | 681acc9 | 2014-04-03 14:49:46 -0700 | [diff] [blame] | 354 | if (!config) |
Viresh Kumar | bdaa2c6 | 2012-12-17 16:02:29 -0800 | [diff] [blame] | 355 | return -ENOMEM; |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 356 | |
Alexandre Belloni | 4fc4d33 | 2022-03-09 17:22:49 +0100 | [diff] [blame] | 357 | config->rtc = devm_rtc_allocate_device(&pdev->dev); |
| 358 | if (IS_ERR(config->rtc)) |
| 359 | return PTR_ERR(config->rtc); |
| 360 | |
Viresh Kumar | bdaa2c6 | 2012-12-17 16:02:29 -0800 | [diff] [blame] | 361 | /* alarm irqs */ |
| 362 | irq = platform_get_irq(pdev, 0); |
Stephen Boyd | faac910 | 2019-07-30 11:15:39 -0700 | [diff] [blame] | 363 | if (irq < 0) |
Viresh Kumar | bdaa2c6 | 2012-12-17 16:02:29 -0800 | [diff] [blame] | 364 | return irq; |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 365 | |
Viresh Kumar | bdaa2c6 | 2012-12-17 16:02:29 -0800 | [diff] [blame] | 366 | status = devm_request_irq(&pdev->dev, irq, spear_rtc_irq, 0, pdev->name, |
| 367 | config); |
| 368 | if (status) { |
| 369 | dev_err(&pdev->dev, "Alarm interrupt IRQ%d already claimed\n", |
| 370 | irq); |
| 371 | return status; |
| 372 | } |
| 373 | |
YueHaibing | 09ef18b | 2019-10-06 18:29:20 +0800 | [diff] [blame] | 374 | config->ioaddr = devm_platform_ioremap_resource(pdev, 0); |
Thierry Reding | 8cbce1e | 2013-01-21 11:09:17 +0100 | [diff] [blame] | 375 | if (IS_ERR(config->ioaddr)) |
| 376 | return PTR_ERR(config->ioaddr); |
Viresh Kumar | bdaa2c6 | 2012-12-17 16:02:29 -0800 | [diff] [blame] | 377 | |
| 378 | config->clk = devm_clk_get(&pdev->dev, NULL); |
| 379 | if (IS_ERR(config->clk)) |
| 380 | return PTR_ERR(config->clk); |
| 381 | |
Deepak Sikri | 93d7839 | 2012-12-17 16:02:32 -0800 | [diff] [blame] | 382 | status = clk_prepare_enable(config->clk); |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 383 | if (status < 0) |
Viresh Kumar | bdaa2c6 | 2012-12-17 16:02:29 -0800 | [diff] [blame] | 384 | return status; |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 385 | |
| 386 | spin_lock_init(&config->lock); |
Viresh Kumar | ee6c54c | 2012-03-23 15:02:30 -0700 | [diff] [blame] | 387 | platform_set_drvdata(pdev, config); |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 388 | |
Alexandre Belloni | 4fc4d33 | 2022-03-09 17:22:49 +0100 | [diff] [blame] | 389 | config->rtc->ops = &spear_rtc_ops; |
Alexandre Belloni | f395e1d | 2022-03-09 17:22:50 +0100 | [diff] [blame] | 390 | config->rtc->range_min = RTC_TIMESTAMP_BEGIN_0000; |
Zeng Jingxiang | 03c4cd6 | 2022-07-28 18:01:01 +0800 | [diff] [blame] | 391 | config->rtc->range_max = RTC_TIMESTAMP_END_9999; |
Deepak Sikri | c9f5c7e | 2012-12-17 16:02:34 -0800 | [diff] [blame] | 392 | |
Alexandre Belloni | 4fc4d33 | 2022-03-09 17:22:49 +0100 | [diff] [blame] | 393 | status = devm_rtc_register_device(config->rtc); |
| 394 | if (status) |
| 395 | goto err_disable_clock; |
| 396 | |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 397 | if (!device_can_wakeup(&pdev->dev)) |
| 398 | device_init_wakeup(&pdev->dev, 1); |
| 399 | |
| 400 | return 0; |
| 401 | |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 402 | err_disable_clock: |
Deepak Sikri | 93d7839 | 2012-12-17 16:02:32 -0800 | [diff] [blame] | 403 | clk_disable_unprepare(config->clk); |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 404 | |
| 405 | return status; |
| 406 | } |
| 407 | |
Uwe Kleine-König | 25ffc85 | 2023-03-04 14:30:18 +0100 | [diff] [blame] | 408 | static void spear_rtc_remove(struct platform_device *pdev) |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 409 | { |
Viresh Kumar | ee6c54c | 2012-03-23 15:02:30 -0700 | [diff] [blame] | 410 | struct spear_rtc_config *config = platform_get_drvdata(pdev); |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 411 | |
Viresh Kumar | bdaa2c6 | 2012-12-17 16:02:29 -0800 | [diff] [blame] | 412 | spear_rtc_disable_interrupt(config); |
Deepak Sikri | 93d7839 | 2012-12-17 16:02:32 -0800 | [diff] [blame] | 413 | clk_disable_unprepare(config->clk); |
Viresh Kumar | bdaa2c6 | 2012-12-17 16:02:29 -0800 | [diff] [blame] | 414 | device_init_wakeup(&pdev->dev, 0); |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 415 | } |
| 416 | |
Jingoo Han | b086e39 | 2013-04-29 16:21:02 -0700 | [diff] [blame] | 417 | #ifdef CONFIG_PM_SLEEP |
| 418 | static int spear_rtc_suspend(struct device *dev) |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 419 | { |
Jingoo Han | b086e39 | 2013-04-29 16:21:02 -0700 | [diff] [blame] | 420 | struct platform_device *pdev = to_platform_device(dev); |
Viresh Kumar | ee6c54c | 2012-03-23 15:02:30 -0700 | [diff] [blame] | 421 | struct spear_rtc_config *config = platform_get_drvdata(pdev); |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 422 | int irq; |
| 423 | |
| 424 | irq = platform_get_irq(pdev, 0); |
Deepak Sikri | cd0e08a | 2012-03-23 15:02:29 -0700 | [diff] [blame] | 425 | if (device_may_wakeup(&pdev->dev)) { |
| 426 | if (!enable_irq_wake(irq)) |
| 427 | config->irq_wake = 1; |
| 428 | } else { |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 429 | spear_rtc_disable_interrupt(config); |
| 430 | clk_disable(config->clk); |
| 431 | } |
| 432 | |
| 433 | return 0; |
| 434 | } |
| 435 | |
Jingoo Han | b086e39 | 2013-04-29 16:21:02 -0700 | [diff] [blame] | 436 | static int spear_rtc_resume(struct device *dev) |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 437 | { |
Jingoo Han | b086e39 | 2013-04-29 16:21:02 -0700 | [diff] [blame] | 438 | struct platform_device *pdev = to_platform_device(dev); |
Viresh Kumar | ee6c54c | 2012-03-23 15:02:30 -0700 | [diff] [blame] | 439 | struct spear_rtc_config *config = platform_get_drvdata(pdev); |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 440 | int irq; |
| 441 | |
| 442 | irq = platform_get_irq(pdev, 0); |
| 443 | |
Deepak Sikri | cd0e08a | 2012-03-23 15:02:29 -0700 | [diff] [blame] | 444 | if (device_may_wakeup(&pdev->dev)) { |
| 445 | if (config->irq_wake) { |
| 446 | disable_irq_wake(irq); |
| 447 | config->irq_wake = 0; |
| 448 | } |
| 449 | } else { |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 450 | clk_enable(config->clk); |
| 451 | spear_rtc_enable_interrupt(config); |
| 452 | } |
| 453 | |
| 454 | return 0; |
| 455 | } |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 456 | #endif |
| 457 | |
Jingoo Han | b086e39 | 2013-04-29 16:21:02 -0700 | [diff] [blame] | 458 | static SIMPLE_DEV_PM_OPS(spear_rtc_pm_ops, spear_rtc_suspend, spear_rtc_resume); |
| 459 | |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 460 | static void spear_rtc_shutdown(struct platform_device *pdev) |
| 461 | { |
Viresh Kumar | ee6c54c | 2012-03-23 15:02:30 -0700 | [diff] [blame] | 462 | struct spear_rtc_config *config = platform_get_drvdata(pdev); |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 463 | |
| 464 | spear_rtc_disable_interrupt(config); |
| 465 | clk_disable(config->clk); |
| 466 | } |
| 467 | |
Viresh Kumar | 0108c4f | 2012-05-29 15:07:35 -0700 | [diff] [blame] | 468 | #ifdef CONFIG_OF |
| 469 | static const struct of_device_id spear_rtc_id_table[] = { |
| 470 | { .compatible = "st,spear600-rtc" }, |
| 471 | {} |
| 472 | }; |
| 473 | MODULE_DEVICE_TABLE(of, spear_rtc_id_table); |
| 474 | #endif |
| 475 | |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 476 | static struct platform_driver spear_rtc_driver = { |
| 477 | .probe = spear_rtc_probe, |
Uwe Kleine-König | 25ffc85 | 2023-03-04 14:30:18 +0100 | [diff] [blame] | 478 | .remove_new = spear_rtc_remove, |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 479 | .shutdown = spear_rtc_shutdown, |
| 480 | .driver = { |
| 481 | .name = "rtc-spear", |
Jingoo Han | b086e39 | 2013-04-29 16:21:02 -0700 | [diff] [blame] | 482 | .pm = &spear_rtc_pm_ops, |
Viresh Kumar | 0108c4f | 2012-05-29 15:07:35 -0700 | [diff] [blame] | 483 | .of_match_table = of_match_ptr(spear_rtc_id_table), |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 484 | }, |
| 485 | }; |
| 486 | |
Axel Lin | 0c4eae6 | 2012-01-10 15:10:48 -0800 | [diff] [blame] | 487 | module_platform_driver(spear_rtc_driver); |
Rajeev Kumar | 0942a71 | 2011-05-26 16:25:09 -0700 | [diff] [blame] | 488 | |
| 489 | MODULE_ALIAS("platform:rtc-spear"); |
| 490 | MODULE_AUTHOR("Rajeev Kumar <rajeev-dlh.kumar@st.com>"); |
| 491 | MODULE_DESCRIPTION("ST SPEAr Realtime Clock Driver (RTC)"); |
| 492 | MODULE_LICENSE("GPL"); |