a7y18lte-ubports/android_kernel_samsung_a7y18lte
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
97e4fbcdb3
android_kernel_samsung_a7y1.../drivers/rtc/rtc-sec.c
prashantpaddune 3bca37f224 A750FXXU4CTBC
2020-03-27 21:51:54 +05:30

1577 lines
45 KiB
C
Raw Blame History

/*
* rtc-sec.c
*
* Copyright (c) 2012 Samsung Electronics Co., Ltd
* http://www.samsung.com
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* 2013-12-11 Performance improvements and code clean up by
* Minsung Kim <ms925.kim@samsung.com>
*
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/gpio.h>
#include <linux/rtc.h>
#include <linux/io.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/regmap.h>
#include <linux/platform_device.h>
#include <linux/mfd/samsung/core.h>
#include <linux/mfd/samsung/rtc.h>
#include <linux/mfd/samsung/irq.h>
#include <linux/mfd/samsung/s2mps11.h>
#include <linux/mfd/samsung/s2mps13.h>
#include <linux/mfd/samsung/s2mps15.h>
#include <linux/mfd/samsung/s2mps16.h>
#include <linux/mfd/samsung/s2mpu03.h>
#include <soc/samsung/cpufreq.h>
#ifdef CONFIG_EXYNOS_MBOX
#include <linux/apm-exynos.h>
#endif
struct s2m_rtc_info {
struct device *dev;
struct sec_pmic_dev *iodev;
struct rtc_device *rtc_dev;
struct mutex lock;
struct work_struct irq_work;
int irq;
int smpl_irq;
bool use_irq;
u8 *adc_val;
u8 *adc_reg;
u8 adc_ctrl1;
bool wtsr_en;
bool smpl_en;
bool alarm_enabled;
u8 update_reg;
bool use_alarm_workaround;
bool alarm_check;
bool udr_updated;
u8 wudr_mask;
u8 audr_mask;
int smpl_warn_info;
};
static const unsigned int s2mps15_buck_coeffs[11][2] = { {15625, 17857}, {46875, 53571},
{15625, 17857}, {15625, 17857}, {15625, 17857}, {31250, 35714},
{15625, 17857}, {15625, 15625}, {15625, 15625}, {15625, 17857},
{15625, 17857} };
static const unsigned int s2mps15_ldo_coeff = 4688;
static const unsigned int s2mps16_buck_coeffs[12] = {S2MPS16_BS, S2MPS16_BT, S2MPS16_BS,
S2MPS16_BS, S2MPS16_BS, S2MPS16_BT, S2MPS16_BS, S2MPS16_BV, S2MPS16_BV,
S2MPS16_BS, S2MPS16_BS, S2MPS16_BB};
static const unsigned int s2mps16_ldo_coeffs[38] = {S2MPS16_L600, S2MPS16_L300, S2MPS16_L450,
S2MPS16_L450, S2MPS16_L150, S2MPS16_L150, S2MPS16_L300, S2MPS16_L150, S2MPS16_L150,
S2MPS16_L150, S2MPS16_L300, S2MPS16_L150, S2MPS16_L450, S2MPS16_L150, S2MPS16_L150,
S2MPS16_L150, S2MPS16_L150, S2MPS16_L150, S2MPS16_L150, S2MPS16_L300, S2MPS16_L150,
S2MPS16_L300, S2MPS16_L150, S2MPS16_L150, S2MPS16_L150, S2MPS16_L150, S2MPS16_L600,
S2MPS16_L300, S2MPS16_L450, S2MPS16_L450, S2MPS16_L300, S2MPS16_L150, S2MPS16_L300,
S2MPS16_L300, S2MPS16_L300, S2MPS16_L300, S2MPS16_L150, S2MPS16_L450};
static struct wakeup_source *rtc_ws;
enum S2M_RTC_OP {
S2M_RTC_READ,
S2M_RTC_WRITE_TIME,
S2M_RTC_WRITE_ALARM,
};
static void s2m_data_to_tm(u8 *data, struct rtc_time *tm)
{
tm->tm_sec = data[RTC_SEC] & 0x7f;
tm->tm_min = data[RTC_MIN] & 0x7f;
tm->tm_hour = data[RTC_HOUR] & 0x1f;
tm->tm_wday = __fls(data[RTC_WEEKDAY] & 0x7f);
tm->tm_mday = data[RTC_DATE] & 0x1f;
tm->tm_mon = (data[RTC_MONTH] & 0x0f) - 1;
tm->tm_year = (data[RTC_YEAR] & 0x7f) + 100;
tm->tm_yday = 0;
tm->tm_isdst = 0;
}
static int s2m_tm_to_data(struct rtc_time *tm, u8 *data)
{
data[RTC_SEC] = tm->tm_sec;
data[RTC_MIN] = tm->tm_min;
if (tm->tm_hour >= 12)
data[RTC_HOUR] = tm->tm_hour | HOUR_PM_MASK;
else
data[RTC_HOUR] = tm->tm_hour;
data[RTC_WEEKDAY] = BIT(tm->tm_wday);
data[RTC_DATE] = tm->tm_mday;
data[RTC_MONTH] = tm->tm_mon + 1;
data[RTC_YEAR] = tm->tm_year > 100 ? (tm->tm_year - 100) : 0 ;
if (tm->tm_year < 100) {
pr_warn("%s: SEC RTC cannot handle the year %d\n", __func__,
1900 + tm->tm_year);
return -EINVAL;
}
return 0;
}
static int s2m_rtc_update(struct s2m_rtc_info *info,
enum S2M_RTC_OP op)
{
u8 data;
int ret;
if (!info || !info->iodev) {
pr_err("%s: Invalid argument\n", __func__);
return -EINVAL;
}
switch (op) {
case S2M_RTC_READ:
data = RTC_RUDR_MASK;
break;
case S2M_RTC_WRITE_TIME:
data = info->wudr_mask;
break;
case S2M_RTC_WRITE_ALARM:
if (info->iodev->device_type == S2MPS15X && SEC_PMIC_REV(info->iodev))
data = info->audr_mask;
else if (info->iodev->device_type == S2MPU03X || info->iodev->device_type == S2MPS16X)
data = info->audr_mask;
else if (info->udr_updated)
data = info->audr_mask | info->wudr_mask;
else
data = RTC_RUDR_MASK | info->wudr_mask;
break;
default:
dev_err(info->dev, "%s: invalid op(%d)\n", __func__, op);
return -EINVAL;
}
data |= info->update_reg;
ret = sec_rtc_write(info->iodev, S2M_RTC_UPDATE, data);
if (ret < 0)
dev_err(info->dev, "%s: fail to write update reg(%d,%u)\n",
__func__, ret, data);
else
usleep_range(1000, 1000);
return ret;
}
static int s2m_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
u8 data[NR_RTC_CNT_REGS];
int ret;
mutex_lock(&info->lock);
ret = s2m_rtc_update(info, S2M_RTC_READ);
if (ret < 0)
goto out;
ret = sec_rtc_bulk_read(info->iodev, S2M_RTC_SEC, NR_RTC_CNT_REGS,
data);
if (ret < 0) {
dev_err(info->dev, "%s: fail to read time reg(%d)\n", __func__,
ret);
goto out;
}
dev_info(info->dev, "%s: %d-%02d-%02d %02d:%02d:%02d(0x%02x)%s\n",
__func__, data[RTC_YEAR] + 2000, data[RTC_MONTH],
data[RTC_DATE], data[RTC_HOUR] & 0x1f, data[RTC_MIN],
data[RTC_SEC], data[RTC_WEEKDAY],
data[RTC_HOUR] & HOUR_PM_MASK ? "PM" : "AM");
s2m_data_to_tm(data, tm);
ret = rtc_valid_tm(tm);
out:
mutex_unlock(&info->lock);
return ret;
}
static int s2m_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
u8 data[NR_RTC_CNT_REGS];
int ret;
ret = s2m_tm_to_data(tm, data);
if (ret < 0)
return ret;
dev_info(info->dev, "%s: %d-%02d-%02d %02d:%02d:%02d(0x%02x)%s\n",
__func__, data[RTC_YEAR] + 2000, data[RTC_MONTH],
data[RTC_DATE], data[RTC_HOUR] & 0x1f, data[RTC_MIN],
data[RTC_SEC], data[RTC_WEEKDAY],
data[RTC_HOUR] & HOUR_PM_MASK ? "PM" : "AM");
mutex_lock(&info->lock);
ret = sec_rtc_bulk_write(info->iodev, S2M_RTC_SEC, NR_RTC_CNT_REGS,
data);
if (ret < 0) {
dev_err(info->dev, "%s: fail to write time reg(%d)\n", __func__,
ret);
goto out;
}
ret = s2m_rtc_update(info, S2M_RTC_WRITE_TIME);
out:
mutex_unlock(&info->lock);
return ret;
}
/* This is a workaround for the problem that RTC TIME is overwirted by write
* buffer when setting RTC ALARM. It is quite rare but it does happen. The root
* cuase is that clear signal of RUDR & WUDR is 1 clock delay while it should be
* 2 clock delay.
*/
static int s2m_rtc_check_rtc_time(struct s2m_rtc_info *info)
{
u8 data[NR_RTC_CNT_REGS];
struct rtc_time tm;
struct timeval sys_time;
unsigned long rtc_time;
int ret;
/* Read RTC TIME */
ret = s2m_rtc_update(info, S2M_RTC_READ);
if (ret < 0)
goto out;
ret = sec_rtc_bulk_read(info->iodev, S2M_RTC_SEC, NR_RTC_CNT_REGS,
data);
if (ret < 0) {
dev_err(info->dev, "%s: fail to read time reg(%d)\n", __func__,
ret);
goto out;
}
/* Get system time */
do_gettimeofday(&sys_time);
/* Convert RTC TIME to seconds since 01-01-1970 00:00:00. */
s2m_data_to_tm(data, &tm);
rtc_tm_to_time(&tm, &rtc_time);
if (abs(rtc_time - sys_time.tv_sec) > 2) {
/* Set RTC TIME */
rtc_time_to_tm(sys_time.tv_sec, &tm);
ret = s2m_tm_to_data(&tm, data);
if (ret < 0) {
dev_err(info->dev, "%s: fail to tm_to_data(%d)\n",
__func__, ret);
goto out;
}
ret = sec_rtc_bulk_write(info->iodev, S2M_RTC_SEC,
NR_RTC_CNT_REGS, data);
if (ret < 0) {
dev_err(info->dev, "%s: fail to write time reg(%d)\n",
__func__, ret);
goto out;
}
ret = s2m_rtc_update(info, S2M_RTC_WRITE_TIME);
dev_warn(info->dev, "%s: adjust RTC TIME: sys_time: %lu, "
"rtc_time: %lu\n", __func__, sys_time.tv_sec,
rtc_time);
dev_info(info->dev, "%s: %d-%02d-%02d %02d:%02d:%02d(0x%02x)%s\n",
__func__, data[RTC_YEAR] + 2000, data[RTC_MONTH],
data[RTC_DATE], data[RTC_HOUR] & 0x1f, data[RTC_MIN],
data[RTC_SEC], data[RTC_WEEKDAY],
data[RTC_HOUR] & HOUR_PM_MASK ? "PM" : "AM");
}
out:
return ret;
}
static int s2m_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
u8 data[NR_RTC_CNT_REGS];
u32 reg, val;
int ret;
mutex_lock(&info->lock);
ret = s2m_rtc_update(info, S2M_RTC_READ);
if (ret < 0)
goto out;
ret = sec_rtc_bulk_read(info->iodev, S2M_ALARM0_SEC, NR_RTC_CNT_REGS,
data);
if (ret < 0) {
dev_err(info->dev, "%s:%d fail to read alarm reg(%d)\n",
__func__, __LINE__, ret);
goto out;
}
s2m_data_to_tm(data, &alrm->time);
dev_info(info->dev, "%s: %d-%02d-%02d %02d:%02d:%02d(%d)\n", __func__,
alrm->time.tm_year + 1900, alrm->time.tm_mon + 1,
alrm->time.tm_mday, alrm->time.tm_hour,
alrm->time.tm_min, alrm->time.tm_sec,
alrm->time.tm_wday);
alrm->enabled = info->alarm_enabled;
alrm->pending = 0;
switch (info->iodev->device_type) {
case S2MPS11X:
reg = S2MPS11_REG_ST2;
break;
case S2MPS13X:
reg = S2MPS13_REG_ST2;
break;
case S2MPS15X:
reg = S2MPS15_REG_ST2;
break;
case S2MPU03X:
reg = S2MPU03_REG_ST2;
break;
case S2MPS16X:
reg = S2MPS16_REG_ST2;
break;
default:
/* If this happens the core funtion has a problem */
BUG();
}
ret = sec_reg_read(info->iodev, reg, &val);
if (ret < 0) {
dev_err(info->dev, "%s:%d fail to read STATUS2 reg(%d)\n",
__func__, __LINE__, ret);
goto out;
}
if (val & RTCA0E)
alrm->pending = 1;
out:
mutex_unlock(&info->lock);
return ret;
}
static int s2m_rtc_set_alarm_enable(struct s2m_rtc_info *info, bool enabled)
{
if (!info->use_irq)
return -EPERM;
if (enabled && !info->alarm_enabled) {
info->alarm_enabled = true;
enable_irq(info->irq);
} else if (!enabled && info->alarm_enabled) {
info->alarm_enabled = false;
disable_irq(info->irq);
}
return 0;
}
static int s2m_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
u8 data[NR_RTC_CNT_REGS];
int ret, i;
mutex_lock(&info->lock);
ret = s2m_tm_to_data(&alrm->time, data);
if (ret < 0)
goto out;
dev_info(info->dev, "%s: %d-%02d-%02d %02d:%02d:%02d(0x%02x)%s\n",
__func__, data[RTC_YEAR] + 2000, data[RTC_MONTH],
data[RTC_DATE], data[RTC_HOUR] & 0x1f, data[RTC_MIN],
data[RTC_SEC], data[RTC_WEEKDAY],
data[RTC_HOUR] & HOUR_PM_MASK ? "PM" : "AM");
if (info->alarm_check) {
for (i = 0; i < NR_RTC_CNT_REGS; i++)
data[i] &= ~ALARM_ENABLE_MASK;
ret = sec_rtc_bulk_write(info->iodev, S2M_ALARM0_SEC, NR_RTC_CNT_REGS,
data);
if (ret < 0) {
dev_err(info->dev, "%s: fail to disable alarm reg(%d)\n",
__func__, ret);
goto out;
}
ret = s2m_rtc_update(info, S2M_RTC_WRITE_ALARM);
if (ret < 0)
goto out;
}
for (i = 0; i < NR_RTC_CNT_REGS; i++)
data[i] |= ALARM_ENABLE_MASK;
ret = sec_rtc_bulk_write(info->iodev, S2M_ALARM0_SEC, NR_RTC_CNT_REGS,
data);
if (ret < 0) {
dev_err(info->dev, "%s: fail to write alarm reg(%d)\n",
__func__, ret);
goto out;
}
ret = s2m_rtc_update(info, S2M_RTC_WRITE_ALARM);
if (ret < 0)
goto out;
if (info->use_alarm_workaround) {
ret = s2m_rtc_check_rtc_time(info);
if (ret < 0)
goto out;
}
ret = s2m_rtc_set_alarm_enable(info, alrm->enabled);
out:
mutex_unlock(&info->lock);
return ret;
}
static int s2m_rtc_alarm_irq_enable(struct device *dev,
unsigned int enabled)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
int ret;
mutex_lock(&info->lock);
ret = s2m_rtc_set_alarm_enable(info, enabled);
mutex_unlock(&info->lock);
return ret;
}
static irqreturn_t s2m_rtc_alarm_irq(int irq, void *data)
{
struct s2m_rtc_info *info = data;
if (!info->rtc_dev)
return IRQ_HANDLED;
dev_info(info->dev, "%s:irq(%d)\n", __func__, irq);
rtc_update_irq(info->rtc_dev, 1, RTC_IRQF | RTC_AF);
__pm_wakeup_event(rtc_ws, 500);
return IRQ_HANDLED;
}
static irqreturn_t s2m_smpl_warn_irq(int irq, void *data)
{
struct s2m_rtc_info *info = data;
if (!info->rtc_dev)
return IRQ_HANDLED;
dev_info(info->dev, "%s:irq(%d)\n", __func__, irq);
schedule_work(&info->irq_work);
return IRQ_HANDLED;
}
static void exynos_smpl_warn_work(struct work_struct *work)
{
struct s2m_rtc_info *info = container_of(work,
struct s2m_rtc_info, irq_work);
int state = 0;
switch(info->iodev->device_type) {
/* smpl_warn interrupt is active high */
case S2MPS13X:
case S2MPS15X:
do {
state = (gpio_get_value(info->smpl_warn_info) & 0x1);
msleep(100);
} while (state);
break;
/* smpl_warn interrupt is active low */
case S2MPS16X:
do {
state = (gpio_get_value(info->smpl_warn_info) & 0x1);
msleep(100);
} while (!state);
break;
}
exynos_cpufreq_smpl_warn_notify_call_chain();
}
static void s2m_adc_read_data(struct s2m_rtc_info *info)
{
/* adc data read */
switch(info->iodev->device_type) {
case S2MPS15X:
sec_reg_write(info->iodev, S2MPS15_REG_ADC_CTRL2, 0x93);
sec_bulk_read(info->iodev, S2MPS15_REG_ADC_DATA, S2MPS15_MAX_ADC_CHANNEL, info->adc_val);
break;
case S2MPS16X:
sec_reg_write(info->iodev, S2MPS16_REG_ADC_CTRL2, 0xCF);
sec_bulk_read(info->iodev, S2MPS16_REG_ADC_DATA, S2MPS16_MAX_ADC_CHANNEL, info->adc_val);
break;
}
}
static unsigned int get_coeff(struct device *dev, u8 adc_reg_num)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
unsigned int coeff, temp;
u8 is_evt2;
switch(info->iodev->device_type) {
case S2MPS15X:
if (SEC_PMIC_REV(info->iodev) == 0x0)
is_evt2 = 0;
else if (SEC_PMIC_REV(info->iodev) == 0x1) {
sec_reg_read(info->iodev, 0x59, &temp);
is_evt2 = ((temp & 0x10) == 0x10) ? 1 : 0;
} else
is_evt2 = 1;
/* if the regulator is LDO */
if (adc_reg_num >= S2MPS15_LDO_START && adc_reg_num <= S2MPS15_LDO_END)
coeff = s2mps15_ldo_coeff;
/* if the regulator is BUCK */
else if (adc_reg_num >= S2MPS15_BUCK_START && adc_reg_num <= S2MPS15_BUCK_END)
coeff = is_evt2 ? s2mps15_buck_coeffs[adc_reg_num - 1][1] : s2mps15_buck_coeffs[adc_reg_num - 1][0];
else {
dev_err(info->dev, "%s: invalid adc regulator number(%d)\n", __func__, adc_reg_num);
coeff = 0;
}
break;
case S2MPS16X:
/* if the regulator is LDO */
if (adc_reg_num >= S2MPS16_LDO_START && adc_reg_num <= S2MPS16_LDO_END)
coeff = s2mps16_ldo_coeffs[adc_reg_num - 0x41];
/* if the regulator is BUCK */
else if (adc_reg_num >= S2MPS16_BUCK_START && adc_reg_num <= S2MPS16_BUCK_END)
coeff = s2mps16_buck_coeffs[adc_reg_num - 1];
else {
dev_err(info->dev, "%s: invalid adc regulator number(%d)\n", __func__, adc_reg_num);
coeff = 0;
}
break;
}
return coeff;
}
static ssize_t adc_val_0_show(struct device *dev, struct device_attribute *attr, char *buf)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
s2m_adc_read_data(info);
return snprintf(buf, PAGE_SIZE, "%d\n", info->adc_val[0] * get_coeff(dev, info->adc_reg[0]));
}
static ssize_t adc_val_1_show(struct device *dev, struct device_attribute *attr, char *buf)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
s2m_adc_read_data(info);
return snprintf(buf, PAGE_SIZE, "%d\n", info->adc_val[1] * get_coeff(dev, info->adc_reg[1]));
}
static ssize_t adc_val_2_show(struct device *dev, struct device_attribute *attr, char *buf)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
s2m_adc_read_data(info);
return snprintf(buf, PAGE_SIZE, "%d\n", info->adc_val[2] * get_coeff(dev, info->adc_reg[2]));
}
static ssize_t adc_val_3_show(struct device *dev, struct device_attribute *attr, char *buf)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
s2m_adc_read_data(info);
return snprintf(buf, PAGE_SIZE, "%d\n", info->adc_val[3] * get_coeff(dev, info->adc_reg[3]));
}
static ssize_t adc_val_4_show(struct device *dev, struct device_attribute *attr, char *buf)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
s2m_adc_read_data(info);
return snprintf(buf, PAGE_SIZE, "%d\n", info->adc_val[4] * get_coeff(dev, info->adc_reg[4]));
}
static ssize_t adc_val_5_show(struct device *dev, struct device_attribute *attr, char *buf)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
s2m_adc_read_data(info);
return snprintf(buf, PAGE_SIZE, "%d\n", info->adc_val[5] * get_coeff(dev, info->adc_reg[5]));
}
static ssize_t adc_val_6_show(struct device *dev, struct device_attribute *attr, char *buf)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
s2m_adc_read_data(info);
return snprintf(buf, PAGE_SIZE, "%d\n", info->adc_val[6] * get_coeff(dev, info->adc_reg[6]));
}
static ssize_t adc_val_7_show(struct device *dev, struct device_attribute *attr, char *buf)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
s2m_adc_read_data(info);
return snprintf(buf, PAGE_SIZE, "%d\n", info->adc_val[7] * get_coeff(dev, info->adc_reg[7]));
}
static ssize_t adc_val_all_show(struct device *dev, struct device_attribute *attr, char *buf)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
s2m_adc_read_data(info);
switch (info->iodev->device_type) {
case S2MPS15X:
return snprintf(buf, PAGE_SIZE, "CH1[%x]:%d uA (%d), CH2[%x]:%d uA (%d), CH3[%x]:%d uA (%d), CH4[%x]:%d uA (%d)\n",
info->adc_reg[0], info->adc_val[0] * get_coeff(dev, info->adc_reg[0]), info->adc_val[0],
info->adc_reg[1], info->adc_val[1] * get_coeff(dev, info->adc_reg[1]), info->adc_val[1],
info->adc_reg[2], info->adc_val[2] * get_coeff(dev, info->adc_reg[2]), info->adc_val[2],
info->adc_reg[3], info->adc_val[3] * get_coeff(dev, info->adc_reg[3]), info->adc_val[3]);
case S2MPS16X:
return snprintf(buf, PAGE_SIZE, "CH1[%x]:%d uA (%d), CH2[%x]:%d uA (%d), CH3[%x]:%d uA (%d), CH4[%x]:%d uA (%d)\nCH4[%x]:%d uA (%d), CH5[%x]:%d uA (%d), CH6[%x]:%d uA (%d), CH7[%x]:%d uA (%d)\n",
info->adc_reg[0], info->adc_val[0] * get_coeff(dev, info->adc_reg[0]), info->adc_val[0],
info->adc_reg[1], info->adc_val[1] * get_coeff(dev, info->adc_reg[1]), info->adc_val[1],
info->adc_reg[2], info->adc_val[2] * get_coeff(dev, info->adc_reg[2]), info->adc_val[2],
info->adc_reg[3], info->adc_val[3] * get_coeff(dev, info->adc_reg[3]), info->adc_val[3],
info->adc_reg[4], info->adc_val[4] * get_coeff(dev, info->adc_reg[4]), info->adc_val[4],
info->adc_reg[5], info->adc_val[5] * get_coeff(dev, info->adc_reg[5]), info->adc_val[5],
info->adc_reg[6], info->adc_val[6] * get_coeff(dev, info->adc_reg[6]), info->adc_val[6],
info->adc_reg[7], info->adc_val[7] * get_coeff(dev, info->adc_reg[7]), info->adc_val[7]);
default:
return 0;
}
}
static ssize_t adc_reg_0_show(struct device *dev, struct device_attribute *attr, char *buf)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%x\n", info->adc_reg[0]);
}
static ssize_t adc_reg_1_show(struct device *dev, struct device_attribute *attr, char *buf)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%x\n", info->adc_reg[1]);
}
static ssize_t adc_reg_2_show(struct device *dev, struct device_attribute *attr, char *buf)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%x\n", info->adc_reg[2]);
}
static ssize_t adc_reg_3_show(struct device *dev, struct device_attribute *attr, char *buf)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%x\n", info->adc_reg[3]);
}
static ssize_t adc_reg_4_show(struct device *dev, struct device_attribute *attr, char *buf)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%x\n", info->adc_reg[4]);
}
static ssize_t adc_reg_5_show(struct device *dev, struct device_attribute *attr, char *buf)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%x\n", info->adc_reg[5]);
}
static ssize_t adc_reg_6_show(struct device *dev, struct device_attribute *attr, char *buf)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%x\n", info->adc_reg[6]);
}
static ssize_t adc_reg_7_show(struct device *dev, struct device_attribute *attr, char *buf)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%x\n", info->adc_reg[7]);
}
static ssize_t adc_ctrl2_show(struct device *dev, struct device_attribute *attr, char *buf)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
u8 adc_ctrl2;
switch (info->iodev->device_type) {
case S2MPS15X:
sec_reg_read(info->iodev, S2MPS15_REG_ADC_CTRL2, &adc_ctrl2);
break;
case S2MPS16X:
sec_reg_read(info->iodev, S2MPS16_REG_ADC_CTRL2, &adc_ctrl2);
break;
default:
adc_ctrl2 = 0;
break;
}
return snprintf(buf, PAGE_SIZE, "%x\n", adc_ctrl2);
}
static u8 buf_to_adc_reg(const char *buf, int device_type)
{
u8 adc_reg_num;
if (kstrtou8(buf, 16, &adc_reg_num))
return 0;
switch (device_type) {
case S2MPS15X:
if ((adc_reg_num >= S2MPS15_BUCK_START && adc_reg_num <= S2MPS15_BUCK_END) ||
(adc_reg_num >= S2MPS15_LDO_START && adc_reg_num <= S2MPS15_LDO_END))
return adc_reg_num;
case S2MPS16X:
if ((adc_reg_num >= S2MPS16_BUCK_START && adc_reg_num <= S2MPS16_BUCK_END) ||
(adc_reg_num >= S2MPS16_LDO_START && adc_reg_num <= S2MPS16_LDO_END))
return adc_reg_num;
default:
return 0;
}
}
static void adc_reg_update(struct device *dev)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
switch (info->iodev->device_type) {
case S2MPS15X:
/* ADC temporarily off */
sec_reg_write(info->iodev, S2MPS15_REG_ADC_CTRL2, 0);
/* mux program enable, auto increase enable */
sec_reg_write(info->iodev, S2MPS15_REG_ADC_CTRL2, 0x14);
sec_bulk_write(info->iodev, S2MPS15_REG_ADC_DATA, S2MPS15_MAX_ADC_CHANNEL, info->adc_reg);
/* ADC Continuous ON */
sec_reg_write(info->iodev, S2MPS15_REG_ADC_CTRL2, S2MPS15_ADCEN_MASK);
break;
case S2MPS16X:
/* ADC temporarily off */
sec_reg_write(info->iodev, S2MPS16_REG_ADC_CTRL2, 0);
/* mux program enable, auto increase enable */
sec_reg_write(info->iodev, S2MPS16_REG_ADC_CTRL2, 0x50);
sec_bulk_write(info->iodev, S2MPS16_REG_ADC_DATA, S2MPS16_MAX_ADC_CHANNEL, info->adc_reg);
/* ADC Continuous ON */
sec_reg_write(info->iodev, S2MPS16_REG_ADC_CTRL2, S2MPS16_ADCEN_MASK);
break;
}
}
static void adc_ctrl1_update(struct device *dev)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
switch (info->iodev->device_type) {
case S2MPS15X:
/* ADC temporarily off */
sec_reg_write(info->iodev, S2MPS15_REG_ADC_CTRL2, 0);
/* update ADC_CTRL1 register */
sec_reg_write(info->iodev, S2MPS15_REG_ADC_CTRL1, info->adc_ctrl1);
/* ADC Continuous ON */
sec_reg_write(info->iodev, S2MPS15_REG_ADC_CTRL2, S2MPS15_ADCEN_MASK);
case S2MPS16X:
/* ADC temporarily off */
sec_reg_write(info->iodev, S2MPS16_REG_ADC_CTRL2, 0);
/* update ADC_CTRL1 register */
sec_reg_write(info->iodev, S2MPS16_REG_ADC_CTRL1, info->adc_ctrl1);
/* ADC Continuous ON */
sec_reg_write(info->iodev, S2MPS16_REG_ADC_CTRL2, S2MPS16_ADCEN_MASK);
}
}
static ssize_t adc_reg_0_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
u8 adc_reg_num = buf_to_adc_reg(buf, info->iodev->device_type);
if (!adc_reg_num)
return -EINVAL;
else {
info->adc_reg[0] = adc_reg_num;
adc_reg_update(dev);
return count;
}
}
static ssize_t adc_reg_1_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
u8 adc_reg_num = buf_to_adc_reg(buf, info->iodev->device_type);
if (!adc_reg_num)
return -EINVAL;
else {
info->adc_reg[1] = adc_reg_num;
adc_reg_update(dev);
return count;
}
}
static ssize_t adc_reg_2_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
u8 adc_reg_num = buf_to_adc_reg(buf, info->iodev->device_type);
if (!adc_reg_num)
return -EINVAL;
else {
info->adc_reg[2] = adc_reg_num;
adc_reg_update(dev);
return count;
}
}
static ssize_t adc_reg_3_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
u8 adc_reg_num = buf_to_adc_reg(buf, info->iodev->device_type);
if (!adc_reg_num)
return -EINVAL;
else {
info->adc_reg[3] = adc_reg_num;
adc_reg_update(dev);
return count;
}
}
static ssize_t adc_reg_4_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
u8 adc_reg_num = buf_to_adc_reg(buf, info->iodev->device_type);
if (!adc_reg_num)
return -EINVAL;
else {
info->adc_reg[4] = adc_reg_num;
adc_reg_update(dev);
return count;
}
}
static ssize_t adc_reg_5_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
u8 adc_reg_num = buf_to_adc_reg(buf, info->iodev->device_type);
if (!adc_reg_num)
return -EINVAL;
else {
info->adc_reg[5] = adc_reg_num;
adc_reg_update(dev);
return count;
}
}
static ssize_t adc_reg_6_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
u8 adc_reg_num = buf_to_adc_reg(buf, info->iodev->device_type);
if (!adc_reg_num)
return -EINVAL;
else {
info->adc_reg[6] = adc_reg_num;
adc_reg_update(dev);
return count;
}
}
static ssize_t adc_reg_7_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
u8 adc_reg_num = buf_to_adc_reg(buf, info->iodev->device_type);
if (!adc_reg_num)
return -EINVAL;
else {
info->adc_reg[7] = adc_reg_num;
adc_reg_update(dev);
return count;
}
}
static ssize_t adc_ctrl1_show(struct device *dev, struct device_attribute *attr, char *buf)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%x\n", info->adc_ctrl1);
}
static ssize_t adc_ctrl1_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct s2m_rtc_info *info = dev_get_drvdata(dev);
int ret;
u8 temp;
ret = kstrtou8(buf, 16, &temp);
if (ret)
return -EINVAL;
else {
info->adc_ctrl1 = temp & 0x3f;
adc_ctrl1_update(dev);
return count;
}
}
static DEVICE_ATTR(adc_val_0, 0444, adc_val_0_show, NULL);
static DEVICE_ATTR(adc_val_1, 0444, adc_val_1_show, NULL);
static DEVICE_ATTR(adc_val_2, 0444, adc_val_2_show, NULL);
static DEVICE_ATTR(adc_val_3, 0444, adc_val_3_show, NULL);
static DEVICE_ATTR(adc_val_4, 0444, adc_val_4_show, NULL);
static DEVICE_ATTR(adc_val_5, 0444, adc_val_5_show, NULL);
static DEVICE_ATTR(adc_val_6, 0444, adc_val_6_show, NULL);
static DEVICE_ATTR(adc_val_7, 0444, adc_val_7_show, NULL);
static DEVICE_ATTR(adc_val_all, 0444, adc_val_all_show, NULL);
static DEVICE_ATTR(adc_ctrl2, 0444, adc_ctrl2_show, NULL);
static DEVICE_ATTR(adc_reg_0, 0644, adc_reg_0_show, adc_reg_0_store);
static DEVICE_ATTR(adc_reg_1, 0644, adc_reg_1_show, adc_reg_1_store);
static DEVICE_ATTR(adc_reg_2, 0644, adc_reg_2_show, adc_reg_2_store);
static DEVICE_ATTR(adc_reg_3, 0644, adc_reg_3_show, adc_reg_3_store);
static DEVICE_ATTR(adc_reg_4, 0644, adc_reg_4_show, adc_reg_4_store);
static DEVICE_ATTR(adc_reg_5, 0644, adc_reg_5_show, adc_reg_5_store);
static DEVICE_ATTR(adc_reg_6, 0644, adc_reg_6_show, adc_reg_6_store);
static DEVICE_ATTR(adc_reg_7, 0644, adc_reg_7_show, adc_reg_7_store);
static DEVICE_ATTR(adc_ctrl1, 0644, adc_ctrl1_show, adc_ctrl1_store);
static void adc_init(struct s2m_rtc_info *info)
{
int ret;
switch (info->iodev->device_type) {
case S2MPS15X:
info->adc_val = kzalloc(sizeof(u8)*S2MPS15_MAX_ADC_CHANNEL, GFP_KERNEL);
info->adc_reg = kzalloc(sizeof(u8)*S2MPS15_MAX_ADC_CHANNEL, GFP_KERNEL);
/* initial regulators : BUCK 2,3,6,1 */
info->adc_reg[0] = 0x2;
info->adc_reg[1] = 0x3;
info->adc_reg[2] = 0x6;
info->adc_reg[3] = 0x1;
/* sample number : 32, divide ratio : (15+1)*2 = 32
ADC clock = 500KHz/32 = 15.625KHz, clock period per sample = 16 cycles,
period of register update = (16/15.625) * 32 samples * 4 channels = 131.072ms */
info->adc_ctrl1 = 0x2f;
sec_reg_write(info->iodev, S2MPS15_REG_ADC_CTRL1, 0x2F);
/* mux program enable, auto increase enable */
sec_reg_write(info->iodev, S2MPS15_REG_ADC_CTRL2, 0x14);
sec_bulk_write(info->iodev, S2MPS15_REG_ADC_DATA, S2MPS15_MAX_ADC_CHANNEL, info->adc_reg);
/* ADC Continuous ON */
sec_reg_write(info->iodev, S2MPS15_REG_ADC_CTRL2, S2MPS15_ADCEN_MASK);
/* create sysfs entries */
ret = device_create_file(info->dev, &dev_attr_adc_val_0);
if (ret)
goto err_adc_val_0;
ret = device_create_file(info->dev, &dev_attr_adc_val_1);
if (ret)
goto remove_adc_val_0;
ret = device_create_file(info->dev, &dev_attr_adc_val_2);
if (ret)
goto remove_adc_val_1;
ret = device_create_file(info->dev, &dev_attr_adc_val_3);
if (ret)
goto remove_adc_val_2;
ret = device_create_file(info->dev, &dev_attr_adc_ctrl2);
if (ret)
goto remove_adc_val_3;
ret = device_create_file(info->dev, &dev_attr_adc_val_all);
if (ret)
goto remove_adc_ctrl2;
ret = device_create_file(info->dev, &dev_attr_adc_reg_0);
if (ret)
goto remove_adc_val_all;
ret = device_create_file(info->dev, &dev_attr_adc_reg_1);
if (ret)
goto remove_adc_reg_0;
ret = device_create_file(info->dev, &dev_attr_adc_reg_2);
if (ret)
goto remove_adc_reg_1;
ret = device_create_file(info->dev, &dev_attr_adc_reg_3);
if (ret)
goto remove_adc_reg_2;
ret = device_create_file(info->dev, &dev_attr_adc_ctrl1);
if (ret)
goto remove_adc_reg_3;
break;
case S2MPS16X:
info->adc_val = kzalloc(sizeof(u8)*S2MPS16_MAX_ADC_CHANNEL, GFP_KERNEL);
info->adc_reg = kzalloc(sizeof(u8)*S2MPS16_MAX_ADC_CHANNEL, GFP_KERNEL);
/* initial regulators : BUCK 1,2,3,4,5,6,7,8 */
info->adc_reg[0] = 0x1;
info->adc_reg[1] = 0x2;
info->adc_reg[2] = 0x3;
info->adc_reg[3] = 0x4;
info->adc_reg[4] = 0x5;
info->adc_reg[5] = 0x6;
info->adc_reg[6] = 0x7;
info->adc_reg[7] = 0x8;
info->adc_ctrl1 = 0x88;
/* mux program enable, auto increase enable */
sec_reg_write(info->iodev, S2MPS16_REG_ADC_CTRL2, 0x50);
sec_bulk_write(info->iodev, S2MPS16_REG_ADC_DATA, S2MPS16_MAX_ADC_CHANNEL, info->adc_reg);
/* ADC Continuous ON */
sec_reg_write(info->iodev, S2MPS16_REG_ADC_CTRL2, S2MPS16_ADCEN_MASK);
/* create sysfs entries */
ret = device_create_file(info->dev, &dev_attr_adc_val_0);
if (ret)
goto err_adc_val_0;
ret = device_create_file(info->dev, &dev_attr_adc_val_1);
if (ret)
goto remove_adc_val_0;
ret = device_create_file(info->dev, &dev_attr_adc_val_2);
if (ret)
goto remove_adc_val_1;
ret = device_create_file(info->dev, &dev_attr_adc_val_3);
if (ret)
goto remove_adc_val_2;
ret = device_create_file(info->dev, &dev_attr_adc_ctrl2);
if (ret)
goto remove_adc_val_3;
ret = device_create_file(info->dev, &dev_attr_adc_val_all);
if (ret)
goto remove_adc_ctrl2;
ret = device_create_file(info->dev, &dev_attr_adc_reg_0);
if (ret)
goto remove_adc_val_all;
ret = device_create_file(info->dev, &dev_attr_adc_reg_1);
if (ret)
goto remove_adc_reg_0;
ret = device_create_file(info->dev, &dev_attr_adc_reg_2);
if (ret)
goto remove_adc_reg_1;
ret = device_create_file(info->dev, &dev_attr_adc_reg_3);
if (ret)
goto remove_adc_reg_2;
ret = device_create_file(info->dev, &dev_attr_adc_ctrl1);
if (ret)
goto remove_adc_reg_3;
/* add channel */
ret = device_create_file(info->dev, &dev_attr_adc_val_4);
if (ret)
goto remove_adc_val_4;
ret = device_create_file(info->dev, &dev_attr_adc_val_5);
if (ret)
goto remove_adc_val_5;
ret = device_create_file(info->dev, &dev_attr_adc_val_6);
if (ret)
goto remove_adc_val_6;
ret = device_create_file(info->dev, &dev_attr_adc_val_7);
if (ret)
goto remove_adc_val_7;
ret = device_create_file(info->dev, &dev_attr_adc_reg_4);
if (ret)
goto remove_adc_reg_4;
ret = device_create_file(info->dev, &dev_attr_adc_reg_5);
if (ret)
goto remove_adc_reg_5;
ret = device_create_file(info->dev, &dev_attr_adc_reg_6);
if (ret)
goto remove_adc_reg_6;
ret = device_create_file(info->dev, &dev_attr_adc_reg_7);
if (ret)
goto remove_adc_reg_7;
break;
default:
break;
}
return ;
remove_adc_reg_7:
device_remove_file(info->dev, &dev_attr_adc_reg_6);
remove_adc_reg_6:
device_remove_file(info->dev, &dev_attr_adc_reg_5);
remove_adc_reg_5:
device_remove_file(info->dev, &dev_attr_adc_reg_4);
remove_adc_reg_4:
device_remove_file(info->dev, &dev_attr_adc_val_7);
remove_adc_val_7:
device_remove_file(info->dev, &dev_attr_adc_val_6);
remove_adc_val_6:
device_remove_file(info->dev, &dev_attr_adc_val_5);
remove_adc_val_5:
device_remove_file(info->dev, &dev_attr_adc_val_4);
remove_adc_val_4:
device_remove_file(info->dev, &dev_attr_adc_ctrl1);
remove_adc_reg_3:
device_remove_file(info->dev, &dev_attr_adc_reg_3);
remove_adc_reg_2:
device_remove_file(info->dev, &dev_attr_adc_reg_2);
remove_adc_reg_1:
device_remove_file(info->dev, &dev_attr_adc_reg_1);
remove_adc_reg_0:
device_remove_file(info->dev, &dev_attr_adc_reg_0);
remove_adc_val_all:
device_remove_file(info->dev, &dev_attr_adc_val_all);
remove_adc_ctrl2:
device_remove_file(info->dev, &dev_attr_adc_ctrl2);
remove_adc_val_3:
device_remove_file(info->dev, &dev_attr_adc_val_3);
remove_adc_val_2:
device_remove_file(info->dev, &dev_attr_adc_val_2);
remove_adc_val_1:
device_remove_file(info->dev, &dev_attr_adc_val_1);
remove_adc_val_0:
device_remove_file(info->dev, &dev_attr_adc_val_0);
err_adc_val_0:
return ;
}
static void adc_deinit(struct s2m_rtc_info *info)
{
switch (info->iodev->device_type) {
case S2MPS15X:
/* remove sysfs entries */
device_remove_file(info->dev, &dev_attr_adc_val_0);
device_remove_file(info->dev, &dev_attr_adc_val_1);
device_remove_file(info->dev, &dev_attr_adc_val_2);
device_remove_file(info->dev, &dev_attr_adc_val_3);
device_remove_file(info->dev, &dev_attr_adc_ctrl2);
device_remove_file(info->dev, &dev_attr_adc_val_all);
device_remove_file(info->dev, &dev_attr_adc_reg_0);
device_remove_file(info->dev, &dev_attr_adc_reg_1);
device_remove_file(info->dev, &dev_attr_adc_reg_2);
device_remove_file(info->dev, &dev_attr_adc_reg_3);
device_remove_file(info->dev, &dev_attr_adc_ctrl1);
/* ADC turned off */
sec_reg_write(info->iodev, S2MPS15_REG_ADC_CTRL2, 0);
kfree(info->adc_val);
kfree(info->adc_reg);
break;
case S2MPS16X:
/* remove sysfs entries */
device_remove_file(info->dev, &dev_attr_adc_val_0);
device_remove_file(info->dev, &dev_attr_adc_val_1);
device_remove_file(info->dev, &dev_attr_adc_val_2);
device_remove_file(info->dev, &dev_attr_adc_val_3);
device_remove_file(info->dev, &dev_attr_adc_ctrl2);
device_remove_file(info->dev, &dev_attr_adc_val_all);
device_remove_file(info->dev, &dev_attr_adc_reg_0);
device_remove_file(info->dev, &dev_attr_adc_reg_1);
device_remove_file(info->dev, &dev_attr_adc_reg_2);
device_remove_file(info->dev, &dev_attr_adc_reg_3);
device_remove_file(info->dev, &dev_attr_adc_ctrl1);
device_remove_file(info->dev, &dev_attr_adc_val_4);
device_remove_file(info->dev, &dev_attr_adc_val_5);
device_remove_file(info->dev, &dev_attr_adc_val_6);
device_remove_file(info->dev, &dev_attr_adc_val_7);
device_remove_file(info->dev, &dev_attr_adc_reg_4);
device_remove_file(info->dev, &dev_attr_adc_reg_5);
device_remove_file(info->dev, &dev_attr_adc_reg_6);
device_remove_file(info->dev, &dev_attr_adc_reg_7);
/* ADC turned off */
sec_reg_write(info->iodev, S2MPS16_REG_ADC_CTRL2, 0);
kfree(info->adc_val);
kfree(info->adc_reg);
break;
default:
break;
}
}
static const struct rtc_class_ops s2m_rtc_ops = {
.read_time = s2m_rtc_read_time,
.set_time = s2m_rtc_set_time,
.read_alarm = s2m_rtc_read_alarm,
.set_alarm = s2m_rtc_set_alarm,
.alarm_irq_enable = s2m_rtc_alarm_irq_enable,
};
static bool s2m_is_jigonb_low(struct s2m_rtc_info *info)
{
int ret, reg;
u32 val, mask;
switch (info->iodev->device_type) {
case S2MPS11X:
reg = S2MPS11_REG_ST1;
mask = BIT(1);
break;
case S2MPS13X:
reg = S2MPS13_REG_ST1;
mask = BIT(1);
break;
case S2MPS15X:
reg = S2MPS15_REG_ST1;
mask = BIT(1);
break;
case S2MPU03X:
reg = S2MPU03_REG_ST1;
mask = BIT(1);
break;
case S2MPS16X:
reg = S2MPS16_REG_ST1;
mask = BIT(1);
break;
default:
/* If this happens the core funtion has a problem */
BUG();
}
ret = sec_reg_read(info->iodev, reg, &val);
if (ret < 0) {
dev_err(info->dev, "%s: fail to read status1 reg(%d)\n",
__func__, ret);
return false;
}
return !(val & mask);
}
static void s2m_rtc_enable_wtsr_smpl(struct s2m_rtc_info *info,
struct sec_platform_data *pdata)
{
u8 val;
int ret;
if (pdata->wtsr_smpl->check_jigon && s2m_is_jigonb_low(info))
pdata->wtsr_smpl->smpl_en = false;
val = (pdata->wtsr_smpl->wtsr_en << WTSR_EN_SHIFT)
| (pdata->wtsr_smpl->smpl_en << SMPL_EN_SHIFT)
| WTSR_TIMER_BITS(pdata->wtsr_smpl->wtsr_timer_val)
| SMPL_TIMER_BITS(pdata->wtsr_smpl->smpl_timer_val);
dev_info(info->dev, "%s: WTSR: %s, SMPL: %s\n", __func__,
pdata->wtsr_smpl->wtsr_en ? "enable" : "disable",
pdata->wtsr_smpl->smpl_en ? "enable" : "disable");
ret = sec_rtc_write(info->iodev, S2M_RTC_WTSR_SMPL, val);
if (ret < 0) {
dev_err(info->dev, "%s: fail to write WTSR/SMPL reg(%d)\n",
__func__, ret);
return;
}
info->wtsr_en = pdata->wtsr_smpl->wtsr_en;
info->smpl_en = pdata->wtsr_smpl->smpl_en;
}
static void s2m_rtc_disable_wtsr_smpl(struct s2m_rtc_info *info,
struct sec_platform_data *pdata)
{
int ret;
dev_info(info->dev, "%s: disable WTSR\n", __func__);
ret = sec_rtc_update(info->iodev, S2M_RTC_WTSR_SMPL, 0,
WTSR_EN_MASK | SMPL_EN_MASK);
if (ret < 0)
dev_err(info->dev, "%s: fail to update WTSR reg(%d)\n",
__func__, ret);
}
static int s2m_rtc_init_reg(struct s2m_rtc_info *info,
struct sec_platform_data *pdata)
{
u32 data, update_val, ctrl_val, capsel_val;
int ret;
ret = sec_rtc_read(info->iodev, S2M_RTC_UPDATE, &update_val);
if (ret < 0) {
dev_err(info->dev, "%s: fail to read update reg(%d)\n",
__func__, ret);
return ret;
}
info->update_reg =
update_val & ~(info->wudr_mask | RTC_FREEZE_MASK | RTC_RUDR_MASK | info->audr_mask);
ret = sec_rtc_write(info->iodev, S2M_RTC_UPDATE, info->update_reg);
if (ret < 0) {
dev_err(info->dev, "%s: fail to write update reg(%d)\n",
__func__, ret);
return ret;
}
s2m_rtc_update(info, S2M_RTC_READ);
ret = sec_rtc_read(info->iodev, S2M_RTC_CTRL, &ctrl_val);
if (ret < 0) {
dev_err(info->dev, "%s: fail to read control reg(%d)\n",
__func__, ret);
return ret;
}
ret = sec_rtc_read(info->iodev, S2M_CAP_SEL, &capsel_val);
if (ret < 0) {
dev_err(info->dev, "%s: fail to read cap_sel reg(%d)\n",
__func__, ret);
return ret;
}
/* If the value of RTC_CTRL register is 0, RTC registers were reset */
if ((ctrl_val & MODEL24_MASK) && (capsel_val == 0xf8))
return 0;
/* Set RTC control register : Binary mode, 24hour mode */
data = MODEL24_MASK;
ret = sec_rtc_write(info->iodev, S2M_RTC_CTRL, data);
if (ret < 0) {
dev_err(info->dev, "%s: fail to write CTRL reg(%d)\n",
__func__, ret);
return ret;
}
ret = s2m_rtc_update(info, S2M_RTC_WRITE_ALARM);
if (ret < 0)
return ret;
ret = sec_rtc_write(info->iodev, S2M_CAP_SEL, 0xf8);
if (ret < 0) {
dev_err(info->dev, "%s: fail to write CAP_SEL reg(%d)\n",
__func__, ret);
return ret;
}
if (pdata->init_time) {
dev_info(info->dev, "%s: initialize RTC time\n", __func__);
ret = s2m_rtc_set_time(info->dev, pdata->init_time);
}
return ret;
}
static int s2m_rtc_probe(struct platform_device *pdev)
{
struct sec_pmic_dev *iodev = dev_get_drvdata(pdev->dev.parent);
struct sec_platform_data *pdata = dev_get_platdata(iodev->dev);
struct s2m_rtc_info *info;
int irq_base;
int ret = 0;
info = devm_kzalloc(&pdev->dev, sizeof(struct s2m_rtc_info),
GFP_KERNEL);
if (!info)
return -ENOMEM;
#ifdef CONFIG_EXYNOS_MBOX
irq_base = iodev->irq_base;
#else
irq_base = regmap_irq_chip_get_base(iodev->irq_data);
#endif
if (!irq_base) {
dev_err(&pdev->dev, "Failed to get irq base %d\n", irq_base);
return -ENODEV;
}
mutex_init(&info->lock);
info->dev = &pdev->dev;
info->iodev = iodev;
info->alarm_check = false;
info->udr_updated = false;
info->use_alarm_workaround = false;
info->wudr_mask = RTC_WUDR_MASK;
info->audr_mask = RTC_AUDR_MASK;
switch (iodev->device_type) {
case S2MPS16X:
info->irq = irq_base + S2MPS16_IRQ_RTCA0;
info->alarm_check = true;
info->wudr_mask = RTC_WUDR_MASK_REV;
info->audr_mask = RTC_AUDR_MASK_REV;
if (pdata->smpl_warn_en) {
if (!gpio_is_valid(pdata->smpl_warn)) {
dev_err(&pdev->dev, "smpl_warn GPIO NOT VALID\n");
goto err_smpl_warn;
}
info->smpl_irq = gpio_to_irq(pdata->smpl_warn);
ret = devm_request_threaded_irq(&pdev->dev, info->smpl_irq,
NULL, s2m_smpl_warn_irq, IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
"SMPL WARN", info);
if (ret < 0) {
dev_err(&pdev->dev, "Failed to request smpl warn IRQ: %d: %d\n",
info->smpl_irq, ret);
goto err_smpl_warn;
}
info->smpl_warn_info = pdata->smpl_warn;
INIT_WORK(&info->irq_work, exynos_smpl_warn_work);
}
if (pdata->adc_en)
adc_init(info);
break;
case S2MPU03X:
info->irq = irq_base + S2MPU03_IRQ_RTCA0;
info->alarm_check = true;
info->wudr_mask = RTC_WUDR_MASK_REV;
info->audr_mask = RTC_AUDR_MASK_REV;
break;
case S2MPS15X:
info->irq = irq_base + S2MPS15_IRQ_RTCA0;
info->alarm_check = true;
if (SEC_PMIC_REV(iodev)) {
info->wudr_mask = RTC_WUDR_MASK_REV;
info->audr_mask = RTC_AUDR_MASK_REV;
}
if (SEC_PMIC_REV(iodev)) {
if (pdata->smpl_warn_en) {
if (!gpio_is_valid(pdata->smpl_warn)) {
dev_err(&pdev->dev, "smpl_warn GPIO NOT VALID\n");
goto err_smpl_warn;
}
info->smpl_irq = gpio_to_irq(pdata->smpl_warn);
ret = devm_request_threaded_irq(&pdev->dev, info->smpl_irq,
NULL, s2m_smpl_warn_irq, IRQF_TRIGGER_RISING | IRQF_ONESHOT,
"SMPL WARN", info);
if (ret < 0) {
dev_err(&pdev->dev, "Failed to request smpl warn IRQ: %d: %d\n",
info->smpl_irq, ret);
goto err_smpl_warn;
}
info->smpl_warn_info = pdata->smpl_warn;
INIT_WORK(&info->irq_work, exynos_smpl_warn_work);
ret = sec_reg_update(info->iodev, S2MPS15_REG_ETC_TEST, 0x00, 0x10);
} else {
ret = sec_reg_update(info->iodev, S2MPS15_REG_ETC_TEST, 0x10, 0x10);
}
if (ret < 0) {
dev_err(info->dev, "%s:%d fail to write smpl_warn_en(%d)\n",
__func__, __LINE__, ret);
goto err_smpl_warn;
}
}
if (pdata->adc_en)
adc_init(info);
break;
case S2MPS13X:
info->irq = irq_base + S2MPS13_IRQ_RTCA0;
if (SEC_PMIC_REV(iodev) > 0x02) {
if (pdata->smpl_warn_en) {
if (!gpio_is_valid(pdata->smpl_warn)) {
dev_err(&pdev->dev, "smpl_warn GPIO NOT VALID\n");
goto err_smpl_warn;
}
info->smpl_irq = gpio_to_irq(pdata->smpl_warn);
ret = devm_request_threaded_irq(&pdev->dev, info->smpl_irq,
NULL, s2m_smpl_warn_irq, IRQF_TRIGGER_RISING | IRQF_ONESHOT,
"SMPL WARN", info);
if (ret < 0) {
dev_err(&pdev->dev, "Failed to request smpl warn IRQ: %d: %d\n",
info->smpl_irq, ret);
goto err_smpl_warn;
}
info->smpl_warn_info = pdata->smpl_warn;
INIT_WORK(&info->irq_work, exynos_smpl_warn_work);
ret = sec_reg_update(info->iodev, S2MPS13_REG_ETC_TEST, 0x00, 0x10);
} else {
ret = sec_reg_update(info->iodev, S2MPS13_REG_ETC_TEST, 0x10, 0x10);
}
if (ret < 0) {
dev_err(info->dev, "%s:%d fail to write smpl_warn_en(%d)\n",
__func__, __LINE__, ret);
goto err_smpl_warn;
}
info->alarm_check = true;
info->udr_updated = true;
} else {
info->use_alarm_workaround = true;
}
break;
case S2MPS11X:
info->irq = irq_base + S2MPS11_IRQ_RTCA0;
break;
default:
/* If this happens the core funtion has a problem */
BUG();
}
platform_set_drvdata(pdev, info);
ret = s2m_rtc_init_reg(info, pdata);
if (ret < 0) {
dev_err(&pdev->dev, "Failed to initialize RTC reg:%d\n", ret);
goto err_rtc_init_reg;
}
if (pdata->wtsr_smpl)
s2m_rtc_enable_wtsr_smpl(info, pdata);
device_init_wakeup(&pdev->dev, true);
rtc_ws = wakeup_source_register("rtc-sec");
ret = devm_request_threaded_irq(&pdev->dev, info->irq, NULL,
s2m_rtc_alarm_irq, 0, "rtc-alarm0", info);
if (ret < 0) {
dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
info->irq, ret);
goto err_rtc_irq;
}
disable_irq(info->irq);
disable_irq(info->irq);
info->use_irq = true;
info->rtc_dev = devm_rtc_device_register(&pdev->dev, "s2m-rtc",
&s2m_rtc_ops, THIS_MODULE);
if (IS_ERR(info->rtc_dev)) {
ret = PTR_ERR(info->rtc_dev);
dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
goto err_rtc_dev_register;
}
enable_irq(info->irq);
return 0;
err_rtc_dev_register:
enable_irq(info->irq);
enable_irq(info->irq);
err_rtc_irq:
wakeup_source_unregister(rtc_ws);
err_rtc_init_reg:
platform_set_drvdata(pdev, NULL);
err_smpl_warn:
mutex_destroy(&info->lock);
return ret;
}
static int s2m_rtc_remove(struct platform_device *pdev)
{
struct s2m_rtc_info *info = platform_get_drvdata(pdev);
struct sec_platform_data *pdata = dev_get_platdata(info->iodev->dev);
if (!info->alarm_enabled)
enable_irq(info->irq);
if (pdata->adc_en)
adc_deinit(info);
wakeup_source_unregister(rtc_ws);
return 0;
}
static void s2m_rtc_shutdown(struct platform_device *pdev)
{
struct s2m_rtc_info *info = platform_get_drvdata(pdev);
struct sec_platform_data *pdata = dev_get_platdata(info->iodev->dev);
if (info->wtsr_en || info->smpl_en)
s2m_rtc_disable_wtsr_smpl(info, pdata);
}
static const struct platform_device_id s2m_rtc_id[] = {
{ "s2m-rtc", 0 },
};
static struct platform_driver s2m_rtc_driver = {
.driver = {
.name = "s2m-rtc",
.owner = THIS_MODULE,
},
.probe = s2m_rtc_probe,
.remove = s2m_rtc_remove,
.shutdown = s2m_rtc_shutdown,
.id_table = s2m_rtc_id,
};
module_platform_driver(s2m_rtc_driver);
/* Module information */
MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
MODULE_DESCRIPTION("Samsung RTC driver");
MODULE_LICENSE("GPL");
Reference in New Issue View Git Blame Copy Permalink