PizzaG/Rtwo
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
Rtwo/kernel/motorola/sm8550/drivers/power/supply/qcom/qpnp-smb2.c
PizzaG 279f0f5973 initial android 16 commit
2025-09-30 19:22:48 -05:00

2396 lines
60 KiB
C
Raw Blame History

// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2016-2017,2019-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2023, Qualcomm Innovation Center, Inc. All rights reserved.
*/
#include <linux/debugfs.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>
#include <linux/power_supply.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_irq.h>
#include <linux/log2.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/of_regulator.h>
#include <linux/regulator/machine.h>
#include "smb-reg.h"
#include "smb-lib.h"
#include "smb2-iio.h"
#include "storm-watch.h"
#include <linux/pmic-voter.h>
#include <linux/iio/consumer.h>
#define SMB2_DEFAULT_WPWR_UW 8000000
static struct smb_params v1_params = {
.fcc = {
.name = "fast charge current",
.reg = FAST_CHARGE_CURRENT_CFG_REG,
.min_u = 0,
.max_u = 4500000,
.step_u = 25000,
},
.fv = {
.name = "float voltage",
.reg = FLOAT_VOLTAGE_CFG_REG,
.min_u = 3487500,
.max_u = 4920000,
.step_u = 7500,
},
.usb_icl = {
.name = "usb input current limit",
.reg = USBIN_CURRENT_LIMIT_CFG_REG,
.min_u = 0,
.max_u = 4800000,
.step_u = 25000,
},
.icl_stat = {
.name = "input current limit status",
.reg = ICL_STATUS_REG,
.min_u = 0,
.max_u = 4800000,
.step_u = 25000,
},
.otg_cl = {
.name = "usb otg current limit",
.reg = OTG_CURRENT_LIMIT_CFG_REG,
.min_u = 250000,
.max_u = 2000000,
.step_u = 250000,
},
.dc_icl = {
.name = "dc input current limit",
.reg = DCIN_CURRENT_LIMIT_CFG_REG,
.min_u = 0,
.max_u = 6000000,
.step_u = 25000,
},
.dc_icl_pt_lv = {
.name = "dc icl PT <8V",
.reg = ZIN_ICL_PT_REG,
.min_u = 0,
.max_u = 3000000,
.step_u = 25000,
},
.dc_icl_pt_hv = {
.name = "dc icl PT >8V",
.reg = ZIN_ICL_PT_HV_REG,
.min_u = 0,
.max_u = 3000000,
.step_u = 25000,
},
.dc_icl_div2_lv = {
.name = "dc icl div2 <5.5V",
.reg = ZIN_ICL_LV_REG,
.min_u = 0,
.max_u = 3000000,
.step_u = 25000,
},
.dc_icl_div2_mid_lv = {
.name = "dc icl div2 5.5-6.5V",
.reg = ZIN_ICL_MID_LV_REG,
.min_u = 0,
.max_u = 3000000,
.step_u = 25000,
},
.dc_icl_div2_mid_hv = {
.name = "dc icl div2 6.5-8.0V",
.reg = ZIN_ICL_MID_HV_REG,
.min_u = 0,
.max_u = 3000000,
.step_u = 25000,
},
.dc_icl_div2_hv = {
.name = "dc icl div2 >8.0V",
.reg = ZIN_ICL_HV_REG,
.min_u = 0,
.max_u = 3000000,
.step_u = 25000,
},
.jeita_cc_comp = {
.name = "jeita fcc reduction",
.reg = JEITA_CCCOMP_CFG_REG,
.min_u = 0,
.max_u = 1575000,
.step_u = 25000,
},
.freq_buck = {
.name = "buck switching frequency",
.reg = CFG_BUCKBOOST_FREQ_SELECT_BUCK_REG,
.min_u = 600,
.max_u = 2000,
.step_u = 200,
},
.freq_boost = {
.name = "boost switching frequency",
.reg = CFG_BUCKBOOST_FREQ_SELECT_BOOST_REG,
.min_u = 600,
.max_u = 2000,
.step_u = 200,
},
};
static struct smb_params pm660_params = {
.freq_buck = {
.name = "buck switching frequency",
.reg = FREQ_CLK_DIV_REG,
.min_u = 600,
.max_u = 1600,
.set_proc = smblib_set_chg_freq,
},
.freq_boost = {
.name = "boost switching frequency",
.reg = FREQ_CLK_DIV_REG,
.min_u = 600,
.max_u = 1600,
.set_proc = smblib_set_chg_freq,
},
};
struct smb_dt_props {
int usb_icl_ua;
int dc_icl_ua;
int boost_threshold_ua;
int wipower_max_uw;
int min_freq_khz;
int max_freq_khz;
int float_option;
int chg_inhibit_thr_mv;
bool no_battery;
bool hvdcp_disable;
bool auto_recharge_soc;
int wd_bark_time;
bool no_pd;
};
struct smb2 {
struct smb_charger chg;
struct dentry *dfs_root;
struct smb_dt_props dt;
unsigned int nchannels;
struct iio_channel *iio_chans;
struct iio_chan_spec *iio_chan_ids;
};
static int __debug_mask;
static int __weak_chg_icl_ua = 500000;
static ssize_t weak_chg_icl_ua_show(struct device *dev, struct device_attribute
*attr, char *buf)
{
return scnprintf(buf, PAGE_SIZE, "%d\n", __weak_chg_icl_ua);
}
static ssize_t weak_chg_icl_ua_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
int val;
if (kstrtos32(buf, 0, &val))
return -EINVAL;
__weak_chg_icl_ua = val;
return count;
}
static DEVICE_ATTR_RW(weak_chg_icl_ua);
static int __try_sink_enabled = 1;
static ssize_t try_sink_enabled_show(struct device *dev, struct device_attribute
*attr, char *buf)
{
return scnprintf(buf, PAGE_SIZE, "%d\n", __try_sink_enabled);
}
static ssize_t try_sink_enabled_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
int val;
if (kstrtos32(buf, 0, &val))
return -EINVAL;
__try_sink_enabled = val;
return count;
}
static DEVICE_ATTR_RW(try_sink_enabled);
static int __audio_headset_drp_wait_ms = 100;
static ssize_t audio_headset_drp_wait_ms_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
return scnprintf(buf, PAGE_SIZE, "%d\n", __audio_headset_drp_wait_ms);
}
static ssize_t audio_headset_drp_wait_ms_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
int val;
if (kstrtos32(buf, 0, &val))
return -EINVAL;
__audio_headset_drp_wait_ms = val;
return count;
}
static DEVICE_ATTR_RW(audio_headset_drp_wait_ms);
static struct attribute *smb2_attrs[] = {
&dev_attr_weak_chg_icl_ua.attr,
&dev_attr_try_sink_enabled.attr,
&dev_attr_audio_headset_drp_wait_ms.attr,
NULL,
};
ATTRIBUTE_GROUPS(smb2);
#define MICRO_1P5A 1500000
#define MICRO_P1A 100000
#define OTG_DEFAULT_DEGLITCH_TIME_MS 50
#define MIN_WD_BARK_TIME 16
#define DEFAULT_WD_BARK_TIME 64
#define BITE_WDOG_TIMEOUT_8S 0x3
#define BARK_WDOG_TIMEOUT_MASK GENMASK(3, 2)
#define BARK_WDOG_TIMEOUT_SHIFT 2
static int smb2_parse_dt(struct smb2 *chip)
{
struct smb_charger *chg = &chip->chg;
struct device_node *node = chg->dev->of_node;
int rc, byte_len;
if (!node) {
pr_err("device tree node missing\n");
return -EINVAL;
}
chg->reddragon_ipc_wa = of_property_read_bool(node,
"qcom,qcs605-ipc-wa");
chg->step_chg_enabled = of_property_read_bool(node,
"qcom,step-charging-enable");
chg->sw_jeita_enabled = of_property_read_bool(node,
"qcom,sw-jeita-enable");
rc = of_property_read_u32(node, "qcom,wd-bark-time-secs",
&chip->dt.wd_bark_time);
if (rc < 0 || chip->dt.wd_bark_time < MIN_WD_BARK_TIME)
chip->dt.wd_bark_time = DEFAULT_WD_BARK_TIME;
chip->dt.no_battery = of_property_read_bool(node,
"qcom,batteryless-platform");
chip->dt.no_pd = of_property_read_bool(node,
"qcom,pd-not-supported");
rc = of_property_read_u32(node,
"qcom,fcc-max-ua", &chg->batt_profile_fcc_ua);
if (rc < 0)
chg->batt_profile_fcc_ua = -EINVAL;
rc = of_property_read_u32(node,
"qcom,fv-max-uv", &chg->batt_profile_fv_uv);
if (rc < 0)
chg->batt_profile_fv_uv = -EINVAL;
rc = of_property_read_u32(node,
"qcom,usb-icl-ua", &chip->dt.usb_icl_ua);
if (rc < 0)
chip->dt.usb_icl_ua = -EINVAL;
rc = of_property_read_u32(node,
"qcom,otg-cl-ua", &chg->otg_cl_ua);
if (rc < 0)
chg->otg_cl_ua = MICRO_1P5A;
rc = of_property_read_u32(node,
"qcom,dc-icl-ua", &chip->dt.dc_icl_ua);
if (rc < 0)
chip->dt.dc_icl_ua = -EINVAL;
rc = of_property_read_u32(node,
"qcom,boost-threshold-ua",
&chip->dt.boost_threshold_ua);
if (rc < 0)
chip->dt.boost_threshold_ua = MICRO_P1A;
rc = of_property_read_u32(node,
"qcom,min-freq-khz",
&chip->dt.min_freq_khz);
if (rc < 0)
chip->dt.min_freq_khz = -EINVAL;
rc = of_property_read_u32(node,
"qcom,max-freq-khz",
&chip->dt.max_freq_khz);
if (rc < 0)
chip->dt.max_freq_khz = -EINVAL;
rc = of_property_read_u32(node, "qcom,wipower-max-uw",
&chip->dt.wipower_max_uw);
if (rc < 0)
chip->dt.wipower_max_uw = -EINVAL;
if (of_find_property(node, "qcom,thermal-mitigation", &byte_len)) {
chg->thermal_mitigation = devm_kzalloc(chg->dev, byte_len,
GFP_KERNEL);
if (chg->thermal_mitigation == NULL)
return -ENOMEM;
chg->thermal_levels = byte_len / sizeof(u32);
rc = of_property_read_u32_array(node,
"qcom,thermal-mitigation",
chg->thermal_mitigation,
chg->thermal_levels);
if (rc < 0) {
dev_err(chg->dev,
"Couldn't read threm limits rc = %d\n", rc);
return rc;
}
}
of_property_read_u32(node, "qcom,float-option", &chip->dt.float_option);
if (chip->dt.float_option < 0 || chip->dt.float_option > 4) {
pr_err("qcom,float-option is out of range [0, 4]\n");
return -EINVAL;
}
chip->dt.hvdcp_disable = of_property_read_bool(node,
"qcom,hvdcp-disable");
of_property_read_u32(node, "qcom,chg-inhibit-threshold-mv",
&chip->dt.chg_inhibit_thr_mv);
if ((chip->dt.chg_inhibit_thr_mv < 0 ||
chip->dt.chg_inhibit_thr_mv > 300)) {
pr_err("qcom,chg-inhibit-threshold-mv is incorrect\n");
return -EINVAL;
}
chip->dt.auto_recharge_soc = of_property_read_bool(node,
"qcom,auto-recharge-soc");
chg->use_extcon = of_property_read_bool(node,
"qcom,use-extcon");
chg->dcp_icl_ua = chip->dt.usb_icl_ua;
chg->suspend_input_on_debug_batt = of_property_read_bool(node,
"qcom,suspend-input-on-debug-batt");
rc = of_property_read_u32(node, "qcom,otg-deglitch-time-ms",
&chg->otg_delay_ms);
if (rc < 0)
chg->otg_delay_ms = OTG_DEFAULT_DEGLITCH_TIME_MS;
chg->disable_stat_sw_override = of_property_read_bool(node,
"qcom,disable-stat-sw-override");
chg->fcc_stepper_enable = of_property_read_bool(node,
"qcom,fcc-stepping-enable");
chg->ufp_only_mode = of_property_read_bool(node,
"qcom,ufp-only-mode");
return 0;
}
/************************
* USB PSY REGISTRATION *
************************/
static enum power_supply_property smb2_usb_props[] = {
POWER_SUPPLY_PROP_PRESENT,
POWER_SUPPLY_PROP_ONLINE,
POWER_SUPPLY_PROP_VOLTAGE_MAX,
POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
POWER_SUPPLY_PROP_VOLTAGE_NOW,
POWER_SUPPLY_PROP_CURRENT_MAX,
POWER_SUPPLY_PROP_CURRENT_NOW,
POWER_SUPPLY_PROP_TYPE,
};
static int smb2_usb_get_prop(struct power_supply *psy,
enum power_supply_property psp,
union power_supply_propval *val)
{
struct smb2 *chip = power_supply_get_drvdata(psy);
struct smb_charger *chg = &chip->chg;
int rc = 0;
switch (psp) {
case POWER_SUPPLY_PROP_PRESENT:
rc = smblib_get_prop_usb_present(chg, val);
break;
case POWER_SUPPLY_PROP_ONLINE:
rc = smblib_get_prop_usb_online(chg, val);
if (!val->intval)
break;
if (((chg->typec_mode == QTI_POWER_SUPPLY_TYPEC_SOURCE_DEFAULT)
|| (chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_MICRO_USB))
&& (chg->real_charger_type == POWER_SUPPLY_TYPE_USB))
val->intval = 0;
else
val->intval = 1;
if (chg->real_charger_type == POWER_SUPPLY_TYPE_UNKNOWN)
val->intval = 0;
break;
case POWER_SUPPLY_PROP_VOLTAGE_MAX:
rc = smblib_get_prop_usb_voltage_max(chg, val);
break;
case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
rc = smblib_get_prop_usb_voltage_max_design(chg, val);
break;
case POWER_SUPPLY_PROP_VOLTAGE_NOW:
rc = smblib_get_prop_usb_voltage_now(chg, val);
break;
case POWER_SUPPLY_PROP_CURRENT_MAX:
rc = smblib_get_prop_input_current_settled(chg, val);
break;
case POWER_SUPPLY_PROP_TYPE:
val->intval = POWER_SUPPLY_TYPE_USB_PD;
break;
case POWER_SUPPLY_PROP_CURRENT_NOW:
rc = smblib_get_prop_usb_current_now(chg, val);
break;
default:
pr_err("get prop %d is not supported in usb\n", psp);
rc = -EINVAL;
break;
}
if (rc < 0) {
pr_debug("Couldn't get prop %d rc = %d\n", psp, rc);
return -ENODATA;
}
return 0;
}
static int smb2_usb_set_prop(struct power_supply *psy,
enum power_supply_property psp,
const union power_supply_propval *val)
{
struct smb2 *chip = power_supply_get_drvdata(psy);
struct smb_charger *chg = &chip->chg;
int rc = 0;
mutex_lock(&chg->lock);
switch (psp) {
case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
rc = smblib_set_prop_sdp_current_max(chg, val->intval);
break;
default:
pr_err("set prop %d is not supported\n", psp);
rc = -EINVAL;
break;
}
mutex_unlock(&chg->lock);
return rc;
}
static int smb2_usb_prop_is_writeable(struct power_supply *psy,
enum power_supply_property psp)
{
switch (psp) {
case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
return 1;
default:
break;
}
return 0;
}
static int smb2_init_usb_psy(struct smb2 *chip)
{
struct power_supply_config usb_cfg = {};
struct smb_charger *chg = &chip->chg;
chg->usb_psy_desc.name = "usb";
chg->usb_psy_desc.type = POWER_SUPPLY_TYPE_USB_PD;
chg->usb_psy_desc.properties = smb2_usb_props;
chg->usb_psy_desc.num_properties = ARRAY_SIZE(smb2_usb_props);
chg->usb_psy_desc.get_property = smb2_usb_get_prop;
chg->usb_psy_desc.set_property = smb2_usb_set_prop;
chg->usb_psy_desc.property_is_writeable = smb2_usb_prop_is_writeable;
usb_cfg.drv_data = chip;
usb_cfg.of_node = chg->dev->of_node;
chg->usb_psy = power_supply_register(chg->dev,
&chg->usb_psy_desc,
&usb_cfg);
if (IS_ERR(chg->usb_psy)) {
pr_err("Couldn't register USB power supply\n");
return PTR_ERR(chg->usb_psy);
}
return 0;
}
/********************************
* USB PC_PORT PSY REGISTRATION *
********************************/
static enum power_supply_property smb2_usb_port_props[] = {
POWER_SUPPLY_PROP_TYPE,
POWER_SUPPLY_PROP_ONLINE,
POWER_SUPPLY_PROP_VOLTAGE_MAX,
POWER_SUPPLY_PROP_CURRENT_MAX,
};
static int smb2_usb_port_get_prop(struct power_supply *psy,
enum power_supply_property psp,
union power_supply_propval *val)
{
struct smb2 *chip = power_supply_get_drvdata(psy);
struct smb_charger *chg = &chip->chg;
int rc = 0;
switch (psp) {
case POWER_SUPPLY_PROP_TYPE:
val->intval = POWER_SUPPLY_TYPE_USB;
break;
case POWER_SUPPLY_PROP_ONLINE:
rc = smblib_get_prop_usb_online(chg, val);
if (!val->intval)
break;
if (((chg->typec_mode == QTI_POWER_SUPPLY_TYPEC_SOURCE_DEFAULT)
|| (chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_MICRO_USB))
&& (chg->real_charger_type == POWER_SUPPLY_TYPE_USB))
val->intval = 1;
else
val->intval = 0;
break;
case POWER_SUPPLY_PROP_VOLTAGE_MAX:
val->intval = 5000000;
break;
case POWER_SUPPLY_PROP_CURRENT_MAX:
rc = smblib_get_prop_input_current_settled(chg, val);
break;
default:
pr_err_ratelimited("Get prop %d is not supported in pc_port\n",
psp);
return -EINVAL;
}
if (rc < 0) {
pr_debug("Couldn't get prop %d rc = %d\n", psp, rc);
return -ENODATA;
}
return 0;
}
static int smb2_usb_port_set_prop(struct power_supply *psy,
enum power_supply_property psp,
const union power_supply_propval *val)
{
int rc = 0;
switch (psp) {
default:
pr_err_ratelimited("Set prop %d is not supported in pc_port\n",
psp);
rc = -EINVAL;
break;
}
return rc;
}
static const struct power_supply_desc usb_port_psy_desc = {
.name = "pc_port",
.type = POWER_SUPPLY_TYPE_USB,
.properties = smb2_usb_port_props,
.num_properties = ARRAY_SIZE(smb2_usb_port_props),
.get_property = smb2_usb_port_get_prop,
.set_property = smb2_usb_port_set_prop,
};
static int smb2_init_usb_port_psy(struct smb2 *chip)
{
struct power_supply_config usb_port_cfg = {};
struct smb_charger *chg = &chip->chg;
usb_port_cfg.drv_data = chip;
usb_port_cfg.of_node = chg->dev->of_node;
chg->usb_port_psy = power_supply_register(chg->dev,
&usb_port_psy_desc,
&usb_port_cfg);
if (IS_ERR(chg->usb_port_psy)) {
pr_err("Couldn't register USB pc_port power supply\n");
return PTR_ERR(chg->usb_port_psy);
}
return 0;
}
/*************************
* DC PSY REGISTRATION *
*************************/
static enum power_supply_property smb2_dc_props[] = {
POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
POWER_SUPPLY_PROP_PRESENT,
POWER_SUPPLY_PROP_ONLINE,
POWER_SUPPLY_PROP_CURRENT_MAX,
};
static int smb2_dc_get_prop(struct power_supply *psy,
enum power_supply_property psp,
union power_supply_propval *val)
{
struct smb2 *chip = power_supply_get_drvdata(psy);
struct smb_charger *chg = &chip->chg;
int rc = 0;
switch (psp) {
case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
val->intval = get_effective_result(chg->dc_suspend_votable);
break;
case POWER_SUPPLY_PROP_PRESENT:
rc = smblib_get_prop_dc_present(chg, val);
break;
case POWER_SUPPLY_PROP_ONLINE:
rc = smblib_get_prop_dc_online(chg, val);
break;
case POWER_SUPPLY_PROP_CURRENT_MAX:
rc = smblib_get_prop_dc_current_max(chg, val);
break;
default:
return -EINVAL;
}
if (rc < 0) {
pr_debug("Couldn't get prop %d rc = %d\n", psp, rc);
return -ENODATA;
}
return 0;
}
static int smb2_dc_set_prop(struct power_supply *psy,
enum power_supply_property psp,
const union power_supply_propval *val)
{
struct smb2 *chip = power_supply_get_drvdata(psy);
struct smb_charger *chg = &chip->chg;
int rc = 0;
switch (psp) {
case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
rc = vote(chg->dc_suspend_votable, WBC_VOTER,
(bool)val->intval, 0);
break;
case POWER_SUPPLY_PROP_CURRENT_MAX:
rc = smblib_set_prop_dc_current_max(chg, val);
break;
default:
return -EINVAL;
}
return rc;
}
static int smb2_dc_prop_is_writeable(struct power_supply *psy,
enum power_supply_property psp)
{
int rc;
switch (psp) {
case POWER_SUPPLY_PROP_CURRENT_MAX:
rc = 1;
break;
default:
rc = 0;
break;
}
return rc;
}
static const struct power_supply_desc dc_psy_desc = {
.name = "dc",
.type = POWER_SUPPLY_TYPE_MAINS,
.properties = smb2_dc_props,
.num_properties = ARRAY_SIZE(smb2_dc_props),
.get_property = smb2_dc_get_prop,
.set_property = smb2_dc_set_prop,
.property_is_writeable = smb2_dc_prop_is_writeable,
};
static int smb2_init_dc_psy(struct smb2 *chip)
{
struct power_supply_config dc_cfg = {};
struct smb_charger *chg = &chip->chg;
dc_cfg.drv_data = chip;
dc_cfg.of_node = chg->dev->of_node;
chg->dc_psy = power_supply_register(chg->dev,
&dc_psy_desc,
&dc_cfg);
if (IS_ERR(chg->dc_psy)) {
pr_err("Couldn't register USB power supply\n");
return PTR_ERR(chg->dc_psy);
}
return 0;
}
/*************************
* BATT PSY REGISTRATION *
*************************/
static enum power_supply_property smb2_batt_props[] = {
POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
POWER_SUPPLY_PROP_STATUS,
POWER_SUPPLY_PROP_HEALTH,
POWER_SUPPLY_PROP_PRESENT,
POWER_SUPPLY_PROP_CHARGE_TYPE,
POWER_SUPPLY_PROP_CAPACITY,
POWER_SUPPLY_PROP_VOLTAGE_NOW,
POWER_SUPPLY_PROP_VOLTAGE_MAX,
POWER_SUPPLY_PROP_CURRENT_NOW,
POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
POWER_SUPPLY_PROP_TEMP,
POWER_SUPPLY_PROP_TECHNOLOGY,
POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX,
POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT,
POWER_SUPPLY_PROP_CHARGE_COUNTER,
POWER_SUPPLY_PROP_CHARGE_FULL,
POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
POWER_SUPPLY_PROP_CYCLE_COUNT,
};
static int smb2_batt_get_prop(struct power_supply *psy,
enum power_supply_property psp,
union power_supply_propval *val)
{
struct smb_charger *chg = power_supply_get_drvdata(psy);
int rc = 0;
switch (psp) {
case POWER_SUPPLY_PROP_STATUS:
rc = smblib_get_prop_batt_status(chg, val);
break;
case POWER_SUPPLY_PROP_HEALTH:
rc = smblib_get_prop_batt_health(chg, val);
break;
case POWER_SUPPLY_PROP_PRESENT:
rc = smblib_get_prop_batt_present(chg, val);
break;
case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
rc = smblib_get_prop_input_suspend(chg, val);
break;
case POWER_SUPPLY_PROP_CHARGE_TYPE:
rc = smblib_get_prop_batt_charge_type(chg, val);
break;
case POWER_SUPPLY_PROP_CAPACITY:
rc = smblib_get_prop_batt_capacity(chg, val);
break;
case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT:
rc = smblib_get_prop_system_temp_level(chg, val);
break;
case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX:
rc = smblib_get_prop_system_temp_level_max(chg, val);
break;
case POWER_SUPPLY_PROP_VOLTAGE_MAX:
val->intval = get_client_vote(chg->fv_votable,
BATT_PROFILE_VOTER);
break;
case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
val->intval = get_client_vote(chg->fcc_votable,
BATT_PROFILE_VOTER);
break;
case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
val->intval = get_client_vote(chg->fcc_votable,
FG_ESR_VOTER);
break;
case POWER_SUPPLY_PROP_TECHNOLOGY:
val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
break;
case POWER_SUPPLY_PROP_CHARGE_COUNTER:
rc = smblib_get_prop_from_bms(chg,
SMB2_FG_GEN3_CHARGE_COUNTER, &val->intval);
break;
case POWER_SUPPLY_PROP_CHARGE_FULL:
rc = smblib_get_prop_from_bms(chg,
SMB2_FG_GEN3_CHARGE_FULL, &val->intval);
break;
case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
rc = smblib_get_prop_from_bms(chg,
SMB2_FG_GEN3_CHARGE_FULL_DESIGN, &val->intval);
break;
case POWER_SUPPLY_PROP_CYCLE_COUNT:
rc = smblib_get_prop_from_bms(chg,
SMB2_FG_GEN3_CYCLE_COUNT, &val->intval);
break;
case POWER_SUPPLY_PROP_VOLTAGE_NOW:
rc = smblib_get_prop_from_bms(chg,
SMB2_FG_GEN3_VOLTAGE_NOW, &val->intval);
break;
case POWER_SUPPLY_PROP_TEMP:
rc = smblib_get_prop_from_bms(chg,
SMB2_FG_GEN3_TEMP, &val->intval);
break;
case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW:
rc = smblib_get_prop_from_bms(chg,
SMB2_FG_GEN3_TIME_TO_FULL_NOW, &val->intval);
break;
case POWER_SUPPLY_PROP_CURRENT_NOW:
rc = smblib_get_prop_from_bms(chg,
SMB2_FG_GEN3_CURRENT_NOW, &val->intval);
if (!rc)
val->intval *= (-1);
break;
default:
pr_err("batt power supply prop %d not supported\n", psp);
return -EINVAL;
}
if (rc < 0) {
pr_debug("Couldn't get prop %d rc = %d\n", psp, rc);
return -ENODATA;
}
return 0;
}
static int smb2_batt_set_prop(struct power_supply *psy,
enum power_supply_property prop,
const union power_supply_propval *val)
{
int rc = 0;
struct smb_charger *chg = power_supply_get_drvdata(psy);
switch (prop) {
case POWER_SUPPLY_PROP_STATUS:
rc = smblib_set_prop_batt_status(chg, val);
break;
case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
rc = smblib_set_prop_input_suspend(chg, val);
break;
case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT:
rc = smblib_set_prop_system_temp_level(chg, val);
break;
case POWER_SUPPLY_PROP_CAPACITY:
rc = smblib_set_prop_batt_capacity(chg, val);
break;
case POWER_SUPPLY_PROP_VOLTAGE_MAX:
chg->batt_profile_fv_uv = val->intval;
vote(chg->fv_votable, BATT_PROFILE_VOTER, true, val->intval);
break;
case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
chg->batt_profile_fcc_ua = val->intval;
vote(chg->fcc_votable, BATT_PROFILE_VOTER, true, val->intval);
break;
case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
if (val->intval)
vote(chg->fcc_votable, FG_ESR_VOTER, true, val->intval);
else
vote(chg->fcc_votable, FG_ESR_VOTER, false, 0);
break;
default:
rc = -EINVAL;
}
return rc;
}
static int smb2_batt_prop_is_writeable(struct power_supply *psy,
enum power_supply_property psp)
{
switch (psp) {
case POWER_SUPPLY_PROP_STATUS:
case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
case POWER_SUPPLY_PROP_CAPACITY:
return 1;
default:
break;
}
return 0;
}
static const struct power_supply_desc batt_psy_desc = {
.name = "battery",
.type = POWER_SUPPLY_TYPE_BATTERY,
.properties = smb2_batt_props,
.num_properties = ARRAY_SIZE(smb2_batt_props),
.get_property = smb2_batt_get_prop,
.set_property = smb2_batt_set_prop,
.property_is_writeable = smb2_batt_prop_is_writeable,
};
static int smb2_init_batt_psy(struct smb2 *chip)
{
struct power_supply_config batt_cfg = {};
struct smb_charger *chg = &chip->chg;
int rc = 0;
batt_cfg.drv_data = chg;
batt_cfg.of_node = chg->dev->of_node;
chg->batt_psy = power_supply_register(chg->dev,
&batt_psy_desc,
&batt_cfg);
if (IS_ERR(chg->batt_psy)) {
pr_err("Couldn't register battery power supply\n");
return PTR_ERR(chg->batt_psy);
}
return rc;
}
/******************************
* VBUS REGULATOR REGISTRATION *
******************************/
static const struct regulator_ops smb2_vbus_reg_ops = {
.enable = smblib_vbus_regulator_enable,
.disable = smblib_vbus_regulator_disable,
.is_enabled = smblib_vbus_regulator_is_enabled,
};
static int smb2_init_vbus_regulator(struct smb2 *chip)
{
struct smb_charger *chg = &chip->chg;
struct regulator_config cfg = {};
int rc = 0;
chg->vbus_vreg = devm_kzalloc(chg->dev, sizeof(*chg->vbus_vreg),
GFP_KERNEL);
if (!chg->vbus_vreg)
return -ENOMEM;
cfg.dev = chg->dev;
cfg.driver_data = chip;
chg->vbus_vreg->rdesc.owner = THIS_MODULE;
chg->vbus_vreg->rdesc.type = REGULATOR_VOLTAGE;
chg->vbus_vreg->rdesc.ops = &smb2_vbus_reg_ops;
chg->vbus_vreg->rdesc.of_match = "qcom,smb2-vbus";
chg->vbus_vreg->rdesc.name = "qcom,smb2-vbus";
chg->vbus_vreg->rdev = devm_regulator_register(chg->dev,
&chg->vbus_vreg->rdesc, &cfg);
if (IS_ERR(chg->vbus_vreg->rdev)) {
rc = PTR_ERR(chg->vbus_vreg->rdev);
chg->vbus_vreg->rdev = NULL;
if (rc != -EPROBE_DEFER)
pr_err("Couldn't register VBUS regualtor rc=%d\n", rc);
}
return rc;
}
/******************************
* VCONN REGULATOR REGISTRATION *
******************************/
static const struct regulator_ops smb2_vconn_reg_ops = {
.enable = smblib_vconn_regulator_enable,
.disable = smblib_vconn_regulator_disable,
.is_enabled = smblib_vconn_regulator_is_enabled,
};
static int smb2_init_vconn_regulator(struct smb2 *chip)
{
struct smb_charger *chg = &chip->chg;
struct regulator_config cfg = {};
int rc = 0;
if (chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_MICRO_USB)
return 0;
chg->vconn_vreg = devm_kzalloc(chg->dev, sizeof(*chg->vconn_vreg),
GFP_KERNEL);
if (!chg->vconn_vreg)
return -ENOMEM;
cfg.dev = chg->dev;
cfg.driver_data = chip;
chg->vconn_vreg->rdesc.owner = THIS_MODULE;
chg->vconn_vreg->rdesc.type = REGULATOR_VOLTAGE;
chg->vconn_vreg->rdesc.ops = &smb2_vconn_reg_ops;
chg->vconn_vreg->rdesc.of_match = "qcom,smb2-vconn";
chg->vconn_vreg->rdesc.name = "qcom,smb2-vconn";
chg->vconn_vreg->rdev = devm_regulator_register(chg->dev,
&chg->vconn_vreg->rdesc, &cfg);
if (IS_ERR(chg->vconn_vreg->rdev)) {
rc = PTR_ERR(chg->vconn_vreg->rdev);
chg->vconn_vreg->rdev = NULL;
if (rc != -EPROBE_DEFER)
pr_err("Couldn't register VCONN regualtor rc=%d\n", rc);
}
return rc;
}
/***************************
* HARDWARE INITIALIZATION *
***************************/
static int smb2_config_wipower_input_power(struct smb2 *chip, int uw)
{
int rc;
int ua;
struct smb_charger *chg = &chip->chg;
s64 nw = (s64)uw * 1000;
if (uw < 0)
return 0;
ua = div_s64(nw, ZIN_ICL_PT_MAX_MV);
rc = smblib_set_charge_param(chg, &chg->param.dc_icl_pt_lv, ua);
if (rc < 0) {
pr_err("Couldn't configure dc_icl_pt_lv rc = %d\n", rc);
return rc;
}
ua = div_s64(nw, ZIN_ICL_PT_HV_MAX_MV);
rc = smblib_set_charge_param(chg, &chg->param.dc_icl_pt_hv, ua);
if (rc < 0) {
pr_err("Couldn't configure dc_icl_pt_hv rc = %d\n", rc);
return rc;
}
ua = div_s64(nw, ZIN_ICL_LV_MAX_MV);
rc = smblib_set_charge_param(chg, &chg->param.dc_icl_div2_lv, ua);
if (rc < 0) {
pr_err("Couldn't configure dc_icl_div2_lv rc = %d\n", rc);
return rc;
}
ua = div_s64(nw, ZIN_ICL_MID_LV_MAX_MV);
rc = smblib_set_charge_param(chg, &chg->param.dc_icl_div2_mid_lv, ua);
if (rc < 0) {
pr_err("Couldn't configure dc_icl_div2_mid_lv rc = %d\n", rc);
return rc;
}
ua = div_s64(nw, ZIN_ICL_MID_HV_MAX_MV);
rc = smblib_set_charge_param(chg, &chg->param.dc_icl_div2_mid_hv, ua);
if (rc < 0) {
pr_err("Couldn't configure dc_icl_div2_mid_hv rc = %d\n", rc);
return rc;
}
ua = div_s64(nw, ZIN_ICL_HV_MAX_MV);
rc = smblib_set_charge_param(chg, &chg->param.dc_icl_div2_hv, ua);
if (rc < 0) {
pr_err("Couldn't configure dc_icl_div2_hv rc = %d\n", rc);
return rc;
}
return 0;
}
static int smb2_configure_typec(struct smb_charger *chg)
{
int rc;
/*
* trigger the usb-typec-change interrupt only when the CC state
* changes
*/
rc = smblib_write(chg, TYPE_C_INTRPT_ENB_REG,
TYPEC_CCSTATE_CHANGE_INT_EN_BIT);
if (rc < 0) {
dev_err(chg->dev,
"Couldn't configure Type-C interrupts rc=%d\n", rc);
return rc;
}
/*
* disable Type-C factory mode and stay in Attached.SRC state when VCONN
* over-current happens
*/
rc = smblib_masked_write(chg, TYPE_C_CFG_REG,
FACTORY_MODE_DETECTION_EN_BIT | VCONN_OC_CFG_BIT, 0);
if (rc < 0) {
dev_err(chg->dev, "Couldn't configure Type-C rc=%d\n", rc);
return rc;
}
/* increase VCONN softstart */
rc = smblib_masked_write(chg, TYPE_C_CFG_2_REG,
VCONN_SOFTSTART_CFG_MASK, VCONN_SOFTSTART_CFG_MASK);
if (rc < 0) {
dev_err(chg->dev, "Couldn't increase VCONN softstart rc=%d\n",
rc);
return rc;
}
/* disable try.SINK mode and legacy cable IRQs */
rc = smblib_masked_write(chg, TYPE_C_CFG_3_REG, EN_TRYSINK_MODE_BIT |
TYPEC_NONCOMPLIANT_LEGACY_CABLE_INT_EN_BIT |
TYPEC_LEGACY_CABLE_INT_EN_BIT, 0);
if (rc < 0) {
dev_err(chg->dev, "Couldn't set Type-C config rc=%d\n", rc);
return rc;
}
/* Set CC threshold to 1.6 V in source mode */
rc = smblib_masked_write(chg, TYPE_C_CFG_2_REG, DFP_CC_1P4V_OR_1P6V_BIT,
DFP_CC_1P4V_OR_1P6V_BIT);
if (rc < 0)
dev_err(chg->dev,
"Couldn't configure CC threshold voltage rc=%d\n", rc);
return rc;
}
static int smb2_disable_typec(struct smb_charger *chg)
{
int rc;
/* Move to typeC mode */
/* configure FSM in idle state and disable UFP_ENABLE bit */
rc = smblib_masked_write(chg, TYPE_C_INTRPT_ENB_SOFTWARE_CTRL_REG,
TYPEC_DISABLE_CMD_BIT | UFP_EN_CMD_BIT,
TYPEC_DISABLE_CMD_BIT);
if (rc < 0) {
dev_err(chg->dev, "Couldn't put FSM in idle rc=%d\n", rc);
return rc;
}
/* wait for FSM to enter idle state */
msleep(200);
/* configure TypeC mode */
rc = smblib_masked_write(chg, TYPE_C_CFG_REG,
TYPE_C_OR_U_USB_BIT, 0);
if (rc < 0) {
dev_err(chg->dev, "Couldn't enable micro USB mode rc=%d\n", rc);
return rc;
}
/* wait for mode change before enabling FSM */
usleep_range(10000, 11000);
/* release FSM from idle state */
rc = smblib_masked_write(chg, TYPE_C_INTRPT_ENB_SOFTWARE_CTRL_REG,
TYPEC_DISABLE_CMD_BIT, 0);
if (rc < 0) {
dev_err(chg->dev, "Couldn't release FSM rc=%d\n", rc);
return rc;
}
/* wait for FSM to start */
msleep(100);
/* move to uUSB mode */
/* configure FSM in idle state */
rc = smblib_masked_write(chg, TYPE_C_INTRPT_ENB_SOFTWARE_CTRL_REG,
TYPEC_DISABLE_CMD_BIT, TYPEC_DISABLE_CMD_BIT);
if (rc < 0) {
dev_err(chg->dev, "Couldn't put FSM in idle rc=%d\n", rc);
return rc;
}
/* wait for FSM to enter idle state */
msleep(200);
/* configure micro USB mode */
rc = smblib_masked_write(chg, TYPE_C_CFG_REG,
TYPE_C_OR_U_USB_BIT, TYPE_C_OR_U_USB_BIT);
if (rc < 0) {
dev_err(chg->dev, "Couldn't enable micro USB mode rc=%d\n", rc);
return rc;
}
/* wait for mode change before enabling FSM */
usleep_range(10000, 11000);
/* release FSM from idle state */
rc = smblib_masked_write(chg, TYPE_C_INTRPT_ENB_SOFTWARE_CTRL_REG,
TYPEC_DISABLE_CMD_BIT, 0);
if (rc < 0) {
dev_err(chg->dev, "Couldn't release FSM rc=%d\n", rc);
return rc;
}
return rc;
}
static int smb2_init_hw(struct smb2 *chip)
{
struct smb_charger *chg = &chip->chg;
int rc;
u8 stat, val;
if (chip->dt.no_battery)
chg->fake_capacity = 50;
if (chg->batt_profile_fcc_ua < 0)
smblib_get_charge_param(chg, &chg->param.fcc,
&chg->batt_profile_fcc_ua);
if (chg->batt_profile_fv_uv < 0)
smblib_get_charge_param(chg, &chg->param.fv,
&chg->batt_profile_fv_uv);
smblib_get_charge_param(chg, &chg->param.usb_icl,
&chg->default_icl_ua);
if (chip->dt.usb_icl_ua < 0)
chip->dt.usb_icl_ua = chg->default_icl_ua;
if (chip->dt.dc_icl_ua < 0)
smblib_get_charge_param(chg, &chg->param.dc_icl,
&chip->dt.dc_icl_ua);
if (chip->dt.min_freq_khz > 0) {
chg->param.freq_buck.min_u = chip->dt.min_freq_khz;
chg->param.freq_boost.min_u = chip->dt.min_freq_khz;
}
if (chip->dt.max_freq_khz > 0) {
chg->param.freq_buck.max_u = chip->dt.max_freq_khz;
chg->param.freq_boost.max_u = chip->dt.max_freq_khz;
}
/* set a slower soft start setting for OTG */
rc = smblib_masked_write(chg, DC_ENG_SSUPPLY_CFG2_REG,
ENG_SSUPPLY_IVREF_OTG_SS_MASK, OTG_SS_SLOW);
if (rc < 0) {
pr_err("Couldn't set otg soft start rc=%d\n", rc);
return rc;
}
/* set OTG current limit */
rc = smblib_set_charge_param(chg, &chg->param.otg_cl,
(chg->wa_flags & OTG_WA) ?
chg->param.otg_cl.min_u : chg->otg_cl_ua);
if (rc < 0) {
pr_err("Couldn't set otg current limit rc=%d\n", rc);
return rc;
}
chg->boost_threshold_ua = chip->dt.boost_threshold_ua;
rc = smblib_read(chg, APSD_RESULT_STATUS_REG, &stat);
if (rc < 0) {
pr_err("Couldn't read APSD_RESULT_STATUS rc=%d\n", rc);
return rc;
}
smblib_rerun_apsd_if_required(chg);
/* clear the ICL override if it is set */
if (smblib_icl_override(chg, false) < 0) {
pr_err("Couldn't disable ICL override rc=%d\n", rc);
return rc;
}
/* votes must be cast before configuring software control */
/* vote 0mA on usb_icl for non battery platforms */
vote(chg->usb_icl_votable,
DEFAULT_VOTER, chip->dt.no_battery, 0);
vote(chg->dc_suspend_votable,
DEFAULT_VOTER, chip->dt.no_battery, 0);
vote(chg->fcc_votable,
BATT_PROFILE_VOTER, true, chg->batt_profile_fcc_ua);
vote(chg->fv_votable,
BATT_PROFILE_VOTER, true, chg->batt_profile_fv_uv);
vote(chg->dc_icl_votable,
DEFAULT_VOTER, true, chip->dt.dc_icl_ua);
vote(chg->hvdcp_disable_votable_indirect, DEFAULT_VOTER,
chip->dt.hvdcp_disable, 0);
vote(chg->pd_disallowed_votable_indirect, CC_DETACHED_VOTER,
true, 0);
vote(chg->pd_disallowed_votable_indirect, HVDCP_TIMEOUT_VOTER,
true, 0);
vote(chg->pd_disallowed_votable_indirect, PD_NOT_SUPPORTED_VOTER,
chip->dt.no_pd, 0);
/*
* AICL configuration:
* start from min and AICL ADC disable
*/
rc = smblib_masked_write(chg, USBIN_AICL_OPTIONS_CFG_REG,
USBIN_AICL_START_AT_MAX_BIT
| USBIN_AICL_ADC_EN_BIT, 0);
if (rc < 0) {
dev_err(chg->dev, "Couldn't configure AICL rc=%d\n", rc);
return rc;
}
/* Configure charge enable for software control; active high */
rc = smblib_masked_write(chg, CHGR_CFG2_REG,
CHG_EN_POLARITY_BIT |
CHG_EN_SRC_BIT, 0);
if (rc < 0) {
dev_err(chg->dev, "Couldn't configure charger rc=%d\n", rc);
return rc;
}
/* enable the charging path */
rc = vote(chg->chg_disable_votable, DEFAULT_VOTER, false, 0);
if (rc < 0) {
dev_err(chg->dev, "Couldn't enable charging rc=%d\n", rc);
return rc;
}
/* Check USB connector type (typeC/microUSB) */
rc = smblib_read(chg, RID_CC_CONTROL_7_0_REG, &val);
if (rc < 0) {
dev_err(chg->dev, "Couldn't read RID_CC_CONTROL_7_0 rc=%d\n",
rc);
return rc;
}
chg->connector_type = (val & EN_MICRO_USB_MODE_BIT) ?
QTI_POWER_SUPPLY_CONNECTOR_MICRO_USB
: QTI_POWER_SUPPLY_CONNECTOR_TYPEC;
if (chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_MICRO_USB)
rc = smb2_disable_typec(chg);
else
rc = smb2_configure_typec(chg);
if (rc < 0) {
dev_err(chg->dev,
"Couldn't configure Type-C interrupts rc=%d\n", rc);
return rc;
}
/* Connector types based votes */
vote(chg->hvdcp_disable_votable_indirect, PD_INACTIVE_VOTER,
(chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_TYPEC), 0);
vote(chg->hvdcp_disable_votable_indirect, VBUS_CC_SHORT_VOTER,
(chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_TYPEC), 0);
vote(chg->pd_disallowed_votable_indirect, MICRO_USB_VOTER,
(chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_MICRO_USB), 0);
vote(chg->hvdcp_enable_votable, MICRO_USB_VOTER,
(chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_MICRO_USB), 0);
/* configure VCONN for software control */
rc = smblib_masked_write(chg, TYPE_C_INTRPT_ENB_SOFTWARE_CTRL_REG,
VCONN_EN_SRC_BIT | VCONN_EN_VALUE_BIT,
VCONN_EN_SRC_BIT);
if (rc < 0) {
dev_err(chg->dev,
"Couldn't configure VCONN for SW control rc=%d\n", rc);
return rc;
}
/* configure VBUS for software control */
rc = smblib_masked_write(chg, OTG_CFG_REG, OTG_EN_SRC_CFG_BIT, 0);
if (rc < 0) {
dev_err(chg->dev,
"Couldn't configure VBUS for SW control rc=%d\n", rc);
return rc;
}
val = (ilog2(chip->dt.wd_bark_time / 16) << BARK_WDOG_TIMEOUT_SHIFT) &
BARK_WDOG_TIMEOUT_MASK;
val |= BITE_WDOG_TIMEOUT_8S;
rc = smblib_masked_write(chg, SNARL_BARK_BITE_WD_CFG_REG,
BITE_WDOG_DISABLE_CHARGING_CFG_BIT |
BARK_WDOG_TIMEOUT_MASK | BITE_WDOG_TIMEOUT_MASK,
val);
if (rc) {
pr_err("Couldn't configue WD config rc=%d\n", rc);
return rc;
}
/* enable WD BARK and enable it on plugin */
rc = smblib_masked_write(chg, WD_CFG_REG,
WATCHDOG_TRIGGER_AFP_EN_BIT |
WDOG_TIMER_EN_ON_PLUGIN_BIT |
BARK_WDOG_INT_EN_BIT,
WDOG_TIMER_EN_ON_PLUGIN_BIT |
BARK_WDOG_INT_EN_BIT);
if (rc) {
pr_err("Couldn't configue WD config rc=%d\n", rc);
return rc;
}
/* configure wipower watts */
rc = smb2_config_wipower_input_power(chip, chip->dt.wipower_max_uw);
if (rc < 0) {
dev_err(chg->dev, "Couldn't configure wipower rc=%d\n", rc);
return rc;
}
/* disable h/w autonomous parallel charging control */
rc = smblib_masked_write(chg, MISC_CFG_REG,
STAT_PARALLEL_1400MA_EN_CFG_BIT, 0);
if (rc < 0) {
dev_err(chg->dev,
"Couldn't disable h/w autonomous parallel control rc=%d\n",
rc);
return rc;
}
/*
* allow DRP.DFP time to exceed by tPDdebounce time.
*/
rc = smblib_masked_write(chg, TAPER_TIMER_SEL_CFG_REG,
TYPEC_DRP_DFP_TIME_CFG_BIT,
TYPEC_DRP_DFP_TIME_CFG_BIT);
if (rc < 0) {
dev_err(chg->dev, "Couldn't configure DRP.DFP time rc=%d\n",
rc);
return rc;
}
/* configure float charger options */
switch (chip->dt.float_option) {
case 1:
rc = smblib_masked_write(chg, USBIN_OPTIONS_2_CFG_REG,
FLOAT_OPTIONS_MASK, 0);
break;
case 2:
rc = smblib_masked_write(chg, USBIN_OPTIONS_2_CFG_REG,
FLOAT_OPTIONS_MASK, FORCE_FLOAT_SDP_CFG_BIT);
break;
case 3:
rc = smblib_masked_write(chg, USBIN_OPTIONS_2_CFG_REG,
FLOAT_OPTIONS_MASK, FLOAT_DIS_CHGING_CFG_BIT);
break;
case 4:
rc = smblib_masked_write(chg, USBIN_OPTIONS_2_CFG_REG,
FLOAT_OPTIONS_MASK, SUSPEND_FLOAT_CFG_BIT);
break;
default:
rc = 0;
break;
}
if (rc < 0) {
dev_err(chg->dev, "Couldn't configure float charger options rc=%d\n",
rc);
return rc;
}
rc = smblib_read(chg, USBIN_OPTIONS_2_CFG_REG, &chg->float_cfg);
if (rc < 0) {
dev_err(chg->dev, "Couldn't read float charger options rc=%d\n",
rc);
return rc;
}
switch (chip->dt.chg_inhibit_thr_mv) {
case 50:
rc = smblib_masked_write(chg, CHARGE_INHIBIT_THRESHOLD_CFG_REG,
CHARGE_INHIBIT_THRESHOLD_MASK,
CHARGE_INHIBIT_THRESHOLD_50MV);
break;
case 100:
rc = smblib_masked_write(chg, CHARGE_INHIBIT_THRESHOLD_CFG_REG,
CHARGE_INHIBIT_THRESHOLD_MASK,
CHARGE_INHIBIT_THRESHOLD_100MV);
break;
case 200:
rc = smblib_masked_write(chg, CHARGE_INHIBIT_THRESHOLD_CFG_REG,
CHARGE_INHIBIT_THRESHOLD_MASK,
CHARGE_INHIBIT_THRESHOLD_200MV);
break;
case 300:
rc = smblib_masked_write(chg, CHARGE_INHIBIT_THRESHOLD_CFG_REG,
CHARGE_INHIBIT_THRESHOLD_MASK,
CHARGE_INHIBIT_THRESHOLD_300MV);
break;
case 0:
rc = smblib_masked_write(chg, CHGR_CFG2_REG,
CHARGER_INHIBIT_BIT, 0);
default:
break;
}
if (rc < 0) {
dev_err(chg->dev, "Couldn't configure charge inhibit threshold rc=%d\n",
rc);
return rc;
}
if (chip->dt.auto_recharge_soc) {
rc = smblib_masked_write(chg, FG_UPDATE_CFG_2_SEL_REG,
SOC_LT_CHG_RECHARGE_THRESH_SEL_BIT |
VBT_LT_CHG_RECHARGE_THRESH_SEL_BIT,
VBT_LT_CHG_RECHARGE_THRESH_SEL_BIT);
if (rc < 0) {
dev_err(chg->dev, "Couldn't configure FG_UPDATE_CFG2_SEL_REG rc=%d\n",
rc);
return rc;
}
} else {
rc = smblib_masked_write(chg, FG_UPDATE_CFG_2_SEL_REG,
SOC_LT_CHG_RECHARGE_THRESH_SEL_BIT |
VBT_LT_CHG_RECHARGE_THRESH_SEL_BIT,
SOC_LT_CHG_RECHARGE_THRESH_SEL_BIT);
if (rc < 0) {
dev_err(chg->dev, "Couldn't configure FG_UPDATE_CFG2_SEL_REG rc=%d\n",
rc);
return rc;
}
}
if (chg->sw_jeita_enabled) {
rc = smblib_disable_hw_jeita(chg, true);
if (rc < 0) {
dev_err(chg->dev, "Couldn't set hw jeita rc=%d\n", rc);
return rc;
}
}
if (chg->disable_stat_sw_override) {
rc = smblib_masked_write(chg, STAT_CFG_REG,
STAT_SW_OVERRIDE_CFG_BIT, 0);
if (rc < 0) {
dev_err(chg->dev, "Couldn't disable STAT SW override rc=%d\n",
rc);
return rc;
}
}
return rc;
}
static int smb2_post_init(struct smb2 *chip)
{
struct smb_charger *chg = &chip->chg;
int rc;
u8 stat;
/* In case the usb path is suspended, we would have missed disabling
* the icl change interrupt because the interrupt could have been
* not requested
*/
rerun_election(chg->usb_icl_votable);
/* Force charger in Sink Only mode */
if (chg->ufp_only_mode) {
rc = smblib_read(chg, TYPE_C_INTRPT_ENB_SOFTWARE_CTRL_REG,
&stat);
if (rc < 0) {
dev_err(chg->dev,
"Couldn't read SOFTWARE_CTRL_REG rc=%d\n", rc);
return rc;
}
if (!(stat & UFP_EN_CMD_BIT)) {
/* configure charger in UFP only mode */
rc = smblib_force_ufp(chg);
if (rc < 0) {
dev_err(chg->dev,
"Couldn't force UFP mode rc=%d\n", rc);
return rc;
}
}
} else {
/* configure power role for dual-role */
rc = smblib_masked_write(chg,
TYPE_C_INTRPT_ENB_SOFTWARE_CTRL_REG,
TYPEC_POWER_ROLE_CMD_MASK, 0);
if (rc < 0) {
dev_err(chg->dev,
"Couldn't configure power role for DRP rc=%d\n",
rc);
return rc;
}
}
rerun_election(chg->usb_irq_enable_votable);
return 0;
}
static int smb2_chg_config_init(struct smb2 *chip)
{
struct smb_charger *chg = &chip->chg;
int subtype = (unsigned long)of_device_get_match_data(chg->dev);
switch (subtype) {
case PMI8998:
chip->chg.chg_param.smb_version = PMI8998;
chip->chg.wa_flags |= BOOST_BACK_WA | QC_AUTH_INTERRUPT_WA_BIT
| TYPEC_PBS_WA_BIT;
chg->wa_flags |= QC_CHARGER_DETECTION_WA_BIT;
chg->wa_flags |= TYPEC_CC2_REMOVAL_WA_BIT;
chg->chg_freq.freq_5V = 600;
chg->chg_freq.freq_6V_8V = 800;
chg->chg_freq.freq_9V = 1000;
chg->chg_freq.freq_12V = 1200;
chg->chg_freq.freq_removal = 1000;
chg->chg_freq.freq_below_otg_threshold = 2000;
chg->chg_freq.freq_above_otg_threshold = 800;
break;
case PM660:
chip->chg.chg_param.smb_version = PM660;
chip->chg.wa_flags |= BOOST_BACK_WA | OTG_WA | OV_IRQ_WA_BIT
| TYPEC_PBS_WA_BIT;
chg->param.freq_buck = pm660_params.freq_buck;
chg->param.freq_boost = pm660_params.freq_boost;
chg->chg_freq.freq_5V = 650;
chg->chg_freq.freq_6V_8V = 850;
chg->chg_freq.freq_9V = 1050;
chg->chg_freq.freq_12V = 1200;
chg->chg_freq.freq_removal = 1050;
chg->chg_freq.freq_below_otg_threshold = 1600;
chg->chg_freq.freq_above_otg_threshold = 800;
break;
default:
pr_err("PMIC subtype %d not supported\n", subtype);
return -EINVAL;
}
return 0;
}
/****************************
* DETERMINE INITIAL STATUS *
****************************/
static int smb2_determine_initial_status(struct smb2 *chip)
{
struct smb_irq_data irq_data = {chip, "determine-initial-status"};
struct smb_charger *chg = &chip->chg;
if (chg->iio_chan_list_fg_gen3)
smblib_suspend_on_debug_battery(chg);
smblib_handle_usb_plugin(0, &irq_data);
smblib_handle_usb_typec_change(0, &irq_data);
smblib_handle_usb_source_change(0, &irq_data);
smblib_handle_chg_state_change(0, &irq_data);
smblib_handle_icl_change(0, &irq_data);
smblib_handle_batt_temp_changed(0, &irq_data);
smblib_handle_wdog_bark(0, &irq_data);
return 0;
}
/**************************
* INTERRUPT REGISTRATION *
**************************/
static struct smb_irq_info smb2_irqs[] = {
/* CHARGER IRQs */
[CHG_ERROR_IRQ] = {
.name = "chg-error",
.handler = smblib_handle_debug,
},
[CHG_STATE_CHANGE_IRQ] = {
.name = "chg-state-change",
.handler = smblib_handle_chg_state_change,
.wake = true,
},
[STEP_CHG_STATE_CHANGE_IRQ] = {
.name = "step-chg-state-change",
.handler = NULL,
},
[STEP_CHG_SOC_UPDATE_FAIL_IRQ] = {
.name = "step-chg-soc-update-fail",
.handler = NULL,
},
[STEP_CHG_SOC_UPDATE_REQ_IRQ] = {
.name = "step-chg-soc-update-request",
.handler = NULL,
},
/* OTG IRQs */
[OTG_FAIL_IRQ] = {
.name = "otg-fail",
.handler = smblib_handle_debug,
},
[OTG_OVERCURRENT_IRQ] = {
.name = "otg-overcurrent",
.handler = smblib_handle_otg_overcurrent,
},
[OTG_OC_DIS_SW_STS_IRQ] = {
.name = "otg-oc-dis-sw-sts",
.handler = smblib_handle_debug,
},
[TESTMODE_CHANGE_DET_IRQ] = {
.name = "testmode-change-detect",
.handler = smblib_handle_debug,
},
/* BATTERY IRQs */
[BATT_TEMP_IRQ] = {
.name = "bat-temp",
.handler = smblib_handle_batt_temp_changed,
.wake = true,
},
[BATT_OCP_IRQ] = {
.name = "bat-ocp",
.handler = smblib_handle_batt_psy_changed,
},
[BATT_OV_IRQ] = {
.name = "bat-ov",
.handler = smblib_handle_batt_psy_changed,
},
[BATT_LOW_IRQ] = {
.name = "bat-low",
.handler = smblib_handle_batt_psy_changed,
},
[BATT_THERM_ID_MISS_IRQ] = {
.name = "bat-therm-or-id-missing",
.handler = smblib_handle_batt_psy_changed,
},
[BATT_TERM_MISS_IRQ] = {
.name = "bat-terminal-missing",
.handler = smblib_handle_batt_psy_changed,
},
/* USB INPUT IRQs */
[USBIN_COLLAPSE_IRQ] = {
.name = "usbin-collapse",
.handler = smblib_handle_debug,
},
[USBIN_LT_3P6V_IRQ] = {
.name = "usbin-lt-3p6v",
.handler = smblib_handle_debug,
},
[USBIN_UV_IRQ] = {
.name = "usbin-uv",
.handler = smblib_handle_usbin_uv,
},
[USBIN_OV_IRQ] = {
.name = "usbin-ov",
.handler = smblib_handle_debug,
},
[USBIN_PLUGIN_IRQ] = {
.name = "usbin-plugin",
.handler = smblib_handle_usb_plugin,
.wake = true,
},
[USBIN_SRC_CHANGE_IRQ] = {
.name = "usbin-src-change",
.handler = smblib_handle_usb_source_change,
.wake = true,
},
[USBIN_ICL_CHANGE_IRQ] = {
.name = "usbin-icl-change",
.handler = smblib_handle_icl_change,
.wake = true,
},
[TYPE_C_CHANGE_IRQ] = {
.name = "type-c-change",
.handler = smblib_handle_usb_typec_change,
.wake = true,
},
/* DC INPUT IRQs */
[DCIN_COLLAPSE_IRQ] = {
.name = "dcin-collapse",
.handler = smblib_handle_debug,
},
[DCIN_LT_3P6V_IRQ] = {
.name = "dcin-lt-3p6v",
.handler = smblib_handle_debug,
},
[DCIN_UV_IRQ] = {
.name = "dcin-uv",
.handler = smblib_handle_debug,
},
[DCIN_OV_IRQ] = {
.name = "dcin-ov",
.handler = smblib_handle_debug,
},
[DCIN_PLUGIN_IRQ] = {
.name = "dcin-plugin",
.handler = smblib_handle_dc_plugin,
.wake = true,
},
[DIV2_EN_DG_IRQ] = {
.name = "div2-en-dg",
.handler = smblib_handle_debug,
},
[DCIN_ICL_CHANGE_IRQ] = {
.name = "dcin-icl-change",
.handler = smblib_handle_debug,
},
/* MISCELLANEOUS IRQs */
[WDOG_SNARL_IRQ] = {
.name = "wdog-snarl",
.handler = NULL,
},
[WDOG_BARK_IRQ] = {
.name = "wdog-bark",
.handler = smblib_handle_wdog_bark,
.wake = true,
},
[AICL_FAIL_IRQ] = {
.name = "aicl-fail",
.handler = smblib_handle_debug,
},
[AICL_DONE_IRQ] = {
.name = "aicl-done",
.handler = smblib_handle_debug,
},
[HIGH_DUTY_CYCLE_IRQ] = {
.name = "high-duty-cycle",
.handler = smblib_handle_high_duty_cycle,
.wake = true,
},
[INPUT_CURRENT_LIMIT_IRQ] = {
.name = "input-current-limiting",
.handler = smblib_handle_debug,
},
[TEMPERATURE_CHANGE_IRQ] = {
.name = "temperature-change",
.handler = smblib_handle_debug,
},
[SWITCH_POWER_OK_IRQ] = {
.name = "switcher-power-ok",
.handler = smblib_handle_switcher_power_ok,
.wake = true,
.storm_data = {true, 1000, 8},
},
};
static int smb2_get_irq_index_byname(const char *irq_name)
{
int i;
for (i = 0; i < ARRAY_SIZE(smb2_irqs); i++) {
if (strcmp(smb2_irqs[i].name, irq_name) == 0)
return i;
}
return -ENOENT;
}
static int smb2_request_interrupt(struct smb2 *chip,
struct device_node *node, const char *irq_name)
{
struct smb_charger *chg = &chip->chg;
int rc, irq, irq_index;
struct smb_irq_data *irq_data;
irq = of_irq_get_byname(node, irq_name);
if (irq < 0) {
pr_err("Couldn't get irq %s byname\n", irq_name);
return irq;
}
irq_index = smb2_get_irq_index_byname(irq_name);
if (irq_index < 0) {
pr_err("%s is not a defined irq\n", irq_name);
return irq_index;
}
if (!smb2_irqs[irq_index].handler)
return 0;
irq_data = devm_kzalloc(chg->dev, sizeof(*irq_data), GFP_KERNEL);
if (!irq_data)
return -ENOMEM;
irq_data->parent_data = chip;
irq_data->name = irq_name;
irq_data->storm_data = smb2_irqs[irq_index].storm_data;
mutex_init(&irq_data->storm_data.storm_lock);
rc = devm_request_threaded_irq(chg->dev, irq, NULL,
smb2_irqs[irq_index].handler,
IRQF_ONESHOT, irq_name, irq_data);
if (rc < 0) {
pr_err("Couldn't request irq %d\n", irq);
return rc;
}
smb2_irqs[irq_index].irq = irq;
smb2_irqs[irq_index].irq_data = irq_data;
if (smb2_irqs[irq_index].wake)
enable_irq_wake(irq);
return rc;
}
static int smb2_request_interrupts(struct smb2 *chip)
{
struct smb_charger *chg = &chip->chg;
struct device_node *node = chg->dev->of_node;
struct device_node *child;
int rc = 0;
const char *name;
struct property *prop;
for_each_available_child_of_node(node, child) {
of_property_for_each_string(child, "interrupt-names",
prop, name) {
rc = smb2_request_interrupt(chip, child, name);
if (rc < 0)
return rc;
}
}
if (chg->irq_info[USBIN_ICL_CHANGE_IRQ].irq)
chg->usb_icl_change_irq_enabled = true;
return rc;
}
static void smb2_free_interrupts(struct smb_charger *chg)
{
int i;
for (i = 0; i < ARRAY_SIZE(smb2_irqs); i++) {
if (smb2_irqs[i].irq > 0) {
if (smb2_irqs[i].wake)
disable_irq_wake(smb2_irqs[i].irq);
}
}
}
static void smb2_disable_interrupts(struct smb_charger *chg)
{
int i;
for (i = 0; i < ARRAY_SIZE(smb2_irqs); i++) {
if (smb2_irqs[i].irq > 0)
disable_irq(smb2_irqs[i].irq);
}
}
#if defined(CONFIG_DEBUG_FS)
static int force_batt_psy_update_write(void *data, u64 val)
{
struct smb_charger *chg = data;
power_supply_changed(chg->batt_psy);
return 0;
}
DEFINE_DEBUGFS_ATTRIBUTE(force_batt_psy_update_ops, NULL,
force_batt_psy_update_write, "0x%02llx\n");
static int force_usb_psy_update_write(void *data, u64 val)
{
struct smb_charger *chg = data;
power_supply_changed(chg->usb_psy);
return 0;
}
DEFINE_DEBUGFS_ATTRIBUTE(force_usb_psy_update_ops, NULL,
force_usb_psy_update_write, "0x%02llx\n");
static int force_dc_psy_update_write(void *data, u64 val)
{
struct smb_charger *chg = data;
power_supply_changed(chg->dc_psy);
return 0;
}
DEFINE_DEBUGFS_ATTRIBUTE(force_dc_psy_update_ops, NULL,
force_dc_psy_update_write, "0x%02llx\n");
static void smb2_create_debugfs(struct smb2 *chip)
{
struct dentry *file;
chip->dfs_root = debugfs_create_dir("charger", NULL);
if (IS_ERR_OR_NULL(chip->dfs_root)) {
pr_err("Couldn't create charger debugfs rc=%ld\n",
(long)chip->dfs_root);
return;
}
file = debugfs_create_file("force_batt_psy_update", 0600,
chip->dfs_root, chip, &force_batt_psy_update_ops);
if (IS_ERR_OR_NULL(file))
pr_err("Couldn't create force_batt_psy_update file rc=%ld\n",
(long)file);
file = debugfs_create_file("force_usb_psy_update", 0600,
chip->dfs_root, chip, &force_usb_psy_update_ops);
if (IS_ERR_OR_NULL(file))
pr_err("Couldn't create force_usb_psy_update file rc=%ld\n",
(long)file);
file = debugfs_create_file("force_dc_psy_update", 0600,
chip->dfs_root, chip, &force_dc_psy_update_ops);
if (IS_ERR_OR_NULL(file))
pr_err("Couldn't create force_dc_psy_update file rc=%ld\n",
(long)file);
debugfs_create_u32("debug_mask", 0600, chip->dfs_root,
&__debug_mask);
}
#else
static void smb2_create_debugfs(struct smb2 *chip)
{}
#endif
static int smb2_of_xlate(struct iio_dev *indio_dev,
const struct of_phandle_args *iiospec)
{
struct smb2 *iio_chip = iio_priv(indio_dev);
struct iio_chan_spec *iio_chan = iio_chip->iio_chan_ids;
int i;
for (i = 0; i < iio_chip->nchannels; i++, iio_chan++)
if (iio_chan->channel == iiospec->args[0])
return i;
return -EINVAL;
}
static int smb2_read_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan, int *val, int *val2,
long mask)
{
struct smb2 *iio_chip = iio_priv(indio_dev);
struct smb_charger *chg = &iio_chip->chg;
return smb2_iio_get_prop(chg, chan->channel, val);
}
static int smb2_write_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan, int val, int val2,
long mask)
{
struct smb2 *iio_chip = iio_priv(indio_dev);
struct smb_charger *chg = &iio_chip->chg;
return smb2_iio_set_prop(chg, chan->channel, val);
}
static const struct iio_info smb2_iio_info = {
.read_raw = smb2_read_raw,
.write_raw = smb2_write_raw,
.of_xlate = smb2_of_xlate,
};
static int smb2_direct_iio_read(struct device *dev, int iio_chan_no, int *val)
{
struct smb2 *chip = dev_get_drvdata(dev);
struct smb_charger *chg = &chip->chg;
int rc;
rc = smb2_iio_get_prop(chg, iio_chan_no, val);
return (rc < 0) ? rc : 0;
}
static int smb2_direct_iio_write(struct device *dev, int iio_chan_no, int val)
{
struct smb2 *chip = dev_get_drvdata(dev);
struct smb_charger *chg = &chip->chg;
return smb2_iio_set_prop(chg, iio_chan_no, val);
}
static int smb2_iio_init(struct smb2 *chip, struct platform_device *pdev,
struct iio_dev *indio_dev)
{
struct iio_chan_spec *iio_chan;
int i, rc;
for (i = 0; i < chip->nchannels; i++) {
chip->iio_chans[i].indio_dev = indio_dev;
iio_chan = &chip->iio_chan_ids[i];
chip->iio_chans[i].channel = iio_chan;
iio_chan->channel = smb2_chans_pmic[i].channel_num;
iio_chan->datasheet_name = smb2_chans_pmic[i].datasheet_name;
iio_chan->extend_name = smb2_chans_pmic[i].datasheet_name;
iio_chan->info_mask_separate = smb2_chans_pmic[i].info_mask;
iio_chan->type = smb2_chans_pmic[i].type;
iio_chan->address = i;
}
indio_dev->dev.parent = &pdev->dev;
indio_dev->dev.of_node = pdev->dev.of_node;
indio_dev->name = pdev->name;
indio_dev->modes = INDIO_DIRECT_MODE;
indio_dev->channels = chip->iio_chan_ids;
indio_dev->num_channels = chip->nchannels;
rc = devm_iio_device_register(&pdev->dev, indio_dev);
if (rc)
pr_err("iio device register failed rc=%d\n", rc);
return rc;
}
int smb2_extcon_init(struct smb_charger *chg)
{
int rc;
/* extcon registration */
chg->extcon = devm_extcon_dev_allocate(chg->dev, smblib_extcon_cable);
if (IS_ERR(chg->extcon)) {
rc = PTR_ERR(chg->extcon);
dev_err(chg->dev, "failed to allocate extcon device rc=%d\n",
rc);
return rc;
}
rc = devm_extcon_dev_register(chg->dev, chg->extcon);
if (rc < 0) {
dev_err(chg->dev, "failed to register extcon device rc=%d\n",
rc);
return rc;
}
return rc;
}
static int smb2_probe(struct platform_device *pdev)
{
struct smb2 *chip;
struct smb_charger *chg;
struct iio_dev *indio_dev;
int rc = 0;
union power_supply_propval val;
int usb_present, batt_present, batt_health, batt_charge_type;
indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*chip));
if (!indio_dev)
return -ENOMEM;
indio_dev->info = &smb2_iio_info;
chip = iio_priv(indio_dev);
chip->nchannels = ARRAY_SIZE(smb2_chans_pmic);
chip->iio_chans = devm_kcalloc(&pdev->dev, chip->nchannels,
sizeof(*chip->iio_chans), GFP_KERNEL);
if (!chip->iio_chans)
return -ENOMEM;
chip->iio_chan_ids = devm_kcalloc(&pdev->dev, chip->nchannels,
sizeof(*chip->iio_chan_ids), GFP_KERNEL);
if (!chip->iio_chan_ids)
return -ENOMEM;
chg = &chip->chg;
chg->iio_chans = chip->iio_chans;
chg->iio_chan_list_fg_gen3 = NULL;
chg->dev = &pdev->dev;
chg->param = v1_params;
chg->debug_mask = &__debug_mask;
chg->try_sink_enabled = &__try_sink_enabled;
chg->weak_chg_icl_ua = &__weak_chg_icl_ua;
chg->mode = PARALLEL_MASTER;
chg->irq_info = smb2_irqs;
chg->die_health = -EINVAL;
chg->name = "PMI";
chg->audio_headset_drp_wait_ms = &__audio_headset_drp_wait_ms;
chg->regmap = dev_get_regmap(chg->dev->parent, NULL);
if (!chg->regmap) {
pr_err("parent regmap is missing\n");
return -EINVAL;
}
rc = smb2_iio_init(chip, pdev, indio_dev);
if (rc < 0)
return rc;
rc = smb2_chg_config_init(chip);
if (rc < 0) {
if (rc != -EPROBE_DEFER)
pr_err("Couldn't setup chg_config rc=%d\n", rc);
return rc;
}
rc = smb2_parse_dt(chip);
if (rc < 0) {
pr_err("Couldn't parse device tree rc=%d\n", rc);
goto cleanup;
}
/* set driver data before resources request it */
platform_set_drvdata(pdev, chip);
chg->chg_param.iio_read = smb2_direct_iio_read;
chg->chg_param.iio_write = smb2_direct_iio_write;
rc = smblib_init(chg);
if (rc < 0) {
pr_err("Smblib_init failed rc=%d\n", rc);
goto cleanup;
}
rc = smb2_init_vbus_regulator(chip);
if (rc < 0) {
pr_err("Couldn't initialize vbus regulator rc=%d\n",
rc);
goto cleanup;
}
rc = smb2_init_vconn_regulator(chip);
if (rc < 0) {
pr_err("Couldn't initialize vconn regulator rc=%d\n",
rc);
goto cleanup;
}
rc = smb2_extcon_init(chg);
if (rc < 0)
goto cleanup;
rc = smb2_init_hw(chip);
if (rc < 0) {
pr_err("Couldn't initialize hardware rc=%d\n", rc);
goto cleanup;
}
rc = smb2_init_dc_psy(chip);
if (rc < 0) {
pr_err("Couldn't initialize dc psy rc=%d\n", rc);
goto cleanup;
}
rc = smb2_init_usb_psy(chip);
if (rc < 0) {
pr_err("Couldn't initialize usb psy rc=%d\n", rc);
goto cleanup;
}
rc = smb2_init_usb_port_psy(chip);
if (rc < 0) {
pr_err("Couldn't initialize usb pc_port psy rc=%d\n", rc);
goto cleanup;
}
rc = smb2_init_batt_psy(chip);
if (rc < 0) {
pr_err("Couldn't initialize batt psy rc=%d\n", rc);
goto cleanup;
}
rc = smb2_determine_initial_status(chip);
if (rc < 0) {
pr_err("Couldn't determine initial status rc=%d\n",
rc);
goto cleanup;
}
rc = smb2_request_interrupts(chip);
if (rc < 0) {
pr_err("Couldn't request interrupts rc=%d\n", rc);
goto cleanup;
}
rc = smb2_post_init(chip);
if (rc < 0) {
pr_err("Failed in post init rc=%d\n", rc);
goto cleanup;
}
smb2_create_debugfs(chip);
rc = smblib_get_prop_usb_present(chg, &val);
if (rc < 0) {
pr_err("Couldn't get usb present rc=%d\n", rc);
goto cleanup;
}
usb_present = val.intval;
rc = sysfs_create_groups(&chg->dev->kobj, smb2_groups);
if (rc < 0) {
pr_err("Failed to create sysfs files rc=%d\n", rc);
goto cleanup;
}
rc = smblib_get_prop_batt_present(chg, &val);
if (rc < 0) {
pr_err("Couldn't get batt present rc=%d\n", rc);
goto cleanup;
}
batt_present = val.intval;
rc = smblib_get_prop_batt_health(chg, &val);
if (rc < 0) {
pr_err("Couldn't get batt health rc=%d\n", rc);
val.intval = POWER_SUPPLY_HEALTH_UNKNOWN;
}
batt_health = val.intval;
rc = smblib_get_prop_batt_charge_type(chg, &val);
if (rc < 0) {
pr_err("Couldn't get batt charge type rc=%d\n", rc);
goto cleanup;
}
batt_charge_type = val.intval;
device_init_wakeup(chg->dev, true);
pr_info("QPNP SMB2 probed successfully usb:present=%d type=%d batt:present = %d health = %d charge = %d\n",
usb_present, chg->real_charger_type,
batt_present, batt_health, batt_charge_type);
return rc;
cleanup:
smb2_free_interrupts(chg);
if (chg->batt_psy)
power_supply_unregister(chg->batt_psy);
if (chg->usb_psy)
power_supply_unregister(chg->usb_psy);
if (chg->usb_port_psy)
power_supply_unregister(chg->usb_port_psy);
if (chg->dc_psy)
power_supply_unregister(chg->dc_psy);
smblib_deinit(chg);
platform_set_drvdata(pdev, NULL);
return rc;
}
static int smb2_remove(struct platform_device *pdev)
{
struct smb2 *chip = platform_get_drvdata(pdev);
struct smb_charger *chg = &chip->chg;
power_supply_unregister(chg->batt_psy);
power_supply_unregister(chg->usb_psy);
power_supply_unregister(chg->usb_port_psy);
regulator_unregister(chg->vconn_vreg->rdev);
regulator_unregister(chg->vbus_vreg->rdev);
sysfs_remove_groups(&chg->dev->kobj, smb2_groups);
debugfs_remove_recursive(chip->dfs_root);
platform_set_drvdata(pdev, NULL);
return 0;
}
static void smb2_shutdown(struct platform_device *pdev)
{
struct smb2 *chip = platform_get_drvdata(pdev);
struct smb_charger *chg = &chip->chg;
/* disable all interrupts */
smb2_disable_interrupts(chg);
if (!chg->ufp_only_mode)
/* configure power role for UFP */
smblib_masked_write(chg, TYPE_C_INTRPT_ENB_SOFTWARE_CTRL_REG,
TYPEC_POWER_ROLE_CMD_MASK, UFP_EN_CMD_BIT);
/* force HVDCP to 5V */
smblib_masked_write(chg, USBIN_OPTIONS_1_CFG_REG,
HVDCP_AUTONOMOUS_MODE_EN_CFG_BIT, 0);
smblib_write(chg, CMD_HVDCP_2_REG, FORCE_5V_BIT);
/* force enable APSD */
smblib_masked_write(chg, USBIN_OPTIONS_1_CFG_REG,
AUTO_SRC_DETECT_BIT, AUTO_SRC_DETECT_BIT);
}
static const struct of_device_id match_table[] = {
{ .compatible = "qcom,pmi8998-smb2",
.data = (void *)PMI8998,
},
{ .compatible = "qcom,pm660-smb2",
.data = (void *)PM660,
},
{ },
};
static struct platform_driver smb2_driver = {
.driver = {
.name = "qcom,qpnp-smb2",
.of_match_table = match_table,
},
.probe = smb2_probe,
.remove = smb2_remove,
.shutdown = smb2_shutdown,
};
module_platform_driver(smb2_driver);
MODULE_DESCRIPTION("QPNP SMB2 Charger Driver");
MODULE_LICENSE("GPL v2");
Reference in a new issue View git blame Copy permalink