// 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include "smb-reg.h" #include "smb-lib.h" #include "smb2-iio.h" #include "storm-watch.h" #include #include #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");