aubrey/kernel_samsung_a34x-permissive
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity
kernel_samsung_a34x-permissive/drivers/misc/mediatek/rtc/mtk_rtc_common.c
Fede2782 6db4831e98
Import A346BXXU4BWK2 kernel source 
Android 14
2024-04-28 15:51:13 +02:00

1036 lines
23 KiB
C
Raw Blame History

/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2021 MediaTek Inc.
*/
/*****************************************************************************
*
* Filename:
* ---------
* rtc_common.c
*
* Project:
* --------
* Android_Software
*
* Description:
* ------------
* This Module defines functions of rtc basic operation.
*
* Author:
* -------
* Owen Chen
*
****************************************************************************/
#if defined(CONFIG_MTK_RTC)
#ifdef pr_fmt
#undef pr_fmt
#endif
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/pm.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/rtc.h>
#include <linux/spinlock.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/pm_wakeup.h>
#include <linux/sched.h>
#include <linux/types.h>
#include <linux/reboot.h>
#include <linux/of.h>
#include <asm/div64.h>
/* #include <mach/mt6577_boot.h> */
/* #include <mach/mt6577_reg_base.h> */
#include <mtk_rtc.h>
#include <mtk_rtc_hal_common.h>
#include <mtk_rtc_hal.h>
/* #include <mach/pmic_mt6320_sw.h> */
#include <upmu_common.h>
/* #include <mach/upmu_hw.h> */
#include <mach/mtk_pmic_wrap.h>
#include <mtk_boot.h>
#include <mt-plat/mtk_boot_common.h>
/* #include <linux/printk.h> */
#include <mtk_reboot.h>
// #include "../include/mt-plat/mtk_rtc.h"
#ifdef CONFIG_MTK_CHARGER
#include <mt-plat/v1/mtk_charger.h>
#endif
#define RTC_NAME "mt-rtc"
#define RTC_RELPWR_WHEN_XRST 1 /* BBPU = 0 when xreset_rstb goes low */
/* we map HW YEA 0 (2000) to 1968 not 1970 because 2000 is the leap year */
#define RTC_MIN_YEAR 1968
#define RTC_NUM_YEARS 128
/* #define RTC_MAX_YEAR (RTC_MIN_YEAR + RTC_NUM_YEARS - 1) */
/*
* Reset to default date if RTC time is over 2038/1/19 3:14:7
* Year (YEA) : 1970 ~ 2037
* Month (MTH) : 1 ~ 12
* Day of Month (DOM): 1 ~ 31
*/
#define RTC_OVER_TIME_RESET 1
#define RTC_DEFAULT_YEA 2010
#define RTC_DEFAULT_MTH 1
#define RTC_DEFAULT_DOM 1
#define RTC_MIN_YEAR_OFFSET (RTC_MIN_YEAR - 1900)
#define AUTOBOOT_ON 0
#define AUTOBOOT_OFF 1
#define RTC_POFF_ALM_SET _IOW('p', 0x15, struct rtc_time) /* Set alarm time */
/*
* 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 : POWER DROP AUTO BOOT 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 : Low power detected in preloader
* bit 8 - 15: reserved bits
*/
/*
* 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
*/
/*
* RTC_NEW_SPARE0: RTC_AL_HOU bit8~15
* bit 8 ~ 14 : Fuel Gauge
* bit 15 : reserved bits
*/
/*
* RTC_NEW_SPARE1: RTC_AL_DOM bit8~15
* bit 8 ~ 15 : reserved bits
*/
/*
* RTC_NEW_SPARE2: RTC_AL_DOW bit8~15
* bit 8 ~ 15 : reserved bits
*/
/*
* RTC_NEW_SPARE3: RTC_AL_MTH bit8~15
* bit 8 ~ 15 : reserved bits
*/
#define rtc_xinfo(fmt, args...) \
pr_notice(fmt, ##args)
static struct rtc_device *rtc;
static DEFINE_SPINLOCK(rtc_lock);
static void rtc_save_pwron_time(bool enable, struct rtc_time *tm, bool logo);
void __attribute__((weak)) arch_reset(char mode, const char *cmd)
{
pr_info("arch_reset is not ready\n");
}
struct tag_bootmode {
u32 size;
u32 tag;
u32 bootmode;
u32 boottype;
};
static int rtc_show_time;
static int rtc_show_alarm = 1;
static int alarm1m15s;
static u32 bootmode;
#if 1
unsigned long rtc_read_hw_time(void)
{
unsigned long time, flags;
struct rtc_time tm;
spin_lock_irqsave(&rtc_lock, flags);
/* rtc_ctrl_func(HAL_RTC_CMD_RELOAD, NULL); */
/* rtc_ctrl_func(HAL_RTC_CMD_GET_TIME, &tm); */
hal_rtc_get_tick_time(&tm);
spin_unlock_irqrestore(&rtc_lock, flags);
tm.tm_year += RTC_MIN_YEAR_OFFSET;
tm.tm_mon--;
rtc_tm_to_time(&tm, &time);
tm.tm_wday = (time / 86400 + 4) % 7; /* 1970/01/01 is Thursday */
return time;
}
EXPORT_SYMBOL(rtc_read_hw_time);
#endif
int get_rtc_spare_fg_value(void)
{
/* RTC_AL_HOU bit8~14 */
u16 temp;
unsigned long flags;
spin_lock_irqsave(&rtc_lock, flags);
temp = hal_rtc_get_spare_register(RTC_FGSOC);
spin_unlock_irqrestore(&rtc_lock, flags);
return temp;
}
int set_rtc_spare_fg_value(int val)
{
/* RTC_AL_HOU bit8~14 */
unsigned long flags;
#ifdef CONFIG_MTK_GAUGE_VERSION
#if (CONFIG_MTK_GAUGE_VERSION != 30)
if (val > 100)
return 1;
#endif
#endif
spin_lock_irqsave(&rtc_lock, flags);
hal_rtc_set_spare_register(RTC_FGSOC, val);
spin_unlock_irqrestore(&rtc_lock, flags);
return 0;
}
int get_rtc_spare0_fg_value(void)
{
u16 temp;
unsigned long flags;
spin_lock_irqsave(&rtc_lock, flags);
temp = hal_rtc_get_spare_register(RTC_FG_INIT);
spin_unlock_irqrestore(&rtc_lock, flags);
return temp;
}
int set_rtc_spare0_fg_value(int val)
{
unsigned long flags;
spin_lock_irqsave(&rtc_lock, flags);
hal_rtc_set_spare_register(RTC_FG_INIT, val);
spin_unlock_irqrestore(&rtc_lock, flags);
return 0;
}
bool crystal_exist_status(void)
{
unsigned long flags;
u16 ret;
spin_lock_irqsave(&rtc_lock, flags);
ret = hal_rtc_get_spare_register(RTC_32K_LESS);
spin_unlock_irqrestore(&rtc_lock, flags);
if (ret)
return true;
else
return false;
}
EXPORT_SYMBOL(crystal_exist_status);
/*
* Only for GPS to check the status.
* Others do not use this API
* This low power detected API is read clear.
*/
bool rtc_low_power_detected(void)
{
unsigned long flags;
u16 ret;
spin_lock_irqsave(&rtc_lock, flags);
ret = hal_rtc_get_spare_register(RTC_LP_DET);
spin_unlock_irqrestore(&rtc_lock, flags);
if (ret)
return true;
else
return false;
}
EXPORT_SYMBOL(rtc_low_power_detected);
void rtc_gpio_enable_32k(enum rtc_gpio_user_t user)
{
unsigned long flags;
rtc_xinfo("%s, user = %d\n", __func__, user);
if (user < RTC_GPIO_USER_WIFI || user > RTC_GPIO_USER_PMIC)
return;
spin_lock_irqsave(&rtc_lock, flags);
hal_rtc_set_gpio_32k_status(user, true);
spin_unlock_irqrestore(&rtc_lock, flags);
}
EXPORT_SYMBOL(rtc_gpio_enable_32k);
void rtc_gpio_disable_32k(enum rtc_gpio_user_t user)
{
unsigned long flags;
rtc_xinfo("%s, user = %d\n", __func__, user);
if (user < RTC_GPIO_USER_WIFI || user > RTC_GPIO_USER_PMIC)
return;
spin_lock_irqsave(&rtc_lock, flags);
hal_rtc_set_gpio_32k_status(user, false);
spin_unlock_irqrestore(&rtc_lock, flags);
}
EXPORT_SYMBOL(rtc_gpio_disable_32k);
bool rtc_gpio_32k_status(void)
{
unsigned long flags;
u16 ret;
spin_lock_irqsave(&rtc_lock, flags);
ret = hal_rtc_get_gpio_32k_status();
spin_unlock_irqrestore(&rtc_lock, flags);
if (ret)
return true;
else
return false;
}
EXPORT_SYMBOL(rtc_gpio_32k_status);
void rtc_enable_abb_32k(void)
{
unsigned long flags;
spin_lock_irqsave(&rtc_lock, flags);
hal_rtc_set_abb_32k(1);
spin_unlock_irqrestore(&rtc_lock, flags);
}
void rtc_disable_abb_32k(void)
{
unsigned long flags;
spin_lock_irqsave(&rtc_lock, flags);
hal_rtc_set_abb_32k(0);
spin_unlock_irqrestore(&rtc_lock, flags);
}
void rtc_enable_writeif(void)
{
unsigned long flags;
spin_lock_irqsave(&rtc_lock, flags);
rtc_set_writeif(true);
spin_unlock_irqrestore(&rtc_lock, flags);
}
void rtc_disable_writeif(void)
{
unsigned long flags;
spin_lock_irqsave(&rtc_lock, flags);
rtc_set_writeif(false);
spin_unlock_irqrestore(&rtc_lock, flags);
}
void rtc_mark_recovery(void)
{
unsigned long flags;
struct rtc_time defaulttm;
rtc_xinfo("%s\n", __func__);
spin_lock_irqsave(&rtc_lock, flags);
hal_rtc_set_spare_register(RTC_FAC_RESET, 0x1);
/* Clear alarm setting when doing factory recovery. */
defaulttm.tm_year = RTC_DEFAULT_YEA - RTC_MIN_YEAR;
defaulttm.tm_mon = RTC_DEFAULT_MTH;
defaulttm.tm_mday = RTC_DEFAULT_DOM;
defaulttm.tm_wday = 1;
defaulttm.tm_hour = 0;
defaulttm.tm_min = 0;
defaulttm.tm_sec = 0;
rtc_save_pwron_time(false, &defaulttm, false);
hal_rtc_clear_alarm(&defaulttm);
spin_unlock_irqrestore(&rtc_lock, flags);
}
void rtc_mark_kpoc(void)
{
unsigned long flags;
spin_lock_irqsave(&rtc_lock, flags);
hal_rtc_set_spare_register(RTC_KPOC, 0x1);
spin_unlock_irqrestore(&rtc_lock, flags);
}
void rtc_mark_fast(void)
{
unsigned long flags;
rtc_xinfo("%s\n", __func__);
spin_lock_irqsave(&rtc_lock, flags);
hal_rtc_set_spare_register(RTC_FAST_BOOT, 0x1);
spin_unlock_irqrestore(&rtc_lock, flags);
}
u16 rtc_rdwr_uart_bits(u16 *val)
{
u16 ret = 0;
unsigned long flags;
spin_lock_irqsave(&rtc_lock, flags);
hal_rtc_set_spare_register(RTC_UART, *val);
spin_unlock_irqrestore(&rtc_lock, flags);
return ret;
}
void rtc_bbpu_power_down(void)
{
unsigned long flags;
bool charger_status = false;
struct rtc_time rtc_time_now;
struct rtc_time rtc_time_alarm;
ktime_t ktime_now;
ktime_t ktime_alarm;
bool is_pwron_alarm;
#ifdef CONFIG_MTK_CHARGER
unsigned char exist;
mtk_chr_is_charger_exist(&exist);
if (exist == 1)
charger_status = true;
else
charger_status = false;
rtc_xinfo("charger_status = %d\n", charger_status);
#endif
if (alarm1m15s == 1) {
is_pwron_alarm = hal_rtc_is_pwron_alarm(&rtc_time_now,
&rtc_time_alarm);
if (is_pwron_alarm) {
rtc_time_now.tm_year += RTC_MIN_YEAR_OFFSET;
rtc_time_now.tm_mon--;
rtc_time_alarm.tm_year += RTC_MIN_YEAR_OFFSET;
rtc_time_alarm.tm_mon--;
pr_notice("now = %04d/%02d/%02d %02d:%02d:%02d\n",
rtc_time_now.tm_year + 1900,
rtc_time_now.tm_mon + 1,
rtc_time_now.tm_mday,
rtc_time_now.tm_hour,
rtc_time_now.tm_min,
rtc_time_now.tm_sec);
pr_notice("alarm = %04d/%02d/%02d %02d:%02d:%02d\n",
rtc_time_alarm.tm_year + 1900,
rtc_time_alarm.tm_mon + 1,
rtc_time_alarm.tm_mday,
rtc_time_alarm.tm_hour,
rtc_time_alarm.tm_min,
rtc_time_alarm.tm_sec);
ktime_now = rtc_tm_to_ktime(rtc_time_now);
ktime_alarm = rtc_tm_to_ktime(rtc_time_alarm);
if (ktime_after(ktime_alarm, ktime_now)) {
/* alarm has not happened */
ktime_alarm = ktime_sub_ms(ktime_alarm,
MSEC_PER_SEC * 60);
if (ktime_after(ktime_alarm, ktime_now))
pr_notice("Alarm will happen after 1 minute\n");
else {
ktime_alarm = ktime_add_ms(ktime_now,
MSEC_PER_SEC * 15);
pr_notice("Alarm will happen in 15 seconds\n");
}
rtc_time_alarm = rtc_ktime_to_tm(ktime_alarm);
pr_notice("new alarm = %04d/%02d/%02d %02d:%02d:%02d\n",
rtc_time_alarm.tm_year + 1900,
rtc_time_alarm.tm_mon + 1,
rtc_time_alarm.tm_mday,
rtc_time_alarm.tm_hour,
rtc_time_alarm.tm_min,
rtc_time_alarm.tm_sec);
rtc_time_alarm.tm_year -= RTC_MIN_YEAR_OFFSET;
rtc_time_alarm.tm_mon++;
hal_rtc_set_pwron_alarm_time(&rtc_time_alarm);
hal_rtc_set_alarm(&rtc_time_alarm);
} else
pr_notice("Alarm has happened before\n");
} else
pr_notice("No power-off alarm is set\n");
}
spin_lock_irqsave(&rtc_lock, flags);
hal_rtc_bbpu_pwdn(charger_status);
spin_unlock_irqrestore(&rtc_lock, flags);
}
void mt_power_off(void)
{
int count = 0;
#if !defined(CONFIG_POWER_EXT)
#ifdef CONFIG_MTK_CHARGER
unsigned char exist;
#endif
#endif
rtc_xinfo("%s\n", __func__);
dump_stack();
/* pull PWRBB low */
rtc_bbpu_power_down();
while (count < INT_MAX) {
#if defined(CONFIG_POWER_EXT)
/* EVB */
rtc_xinfo("EVB without charger\n");
#else
/* Phone */
rtc_xinfo("Phone with charger\n");
mdelay(100);
rtc_xinfo("arch_reset\n");
#ifdef CONFIG_MTK_CHARGER
mtk_chr_is_charger_exist(&exist);
if (exist == 1 || count > 10)
arch_reset(0, "charger");
#endif
#endif
count++;
}
}
void rtc_read_pwron_alarm(struct rtc_wkalrm *alm)
{
unsigned long flags;
struct rtc_time *tm;
if (alm == NULL)
return;
tm = &alm->time;
spin_lock_irqsave(&rtc_lock, flags);
hal_rtc_get_pwron_alarm(tm, alm);
spin_unlock_irqrestore(&rtc_lock, flags);
tm->tm_year += RTC_MIN_YEAR_OFFSET;
tm->tm_mon -= 1;
if (rtc_show_alarm) {
rtc_xinfo("power-on = %04d/%02d/%02d %02d:%02d:%02d (%d)(%d)\n",
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
tm->tm_hour, tm->tm_min, tm->tm_sec, alm->enabled,
alm->pending);
}
}
/* static void rtc_tasklet_handler(unsigned long data) */
static void rtc_handler(void)
{
bool pwron_alm = false, isLowPowerIrq = false, pwron_alarm = false;
struct rtc_time nowtm;
struct rtc_time tm;
unsigned long flags;
rtc_xinfo("rtc_tasklet_handler start\n");
spin_lock_irqsave(&rtc_lock, flags);
isLowPowerIrq = hal_rtc_is_lp_irq();
if (isLowPowerIrq) {
spin_unlock_irqrestore(&rtc_lock, flags);
return;
}
pwron_alarm = hal_rtc_is_pwron_alarm(&nowtm, &tm);
nowtm.tm_year += RTC_MIN_YEAR;
tm.tm_year += RTC_MIN_YEAR;
if (pwron_alarm) {
unsigned long now_time, time;
now_time =
mktime(nowtm.tm_year, nowtm.tm_mon, nowtm.tm_mday,
nowtm.tm_hour, nowtm.tm_min, nowtm.tm_sec);
if (now_time == -1) {
spin_unlock_irqrestore(&rtc_lock, flags);
return;
}
time =
mktime(tm.tm_year, tm.tm_mon, tm.tm_mday, tm.tm_hour,
tm.tm_min, tm.tm_sec);
if (time == -1) {
spin_unlock_irqrestore(&rtc_lock, flags);
return;
}
/* power on */
if (now_time >= time - 1 && now_time <= time + 4) {
if (bootmode == KERNEL_POWER_OFF_CHARGING_BOOT
|| bootmode == LOW_POWER_OFF_CHARGING_BOOT) {
do {
now_time += 1;
rtc_time_to_tm(now_time, &tm);
tm.tm_year -= RTC_MIN_YEAR_OFFSET;
tm.tm_mon += 1;
hal_rtc_set_pwron_alarm_time(&tm);
hal_rtc_set_alarm(&tm);
hal_rtc_is_pwron_alarm(&nowtm, &tm);
nowtm.tm_year += RTC_MIN_YEAR;
tm.tm_year += RTC_MIN_YEAR;
now_time =
mktime(nowtm.tm_year, nowtm.tm_mon,
nowtm.tm_mday, nowtm.tm_hour,
nowtm.tm_min, nowtm.tm_sec);
if (now_time == -1) {
spin_unlock_irqrestore(&rtc_lock, flags);
return;
}
time =
mktime(tm.tm_year, tm.tm_mon,
tm.tm_mday, tm.tm_hour,
tm.tm_min, tm.tm_sec);
if (time == -1) {
spin_unlock_irqrestore(&rtc_lock, flags);
return;
}
} while (time <= now_time);
spin_unlock_irqrestore(&rtc_lock, flags);
rtc_mark_kpoc();
kernel_restart("kpoc");
} else {
hal_rtc_save_pwron_alarm();
pwron_alm = true;
}
} else if (now_time < time) { /* set power-on alarm */
time -= 1;
rtc_time_to_tm(time, &tm);
tm.tm_year -= RTC_MIN_YEAR_OFFSET;
tm.tm_mon += 1;
hal_rtc_set_alarm(&tm);
}
}
spin_unlock_irqrestore(&rtc_lock, flags);
if (rtc != NULL)
rtc_update_irq(rtc, 1, RTC_IRQF | RTC_AF);
if (rtc_show_alarm)
rtc_xinfo("%s time is up\n", pwron_alm ? "power-on" : "alarm");
}
/* static DECLARE_TASKLET(rtc_tasklet, rtc_tasklet_handler, 0); */
/* static irqreturn_t rtc_irq_handler(int irq, void *dev_id) */
void rtc_irq_handler(void)
{
/* rtc_xinfo("rtc_irq_handler start\n"); */
rtc_handler();
/* tasklet_schedule(&rtc_tasklet); */
}
#if RTC_OVER_TIME_RESET
static void rtc_reset_to_deftime(struct rtc_time *tm)
{
unsigned long flags;
struct rtc_time defaulttm;
tm->tm_year = RTC_DEFAULT_YEA - 1900;
tm->tm_mon = RTC_DEFAULT_MTH - 1;
tm->tm_mday = RTC_DEFAULT_DOM;
tm->tm_wday = 1;
tm->tm_hour = 0;
tm->tm_min = 0;
tm->tm_sec = 0;
/* set default alarm time */
defaulttm.tm_year = RTC_DEFAULT_YEA - RTC_MIN_YEAR;
defaulttm.tm_mon = RTC_DEFAULT_MTH;
defaulttm.tm_mday = RTC_DEFAULT_DOM;
defaulttm.tm_wday = 1;
defaulttm.tm_hour = 0;
defaulttm.tm_min = 0;
defaulttm.tm_sec = 0;
spin_lock_irqsave(&rtc_lock, flags);
hal_rtc_set_alarm(&defaulttm);
spin_unlock_irqrestore(&rtc_lock, flags);
pr_info("reset to default date %04d/%02d/%02d\n",
RTC_DEFAULT_YEA, RTC_DEFAULT_MTH, RTC_DEFAULT_DOM);
}
#endif
static int rtc_ops_read_time(struct device *dev, struct rtc_time *tm)
{
unsigned long long time;
unsigned long flags;
spin_lock_irqsave(&rtc_lock, flags);
hal_rtc_get_tick_time(tm);
spin_unlock_irqrestore(&rtc_lock, flags);
tm->tm_year += RTC_MIN_YEAR_OFFSET;
tm->tm_mon--;
time = rtc_tm_to_time64(tm);
if (time > (unsigned long long)ULLONG_MAX)
return -EINVAL;
#if RTC_OVER_TIME_RESET
if (unlikely(time > (unsigned long)LONG_MAX)) {
rtc_reset_to_deftime(tm);
time = rtc_tm_to_time64(tm);
}
#endif
do_div(time, 86400);
time += 4;
tm->tm_wday = do_div(time, 7); /* 1970/01/01 is Thursday */
if (rtc_show_time) {
rtc_xinfo("read tc time = %04d/%02d/%02d (%d) %02d:%02d:%02d\n",
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
tm->tm_wday, tm->tm_hour, tm->tm_min, tm->tm_sec);
}
return 0;
}
static int rtc_ops_set_time(struct device *dev, struct rtc_time *tm)
{
unsigned long time, flags;
rtc_tm_to_time(tm, &time);
if (time > (unsigned long)LONG_MAX)
return -EINVAL;
tm->tm_year -= RTC_MIN_YEAR_OFFSET;
tm->tm_mon++;
rtc_xinfo("set tc time = %04d/%02d/%02d %02d:%02d:%02d\n",
tm->tm_year + RTC_MIN_YEAR, tm->tm_mon, tm->tm_mday,
tm->tm_hour, tm->tm_min, tm->tm_sec);
spin_lock_irqsave(&rtc_lock, flags);
hal_rtc_set_tick_time(tm);
spin_unlock_irqrestore(&rtc_lock, flags);
return 0;
}
static int rtc_ops_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
{
unsigned long flags;
struct rtc_time *tm = &alm->time;
spin_lock_irqsave(&rtc_lock, flags);
hal_rtc_get_alarm(tm, alm);
spin_unlock_irqrestore(&rtc_lock, flags);
tm->tm_year += RTC_MIN_YEAR_OFFSET;
tm->tm_mon--;
rtc_xinfo("read al time = %04d/%02d/%02d %02d:%02d:%02d (%d)\n",
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
tm->tm_hour, tm->tm_min, tm->tm_sec, alm->enabled);
return 0;
}
static void rtc_save_pwron_time(bool enable, struct rtc_time *tm, bool logo)
{
hal_rtc_save_pwron_time(enable, tm, logo);
}
static int rtc_ops_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
{
unsigned long time, flags;
struct rtc_time tm = alm->time;
ktime_t target;
rtc_tm_to_time(&tm, &time);
if (time > (unsigned long)LONG_MAX)
return -EINVAL;
if (alm->enabled == 1) {
/* Add one more second to postpone wake time. */
target = rtc_tm_to_ktime(tm);
target = ktime_add_ns(target, NSEC_PER_SEC);
tm = rtc_ktime_to_tm(target);
} else if (alm->enabled == 5) {
/* Power on system 1 minute earlier */
alarm1m15s = 1;
}
tm.tm_year -= RTC_MIN_YEAR_OFFSET;
tm.tm_mon++;
rtc_xinfo("set al time = %04d/%02d/%02d %02d:%02d:%02d (%d)\n",
tm.tm_year + RTC_MIN_YEAR, tm.tm_mon, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec, alm->enabled);
spin_lock_irqsave(&rtc_lock, flags);
if (alm->enabled == 2) { /* enable power-on alarm */
rtc_save_pwron_time(true, &tm, false);
} else if (alm->enabled == 3 || alm->enabled == 5) {
/* enable power-on alarm with logo */
rtc_save_pwron_time(true, &tm, true);
} else if (alm->enabled == 4) { /* disable power-on alarm */
/* alm->enabled = 0; */
rtc_save_pwron_time(false, &tm, false);
alarm1m15s = 0;
}
/* disable alarm and clear Power-On Alarm bit */
hal_rtc_clear_alarm(&tm);
if (alm->enabled)
hal_rtc_set_alarm(&tm);
spin_unlock_irqrestore(&rtc_lock, flags);
return 0;
}
int mtk_set_power_on(struct device *dev, struct rtc_wkalrm *alm)
{
int err = 0;
struct rtc_time tm;
time64_t now, scheduled;
err = rtc_valid_tm(&alm->time);
if (err != 0)
return err;
scheduled = rtc_tm_to_time64(&alm->time);
err = rtc_ops_read_time(dev, &tm);
if (err != 0)
return err;
now = rtc_tm_to_time64(&tm);
if (scheduled <= now)
alm->enabled = 4;
else
alm->enabled = 3;
rtc_ops_set_alarm(dev, alm);
return err;
}
static int rtc_ops_ioctl(struct device *dev, unsigned int cmd,
unsigned long arg)
{
void __user *uarg = (void __user *) arg;
int err = 0;
struct rtc_wkalrm alm;
rtc_xinfo("%s cmd=%d\n", __func__, cmd);
switch (cmd) {
case RTC_POFF_ALM_SET:
if (copy_from_user(&alm.time, uarg, sizeof(alm.time)))
return -EFAULT;
err = mtk_set_power_on(dev, &alm);
break;
default:
err = -EINVAL;
break;
}
return err;
}
static int rtc_get_boot_mode(void)
{
struct device_node *np = NULL;
struct device_node *boot_node = NULL;
struct tag_bootmode *tag = NULL;
bootmode = 0;
np = of_find_node_by_name(NULL, "mt6357_rtc");
if (!np) {
rtc_xinfo("%s: of_find_node_by_name fail.\n", __func__);
return -ENXIO;
}
boot_node = of_parse_phandle(np, "bootmode", 0);
if (!boot_node) {
rtc_xinfo("%s: failed to get boot mode phandle\n", __func__);
return -ENXIO;
}
tag = (struct tag_bootmode *)of_get_property(boot_node, "atag,boot", NULL);
if (!tag) {
rtc_xinfo("%s: failed to get atag,boot\n", __func__);
return -ENXIO;
}
bootmode = tag->bootmode;
rtc_xinfo("%s: bootmode:%u\n", __func__, bootmode);
return 0;
}
static const struct rtc_class_ops rtc_ops = {
.read_time = rtc_ops_read_time,
.set_time = rtc_ops_set_time,
.read_alarm = rtc_ops_read_alarm,
.set_alarm = rtc_ops_set_alarm,
.ioctl = rtc_ops_ioctl,
};
static int rtc_pdrv_probe(struct platform_device *pdev)
{
unsigned long flags;
int ret;
/* only enable LPD interrupt in engineering build */
spin_lock_irqsave(&rtc_lock, flags);
hal_rtc_set_lp_irq();
/* lpsd */
rtc_lpsd_restore_al_mask();
spin_unlock_irqrestore(&rtc_lock, flags);
device_init_wakeup(&pdev->dev, 1);
/* register rtc device (/dev/rtc0) */
rtc = rtc_device_register(RTC_NAME, &pdev->dev, &rtc_ops, THIS_MODULE);
if (IS_ERR(rtc)) {
pr_err("register rtc device failed (%ld)\n", PTR_ERR(rtc));
return PTR_ERR(rtc);
}
ret = rtc_get_boot_mode();
if (ret)
rtc_xinfo("%s: RTC get boot mode fail, but RTC can work\n", __func__);
pmic_register_interrupt_callback(INT_RTC, rtc_irq_handler);
pmic_enable_interrupt(INT_RTC, 1, "RTC");
return 0;
}
/* should never be called */
static int rtc_pdrv_remove(struct platform_device *pdev)
{
return 0;
}
static struct platform_driver rtc_pdrv = {
.probe = rtc_pdrv_probe,
.remove = rtc_pdrv_remove,
.driver = {
.name = RTC_NAME,
.owner = THIS_MODULE,
},
};
static struct platform_device rtc_pdev = {
.name = RTC_NAME,
.id = -1,
};
static int __init rtc_device_init(void)
{
int r;
rtc_xinfo("rtc_init");
pm_power_off = mt_power_off;
r = platform_device_register(&rtc_pdev);
if (r) {
pr_err("register device failed (%d)\n", r);
return r;
}
r = platform_driver_register(&rtc_pdrv);
if (r) {
pr_err("register driver failed (%d)\n", r);
platform_device_unregister(&rtc_pdev);
return r;
}
#if (defined(MTK_GPS_MT3332))
hal_rtc_set_gpio_32k_status(0, true);
#endif
return 0;
}
static int __init rtc_late_init(void)
{
unsigned long flags;
spin_lock_irqsave(&rtc_lock, flags);
hal_rtc_read_rg();
spin_unlock_irqrestore(&rtc_lock, flags);
if (crystal_exist_status() == true)
rtc_xinfo("There is Crystal\n");
else
rtc_xinfo("There is no Crystal\n");
rtc_writeif_unlock();
#if (defined(MTK_GPS_MT3332))
hal_rtc_set_gpio_32k_status(0, true);
#endif
return 0;
}
static int __init rtc_arch_init(void)
{
//pm_power_off = mt_power_off;
return 0;
}
/* module_init(rtc_mod_init); */
/* module_exit(rtc_mod_exit); */
late_initcall(rtc_late_init);
device_initcall(rtc_device_init);
module_init(rtc_arch_init);
module_param(rtc_show_time, int, 0644);
module_param(rtc_show_alarm, int, 0644);
MODULE_LICENSE("GPL");
#endif /*#if defined(CONFIG_MTK_RTC) */
Reference in a new issue View git blame Copy permalink