1 // SPDX-License-Identifier: GPL-2.0+
3 // RTC driver for Maxim MAX77686 and MAX77802
5 // Copyright (C) 2012 Samsung Electronics Co.Ltd
7 // based on rtc-max8997.c
10 #include <linux/slab.h>
11 #include <linux/rtc.h>
12 #include <linux/delay.h>
13 #include <linux/mutex.h>
14 #include <linux/module.h>
15 #include <linux/platform_device.h>
16 #include <linux/mfd/max77686-private.h>
17 #include <linux/irqdomain.h>
18 #include <linux/regmap.h>
20 #define MAX77686_I2C_ADDR_RTC (0x0C >> 1)
21 #define MAX77620_I2C_ADDR_RTC 0x68
22 #define MAX77686_INVALID_I2C_ADDR (-1)
24 /* Define non existing register */
25 #define MAX77686_INVALID_REG (-1)
27 /* RTC Control Register */
28 #define BCD_EN_SHIFT 0
29 #define BCD_EN_MASK BIT(BCD_EN_SHIFT)
30 #define MODEL24_SHIFT 1
31 #define MODEL24_MASK BIT(MODEL24_SHIFT)
32 /* RTC Update Register1 */
33 #define RTC_UDR_SHIFT 0
34 #define RTC_UDR_MASK BIT(RTC_UDR_SHIFT)
35 #define RTC_RBUDR_SHIFT 4
36 #define RTC_RBUDR_MASK BIT(RTC_RBUDR_SHIFT)
37 /* RTC Hour register */
38 #define HOUR_PM_SHIFT 6
39 #define HOUR_PM_MASK BIT(HOUR_PM_SHIFT)
40 /* RTC Alarm Enable */
41 #define ALARM_ENABLE_SHIFT 7
42 #define ALARM_ENABLE_MASK BIT(ALARM_ENABLE_SHIFT)
44 #define REG_RTC_NONE 0xdeadbeef
47 * MAX77802 has separate register (RTCAE1) for alarm enable instead
48 * using 1 bit from registers RTC{SEC,MIN,HOUR,DAY,MONTH,YEAR,DATE}
49 * as in done in MAX77686.
51 #define MAX77802_ALARM_ENABLE_VALUE 0x77
65 * struct max77686_rtc_driver_data - model-specific configuration
66 * @delay: Minimum usecs needed for a RTC update
67 * @mask: Mask used to read RTC registers value
68 * @map: Registers offset to I2C addresses map
69 * @alarm_enable_reg: Has a separate alarm enable register?
70 * @rtc_i2c_addr: I2C address for RTC block
71 * @rtc_irq_from_platform: RTC interrupt via platform resource
72 * @alarm_pending_status_reg: Pending alarm status register
73 * @rtc_irq_chip: RTC IRQ CHIP for regmap
74 * @regmap_config: regmap configuration for the chip
76 struct max77686_rtc_driver_data {
79 const unsigned int *map;
80 bool alarm_enable_reg;
82 bool rtc_irq_from_platform;
83 int alarm_pending_status_reg;
84 const struct regmap_irq_chip *rtc_irq_chip;
85 const struct regmap_config *regmap_config;
88 struct max77686_rtc_info {
90 struct i2c_client *rtc;
91 struct rtc_device *rtc_dev;
94 struct regmap *regmap;
95 struct regmap *rtc_regmap;
97 const struct max77686_rtc_driver_data *drv_data;
98 struct regmap_irq_chip_data *rtc_irq_data;
105 enum MAX77686_RTC_OP {
110 /* These are not registers but just offsets that are mapped to addresses */
111 enum max77686_rtc_reg_offset {
112 REG_RTC_CONTROLM = 0,
141 /* Maps RTC registers offset to the MAX77686 register addresses */
142 static const unsigned int max77686_map[REG_RTC_END] = {
143 [REG_RTC_CONTROLM] = MAX77686_RTC_CONTROLM,
144 [REG_RTC_CONTROL] = MAX77686_RTC_CONTROL,
145 [REG_RTC_UPDATE0] = MAX77686_RTC_UPDATE0,
146 [REG_WTSR_SMPL_CNTL] = MAX77686_WTSR_SMPL_CNTL,
147 [REG_RTC_SEC] = MAX77686_RTC_SEC,
148 [REG_RTC_MIN] = MAX77686_RTC_MIN,
149 [REG_RTC_HOUR] = MAX77686_RTC_HOUR,
150 [REG_RTC_WEEKDAY] = MAX77686_RTC_WEEKDAY,
151 [REG_RTC_MONTH] = MAX77686_RTC_MONTH,
152 [REG_RTC_YEAR] = MAX77686_RTC_YEAR,
153 [REG_RTC_DATE] = MAX77686_RTC_DATE,
154 [REG_ALARM1_SEC] = MAX77686_ALARM1_SEC,
155 [REG_ALARM1_MIN] = MAX77686_ALARM1_MIN,
156 [REG_ALARM1_HOUR] = MAX77686_ALARM1_HOUR,
157 [REG_ALARM1_WEEKDAY] = MAX77686_ALARM1_WEEKDAY,
158 [REG_ALARM1_MONTH] = MAX77686_ALARM1_MONTH,
159 [REG_ALARM1_YEAR] = MAX77686_ALARM1_YEAR,
160 [REG_ALARM1_DATE] = MAX77686_ALARM1_DATE,
161 [REG_ALARM2_SEC] = MAX77686_ALARM2_SEC,
162 [REG_ALARM2_MIN] = MAX77686_ALARM2_MIN,
163 [REG_ALARM2_HOUR] = MAX77686_ALARM2_HOUR,
164 [REG_ALARM2_WEEKDAY] = MAX77686_ALARM2_WEEKDAY,
165 [REG_ALARM2_MONTH] = MAX77686_ALARM2_MONTH,
166 [REG_ALARM2_YEAR] = MAX77686_ALARM2_YEAR,
167 [REG_ALARM2_DATE] = MAX77686_ALARM2_DATE,
168 [REG_RTC_AE1] = REG_RTC_NONE,
171 static const struct regmap_irq max77686_rtc_irqs[] = {
173 REGMAP_IRQ_REG(0, 0, MAX77686_RTCINT_RTC60S_MSK),
174 REGMAP_IRQ_REG(1, 0, MAX77686_RTCINT_RTCA1_MSK),
175 REGMAP_IRQ_REG(2, 0, MAX77686_RTCINT_RTCA2_MSK),
176 REGMAP_IRQ_REG(3, 0, MAX77686_RTCINT_SMPL_MSK),
177 REGMAP_IRQ_REG(4, 0, MAX77686_RTCINT_RTC1S_MSK),
178 REGMAP_IRQ_REG(5, 0, MAX77686_RTCINT_WTSR_MSK),
181 static const struct regmap_irq_chip max77686_rtc_irq_chip = {
182 .name = "max77686-rtc",
183 .status_base = MAX77686_RTC_INT,
184 .mask_base = MAX77686_RTC_INTM,
186 .irqs = max77686_rtc_irqs,
187 .num_irqs = ARRAY_SIZE(max77686_rtc_irqs),
190 static const struct regmap_config max77686_rtc_regmap_config = {
195 static const struct max77686_rtc_driver_data max77686_drv_data = {
199 .alarm_enable_reg = false,
200 .rtc_irq_from_platform = false,
201 .alarm_pending_status_reg = MAX77686_REG_STATUS2,
202 .rtc_i2c_addr = MAX77686_I2C_ADDR_RTC,
203 .rtc_irq_chip = &max77686_rtc_irq_chip,
204 .regmap_config = &max77686_rtc_regmap_config,
207 static const struct regmap_config max77620_rtc_regmap_config = {
210 .use_single_write = true,
213 static const struct max77686_rtc_driver_data max77620_drv_data = {
217 .alarm_enable_reg = false,
218 .rtc_irq_from_platform = true,
219 .alarm_pending_status_reg = MAX77686_INVALID_REG,
220 .rtc_i2c_addr = MAX77620_I2C_ADDR_RTC,
221 .rtc_irq_chip = &max77686_rtc_irq_chip,
222 .regmap_config = &max77620_rtc_regmap_config,
225 static const unsigned int max77802_map[REG_RTC_END] = {
226 [REG_RTC_CONTROLM] = MAX77802_RTC_CONTROLM,
227 [REG_RTC_CONTROL] = MAX77802_RTC_CONTROL,
228 [REG_RTC_UPDATE0] = MAX77802_RTC_UPDATE0,
229 [REG_WTSR_SMPL_CNTL] = MAX77802_WTSR_SMPL_CNTL,
230 [REG_RTC_SEC] = MAX77802_RTC_SEC,
231 [REG_RTC_MIN] = MAX77802_RTC_MIN,
232 [REG_RTC_HOUR] = MAX77802_RTC_HOUR,
233 [REG_RTC_WEEKDAY] = MAX77802_RTC_WEEKDAY,
234 [REG_RTC_MONTH] = MAX77802_RTC_MONTH,
235 [REG_RTC_YEAR] = MAX77802_RTC_YEAR,
236 [REG_RTC_DATE] = MAX77802_RTC_DATE,
237 [REG_ALARM1_SEC] = MAX77802_ALARM1_SEC,
238 [REG_ALARM1_MIN] = MAX77802_ALARM1_MIN,
239 [REG_ALARM1_HOUR] = MAX77802_ALARM1_HOUR,
240 [REG_ALARM1_WEEKDAY] = MAX77802_ALARM1_WEEKDAY,
241 [REG_ALARM1_MONTH] = MAX77802_ALARM1_MONTH,
242 [REG_ALARM1_YEAR] = MAX77802_ALARM1_YEAR,
243 [REG_ALARM1_DATE] = MAX77802_ALARM1_DATE,
244 [REG_ALARM2_SEC] = MAX77802_ALARM2_SEC,
245 [REG_ALARM2_MIN] = MAX77802_ALARM2_MIN,
246 [REG_ALARM2_HOUR] = MAX77802_ALARM2_HOUR,
247 [REG_ALARM2_WEEKDAY] = MAX77802_ALARM2_WEEKDAY,
248 [REG_ALARM2_MONTH] = MAX77802_ALARM2_MONTH,
249 [REG_ALARM2_YEAR] = MAX77802_ALARM2_YEAR,
250 [REG_ALARM2_DATE] = MAX77802_ALARM2_DATE,
251 [REG_RTC_AE1] = MAX77802_RTC_AE1,
254 static const struct regmap_irq_chip max77802_rtc_irq_chip = {
255 .name = "max77802-rtc",
256 .status_base = MAX77802_RTC_INT,
257 .mask_base = MAX77802_RTC_INTM,
259 .irqs = max77686_rtc_irqs, /* same masks as 77686 */
260 .num_irqs = ARRAY_SIZE(max77686_rtc_irqs),
263 static const struct max77686_rtc_driver_data max77802_drv_data = {
267 .alarm_enable_reg = true,
268 .rtc_irq_from_platform = false,
269 .alarm_pending_status_reg = MAX77686_REG_STATUS2,
270 .rtc_i2c_addr = MAX77686_INVALID_I2C_ADDR,
271 .rtc_irq_chip = &max77802_rtc_irq_chip,
274 static void max77686_rtc_data_to_tm(u8 *data, struct rtc_time *tm,
275 struct max77686_rtc_info *info)
277 u8 mask = info->drv_data->mask;
279 tm->tm_sec = data[RTC_SEC] & mask;
280 tm->tm_min = data[RTC_MIN] & mask;
281 if (info->rtc_24hr_mode) {
282 tm->tm_hour = data[RTC_HOUR] & 0x1f;
284 tm->tm_hour = data[RTC_HOUR] & 0x0f;
285 if (data[RTC_HOUR] & HOUR_PM_MASK)
289 /* Only a single bit is set in data[], so fls() would be equivalent */
290 tm->tm_wday = ffs(data[RTC_WEEKDAY] & mask) - 1;
291 tm->tm_mday = data[RTC_DATE] & 0x1f;
292 tm->tm_mon = (data[RTC_MONTH] & 0x0f) - 1;
293 tm->tm_year = data[RTC_YEAR] & mask;
298 * MAX77686 uses 1 bit from sec/min/hour/etc RTC registers and the
299 * year values are just 0..99 so add 100 to support up to 2099.
301 if (!info->drv_data->alarm_enable_reg)
305 static int max77686_rtc_tm_to_data(struct rtc_time *tm, u8 *data,
306 struct max77686_rtc_info *info)
308 data[RTC_SEC] = tm->tm_sec;
309 data[RTC_MIN] = tm->tm_min;
310 data[RTC_HOUR] = tm->tm_hour;
311 data[RTC_WEEKDAY] = 1 << tm->tm_wday;
312 data[RTC_DATE] = tm->tm_mday;
313 data[RTC_MONTH] = tm->tm_mon + 1;
315 if (info->drv_data->alarm_enable_reg) {
316 data[RTC_YEAR] = tm->tm_year;
320 data[RTC_YEAR] = tm->tm_year > 100 ? (tm->tm_year - 100) : 0;
322 if (tm->tm_year < 100) {
323 dev_err(info->dev, "RTC cannot handle the year %d.\n",
331 static int max77686_rtc_update(struct max77686_rtc_info *info,
332 enum MAX77686_RTC_OP op)
336 unsigned long delay = info->drv_data->delay;
338 if (op == MAX77686_RTC_WRITE)
339 data = 1 << RTC_UDR_SHIFT;
341 data = 1 << RTC_RBUDR_SHIFT;
343 ret = regmap_update_bits(info->rtc_regmap,
344 info->drv_data->map[REG_RTC_UPDATE0],
347 dev_err(info->dev, "Fail to write update reg(ret=%d, data=0x%x)\n",
350 /* Minimum delay required before RTC update. */
351 usleep_range(delay, delay * 2);
357 static int max77686_rtc_read_time(struct device *dev, struct rtc_time *tm)
359 struct max77686_rtc_info *info = dev_get_drvdata(dev);
360 u8 data[RTC_NR_TIME];
363 mutex_lock(&info->lock);
365 ret = max77686_rtc_update(info, MAX77686_RTC_READ);
369 ret = regmap_bulk_read(info->rtc_regmap,
370 info->drv_data->map[REG_RTC_SEC],
371 data, ARRAY_SIZE(data));
373 dev_err(info->dev, "Fail to read time reg(%d)\n", ret);
377 max77686_rtc_data_to_tm(data, tm, info);
380 mutex_unlock(&info->lock);
384 static int max77686_rtc_set_time(struct device *dev, struct rtc_time *tm)
386 struct max77686_rtc_info *info = dev_get_drvdata(dev);
387 u8 data[RTC_NR_TIME];
390 ret = max77686_rtc_tm_to_data(tm, data, info);
394 mutex_lock(&info->lock);
396 ret = regmap_bulk_write(info->rtc_regmap,
397 info->drv_data->map[REG_RTC_SEC],
398 data, ARRAY_SIZE(data));
400 dev_err(info->dev, "Fail to write time reg(%d)\n", ret);
404 ret = max77686_rtc_update(info, MAX77686_RTC_WRITE);
407 mutex_unlock(&info->lock);
411 static int max77686_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
413 struct max77686_rtc_info *info = dev_get_drvdata(dev);
414 u8 data[RTC_NR_TIME];
416 const unsigned int *map = info->drv_data->map;
419 mutex_lock(&info->lock);
421 ret = max77686_rtc_update(info, MAX77686_RTC_READ);
425 ret = regmap_bulk_read(info->rtc_regmap, map[REG_ALARM1_SEC],
426 data, ARRAY_SIZE(data));
428 dev_err(info->dev, "Fail to read alarm reg(%d)\n", ret);
432 max77686_rtc_data_to_tm(data, &alrm->time, info);
436 if (info->drv_data->alarm_enable_reg) {
437 if (map[REG_RTC_AE1] == REG_RTC_NONE) {
440 "alarm enable register not set(%d)\n", ret);
444 ret = regmap_read(info->rtc_regmap, map[REG_RTC_AE1], &val);
447 "fail to read alarm enable(%d)\n", ret);
454 for (i = 0; i < ARRAY_SIZE(data); i++) {
455 if (data[i] & ALARM_ENABLE_MASK) {
464 if (info->drv_data->alarm_pending_status_reg == MAX77686_INVALID_REG)
467 ret = regmap_read(info->regmap,
468 info->drv_data->alarm_pending_status_reg, &val);
471 "Fail to read alarm pending status reg(%d)\n", ret);
475 if (val & (1 << 4)) /* RTCA1 */
479 mutex_unlock(&info->lock);
483 static int max77686_rtc_stop_alarm(struct max77686_rtc_info *info)
485 u8 data[RTC_NR_TIME];
488 const unsigned int *map = info->drv_data->map;
490 if (!mutex_is_locked(&info->lock))
491 dev_warn(info->dev, "%s: should have mutex locked\n", __func__);
493 ret = max77686_rtc_update(info, MAX77686_RTC_READ);
497 if (info->drv_data->alarm_enable_reg) {
498 if (map[REG_RTC_AE1] == REG_RTC_NONE) {
501 "alarm enable register not set(%d)\n", ret);
505 ret = regmap_write(info->rtc_regmap, map[REG_RTC_AE1], 0);
507 ret = regmap_bulk_read(info->rtc_regmap, map[REG_ALARM1_SEC],
508 data, ARRAY_SIZE(data));
510 dev_err(info->dev, "Fail to read alarm reg(%d)\n", ret);
514 max77686_rtc_data_to_tm(data, &tm, info);
516 for (i = 0; i < ARRAY_SIZE(data); i++)
517 data[i] &= ~ALARM_ENABLE_MASK;
519 ret = regmap_bulk_write(info->rtc_regmap, map[REG_ALARM1_SEC],
520 data, ARRAY_SIZE(data));
524 dev_err(info->dev, "Fail to write alarm reg(%d)\n", ret);
528 ret = max77686_rtc_update(info, MAX77686_RTC_WRITE);
533 static int max77686_rtc_start_alarm(struct max77686_rtc_info *info)
535 u8 data[RTC_NR_TIME];
538 const unsigned int *map = info->drv_data->map;
540 if (!mutex_is_locked(&info->lock))
541 dev_warn(info->dev, "%s: should have mutex locked\n", __func__);
543 ret = max77686_rtc_update(info, MAX77686_RTC_READ);
547 if (info->drv_data->alarm_enable_reg) {
548 ret = regmap_write(info->rtc_regmap, map[REG_RTC_AE1],
549 MAX77802_ALARM_ENABLE_VALUE);
551 ret = regmap_bulk_read(info->rtc_regmap, map[REG_ALARM1_SEC],
552 data, ARRAY_SIZE(data));
554 dev_err(info->dev, "Fail to read alarm reg(%d)\n", ret);
558 max77686_rtc_data_to_tm(data, &tm, info);
560 data[RTC_SEC] |= (1 << ALARM_ENABLE_SHIFT);
561 data[RTC_MIN] |= (1 << ALARM_ENABLE_SHIFT);
562 data[RTC_HOUR] |= (1 << ALARM_ENABLE_SHIFT);
563 data[RTC_WEEKDAY] &= ~ALARM_ENABLE_MASK;
564 if (data[RTC_MONTH] & 0xf)
565 data[RTC_MONTH] |= (1 << ALARM_ENABLE_SHIFT);
566 if (data[RTC_YEAR] & info->drv_data->mask)
567 data[RTC_YEAR] |= (1 << ALARM_ENABLE_SHIFT);
568 if (data[RTC_DATE] & 0x1f)
569 data[RTC_DATE] |= (1 << ALARM_ENABLE_SHIFT);
571 ret = regmap_bulk_write(info->rtc_regmap, map[REG_ALARM1_SEC],
572 data, ARRAY_SIZE(data));
576 dev_err(info->dev, "Fail to write alarm reg(%d)\n", ret);
580 ret = max77686_rtc_update(info, MAX77686_RTC_WRITE);
585 static int max77686_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
587 struct max77686_rtc_info *info = dev_get_drvdata(dev);
588 u8 data[RTC_NR_TIME];
591 ret = max77686_rtc_tm_to_data(&alrm->time, data, info);
595 mutex_lock(&info->lock);
597 ret = max77686_rtc_stop_alarm(info);
601 ret = regmap_bulk_write(info->rtc_regmap,
602 info->drv_data->map[REG_ALARM1_SEC],
603 data, ARRAY_SIZE(data));
606 dev_err(info->dev, "Fail to write alarm reg(%d)\n", ret);
610 ret = max77686_rtc_update(info, MAX77686_RTC_WRITE);
615 ret = max77686_rtc_start_alarm(info);
617 mutex_unlock(&info->lock);
621 static int max77686_rtc_alarm_irq_enable(struct device *dev,
622 unsigned int enabled)
624 struct max77686_rtc_info *info = dev_get_drvdata(dev);
627 mutex_lock(&info->lock);
629 ret = max77686_rtc_start_alarm(info);
631 ret = max77686_rtc_stop_alarm(info);
632 mutex_unlock(&info->lock);
637 static irqreturn_t max77686_rtc_alarm_irq(int irq, void *data)
639 struct max77686_rtc_info *info = data;
641 dev_dbg(info->dev, "RTC alarm IRQ: %d\n", irq);
643 rtc_update_irq(info->rtc_dev, 1, RTC_IRQF | RTC_AF);
648 static const struct rtc_class_ops max77686_rtc_ops = {
649 .read_time = max77686_rtc_read_time,
650 .set_time = max77686_rtc_set_time,
651 .read_alarm = max77686_rtc_read_alarm,
652 .set_alarm = max77686_rtc_set_alarm,
653 .alarm_irq_enable = max77686_rtc_alarm_irq_enable,
656 static int max77686_rtc_init_reg(struct max77686_rtc_info *info)
661 /* Set RTC control register : Binary mode, 24hour mdoe */
662 data[0] = (1 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
663 data[1] = (0 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
665 info->rtc_24hr_mode = 1;
667 ret = regmap_bulk_write(info->rtc_regmap,
668 info->drv_data->map[REG_RTC_CONTROLM],
669 data, ARRAY_SIZE(data));
671 dev_err(info->dev, "Fail to write controlm reg(%d)\n", ret);
675 ret = max77686_rtc_update(info, MAX77686_RTC_WRITE);
679 static int max77686_init_rtc_regmap(struct max77686_rtc_info *info)
681 struct device *parent = info->dev->parent;
682 struct i2c_client *parent_i2c = to_i2c_client(parent);
685 if (info->drv_data->rtc_irq_from_platform) {
686 struct platform_device *pdev = to_platform_device(info->dev);
688 info->rtc_irq = platform_get_irq(pdev, 0);
689 if (info->rtc_irq < 0)
690 return info->rtc_irq;
692 info->rtc_irq = parent_i2c->irq;
695 info->regmap = dev_get_regmap(parent, NULL);
697 dev_err(info->dev, "Failed to get rtc regmap\n");
701 if (info->drv_data->rtc_i2c_addr == MAX77686_INVALID_I2C_ADDR) {
702 info->rtc_regmap = info->regmap;
706 info->rtc = devm_i2c_new_dummy_device(info->dev, parent_i2c->adapter,
707 info->drv_data->rtc_i2c_addr);
708 if (IS_ERR(info->rtc)) {
709 dev_err(info->dev, "Failed to allocate I2C device for RTC\n");
710 return PTR_ERR(info->rtc);
713 info->rtc_regmap = devm_regmap_init_i2c(info->rtc,
714 info->drv_data->regmap_config);
715 if (IS_ERR(info->rtc_regmap)) {
716 ret = PTR_ERR(info->rtc_regmap);
717 dev_err(info->dev, "Failed to allocate RTC regmap: %d\n", ret);
722 ret = regmap_add_irq_chip(info->rtc_regmap, info->rtc_irq,
723 IRQF_ONESHOT | IRQF_SHARED,
724 0, info->drv_data->rtc_irq_chip,
725 &info->rtc_irq_data);
727 dev_err(info->dev, "Failed to add RTC irq chip: %d\n", ret);
734 static int max77686_rtc_probe(struct platform_device *pdev)
736 struct max77686_rtc_info *info;
737 const struct platform_device_id *id = platform_get_device_id(pdev);
740 info = devm_kzalloc(&pdev->dev, sizeof(struct max77686_rtc_info),
745 mutex_init(&info->lock);
746 info->dev = &pdev->dev;
747 info->drv_data = (const struct max77686_rtc_driver_data *)
750 ret = max77686_init_rtc_regmap(info);
754 platform_set_drvdata(pdev, info);
756 ret = max77686_rtc_init_reg(info);
758 dev_err(&pdev->dev, "Failed to initialize RTC reg:%d\n", ret);
762 device_init_wakeup(&pdev->dev, 1);
764 info->rtc_dev = devm_rtc_device_register(&pdev->dev, id->name,
765 &max77686_rtc_ops, THIS_MODULE);
767 if (IS_ERR(info->rtc_dev)) {
768 ret = PTR_ERR(info->rtc_dev);
769 dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
775 info->virq = regmap_irq_get_virq(info->rtc_irq_data,
776 MAX77686_RTCIRQ_RTCA1);
777 if (info->virq <= 0) {
782 ret = request_threaded_irq(info->virq, NULL, max77686_rtc_alarm_irq, 0,
785 dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
793 regmap_del_irq_chip(info->rtc_irq, info->rtc_irq_data);
798 static int max77686_rtc_remove(struct platform_device *pdev)
800 struct max77686_rtc_info *info = platform_get_drvdata(pdev);
802 free_irq(info->virq, info);
803 regmap_del_irq_chip(info->rtc_irq, info->rtc_irq_data);
808 #ifdef CONFIG_PM_SLEEP
809 static int max77686_rtc_suspend(struct device *dev)
811 struct max77686_rtc_info *info = dev_get_drvdata(dev);
814 if (device_may_wakeup(dev)) {
815 struct max77686_rtc_info *info = dev_get_drvdata(dev);
817 ret = enable_irq_wake(info->virq);
821 * If the main IRQ (not virtual) is the parent IRQ, then it must be
822 * disabled during suspend because if it happens while suspended it
823 * will be handled before resuming I2C.
825 * Since Main IRQ is shared, all its users should disable it to be sure
826 * it won't fire while one of them is still suspended.
828 if (!info->drv_data->rtc_irq_from_platform)
829 disable_irq(info->rtc_irq);
834 static int max77686_rtc_resume(struct device *dev)
836 struct max77686_rtc_info *info = dev_get_drvdata(dev);
838 if (!info->drv_data->rtc_irq_from_platform)
839 enable_irq(info->rtc_irq);
841 if (device_may_wakeup(dev)) {
842 struct max77686_rtc_info *info = dev_get_drvdata(dev);
844 return disable_irq_wake(info->virq);
851 static SIMPLE_DEV_PM_OPS(max77686_rtc_pm_ops,
852 max77686_rtc_suspend, max77686_rtc_resume);
854 static const struct platform_device_id rtc_id[] = {
855 { "max77686-rtc", .driver_data = (kernel_ulong_t)&max77686_drv_data, },
856 { "max77802-rtc", .driver_data = (kernel_ulong_t)&max77802_drv_data, },
857 { "max77620-rtc", .driver_data = (kernel_ulong_t)&max77620_drv_data, },
860 MODULE_DEVICE_TABLE(platform, rtc_id);
862 static struct platform_driver max77686_rtc_driver = {
864 .name = "max77686-rtc",
865 .pm = &max77686_rtc_pm_ops,
867 .probe = max77686_rtc_probe,
868 .remove = max77686_rtc_remove,
872 module_platform_driver(max77686_rtc_driver);
874 MODULE_DESCRIPTION("Maxim MAX77686 RTC driver");
875 MODULE_AUTHOR("Chiwoong Byun <woong.byun@samsung.com>");
876 MODULE_LICENSE("GPL");