494 lines
12 KiB
C
494 lines
12 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
//
|
|
// Copyright (C) 2018 ROHM Semiconductors
|
|
//
|
|
// RTC driver for ROHM BD70528 PMIC
|
|
|
|
#include <linux/bcd.h>
|
|
#include <linux/mfd/rohm-bd70528.h>
|
|
#include <linux/module.h>
|
|
#include <linux/of.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/regmap.h>
|
|
#include <linux/rtc.h>
|
|
|
|
/*
|
|
* We read regs RTC_SEC => RTC_YEAR
|
|
* this struct is ordered according to chip registers.
|
|
* Keep it u8 only to avoid padding issues.
|
|
*/
|
|
struct bd70528_rtc_day {
|
|
u8 sec;
|
|
u8 min;
|
|
u8 hour;
|
|
} __packed;
|
|
|
|
struct bd70528_rtc_data {
|
|
struct bd70528_rtc_day time;
|
|
u8 week;
|
|
u8 day;
|
|
u8 month;
|
|
u8 year;
|
|
} __packed;
|
|
|
|
struct bd70528_rtc_wake {
|
|
struct bd70528_rtc_day time;
|
|
u8 ctrl;
|
|
} __packed;
|
|
|
|
struct bd70528_rtc_alm {
|
|
struct bd70528_rtc_data data;
|
|
u8 alm_mask;
|
|
u8 alm_repeat;
|
|
} __packed;
|
|
|
|
struct bd70528_rtc {
|
|
struct rohm_regmap_dev *mfd;
|
|
struct device *dev;
|
|
};
|
|
|
|
static int bd70528_set_wake(struct rohm_regmap_dev *bd70528,
|
|
int enable, int *old_state)
|
|
{
|
|
int ret;
|
|
unsigned int ctrl_reg;
|
|
|
|
ret = regmap_read(bd70528->regmap, BD70528_REG_WAKE_EN, &ctrl_reg);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (old_state) {
|
|
if (ctrl_reg & BD70528_MASK_WAKE_EN)
|
|
*old_state |= BD70528_WAKE_STATE_BIT;
|
|
else
|
|
*old_state &= ~BD70528_WAKE_STATE_BIT;
|
|
|
|
if (!enable == !(*old_state & BD70528_WAKE_STATE_BIT))
|
|
return 0;
|
|
}
|
|
|
|
if (enable)
|
|
ctrl_reg |= BD70528_MASK_WAKE_EN;
|
|
else
|
|
ctrl_reg &= ~BD70528_MASK_WAKE_EN;
|
|
|
|
return regmap_write(bd70528->regmap, BD70528_REG_WAKE_EN,
|
|
ctrl_reg);
|
|
}
|
|
|
|
static int bd70528_set_elapsed_tmr(struct rohm_regmap_dev *bd70528,
|
|
int enable, int *old_state)
|
|
{
|
|
int ret;
|
|
unsigned int ctrl_reg;
|
|
|
|
/*
|
|
* TBD
|
|
* What is the purpose of elapsed timer ?
|
|
* Is the timeout registers counting down, or is the disable - re-enable
|
|
* going to restart the elapsed-time counting? If counting is restarted
|
|
* the timeout should be decreased by the amount of time that has
|
|
* elapsed since starting the timer. Maybe we should store the monotonic
|
|
* clock value when timer is started so that if RTC is set while timer
|
|
* is armed we could do the compensation. This is a hack if RTC/system
|
|
* clk are drifting. OTOH, RTC controlled via I2C is in any case
|
|
* inaccurate...
|
|
*/
|
|
ret = regmap_read(bd70528->regmap, BD70528_REG_ELAPSED_TIMER_EN,
|
|
&ctrl_reg);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (old_state) {
|
|
if (ctrl_reg & BD70528_MASK_ELAPSED_TIMER_EN)
|
|
*old_state |= BD70528_ELAPSED_STATE_BIT;
|
|
else
|
|
*old_state &= ~BD70528_ELAPSED_STATE_BIT;
|
|
|
|
if ((!enable) == (!(*old_state & BD70528_ELAPSED_STATE_BIT)))
|
|
return 0;
|
|
}
|
|
|
|
if (enable)
|
|
ctrl_reg |= BD70528_MASK_ELAPSED_TIMER_EN;
|
|
else
|
|
ctrl_reg &= ~BD70528_MASK_ELAPSED_TIMER_EN;
|
|
|
|
return regmap_write(bd70528->regmap, BD70528_REG_ELAPSED_TIMER_EN,
|
|
ctrl_reg);
|
|
}
|
|
|
|
static int bd70528_set_rtc_based_timers(struct bd70528_rtc *r, int new_state,
|
|
int *old_state)
|
|
{
|
|
int ret;
|
|
|
|
ret = bd70528_wdt_set(r->mfd, new_state & BD70528_WDT_STATE_BIT,
|
|
old_state);
|
|
if (ret) {
|
|
dev_err(r->dev,
|
|
"Failed to disable WDG for RTC setting (%d)\n", ret);
|
|
return ret;
|
|
}
|
|
ret = bd70528_set_elapsed_tmr(r->mfd,
|
|
new_state & BD70528_ELAPSED_STATE_BIT,
|
|
old_state);
|
|
if (ret) {
|
|
dev_err(r->dev,
|
|
"Failed to disable 'elapsed timer' for RTC setting\n");
|
|
return ret;
|
|
}
|
|
ret = bd70528_set_wake(r->mfd, new_state & BD70528_WAKE_STATE_BIT,
|
|
old_state);
|
|
if (ret) {
|
|
dev_err(r->dev,
|
|
"Failed to disable 'wake timer' for RTC setting\n");
|
|
return ret;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int bd70528_re_enable_rtc_based_timers(struct bd70528_rtc *r,
|
|
int old_state)
|
|
{
|
|
return bd70528_set_rtc_based_timers(r, old_state, NULL);
|
|
}
|
|
|
|
static int bd70528_disable_rtc_based_timers(struct bd70528_rtc *r,
|
|
int *old_state)
|
|
{
|
|
return bd70528_set_rtc_based_timers(r, 0, old_state);
|
|
}
|
|
|
|
static inline void tmday2rtc(struct rtc_time *t, struct bd70528_rtc_day *d)
|
|
{
|
|
d->sec &= ~BD70528_MASK_RTC_SEC;
|
|
d->min &= ~BD70528_MASK_RTC_MINUTE;
|
|
d->hour &= ~BD70528_MASK_RTC_HOUR;
|
|
d->sec |= bin2bcd(t->tm_sec);
|
|
d->min |= bin2bcd(t->tm_min);
|
|
d->hour |= bin2bcd(t->tm_hour);
|
|
}
|
|
|
|
static inline void tm2rtc(struct rtc_time *t, struct bd70528_rtc_data *r)
|
|
{
|
|
r->day &= ~BD70528_MASK_RTC_DAY;
|
|
r->week &= ~BD70528_MASK_RTC_WEEK;
|
|
r->month &= ~BD70528_MASK_RTC_MONTH;
|
|
/*
|
|
* PM and 24H bits are not used by Wake - thus we clear them
|
|
* here and not in tmday2rtc() which is also used by wake.
|
|
*/
|
|
r->time.hour &= ~(BD70528_MASK_RTC_HOUR_PM | BD70528_MASK_RTC_HOUR_24H);
|
|
|
|
tmday2rtc(t, &r->time);
|
|
/*
|
|
* We do always set time in 24H mode.
|
|
*/
|
|
r->time.hour |= BD70528_MASK_RTC_HOUR_24H;
|
|
r->day |= bin2bcd(t->tm_mday);
|
|
r->week |= bin2bcd(t->tm_wday);
|
|
r->month |= bin2bcd(t->tm_mon + 1);
|
|
r->year = bin2bcd(t->tm_year - 100);
|
|
}
|
|
|
|
static inline void rtc2tm(struct bd70528_rtc_data *r, struct rtc_time *t)
|
|
{
|
|
t->tm_sec = bcd2bin(r->time.sec & BD70528_MASK_RTC_SEC);
|
|
t->tm_min = bcd2bin(r->time.min & BD70528_MASK_RTC_MINUTE);
|
|
t->tm_hour = bcd2bin(r->time.hour & BD70528_MASK_RTC_HOUR);
|
|
/*
|
|
* If RTC is in 12H mode, then bit BD70528_MASK_RTC_HOUR_PM
|
|
* is not BCD value but tells whether it is AM or PM
|
|
*/
|
|
if (!(r->time.hour & BD70528_MASK_RTC_HOUR_24H)) {
|
|
t->tm_hour %= 12;
|
|
if (r->time.hour & BD70528_MASK_RTC_HOUR_PM)
|
|
t->tm_hour += 12;
|
|
}
|
|
t->tm_mday = bcd2bin(r->day & BD70528_MASK_RTC_DAY);
|
|
t->tm_mon = bcd2bin(r->month & BD70528_MASK_RTC_MONTH) - 1;
|
|
t->tm_year = 100 + bcd2bin(r->year & BD70528_MASK_RTC_YEAR);
|
|
t->tm_wday = bcd2bin(r->week & BD70528_MASK_RTC_WEEK);
|
|
}
|
|
|
|
static int bd70528_set_alarm(struct device *dev, struct rtc_wkalrm *a)
|
|
{
|
|
struct bd70528_rtc_wake wake;
|
|
struct bd70528_rtc_alm alm;
|
|
int ret;
|
|
struct bd70528_rtc *r = dev_get_drvdata(dev);
|
|
struct rohm_regmap_dev *bd70528 = r->mfd;
|
|
|
|
ret = regmap_bulk_read(bd70528->regmap, BD70528_REG_RTC_WAKE_START,
|
|
&wake, sizeof(wake));
|
|
if (ret) {
|
|
dev_err(dev, "Failed to read wake regs\n");
|
|
return ret;
|
|
}
|
|
|
|
ret = regmap_bulk_read(bd70528->regmap, BD70528_REG_RTC_ALM_START,
|
|
&alm, sizeof(alm));
|
|
if (ret) {
|
|
dev_err(dev, "Failed to read alarm regs\n");
|
|
return ret;
|
|
}
|
|
|
|
tm2rtc(&a->time, &alm.data);
|
|
tmday2rtc(&a->time, &wake.time);
|
|
|
|
if (a->enabled) {
|
|
alm.alm_mask &= ~BD70528_MASK_ALM_EN;
|
|
wake.ctrl |= BD70528_MASK_WAKE_EN;
|
|
} else {
|
|
alm.alm_mask |= BD70528_MASK_ALM_EN;
|
|
wake.ctrl &= ~BD70528_MASK_WAKE_EN;
|
|
}
|
|
|
|
ret = regmap_bulk_write(bd70528->regmap,
|
|
BD70528_REG_RTC_WAKE_START, &wake,
|
|
sizeof(wake));
|
|
if (ret) {
|
|
dev_err(dev, "Failed to set wake time\n");
|
|
return ret;
|
|
}
|
|
ret = regmap_bulk_write(bd70528->regmap, BD70528_REG_RTC_ALM_START,
|
|
&alm, sizeof(alm));
|
|
if (ret)
|
|
dev_err(dev, "Failed to set alarm time\n");
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int bd70528_read_alarm(struct device *dev, struct rtc_wkalrm *a)
|
|
{
|
|
struct bd70528_rtc_alm alm;
|
|
int ret;
|
|
struct bd70528_rtc *r = dev_get_drvdata(dev);
|
|
struct rohm_regmap_dev *bd70528 = r->mfd;
|
|
|
|
ret = regmap_bulk_read(bd70528->regmap, BD70528_REG_RTC_ALM_START,
|
|
&alm, sizeof(alm));
|
|
if (ret) {
|
|
dev_err(dev, "Failed to read alarm regs\n");
|
|
return ret;
|
|
}
|
|
|
|
rtc2tm(&alm.data, &a->time);
|
|
a->time.tm_mday = -1;
|
|
a->time.tm_mon = -1;
|
|
a->time.tm_year = -1;
|
|
a->enabled = !(alm.alm_mask & BD70528_MASK_ALM_EN);
|
|
a->pending = 0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int bd70528_set_time_locked(struct device *dev, struct rtc_time *t)
|
|
{
|
|
int ret, tmpret, old_states;
|
|
struct bd70528_rtc_data rtc_data;
|
|
struct bd70528_rtc *r = dev_get_drvdata(dev);
|
|
struct rohm_regmap_dev *bd70528 = r->mfd;
|
|
|
|
ret = bd70528_disable_rtc_based_timers(r, &old_states);
|
|
if (ret)
|
|
return ret;
|
|
|
|
tmpret = regmap_bulk_read(bd70528->regmap,
|
|
BD70528_REG_RTC_START, &rtc_data,
|
|
sizeof(rtc_data));
|
|
if (tmpret) {
|
|
dev_err(dev, "Failed to read RTC time registers\n");
|
|
goto renable_out;
|
|
}
|
|
tm2rtc(t, &rtc_data);
|
|
|
|
tmpret = regmap_bulk_write(bd70528->regmap,
|
|
BD70528_REG_RTC_START, &rtc_data,
|
|
sizeof(rtc_data));
|
|
if (tmpret) {
|
|
dev_err(dev, "Failed to set RTC time\n");
|
|
goto renable_out;
|
|
}
|
|
|
|
renable_out:
|
|
ret = bd70528_re_enable_rtc_based_timers(r, old_states);
|
|
if (tmpret)
|
|
ret = tmpret;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int bd70528_set_time(struct device *dev, struct rtc_time *t)
|
|
{
|
|
int ret;
|
|
struct bd70528_rtc *r = dev_get_drvdata(dev);
|
|
|
|
bd70528_wdt_lock(r->mfd);
|
|
ret = bd70528_set_time_locked(dev, t);
|
|
bd70528_wdt_unlock(r->mfd);
|
|
return ret;
|
|
}
|
|
|
|
static int bd70528_get_time(struct device *dev, struct rtc_time *t)
|
|
{
|
|
struct bd70528_rtc *r = dev_get_drvdata(dev);
|
|
struct rohm_regmap_dev *bd70528 = r->mfd;
|
|
struct bd70528_rtc_data rtc_data;
|
|
int ret;
|
|
|
|
/* read the RTC date and time registers all at once */
|
|
ret = regmap_bulk_read(bd70528->regmap,
|
|
BD70528_REG_RTC_START, &rtc_data,
|
|
sizeof(rtc_data));
|
|
if (ret) {
|
|
dev_err(dev, "Failed to read RTC time (err %d)\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
rtc2tm(&rtc_data, t);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int bd70528_alm_enable(struct device *dev, unsigned int enabled)
|
|
{
|
|
int ret;
|
|
unsigned int enableval = BD70528_MASK_ALM_EN;
|
|
struct bd70528_rtc *r = dev_get_drvdata(dev);
|
|
|
|
if (enabled)
|
|
enableval = 0;
|
|
|
|
bd70528_wdt_lock(r->mfd);
|
|
ret = bd70528_set_wake(r->mfd, enabled, NULL);
|
|
if (ret) {
|
|
dev_err(dev, "Failed to change wake state\n");
|
|
goto out_unlock;
|
|
}
|
|
ret = regmap_update_bits(r->mfd->regmap, BD70528_REG_RTC_ALM_MASK,
|
|
BD70528_MASK_ALM_EN, enableval);
|
|
if (ret)
|
|
dev_err(dev, "Failed to change alarm state\n");
|
|
|
|
out_unlock:
|
|
bd70528_wdt_unlock(r->mfd);
|
|
return ret;
|
|
}
|
|
|
|
static const struct rtc_class_ops bd70528_rtc_ops = {
|
|
.read_time = bd70528_get_time,
|
|
.set_time = bd70528_set_time,
|
|
.read_alarm = bd70528_read_alarm,
|
|
.set_alarm = bd70528_set_alarm,
|
|
.alarm_irq_enable = bd70528_alm_enable,
|
|
};
|
|
|
|
static irqreturn_t alm_hndlr(int irq, void *data)
|
|
{
|
|
struct rtc_device *rtc = data;
|
|
|
|
rtc_update_irq(rtc, 1, RTC_IRQF | RTC_AF | RTC_PF);
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static int bd70528_probe(struct platform_device *pdev)
|
|
{
|
|
struct bd70528_rtc *bd_rtc;
|
|
struct rohm_regmap_dev *mfd;
|
|
int ret;
|
|
struct rtc_device *rtc;
|
|
int irq;
|
|
unsigned int hr;
|
|
|
|
mfd = dev_get_drvdata(pdev->dev.parent);
|
|
if (!mfd) {
|
|
dev_err(&pdev->dev, "No MFD driver data\n");
|
|
return -EINVAL;
|
|
}
|
|
bd_rtc = devm_kzalloc(&pdev->dev, sizeof(*bd_rtc), GFP_KERNEL);
|
|
if (!bd_rtc)
|
|
return -ENOMEM;
|
|
|
|
bd_rtc->mfd = mfd;
|
|
bd_rtc->dev = &pdev->dev;
|
|
|
|
irq = platform_get_irq_byname(pdev, "bd70528-rtc-alm");
|
|
if (irq < 0)
|
|
return irq;
|
|
|
|
platform_set_drvdata(pdev, bd_rtc);
|
|
|
|
ret = regmap_read(mfd->regmap, BD70528_REG_RTC_HOUR, &hr);
|
|
|
|
if (ret) {
|
|
dev_err(&pdev->dev, "Failed to reag RTC clock\n");
|
|
return ret;
|
|
}
|
|
|
|
if (!(hr & BD70528_MASK_RTC_HOUR_24H)) {
|
|
struct rtc_time t;
|
|
|
|
ret = bd70528_get_time(&pdev->dev, &t);
|
|
|
|
if (!ret)
|
|
ret = bd70528_set_time(&pdev->dev, &t);
|
|
|
|
if (ret) {
|
|
dev_err(&pdev->dev,
|
|
"Setting 24H clock for RTC failed\n");
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
device_set_wakeup_capable(&pdev->dev, true);
|
|
device_wakeup_enable(&pdev->dev);
|
|
|
|
rtc = devm_rtc_allocate_device(&pdev->dev);
|
|
if (IS_ERR(rtc)) {
|
|
dev_err(&pdev->dev, "RTC device creation failed\n");
|
|
return PTR_ERR(rtc);
|
|
}
|
|
|
|
rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
|
|
rtc->range_max = RTC_TIMESTAMP_END_2099;
|
|
rtc->ops = &bd70528_rtc_ops;
|
|
|
|
/* Request alarm IRQ prior to registerig the RTC */
|
|
ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, &alm_hndlr,
|
|
IRQF_ONESHOT, "bd70528-rtc", rtc);
|
|
if (ret)
|
|
return ret;
|
|
|
|
/*
|
|
* BD70528 irq controller is not touching the main mask register.
|
|
* So enable the RTC block interrupts at main level. We can just
|
|
* leave them enabled as irq-controller should disable irqs
|
|
* from sub-registers when IRQ is disabled or freed.
|
|
*/
|
|
ret = regmap_update_bits(mfd->regmap,
|
|
BD70528_REG_INT_MAIN_MASK,
|
|
BD70528_INT_RTC_MASK, 0);
|
|
if (ret) {
|
|
dev_err(&pdev->dev, "Failed to enable RTC interrupts\n");
|
|
return ret;
|
|
}
|
|
|
|
return rtc_register_device(rtc);
|
|
}
|
|
|
|
static struct platform_driver bd70528_rtc = {
|
|
.driver = {
|
|
.name = "bd70528-rtc"
|
|
},
|
|
.probe = bd70528_probe,
|
|
};
|
|
|
|
module_platform_driver(bd70528_rtc);
|
|
|
|
MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
|
|
MODULE_DESCRIPTION("BD70528 RTC driver");
|
|
MODULE_LICENSE("GPL");
|