2 * Copyright (c) 2013-2014 Samsung Electronics Co., Ltd
3 * http://www.samsung.com
5 * Copyright (C) 2013 Google, Inc
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
18 #include <linux/module.h>
19 #include <linux/i2c.h>
20 #include <linux/bcd.h>
21 #include <linux/regmap.h>
22 #include <linux/rtc.h>
23 #include <linux/platform_device.h>
24 #include <linux/mfd/samsung/core.h>
25 #include <linux/mfd/samsung/irq.h>
26 #include <linux/mfd/samsung/rtc.h>
27 #include <linux/mfd/samsung/s2mps14.h>
30 * Maximum number of retries for checking changes in UDR field
31 * of S5M_RTC_UDR_CON register (to limit possible endless loop).
33 * After writing to RTC registers (setting time or alarm) read the UDR field
34 * in S5M_RTC_UDR_CON register. UDR is auto-cleared when data have
37 #define UDR_READ_RETRY_CNT 5
39 /* Registers used by the driver which are different between chipsets. */
40 struct s5m_rtc_reg_config
{
41 /* Number of registers used for setting time/alarm0/alarm1 */
42 unsigned int regs_count
;
43 /* First register for time, seconds */
45 /* RTC control register */
47 /* First register for alarm 0, seconds */
49 /* First register for alarm 1, seconds */
52 * Register for update flag (UDR). Typically setting UDR field to 1
53 * will enable update of time or alarm register. Then it will be
54 * auto-cleared after successful update.
56 unsigned int rtc_udr_update
;
57 /* Mask for UDR field in 'rtc_udr_update' register */
58 unsigned int rtc_udr_mask
;
61 /* Register map for S5M8763 and S5M8767 */
62 static const struct s5m_rtc_reg_config s5m_rtc_regs
= {
65 .ctrl
= S5M_ALARM1_CONF
,
66 .alarm0
= S5M_ALARM0_SEC
,
67 .alarm1
= S5M_ALARM1_SEC
,
68 .rtc_udr_update
= S5M_RTC_UDR_CON
,
69 .rtc_udr_mask
= S5M_RTC_UDR_MASK
,
73 * Register map for S2MPS14.
74 * It may be also suitable for S2MPS11 but this was not tested.
76 static const struct s5m_rtc_reg_config s2mps_rtc_regs
= {
78 .time
= S2MPS_RTC_SEC
,
79 .ctrl
= S2MPS_RTC_CTRL
,
80 .alarm0
= S2MPS_ALARM0_SEC
,
81 .alarm1
= S2MPS_ALARM1_SEC
,
82 .rtc_udr_update
= S2MPS_RTC_UDR_CON
,
83 .rtc_udr_mask
= S2MPS_RTC_WUDR_MASK
,
88 struct i2c_client
*i2c
;
89 struct sec_pmic_dev
*s5m87xx
;
90 struct regmap
*regmap
;
91 struct rtc_device
*rtc_dev
;
95 const struct s5m_rtc_reg_config
*regs
;
98 static const struct regmap_config s5m_rtc_regmap_config
= {
102 .max_register
= S5M_RTC_REG_MAX
,
105 static const struct regmap_config s2mps14_rtc_regmap_config
= {
109 .max_register
= S2MPS_RTC_REG_MAX
,
112 static void s5m8767_data_to_tm(u8
*data
, struct rtc_time
*tm
,
115 tm
->tm_sec
= data
[RTC_SEC
] & 0x7f;
116 tm
->tm_min
= data
[RTC_MIN
] & 0x7f;
118 tm
->tm_hour
= data
[RTC_HOUR
] & 0x1f;
120 tm
->tm_hour
= data
[RTC_HOUR
] & 0x0f;
121 if (data
[RTC_HOUR
] & HOUR_PM_MASK
)
125 tm
->tm_wday
= ffs(data
[RTC_WEEKDAY
] & 0x7f);
126 tm
->tm_mday
= data
[RTC_DATE
] & 0x1f;
127 tm
->tm_mon
= (data
[RTC_MONTH
] & 0x0f) - 1;
128 tm
->tm_year
= (data
[RTC_YEAR1
] & 0x7f) + 100;
133 static int s5m8767_tm_to_data(struct rtc_time
*tm
, u8
*data
)
135 data
[RTC_SEC
] = tm
->tm_sec
;
136 data
[RTC_MIN
] = tm
->tm_min
;
138 if (tm
->tm_hour
>= 12)
139 data
[RTC_HOUR
] = tm
->tm_hour
| HOUR_PM_MASK
;
141 data
[RTC_HOUR
] = tm
->tm_hour
& ~HOUR_PM_MASK
;
143 data
[RTC_WEEKDAY
] = 1 << tm
->tm_wday
;
144 data
[RTC_DATE
] = tm
->tm_mday
;
145 data
[RTC_MONTH
] = tm
->tm_mon
+ 1;
146 data
[RTC_YEAR1
] = tm
->tm_year
> 100 ? (tm
->tm_year
- 100) : 0;
148 if (tm
->tm_year
< 100) {
149 pr_err("s5m8767 RTC cannot handle the year %d.\n",
158 * Read RTC_UDR_CON register and wait till UDR field is cleared.
159 * This indicates that time/alarm update ended.
161 static inline int s5m8767_wait_for_udr_update(struct s5m_rtc_info
*info
)
163 int ret
, retry
= UDR_READ_RETRY_CNT
;
167 ret
= regmap_read(info
->regmap
, info
->regs
->rtc_udr_update
,
169 } while (--retry
&& (data
& info
->regs
->rtc_udr_mask
) && !ret
);
172 dev_err(info
->dev
, "waiting for UDR update, reached max number of retries\n");
177 static inline int s5m_check_peding_alarm_interrupt(struct s5m_rtc_info
*info
,
178 struct rtc_wkalrm
*alarm
)
183 switch (info
->device_type
) {
186 ret
= regmap_read(info
->regmap
, S5M_RTC_STATUS
, &val
);
187 val
&= S5M_ALARM0_STATUS
;
190 ret
= regmap_read(info
->s5m87xx
->regmap_pmic
, S2MPS14_REG_ST2
,
192 val
&= S2MPS_ALARM0_STATUS
;
208 static inline int s5m8767_rtc_set_time_reg(struct s5m_rtc_info
*info
)
213 ret
= regmap_read(info
->regmap
, info
->regs
->rtc_udr_update
, &data
);
215 dev_err(info
->dev
, "failed to read update reg(%d)\n", ret
);
219 data
|= info
->regs
->rtc_udr_mask
;
220 if (info
->device_type
== S5M8763X
|| info
->device_type
== S5M8767X
)
221 data
|= S5M_RTC_TIME_EN_MASK
;
223 ret
= regmap_write(info
->regmap
, info
->regs
->rtc_udr_update
, data
);
225 dev_err(info
->dev
, "failed to write update reg(%d)\n", ret
);
229 ret
= s5m8767_wait_for_udr_update(info
);
234 static inline int s5m8767_rtc_set_alarm_reg(struct s5m_rtc_info
*info
)
239 ret
= regmap_read(info
->regmap
, info
->regs
->rtc_udr_update
, &data
);
241 dev_err(info
->dev
, "%s: fail to read update reg(%d)\n",
246 data
|= info
->regs
->rtc_udr_mask
;
247 switch (info
->device_type
) {
250 data
&= ~S5M_RTC_TIME_EN_MASK
;
253 data
|= S2MPS_RTC_RUDR_MASK
;
259 ret
= regmap_write(info
->regmap
, info
->regs
->rtc_udr_update
, data
);
261 dev_err(info
->dev
, "%s: fail to write update reg(%d)\n",
266 ret
= s5m8767_wait_for_udr_update(info
);
271 static void s5m8763_data_to_tm(u8
*data
, struct rtc_time
*tm
)
273 tm
->tm_sec
= bcd2bin(data
[RTC_SEC
]);
274 tm
->tm_min
= bcd2bin(data
[RTC_MIN
]);
276 if (data
[RTC_HOUR
] & HOUR_12
) {
277 tm
->tm_hour
= bcd2bin(data
[RTC_HOUR
] & 0x1f);
278 if (data
[RTC_HOUR
] & HOUR_PM
)
281 tm
->tm_hour
= bcd2bin(data
[RTC_HOUR
] & 0x3f);
284 tm
->tm_wday
= data
[RTC_WEEKDAY
] & 0x07;
285 tm
->tm_mday
= bcd2bin(data
[RTC_DATE
]);
286 tm
->tm_mon
= bcd2bin(data
[RTC_MONTH
]);
287 tm
->tm_year
= bcd2bin(data
[RTC_YEAR1
]) + bcd2bin(data
[RTC_YEAR2
]) * 100;
291 static void s5m8763_tm_to_data(struct rtc_time
*tm
, u8
*data
)
293 data
[RTC_SEC
] = bin2bcd(tm
->tm_sec
);
294 data
[RTC_MIN
] = bin2bcd(tm
->tm_min
);
295 data
[RTC_HOUR
] = bin2bcd(tm
->tm_hour
);
296 data
[RTC_WEEKDAY
] = tm
->tm_wday
;
297 data
[RTC_DATE
] = bin2bcd(tm
->tm_mday
);
298 data
[RTC_MONTH
] = bin2bcd(tm
->tm_mon
);
299 data
[RTC_YEAR1
] = bin2bcd(tm
->tm_year
% 100);
300 data
[RTC_YEAR2
] = bin2bcd((tm
->tm_year
+ 1900) / 100);
303 static int s5m_rtc_read_time(struct device
*dev
, struct rtc_time
*tm
)
305 struct s5m_rtc_info
*info
= dev_get_drvdata(dev
);
306 u8 data
[info
->regs
->regs_count
];
309 if (info
->device_type
== S2MPS14X
) {
310 ret
= regmap_update_bits(info
->regmap
,
311 info
->regs
->rtc_udr_update
,
312 S2MPS_RTC_RUDR_MASK
, S2MPS_RTC_RUDR_MASK
);
315 "Failed to prepare registers for time reading: %d\n",
320 ret
= regmap_bulk_read(info
->regmap
, info
->regs
->time
, data
,
321 info
->regs
->regs_count
);
325 switch (info
->device_type
) {
327 s5m8763_data_to_tm(data
, tm
);
332 s5m8767_data_to_tm(data
, tm
, info
->rtc_24hr_mode
);
339 dev_dbg(dev
, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__
,
340 1900 + tm
->tm_year
, 1 + tm
->tm_mon
, tm
->tm_mday
,
341 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
, tm
->tm_wday
);
343 return rtc_valid_tm(tm
);
346 static int s5m_rtc_set_time(struct device
*dev
, struct rtc_time
*tm
)
348 struct s5m_rtc_info
*info
= dev_get_drvdata(dev
);
349 u8 data
[info
->regs
->regs_count
];
352 switch (info
->device_type
) {
354 s5m8763_tm_to_data(tm
, data
);
358 ret
= s5m8767_tm_to_data(tm
, data
);
367 dev_dbg(dev
, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__
,
368 1900 + tm
->tm_year
, 1 + tm
->tm_mon
, tm
->tm_mday
,
369 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
, tm
->tm_wday
);
371 ret
= regmap_raw_write(info
->regmap
, info
->regs
->time
, data
,
372 info
->regs
->regs_count
);
376 ret
= s5m8767_rtc_set_time_reg(info
);
381 static int s5m_rtc_read_alarm(struct device
*dev
, struct rtc_wkalrm
*alrm
)
383 struct s5m_rtc_info
*info
= dev_get_drvdata(dev
);
384 u8 data
[info
->regs
->regs_count
];
388 ret
= regmap_bulk_read(info
->regmap
, info
->regs
->alarm0
, data
,
389 info
->regs
->regs_count
);
393 switch (info
->device_type
) {
395 s5m8763_data_to_tm(data
, &alrm
->time
);
396 ret
= regmap_read(info
->regmap
, S5M_ALARM0_CONF
, &val
);
400 alrm
->enabled
= !!val
;
405 s5m8767_data_to_tm(data
, &alrm
->time
, info
->rtc_24hr_mode
);
407 for (i
= 0; i
< info
->regs
->regs_count
; i
++) {
408 if (data
[i
] & ALARM_ENABLE_MASK
) {
419 dev_dbg(dev
, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__
,
420 1900 + alrm
->time
.tm_year
, 1 + alrm
->time
.tm_mon
,
421 alrm
->time
.tm_mday
, alrm
->time
.tm_hour
,
422 alrm
->time
.tm_min
, alrm
->time
.tm_sec
,
425 ret
= s5m_check_peding_alarm_interrupt(info
, alrm
);
430 static int s5m_rtc_stop_alarm(struct s5m_rtc_info
*info
)
432 u8 data
[info
->regs
->regs_count
];
436 ret
= regmap_bulk_read(info
->regmap
, info
->regs
->alarm0
, data
,
437 info
->regs
->regs_count
);
441 s5m8767_data_to_tm(data
, &tm
, info
->rtc_24hr_mode
);
442 dev_dbg(info
->dev
, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__
,
443 1900 + tm
.tm_year
, 1 + tm
.tm_mon
, tm
.tm_mday
,
444 tm
.tm_hour
, tm
.tm_min
, tm
.tm_sec
, tm
.tm_wday
);
446 switch (info
->device_type
) {
448 ret
= regmap_write(info
->regmap
, S5M_ALARM0_CONF
, 0);
453 for (i
= 0; i
< info
->regs
->regs_count
; i
++)
454 data
[i
] &= ~ALARM_ENABLE_MASK
;
456 ret
= regmap_raw_write(info
->regmap
, info
->regs
->alarm0
, data
,
457 info
->regs
->regs_count
);
461 ret
= s5m8767_rtc_set_alarm_reg(info
);
472 static int s5m_rtc_start_alarm(struct s5m_rtc_info
*info
)
475 u8 data
[info
->regs
->regs_count
];
479 ret
= regmap_bulk_read(info
->regmap
, info
->regs
->alarm0
, data
,
480 info
->regs
->regs_count
);
484 s5m8767_data_to_tm(data
, &tm
, info
->rtc_24hr_mode
);
485 dev_dbg(info
->dev
, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__
,
486 1900 + tm
.tm_year
, 1 + tm
.tm_mon
, tm
.tm_mday
,
487 tm
.tm_hour
, tm
.tm_min
, tm
.tm_sec
, tm
.tm_wday
);
489 switch (info
->device_type
) {
492 ret
= regmap_write(info
->regmap
, S5M_ALARM0_CONF
, alarm0_conf
);
497 data
[RTC_SEC
] |= ALARM_ENABLE_MASK
;
498 data
[RTC_MIN
] |= ALARM_ENABLE_MASK
;
499 data
[RTC_HOUR
] |= ALARM_ENABLE_MASK
;
500 data
[RTC_WEEKDAY
] &= ~ALARM_ENABLE_MASK
;
501 if (data
[RTC_DATE
] & 0x1f)
502 data
[RTC_DATE
] |= ALARM_ENABLE_MASK
;
503 if (data
[RTC_MONTH
] & 0xf)
504 data
[RTC_MONTH
] |= ALARM_ENABLE_MASK
;
505 if (data
[RTC_YEAR1
] & 0x7f)
506 data
[RTC_YEAR1
] |= ALARM_ENABLE_MASK
;
508 ret
= regmap_raw_write(info
->regmap
, info
->regs
->alarm0
, data
,
509 info
->regs
->regs_count
);
512 ret
= s5m8767_rtc_set_alarm_reg(info
);
523 static int s5m_rtc_set_alarm(struct device
*dev
, struct rtc_wkalrm
*alrm
)
525 struct s5m_rtc_info
*info
= dev_get_drvdata(dev
);
526 u8 data
[info
->regs
->regs_count
];
529 switch (info
->device_type
) {
531 s5m8763_tm_to_data(&alrm
->time
, data
);
536 s5m8767_tm_to_data(&alrm
->time
, data
);
543 dev_dbg(dev
, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__
,
544 1900 + alrm
->time
.tm_year
, 1 + alrm
->time
.tm_mon
,
545 alrm
->time
.tm_mday
, alrm
->time
.tm_hour
, alrm
->time
.tm_min
,
546 alrm
->time
.tm_sec
, alrm
->time
.tm_wday
);
548 ret
= s5m_rtc_stop_alarm(info
);
552 ret
= regmap_raw_write(info
->regmap
, info
->regs
->alarm0
, data
,
553 info
->regs
->regs_count
);
557 ret
= s5m8767_rtc_set_alarm_reg(info
);
562 ret
= s5m_rtc_start_alarm(info
);
567 static int s5m_rtc_alarm_irq_enable(struct device
*dev
,
568 unsigned int enabled
)
570 struct s5m_rtc_info
*info
= dev_get_drvdata(dev
);
573 return s5m_rtc_start_alarm(info
);
575 return s5m_rtc_stop_alarm(info
);
578 static irqreturn_t
s5m_rtc_alarm_irq(int irq
, void *data
)
580 struct s5m_rtc_info
*info
= data
;
582 rtc_update_irq(info
->rtc_dev
, 1, RTC_IRQF
| RTC_AF
);
587 static const struct rtc_class_ops s5m_rtc_ops
= {
588 .read_time
= s5m_rtc_read_time
,
589 .set_time
= s5m_rtc_set_time
,
590 .read_alarm
= s5m_rtc_read_alarm
,
591 .set_alarm
= s5m_rtc_set_alarm
,
592 .alarm_irq_enable
= s5m_rtc_alarm_irq_enable
,
595 static int s5m8767_rtc_init_reg(struct s5m_rtc_info
*info
)
600 switch (info
->device_type
) {
603 /* UDR update time. Default of 7.32 ms is too long. */
604 ret
= regmap_update_bits(info
->regmap
, S5M_RTC_UDR_CON
,
605 S5M_RTC_UDR_T_MASK
, S5M_RTC_UDR_T_450_US
);
607 dev_err(info
->dev
, "%s: fail to change UDR time: %d\n",
610 /* Set RTC control register : Binary mode, 24hour mode */
611 data
[0] = (1 << BCD_EN_SHIFT
) | (1 << MODEL24_SHIFT
);
612 data
[1] = (0 << BCD_EN_SHIFT
) | (1 << MODEL24_SHIFT
);
614 ret
= regmap_raw_write(info
->regmap
, S5M_ALARM0_CONF
, data
, 2);
618 data
[0] = (0 << BCD_EN_SHIFT
) | (1 << MODEL24_SHIFT
);
619 ret
= regmap_write(info
->regmap
, info
->regs
->ctrl
, data
[0]);
626 info
->rtc_24hr_mode
= 1;
628 dev_err(info
->dev
, "%s: fail to write controlm reg(%d)\n",
636 static int s5m_rtc_probe(struct platform_device
*pdev
)
638 struct sec_pmic_dev
*s5m87xx
= dev_get_drvdata(pdev
->dev
.parent
);
639 struct sec_platform_data
*pdata
= s5m87xx
->pdata
;
640 struct s5m_rtc_info
*info
;
641 const struct regmap_config
*regmap_cfg
;
645 dev_err(pdev
->dev
.parent
, "Platform data not supplied\n");
649 info
= devm_kzalloc(&pdev
->dev
, sizeof(*info
), GFP_KERNEL
);
653 switch (pdata
->device_type
) {
655 regmap_cfg
= &s2mps14_rtc_regmap_config
;
656 info
->regs
= &s2mps_rtc_regs
;
657 alarm_irq
= S2MPS14_IRQ_RTCA0
;
660 regmap_cfg
= &s5m_rtc_regmap_config
;
661 info
->regs
= &s5m_rtc_regs
;
662 alarm_irq
= S5M8763_IRQ_ALARM0
;
665 regmap_cfg
= &s5m_rtc_regmap_config
;
666 info
->regs
= &s5m_rtc_regs
;
667 alarm_irq
= S5M8767_IRQ_RTCA1
;
670 dev_err(&pdev
->dev
, "Device type is not supported by RTC driver\n");
674 info
->i2c
= i2c_new_dummy(s5m87xx
->i2c
->adapter
, RTC_I2C_ADDR
);
676 dev_err(&pdev
->dev
, "Failed to allocate I2C for RTC\n");
680 info
->regmap
= devm_regmap_init_i2c(info
->i2c
, regmap_cfg
);
681 if (IS_ERR(info
->regmap
)) {
682 ret
= PTR_ERR(info
->regmap
);
683 dev_err(&pdev
->dev
, "Failed to allocate RTC register map: %d\n",
688 info
->dev
= &pdev
->dev
;
689 info
->s5m87xx
= s5m87xx
;
690 info
->device_type
= s5m87xx
->device_type
;
692 if (s5m87xx
->irq_data
) {
693 info
->irq
= regmap_irq_get_virq(s5m87xx
->irq_data
, alarm_irq
);
694 if (info
->irq
<= 0) {
696 dev_err(&pdev
->dev
, "Failed to get virtual IRQ %d\n",
702 platform_set_drvdata(pdev
, info
);
704 ret
= s5m8767_rtc_init_reg(info
);
706 device_init_wakeup(&pdev
->dev
, 1);
708 info
->rtc_dev
= devm_rtc_device_register(&pdev
->dev
, "s5m-rtc",
709 &s5m_rtc_ops
, THIS_MODULE
);
711 if (IS_ERR(info
->rtc_dev
)) {
712 ret
= PTR_ERR(info
->rtc_dev
);
717 dev_info(&pdev
->dev
, "Alarm IRQ not available\n");
721 ret
= devm_request_threaded_irq(&pdev
->dev
, info
->irq
, NULL
,
722 s5m_rtc_alarm_irq
, 0, "rtc-alarm0",
725 dev_err(&pdev
->dev
, "Failed to request alarm IRQ: %d: %d\n",
733 i2c_unregister_device(info
->i2c
);
738 static int s5m_rtc_remove(struct platform_device
*pdev
)
740 struct s5m_rtc_info
*info
= platform_get_drvdata(pdev
);
742 i2c_unregister_device(info
->i2c
);
747 #ifdef CONFIG_PM_SLEEP
748 static int s5m_rtc_resume(struct device
*dev
)
750 struct s5m_rtc_info
*info
= dev_get_drvdata(dev
);
753 if (info
->irq
&& device_may_wakeup(dev
))
754 ret
= disable_irq_wake(info
->irq
);
759 static int s5m_rtc_suspend(struct device
*dev
)
761 struct s5m_rtc_info
*info
= dev_get_drvdata(dev
);
764 if (info
->irq
&& device_may_wakeup(dev
))
765 ret
= enable_irq_wake(info
->irq
);
769 #endif /* CONFIG_PM_SLEEP */
771 static SIMPLE_DEV_PM_OPS(s5m_rtc_pm_ops
, s5m_rtc_suspend
, s5m_rtc_resume
);
773 static const struct platform_device_id s5m_rtc_id
[] = {
774 { "s5m-rtc", S5M8767X
},
775 { "s2mps14-rtc", S2MPS14X
},
779 static struct platform_driver s5m_rtc_driver
= {
782 .pm
= &s5m_rtc_pm_ops
,
784 .probe
= s5m_rtc_probe
,
785 .remove
= s5m_rtc_remove
,
786 .id_table
= s5m_rtc_id
,
789 module_platform_driver(s5m_rtc_driver
);
791 /* Module information */
792 MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
793 MODULE_DESCRIPTION("Samsung S5M/S2MPS14 RTC driver");
794 MODULE_LICENSE("GPL");
795 MODULE_ALIAS("platform:s5m-rtc");