aubrey/kernel_samsung_a34x-permissive
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity
kernel_samsung_a34x-permissive/drivers/power/supply/mediatek/charger/rt9750.c

1696 lines
40 KiB
C
Raw Permalink Normal View History

Import A346BXXU1AWB9 kernel source Android 13
2024-04-28 06:49:01 -07:00
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/i2c.h>
#include <linux/of_device.h>
#include <linux/of_irq.h>
#include <linux/of_gpio.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/delay.h>
#include <linux/mutex.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/kthread.h>
#include "mtk_charger_intf.h"
#include "rt9750.h"
#ifdef CONFIG_RT_REGMAP
#include <mt-plat/rt-regmap.h>
#endif
#define RT9750_DRV_VERSION "1.0.10_MTK"
#define I2C_ACCESS_MAX_RETRY 5
struct rt9750_desc {
int regmap_represent_slave_addr;
const char *regmap_name;
const char *chg_dev_name;
const char *alias_name;
u32 vbat_reg;
u32 vout_reg;
u32 iococp;
u32 wdt;
};
static struct rt9750_desc rt9750_default_desc = {
.regmap_represent_slave_addr = RT9750_SLAVE_ADDR,
.regmap_name = "rt9750",
.alias_name = "rt9750",
.chg_dev_name = "primary_load_switch",
.vbat_reg = 4400000, /* uV */
.vout_reg = 5000000, /* uV */
.iococp = 5000000, /* uA */
.wdt = 2000000, /* us */
};
struct rt9750_info {
struct i2c_client *i2c;
struct device *dev;
struct rt9750_desc *desc;
struct charger_device *chg_dev;
struct charger_properties chg_props;
struct mutex i2c_access_lock;
struct mutex adc_access_lock;
struct mutex gpio_access_lock;
u32 intr_gpio;
u32 en_gpio;
int irq;
u8 chip_rev;
bool is_chip_en;
#if 0
struct task_struct *task;
#endif
#ifdef CONFIG_RT_REGMAP
struct rt_regmap_device *regmap_dev;
struct rt_regmap_properties *regmap_prop;
#endif
};
static u32 rt9750_wdt[] = {
0, 500000, 1000000, 2000000,
}; /* us */
enum rt9750_irq_idx {
RT9750_IRQIDX_EVT1 = 0,
RT9750_IRQIDX_EVT2,
RT9750_IRQIDX_MAX,
};
static u8 rt9750_irqmask[RT9750_IRQIDX_MAX] = {
0xEF, 0xFF,
};
static const u8 rt9750_irq_maskall[RT9750_IRQIDX_MAX] = {
0xEF, 0xFF,
};
struct irq_mapping_tbl {
const char *name;
const int id;
};
#define RT9750_IRQ_MAPPING(_name, _id) {.name = #_name, .id = _id}
static const struct irq_mapping_tbl rt9750_irq_mapping_tbl[] = {
RT9750_IRQ_MAPPING(ibus_irev_flt, 0),
RT9750_IRQ_MAPPING(tbat_otp_flt, 1),
RT9750_IRQ_MAPPING(tbus_otp_flt, 2),
RT9750_IRQ_MAPPING(vout_reg_ldo, 3),
RT9750_IRQ_MAPPING(vbat_reg_ldo, 5),
RT9750_IRQ_MAPPING(ibus_reg_ldo, 6),
RT9750_IRQ_MAPPING(vbus_ovp_flt, 7),
RT9750_IRQ_MAPPING(ioc_flt, 8),
RT9750_IRQ_MAPPING(tshut_flt, 9),
RT9750_IRQ_MAPPING(bat_insert, 10),
RT9750_IRQ_MAPPING(vbus_insert, 11),
RT9750_IRQ_MAPPING(vdrop_ovp_flt, 12),
RT9750_IRQ_MAPPING(vdrop_alm_flt, 13),
RT9750_IRQ_MAPPING(adc_done, 14),
RT9750_IRQ_MAPPING(lowchg_alm_flt, 15),
};
/* ========= */
/* RT Regmap */
/* ========= */
#ifdef CONFIG_RT_REGMAP
RT_REG_DECL(RT9750_REG_CORE_CTRL0, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_EVENT1_MASK, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_EVENT2_MASK, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_EVENT1, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_EVENT2, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_EVENT1_EN, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_CONTROL, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_ADC_CTRL, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_SAMPLE_EN, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_PROT_DLYOCP, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_VBUS_OVP, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_VOUT_REG, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_VDROP_OVP, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_VDROP_ALM, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_VBAT_REG, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_IBUS_OCP, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_TBUS_OTP, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_TBAT_OTP, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_VBUS_ADC2, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_VBUS_ADC1, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_IBUS_ADC2, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_IBUS_ADC1, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_VOUT_ADC2, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_VOUT_ADC1, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_VDROP_ADC2, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_VDROP_ADC1, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_VBAT_ADC2, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_VBAT_ADC1, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_TBUS_ADC2, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_TBUS_ADC1, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_TBAT_ADC2, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_TBAT_ADC1, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_TDIE_ADC1, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_EVENT_STATUS1, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_EVENT_STATUS2, 1, RT_VOLATILE, {});
RT_REG_DECL(RT9750_REG_EVENT_STATUS, 1, RT_VOLATILE, {});
static const rt_register_map_t rt9750_regmap_map[] = {
RT_REG(RT9750_REG_CORE_CTRL0),
RT_REG(RT9750_REG_EVENT1_MASK),
RT_REG(RT9750_REG_EVENT2_MASK),
RT_REG(RT9750_REG_EVENT1),
RT_REG(RT9750_REG_EVENT2),
RT_REG(RT9750_REG_EVENT1_EN),
RT_REG(RT9750_REG_CONTROL),
RT_REG(RT9750_REG_ADC_CTRL),
RT_REG(RT9750_REG_SAMPLE_EN),
RT_REG(RT9750_REG_PROT_DLYOCP),
RT_REG(RT9750_REG_VBUS_OVP),
RT_REG(RT9750_REG_VOUT_REG),
RT_REG(RT9750_REG_VDROP_OVP),
RT_REG(RT9750_REG_VDROP_ALM),
RT_REG(RT9750_REG_VBAT_REG),
RT_REG(RT9750_REG_IBUS_OCP),
RT_REG(RT9750_REG_TBUS_OTP),
RT_REG(RT9750_REG_TBAT_OTP),
RT_REG(RT9750_REG_VBUS_ADC2),
RT_REG(RT9750_REG_VBUS_ADC1),
RT_REG(RT9750_REG_IBUS_ADC2),
RT_REG(RT9750_REG_IBUS_ADC1),
RT_REG(RT9750_REG_VOUT_ADC2),
RT_REG(RT9750_REG_VOUT_ADC1),
RT_REG(RT9750_REG_VDROP_ADC2),
RT_REG(RT9750_REG_VDROP_ADC1),
RT_REG(RT9750_REG_VBAT_ADC2),
RT_REG(RT9750_REG_VBAT_ADC1),
RT_REG(RT9750_REG_TBUS_ADC2),
RT_REG(RT9750_REG_TBUS_ADC1),
RT_REG(RT9750_REG_TBAT_ADC2),
RT_REG(RT9750_REG_TBAT_ADC1),
RT_REG(RT9750_REG_TDIE_ADC1),
RT_REG(RT9750_REG_EVENT_STATUS1),
RT_REG(RT9750_REG_EVENT_STATUS2),
RT_REG(RT9750_REG_EVENT_STATUS),
};
#endif /* CONFIG_RT_REGMAP */
static const unsigned char rt9750_reg_addr[] = {
RT9750_REG_CORE_CTRL0,
RT9750_REG_EVENT1_MASK,
RT9750_REG_EVENT2_MASK,
RT9750_REG_EVENT1,
RT9750_REG_EVENT2,
RT9750_REG_EVENT1_EN,
RT9750_REG_CONTROL,
RT9750_REG_ADC_CTRL,
RT9750_REG_SAMPLE_EN,
RT9750_REG_PROT_DLYOCP,
RT9750_REG_VBUS_OVP,
RT9750_REG_VOUT_REG,
RT9750_REG_VDROP_OVP,
RT9750_REG_VDROP_ALM,
RT9750_REG_VBAT_REG,
RT9750_REG_IBUS_OCP,
RT9750_REG_TBUS_OTP,
RT9750_REG_TBAT_OTP,
RT9750_REG_VBUS_ADC2,
RT9750_REG_VBUS_ADC1,
RT9750_REG_IBUS_ADC2,
RT9750_REG_IBUS_ADC1,
RT9750_REG_VOUT_ADC2,
RT9750_REG_VOUT_ADC1,
RT9750_REG_VDROP_ADC2,
RT9750_REG_VDROP_ADC1,
RT9750_REG_VBAT_ADC2,
RT9750_REG_VBAT_ADC1,
RT9750_REG_TBUS_ADC2,
RT9750_REG_TBUS_ADC1,
RT9750_REG_TBAT_ADC2,
RT9750_REG_TBAT_ADC1,
RT9750_REG_TDIE_ADC1,
RT9750_REG_EVENT_STATUS1,
RT9750_REG_EVENT_STATUS2,
RT9750_REG_EVENT_STATUS,
};
/* ========================= */
/* I2C operations */
/* ========================= */
static inline bool rt9750_is_chip_en(struct rt9750_info *info)
{
int en = 0;
en = gpio_get_value(info->en_gpio);
if ((en && !info->is_chip_en) || (!en && info->is_chip_en))
dev_notice(info->dev, "%s: en not sync(%d, %d)\n", __func__, en,
info->is_chip_en);
return en ? true : false;
}
static int rt9750_device_read(void *client, u32 addr, int leng, void *dst)
{
int ret = 0;
struct i2c_client *i2c = NULL;
i2c = (struct i2c_client *)client;
ret = i2c_smbus_read_i2c_block_data(i2c, addr, leng, dst);
return ret;
}
static int rt9750_device_write(void *client, u32 addr, int leng,
const void *src)
{
int ret = 0;
struct i2c_client *i2c = NULL;
i2c = (struct i2c_client *)client;
ret = i2c_smbus_write_i2c_block_data(i2c, addr, leng, src);
return ret;
}
#ifdef CONFIG_RT_REGMAP
static struct rt_regmap_fops rt9750_regmap_fops = {
.read_device = rt9750_device_read,
.write_device = rt9750_device_write,
};
static int rt9750_register_rt_regmap(struct rt9750_info *info)
{
int ret = 0;
struct i2c_client *i2c = info->i2c;
struct rt_regmap_properties *prop = NULL;
dev_info(info->dev, "%s\n", __func__);
prop = devm_kzalloc(&i2c->dev, sizeof(struct rt_regmap_properties),
GFP_KERNEL);
if (!prop)
return -ENOMEM;
prop->name = info->desc->regmap_name;
prop->aliases = info->desc->regmap_name;
prop->register_num = ARRAY_SIZE(rt9750_regmap_map);
prop->rm = rt9750_regmap_map;
prop->rt_regmap_mode = RT_SINGLE_BYTE | RT_CACHE_DISABLE |
RT_IO_PASS_THROUGH;
prop->io_log_en = 0;
info->regmap_prop = prop;
info->regmap_dev = rt_regmap_device_register_ex(
info->regmap_prop,
&rt9750_regmap_fops,
&i2c->dev,
i2c,
info->desc->regmap_represent_slave_addr,
info
);
if (!info->regmap_dev) {
dev_notice(&i2c->dev, "register regmap device failed\n");
return -EIO;
}
return ret;
}
#endif /* CONFIG_RT_REGMAP */
static inline int _rt9750_i2c_write_byte(struct rt9750_info *info, u8 cmd,
u8 data)
{
int ret = 0, retry = 0;
do {
#ifdef CONFIG_RT_REGMAP
ret = rt_regmap_block_write(info->regmap_dev, cmd, 1, &data);
#else
ret = rt9750_device_write(info->i2c, cmd, 1, &data);
#endif
retry++;
if (ret < 0)
mdelay(20);
} while (ret < 0 && retry < I2C_ACCESS_MAX_RETRY);
if (ret < 0)
dev_notice(info->dev, "%s: I2CW[0x%02X] = 0x%02X fail\n",
__func__, cmd, data);
else
dev_dbg_ratelimited(info->dev, "%s: I2CW[0x%02X] = 0x%02X\n",
__func__, cmd, data);
return ret;
}
#if 0
static int rt9750_i2c_write_byte(struct rt9750_info *info, u8 cmd, u8 data)
{
int ret = 0, en = 0;
mutex_lock(&info->i2c_access_lock);
mutex_lock(&info->gpio_access_lock);
if (rt9750_is_chip_en(info))
ret = _rt9750_i2c_write_byte(info, cmd, data);
mutex_unlock(&info->gpio_access_lock);
mutex_unlock(&info->i2c_access_lock);
return ret;
}
#endif
static inline int _rt9750_i2c_read_byte(struct rt9750_info *info, u8 cmd)
{
int ret = 0, ret_val = 0, retry = 0;
do {
#ifdef CONFIG_RT_REGMAP
ret = rt_regmap_block_read(info->regmap_dev, cmd, 1, &ret_val);
#else
ret = rt9750_device_read(info->i2c, cmd, 1, &ret_val);
#endif
retry++;
if (ret < 0)
msleep(20);
} while (ret < 0 && retry < I2C_ACCESS_MAX_RETRY);
if (ret < 0) {
dev_notice(info->dev, "%s: I2CR[0x%02X] fail\n", __func__, cmd);
return ret;
}
ret_val = ret_val & 0xFF;
dev_dbg_ratelimited(info->dev, "%s: I2CR[0x%02X] = 0x%02X\n", __func__,
cmd, ret_val);
return ret_val;
}
static int rt9750_i2c_read_byte(struct rt9750_info *info, u8 cmd)
{
int ret = 0;
mutex_lock(&info->i2c_access_lock);
mutex_lock(&info->gpio_access_lock);
if (rt9750_is_chip_en(info))
ret = _rt9750_i2c_read_byte(info, cmd);
mutex_unlock(&info->gpio_access_lock);
mutex_unlock(&info->i2c_access_lock);
if (ret < 0)
return ret;
return (ret & 0xFF);
}
static inline int _rt9750_i2c_block_write(struct rt9750_info *info, u8 cmd,
u32 leng, const u8 *data)
{
int ret = 0;
#ifdef CONFIG_RT_REGMAP
ret = rt_regmap_block_write(info->regmap_dev, cmd, leng, data);
#else
ret = rt9750_device_write(info->i2c, cmd, leng, data);
#endif
return ret;
}
static int rt9750_i2c_block_write(struct rt9750_info *info, u8 cmd, u32 leng,
const u8 *data)
{
int ret = 0;
mutex_lock(&info->i2c_access_lock);
mutex_lock(&info->gpio_access_lock);
if (rt9750_is_chip_en(info))
ret = _rt9750_i2c_block_write(info, cmd, leng, data);
mutex_unlock(&info->gpio_access_lock);
mutex_unlock(&info->i2c_access_lock);
return ret;
}
static inline int _rt9750_i2c_block_read(struct rt9750_info *info, u8 cmd,
u32 leng, u8 *data)
{
int ret = 0;
#ifdef CONFIG_RT_REGMAP
ret = rt_regmap_block_read(info->regmap_dev, cmd, leng, data);
#else
ret = rt9750_device_read(info->i2c, cmd, leng, data);
#endif
return ret;
}
static int rt9750_i2c_block_read(struct rt9750_info *info, u8 cmd, u32 leng,
u8 *data)
{
int ret = 0;
mutex_lock(&info->i2c_access_lock);
mutex_lock(&info->gpio_access_lock);
if (rt9750_is_chip_en(info))
ret = _rt9750_i2c_block_read(info, cmd, leng, data);
mutex_unlock(&info->gpio_access_lock);
mutex_unlock(&info->i2c_access_lock);
return ret;
}
static int rt9750_i2c_test_bit(struct rt9750_info *info, u8 cmd, u8 shift)
{
int ret = 0;
ret = rt9750_i2c_read_byte(info, cmd);
if (ret < 0)
return ret;
ret = ret & (1 << shift);
return ret;
}
static int rt9750_i2c_update_bits(struct rt9750_info *info, u8 cmd, u8 data,
u8 mask)
{
int ret = 0;
u8 reg_data = 0;
mutex_lock(&info->i2c_access_lock);
mutex_lock(&info->gpio_access_lock);
if (rt9750_is_chip_en(info)) {
ret = _rt9750_i2c_read_byte(info, cmd);
if (ret < 0)
goto out;
reg_data = ret & 0xFF;
reg_data &= ~mask;
reg_data |= (data & mask);
ret = _rt9750_i2c_write_byte(info, cmd, reg_data);
}
out:
mutex_unlock(&info->gpio_access_lock);
mutex_unlock(&info->i2c_access_lock);
return ret;
}
static inline int rt9750_set_bit(struct rt9750_info *info, u8 reg, u8 mask)
{
return rt9750_i2c_update_bits(info, reg, mask, mask);
}
static inline int rt9750_clr_bit(struct rt9750_info *info, u8 reg, u8 mask)
{
return rt9750_i2c_update_bits(info, reg, 0x00, mask);
}
/* ========================= */
/* Internal function */
/* ========================= */
static u8 rt9750_find_closest_reg_value(const u32 min, const u32 max,
const u32 step, const u32 num, const u32 target)
{
u32 i = 0, cur_val = 0, next_val = 0;
/* Smaller than minimum supported value, use minimum one */
if (target < min)
return 0;
for (i = 0; i < num - 1; i++) {
cur_val = min + i * step;
next_val = cur_val + step;
if (cur_val > max)
cur_val = max;
if (next_val > max)
next_val = max;
if (target >= cur_val && target < next_val)
return i;
}
/* Greater than maximum supported value, use maximum one */
return num - 1;
}
static u8 rt9750_find_closest_reg_value_via_table(const u32 *value_table,
const u32 table_size, const u32 target_value)
{
u32 i = 0;
/* Smaller than minimum supported value, use minimum one */
if (target_value < value_table[0])
return 0;
for (i = 0; i < table_size - 1; i++) {
if (target_value >= value_table[i] &&
target_value < value_table[i + 1])
return i;
}
/* Greater than maximum supported value, use maximum one */
return table_size - 1;
}
static u32 rt9750_find_closest_real_value(const u32 min, const u32 max,
const u32 step, const u8 reg_val)
{
u32 ret_val = 0;
ret_val = min + reg_val * step;
if (ret_val > max)
ret_val = max;
return ret_val;
}
static int rt9750_is_hw_exist(struct rt9750_info *info)
{
int ret = 0;
u8 dev_id = 0, chip_rev = 0;
ret = i2c_smbus_read_byte_data(info->i2c, RT9750_REG_CORE_CTRL0);
if (ret < 0)
return false;
dev_id = ret & 0x07;
chip_rev = ret & 0x38;
if (dev_id != RT9750_DEVICE_ID) {
dev_notice(info->dev, "%s: device id is incorrect\n", __func__);
return false;
}
dev_info(info->dev, "%s: E%d(0x%02X)\n",
__func__, chip_rev + 1, chip_rev);
info->chip_rev = chip_rev;
return true;
}
static inline const char *rt9750_get_irq_name(struct rt9750_info *info,
int irqnum)
{
int i = 0;
for (i = 0; i < ARRAY_SIZE(rt9750_irq_mapping_tbl); i++) {
if (rt9750_irq_mapping_tbl[i].id == irqnum)
return rt9750_irq_mapping_tbl[i].name;
}
return "not found";
}
static inline void rt9750_irq_mask(struct rt9750_info *info, int irqnum)
{
dev_dbg(info->dev, "%s: irq = %d, %s\n", __func__, irqnum,
rt9750_get_irq_name(info, irqnum));
rt9750_irqmask[irqnum / 8] |= (1 << (irqnum % 8));
}
static inline void rt9750_irq_unmask(struct rt9750_info *info, int irqnum)
{
dev_dbg(info->dev, "%s: irq = %d, %s\n", __func__, irqnum,
rt9750_get_irq_name(info, irqnum));
rt9750_irqmask[irqnum / 8] &= ~(1 << (irqnum % 8));
}
static int rt9750_ibus_irev_flt_irq_handler(struct rt9750_info *info)
{
dev_info(info->dev, "%s\n", __func__);
return 0;
}
static int rt9750_tbat_otp_flt_irq_handler(struct rt9750_info *info)
{
dev_info(info->dev, "%s\n", __func__);
return 0;
}
static int rt9750_tbus_otp_flt_irq_handler(struct rt9750_info *info)
{
dev_info(info->dev, "%s\n", __func__);
return 0;
}
static int rt9750_vout_reg_ldo_irq_handler(struct rt9750_info *info)
{
dev_info(info->dev, "%s\n", __func__);
return 0;
}
static int rt9750_vbat_reg_ldo_irq_handler(struct rt9750_info *info)
{
dev_info(info->dev, "%s\n", __func__);
return 0;
}
static int rt9750_ibus_reg_ldo_irq_handler(struct rt9750_info *info)
{
dev_info(info->dev, "%s\n", __func__);
return 0;
}
static int rt9750_vbus_ovp_flt_irq_handler(struct rt9750_info *info)
{
dev_info(info->dev, "%s\n", __func__);
return 0;
}
static int rt9750_ioc_flt_irq_handler(struct rt9750_info *info)
{
dev_info(info->dev, "%s\n", __func__);
return 0;
}
static int rt9750_tshut_flt_irq_handler(struct rt9750_info *info)
{
dev_info(info->dev, "%s\n", __func__);
return 0;
}
static int rt9750_bat_insert_irq_handler(struct rt9750_info *info)
{
dev_info(info->dev, "%s\n", __func__);
return 0;
}
static int rt9750_vbus_insert_irq_handler(struct rt9750_info *info)
{
dev_info(info->dev, "%s\n", __func__);
return 0;
}
static int rt9750_vdrop_ovp_flt_irq_handler(struct rt9750_info *info)
{
dev_info(info->dev, "%s\n", __func__);
return 0;
}
static int rt9750_vdrop_alm_flt_irq_handler(struct rt9750_info *info)
{
dev_info(info->dev, "%s\n", __func__);
return 0;
}
static int rt9750_adc_done_irq_handler(struct rt9750_info *info)
{
dev_info(info->dev, "%s\n", __func__);
return 0;
}
static int rt9750_lowchg_alm_flt_irq_handler(struct rt9750_info *info)
{
dev_info(info->dev, "%s\n", __func__);
return 0;
}
typedef int (*rt9750_irq_fptr)(struct rt9750_info *);
static rt9750_irq_fptr rt9750_irq_handler_tbl[16] = {
rt9750_ibus_irev_flt_irq_handler,
rt9750_tbat_otp_flt_irq_handler,
rt9750_tbus_otp_flt_irq_handler,
rt9750_vout_reg_ldo_irq_handler,
NULL,
rt9750_vbat_reg_ldo_irq_handler,
rt9750_ibus_reg_ldo_irq_handler,
rt9750_vbus_ovp_flt_irq_handler,
rt9750_ioc_flt_irq_handler,
rt9750_tshut_flt_irq_handler,
rt9750_bat_insert_irq_handler,
rt9750_vbus_insert_irq_handler,
rt9750_vdrop_ovp_flt_irq_handler,
rt9750_vdrop_alm_flt_irq_handler,
rt9750_adc_done_irq_handler,
rt9750_lowchg_alm_flt_irq_handler,
};
static irqreturn_t rt9750_irq_handler(int irq, void *data)
{
int ret = 0, i = 0, j = 0;
struct rt9750_info *info = (struct rt9750_info *)data;
u8 evt[RT9750_IRQIDX_MAX] = {0};
u8 mask[RT9750_IRQIDX_MAX] = {0};
dev_info(info->dev, "%s\n", __func__);
ret = rt9750_i2c_block_read(info, RT9750_REG_EVENT1, RT9750_IRQIDX_MAX,
evt);
if (ret < 0) {
dev_notice(info->dev, "%s: read irq data failed\n", __func__);
goto err_read_irq;
}
ret = rt9750_i2c_block_read(info, RT9750_REG_EVENT1_MASK,
RT9750_IRQIDX_MAX, mask);
if (ret < 0) {
dev_notice(info->dev, "%s: read irq mask failed\n", __func__);
goto err_read_irq;
}
for (i = 0; i < RT9750_IRQIDX_MAX; i++) {
evt[i] &= ~mask[i];
for (j = 0; j < 8; j++) {
if (!(evt[i] & (1 << j)))
continue;
if (rt9750_irq_handler_tbl[i * 8 + j])
rt9750_irq_handler_tbl[i * 8 + j](info);
}
}
err_read_irq:
return IRQ_HANDLED;
}
static int rt9750_register_irq(struct rt9750_info *info)
{
int ret = 0, len = 0;
char *name = NULL;
/* request gpio */
len = strlen(info->desc->chg_dev_name);
name = devm_kzalloc(info->dev, len + 10, GFP_KERNEL);
snprintf(name, len + 10, "%s_irq_gpio", info->desc->chg_dev_name);
ret = devm_gpio_request_one(info->dev, info->intr_gpio, GPIOF_IN, name);
if (ret < 0) {
dev_notice(info->dev, "%s: gpio request fail\n", __func__);
goto err;
}
ret = gpio_to_irq(info->intr_gpio);
if (ret < 0) {
dev_notice(info->dev, "%s: irq mapping fail\n", __func__);
goto err;
}
info->irq = ret;
dev_info(info->dev, "%s: irq = %d\n", __func__, info->irq);
/* Request threaded IRQ */
name = devm_kzalloc(info->dev, len + 5, GFP_KERNEL);
snprintf(name, len + 5, "%s_irq", info->desc->chg_dev_name);
ret = devm_request_threaded_irq(info->dev, info->irq, NULL,
rt9750_irq_handler, IRQF_TRIGGER_FALLING | IRQF_ONESHOT, name,
info);
if (ret < 0) {
dev_notice(info->dev, "%s: request thread irq fail\n",
__func__);
goto err;
}
return 0;
err:
return ret;
}
static inline int rt9750_get_irq_number(struct rt9750_info *info,
const char *name)
{
int i = 0;
if (!name) {
dev_notice(info->dev, "%s: null name\n", __func__);
return -EINVAL;
}
for (i = 0; i < ARRAY_SIZE(rt9750_irq_mapping_tbl); i++) {
if (!strcmp(name, rt9750_irq_mapping_tbl[i].name))
return rt9750_irq_mapping_tbl[i].id;
}
return -EINVAL;
}
static int rt9750_parse_dt(struct rt9750_info *info, struct device *dev)
{
int ret = 0, irqcnt = 0, irqnum = 0, len = 0;
struct rt9750_desc *desc = NULL;
struct device_node *np = dev->of_node;
char *en_name = NULL;
const char *name = NULL;
dev_info(info->dev, "%s\n", __func__);
if (!np) {
dev_notice(info->dev, "%s: no device node\n", __func__);
return -EINVAL;
}
info->desc = &rt9750_default_desc;
desc = devm_kzalloc(dev, sizeof(struct rt9750_desc), GFP_KERNEL);
if (!desc)
return -ENOMEM;
memcpy(desc, &rt9750_default_desc, sizeof(struct rt9750_desc));
if (of_property_read_string(np, "charger_name",
&desc->chg_dev_name) < 0)
dev_notice(info->dev, "%s: no charger name\n", __func__);
#if (!defined(CONFIG_MTK_GPIO) || defined(CONFIG_MTK_GPIOLIB_STAND))
ret = of_get_named_gpio(np, "rt,intr_gpio", 0);
if (ret < 0)
return ret;
info->intr_gpio = ret;
ret = of_get_named_gpio(np, "rt,en_gpio", 0);
if (ret < 0)
return ret;
info->en_gpio = ret;
#else
ret = of_property_read_u32(np, "rt,intr_gpio_num", &info->intr_gpio);
if (ret < 0)
return ret;
ret = of_property_read_u32(np, "rt,en_gpio_num", &info->en_gpio);
if (ret < 0)
return ret;
#endif
dev_info(info->dev, "%s: intr/en gpio = %d, %d\n", __func__,
info->intr_gpio, info->en_gpio);
len = strlen(desc->chg_dev_name);
en_name = devm_kzalloc(info->dev, len + 9, GFP_KERNEL);
snprintf(en_name, len + 9, "%s_en_gpio", desc->chg_dev_name);
/* request en gpio */
ret = devm_gpio_request_one(info->dev, info->en_gpio, GPIOF_DIR_OUT,
en_name);
if (ret < 0) {
dev_notice(info->dev, "%s: en gpio request fail\n", __func__);
return ret;
}
if (of_property_read_string(np, "regmap_name", &desc->regmap_name) < 0)
dev_notice(info->dev, "%s: no regmap name\n", __func__);
if (of_property_read_string(np, "alias_name", &desc->alias_name) < 0)
dev_notice(info->dev, "%s: no alias name\n", __func__);
if (of_property_read_u32(np, "vout_reg", &desc->vout_reg) < 0)
dev_notice(info->dev, "%s: no vout regulation\n", __func__);
if (of_property_read_u32(np, "vbat_reg", &desc->vbat_reg) < 0)
dev_notice(info->dev, "%s: no vbat regulation\n", __func__);
if (of_property_read_u32(np, "iococp", &desc->iococp) < 0)
dev_notice(info->dev, "%s: no iococp\n", __func__);
if (of_property_read_u32(np, "wdt", &desc->wdt) < 0)
dev_notice(info->dev, "%s: no wdt\n", __func__);
while (true) {
ret = of_property_read_string_index(np, "interrupt-names",
irqcnt, &name);
if (ret < 0)
break;
irqcnt++;
irqnum = rt9750_get_irq_number(info, name);
if (irqnum >= 0)
rt9750_irq_unmask(info, irqnum);
}
info->desc = desc;
info->chg_props.alias_name = info->desc->alias_name;
dev_info(info->dev, "%s: chg_name:%s alias:%s\n", __func__,
info->desc->chg_dev_name, info->chg_props.alias_name);
return 0;
}
static int rt9750_set_wdt(struct rt9750_info *info, const u32 us)
{
int ret = 0;
u8 wdt_reg = 0;
wdt_reg = rt9750_find_closest_reg_value_via_table(rt9750_wdt,
ARRAY_SIZE(rt9750_wdt), us);
dev_info(info->dev, "%s: set wdt = %dms(0x%02X)\n",
__func__, us / 1000, wdt_reg);
ret = rt9750_i2c_update_bits(
info,
RT9750_REG_CONTROL,
wdt_reg << RT9750_SHIFT_WDT,
RT9750_MASK_WDT
);
return ret;
}
static int rt9750_get_vout(struct rt9750_info *info, u32 *vout)
{
int ret = 0;
u8 reg_vout = 0;
ret = rt9750_i2c_read_byte(info, RT9750_REG_VOUT_REG);
if (ret < 0)
return ret;
reg_vout = ((ret & RT9750_MASK_VOUT) >> RT9750_SHIFT_VOUT) & 0xFF;
*vout = rt9750_find_closest_real_value(RT9750_VOUT_MIN, RT9750_VOUT_MAX,
RT9750_VOUT_STEP, reg_vout);
return ret;
}
static int rt9750_set_vout(struct rt9750_info *info, u32 uV)
{
int ret = 0;
u8 reg_vout = 0;
reg_vout = rt9750_find_closest_reg_value(
RT9750_VOUT_MIN,
RT9750_VOUT_MAX,
RT9750_VOUT_STEP,
RT9750_VOUT_NUM,
uV
);
dev_info(info->dev, "%s: vout = %d (0x%02X)\n", __func__, uV, reg_vout);
ret = rt9750_i2c_update_bits(
info,
RT9750_REG_VOUT_REG,
reg_vout << RT9750_SHIFT_VOUT,
RT9750_MASK_VOUT
);
return ret;
}
static int rt9750_get_vbat(struct rt9750_info *info, u32 *vbat)
{
int ret = 0;
u8 reg_vbat = 0;
ret = rt9750_i2c_read_byte(info, RT9750_REG_VBAT_REG);
if (ret < 0)
return ret;
reg_vbat = ((ret & RT9750_MASK_VBAT) >> RT9750_SHIFT_VBAT) & 0xFF;
*vbat = rt9750_find_closest_real_value(RT9750_VBAT_MIN, RT9750_VBAT_MAX,
RT9750_VBAT_STEP, reg_vbat);
return ret;
}
static int rt9750_set_vbat(struct rt9750_info *info, u32 uV)
{
int ret = 0;
u8 reg_vbat = 0;
reg_vbat = rt9750_find_closest_reg_value(
RT9750_VBAT_MIN,
RT9750_VBAT_MAX,
RT9750_VBAT_STEP,
RT9750_VBAT_NUM,
uV
);
dev_info(info->dev, "%s: vbat = %d (0x%02X)\n", __func__, uV, reg_vbat);
ret = rt9750_i2c_update_bits(
info,
RT9750_REG_VBAT_REG,
reg_vbat << RT9750_SHIFT_VBAT,
RT9750_MASK_VBAT
);
return ret;
}
static int rt9750_set_iococp(struct rt9750_info *info, u32 uA)
{
int ret = 0;
u8 reg_iococp = 0;
reg_iococp = rt9750_find_closest_reg_value(RT9750_IOCOCP_MIN,
RT9750_IOCOCP_MAX, RT9750_IOCOCP_STEP, RT9750_IOCOCP_NUM, uA);
dev_info(info->dev, "%s: iococp = %d (0x%02X)\n",
__func__, uA, reg_iococp);
ret = rt9750_i2c_update_bits(
info,
RT9750_REG_PROT_DLYOCP,
reg_iococp << RT9750_SHIFT_IOCOCP,
RT9750_MASK_IOCOCP
);
return ret;
}
static int rt9750_maskall_irq(struct rt9750_info *info)
{
int ret = 0;
dev_info(info->dev, "%s\n", __func__);
ret = rt9750_i2c_block_write(info, RT9750_REG_EVENT1_MASK,
ARRAY_SIZE(rt9750_irq_maskall), rt9750_irq_maskall);
return ret;
}
static int rt9750_init_irq(struct rt9750_info *info)
{
int ret = 0;
dev_info(info->dev, "%s\n", __func__);
ret = rt9750_i2c_block_write(info, RT9750_REG_EVENT1_MASK,
ARRAY_SIZE(rt9750_irqmask), rt9750_irqmask);
return ret;
}
static int rt9750_init_setting(struct rt9750_info *info)
{
int ret = 0;
u8 evt[RT9750_IRQIDX_MAX] = {0};
ret = rt9750_maskall_irq(info);
if (ret < 0)
dev_notice(info->dev, "%s: mask all irq fail\n", __func__);
/* clear evt */
ret = rt9750_i2c_block_read(info, RT9750_REG_EVENT1, RT9750_IRQIDX_MAX,
evt);
if (ret < 0)
dev_notice(info->dev, "%s: read irq data fail\n", __func__);
ret = rt9750_set_wdt(info, info->desc->wdt);
if (ret < 0)
dev_notice(info->dev, "%s: set wdt failed\n", __func__);
ret = rt9750_set_vout(info, info->desc->vout_reg);
if (ret < 0)
dev_notice(info->dev, "%s: set vout failed\n", __func__);
ret = rt9750_set_vbat(info, info->desc->vbat_reg);
if (ret < 0)
dev_notice(info->dev, "%s: set vbat failed\n", __func__);
ret = rt9750_set_iococp(info, info->desc->iococp);
if (ret < 0)
dev_notice(info->dev, "%s: set iococp failed\n", __func__);
ret = rt9750_init_irq(info);
if (ret < 0)
dev_notice(info->dev, "%s: init irq fail\n", __func__);
return ret;
}
static int rt9750_is_switch_enable(struct rt9750_info *info, bool *en)
{
int ret = 0;
ret = rt9750_i2c_test_bit(info, RT9750_REG_CONTROL,
RT9750_SHIFT_CHG_EN);
if (ret < 0) {
*en = false;
return ret;
}
*en = (ret == 0 ? false : true);
dev_info(info->dev, "%s: enable = %d\n", __func__, *en);
return ret;
}
#if 0
static int rt9750_get_vbus_adc(struct rt9750_info *info, u32 *vbus_adc)
{
int ret = 0;
u8 data[2] = {0};
ret = rt9750_i2c_block_read(info, RT9750_REG_VBUS_ADC2, 2, data);
if (ret < 0) {
dev_notice(info->dev, "%s: get vbus adc failed\n", __func__);
return ret;
}
*vbus_adc = ((data[0] & RT9750_MASK_VBUS_ADC2) << 8) + data[1];
dev_info(info->dev, "%s: vbus_adc = %dmV\n", __func__, *vbus_adc);
return ret;
}
static int rt9750_get_vout_adc(struct rt9750_info *info, u32 *vout_adc)
{
int ret = 0;
u8 data[2] = {0};
ret = rt9750_i2c_block_read(info, RT9750_REG_VOUT_ADC2, 2, data);
if (ret < 0) {
dev_notice(info->dev, "%s: get vout adc failed\n", __func__);
return ret;
}
*vout_adc = ((data[0] & RT9750_MASK_VOUT_ADC2) << 8) + data[1];
dev_info(info->dev, "%s: vout_adc = %dmV\n", __func__, *vout_adc);
return ret;
}
static int rt9750_get_vdrop_adc(struct rt9750_info *info, u32 *vdrop_adc)
{
int ret = 0;
u8 data[2] = {0};
ret = rt9750_i2c_block_read(info, RT9750_REG_VDROP_ADC2, 2, data);
if (ret < 0) {
dev_notice(info->dev, "%s: get vdrop adc failed\n", __func__);
return ret;
}
*vdrop_adc = ((data[0] & RT9750_MASK_VDROP_ADC2) << 8) + data[1];
dev_info(info->dev, "%s: vdrop_adc = %dmV\n", __func__, *vdrop_adc);
return ret;
}
static int rt9750_get_vbat_adc(struct rt9750_info *info, u32 *vbat_adc)
{
int ret = 0;
u8 data[2] = {0};
ret = rt9750_i2c_block_read(info, RT9750_REG_VBAT_ADC2, 2, data);
if (ret < 0) {
dev_notice(info->dev, "%s: get vbat adc failed\n", __func__);
return ret;
}
*vbat_adc = ((data[0] & RT9750_MASK_VBAT_ADC2) << 8) + data[1];
dev_info(info->dev, "%s: vbat_adc = %dmV\n", __func__, *vbat_adc);
return ret;
}
static int rt9750_get_tbat_adc(struct rt9750_info *info, u32 *tbat_adc)
{
int ret = 0;
u8 data[2] = {0};
ret = rt9750_i2c_block_read(info, RT9750_REG_TBAT_ADC2, 2, data);
if (ret < 0) {
dev_notice(info->dev, "%s: get tbat adc failed\n", __func__);
return ret;
}
*tbat_adc = ((data[0] & RT9750_MASK_TBAT_ADC2) << 8) + data[1];
dev_info(info->dev, "%s: tbat_adc = %ddegree\n", __func__, *tbat_adc);
return ret;
}
static int rt9750_get_tbus_adc(struct rt9750_info *info, u32 *tbus_adc)
{
int ret = 0;
u8 data[2] = {0};
ret = rt9750_i2c_block_read(info, RT9750_REG_TBUS_ADC2, 2, data);
if (ret < 0) {
dev_notice(info->dev, "%s: get tbus adc failed\n", __func__);
return ret;
}
*tbus_adc = ((data[0] & RT9750_MASK_TBUS_ADC2) << 8) + data[1];
dev_info(info->dev, "%s: tbus_adc = %ddegree\n", __func__, *tbus_adc);
return ret;
}
#endif
/* ========================= */
/* Released function */
/* ========================= */
static int rt9750_dump_register(struct charger_device *chg_dev)
{
int i = 0, ret = 0;
u32 vout = 0, vbat = 0;
bool en = false;
struct rt9750_info *info = dev_get_drvdata(&chg_dev->dev);
ret = rt9750_get_vout(info, &vout);
ret = rt9750_get_vbat(info, &vbat);
ret = rt9750_is_switch_enable(info, &en);
for (i = 0; i < ARRAY_SIZE(rt9750_reg_addr); i++) {
ret = rt9750_i2c_read_byte(info, rt9750_reg_addr[i]);
if (ret < 0)
return ret;
}
dev_info(info->dev, "%s: VOUT = %dmV, VBAT = %dmV, SWITCH_EN = %d\n",
__func__, vout / 1000, vbat / 1000, en);
return ret;
}
static int _rt9750_enable_chip(struct rt9750_info *info, bool en)
{
dev_info(info->dev, "%s\n", __func__);
mutex_lock(&info->gpio_access_lock);
if (en) {
/* Lock I2C to solve I2C SDA drop problem */
i2c_lock_adapter(info->i2c->adapter);
gpio_set_value(info->en_gpio, 1);
dev_info(info->dev, "%s: set gpio high\n", __func__);
udelay(10);
i2c_unlock_adapter(info->i2c->adapter);
/* wait rt9750 enable, at least 200us */
mdelay(1);
} else {
gpio_set_value(info->en_gpio, 0);
dev_info(info->dev, "%s: set gpio low\n", __func__);
}
info->is_chip_en = en;
mutex_unlock(&info->gpio_access_lock);
return 0;
}
static int rt9750_enable_chip(struct charger_device *chg_dev, bool en)
{
int ret = 0;
struct rt9750_info *info = dev_get_drvdata(&chg_dev->dev);
ret = _rt9750_enable_chip(info, en);
if (ret < 0) {
dev_notice(info->dev, "%s: enable chip failed\n", __func__);
return ret;
}
if (en) {
ret = rt9750_init_setting(info);
if (ret < 0)
dev_notice(info->dev, "%s: init setting failed\n",
__func__);
}
return ret;
}
static int rt9750_enable_switch(struct charger_device *chg_dev, bool en)
{
int ret = 0;
struct rt9750_info *info = dev_get_drvdata(&chg_dev->dev);
dev_info(info->dev, "%s, enable = %d\n", __func__, en);
ret = (en ? rt9750_set_bit : rt9750_clr_bit)
(info, RT9750_REG_CONTROL, RT9750_MASK_CHG_EN);
return ret;
}
static int rt9750_set_ibusoc(struct charger_device *chg_dev, u32 uA)
{
int ret = 0;
struct rt9750_info *info = dev_get_drvdata(&chg_dev->dev);
u8 reg_ibusoc = 0;
reg_ibusoc = rt9750_find_closest_reg_value(RT9750_IBUSOC_MIN,
RT9750_IBUSOC_MAX, RT9750_IBUSOC_STEP, RT9750_IBUSOC_NUM, uA);
dev_info(info->dev, "%s: ibusoc = %d (0x%02X)\n", __func__, uA,
reg_ibusoc);
ret = rt9750_i2c_update_bits(
info,
RT9750_REG_IBUS_OCP,
reg_ibusoc << RT9750_SHIFT_IBUS_OCP,
RT9750_MASK_IBUS_OCP
);
return ret;
}
static int rt9750_set_vbusov(struct charger_device *chg_dev, u32 uV)
{
int ret = 0;
struct rt9750_info *info = dev_get_drvdata(&chg_dev->dev);
u8 reg_vbusov = 0;
reg_vbusov = rt9750_find_closest_reg_value(RT9750_VBUSOV_MIN,
RT9750_VBUSOV_MAX, RT9750_VBUSOV_STEP, RT9750_VBUSOV_NUM,
uV);
dev_info(info->dev, "%s: vbusov = %d (0x%02X)\n",
__func__, uV, reg_vbusov);
ret = rt9750_i2c_update_bits(
info,
RT9750_REG_VBUS_OVP,
reg_vbusov << RT9750_SHIFT_VBUSOVP,
RT9750_MASK_VBUSOVP
);
return ret;
}
static int rt9750_kick_wdt(struct charger_device *chg_dev)
{
int ret = 0;
u32 vout = 0;
struct rt9750_info *info = dev_get_drvdata(&chg_dev->dev);
/* Any I2C operation can kick wdt */
dev_info(info->dev, "%s\n", __func__);
ret = rt9750_get_vout(info, &vout);
return ret;
}
static int rt9750_get_ibus_adc(struct charger_device *chg_dev, u32 *ibus_adc)
{
int ret = 0;
u8 data[2] = {0};
struct rt9750_info *info = dev_get_drvdata(&chg_dev->dev);
ret = rt9750_i2c_block_read(info, RT9750_REG_IBUS_ADC2, 2, data);
if (ret < 0) {
dev_notice(info->dev, "%s: get ibus adc failed\n", __func__);
return ret;
}
*ibus_adc = ((data[0] & RT9750_MASK_IBUS_ADC2) << 8) + data[1];
*ibus_adc *= 1000; /* uA */
dev_info(info->dev, "%s: ibus_adc = %dmA\n", __func__, *ibus_adc);
return ret;
}
static int rt9750_get_tdie_adc(struct charger_device *chg_dev,
int *tdie_adc_min, int *tdie_adc_max)
{
int ret = 0;
struct rt9750_info *info = dev_get_drvdata(&chg_dev->dev);
ret = rt9750_i2c_read_byte(info, RT9750_REG_TDIE_ADC1);
if (ret < 0) {
dev_notice(info->dev, "%s: get vbus adc failed\n", __func__);
return ret;
}
*tdie_adc_min = ret;
*tdie_adc_max = ret;
dev_info(info->dev, "%s: tdie_adc = %ddegree\n",
__func__, *tdie_adc_min);
return ret;
}
static struct charger_ops rt9750_chg_ops = {
.enable_chip = rt9750_enable_chip,
.enable_direct_charging = rt9750_enable_switch,
.dump_registers = rt9750_dump_register,
.kick_direct_charging_wdt = rt9750_kick_wdt,
.set_direct_charging_ibusoc = rt9750_set_ibusoc,
.set_direct_charging_vbusov = rt9750_set_vbusov,
.get_ibus_adc = rt9750_get_ibus_adc,
.get_tchg_adc = rt9750_get_tdie_adc,
};
/* ========================= */
/* I2C driver function */
/* ========================= */
#if 0
static int rt9750_dbg_thread(void *data)
{
int ret = 0;
u32 ibus_adc = 0;
int tdie_min = 0, tdie_max = 0;
bool en = false;
struct rt9750_info *info = (struct rt9750_info *)data;
dev_info(info->dev, "%s\n", __func__);
ret = rt9750_enable_chip(info->chg_dev, true);
while (1) {
ret = rt9750_get_ibus_adc(info->chg_dev, &ibus_adc);
ret = rt9750_get_tdie_adc(info->chg_dev, &tdie_min, &tdie_max);
ret = rt9750_set_ibusoc(info->chg_dev, 6000000);
ret = rt9750_set_vbusov(info->chg_dev, 6000000);
ret = rt9750_is_switch_enable(info, &en);
msleep(2000);
};
return ret;
}
#endif
static int rt9750_probe(struct i2c_client *i2c,
const struct i2c_device_id *dev_id)
{
int ret = 0;
struct rt9750_info *info = NULL;
pr_info("%s: %s\n", __func__, RT9750_DRV_VERSION);
info = devm_kzalloc(&i2c->dev, sizeof(struct rt9750_info), GFP_KERNEL);
if (!info)
return -ENOMEM;
info->i2c = i2c;
info->dev = &i2c->dev;
info->is_chip_en = false;
mutex_init(&info->i2c_access_lock);
mutex_init(&info->adc_access_lock);
mutex_init(&info->gpio_access_lock);
ret = rt9750_parse_dt(info, &i2c->dev);
if (ret < 0) {
dev_notice(info->dev, "%s: parse dt failed\n", __func__);
goto err_parse_dt;
}
/* Enable Chip */
ret = _rt9750_enable_chip(info, true);
if (ret < 0) {
dev_notice(info->dev, "%s: enable chip failed\n", __func__);
goto err_enable_chip;
}
/* Is HW exist */
if (!rt9750_is_hw_exist(info)) {
dev_notice(info->dev, "%s: no rt9750 exists\n", __func__);
ret = -ENODEV;
goto err_no_dev;
}
i2c_set_clientdata(i2c, info);
#ifdef CONFIG_RT_REGMAP
ret = rt9750_register_rt_regmap(info);
if (ret < 0)
goto err_register_regmap;
#endif
/* Register charger device */
info->chg_dev = charger_device_register(info->desc->chg_dev_name,
&i2c->dev, info, &rt9750_chg_ops, &info->chg_props);
if (IS_ERR_OR_NULL(info->chg_dev)) {
ret = PTR_ERR(info->chg_dev);
goto err_register_chg_dev;
}
ret = rt9750_register_irq(info);
if (ret < 0) {
dev_notice(info->dev, "%s: register irq failed\n", __func__);
goto err_register_irq;
}
rt9750_dump_register(info->chg_dev);
/* Disable Chip */
ret = _rt9750_enable_chip(info, false);
if (ret < 0) {
dev_notice(info->dev, "%s: disable chip failed\n", __func__);
goto err_disable_chip;
}
#if 0
info->task = kthread_create(rt9750_dbg_thread, (void *)info,
"dbg_thread");
if (IS_ERR(info->task))
dev_notice(info->dev, "%s: create dbg thread failed\n",
__func__);
wake_up_process(info->task);
#endif
dev_info(info->dev, "%s: ends\n", __func__);
return ret;
err_disable_chip:
err_register_irq:
err_register_chg_dev:
#ifdef CONFIG_RT_REGMAP
rt_regmap_device_unregister(info->regmap_dev);
err_register_regmap:
#endif
err_no_dev:
_rt9750_enable_chip(info, false);
err_enable_chip:
err_parse_dt:
mutex_destroy(&info->i2c_access_lock);
mutex_destroy(&info->adc_access_lock);
mutex_destroy(&info->gpio_access_lock);
return ret;
}
static int rt9750_remove(struct i2c_client *i2c)
{
int ret = 0;
struct rt9750_info *info = i2c_get_clientdata(i2c);
pr_info("%s\n", __func__);
if (info) {
#ifdef CONFIG_RT_REGMAP
rt_regmap_device_unregister(info->regmap_dev);
#endif
charger_device_unregister(info->chg_dev);
mutex_destroy(&info->i2c_access_lock);
mutex_destroy(&info->adc_access_lock);
mutex_destroy(&info->gpio_access_lock);
}
return ret;
}
static void rt9750_shutdown(struct i2c_client *i2c)
{
pr_info("%s\n", __func__);
}
static const struct i2c_device_id rt9750_i2c_id[] = {
{"rt9750", 0},
{}
};
#ifdef CONFIG_OF
static const struct of_device_id rt9750_of_match[] = {
{ .compatible = "richtek,rt9750", },
{},
};
#else /* Not define CONFIG_OF */
#define RT9750_BUSNUM 0
static struct i2c_board_info rt9750_i2c_board_info __initdata = {
I2C_BOARD_INFO("rt9750", rt9750_SALVE_ADDR)
};
#endif /* CONFIG_OF */
static struct i2c_driver rt9750_i2c_driver = {
.driver = {
.name = "rt9750",
.owner = THIS_MODULE,
#ifdef CONFIG_OF
.of_match_table = rt9750_of_match,
#endif
},
.probe = rt9750_probe,
.remove = rt9750_remove,
.shutdown = rt9750_shutdown,
.id_table = rt9750_i2c_id,
};
static int __init rt9750_init(void)
{
int ret = 0;
#ifdef CONFIG_OF
pr_info("%s: with dts\n", __func__);
#else
pr_info("%s: without dts\n", __func__);
i2c_register_board_info(RT9750_BUSNUM, &rt9750_i2c_board_info, 1);
#endif
ret = i2c_add_driver(&rt9750_i2c_driver);
if (ret < 0)
pr_notice("%s: register i2c driver failed\n", __func__);
return ret;
}
module_init(rt9750_init);
static void __exit rt9750_exit(void)
{
i2c_del_driver(&rt9750_i2c_driver);
}
module_exit(rt9750_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("ShuFanLee <shufan_lee@richtek.com>");
MODULE_DESCRIPTION("RT9750 Load Switch Driver");
MODULE_VERSION(RT9750_DRV_VERSION);
/*
* Version Note
* 1.0.10
* (1) Use GPIO API instead of pinctrl
* (2) Add IRQ handlers for each IRQ
*
* 1.0.9
* (1) Modify init sequence in probe function
* (2) Change pr_xxx to dev_xxx
*
* 1.0.8
* (1) Modify unit of get_ibus to uA
* (2) Modify load switch name to primary_load_switch
*
* 1.0.7
* (1) Add 1ms delay after enabling chip
*
* 1.0.6
* (1) Disable chip if probed failed
*
* 1.0.5
* (1) Unregister charger device if probe failed
* (2) Mask all irqs for now
*
* 1.0.4
* (1) Add set_iococp
* (2) Init iococp in init_setting
*
* 1.0.3
* (1) Remove registering power supply class
*
* 1.0.2
* (1) Add interface for setting ibusoc/vbusov
* (2) Write initial setting every time after enabling chip
* (3) Init vout_reg/vbat_reg in init_setting
*
* 1.0.1
* (1) Add gpio lock for rt9750_enable_chip
*
* 1.0.0
* First Release
*/
Reference in a new issue Copy permalink