// SPDX-License-Identifier: GPL-2.0-only /* * Copyright (c) 2020-2021 The Linux Foundation. All rights reserved. * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include "battery-profile-loader.h" #include "smblite-lib.h" #include "smblite-reg.h" #include "step-chg-jeita.h" #include "storm-watch.h" #include "schgm-flashlite.h" #include "smb5-iio.h" #define smblite_lib_err(chg, fmt, ...) \ pr_err("%s: %s: " fmt, chg->name, \ __func__, ##__VA_ARGS__) \ #define smblite_lib_dbg(chg, reason, fmt, ...) \ do { \ if (*chg->debug_mask & (reason)) \ pr_info("%s: %s: " fmt, chg->name, \ __func__, ##__VA_ARGS__); \ else \ pr_debug("%s: %s: " fmt, chg->name, \ __func__, ##__VA_ARGS__); \ } while (0) #define typec_rp_med_high(chg, typec_mode) \ ((typec_mode == QTI_POWER_SUPPLY_TYPEC_SOURCE_MEDIUM \ || typec_mode == QTI_POWER_SUPPLY_TYPEC_SOURCE_HIGH) \ && (!chg->typec_legacy || chg->typec_legacy_use_rp_icl)) static void update_sw_icl_max(struct smb_charger *chg, int type); static int smblite_lib_get_prop_typec_mode(struct smb_charger *chg); #define MIN_ADDRESS_RANGE 0x100 int smblite_lib_read(struct smb_charger *chg, u16 addr, u8 *val) { unsigned int value; int rc = 0; /* Ignore address range below MIN_ADDRESS_RANGE */ if (addr < MIN_ADDRESS_RANGE) { pr_debug("Invalid addr = 0x%x\n", addr); return 0; } rc = regmap_read(chg->regmap, addr, &value); if (rc >= 0) *val = (u8)value; return rc; } int smblite_lib_batch_read(struct smb_charger *chg, u16 addr, u8 *val, int count) { /* Ignore address range below MIN_ADDRESS_RANGE */ if (addr < MIN_ADDRESS_RANGE) { pr_debug("Invalid addr = 0x%x\n", addr); return 0; } return regmap_bulk_read(chg->regmap, addr, val, count); } int smblite_lib_write(struct smb_charger *chg, u16 addr, u8 val) { /* Ignore address range below MIN_ADDRESS_RANGE */ if (addr < MIN_ADDRESS_RANGE) { pr_debug("Invalid addr = 0x%x\n", addr); return 0; } return regmap_write(chg->regmap, addr, val); } int smblite_lib_batch_write(struct smb_charger *chg, u16 addr, u8 *val, int count) { /* Ignore address range below MIN_ADDRESS_RANGE */ if (addr < MIN_ADDRESS_RANGE) { pr_debug("Invalid addr = 0x%x\n", addr); return 0; } return regmap_bulk_write(chg->regmap, addr, val, count); } int smblite_lib_masked_write(struct smb_charger *chg, u16 addr, u8 mask, u8 val) { /* Ignore address range below MIN_ADDRESS_RANGE */ if (addr < MIN_ADDRESS_RANGE) { pr_debug("Invalid addr = 0x%x\n", addr); return 0; } return regmap_update_bits(chg->regmap, addr, mask, val); } int smblite_lib_get_iio_channel(struct smb_charger *chg, const char *propname, struct iio_channel **chan) { int rc = 0; rc = of_property_match_string(chg->dev->of_node, "io-channel-names", propname); if (rc < 0) return 0; *chan = iio_channel_get(chg->dev, propname); if (IS_ERR(*chan)) { rc = PTR_ERR(*chan); if (rc != -EPROBE_DEFER) smblite_lib_err(chg, "%s channel unavailable, %d\n", propname, rc); *chan = NULL; } return rc; } #define DIV_FACTOR_MICRO_V_I 1 #define DIV_FACTOR_MILI_V_I 1000 #define DIV_FACTOR_DECIDEGC 100 int smblite_lib_icl_override(struct smb_charger *chg, enum icl_override_mode mode) { int rc; u8 usb51_mode, icl_override; switch (mode) { case SW_OVERRIDE_USB51_MODE: usb51_mode = 0; icl_override = ICL_OVERRIDE_BIT; break; case SW_OVERRIDE_HC_MODE: usb51_mode = USBIN_MODE_CHG_BIT; icl_override = ICL_OVERRIDE_BIT; break; case HW_AUTO_MODE: default: usb51_mode = USBIN_MODE_CHG_BIT; icl_override = 0; break; } rc = smblite_lib_masked_write(chg, USBIN_ICL_OPTIONS_REG(chg->base), USBIN_MODE_CHG_BIT, usb51_mode); if (rc < 0) { smblite_lib_err(chg, "Couldn't set USBIN_ICL_OPTIONS rc=%d\n", rc); return rc; } rc = smblite_lib_masked_write(chg, CMD_ICL_OVERRIDE_REG(chg->base), ICL_OVERRIDE_BIT, icl_override); if (rc < 0) { smblite_lib_err(chg, "Couldn't override ICL rc=%d\n", rc); return rc; } return rc; } static void smblite_lib_notify_extcon_props(struct smb_charger *chg, int id) { union extcon_property_value val; int prop_val; if (chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_TYPEC) { smblite_lib_get_prop_typec_cc_orientation(chg, &prop_val); val.intval = ((prop_val == 2) ? 1 : 0); extcon_set_property(chg->extcon, id, EXTCON_PROP_USB_TYPEC_POLARITY, val); val.intval = true; extcon_set_property(chg->extcon, id, EXTCON_PROP_USB_SS, val); } else if (chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_MICRO_USB) { /* * To send extcon notification for SS mode for 10pin * Micro AB 3.0 connector type. */ if (chg->uusb_ss_mode_extcon_enable) val.intval = true; else val.intval = false; extcon_set_property(chg->extcon, id, EXTCON_PROP_USB_SS, val); } } static void smblite_lib_notify_device_mode(struct smb_charger *chg, bool enable) { if (enable) smblite_lib_notify_extcon_props(chg, EXTCON_USB); extcon_set_state_sync(chg->extcon, EXTCON_USB, enable); } #define VBOOST_5P00V 0x03 static void smblite_lib_notify_usb_host(struct smb_charger *chg, bool enable) { int rc = 0; /* LDO mode doesn't support OTG */ if (chg->ldo_mode) return; if (enable) { smblite_lib_dbg(chg, PR_OTG, "enabling VBUS in OTG mode\n"); rc = smblite_lib_masked_write(chg, DCDC_CMD_OTG_REG(chg->base), OTG_EN_BIT, OTG_EN_BIT); if (rc < 0) { smblite_lib_err(chg, "Couldn't enable VBUS in OTG mode rc=%d\n", rc); return; } rc = smblite_lib_masked_write(chg, DCDC_BST_VREG_SEL(chg->base), VBOOST_MASK, VBOOST_5P00V); if (rc < 0) { smblite_lib_err(chg, "Couldn't write BST_VREG_SEL rc=%d\n", rc); return; } smblite_lib_notify_extcon_props(chg, EXTCON_USB_HOST); } else { smblite_lib_dbg(chg, PR_OTG, "disabling VBUS in OTG mode\n"); rc = smblite_lib_masked_write(chg, DCDC_CMD_OTG_REG(chg->base), OTG_EN_BIT, 0); if (rc < 0) { smblite_lib_err(chg, "Couldn't disable VBUS in OTG mode rc=%d\n", rc); return; } } extcon_set_state_sync(chg->extcon, EXTCON_USB_HOST, enable); chg->otg_present = enable; } /******************** * REGISTER GETTERS * ********************/ int smblite_lib_get_charge_param(struct smb_charger *chg, struct smb_chg_param *param, int *val_u) { int rc = 0; u8 val_raw; rc = smblite_lib_read(chg, param->reg, &val_raw); if (rc < 0) { smblite_lib_err(chg, "%s: Couldn't read from 0x%04x rc=%d\n", param->name, param->reg, rc); return rc; } if (param->get_proc) *val_u = param->get_proc(param, val_raw); else *val_u = val_raw * param->step_u + param->min_u; smblite_lib_dbg(chg, PR_REGISTER, "%s = %d (0x%02x)\n", param->name, *val_u, val_raw); return rc; } #define INPUT_NOT_PRESENT 0 #define INPUT_PRESENT_USB BIT(1) static int smblite_lib_is_input_present(struct smb_charger *chg, int *present) { int rc; union power_supply_propval pval = {0, }; *present = INPUT_NOT_PRESENT; rc = smblite_lib_get_prop_usb_present(chg, &pval); if (rc < 0) { pr_err("Couldn't get usb presence status rc=%d\n", rc); return rc; } *present |= pval.intval ? INPUT_PRESENT_USB : INPUT_NOT_PRESENT; return 0; } /******************** * REGISTER SETTERS * ********************/ int smblite_lib_set_charge_param(struct smb_charger *chg, struct smb_chg_param *param, int val_u) { int rc = 0; u8 val_raw; if (param->set_proc) { rc = param->set_proc(param, val_u, &val_raw); if (rc < 0) return -EINVAL; } else { if (val_u > param->max_u || val_u < param->min_u) smblite_lib_dbg(chg, PR_MISC, "%s: %d is out of range [%d, %d]\n", param->name, val_u, param->min_u, param->max_u); if (val_u > param->max_u) val_u = param->max_u; if (val_u < param->min_u) val_u = param->min_u; val_raw = (val_u - param->min_u) / param->step_u; } rc = smblite_lib_write(chg, param->reg, val_raw); if (rc < 0) { smblite_lib_err(chg, "%s: Couldn't write 0x%02x to 0x%04x rc=%d\n", param->name, val_raw, param->reg, rc); return rc; } smblite_lib_dbg(chg, PR_REGISTER, "%s = %d (0x%02x)\n", param->name, val_u, val_raw); return rc; } int smblite_lib_set_usb_suspend(struct smb_charger *chg, bool suspend) { int rc = 0; if (suspend) vote(chg->icl_irq_disable_votable, USB_SUSPEND_VOTER, true, 0); rc = smblite_lib_masked_write(chg, USBIN_INPUT_SUSPEND_REG(chg->base), USBIN_SUSPEND_BIT, suspend ? USBIN_SUSPEND_BIT : 0); if (rc < 0) smblite_lib_err(chg, "Couldn't write %s to USBIN_SUSPEND_BIT rc=%d\n", suspend ? "suspend" : "resume", rc); if (!suspend) vote(chg->icl_irq_disable_votable, USB_SUSPEND_VOTER, false, 0); return rc; } /******************** * HELPER FUNCTIONS * ********************/ /* QG/FG channels */ static const char * const smblite_lib_qg_ext_iio_chan[] = { [SMB5_QG_DEBUG_BATTERY] = "debug_battery", [SMB5_QG_CAPACITY] = "capacity", [SMB5_QG_CURRENT_NOW] = "current_now", [SMB5_QG_VOLTAGE_NOW] = "voltage_now", [SMB5_QG_VOLTAGE_MAX] = "voltage_max", [SMB5_QG_CHARGE_FULL] = "charge_full", [SMB5_QG_RESISTANCE_ID] = "resistance_id", [SMB5_QG_TEMP] = "temp", [SMB5_QG_CHARGE_COUNTER] = "charge_counter", [SMB5_QG_CYCLE_COUNT] = "cycle_count", [SMB5_QG_CHARGE_FULL_DESIGN] = "charge_full_design", [SMB5_QG_TIME_TO_FULL_NOW] = "time_to_full_now", }; int smblite_lib_get_prop_from_bms(struct smb_charger *chg, int channel, int *val) { int rc; if (chg->is_fg_remote) { rc = remote_bms_get_prop(channel, val, BMS_GLINK); if ((rc < 0) && (rc != -EAGAIN)) smblite_lib_err(chg, "Couldn't get prop from remote bms, rc = %d", rc); } else { if (IS_ERR_OR_NULL(chg->iio_chan_list_qg)) return -ENODEV; rc = iio_read_channel_processed(chg->iio_chan_list_qg[channel], val); } return rc < 0 ? rc : 0; } enum chg_type { UNKNOWN, SDP, CDP, DCP, OCP, FLOAT, MAX_TYPES }; static const struct apsd_result smblite_apsd_results[] = { [UNKNOWN] = { .name = "UNKNOWN", .bit = 0, .val = POWER_SUPPLY_TYPE_UNKNOWN }, [SDP] = { .name = "SDP", .bit = SDP_CHARGER_BIT, .val = POWER_SUPPLY_TYPE_USB }, [CDP] = { .name = "CDP", .bit = CDP_CHARGER_BIT, .val = POWER_SUPPLY_TYPE_USB_CDP }, [DCP] = { .name = "DCP", .bit = DCP_CHARGER_BIT, .val = POWER_SUPPLY_TYPE_USB_DCP }, [OCP] = { .name = "OCP", .bit = OCP_CHARGER_BIT, .val = POWER_SUPPLY_TYPE_USB_DCP }, [FLOAT] = { .name = "FLOAT", .bit = FLOAT_CHARGER_BIT, .val = QTI_POWER_SUPPLY_TYPE_USB_FLOAT }, }; const struct apsd_result *smblite_lib_get_apsd_result(struct smb_charger *chg) { int rc, i; u8 apsd_stat; const struct apsd_result *result = &smblite_apsd_results[UNKNOWN]; rc = smblite_lib_read(chg, APSD_STATUS_REG(chg->base), &apsd_stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read APSD_STATUS rc=%d\n", rc); return result; } smblite_lib_dbg(chg, PR_REGISTER, "APSD_STATUS = 0x%02x\n", apsd_stat); if (!(apsd_stat & APSD_DTC_STATUS_DONE_BIT)) return result; rc = smblite_lib_read(chg, APSD_RESULT_STATUS_REG(chg->base), &apsd_stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read APSD_RESULT_STATUS rc=%d\n", rc); return result; } apsd_stat &= APSD_RESULT_STATUS_MASK; for (i = 0; i < ARRAY_SIZE(smblite_apsd_results); i++) { if (smblite_apsd_results[i].bit == apsd_stat) result = &smblite_apsd_results[i]; } /* Report HVDCP Adapter as DCP.*/ if (apsd_stat & QC_3P0_BIT) result = &smblite_apsd_results[DCP]; return result; } static const struct apsd_result *smblite_lib_update_usb_type(struct smb_charger *chg, enum power_supply_type type) { const struct apsd_result *apsd_result = smblite_lib_get_apsd_result(chg); if (apsd_result->val == POWER_SUPPLY_TYPE_UNKNOWN) chg->real_charger_type = type; /* * Update real charger type only if its not FLOAT * detected as SDP */ if (apsd_result->val != POWER_SUPPLY_TYPE_UNKNOWN && !(apsd_result->val == QTI_POWER_SUPPLY_TYPE_USB_FLOAT && chg->real_charger_type == POWER_SUPPLY_TYPE_USB)) chg->real_charger_type = apsd_result->val; smblite_update_usb_desc(chg); smblite_lib_dbg(chg, PR_MISC, "APSD=%s, real_charger_type =%d\n", apsd_result->name, chg->real_charger_type); return apsd_result; } static int smblite_lib_notifier_call(struct notifier_block *nb, unsigned long ev, void *v) { struct power_supply *psy = v; struct smb_charger *chg = container_of(nb, struct smb_charger, nb); if (!strcmp(psy->desc->name, "bms")) { if (ev == PSY_EVENT_PROP_CHANGED) schedule_work(&chg->bms_update_work); } if (chg->jeita_configured == JEITA_CFG_NONE) schedule_work(&chg->jeita_update_work); return NOTIFY_OK; } static int smblite_lib_register_notifier(struct smb_charger *chg) { int rc; chg->nb.notifier_call = smblite_lib_notifier_call; rc = power_supply_reg_notifier(&chg->nb); if (rc < 0) { smblite_lib_err(chg, "Couldn't register psy notifier rc = %d\n", rc); return rc; } return 0; } bool is_concurrent_mode_supported(struct smb_charger *chg) { return (chg->concurrent_mode_supported && chg->subtype == PM5100); } static int smblite_lib_concurrent_mode_config(struct smb_charger *chg, bool enable) { int rc; if (!is_concurrent_mode_supported(chg)) return 0; rc = smblite_lib_masked_write(chg, CONCURRENT_MODE_CFG_REG(chg->base), CONCURRENT_MODE_EN_BIT, !!enable); if (rc < 0) smblite_lib_err(chg, "Failed to write CONCURRENT_MODE_CFG_REG rc=%d\n", rc); if (!enable) { /* Remove usb_icl_vote when concurrency mode is disabled */ rc = vote(chg->usb_icl_votable, CONCURRENT_MODE_VOTER, false, 0); if (rc < 0) smblite_lib_err(chg, "Failed to vote on ICL rc=%d\n", rc); /* Remove chg_disable_vote when concurrency mode is disabled */ rc = vote(chg->chg_disable_votable, CONCURRENT_MODE_VOTER, false, 0); if (rc < 0) smblite_lib_err(chg, "Failed to vote on ICL rc=%d\n", rc); } return rc; } static void smblite_lib_uusb_removal(struct smb_charger *chg) { int rc; struct smb_irq_data *data; struct storm_watch *wdata; cancel_delayed_work_sync(&chg->pl_enable_work); if (chg->wa_flags & BOOST_BACK_WA) { data = chg->irq_info[SWITCHER_POWER_OK_IRQ].irq_data; if (data) { wdata = &data->storm_data; update_storm_count(wdata, WEAK_CHG_STORM_COUNT); vote(chg->usb_icl_votable, BOOST_BACK_VOTER, false, 0); vote(chg->usb_icl_votable, WEAK_CHARGER_VOTER, false, 0); } } vote(chg->pl_disable_votable, PL_DELAY_VOTER, true, 0); vote(chg->awake_votable, PL_DELAY_VOTER, false, 0); /* reset both usbin current and voltage votes */ vote(chg->pl_enable_votable_indirect, USBIN_I_VOTER, false, 0); vote(chg->pl_enable_votable_indirect, USBIN_V_VOTER, false, 0); vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, true, is_flashlite_active(chg) ? USBIN_500UA : USBIN_100UA); vote(chg->usb_icl_votable, FLASH_ACTIVE_VOTER, false, 0); vote_override(chg->fcc_main_votable, FCC_STEPPER_VOTER, false, chg->chg_param.fcc_step_start_ua); /* Remove SW thermal regulation votes */ vote(chg->usb_icl_votable, SW_THERM_REGULATION_VOTER, false, 0); vote(chg->awake_votable, SW_THERM_REGULATION_VOTER, false, 0); /* clear USB ICL vote for USB_PSY_VOTER */ rc = vote(chg->usb_icl_votable, USB_PSY_VOTER, false, 0); if (rc < 0) smblite_lib_err(chg, "Couldn't un-vote for USB ICL rc=%d\n", rc); chg->uusb_apsd_rerun_done = false; chg->hvdcp3_detected = false; /* Disable concurrent mode on USB removal. */ smblite_lib_concurrent_mode_config(chg, false); chg->concurrent_mode_status = false; } void smblite_lib_suspend_on_debug_battery(struct smb_charger *chg) { int rc, val; if (!chg->iio_chan_list_qg && !chg->is_fg_remote) return; rc = smblite_lib_get_prop_from_bms(chg, SMB5_QG_DEBUG_BATTERY, &val); if (rc < 0) { smblite_lib_err(chg, "Couldn't get debug battery prop rc=%d\n", rc); return; } chg->is_debug_batt = val; if (chg->suspend_input_on_debug_batt) { vote(chg->usb_icl_votable, DEBUG_BOARD_VOTER, val, 0); if (val) { pr_info("Input suspended: Fake battery\n"); schgm_flashlite_config_usbin_collapse(chg, false); } } else { vote(chg->chg_disable_votable, DEBUG_BOARD_VOTER, val, 0); } } static int set_sdp_current(struct smb_charger *chg, int icl_ua) { int rc; u8 icl_options; enum icl_override_mode icl_override = SW_OVERRIDE_USB51_MODE; /* power source is SDP */ switch (icl_ua) { case USBIN_100UA: case USBIN_150UA: /* USB 2.0 100mA */ icl_options = 0; break; case USBIN_500UA: /* USB 2.0 500mA*/ icl_options = USB51_MODE_BIT; break; default: /* Use ICL configuration register for HC_MODE*/ icl_override = SW_OVERRIDE_HC_MODE; icl_options = USBIN_MODE_CHG_BIT; break; } rc = smblite_lib_set_charge_param(chg, &chg->param.usb_icl, icl_ua); if (rc < 0) { smblite_lib_err(chg, "Couldn't set HC ICL rc=%d\n", rc); return rc; } rc = smblite_lib_masked_write(chg, USBIN_ICL_OPTIONS_REG(chg->base), CFG_USB3P0_SEL_BIT | USB51_MODE_BIT, icl_options); if (rc < 0) { smblite_lib_err(chg, "Couldn't set ICL options rc=%d\n", rc); return rc; } rc = smblite_lib_icl_override(chg, icl_override); if (rc < 0) { smblite_lib_err(chg, "Couldn't set ICL override rc=%d\n", rc); return rc; } return rc; } int smblite_lib_set_icl_current(struct smb_charger *chg, const int icl_ua) { int rc = 0; enum icl_override_mode icl_override = HW_AUTO_MODE; /* suspend if 25mA or less is requested */ bool suspend = (icl_ua <= USBIN_25UA); if (chg->subtype == PM2250) schgm_flashlite_torch_priority(chg, suspend ? TORCH_BOOST_MODE : TORCH_BUCK_MODE); /* Do not configure ICL from SW for DAM */ if (smblite_lib_get_prop_typec_mode(chg) == QTI_POWER_SUPPLY_TYPEC_SINK_DEBUG_ACCESSORY) return 0; if (suspend) return smblite_lib_set_usb_suspend(chg, true); /* No client updated it's vote */ if (icl_ua == INT_MAX) goto set_mode; /* configure current */ if (chg->real_charger_type == POWER_SUPPLY_TYPE_USB && (chg->typec_legacy || chg->typec_mode == QTI_POWER_SUPPLY_TYPEC_SOURCE_DEFAULT || chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_MICRO_USB)) { rc = set_sdp_current(chg, icl_ua); if (rc < 0) { smblite_lib_err(chg, "Couldn't set SDP ICL rc=%d\n", rc); goto out; } goto unsuspend; } else { /* * Try USB 2.0/3,0 option first on USB path when maximum input * current limit is 500mA or below for better accuracy; in case * of error, proceed to use USB high-current mode. */ if (icl_ua <= USBIN_500UA) { rc = set_sdp_current(chg, icl_ua); if (rc >= 0) goto unsuspend; } rc = smblite_lib_set_charge_param(chg, &chg->param.usb_icl, icl_ua); if (rc < 0) { smblite_lib_err(chg, "Couldn't set HC ICL rc=%d\n", rc); goto out; } icl_override = SW_OVERRIDE_HC_MODE; } set_mode: rc = smblite_lib_icl_override(chg, icl_override); if (rc < 0) { smblite_lib_err(chg, "Couldn't set ICL override rc=%d\n", rc); goto out; } unsuspend: /* unsuspend after configuring current and override */ rc = smblite_lib_set_usb_suspend(chg, false); if (rc < 0) { smblite_lib_err(chg, "Couldn't resume input rc=%d\n", rc); goto out; } /* Re-run AICL */ if (icl_override != SW_OVERRIDE_HC_MODE) rc = smblite_lib_run_aicl(chg, RERUN_AICL); out: return rc; } int smblite_lib_get_icl_current(struct smb_charger *chg, int *icl_ua) { int rc; rc = smblite_lib_get_charge_param(chg, &chg->param.icl_max_stat, icl_ua); if (rc < 0) smblite_lib_err(chg, "Couldn't get HC ICL rc=%d\n", rc); return rc; } #define FCC_STEP_1_SIZE_UA 25000 #define FCC_STEP_2_SIZE_UA 150000 #define FCC_STEP_1_MAX_DATA 60 #define STEP_1_MAX_FCC_UA 1500000 /* * Fast Charge Current = [DATA]x25mA, DATA = 0..60 (0-1500ma) * or [DATA-49]x150mA, DATA = 61..63 (1650mA-1.95A) */ int smblite_lib_get_fcc(struct smb_chg_param *param, u8 val_raw) { if (val_raw > FCC_STEP_1_MAX_DATA) return (((val_raw - FCC_STEP_1_MAX_DATA) * FCC_STEP_2_SIZE_UA) + STEP_1_MAX_FCC_UA); return (val_raw * FCC_STEP_1_SIZE_UA); } int smblite_lib_set_fcc(struct smb_chg_param *param, int val_u, u8 *val_raw) { if (val_u > param->max_u) val_u = param->max_u; else if (val_u < param->min_u) val_u = param->min_u; if (val_u > (FCC_STEP_1_MAX_DATA * FCC_STEP_1_SIZE_UA)) *val_raw = (((val_u - STEP_1_MAX_FCC_UA) / FCC_STEP_2_SIZE_UA) + FCC_STEP_1_MAX_DATA); else *val_raw = (val_u / FCC_STEP_1_SIZE_UA); return 0; } /********************* * VOTABLE CALLBACKS * *********************/ static int smblite_lib_awake_vote_callback(struct votable *votable, void *data, int awake, const char *client) { struct smb_charger *chg = data; if (awake) pm_stay_awake(chg->dev); else pm_relax(chg->dev); return 0; } static int smblite_lib_chg_disable_vote_callback(struct votable *votable, void *data, int chg_disable, const char *client) { struct smb_charger *chg = data; int rc; rc = smblite_lib_masked_write(chg, CHARGING_ENABLE_CMD_REG(chg->base), CHARGING_ENABLE_CMD_BIT, chg_disable ? 0 : CHARGING_ENABLE_CMD_BIT); if (rc < 0) { smblite_lib_err(chg, "Couldn't %s charging rc=%d\n", chg_disable ? "disable" : "enable", rc); return rc; } return 0; } static int smblite_lib_icl_irq_disable_vote_callback(struct votable *votable, void *data, int disable, const char *client) { struct smb_charger *chg = data; if (!chg->irq_info[USBIN_ICL_CHANGE_IRQ].is_requested) return 0; if (chg->irq_info[USBIN_ICL_CHANGE_IRQ].enabled) { if (disable) { irq_set_status_flags(chg->irq_info[USBIN_ICL_CHANGE_IRQ].irq, IRQ_DISABLE_UNLAZY); disable_irq_nosync( chg->irq_info[USBIN_ICL_CHANGE_IRQ].irq); } } else { if (!disable) enable_irq(chg->irq_info[USBIN_ICL_CHANGE_IRQ].irq); } chg->irq_info[USBIN_ICL_CHANGE_IRQ].enabled = !disable; return 0; } static int smblite_lib_temp_change_irq_disable_vote_callback( struct votable *votable, void *data, int disable, const char *client) { struct smb_charger *chg = data; if (!chg->irq_info[TEMP_CHANGE_IRQ].is_requested) return 0; if (chg->irq_info[TEMP_CHANGE_IRQ].enabled && disable) { if (chg->irq_info[TEMP_CHANGE_IRQ].wake) disable_irq_wake(chg->irq_info[TEMP_CHANGE_IRQ].irq); irq_set_status_flags(chg->irq_info[TEMP_CHANGE_IRQ].irq, IRQ_DISABLE_UNLAZY); disable_irq_nosync(chg->irq_info[TEMP_CHANGE_IRQ].irq); } else if (!chg->irq_info[TEMP_CHANGE_IRQ].enabled && !disable) { enable_irq(chg->irq_info[TEMP_CHANGE_IRQ].irq); if (chg->irq_info[TEMP_CHANGE_IRQ].wake) enable_irq_wake(chg->irq_info[TEMP_CHANGE_IRQ].irq); } chg->irq_info[TEMP_CHANGE_IRQ].enabled = !disable; return 0; } /******************** * BATT PSY GETTERS * ********************/ int smblite_lib_get_prop_input_suspend(struct smb_charger *chg, int *val) { *val = (get_client_vote(chg->usb_icl_votable, USER_VOTER) == 0); return 0; } int smblite_lib_get_prop_batt_present(struct smb_charger *chg, union power_supply_propval *val) { int rc; u8 stat; rc = smblite_lib_read(chg, chg->base.batif_base + INT_RT_STS_OFFSET, &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read BATIF_INT_RT_STS rc=%d\n", rc); return rc; } val->intval = !(stat & BAT_THERM_OR_ID_MISSING_RT_STS_BIT); return rc; } int smblite_lib_get_prop_batt_capacity(struct smb_charger *chg, union power_supply_propval *val) { int rc = -EINVAL; if (chg->fake_capacity >= 0) { val->intval = chg->fake_capacity; return 0; } rc = smblite_lib_get_prop_from_bms(chg, SMB5_QG_CAPACITY, &val->intval); if ((rc < 0) && (rc != -EAGAIN)) smblite_lib_err(chg, "Couldn't get capacity prop rc=%d\n", rc); return rc; } static bool is_charging_paused(struct smb_charger *chg) { int rc; u8 val; rc = smblite_lib_read(chg, CHARGING_ENABLE_CMD_REG(chg->base), &val); if (rc < 0) { smblite_lib_err(chg, "Couldn't read CHARGING_PAUSE_CMD rc=%d\n", rc); return false; } return val & CHARGING_PAUSE_CMD_BIT; } #define PERCENT_TO_10NANO_RATIO 1000000 static int smblite_lib_read_soc(struct smb_charger *chg) { ssize_t len; u16 *val; int soc; if (!chg->soc_nvmem) return -EINVAL; val = nvmem_cell_read(chg->soc_nvmem, &len); if (IS_ERR(val)) { smblite_lib_err(chg, "Failed to read charger msoc from SDAM\n"); return PTR_ERR(val); } soc = (int)*val; soc = (soc << 16) / PERCENT_TO_10NANO_RATIO; kfree(val); return soc; } #define CUTOFF_COUNT 3 int smblite_lib_get_prop_batt_status(struct smb_charger *chg, union power_supply_propval *val) { union power_supply_propval pval = {0, }; bool usb_online; u8 stat; int rc, input_present = 0, count = 4, data = 0; if (chg->fake_chg_status_on_debug_batt) { rc = smblite_lib_get_prop_from_bms(chg, SMB5_QG_DEBUG_BATTERY, &pval.intval); if (rc < 0) { pr_err_ratelimited("Couldn't get debug battery prop rc=%d\n", rc); } else if (pval.intval == 1) { val->intval = POWER_SUPPLY_STATUS_UNKNOWN; return 0; } } /* * If SOC = 0 and we are discharging with input connected, report * the battery status as DISCHARGING. */ smblite_lib_is_input_present(chg, &input_present); rc = smblite_lib_get_prop_from_bms(chg, SMB5_QG_CAPACITY, &pval.intval); if (!rc && pval.intval == 0 && input_present) { rc = smblite_lib_get_prop_from_bms(chg, SMB5_QG_CURRENT_NOW, &pval.intval); if (!rc && pval.intval > 0) { if (chg->cutoff_count > CUTOFF_COUNT) { val->intval = POWER_SUPPLY_STATUS_DISCHARGING; return 0; } chg->cutoff_count++; } else { chg->cutoff_count = 0; } } else { chg->cutoff_count = 0; } rc = smblite_lib_get_prop_usb_online(chg, &pval); if (rc < 0) { smblite_lib_err(chg, "Couldn't get usb online property rc=%d\n", rc); return rc; } usb_online = (bool)pval.intval; rc = smblite_lib_read(chg, BATTERY_CHARGER_STATUS_1_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read BATTERY_CHARGER_STATUS_1 rc=%d\n", rc); return rc; } stat = stat & BATTERY_CHARGER_STATUS_MASK; if (!usb_online) { switch (stat) { case TERMINATE_CHARGE: case INHIBIT_CHARGE: val->intval = POWER_SUPPLY_STATUS_FULL; break; default: val->intval = POWER_SUPPLY_STATUS_DISCHARGING; break; } return rc; } switch (stat) { case TRICKLE_CHARGE: case PRE_CHARGE: case FULLON_CHARGE: case TAPER_CHARGE: val->intval = POWER_SUPPLY_STATUS_CHARGING; break; case TERMINATE_CHARGE: val->intval = POWER_SUPPLY_STATUS_FULL; break; case INHIBIT_CHARGE: data = smblite_lib_read_soc(chg); if (data < 0) { smblite_lib_err(chg, "Failed to read msoc rc = %d\n", data); return data; } smblite_lib_dbg(chg, PR_MISC, "Read soc = %d\n", data); /* * Write msoc value to charger SOC_PCT register 4 times after entered * inhibit mode. */ while (count--) { rc = smblite_lib_set_prop_batt_sys_soc(chg, data); if (rc < 0) { smblite_lib_err(chg, "Failed to set battery system soc rc=%d\n", rc); return rc; } } break; case DISABLE_CHARGE: case PAUSE_CHARGE: val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; break; default: val->intval = POWER_SUPPLY_STATUS_UNKNOWN; break; } if (is_charging_paused(chg)) { val->intval = POWER_SUPPLY_STATUS_CHARGING; return 0; } if (val->intval != POWER_SUPPLY_STATUS_CHARGING) return 0; if (!usb_online && chg->fake_batt_status == POWER_SUPPLY_STATUS_FULL) { val->intval = POWER_SUPPLY_STATUS_FULL; return 0; } return 0; } int smblite_lib_get_prop_batt_charge_type(struct smb_charger *chg, union power_supply_propval *val) { int rc; u8 stat; rc = smblite_lib_read(chg, BATTERY_CHARGER_STATUS_1_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read BATTERY_CHARGER_STATUS_1 rc=%d\n", rc); return rc; } switch (stat & BATTERY_CHARGER_STATUS_MASK) { case TRICKLE_CHARGE: case PRE_CHARGE: val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE; break; case FULLON_CHARGE: val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST; break; case TAPER_CHARGE: val->intval = POWER_SUPPLY_CHARGE_TYPE_ADAPTIVE; break; default: val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE; } return rc; } int smblite_lib_get_prop_batt_health(struct smb_charger *chg, union power_supply_propval *val) { union power_supply_propval pval; int rc; int effective_fv_uv; u8 stat; rc = smblite_lib_read(chg, CHARGER_VBAT_STATUS_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read CHARGER_VBAT_STATUS_REG rc=%d\n", rc); return rc; } smblite_lib_dbg(chg, PR_REGISTER, "CHARGER_VBAT_STATUS_REG = 0x%02x\n", stat); if (stat & BAT_OV_BIT) { rc = smblite_lib_get_prop_from_bms(chg, SMB5_QG_VOLTAGE_NOW, &pval.intval); if (!rc) { /* * If Vbatt is within 40mV above Vfloat, then don't * treat it as overvoltage. */ effective_fv_uv = get_effective_result(chg->fv_votable); if (pval.intval >= effective_fv_uv + 40000) { val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE; smblite_lib_err(chg, "battery over-voltage vbat_fg = %duV, fv = %duV\n", pval.intval, effective_fv_uv); goto done; } } } rc = smblite_lib_read(chg, BATTERY_TEMP_STATUS_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read BATTERY_CHARGER_STATUS_2 rc=%d\n", rc); return rc; } if (stat & BAT_TEMP_STATUS_TOO_COLD_BIT) val->intval = POWER_SUPPLY_HEALTH_COLD; else if (stat & BAT_TEMP_STATUS_TOO_HOT_BIT) val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; else if (stat & BAT_TEMP_STATUS_COLD_SOFT_BIT) val->intval = POWER_SUPPLY_HEALTH_COOL; else if (stat & BAT_TEMP_STATUS_HOT_SOFT_BIT) val->intval = POWER_SUPPLY_HEALTH_WARM; else val->intval = POWER_SUPPLY_HEALTH_GOOD; done: return rc; } int smblite_lib_get_prop_system_temp_level(struct smb_charger *chg, union power_supply_propval *val) { val->intval = chg->system_temp_level; return 0; } int smblite_lib_get_prop_system_temp_level_max(struct smb_charger *chg, union power_supply_propval *val) { val->intval = chg->thermal_levels; return 0; } int smblite_lib_get_prop_input_current_limited(struct smb_charger *chg, int *val) { u8 stat; int rc; if (chg->input_current_limited >= 0) { *val = chg->input_current_limited; return 0; } rc = smblite_lib_read(chg, AICL_STATUS_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read AICL_STATUS rc=%d\n", rc); return rc; } *val = (stat & SOFT_ILIMIT_BIT); return 0; } int smblite_lib_get_prop_batt_iterm(struct smb_charger *chg, union power_supply_propval *val) { int rc, temp; u8 stat, buf[2]; /* Currently, only ADC comparator-based termination is supported * and validate, hence read only the threshold corresponding to ADC * source. Proceed only if CHGR_ITERM_USE_ANALOG_BIT is 0. */ rc = smblite_lib_read(chg, CHGR_TERM_CFG_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read CHGR_TERM_CFG_REG rc=%d\n", rc); return rc; } if (stat & CHGR_ITERM_USE_ANALOG_BIT) { val->intval = -EINVAL; return 0; } rc = smblite_lib_batch_read(chg, CHGR_ADC_ITERM_UP_THD_MSB_REG(chg->base), buf, 2); if (rc < 0) { smblite_lib_err(chg, "Couldn't read CHGR_ADC_ITERM_UP_THD_MSB_REG rc=%d\n", rc); return rc; } temp = buf[1] | (buf[0] << 8); temp = sign_extend32(temp, 15); if (chg->subtype == PM5100) temp = DIV_ROUND_CLOSEST((temp * 1000), PM5100_ADC_CHG_ITERM_MULT); else temp = DIV_ROUND_CLOSEST(temp * ITERM_LIMITS_MA, ADC_CHG_ITERM_MASK); val->intval = temp; return rc; } int smblite_lib_set_prop_batt_iterm(struct smb_charger *chg, int iterm_ma) { int rc; s16 raw_hi_thresh; u8 stat, *buf; if (chg->subtype != PM5100) return -EINVAL; if (iterm_ma < (-1 * PM5100_MAX_LIMITS_MA) || iterm_ma > PM5100_MAX_LIMITS_MA) return -EINVAL; /* Currently, only ADC comparator-based termination is supported * and validate, hence read only the threshold corresponding to ADC * source. Proceed only if CHGR_ITERM_USE_ANALOG_BIT is 0. */ rc = smblite_lib_read(chg, CHGR_TERM_CFG_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read CHGR_TERM_CFG_REG rc=%d\n", rc); return rc; } if (stat & CHGR_ITERM_USE_ANALOG_BIT) return -EINVAL; raw_hi_thresh = PM5100_RAW_ITERM(iterm_ma); raw_hi_thresh = sign_extend32(raw_hi_thresh, 15); buf = (u8 *)&raw_hi_thresh; raw_hi_thresh = buf[1] | (buf[0] << 8); rc = smblite_lib_batch_write(chg, CHGR_ADC_ITERM_UP_THD_MSB_REG(chg->base), (u8 *)&raw_hi_thresh, 2); if (rc < 0) { dev_err(chg->dev, "Couldn't configure ITERM threshold HIGH rc=%d\n", rc); return rc; } return rc; } int smblite_lib_get_prop_batt_charge_done(struct smb_charger *chg, int *val) { int rc; u8 stat; rc = smblite_lib_read(chg, BATTERY_CHARGER_STATUS_1_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read BATTERY_CHARGER_STATUS_1 rc=%d\n", rc); return rc; } stat = stat & BATTERY_CHARGER_STATUS_MASK; *val = (stat == TERMINATE_CHARGE); return 0; } int smblite_lib_get_batt_current_now(struct smb_charger *chg, int *val) { int rc; rc = smblite_lib_get_prop_from_bms(chg, SMB5_QG_CURRENT_NOW, val); if (!rc) *val *= (-1); else smblite_lib_err(chg, "Couldn't get current_now prop rc=%d\n", rc); return rc; } /*********************** * BATTERY PSY SETTERS * ***********************/ int smblite_lib_set_prop_input_suspend(struct smb_charger *chg, const int val) { int rc; /* vote 0mA when suspended */ rc = vote(chg->usb_icl_votable, USER_VOTER, (bool)val, 0); if (rc < 0) { smblite_lib_err(chg, "Couldn't vote to %s USB rc=%d\n", (bool)val ? "suspend" : "resume", rc); return rc; } power_supply_changed(chg->batt_psy); return rc; } int smblite_lib_set_prop_batt_capacity(struct smb_charger *chg, const union power_supply_propval *val) { chg->fake_capacity = val->intval; power_supply_changed(chg->batt_psy); return 0; } int smblite_lib_set_prop_batt_sys_soc(struct smb_charger *chg, int val) { int rc; u8 sys_soc; if (val < 0 || val > 100) { smblite_lib_err(chg, "Invalid system soc = %d\n", val); return -EINVAL; } sys_soc = DIV_ROUND_CLOSEST(val * 255, 100); /* This is used to trigger SOC based auto-recharge */ rc = smblite_lib_write(chg, CHGR_QG_SOC_REG(chg->base), sys_soc); if (rc < 0) { smblite_lib_err(chg, "Couldn't write to CHGR_QG_SOC_REG rc=%d\n", rc); return rc; } rc = smblite_lib_write(chg, CHGR_QG_SOC_UPDATE_REG(chg->base), SOC_UPDATE_PCT_BIT); if (rc < 0) smblite_lib_err(chg, "Couldn't write to CHGR_QG_SOC_UPDATE_REG rc=%d\n", rc); return rc; } int smblite_lib_set_prop_batt_status(struct smb_charger *chg, const union power_supply_propval *val) { /* Faking battery full */ if (val->intval == POWER_SUPPLY_STATUS_FULL) chg->fake_batt_status = val->intval; else chg->fake_batt_status = -EINVAL; power_supply_changed(chg->batt_psy); return 0; } int smblite_lib_set_prop_system_temp_level(struct smb_charger *chg, const union power_supply_propval *val) { if (val->intval < 0) return -EINVAL; if (chg->thermal_levels <= 0) return -EINVAL; if (val->intval > chg->thermal_levels) return -EINVAL; chg->system_temp_level = val->intval; if (chg->system_temp_level == chg->thermal_levels) return vote(chg->chg_disable_votable, THERMAL_DAEMON_VOTER, true, 0); vote(chg->chg_disable_votable, THERMAL_DAEMON_VOTER, false, 0); if (chg->system_temp_level == 0) return vote(chg->fcc_votable, THERMAL_DAEMON_VOTER, false, 0); vote(chg->fcc_votable, THERMAL_DAEMON_VOTER, true, chg->thermal_mitigation[chg->system_temp_level]); return 0; } static int smblite_lib_dp_pulse(struct smb_charger *chg) { int rc; /* QC 3.0 increment */ rc = smblite_lib_masked_write(chg, CMD_HVDCP_REG(chg->base), SINGLE_INCREMENT_BIT, SINGLE_INCREMENT_BIT); if (rc < 0) smblite_lib_err(chg, "Couldn't write to CMD_HVDCP_REG rc=%d\n", rc); return rc; } static int smblite_lib_force_vbus_voltage(struct smb_charger *chg, u8 val) { int rc; rc = smblite_lib_masked_write(chg, CMD_HVDCP_REG(chg->base), val, val); if (rc < 0) smblite_lib_err(chg, "Couldn't write to CMD_HVDCP_2_REG rc=%d\n", rc); return rc; } static bool is_boost_en(struct smb_charger *chg) { int rc; u8 stat = 0; if (chg->subtype != PM5100) return false; rc = smblite_lib_read(chg, BOOST_BST_EN_REG(chg->base), &stat); if (rc < 0) smblite_lib_err(chg, "Couldn't read BOOST_BST_EN_REG rc=%d\n", rc); return (stat & DCIN_BST_EN_BIT); } #define HVDCP3_QUALIFICATION_UV 300000 static int smblite_lib_hvdcp3_force_max_vbus(struct smb_charger *chg) { union power_supply_propval pval = {0, }; int cnt = 0, rc = 0, prev_vbus; bool boost_en; mutex_lock(&chg->dpdm_pulse_lock); boost_en = is_boost_en(chg); if (boost_en || chg->hvdcp3_detected) { smblite_lib_dbg(chg, PR_MISC, "HVDCP3 : Ignore VBUS increment due to boost_en=%s, hvdcp3_detected=%s\n", (boost_en ? "True" : "False"), (chg->hvdcp3_detected ? "True" : "False")); goto failure; } /* Move adapter to IDLE state (continuous mode). */ rc = smblite_lib_force_vbus_voltage(chg, IDLE_BIT); if (rc < 0) smblite_lib_dbg(chg, PR_MISC, "HVDCP3 : Failed to reset adapter to IDLE state\n"); /* Wait for 100ms for adapter to move to idle mode */ msleep(100); rc = smblite_lib_get_prop_usb_voltage_now(chg, &pval); if (rc < 0) { smblite_lib_err(chg, "Couldn't read voltage_now rc=%d\n", rc); goto failure; } prev_vbus = pval.intval; /* * Statically increase voltage till 6V. * ( i.e : 1V / 200mV = 5 pulses ). */ while (cnt++ < PM5100_MAX_HVDCP3_PULSES) { smblite_lib_dp_pulse(chg); /* wait for 100ms for vbus to settle. */ msleep(100); } if (is_boost_en(chg)) { smblite_lib_dbg(chg, PR_MISC, "HVDCP3 : Failed to increase vbus due to boost_en\n"); goto failure; } /* Wait for 200ms for vbus to settle before reading it. */ msleep(200); rc = smblite_lib_get_prop_usb_voltage_now(chg, &pval); if (rc < 0) { smblite_lib_err(chg, "Couldn't read voltage_now rc=%d\n", rc); goto failure; } /* Check if voltage incremented. (i.e if QC3 ) */ if (pval.intval >= (prev_vbus + HVDCP3_QUALIFICATION_UV)) chg->hvdcp3_detected = true; smblite_lib_dbg(chg, PR_MISC, "HVDCP3 : detected=%s, prev_vbus=%d, vbus_now=%d\n", (chg->hvdcp3_detected ? "True" : "False"), prev_vbus, pval.intval); failure: if (!chg->hvdcp3_detected) { /* Incase of failure during QC3 detection force 5V. */ rc = smblite_lib_force_vbus_voltage(chg, FORCE_5V_BIT); if (rc < 0) smblite_lib_dbg(chg, PR_MISC, "HVDCP3 : Failed to move adapter vbus to 5V\n"); } mutex_unlock(&chg->dpdm_pulse_lock); return rc; } int smblite_lib_set_prop_rechg_soc_thresh(struct smb_charger *chg, const int val) { int rc; u8 new_thr = DIV_ROUND_CLOSEST(val * 255, 100); rc = smblite_lib_write(chg, CHARGE_RCHG_SOC_THRESHOLD_CFG_REG(chg->base), new_thr); if (rc < 0) { smblite_lib_err(chg, "Couldn't write to RCHG_SOC_THRESHOLD_CFG_REG rc=%d\n", rc); return rc; } chg->auto_recharge_soc = val; return rc; } int smblite_lib_run_aicl(struct smb_charger *chg, int type) { int rc; u8 stat; rc = smblite_lib_read(chg, POWER_PATH_STATUS_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read POWER_PATH_STATUS rc=%d\n", rc); return rc; } /* USB is suspended so skip re-running AICL */ if (stat & USBIN_SUSPEND_STS_BIT) return rc; smblite_lib_dbg(chg, PR_MISC, "re-running AICL\n"); stat = (type == RERUN_AICL) ? RERUN_AICL_BIT : RESTART_AICL_BIT; rc = smblite_lib_masked_write(chg, AICL_CMD_REG(chg->base), stat, stat); if (rc < 0) smblite_lib_err(chg, "Couldn't write to AICL_CMD_REG rc=%d\n", rc); return 0; } #define BOOST_SS_TIMEOUT_COUNT 4 static int smblite_lib_check_boost_ss(struct smb_charger *chg) { int rc, cnt = 0; bool is_ss_done = false; u8 boost_status = 0; /* * POLL on BOOST_SW_DONE bit for 80ms with 20ms interval for * BOOST start-up to be done. */ while (cnt < BOOST_SS_TIMEOUT_COUNT) { rc = smblite_lib_read(chg, BOOST_BST_STATUS_REG(chg->base), &boost_status); if (rc < 0) smblite_lib_err(chg, "Couldn't read BOOST_BST_STATUS_REG rc=%d\n", rc); if (!rc && (boost_status & BOOST_SOFTSTART_DONE_BIT)) { is_ss_done = true; break; } cnt++; msleep(20); } smblite_lib_dbg(chg, PR_MISC, "Concurrent-mode: BOOST_STATUS=%x, cnt=%d\n", boost_status, cnt); /* In case of BOOST failure disable concurrency mode and return failure. */ if (!is_ss_done) { smblite_lib_err(chg, "Boost ss-done failed, failed to enable concurrency\n"); return -ETIME; } return 0; } #define CONCURRENCY_REDUCED_ICL_UA 300000 #define CONCURRENCY_MODE_SUPPORTED_ICL_UA 500000 int smblite_lib_set_concurrent_config(struct smb_charger *chg, bool enable) { int rc = 0, icl_ua = 0, fixed_icl_ua = 0, usb_present = 0; union power_supply_propval pval = {0, }; u8 apsd_status = 0; bool boost_enabled = is_boost_en(chg); if (!is_concurrent_mode_supported(chg)) { smblite_lib_dbg(chg, PR_MISC, "concurrency-mode: support disabled\n"); return -ENXIO; } /* Do not enable concurrency mode when connected to debug batt. */ if (chg->is_debug_batt) { smblite_lib_dbg(chg, PR_MISC, "concurrency-mode: disabled debug board detected\n"); return -EPERM; } /* Exit if there is no change in state */ if (chg->concurrent_mode_status == enable) goto out; rc = smblite_lib_get_prop_usb_present(chg, &pval); if (rc < 0) { smblite_lib_dbg(chg, PR_MISC, "Couldn't get USB preset status rc=%d\n", rc); goto failure; } usb_present = pval.intval; if (enable) { /* Check if USB is connected */ if (!usb_present) { smblite_lib_dbg(chg, PR_MISC, "Failed to enable concurrent mode USB disconnected\n", rc); goto failure; } /* * When boost is enabled and usb is inserted chargering will be disabled causing * AICL to be always zero, Skip calculating ICL for this. */ if (boost_enabled) { smblite_lib_dbg(chg, PR_MISC, "boost is already enabled. Skipping ICL vote.\n"); } else { /* * Incase were AICL is reruning and there is a request from Audio to * enable concurrency mode it may lead us to wait for 1+ secounds which * may in turn compromise with users Audio expirence. Eliminate this * delay by forcing ICL to a fixed value. */ fixed_icl_ua = CONCURRENCY_MODE_SUPPORTED_ICL_UA; if (fixed_icl_ua <= CONCURRENCY_REDUCED_ICL_UA) { /* Return as failure if settled ICL is less than required ICL. */ smblite_lib_err(chg, "fixed_icl_ua=%d less can't enable concurrency-mode\n", fixed_icl_ua); return -EIO; } /* Reduce ICL to go into concurrency mode */ icl_ua = fixed_icl_ua - CONCURRENCY_REDUCED_ICL_UA; rc = vote(chg->usb_icl_votable, CONCURRENT_MODE_VOTER, true, icl_ua); if (rc < 0) { smblite_lib_err(chg, "Failed to vote on ICL rc=%d\n", rc); goto failure; } smblite_lib_dbg(chg, PR_MISC, "concurrent-mode: Reduced ICL to %d for concurrency mode\n", icl_ua); } if (chg->hvdcp3_detected) { /* Force Vbus to 5V. */ rc = smblite_lib_force_vbus_voltage(chg, FORCE_5V_BIT); if (rc < 0) smblite_lib_err(chg, "Failed to force vbus to 5V rc=%d\n", rc); chg->hvdcp3_detected = false; } /* Enable charger if already disabled */ rc = vote(chg->chg_disable_votable, CONCURRENT_MODE_VOTER, false, 0); if (rc < 0) { smblite_lib_err(chg, "Failed to Enable charger rc=%d\n", rc); goto failure; } /* Enable concurrent mode */ rc = smblite_lib_concurrent_mode_config(chg, true); if (rc < 0) goto failure; /* * If Audio playback is in progress and charger is inserted, on enabling * concurrency there is a possibility of it to fail if the BOOST soft-start * is not complete. Avoid this by polling on BOOST_SW_DONE bit which gets * set after concurrency is successfully enabled and then returning back to * the caller. In case of failure disable concurrency-mode and return failure. */ if (boost_enabled) { rc = smblite_lib_check_boost_ss(chg); if (rc < 0) { /* * Disable concurrency mode to move back the switcher to * BOOST-mode and wait for SS_DONE for BOOST to settle. */ boost_enabled = is_boost_en(chg); smblite_lib_dbg(chg, PR_MISC, "Concurrency failed, Disabling concurrency BOOST_EN=%s - going back to BOOST mode\n", (boost_enabled ? "True" : "False")); smblite_lib_concurrent_mode_config(chg, false); if (boost_enabled) { rc = smblite_lib_check_boost_ss(chg); if (rc < 0) { smblite_lib_dbg(chg, PR_MISC, "SS_DONE failed for BOOST-mode rc=%d\n", rc); /* * This is a gross failure where concurrency and * subsequently BOOST failed. */ rc = -EFAULT; } else { /* Concurrency failed, but BOOST came up. */ rc = -ETIME; } } goto boost_ss_failure; } } chg->concurrent_mode_status = true; smblite_lib_dbg(chg, PR_MISC, "Concurrent Mode enabled successfully: fixed_icl_ua=%duA, icl_ua=%duA, is_hvdcp3=%d\n", fixed_icl_ua, icl_ua, chg->hvdcp3_detected); goto out; } else { if (!usb_present) { /* USB removed while concurrency was active */ smblite_lib_dbg(chg, PR_MISC, "USB removed: concurrency mode already disabled\n"); return 0; } /* Disable concurrent mode */ rc = smblite_lib_concurrent_mode_config(chg, false); if (rc < 0) goto failure; rc = smblite_lib_read(chg, APSD_RESULT_STATUS_REG(chg->base), &apsd_status); if (rc < 0) smblite_lib_err(chg, "Couldn't read APSD_RESULT_STATUS rc=%d\n", rc); /* * Try to Restore vbus to MAX(6V) only if: * 1. QC adapter is connected. * 2. USB is present. * 3. Boost is disabled : DPDM request does not take * effect with boost enabled. */ if ((apsd_status & QC_3P0_BIT) && usb_present && !boost_enabled) smblite_lib_hvdcp3_force_max_vbus(chg); rc = smblite_lib_run_aicl(chg, RERUN_AICL); if (rc < 0) smblite_lib_err(chg, "Failed to rerun_aicl rc=%d\n", rc); chg->concurrent_mode_status = false; smblite_lib_dbg(chg, PR_MISC, "Concurrent Mode disabled successfully: is_hvdcp3=%d\n", chg->hvdcp3_detected); return 0; } failure: rc = -EINVAL; boost_ss_failure: smblite_lib_err(chg, "Failed to %s concurrent mode, rc=%d\n", (enable ? "Enable" : "Disable"), rc); out: return rc; } /******************* * USB PSY GETTERS * *******************/ int smblite_lib_get_prop_usb_present(struct smb_charger *chg, union power_supply_propval *val) { int rc; u8 stat; rc = smblite_lib_read(chg, chg->base.usbin_base + INT_RT_STS_OFFSET, &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read USBIN_RT_STS rc=%d\n", rc); return rc; } val->intval = (bool)(stat & USBIN_PLUGIN_RT_STS_BIT); return 0; } int smblite_lib_get_prop_usb_online(struct smb_charger *chg, union power_supply_propval *val) { int rc = 0, input_present = 0; u8 stat; /* * Android plays an audio notification on USB insertion when USB_ONLINE = 1, * which on PM5100 will move the charger to BOOST again setting back USB_ONLINE = 0. * Avoid this endless loop by reporting USB_ONLINE = 1 as long as boost is enabled * while the charger is inserted. */ smblite_lib_is_input_present(chg, &input_present); if (is_boost_en(chg) && input_present) { val->intval = true; smblite_lib_dbg(chg, PR_MISC, "USB_ONLINE set due to boost_en and input_present\n"); return 0; } /* * USB_ONLINE is reported as 0 for Debug board + USB present use-case * because USE_USBIN bit is set to 0. Report USB_ONLINE = 1 for * Debug Board + USB present use-case. */ if (input_present && chg->is_debug_batt) { val->intval = true; return 0; } if (get_client_vote_locked(chg->usb_icl_votable, USER_VOTER) == 0) { val->intval = false; return rc; } rc = smblite_lib_read(chg, POWER_PATH_STATUS_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read POWER_PATH_STATUS rc=%d\n", rc); return rc; } smblite_lib_dbg(chg, PR_REGISTER, "POWER_PATH_STATUS = 0x%02x\n", stat); val->intval = (stat & USE_USBIN_BIT) && (stat & VALID_INPUT_POWER_SOURCE_STS_BIT); return rc; } int smblite_lib_get_usb_online(struct smb_charger *chg, union power_supply_propval *val) { int rc, input_present = 0; /* * Incase of APSD rerun real_charger_type (i.e APSD_STATUS) * is reset which may cause the USB_ONLINE to always return * zero. Report USB_ONLINE=0 only when real_charger_type is * UNKNOWN and input is not present. */ smblite_lib_is_input_present(chg, &input_present); if ((chg->real_charger_type == POWER_SUPPLY_TYPE_UNKNOWN) && !input_present) { val->intval = 0; return 0; } rc = smblite_lib_get_prop_usb_online(chg, val); if (!val->intval) goto exit; exit: return rc; } static int smblite_lib_read_usbin_voltage_chan(struct smb_charger *chg, union power_supply_propval *val) { int rc; if (!chg->iio.usbin_v_chan) return -ENODATA; rc = iio_read_channel_processed(chg->iio.usbin_v_chan, &val->intval); if (rc < 0) { smblite_lib_err(chg, "Couldn't read USBIN channel rc=%d\n", rc); return rc; } return 0; } int smblite_lib_get_prop_usb_voltage_now(struct smb_charger *chg, union power_supply_propval *val) { union power_supply_propval pval = {0, }; int rc = 0; u8 reg; rc = smblite_lib_get_prop_usb_present(chg, &pval); if (rc < 0) { smblite_lib_err(chg, "Couldn't get usb presence status rc=%d\n", rc); goto out; } /* * Skip reading voltage only if USB is not present and we are not in * OTG mode. */ if (!pval.intval) { rc = smblite_lib_read(chg, DCDC_CMD_OTG_REG(chg->base), ®); if (rc < 0) { smblite_lib_err(chg, "Couldn't read CMD_OTG rc=%d", rc); goto out; } if (!(reg & OTG_EN_BIT)) goto out; } rc = smblite_lib_read_usbin_voltage_chan(chg, val); if (rc < 0) smblite_lib_err(chg, "Couldn't to read USBIN over vadc, rc=%d\n", rc); out: return rc; } int smblite_lib_get_prop_charger_temp(struct smb_charger *chg, int *val) { int temp, rc; int input_present; rc = smblite_lib_is_input_present(chg, &input_present); if (rc < 0) return rc; if (input_present == INPUT_NOT_PRESENT) return -ENODATA; if (chg->iio.temp_chan) { rc = iio_read_channel_processed(chg->iio.temp_chan, &temp); if (rc < 0) { pr_err("Error in reading temp channel, rc=%d\n", rc); return rc; } *val = temp / 100; } else { return -ENODATA; } return rc; } int smblite_lib_get_prop_typec_cc_orientation(struct smb_charger *chg, int *val) { int rc = 0; u8 stat; *val = 0; if (chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_MICRO_USB) return 0; rc = smblite_lib_read(chg, TYPE_C_MISC_STATUS_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read TYPE_C_STATUS_4 rc=%d\n", rc); return rc; } smblite_lib_dbg(chg, PR_REGISTER, "TYPE_C_STATUS_4 = 0x%02x\n", stat); if (stat & CC_ATTACHED_BIT) *val = (bool)(stat & CC_ORIENTATION_BIT) + 1; return rc; } static const char * const smblite_lib_typec_mode_name[] = { [QTI_POWER_SUPPLY_TYPEC_NONE] = "NONE", [QTI_POWER_SUPPLY_TYPEC_SOURCE_DEFAULT] = "SOURCE_DEFAULT", [QTI_POWER_SUPPLY_TYPEC_SOURCE_MEDIUM] = "SOURCE_MEDIUM", [QTI_POWER_SUPPLY_TYPEC_SOURCE_HIGH] = "SOURCE_HIGH", [QTI_POWER_SUPPLY_TYPEC_NON_COMPLIANT] = "NON_COMPLIANT", [QTI_POWER_SUPPLY_TYPEC_SINK] = "SINK", [QTI_POWER_SUPPLY_TYPEC_SINK_POWERED_CABLE] = "SINK_POWERED_CABLE", [QTI_POWER_SUPPLY_TYPEC_SINK_DEBUG_ACCESSORY] = "SINK_DEBUG_ACCESSORY", [QTI_POWER_SUPPLY_TYPEC_SINK_AUDIO_ADAPTER] = "SINK_AUDIO_ADAPTER", [QTI_POWER_SUPPLY_TYPEC_POWERED_CABLE_ONLY] = "POWERED_CABLE_ONLY", }; static int smblite_lib_get_prop_ufp_mode(struct smb_charger *chg) { int rc; u8 stat; rc = smblite_lib_read(chg, TYPE_C_SNK_STATUS_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read TYPE_C_STATUS_1 rc=%d\n", rc); return QTI_POWER_SUPPLY_TYPEC_NONE; } smblite_lib_dbg(chg, PR_REGISTER, "TYPE_C_STATUS_1 = 0x%02x\n", stat); switch (stat & DETECTED_SRC_TYPE_MASK) { case SNK_RP_STD_BIT: return QTI_POWER_SUPPLY_TYPEC_SOURCE_DEFAULT; case SNK_RP_1P5_BIT: return QTI_POWER_SUPPLY_TYPEC_SOURCE_MEDIUM; case SNK_RP_3P0_BIT: return QTI_POWER_SUPPLY_TYPEC_SOURCE_HIGH; case SNK_RP_SHORT_BIT: return QTI_POWER_SUPPLY_TYPEC_NON_COMPLIANT; case SNK_DAM_500MA_BIT: case SNK_DAM_1500MA_BIT: case SNK_DAM_3000MA_BIT: return QTI_POWER_SUPPLY_TYPEC_SINK_DEBUG_ACCESSORY; default: break; } return QTI_POWER_SUPPLY_TYPEC_NONE; } static int smblite_lib_get_prop_dfp_mode(struct smb_charger *chg) { int rc; u8 stat; rc = smblite_lib_read(chg, TYPE_C_SRC_STATUS_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read TYPE_C_SRC_STATUS_REG rc=%d\n", rc); return QTI_POWER_SUPPLY_TYPEC_NONE; } smblite_lib_dbg(chg, PR_REGISTER, "TYPE_C_SRC_STATUS_REG = 0x%02x\n", stat); switch (stat & DETECTED_SNK_TYPE_MASK) { case AUDIO_ACCESS_RA_RA_BIT: return QTI_POWER_SUPPLY_TYPEC_SINK_AUDIO_ADAPTER; case SRC_DEBUG_ACCESS_BIT: return QTI_POWER_SUPPLY_TYPEC_SINK_DEBUG_ACCESSORY; case SRC_RD_OPEN_BIT: return QTI_POWER_SUPPLY_TYPEC_SINK; default: break; } return QTI_POWER_SUPPLY_TYPEC_NONE; } static int smblite_lib_get_prop_typec_mode(struct smb_charger *chg) { int rc; u8 stat; if (chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_MICRO_USB) return QTI_POWER_SUPPLY_TYPEC_NONE; rc = smblite_lib_read(chg, TYPE_C_MISC_STATUS_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read TYPE_C_MISC_STATUS_REG rc=%d\n", rc); return 0; } smblite_lib_dbg(chg, PR_REGISTER, "TYPE_C_MISC_STATUS_REG = 0x%02x\n", stat); if (stat & SNK_SRC_MODE_BIT) return smblite_lib_get_prop_dfp_mode(chg); else return smblite_lib_get_prop_ufp_mode(chg); } inline int smblite_lib_get_usb_prop_typec_mode(struct smb_charger *chg, int *val) { if (chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_MICRO_USB) *val = QTI_POWER_SUPPLY_TYPEC_NONE; else *val = chg->typec_mode; return 0; } int smblite_lib_get_prop_typec_power_role(struct smb_charger *chg, int *val) { int rc = 0; u8 ctrl; if (chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_MICRO_USB) { *val = QTI_POWER_SUPPLY_TYPEC_PR_NONE; return 0; } rc = smblite_lib_read(chg, TYPE_C_MODE_CFG_REG(chg->base), &ctrl); if (rc < 0) { smblite_lib_err(chg, "Couldn't read TYPE_C_MODE_CFG_REG rc=%d\n", rc); return rc; } smblite_lib_dbg(chg, PR_REGISTER, "TYPE_C_MODE_CFG_REG = 0x%02x\n", ctrl); if (ctrl & TYPEC_DISABLE_CMD_BIT) { *val = QTI_POWER_SUPPLY_TYPEC_PR_NONE; return rc; } switch (ctrl & (EN_SRC_ONLY_BIT | EN_SNK_ONLY_BIT)) { case 0: *val = QTI_POWER_SUPPLY_TYPEC_PR_DUAL; break; case EN_SRC_ONLY_BIT: *val = QTI_POWER_SUPPLY_TYPEC_PR_SOURCE; break; case EN_SNK_ONLY_BIT: *val = QTI_POWER_SUPPLY_TYPEC_PR_SINK; break; default: *val = QTI_POWER_SUPPLY_TYPEC_PR_NONE; smblite_lib_err(chg, "unsupported power role 0x%02lx\n", ctrl & (EN_SRC_ONLY_BIT | EN_SNK_ONLY_BIT)); return -EINVAL; } chg->power_role = *val; return rc; } inline int smblite_lib_get_usb_prop_typec_accessory_mode(struct smb_charger *chg, int *val) { if (chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_MICRO_USB) { *val = TYPEC_ACCESSORY_NONE; return 0; } chg->typec_mode = smblite_lib_get_prop_typec_mode(chg); switch (chg->typec_mode) { case QTI_POWER_SUPPLY_TYPEC_NONE: *val = TYPEC_ACCESSORY_NONE; break; case QTI_POWER_SUPPLY_TYPEC_SINK_AUDIO_ADAPTER: *val = TYPEC_ACCESSORY_AUDIO; break; case QTI_POWER_SUPPLY_TYPEC_SINK_DEBUG_ACCESSORY: *val = TYPEC_ACCESSORY_DEBUG; break; default: *val = -EINVAL; } return 0; } int smblite_lib_get_prop_input_current_settled(struct smb_charger *chg, int *val) { return smblite_lib_get_charge_param(chg, &chg->param.icl_stat, val); } int smblite_lib_get_prop_input_voltage_settled(struct smb_charger *chg, int *val) { union power_supply_propval pval = {0, }; int rc; rc = smblite_lib_get_prop_usb_voltage_now(chg, &pval); *val = pval.intval; return rc; } int smblite_lib_get_prop_die_health(struct smb_charger *chg) { int rc; u8 stat; int input_present; rc = smblite_lib_is_input_present(chg, &input_present); if (rc < 0) return rc; if (input_present == INPUT_NOT_PRESENT) return POWER_SUPPLY_HEALTH_UNKNOWN; rc = smblite_lib_read(chg, DIE_TEMP_STATUS_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read DIE_TEMP_STATUS_REG, rc=%d\n", rc); return POWER_SUPPLY_HEALTH_UNKNOWN; } if (stat & DIE_TEMP_RST_BIT) return POWER_SUPPLY_HEALTH_OVERHEAT; if (stat & DIE_TEMP_UB_BIT) return POWER_SUPPLY_HEALTH_HOT; if (stat & DIE_TEMP_LB_BIT) return POWER_SUPPLY_HEALTH_WARM; return POWER_SUPPLY_HEALTH_COOL; } int smblite_lib_get_die_health(struct smb_charger *chg, int *val) { *val = smblite_lib_get_prop_die_health(chg); return 0; } int smblite_lib_get_prop_scope(struct smb_charger *chg, union power_supply_propval *val) { int rc; union power_supply_propval pval; val->intval = POWER_SUPPLY_SCOPE_UNKNOWN; rc = smblite_lib_get_prop_usb_present(chg, &pval); if (rc < 0) return rc; val->intval = pval.intval ? POWER_SUPPLY_SCOPE_DEVICE : chg->otg_present ? POWER_SUPPLY_SCOPE_SYSTEM : POWER_SUPPLY_SCOPE_UNKNOWN; return 0; } static int get_rp_based_dcp_current(struct smb_charger *chg, int typec_mode) { int rp_ua; switch (typec_mode) { case QTI_POWER_SUPPLY_TYPEC_SOURCE_HIGH: rp_ua = TYPEC_HIGH_CURRENT_UA; break; case QTI_POWER_SUPPLY_TYPEC_SOURCE_MEDIUM: case QTI_POWER_SUPPLY_TYPEC_SOURCE_DEFAULT: default: rp_ua = DCP_CURRENT_UA; } return rp_ua; } /******************* * USB PSY SETTERS * * *****************/ int smblite_lib_set_prop_usb_type(struct smb_charger *chg, const int val) { smblite_lib_dbg(chg, PR_MISC, "Charger type request form USB driver type=%d\n", val); /* update real charger type */ smblite_lib_update_usb_type(chg, val); /* For SDP rely on USB enumeration based reported the current */ if ((chg->real_charger_type == POWER_SUPPLY_TYPE_USB) || (chg->real_charger_type == POWER_SUPPLY_TYPE_UNKNOWN)) return 0; vote(chg->usb_icl_votable, USB_PSY_VOTER, false, 0); update_sw_icl_max(chg, chg->real_charger_type); power_supply_changed(chg->usb_psy); return 0; } int smblite_lib_set_prop_current_max(struct smb_charger *chg, const union power_supply_propval *val) { int rc = 0; smblite_lib_dbg(chg, PR_MISC, "Current request from USB driver current=%dmA, charger_type=%d\n", val->intval, chg->real_charger_type); if (chg->real_charger_type == QTI_POWER_SUPPLY_TYPE_USB_FLOAT) { if (val->intval == -ETIMEDOUT) { if ((chg->float_cfg & FLOAT_OPTIONS_MASK) == FORCE_FLOAT_SDP_CFG_BIT) { /* * Confiugure USB500 mode if Float charger is * configured for SDP mode. */ rc = vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, true, USBIN_500UA); if (rc < 0) smblite_lib_err(chg, "Couldn't set SDP ICL rc=%d\n", rc); return rc; } /* Set ICL to 1.5A if its configured for DCP */ rc = vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, true, DCP_CURRENT_UA); if (rc < 0) return rc; } else { /* * FLOAT charger detected as SDP by USB driver, * charge with the requested current and update the * real_charger_type */ chg->real_charger_type = POWER_SUPPLY_TYPE_USB; rc = vote(chg->usb_icl_votable, USB_PSY_VOTER, true, val->intval); if (rc < 0) return rc; rc = vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, false, 0); if (rc < 0) return rc; } } else if (chg->real_charger_type == POWER_SUPPLY_TYPE_USB) { rc = vote(chg->usb_icl_votable, USB_PSY_VOTER, true, val->intval); if (rc < 0) { pr_err("Couldn't vote ICL USB_PSY_VOTER rc=%d\n", rc); return rc; } rc = vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, false, 0); if (rc < 0) { pr_err("Couldn't remove SW_ICL_MAX vote rc=%d\n", rc); return rc; } /* Update TypeC Rp based current */ if (chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_TYPEC) { update_sw_icl_max(chg, chg->real_charger_type); } else if (is_flashlite_active(chg) && (val->intval >= USBIN_400UA)) { /* For Uusb based SDP port */ vote(chg->usb_icl_votable, FLASH_ACTIVE_VOTER, true, val->intval - USBIN_300UA); smblite_lib_dbg(chg, PR_MISC, "flash_active = 1, ICL set to %d\n", val->intval - USBIN_300UA); } } return 0; } int smblite_lib_set_prop_typec_power_role(struct smb_charger *chg, const int val) { int rc = 0; u8 power_role; if (chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_MICRO_USB) return -EINVAL; smblite_lib_dbg(chg, PR_MISC, "power role change: %d --> %d!", chg->power_role, val); if (chg->power_role == val) { smblite_lib_dbg(chg, PR_MISC, "power role already in %d, ignore!", chg->power_role); return 0; } switch (val) { case QTI_POWER_SUPPLY_TYPEC_PR_NONE: power_role = TYPEC_DISABLE_CMD_BIT; break; case QTI_POWER_SUPPLY_TYPEC_PR_DUAL: power_role = 0; break; case QTI_POWER_SUPPLY_TYPEC_PR_SINK: power_role = EN_SNK_ONLY_BIT; break; case QTI_POWER_SUPPLY_TYPEC_PR_SOURCE: power_role = EN_SRC_ONLY_BIT; break; default: smblite_lib_err(chg, "power role %d not supported\n", val); return -EINVAL; } rc = smblite_lib_masked_write(chg, TYPE_C_MODE_CFG_REG(chg->base), TYPEC_POWER_ROLE_CMD_MASK | TYPEC_TRY_MODE_MASK, power_role); if (rc < 0) { smblite_lib_err(chg, "Couldn't write 0x%02x to TYPE_C_INTRPT_ENB_SOFTWARE_CTRL rc=%d\n", power_role, rc); return rc; } chg->power_role = val; return rc; } int smblite_lib_set_prop_ship_mode(struct smb_charger *chg, const int val) { int rc; smblite_lib_dbg(chg, PR_MISC, "Set ship mode: %d!!\n", !!val); rc = smblite_lib_masked_write(chg, SHIP_MODE_REG(chg->base), SHIP_MODE_EN_BIT, !!val ? SHIP_MODE_EN_BIT : 0); if (rc < 0) dev_err(chg->dev, "Couldn't %s ship mode, rc=%d\n", !!val ? "enable" : "disable", rc); return rc; } #define JEITA_SOFT 0 #define JEITA_HARD 1 static int smblite_lib_update_jeita(struct smb_charger *chg, u32 *thresholds, int type) { int rc; u16 temp, base_low, base_high; base_low = (type == JEITA_SOFT) ? CHGR_JEITA_COOL_THRESHOLD_REG(chg->base) : CHGR_JEITA_COLD_THRESHOLD_REG(chg->base); base_high = (type == JEITA_SOFT) ? CHGR_JEITA_WARM_THRESHOLD_REG(chg->base) : CHGR_JEITA_HOT_THRESHOLD_REG(chg->base); temp = thresholds[1] & 0xFFFF; temp = ((temp & 0xFF00) >> 8) | ((temp & 0xFF) << 8); rc = smblite_lib_batch_write(chg, base_high, (u8 *)&temp, 2); if (rc < 0) { smblite_lib_err(chg, "Couldn't configure Jeita %s hot threshold rc=%d\n", (type == JEITA_SOFT) ? "Soft" : "Hard", rc); return rc; } temp = thresholds[0] & 0xFFFF; temp = ((temp & 0xFF00) >> 8) | ((temp & 0xFF) << 8); rc = smblite_lib_batch_write(chg, base_low, (u8 *)&temp, 2); if (rc < 0) { smblite_lib_err(chg, "Couldn't configure Jeita %s cold threshold rc=%d\n", (type == JEITA_SOFT) ? "Soft" : "Hard", rc); return rc; } smblite_lib_dbg(chg, PR_MISC, "%s Jeita threshold configured\n", (type == JEITA_SOFT) ? "Soft" : "Hard"); return 0; } static int smblite_lib_charge_inhibit_en(struct smb_charger *chg, bool enable) { int rc; rc = smblite_lib_masked_write(chg, CHGR_INHIBIT_REG(chg->base), CHGR_INHIBIT_BIT, enable ? CHGR_INHIBIT_BIT : 0); return rc; } static int smblite_lib_soft_jeita_arb_wa(struct smb_charger *chg) { union power_supply_propval pval; int rc = 0; bool soft_jeita; rc = smblite_lib_get_prop_batt_health(chg, &pval); if (rc < 0) { smblite_lib_err(chg, "Couldn't get battery health rc=%d\n", rc); return rc; } /* Do nothing on entering hard JEITA condition */ if (pval.intval == POWER_SUPPLY_HEALTH_COLD || pval.intval == POWER_SUPPLY_HEALTH_HOT) return 0; if (chg->jeita_soft_fcc[0] < 0 || chg->jeita_soft_fcc[1] < 0 || chg->jeita_soft_fv[0] < 0 || chg->jeita_soft_fv[1] < 0) return 0; soft_jeita = (pval.intval == POWER_SUPPLY_HEALTH_COOL) || (pval.intval == POWER_SUPPLY_HEALTH_WARM); /* Do nothing on entering soft JEITA from hard JEITA */ if (chg->jeita_arb_flag && soft_jeita) return 0; /* Do nothing, initial to health condition */ if (!chg->jeita_arb_flag && !soft_jeita) return 0; /* Entering soft JEITA from normal state */ if (!chg->jeita_arb_flag && soft_jeita) { vote(chg->chg_disable_votable, JEITA_ARB_VOTER, true, 0); rc = smblite_lib_charge_inhibit_en(chg, true); if (rc < 0) smblite_lib_err(chg, "Couldn't enable charge inhibit rc=%d\n", rc); rc = smblite_lib_update_jeita(chg, chg->jeita_soft_hys_thlds, JEITA_SOFT); if (rc < 0) smblite_lib_err(chg, "Couldn't configure Jeita soft threshold rc=%d\n", rc); if (pval.intval == POWER_SUPPLY_HEALTH_COOL) { vote(chg->fcc_votable, JEITA_ARB_VOTER, true, chg->jeita_soft_fcc[0]); vote(chg->fv_votable, JEITA_ARB_VOTER, true, chg->jeita_soft_fv[0]); } else { vote(chg->fcc_votable, JEITA_ARB_VOTER, true, chg->jeita_soft_fcc[1]); vote(chg->fv_votable, JEITA_ARB_VOTER, true, chg->jeita_soft_fv[1]); } vote(chg->chg_disable_votable, JEITA_ARB_VOTER, false, 0); chg->jeita_arb_flag = true; } else if (chg->jeita_arb_flag && !soft_jeita) { /* Exit to health state from soft JEITA */ vote(chg->chg_disable_votable, JEITA_ARB_VOTER, true, 0); rc = smblite_lib_charge_inhibit_en(chg, false); if (rc < 0) smblite_lib_err(chg, "Couldn't disable charge inhibit rc=%d\n", rc); rc = smblite_lib_update_jeita(chg, chg->jeita_soft_thlds, JEITA_SOFT); if (rc < 0) smblite_lib_err(chg, "Couldn't configure Jeita soft threshold rc=%d\n", rc); vote(chg->fcc_votable, JEITA_ARB_VOTER, false, 0); vote(chg->fv_votable, JEITA_ARB_VOTER, false, 0); vote(chg->chg_disable_votable, JEITA_ARB_VOTER, false, 0); chg->jeita_arb_flag = false; } smblite_lib_dbg(chg, PR_MISC, "JEITA ARB status %d, soft JEITA status %d\n", chg->jeita_arb_flag, soft_jeita); return rc; } /************************ * USB MAIN PSY SETTERS * ************************/ int smblite_lib_get_hw_current_max(struct smb_charger *chg, int *total_current_ua) { union power_supply_propval val = {0, }; int rc = 0, typec_source_rd, current_ua; bool non_compliant; u8 stat; rc = smblite_lib_read(chg, LEGACY_CABLE_STATUS_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read TYPE_C_STATUS_5 rc=%d\n", rc); return rc; } non_compliant = stat & TYPEC_NONCOMP_LEGACY_CABLE_STATUS_BIT; /* get settled ICL */ rc = smblite_lib_get_prop_input_current_settled(chg, &val.intval); if (rc < 0) { smblite_lib_err(chg, "Couldn't get settled ICL rc=%d\n", rc); return rc; } typec_source_rd = smblite_lib_get_prop_ufp_mode(chg); if ((chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_MICRO_USB) || (non_compliant && !chg->typec_legacy_use_rp_icl)) { switch (chg->real_charger_type) { case POWER_SUPPLY_TYPE_USB_CDP: current_ua = CDP_CURRENT_UA; break; case POWER_SUPPLY_TYPE_USB_DCP: current_ua = DCP_CURRENT_UA; break; default: current_ua = 0; break; } *total_current_ua = max(current_ua, val.intval); return 0; } switch (typec_source_rd) { case QTI_POWER_SUPPLY_TYPEC_SOURCE_DEFAULT: switch (chg->real_charger_type) { case POWER_SUPPLY_TYPE_USB_CDP: current_ua = CDP_CURRENT_UA; break; case POWER_SUPPLY_TYPE_USB_DCP: current_ua = DCP_CURRENT_UA; break; default: current_ua = 0; break; } break; case QTI_POWER_SUPPLY_TYPEC_SOURCE_MEDIUM: current_ua = TYPEC_MEDIUM_CURRENT_UA; break; case QTI_POWER_SUPPLY_TYPEC_SOURCE_HIGH: current_ua = TYPEC_HIGH_CURRENT_UA; break; case QTI_POWER_SUPPLY_TYPEC_NON_COMPLIANT: case QTI_POWER_SUPPLY_TYPEC_NONE: default: current_ua = 0; break; } *total_current_ua = max(current_ua, val.intval); return 0; } int smblite_lib_get_charge_current(struct smb_charger *chg, int *total_current_ua) { if (chg->usb_icl_votable) *total_current_ua = get_effective_result(chg->usb_icl_votable); return 0; } /********************** * INTERRUPT HANDLERS * **********************/ irqreturn_t smblite_default_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; smblite_lib_dbg(chg, PR_INTERRUPT, "IRQ: %s\n", irq_data->name); return IRQ_HANDLED; } irqreturn_t smblite_chg_state_change_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; u8 stat, boost_en_chgr; int rc; int present; smblite_lib_dbg(chg, PR_INTERRUPT, "IRQ: %s\n", irq_data->name); rc = smblite_lib_read(chg, BATTERY_CHARGER_STATUS_1_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read BATTERY_CHARGER_STATUS_1 rc=%d\n", rc); goto failure; } stat = stat & BATTERY_CHARGER_STATUS_MASK; rc = smblite_lib_is_input_present(chg, &present); if (rc < 0) { smblite_lib_err(chg, "Couldn't read USB_INPUT status rc=%d\n", rc); goto failure; } if ((chg->subtype == PM5100) && !!present) { rc = smblite_lib_read(chg, CHGR_CHG_EN_STATUS_REG(chg->base), &boost_en_chgr); if (rc < 0) { smblite_lib_err(chg, "Couldn't read BATTERY_CHARGER_STATUS_1 rc=%d\n", rc); goto failure; } /* * Every time BOOST disables charging, reset the FCC stepper from * fcc_step_start. Enforce this by using the override voter. when * BOOST-disable re-enables charging restart the stepper from * fcc_step_start */ if (boost_en_chgr & CHARGING_DISABLED_FROM_BOOST_BIT) { vote_override(chg->fcc_main_votable, FCC_STEPPER_VOTER, true, chg->chg_param.fcc_step_start_ua); vote(chg->fcc_votable, FCC_STEPPER_VOTER, true, chg->chg_param.fcc_step_start_ua); smblite_lib_dbg(chg, PR_INTERRUPT, "Reset FCC stepper due to boost enabled\n"); } else { vote_override(chg->fcc_main_votable, FCC_STEPPER_VOTER, false, chg->chg_param.fcc_step_start_ua); /* Remove this vote to allow stepper to ramp-up */ vote(chg->fcc_votable, FCC_STEPPER_VOTER, false, 0); } } power_supply_changed(chg->batt_psy); failure: return IRQ_HANDLED; } irqreturn_t smblite_batt_temp_changed_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; int rc; smblite_lib_dbg(chg, PR_INTERRUPT, "IRQ: %s\n", irq_data->name); if (chg->jeita_configured != JEITA_CFG_COMPLETE) return IRQ_HANDLED; rc = smblite_lib_soft_jeita_arb_wa(chg); if (rc < 0) { smblite_lib_err(chg, "Couldn't fix soft jeita arb rc=%d\n", rc); return IRQ_HANDLED; } return IRQ_HANDLED; } irqreturn_t smblite_batt_psy_changed_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; smblite_lib_dbg(chg, PR_INTERRUPT, "IRQ: %s\n", irq_data->name); power_supply_changed(chg->batt_psy); return IRQ_HANDLED; } #define AICL_STEP_MV 200 #define MAX_AICL_THRESHOLD_MV 4800 irqreturn_t smblite_usbin_uv_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; struct storm_watch *wdata; int rc; smblite_lib_dbg(chg, PR_INTERRUPT, "IRQ: %s\n", irq_data->name); if ((chg->wa_flags & WEAK_ADAPTER_WA) && is_storming(&irq_data->storm_data)) { if (chg->aicl_max_reached) { smblite_lib_dbg(chg, PR_MISC, "USBIN_UV storm at max AICL threshold\n"); return IRQ_HANDLED; } smblite_lib_dbg(chg, PR_MISC, "USBIN_UV storm at threshold %d\n", chg->aicl_5v_threshold_mv); /* suspend USBIN before updating AICL threshold */ vote(chg->usb_icl_votable, AICL_THRESHOLD_VOTER, true, 0); /* delay for VASHDN deglitch */ msleep(20); if (chg->aicl_5v_threshold_mv > MAX_AICL_THRESHOLD_MV) { /* reached max AICL threshold */ chg->aicl_max_reached = true; goto unsuspend_input; } /* Increase AICL threshold by 200mV */ rc = smblite_lib_set_charge_param(chg, &chg->param.aicl_5v_threshold, chg->aicl_5v_threshold_mv + AICL_STEP_MV); if (rc < 0) dev_err(chg->dev, "Error in setting AICL threshold rc=%d\n", rc); else chg->aicl_5v_threshold_mv += AICL_STEP_MV; unsuspend_input: /* Force torch in boost mode to ensure it works with low ICL */ if (chg->subtype == PM2250) schgm_flashlite_torch_priority(chg, TORCH_BOOST_MODE); if (chg->aicl_max_reached) { smblite_lib_dbg(chg, PR_MISC, "Reached max AICL threshold resctricting ICL to 100mA\n"); vote(chg->usb_icl_votable, AICL_THRESHOLD_VOTER, true, USBIN_100UA); smblite_lib_run_aicl(chg, RESTART_AICL); } else { smblite_lib_run_aicl(chg, RESTART_AICL); vote(chg->usb_icl_votable, AICL_THRESHOLD_VOTER, false, 0); } wdata = &chg->irq_info[USBIN_UV_IRQ].irq_data->storm_data; reset_storm_count(wdata); } if (!chg->irq_info[SWITCHER_POWER_OK_IRQ].irq_data) return IRQ_HANDLED; wdata = &chg->irq_info[SWITCHER_POWER_OK_IRQ].irq_data->storm_data; reset_storm_count(wdata); return IRQ_HANDLED; } #define USB_WEAK_INPUT_UA 1400000 #define ICL_CHANGE_DELAY_MS 1000 irqreturn_t smblite_icl_change_irq_handler(int irq, void *data) { int rc, settled_ua, delay = ICL_CHANGE_DELAY_MS; struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; if (chg->mode == PARALLEL_MASTER) { rc = smblite_lib_get_charge_param(chg, &chg->param.icl_stat, &settled_ua); if (rc < 0) { smblite_lib_err(chg, "Couldn't get ICL status rc=%d\n", rc); return IRQ_HANDLED; } /* If AICL settled then schedule work now */ if (settled_ua == get_effective_result(chg->usb_icl_votable)) delay = 0; cancel_delayed_work_sync(&chg->icl_change_work); schedule_delayed_work(&chg->icl_change_work, msecs_to_jiffies(delay)); } return IRQ_HANDLED; } static int smblite_lib_role_switch_failure(struct smb_charger *chg) { int rc = 0; union power_supply_propval pval = {0, }; if (!chg->use_extcon) return 0; rc = smblite_lib_get_prop_usb_present(chg, &pval); if (rc < 0) { smblite_lib_err(chg, "Couldn't get usb presence status rc=%d\n", rc); return rc; } /* * When role switch fails notify the * current charger state to usb driver. */ if (pval.intval) { smblite_lib_dbg(chg, PR_MISC, "Role reversal failed, notifying device mode to usb driver.\n"); smblite_lib_notify_device_mode(chg, true); } return rc; } static int typec_partner_register(struct smb_charger *chg) { int typec_mode, rc = 0; mutex_lock(&chg->typec_lock); if (!chg->typec_port || chg->pr_swap_in_progress) goto unlock; if (!chg->typec_partner) { if (chg->sink_src_mode == AUDIO_ACCESS_MODE) chg->typec_partner_desc.accessory = TYPEC_ACCESSORY_AUDIO; else chg->typec_partner_desc.accessory = TYPEC_ACCESSORY_NONE; chg->typec_partner = typec_register_partner(chg->typec_port, &chg->typec_partner_desc); if (IS_ERR(chg->typec_partner)) { rc = PTR_ERR(chg->typec_partner); pr_err("Couldn't to register typec_partner rc=%d\n", rc); goto unlock; } } if (chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_MICRO_USB) goto unlock; typec_mode = smblite_lib_get_prop_typec_mode(chg); if (typec_mode >= QTI_POWER_SUPPLY_TYPEC_SOURCE_DEFAULT || typec_mode == QTI_POWER_SUPPLY_TYPEC_NONE) { if (chg->typec_role_swap_failed) { rc = smblite_lib_role_switch_failure(chg); if (rc < 0) smblite_lib_err(chg, "Failed to role switch rc=%d\n", rc); chg->typec_role_swap_failed = false; } typec_set_data_role(chg->typec_port, TYPEC_DEVICE); typec_set_pwr_role(chg->typec_port, TYPEC_SINK); } else { typec_set_data_role(chg->typec_port, TYPEC_HOST); typec_set_pwr_role(chg->typec_port, TYPEC_SOURCE); } unlock: mutex_unlock(&chg->typec_lock); return rc; } static void typec_partner_unregister(struct smb_charger *chg) { mutex_lock(&chg->typec_lock); if (!chg->typec_port) goto unlock; if (chg->typec_partner && !chg->pr_swap_in_progress) { smblite_lib_dbg(chg, PR_MISC, "Un-registering typeC partner\n"); typec_unregister_partner(chg->typec_partner); chg->typec_partner = NULL; } unlock: mutex_unlock(&chg->typec_lock); } static void smblite_lib_micro_usb_plugin(struct smb_charger *chg, bool vbus_rising) { int rc = 0; u8 stat; if (vbus_rising) { /* * Send extcon notification for only Non-ADSP supported charger. */ if (chg->subtype == PM2250) smblite_lib_notify_device_mode(chg, true); rc = typec_partner_register(chg); if (rc < 0) smblite_lib_err(chg, "Couldn't register partner rc =%d\n", rc); /* * For PM5100 check if concurrent mode support is enabled and * charging is paused in hardware due to boost being enabled, * force charging to be disabled in SW. */ if (is_concurrent_mode_supported(chg)) { rc = smblite_lib_read(chg, CHGR_CHG_EN_STATUS_REG(chg->base), &stat); if (rc < 0) smblite_lib_err(chg, "Couldn't read CHGR_EN_STATUS_REG rc=%d\n", rc); vote(chg->chg_disable_votable, CONCURRENT_MODE_VOTER, (stat & CHARGING_DISABLED_FROM_BOOST_BIT), 0); smblite_lib_dbg(chg, PR_MISC, "charger_en_status=%x, Charging disable by boost\n", stat); } if (chg->wa_flags & HDC_ICL_REDUCTION_WA) { rc = smblite_lib_masked_write(chg, BATIF_PULLDOWN_VPH_CONTROL(chg->base), BATIF_PULLDOWN_VPH_SEL_MASK, (PULLDOWN_VPH_SW_EN_BIT | PULLDOWN_VPH_HW_EN_BIT)); if (rc < 0) smblite_lib_err(chg, "Couldn't set BATIF_PULLDOWN_VPH_CONTROL rc=%d\n", rc); rc = smblite_lib_run_aicl(chg, RERUN_AICL); if (rc < 0) smblite_lib_err(chg, "Couldn't rerun AICL rc=%d\n", rc); } } else { smblite_lib_notify_device_mode(chg, false); smblite_lib_uusb_removal(chg); typec_partner_unregister(chg); if (chg->wa_flags & HDC_ICL_REDUCTION_WA) { rc = smblite_lib_masked_write(chg, BATIF_PULLDOWN_VPH_CONTROL(chg->base), BATIF_PULLDOWN_VPH_SEL_MASK, PULLDOWN_VPH_HW_EN_BIT); if (rc < 0) smblite_lib_err(chg, "Couldn't set BATIF_PULLDOWN_VPH_CONTROL rc=%d\n", rc); } } } static int smblite_lib_request_dpdm(struct smb_charger *chg, bool enable) { int rc = 0; /* Enable dpdm requests only for platform with PM5100 */ if (chg->subtype != PM5100) return 0; /* fetch the DPDM regulator */ if (!chg->dpdm_reg && of_get_property(chg->dev->of_node, "dpdm-supply", NULL)) { chg->dpdm_reg = devm_regulator_get(chg->dev, "dpdm"); if (IS_ERR(chg->dpdm_reg)) { rc = PTR_ERR(chg->dpdm_reg); smblite_lib_err(chg, "Couldn't get dpdm regulator rc=%d\n", rc); chg->dpdm_reg = NULL; return rc; } } mutex_lock(&chg->dpdm_lock); if (enable) { if (chg->dpdm_reg && !chg->dpdm_enabled) { smblite_lib_dbg(chg, PR_MISC, "enabling DPDM regulator\n"); rc = regulator_enable(chg->dpdm_reg); if (rc < 0) smblite_lib_err(chg, "Couldn't enable dpdm regulator rc=%d\n", rc); else chg->dpdm_enabled = true; } } else { if (chg->dpdm_reg && chg->dpdm_enabled) { smblite_lib_dbg(chg, PR_MISC, "disabling DPDM regulator\n"); rc = regulator_disable(chg->dpdm_reg); if (rc < 0) smblite_lib_err(chg, "Couldn't disable dpdm regulator rc=%d\n", rc); else chg->dpdm_enabled = false; } } mutex_unlock(&chg->dpdm_lock); return rc; } #define PL_DELAY_MS 30000 static void smblite_lib_usb_plugin_locked(struct smb_charger *chg) { int rc; u8 stat; bool vbus_rising; struct smb_irq_data *data; struct storm_watch *wdata; rc = smblite_lib_read(chg, chg->base.usbin_base + INT_RT_STS_OFFSET, &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read USB_INT_RT_STS rc=%d\n", rc); return; } vbus_rising = (bool)(stat & USBIN_PLUGIN_RT_STS_BIT); if (vbus_rising) { /* Remove FCC_STEPPER 1.5A init vote to allow FCC ramp up */ if (chg->fcc_stepper_enable) vote(chg->fcc_votable, FCC_STEPPER_VOTER, false, 0); rc = smblite_lib_request_dpdm(chg, true); if (rc < 0) smblite_lib_err(chg, "Couldn't to enable DPDM rc=%d\n", rc); /* Schedule work to enable parallel charger */ vote(chg->awake_votable, PL_DELAY_VOTER, true, 0); schedule_delayed_work(&chg->pl_enable_work, msecs_to_jiffies(PL_DELAY_MS)); } else { smblite_lib_update_usb_type(chg, POWER_SUPPLY_TYPE_UNKNOWN); if (chg->wa_flags & BOOST_BACK_WA) { data = chg->irq_info[SWITCHER_POWER_OK_IRQ].irq_data; if (data) { wdata = &data->storm_data; update_storm_count(wdata, WEAK_CHG_STORM_COUNT); vote(chg->usb_icl_votable, BOOST_BACK_VOTER, false, 0); vote(chg->usb_icl_votable, WEAK_CHARGER_VOTER, false, 0); } } if (chg->fcc_stepper_enable) vote(chg->fcc_votable, FCC_STEPPER_VOTER, true, chg->chg_param.fcc_step_start_ua); if (chg->wa_flags & WEAK_ADAPTER_WA) { chg->aicl_5v_threshold_mv = chg->default_aicl_5v_threshold_mv; smblite_lib_set_charge_param(chg, &chg->param.aicl_5v_threshold, chg->aicl_5v_threshold_mv); chg->aicl_max_reached = false; /* * schgm_flash_torch_priority(chg, TORCH_BUCK_MODE); */ data = chg->irq_info[USBIN_UV_IRQ].irq_data; if (data) { wdata = &data->storm_data; reset_storm_count(wdata); } vote(chg->usb_icl_votable, AICL_THRESHOLD_VOTER, false, 0); } rc = smblite_lib_request_dpdm(chg, false); if (rc < 0) smblite_lib_err(chg, "Couldn't to disable DPDM rc=%d\n", rc); } if (chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_MICRO_USB) smblite_lib_micro_usb_plugin(chg, vbus_rising); vote(chg->temp_change_irq_disable_votable, DEFAULT_VOTER, !vbus_rising, 0); power_supply_changed(chg->usb_psy); smblite_lib_dbg(chg, PR_INTERRUPT, "IRQ: usbin-plugin %s\n", vbus_rising ? "attached" : "detached"); } irqreturn_t smblite_usb_plugin_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; smblite_lib_usb_plugin_locked(chg); return IRQ_HANDLED; } static void update_sw_icl_max(struct smb_charger *chg, int type) { int typec_mode; int rp_ua, icl_ua; if (chg->typec_mode == QTI_POWER_SUPPLY_TYPEC_SINK_AUDIO_ADAPTER) { vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, true, 500000); return; } if (chg->real_charger_type == POWER_SUPPLY_TYPE_UNKNOWN) { vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, true, USBIN_100UA); return; } /* TypeC rp med or high, use rp value */ typec_mode = smblite_lib_get_prop_typec_mode(chg); if (typec_rp_med_high(chg, typec_mode)) { rp_ua = get_rp_based_dcp_current(chg, typec_mode); vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, true, rp_ua); vote(chg->usb_icl_votable, USB_PSY_VOTER, false, 0); return; } /* rp-std or legacy, USB BC 1.2 */ switch (type) { case POWER_SUPPLY_TYPE_USB: /* * USB_PSY will vote to increase the current to 500/900mA once * enumeration is done. */ if (!is_client_vote_enabled(chg->usb_icl_votable, USB_PSY_VOTER)) { /* if flash is active force 500mA */ vote(chg->usb_icl_votable, USB_PSY_VOTER, true, is_flashlite_active(chg) ? USBIN_500UA : USBIN_100UA); } vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, false, 0); break; case POWER_SUPPLY_TYPE_USB_CDP: vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, true, CDP_CURRENT_UA); break; case POWER_SUPPLY_TYPE_USB_DCP: rp_ua = get_rp_based_dcp_current(chg, typec_mode); vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, true, rp_ua); break; case QTI_POWER_SUPPLY_TYPE_USB_FLOAT: /* * limit ICL to 100mA, the USB driver will enumerate to check * if this is a SDP and appropriately set the current */ vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, true, USBIN_100UA); break; case POWER_SUPPLY_TYPE_UNKNOWN: default: vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, true, USBIN_100UA); break; } if (is_flashlite_active(chg)) { icl_ua = get_effective_result(chg->usb_icl_votable); if (icl_ua >= USBIN_400UA) { vote(chg->usb_icl_votable, FLASH_ACTIVE_VOTER, true, icl_ua - USBIN_300UA); smblite_lib_dbg(chg, PR_MISC, "flash_active = 1 ICL is set to %d\n", icl_ua - USBIN_300UA); } } } void smblite_lib_hvdcp_detect_enable(struct smb_charger *chg, bool enable) { int rc; u8 mask; mask = HVDCP_NO_AUTH_QC3_CFG_BIT | HVDCP_EN_BIT; rc = smblite_lib_masked_write(chg, USBIN_QC23_EN_REG(chg->base), mask, enable ? mask : 0); if (rc < 0) smblite_lib_err(chg, "failed to write USBIN_QC23_EN_REG rc=%d\n", rc); } /* triggers when HVDCP is detected */ static void smblite_lib_handle_hvdcp_detect_done(struct smb_charger *chg, bool rising) { smblite_lib_dbg(chg, PR_INTERRUPT, "IRQ: hvdcp-detect-done %s\n", rising ? "rising" : "falling"); } void smblite_lib_rerun_apsd(struct smb_charger *chg) { int rc; smblite_lib_dbg(chg, PR_MISC, "re-running APSD\n"); rc = smblite_lib_masked_write(chg, CMD_APSD_REG(chg->base), APSD_RERUN_BIT, APSD_RERUN_BIT); if (rc < 0) smblite_lib_err(chg, "Couldn't re-run APSD rc=%d\n", rc); } int smblite_lib_rerun_apsd_if_required(struct smb_charger *chg) { union power_supply_propval val; int rc; rc = smblite_lib_get_prop_usb_present(chg, &val); if (rc < 0) { smblite_lib_err(chg, "Couldn't get usb present rc = %d\n", rc); return rc; } if (!val.intval) return 0; rc = smblite_lib_request_dpdm(chg, true); if (rc < 0) smblite_lib_err(chg, "Couldn't to enable DPDM rc=%d\n", rc); chg->uusb_apsd_rerun_done = true; smblite_lib_rerun_apsd(chg); return 0; } static void smblite_lib_handle_apsd_done(struct smb_charger *chg, bool rising) { const struct apsd_result *apsd_result = smblite_lib_get_apsd_result(chg); if (!rising) return; apsd_result = smblite_lib_update_usb_type(chg, apsd_result->val); /* set the ICL based on charger type */ update_sw_icl_max(chg, apsd_result->val); switch (apsd_result->bit) { case SDP_CHARGER_BIT: case CDP_CHARGER_BIT: case FLOAT_CHARGER_BIT: if (chg->use_extcon) smblite_lib_notify_device_mode(chg, true); break; case OCP_CHARGER_BIT: case DCP_CHARGER_BIT: break; default: break; } smblite_lib_dbg(chg, PR_INTERRUPT, "IRQ: apsd-done rising; %s detected\n", apsd_result->name); } static void smblite_lib_handle_hvdcp_check_timeout(struct smb_charger *chg, bool rising, bool qc_charger) { int rc = 0; /* Stay at 5V if BOOST is enabled */ if (is_boost_en(chg)) { smblite_lib_dbg(chg, PR_INTERRUPT, "Ignoring HVDCP3 detect as boost is enabled\n"); return; } if (rising) { if (qc_charger && !chg->hvdcp3_detected) { /* Increase vbus to MAX(6V), if incremented HVDCP_3 is detected */ rc = smblite_lib_hvdcp3_force_max_vbus(chg); if (rc < 0) smblite_lib_err(chg, "HVDCP3 detection failure\n"); } } smblite_lib_dbg(chg, PR_INTERRUPT, "IRQ: %s %s, hvdcp3_detected=%s\n", __func__, (rising ? "rising" : "falling"), (chg->hvdcp3_detected ? "True" : "False")); } static void smblite_lib_handle_sdp_enumeration_done(struct smb_charger *chg, bool rising) { smblite_lib_dbg(chg, PR_INTERRUPT, "IRQ: sdp-enumeration-done %s\n", rising ? "rising" : "falling"); } static void smblite_lib_handle_slow_plugin_timeout(struct smb_charger *chg, bool rising) { smblite_lib_dbg(chg, PR_INTERRUPT, "IRQ: slow-plugin-timeout %s\n", rising ? "rising" : "falling"); } irqreturn_t smblite_usb_source_change_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; int rc = 0; u8 stat; rc = smblite_lib_read(chg, APSD_STATUS_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read APSD_STATUS rc=%d\n", rc); return IRQ_HANDLED; } smblite_lib_dbg(chg, PR_INTERRUPT, "APSD_STATUS = 0x%02x\n", stat); if ((chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_MICRO_USB) && (stat & APSD_DTC_STATUS_DONE_BIT) && !chg->uusb_apsd_rerun_done) { /* * Force re-run APSD to handle slow insertion related * charger-mis-detection. */ chg->uusb_apsd_rerun_done = true; smblite_lib_rerun_apsd_if_required(chg); return IRQ_HANDLED; } smblite_lib_handle_apsd_done(chg, (bool)(stat & APSD_DTC_STATUS_DONE_BIT)); smblite_lib_handle_hvdcp_detect_done(chg, (bool)(stat & QC_CHARGER_BIT)); smblite_lib_handle_hvdcp_check_timeout(chg, (bool)(stat & HVDCP_CHECK_TIMEOUT_BIT), (bool)(stat & QC_CHARGER_BIT)); smblite_lib_handle_sdp_enumeration_done(chg, (bool)(stat & ENUMERATION_DONE_BIT)); smblite_lib_handle_slow_plugin_timeout(chg, (bool)(stat & SLOW_PLUGIN_TIMEOUT_BIT)); power_supply_changed(chg->usb_psy); rc = smblite_lib_read(chg, APSD_STATUS_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read APSD_STATUS rc=%d\n", rc); return IRQ_HANDLED; } smblite_lib_dbg(chg, PR_INTERRUPT, "APSD_STATUS = 0x%02x\n", stat); return IRQ_HANDLED; } static void typec_sink_insertion(struct smb_charger *chg) { smblite_lib_notify_usb_host(chg, true); } static void typec_src_insertion(struct smb_charger *chg) { int rc = 0; u8 stat; smblite_lib_notify_device_mode(chg, true); if (chg->pr_swap_in_progress) { vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, false, 0); return; } rc = smblite_lib_read(chg, LEGACY_CABLE_STATUS_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read TYPE_C_STATE_MACHINE_STATUS_REG rc=%d\n", rc); return; } chg->typec_legacy = stat & TYPEC_LEGACY_CABLE_STATUS_BIT; } static void typec_ra_ra_insertion(struct smb_charger *chg) { vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, true, 500000); vote(chg->usb_icl_votable, USB_PSY_VOTER, false, 0); } static const char * const dr_mode_text[] = { "ufp", "dfp", "none" }; static int smblite_lib_force_dr_mode(struct smb_charger *chg, int mode) { int rc = 0; switch (mode) { case TYPEC_PORT_SNK: rc = smblite_lib_masked_write(chg, TYPE_C_MODE_CFG_REG(chg->base), TYPEC_POWER_ROLE_CMD_MASK, EN_SNK_ONLY_BIT); if (rc < 0) { smblite_lib_err(chg, "Couldn't enable snk, rc=%d\n", rc); return rc; } break; case TYPEC_PORT_SRC: rc = smblite_lib_masked_write(chg, TYPE_C_MODE_CFG_REG(chg->base), TYPEC_POWER_ROLE_CMD_MASK, EN_SRC_ONLY_BIT); if (rc < 0) { smblite_lib_err(chg, "Couldn't enable src, rc=%d\n", rc); return rc; } break; case TYPEC_PORT_DRP: rc = smblite_lib_masked_write(chg, TYPE_C_MODE_CFG_REG(chg->base), TYPEC_POWER_ROLE_CMD_MASK, 0); if (rc < 0) { smblite_lib_err(chg, "Couldn't enable DRP, rc=%d\n", rc); return rc; } break; default: smblite_lib_err(chg, "Power role %d not supported\n", mode); return -EINVAL; } chg->dr_mode = mode; return rc; } int smblite_lib_typec_port_type_set(const struct typec_capability *cap, enum typec_port_type type) { struct smb_charger *chg = container_of(cap, struct smb_charger, typec_caps); int rc = 0; if (chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_MICRO_USB) return 0; mutex_lock(&chg->typec_lock); if ((chg->pr_swap_in_progress) || (type == TYPEC_PORT_DRP)) { smblite_lib_dbg(chg, PR_MISC, "Ignoring port type request type = %d swap_in_progress = %d\n", type, chg->pr_swap_in_progress); goto unlock; } chg->pr_swap_in_progress = true; rc = smblite_lib_force_dr_mode(chg, type); if (rc < 0) { chg->pr_swap_in_progress = false; smblite_lib_err(chg, "Couldn't to force mode, rc=%d\n", rc); goto unlock; } smblite_lib_dbg(chg, PR_MISC, "Requested role %s\n", type ? "SINK" : "SOURCE"); /* * As per the hardware requirements, * schedule the work with required delay. */ if (!(delayed_work_pending(&chg->role_reversal_check))) { cancel_delayed_work_sync(&chg->role_reversal_check); schedule_delayed_work(&chg->role_reversal_check, msecs_to_jiffies(ROLE_REVERSAL_DELAY_MS)); vote(chg->awake_votable, TYPEC_SWAP_VOTER, true, 0); } unlock: mutex_unlock(&chg->typec_lock); return rc; } static void smblite_lib_typec_role_check_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, role_reversal_check.work); int rc = 0; if (chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_MICRO_USB) { chg->pr_swap_in_progress = false; vote(chg->awake_votable, TYPEC_SWAP_VOTER, false, 0); return; } mutex_lock(&chg->typec_lock); switch (chg->dr_mode) { case TYPEC_PORT_SNK: if (chg->typec_mode < QTI_POWER_SUPPLY_TYPEC_SOURCE_DEFAULT) { smblite_lib_dbg(chg, PR_MISC, "Role reversal not latched to UFP in %d msecs. Resetting to DRP mode\n", ROLE_REVERSAL_DELAY_MS); rc = smblite_lib_force_dr_mode(chg, TYPEC_PORT_DRP); if (rc < 0) smblite_lib_err(chg, "Couldn't to set DRP mode, rc=%d\n", rc); } else { chg->power_role = QTI_POWER_SUPPLY_TYPEC_PR_SINK; typec_set_pwr_role(chg->typec_port, TYPEC_SINK); typec_set_data_role(chg->typec_port, TYPEC_DEVICE); smblite_lib_dbg(chg, PR_MISC, "Role changed successfully to SINK"); } break; case TYPEC_PORT_SRC: if (chg->typec_mode >= QTI_POWER_SUPPLY_TYPEC_SOURCE_DEFAULT || chg->typec_mode == QTI_POWER_SUPPLY_TYPEC_NONE) { smblite_lib_dbg(chg, PR_MISC, "Role reversal not latched to DFP in %d msecs. Resetting to DRP mode\n", ROLE_REVERSAL_DELAY_MS); chg->pr_swap_in_progress = false; chg->typec_role_swap_failed = true; rc = smblite_lib_force_dr_mode(chg, TYPEC_PORT_DRP); if (rc < 0) smblite_lib_err(chg, "Couldn't to set DRP mode, rc=%d\n", rc); } else { chg->power_role = QTI_POWER_SUPPLY_TYPEC_PR_SOURCE; typec_set_pwr_role(chg->typec_port, TYPEC_SOURCE); typec_set_data_role(chg->typec_port, TYPEC_HOST); smblite_lib_dbg(chg, PR_MISC, "Role changed successfully to SOURCE"); } break; default: pr_debug("Already in DRP mode\n"); break; } chg->pr_swap_in_progress = false; vote(chg->awake_votable, TYPEC_SWAP_VOTER, false, 0); mutex_unlock(&chg->typec_lock); } static void typec_sink_removal(struct smb_charger *chg) { if (chg->otg_present) smblite_lib_notify_usb_host(chg, false); } static void typec_src_removal(struct smb_charger *chg) { struct smb_irq_data *data; struct storm_watch *wdata; if (chg->wa_flags & BOOST_BACK_WA) { data = chg->irq_info[SWITCHER_POWER_OK_IRQ].irq_data; if (data) { wdata = &data->storm_data; update_storm_count(wdata, WEAK_CHG_STORM_COUNT); vote(chg->usb_icl_votable, BOOST_BACK_VOTER, false, 0); vote(chg->usb_icl_votable, WEAK_CHARGER_VOTER, false, 0); } } cancel_delayed_work_sync(&chg->pl_enable_work); /* reset input current limit voters */ vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, true, is_flashlite_active(chg) ? USBIN_500UA : USBIN_100UA); vote(chg->usb_icl_votable, FLASH_ACTIVE_VOTER, false, 0); vote(chg->usb_icl_votable, USB_PSY_VOTER, false, 0); /* reset parallel voters */ vote(chg->pl_disable_votable, PL_DELAY_VOTER, true, 0); vote(chg->pl_enable_votable_indirect, USBIN_I_VOTER, false, 0); vote(chg->pl_enable_votable_indirect, USBIN_V_VOTER, false, 0); vote(chg->awake_votable, PL_DELAY_VOTER, false, 0); /* Remove SW thermal regulation votes */ vote(chg->usb_icl_votable, SW_THERM_REGULATION_VOTER, false, 0); vote(chg->awake_votable, SW_THERM_REGULATION_VOTER, false, 0); smblite_lib_notify_device_mode(chg, false); chg->typec_legacy = false; chg->hvdcp3_detected = false; } static void typec_mode_unattached(struct smb_charger *chg) { vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, true, USBIN_100UA); } static void smblite_lib_handle_rp_change(struct smb_charger *chg, int typec_mode) { /* * if type is not updated or charger current is not set * for SDP ignore Rp change requests. */ if (chg->real_charger_type == POWER_SUPPLY_TYPE_UNKNOWN || (chg->real_charger_type == POWER_SUPPLY_TYPE_USB && !is_client_vote_enabled(chg->usb_icl_votable, USB_PSY_VOTER))) return; update_sw_icl_max(chg, chg->real_charger_type); smblite_lib_dbg(chg, PR_MISC, "CC change old_mode=%d new_mode=%d\n", chg->typec_mode, typec_mode); } irqreturn_t smblite_typec_or_rid_detection_change_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; smblite_lib_dbg(chg, PR_INTERRUPT, "IRQ: %s\n", irq_data->name); if (chg->usb_psy) power_supply_changed(chg->usb_psy); return IRQ_HANDLED; } irqreturn_t smblite_typec_state_change_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; int typec_mode; if (chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_MICRO_USB) { smblite_lib_dbg(chg, PR_INTERRUPT, "Ignoring for micro USB\n"); return IRQ_HANDLED; } typec_mode = smblite_lib_get_prop_typec_mode(chg); if (chg->sink_src_mode != UNATTACHED_MODE && (typec_mode != chg->typec_mode)) smblite_lib_handle_rp_change(chg, typec_mode); chg->typec_mode = typec_mode; smblite_lib_dbg(chg, PR_INTERRUPT, "IRQ: cc-state-change; Type-C %s detected\n", smblite_lib_typec_mode_name[chg->typec_mode]); power_supply_changed(chg->usb_psy); return IRQ_HANDLED; } #define TYPEC_DETACH_DETECT_DELAY_MS 2000 irqreturn_t smblite_typec_attach_detach_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; u8 stat; bool attached = false; int rc; /* IRQ not expected to be executed for uUSB, return */ if (chg->connector_type == QTI_POWER_SUPPLY_CONNECTOR_MICRO_USB) return IRQ_HANDLED; smblite_lib_dbg(chg, PR_INTERRUPT, "IRQ: %s\n", irq_data->name); rc = smblite_lib_read(chg, TYPE_C_STATE_MACHINE_STATUS_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read TYPE_C_STATE_MACHINE_STATUS_REG rc=%d\n", rc); return IRQ_HANDLED; } attached = !!(stat & TYPEC_ATTACH_DETACH_STATE_BIT); if (attached) { rc = smblite_lib_read(chg, TYPE_C_MISC_STATUS_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read TYPE_C_MISC_STATUS_REG rc=%d\n", rc); return IRQ_HANDLED; } if (smblite_lib_get_prop_dfp_mode(chg) == QTI_POWER_SUPPLY_TYPEC_SINK_AUDIO_ADAPTER) { chg->sink_src_mode = AUDIO_ACCESS_MODE; typec_ra_ra_insertion(chg); } else if (stat & SNK_SRC_MODE_BIT) { chg->sink_src_mode = SRC_MODE; typec_sink_insertion(chg); } else { chg->sink_src_mode = SINK_MODE; typec_src_insertion(chg); } rc = typec_partner_register(chg); if (rc < 0) smblite_lib_err(chg, "Couldn't to register partner rc =%d\n", rc); } else { switch (chg->sink_src_mode) { case SRC_MODE: typec_sink_removal(chg); break; case SINK_MODE: case AUDIO_ACCESS_MODE: typec_src_removal(chg); break; case UNATTACHED_MODE: default: typec_mode_unattached(chg); break; } if (!chg->pr_swap_in_progress) chg->sink_src_mode = UNATTACHED_MODE; /* * Restore DRP mode on type-C cable disconnect if role * swap is not in progress, to ensure forced sink or src * mode configuration is reset properly. */ if (chg->typec_port && !chg->pr_swap_in_progress) { /* * Schedule the work to differentiate actual removal * of cable and detach interrupt during role swap, * unregister the partner only during actual cable * removal. */ cancel_delayed_work(&chg->pr_swap_detach_work); vote(chg->awake_votable, DETACH_DETECT_VOTER, true, 0); schedule_delayed_work(&chg->pr_swap_detach_work, msecs_to_jiffies(TYPEC_DETACH_DETECT_DELAY_MS)); smblite_lib_force_dr_mode(chg, TYPEC_PORT_DRP); /* * To handle cable removal during role * swap failure. */ chg->typec_role_swap_failed = false; } } rc = smblite_lib_masked_write(chg, USB_CMD_PULLDOWN_REG(chg->base), EN_PULLDOWN_USB_IN_BIT, attached ? 0 : EN_PULLDOWN_USB_IN_BIT); if (rc < 0) smblite_lib_err(chg, "Couldn't configure pulldown on USB_IN rc=%d\n", rc); power_supply_changed(chg->usb_psy); return IRQ_HANDLED; } static void smblite_lib_bb_removal_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, bb_removal_work.work); vote(chg->usb_icl_votable, BOOST_BACK_VOTER, false, 0); vote(chg->awake_votable, BOOST_BACK_VOTER, false, 0); } #define BOOST_BACK_UNVOTE_DELAY_MS 750 #define BOOST_BACK_STORM_COUNT 3 #define WEAK_CHG_STORM_COUNT 8 irqreturn_t smblite_switcher_power_ok_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; struct storm_watch *wdata = &irq_data->storm_data; int rc, usb_icl; u8 stat; if (!(chg->wa_flags & BOOST_BACK_WA)) return IRQ_HANDLED; rc = smblite_lib_read(chg, POWER_PATH_STATUS_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read POWER_PATH_STATUS rc=%d\n", rc); return IRQ_HANDLED; } /* skip suspending input if its already suspended by some other voter */ usb_icl = get_effective_result(chg->usb_icl_votable); if ((stat & USE_USBIN_BIT) && usb_icl >= 0 && usb_icl <= USBIN_25UA) return IRQ_HANDLED; if (is_storming(&irq_data->storm_data)) { /* This could be a weak charger reduce ICL */ if (!is_client_vote_enabled(chg->usb_icl_votable, WEAK_CHARGER_VOTER)) { smblite_lib_err(chg, "Weak charger detected: voting %dmA ICL\n", chg->weak_chg_icl_ua / 1000); vote(chg->usb_icl_votable, WEAK_CHARGER_VOTER, true, chg->weak_chg_icl_ua); /* * reset storm data and set the storm threshold * to 3 for reverse boost detection. */ update_storm_count(wdata, BOOST_BACK_STORM_COUNT); } else { smblite_lib_err(chg, "Reverse boost detected: voting 0mA to suspend input\n"); vote(chg->usb_icl_votable, BOOST_BACK_VOTER, true, 0); vote(chg->awake_votable, BOOST_BACK_VOTER, true, 0); /* * Remove the boost-back vote after a delay, to avoid * permanently suspending the input if the boost-back * condition is unintentionally hit. */ schedule_delayed_work(&chg->bb_removal_work, msecs_to_jiffies(BOOST_BACK_UNVOTE_DELAY_MS)); } } return IRQ_HANDLED; } irqreturn_t smblite_wdog_bark_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; int rc; smblite_lib_dbg(chg, PR_INTERRUPT, "IRQ: %s\n", irq_data->name); rc = smblite_lib_write(chg, BARK_BITE_WDOG_PET_REG(chg->base), BARK_BITE_WDOG_PET_BIT); if (rc < 0) smblite_lib_err(chg, "Couldn't pet the dog rc=%d\n", rc); power_supply_changed(chg->batt_psy); return IRQ_HANDLED; } /* * triggered when DIE temperature across * either of the _REG_L, _REG_H, _RST, or _SHDN thresholds */ #define THERM_REGULATION_DELAY_MS 1000 #define THERM_REGULATION_STEP_UA 100000 irqreturn_t smblite_temp_change_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; smblite_lib_dbg(chg, PR_INTERRUPT, "IRQ: %s\n", irq_data->name); vote(chg->awake_votable, SW_THERM_REGULATION_VOTER, true, 0); cancel_delayed_work_sync(&chg->thermal_regulation_work); schedule_delayed_work(&chg->thermal_regulation_work, msecs_to_jiffies(THERM_REGULATION_DELAY_MS)); return IRQ_HANDLED; } #define USB_OV_DBC_PERIOD_MS 1000 irqreturn_t smblite_usbin_ov_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; smblite_lib_dbg(chg, PR_INTERRUPT, "IRQ: %s\n", irq_data->name); return IRQ_HANDLED; } irqreturn_t smblite_usb_id_irq_handler(int irq, void *data) { struct smb_charger *chg = data; bool id_state; id_state = gpio_get_value(chg->usb_id_gpio); smblite_lib_dbg(chg, PR_INTERRUPT, "IRQ: %s, id_state=%d\n", "usb-id-irq", id_state); if (id_state) { /*otg cable removed */ if (chg->otg_present) { if (chg->typec_port) { typec_set_data_role(chg->typec_port, TYPEC_DEVICE); typec_set_pwr_role(chg->typec_port, TYPEC_SINK); typec_partner_unregister(chg); } } } else if (chg->typec_port) { /*otg cable inserted */ typec_partner_register(chg); typec_set_data_role(chg->typec_port, TYPEC_HOST); typec_set_pwr_role(chg->typec_port, TYPEC_SOURCE); } smblite_lib_notify_usb_host(chg, !id_state); return IRQ_HANDLED; } irqreturn_t smblite_boost_mode_sw_en_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; union power_supply_propval pval = {0, }; bool is_qc = false, boost_enabled = is_boost_en(chg); u8 apsd_status = 0; int rc = 0; rc = smblite_lib_get_prop_usb_present(chg, &pval); if (rc < 0) smblite_lib_dbg(chg, PR_MISC, "Couldn't get USB preset status rc=%d\n", rc); /* Try to restore VBUS to MAX(6V) once boost is disabled and USB is present. */ if (!boost_enabled && pval.intval) { rc = smblite_lib_read(chg, APSD_RESULT_STATUS_REG(chg->base), &apsd_status); if (rc < 0) smblite_lib_err(chg, "Couldn't read APSD_RESULT_STATUS rc=%d\n", rc); /* Restore vbus to MAX(6V) only if QC adapter is connected */ if (apsd_status & QC_3P0_BIT) { is_qc = true; /* wait for 100ms to move from boosti -> buck mode. */ msleep(100); smblite_lib_hvdcp3_force_max_vbus(chg); } } smblite_lib_dbg(chg, PR_INTERRUPT, "IRQ: %s, BOOST_EN=%s, usb_present=%d, qc_adapter=%s\n", irq_data->name, (boost_enabled ? "True" : "False"), pval.intval, (is_qc ? "True" : "False")); return IRQ_HANDLED; } /*************** * Work Queues * ***************/ static void smblite_lib_pr_swap_detach_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, pr_swap_detach_work.work); int rc; u8 stat; rc = smblite_lib_read(chg, TYPE_C_STATE_MACHINE_STATUS_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read STATE_MACHINE_STS rc=%d\n", rc); goto out; } smblite_lib_dbg(chg, PR_REGISTER, "STATE_MACHINE_STS %#x\n", stat); if (!(stat & TYPEC_ATTACH_DETACH_STATE_BIT)) typec_partner_unregister(chg); out: vote(chg->awake_votable, DETACH_DETECT_VOTER, false, 0); } static void bms_update_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, bms_update_work); struct iio_channel **qg_list; int rc; if (IS_ERR(chg->iio_chan_list_qg)) return; if (!chg->iio_chan_list_qg) { qg_list = get_ext_channels(chg->dev, smblite_lib_qg_ext_iio_chan, ARRAY_SIZE(smblite_lib_qg_ext_iio_chan)); if (IS_ERR(qg_list)) { rc = PTR_ERR(qg_list); if (rc != -EPROBE_DEFER) { dev_err(chg->dev, "Failed to get channels, %d\n", rc); chg->iio_chan_list_qg = ERR_PTR(-EINVAL); } return; } chg->iio_chan_list_qg = qg_list; } smblite_lib_suspend_on_debug_battery(chg); if (chg->batt_psy) power_supply_changed(chg->batt_psy); } static void smblite_lib_icl_change_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, icl_change_work.work); int rc, settled_ua; rc = smblite_lib_get_charge_param(chg, &chg->param.icl_stat, &settled_ua); if (rc < 0) { smblite_lib_err(chg, "Couldn't get ICL status rc=%d\n", rc); return; } power_supply_changed(chg->batt_psy); smblite_lib_dbg(chg, PR_INTERRUPT, "icl_settled=%d\n", settled_ua); } static void smblite_lib_pl_enable_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, pl_enable_work.work); smblite_lib_dbg(chg, PR_PARALLEL, "timer expired, enabling parallel\n"); vote(chg->pl_disable_votable, PL_DELAY_VOTER, false, 0); vote(chg->awake_votable, PL_DELAY_VOTER, false, 0); } static void smblite_lib_thermal_regulation_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, thermal_regulation_work.work); int rc = 0, icl_ua = 0, input_present = 0; u8 stat = 0; if (!chg->usb_icl_votable) goto exit; rc = smblite_lib_is_input_present(chg, &input_present); if (rc < 0) { smblite_lib_err(chg, "Couldn't read input status rc=%d\n", rc); goto exit; } if (input_present == INPUT_NOT_PRESENT) { vote(chg->usb_icl_votable, SW_THERM_REGULATION_VOTER, false, 0); goto exit; } rc = smblite_lib_read(chg, DIE_TEMP_STATUS_REG(chg->base), &stat); if (rc < 0) { smblite_lib_err(chg, "Couldn't read DIE_TEMP_STATUS_REG, rc=%d\n", rc); goto reschedule; } icl_ua = get_effective_result(chg->usb_icl_votable); if (stat & DIE_TEMP_RST_BIT) { vote(chg->usb_icl_votable, SW_THERM_REGULATION_VOTER, true, USBIN_500UA); icl_ua = USBIN_500UA; goto exit; } if (stat & DIE_TEMP_UB_BIT) { /* Check if we reached minimum ICL limit */ if (icl_ua < USBIN_500UA + THERM_REGULATION_STEP_UA) goto exit; /* Decrement ICL by one step */ icl_ua -= THERM_REGULATION_STEP_UA; vote(chg->usb_icl_votable, SW_THERM_REGULATION_VOTER, true, icl_ua); goto reschedule; } /* check if DIE_TEMP is below LB */ if (!(stat & DIE_TEMP_MASK)) { /* * Check if we need further increments: * If thermal is still effective client then work can continue * with increment otherwise if other voter has voted a lower * ICL then remove vote and exit work. */ if (!strcmp(get_effective_client(chg->usb_icl_votable), SW_THERM_REGULATION_VOTER)) { icl_ua += THERM_REGULATION_STEP_UA; vote(chg->usb_icl_votable, SW_THERM_REGULATION_VOTER, true, icl_ua); goto reschedule; } } exit: smblite_lib_dbg(chg, PR_MISC, "exiting DIE_TEMP regulation work DIE_TEMP_STATUS=%x icl=%duA\n", stat, icl_ua); vote(chg->awake_votable, SW_THERM_REGULATION_VOTER, false, 0); return; reschedule: smblite_lib_dbg(chg, PR_MISC, "rescheduling DIE_TEMP regulation work DIE_TEMP_STATUS=%x icl=%duA\n", stat, icl_ua); schedule_delayed_work(&chg->thermal_regulation_work, msecs_to_jiffies(THERM_REGULATION_DELAY_MS)); } #define SOFT_JEITA_HYSTERESIS_OFFSET 0x200 static void jeita_update_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, jeita_update_work); struct device_node *node = chg->dev->of_node; struct device_node *batt_node, *pnode; union power_supply_propval val; int rc, tmp[2], max_fcc_ma, max_fv_uv; u32 jeita_hard_thresholds[2]; u16 addr; u8 buff[2]; batt_node = of_find_node_by_name(node, "qcom,battery-data"); if (!batt_node) { smblite_lib_err(chg, "Batterydata not available\n"); goto out; } /* if BMS is not ready and remote FG does not exist, defer the work */ if ((IS_ERR_OR_NULL(chg->iio_chan_list_qg)) && (!chg->is_fg_remote)) return; rc = smblite_lib_get_prop_from_bms(chg, SMB5_QG_RESISTANCE_ID, &val.intval); if (rc < 0) { smblite_lib_err(chg, "Couldn't to get batt-id rc=%d\n", rc); goto out; } /* if BMS hasn't read out the batt_id yet, defer the work */ if (val.intval <= 0) return; pnode = of_batterydata_get_best_profile(batt_node, val.intval / 1000, NULL); if (IS_ERR(pnode)) { rc = PTR_ERR(pnode); smblite_lib_err(chg, "Couldn't to detect valid battery profile %d\n", rc); goto out; } rc = of_property_read_u32_array(pnode, "qcom,jeita-hard-thresholds", jeita_hard_thresholds, 2); if (!rc) { rc = smblite_lib_update_jeita(chg, jeita_hard_thresholds, JEITA_HARD); if (rc < 0) { smblite_lib_err(chg, "Couldn't configure Hard Jeita rc=%d\n", rc); goto out; } } rc = of_property_read_u32_array(pnode, "qcom,jeita-soft-thresholds", chg->jeita_soft_thlds, 2); if (!rc) { rc = smblite_lib_update_jeita(chg, chg->jeita_soft_thlds, JEITA_SOFT); if (rc < 0) { smblite_lib_err(chg, "Couldn't configure Soft Jeita rc=%d\n", rc); goto out; } rc = of_property_read_u32_array(pnode, "qcom,jeita-soft-hys-thresholds", chg->jeita_soft_hys_thlds, 2); if (rc < 0) { smblite_lib_err(chg, "Couldn't get Soft Jeita hysteresis thresholds rc=%d\n", rc); goto out; } } else { /* Populate the jeita-soft-thresholds */ addr = CHGR_JEITA_COOL_THRESHOLD_REG(chg->base); rc = smblite_lib_batch_read(chg, addr, buff, 2); if (rc < 0) { pr_err("Couldn't to read 0x%4X, rc=%d\n", addr, rc); goto out; } chg->jeita_soft_thlds[0] = buff[1] | buff[0] << 8; rc = smblite_lib_batch_read(chg, addr + 2, buff, 2); if (rc < 0) { pr_err("Couldn't to read 0x%4X, rc=%d\n", addr + 2, rc); goto out; } chg->jeita_soft_thlds[1] = buff[1] | buff[0] << 8; /* * Update the soft jeita hysteresis 2 DegC less for warm and * 2 DegC more for cool than the soft jeita thresholds to avoid * overwriting the registers with invalid values. */ chg->jeita_soft_hys_thlds[1] = chg->jeita_soft_thlds[0] - SOFT_JEITA_HYSTERESIS_OFFSET; chg->jeita_soft_hys_thlds[0] = chg->jeita_soft_thlds[1] + SOFT_JEITA_HYSTERESIS_OFFSET; } chg->jeita_soft_fcc[0] = chg->jeita_soft_fcc[1] = -EINVAL; chg->jeita_soft_fv[0] = chg->jeita_soft_fv[1] = -EINVAL; max_fcc_ma = max_fv_uv = -EINVAL; of_property_read_u32(pnode, "qcom,fastchg-current-ma", &max_fcc_ma); of_property_read_u32(pnode, "qcom,max-voltage-uv", &max_fv_uv); if (max_fcc_ma <= 0 || max_fv_uv <= 0) { smblite_lib_err(chg, "Incorrect fastchg-current-ma or max-voltage-uv\n"); goto out; } rc = of_property_read_u32_array(pnode, "qcom,jeita-soft-fcc-ua", tmp, 2); if (rc < 0) { smblite_lib_err(chg, "Couldn't get fcc values for soft JEITA rc=%d\n", rc); goto out; } max_fcc_ma *= 1000; if (tmp[0] > max_fcc_ma || tmp[1] > max_fcc_ma) { smblite_lib_err(chg, "Incorrect FCC value [%d %d] max: %d\n", tmp[0], tmp[1], max_fcc_ma); goto out; } chg->jeita_soft_fcc[0] = tmp[0]; chg->jeita_soft_fcc[1] = tmp[1]; rc = of_property_read_u32_array(pnode, "qcom,jeita-soft-fv-uv", tmp, 2); if (rc < 0) { smblite_lib_err(chg, "Couldn't get fv values for soft JEITA rc=%d\n", rc); goto out; } if (tmp[0] > max_fv_uv || tmp[1] > max_fv_uv) { smblite_lib_err(chg, "Incorrect FV value [%d %d] max: %d\n", tmp[0], tmp[1], max_fv_uv); goto out; } chg->jeita_soft_fv[0] = tmp[0]; chg->jeita_soft_fv[1] = tmp[1]; rc = smblite_lib_soft_jeita_arb_wa(chg); if (rc < 0) { smblite_lib_err(chg, "Couldn't fix soft jeita arb rc=%d\n", rc); goto out; } chg->jeita_configured = JEITA_CFG_COMPLETE; return; out: chg->jeita_configured = JEITA_CFG_FAILURE; } static int smblite_lib_create_votables(struct smb_charger *chg) { int rc = 0; chg->fcc_votable = find_votable("FCC"); if (chg->fcc_votable == NULL) { rc = -EINVAL; smblite_lib_err(chg, "Couldn't find FCC votable rc=%d\n", rc); return rc; } chg->fcc_main_votable = find_votable("FCC_MAIN"); if (chg->fcc_main_votable == NULL) { rc = -EINVAL; smblite_lib_err(chg, "Couldn't find FCC Main votable rc=%d\n", rc); return rc; } chg->fv_votable = find_votable("FV"); if (chg->fv_votable == NULL) { rc = -EINVAL; smblite_lib_err(chg, "Couldn't find FV votable rc=%d\n", rc); return rc; } chg->usb_icl_votable = find_votable("USB_ICL"); if (chg->usb_icl_votable == NULL) { rc = -EINVAL; smblite_lib_err(chg, "Couldn't find USB_ICL votable rc=%d\n", rc); return rc; } chg->pl_disable_votable = find_votable("PL_DISABLE"); if (chg->pl_disable_votable == NULL) { rc = -EINVAL; smblite_lib_err(chg, "Couldn't find votable PL_DISABLE rc=%d\n", rc); return rc; } chg->pl_enable_votable_indirect = find_votable("PL_ENABLE_INDIRECT"); if (chg->pl_enable_votable_indirect == NULL) { rc = -EINVAL; smblite_lib_err(chg, "Couldn't find votable PL_ENABLE_INDIRECT rc=%d\n", rc); return rc; } vote(chg->pl_disable_votable, PL_DELAY_VOTER, true, 0); chg->awake_votable = create_votable("AWAKE", VOTE_SET_ANY, smblite_lib_awake_vote_callback, chg); if (IS_ERR(chg->awake_votable)) { rc = PTR_ERR(chg->awake_votable); chg->awake_votable = NULL; return rc; } chg->chg_disable_votable = create_votable("CHG_DISABLE", VOTE_SET_ANY, smblite_lib_chg_disable_vote_callback, chg); if (IS_ERR(chg->chg_disable_votable)) { rc = PTR_ERR(chg->chg_disable_votable); chg->chg_disable_votable = NULL; return rc; } chg->icl_irq_disable_votable = create_votable("USB_ICL_IRQ_DISABLE", VOTE_SET_ANY, smblite_lib_icl_irq_disable_vote_callback, chg); if (IS_ERR(chg->icl_irq_disable_votable)) { rc = PTR_ERR(chg->icl_irq_disable_votable); chg->icl_irq_disable_votable = NULL; return rc; } chg->temp_change_irq_disable_votable = create_votable( "TEMP_CHANGE_IRQ_DISABLE", VOTE_SET_ANY, smblite_lib_temp_change_irq_disable_vote_callback, chg); if (IS_ERR(chg->temp_change_irq_disable_votable)) { rc = PTR_ERR(chg->temp_change_irq_disable_votable); chg->temp_change_irq_disable_votable = NULL; return rc; } return rc; } static void smblite_lib_destroy_votables(struct smb_charger *chg) { if (chg->usb_icl_votable) destroy_votable(chg->usb_icl_votable); if (chg->awake_votable) destroy_votable(chg->awake_votable); if (chg->chg_disable_votable) destroy_votable(chg->chg_disable_votable); } static void smblite_lib_iio_deinit(struct smb_charger *chg) { if (!IS_ERR_OR_NULL(chg->iio.usbin_v_chan)) iio_channel_release(chg->iio.usbin_v_chan); if (!IS_ERR_OR_NULL(chg->iio.temp_chan)) iio_channel_release(chg->iio.temp_chan); } int smblite_lib_init(struct smb_charger *chg) { int rc = 0; struct iio_channel **iio_list; struct smblite_remote_bms *remote_bms; mutex_init(&chg->dpdm_lock); mutex_init(&chg->dpdm_pulse_lock); INIT_WORK(&chg->bms_update_work, bms_update_work); INIT_WORK(&chg->jeita_update_work, jeita_update_work); INIT_DELAYED_WORK(&chg->icl_change_work, smblite_lib_icl_change_work); INIT_DELAYED_WORK(&chg->pl_enable_work, smblite_lib_pl_enable_work); INIT_DELAYED_WORK(&chg->bb_removal_work, smblite_lib_bb_removal_work); INIT_DELAYED_WORK(&chg->thermal_regulation_work, smblite_lib_thermal_regulation_work); INIT_DELAYED_WORK(&chg->role_reversal_check, smblite_lib_typec_role_check_work); INIT_DELAYED_WORK(&chg->pr_swap_detach_work, smblite_lib_pr_swap_detach_work); chg->fake_capacity = -EINVAL; chg->fake_batt_status = -EINVAL; chg->sink_src_mode = UNATTACHED_MODE; chg->jeita_configured = false; chg->dr_mode = TYPEC_PORT_DRP; chg->flash_active = false; chg->input_current_limited = -EINVAL; switch (chg->mode) { case PARALLEL_MASTER: rc = qcom_batt_init(chg->dev, &chg->chg_param); if (rc < 0) { smblite_lib_err(chg, "Couldn't init qcom_batt_init rc=%d\n", rc); return rc; } rc = qcom_step_chg_init(chg->dev, true, true, false, chg->iio_chans); if (rc < 0) { smblite_lib_err(chg, "Couldn't init qcom_step_chg_init rc=%d\n", rc); return rc; } rc = smblite_lib_create_votables(chg); if (rc < 0) { smblite_lib_err(chg, "Couldn't create votables rc=%d\n", rc); return rc; } if (chg->is_fg_remote) { remote_bms = &chg->remote_bms; remote_bms->dev = chg->dev; remote_bms->iio_read = chg->chg_param.iio_read; remote_bms->iio_write = chg->chg_param.iio_write; rc = remote_bms_init(remote_bms); if (rc < 0) { smblite_lib_err(chg, "Couldn't initialize remote bms rc=%d\n", rc); return rc; } } else { iio_list = get_ext_channels(chg->dev, smblite_lib_qg_ext_iio_chan, ARRAY_SIZE(smblite_lib_qg_ext_iio_chan)); if (!IS_ERR(iio_list)) chg->iio_chan_list_qg = iio_list; } rc = smblite_lib_register_notifier(chg); if (rc < 0) { smblite_lib_err(chg, "Couldn't register notifier rc=%d\n", rc); return rc; } break; case PARALLEL_SLAVE: break; default: smblite_lib_err(chg, "Unsupported mode %d\n", chg->mode); return -EINVAL; } return rc; } int smblite_lib_deinit(struct smb_charger *chg) { switch (chg->mode) { case PARALLEL_MASTER: cancel_work_sync(&chg->bms_update_work); cancel_work_sync(&chg->jeita_update_work); cancel_delayed_work_sync(&chg->icl_change_work); cancel_delayed_work_sync(&chg->pl_enable_work); cancel_delayed_work_sync(&chg->bb_removal_work); cancel_delayed_work_sync(&chg->thermal_regulation_work); cancel_delayed_work_sync(&chg->role_reversal_check); cancel_delayed_work_sync(&chg->pr_swap_detach_work); power_supply_unreg_notifier(&chg->nb); remote_bms_deinit(); smblite_lib_destroy_votables(chg); qcom_step_chg_deinit(); qcom_batt_deinit(); break; case PARALLEL_SLAVE: break; default: smblite_lib_err(chg, "Unsupported mode %d\n", chg->mode); return -EINVAL; } smblite_lib_iio_deinit(chg); return 0; }