Initial commit: Linux kernel 4.19 for Unplugged OS

This commit is contained in:
ziv committed 2025-10-06 13:52:42 +00:00
commit d30235b04c
80519 files changed
+35800681

No files matched your search

+9
View File
@@ -0,0 +1,9 @@
# RTC Related
config MTK_RTC
bool "MediaTek Real Time Clock Support"
default n
help
A real-time clock (RTC) is a computer
clock (most often in the form of an
integrated circuit) that keeps track
of the current time.
+50
View File
@@ -0,0 +1,50 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that 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.
#
#set IP folder name
ifeq ($(CONFIG_RTC_DRV_MT6358), y)
obj-$(CONFIG_MTK_RTC) += mtk_rtc_debug_v1.o
else
#legacy
ifneq (,$(filter y,$(CONFIG_MTK_PMIC_CHIP_MT6357)))
MDI_IP_FOLDER:=mt6357
endif
ifneq (,$(filter y,$(CONFIG_MTK_PMIC_CHIP_MT6358)))
MDI_IP_FOLDER:=mt6358
endif
ifneq (,$(filter y,$(CONFIG_MTK_PMIC_CHIP_MT6359)))
MDI_IP_FOLDER:=mt6359
endif
ifneq (,$(filter y,$(CONFIG_MTK_PMIC_CHIP_MT6390)))
MDI_IP_FOLDER:=mt6357
endif
MDP_COMMON_FOLDER:= ./
ccflags-y += -I$(srctree)/drivers/misc/mediatek/rtc/$(MDI_IP_FOLDER)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/rtc/include
#Top level common code
obj-$(CONFIG_MTK_RTC) += mtk_rtc_common.o mtk_rtc_hal_common.o mtk_rtc_debug.o
MTK_MDI_IP_SRC:= $(MDI_IP_FOLDER)/
#IP dependent part
obj-y += \
$(MTK_MDI_IP_SRC)
endif
@@ -0,0 +1,28 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2021 MediaTek Inc.
*/
#ifndef _MTK_RTC_HAL_H_
#define _MTK_RTC_HAL_H_
#include <linux/kernel.h>
#include <linux/rtc.h>
extern u16 hal_rtc_get_gpio_32k_status(void);
extern void hal_rtc_set_gpio_32k_status(u16 user, bool enable);
extern void hal_rtc_set_abb_32k(u16 enable);
extern void hal_rtc_bbpu_pwdn(bool charger_status);
extern void hal_rtc_get_pwron_alarm(struct rtc_time *tm,
struct rtc_wkalrm *alm);
extern bool hal_rtc_is_lp_irq(void);
extern bool hal_rtc_is_pwron_alarm(struct rtc_time *nowtm, struct rtc_time *tm);
extern void hal_rtc_get_alarm(struct rtc_time *tm, struct rtc_wkalrm *alm);
extern void hal_rtc_set_alarm(struct rtc_time *tm);
extern void hal_rtc_clear_alarm(struct rtc_time *tm);
extern void hal_rtc_set_lp_irq(void);
extern void hal_rtc_save_pwron_time(bool enable,
struct rtc_time *tm, bool logo);
extern int mmc_charge_shutdown(void);
extern int __init rtc_debug_init(void);
#endif
+20
View File
@@ -0,0 +1,20 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that 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.
#
ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/
ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6357) += -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6357
ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6390) += -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6390
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/mt-plat/$(CONFIG_MTK_PLATFORM)/include
obj-$(CONFIG_MTK_RTC) := mtk_rtc_hal.o
@@ -0,0 +1,443 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2021 MediaTek Inc.
*/
#ifdef pr_fmt
#undef pr_fmt
#endif
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/rtc.h>
#include <mach/upmu_hw.h>
#include <linux/spinlock.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/types.h>
#include <linux/sched/clock.h>
#include <mtk_rtc_hal_common.h>
#include "mtk_rtc_hw.h"
#include <mach/mtk_pmic_wrap.h>
#include <mtk_boot.h>
#include "include/pmic.h"
#define hal_rtc_xinfo(fmt, args...) \
pr_notice(fmt, ##args)
/*TODO extern bool pmic_chrdet_status(void);*/
/*
* RTC_FGSOC = 0,
* RTC_ANDROID,
* RTC_RECOVERY,
* RTC_FAC_RESET,
* RTC_BYPASS_PWR,
* RTC_PWRON_TIME,
* RTC_FAST_BOOT,
* RTC_KPOC,
* RTC_DEBUG,
* RTC_PWRON_AL,
* RTC_UART,
* RTC_AUTOBOOT,
* RTC_PWRON_LOGO,
* RTC_32K_LESS,
* RTC_LP_DET,
* RTC_SPAR_NUM
*
*/
/*
* RTC_PDN1:
* bit 0 - 3 : Android bits
* bit 4 - 5 : Recovery bits (0x10: factory data reset)
* bit 6 : Bypass PWRKEY bit
* bit 7 : Power-On Time bit
* bit 8 : RTC_GPIO_USER_WIFI bit
* bit 9 : RTC_GPIO_USER_GPS bit
* bit 10 : RTC_GPIO_USER_BT bit
* bit 11 : RTC_GPIO_USER_FM bit
* bit 12 : RTC_GPIO_USER_PMIC bit
* bit 13 : Fast Boot
* bit 14 : Kernel Power Off Charging
* bit 15 : Debug bit
*/
/*
* RTC_PDN2:
* bit 0 - 3 : MTH in power-on time
* bit 4 : Power-On Alarm bit
* bit 5 - 6 : UART bits
* bit 7 : autoboot bit
* bit 8 - 14: YEA in power-on time
* bit 15 : Power-On Logo bit
*/
/*
* RTC_SPAR0:
* bit 0 - 5 : SEC in power-on time
* bit 6 : 32K less bit. True:with 32K, False:Without 32K
* bit 7 - 15: reserved bits
*/
u16 rtc_spare_reg[RTC_SPAR_NUM][3] = {
{RTC_AL_MTH, 0xff, 8},
{RTC_PDN1, 0xf, 0},
{RTC_PDN1, 0x3, 4},
{RTC_PDN1, 0x1, 6},
{RTC_PDN1, 0x1, 7},
{RTC_PDN1, 0x1, 13},
{RTC_PDN1, 0x1, 14},
{RTC_PDN1, 0x1, 15},
{RTC_PDN2, 0x1, 4},
{RTC_PDN2, 0x3, 5},
{RTC_PDN2, 0x1, 7},
{RTC_PDN2, 0x1, 15},
{RTC_SPAR0, 0x1, 6},
{RTC_SPAR0, 0x1, 7},
{RTC_AL_HOU, 0xff, 8}
};
static int rtc_eosc_cali_td = 8;
module_param(rtc_eosc_cali_td, int, 0664);
void hal_rtc_set_abb_32k(u16 enable)
{
hal_rtc_xinfo("ABB 32k not support\n");
}
u16 hal_rtc_get_gpio_32k_status(void)
{
u16 con;
con = rtc_read(RTC_CON);
hal_rtc_xinfo("RTC_GPIO 32k status(RTC_CON=0x%x)\n", con);
if (con & RTC_CON_F32KOB)
return 0;
else
return 1;
}
void hal_rtc_set_gpio_32k_status(u16 user, bool enable)
{
u16 con, pdn1;
if (enable) {
pdn1 = rtc_read(RTC_PDN1);
} else {
pdn1 = rtc_read(RTC_PDN1) & ~(1U << user);
rtc_write(RTC_PDN1, pdn1);
rtc_write_trigger();
}
con = rtc_read(RTC_CON);
if (enable) {
con &= ~RTC_CON_F32KOB;
} else {
if (!(pdn1 & RTC_GPIO_USER_MASK)) { /* no users */
con |= RTC_CON_F32KOB;
}
}
rtc_write(RTC_CON, con);
rtc_write_trigger();
if (enable) {
pdn1 |= (1U << user);
rtc_write(RTC_PDN1, pdn1);
rtc_write_trigger();
}
hal_rtc_xinfo("RTC_GPIO user %d enable = %d 32k (0x%x), RTC_CON = %x\n",
user, enable, pdn1, rtc_read(RTC_CON));
}
void rtc_spar_alarm_clear_wait(void)
{
unsigned long long timeout = sched_clock() + 500000000;
do {
if ((rtc_read(RTC_BBPU) & RTC_BBPU_CLR) == 0)
break;
else if (sched_clock() > timeout) {
pr_notice("%s, spar/alarm clear time out, %x,\n",
__func__, rtc_read(RTC_BBPU));
break;
}
} while (1);
}
void rtc_enable_k_eosc(void)
{
u16 osc32;
/* Truning on eosc cali mode clock */
pmic_config_interface_nolock(PMIC_SCK_TOP_CKPDN_CON0_CLR_ADDR,
1, PMIC_RG_RTC_EOSC32_CK_PDN_MASK,
PMIC_RG_RTC_EOSC32_CK_PDN_SHIFT);
pmic_config_interface_nolock(PMIC_RG_SRCLKEN_IN0_HW_MODE_ADDR,
1, PMIC_RG_SRCLKEN_IN0_HW_MODE_MASK,
PMIC_RG_SRCLKEN_IN0_HW_MODE_SHIFT);
pmic_config_interface_nolock(PMIC_RG_SRCLKEN_IN1_HW_MODE_ADDR,
1, PMIC_RG_SRCLKEN_IN1_HW_MODE_MASK,
PMIC_RG_SRCLKEN_IN1_HW_MODE_SHIFT);
pmic_config_interface_nolock(PMIC_RG_RTC_EOSC32_CK_PDN_ADDR, 0,
PMIC_RG_RTC_EOSC32_CK_PDN_MASK,
PMIC_RG_RTC_EOSC32_CK_PDN_SHIFT);
switch (rtc_eosc_cali_td) {
case 1:
pmic_config_interface_nolock(PMIC_EOSC_CALI_TD_ADDR, 0x3,
PMIC_EOSC_CALI_TD_MASK, PMIC_EOSC_CALI_TD_SHIFT);
break;
case 2:
pmic_config_interface_nolock(PMIC_EOSC_CALI_TD_ADDR, 0x4,
PMIC_EOSC_CALI_TD_MASK, PMIC_EOSC_CALI_TD_SHIFT);
break;
case 4:
pmic_config_interface_nolock(PMIC_EOSC_CALI_TD_ADDR, 0x5,
PMIC_EOSC_CALI_TD_MASK, PMIC_EOSC_CALI_TD_SHIFT);
break;
case 16:
pmic_config_interface_nolock(PMIC_EOSC_CALI_TD_ADDR, 0x7,
PMIC_EOSC_CALI_TD_MASK, PMIC_EOSC_CALI_TD_SHIFT);
break;
default:
pmic_config_interface_nolock(PMIC_EOSC_CALI_TD_ADDR, 0x6,
PMIC_EOSC_CALI_TD_MASK, PMIC_EOSC_CALI_TD_SHIFT);
break;
}
/*Switch the DCXO from 32k-less mode to RTC mode, otherwise,
* EOSC cali will fail
*/
/*RTC mode will have only OFF mode and FPM */
pmic_config_interface_nolock(PMIC_XO_EN32K_MAN_ADDR,
0, PMIC_XO_EN32K_MAN_MASK,
PMIC_XO_EN32K_MAN_SHIFT);
rtc_write(RTC_BBPU,
rtc_read(RTC_BBPU) | RTC_BBPU_KEY | RTC_BBPU_RELOAD);
rtc_write_trigger();
/* Enable K EOSC mode for normal power off and then plug out battery */
rtc_write(RTC_AL_YEA, ((rtc_read(RTC_AL_YEA) | RTC_K_EOSC_RSV_0)
& (~RTC_K_EOSC_RSV_1)) | RTC_K_EOSC_RSV_2);
rtc_write_trigger();
osc32 = rtc_read(RTC_OSC32CON);
rtc_xosc_write(osc32 | RTC_EMBCK_SRC_SEL, true);
hal_rtc_xinfo("RTC_enable_k_eosc\n");
}
void rtc_disable_2sec_reboot(void)
{
u16 reboot;
reboot = (rtc_read(RTC_AL_SEC) & ~RTC_BBPU_2SEC_EN)
& ~RTC_BBPU_AUTO_PDN_SEL;
rtc_write(RTC_AL_SEC, reboot);
rtc_write_trigger();
}
void rtc_bbpu_pwrdown(bool auto_boot)
{
PMIC_POWER_HOLD(0);
}
void hal_rtc_bbpu_pwdn(bool charger_status)
{
u16 con, bbpu;
rtc_disable_2sec_reboot();
rtc_enable_k_eosc();
/* disable 32K export if there are no RTC_GPIO users */
if (!(rtc_read(RTC_PDN1) & RTC_GPIO_USER_MASK)) {
con = rtc_read(RTC_CON) | RTC_CON_F32KOB;
rtc_write(RTC_CON, con);
rtc_write_trigger();
}
/* lpsd */
pr_notice("clear lpsd solution\n");
bbpu = RTC_BBPU_KEY | RTC_BBPU_CLR | RTC_BBPU_PWREN;
rtc_write(RTC_BBPU, bbpu);
rtc_write(RTC_AL_MASK, RTC_AL_MASK_DOW); /* mask DOW */
rtc_write_trigger();
rtc_spar_alarm_clear_wait();
wk_pmic_enable_sdn_delay();
rtc_write(RTC_BBPU,
rtc_read(RTC_BBPU) | RTC_BBPU_KEY | RTC_BBPU_RELOAD);
rtc_write_trigger();
pr_notice("RTC_AL_MASK= 0x%x RTC_IRQ_EN= 0x%x\n",
rtc_read(RTC_AL_MASK), rtc_read(RTC_IRQ_EN));
/* lpsd */
rtc_bbpu_pwrdown(true);
}
void hal_rtc_get_pwron_alarm(struct rtc_time *tm, struct rtc_wkalrm *alm)
{
u16 pdn1, pdn2;
pdn1 = rtc_read(RTC_PDN1);
pdn2 = rtc_read(RTC_PDN2);
alm->enabled = (pdn1 & RTC_PDN1_PWRON_TIME ?
(pdn2 & RTC_PDN2_PWRON_LOGO ? 3 : 2) : 0);
/* return Power-On Alarm bit */
alm->pending = !!(pdn2 & RTC_PDN2_PWRON_ALARM);
hal_rtc_get_alarm_time(tm);
}
bool hal_rtc_is_lp_irq(void)
{
u16 irqsta;
irqsta = rtc_read(RTC_IRQ_STA); /* read clear */
if (unlikely(!(irqsta & RTC_IRQ_STA_AL))) {
#ifndef USER_BUILD_KERNEL
if (irqsta & RTC_IRQ_STA_LP)
rtc_lp_exception();
#endif
return true;
}
return false;
}
bool hal_rtc_is_pwron_alarm(struct rtc_time *nowtm, struct rtc_time *tm)
{
u16 pdn1;
pdn1 = rtc_read(RTC_PDN1);
hal_rtc_xinfo("pdn1 = 0x%4x\n", pdn1);
if (pdn1 & RTC_PDN1_PWRON_TIME) { /* power-on time is available */
hal_rtc_xinfo("pdn1 = 0x%4x\n", pdn1);
hal_rtc_get_tick_time(nowtm);
hal_rtc_xinfo("pdn1 = 0x%4x\n", pdn1);
/* SEC has carried */
if (rtc_read(RTC_TC_SEC) < nowtm->tm_sec)
hal_rtc_get_tick_time(nowtm);
hal_rtc_get_pwron_alarm_time(tm);
return true;
}
return false;
}
void hal_rtc_get_alarm(struct rtc_time *tm, struct rtc_wkalrm *alm)
{
u16 irqen, pdn2;
irqen = rtc_read(RTC_IRQ_EN);
hal_rtc_get_alarm_time(tm);
pdn2 = rtc_read(RTC_PDN2);
alm->enabled = !!(irqen & RTC_IRQ_EN_AL);
/* return Power-On Alarm bit */
alm->pending = !!(pdn2 & RTC_PDN2_PWRON_ALARM);
}
void hal_rtc_set_alarm(struct rtc_time *tm)
{
u16 irqen;
hal_rtc_set_alarm_time(tm);
irqen = rtc_read(RTC_IRQ_EN) | RTC_IRQ_EN_ONESHOT_AL;
rtc_write(RTC_IRQ_EN, irqen);
rtc_write_trigger();
}
void hal_rtc_clear_alarm(struct rtc_time *tm)
{
u16 irqsta, irqen, pdn2;
irqen = rtc_read(RTC_IRQ_EN) & ~RTC_IRQ_EN_AL;
pdn2 = rtc_read(RTC_PDN2) & ~RTC_PDN2_PWRON_ALARM;
rtc_write(RTC_IRQ_EN, irqen);
rtc_write(RTC_PDN2, pdn2);
rtc_write_trigger();
irqsta = rtc_read(RTC_IRQ_STA); /* read clear */
hal_rtc_set_alarm_time(tm);
}
void hal_rtc_set_lp_irq(void)
{
u16 irqen;
#ifndef USER_BUILD_KERNEL
irqen = rtc_read(RTC_IRQ_EN) | RTC_IRQ_EN_LP;
#else
irqen = rtc_read(RTC_IRQ_EN) & ~RTC_IRQ_EN_LP;
#endif
rtc_write(RTC_IRQ_EN, irqen);
rtc_write_trigger();
}
void hal_rtc_save_pwron_time(bool enable, struct rtc_time *tm, bool logo)
{
u16 pdn1, pdn2;
hal_rtc_set_pwron_alarm_time(tm);
if (logo)
pdn2 = rtc_read(RTC_PDN2) | RTC_PDN2_PWRON_LOGO;
else
pdn2 = rtc_read(RTC_PDN2) & ~RTC_PDN2_PWRON_LOGO;
rtc_write(RTC_PDN2, pdn2);
if (enable)
pdn1 = rtc_read(RTC_PDN1) | RTC_PDN1_PWRON_TIME;
else
pdn1 = rtc_read(RTC_PDN1) & ~RTC_PDN1_PWRON_TIME;
rtc_write(RTC_PDN1, pdn1);
rtc_write_trigger();
}
void rtc_clock_enable(int enable)
{
if (enable) {
pmic_config_interface_nolock(PMIC_SCK_TOP_CKPDN_CON0_CLR_ADDR,
1,
PMIC_RG_RTC_MCLK_PDN_MASK,
PMIC_RG_RTC_MCLK_PDN_SHIFT);
pmic_config_interface_nolock(PMIC_SCK_TOP_CKPDN_CON0_CLR_ADDR,
1,
PMIC_RG_RTC_32K_CK_PDN_MASK,
PMIC_RG_RTC_32K_CK_PDN_SHIFT);
} else {
pmic_config_interface_nolock(PMIC_SCK_TOP_CKPDN_CON0_SET_ADDR,
1,
PMIC_RG_RTC_MCLK_PDN_MASK,
PMIC_RG_RTC_MCLK_PDN_SHIFT);
pmic_config_interface_nolock(PMIC_SCK_TOP_CKPDN_CON0_SET_ADDR,
1,
PMIC_RG_RTC_32K_CK_PDN_MASK,
PMIC_RG_RTC_32K_CK_PDN_SHIFT);
}
}
void rtc_lpsd_restore_al_mask(void)
{
pr_notice("%s\n", __func__);
rtc_write(RTC_BBPU,
rtc_read(RTC_BBPU) | RTC_BBPU_KEY | RTC_BBPU_RELOAD);
rtc_write_trigger();
pr_notice("1st RTC_AL_MASK = 0x%x\n", rtc_read(RTC_AL_MASK));
/* mask DOW */
rtc_write(RTC_AL_MASK, RTC_AL_MASK_DOW);
rtc_write_trigger();
pr_notice("2nd RTC_AL_MASK = 0x%x\n", rtc_read(RTC_AL_MASK));
}
@@ -0,0 +1,421 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2021 MediaTek Inc.
*/
#ifndef __MT_RTC_HW_H__
#define __MT_RTC_HW_H__
#include <mach/upmu_hw.h>
extern unsigned int pmic_config_interface_nolock(unsigned int RegNum,
unsigned int val, unsigned int MASK, unsigned int SHIFT);
/* RTC registers */
#define RTC_BBPU (PMIC_PWREN_ADDR)
#define RTC_BBPU_PWREN \
(PMIC_PWREN_MASK << PMIC_PWREN_SHIFT)
#define RTC_BBPU_CLR \
(PMIC_BBPU_CLR_MASK << PMIC_BBPU_CLR_SHIFT)
#define RTC_BBPU_INIT \
(PMIC_BBPU_INIT_MASK << PMIC_BBPU_INIT_SHIFT)
#define RTC_BBPU_AUTO \
(PMIC_AUTO_MASK << PMIC_AUTO_SHIFT)
#define RTC_BBPU_CLRPKY \
(PMIC_CLRPKY_MASK << PMIC_CLRPKY_SHIFT)
#define RTC_BBPU_RELOAD \
(PMIC_RELOAD_MASK << PMIC_RELOAD_SHIFT)
#define RTC_BBPU_CBUSY \
(PMIC_CBUSY_MASK << PMIC_CBUSY_SHIFT)
#define RTC_BBPU_KEY \
(0x43 << PMIC_KEY_BBPU_SHIFT)
#define RTC_IRQ_STA (PMIC_ALSTA_ADDR)
#define RTC_IRQ_STA_AL \
(PMIC_ALSTA_MASK << PMIC_ALSTA_SHIFT)
#define RTC_IRQ_STA_TC \
(PMIC_TCSTA_MASK << PMIC_TCSTA_SHIFT)
#define RTC_IRQ_STA_LP \
(PMIC_LPSTA_MASK << PMIC_LPSTA_SHIFT)
#define RTC_IRQ_EN (PMIC_AL_EN_ADDR)
#define RTC_IRQ_EN_AL \
(PMIC_AL_EN_MASK << PMIC_AL_EN_SHIFT)
#define RTC_IRQ_EN_TC \
(PMIC_TC_EN_MASK << PMIC_TC_EN_SHIFT)
#define RTC_IRQ_EN_ONESHOT \
(PMIC_ONESHOT_MASK << PMIC_ONESHOT_SHIFT)
#define RTC_IRQ_EN_LP \
(PMIC_LP_EN_MASK << PMIC_LP_EN_SHIFT)
#define RTC_IRQ_EN_ONESHOT_AL \
(RTC_IRQ_EN_ONESHOT | RTC_IRQ_EN_AL)
#define RTC_CII_EN (PMIC_SECCII_ADDR)
#define RTC_CII_SEC \
(PMIC_SECCII_MASK << PMIC_SECCII_SHIFT)
#define RTC_CII_MIN \
(PMIC_MINCII_MASK << PMIC_MINCII_SHIFT)
#define RTC_CII_HOU \
(PMIC_HOUCII_MASK << PMIC_HOUCII_SHIFT)
#define RTC_CII_DOM \
(PMIC_DOMCII_MASK << PMIC_DOMCII_SHIFT)
#define RTC_CII_DOW \
(PMIC_DOWCII_MASK << PMIC_DOWCII_SHIFT)
#define RTC_CII_MTH \
(PMIC_MTHCII_MASK << PMIC_MTHCII_SHIFT)
#define RTC_CII_YEA \
(PMIC_YEACII_MASK << PMIC_YEACII_SHIFT)
#define RTC_CII_1_2_SEC \
(PMIC_SECCII_1_2_MASK << PMIC_SECCII_1_2_SHIFT)
#define RTC_CII_1_4_SEC \
(PMIC_SECCII_1_4_MASK << PMIC_SECCII_1_4_SHIFT)
#define RTC_CII_1_8_SEC \
(PMIC_SECCII_1_8_MASK << PMIC_SECCII_1_8_SHIFT)
#define RTC_AL_MASK (PMIC_SEC_MSK_ADDR)
#define RTC_AL_MASK_SEC \
(PMIC_SEC_MSK_MASK << PMIC_SEC_MSK_SHIFT)
#define RTC_AL_MASK_MIN \
(PMIC_MIN_MSK_MASK << PMIC_MIN_MSK_SHIFT)
#define RTC_AL_MASK_HOU \
(PMIC_HOU_MSK_MASK << PMIC_HOU_MSK_SHIFT)
#define RTC_AL_MASK_DOM \
(PMIC_DOM_MSK_MASK << PMIC_DOM_MSK_SHIFT)
#define RTC_AL_MASK_DOW \
(PMIC_DOW_MSK_MASK << PMIC_DOW_MSK_SHIFT)
#define RTC_AL_MASK_MTH \
(PMIC_MTH_MSK_MASK << PMIC_MTH_MSK_SHIFT)
#define RTC_AL_MASK_YEA \
(PMIC_YEA_MSK_MASK << PMIC_YEA_MSK_SHIFT)
#define RTC_TC_SEC (PMIC_TC_SECOND_ADDR)
#define RTC_TC_MIN (PMIC_TC_MINUTE_ADDR)
#define RTC_TC_HOU (PMIC_TC_HOUR_ADDR)
#define RTC_TC_DOM (PMIC_TC_DOM_ADDR)
#define RTC_TC_DOW (PMIC_TC_DOW_ADDR)
#define RTC_TC_MTH (PMIC_TC_MONTH_ADDR)
#define RTC_TC_MTH_MASK (PMIC_TC_MONTH_MASK)
#define RTC_TC_YEA (PMIC_TC_YEAR_ADDR)
#define RTC_AL_SEC (PMIC_AL_SECOND_ADDR)
#define RTC_AL_SEC_MASK (PMIC_AL_SECOND_MASK)
#define RTC_BBPU_AUTO_PDN_SEL \
(PMIC_BBPU_AUTO_PDN_SEL_MASK << PMIC_BBPU_AUTO_PDN_SEL_SHIFT)
#define RTC_BBPU_2SEC_CK_SEL \
(PMIC_BBPU_2SEC_CK_SEL_MASK << PMIC_BBPU_2SEC_CK_SEL_SHIFT)
#define RTC_BBPU_2SEC_EN \
(PMIC_BBPU_2SEC_EN_MASK << PMIC_BBPU_2SEC_EN_SHIFT)
#define RTC_BBPU_2SEC_MODE \
(PMIC_BBPU_2SEC_MODE_MASK << PMIC_BBPU_2SEC_MODE_SHIFT)
/* RTC mask include shift */
#define RTC_BBPU_2SEC_MODE_MSK \
(PMIC_BBPU_2SEC_MODE_MASK << PMIC_BBPU_2SEC_MODE_SHIFT)
#define RTC_BBPU_2SEC_MODE_SHIFT (PMIC_BBPU_2SEC_MODE_SHIFT)
#define RTC_BBPU_2SEC_STAT_CLEAR \
(PMIC_BBPU_2SEC_STAT_CLEAR_MASK << PMIC_BBPU_2SEC_STAT_CLEAR_SHIFT)
#define RTC_BBPU_2SEC_STAT_STA \
(PMIC_BBPU_2SEC_STAT_STA_MASK << PMIC_BBPU_2SEC_STAT_STA_SHIFT)
#define RTC_LPD_OPT_SHIFT (PMIC_RTC_LPD_OPT_SHIFT)
#define RTC_LPD_OPT_MASK \
(PMIC_RTC_LPD_OPT_MASK << PMIC_RTC_LPD_OPT_SHIFT)
#define RTC_LPD_OPT_XOSC_AND_EOSC_LPD (0U << PMIC_RTC_LPD_OPT_SHIFT)
#define RTC_LPD_OPT_EOSC_LPD (1U << PMIC_RTC_LPD_OPT_SHIFT)
#define RTC_LPD_OPT_XOSC_LPD (2U << PMIC_RTC_LPD_OPT_SHIFT)
#define RTC_LPD_OPT_F32K_CK_ALIVE (3U << PMIC_RTC_LPD_OPT_SHIFT)
#define RTC_K_EOSC32_VTCXO_ON_SEL \
(PMIC_K_EOSC32_VTCXO_ON_SEL_MASK << PMIC_K_EOSC32_VTCXO_ON_SEL_SHIFT)
#define RTC_AL_MIN (PMIC_AL_MINUTE_ADDR)
#define RTC_AL_MIN_MASK \
(PMIC_AL_MINUTE_MASK << PMIC_AL_MINUTE_SHIFT)
/*
* RTC_NEW_SPARE0: RTC_AL_HOU bit0~4
* bit 8 ~ 15 : For design used, can't be overwrited.
*/
#define RTC_AL_HOU (PMIC_AL_HOUR_ADDR)
#define RTC_AL_HOU_MASK \
(PMIC_AL_HOUR_MASK << PMIC_AL_HOUR_SHIFT)
#define RTC_NEW_SPARE0 \
(PMIC_NEW_SPARE0_MASK << PMIC_NEW_SPARE0_SHIFT)
#define RTC_AL_HOU_FG_SHIFT 8
#define RTC_AL_HOU_FG_MASK 0xff00
/*
* RTC_NEW_SPARE1: RTC_AL_DOM bit0~4
* bit 8 ~ 15 : for 2 second reboot desing used,
* can't be overwrited.
*/
#define RTC_AL_DOM (PMIC_AL_DOM_ADDR)
#define RTC_AL_DOM_MASK \
(PMIC_AL_DOM_MASK << PMIC_AL_DOM_SHIFT)
#define RTC_NEW_SPARE1 \
(PMIC_NEW_SPARE1_MASK << PMIC_NEW_SPARE1_SHIFT)
#define RTC_SPAR_CONDITION (1U << 8) /* by uvlo */
#define RTC_AUTOMATICALLY_SPAR (1U << 9) /* clear by sw */
#define RTC_ALARM_CLEAR_METHOD (1U << 11) /* by sw */
/*
* RTC_NEW_SPARE2: RTC_AL_DOW bit0~2
* bit 8 ~ 15 : reserved bits
*/
#define RTC_AL_DOW (PMIC_AL_DOW_ADDR)
#define RTC_AL_DOW_MASK \
(PMIC_AL_DOW_MASK << PMIC_AL_DOW_SHIFT)
#define RTC_NEW_SPARE2 \
(PMIC_NEW_SPARE2_MASK << PMIC_NEW_SPARE2_SHIFT)
/*
* RTC_NEW_SPARE3: RTC_AL_MTH bit0~3
* bit 8 ~ 15 : Fuel Gauge
*/
#define RTC_AL_MTH (PMIC_AL_MONTH_ADDR)
#define RTC_AL_MTH_MASK \
(PMIC_AL_MONTH_MASK << PMIC_AL_MONTH_SHIFT)
#define RTC_NEW_SPARE3 \
(PMIC_NEW_SPARE3_MASK << PMIC_NEW_SPARE3_SHIFT)
#define RTC_AL_MTH_FG_SHIFT 8
#define RTC_AL_MTH_FG_MASK 0xff00
#define RTC_AL_YEA (PMIC_AL_YEAR_ADDR)
#define RTC_AL_YEA_MASK \
(PMIC_AL_YEAR_MASK << PMIC_AL_YEAR_SHIFT)
#define RTC_K_EOSC_RSV_0 (1U << 8)
#define RTC_K_EOSC_RSV_1 (1U << 9)
#define RTC_K_EOSC_RSV_2 (1U << 10)
#define RTC_K_EOSC_RSV_3 (1U << 11)
#define RTC_K_EOSC_RSV_4 (1U << 12)
#define RTC_K_EOSC_RSV_5 (1U << 13)
#define RTC_K_EOSC_RSV_6 (1U << 14)
#define RTC_K_EOSC_RSV_7 (1U << 15)
#define RTC_OSC32CON (PMIC_XOSCCALI_ADDR)
#define RTC_OSC32CON_UNLOCK1 0x1a57
#define RTC_OSC32CON_UNLOCK2 0x2b68
/*
*Default 4'b0111, 2nd step suggest to set to
* 4'b0000 EOSC_CALI = charging cap calibration
*/
#define RTC_XOSCCALI_MASK \
(PMIC_XOSCCALI_MASK << PMIC_XOSCCALI_SHIFT)
/* 0 (32k crystal exist) 1 (32k crystal doesn't exist)*/
#define RTC_XOSC32_ENB \
(PMIC_RTC_XOSC32_ENB_MASK << PMIC_RTC_XOSC32_ENB_SHIFT)
#define RTC_EMBCK_SEL_MODE \
(PMIC_RTC_EMBCK_SEL_MODE_MASK << PMIC_RTC_EMBCK_SEL_MODE_SHIFT)
#define RTC_EMBCK_SRC_SEL \
(PMIC_RTC_EMBCK_SRC_SEL_MASK << PMIC_RTC_EMBCK_SRC_SEL_SHIFT)
#define RTC_EMBCK_SEL_OPTION \
(PMIC_RTC_EMBCK_SEL_OPTION_MASK << PMIC_RTC_EMBCK_SEL_OPTION_SHIFT)
#define RTC_GPS_CKOUT_EN \
(PMIC_RTC_GPS_CKOUT_EN_MASK << PMIC_RTC_GPS_CKOUT_EN_SHIFT)
#define RTC_EOSC32_VCT_EN \
(PMIC_RTC_EOSC32_VCT_EN_MASK << PMIC_RTC_EOSC32_VCT_EN_SHIFT)
#define RTC_EOSC32_CHOP_EN \
(PMIC_RTC_EOSC32_CHOP_EN_MASK << PMIC_RTC_EOSC32_CHOP_EN_SHIFT)
/*
* Keep RG_EOSC_RSV[0] to low for lower EOSC
* leakage current hardware design change.
*/
#define RTC_GP_OSC32_CON \
(2U << PMIC_RTC_GP_OSC32_CON_SHIFT)
#define RTC_REG_XOSC32_ENB \
(PMIC_RTC_REG_XOSC32_ENB_MASK << PMIC_RTC_REG_XOSC32_ENB_SHIFT)
/* 0: emb_hw 1: emb_k_eosc_32 2:dcxo_ck 3: eosc32_ck*/
#define RTC_EMBCK_SEL_HW \
(0 << PMIC_RTC_EMBCK_SEL_MODE_SHIFT)
#define RTC_EMBCK_SEL_K_EOSC \
(1U << PMIC_RTC_EMBCK_SEL_MODE_SHIFT)
#define RTC_EMBCK_SEL_DCXO \
(2U << PMIC_RTC_EMBCK_SEL_MODE_SHIFT)
#define RTC_EMBCK_SEL_EOSC \
(3U << PMIC_RTC_EMBCK_SEL_MODE_SHIFT)
#define OSC32CON_ANALOG_SETTING \
(RTC_GP_OSC32_CON | RTC_EOSC32_CHOP_EN | RTC_EOSC32_VCT_EN | \
RTC_GPS_CKOUT_EN | RTC_EMBCK_SEL_OPTION | RTC_EMBCK_SEL_K_EOSC)
#define RTC_XOSCCALI_START 0x0000
#define RTC_XOSCCALI_END 0x001f
#define RTC_POWERKEY1 (PMIC_RTC_POWERKEY1_ADDR)
#define RTC_POWERKEY2 (PMIC_RTC_POWERKEY2_ADDR)
#define RTC_POWERKEY1_KEY 0xa357
#define RTC_POWERKEY2_KEY 0x67d2
/*
* RTC_PDN1:
* bit 0 - 3 : Android bits
* bit 4 - 5 : Recovery bits (0x10: factory data reset)
* bit 6 : Bypass PWRKEY bit
* bit 7 : Power-On Time bit
* bit 8 : RTC_GPIO_USER_WIFI bit
* bit 9 : RTC_GPIO_USER_GPS bit
* bit 10 : RTC_GPIO_USER_BT bit
* bit 11 : RTC_GPIO_USER_FM bit
* bit 12 : RTC_GPIO_USER_PMIC bit
* bit 13 : Fast Boot
* bit 14 : Kernel Power Off Charging
* bit 15 : Debug bit
*/
#define RTC_PDN1 (PMIC_RTC_PDN1_ADDR)
#define RTC_PDN1_ANDROID_MASK 0x000f
#define RTC_PDN1_RECOVERY_MASK 0x0030
#define RTC_PDN1_FAC_RESET (1U << 4)
#define RTC_PDN1_BYPASS_PWR (1U << 6)
#define RTC_PDN1_PWRON_TIME (1U << 7)
#define RTC_PDN1_GPIO_WIFI (1U << 8)
#define RTC_PDN1_GPIO_GPS (1U << 9)
#define RTC_PDN1_GPIO_BT (1U << 10)
#define RTC_PDN1_GPIO_FM (1U << 11)
#define RTC_PDN1_GPIO_PMIC (1U << 12)
#define RTC_PDN1_FAST_BOOT (1U << 13)
#define RTC_PDN1_KPOC (1U << 14)
#define RTC_PDN1_DEBUG (1U << 15)
#define RTC_GPIO_USER_MASK (RTC_PDN1_GPIO_WIFI | RTC_PDN1_GPIO_GPS\
| RTC_PDN1_GPIO_BT | RTC_PDN1_GPIO_FM | RTC_PDN1_GPIO_PMIC)
/*
* RTC_PDN2:
* bit 0 - 3 : MTH in power-on time
* bit 4 : Power-On Alarm bit
* bit 5 - 6 : UART bits
* bit 7 : autoboot bit
* bit 8 - 14: YEA in power-on time
* bit 15 : Power-On Logo bit
*/
#define RTC_PDN2 (PMIC_RTC_PDN2_ADDR)
#define RTC_PDN2_PWRON_MTH_MASK 0x000f
#define RTC_PDN2_PWRON_MTH_SHIFT 0
#define RTC_PDN2_PWRON_ALARM (1U << 4)
#define RTC_PDN2_UART_MASK 0x0060
#define RTC_PDN2_UART_SHIFT 5
#define RTC_PDN2_PWRON_YEA_MASK 0x7f00
#define RTC_PDN2_AUTOBOOT (1U << 7)
#define RTC_PDN2_PWRON_YEA_SHIFT 8
#define RTC_PDN2_PWRON_LOGO (1U << 15)
/*
* RTC_SPAR0:
* bit 0 - 5 : SEC in power-on time
* bit 6 : 32K less bit. True:with 32K, False:Without 32K
* bit 7 - 15: reserved bits
*/
#define RTC_SPAR0 (PMIC_RTC_SPAR0_ADDR)
#define RTC_SPAR0_PWRON_SEC_MASK 0x003f
#define RTC_SPAR0_PWRON_SEC_SHIFT 0
#define RTC_SPAR0_32K_LESS (1U << 6)
#define RTC_SPAR0_LP_DET (1U << 7)
/*
* RTC_SPAR1:
* bit 0 - 5 : MIN in power-on time
* bit 6 - 10 : HOU in power-on time
* bit 11 - 15: DOM in power-on time
*/
#define RTC_SPAR1 (PMIC_RTC_SPAR1_ADDR)
#define RTC_SPAR1_PWRON_MIN_MASK 0x003f
#define RTC_SPAR1_PWRON_MIN_SHIFT 0
#define RTC_SPAR1_PWRON_HOU_MASK 0x07c0
#define RTC_SPAR1_PWRON_HOU_SHIFT 6
#define RTC_SPAR1_PWRON_DOM_MASK 0xf800
#define RTC_SPAR1_PWRON_DOM_SHIFT 11
#define RTC_PROT (PMIC_RTC_PROT_ADDR)
#define RTC_PROT_UNLOCK1 0x586a
#define RTC_PROT_UNLOCK2 0x9136
#define RTC_DIFF (PMIC_RTC_DIFF_ADDR)
#define RTC_POWER_DETECTED \
(PMIC_POWER_DETECTED_MASK << PMIC_POWER_DETECTED_SHIFT)
#define RTC_K_EOSC32_RSV \
(PMIC_K_EOSC32_RSV_MASK << PMIC_K_EOSC32_RSV_SHIFT)
#define RTC_CALI_RD_SEL_SHIFT (PMIC_CALI_RD_SEL_SHIFT)
#define RTC_CALI_RD_SEL \
(PMIC_CALI_RD_SEL_MASK << PMIC_CALI_RD_SEL_SHIFT)
#define RTC_CALI (PMIC_RTC_CALI_ADDR)
#define RTC_CALI_MASK \
(PMIC_RTC_CALI_MASK << PMIC_RTC_CALI_SHIFT)
#define RTC_CALI_WR_SEL \
(PMIC_CALI_WR_SEL_MASK << PMIC_CALI_WR_SEL_SHIFT)
#define RTC_CALI_WR_SEL_SHIFT (PMIC_CALI_WR_SEL_SHIFT)
#define RTC_K_EOSC32_OVERFLOW \
(PMIC_K_EOSC32_OVERFLOW_MASK << PMIC_K_EOSC32_OVERFLOW_SHIFT)
#define RTC_WRTGR (PMIC_WRTGR_ADDR)
#define RTC_CON \
(PMIC_VBAT_LPSTA_RAW_ADDR)
#define RTC_VBAT_LPSTA_RAW \
(PMIC_VBAT_LPSTA_RAW_MASK << PMIC_VBAT_LPSTA_RAW_SHIFT)
#define RTC_EOSC32_LPEN \
(PMIC_EOSC32_LPEN_MASK << PMIC_EOSC32_LPEN_SHIFT)
#define RTC_XOSC32_LPEN \
(PMIC_XOSC32_LPEN_MASK << PMIC_XOSC32_LPEN_SHIFT)
#define RTC_CON_LPRST \
(PMIC_LPRST_MASK << PMIC_LPRST_SHIFT)
#define RTC_CON_CDBO \
(PMIC_CDBO_MASK << PMIC_CDBO_SHIFT)
#define RTC_CON_F32KOB \
(PMIC_F32KOB_MASK << PMIC_F32KOB_SHIFT) /* 0: RTC_GPIO exports 32K */
#define RTC_CON_GPO \
(PMIC_GPO_MASK << PMIC_GPO_SHIFT)
/* 1: GPO mode, 0: GPI mode */
#define RTC_CON_GOE \
(PMIC_GOE_MASK << PMIC_GOE_SHIFT)
#define RTC_CON_GSR \
(PMIC_GSR_MASK << PMIC_GSR_SHIFT)
#define RTC_CON_GSMT \
(PMIC_GSMT_MASK << PMIC_GSMT_SHIFT)
#define RTC_CON_GPEN \
(PMIC_GPEN_MASK << PMIC_GPEN_SHIFT)
#define RTC_CON_GPU \
(PMIC_GPU_MASK << PMIC_GPU_SHIFT)
#define RTC_CON_GE4 \
(PMIC_GE4_MASK << PMIC_GE4_SHIFT)
#define RTC_CON_GE8 \
(PMIC_GE8_MASK << PMIC_GE8_SHIFT)
#define RTC_CON_GPI \
(PMIC_GPI_MASK << PMIC_GPI_SHIFT)
#define RTC_CON_LPSTA_RAW \
(PMIC_LPSTA_RAW_MASK << PMIC_LPSTA_RAW_SHIFT) /* 32K was stopped */
#define RTC_INT_CNT (PMIC_RTC_INT_CNT_ADDR)
/* power on alarm time setting */
#define RTC_PWRON_YEA RTC_PDN2
#define RTC_PWRON_YEA_MASK 0x7f00
#define RTC_PWRON_YEA_SHIFT 8
#define RTC_PWRON_MTH RTC_PDN2
#define RTC_PWRON_MTH_MASK 0x000f
#define RTC_PWRON_MTH_SHIFT 0
#define RTC_PWRON_SEC RTC_SPAR0
#define RTC_PWRON_SEC_MASK 0x003f
#define RTC_PWRON_SEC_SHIFT 0
#define RTC_PWRON_MIN RTC_SPAR1
#define RTC_PWRON_MIN_MASK 0x003f
#define RTC_PWRON_MIN_SHIFT 0
#define RTC_PWRON_HOU RTC_SPAR1
#define RTC_PWRON_HOU_MASK 0x07c0
#define RTC_PWRON_HOU_SHIFT 6
#define RTC_PWRON_DOM RTC_SPAR1
#define RTC_PWRON_DOM_MASK 0xf800
#define RTC_PWRON_DOM_SHIFT 11
extern u16 rtc_spare_reg[][3];
#endif /* __MT_RTC_HW_H__ */
+18
View File
@@ -0,0 +1,18 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that 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.
#
ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6358
obj-$(CONFIG_MTK_RTC) := mtk_rtc_hal.o
@@ -0,0 +1,466 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2021 MediaTek Inc.
*/
#ifdef pr_fmt
#undef pr_fmt
#endif
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/rtc.h>
#include <mach/upmu_hw.h>
#include <linux/spinlock.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/types.h>
#include <linux/sched/clock.h>
#include <mtk_rtc_hal_common.h>
#include "mtk_rtc_hw.h"
#include <mach/mtk_pmic_wrap.h>
#include <mtk_boot.h>
#include "include/pmic.h"
#define hal_rtc_xinfo(fmt, args...) \
pr_notice(fmt, ##args)
/*TODO extern bool pmic_chrdet_status(void);*/
/*
* RTC_FGSOC = 0,
* RTC_ANDROID,
* RTC_RECOVERY,
* RTC_FAC_RESET,
* RTC_BYPASS_PWR,
* RTC_PWRON_TIME,
* RTC_FAST_BOOT,
* RTC_KPOC,
* RTC_DEBUG,
* RTC_PWRON_AL,
* RTC_UART,
* RTC_AUTOBOOT,
* RTC_PWRON_LOGO,
* RTC_32K_LESS,
* RTC_LP_DET,
* RTC_SPAR_NUM
*
*/
/*
* RTC_PDN1:
* bit 0 - 3 : Android bits
* bit 4 - 5 : Recovery bits (0x10: factory data reset)
* bit 6 : Bypass PWRKEY bit
* bit 7 : Power-On Time bit
* bit 8 : RTC_GPIO_USER_WIFI bit
* bit 9 : RTC_GPIO_USER_GPS bit
* bit 10 : RTC_GPIO_USER_BT bit
* bit 11 : RTC_GPIO_USER_FM bit
* bit 12 : RTC_GPIO_USER_PMIC bit
* bit 13 : Fast Boot
* bit 14 : Kernel Power Off Charging
* bit 15 : Debug bit
*/
/*
* RTC_PDN2:
* bit 0 - 3 : MTH in power-on time
* bit 4 : Power-On Alarm bit
* bit 5 - 6 : UART bits
* bit 7 : autoboot bit
* bit 8 - 14: YEA in power-on time
* bit 15 : Power-On Logo bit
*/
/*
* RTC_SPAR0:
* bit 0 - 5 : SEC in power-on time
* bit 6 : 32K less bit. True:with 32K, False:Without 32K
* bit 7 - 15: reserved bits
*/
u16 rtc_spare_reg[RTC_SPAR_NUM][3] = {
{RTC_AL_MTH, 0xff, 8},
{RTC_PDN1, 0xf, 0},
{RTC_PDN1, 0x3, 4},
{RTC_PDN1, 0x1, 6},
{RTC_PDN1, 0x1, 7},
{RTC_PDN1, 0x1, 13},
{RTC_PDN1, 0x1, 14},
{RTC_PDN1, 0x1, 15},
{RTC_PDN2, 0x1, 4},
{RTC_PDN2, 0x3, 5},
{RTC_PDN2, 0x1, 7},
{RTC_PDN2, 0x1, 15},
{RTC_SPAR0, 0x1, 6},
{RTC_SPAR0, 0x1, 7},
{RTC_AL_HOU, 0xff, 8}
};
static int rtc_eosc_cali_td = 8;
module_param(rtc_eosc_cali_td, int, 0664);
void hal_rtc_set_abb_32k(u16 enable)
{
hal_rtc_xinfo("ABB 32k not support\n");
}
u16 hal_rtc_get_gpio_32k_status(void)
{
u16 con;
con = rtc_read(RTC_CON);
hal_rtc_xinfo("RTC_GPIO 32k status(RTC_CON=0x%x)\n", con);
if (con & RTC_CON_F32KOB)
return 0;
else
return 1;
}
void hal_rtc_set_gpio_32k_status(u16 user, bool enable)
{
u16 con, pdn1;
if (enable) {
pdn1 = rtc_read(RTC_PDN1);
} else {
pdn1 = rtc_read(RTC_PDN1) & ~(1U << user);
rtc_write(RTC_PDN1, pdn1);
rtc_write_trigger();
}
con = rtc_read(RTC_CON);
if (enable) {
con &= ~RTC_CON_F32KOB;
} else {
if (!(pdn1 & RTC_GPIO_USER_MASK)) { /* no users */
con |= RTC_CON_F32KOB;
}
}
rtc_write(RTC_CON, con);
rtc_write_trigger();
if (enable) {
pdn1 |= (1U << user);
rtc_write(RTC_PDN1, pdn1);
rtc_write_trigger();
}
hal_rtc_xinfo("RTC_GPIO user %d enable = %d 32k (0x%x), RTC_CON = %x\n",
user, enable, pdn1, rtc_read(RTC_CON));
}
void rtc_spar_alarm_clear_wait(void)
{
unsigned long long timeout = sched_clock() + 500000000;
do {
if ((rtc_read(RTC_BBPU) & RTC_BBPU_CLR) == 0)
break;
else if (sched_clock() > timeout) {
hal_rtc_xinfo("%s, spar/alarm clear time out, %x,\n",
__func__, rtc_read(RTC_BBPU));
break;
}
} while (1);
}
void rtc_enable_k_eosc(void)
{
#if 0
u16 osc32;
#endif
/* Truning on eosc cali mode clock */
pmic_config_interface_nolock(PMIC_SCK_TOP_CKPDN_CON0_CLR_ADDR, 1,
PMIC_RG_RTC_EOSC32_CK_PDN_MASK,
PMIC_RG_RTC_EOSC32_CK_PDN_SHIFT);
#if 0
pmic_config_interface_nolock(PMIC_RG_SRCLKEN_IN0_HW_MODE_ADDR, 1,
PMIC_RG_SRCLKEN_IN0_HW_MODE_MASK,
PMIC_RG_SRCLKEN_IN0_HW_MODE_SHIFT);
pmic_config_interface_nolock(PMIC_RG_SRCLKEN_IN1_HW_MODE_ADDR, 1,
PMIC_RG_SRCLKEN_IN1_HW_MODE_MASK,
PMIC_RG_SRCLKEN_IN1_HW_MODE_SHIFT);
pmic_config_interface_nolock(PMIC_RG_RTC_EOSC32_CK_PDN_ADDR, 0,
PMIC_RG_RTC_EOSC32_CK_PDN_MASK,
PMIC_RG_RTC_EOSC32_CK_PDN_SHIFT);
#endif
if (rtc_eosc_cali_td != 8) {
pr_notice("%s set eosc_cali_td = %d\n",
__func__, rtc_eosc_cali_td);
switch (rtc_eosc_cali_td) {
case 1:
pmic_config_interface_nolock(PMIC_EOSC_CALI_TD_ADDR,
0x3,
PMIC_EOSC_CALI_TD_MASK,
PMIC_EOSC_CALI_TD_SHIFT);
break;
case 2:
pmic_config_interface_nolock(PMIC_EOSC_CALI_TD_ADDR,
0x4,
PMIC_EOSC_CALI_TD_MASK,
PMIC_EOSC_CALI_TD_SHIFT);
break;
case 4:
pmic_config_interface_nolock(PMIC_EOSC_CALI_TD_ADDR,
0x5,
PMIC_EOSC_CALI_TD_MASK,
PMIC_EOSC_CALI_TD_SHIFT);
break;
case 16:
pmic_config_interface_nolock(PMIC_EOSC_CALI_TD_ADDR,
0x7,
PMIC_EOSC_CALI_TD_MASK,
PMIC_EOSC_CALI_TD_SHIFT);
break;
default:
pmic_config_interface_nolock(PMIC_EOSC_CALI_TD_ADDR,
0x6,
PMIC_EOSC_CALI_TD_MASK,
PMIC_EOSC_CALI_TD_SHIFT);
break;
}
}
/*Switch the DCXO from 32k-less mode to RTC mode,
*otherwise, EOSC cali will fail
*/
/*RTC mode will have only OFF mode and FPM */
pmic_config_interface_nolock(PMIC_XO_EN32K_MAN_ADDR, 0,
PMIC_XO_EN32K_MAN_MASK,
PMIC_XO_EN32K_MAN_SHIFT);
#if 0
rtc_write(RTC_BBPU,
rtc_read(RTC_BBPU) | RTC_BBPU_KEY | RTC_BBPU_RELOAD);
rtc_write_trigger();
/* Enable K EOSC mode for normal power off and then plug out battery */
rtc_write(RTC_AL_YEA,
((rtc_read(RTC_AL_YEA) | RTC_K_EOSC_RSV_0) &
(~RTC_K_EOSC_RSV_1)) | RTC_K_EOSC_RSV_2);
rtc_write_trigger();
osc32 = rtc_read(RTC_OSC32CON);
rtc_xosc_write(osc32 | RTC_EMBCK_SRC_SEL, true);
#endif
hal_rtc_xinfo("RTC_enable_k_eosc\n");
}
#if 0
void rtc_disable_2sec_reboot(void)
{
u16 reboot;
reboot =
(rtc_read(RTC_AL_SEC) & ~RTC_BBPU_2SEC_EN) & ~RTC_BBPU_AUTO_PDN_SEL;
rtc_write(RTC_AL_SEC, reboot);
rtc_write_trigger();
}
#endif
void rtc_bbpu_pwrdown(bool auto_boot)
{
PMIC_POWER_HOLD(0);
}
void hal_rtc_bbpu_pwdn(bool charger_status)
{
u16 con, bbpu;
#if 0
rtc_disable_2sec_reboot();
#endif
rtc_enable_k_eosc();
/* disable 32K export if there are no RTC_GPIO users */
if (!(rtc_read(RTC_PDN1) & RTC_GPIO_USER_MASK)) {
con = rtc_read(RTC_CON) | RTC_CON_F32KOB;
rtc_write(RTC_CON, con);
rtc_write_trigger();
}
/* lpsd */
hal_rtc_xinfo("clear lpsd solution\n");
bbpu = RTC_BBPU_KEY | RTC_BBPU_CLR | RTC_BBPU_PWREN;
rtc_write(RTC_BBPU, bbpu);
rtc_write(RTC_AL_MASK, RTC_AL_MASK_DOW); /* mask DOW */
rtc_write_trigger();
rtc_spar_alarm_clear_wait();
wk_pmic_enable_sdn_delay();
rtc_write(RTC_BBPU,
rtc_read(RTC_BBPU) | RTC_BBPU_KEY | RTC_BBPU_RELOAD);
rtc_write_trigger();
hal_rtc_xinfo("RTC_AL_MASK= 0x%x RTC_IRQ_EN= 0x%x\n",
rtc_read(RTC_AL_MASK), rtc_read(RTC_IRQ_EN));
/* lpsd */
rtc_bbpu_pwrdown(true);
}
void hal_rtc_get_pwron_alarm(struct rtc_time *tm, struct rtc_wkalrm *alm)
{
u16 pdn1, pdn2;
pdn1 = rtc_read(RTC_PDN1);
pdn2 = rtc_read(RTC_PDN2);
alm->enabled =
(pdn1 & RTC_PDN1_PWRON_TIME ? (pdn2 & RTC_PDN2_PWRON_LOGO ? 3 : 2) :
0);
/* return Power-On Alarm bit */
alm->pending = !!(pdn2 & RTC_PDN2_PWRON_ALARM);
hal_rtc_get_alarm_time(tm);
}
bool hal_rtc_is_lp_irq(void)
{
u16 irqsta;
irqsta = rtc_read(RTC_IRQ_STA); /* read clear */
if (unlikely(!(irqsta & RTC_IRQ_STA_AL))) {
#ifndef USER_BUILD_KERNEL
if (irqsta & RTC_IRQ_STA_LP)
rtc_lp_exception();
#endif
return true;
}
return false;
}
bool hal_rtc_is_pwron_alarm(struct rtc_time *nowtm, struct rtc_time *tm)
{
u16 pdn1;
pdn1 = rtc_read(RTC_PDN1);
hal_rtc_xinfo("pdn1 = 0x%4x\n", pdn1);
if (pdn1 & RTC_PDN1_PWRON_TIME) { /* power-on time is available */
hal_rtc_xinfo("pdn1 = 0x%4x\n", pdn1);
hal_rtc_get_tick_time(nowtm);
hal_rtc_xinfo("pdn1 = 0x%4x\n", pdn1);
/* SEC has carried */
if (rtc_read(RTC_TC_SEC) < nowtm->tm_sec)
hal_rtc_get_tick_time(nowtm);
hal_rtc_get_pwron_alarm_time(tm);
return true;
}
return false;
}
void hal_rtc_get_alarm(struct rtc_time *tm, struct rtc_wkalrm *alm)
{
u16 irqen, pdn2;
irqen = rtc_read(RTC_IRQ_EN);
hal_rtc_get_alarm_time(tm);
pdn2 = rtc_read(RTC_PDN2);
alm->enabled = !!(irqen & RTC_IRQ_EN_AL);
/* return Power-On Alarm bit */
alm->pending = !!(pdn2 & RTC_PDN2_PWRON_ALARM);
}
void hal_rtc_set_alarm(struct rtc_time *tm)
{
u16 irqen;
hal_rtc_set_alarm_time(tm);
irqen = rtc_read(RTC_IRQ_EN) | RTC_IRQ_EN_ONESHOT_AL;
rtc_write(RTC_IRQ_EN, irqen);
rtc_write_trigger();
}
void hal_rtc_clear_alarm(struct rtc_time *tm)
{
u16 irqsta, irqen, pdn2;
irqen = rtc_read(RTC_IRQ_EN) & ~RTC_IRQ_EN_AL;
pdn2 = rtc_read(RTC_PDN2) & ~RTC_PDN2_PWRON_ALARM;
rtc_write(RTC_IRQ_EN, irqen);
rtc_write(RTC_PDN2, pdn2);
rtc_write_trigger();
irqsta = rtc_read(RTC_IRQ_STA); /* read clear */
hal_rtc_set_alarm_time(tm);
}
void hal_rtc_set_lp_irq(void)
{
u16 irqen;
#ifndef USER_BUILD_KERNEL
irqen = rtc_read(RTC_IRQ_EN) | RTC_IRQ_EN_LP;
#else
irqen = rtc_read(RTC_IRQ_EN) & ~RTC_IRQ_EN_LP;
#endif
rtc_write(RTC_IRQ_EN, irqen);
rtc_write_trigger();
}
void hal_rtc_save_pwron_time(bool enable, struct rtc_time *tm, bool logo)
{
u16 pdn1, pdn2;
hal_rtc_set_pwron_alarm_time(tm);
if (logo)
pdn2 = rtc_read(RTC_PDN2) | RTC_PDN2_PWRON_LOGO;
else
pdn2 = rtc_read(RTC_PDN2) & ~RTC_PDN2_PWRON_LOGO;
rtc_write(RTC_PDN2, pdn2);
if (enable)
pdn1 = rtc_read(RTC_PDN1) | RTC_PDN1_PWRON_TIME;
else
pdn1 = rtc_read(RTC_PDN1) & ~RTC_PDN1_PWRON_TIME;
rtc_write(RTC_PDN1, pdn1);
rtc_write_trigger();
}
void rtc_clock_enable(int enable)
{
if (enable) {
pmic_config_interface_nolock(PMIC_SCK_TOP_CKPDN_CON0_CLR_ADDR,
1, PMIC_RG_RTC_MCLK_PDN_MASK,
PMIC_RG_RTC_MCLK_PDN_SHIFT);
pmic_config_interface_nolock(PMIC_SCK_TOP_CKPDN_CON0_CLR_ADDR,
1, PMIC_RG_RTC_32K_CK_PDN_MASK,
PMIC_RG_RTC_32K_CK_PDN_SHIFT);
} else {
pmic_config_interface_nolock(PMIC_SCK_TOP_CKPDN_CON0_SET_ADDR,
1, PMIC_RG_RTC_MCLK_PDN_MASK,
PMIC_RG_RTC_MCLK_PDN_SHIFT);
pmic_config_interface_nolock(PMIC_SCK_TOP_CKPDN_CON0_SET_ADDR,
1, PMIC_RG_RTC_32K_CK_PDN_MASK,
PMIC_RG_RTC_32K_CK_PDN_SHIFT);
}
}
void rtc_lpsd_restore_al_mask(void)
{
hal_rtc_xinfo("%s\n", __func__);
rtc_write(RTC_BBPU,
rtc_read(RTC_BBPU) | RTC_BBPU_KEY | RTC_BBPU_RELOAD);
rtc_write_trigger();
hal_rtc_xinfo("1st RTC_AL_MASK = 0x%x\n", rtc_read(RTC_AL_MASK));
/* mask DOW */
rtc_write(RTC_AL_MASK, RTC_AL_MASK_DOW);
rtc_write_trigger();
hal_rtc_xinfo("2nd RTC_AL_MASK = 0x%x\n", rtc_read(RTC_AL_MASK));
}
@@ -0,0 +1,373 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2021 MediaTek Inc.
*/
#ifndef __MT_RTC_HW_H__
#define __MT_RTC_HW_H__
#include <mach/upmu_hw.h>
extern unsigned int pmic_config_interface_nolock(unsigned int RegNum,
unsigned int val, unsigned int MASK, unsigned int SHIFT);
/* RTC registers */
#define RTC_BBPU (PMIC_PWREN_ADDR)
#define RTC_BBPU_PWREN (PMIC_PWREN_MASK << PMIC_PWREN_SHIFT)
#define RTC_BBPU_CLR (PMIC_BBPU_CLR_MASK << PMIC_BBPU_CLR_SHIFT)
#define RTC_BBPU_INIT (PMIC_BBPU_INIT_MASK << PMIC_BBPU_INIT_SHIFT)
#define RTC_BBPU_AUTO (PMIC_AUTO_MASK << PMIC_AUTO_SHIFT)
#define RTC_BBPU_CLRPKY (PMIC_CLRPKY_MASK << PMIC_CLRPKY_SHIFT)
#define RTC_BBPU_RELOAD (PMIC_RELOAD_MASK << PMIC_RELOAD_SHIFT)
#define RTC_BBPU_CBUSY (PMIC_CBUSY_MASK << PMIC_CBUSY_SHIFT)
#define RTC_BBPU_KEY (0x43 << PMIC_KEY_BBPU_SHIFT)
#define RTC_IRQ_STA (PMIC_ALSTA_ADDR)
#define RTC_IRQ_STA_AL (PMIC_ALSTA_MASK << PMIC_ALSTA_SHIFT)
#define RTC_IRQ_STA_TC (PMIC_TCSTA_MASK << PMIC_TCSTA_SHIFT)
#define RTC_IRQ_STA_LP (PMIC_LPSTA_MASK << PMIC_LPSTA_SHIFT)
#define RTC_IRQ_EN (PMIC_AL_EN_ADDR)
#define RTC_IRQ_EN_AL (PMIC_AL_EN_MASK << PMIC_AL_EN_SHIFT)
#define RTC_IRQ_EN_TC (PMIC_TC_EN_MASK << PMIC_TC_EN_SHIFT)
#define RTC_IRQ_EN_ONESHOT (PMIC_ONESHOT_MASK << PMIC_ONESHOT_SHIFT)
#define RTC_IRQ_EN_LP (PMIC_LP_EN_MASK << PMIC_LP_EN_SHIFT)
#define RTC_IRQ_EN_ONESHOT_AL (RTC_IRQ_EN_ONESHOT | RTC_IRQ_EN_AL)
#define RTC_CII_EN (PMIC_SECCII_ADDR)
#define RTC_CII_SEC (PMIC_SECCII_MASK << PMIC_SECCII_SHIFT)
#define RTC_CII_MIN (PMIC_MINCII_MASK << PMIC_MINCII_SHIFT)
#define RTC_CII_HOU (PMIC_HOUCII_MASK << PMIC_HOUCII_SHIFT)
#define RTC_CII_DOM (PMIC_DOMCII_MASK << PMIC_DOMCII_SHIFT)
#define RTC_CII_DOW (PMIC_DOWCII_MASK << PMIC_DOWCII_SHIFT)
#define RTC_CII_MTH (PMIC_MTHCII_MASK << PMIC_MTHCII_SHIFT)
#define RTC_CII_YEA (PMIC_YEACII_MASK << PMIC_YEACII_SHIFT)
#define RTC_CII_1_2_SEC (PMIC_SECCII_1_2_MASK << PMIC_SECCII_1_2_SHIFT)
#define RTC_CII_1_4_SEC (PMIC_SECCII_1_4_MASK << PMIC_SECCII_1_4_SHIFT)
#define RTC_CII_1_8_SEC (PMIC_SECCII_1_8_MASK << PMIC_SECCII_1_8_SHIFT)
#define RTC_AL_MASK (PMIC_SEC_MSK_ADDR)
#define RTC_AL_MASK_SEC (PMIC_SEC_MSK_MASK << PMIC_SEC_MSK_SHIFT)
#define RTC_AL_MASK_MIN (PMIC_MIN_MSK_MASK << PMIC_MIN_MSK_SHIFT)
#define RTC_AL_MASK_HOU (PMIC_HOU_MSK_MASK << PMIC_HOU_MSK_SHIFT)
#define RTC_AL_MASK_DOM (PMIC_DOM_MSK_MASK << PMIC_DOM_MSK_SHIFT)
#define RTC_AL_MASK_DOW (PMIC_DOW_MSK_MASK << PMIC_DOW_MSK_SHIFT)
#define RTC_AL_MASK_MTH (PMIC_MTH_MSK_MASK << PMIC_MTH_MSK_SHIFT)
#define RTC_AL_MASK_YEA (PMIC_YEA_MSK_MASK << PMIC_YEA_MSK_SHIFT)
#define RTC_TC_SEC (PMIC_TC_SECOND_ADDR)
#define RTC_TC_MIN (PMIC_TC_MINUTE_ADDR)
#define RTC_TC_HOU (PMIC_TC_HOUR_ADDR)
#define RTC_TC_DOM (PMIC_TC_DOM_ADDR)
#define RTC_TC_DOW (PMIC_TC_DOW_ADDR)
#define RTC_TC_MTH (PMIC_TC_MONTH_ADDR)
#define RTC_TC_MTH_MASK (PMIC_TC_MONTH_MASK)
#define RTC_TC_YEA (PMIC_TC_YEAR_ADDR)
#define RTC_AL_SEC \
(PMIC_AL_SECOND_ADDR)
#define RTC_AL_SEC_MASK \
(PMIC_AL_SECOND_MASK)
#define RTC_BBPU_AUTO_PDN_SEL \
(PMIC_BBPU_AUTO_PDN_SEL_MASK << PMIC_BBPU_AUTO_PDN_SEL_SHIFT)
#define RTC_BBPU_2SEC_CK_SEL \
(PMIC_BBPU_2SEC_CK_SEL_MASK << PMIC_BBPU_2SEC_CK_SEL_SHIFT)
#define RTC_BBPU_2SEC_EN \
(PMIC_BBPU_2SEC_EN_MASK << PMIC_BBPU_2SEC_EN_SHIFT)
#define RTC_BBPU_2SEC_MODE \
(PMIC_BBPU_2SEC_MODE_MASK << PMIC_BBPU_2SEC_MODE_SHIFT)
/* RTC mask include shift */
#define RTC_BBPU_2SEC_MODE_MSK \
(PMIC_BBPU_2SEC_MODE_MASK << PMIC_BBPU_2SEC_MODE_SHIFT)
#define RTC_BBPU_2SEC_MODE_SHIFT (PMIC_BBPU_2SEC_MODE_SHIFT)
#define RTC_BBPU_2SEC_STAT_CLEAR \
(PMIC_BBPU_2SEC_STAT_CLEAR_MASK << PMIC_BBPU_2SEC_STAT_CLEAR_SHIFT)
#define RTC_BBPU_2SEC_STAT_STA \
(PMIC_BBPU_2SEC_STAT_STA_MASK << PMIC_BBPU_2SEC_STAT_STA_SHIFT)
#define RTC_LPD_OPT_SHIFT (PMIC_RTC_LPD_OPT_SHIFT)
#define RTC_LPD_OPT_MASK \
(PMIC_RTC_LPD_OPT_MASK << PMIC_RTC_LPD_OPT_SHIFT)
#define RTC_LPD_OPT_XOSC_AND_EOSC_LPD (0U << PMIC_RTC_LPD_OPT_SHIFT)
#define RTC_LPD_OPT_EOSC_LPD (1U << PMIC_RTC_LPD_OPT_SHIFT)
#define RTC_LPD_OPT_XOSC_LPD (2U << PMIC_RTC_LPD_OPT_SHIFT)
#define RTC_LPD_OPT_F32K_CK_ALIVE (3U << PMIC_RTC_LPD_OPT_SHIFT)
#define RTC_K_EOSC32_VTCXO_ON_SEL \
(PMIC_K_EOSC32_VTCXO_ON_SEL_MASK << PMIC_K_EOSC32_VTCXO_ON_SEL_SHIFT)
#define RTC_AL_MIN (PMIC_AL_MINUTE_ADDR)
#define RTC_AL_MIN_MASK \
(PMIC_AL_MINUTE_MASK << PMIC_AL_MINUTE_SHIFT)
/*
* RTC_NEW_SPARE0: RTC_AL_HOU bit0~4
* bit 8 ~ 15 : For design used, can't be overwrited.
*/
#define RTC_AL_HOU (PMIC_AL_HOUR_ADDR)
#define RTC_AL_HOU_MASK \
(PMIC_AL_HOUR_MASK << PMIC_AL_HOUR_SHIFT)
#define RTC_NEW_SPARE0 \
(PMIC_NEW_SPARE0_MASK << PMIC_NEW_SPARE0_SHIFT)
#define RTC_AL_HOU_FG_SHIFT 8
#define RTC_AL_HOU_FG_MASK 0xff00
/*
* RTC_NEW_SPARE1: RTC_AL_DOM bit0~4
* bit 8 ~ 15 : for 2 second reboot desing used,
* can't be overwrited.
*/
#define RTC_AL_DOM (PMIC_AL_DOM_ADDR)
#define RTC_AL_DOM_MASK \
(PMIC_AL_DOM_MASK << PMIC_AL_DOM_SHIFT)
#define RTC_NEW_SPARE1 \
(PMIC_NEW_SPARE1_MASK << PMIC_NEW_SPARE1_SHIFT)
#define RTC_SPAR_CONDITION (1U << 8) /* by uvlo */
#define RTC_AUTOMATICALLY_SPAR (1U << 9) /* clear by sw */
#define RTC_ALARM_CLEAR_METHOD (1U << 11) /* by sw */
/*
* RTC_NEW_SPARE2: RTC_AL_DOW bit0~2
* bit 8 ~ 15 : reserved bits
*/
#define RTC_AL_DOW (PMIC_AL_DOW_ADDR)
#define RTC_AL_DOW_MASK \
(PMIC_AL_DOW_MASK << PMIC_AL_DOW_SHIFT)
#define RTC_NEW_SPARE2 \
(PMIC_NEW_SPARE2_MASK << PMIC_NEW_SPARE2_SHIFT)
/*
* RTC_NEW_SPARE3: RTC_AL_MTH bit0~3
* bit 8 ~ 15 : Fuel Gauge
*/
#define RTC_AL_MTH (PMIC_AL_MONTH_ADDR)
#define RTC_AL_MTH_MASK \
(PMIC_AL_MONTH_MASK << PMIC_AL_MONTH_SHIFT)
#define RTC_NEW_SPARE3 \
(PMIC_NEW_SPARE3_MASK << PMIC_NEW_SPARE3_SHIFT)
#define RTC_AL_MTH_FG_SHIFT 8
#define RTC_AL_MTH_FG_MASK 0xff00
#define RTC_AL_YEA (PMIC_AL_YEAR_ADDR)
#define RTC_AL_YEA_MASK \
(PMIC_AL_YEAR_MASK << PMIC_AL_YEAR_SHIFT)
#define RTC_K_EOSC_RSV_0 (1U << 8)
#define RTC_K_EOSC_RSV_1 (1U << 9)
#define RTC_K_EOSC_RSV_2 (1U << 10)
#define RTC_K_EOSC_RSV_3 (1U << 11)
#define RTC_K_EOSC_RSV_4 (1U << 12)
#define RTC_K_EOSC_RSV_5 (1U << 13)
#define RTC_K_EOSC_RSV_6 (1U << 14)
#define RTC_K_EOSC_RSV_7 (1U << 15)
#define RTC_OSC32CON (PMIC_XOSCCALI_ADDR)
#define RTC_OSC32CON_UNLOCK1 0x1a57
#define RTC_OSC32CON_UNLOCK2 0x2b68
/*Default 4'b0111, 2nd step suggest to set
*to 4'b0000 EOSC_CALI = charging cap calibration
*/
#define RTC_XOSCCALI_MASK \
(PMIC_XOSCCALI_MASK << PMIC_XOSCCALI_SHIFT)
/* 0 (32k crystal exist) 1 (32k crystal doesn't exist)*/
#define RTC_XOSC32_ENB \
(PMIC_RTC_XOSC32_ENB_MASK << PMIC_RTC_XOSC32_ENB_SHIFT)
#define RTC_EMBCK_SEL_MODE \
(PMIC_RTC_EMBCK_SEL_MODE_MASK << PMIC_RTC_EMBCK_SEL_MODE_SHIFT)
#define RTC_EMBCK_SRC_SEL \
(PMIC_RTC_EMBCK_SRC_SEL_MASK << PMIC_RTC_EMBCK_SRC_SEL_SHIFT)
#define RTC_EMBCK_SEL_OPTION \
(PMIC_RTC_EMBCK_SEL_OPTION_MASK << PMIC_RTC_EMBCK_SEL_OPTION_SHIFT)
#define RTC_GPS_CKOUT_EN \
(PMIC_RTC_GPS_CKOUT_EN_MASK << PMIC_RTC_GPS_CKOUT_EN_SHIFT)
#define RTC_EOSC32_VCT_EN \
(PMIC_RTC_EOSC32_VCT_EN_MASK << PMIC_RTC_EOSC32_VCT_EN_SHIFT)
#define RTC_EOSC32_CHOP_EN \
(PMIC_RTC_EOSC32_CHOP_EN_MASK << PMIC_RTC_EOSC32_CHOP_EN_SHIFT)
/* Keep RG_EOSC_RSV[0] to low for lower EOSC
*leakage current hardware design change.
*/
#define RTC_GP_OSC32_CON \
(2U << PMIC_RTC_GP_OSC32_CON_SHIFT)
#define RTC_REG_XOSC32_ENB \
(PMIC_RTC_REG_XOSC32_ENB_MASK << PMIC_RTC_REG_XOSC32_ENB_SHIFT)
/* 0: emb_hw 1: emb_k_eosc_32 2:dcxo_ck 3: eosc32_ck*/
#define RTC_EMBCK_SEL_HW (0 << PMIC_RTC_EMBCK_SEL_MODE_SHIFT)
#define RTC_EMBCK_SEL_K_EOSC (1U << PMIC_RTC_EMBCK_SEL_MODE_SHIFT)
#define RTC_EMBCK_SEL_DCXO (2U << PMIC_RTC_EMBCK_SEL_MODE_SHIFT)
#define RTC_EMBCK_SEL_EOSC (3U << PMIC_RTC_EMBCK_SEL_MODE_SHIFT)
#define OSC32CON_ANALOG_SETTING (RTC_GP_OSC32_CON | RTC_EOSC32_CHOP_EN | \
RTC_EOSC32_VCT_EN | RTC_GPS_CKOUT_EN | \
RTC_EMBCK_SEL_OPTION | \
RTC_EMBCK_SEL_K_EOSC)
#define RTC_XOSCCALI_START 0x0000
#define RTC_XOSCCALI_END 0x001f
#define RTC_POWERKEY1 (PMIC_RTC_POWERKEY1_ADDR)
#define RTC_POWERKEY2 (PMIC_RTC_POWERKEY2_ADDR)
#define RTC_POWERKEY1_KEY 0xa357
#define RTC_POWERKEY2_KEY 0x67d2
/*
* RTC_PDN1:
* bit 0 - 3 : Android bits
* bit 4 - 5 : Recovery bits (0x10: factory data reset)
* bit 6 : Bypass PWRKEY bit
* bit 7 : Power-On Time bit
* bit 8 : RTC_GPIO_USER_WIFI bit
* bit 9 : RTC_GPIO_USER_GPS bit
* bit 10 : RTC_GPIO_USER_BT bit
* bit 11 : RTC_GPIO_USER_FM bit
* bit 12 : RTC_GPIO_USER_PMIC bit
* bit 13 : Fast Boot
* bit 14 : Kernel Power Off Charging
* bit 15 : Debug bit
*/
#define RTC_PDN1 (PMIC_RTC_PDN1_ADDR)
#define RTC_PDN1_ANDROID_MASK 0x000f
#define RTC_PDN1_RECOVERY_MASK 0x0030
#define RTC_PDN1_FAC_RESET (1U << 4)
#define RTC_PDN1_BYPASS_PWR (1U << 6)
#define RTC_PDN1_PWRON_TIME (1U << 7)
#define RTC_PDN1_GPIO_WIFI (1U << 8)
#define RTC_PDN1_GPIO_GPS (1U << 9)
#define RTC_PDN1_GPIO_BT (1U << 10)
#define RTC_PDN1_GPIO_FM (1U << 11)
#define RTC_PDN1_GPIO_PMIC (1U << 12)
#define RTC_PDN1_FAST_BOOT (1U << 13)
#define RTC_PDN1_KPOC (1U << 14)
#define RTC_PDN1_DEBUG (1U << 15)
#define RTC_GPIO_USER_MASK (RTC_PDN1_GPIO_WIFI | RTC_PDN1_GPIO_GPS\
| RTC_PDN1_GPIO_BT | RTC_PDN1_GPIO_FM | RTC_PDN1_GPIO_PMIC)
/*
* RTC_PDN2:
* bit 0 - 3 : MTH in power-on time
* bit 4 : Power-On Alarm bit
* bit 5 - 6 : UART bits
* bit 7 : autoboot bit
* bit 8 - 14: YEA in power-on time
* bit 15 : Power-On Logo bit
*/
#define RTC_PDN2 (PMIC_RTC_PDN2_ADDR)
#define RTC_PDN2_PWRON_MTH_MASK 0x000f
#define RTC_PDN2_PWRON_MTH_SHIFT 0
#define RTC_PDN2_PWRON_ALARM (1U << 4)
#define RTC_PDN2_UART_MASK 0x0060
#define RTC_PDN2_UART_SHIFT 5
#define RTC_PDN2_PWRON_YEA_MASK 0x7f00
#define RTC_PDN2_AUTOBOOT (1U << 7)
#define RTC_PDN2_PWRON_YEA_SHIFT 8
#define RTC_PDN2_PWRON_LOGO (1U << 15)
/*
* RTC_SPAR0:
* bit 0 - 5 : SEC in power-on time
* bit 6 : 32K less bit. True:with 32K, False:Without 32K
* bit 7 - 15: reserved bits
*/
#define RTC_SPAR0 (PMIC_RTC_SPAR0_ADDR)
#define RTC_SPAR0_PWRON_SEC_MASK 0x003f
#define RTC_SPAR0_PWRON_SEC_SHIFT 0
#define RTC_SPAR0_32K_LESS (1U << 6)
#define RTC_SPAR0_LP_DET (1U << 7)
/*
* RTC_SPAR1:
* bit 0 - 5 : MIN in power-on time
* bit 6 - 10 : HOU in power-on time
* bit 11 - 15: DOM in power-on time
*/
#define RTC_SPAR1 (PMIC_RTC_SPAR1_ADDR)
#define RTC_SPAR1_PWRON_MIN_MASK 0x003f
#define RTC_SPAR1_PWRON_MIN_SHIFT 0
#define RTC_SPAR1_PWRON_HOU_MASK 0x07c0
#define RTC_SPAR1_PWRON_HOU_SHIFT 6
#define RTC_SPAR1_PWRON_DOM_MASK 0xf800
#define RTC_SPAR1_PWRON_DOM_SHIFT 11
#define RTC_PROT (PMIC_RTC_PROT_ADDR)
#define RTC_PROT_UNLOCK1 0x586a
#define RTC_PROT_UNLOCK2 0x9136
#define RTC_DIFF (PMIC_RTC_DIFF_ADDR)
#define RTC_POWER_DETECTED \
(PMIC_POWER_DETECTED_MASK << PMIC_POWER_DETECTED_SHIFT)
#define RTC_K_EOSC32_RSV \
(PMIC_K_EOSC32_RSV_MASK << PMIC_K_EOSC32_RSV_SHIFT)
#define RTC_CALI_RD_SEL_SHIFT (PMIC_CALI_RD_SEL_SHIFT)
#define RTC_CALI_RD_SEL \
(PMIC_CALI_RD_SEL_MASK << PMIC_CALI_RD_SEL_SHIFT)
#define RTC_CALI (PMIC_RTC_CALI_ADDR)
#define RTC_CALI_MASK \
(PMIC_RTC_CALI_MASK << PMIC_RTC_CALI_SHIFT)
#define RTC_CALI_WR_SEL \
(PMIC_CALI_WR_SEL_MASK << PMIC_CALI_WR_SEL_SHIFT)
#define RTC_CALI_WR_SEL_SHIFT (PMIC_CALI_WR_SEL_SHIFT)
#define RTC_K_EOSC32_OVERFLOW \
(PMIC_K_EOSC32_OVERFLOW_MASK << PMIC_K_EOSC32_OVERFLOW_SHIFT)
#define RTC_WRTGR (PMIC_WRTGR_ADDR)
#define RTC_CON (PMIC_VBAT_LPSTA_RAW_ADDR)
#define RTC_VBAT_LPSTA_RAW \
(PMIC_VBAT_LPSTA_RAW_MASK << PMIC_VBAT_LPSTA_RAW_SHIFT)
#define RTC_EOSC32_LPEN \
(PMIC_EOSC32_LPEN_MASK << PMIC_EOSC32_LPEN_SHIFT)
#define RTC_XOSC32_LPEN \
(PMIC_XOSC32_LPEN_MASK << PMIC_XOSC32_LPEN_SHIFT)
#define RTC_CON_LPRST (PMIC_LPRST_MASK << PMIC_LPRST_SHIFT)
#define RTC_CON_CDBO (PMIC_CDBO_MASK << PMIC_CDBO_SHIFT)
#define RTC_CON_F32KOB \
(PMIC_F32KOB_MASK << PMIC_F32KOB_SHIFT) /* 0: RTC_GPIO exports 32K */
#define RTC_CON_GPO (PMIC_GPO_MASK << PMIC_GPO_SHIFT)
/* 1: GPO mode, 0: GPI mode */
#define RTC_CON_GOE (PMIC_GOE_MASK << PMIC_GOE_SHIFT)
#define RTC_CON_GSR (PMIC_GSR_MASK << PMIC_GSR_SHIFT)
#define RTC_CON_GSMT (PMIC_GSMT_MASK << PMIC_GSMT_SHIFT)
#define RTC_CON_GPEN (PMIC_GPEN_MASK << PMIC_GPEN_SHIFT)
#define RTC_CON_GPU (PMIC_GPU_MASK << PMIC_GPU_SHIFT)
#define RTC_CON_GE4 (PMIC_GE4_MASK << PMIC_GE4_SHIFT)
#define RTC_CON_GE8 (PMIC_GE8_MASK << PMIC_GE8_SHIFT)
#define RTC_CON_GPI (PMIC_GPI_MASK << PMIC_GPI_SHIFT)
#define RTC_CON_LPSTA_RAW \
(PMIC_LPSTA_RAW_MASK << PMIC_LPSTA_RAW_SHIFT) /* 32K was stopped */
#define RTC_INT_CNT (PMIC_RTC_INT_CNT_ADDR)
/* power on alarm time setting */
#define RTC_PWRON_YEA RTC_PDN2
#define RTC_PWRON_YEA_MASK 0x7f00
#define RTC_PWRON_YEA_SHIFT 8
#define RTC_PWRON_MTH RTC_PDN2
#define RTC_PWRON_MTH_MASK 0x000f
#define RTC_PWRON_MTH_SHIFT 0
#define RTC_PWRON_SEC RTC_SPAR0
#define RTC_PWRON_SEC_MASK 0x003f
#define RTC_PWRON_SEC_SHIFT 0
#define RTC_PWRON_MIN RTC_SPAR1
#define RTC_PWRON_MIN_MASK 0x003f
#define RTC_PWRON_MIN_SHIFT 0
#define RTC_PWRON_HOU RTC_SPAR1
#define RTC_PWRON_HOU_MASK 0x07c0
#define RTC_PWRON_HOU_SHIFT 6
#define RTC_PWRON_DOM RTC_SPAR1
#define RTC_PWRON_DOM_MASK 0xf800
#define RTC_PWRON_DOM_SHIFT 11
extern u16 rtc_spare_reg[][3];
#endif /* __MT_RTC_HW_H__ */
File diff suppressed because it is too large. Load diff
+93
View File
@@ -0,0 +1,93 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2021 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/seq_file.h>
#include <linux/uaccess.h>
#include <linux/debugfs.h>
#include <upmu_common.h>
static int rtc_alarm_enabled = 1;
static ssize_t mtk_rtc_debug_write(struct file *file,
const char __user *buf, size_t size, loff_t *ppos)
{
char lbuf[128];
char option[16];
int setting;
ssize_t res;
if (*ppos != 0 || size >= sizeof(lbuf) || size == 0)
return -EINVAL;
res = simple_write_to_buffer(lbuf, sizeof(lbuf) - 1, ppos, buf, size);
if (res <= 0)
return -EFAULT;
lbuf[size] = '\0';
if (sscanf(lbuf, "%15s %d", option, &setting) != 2) {
pr_notice("Invalid para %s\n", lbuf);
return -EFAULT;
}
if (!strncmp(option, "alarm", strlen("alarm"))) {
pr_notice("alarm = %d\n", setting);
rtc_alarm_enabled = setting;
if (rtc_alarm_enabled)
pmic_enable_interrupt(INT_RTC, 1, "RTC");
else
pmic_enable_interrupt(INT_RTC, 0, "RTC");
}
return size;
}
static int mtk_rtc_debug_show(struct seq_file *s, void *unused)
{
seq_printf(s, "rtc alarm %s\n",
rtc_alarm_enabled ? "enabled" : "disabled");
return 0;
}
static int mtk_rtc_debug_open(struct inode *inode,
struct file *file)
{
return single_open(file, mtk_rtc_debug_show, NULL);
}
static const struct file_operations mtk_rtc_debug_ops = {
.open = mtk_rtc_debug_open,
.read = seq_read,
.write = mtk_rtc_debug_write,
.llseek = seq_lseek,
.release = single_release,
};
int __init rtc_debug_init(void)
{
struct dentry *mtk_rtc_dir = NULL;
struct dentry *mtk_rtc_file = NULL;
mtk_rtc_dir = debugfs_create_dir("mtk_rtc", NULL);
if (!mtk_rtc_dir) {
pr_info("create /sys/kernel/debug/mtk_rtc_dir failed\n");
return -ENOMEM;
}
mtk_rtc_file = debugfs_create_file("mtk_rtc", 0644,
mtk_rtc_dir, NULL,
&mtk_rtc_debug_ops);
if (!mtk_rtc_file) {
pr_info("create /sys/kernel/debug/mtk_rtc/mtk_rtc failed\n");
return -ENOMEM;
}
return 0;
}
device_initcall(rtc_debug_init);
@@ -0,0 +1,124 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2021 MediaTek Inc.
*/
#include <linux/debugfs.h>
#include <linux/err.h>
#include <linux/proc_fs.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/of_device.h>
#include <linux/platform_device.h>
static int rtc_alarm_enabled = 1;
int irq;
static ssize_t mtk_rtc_debug_write(struct file *file,
const char __user *buf, size_t size, loff_t *ppos)
{
char lbuf[128];
char option[16];
int setting;
ssize_t res;
if (*ppos != 0 || size >= sizeof(lbuf) || size == 0)
return -EINVAL;
res = simple_write_to_buffer(lbuf, sizeof(lbuf) - 1, ppos, buf, size);
if (res <= 0)
return -EFAULT;
lbuf[size] = '\0';
if (sscanf(lbuf, "%15s %d", option, &setting) != 2) {
pr_notice("Invalid para %s\n", lbuf);
return -EFAULT;
}
if (!strncmp(option, "alarm", strlen("alarm"))) {
pr_notice("alarm = %d\n", setting);
rtc_alarm_enabled = setting;
if (rtc_alarm_enabled)
enable_irq(irq);
else
disable_irq_nosync(irq);
}
return size;
}
static int mtk_rtc_debug_show(struct seq_file *s, void *unused)
{
seq_printf(s, "rtc alarm %s\n",
rtc_alarm_enabled ? "enabled" : "disabled");
return 0;
}
static int mtk_rtc_debug_open(struct inode *inode,
struct file *file)
{
return single_open(file, mtk_rtc_debug_show, NULL);
}
static const struct file_operations mtk_rtc_debug_ops = {
.open = mtk_rtc_debug_open,
.read = seq_read,
.write = mtk_rtc_debug_write,
.llseek = seq_lseek,
.release = single_release,
};
static int mtk_rtc_dbg_probe(struct platform_device *pdev)
{
struct dentry *mtk_rtc_dir;
struct dentry *mtk_rtc_file;
struct proc_dir_entry *pdir, *pentry;
irq = platform_get_irq(to_platform_device(pdev->dev.parent), 0);
if (irq <= 0)
return -EINVAL;
dev_notice(&pdev->dev, " irq = %d\n", irq);
mtk_rtc_dir = debugfs_create_dir("mtk_rtc", NULL);
if (!mtk_rtc_dir) {
dev_err(&pdev->dev,
"create /sys/kernel/debug/mtk_rtc_dir failed\n");
} else {
mtk_rtc_file = debugfs_create_file("mtk_rtc", 0644,
mtk_rtc_dir, NULL,
&mtk_rtc_debug_ops);
if (!mtk_rtc_file) {
dev_err(&pdev->dev,
"create /sys/kernel/debug/mtk_rtc/mtk_rtc failed\n");
}
}
pdir = proc_mkdir("mtk_rtc", NULL);
if (!pdir) {
dev_notice(&pdev->dev,
"create /proc/mtk_rtc_dir failed\n");
} else {
pentry = proc_create_data("mtk_rtc", 0644,
pdir, &mtk_rtc_debug_ops, NULL);
if (!pentry) {
dev_notice(&pdev->dev,
"create /proc/mtk_rtc/mtk_rtc failed\n");
}
}
return 0;
}
static struct platform_driver mtk_rtc_dbg_driver = {
.driver = {
.name = "mtk_rtc_dbg",
},
.probe = mtk_rtc_dbg_probe,
};
module_platform_driver(mtk_rtc_dbg_driver);
@@ -0,0 +1,337 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2021 MediaTek Inc.
*/
#if defined(CONFIG_MTK_RTC)
#ifdef pr_fmt
#undef pr_fmt
#endif
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/rtc.h>
#include <mach/upmu_hw.h>
#include <linux/spinlock.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/types.h>
#include <linux/sched/clock.h>
#include <mtk_rtc_hal.h>
#include <mtk_rtc_hw.h>
#include <mtk_rtc_hal_common.h>
#ifdef CONFIG_MTK_PMIC_WRAP_HAL
#include <mach/mtk_pmic_wrap.h>
#endif
#define hal_rtc_xinfo(fmt, args...) \
pr_notice(fmt, ##args)
u16 rtc_read(u16 addr)
{
u32 rdata = 0;
#ifdef CONFIG_MTK_PMIC_WRAP_HAL
pwrap_read((u32) addr, &rdata);
#endif
return (u16) rdata;
}
void rtc_write(u16 addr, u16 data)
{
#ifdef CONFIG_MTK_PMIC_WRAP_HAL
pwrap_write((u32) addr, (u32) data);
#endif
}
void rtc_busy_wait(void)
{
unsigned long long timeout = sched_clock() + 500000000;
do {
if ((rtc_read(RTC_BBPU) & RTC_BBPU_CBUSY) == 0)
break;
else if (sched_clock() > timeout) {
pr_err("%s, wait cbusy timeout, %x, %x, %x, %d\n",
__func__,
rtc_read(RTC_BBPU), rtc_read(RTC_POWERKEY1),
rtc_read(RTC_POWERKEY2), rtc_read(RTC_TC_SEC));
break;
}
} while (1);
}
void rtc_write_trigger(void)
{
rtc_write(RTC_WRTGR, 1);
rtc_busy_wait();
}
void rtc_writeif_unlock(void)
{
rtc_write(RTC_PROT, RTC_PROT_UNLOCK1);
rtc_write_trigger();
rtc_write(RTC_PROT, RTC_PROT_UNLOCK2);
rtc_write_trigger();
}
void rtc_xosc_write(u16 val, bool reload)
{
rtc_write(RTC_OSC32CON, RTC_OSC32CON_UNLOCK1);
rtc_busy_wait();
rtc_write(RTC_OSC32CON, RTC_OSC32CON_UNLOCK2);
rtc_busy_wait();
rtc_write(RTC_OSC32CON, val);
rtc_busy_wait();
if (reload) {
u16 bbpu;
bbpu = rtc_read(RTC_BBPU) | RTC_BBPU_KEY | RTC_BBPU_RELOAD;
rtc_write(RTC_BBPU, bbpu);
rtc_write_trigger();
}
}
void rtc_set_writeif(bool enable)
{
if (enable) {
rtc_writeif_unlock();
} else {
rtc_write(RTC_PROT, 0);
rtc_write_trigger();
}
}
void hal_rtc_set_spare_register(enum rtc_spare_enum cmd, u16 val)
{
u16 tmp_val;
if (cmd >= 0 && cmd < RTC_SPAR_NUM) {
hal_rtc_xinfo("%s: cmd[%d], set rg[0x%x, 0x%x , %d] = 0x%x\n",
__func__, cmd,
rtc_spare_reg[cmd][RTC_REG],
rtc_spare_reg[cmd][RTC_MASK],
rtc_spare_reg[cmd][RTC_SHIFT], val);
tmp_val =
rtc_read(rtc_spare_reg[cmd][RTC_REG]) &
~(rtc_spare_reg[cmd][RTC_MASK] <<
rtc_spare_reg[cmd][RTC_SHIFT]);
rtc_write(rtc_spare_reg[cmd][RTC_REG],
tmp_val | ((val & rtc_spare_reg[cmd][RTC_MASK]) <<
rtc_spare_reg[cmd][RTC_SHIFT]));
rtc_write_trigger();
}
}
u16 hal_rtc_get_spare_register(enum rtc_spare_enum cmd)
{
u16 tmp_val;
if (cmd >= 0 && cmd < RTC_SPAR_NUM) {
tmp_val = rtc_read(rtc_spare_reg[cmd][RTC_REG]);
tmp_val =
(tmp_val >> rtc_spare_reg[cmd][RTC_SHIFT]) &
rtc_spare_reg[cmd][RTC_MASK];
hal_rtc_xinfo("%s: cmd[%d], get rg[0x%x, 0x%x , %d] = 0x%x\n",
__func__, cmd,
rtc_spare_reg[cmd][RTC_REG],
rtc_spare_reg[cmd][RTC_MASK],
rtc_spare_reg[cmd][RTC_SHIFT], tmp_val);
return tmp_val;
}
return 0;
}
static void rtc_get_tick(struct rtc_time *tm)
{
tm->tm_sec = rtc_read(RTC_TC_SEC);
tm->tm_min = rtc_read(RTC_TC_MIN);
tm->tm_hour = rtc_read(RTC_TC_HOU);
tm->tm_mday = rtc_read(RTC_TC_DOM);
tm->tm_mon = rtc_read(RTC_TC_MTH) & RTC_TC_MTH_MASK;
tm->tm_year = rtc_read(RTC_TC_YEA);
}
void hal_rtc_get_tick_time(struct rtc_time *tm)
{
u16 bbpu;
bbpu = rtc_read(RTC_BBPU) | RTC_BBPU_KEY | RTC_BBPU_RELOAD;
rtc_write(RTC_BBPU, bbpu);
rtc_write_trigger();
rtc_get_tick(tm);
bbpu = rtc_read(RTC_BBPU) | RTC_BBPU_KEY | RTC_BBPU_RELOAD;
rtc_write(RTC_BBPU, bbpu);
rtc_write_trigger();
if (rtc_read(RTC_TC_SEC) < tm->tm_sec) { /* SEC has carried */
rtc_get_tick(tm);
}
}
void hal_rtc_set_tick_time(struct rtc_time *tm)
{
rtc_write(RTC_TC_YEA, tm->tm_year);
rtc_write(RTC_TC_MTH, tm->tm_mon);
rtc_write(RTC_TC_DOM, tm->tm_mday);
rtc_write(RTC_TC_HOU, tm->tm_hour);
rtc_write(RTC_TC_MIN, tm->tm_min);
rtc_write(RTC_TC_SEC, tm->tm_sec);
rtc_write_trigger();
}
void hal_rtc_get_alarm_time(struct rtc_time *tm)
{
tm->tm_sec = rtc_read(RTC_AL_SEC) & RTC_AL_SEC_MASK;
tm->tm_min = rtc_read(RTC_AL_MIN) & RTC_AL_MIN_MASK;
tm->tm_hour = rtc_read(RTC_AL_HOU) & RTC_AL_HOU_MASK;
tm->tm_mday = rtc_read(RTC_AL_DOM) & RTC_AL_DOM_MASK;
tm->tm_mon = rtc_read(RTC_AL_MTH) & RTC_AL_MTH_MASK;
tm->tm_year = rtc_read(RTC_AL_YEA) & RTC_AL_YEA_MASK;
}
void hal_rtc_set_alarm_time(struct rtc_time *tm)
{
hal_rtc_xinfo("mon = %d, day = %d, hour = %d\n",
(rtc_read(RTC_AL_MTH) & ~(RTC_AL_MTH_MASK)) | tm->tm_mon,
(rtc_read(RTC_AL_DOM) & ~(RTC_AL_DOM_MASK)) | tm->tm_mday,
(rtc_read(RTC_AL_HOU) & ~(RTC_AL_HOU_MASK)) | tm->tm_hour);
rtc_write(RTC_AL_YEA,
(rtc_read(RTC_AL_YEA) & ~(RTC_AL_YEA_MASK)) |
(tm->tm_year & RTC_AL_YEA_MASK));
rtc_write(RTC_AL_MTH,
(rtc_read(RTC_AL_MTH) & ~(RTC_AL_MTH_MASK)) |
(tm->tm_mon & RTC_AL_MTH_MASK));
rtc_write(RTC_AL_DOM,
(rtc_read(RTC_AL_DOM) & ~(RTC_AL_DOM_MASK)) |
(tm->tm_mday & RTC_AL_DOM_MASK));
rtc_write(RTC_AL_HOU,
(rtc_read(RTC_AL_HOU) & ~(RTC_AL_HOU_MASK)) |
(tm->tm_hour & RTC_AL_HOU_MASK));
rtc_write(RTC_AL_MIN,
(rtc_read(RTC_AL_MIN) & ~(RTC_AL_MIN_MASK)) |
(tm->tm_min & RTC_AL_MIN_MASK));
rtc_write(RTC_AL_SEC,
(rtc_read(RTC_AL_SEC) & ~(RTC_AL_SEC_MASK)) |
(tm->tm_sec & RTC_AL_SEC_MASK));
rtc_write(RTC_AL_MASK, RTC_AL_MASK_DOW); /* mask DOW */
rtc_write_trigger();
}
void hal_rtc_save_pwron_alarm(void)
{
rtc_write(RTC_PDN1, rtc_read(RTC_PDN1) & (~RTC_PDN1_PWRON_TIME));
rtc_write(RTC_PDN2, rtc_read(RTC_PDN2) | RTC_PDN2_PWRON_ALARM);
rtc_write_trigger();
}
void hal_rtc_get_pwron_alarm_time(struct rtc_time *tm)
{
tm->tm_sec =
(rtc_read(RTC_PWRON_SEC) & RTC_PWRON_SEC_MASK) >>
RTC_PWRON_SEC_SHIFT;
tm->tm_min =
(rtc_read(RTC_PWRON_MIN) & RTC_PWRON_MIN_MASK) >>
RTC_PWRON_MIN_SHIFT;
tm->tm_hour =
(rtc_read(RTC_PWRON_HOU) & RTC_PWRON_HOU_MASK) >>
RTC_PWRON_HOU_SHIFT;
tm->tm_mday =
(rtc_read(RTC_PWRON_DOM) & RTC_PWRON_DOM_MASK) >>
RTC_PWRON_DOM_SHIFT;
tm->tm_mon =
(rtc_read(RTC_PWRON_MTH) & RTC_PWRON_MTH_MASK) >>
RTC_PWRON_MTH_SHIFT;
tm->tm_year =
(rtc_read(RTC_PWRON_YEA) & RTC_PWRON_YEA_MASK) >>
RTC_PWRON_YEA_SHIFT;
}
void hal_rtc_set_pwron_alarm_time(struct rtc_time *tm)
{
rtc_write(RTC_PWRON_YEA,
(rtc_read(RTC_PWRON_YEA) & ~(RTC_PWRON_YEA_MASK))
| ((tm->tm_year << RTC_PWRON_YEA_SHIFT) &
RTC_PWRON_YEA_MASK));
rtc_write_trigger();
rtc_write(RTC_PWRON_MTH,
(rtc_read(RTC_PWRON_MTH) & ~(RTC_PWRON_MTH_MASK))
| ((tm->tm_mon << RTC_PWRON_MTH_SHIFT) & RTC_PWRON_MTH_MASK));
rtc_write_trigger();
rtc_write(RTC_PWRON_DOM,
(rtc_read(RTC_PWRON_DOM) & ~(RTC_PWRON_DOM_MASK))
| ((tm->tm_mday << RTC_PWRON_DOM_SHIFT) &
RTC_PWRON_DOM_MASK));
rtc_write_trigger();
rtc_write(RTC_PWRON_HOU,
(rtc_read(RTC_PWRON_HOU) & ~(RTC_PWRON_HOU_MASK))
| ((tm->tm_hour << RTC_PWRON_HOU_SHIFT) &
RTC_PWRON_HOU_MASK));
rtc_write_trigger();
rtc_write(RTC_PWRON_MIN,
(rtc_read(RTC_PWRON_MIN) & ~(RTC_PWRON_MIN_MASK))
| ((tm->tm_min << RTC_PWRON_MIN_SHIFT) & RTC_PWRON_MIN_MASK));
rtc_write_trigger();
rtc_write(RTC_PWRON_SEC,
(rtc_read(RTC_PWRON_SEC) & ~(RTC_PWRON_SEC_MASK))
| ((tm->tm_sec << RTC_PWRON_SEC_SHIFT) & RTC_PWRON_SEC_MASK));
rtc_write_trigger();
}
void hal_rtc_read_rg(void)
{
u16 irqen, pdn1;
irqen = rtc_read(RTC_IRQ_EN);
pdn1 = rtc_read(RTC_PDN1);
hal_rtc_xinfo("RTC_IRQ_EN = 0x%x, RTC_PDN1 = 0x%x\n", irqen, pdn1);
}
#ifndef USER_BUILD_KERNEL
void rtc_lp_exception(void)
{
u16 bbpu, irqsta, irqen, osc32;
u16 pwrkey1, pwrkey2, prot, con, sec1, sec2;
bbpu = rtc_read(RTC_BBPU);
irqsta = rtc_read(RTC_IRQ_STA);
irqen = rtc_read(RTC_IRQ_EN);
osc32 = rtc_read(RTC_OSC32CON);
pwrkey1 = rtc_read(RTC_POWERKEY1);
pwrkey2 = rtc_read(RTC_POWERKEY2);
prot = rtc_read(RTC_PROT);
con = rtc_read(RTC_CON);
sec1 = rtc_read(RTC_TC_SEC);
mdelay(2000);
sec2 = rtc_read(RTC_TC_SEC);
pr_emerg("!!! 32K WAS STOPPED !!!\n"
"RTC_BBPU = 0x%x\n"
"RTC_IRQ_STA = 0x%x\n"
"RTC_IRQ_EN = 0x%x\n"
"RTC_OSC32CON = 0x%x\n"
"RTC_POWERKEY1 = 0x%x\n"
"RTC_POWERKEY2 = 0x%x\n"
"RTC_PROT = 0x%x\n"
"RTC_CON = 0x%x\n"
"RTC_TC_SEC = %02d\n"
"RTC_TC_SEC = %02d\n",
bbpu, irqsta, irqen, osc32, pwrkey1, pwrkey2, prot, con, sec1,
sec2);
}
#endif
#endif /*#if defined(CONFIG_MTK_RTC) */