Thomas Gleixner | 2874c5f | 2019-05-27 08:55:01 +0200 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 2 | /* |
| 3 | * Real Time Clock driver for Wolfson Microelectronics WM8350 |
| 4 | * |
| 5 | * Copyright (C) 2007, 2008 Wolfson Microelectronics PLC. |
| 6 | * |
| 7 | * Author: Liam Girdwood |
| 8 | * linux@wolfsonmicro.com |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 9 | */ |
| 10 | |
| 11 | #include <linux/module.h> |
| 12 | #include <linux/kernel.h> |
| 13 | #include <linux/time.h> |
| 14 | #include <linux/rtc.h> |
| 15 | #include <linux/bcd.h> |
| 16 | #include <linux/interrupt.h> |
| 17 | #include <linux/ioctl.h> |
| 18 | #include <linux/completion.h> |
| 19 | #include <linux/mfd/wm8350/rtc.h> |
| 20 | #include <linux/mfd/wm8350/core.h> |
| 21 | #include <linux/delay.h> |
| 22 | #include <linux/platform_device.h> |
| 23 | |
| 24 | #define WM8350_SET_ALM_RETRIES 5 |
| 25 | #define WM8350_SET_TIME_RETRIES 5 |
| 26 | #define WM8350_GET_TIME_RETRIES 5 |
| 27 | |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 28 | /* |
| 29 | * Read current time and date in RTC |
| 30 | */ |
| 31 | static int wm8350_rtc_readtime(struct device *dev, struct rtc_time *tm) |
| 32 | { |
| 33 | struct wm8350 *wm8350 = dev_get_drvdata(dev); |
| 34 | u16 time1[4], time2[4]; |
| 35 | int retries = WM8350_GET_TIME_RETRIES, ret; |
| 36 | |
| 37 | /* |
| 38 | * Read the time twice and compare. |
| 39 | * If time1 == time2, then time is valid else retry. |
| 40 | */ |
| 41 | do { |
| 42 | ret = wm8350_block_read(wm8350, WM8350_RTC_SECONDS_MINUTES, |
| 43 | 4, time1); |
| 44 | if (ret < 0) |
| 45 | return ret; |
| 46 | ret = wm8350_block_read(wm8350, WM8350_RTC_SECONDS_MINUTES, |
| 47 | 4, time2); |
| 48 | if (ret < 0) |
| 49 | return ret; |
| 50 | |
| 51 | if (memcmp(time1, time2, sizeof(time1)) == 0) { |
| 52 | tm->tm_sec = time1[0] & WM8350_RTC_SECS_MASK; |
| 53 | |
| 54 | tm->tm_min = (time1[0] & WM8350_RTC_MINS_MASK) |
| 55 | >> WM8350_RTC_MINS_SHIFT; |
| 56 | |
| 57 | tm->tm_hour = time1[1] & WM8350_RTC_HRS_MASK; |
| 58 | |
| 59 | tm->tm_wday = ((time1[1] >> WM8350_RTC_DAY_SHIFT) |
| 60 | & 0x7) - 1; |
| 61 | |
| 62 | tm->tm_mon = ((time1[2] & WM8350_RTC_MTH_MASK) |
| 63 | >> WM8350_RTC_MTH_SHIFT) - 1; |
| 64 | |
| 65 | tm->tm_mday = (time1[2] & WM8350_RTC_DATE_MASK); |
| 66 | |
| 67 | tm->tm_year = ((time1[3] & WM8350_RTC_YHUNDREDS_MASK) |
| 68 | >> WM8350_RTC_YHUNDREDS_SHIFT) * 100; |
| 69 | tm->tm_year += time1[3] & WM8350_RTC_YUNITS_MASK; |
| 70 | |
| 71 | tm->tm_yday = rtc_year_days(tm->tm_mday, tm->tm_mon, |
| 72 | tm->tm_year); |
| 73 | tm->tm_year -= 1900; |
| 74 | |
| 75 | dev_dbg(dev, "Read (%d left): %04x %04x %04x %04x\n", |
| 76 | retries, |
| 77 | time1[0], time1[1], time1[2], time1[3]); |
| 78 | |
| 79 | return 0; |
| 80 | } |
| 81 | } while (retries--); |
| 82 | |
| 83 | dev_err(dev, "timed out reading RTC time\n"); |
| 84 | return -EIO; |
| 85 | } |
| 86 | |
| 87 | /* |
| 88 | * Set current time and date in RTC |
| 89 | */ |
| 90 | static int wm8350_rtc_settime(struct device *dev, struct rtc_time *tm) |
| 91 | { |
| 92 | struct wm8350 *wm8350 = dev_get_drvdata(dev); |
| 93 | u16 time[4]; |
| 94 | u16 rtc_ctrl; |
| 95 | int ret, retries = WM8350_SET_TIME_RETRIES; |
| 96 | |
| 97 | time[0] = tm->tm_sec; |
| 98 | time[0] |= tm->tm_min << WM8350_RTC_MINS_SHIFT; |
| 99 | time[1] = tm->tm_hour; |
| 100 | time[1] |= (tm->tm_wday + 1) << WM8350_RTC_DAY_SHIFT; |
| 101 | time[2] = tm->tm_mday; |
| 102 | time[2] |= (tm->tm_mon + 1) << WM8350_RTC_MTH_SHIFT; |
| 103 | time[3] = ((tm->tm_year + 1900) / 100) << WM8350_RTC_YHUNDREDS_SHIFT; |
| 104 | time[3] |= (tm->tm_year + 1900) % 100; |
| 105 | |
| 106 | dev_dbg(dev, "Setting: %04x %04x %04x %04x\n", |
| 107 | time[0], time[1], time[2], time[3]); |
| 108 | |
| 109 | /* Set RTC_SET to stop the clock */ |
| 110 | ret = wm8350_set_bits(wm8350, WM8350_RTC_TIME_CONTROL, WM8350_RTC_SET); |
| 111 | if (ret < 0) |
| 112 | return ret; |
| 113 | |
| 114 | /* Wait until confirmation of stopping */ |
| 115 | do { |
| 116 | rtc_ctrl = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL); |
| 117 | schedule_timeout_uninterruptible(msecs_to_jiffies(1)); |
Roel Kluin | 62da659 | 2009-03-31 15:24:59 -0700 | [diff] [blame] | 118 | } while (--retries && !(rtc_ctrl & WM8350_RTC_STS)); |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 119 | |
| 120 | if (!retries) { |
| 121 | dev_err(dev, "timed out on set confirmation\n"); |
| 122 | return -EIO; |
| 123 | } |
| 124 | |
| 125 | /* Write time to RTC */ |
| 126 | ret = wm8350_block_write(wm8350, WM8350_RTC_SECONDS_MINUTES, 4, time); |
| 127 | if (ret < 0) |
| 128 | return ret; |
| 129 | |
| 130 | /* Clear RTC_SET to start the clock */ |
| 131 | ret = wm8350_clear_bits(wm8350, WM8350_RTC_TIME_CONTROL, |
| 132 | WM8350_RTC_SET); |
| 133 | return ret; |
| 134 | } |
| 135 | |
| 136 | /* |
| 137 | * Read alarm time and date in RTC |
| 138 | */ |
| 139 | static int wm8350_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm) |
| 140 | { |
| 141 | struct wm8350 *wm8350 = dev_get_drvdata(dev); |
| 142 | struct rtc_time *tm = &alrm->time; |
| 143 | u16 time[4]; |
| 144 | int ret; |
| 145 | |
| 146 | ret = wm8350_block_read(wm8350, WM8350_ALARM_SECONDS_MINUTES, 4, time); |
| 147 | if (ret < 0) |
| 148 | return ret; |
| 149 | |
| 150 | tm->tm_sec = time[0] & WM8350_RTC_ALMSECS_MASK; |
| 151 | if (tm->tm_sec == WM8350_RTC_ALMSECS_MASK) |
| 152 | tm->tm_sec = -1; |
| 153 | |
| 154 | tm->tm_min = time[0] & WM8350_RTC_ALMMINS_MASK; |
| 155 | if (tm->tm_min == WM8350_RTC_ALMMINS_MASK) |
| 156 | tm->tm_min = -1; |
| 157 | else |
| 158 | tm->tm_min >>= WM8350_RTC_ALMMINS_SHIFT; |
| 159 | |
| 160 | tm->tm_hour = time[1] & WM8350_RTC_ALMHRS_MASK; |
| 161 | if (tm->tm_hour == WM8350_RTC_ALMHRS_MASK) |
| 162 | tm->tm_hour = -1; |
| 163 | |
| 164 | tm->tm_wday = ((time[1] >> WM8350_RTC_ALMDAY_SHIFT) & 0x7) - 1; |
| 165 | if (tm->tm_wday > 7) |
| 166 | tm->tm_wday = -1; |
| 167 | |
| 168 | tm->tm_mon = time[2] & WM8350_RTC_ALMMTH_MASK; |
| 169 | if (tm->tm_mon == WM8350_RTC_ALMMTH_MASK) |
| 170 | tm->tm_mon = -1; |
| 171 | else |
| 172 | tm->tm_mon = (tm->tm_mon >> WM8350_RTC_ALMMTH_SHIFT) - 1; |
| 173 | |
| 174 | tm->tm_mday = (time[2] & WM8350_RTC_ALMDATE_MASK); |
| 175 | if (tm->tm_mday == WM8350_RTC_ALMDATE_MASK) |
| 176 | tm->tm_mday = -1; |
| 177 | |
| 178 | tm->tm_year = -1; |
| 179 | |
| 180 | alrm->enabled = !(time[3] & WM8350_RTC_ALMSTS); |
| 181 | |
| 182 | return 0; |
| 183 | } |
| 184 | |
| 185 | static int wm8350_rtc_stop_alarm(struct wm8350 *wm8350) |
| 186 | { |
| 187 | int retries = WM8350_SET_ALM_RETRIES; |
| 188 | u16 rtc_ctrl; |
| 189 | int ret; |
| 190 | |
| 191 | /* Set RTC_SET to stop the clock */ |
| 192 | ret = wm8350_set_bits(wm8350, WM8350_RTC_TIME_CONTROL, |
| 193 | WM8350_RTC_ALMSET); |
| 194 | if (ret < 0) |
| 195 | return ret; |
| 196 | |
| 197 | /* Wait until confirmation of stopping */ |
| 198 | do { |
| 199 | rtc_ctrl = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL); |
| 200 | schedule_timeout_uninterruptible(msecs_to_jiffies(1)); |
| 201 | } while (retries-- && !(rtc_ctrl & WM8350_RTC_ALMSTS)); |
| 202 | |
| 203 | if (!(rtc_ctrl & WM8350_RTC_ALMSTS)) |
| 204 | return -ETIMEDOUT; |
| 205 | |
| 206 | return 0; |
| 207 | } |
| 208 | |
| 209 | static int wm8350_rtc_start_alarm(struct wm8350 *wm8350) |
| 210 | { |
| 211 | int ret; |
| 212 | int retries = WM8350_SET_ALM_RETRIES; |
| 213 | u16 rtc_ctrl; |
| 214 | |
| 215 | ret = wm8350_clear_bits(wm8350, WM8350_RTC_TIME_CONTROL, |
| 216 | WM8350_RTC_ALMSET); |
| 217 | if (ret < 0) |
| 218 | return ret; |
| 219 | |
| 220 | /* Wait until confirmation */ |
| 221 | do { |
| 222 | rtc_ctrl = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL); |
| 223 | schedule_timeout_uninterruptible(msecs_to_jiffies(1)); |
| 224 | } while (retries-- && rtc_ctrl & WM8350_RTC_ALMSTS); |
| 225 | |
| 226 | if (rtc_ctrl & WM8350_RTC_ALMSTS) |
| 227 | return -ETIMEDOUT; |
| 228 | |
| 229 | return 0; |
| 230 | } |
| 231 | |
Mark Brown | 47367a3 | 2009-03-31 15:24:46 -0700 | [diff] [blame] | 232 | static int wm8350_rtc_alarm_irq_enable(struct device *dev, |
| 233 | unsigned int enabled) |
| 234 | { |
| 235 | struct wm8350 *wm8350 = dev_get_drvdata(dev); |
| 236 | |
| 237 | if (enabled) |
| 238 | return wm8350_rtc_start_alarm(wm8350); |
| 239 | else |
| 240 | return wm8350_rtc_stop_alarm(wm8350); |
| 241 | } |
| 242 | |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 243 | static int wm8350_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm) |
| 244 | { |
| 245 | struct wm8350 *wm8350 = dev_get_drvdata(dev); |
| 246 | struct rtc_time *tm = &alrm->time; |
| 247 | u16 time[3]; |
| 248 | int ret; |
| 249 | |
| 250 | memset(time, 0, sizeof(time)); |
| 251 | |
| 252 | if (tm->tm_sec != -1) |
| 253 | time[0] |= tm->tm_sec; |
| 254 | else |
| 255 | time[0] |= WM8350_RTC_ALMSECS_MASK; |
| 256 | |
| 257 | if (tm->tm_min != -1) |
| 258 | time[0] |= tm->tm_min << WM8350_RTC_ALMMINS_SHIFT; |
| 259 | else |
| 260 | time[0] |= WM8350_RTC_ALMMINS_MASK; |
| 261 | |
| 262 | if (tm->tm_hour != -1) |
| 263 | time[1] |= tm->tm_hour; |
| 264 | else |
| 265 | time[1] |= WM8350_RTC_ALMHRS_MASK; |
| 266 | |
| 267 | if (tm->tm_wday != -1) |
| 268 | time[1] |= (tm->tm_wday + 1) << WM8350_RTC_ALMDAY_SHIFT; |
| 269 | else |
| 270 | time[1] |= WM8350_RTC_ALMDAY_MASK; |
| 271 | |
| 272 | if (tm->tm_mday != -1) |
| 273 | time[2] |= tm->tm_mday; |
| 274 | else |
| 275 | time[2] |= WM8350_RTC_ALMDATE_MASK; |
| 276 | |
| 277 | if (tm->tm_mon != -1) |
| 278 | time[2] |= (tm->tm_mon + 1) << WM8350_RTC_ALMMTH_SHIFT; |
| 279 | else |
| 280 | time[2] |= WM8350_RTC_ALMMTH_MASK; |
| 281 | |
| 282 | ret = wm8350_rtc_stop_alarm(wm8350); |
| 283 | if (ret < 0) |
| 284 | return ret; |
| 285 | |
| 286 | /* Write time to RTC */ |
| 287 | ret = wm8350_block_write(wm8350, WM8350_ALARM_SECONDS_MINUTES, |
| 288 | 3, time); |
| 289 | if (ret < 0) |
| 290 | return ret; |
| 291 | |
| 292 | if (alrm->enabled) |
| 293 | ret = wm8350_rtc_start_alarm(wm8350); |
| 294 | |
| 295 | return ret; |
| 296 | } |
| 297 | |
Mark Brown | 5a65edb | 2009-11-04 16:10:51 +0000 | [diff] [blame] | 298 | static irqreturn_t wm8350_rtc_alarm_handler(int irq, void *data) |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 299 | { |
Mark Brown | 5a65edb | 2009-11-04 16:10:51 +0000 | [diff] [blame] | 300 | struct wm8350 *wm8350 = data; |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 301 | struct rtc_device *rtc = wm8350->rtc.rtc; |
| 302 | int ret; |
| 303 | |
| 304 | rtc_update_irq(rtc, 1, RTC_IRQF | RTC_AF); |
| 305 | |
| 306 | /* Make it one shot */ |
| 307 | ret = wm8350_set_bits(wm8350, WM8350_RTC_TIME_CONTROL, |
| 308 | WM8350_RTC_ALMSET); |
| 309 | if (ret != 0) { |
| 310 | dev_err(&(wm8350->rtc.pdev->dev), |
| 311 | "Failed to disable alarm: %d\n", ret); |
| 312 | } |
Mark Brown | 5a65edb | 2009-11-04 16:10:51 +0000 | [diff] [blame] | 313 | |
| 314 | return IRQ_HANDLED; |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 315 | } |
| 316 | |
Mark Brown | 5a65edb | 2009-11-04 16:10:51 +0000 | [diff] [blame] | 317 | static irqreturn_t wm8350_rtc_update_handler(int irq, void *data) |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 318 | { |
Mark Brown | 5a65edb | 2009-11-04 16:10:51 +0000 | [diff] [blame] | 319 | struct wm8350 *wm8350 = data; |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 320 | struct rtc_device *rtc = wm8350->rtc.rtc; |
| 321 | |
| 322 | rtc_update_irq(rtc, 1, RTC_IRQF | RTC_UF); |
Mark Brown | 5a65edb | 2009-11-04 16:10:51 +0000 | [diff] [blame] | 323 | |
| 324 | return IRQ_HANDLED; |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 325 | } |
| 326 | |
| 327 | static const struct rtc_class_ops wm8350_rtc_ops = { |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 328 | .read_time = wm8350_rtc_readtime, |
| 329 | .set_time = wm8350_rtc_settime, |
| 330 | .read_alarm = wm8350_rtc_readalarm, |
| 331 | .set_alarm = wm8350_rtc_setalarm, |
Mark Brown | 47367a3 | 2009-03-31 15:24:46 -0700 | [diff] [blame] | 332 | .alarm_irq_enable = wm8350_rtc_alarm_irq_enable, |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 333 | }; |
| 334 | |
Jingoo Han | 7d17158 | 2013-04-29 16:20:01 -0700 | [diff] [blame] | 335 | #ifdef CONFIG_PM_SLEEP |
Mark Brown | 6f38b04 | 2009-12-15 16:46:09 -0800 | [diff] [blame] | 336 | static int wm8350_rtc_suspend(struct device *dev) |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 337 | { |
Kefeng Wang | 527bd75 | 2019-04-23 15:50:16 +0800 | [diff] [blame] | 338 | struct wm8350 *wm8350 = dev_get_drvdata(dev); |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 339 | int ret = 0; |
| 340 | u16 reg; |
| 341 | |
| 342 | reg = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL); |
| 343 | |
| 344 | if (device_may_wakeup(&wm8350->rtc.pdev->dev) && |
| 345 | reg & WM8350_RTC_ALMSTS) { |
| 346 | ret = wm8350_rtc_stop_alarm(wm8350); |
| 347 | if (ret != 0) |
Kefeng Wang | 527bd75 | 2019-04-23 15:50:16 +0800 | [diff] [blame] | 348 | dev_err(dev, "Failed to stop RTC alarm: %d\n", ret); |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 349 | } |
| 350 | |
| 351 | return ret; |
| 352 | } |
| 353 | |
Mark Brown | 6f38b04 | 2009-12-15 16:46:09 -0800 | [diff] [blame] | 354 | static int wm8350_rtc_resume(struct device *dev) |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 355 | { |
Kefeng Wang | 527bd75 | 2019-04-23 15:50:16 +0800 | [diff] [blame] | 356 | struct wm8350 *wm8350 = dev_get_drvdata(dev); |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 357 | int ret; |
| 358 | |
| 359 | if (wm8350->rtc.alarm_enabled) { |
| 360 | ret = wm8350_rtc_start_alarm(wm8350); |
| 361 | if (ret != 0) |
Kefeng Wang | 527bd75 | 2019-04-23 15:50:16 +0800 | [diff] [blame] | 362 | dev_err(dev, "Failed to restart RTC alarm: %d\n", ret); |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 363 | } |
| 364 | |
| 365 | return 0; |
| 366 | } |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 367 | #endif |
| 368 | |
| 369 | static int wm8350_rtc_probe(struct platform_device *pdev) |
| 370 | { |
| 371 | struct wm8350 *wm8350 = platform_get_drvdata(pdev); |
| 372 | struct wm8350_rtc *wm_rtc = &wm8350->rtc; |
| 373 | int ret = 0; |
| 374 | u16 timectl, power5; |
| 375 | |
| 376 | timectl = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL); |
| 377 | if (timectl & WM8350_RTC_BCD) { |
| 378 | dev_err(&pdev->dev, "RTC BCD mode not supported\n"); |
| 379 | return -EINVAL; |
| 380 | } |
| 381 | if (timectl & WM8350_RTC_12HR) { |
| 382 | dev_err(&pdev->dev, "RTC 12 hour mode not supported\n"); |
| 383 | return -EINVAL; |
| 384 | } |
| 385 | |
| 386 | /* enable the RTC if it's not already enabled */ |
| 387 | power5 = wm8350_reg_read(wm8350, WM8350_POWER_MGMT_5); |
| 388 | if (!(power5 & WM8350_RTC_TICK_ENA)) { |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 389 | wm8350_reg_unlock(wm8350); |
| 390 | |
| 391 | ret = wm8350_set_bits(wm8350, WM8350_POWER_MGMT_5, |
| 392 | WM8350_RTC_TICK_ENA); |
| 393 | if (ret < 0) { |
| 394 | dev_err(&pdev->dev, "failed to enable RTC: %d\n", ret); |
| 395 | return ret; |
| 396 | } |
| 397 | |
| 398 | wm8350_reg_lock(wm8350); |
| 399 | } |
| 400 | |
| 401 | if (timectl & WM8350_RTC_STS) { |
| 402 | int retries; |
| 403 | |
| 404 | ret = wm8350_clear_bits(wm8350, WM8350_RTC_TIME_CONTROL, |
| 405 | WM8350_RTC_SET); |
| 406 | if (ret < 0) { |
| 407 | dev_err(&pdev->dev, "failed to start: %d\n", ret); |
| 408 | return ret; |
| 409 | } |
| 410 | |
| 411 | retries = WM8350_SET_TIME_RETRIES; |
| 412 | do { |
| 413 | timectl = wm8350_reg_read(wm8350, |
| 414 | WM8350_RTC_TIME_CONTROL); |
Roel Kluin | 62da659 | 2009-03-31 15:24:59 -0700 | [diff] [blame] | 415 | } while (timectl & WM8350_RTC_STS && --retries); |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 416 | |
| 417 | if (retries == 0) { |
| 418 | dev_err(&pdev->dev, "failed to start: timeout\n"); |
| 419 | return -ENODEV; |
| 420 | } |
| 421 | } |
| 422 | |
| 423 | device_init_wakeup(&pdev->dev, 1); |
| 424 | |
Jingoo Han | a5aa777 | 2013-04-29 16:19:54 -0700 | [diff] [blame] | 425 | wm_rtc->rtc = devm_rtc_device_register(&pdev->dev, "wm8350", |
| 426 | &wm8350_rtc_ops, THIS_MODULE); |
Alexandre Belloni | d844c64 | 2023-08-28 00:16:42 +0200 | [diff] [blame] | 427 | if (IS_ERR(wm_rtc->rtc)) |
| 428 | return PTR_ERR(wm_rtc->rtc); |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 429 | |
Jiasheng Jiang | 43f0269 | 2022-03-03 16:50:30 +0800 | [diff] [blame] | 430 | ret = wm8350_register_irq(wm8350, WM8350_IRQ_RTC_SEC, |
Mark Brown | 5a65edb | 2009-11-04 16:10:51 +0000 | [diff] [blame] | 431 | wm8350_rtc_update_handler, 0, |
| 432 | "RTC Seconds", wm8350); |
Jiasheng Jiang | 43f0269 | 2022-03-03 16:50:30 +0800 | [diff] [blame] | 433 | if (ret) |
| 434 | return ret; |
| 435 | |
Mark Brown | 6a61274 | 2009-11-04 16:10:52 +0000 | [diff] [blame] | 436 | wm8350_mask_irq(wm8350, WM8350_IRQ_RTC_SEC); |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 437 | |
Jiasheng Jiang | 43f0269 | 2022-03-03 16:50:30 +0800 | [diff] [blame] | 438 | ret = wm8350_register_irq(wm8350, WM8350_IRQ_RTC_ALM, |
Mark Brown | 5a65edb | 2009-11-04 16:10:51 +0000 | [diff] [blame] | 439 | wm8350_rtc_alarm_handler, 0, |
| 440 | "RTC Alarm", wm8350); |
Jiasheng Jiang | 43f0269 | 2022-03-03 16:50:30 +0800 | [diff] [blame] | 441 | if (ret) { |
| 442 | wm8350_free_irq(wm8350, WM8350_IRQ_RTC_SEC, wm8350); |
| 443 | return ret; |
| 444 | } |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 445 | |
| 446 | return 0; |
| 447 | } |
| 448 | |
Uwe Kleine-König | 631aa2d | 2023-03-04 14:30:26 +0100 | [diff] [blame] | 449 | static void wm8350_rtc_remove(struct platform_device *pdev) |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 450 | { |
| 451 | struct wm8350 *wm8350 = platform_get_drvdata(pdev); |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 452 | |
Mark Brown | f99344f | 2010-01-05 13:59:07 +0000 | [diff] [blame] | 453 | wm8350_free_irq(wm8350, WM8350_IRQ_RTC_SEC, wm8350); |
| 454 | wm8350_free_irq(wm8350, WM8350_IRQ_RTC_ALM, wm8350); |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 455 | } |
| 456 | |
Jingoo Han | 7d17158 | 2013-04-29 16:20:01 -0700 | [diff] [blame] | 457 | static SIMPLE_DEV_PM_OPS(wm8350_rtc_pm_ops, wm8350_rtc_suspend, |
| 458 | wm8350_rtc_resume); |
Mark Brown | 6f38b04 | 2009-12-15 16:46:09 -0800 | [diff] [blame] | 459 | |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 460 | static struct platform_driver wm8350_rtc_driver = { |
| 461 | .probe = wm8350_rtc_probe, |
Uwe Kleine-König | 631aa2d | 2023-03-04 14:30:26 +0100 | [diff] [blame] | 462 | .remove_new = wm8350_rtc_remove, |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 463 | .driver = { |
| 464 | .name = "wm8350-rtc", |
Mark Brown | 6f38b04 | 2009-12-15 16:46:09 -0800 | [diff] [blame] | 465 | .pm = &wm8350_rtc_pm_ops, |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 466 | }, |
| 467 | }; |
| 468 | |
Axel Lin | 0c4eae6 | 2012-01-10 15:10:48 -0800 | [diff] [blame] | 469 | module_platform_driver(wm8350_rtc_driver); |
Mark Brown | 077eaf5 | 2008-11-12 13:27:04 -0800 | [diff] [blame] | 470 | |
| 471 | MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>"); |
| 472 | MODULE_DESCRIPTION("RTC driver for the WM8350"); |
| 473 | MODULE_LICENSE("GPL"); |
| 474 | MODULE_ALIAS("platform:wm8350-rtc"); |