/*
|
* (C) Copyright 2022 Rockchip Electronics Co., Ltd
|
*
|
* SPDX-License-Identifier: GPL-2.0+
|
*/
|
|
#include <common.h>
|
#include <dm.h>
|
#include <i2c.h>
|
#include <irq-generic.h>
|
#include <power/fuel_gauge.h>
|
#include <linux/usb/phy-rockchip-usb2.h>
|
#include <power/power_delivery/power_delivery.h>
|
|
DECLARE_GLOBAL_DATA_PTR;
|
|
static int dbg_enable;
|
|
#define SGM_DBG(args...) \
|
do { \
|
if (dbg_enable) { \
|
printf(args); \
|
} \
|
} while (0)
|
|
/* define register */
|
#define SGM4154x_CHRG_CTRL_0 0x00
|
#define SGM4154x_CHRG_CTRL_1 0x01
|
#define SGM4154x_CHRG_CTRL_2 0x02
|
#define SGM4154x_CHRG_CTRL_3 0x03
|
#define SGM4154x_CHRG_CTRL_4 0x04
|
#define SGM4154x_CHRG_CTRL_5 0x05
|
#define SGM4154x_CHRG_CTRL_6 0x06
|
#define SGM4154x_CHRG_CTRL_7 0x07
|
#define SGM4154x_CHRG_STAT 0x08
|
#define SGM4154x_CHRG_FAULT 0x09
|
#define SGM4154x_CHRG_CTRL_a 0x0a
|
#define SGM4154x_CHRG_CTRL_b 0x0b
|
#define SGM4154x_CHRG_CTRL_c 0x0c
|
#define SGM4154x_CHRG_CTRL_d 0x0d
|
#define SGM4154x_INPUT_DET 0x0e
|
#define SGM4154x_CHRG_CTRL_f 0x0f
|
|
/* charge status flags */
|
#define SGM4154x_CHRG_EN BIT(4)
|
#define SGM4154x_HIZ_EN BIT(7)
|
#define SGM4154x_TERM_EN BIT(7)
|
#define SGM4154x_VAC_OVP_MASK GENMASK(7, 6)
|
#define SGM4154x_DPDM_ONGOING BIT(7)
|
#define SGM4154x_VBUS_GOOD BIT(7)
|
|
#define SGM4154x_BOOSTV GENMASK(5, 4)
|
#define SGM4154x_BOOST_LIM BIT(7)
|
#define SGM4154x_OTG_EN BIT(5)
|
|
/* Part ID */
|
#define SGM4154x_PN_MASK GENMASK(6, 3)
|
|
/* WDT TIMER SET */
|
#define SGM4154x_WDT_TIMER_MASK GENMASK(5, 4)
|
#define SGM4154x_WDT_TIMER_DISABLE 0
|
#define SGM4154x_WDT_TIMER_40S BIT(4)
|
#define SGM4154x_WDT_TIMER_80S BIT(5)
|
#define SGM4154x_WDT_TIMER_160S (BIT(4) | BIT(5))
|
|
#define SGM4154x_WDT_RST_MASK BIT(6)
|
|
/* SAFETY TIMER SET */
|
#define SGM4154x_SAFETY_TIMER_MASK GENMASK(3, 3)
|
#define SGM4154x_SAFETY_TIMER_DISABLE 0
|
#define SGM4154x_SAFETY_TIMER_EN BIT(3)
|
#define SGM4154x_SAFETY_TIMER_5H 0
|
#define SGM4154x_SAFETY_TIMER_10H BIT(2)
|
|
/* recharge voltage */
|
#define SGM4154x_VRECHARGE BIT(0)
|
#define SGM4154x_VRECHRG_STEP_mV 100
|
#define SGM4154x_VRECHRG_OFFSET_mV 100
|
|
/* charge status */
|
#define SGM4154x_VSYS_STAT BIT(0)
|
#define SGM4154x_THERM_STAT BIT(1)
|
#define SGM4154x_PG_STAT BIT(2)
|
#define SGM4154x_CHG_STAT_MASK GENMASK(4, 3)
|
#define SGM4154x_PRECHRG BIT(3)
|
#define SGM4154x_FAST_CHRG BIT(4)
|
#define SGM4154x_TERM_CHRG (BIT(3) | BIT(4))
|
|
/* charge type */
|
#define SGM4154x_VBUS_STAT_MASK GENMASK(7, 5)
|
#define SGM4154x_NOT_CHRGING 0
|
#define SGM4154x_USB_SDP BIT(5)
|
#define SGM4154x_USB_CDP BIT(6)
|
#define SGM4154x_USB_DCP (BIT(5) | BIT(6))
|
#define SGM4154x_UNKNOWN (BIT(7) | BIT(5))
|
#define SGM4154x_NON_STANDARD (BIT(7) | BIT(6))
|
#define SGM4154x_OTG_MODE (BIT(7) | BIT(6) | BIT(5))
|
|
/* TEMP Status */
|
#define SGM4154x_TEMP_MASK GENMASK(2, 0)
|
#define SGM4154x_TEMP_NORMAL BIT(0)
|
#define SGM4154x_TEMP_WARM BIT(1)
|
#define SGM4154x_TEMP_COOL (BIT(0) | BIT(1))
|
#define SGM4154x_TEMP_COLD (BIT(0) | BIT(3))
|
#define SGM4154x_TEMP_HOT (BIT(2) | BIT(3))
|
|
/* precharge current */
|
#define SGM4154x_PRECHRG_CUR_MASK GENMASK(7, 4)
|
#define SGM4154x_PRECHRG_CURRENT_STEP_uA 60000
|
#define SGM4154x_PRECHRG_I_MIN_uA 60000
|
#define SGM4154x_PRECHRG_I_MAX_uA 780000
|
#define SGM4154x_PRECHRG_I_DEF_uA 180000
|
|
/* termination current */
|
#define SGM4154x_TERMCHRG_CUR_MASK GENMASK(3, 0)
|
#define SGM4154x_TERMCHRG_CURRENT_STEP_uA 60000
|
#define SGM4154x_TERMCHRG_I_MIN_uA 60000
|
#define SGM4154x_TERMCHRG_I_MAX_uA 960000
|
#define SGM4154x_TERMCHRG_I_DEF_uA 180000
|
|
/* charge current */
|
#define SGM4154x_ICHRG_CUR_MASK GENMASK(5, 0)
|
#define SGM4154x_ICHRG_I_STEP_uA 60000
|
#define SGM4154x_ICHRG_I_MIN_uA 0
|
#define SGM4154x_ICHRG_I_MAX_uA 3780000
|
#define SGM4154x_ICHRG_I_DEF_uA 2040000
|
|
/* charge voltage */
|
#define SGM4154x_VREG_V_MASK GENMASK(7, 3)
|
#define SGM4154x_VREG_V_MAX_uV 4624000
|
#define SGM4154x_VREG_V_MIN_uV 3856000
|
#define SGM4154x_VREG_V_DEF_uV 4208000
|
#define SGM4154x_VREG_V_STEP_uV 32000
|
|
/* VREG Fine Tuning */
|
#define SGM4154x_VREG_FT_MASK GENMASK(7, 6)
|
#define SGM4154x_VREG_FT_UP_8mV BIT(6)
|
#define SGM4154x_VREG_FT_DN_8mV BIT(7)
|
#define SGM4154x_VREG_FT_DN_16mV (BIT(7) | BIT(6))
|
|
/* iindpm current */
|
#define SGM4154x_IINDPM_I_MASK GENMASK(4, 0)
|
#define SGM4154x_IINDPM_I_MIN_uA 100000
|
#define SGM4154x_IINDPM_I_MAX_uA 2000000
|
#define SGM4154x_IINDPM_STEP_uA 100000
|
#define SGM4154x_IINDPM_DEF_uA 2400000
|
|
#define SGM4154x_VINDPM_INT_MASK BIT(1)
|
#define SGM4154x_VINDPM_INT_DIS BIT(1)
|
#define SGM4154x_IINDPM_INT_MASK BIT(0)
|
#define SGM4154x_IINDPM_INT_DIS BIT(0)
|
|
/* vindpm voltage */
|
#define SGM4154x_VINDPM_V_MASK GENMASK(3, 0)
|
#define SGM4154x_VINDPM_V_MIN_uV 3900000
|
#define SGM4154x_VINDPM_V_MAX_uV 12000000
|
#define SGM4154x_VINDPM_STEP_uV 100000
|
#define SGM4154x_VINDPM_DEF_uV 4500000
|
#define SGM4154x_VINDPM_OS_MASK GENMASK(1, 0)
|
|
/* DP DM SEL */
|
#define SGM4154x_DP_VSEL_MASK GENMASK(4, 3)
|
#define SGM4154x_DM_VSEL_MASK GENMASK(2, 1)
|
|
/* PUMPX SET */
|
#define SGM4154x_EN_PUMPX BIT(7)
|
#define SGM4154x_PUMPX_UP BIT(6)
|
#define SGM4154x_PUMPX_DN BIT(5)
|
|
struct sgm41542 {
|
struct udevice *dev;
|
struct udevice *pd;
|
bool pd_online;
|
u32 init_count;
|
u32 ichg;
|
u32 vchg;
|
int irq;
|
};
|
|
enum power_supply_type {
|
POWER_SUPPLY_TYPE_UNKNOWN = 0,
|
POWER_SUPPLY_TYPE_USB, /* Standard Downstream Port */
|
POWER_SUPPLY_TYPE_USB_DCP, /* Dedicated Charging Port */
|
POWER_SUPPLY_TYPE_USB_CDP, /* Charging Downstream Port */
|
POWER_SUPPLY_TYPE_USB_FLOATING, /* DCP without shorting D+/D- */
|
};
|
|
static int sgm41542_read(struct sgm41542 *charger, uint reg, u8 *buffer)
|
{
|
u8 val;
|
int ret;
|
|
ret = dm_i2c_read(charger->dev, reg, &val, 1);
|
if (ret) {
|
printf("sgm41542: read %#x error, ret=%d", reg, ret);
|
return ret;
|
}
|
|
*buffer = val;
|
return 0;
|
}
|
|
static int sgm41542_write(struct sgm41542 *charger, uint reg, u8 val)
|
{
|
int ret;
|
|
ret = dm_i2c_write(charger->dev, reg, &val, 1);
|
if (ret)
|
printf("sgm41542: write %#x error, ret=%d", reg, ret);
|
|
return ret;
|
}
|
|
static int sgm41542_update_bits(struct sgm41542 *charger,
|
u8 offset,
|
u8 mask,
|
u8 val)
|
{
|
u8 reg;
|
|
sgm41542_read(charger, offset, ®);
|
|
reg &= ~mask;
|
|
return sgm41542_write(charger, offset, reg | val);
|
}
|
|
static int sgm4154x_set_input_curr_lim(struct sgm41542 *charger, int iindpm)
|
{
|
u8 reg_val;
|
int ret;
|
|
if (iindpm < SGM4154x_IINDPM_I_MIN_uA)
|
iindpm = SGM4154x_IINDPM_I_MIN_uA;
|
if (iindpm >= SGM4154x_IINDPM_I_MAX_uA)
|
iindpm = SGM4154x_IINDPM_I_MAX_uA;
|
|
if (iindpm >= SGM4154x_IINDPM_I_MIN_uA &&
|
iindpm <= SGM4154x_IINDPM_I_MAX_uA)
|
reg_val = (iindpm - SGM4154x_IINDPM_I_MIN_uA) / SGM4154x_IINDPM_STEP_uA;
|
|
ret = sgm41542_update_bits(charger,
|
SGM4154x_CHRG_CTRL_0,
|
SGM4154x_IINDPM_I_MASK,
|
reg_val);
|
|
return ret;
|
}
|
|
static int sgm41542_get_usb_type(void)
|
{
|
#ifdef CONFIG_PHY_ROCKCHIP_INNO_USB2
|
return rockchip_chg_get_type();
|
#else
|
return 0;
|
#endif
|
}
|
|
static int sgm41542_charger_capability(struct udevice *dev)
|
{
|
return FG_CAP_CHARGER;
|
}
|
|
static int sgm4154x_set_ichrg_curr(struct sgm41542 *charger, int uA)
|
{
|
u8 reg_val;
|
int ret;
|
|
if (uA < SGM4154x_ICHRG_I_MIN_uA)
|
uA = SGM4154x_ICHRG_I_MIN_uA;
|
else if (uA > charger->ichg)
|
uA = uA > charger->ichg;
|
|
reg_val = uA / SGM4154x_ICHRG_I_STEP_uA;
|
|
ret = sgm41542_update_bits(charger,
|
SGM4154x_CHRG_CTRL_2,
|
SGM4154x_ICHRG_CUR_MASK,
|
reg_val);
|
if (ret)
|
printf("sgm41542: set icharge current error!\n");
|
|
return ret;
|
}
|
|
static int sgm4154x_set_prechrg_curr(struct sgm41542 *charger, int uA)
|
{
|
u8 reg_val;
|
int ret;
|
|
if (uA < SGM4154x_PRECHRG_I_MIN_uA)
|
uA = SGM4154x_PRECHRG_I_MIN_uA;
|
else if (uA > SGM4154x_PRECHRG_I_MAX_uA)
|
uA = SGM4154x_PRECHRG_I_MAX_uA;
|
|
reg_val = (uA - SGM4154x_PRECHRG_I_MIN_uA) / SGM4154x_PRECHRG_CURRENT_STEP_uA;
|
|
reg_val = reg_val << 4;
|
ret = sgm41542_update_bits(charger,
|
SGM4154x_CHRG_CTRL_3,
|
SGM4154x_PRECHRG_CUR_MASK,
|
reg_val);
|
if (ret)
|
printf("sgm41542: set icharge current error!\n");
|
|
return ret;
|
}
|
|
static int sgm4154x_set_chrg_volt(struct sgm41542 *charger, int chrg_volt)
|
{
|
u8 reg_val;
|
int ret;
|
|
if (chrg_volt < SGM4154x_VREG_V_MIN_uV)
|
chrg_volt = SGM4154x_VREG_V_MIN_uV;
|
else if (chrg_volt > SGM4154x_VREG_V_MAX_uV)
|
chrg_volt = SGM4154x_VREG_V_MAX_uV;
|
|
reg_val = (chrg_volt - SGM4154x_VREG_V_MIN_uV) / SGM4154x_VREG_V_STEP_uV;
|
reg_val = reg_val << 3;
|
SGM_DBG("reg_val: 0x%x\n", reg_val);
|
ret = sgm41542_update_bits(charger,
|
SGM4154x_CHRG_CTRL_4,
|
SGM4154x_VREG_V_MASK,
|
reg_val);
|
|
return ret;
|
}
|
|
static int sgm41542_set_charger_voltage(struct udevice *dev, int uV)
|
{
|
struct sgm41542 *charger = dev_get_priv(dev);
|
|
SGM_DBG("SGM41542: charger voltage %d\n", uV);
|
return sgm4154x_set_chrg_volt(charger, uV);
|
}
|
|
static int sgm41542_charger_enable(struct udevice *dev)
|
{
|
struct sgm41542 *charger = dev_get_priv(dev);
|
|
SGM_DBG("SGM41542: charger enable\n");
|
sgm41542_update_bits(charger, SGM4154x_CHRG_CTRL_1,
|
SGM4154x_CHRG_EN,
|
SGM4154x_CHRG_EN);
|
return 0;
|
}
|
|
static int sgm41542_charger_disable(struct udevice *dev)
|
{
|
struct sgm41542 *charger = dev_get_priv(dev);
|
|
SGM_DBG("SGM41542: charger disable\n");
|
sgm41542_update_bits(charger, SGM4154x_CHRG_CTRL_1,
|
SGM4154x_CHRG_EN,
|
0);
|
return 0;
|
}
|
|
static int sgm41542_iprechg_current(struct udevice *dev, int iprechrg_uA)
|
{
|
struct sgm41542 *charger = dev_get_priv(dev);
|
|
SGM_DBG("SGM41542: charger current:iprechrg_uA: %d\n",
|
iprechrg_uA);
|
|
return sgm4154x_set_prechrg_curr(charger, iprechrg_uA);
|
}
|
|
static int sgm41542_charger_current(struct udevice *dev, int ichrg_uA)
|
{
|
struct sgm41542 *charger = dev_get_priv(dev);
|
|
SGM_DBG("SGM41542: charger current:ichrg_uA%d\n",
|
ichrg_uA);
|
|
return sgm4154x_set_ichrg_curr(charger, ichrg_uA);
|
}
|
|
static int sgm41542_get_pd_output_val(struct sgm41542 *charger,
|
int *vol,
|
int *cur)
|
{
|
struct power_delivery_data pd_data;
|
int ret;
|
|
if (!charger->pd)
|
return -EINVAL;
|
|
memset(&pd_data, 0, sizeof(pd_data));
|
ret = power_delivery_get_data(charger->pd, &pd_data);
|
if (ret)
|
return ret;
|
if (!pd_data.online || !pd_data.voltage || !pd_data.current)
|
return -EINVAL;
|
|
*vol = pd_data.voltage;
|
*cur = pd_data.current;
|
charger->pd_online = pd_data.online;
|
|
return 0;
|
}
|
|
static void sgm41542_charger_input_current_init(struct sgm41542 *charger)
|
{
|
int sdp_inputcurrent = 500 * 1000;
|
int dcp_inputcurrent = 2000 * 1000;
|
int pd_inputvol, pd_inputcurrent;
|
int ret;
|
|
if (!charger->pd) {
|
ret = uclass_get_device(UCLASS_PD, 0, &charger->pd);
|
if (ret) {
|
if (ret == -ENODEV)
|
printf("sgm41542: Can't find PD\n");
|
else
|
printf("sgm41542: Get UCLASS PD failed: %d\n", ret);
|
charger->pd = NULL;
|
}
|
}
|
|
if (!sgm41542_get_pd_output_val(charger, &pd_inputvol, &pd_inputcurrent)) {
|
SGM_DBG("pd adapter\n");
|
sgm4154x_set_input_curr_lim(charger, pd_inputcurrent);
|
} else {
|
SGM_DBG("normal adapter: %d\n", sgm41542_get_usb_type());
|
if (sgm41542_get_usb_type() == POWER_SUPPLY_TYPE_USB_DCP)
|
sgm4154x_set_input_curr_lim(charger, dcp_inputcurrent);
|
else if (sgm41542_get_usb_type() == POWER_SUPPLY_TYPE_USB_CDP)
|
sgm4154x_set_input_curr_lim(charger, dcp_inputcurrent);
|
else if (sgm41542_get_usb_type() == POWER_SUPPLY_TYPE_USB_FLOATING)
|
sgm4154x_set_input_curr_lim(charger, dcp_inputcurrent);
|
else
|
sgm4154x_set_input_curr_lim(charger, sdp_inputcurrent);
|
}
|
}
|
|
static bool sgm41542_charger_status(struct udevice *dev)
|
{
|
struct sgm41542 *charger = dev_get_priv(dev);
|
int state_of_charger;
|
u8 value;
|
int i = 0;
|
|
__retry:
|
sgm41542_read(charger, SGM4154x_CHRG_STAT, &value);
|
state_of_charger = !!(value & SGM4154x_PG_STAT);
|
if (!state_of_charger && charger->pd_online) {
|
if (i < 3) {
|
i++;
|
mdelay(20);
|
goto __retry;
|
}
|
}
|
|
if ((state_of_charger) && (charger->init_count < 5)) {
|
sgm41542_charger_input_current_init(charger);
|
sgm41542_update_bits(charger,
|
SGM4154x_CHRG_CTRL_1,
|
SGM4154x_CHRG_EN,
|
SGM4154x_CHRG_EN);
|
charger->init_count++;
|
}
|
|
if (!state_of_charger)
|
sgm4154x_set_prechrg_curr(charger, SGM4154x_PRECHRG_I_DEF_uA);
|
|
SGM_DBG("dump register:\n");
|
for (i = SGM4154x_CHRG_CTRL_0; i < SGM4154x_CHRG_CTRL_f; i++) {
|
sgm41542_read(charger, i, &value);
|
SGM_DBG("[%d]: 0x%x\n", i, value);
|
}
|
return state_of_charger;
|
}
|
|
static void sgm41542_irq_handler(int irq, void *data)
|
{
|
}
|
|
static int sgm41542_ofdata_to_platdata(struct udevice *dev)
|
{
|
struct sgm41542 *charger = dev_get_priv(dev);
|
u32 interrupt, phandle;
|
int ret;
|
|
charger->dev = dev;
|
charger->ichg = dev_read_u32_default(dev,
|
"vbat-current-limit-microamp",
|
0);
|
if (charger->ichg == 0)
|
charger->ichg = 3000 * 1000;
|
charger->vchg = dev_read_u32_default(dev,
|
"vbat-voltage-limit-microamp",
|
0);
|
if (charger->vchg == 0)
|
charger->vchg = 4400 * 1000;
|
SGM_DBG("charger->ichg: %d\n", charger->ichg);
|
SGM_DBG("charger->vchg: %d\n", charger->vchg);
|
|
phandle = dev_read_u32_default(dev, "interrupt-parent", -ENODATA);
|
if (phandle == -ENODATA) {
|
printf("sgm41542: read 'interrupt-parent' failed, ret=%d\n",
|
phandle);
|
return phandle;
|
}
|
|
ret = dev_read_u32_array(dev, "interrupts", &interrupt, 1);
|
if (ret) {
|
printf("sgm41542: read 'interrupts' failed, ret=%d\n", ret);
|
return ret;
|
}
|
|
charger->irq = phandle_gpio_to_irq(phandle, interrupt);
|
if (charger->irq < 0)
|
printf("sgm41542: failed to request irq: %d\n", charger->irq);
|
|
return 0;
|
}
|
|
static int sgm41542_probe(struct udevice *dev)
|
{
|
struct sgm41542 *charger = dev_get_priv(dev);
|
u8 value;
|
int i;
|
|
SGM_DBG("sgm41542: driver version-20220903\n");
|
SGM_DBG("sgm41542: dump register:\n");
|
for (i = SGM4154x_CHRG_CTRL_0; i < SGM4154x_CHRG_CTRL_f; i++) {
|
sgm41542_read(charger, i, &value);
|
SGM_DBG("gm41542: [%d]: 0x%x\n", i, value);
|
}
|
|
charger->dev = dev;
|
/* disable watchdog */
|
sgm41542_update_bits(charger, SGM4154x_CHRG_CTRL_5,
|
SGM4154x_WDT_TIMER_MASK,
|
SGM4154x_WDT_TIMER_DISABLE);
|
|
sgm41542_update_bits(charger, SGM4154x_CHRG_CTRL_a,
|
SGM4154x_VINDPM_INT_MASK | SGM4154x_IINDPM_INT_MASK,
|
SGM4154x_VINDPM_INT_DIS | SGM4154x_IINDPM_INT_DIS);
|
|
sgm4154x_set_ichrg_curr(charger, charger->ichg);
|
sgm4154x_set_chrg_volt(charger, charger->vchg);
|
|
if (0 && charger->irq) {
|
SGM_DBG("sgm41542: enable sgm42542 irq\n");
|
irq_install_handler(charger->irq, sgm41542_irq_handler, dev);
|
irq_handler_enable(charger->irq);
|
}
|
|
return 0;
|
}
|
|
static const struct udevice_id charger_ids[] = {
|
{ .compatible = "sgm,sgm41542" },
|
{ },
|
};
|
|
static struct dm_fuel_gauge_ops charger_ops = {
|
.get_chrg_online = sgm41542_charger_status,
|
.capability = sgm41542_charger_capability,
|
.set_charger_voltage = sgm41542_set_charger_voltage,
|
.set_charger_enable = sgm41542_charger_enable,
|
.set_charger_disable = sgm41542_charger_disable,
|
.set_charger_current = sgm41542_charger_current,
|
.set_iprechg_current = sgm41542_iprechg_current,
|
|
};
|
|
U_BOOT_DRIVER(sgm41542_charger) = {
|
.name = "sgm41542_charger",
|
.id = UCLASS_FG,
|
.probe = sgm41542_probe,
|
.of_match = charger_ids,
|
.ops = &charger_ops,
|
.ofdata_to_platdata = sgm41542_ofdata_to_platdata,
|
.priv_auto_alloc_size = sizeof(struct sgm41542),
|
};
|
