![Thomas Gleixner](/assets/img/avatar_default.png)
Based on 1 normalized pattern(s): this program is free software you can redistribute it and or modify it under the terms and conditions of the gnu general public license version 2 as published by the free software foundation this program is distributed in the hope it will be useful but without any warranty without even the implied warranty of merchantability or fitness for a particular purpose see the gnu general public license for more details extracted by the scancode license scanner the SPDX license identifier GPL-2.0-only has been chosen to replace the boilerplate/reference in 263 file(s). Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Reviewed-by: Allison Randal <allison@lohutok.net> Reviewed-by: Alexios Zavras <alexios.zavras@intel.com> Cc: linux-spdx@vger.kernel.org Link: https://lkml.kernel.org/r/20190529141901.208660670@linutronix.de Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
432 lines
12 KiB
C
432 lines
12 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* RTC driver for Rockchip RK808
|
|
*
|
|
* Copyright (c) 2014, Fuzhou Rockchip Electronics Co., Ltd
|
|
*
|
|
* Author: Chris Zhong <zyw@rock-chips.com>
|
|
* Author: Zhang Qing <zhangqing@rock-chips.com>
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/rtc.h>
|
|
#include <linux/bcd.h>
|
|
#include <linux/mfd/rk808.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/i2c.h>
|
|
|
|
/* RTC_CTRL_REG bitfields */
|
|
#define BIT_RTC_CTRL_REG_STOP_RTC_M BIT(0)
|
|
|
|
/* RK808 has a shadowed register for saving a "frozen" RTC time.
|
|
* When user setting "GET_TIME" to 1, the time will save in this shadowed
|
|
* register. If set "READSEL" to 1, user read rtc time register, actually
|
|
* get the time of that moment. If we need the real time, clr this bit.
|
|
*/
|
|
#define BIT_RTC_CTRL_REG_RTC_GET_TIME BIT(6)
|
|
#define BIT_RTC_CTRL_REG_RTC_READSEL_M BIT(7)
|
|
#define BIT_RTC_INTERRUPTS_REG_IT_ALARM_M BIT(3)
|
|
#define RTC_STATUS_MASK 0xFE
|
|
|
|
#define SECONDS_REG_MSK 0x7F
|
|
#define MINUTES_REG_MAK 0x7F
|
|
#define HOURS_REG_MSK 0x3F
|
|
#define DAYS_REG_MSK 0x3F
|
|
#define MONTHS_REG_MSK 0x1F
|
|
#define YEARS_REG_MSK 0xFF
|
|
#define WEEKS_REG_MSK 0x7
|
|
|
|
/* REG_SECONDS_REG through REG_YEARS_REG is how many registers? */
|
|
|
|
#define NUM_TIME_REGS (RK808_WEEKS_REG - RK808_SECONDS_REG + 1)
|
|
#define NUM_ALARM_REGS (RK808_ALARM_YEARS_REG - RK808_ALARM_SECONDS_REG + 1)
|
|
|
|
struct rk808_rtc {
|
|
struct rk808 *rk808;
|
|
struct rtc_device *rtc;
|
|
int irq;
|
|
};
|
|
|
|
/*
|
|
* The Rockchip calendar used by the RK808 counts November with 31 days. We use
|
|
* these translation functions to convert its dates to/from the Gregorian
|
|
* calendar used by the rest of the world. We arbitrarily define Jan 1st, 2016
|
|
* as the day when both calendars were in sync, and treat all other dates
|
|
* relative to that.
|
|
* NOTE: Other system software (e.g. firmware) that reads the same hardware must
|
|
* implement this exact same conversion algorithm, with the same anchor date.
|
|
*/
|
|
static time64_t nov2dec_transitions(struct rtc_time *tm)
|
|
{
|
|
return (tm->tm_year + 1900) - 2016 + (tm->tm_mon + 1 > 11 ? 1 : 0);
|
|
}
|
|
|
|
static void rockchip_to_gregorian(struct rtc_time *tm)
|
|
{
|
|
/* If it's Nov 31st, rtc_tm_to_time64() will count that like Dec 1st */
|
|
time64_t time = rtc_tm_to_time64(tm);
|
|
rtc_time64_to_tm(time + nov2dec_transitions(tm) * 86400, tm);
|
|
}
|
|
|
|
static void gregorian_to_rockchip(struct rtc_time *tm)
|
|
{
|
|
time64_t extra_days = nov2dec_transitions(tm);
|
|
time64_t time = rtc_tm_to_time64(tm);
|
|
rtc_time64_to_tm(time - extra_days * 86400, tm);
|
|
|
|
/* Compensate if we went back over Nov 31st (will work up to 2381) */
|
|
if (nov2dec_transitions(tm) < extra_days) {
|
|
if (tm->tm_mon + 1 == 11)
|
|
tm->tm_mday++; /* This may result in 31! */
|
|
else
|
|
rtc_time64_to_tm(time - (extra_days - 1) * 86400, tm);
|
|
}
|
|
}
|
|
|
|
/* Read current time and date in RTC */
|
|
static int rk808_rtc_readtime(struct device *dev, struct rtc_time *tm)
|
|
{
|
|
struct rk808_rtc *rk808_rtc = dev_get_drvdata(dev);
|
|
struct rk808 *rk808 = rk808_rtc->rk808;
|
|
u8 rtc_data[NUM_TIME_REGS];
|
|
int ret;
|
|
|
|
/* Force an update of the shadowed registers right now */
|
|
ret = regmap_update_bits(rk808->regmap, RK808_RTC_CTRL_REG,
|
|
BIT_RTC_CTRL_REG_RTC_GET_TIME,
|
|
BIT_RTC_CTRL_REG_RTC_GET_TIME);
|
|
if (ret) {
|
|
dev_err(dev, "Failed to update bits rtc_ctrl: %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* After we set the GET_TIME bit, the rtc time can't be read
|
|
* immediately. So we should wait up to 31.25 us, about one cycle of
|
|
* 32khz. If we clear the GET_TIME bit here, the time of i2c transfer
|
|
* certainly more than 31.25us: 16 * 2.5us at 400kHz bus frequency.
|
|
*/
|
|
ret = regmap_update_bits(rk808->regmap, RK808_RTC_CTRL_REG,
|
|
BIT_RTC_CTRL_REG_RTC_GET_TIME,
|
|
0);
|
|
if (ret) {
|
|
dev_err(dev, "Failed to update bits rtc_ctrl: %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
ret = regmap_bulk_read(rk808->regmap, RK808_SECONDS_REG,
|
|
rtc_data, NUM_TIME_REGS);
|
|
if (ret) {
|
|
dev_err(dev, "Failed to bulk read rtc_data: %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
tm->tm_sec = bcd2bin(rtc_data[0] & SECONDS_REG_MSK);
|
|
tm->tm_min = bcd2bin(rtc_data[1] & MINUTES_REG_MAK);
|
|
tm->tm_hour = bcd2bin(rtc_data[2] & HOURS_REG_MSK);
|
|
tm->tm_mday = bcd2bin(rtc_data[3] & DAYS_REG_MSK);
|
|
tm->tm_mon = (bcd2bin(rtc_data[4] & MONTHS_REG_MSK)) - 1;
|
|
tm->tm_year = (bcd2bin(rtc_data[5] & YEARS_REG_MSK)) + 100;
|
|
tm->tm_wday = bcd2bin(rtc_data[6] & WEEKS_REG_MSK);
|
|
rockchip_to_gregorian(tm);
|
|
dev_dbg(dev, "RTC date/time %ptRd(%d) %ptRt\n", tm, tm->tm_wday, tm);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* Set current time and date in RTC */
|
|
static int rk808_rtc_set_time(struct device *dev, struct rtc_time *tm)
|
|
{
|
|
struct rk808_rtc *rk808_rtc = dev_get_drvdata(dev);
|
|
struct rk808 *rk808 = rk808_rtc->rk808;
|
|
u8 rtc_data[NUM_TIME_REGS];
|
|
int ret;
|
|
|
|
dev_dbg(dev, "set RTC date/time %ptRd(%d) %ptRt\n", tm, tm->tm_wday, tm);
|
|
gregorian_to_rockchip(tm);
|
|
rtc_data[0] = bin2bcd(tm->tm_sec);
|
|
rtc_data[1] = bin2bcd(tm->tm_min);
|
|
rtc_data[2] = bin2bcd(tm->tm_hour);
|
|
rtc_data[3] = bin2bcd(tm->tm_mday);
|
|
rtc_data[4] = bin2bcd(tm->tm_mon + 1);
|
|
rtc_data[5] = bin2bcd(tm->tm_year - 100);
|
|
rtc_data[6] = bin2bcd(tm->tm_wday);
|
|
|
|
/* Stop RTC while updating the RTC registers */
|
|
ret = regmap_update_bits(rk808->regmap, RK808_RTC_CTRL_REG,
|
|
BIT_RTC_CTRL_REG_STOP_RTC_M,
|
|
BIT_RTC_CTRL_REG_STOP_RTC_M);
|
|
if (ret) {
|
|
dev_err(dev, "Failed to update RTC control: %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
ret = regmap_bulk_write(rk808->regmap, RK808_SECONDS_REG,
|
|
rtc_data, NUM_TIME_REGS);
|
|
if (ret) {
|
|
dev_err(dev, "Failed to bull write rtc_data: %d\n", ret);
|
|
return ret;
|
|
}
|
|
/* Start RTC again */
|
|
ret = regmap_update_bits(rk808->regmap, RK808_RTC_CTRL_REG,
|
|
BIT_RTC_CTRL_REG_STOP_RTC_M, 0);
|
|
if (ret) {
|
|
dev_err(dev, "Failed to update RTC control: %d\n", ret);
|
|
return ret;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Read alarm time and date in RTC */
|
|
static int rk808_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm)
|
|
{
|
|
struct rk808_rtc *rk808_rtc = dev_get_drvdata(dev);
|
|
struct rk808 *rk808 = rk808_rtc->rk808;
|
|
u8 alrm_data[NUM_ALARM_REGS];
|
|
uint32_t int_reg;
|
|
int ret;
|
|
|
|
ret = regmap_bulk_read(rk808->regmap, RK808_ALARM_SECONDS_REG,
|
|
alrm_data, NUM_ALARM_REGS);
|
|
|
|
alrm->time.tm_sec = bcd2bin(alrm_data[0] & SECONDS_REG_MSK);
|
|
alrm->time.tm_min = bcd2bin(alrm_data[1] & MINUTES_REG_MAK);
|
|
alrm->time.tm_hour = bcd2bin(alrm_data[2] & HOURS_REG_MSK);
|
|
alrm->time.tm_mday = bcd2bin(alrm_data[3] & DAYS_REG_MSK);
|
|
alrm->time.tm_mon = (bcd2bin(alrm_data[4] & MONTHS_REG_MSK)) - 1;
|
|
alrm->time.tm_year = (bcd2bin(alrm_data[5] & YEARS_REG_MSK)) + 100;
|
|
rockchip_to_gregorian(&alrm->time);
|
|
|
|
ret = regmap_read(rk808->regmap, RK808_RTC_INT_REG, &int_reg);
|
|
if (ret) {
|
|
dev_err(dev, "Failed to read RTC INT REG: %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
dev_dbg(dev, "alrm read RTC date/time %ptRd(%d) %ptRt\n",
|
|
&alrm->time, alrm->time.tm_wday, &alrm->time);
|
|
|
|
alrm->enabled = (int_reg & BIT_RTC_INTERRUPTS_REG_IT_ALARM_M) ? 1 : 0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int rk808_rtc_stop_alarm(struct rk808_rtc *rk808_rtc)
|
|
{
|
|
struct rk808 *rk808 = rk808_rtc->rk808;
|
|
int ret;
|
|
|
|
ret = regmap_update_bits(rk808->regmap, RK808_RTC_INT_REG,
|
|
BIT_RTC_INTERRUPTS_REG_IT_ALARM_M, 0);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int rk808_rtc_start_alarm(struct rk808_rtc *rk808_rtc)
|
|
{
|
|
struct rk808 *rk808 = rk808_rtc->rk808;
|
|
int ret;
|
|
|
|
ret = regmap_update_bits(rk808->regmap, RK808_RTC_INT_REG,
|
|
BIT_RTC_INTERRUPTS_REG_IT_ALARM_M,
|
|
BIT_RTC_INTERRUPTS_REG_IT_ALARM_M);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int rk808_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
|
|
{
|
|
struct rk808_rtc *rk808_rtc = dev_get_drvdata(dev);
|
|
struct rk808 *rk808 = rk808_rtc->rk808;
|
|
u8 alrm_data[NUM_ALARM_REGS];
|
|
int ret;
|
|
|
|
ret = rk808_rtc_stop_alarm(rk808_rtc);
|
|
if (ret) {
|
|
dev_err(dev, "Failed to stop alarm: %d\n", ret);
|
|
return ret;
|
|
}
|
|
dev_dbg(dev, "alrm set RTC date/time %ptRd(%d) %ptRt\n",
|
|
&alrm->time, alrm->time.tm_wday, &alrm->time);
|
|
|
|
gregorian_to_rockchip(&alrm->time);
|
|
alrm_data[0] = bin2bcd(alrm->time.tm_sec);
|
|
alrm_data[1] = bin2bcd(alrm->time.tm_min);
|
|
alrm_data[2] = bin2bcd(alrm->time.tm_hour);
|
|
alrm_data[3] = bin2bcd(alrm->time.tm_mday);
|
|
alrm_data[4] = bin2bcd(alrm->time.tm_mon + 1);
|
|
alrm_data[5] = bin2bcd(alrm->time.tm_year - 100);
|
|
|
|
ret = regmap_bulk_write(rk808->regmap, RK808_ALARM_SECONDS_REG,
|
|
alrm_data, NUM_ALARM_REGS);
|
|
if (ret) {
|
|
dev_err(dev, "Failed to bulk write: %d\n", ret);
|
|
return ret;
|
|
}
|
|
if (alrm->enabled) {
|
|
ret = rk808_rtc_start_alarm(rk808_rtc);
|
|
if (ret) {
|
|
dev_err(dev, "Failed to start alarm: %d\n", ret);
|
|
return ret;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int rk808_rtc_alarm_irq_enable(struct device *dev,
|
|
unsigned int enabled)
|
|
{
|
|
struct rk808_rtc *rk808_rtc = dev_get_drvdata(dev);
|
|
|
|
if (enabled)
|
|
return rk808_rtc_start_alarm(rk808_rtc);
|
|
|
|
return rk808_rtc_stop_alarm(rk808_rtc);
|
|
}
|
|
|
|
/*
|
|
* We will just handle setting the frequency and make use the framework for
|
|
* reading the periodic interupts.
|
|
*
|
|
* @freq: Current periodic IRQ freq:
|
|
* bit 0: every second
|
|
* bit 1: every minute
|
|
* bit 2: every hour
|
|
* bit 3: every day
|
|
*/
|
|
static irqreturn_t rk808_alarm_irq(int irq, void *data)
|
|
{
|
|
struct rk808_rtc *rk808_rtc = data;
|
|
struct rk808 *rk808 = rk808_rtc->rk808;
|
|
struct i2c_client *client = rk808->i2c;
|
|
int ret;
|
|
|
|
ret = regmap_write(rk808->regmap, RK808_RTC_STATUS_REG,
|
|
RTC_STATUS_MASK);
|
|
if (ret) {
|
|
dev_err(&client->dev,
|
|
"%s:Failed to update RTC status: %d\n", __func__, ret);
|
|
return ret;
|
|
}
|
|
|
|
rtc_update_irq(rk808_rtc->rtc, 1, RTC_IRQF | RTC_AF);
|
|
dev_dbg(&client->dev,
|
|
"%s:irq=%d\n", __func__, irq);
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static const struct rtc_class_ops rk808_rtc_ops = {
|
|
.read_time = rk808_rtc_readtime,
|
|
.set_time = rk808_rtc_set_time,
|
|
.read_alarm = rk808_rtc_readalarm,
|
|
.set_alarm = rk808_rtc_setalarm,
|
|
.alarm_irq_enable = rk808_rtc_alarm_irq_enable,
|
|
};
|
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
/* Turn off the alarm if it should not be a wake source. */
|
|
static int rk808_rtc_suspend(struct device *dev)
|
|
{
|
|
struct rk808_rtc *rk808_rtc = dev_get_drvdata(dev);
|
|
|
|
if (device_may_wakeup(dev))
|
|
enable_irq_wake(rk808_rtc->irq);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Enable the alarm if it should be enabled (in case it was disabled to
|
|
* prevent use as a wake source).
|
|
*/
|
|
static int rk808_rtc_resume(struct device *dev)
|
|
{
|
|
struct rk808_rtc *rk808_rtc = dev_get_drvdata(dev);
|
|
|
|
if (device_may_wakeup(dev))
|
|
disable_irq_wake(rk808_rtc->irq);
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
static SIMPLE_DEV_PM_OPS(rk808_rtc_pm_ops,
|
|
rk808_rtc_suspend, rk808_rtc_resume);
|
|
|
|
static int rk808_rtc_probe(struct platform_device *pdev)
|
|
{
|
|
struct rk808 *rk808 = dev_get_drvdata(pdev->dev.parent);
|
|
struct rk808_rtc *rk808_rtc;
|
|
int ret;
|
|
|
|
rk808_rtc = devm_kzalloc(&pdev->dev, sizeof(*rk808_rtc), GFP_KERNEL);
|
|
if (rk808_rtc == NULL)
|
|
return -ENOMEM;
|
|
|
|
platform_set_drvdata(pdev, rk808_rtc);
|
|
rk808_rtc->rk808 = rk808;
|
|
|
|
/* start rtc running by default, and use shadowed timer. */
|
|
ret = regmap_update_bits(rk808->regmap, RK808_RTC_CTRL_REG,
|
|
BIT_RTC_CTRL_REG_STOP_RTC_M |
|
|
BIT_RTC_CTRL_REG_RTC_READSEL_M,
|
|
BIT_RTC_CTRL_REG_RTC_READSEL_M);
|
|
if (ret) {
|
|
dev_err(&pdev->dev,
|
|
"Failed to update RTC control: %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
ret = regmap_write(rk808->regmap, RK808_RTC_STATUS_REG,
|
|
RTC_STATUS_MASK);
|
|
if (ret) {
|
|
dev_err(&pdev->dev,
|
|
"Failed to write RTC status: %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
device_init_wakeup(&pdev->dev, 1);
|
|
|
|
rk808_rtc->rtc = devm_rtc_allocate_device(&pdev->dev);
|
|
if (IS_ERR(rk808_rtc->rtc))
|
|
return PTR_ERR(rk808_rtc->rtc);
|
|
|
|
rk808_rtc->rtc->ops = &rk808_rtc_ops;
|
|
|
|
rk808_rtc->irq = platform_get_irq(pdev, 0);
|
|
if (rk808_rtc->irq < 0) {
|
|
if (rk808_rtc->irq != -EPROBE_DEFER)
|
|
dev_err(&pdev->dev, "Wake up is not possible as irq = %d\n",
|
|
rk808_rtc->irq);
|
|
return rk808_rtc->irq;
|
|
}
|
|
|
|
/* request alarm irq of rk808 */
|
|
ret = devm_request_threaded_irq(&pdev->dev, rk808_rtc->irq, NULL,
|
|
rk808_alarm_irq, 0,
|
|
"RTC alarm", rk808_rtc);
|
|
if (ret) {
|
|
dev_err(&pdev->dev, "Failed to request alarm IRQ %d: %d\n",
|
|
rk808_rtc->irq, ret);
|
|
return ret;
|
|
}
|
|
|
|
return rtc_register_device(rk808_rtc->rtc);
|
|
}
|
|
|
|
static struct platform_driver rk808_rtc_driver = {
|
|
.probe = rk808_rtc_probe,
|
|
.driver = {
|
|
.name = "rk808-rtc",
|
|
.pm = &rk808_rtc_pm_ops,
|
|
},
|
|
};
|
|
|
|
module_platform_driver(rk808_rtc_driver);
|
|
|
|
MODULE_DESCRIPTION("RTC driver for the rk808 series PMICs");
|
|
MODULE_AUTHOR("Chris Zhong <zyw@rock-chips.com>");
|
|
MODULE_AUTHOR("Zhang Qing <zhangqing@rock-chips.com>");
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_ALIAS("platform:rk808-rtc");
|