// SPDX-License-Identifier: GPL-2.0-only /* * Copyright (C) 2018-2020 Oplus. All rights reserved. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef OPLUS_FEATURE_CHG_BASIC #include "../../../../drivers/power/supply/qcom/smb5-reg.h" #include "../../../../drivers/power/supply/qcom/schgm-flash.h" #include "../../../../drivers/power/supply/qcom/battery.h" #include "../../../../drivers/power/supply/qcom/step-chg-jeita.h" #include "../voocphy/oplus_voocphy.h" #ifdef OPLUS_CUSTOM_OP_DEF #include "../../../../drivers/power/supply/qcom/storm-watch.h" #endif #endif #include #include #ifdef OPLUS_CUSTOM_OP_DEF #include #endif #ifdef OPLUS_FEATURE_CHG_BASIC #include #include #include #include #include #include #include #include //#include //#include #include #include "oplus_battery_msm8250.h" #include "../oplus_charger.h" #include "../oplus_gauge.h" #include "../oplus_vooc.h" #include "../oplus_short.h" #include "../charger_ic/oplus_short_ic.h" #include "../oplus_adapter.h" //#include "../charger_ic/oplus_bq25882.h" #include "../gauge_ic/oplus_bq27541.h" #include "oplus_mp2650.h" #include "oplus_da9313.h" //for WPC #include "op_charge.h" #include "../oplus_configfs.h" #include "../oplus_chg_track.h" #ifdef OPLUS_CUSTOM_OP_DEF #include "../oplus_wlchg_policy.h" #else #include "../oplus_wireless.h" //for WPC #endif // OPLUS_CUSTOM_OP_DEF #ifdef CONFIG_OPLUS_FEATURE_SEC_DEBUG extern void oplus_force_panic(void); #endif struct oplus_chg_chip *g_oplus_chip = NULL; #ifdef OPLUS_CUSTOM_OP_DEF struct smb_charger *g_chg; #endif // OPLUS_CUSTOM_OP_DEF bool fg_oplus_set_input_current = false; bool suspend_usb = false; bool oplus_ccdetect_check_is_gpio(struct oplus_chg_chip *chip); int oplus_ccdetect_gpio_init(struct oplus_chg_chip *chip); void oplus_ccdetect_irq_init(struct oplus_chg_chip *chip); void oplus_ccdetect_disable(void); void oplus_ccdetect_enable(void); int oplus_ccdetect_get_power_role(void); int qpnp_get_prop_charger_voltage_now(void); bool oplus_get_otg_switch_status(void); int oplus_ccdetect_support_check(void); void oplus_set_smb5_usb_props_type(enum power_supply_type type); void oplus_wake_up_usbtemp_thread(void); bool oplus_usbtemp_check_is_support(void); void oplus_set_usb_status(int status); void oplus_clear_usb_status(int status); int oplus_get_usb_status(void); int oplus_chg_get_charger_subtype(void); extern int oplus_usbtemp_monitor_common(void *data); extern void oplus_usbtemp_recover_func(struct oplus_chg_chip *chip); int oplus_tbatt_power_off_task_init(struct oplus_chg_chip *chip); //static void oplus_otg_disable_config(void); //static void oplus_set_otg_switch_status_default(bool value); //static bool oplus_usb_or_otg_is_present(void); int oplus_get_otg_online_status(void); void oplus_set_otg_switch_status(bool value); int oplus_chg_enable_qc_detect(void); int oplus_check_is_pd_svooc(void); static void register_oplus_pdsvooc_svid(struct work_struct *work) ; static bool oplus_check_pdphy_ready(void) ; //extern int usbpd_send_vdm(struct usbpd *pd, u32 vdm_hdr, const u32 *vdos, int num_vdos); bool oplus_check_pd_state_ready(void); bool oplus_usbtemp_condition(void); extern bool oplus_is_use_external_boost(void); //extern void oplus_chg_cancel_update_work_sync(void); #define OPLUS_CHG_MONITOR_INTERVAL round_jiffies_relative(msecs_to_jiffies(5000)) #define REC_SUSPEND_WORK_SCH_DELAY round_jiffies_relative(msecs_to_jiffies(1000)) #define OPLUS_HVDCP_DISABLE_INTERVAL round_jiffies_relative(msecs_to_jiffies(15000)) #define OPLUS_HVDCP_DETECT_TO_DETACH_TIME 450 #define FLASH_SCREEN_CTRL_DTSI 0X02 #define SOC_READY_RETRY_COUNT 10 #define SOC_READY_WAITING_TIME 100 #define SOC_CHECK_NOT_READY 0 void oplus_set_idt_en_val(int value); // 0 active, 1 inactive void smblib_usb_plugin_locked(struct smb_charger *chg); int oplus_wpc_get_adapter_type(void); int __attribute__((weak)) oplus_get_chg_i2c_err(void) { return 0; } void __attribute__((weak)) oplus_clear_chg_i2c_err(void) { return; } bool is_ext_chg_ops(void) { //return (strncmp(oplus_chg_ops_name_get(), "plat-pmic", 64)); return true; } EXPORT_SYMBOL(is_ext_chg_ops); #endif #define DIV_FACTOR_MICRO_V_I 1 #define DIV_FACTOR_MILI_V_I 1000 #define DIV_FACTOR_DECIDEGC 100 static struct task_struct *oplus_usbtemp_kthread; DECLARE_WAIT_QUEUE_HEAD(oplus_usbtemp_wq); struct delayed_work usbtemp_recover_work; static DEFINE_MUTEX(pd_select_pdo_v); extern bool fg_oplus_set_input_current; #define OPLUS_SUPPORT_CCDETECT_IN_FTM_MODE 2 #define OPLUS_SUPPORT_CCDETECT_NOT_FTM_MODE 1 #define OPLUS_NOT_SUPPORT_CCDETECT 0 static struct smb_params smb5_pmi632_params = { .fcc = { .name = "fast charge current", .reg = CHGR_FAST_CHARGE_CURRENT_CFG_REG, .min_u = 0, .max_u = 3000000, .step_u = 50000, }, .fv = { .name = "float voltage", .reg = CHGR_FLOAT_VOLTAGE_CFG_REG, .min_u = 3600000, .max_u = 4800000, .step_u = 10000, }, .usb_icl = { .name = "usb input current limit", .reg = USBIN_CURRENT_LIMIT_CFG_REG, .min_u = 0, .max_u = 3000000, .step_u = 50000, }, .icl_max_stat = { .name = "dcdc icl max status", .reg = ICL_MAX_STATUS_REG, .min_u = 0, .max_u = 3000000, .step_u = 50000, }, .icl_stat = { .name = "input current limit status", .reg = ICL_STATUS_REG, .min_u = 0, .max_u = 3000000, .step_u = 50000, }, .otg_cl = { .name = "usb otg current limit", .reg = DCDC_OTG_CURRENT_LIMIT_CFG_REG, .min_u = 500000, .max_u = 1000000, .step_u = 250000, }, .jeita_cc_comp_hot = { .name = "jeita fcc reduction", .reg = JEITA_CCCOMP_CFG_HOT_REG, .min_u = 0, .max_u = 1575000, .step_u = 25000, }, .jeita_cc_comp_cold = { .name = "jeita fcc reduction", .reg = JEITA_CCCOMP_CFG_COLD_REG, .min_u = 0, .max_u = 1575000, .step_u = 25000, }, .freq_switcher = { .name = "switching frequency", .reg = DCDC_FSW_SEL_REG, .min_u = 600, .max_u = 1200, .step_u = 400, .set_proc = smblib_set_chg_freq, }, .aicl_5v_threshold = { .name = "AICL 5V threshold", .reg = USBIN_5V_AICL_THRESHOLD_REG, .min_u = 4000, .max_u = 4700, .step_u = 100, }, .aicl_cont_threshold = { .name = "AICL CONT threshold", .reg = USBIN_CONT_AICL_THRESHOLD_REG, .min_u = 4000, .max_u = 8800, .step_u = 100, .get_proc = smblib_get_aicl_cont_threshold, .set_proc = smblib_set_aicl_cont_threshold, }, }; static struct smb_params smb5_pm8150b_params = { .fcc = { .name = "fast charge current", .reg = CHGR_FAST_CHARGE_CURRENT_CFG_REG, .min_u = 0, .max_u = 8000000, .step_u = 50000, }, .fv = { .name = "float voltage", .reg = CHGR_FLOAT_VOLTAGE_CFG_REG, .min_u = 3600000, .max_u = 4790000, .step_u = 10000, }, .usb_icl = { .name = "usb input current limit", .reg = USBIN_CURRENT_LIMIT_CFG_REG, .min_u = 0, .max_u = 5000000, .step_u = 50000, }, .icl_max_stat = { .name = "dcdc icl max status", .reg = ICL_MAX_STATUS_REG, .min_u = 0, .max_u = 5000000, .step_u = 50000, }, .icl_stat = { .name = "aicl icl status", .reg = AICL_ICL_STATUS_REG, .min_u = 0, .max_u = 5000000, .step_u = 50000, }, .otg_cl = { .name = "usb otg current limit", .reg = DCDC_OTG_CURRENT_LIMIT_CFG_REG, .min_u = 500000, .max_u = 3000000, .step_u = 500000, }, .dc_icl = { .name = "DC input current limit", .reg = DCDC_CFG_REF_MAX_PSNS_REG, .min_u = 0, .max_u = DCIN_ICL_MAX_UA, .step_u = 50000, }, .jeita_cc_comp_hot = { .name = "jeita fcc reduction", .reg = JEITA_CCCOMP_CFG_HOT_REG, .min_u = 0, .max_u = 8000000, .step_u = 25000, .set_proc = NULL, }, .jeita_cc_comp_cold = { .name = "jeita fcc reduction", .reg = JEITA_CCCOMP_CFG_COLD_REG, .min_u = 0, .max_u = 8000000, .step_u = 25000, .set_proc = NULL, }, .freq_switcher = { .name = "switching frequency", .reg = DCDC_FSW_SEL_REG, .min_u = 600, .max_u = 1200, .step_u = 400, .set_proc = smblib_set_chg_freq, }, .aicl_5v_threshold = { .name = "AICL 5V threshold", .reg = USBIN_5V_AICL_THRESHOLD_REG, .min_u = 4000, .max_u = 4700, .step_u = 100, }, .aicl_cont_threshold = { .name = "AICL CONT threshold", .reg = USBIN_CONT_AICL_THRESHOLD_REG, .min_u = 4000, .max_u = 11800, .step_u = 100, .get_proc = smblib_get_aicl_cont_threshold, .set_proc = smblib_set_aicl_cont_threshold, }, }; #ifdef OPLUS_FEATURE_CHG_BASIC static int __debug_mask = PR_MISC | PR_OTG | PR_INTERRUPT | PR_REGISTER; module_param_named( debug_mask, __debug_mask, int, 0600 ); #else static int __debug_mask; #endif #ifdef OPLUS_FEATURE_CHG_BASIC void __attribute__((weak)) switch_usb_state(int usb_state) {return;} #endif #ifdef OPLUS_FEATURE_CHG_BASIC bool __attribute__((weak)) boot_with_console(void) {return false;} int __attribute__((weak)) oplus_pdo_select(int vbus_mv, int ibus_ma) {return 0;} #endif #define smblib_err(chg, fmt, ...) \ pr_err("%s: %s: " fmt, chg->name, \ __func__, ##__VA_ARGS__) \ #ifdef OPLUS_FEATURE_CHG_BASIC #define smblib_dbg(chg, reason, fmt, ...) \ do{ \ if (*chg->debug_mask & (reason)) \ pr_debug("%s: %s: " fmt, chg->name, \ __func__, ##__VA_ARGS__); \ else \ pr_debug("%s: %s: " fmt, chg->name, \ __func__, ##__VA_ARGS__); \ } while (0) #else #define smblib_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) #endif #ifdef OPLUS_FEATURE_CHG_BASIC static int oplus_otg_en_gpio_init(struct oplus_chg_chip *chip) { struct smb_charger *chg = NULL; printk(KERN_ERR "[OPLUS_CHG][%s]: tongfeng test start!\n", __func__); if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb2_chg not ready!\n", __func__); return -EINVAL; } chg = &chip->pmic_spmi.smb5_chip->chg; chg->otg_en_pinctrl = devm_pinctrl_get(chip->dev); if (IS_ERR_OR_NULL(chg->otg_en_pinctrl)) { chg_err("get otg_en otg_en_pinctrl fail\n"); return -EINVAL; } printk(KERN_ERR "[OPLUS_CHG][%s]: tongfeng 111!\n", __func__); chg->otg_en_active = pinctrl_lookup_state(chg->otg_en_pinctrl, "otg_en_active"); if (IS_ERR_OR_NULL(chg->otg_en_active)) { chg_err("get otg_en_active fail\n"); return -EINVAL; } printk(KERN_ERR "[OPLUS_CHG][%s]: tongfeng 222!\n", __func__); chg->otg_en_sleep = pinctrl_lookup_state(chg->otg_en_pinctrl, "otg_en_sleep"); if (IS_ERR_OR_NULL(chg->otg_en_sleep)) { chg_err("get otg_en fail\n"); return -EINVAL; } printk(KERN_ERR "[OPLUS_CHG][%s]: tongfeng 333!\n", __func__); chg->otg_en_default = pinctrl_lookup_state(chg->otg_en_pinctrl, "otg_en_default"); if (IS_ERR_OR_NULL(chg->otg_en_default)) { chg_err("get otg_en_default fail\n"); return -EINVAL; } printk(KERN_ERR "[OPLUS_CHG][%s]: tongfeng 444!\n", __func__); //if (chg->otg_en_gpio > 0) { //gpio_direction_input(chg->wired_conn_gpio); //} pinctrl_select_state(chg->otg_en_pinctrl, chg->otg_en_sleep); chg_err("tongfeng test , gpio_val:%d\n", gpio_get_value(chg->otg_en_gpio)); return 0; } static int oplus_wired_conn_gpio_init(struct oplus_chg_chip *chip) { struct smb_charger *chg = NULL; printk(KERN_ERR "[OPLUS_CHG][%s]: tongfeng test start!\n", __func__); if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb2_chg not ready!\n", __func__); return -EINVAL; } chg = &chip->pmic_spmi.smb5_chip->chg; chg->wired_conn_pinctrl = devm_pinctrl_get(chip->dev); if (IS_ERR_OR_NULL(chg->wired_conn_pinctrl)) { chg_err("get wired_conn wired_connpinctrl fail\n"); return -EINVAL; } chg->wired_conn_active = pinctrl_lookup_state(chg->wired_conn_pinctrl, "wired_con_int_active"); if (IS_ERR_OR_NULL(chg->wired_conn_active)) { chg_err("get wired_conn_active fail\n"); return -EINVAL; } chg->wired_conn_sleep = pinctrl_lookup_state(chg->wired_conn_pinctrl, "wired_con_int_sleep"); if (IS_ERR_OR_NULL(chg->wired_conn_sleep)) { chg_err("get wired_conn_sleep fail\n"); return -EINVAL; } if (chg->wired_conn_gpio > 0) { gpio_direction_input(chg->wired_conn_gpio); } pinctrl_select_state(chg->wired_conn_pinctrl, chg->wired_conn_active); return 0; } static void oplus_wired_conn_irq_init(struct oplus_chg_chip *chip) { struct smb_charger *chg = NULL; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb2_chg not ready!\n", __func__); return; } chg = &chip->pmic_spmi.smb5_chip->chg; chg->wired_conn_irq = gpio_to_irq(chg->wired_conn_gpio); printk(KERN_ERR "[OPLUS_CHG][%s]: chg->wired_conn_irq[%d]!\n", __func__, chg->wired_conn_irq); } static bool oplus_wired_conn_check_is_gpio(struct oplus_chg_chip *chip) { struct smb_charger *chg = NULL; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb2_chg not ready!\n", __func__); return false; } chg = &chip->pmic_spmi.smb5_chip->chg; if (gpio_is_valid(chg->wired_conn_gpio)) return true; return false; } static void oplus_wait_wired_charge_on_work(struct work_struct *work) { printk(KERN_ERR "[OPLUS_CHG][%s]<~WPC~> wait_wired_charge_on\n", __func__); oplus_wpc_set_wrx_en_value(0); oplus_wpc_set_booster_en_val(1); oplus_wpc_set_ext2_wireless_otg_en_val(0); return; } static void oplus_wait_wired_charge_off_work(struct work_struct *work) { printk(KERN_ERR "[OPLUS_CHG][%s]<~WPC~> wait_wired_charge_off\n", __func__); oplus_wpc_set_vbat_en_val(0); oplus_wpc_set_rtx_function_prepare(); oplus_wpc_set_rtx_function(true); return; } static void oplus_otg_disable_timeout_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, otg_disable_timeout_work.work); printk(KERN_ERR "[OPLUS_CHG][%s]<~WPC~> clear otg_disable_timeout\n", __func__); chg->otg_disable_timeout = 0; if (g_oplus_chip->wpc_no_chargerpump && oplus_wpc_get_otg_charging() == true) { msleep(100); oplus_wpc_set_rtx_function_prepare(); oplus_wpc_set_rtx_function(true); } } void smblib_apsd_enable(struct smb_charger *chg, bool enable); static void smblib_rerun_apsd(struct smb_charger *chg); static void oplus_wired_conn_int_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, wired_in_work.work); smblib_usb_plugin_locked(chg); msleep(100); smblib_apsd_enable(chg, true); smblib_rerun_apsd(chg); vote(chg->awake_votable, WIRED_CONN_VOTER, false, 0); return; } #define REC_SUSPEND_WORK_MSLEEP 100 static void oplus_recovery_suspend_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, recovery_suspend_work.work); chg_err("oplus_recovery_suspend_work\n"); smblib_set_usb_suspend(chg, false); return; } irqreturn_t oplus_wired_conn_change_handler(int irq, void *data) { struct oplus_chg_chip *chip = data; struct smb_charger *chg = &chip->pmic_spmi.smb5_chip->chg; //struct oplus_chg_chip *chip = g_oplus_chip; if ((chg->typec_mode == POWER_SUPPLY_TYPEC_SINK || chg->typec_mode == POWER_SUPPLY_TYPEC_SINK_POWERED_CABLE) && chip->vbatt_num == 2) { pr_info("%s:chg->typec_mode = sink return!\n", __func__); return IRQ_HANDLED; } cancel_delayed_work_sync(&chg->wired_in_work); vote(chg->awake_votable, WIRED_CONN_VOTER, true, 0); schedule_delayed_work(&chg->wired_in_work, 0); printk(KERN_ERR "[OPLUS_CHG][%s]: tongfeng test irq happened\n", __func__); //oplus_set_idt_en_val(1); //oplus_set_wrx_en_value(0); //chip->chg_ops->otg_enable(); return IRQ_HANDLED; } static void oplus_wired_conn_irq_register(struct oplus_chg_chip *chip) { int ret = 0; struct smb_charger *chg = NULL; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb2_chg not ready!\n", __func__); return; } chg = &chip->pmic_spmi.smb5_chip->chg; ret = devm_request_threaded_irq(chip->dev, chg->wired_conn_irq, NULL, oplus_wired_conn_change_handler, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_ONESHOT, "wired_conn-change", chip); if (ret < 0) { chg_err("Unable to request wired_conn-change irq: %d\n", ret); } printk(KERN_ERR "%s: !!!!! irq register\n", __FUNCTION__); ret = enable_irq_wake(chg->wired_conn_irq); if (ret != 0) { chg_err("enable_irq_wake: wired_conn_irq failed %d\n", ret); } } void oplus_wireless_set_otg_en_val(int value) { struct oplus_chg_chip *chip = g_oplus_chip; struct smb_charger *chg = NULL; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb2_chg not ready!\n", __func__); return; } chg = &chip->pmic_spmi.smb5_chip->chg; if (chg == NULL) { chg_err("tongfeng NULL test return chg[%p], chip[%p]\n", chg, chip); return; } chg_err("tongfeng chg->otg_en_gpio[%d] 111\n", chg->otg_en_gpio); if (chg->otg_en_gpio <= 0) { chg_err("otg_en_gpio not exist, return\n"); return; } if (IS_ERR_OR_NULL(chg->otg_en_pinctrl) || IS_ERR_OR_NULL(chg->otg_en_active) || IS_ERR_OR_NULL(chg->otg_en_sleep) || IS_ERR_OR_NULL(chg->otg_en_default)) { chg_err("pinctrl null, return\n"); return; } if (value) { gpio_direction_output(chg->otg_en_gpio, 1); pinctrl_select_state(chg->otg_en_pinctrl, chg->otg_en_active); } else { gpio_direction_output(chg->otg_en_gpio, 0); pinctrl_select_state(chg->otg_en_pinctrl, chg->otg_en_default); } chg_err("set value:%d, gpio_val:%d\n", value, gpio_get_value(chg->otg_en_gpio)); } int oplus_wireless_get_otg_en_val(struct oplus_chg_chip *chip) { struct smb_charger *chg = NULL; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb2_chg not ready!\n", __func__); return -1; } chg = &chip->pmic_spmi.smb5_chip->chg; if (chg->otg_en_gpio <= 0) { chg_err("otg_en_gpio not exist, return\n"); return -1; } if (IS_ERR_OR_NULL(chg->otg_en_pinctrl) || IS_ERR_OR_NULL(chg->otg_en_active) || IS_ERR_OR_NULL(chg->otg_en_sleep)) { chg_err("pinctrl null, return\n"); return -1; } return gpio_get_value(chg->otg_en_gpio); } static int oplus_idt_en_gpio_init(struct oplus_chg_chip *chip) { struct smb_charger *chg = NULL; printk(KERN_ERR "[OPLUS_CHG][%s]: tongfeng test start!\n", __func__); if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb2_chg not ready!\n", __func__); return -EINVAL; } chg = &chip->pmic_spmi.smb5_chip->chg; printk(KERN_ERR "[OPLUS_CHG][%s]: tongfeng test start chg = %p!\n", __func__, chg); if (!chg) { printk(KERN_ERR "[OPLUS_CHG][%s]: tongfeng test start chg NULL !\n", __func__); return 0; } chg->idt_en_pinctrl = devm_pinctrl_get(chip->dev); if (IS_ERR_OR_NULL(chg->idt_en_pinctrl)) { chg_err("get idt_en idt_en_pinctrl fail\n"); return -EINVAL; } printk(KERN_ERR "[OPLUS_CHG][%s]: tongfeng test start 333333!\n", __func__); chg->idt_en_active = pinctrl_lookup_state(chg->idt_en_pinctrl, "idt_en_active"); if (IS_ERR_OR_NULL(chg->idt_en_active)) { chg_err("get idt_en_active fail\n"); return -EINVAL; } printk(KERN_ERR "[OPLUS_CHG][%s]: tongfeng test start 44444!\n", __func__); chg->idt_en_sleep = pinctrl_lookup_state(chg->idt_en_pinctrl, "idt_en_sleep"); if (IS_ERR_OR_NULL(chg->idt_en_sleep)) { chg_err("get idt_en_sleep fail\n"); return -EINVAL; } chg->idt_en_default = pinctrl_lookup_state(chg->idt_en_pinctrl, "idt_en_default"); if (IS_ERR_OR_NULL(chg->idt_en_default)) { chg_err("get idt_en_default fail\n"); return -EINVAL; } printk(KERN_ERR "[OPLUS_CHG][%s]: tongfeng test start 555!\n", __func__); if (chg->idt_en_gpio > 0) { gpio_direction_output(chg->idt_en_gpio, 0); } pinctrl_select_state(chg->idt_en_pinctrl, chg->idt_en_default); printk(KERN_ERR "[OPLUS_CHG][%s]: tongfeng test end!\n", __func__); return 0; } void oplus_set_idt_en_val(int value) // 0 active, 1 inactive { struct oplus_chg_chip *chip = g_oplus_chip; struct smb_charger *chg = NULL; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb2_chg not ready!\n", __func__); return; } chg = &chip->pmic_spmi.smb5_chip->chg; if (chg->idt_en_gpio <= 0) { chg_err("idt_en_gpio not exist, return\n"); return; } if (IS_ERR_OR_NULL(chg->idt_en_pinctrl) || IS_ERR_OR_NULL(chg->idt_en_active) || IS_ERR_OR_NULL(chg->idt_en_sleep) || IS_ERR_OR_NULL(chg->idt_en_default)) { chg_err("pinctrl null, return\n"); return; } if (value) { gpio_direction_output(chg->idt_en_gpio, 1); pinctrl_select_state(chg->idt_en_pinctrl, chg->idt_en_active); } else { gpio_direction_output(chg->idt_en_gpio, 0); pinctrl_select_state(chg->idt_en_pinctrl, chg->idt_en_default); } chg_err("<~WPC~> set value:%d, gpio_val:%d\n", value, gpio_get_value(chg->idt_en_gpio)); } int oplus_get_idt_en_val(void) { struct oplus_chg_chip *chip = g_oplus_chip; struct smb_charger *chg = NULL; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb2_chg not ready!\n", __func__); return -1; } chg = &chip->pmic_spmi.smb5_chip->chg; if (chg->idt_en_gpio <= 0) { chg_err("idt_en_gpio not exist, return\n"); return -1; } if (IS_ERR_OR_NULL(chg->idt_en_pinctrl) || IS_ERR_OR_NULL(chg->idt_en_active) || IS_ERR_OR_NULL(chg->idt_en_sleep) || IS_ERR_OR_NULL(chg->idt_en_default)) { chg_err("pinctrl null, return\n"); return -1; } return gpio_get_value(chg->idt_en_gpio); } bool oplus_get_wired_otg_online(void) { int ret; union power_supply_propval val; struct smb_charger *chg = NULL; struct oplus_chg_chip *chip = g_oplus_chip; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb2_chg not ready!\n", __func__); return false; } if (chip->wpc_no_chargerpump && oplus_wpc_get_fw_updating() == true) { return false; } chg = &chip->pmic_spmi.smb5_chip->chg; ret = power_supply_get_property(chg->usb_psy, POWER_SUPPLY_PROP_TYPEC_MODE, &val); if (ret) { printk(KERN_ERR "%s: Unable to read USB TYPEC_MODE\n", __func__); val.intval = 0; } if (val.intval >= POWER_SUPPLY_TYPEC_SINK && val.intval <= POWER_SUPPLY_TYPEC_POWERED_CABLE_ONLY && val.intval != POWER_SUPPLY_TYPEC_SINK_AUDIO_ADAPTER) { return true; } else { return false; } } bool oplus_get_wired_chg_present(void) { int rc = 0; u8 stat = 0; bool vbus_rising = false; struct smb_charger *chg = NULL; struct oplus_chg_chip *chip = g_oplus_chip; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb2_chg not ready!\n", __func__); return false; } chg = &chip->pmic_spmi.smb5_chip->chg; if (oplus_get_wired_otg_online()) return false; rc = smblib_read(chg, USBIN_BASE + INT_RT_STS_OFFSET, &stat); if (rc < 0) { smblib_err(chg, "oplus_get_wired_chg_present fail, rc=%d\n", rc); return false; } vbus_rising = (bool)(stat & USBIN_PLUGIN_RT_STS_BIT); return vbus_rising; } void oplus_switch_to_wired_charge(struct smb_charger *chg) { oplus_wpc_dis_wireless_chg(1); if (oplus_wpc_get_wireless_charge_start() == true) { if (g_oplus_chip->wpc_no_chargerpump == false) oplus_wpc_set_vbat_en_val(1); } if (oplus_wpc_get_otg_charging()) { if (g_oplus_chip->wpc_no_chargerpump) { oplus_wpc_set_rtx_function(false); } mp2650_wireless_set_mps_otg_en_val(0); oplus_wpc_set_wrx_otg_en_value(0); cancel_delayed_work_sync(&chg->wait_wired_charge_on); schedule_delayed_work(&chg->wait_wired_charge_on, msecs_to_jiffies(100)); } } void oplus_switch_from_wired_charge(struct smb_charger *chg) { if (oplus_wpc_get_otg_charging()) { oplus_wpc_set_booster_en_val(0); oplus_wpc_set_ext2_wireless_otg_en_val(1); cancel_delayed_work_sync(&chg->wait_wired_charge_off); schedule_delayed_work(&chg->wait_wired_charge_off, msecs_to_jiffies(100)); } else { oplus_wpc_set_vbat_en_val(0); if (g_oplus_chip->wpc_no_chargerpump && oplus_wpc_get_fw_updating() == false) oplus_wpc_dis_wireless_chg(0); } } void oplus_dcin_irq_enable(bool enable) { static bool dcin_en = true; struct oplus_chg_chip *chip = g_oplus_chip; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb2_chg not ready!\n", __func__); return; } if (enable && !dcin_en) { printk(KERN_ERR "[OPLUS_CHG][%s]: enable!\n", __func__); enable_irq(chip->pmic_spmi.smb5_chip->chg.irq_info[DCIN_UV_IRQ].irq); enable_irq(chip->pmic_spmi.smb5_chip->chg.irq_info[DCIN_OV_IRQ].irq); enable_irq(chip->pmic_spmi.smb5_chip->chg.irq_info[DCIN_PLUGIN_IRQ].irq); enable_irq(chip->pmic_spmi.smb5_chip->chg.irq_info[DCIN_REVI_IRQ].irq); enable_irq(chip->pmic_spmi.smb5_chip->chg.irq_info[DCIN_PON_IRQ].irq); enable_irq(chip->pmic_spmi.smb5_chip->chg.irq_info[DCIN_EN_IRQ].irq); } else if (!enable && dcin_en) { printk(KERN_ERR "[OPLUS_CHG][%s]: disable!\n", __func__); disable_irq_nosync(chip->pmic_spmi.smb5_chip->chg.irq_info[DCIN_UV_IRQ].irq); disable_irq_nosync(chip->pmic_spmi.smb5_chip->chg.irq_info[DCIN_OV_IRQ].irq); disable_irq_nosync(chip->pmic_spmi.smb5_chip->chg.irq_info[DCIN_PLUGIN_IRQ].irq); disable_irq_nosync(chip->pmic_spmi.smb5_chip->chg.irq_info[DCIN_REVI_IRQ].irq); disable_irq_nosync(chip->pmic_spmi.smb5_chip->chg.irq_info[DCIN_PON_IRQ].irq); disable_irq_nosync(chip->pmic_spmi.smb5_chip->chg.irq_info[DCIN_EN_IRQ].irq); } dcin_en = enable; } #endif /* OPLUS_FEATURE_CHG_BASIC */ #define typec_rp_med_high(chg, typec_mode) \ ((typec_mode == POWER_SUPPLY_TYPEC_SOURCE_MEDIUM \ || typec_mode == 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 pst); int smblib_read(struct smb_charger *chg, u16 addr, u8 *val) { unsigned int value; int rc = 0; rc = regmap_read(chg->regmap, addr, &value); if (rc >= 0) *val = (u8)value; return rc; } int smblib_batch_read(struct smb_charger *chg, u16 addr, u8 *val, int count) { return regmap_bulk_read(chg->regmap, addr, val, count); } int smblib_write(struct smb_charger *chg, u16 addr, u8 val) { return regmap_write(chg->regmap, addr, val); } int smblib_batch_write(struct smb_charger *chg, u16 addr, u8 *val, int count) { return regmap_bulk_write(chg->regmap, addr, val, count); } int smblib_masked_write(struct smb_charger *chg, u16 addr, u8 mask, u8 val) { return regmap_update_bits(chg->regmap, addr, mask, val); } int smblib_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) smblib_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 smblib_read_iio_channel(struct smb_charger *chg, struct iio_channel *chan, int div, int *data) { int rc = 0; *data = -ENODATA; if (chan) { rc = iio_read_channel_processed(chan, data); if (rc < 0) { smblib_err(chg, "Error in reading IIO channel data, rc=%d\n", rc); return rc; } if (div != 0) *data /= div; } return rc; } int smblib_get_jeita_cc_delta(struct smb_charger *chg, int *cc_delta_ua) { int rc, cc_minus_ua; u8 stat; rc = smblib_read(chg, BATTERY_CHARGER_STATUS_7_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read BATTERY_CHARGER_STATUS_2 rc=%d\n", rc); return rc; } if (stat & BAT_TEMP_STATUS_HOT_SOFT_BIT) { rc = smblib_get_charge_param(chg, &chg->param.jeita_cc_comp_hot, &cc_minus_ua); if (rc < 0) { smblib_err(chg, "Couldn't get jeita cc minus rc=%d\n", rc); return rc; } } else if (stat & BAT_TEMP_STATUS_COLD_SOFT_BIT) { rc = smblib_get_charge_param(chg, &chg->param.jeita_cc_comp_cold, &cc_minus_ua); if (rc < 0) { smblib_err(chg, "Couldn't get jeita cc minus rc=%d\n", rc); return rc; } } else { cc_minus_ua = 0; } *cc_delta_ua = -cc_minus_ua; return 0; } int smblib_icl_override(struct smb_charger *chg, enum icl_override_mode mode) { int rc; u8 usb51_mode, icl_override, apsd_override; switch (mode) { case SW_OVERRIDE_USB51_MODE: usb51_mode = 0; icl_override = ICL_OVERRIDE_BIT; apsd_override = 0; break; case SW_OVERRIDE_HC_MODE: usb51_mode = USBIN_MODE_CHG_BIT; icl_override = 0; apsd_override = ICL_OVERRIDE_AFTER_APSD_BIT; break; #ifdef OPLUS_CUSTOM_OP_DEF case SW_OVERRIDE_WIRELESS_MODE: usb51_mode = USBIN_MODE_CHG_BIT; icl_override = ICL_OVERRIDE_BIT; apsd_override = ICL_OVERRIDE_AFTER_APSD_BIT; break; #endif case HW_AUTO_MODE: default: usb51_mode = USBIN_MODE_CHG_BIT; icl_override = 0; apsd_override = 0; break; } rc = smblib_masked_write(chg, USBIN_ICL_OPTIONS_REG, USBIN_MODE_CHG_BIT, usb51_mode); if (rc < 0) { smblib_err(chg, "Couldn't set USBIN_ICL_OPTIONS rc=%d\n", rc); return rc; } rc = smblib_masked_write(chg, CMD_ICL_OVERRIDE_REG, ICL_OVERRIDE_BIT, icl_override); if (rc < 0) { smblib_err(chg, "Couldn't override ICL rc=%d\n", rc); return rc; } rc = smblib_masked_write(chg, USBIN_LOAD_CFG_REG, ICL_OVERRIDE_AFTER_APSD_BIT, apsd_override); if (rc < 0) { smblib_err(chg, "Couldn't override ICL_AFTER_APSD rc=%d\n", rc); return rc; } return rc; } /* * This function does smb_en pin access, which is lock protected. * It should be called with smb_lock held. */ static int smblib_select_sec_charger_locked(struct smb_charger *chg, int sec_chg) { int rc = 0; switch (sec_chg) { case POWER_SUPPLY_CHARGER_SEC_CP: vote(chg->pl_disable_votable, PL_SMB_EN_VOTER, true, 0); /* select Charge Pump instead of slave charger */ rc = smblib_masked_write(chg, MISC_SMB_CFG_REG, SMB_EN_SEL_BIT, SMB_EN_SEL_BIT); if (rc < 0) { dev_err(chg->dev, "Couldn't select SMB charger rc=%d\n", rc); return rc; } /* Enable Charge Pump, under HW control */ rc = smblib_masked_write(chg, MISC_SMB_EN_CMD_REG, EN_CP_CMD_BIT, EN_CP_CMD_BIT); if (rc < 0) { dev_err(chg->dev, "Couldn't enable SMB charger rc=%d\n", rc); return rc; } vote(chg->smb_override_votable, PL_SMB_EN_VOTER, false, 0); break; case POWER_SUPPLY_CHARGER_SEC_PL: /* select slave charger instead of Charge Pump */ rc = smblib_masked_write(chg, MISC_SMB_CFG_REG, SMB_EN_SEL_BIT, 0); if (rc < 0) { dev_err(chg->dev, "Couldn't select SMB charger rc=%d\n", rc); return rc; } /* Enable slave charger, under HW control */ rc = smblib_masked_write(chg, MISC_SMB_EN_CMD_REG, EN_STAT_CMD_BIT, EN_STAT_CMD_BIT); if (rc < 0) { dev_err(chg->dev, "Couldn't enable SMB charger rc=%d\n", rc); return rc; } vote(chg->smb_override_votable, PL_SMB_EN_VOTER, false, 0); vote(chg->pl_disable_votable, PL_SMB_EN_VOTER, false, 0); break; case POWER_SUPPLY_CHARGER_SEC_NONE: default: vote(chg->pl_disable_votable, PL_SMB_EN_VOTER, true, 0); /* SW override, disabling secondary charger(s) */ vote(chg->smb_override_votable, PL_SMB_EN_VOTER, true, 0); break; } return rc; } static int smblib_select_sec_charger(struct smb_charger *chg, int sec_chg, int reason, bool toggle) { int rc; mutex_lock(&chg->smb_lock); if (toggle && sec_chg == POWER_SUPPLY_CHARGER_SEC_CP) { rc = smblib_select_sec_charger_locked(chg, POWER_SUPPLY_CHARGER_SEC_NONE); if (rc < 0) { dev_err(chg->dev, "Couldn't disable secondary charger rc=%d\n", rc); goto unlock_out; } /* * A minimum of 20us delay is expected before switching on STAT * pin. */ usleep_range(20, 30); } rc = smblib_select_sec_charger_locked(chg, sec_chg); if (rc < 0) { dev_err(chg->dev, "Couldn't switch secondary charger rc=%d\n", rc); goto unlock_out; } chg->sec_chg_selected = sec_chg; chg->cp_reason = reason; unlock_out: mutex_unlock(&chg->smb_lock); return rc; } static void smblib_notify_extcon_props(struct smb_charger *chg, int id) { union extcon_property_value val; union power_supply_propval prop_val; if (chg->connector_type == POWER_SUPPLY_CONNECTOR_TYPEC) { smblib_get_prop_typec_cc_orientation(chg, &prop_val); val.intval = ((prop_val.intval == 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 == POWER_SUPPLY_CONNECTOR_MICRO_USB) { val.intval = false; extcon_set_property(chg->extcon, id, EXTCON_PROP_USB_SS, val); } } static void smblib_notify_device_mode(struct smb_charger *chg, bool enable) { if (enable) smblib_notify_extcon_props(chg, EXTCON_USB); extcon_set_state_sync(chg->extcon, EXTCON_USB, enable); } static void smblib_notify_usb_host(struct smb_charger *chg, bool enable) { int rc = 0; if (enable) { smblib_dbg(chg, PR_OTG, "enabling VBUS in OTG mode\n"); rc = smblib_masked_write(chg, DCDC_CMD_OTG_REG, OTG_EN_BIT, OTG_EN_BIT); if (rc < 0) { smblib_err(chg, "Couldn't enable VBUS in OTG mode rc=%d\n", rc); return; } smblib_notify_extcon_props(chg, EXTCON_USB_HOST); } else { smblib_dbg(chg, PR_OTG, "disabling VBUS in OTG mode\n"); rc = smblib_masked_write(chg, DCDC_CMD_OTG_REG, OTG_EN_BIT, 0); if (rc < 0) { smblib_err(chg, "Couldn't disable VBUS in OTG mode rc=%d\n", rc); return; } } extcon_set_state_sync(chg->extcon, EXTCON_USB_HOST, enable); } /******************** * REGISTER GETTERS * ********************/ int smblib_get_charge_param(struct smb_charger *chg, struct smb_chg_param *param, int *val_u) { int rc = 0; u8 val_raw; rc = smblib_read(chg, param->reg, &val_raw); if (rc < 0) { smblib_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; /*smblib_dbg(chg, PR_REGISTER, "%s = %d (0x%02x)\n", param->name, *val_u, val_raw);*/ return rc; } int smblib_get_usb_suspend(struct smb_charger *chg, int *suspend) { int rc = 0; u8 temp; rc = smblib_read(chg, USBIN_CMD_IL_REG, &temp); if (rc < 0) { smblib_err(chg, "Couldn't read USBIN_CMD_IL rc=%d\n", rc); return rc; } *suspend = temp & USBIN_SUSPEND_BIT; return rc; } static const s16 therm_lookup_table[] = { /* Index -30C~85C, ADC raw code */ 0x6C92, 0x6C43, 0x6BF0, 0x6B98, 0x6B3A, 0x6AD8, 0x6A70, 0x6A03, 0x6990, 0x6916, 0x6897, 0x6811, 0x6785, 0x66F2, 0x6658, 0x65B7, 0x650F, 0x6460, 0x63AA, 0x62EC, 0x6226, 0x6159, 0x6084, 0x5FA8, 0x5EC3, 0x5DD8, 0x5CE4, 0x5BE9, 0x5AE7, 0x59DD, 0x58CD, 0x57B5, 0x5696, 0x5571, 0x5446, 0x5314, 0x51DD, 0x50A0, 0x4F5E, 0x4E17, 0x4CCC, 0x4B7D, 0x4A2A, 0x48D4, 0x477C, 0x4621, 0x44C4, 0x4365, 0x4206, 0x40A6, 0x3F45, 0x3DE6, 0x3C86, 0x3B28, 0x39CC, 0x3872, 0x3719, 0x35C4, 0x3471, 0x3322, 0x31D7, 0x308F, 0x2F4C, 0x2E0D, 0x2CD3, 0x2B9E, 0x2A6E, 0x2943, 0x281D, 0x26FE, 0x25E3, 0x24CF, 0x23C0, 0x22B8, 0x21B5, 0x20B8, 0x1FC2, 0x1ED1, 0x1DE6, 0x1D01, 0x1C22, 0x1B49, 0x1A75, 0x19A8, 0x18E0, 0x181D, 0x1761, 0x16A9, 0x15F7, 0x154A, 0x14A2, 0x13FF, 0x1361, 0x12C8, 0x1234, 0x11A4, 0x1119, 0x1091, 0x100F, 0x0F90, 0x0F15, 0x0E9E, 0x0E2B, 0x0DBC, 0x0D50, 0x0CE8, 0x0C83, 0x0C21, 0x0BC3, 0x0B67, 0x0B0F, 0x0AB9, 0x0A66, 0x0A16, 0x09C9, 0x097E, }; int smblib_get_thermal_threshold(struct smb_charger *chg, u16 addr, int *val) { u8 buff[2]; s16 temp; int rc = 0; int i, lower, upper; rc = smblib_batch_read(chg, addr, buff, 2); if (rc < 0) { pr_err("failed to write to 0x%04X, rc=%d\n", addr, rc); return rc; } temp = buff[1] | buff[0] << 8; lower = 0; upper = ARRAY_SIZE(therm_lookup_table) - 1; while (lower <= upper) { i = (upper + lower) / 2; if (therm_lookup_table[i] < temp) upper = i - 1; else if (therm_lookup_table[i] > temp) lower = i + 1; else break; } /* index 0 corresonds to -30C */ *val = (i - 30) * 10; return rc; } struct apsd_result { const char * const name; const u8 bit; const enum power_supply_type pst; }; enum { UNKNOWN, SDP, CDP, DCP, OCP, FLOAT, HVDCP2, HVDCP3, MAX_TYPES }; static const struct apsd_result smblib_apsd_results[] = { [UNKNOWN] = { .name = "UNKNOWN", .bit = 0, .pst = POWER_SUPPLY_TYPE_UNKNOWN }, [SDP] = { .name = "SDP", .bit = SDP_CHARGER_BIT, .pst = POWER_SUPPLY_TYPE_USB }, [CDP] = { .name = "CDP", .bit = CDP_CHARGER_BIT, .pst = POWER_SUPPLY_TYPE_USB_CDP }, [DCP] = { .name = "DCP", .bit = DCP_CHARGER_BIT, .pst = POWER_SUPPLY_TYPE_USB_DCP }, [OCP] = { .name = "OCP", .bit = OCP_CHARGER_BIT, .pst = POWER_SUPPLY_TYPE_USB_DCP }, [FLOAT] = { .name = "FLOAT", .bit = FLOAT_CHARGER_BIT, #ifndef OPLUS_FEATURE_CHG_BASIC .pst = POWER_SUPPLY_TYPE_USB_FLOAT #else .pst = POWER_SUPPLY_TYPE_USB_DCP #endif }, [HVDCP2] = { .name = "HVDCP2", .bit = DCP_CHARGER_BIT | QC_2P0_BIT, .pst = POWER_SUPPLY_TYPE_USB_HVDCP }, [HVDCP3] = { .name = "HVDCP3", .bit = DCP_CHARGER_BIT | QC_3P0_BIT, .pst = POWER_SUPPLY_TYPE_USB_HVDCP_3, }, }; static const struct apsd_result *smblib_get_apsd_result(struct smb_charger *chg) { int rc, i; u8 apsd_stat, stat; const struct apsd_result *result = &smblib_apsd_results[UNKNOWN]; rc = smblib_read(chg, APSD_STATUS_REG, &apsd_stat); if (rc < 0) { smblib_err(chg, "Couldn't read APSD_STATUS rc=%d\n", rc); return result; } smblib_dbg(chg, PR_REGISTER, "APSD_STATUS = 0x%02x\n", apsd_stat); if (!(apsd_stat & APSD_DTC_STATUS_DONE_BIT)) return result; rc = smblib_read(chg, APSD_RESULT_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read APSD_RESULT_STATUS rc=%d\n", rc); return result; } stat &= APSD_RESULT_STATUS_MASK; for (i = 0; i < ARRAY_SIZE(smblib_apsd_results); i++) { if (smblib_apsd_results[i].bit == stat) result = &smblib_apsd_results[i]; } if (apsd_stat & QC_CHARGER_BIT) { /* since its a qc_charger, either return HVDCP3 or HVDCP2 */ #ifdef OPLUS_FEATURE_CHG_BASIC if (result != &smblib_apsd_results[HVDCP3]) result = &smblib_apsd_results[HVDCP2]; #else if (result != &smblib_apsd_results[HVDCP3] && result->bit == (DCP_CHARGER_BIT | QC_2P0_BIT)) result = &smblib_apsd_results[HVDCP2]; #endif } return result; } #define INPUT_NOT_PRESENT 0 #define INPUT_PRESENT_USB BIT(1) #define INPUT_PRESENT_DC BIT(2) static int smblib_is_input_present(struct smb_charger *chg, int *present) { int rc; union power_supply_propval pval = {0, }; *present = INPUT_NOT_PRESENT; rc = smblib_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; rc = smblib_get_prop_dc_present(chg, &pval); if (rc < 0) { pr_err("Couldn't get dc presence status rc=%d\n", rc); return rc; } *present |= pval.intval ? INPUT_PRESENT_DC : INPUT_NOT_PRESENT; return 0; } #define AICL_RANGE2_MIN_MV 5600 #define AICL_RANGE2_STEP_DELTA_MV 200 #define AICL_RANGE2_OFFSET 16 int smblib_get_aicl_cont_threshold(struct smb_chg_param *param, u8 val_raw) { int base = param->min_u; u8 reg = val_raw; int step = param->step_u; if (val_raw >= AICL_RANGE2_OFFSET) { reg = val_raw - AICL_RANGE2_OFFSET; base = AICL_RANGE2_MIN_MV; step = AICL_RANGE2_STEP_DELTA_MV; } return base + (reg * step); } /******************** * REGISTER SETTERS * ********************/ static const struct buck_boost_freq chg_freq_list[] = { [0] = { .freq_khz = 2400, .val = 7, }, [1] = { .freq_khz = 2100, .val = 8, }, [2] = { .freq_khz = 1600, .val = 11, }, [3] = { .freq_khz = 1200, .val = 15, }, }; int smblib_set_chg_freq(struct smb_chg_param *param, int val_u, u8 *val_raw) { u8 i; if (val_u > param->max_u || val_u < param->min_u) return -EINVAL; /* Charger FSW is the configured freqency / 2 */ val_u *= 2; for (i = 0; i < ARRAY_SIZE(chg_freq_list); i++) { if (chg_freq_list[i].freq_khz == val_u) break; } if (i == ARRAY_SIZE(chg_freq_list)) { pr_err("Invalid frequency %d Hz\n", val_u / 2); return -EINVAL; } *val_raw = chg_freq_list[i].val; return 0; } int smblib_set_opt_switcher_freq(struct smb_charger *chg, int fsw_khz) { union power_supply_propval pval = {0, }; int rc = 0; rc = smblib_set_charge_param(chg, &chg->param.freq_switcher, fsw_khz); if (rc < 0) dev_err(chg->dev, "Error in setting freq_buck rc=%d\n", rc); if (chg->mode == PARALLEL_MASTER && chg->pl.psy) { pval.intval = fsw_khz; /* * Some parallel charging implementations may not have * PROP_BUCK_FREQ property - they could be running * with a fixed frequency */ power_supply_set_property(chg->pl.psy, POWER_SUPPLY_PROP_BUCK_FREQ, &pval); } return rc; } int smblib_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) smblib_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 = smblib_write(chg, param->reg, val_raw); if (rc < 0) { smblib_err(chg, "%s: Couldn't write 0x%02x to 0x%04x rc=%d\n", param->name, val_raw, param->reg, rc); return rc; } /*smblib_dbg(chg, PR_REGISTER, "%s = %d (0x%02x)\n", param->name, val_u, val_raw);*/ return rc; } int smblib_set_usb_suspend(struct smb_charger *chg, bool suspend) { int rc = 0; #ifndef OPLUS_FEATURE_CHG_BASIC int boot_mode = get_boot_mode(); if ((boot_mode == MSM_BOOT_MODE__RF || boot_mode == MSM_BOOT_MODE__WLAN) && suspend == false) { chg_err("RF/WLAN, suspending...\n"); suspend = true; } #endif #ifdef OPLUS_FEATURE_CHG_BASIC #ifdef OPLUS_CUSTOM_OP_DEF if (g_oplus_chip && (g_oplus_chip->vbatt_num == 2)) { suspend = true; } #else if(!oplus_charger_ic_chip_is_null()) { suspend = true; } #endif #endif if (suspend) vote(chg->icl_irq_disable_votable, USB_SUSPEND_VOTER, true, 0); suspend_usb = suspend; rc = smblib_masked_write(chg, USBIN_CMD_IL_REG, USBIN_SUSPEND_BIT, suspend ? USBIN_SUSPEND_BIT : 0); if (rc < 0) smblib_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; } int smblib_set_dc_suspend(struct smb_charger *chg, bool suspend) { int rc = 0; rc = smblib_masked_write(chg, DCIN_CMD_IL_REG, DCIN_SUSPEND_BIT, suspend ? DCIN_SUSPEND_BIT : 0); if (rc < 0) smblib_err(chg, "Couldn't write %s to DCIN_SUSPEND_BIT rc=%d\n", suspend ? "suspend" : "resume", rc); return rc; } #ifdef OPLUS_CUSTOM_OP_DEF #define MICRO_5V 5000000 #define MICRO_9V 9000000 #define MICRO_12V 12000000 static int op_set_wireless_fsw(struct smb_charger *chg, int voltage) { int rc = 0; if (voltage == MICRO_5V) rc = smblib_set_opt_switcher_freq(chg, chg->chg_freq.freq_6V_8V); else if (voltage > MICRO_5V && voltage < MICRO_9V) rc = smblib_set_opt_switcher_freq(chg, chg->chg_freq.freq_6V_8V); else if (voltage >= MICRO_9V && voltage < MICRO_12V) rc = smblib_set_opt_switcher_freq(chg, chg->chg_freq.freq_12V); else if (voltage == MICRO_12V) rc = smblib_set_opt_switcher_freq(chg, chg->chg_freq.freq_12V); else { smblib_err(chg, "Couldn't set Fsw: invalid voltage %d\n", voltage); return -EINVAL; } return rc; } int op_wireless_high_vol_en(bool enable) { int rc; static bool reconfiged_aicl; g_chg->wireless_high_vol_mode = enable; smblib_hvdcp_detect_enable(g_chg, enable); rc = smblib_write(g_chg, USBIN_ADAPTER_ALLOW_CFG_REG, enable ? USBIN_ADAPTER_ALLOW_5V_TO_12V : USBIN_ADAPTER_ALLOW_5V); if (rc < 0) { smblib_err(g_chg, "Couldn't write USBIN_ADAPTER_ALLOW_CFG_REG, rc=%d\n", rc); return rc; } if (g_chg->wireless_present) { rc = op_set_wireless_fsw(g_chg, enable ? MICRO_9V : MICRO_5V); if (rc < 0) { smblib_err(g_chg, "Couldn't set buck freq, rc=%d\n", rc); return rc; } if (!reconfiged_aicl) { /* usbin collapse keep FET on. */ rc = smblib_masked_write(g_chg, USBIN_AICL_OPTIONS_CFG_REG, USBIN_AICL_EN_BIT | USBIN_HV_COLLAPSE_RESPONSE_BIT | USBIN_LV_COLLAPSE_RESPONSE_BIT, USBIN_AICL_EN_BIT); if (rc < 0) { smblib_err(g_chg, "Couldn't turn on USBIN_AICL_OPTIONS_CFG_REG AICL rc=%d\n", rc); return rc; } rc = smblib_masked_write(g_chg, USBIN_LOAD_CFG_REG, USBIN_AICL_STEP_TIMING_SEL_MASK | USBIN_IN_COLLAPSE_GF_SEL_MASK, USBIN_AICL_STEP_TIMING_SEL_MASK | BIT(1)); if (rc < 0) { smblib_err(g_chg, "Couldn't turn on USBIN_LOAD_CFG_REG rc=%d\n", rc); return rc; } reconfiged_aicl = true; } } else { reconfiged_aicl = false; /* restore usbin aicl step timing. */ rc = smblib_masked_write(g_chg, USBIN_LOAD_CFG_REG, USBIN_AICL_STEP_TIMING_SEL_MASK | USBIN_IN_COLLAPSE_GF_SEL_MASK, 0); if (rc < 0) { smblib_err(g_chg, "Couldn't turn on USBIN_LOAD_CFG_REG rc=%d\n", rc); return rc; } } return rc; } void op_switch_normal_set(void) { bool support_4p45 = true; struct smb_charger *chg = g_chg; if (!chg) return; /*support_4p45 = get_4p45_battery_support();*/ pr_info("switch_normal_set,support_4p45:%d\n", support_4p45); #ifdef OP_SWARP_SUPPORTED if (chg->swarp_supported && chg->pd_active) { op_pdo_select(5000, 3000); msleep(300); } #endif vote(chg->usb_icl_votable, DCP_VOTER, true, 2000 * 1000); if (support_4p45) vote(chg->fv_votable, DEFAULT_VOTER, true, 4550 * 1000); else vote(chg->fv_votable, DEFAULT_VOTER, true, 4500 * 1000); if (chg->wireless_present) { vote(chg->usb_icl_votable, WLCH_FFC_VOTER, true, 1000000); vote(chg->fcc_votable, DEFAULT_VOTER, true, 1500 * 1000); } else { #ifdef OP_SWARP_SUPPORTED if (chg->swarp_supported) vote(chg->fcc_votable, DEFAULT_VOTER, true, chg->FFC_FAST_FCC * 1000); else #endif vote(chg->fcc_votable, DEFAULT_VOTER, true, 1400 * 1000); } /*chg->ffc_status = FFC_FAST;*/ } #endif // OPLUS_CUSTOM_OP_DEF static int smblib_usb_pd_adapter_allowance_override(struct smb_charger *chg, u8 allowed_voltage) { int rc = 0; if (chg->chg_param.smb_version == PMI632_SUBTYPE) return 0; #ifdef OPLUS_CUSTOM_OP_DEF if (chg->wireless_high_vol_mode) { smblib_dbg(chg, PR_MISC, "Wireless high voltage mode, exit\n"); return 0; } #endif rc = smblib_write(chg, USBIN_ADAPTER_ALLOW_OVERRIDE_REG, allowed_voltage); if (rc < 0) smblib_err(chg, "Couldn't write 0x%02x to USBIN_ADAPTER_ALLOW_OVERRIDE_REG rc=%d\n", allowed_voltage, rc); smblib_dbg(chg, PR_MISC, "set USBIN_ALLOW_OVERRIDE: %d\n", allowed_voltage); return rc; } #define MICRO_5V 5000000 #define MICRO_9V 9000000 #define MICRO_12V 12000000 static int smblib_set_usb_pd_fsw(struct smb_charger *chg, int voltage) { int rc = 0; if (voltage == MICRO_5V) rc = smblib_set_opt_switcher_freq(chg, chg->chg_freq.freq_5V); else if (voltage > MICRO_5V && voltage < MICRO_9V) rc = smblib_set_opt_switcher_freq(chg, chg->chg_freq.freq_6V_8V); else if (voltage >= MICRO_9V && voltage < MICRO_12V) rc = smblib_set_opt_switcher_freq(chg, chg->chg_freq.freq_9V); else if (voltage == MICRO_12V) rc = smblib_set_opt_switcher_freq(chg, chg->chg_freq.freq_12V); else { smblib_err(chg, "Couldn't set Fsw: invalid voltage %d\n", voltage); return -EINVAL; } return rc; } #define CONT_AICL_HEADROOM_MV 1000 #define AICL_THRESHOLD_MV_IN_CC 5000 static int smblib_set_usb_pd_allowed_voltage(struct smb_charger *chg, int min_allowed_uv, int max_allowed_uv) { int rc, aicl_threshold; u8 vbus_allowance; if (chg->chg_param.smb_version == PMI632_SUBTYPE) return 0; if (chg->pd_active == POWER_SUPPLY_PD_PPS_ACTIVE) { vbus_allowance = CONTINUOUS; } else if (min_allowed_uv == MICRO_5V && max_allowed_uv == MICRO_5V) { vbus_allowance = FORCE_5V; } else if (min_allowed_uv == MICRO_9V && max_allowed_uv == MICRO_9V) { vbus_allowance = FORCE_9V; } else if (min_allowed_uv == MICRO_12V && max_allowed_uv == MICRO_12V) { vbus_allowance = FORCE_12V; } else if (min_allowed_uv < MICRO_12V && max_allowed_uv <= MICRO_12V) { vbus_allowance = CONTINUOUS; } else { smblib_err(chg, "invalid allowed voltage [%d, %d]\n", min_allowed_uv, max_allowed_uv); return -EINVAL; } rc = smblib_usb_pd_adapter_allowance_override(chg, vbus_allowance); if (rc < 0) { smblib_err(chg, "set CONTINUOUS allowance failed, rc=%d\n", rc); return rc; } if (vbus_allowance != CONTINUOUS) return 0; aicl_threshold = min_allowed_uv / 1000 - CONT_AICL_HEADROOM_MV; if (chg->adapter_cc_mode) aicl_threshold = min(aicl_threshold, AICL_THRESHOLD_MV_IN_CC); rc = smblib_set_charge_param(chg, &chg->param.aicl_cont_threshold, aicl_threshold); if (rc < 0) { smblib_err(chg, "set CONT_AICL_THRESHOLD failed, rc=%d\n", rc); return rc; } return rc; } int smblib_set_aicl_cont_threshold(struct smb_chg_param *param, int val_u, u8 *val_raw) { int base = param->min_u; int offset = 0; int step = param->step_u; if (val_u > param->max_u) val_u = param->max_u; if (val_u < param->min_u) val_u = param->min_u; if (val_u >= AICL_RANGE2_MIN_MV) { base = AICL_RANGE2_MIN_MV; step = AICL_RANGE2_STEP_DELTA_MV; offset = AICL_RANGE2_OFFSET; }; *val_raw = ((val_u - base) / step) + offset; return 0; } /******************** * HELPER FUNCTIONS * ********************/ static bool is_cp_available(struct smb_charger *chg) { if (!chg->cp_psy) chg->cp_psy = power_supply_get_by_name("charge_pump_master"); return !!chg->cp_psy; } #define CP_TO_MAIN_ICL_OFFSET_PC 10 int smblib_get_qc3_main_icl_offset(struct smb_charger *chg, int *offset_ua) { union power_supply_propval pval = {0, }; int rc; if ((chg->real_charger_type != POWER_SUPPLY_TYPE_USB_HVDCP_3) || chg->hvdcp3_standalone_config || !is_cp_available(chg)) { *offset_ua = 0; return 0; } rc = power_supply_get_property(chg->cp_psy, POWER_SUPPLY_PROP_CP_ILIM, &pval); if (rc < 0) { smblib_err(chg, "Couldn't get CP ILIM rc=%d\n", rc); return rc; } *offset_ua = (pval.intval * CP_TO_MAIN_ICL_OFFSET_PC * 2) / 100; return 0; } int smblib_get_prop_from_bms(struct smb_charger *chg, enum power_supply_property psp, union power_supply_propval *val) { int rc; #ifdef OPLUS_FEATURE_CHG_BASIC if (!chg->bms_psy) { val->intval = 50; return 0; } #else if (!chg->bms_psy) return -EINVAL; #endif rc = power_supply_get_property(chg->bms_psy, psp, val); return rc; } void smblib_apsd_enable(struct smb_charger *chg, bool enable) { int rc; rc = smblib_masked_write(chg, USBIN_OPTIONS_1_CFG_REG, BC1P2_SRC_DETECT_BIT, enable ? BC1P2_SRC_DETECT_BIT : 0); if (rc < 0) smblib_err(chg, "failed to write USBIN_OPTIONS_1_CFG rc=%d\n", rc); } #ifdef OPLUS_CUSTOM_OP_DEF void smblib_bypass_vsafe0_control(struct smb_charger *chg, bool enable) { int rc = -1; rc = smblib_masked_write(g_chg, TYPE_C_EXIT_STATE_CFG_REG, BYPASS_VSAFE0V_DURING_ROLE_SWAP_BIT, (enable ? (u8)BYPASS_VSAFE0V_DURING_ROLE_SWAP_BIT : 0)); if (rc < 0) smblib_err(g_chg, "Couldn't set exit state cfg(0x1550) rc=%d\n", rc); } #endif void smblib_hvdcp_detect_enable(struct smb_charger *chg, bool enable) { int rc; u8 mask; #ifdef OPLUS_FEATURE_CHG_BASIC mask = HVDCP_EN_BIT; #else mask = HVDCP_AUTH_ALG_EN_CFG_BIT | HVDCP_EN_BIT; #endif rc = smblib_masked_write(chg, USBIN_OPTIONS_1_CFG_REG, mask, enable ? mask : 0); if (rc < 0) smblib_err(chg, "failed to write USBIN_OPTIONS_1_CFG rc=%d\n", rc); smblib_err(chg, "success to write enable =%d\n", enable); } static void smblib_hvdcp_detect_try_enable(struct smb_charger *chg, bool enable) { if (chg->hvdcp_disable || chg->pd_not_supported) return; smblib_hvdcp_detect_enable(chg, enable); } void smblib_hvdcp_hw_inov_enable(struct smb_charger *chg, bool enable) { int rc; rc = smblib_masked_write(chg, USBIN_OPTIONS_1_CFG_REG, HVDCP_AUTONOMOUS_MODE_EN_CFG_BIT, enable ? HVDCP_AUTONOMOUS_MODE_EN_CFG_BIT : 0); if (rc < 0) smblib_err(chg, "failed to write USBIN_OPTIONS_1_CFG rc=%d\n", rc); } void smblib_hvdcp_exit_config(struct smb_charger *chg) { u8 stat; int rc; rc = smblib_read(chg, APSD_RESULT_STATUS_REG, &stat); if (rc < 0) return; if (stat & (QC_3P0_BIT | QC_2P0_BIT)) { /* force HVDCP to 5V */ smblib_masked_write(chg, USBIN_OPTIONS_1_CFG_REG, HVDCP_AUTONOMOUS_MODE_EN_CFG_BIT, 0); smblib_write(chg, CMD_HVDCP_2_REG, FORCE_5V_BIT); /* rerun APSD */ smblib_masked_write(chg, CMD_APSD_REG, APSD_RERUN_BIT, APSD_RERUN_BIT); } } static int smblib_request_dpdm(struct smb_charger *chg, bool enable) { int rc = 0; if (chg->pr_swap_in_progress) 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); smblib_err(chg, "Couldn't get dpdm regulator rc=%d\n", rc); chg->dpdm_reg = NULL; return rc; } } if (enable) { if (chg->dpdm_reg && !regulator_is_enabled(chg->dpdm_reg)) { smblib_dbg(chg, PR_MISC, "enabling DPDM regulator\n"); rc = regulator_enable(chg->dpdm_reg); if (rc < 0) smblib_err(chg, "Couldn't enable dpdm regulator rc=%d\n", rc); } } else { if (chg->dpdm_reg && regulator_is_enabled(chg->dpdm_reg)) { smblib_dbg(chg, PR_MISC, "disabling DPDM regulator\n"); rc = regulator_disable(chg->dpdm_reg); if (rc < 0) smblib_err(chg, "Couldn't disable dpdm regulator rc=%d\n", rc); } } return rc; } static void smblib_rerun_apsd(struct smb_charger *chg) { int rc; smblib_dbg(chg, PR_MISC, "re-running APSD\n"); rc = smblib_masked_write(chg, CMD_APSD_REG, APSD_RERUN_BIT, APSD_RERUN_BIT); if (rc < 0) smblib_err(chg, "Couldn't re-run APSD rc=%d\n", rc); } static const struct apsd_result *smblib_update_usb_type(struct smb_charger *chg) { const struct apsd_result *apsd_result = smblib_get_apsd_result(chg); /* if PD is active, APSD is disabled so won't have a valid result */ if (chg->pd_active) { chg->real_charger_type = POWER_SUPPLY_TYPE_USB_PD; #ifdef OPLUS_CUSTOM_OP_DEF if (chg->wireless_present) notify_pd_in_to_wireless(); #endif // OPLUS_CUSTOM_OP_DEF #ifdef OPLUS_FEATURE_CHG_BASIC printk(KERN_ERR "!!!smblib_update_usb_type: APSD=%s PD=%d\n", apsd_result->name, chg->pd_active); #endif #ifdef OPLUS_CUSTOM_OP_DEF } else if (chg->wireless_present) { chg->real_charger_type = POWER_SUPPLY_TYPE_WIRELESS; chg->usb_psy_desc.type = POWER_SUPPLY_TYPE_WIRELESS; #endif // OPLUS_CUSTOM_OP_DEF } else { /* * Update real charger type only if its not FLOAT * detected as as SDP */ #ifndef OPLUS_FEATURE_CHG_BASIC if (!(apsd_result->pst == POWER_SUPPLY_TYPE_USB_FLOAT && chg->real_charger_type == POWER_SUPPLY_TYPE_USB)) chg->real_charger_type = apsd_result->pst; #else if (!(apsd_result->pst == POWER_SUPPLY_TYPE_USB_FLOAT && chg->real_charger_type == POWER_SUPPLY_TYPE_USB)) { chg->real_charger_type = apsd_result->pst; //chg->usb_psy_desc.type = apsd_result->pst; oplus_set_smb5_usb_props_type(apsd_result->pst); } #endif } smblib_dbg(chg, PR_MISC, "APSD=%s PD=%d\n", apsd_result->name, chg->pd_active); return apsd_result; } #ifdef OPLUS_FEATURE_CHG_BASIC bool opluschg_pd_sdp = false; void opchg_set_pd_sdp(bool pd_sdp) { opluschg_pd_sdp = pd_sdp; return; } EXPORT_SYMBOL(opchg_set_pd_sdp); int opchg_get_charger_type(void) { u8 apsd_stat; int rc; struct smb_charger *chg = NULL; struct oplus_chg_chip *chip = g_oplus_chip; const struct apsd_result *apsd_result; enum power_supply_type type = POWER_SUPPLY_TYPE_UNKNOWN; if (!chip) { type = POWER_SUPPLY_TYPE_UNKNOWN; goto get_type_done; } chg = &chip->pmic_spmi.smb5_chip->chg; apsd_result = smblib_get_apsd_result(chg); /* reset for fastchg to normal */ if (chip->charger_type == POWER_SUPPLY_TYPE_UNKNOWN) chg->pre_current_ma = -1; rc = smblib_read(chg, APSD_STATUS_REG, &apsd_stat); if (rc < 0) { chg_err("Couldn't read APSD_STATUS rc=%d\n", rc); type = POWER_SUPPLY_TYPE_UNKNOWN; goto get_type_done; } //chg_debug("APSD_STATUS = 0x%02x\n", apsd_stat); if (!(apsd_stat & APSD_DTC_STATUS_DONE_BIT)) { if (POWER_SUPPLY_TYPE_USB_PD == chg->real_charger_type) { if (opluschg_pd_sdp == true) { type = POWER_SUPPLY_TYPE_USB; } else { type = POWER_SUPPLY_TYPE_USB_DCP; } goto get_type_done; } type = POWER_SUPPLY_TYPE_UNKNOWN; goto get_type_done; } if (chg->real_charger_type == POWER_SUPPLY_TYPE_USB || chg->real_charger_type == POWER_SUPPLY_TYPE_USB_CDP || chg->real_charger_type == POWER_SUPPLY_TYPE_USB_DCP) { oplus_chg_soc_update(); } if (POWER_SUPPLY_TYPE_UNKNOWN == chg->real_charger_type) { smblib_update_usb_type(chg); chg_debug("update_usb_type: get_charger_type=%d\n", chg->real_charger_type); } if (POWER_SUPPLY_TYPE_USB_PD == chg->real_charger_type) { if (strcmp("SDP", apsd_result->name) == 0 || opluschg_pd_sdp == true) { type = POWER_SUPPLY_TYPE_USB; } else { type = POWER_SUPPLY_TYPE_USB_DCP; } goto get_type_done; } type = chg->real_charger_type; if(type == POWER_SUPPLY_TYPE_UNKNOWN && oplus_chg_get_voocphy_support() == NO_VOOCPHY && oplus_vooc_get_fastchg_to_normal() == true) { chg_err("0x5a quit svooc,set dcp\n"); type = POWER_SUPPLY_TYPE_USB_DCP; } get_type_done: if (chip && chip->wireless_support && oplus_wpc_get_wireless_charge_start() == true) type = POWER_SUPPLY_TYPE_WIRELESS; return type; } int opchg_get_real_charger_type(void) { struct smb_charger *chg = NULL; struct oplus_chg_chip *chip = g_oplus_chip; if (!chip) { return POWER_SUPPLY_TYPE_UNKNOWN; } chg = &chip->pmic_spmi.smb5_chip->chg; return chg->real_charger_type; } static int oplus_chg_get_charger_type(void) { u8 apsd_stat; int rc; struct smb_charger *chg = NULL; struct oplus_chg_chip *chip = g_oplus_chip; const struct apsd_result *apsd_result; enum power_supply_type type = POWER_SUPPLY_TYPE_UNKNOWN; if (!chip) { type = POWER_SUPPLY_TYPE_UNKNOWN; goto get_type_done; } chg = &chip->pmic_spmi.smb5_chip->chg; apsd_result = smblib_get_apsd_result(chg); /* reset for fastchg to normal */ if (chip->charger_type == POWER_SUPPLY_TYPE_UNKNOWN) chg->pre_current_ma = -1; rc = smblib_read(chg, APSD_STATUS_REG, &apsd_stat); if (rc < 0) { chg_err("Couldn't read APSD_STATUS rc=%d\n", rc); type = POWER_SUPPLY_TYPE_UNKNOWN; goto get_type_done; } //chg_debug("APSD_STATUS = 0x%02x\n", apsd_stat); if (!(apsd_stat & APSD_DTC_STATUS_DONE_BIT)) { if (POWER_SUPPLY_TYPE_USB_PD == chg->real_charger_type) { if (opluschg_pd_sdp == true) { type = POWER_SUPPLY_TYPE_USB; } else { type = POWER_SUPPLY_TYPE_USB_DCP; } goto get_type_done; } type = POWER_SUPPLY_TYPE_UNKNOWN; goto get_type_done; } if (POWER_SUPPLY_TYPE_UNKNOWN == chg->real_charger_type) { smblib_update_usb_type(chg); chg_debug("update_usb_type: get_charger_type=%d\n", chg->real_charger_type); } if (POWER_SUPPLY_TYPE_USB_PD == chg->real_charger_type) { if (strcmp("SDP", apsd_result->name) == 0 || opluschg_pd_sdp == true) { type = POWER_SUPPLY_TYPE_USB; } else { type = POWER_SUPPLY_TYPE_USB_DCP; } goto get_type_done; } type = chg->real_charger_type; get_type_done: return type; } #endif static int smblib_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 (!chg->bms_psy) chg->bms_psy = psy; 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); if (chg->sec_pl_present && !chg->pl.psy && !strcmp(psy->desc->name, "parallel")) { chg->pl.psy = psy; schedule_work(&chg->pl_update_work); } if (!strcmp(psy->desc->name, "charge_pump_master")) { pm_stay_awake(chg->dev); schedule_work(&chg->cp_status_change_work); } return NOTIFY_OK; } static int smblib_register_notifier(struct smb_charger *chg) { int rc; chg->nb.notifier_call = smblib_notifier_call; rc = power_supply_reg_notifier(&chg->nb); if (rc < 0) { smblib_err(chg, "Couldn't register psy notifier rc = %d\n", rc); return rc; } return 0; } int smblib_mapping_soc_from_field_value(struct smb_chg_param *param, int val_u, u8 *val_raw) { if (val_u > param->max_u || val_u < param->min_u) return -EINVAL; *val_raw = val_u << 1; return 0; } int smblib_mapping_cc_delta_to_field_value(struct smb_chg_param *param, u8 val_raw) { int val_u = val_raw * param->step_u + param->min_u; if (val_u > param->max_u) val_u -= param->max_u * 2; return val_u; } int smblib_mapping_cc_delta_from_field_value(struct smb_chg_param *param, int val_u, u8 *val_raw) { if (val_u > param->max_u || val_u < param->min_u - param->max_u) return -EINVAL; val_u += param->max_u * 2 - param->min_u; val_u %= param->max_u * 2; *val_raw = val_u / param->step_u; return 0; } static void smblib_uusb_removal(struct smb_charger *chg) { int rc; struct smb_irq_data *data; struct storm_watch *wdata; int sec_charger; sec_charger = chg->sec_pl_present ? POWER_SUPPLY_CHARGER_SEC_PL : POWER_SUPPLY_CHARGER_SEC_NONE; smblib_select_sec_charger(chg, sec_charger, POWER_SUPPLY_CP_NONE, false); 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_flash_active(chg) ? SDP_CURRENT_UA : SDP_100_MA); vote(chg->usb_icl_votable, SW_QC3_VOTER, false, 0); vote(chg->usb_icl_votable, HVDCP2_ICL_VOTER, false, 0); vote(chg->usb_icl_votable, CHG_TERMINATION_VOTER, false, 0); vote(chg->usb_icl_votable, THERMAL_THROTTLE_VOTER, false, 0); vote(chg->limited_irq_disable_votable, CHARGER_TYPE_VOTER, true, 0); vote(chg->hdc_irq_disable_votable, CHARGER_TYPE_VOTER, true, 0); vote(chg->hdc_irq_disable_votable, HDC_IRQ_VOTER, false, 0); /* Remove SW thermal regulation WA votes */ vote(chg->usb_icl_votable, SW_THERM_REGULATION_VOTER, false, 0); vote(chg->pl_disable_votable, SW_THERM_REGULATION_VOTER, false, 0); vote(chg->dc_suspend_votable, SW_THERM_REGULATION_VOTER, false, 0); if (chg->cp_disable_votable) vote(chg->cp_disable_votable, SW_THERM_REGULATION_VOTER, false, 0); /* reset USBOV votes and cancel work */ cancel_delayed_work_sync(&chg->usbov_dbc_work); vote(chg->awake_votable, USBOV_DBC_VOTER, false, 0); chg->dbc_usbov = false; chg->voltage_min_uv = MICRO_5V; chg->voltage_max_uv = MICRO_5V; chg->usbin_forced_max_uv = 0; chg->usb_icl_delta_ua = 0; chg->pulse_cnt = 0; chg->uusb_apsd_rerun_done = false; /* write back the default FLOAT charger configuration */ rc = smblib_masked_write(chg, USBIN_OPTIONS_2_CFG_REG, (u8)FLOAT_OPTIONS_MASK, chg->float_cfg); if (rc < 0) smblib_err(chg, "Couldn't write float charger options rc=%d\n", rc); /* clear USB ICL vote for USB_PSY_VOTER */ rc = vote(chg->usb_icl_votable, USB_PSY_VOTER, false, 0); if (rc < 0) smblib_err(chg, "Couldn't un-vote for USB ICL rc=%d\n", rc); /* clear USB ICL vote for DCP_VOTER */ rc = vote(chg->usb_icl_votable, DCP_VOTER, false, 0); if (rc < 0) smblib_err(chg, "Couldn't un-vote DCP from USB ICL rc=%d\n", rc); /* * if non-compliant charger caused UV, restore original max pulses * and turn SUSPEND_ON_COLLAPSE_USBIN_BIT back on. */ if (chg->qc2_unsupported_voltage) { rc = smblib_masked_write(chg, HVDCP_PULSE_COUNT_MAX_REG, HVDCP_PULSE_COUNT_MAX_QC2_MASK, chg->qc2_max_pulses); if (rc < 0) smblib_err(chg, "Couldn't restore max pulses rc=%d\n", rc); rc = smblib_masked_write(chg, USBIN_AICL_OPTIONS_CFG_REG, SUSPEND_ON_COLLAPSE_USBIN_BIT, SUSPEND_ON_COLLAPSE_USBIN_BIT); if (rc < 0) smblib_err(chg, "Couldn't turn on SUSPEND_ON_COLLAPSE_USBIN_BIT rc=%d\n", rc); chg->qc2_unsupported_voltage = QC2_COMPLIANT; } } void smblib_suspend_on_debug_battery(struct smb_charger *chg) { int rc; union power_supply_propval val; rc = smblib_get_prop_from_bms(chg, POWER_SUPPLY_PROP_DEBUG_BATTERY, &val); if (rc < 0) { smblib_err(chg, "Couldn't get debug battery prop rc=%d\n", rc); return; } if (chg->suspend_input_on_debug_batt) { vote(chg->usb_icl_votable, DEBUG_BOARD_VOTER, val.intval, 0); vote(chg->dc_suspend_votable, DEBUG_BOARD_VOTER, val.intval, 0); if (val.intval) pr_info("Input suspended: Fake battery\n"); } else { vote(chg->chg_disable_votable, DEBUG_BOARD_VOTER, val.intval, 0); } } int smblib_rerun_apsd_if_required(struct smb_charger *chg) { #ifdef OPLUS_FEATURE_CHG_BASIC const struct apsd_result *apsd_result; #endif union power_supply_propval val; int rc; rc = smblib_get_prop_usb_present(chg, &val); if (rc < 0) { smblib_err(chg, "Couldn't get usb present rc = %d\n", rc); return rc; } if (!val.intval) return 0; #ifdef OPLUS_FEATURE_CHG_BASIC apsd_result = smblib_get_apsd_result(chg); if ((apsd_result->pst != POWER_SUPPLY_TYPE_UNKNOWN) && (apsd_result->pst != POWER_SUPPLY_TYPE_USB) && (apsd_result->pst != POWER_SUPPLY_TYPE_USB_CDP)) /* if type is not usb or unknown no need to rerun apsd */ return 0; #endif rc = smblib_request_dpdm(chg, true); if (rc < 0) smblib_err(chg, "Couldn't to enable DPDM rc=%d\n", rc); chg->uusb_apsd_rerun_done = true; smblib_rerun_apsd(chg); return 0; } static int smblib_get_pulse_cnt(struct smb_charger *chg, int *count) { *count = chg->pulse_cnt; return 0; } #define USBIN_25MA 25000 #define USBIN_100MA 100000 #define USBIN_150MA 150000 #define USBIN_500MA 500000 #define USBIN_900MA 900000 static int set_sdp_current(struct smb_charger *chg, int icl_ua) { int rc; u8 icl_options; const struct apsd_result *apsd_result = smblib_get_apsd_result(chg); /* power source is SDP */ switch (icl_ua) { case USBIN_100MA: /* USB 2.0 100mA */ icl_options = 0; break; case USBIN_150MA: /* USB 3.0 150mA */ icl_options = CFG_USB3P0_SEL_BIT; break; case USBIN_500MA: /* USB 2.0 500mA */ icl_options = USB51_MODE_BIT; break; case USBIN_900MA: /* USB 3.0 900mA */ icl_options = CFG_USB3P0_SEL_BIT | USB51_MODE_BIT; break; default: return -EINVAL; } #ifdef OPLUS_FEATURE_CHG_BASIC if (icl_ua <= USBIN_150MA) icl_options = 0; else icl_options = USB51_MODE_BIT; #endif if (chg->real_charger_type == POWER_SUPPLY_TYPE_USB && apsd_result->pst == POWER_SUPPLY_TYPE_USB_FLOAT) { /* * change the float charger configuration to SDP, if this * is the case of SDP being detected as FLOAT */ rc = smblib_masked_write(chg, USBIN_OPTIONS_2_CFG_REG, FORCE_FLOAT_SDP_CFG_BIT, FORCE_FLOAT_SDP_CFG_BIT); if (rc < 0) { smblib_err(chg, "Couldn't set float ICL options rc=%d\n", rc); return rc; } } rc = smblib_masked_write(chg, USBIN_ICL_OPTIONS_REG, CFG_USB3P0_SEL_BIT | USB51_MODE_BIT, icl_options); if (rc < 0) { smblib_err(chg, "Couldn't set ICL options rc=%d\n", rc); return rc; } rc = smblib_icl_override(chg, SW_OVERRIDE_USB51_MODE); if (rc < 0) { smblib_err(chg, "Couldn't set ICL override rc=%d\n", rc); return rc; } return rc; } int smblib_set_icl_current(struct smb_charger *chg, 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_25MA); #ifndef OPLUS_FEATURE_CHG_BASIC int boot_mode = get_boot_mode(); if (boot_mode == MSM_BOOT_MODE__RF || boot_mode == MSM_BOOT_MODE__WLAN) { icl_ua = 0; suspend = true; } #endif #ifdef OPLUS_CUSTOM_OP_DEF smblib_err(chg, "icl_ua=%d, connector_type=%d, real_charger_type=%d,wireles_present[%d]\n", icl_ua, chg->connector_type, chg->real_charger_type, chg->wireless_present); #endif // OPLUS_CUSTOM_OP_DEF #ifdef OPLUS_CUSTOM_OP_DEF if ((chg->connector_type == POWER_SUPPLY_CONNECTOR_TYPEC) && (!chg->wireless_present)) { #else if (chg->connector_type == POWER_SUPPLY_CONNECTOR_TYPEC) { #endif // OPLUS_CUSTOM_OP_DEF rc = smblib_masked_write(chg, USB_CMD_PULLDOWN_REG, EN_PULLDOWN_USB_IN_BIT, suspend ? 0 : EN_PULLDOWN_USB_IN_BIT); if (rc < 0) { smblib_err(chg, "Couldn't write %s to EN_PULLDOWN_USB_IN_BIT rc=%d\n", suspend ? "disable" : "enable", rc); goto out; } } #ifdef OPLUS_CUSTOM_OP_DEF if (suspend || (suspend_usb && !chg->wireless_present)) #else if (suspend || suspend_usb) #endif return smblib_set_usb_suspend(chg, true); 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 == POWER_SUPPLY_TYPEC_SOURCE_DEFAULT || chg->connector_type == POWER_SUPPLY_CONNECTOR_MICRO_USB)) { rc = set_sdp_current(chg, icl_ua); if (rc < 0) { smblib_err(chg, "Couldn't set SDP ICL rc=%d\n", rc); goto out; } #ifdef OPLUS_CUSTOM_OP_DEF } else if (chg->wireless_present) { if (icl_ua <= USBIN_500MA) { rc = set_sdp_current(chg, icl_ua); if (rc >= 0) goto unsuspend; } rc = smblib_set_charge_param(chg, &chg->param.usb_icl, icl_ua); if (rc < 0) { smblib_err(chg, "Couldn't set wireless ICL rc=%d\n", rc); goto out; } icl_override = SW_OVERRIDE_WIRELESS_MODE; #endif // OPLUS_CUSTOM_OP_DEF } 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_500MA) { rc = set_sdp_current(chg, icl_ua); if (rc >= 0) goto unsuspend; } rc = smblib_set_charge_param(chg, &chg->param.usb_icl, icl_ua); if (rc < 0) { smblib_err(chg, "Couldn't set HC ICL rc=%d\n", rc); goto out; } icl_override = SW_OVERRIDE_HC_MODE; } set_mode: rc = smblib_icl_override(chg, icl_override); if (rc < 0) { smblib_err(chg, "Couldn't set ICL override rc=%d\n", rc); goto out; } unsuspend: /* unsuspend after configuring current and override */ rc = smblib_set_usb_suspend(chg, false); if (rc < 0) { smblib_err(chg, "Couldn't resume input rc=%d\n", rc); goto out; } #ifndef OPLUS_FEATURE_CHG_BASIC /* Re-run AICL */ if (icl_override != SW_OVERRIDE_HC_MODE) rc = smblib_run_aicl(chg, RERUN_AICL); #else #ifdef OPLUS_CUSTOM_OP_DEF if ((icl_override != SW_OVERRIDE_HC_MODE) && (chg->wireless_present)) rc = smblib_run_aicl(chg, RERUN_AICL); #endif #endif // OPLUS_FEATURE_CHG_BASIC out: return rc; } int smblib_get_icl_current(struct smb_charger *chg, int *icl_ua) { int rc; rc = smblib_get_charge_param(chg, &chg->param.icl_max_stat, icl_ua); if (rc < 0) smblib_err(chg, "Couldn't get HC ICL rc=%d\n", rc); return rc; } int smblib_toggle_smb_en(struct smb_charger *chg, int toggle) { int rc = 0; if (!toggle) return rc; rc = smblib_select_sec_charger(chg, chg->sec_chg_selected, chg->cp_reason, true); return rc; } int smblib_get_irq_status(struct smb_charger *chg, union power_supply_propval *val) { int rc; u8 reg; if (chg->wa_flags & SKIP_MISC_PBS_IRQ_WA) { val->intval = 0; return 0; } mutex_lock(&chg->irq_status_lock); /* Report and clear cached status */ val->intval = chg->irq_status; chg->irq_status = 0; /* get real time status of pulse skip irq */ rc = smblib_read(chg, MISC_PBS_RT_STS_REG, ®); if (rc < 0) smblib_err(chg, "Couldn't read MISC_PBS_RT_STS_REG rc=%d\n", rc); else val->intval |= (reg & PULSE_SKIP_IRQ_BIT); mutex_unlock(&chg->irq_status_lock); return rc; } /**************************** * uUSB Moisture Protection * ****************************/ #define MICRO_USB_DETECTION_ON_TIME_20_MS 0x08 #define MICRO_USB_DETECTION_PERIOD_X_100 0x03 #define U_USB_STATUS_WATER_PRESENT 0x00 static int smblib_set_moisture_protection(struct smb_charger *chg, bool enable) { int rc = 0; if (chg->moisture_present == enable) { smblib_dbg(chg, PR_MISC, "No change in moisture protection status\n"); return rc; } if (enable) { chg->moisture_present = true; /* Disable uUSB factory mode detection */ rc = smblib_masked_write(chg, TYPEC_U_USB_CFG_REG, EN_MICRO_USB_FACTORY_MODE_BIT, 0); if (rc < 0) { smblib_err(chg, "Couldn't disable uUSB factory mode detection rc=%d\n", rc); return rc; } /* Disable moisture detection and uUSB state change interrupt */ rc = smblib_masked_write(chg, TYPE_C_INTERRUPT_EN_CFG_2_REG, TYPEC_WATER_DETECTION_INT_EN_BIT | MICRO_USB_STATE_CHANGE_INT_EN_BIT, 0); if (rc < 0) { smblib_err(chg, "Couldn't disable moisture detection interrupt rc=%d\n", rc); return rc; } /* Set 1% duty cycle on ID detection */ rc = smblib_masked_write(chg, ((chg->chg_param.smb_version == PMI632_SUBTYPE) ? PMI632_TYPEC_U_USB_WATER_PROTECTION_CFG_REG : TYPEC_U_USB_WATER_PROTECTION_CFG_REG), EN_MICRO_USB_WATER_PROTECTION_BIT | MICRO_USB_DETECTION_ON_TIME_CFG_MASK | MICRO_USB_DETECTION_PERIOD_CFG_MASK, EN_MICRO_USB_WATER_PROTECTION_BIT | MICRO_USB_DETECTION_ON_TIME_20_MS | MICRO_USB_DETECTION_PERIOD_X_100); if (rc < 0) { smblib_err(chg, "Couldn't set 1 percent CC_ID duty cycle rc=%d\n", rc); return rc; } vote(chg->usb_icl_votable, MOISTURE_VOTER, true, 0); } else { chg->moisture_present = false; vote(chg->usb_icl_votable, MOISTURE_VOTER, false, 0); /* Enable moisture detection and uUSB state change interrupt */ rc = smblib_masked_write(chg, TYPE_C_INTERRUPT_EN_CFG_2_REG, TYPEC_WATER_DETECTION_INT_EN_BIT | MICRO_USB_STATE_CHANGE_INT_EN_BIT, TYPEC_WATER_DETECTION_INT_EN_BIT | MICRO_USB_STATE_CHANGE_INT_EN_BIT); if (rc < 0) { smblib_err(chg, "Couldn't enable moisture detection and uUSB state change interrupt rc=%d\n", rc); return rc; } /* Disable periodic monitoring of CC_ID pin */ rc = smblib_write(chg, ((chg->chg_param.smb_version == PMI632_SUBTYPE) ? PMI632_TYPEC_U_USB_WATER_PROTECTION_CFG_REG : TYPEC_U_USB_WATER_PROTECTION_CFG_REG), 0); if (rc < 0) { smblib_err(chg, "Couldn't disable 1 percent CC_ID duty cycle rc=%d\n", rc); return rc; } /* Enable uUSB factory mode detection */ rc = smblib_masked_write(chg, TYPEC_U_USB_CFG_REG, EN_MICRO_USB_FACTORY_MODE_BIT, EN_MICRO_USB_FACTORY_MODE_BIT); if (rc < 0) { smblib_err(chg, "Couldn't disable uUSB factory mode detection rc=%d\n", rc); return rc; } } smblib_dbg(chg, PR_MISC, "Moisture protection %s\n", chg->moisture_present ? "enabled" : "disabled"); return rc; } /********************* * VOTABLE CALLBACKS * *********************/ static int smblib_smb_disable_override_vote_callback(struct votable *votable, void *data, int disable_smb, const char *client) { struct smb_charger *chg = data; int rc = 0; /* Enable/disable SMB_EN pin */ rc = smblib_masked_write(chg, MISC_SMB_EN_CMD_REG, SMB_EN_OVERRIDE_BIT | SMB_EN_OVERRIDE_VALUE_BIT, disable_smb ? SMB_EN_OVERRIDE_BIT : 0); if (rc < 0) smblib_err(chg, "Couldn't configure SMB_EN, rc=%d\n", rc); return rc; } static int smblib_dc_suspend_vote_callback(struct votable *votable, void *data, int suspend, const char *client) { struct smb_charger *chg = data; if (chg->chg_param.smb_version == PMI632_SUBTYPE) return 0; /* resume input if suspend is invalid */ if (suspend < 0) suspend = 0; return smblib_set_dc_suspend(chg, (bool)suspend); } static int smblib_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 smblib_chg_disable_vote_callback(struct votable *votable, void *data, int chg_disable, const char *client) { struct smb_charger *chg = data; int rc; rc = smblib_masked_write(chg, CHARGING_ENABLE_CMD_REG, CHARGING_ENABLE_CMD_BIT, chg_disable ? 0 : CHARGING_ENABLE_CMD_BIT); if (rc < 0) { smblib_err(chg, "Couldn't %s charging rc=%d\n", chg_disable ? "disable" : "enable", rc); return rc; } return 0; } static int smblib_hdc_irq_disable_vote_callback(struct votable *votable, void *data, int disable, const char *client) { struct smb_charger *chg = data; if (!chg->irq_info[HIGH_DUTY_CYCLE_IRQ].irq) return 0; if (chg->irq_info[HIGH_DUTY_CYCLE_IRQ].enabled) { if (disable) disable_irq_nosync( chg->irq_info[HIGH_DUTY_CYCLE_IRQ].irq); } else { if (!disable) enable_irq(chg->irq_info[HIGH_DUTY_CYCLE_IRQ].irq); } chg->irq_info[HIGH_DUTY_CYCLE_IRQ].enabled = !disable; return 0; } static int smblib_limited_irq_disable_vote_callback(struct votable *votable, void *data, int disable, const char *client) { struct smb_charger *chg = data; if (!chg->irq_info[INPUT_CURRENT_LIMITING_IRQ].irq) return 0; if (chg->irq_info[INPUT_CURRENT_LIMITING_IRQ].enabled) { if (disable) disable_irq_nosync( chg->irq_info[INPUT_CURRENT_LIMITING_IRQ].irq); } else { if (!disable) enable_irq( chg->irq_info[INPUT_CURRENT_LIMITING_IRQ].irq); } chg->irq_info[INPUT_CURRENT_LIMITING_IRQ].enabled = !disable; return 0; } static int smblib_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].irq) return 0; if (chg->irq_info[USBIN_ICL_CHANGE_IRQ].enabled) { if (disable) 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 smblib_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].irq) 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); 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; } /******************* * VCONN REGULATOR * * *****************/ int smblib_vconn_regulator_enable(struct regulator_dev *rdev) { struct smb_charger *chg = rdev_get_drvdata(rdev); int rc = 0; u8 stat, orientation; smblib_dbg(chg, PR_OTG, "enabling VCONN\n"); rc = smblib_read(chg, TYPE_C_MISC_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read TYPE_C_STATUS_4 rc=%d\n", rc); return rc; } /* VCONN orientation is oplussite to that of CC */ orientation = stat & TYPEC_CCOUT_VALUE_BIT ? 0 : VCONN_EN_ORIENTATION_BIT; rc = smblib_masked_write(chg, TYPE_C_VCONN_CONTROL_REG, VCONN_EN_VALUE_BIT | VCONN_EN_ORIENTATION_BIT, VCONN_EN_VALUE_BIT | orientation); if (rc < 0) { smblib_err(chg, "Couldn't read TYPE_C_CCOUT_CONTROL_REG rc=%d\n", rc); return rc; } return 0; } int smblib_vconn_regulator_disable(struct regulator_dev *rdev) { struct smb_charger *chg = rdev_get_drvdata(rdev); int rc = 0; smblib_dbg(chg, PR_OTG, "disabling VCONN\n"); rc = smblib_masked_write(chg, TYPE_C_VCONN_CONTROL_REG, VCONN_EN_VALUE_BIT, 0); if (rc < 0) smblib_err(chg, "Couldn't disable vconn regulator rc=%d\n", rc); return 0; } int smblib_vconn_regulator_is_enabled(struct regulator_dev *rdev) { struct smb_charger *chg = rdev_get_drvdata(rdev); int rc; u8 cmd; rc = smblib_read(chg, TYPE_C_VCONN_CONTROL_REG, &cmd); if (rc < 0) { smblib_err(chg, "Couldn't read TYPE_C_INTRPT_ENB_SOFTWARE_CTRL rc=%d\n", rc); return rc; } return (cmd & VCONN_EN_VALUE_BIT) ? 1 : 0; } /***************** * OTG REGULATOR * *****************/ int smblib_vbus_regulator_enable(struct regulator_dev *rdev) { struct smb_charger *chg = rdev_get_drvdata(rdev); int rc = 0; #ifdef OPLUS_FEATURE_CHG_BASIC//Fanhong.Kong@ProDrv.CHG,add 2018/06/02 for SVOOC OTG struct oplus_chg_chip *chip = g_oplus_chip; int count = 20; #endif/*OPLUS_FEATURE_CHG_BASIC*/ smblib_dbg(chg, PR_OTG, "enabling OTG\n"); oplus_wake_up_usbtemp_thread(); #ifdef OPLUS_FEATURE_CHG_BASIC//Fanhong.Kong@ProDrv.CHG,add 2018/06/02 for SVOOC OTG if (chip->vbatt_num == 2) { smblib_err(chg, "enabling OTG\n"); if (chip->wireless_support) { while (count--) { if (oplus_wpc_check_chip_is_null() == false) break; msleep(500); } if (chip->wpc_no_chargerpump) { if (oplus_wpc_get_fw_updating() == true) { smblib_err(chg, "[WPC] idt_fw_update,don't enabling OTG\n"); return rc; } oplus_wpc_dis_wireless_chg(1); if (oplus_wpc_get_otg_charging()) { oplus_wpc_set_rtx_function(false); } oplus_wpc_set_wrx_en_value(0); oplus_wpc_set_wrx_otg_en_value(0); msleep(100); rc = chip->chg_ops->otg_enable(); } else { oplus_wpc_set_wrx_en_value(1); msleep(100); } oplus_wireless_set_otg_en_val(1); oplus_wpc_set_booster_en_val(1); oplus_wpc_set_ext1_wired_otg_en_val(0); oplus_wpc_set_ext2_wireless_otg_en_val(1); } else { rc = chip->chg_ops->otg_enable(); } } else { rc = smblib_masked_write(chg, DCDC_CMD_OTG_REG, OTG_EN_BIT, OTG_EN_BIT); } #else/*OPLUS_FEATURE_CHG_BASIC*/ rc = smblib_masked_write(chg, DCDC_CMD_OTG_REG, OTG_EN_BIT, OTG_EN_BIT); #endif/*OPLUS_FEATURE_CHG_BASIC*/ if (rc < 0) { smblib_err(chg, "Couldn't enable OTG rc=%d\n", rc); return rc; } return 0; } int smblib_vbus_regulator_disable(struct regulator_dev *rdev) { struct smb_charger *chg = rdev_get_drvdata(rdev); int rc = 0; #ifdef OPLUS_FEATURE_CHG_BASIC//Fanhong.Kong@ProDrv.CHG,add 2018/06/02 for SVOOC OTG struct oplus_chg_chip *chip = g_oplus_chip; #endif/*OPLUS_FEATURE_CHG_BASIC*/ smblib_dbg(chg, PR_OTG, "disabling OTG\n"); #ifdef OPLUS_FEATURE_CHG_BASIC if (g_oplus_chip) g_oplus_chip->usbtemp_check = oplus_usbtemp_condition(); if (chip->vbatt_num == 2) { smblib_err(chg, "disabling OTG\n"); if (chip->wireless_support) { if (chip->wpc_no_chargerpump && oplus_wpc_get_fw_updating() == true) { smblib_err(chg, "[WPC] idt_fw_update,don't disabling OTG\n"); return rc; } chg->otg_disable_timeout = 1; cancel_delayed_work_sync(&chg->otg_disable_timeout_work); schedule_delayed_work(&chg->otg_disable_timeout_work, msecs_to_jiffies(100)); oplus_wireless_set_otg_en_val(0); oplus_wpc_set_booster_en_val(0); oplus_wpc_set_ext1_wired_otg_en_val(1); oplus_wpc_set_ext2_wireless_otg_en_val(1); if (oplus_wpc_get_normal_charging() != true && oplus_wpc_get_fast_charging() != true && oplus_wpc_get_otg_charging() != true) { oplus_wpc_set_wrx_en_value(0); if (chip->wpc_no_chargerpump) { oplus_wpc_dis_wireless_chg(0); rc = chip->chg_ops->otg_disable(); } } if (chip->wpc_no_chargerpump && oplus_wpc_get_otg_charging() == true) { oplus_wpc_dis_wireless_chg(0); rc = chip->chg_ops->otg_disable(); } } else { rc = chip->chg_ops->otg_disable(); } } else { rc = smblib_masked_write(chg, DCDC_CMD_OTG_REG, OTG_EN_BIT, 0); } #else/*OPLUS_FEATURE_CHG_BASIC*/ rc = smblib_masked_write(chg, DCDC_CMD_OTG_REG, OTG_EN_BIT, 0); #endif/*OPLUS_FEATURE_CHG_BASIC*/ if (rc < 0) { smblib_err(chg, "Couldn't disable OTG regulator rc=%d\n", rc); return rc; } return 0; } int smblib_vbus_regulator_is_enabled(struct regulator_dev *rdev) { struct smb_charger *chg = rdev_get_drvdata(rdev); int rc = 0; u8 cmd; rc = smblib_read(chg, DCDC_CMD_OTG_REG, &cmd); if (rc < 0) { smblib_err(chg, "Couldn't read CMD_OTG rc=%d", rc); return rc; } return (cmd & OTG_EN_BIT) ? 1 : 0; } /******************** * BATT PSY GETTERS * ********************/ int smblib_get_prop_input_suspend(struct smb_charger *chg, union power_supply_propval *val) { val->intval = (get_client_vote(chg->usb_icl_votable, USER_VOTER) == 0) && get_client_vote(chg->dc_suspend_votable, USER_VOTER); return 0; } int smblib_get_prop_batt_present(struct smb_charger *chg, union power_supply_propval *val) { int rc; u8 stat; rc = smblib_read(chg, BATIF_BASE + INT_RT_STS_OFFSET, &stat); if (rc < 0) { smblib_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 | BAT_TERMINAL_MISSING_RT_STS_BIT)); return rc; } int smblib_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 = smblib_get_prop_from_bms(chg, POWER_SUPPLY_PROP_CAPACITY, val); return rc; } static bool is_charging_paused(struct smb_charger *chg) { int rc; u8 val; rc = smblib_read(chg, CHARGING_PAUSE_CMD_REG, &val); if (rc < 0) { smblib_err(chg, "Couldn't read CHARGING_PAUSE_CMD rc=%d\n", rc); return false; } return val & CHARGING_PAUSE_CMD_BIT; } int smblib_get_prop_batt_status(struct smb_charger *chg, union power_supply_propval *val) { union power_supply_propval pval = {0, }; bool usb_online, dc_online; u8 stat; int rc, suspend = 0; rc = smblib_get_prop_from_bms(chg, POWER_SUPPLY_PROP_DEBUG_BATTERY, &pval); 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 (chg->dbc_usbov) { rc = smblib_get_prop_usb_present(chg, &pval); if (rc < 0) { smblib_err(chg, "Couldn't get usb present prop rc=%d\n", rc); return rc; } rc = smblib_get_usb_suspend(chg, &suspend); if (rc < 0) { smblib_err(chg, "Couldn't get usb suspend rc=%d\n", rc); return rc; } /* * Report charging as long as USBOV is not debounced and * charging path is un-suspended. */ if (pval.intval && !suspend) { val->intval = POWER_SUPPLY_STATUS_CHARGING; return 0; } } rc = smblib_get_prop_usb_online(chg, &pval); if (rc < 0) { smblib_err(chg, "Couldn't get usb online property rc=%d\n", rc); return rc; } usb_online = (bool)pval.intval; rc = smblib_get_prop_dc_online(chg, &pval); if (rc < 0) { smblib_err(chg, "Couldn't get dc online property rc=%d\n", rc); return rc; } dc_online = (bool)pval.intval; rc = smblib_read(chg, BATTERY_CHARGER_STATUS_1_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read BATTERY_CHARGER_STATUS_1 rc=%d\n", rc); return rc; } stat = stat & BATTERY_CHARGER_STATUS_MASK; if (!usb_online && !dc_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: case INHIBIT_CHARGE: val->intval = POWER_SUPPLY_STATUS_FULL; 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 charge termination WA is active and has suspended charging, then * continue reporting charging status as FULL. */ if (is_client_vote_enabled_locked(chg->usb_icl_votable, CHG_TERMINATION_VOTER)) { val->intval = POWER_SUPPLY_STATUS_FULL; return 0; } if (val->intval != POWER_SUPPLY_STATUS_CHARGING) return 0; if (!usb_online && dc_online && chg->fake_batt_status == POWER_SUPPLY_STATUS_FULL) { val->intval = POWER_SUPPLY_STATUS_FULL; return 0; } rc = smblib_read(chg, BATTERY_CHARGER_STATUS_5_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read BATTERY_CHARGER_STATUS_2 rc=%d\n", rc); return rc; } stat &= ENABLE_TRICKLE_BIT | ENABLE_PRE_CHARGING_BIT | ENABLE_FULLON_MODE_BIT; if (!stat) val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; return 0; } int smblib_get_prop_batt_charge_type(struct smb_charger *chg, union power_supply_propval *val) { int rc; u8 stat; rc = smblib_read(chg, BATTERY_CHARGER_STATUS_1_REG, &stat); if (rc < 0) { smblib_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_TAPER; break; default: val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE; } return rc; } int smblib_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 = smblib_read(chg, BATTERY_CHARGER_STATUS_2_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read BATTERY_CHARGER_STATUS_2 rc=%d\n", rc); return rc; } smblib_dbg(chg, PR_REGISTER, "BATTERY_CHARGER_STATUS_2 = 0x%02x\n", stat); if (stat & CHARGER_ERROR_STATUS_BAT_OV_BIT) { rc = smblib_get_prop_from_bms(chg, POWER_SUPPLY_PROP_VOLTAGE_NOW, &pval); 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; smblib_err(chg, "battery over-voltage vbat_fg = %duV, fv = %duV\n", pval.intval, effective_fv_uv); goto done; } } } rc = smblib_read(chg, BATTERY_CHARGER_STATUS_7_REG, &stat); if (rc < 0) { smblib_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 smblib_get_prop_system_temp_level(struct smb_charger *chg, union power_supply_propval *val) { val->intval = chg->system_temp_level; return 0; } int smblib_get_prop_system_temp_level_max(struct smb_charger *chg, union power_supply_propval *val) { val->intval = chg->thermal_levels; return 0; } int smblib_get_prop_input_current_limited(struct smb_charger *chg, union power_supply_propval *val) { u8 stat; int rc; if (chg->fake_input_current_limited >= 0) { val->intval = chg->fake_input_current_limited; return 0; } rc = smblib_read(chg, AICL_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read AICL_STATUS rc=%d\n", rc); return rc; } val->intval = (stat & SOFT_ILIMIT_BIT) || chg->is_hdc; return 0; } int smblib_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, * hence read only the threshold corresponding to ADC source. * Proceed only if CHGR_ITERM_USE_ANALOG_BIT is 0. */ rc = smblib_read(chg, CHGR_ENG_CHARGING_CFG_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read CHGR_ENG_CHARGING_CFG_REG rc=%d\n", rc); return rc; } if (stat & CHGR_ITERM_USE_ANALOG_BIT) { val->intval = -EINVAL; return 0; } rc = smblib_batch_read(chg, CHGR_ADC_ITERM_UP_THD_MSB_REG, buf, 2); if (rc < 0) { smblib_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->chg_param.smb_version == PMI632_SUBTYPE) temp = DIV_ROUND_CLOSEST(temp * ITERM_LIMITS_PMI632_MA, ADC_CHG_ITERM_MASK); else temp = DIV_ROUND_CLOSEST(temp * ITERM_LIMITS_PM8150B_MA, ADC_CHG_ITERM_MASK); val->intval = temp; return rc; } int smblib_get_prop_batt_charge_done(struct smb_charger *chg, union power_supply_propval *val) { int rc; u8 stat; rc = smblib_read(chg, BATTERY_CHARGER_STATUS_1_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read BATTERY_CHARGER_STATUS_1 rc=%d\n", rc); return rc; } stat = stat & BATTERY_CHARGER_STATUS_MASK; val->intval = (stat == TERMINATE_CHARGE); return 0; } int smblib_get_batt_current_now(struct smb_charger *chg, union power_supply_propval *val) { int rc; rc = smblib_get_prop_from_bms(chg, POWER_SUPPLY_PROP_CURRENT_NOW, val); if (!rc) val->intval *= (-1); return rc; } /*********************** * BATTERY PSY SETTERS * ***********************/ int smblib_set_prop_input_suspend(struct smb_charger *chg, const union power_supply_propval *val) { int rc; /* vote 0mA when suspended */ rc = vote(chg->usb_icl_votable, USER_VOTER, (bool)val->intval, 0); if (rc < 0) { smblib_err(chg, "Couldn't vote to %s USB rc=%d\n", (bool)val->intval ? "suspend" : "resume", rc); return rc; } rc = vote(chg->dc_suspend_votable, USER_VOTER, (bool)val->intval, 0); if (rc < 0) { smblib_err(chg, "Couldn't vote to %s DC rc=%d\n", (bool)val->intval ? "suspend" : "resume", rc); return rc; } power_supply_changed(chg->batt_psy); return rc; } int smblib_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 smblib_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 smblib_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; } int smblib_set_prop_input_current_limited(struct smb_charger *chg, const union power_supply_propval *val) { chg->fake_input_current_limited = val->intval; return 0; } int smblib_set_prop_rechg_soc_thresh(struct smb_charger *chg, const union power_supply_propval *val) { int rc; u8 new_thr = DIV_ROUND_CLOSEST(val->intval * 255, 100); rc = smblib_write(chg, CHARGE_RCHG_SOC_THRESHOLD_CFG_REG, new_thr); if (rc < 0) { smblib_err(chg, "Couldn't write to RCHG_SOC_THRESHOLD_CFG_REG rc=%d\n", rc); return rc; } chg->auto_recharge_soc = val->intval; return rc; } int smblib_run_aicl(struct smb_charger *chg, int type) { int rc; u8 stat; rc = smblib_read(chg, POWER_PATH_STATUS_REG, &stat); if (rc < 0) { smblib_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; #ifdef OPLUS_CUSTOM_OP_DEF /* @bsp enable aicl_rerun before rerurn aicl */ rc = smblib_masked_write(chg, USBIN_AICL_OPTIONS_CFG_REG, USBIN_AICL_PERIODIC_RERUN_EN_BIT, USBIN_AICL_PERIODIC_RERUN_EN_BIT); #endif // OPLUS_CUSTOM_OP_DEF smblib_dbg(chg, PR_MISC, "re-running AICL\n"); stat = (type == RERUN_AICL) ? RERUN_AICL_BIT : RESTART_AICL_BIT; rc = smblib_masked_write(chg, AICL_CMD_REG, stat, stat); if (rc < 0) smblib_err(chg, "Couldn't write to AICL_CMD_REG rc=%d\n", rc); return 0; } static int smblib_dp_pulse(struct smb_charger *chg) { int rc; /* QC 3.0 increment */ rc = smblib_masked_write(chg, CMD_HVDCP_2_REG, SINGLE_INCREMENT_BIT, SINGLE_INCREMENT_BIT); if (rc < 0) smblib_err(chg, "Couldn't write to CMD_HVDCP_2_REG rc=%d\n", rc); return rc; } static int smblib_dm_pulse(struct smb_charger *chg) { int rc; /* QC 3.0 decrement */ rc = smblib_masked_write(chg, CMD_HVDCP_2_REG, SINGLE_DECREMENT_BIT, SINGLE_DECREMENT_BIT); if (rc < 0) smblib_err(chg, "Couldn't write to CMD_HVDCP_2_REG rc=%d\n", rc); return rc; } int smblib_force_vbus_voltage(struct smb_charger *chg, u8 val) { int rc; rc = smblib_masked_write(chg, CMD_HVDCP_2_REG, val, val); if (rc < 0) smblib_err(chg, "Couldn't write to CMD_HVDCP_2_REG rc=%d\n", rc); return rc; } static void smblib_hvdcp_set_fsw(struct smb_charger *chg, int bit) { switch (bit) { case QC_5V_BIT: smblib_set_opt_switcher_freq(chg, chg->chg_freq.freq_5V); break; case QC_9V_BIT: smblib_set_opt_switcher_freq(chg, chg->chg_freq.freq_9V); break; case QC_12V_BIT: smblib_set_opt_switcher_freq(chg, chg->chg_freq.freq_12V); break; default: smblib_set_opt_switcher_freq(chg, chg->chg_freq.freq_removal); break; } } #define QC3_PULSES_FOR_6V 5 #define QC3_PULSES_FOR_9V 20 #define QC3_PULSES_FOR_12V 35 static int smblib_hvdcp3_set_fsw(struct smb_charger *chg) { int pulse_count, rc; rc = smblib_get_pulse_cnt(chg, &pulse_count); if (rc < 0) { smblib_err(chg, "Couldn't read QC_PULSE_COUNT rc=%d\n", rc); return rc; } if (pulse_count < QC3_PULSES_FOR_6V) smblib_set_opt_switcher_freq(chg, chg->chg_freq.freq_5V); else if (pulse_count < QC3_PULSES_FOR_9V) smblib_set_opt_switcher_freq(chg, chg->chg_freq.freq_6V_8V); else if (pulse_count < QC3_PULSES_FOR_12V) smblib_set_opt_switcher_freq(chg, chg->chg_freq.freq_9V); else smblib_set_opt_switcher_freq(chg, chg->chg_freq.freq_12V); return 0; } static void smblib_hvdcp_adaptive_voltage_change(struct smb_charger *chg) { int rc; u8 stat; if (chg->real_charger_type == POWER_SUPPLY_TYPE_USB_HVDCP) { rc = smblib_read(chg, QC_CHANGE_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read QC_CHANGE_STATUS rc=%d\n", rc); return; } #ifdef OPLUS_CUSTOM_OP_DEF smblib_err(chg, "QC_CHANGE_STATUS_REG=0x%02x", stat); #endif // OPLUS_CUSTOM_OP_DEF smblib_hvdcp_set_fsw(chg, stat & QC_2P0_STATUS_MASK); vote(chg->usb_icl_votable, HVDCP2_ICL_VOTER, false, 0); } if (chg->real_charger_type == POWER_SUPPLY_TYPE_USB_HVDCP_3) { rc = smblib_hvdcp3_set_fsw(chg); if (rc < 0) smblib_err(chg, "Couldn't set QC3.0 Fsw rc=%d\n", rc); } power_supply_changed(chg->usb_main_psy); } int smblib_dp_dm(struct smb_charger *chg, int val) { int target_icl_ua, rc = 0; union power_supply_propval pval; u8 stat; switch (val) { case POWER_SUPPLY_DP_DM_DP_PULSE: /* * Pre-emptively increment pulse count to enable the setting * of FSW prior to increasing voltage. */ chg->pulse_cnt++; rc = smblib_hvdcp3_set_fsw(chg); if (rc < 0) smblib_err(chg, "Couldn't set QC3.0 Fsw rc=%d\n", rc); rc = smblib_dp_pulse(chg); if (rc < 0) { smblib_err(chg, "Couldn't increase pulse count rc=%d\n", rc); /* * Increment pulse count failed; * reset to former value. */ chg->pulse_cnt--; } smblib_dbg(chg, PR_PARALLEL, "DP_DM_DP_PULSE rc=%d cnt=%d\n", rc, chg->pulse_cnt); break; case POWER_SUPPLY_DP_DM_DM_PULSE: rc = smblib_dm_pulse(chg); if (!rc && chg->pulse_cnt) chg->pulse_cnt--; smblib_dbg(chg, PR_PARALLEL, "DP_DM_DM_PULSE rc=%d cnt=%d\n", rc, chg->pulse_cnt); break; case POWER_SUPPLY_DP_DM_ICL_DOWN: target_icl_ua = get_effective_result(chg->usb_icl_votable); if (target_icl_ua < 0) { /* no client vote, get the ICL from charger */ rc = power_supply_get_property(chg->usb_psy, POWER_SUPPLY_PROP_HW_CURRENT_MAX, &pval); if (rc < 0) { smblib_err(chg, "Couldn't get max curr rc=%d\n", rc); return rc; } target_icl_ua = pval.intval; } /* * Check if any other voter voted on USB_ICL in case of * voter other than SW_QC3_VOTER reset and restart reduction * again. */ if (target_icl_ua != get_client_vote(chg->usb_icl_votable, SW_QC3_VOTER)) chg->usb_icl_delta_ua = 0; chg->usb_icl_delta_ua += 100000; vote(chg->usb_icl_votable, SW_QC3_VOTER, true, target_icl_ua - 100000); smblib_dbg(chg, PR_PARALLEL, "ICL DOWN ICL=%d reduction=%d\n", target_icl_ua, chg->usb_icl_delta_ua); break; case POWER_SUPPLY_DP_DM_FORCE_5V: rc = smblib_force_vbus_voltage(chg, FORCE_5V_BIT); if (rc < 0) pr_err("Failed to force 5V\n"); break; case POWER_SUPPLY_DP_DM_FORCE_9V: if (chg->qc2_unsupported_voltage == QC2_NON_COMPLIANT_9V) { smblib_err(chg, "Couldn't set 9V: unsupported\n"); return -EINVAL; } /* If we are increasing voltage to get to 9V, set FSW first */ rc = smblib_read(chg, QC_CHANGE_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read QC_CHANGE_STATUS_REG rc=%d\n", rc); break; } if (stat & QC_5V_BIT) { /* Force 1A ICL before requesting higher voltage */ vote(chg->usb_icl_votable, HVDCP2_ICL_VOTER, true, 1000000); smblib_hvdcp_set_fsw(chg, QC_9V_BIT); } rc = smblib_force_vbus_voltage(chg, FORCE_9V_BIT); if (rc < 0) pr_err("Failed to force 9V\n"); break; case POWER_SUPPLY_DP_DM_FORCE_12V: if (chg->qc2_unsupported_voltage == QC2_NON_COMPLIANT_12V) { smblib_err(chg, "Couldn't set 12V: unsupported\n"); return -EINVAL; } /* If we are increasing voltage to get to 12V, set FSW first */ rc = smblib_read(chg, QC_CHANGE_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read QC_CHANGE_STATUS_REG rc=%d\n", rc); break; } if ((stat & QC_9V_BIT) || (stat & QC_5V_BIT)) { /* Force 1A ICL before requesting higher voltage */ vote(chg->usb_icl_votable, HVDCP2_ICL_VOTER, true, 1000000); smblib_hvdcp_set_fsw(chg, QC_12V_BIT); } rc = smblib_force_vbus_voltage(chg, FORCE_12V_BIT); if (rc < 0) pr_err("Failed to force 12V\n"); break; case POWER_SUPPLY_DP_DM_ICL_UP: default: break; } return rc; } int smblib_disable_hw_jeita(struct smb_charger *chg, bool disable) { int rc; u8 mask; /* * Disable h/w base JEITA compensation if s/w JEITA is enabled */ #ifdef OPLUS_FEATURE_CHG_BASIC #ifdef OPLUS_CUSTOM_OP_DEF mask = JEITA_EN_HARDLIMIT_BIT | JEITA_EN_COLD_SL_FCV_BIT | #endif #else mask = JEITA_EN_COLD_SL_FCV_BIT | #endif JEITA_EN_HOT_SL_FCV_BIT | JEITA_EN_HOT_SL_CCC_BIT | JEITA_EN_COLD_SL_CCC_BIT; rc = smblib_masked_write(chg, JEITA_EN_CFG_REG, mask, disable ? 0 : mask); if (rc < 0) { dev_err(chg->dev, "Couldn't configure s/w jeita rc=%d\n", rc); return rc; } return 0; } static int smblib_set_sw_thermal_regulation(struct smb_charger *chg, bool enable) { int rc = 0; if (!(chg->wa_flags & SW_THERM_REGULATION_WA)) return rc; if (enable) { /* * Configure min time to quickly address thermal * condition. */ rc = smblib_masked_write(chg, SNARL_BARK_BITE_WD_CFG_REG, SNARL_WDOG_TIMEOUT_MASK, SNARL_WDOG_TMOUT_62P5MS); if (rc < 0) { smblib_err(chg, "Couldn't configure snarl wdog tmout, rc=%d\n", rc); return rc; } /* * Schedule SW_THERM_REGULATION_WORK directly if USB input * is suspended due to SW thermal regulation WA since WDOG * IRQ won't trigger with input suspended. */ if (is_client_vote_enabled(chg->usb_icl_votable, SW_THERM_REGULATION_VOTER)) { vote(chg->awake_votable, SW_THERM_REGULATION_VOTER, true, 0); schedule_delayed_work(&chg->thermal_regulation_work, 0); } } else { cancel_delayed_work_sync(&chg->thermal_regulation_work); vote(chg->awake_votable, SW_THERM_REGULATION_VOTER, false, 0); } smblib_dbg(chg, PR_MISC, "WDOG SNARL INT %s\n", enable ? "Enabled" : "Disabled"); return rc; } static int smblib_update_thermal_readings(struct smb_charger *chg) { union power_supply_propval pval = {0, }; int rc = 0; if (!chg->pl.psy) chg->pl.psy = power_supply_get_by_name("parallel"); rc = smblib_read_iio_channel(chg, chg->iio.die_temp_chan, DIV_FACTOR_DECIDEGC, &chg->die_temp); if (rc < 0) { smblib_err(chg, "Couldn't read DIE TEMP channel, rc=%d\n", rc); return rc; } rc = smblib_read_iio_channel(chg, chg->iio.connector_temp_chan, DIV_FACTOR_DECIDEGC, &chg->connector_temp); if (rc < 0) { smblib_err(chg, "Couldn't read CONN TEMP channel, rc=%d\n", rc); return rc; } rc = smblib_read_iio_channel(chg, chg->iio.skin_temp_chan, DIV_FACTOR_DECIDEGC, &chg->skin_temp); if (rc < 0) { smblib_err(chg, "Couldn't read SKIN TEMP channel, rc=%d\n", rc); return rc; } if (chg->sec_chg_selected == POWER_SUPPLY_CHARGER_SEC_CP) { if (is_cp_available(chg)) { rc = power_supply_get_property(chg->cp_psy, POWER_SUPPLY_PROP_CP_DIE_TEMP, &pval); if (rc < 0) { smblib_err(chg, "Couldn't get smb1390 charger temp, rc=%d\n", rc); return rc; } chg->smb_temp = pval.intval; } else { smblib_dbg(chg, PR_MISC, "Coudln't find cp_psy\n"); chg->smb_temp = -ENODATA; } } else if (chg->pl.psy && chg->sec_chg_selected == POWER_SUPPLY_CHARGER_SEC_PL) { rc = power_supply_get_property(chg->pl.psy, POWER_SUPPLY_PROP_CHARGER_TEMP, &pval); if (rc < 0) { smblib_err(chg, "Couldn't get smb1355 charger temp, rc=%d\n", rc); return rc; } chg->smb_temp = pval.intval; } else { chg->smb_temp = -ENODATA; } return rc; } /* SW thermal regulation thresholds in deciDegC */ #define DIE_TEMP_RST_THRESH 1000 #define DIE_TEMP_REG_H_THRESH 800 #define DIE_TEMP_REG_L_THRESH 600 #define CONNECTOR_TEMP_SHDN_THRESH 700 #define CONNECTOR_TEMP_RST_THRESH 600 #define CONNECTOR_TEMP_REG_H_THRESH 550 #define CONNECTOR_TEMP_REG_L_THRESH 500 #define SMB_TEMP_SHDN_THRESH 1400 #define SMB_TEMP_RST_THRESH 900 #define SMB_TEMP_REG_H_THRESH 800 #define SMB_TEMP_REG_L_THRESH 600 #define SKIN_TEMP_SHDN_THRESH 700 #define SKIN_TEMP_RST_THRESH 600 #define SKIN_TEMP_REG_H_THRESH 550 #define SKIN_TEMP_REG_L_THRESH 500 #define THERM_REG_RECHECK_DELAY_1S 1000 /* 1 sec */ #define THERM_REG_RECHECK_DELAY_8S 8000 /* 8 sec */ static int smblib_process_thermal_readings(struct smb_charger *chg) { int rc = 0, wdog_timeout = SNARL_WDOG_TMOUT_8S; u32 thermal_status = TEMP_BELOW_RANGE; bool suspend_input = false, disable_smb = false; /* * Following is the SW thermal regulation flow: * * TEMP_SHUT_DOWN_LEVEL: If either connector temp or skin temp * exceeds their respective SHDN threshold. Need to suspend input * and secondary charger. * * TEMP_SHUT_DOWN_SMB_LEVEL: If smb temp exceed its SHDN threshold * but connector and skin temp are below it. Need to suspend SMB. * * TEMP_ALERT_LEVEL: If die, connector, smb or skin temp exceeds it's * respective RST threshold. Stay put and monitor temperature closely. * * TEMP_ABOVE_RANGE or TEMP_WITHIN_RANGE or TEMP_BELOW_RANGE: If die, * connector, smb or skin temp exceeds it's respective REG_H or REG_L * threshold. Unsuspend input and SMB. */ if (chg->connector_temp > CONNECTOR_TEMP_SHDN_THRESH || chg->skin_temp > SKIN_TEMP_SHDN_THRESH) { thermal_status = TEMP_SHUT_DOWN; wdog_timeout = SNARL_WDOG_TMOUT_1S; suspend_input = true; disable_smb = true; goto out; } if (chg->smb_temp > SMB_TEMP_SHDN_THRESH) { thermal_status = TEMP_SHUT_DOWN_SMB; wdog_timeout = SNARL_WDOG_TMOUT_1S; disable_smb = true; goto out; } if (chg->connector_temp > CONNECTOR_TEMP_RST_THRESH || chg->skin_temp > SKIN_TEMP_RST_THRESH || chg->smb_temp > SMB_TEMP_RST_THRESH || chg->die_temp > DIE_TEMP_RST_THRESH) { thermal_status = TEMP_ALERT_LEVEL; wdog_timeout = SNARL_WDOG_TMOUT_1S; goto out; } if (chg->connector_temp > CONNECTOR_TEMP_REG_H_THRESH || chg->skin_temp > SKIN_TEMP_REG_H_THRESH || chg->smb_temp > SMB_TEMP_REG_H_THRESH || chg->die_temp > DIE_TEMP_REG_H_THRESH) { thermal_status = TEMP_ABOVE_RANGE; wdog_timeout = SNARL_WDOG_TMOUT_1S; goto out; } if (chg->connector_temp > CONNECTOR_TEMP_REG_L_THRESH || chg->skin_temp > SKIN_TEMP_REG_L_THRESH || chg->smb_temp > SMB_TEMP_REG_L_THRESH || chg->die_temp > DIE_TEMP_REG_L_THRESH) { thermal_status = TEMP_WITHIN_RANGE; wdog_timeout = SNARL_WDOG_TMOUT_8S; } out: smblib_dbg(chg, PR_MISC, "Current temperatures: \tDIE_TEMP: %d,\tCONN_TEMP: %d,\tSMB_TEMP: %d,\tSKIN_TEMP: %d\nTHERMAL_STATUS: %d\n", chg->die_temp, chg->connector_temp, chg->smb_temp, chg->skin_temp, thermal_status); if (thermal_status != chg->thermal_status) { chg->thermal_status = thermal_status; /* * If thermal level changes to TEMP ALERT LEVEL, don't * enable/disable main/parallel charging. */ if (chg->thermal_status == TEMP_ALERT_LEVEL) goto exit; vote(chg->smb_override_votable, SW_THERM_REGULATION_VOTER, disable_smb, 0); /* * Enable/disable secondary charger through votables to ensure * that if SMB_EN pin get's toggled somehow, secondary charger * remains enabled/disabled according to SW thermal regulation. */ if (!chg->cp_disable_votable) chg->cp_disable_votable = find_votable("CP_DISABLE"); if (chg->cp_disable_votable) vote(chg->cp_disable_votable, SW_THERM_REGULATION_VOTER, disable_smb, 0); vote(chg->pl_disable_votable, SW_THERM_REGULATION_VOTER, disable_smb, 0); smblib_dbg(chg, PR_MISC, "Parallel %s as per SW thermal regulation\n", disable_smb ? "disabled" : "enabled"); /* * If thermal level changes to TEMP_SHUT_DOWN_SMB, don't * enable/disable main charger. */ if (chg->thermal_status == TEMP_SHUT_DOWN_SMB) goto exit; /* Suspend input if SHDN threshold reached */ vote(chg->dc_suspend_votable, SW_THERM_REGULATION_VOTER, suspend_input, 0); vote(chg->usb_icl_votable, SW_THERM_REGULATION_VOTER, suspend_input, 0); smblib_dbg(chg, PR_MISC, "USB/DC %s as per SW thermal regulation\n", suspend_input ? "suspended" : "unsuspended"); } exit: /* * On USB suspend, WDOG IRQ stops triggering. To continue thermal * monitoring and regulation until USB is plugged out, reschedule * the SW thermal regulation work without releasing the wake lock. */ if (is_client_vote_enabled(chg->usb_icl_votable, SW_THERM_REGULATION_VOTER)) { schedule_delayed_work(&chg->thermal_regulation_work, msecs_to_jiffies(THERM_REG_RECHECK_DELAY_1S)); return 0; } rc = smblib_masked_write(chg, SNARL_BARK_BITE_WD_CFG_REG, SNARL_WDOG_TIMEOUT_MASK, wdog_timeout); if (rc < 0) smblib_err(chg, "Couldn't set WD SNARL timer, rc=%d\n", rc); vote(chg->awake_votable, SW_THERM_REGULATION_VOTER, false, 0); return rc; } /******************* * DC PSY GETTERS * *******************/ int smblib_get_prop_voltage_wls_output(struct smb_charger *chg, union power_supply_propval *val) { int rc; if (!chg->wls_psy) { chg->wls_psy = power_supply_get_by_name("wireless"); if (!chg->wls_psy) return -ENODEV; } rc = power_supply_get_property(chg->wls_psy, POWER_SUPPLY_PROP_INPUT_VOLTAGE_REGULATION, val); if (rc < 0) dev_err(chg->dev, "Couldn't get POWER_SUPPLY_PROP_VOLTAGE_REGULATION, rc=%d\n", rc); return rc; } int smblib_get_prop_dc_present(struct smb_charger *chg, union power_supply_propval *val) { int rc; u8 stat; if (chg->chg_param.smb_version == PMI632_SUBTYPE) { val->intval = 0; return 0; } rc = smblib_read(chg, DCIN_BASE + INT_RT_STS_OFFSET, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read DCIN_RT_STS rc=%d\n", rc); return rc; } val->intval = (bool)(stat & DCIN_PLUGIN_RT_STS_BIT); return 0; } int smblib_get_prop_dc_online(struct smb_charger *chg, union power_supply_propval *val) { int rc = 0; u8 stat; if (chg->chg_param.smb_version == PMI632_SUBTYPE) { val->intval = 0; return 0; } if (get_client_vote(chg->dc_suspend_votable, USER_VOTER)) { val->intval = false; return rc; } if (is_client_vote_enabled(chg->dc_suspend_votable, CHG_TERMINATION_VOTER)) { rc = smblib_get_prop_dc_present(chg, val); return rc; } rc = smblib_read(chg, POWER_PATH_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read POWER_PATH_STATUS rc=%d\n", rc); return rc; } smblib_dbg(chg, PR_REGISTER, "POWER_PATH_STATUS = 0x%02x\n", stat); val->intval = (stat & USE_DCIN_BIT) && (stat & VALID_INPUT_POWER_SOURCE_STS_BIT); return rc; } int smblib_get_prop_dc_current_max(struct smb_charger *chg, union power_supply_propval *val) { return smblib_get_charge_param(chg, &chg->param.dc_icl, &val->intval); } int smblib_get_prop_dc_voltage_max(struct smb_charger *chg, union power_supply_propval *val) { val->intval = MICRO_12V; return 0; } int smblib_get_prop_dc_voltage_now(struct smb_charger *chg, union power_supply_propval *val) { int rc; if (!chg->wls_psy) { chg->wls_psy = power_supply_get_by_name("wireless"); if (!chg->wls_psy) return -ENODEV; } rc = power_supply_get_property(chg->wls_psy, POWER_SUPPLY_PROP_INPUT_VOLTAGE_REGULATION, val); if (rc < 0) { dev_err(chg->dev, "Couldn't get POWER_SUPPLY_PROP_VOLTAGE_REGULATION, rc=%d\n", rc); return rc; } return rc; } /******************* * DC PSY SETTERS * *******************/ int smblib_set_prop_dc_current_max(struct smb_charger *chg, const union power_supply_propval *val) { return smblib_set_charge_param(chg, &chg->param.dc_icl, val->intval); } #define DCIN_AICL_RERUN_DELAY_MS 5000 int smblib_set_prop_voltage_wls_output(struct smb_charger *chg, const union power_supply_propval *val) { int rc; if (!chg->wls_psy) { chg->wls_psy = power_supply_get_by_name("wireless"); if (!chg->wls_psy) return -ENODEV; } rc = power_supply_set_property(chg->wls_psy, POWER_SUPPLY_PROP_INPUT_VOLTAGE_REGULATION, val); if (rc < 0) dev_err(chg->dev, "Couldn't set POWER_SUPPLY_PROP_VOLTAGE_REGULATION, rc=%d\n", rc); smblib_dbg(chg, PR_WLS, "%d\n", val->intval); /* * When WLS VOUT goes down, the power-constrained adaptor may be able * to supply more current, so allow it to do so. */ if ((val->intval > 0) && (val->intval < chg->last_wls_vout)) { alarm_start_relative(&chg->dcin_aicl_alarm, ms_to_ktime(DCIN_AICL_RERUN_DELAY_MS)); } chg->last_wls_vout = val->intval; return rc; } int smblib_set_prop_dc_reset(struct smb_charger *chg) { int rc; rc = vote(chg->dc_suspend_votable, VOUT_VOTER, true, 0); if (rc < 0) { smblib_err(chg, "Couldn't suspend DC rc=%d\n", rc); return rc; } rc = smblib_masked_write(chg, DCIN_CMD_IL_REG, DCIN_EN_MASK, DCIN_EN_OVERRIDE_BIT); if (rc < 0) { smblib_err(chg, "Couldn't set DCIN_EN_OVERRIDE_BIT rc=%d\n", rc); return rc; } rc = smblib_write(chg, DCIN_CMD_PON_REG, DCIN_PON_BIT | MID_CHG_BIT); if (rc < 0) { smblib_err(chg, "Couldn't write %d to DCIN_CMD_PON_REG rc=%d\n", DCIN_PON_BIT | MID_CHG_BIT, rc); return rc; } /* Wait for 10ms to allow the charge to get drained */ usleep_range(10000, 10010); rc = smblib_write(chg, DCIN_CMD_PON_REG, 0); if (rc < 0) { smblib_err(chg, "Couldn't clear DCIN_CMD_PON_REG rc=%d\n", rc); return rc; } rc = smblib_masked_write(chg, DCIN_CMD_IL_REG, DCIN_EN_MASK, 0); if (rc < 0) { smblib_err(chg, "Couldn't clear DCIN_EN_OVERRIDE_BIT rc=%d\n", rc); return rc; } rc = vote(chg->dc_suspend_votable, VOUT_VOTER, false, 0); if (rc < 0) { smblib_err(chg, "Couldn't unsuspend DC rc=%d\n", rc); return rc; } smblib_dbg(chg, PR_MISC, "Wireless charger removal detection successful\n"); return rc; } /******************* * USB PSY GETTERS * *******************/ int smblib_get_prop_usb_present(struct smb_charger *chg, union power_supply_propval *val) { int rc; u8 stat; rc = smblib_read(chg, USBIN_BASE + INT_RT_STS_OFFSET, &stat); if (rc < 0) { smblib_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; } #ifdef OPLUS_FEATURE_CHG_BASIC /* when set USBIN_SUSPEND_BIT, use present instead of online */ static bool usb_online_status = false; #endif int smblib_get_prop_usb_online(struct smb_charger *chg, union power_supply_propval *val) { int rc = 0; u8 stat; #ifdef OPLUS_FEATURE_CHG_BASIC if (usb_online_status == true) { rc = smblib_read(chg, USBIN_BASE + INT_RT_STS_OFFSET, &stat); if (rc < 0) { smblib_err(chg, "usb_online_status: Couldn't read USBIN_RT_STS rc=%d\n", rc); return rc; } val->intval = (bool)(stat & USBIN_PLUGIN_RT_STS_BIT); return rc; } #endif /*OPLUS_FEATURE_CHG_BASIC*/ if (get_client_vote_locked(chg->usb_icl_votable, USER_VOTER) == 0) { val->intval = false; #ifdef OPLUS_FEATURE_CHG_BASIC printk(KERN_ERR "smblib_get_prop_usb_online false\n"); #endif return rc; } if (is_client_vote_enabled_locked(chg->usb_icl_votable, CHG_TERMINATION_VOTER)) { rc = smblib_get_prop_usb_present(chg, val); return rc; } rc = smblib_read(chg, POWER_PATH_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read POWER_PATH_STATUS rc=%d\n", rc); return rc; } smblib_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 smblib_get_usb_online(struct smb_charger *chg, union power_supply_propval *val) { int rc; rc = smblib_get_prop_usb_online(chg, val); if (!val->intval) goto exit; if (((chg->typec_mode == POWER_SUPPLY_TYPEC_SOURCE_DEFAULT) || (chg->typec_mode == POWER_SUPPLY_TYPEC_SOURCE_MEDIUM) || (chg->typec_mode == POWER_SUPPLY_TYPEC_SOURCE_HIGH) || (chg->connector_type == POWER_SUPPLY_CONNECTOR_MICRO_USB)) && (chg->real_charger_type == POWER_SUPPLY_TYPE_USB)) val->intval = 1; else val->intval = 0; if (chg->real_charger_type == POWER_SUPPLY_TYPE_UNKNOWN) val->intval = 0; #ifdef OPLUS_CUSTOM_OP_DEF if (chg->wireless_present) val->intval = 0; #endif // OPLUS_CUSTOM_OP_DEF exit: return rc; } int smblib_get_prop_usb_voltage_max_design(struct smb_charger *chg, union power_supply_propval *val) { switch (chg->real_charger_type) { case POWER_SUPPLY_TYPE_USB_HVDCP: if (chg->qc2_unsupported_voltage == QC2_NON_COMPLIANT_9V) { val->intval = MICRO_5V; break; } else if (chg->qc2_unsupported_voltage == QC2_NON_COMPLIANT_12V) { val->intval = MICRO_9V; break; } /* else, fallthrough */ case POWER_SUPPLY_TYPE_USB_HVDCP_3: case POWER_SUPPLY_TYPE_USB_PD: if (chg->chg_param.smb_version == PMI632_SUBTYPE) val->intval = MICRO_9V; else{ #ifndef OPLUS_FEATURE_CHG_BASIC val->intval = MICRO_12V; #else val->intval = MICRO_9V; #endif } break; default: val->intval = MICRO_5V; break; } return 0; } int smblib_get_prop_usb_voltage_max(struct smb_charger *chg, union power_supply_propval *val) { switch (chg->real_charger_type) { case POWER_SUPPLY_TYPE_USB_HVDCP: if (chg->qc2_unsupported_voltage == QC2_NON_COMPLIANT_9V) { val->intval = MICRO_5V; break; } else if (chg->qc2_unsupported_voltage == QC2_NON_COMPLIANT_12V) { val->intval = MICRO_9V; break; } /* else, fallthrough */ case POWER_SUPPLY_TYPE_USB_HVDCP_3: if (chg->chg_param.smb_version == PMI632_SUBTYPE) val->intval = MICRO_9V; else{ #ifndef OPLUS_FEATURE_CHG_BASIC val->intval = MICRO_12V; #else val->intval = MICRO_9V; #endif } break; case POWER_SUPPLY_TYPE_USB_PD: val->intval = chg->voltage_max_uv; break; default: val->intval = MICRO_5V; break; } return 0; } #define HVDCP3_STEP_UV 200000 static int smblib_estimate_adaptor_voltage(struct smb_charger *chg, union power_supply_propval *val) { switch (chg->real_charger_type) { case POWER_SUPPLY_TYPE_USB_HVDCP: val->intval = MICRO_12V; break; case POWER_SUPPLY_TYPE_USB_HVDCP_3: val->intval = MICRO_5V + (HVDCP3_STEP_UV * chg->pulse_cnt); break; case POWER_SUPPLY_TYPE_USB_PD: /* Take the average of min and max values */ val->intval = chg->voltage_min_uv + ((chg->voltage_max_uv - chg->voltage_min_uv) / 2); break; default: val->intval = MICRO_5V; break; } return 0; } static int smblib_read_mid_voltage_chan(struct smb_charger *chg, union power_supply_propval *val) { int rc; if (!chg->iio.mid_chan) return -ENODATA; rc = iio_read_channel_processed(chg->iio.mid_chan, &val->intval); if (rc < 0) { smblib_err(chg, "Couldn't read MID channel rc=%d\n", rc); return rc; } /* * If MID voltage < 1V, it is unreliable. * Figure out voltage from registers and calculations. */ if (val->intval < 1000000) return smblib_estimate_adaptor_voltage(chg, val); return 0; } static int smblib_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) { smblib_err(chg, "Couldn't read USBIN channel rc=%d\n", rc); return rc; } return 0; } int smblib_get_prop_usb_voltage_now(struct smb_charger *chg, union power_supply_propval *val) { union power_supply_propval pval = {0, }; int rc, ret = 0; u8 reg; mutex_lock(&chg->adc_lock); if (chg->wa_flags & USBIN_ADC_WA) { /* Store ADC channel config in order to restore later */ rc = smblib_read(chg, BATIF_ADC_CHANNEL_EN_REG, ®); if (rc < 0) { smblib_err(chg, "Couldn't read ADC config rc=%d\n", rc); ret = rc; goto unlock; } /* Disable all ADC channels except IBAT channel */ rc = smblib_write(chg, BATIF_ADC_CHANNEL_EN_REG, IBATT_CHANNEL_EN_BIT); if (rc < 0) { smblib_err(chg, "Couldn't disable ADC channels rc=%d\n", rc); ret = rc; goto unlock; } } rc = smblib_get_prop_usb_present(chg, &pval); if (rc < 0) { smblib_err(chg, "Couldn't get usb presence status rc=%d\n", rc); ret = -ENODATA; goto restore_adc_config; } /* * For PM8150B, use MID_CHG ADC channel because overvoltage is observed * to occur randomly in the USBIN channel, particularly at high * voltages. */ if (chg->chg_param.smb_version == PM8150B_SUBTYPE && pval.intval) rc = smblib_read_mid_voltage_chan(chg, val); else rc = smblib_read_usbin_voltage_chan(chg, val); if (rc < 0) { smblib_err(chg, "Failed to read USBIN over vadc, rc=%d\n", rc); ret = rc; } restore_adc_config: /* Restore ADC channel config */ if (chg->wa_flags & USBIN_ADC_WA) { rc = smblib_write(chg, BATIF_ADC_CHANNEL_EN_REG, reg); if (rc < 0) smblib_err(chg, "Couldn't write ADC config rc=%d\n", rc); } unlock: mutex_unlock(&chg->adc_lock); return ret; } int smblib_get_prop_vph_voltage_now(struct smb_charger *chg, union power_supply_propval *val) { int rc; if (!chg->iio.vph_v_chan) return -ENODATA; rc = iio_read_channel_processed(chg->iio.vph_v_chan, &val->intval); if (rc < 0) { smblib_err(chg, "Couldn't read vph channel rc=%d\n", rc); return rc; } return 0; } bool smblib_rsbux_low(struct smb_charger *chg, int r_thr) { int r_sbu1, r_sbu2; bool ret = false; int rc; if (!chg->iio.sbux_chan) return false; /* disable crude sensors */ rc = smblib_masked_write(chg, TYPE_C_CRUDE_SENSOR_CFG_REG, EN_SRC_CRUDE_SENSOR_BIT | EN_SNK_CRUDE_SENSOR_BIT, 0); if (rc < 0) { smblib_err(chg, "Couldn't disable crude sensor rc=%d\n", rc); return false; } /* select SBU1 as current source */ rc = smblib_write(chg, TYPE_C_SBU_CFG_REG, SEL_SBU1_ISRC_VAL); if (rc < 0) { smblib_err(chg, "Couldn't select SBU1 rc=%d\n", rc); goto cleanup; } rc = iio_read_channel_processed(chg->iio.sbux_chan, &r_sbu1); if (rc < 0) { smblib_err(chg, "Couldn't read SBU1 rc=%d\n", rc); goto cleanup; } if (r_sbu1 < r_thr) { ret = true; goto cleanup; } /* select SBU2 as current source */ rc = smblib_write(chg, TYPE_C_SBU_CFG_REG, SEL_SBU2_ISRC_VAL); if (rc < 0) { smblib_err(chg, "Couldn't select SBU1 rc=%d\n", rc); goto cleanup; } rc = iio_read_channel_processed(chg->iio.sbux_chan, &r_sbu2); if (rc < 0) { smblib_err(chg, "Couldn't read SBU1 rc=%d\n", rc); goto cleanup; } if (r_sbu2 < r_thr) ret = true; cleanup: /* enable crude sensors */ rc = smblib_masked_write(chg, TYPE_C_CRUDE_SENSOR_CFG_REG, EN_SRC_CRUDE_SENSOR_BIT | EN_SNK_CRUDE_SENSOR_BIT, EN_SRC_CRUDE_SENSOR_BIT | EN_SNK_CRUDE_SENSOR_BIT); if (rc < 0) smblib_err(chg, "Couldn't enable crude sensor rc=%d\n", rc); /* disable current source */ rc = smblib_write(chg, TYPE_C_SBU_CFG_REG, 0); if (rc < 0) smblib_err(chg, "Couldn't select SBU1 rc=%d\n", rc); return ret; } int smblib_get_prop_charger_temp(struct smb_charger *chg, union power_supply_propval *val) { int temp, rc; int input_present; rc = smblib_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->intval = temp / 100; } else { return -ENODATA; } return rc; } int smblib_get_prop_typec_cc_orientation(struct smb_charger *chg, union power_supply_propval *val) { int rc = 0; u8 stat; val->intval = 0; if (chg->connector_type == POWER_SUPPLY_CONNECTOR_MICRO_USB) return 0; rc = smblib_read(chg, TYPE_C_MISC_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read TYPE_C_STATUS_4 rc=%d\n", rc); return rc; } smblib_dbg(chg, PR_REGISTER, "TYPE_C_STATUS_4 = 0x%02x\n", stat); if (stat & CC_ATTACHED_BIT) val->intval = (bool)(stat & CC_ORIENTATION_BIT) + 1; return rc; } static const char * const smblib_typec_mode_name[] = { [POWER_SUPPLY_TYPEC_NONE] = "NONE", [POWER_SUPPLY_TYPEC_SOURCE_DEFAULT] = "SOURCE_DEFAULT", [POWER_SUPPLY_TYPEC_SOURCE_MEDIUM] = "SOURCE_MEDIUM", [POWER_SUPPLY_TYPEC_SOURCE_HIGH] = "SOURCE_HIGH", [POWER_SUPPLY_TYPEC_NON_COMPLIANT] = "NON_COMPLIANT", [POWER_SUPPLY_TYPEC_SINK] = "SINK", [POWER_SUPPLY_TYPEC_SINK_POWERED_CABLE] = "SINK_POWERED_CABLE", [POWER_SUPPLY_TYPEC_SINK_DEBUG_ACCESSORY] = "SINK_DEBUG_ACCESSORY", [POWER_SUPPLY_TYPEC_SINK_AUDIO_ADAPTER] = "SINK_AUDIO_ADAPTER", [POWER_SUPPLY_TYPEC_POWERED_CABLE_ONLY] = "POWERED_CABLE_ONLY", }; static int smblib_get_prop_ufp_mode(struct smb_charger *chg) { int rc; u8 stat; rc = smblib_read(chg, TYPE_C_SNK_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read TYPE_C_STATUS_1 rc=%d\n", rc); return POWER_SUPPLY_TYPEC_NONE; } smblib_dbg(chg, PR_REGISTER, "TYPE_C_STATUS_1 = 0x%02x\n", stat); #ifdef OPLUS_FEATURE_CHG_BASIC /* config 0x154A to 0x17 */ if (stat & (SNK_DAM_500MA_BIT | SNK_DAM_1500MA_BIT | SNK_DAM_3000MA_BIT)) { rc = smblib_masked_write(chg, DEBUG_ACCESS_SNK_CFG_REG, 0x1f, 0x17); if (rc < 0) smblib_err(chg, "Couldn't config DEBUG_ACCESS_SNK_CFG_REG rc=%d\n", rc); } #endif switch (stat & DETECTED_SRC_TYPE_MASK) { case SNK_RP_STD_BIT: #ifdef OPLUS_FEATURE_CHG_BASIC case SNK_DAM_500MA_BIT: #endif return POWER_SUPPLY_TYPEC_SOURCE_DEFAULT; case SNK_RP_1P5_BIT: #ifdef OPLUS_FEATURE_CHG_BASIC case SNK_DAM_1500MA_BIT: #endif return POWER_SUPPLY_TYPEC_SOURCE_MEDIUM; case SNK_RP_3P0_BIT: #ifdef OPLUS_FEATURE_CHG_BASIC case SNK_DAM_3000MA_BIT: #endif return POWER_SUPPLY_TYPEC_SOURCE_HIGH; case SNK_RP_SHORT_BIT: return POWER_SUPPLY_TYPEC_NON_COMPLIANT; default: break; } return POWER_SUPPLY_TYPEC_NONE; } static int smblib_get_prop_dfp_mode(struct smb_charger *chg) { int rc; u8 stat; if (chg->lpd_stage == LPD_STAGE_COMMIT) return POWER_SUPPLY_TYPEC_NONE; rc = smblib_read(chg, TYPE_C_SRC_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read TYPE_C_SRC_STATUS_REG rc=%d\n", rc); return POWER_SUPPLY_TYPEC_NONE; } smblib_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: #ifdef OPLUS_CUSTOM_OP_DEF chg->is_audio_adapter = true; #endif return POWER_SUPPLY_TYPEC_SINK_AUDIO_ADAPTER; case SRC_DEBUG_ACCESS_BIT: return POWER_SUPPLY_TYPEC_SINK_DEBUG_ACCESSORY; case SRC_RD_RA_VCONN_BIT: return POWER_SUPPLY_TYPEC_SINK_POWERED_CABLE; case SRC_RD_OPEN_BIT: return POWER_SUPPLY_TYPEC_SINK; default: break; } return POWER_SUPPLY_TYPEC_NONE; } static int smblib_get_prop_typec_mode(struct smb_charger *chg) { int rc; u8 stat; rc = smblib_read(chg, TYPE_C_MISC_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read TYPE_C_MISC_STATUS_REG rc=%d\n", rc); return 0; } smblib_dbg(chg, PR_REGISTER, "TYPE_C_MISC_STATUS_REG = 0x%02x\n", stat); if (stat & SNK_SRC_MODE_BIT) { rc = smblib_get_prop_dfp_mode(chg); } else { rc = smblib_get_prop_ufp_mode(chg); } pr_info("typec mode is %d\n", rc); return rc; } inline int smblib_get_usb_prop_typec_mode(struct smb_charger *chg, union power_supply_propval *val) { if (chg->connector_type == POWER_SUPPLY_CONNECTOR_MICRO_USB) val->intval = POWER_SUPPLY_TYPEC_NONE; else val->intval = chg->typec_mode; return 0; } int smblib_get_prop_typec_power_role(struct smb_charger *chg, union power_supply_propval *val) { int rc = 0; u8 ctrl; if (chg->connector_type == POWER_SUPPLY_CONNECTOR_MICRO_USB) { val->intval = POWER_SUPPLY_TYPEC_PR_NONE; return 0; } rc = smblib_read(chg, TYPE_C_MODE_CFG_REG, &ctrl); if (rc < 0) { smblib_err(chg, "Couldn't read TYPE_C_MODE_CFG_REG rc=%d\n", rc); return rc; } smblib_dbg(chg, PR_REGISTER, "TYPE_C_MODE_CFG_REG = 0x%02x\n", ctrl); if (ctrl & TYPEC_DISABLE_CMD_BIT) { val->intval = POWER_SUPPLY_TYPEC_PR_NONE; return rc; } switch (ctrl & (EN_SRC_ONLY_BIT | EN_SNK_ONLY_BIT)) { case 0: val->intval = POWER_SUPPLY_TYPEC_PR_DUAL; break; case EN_SRC_ONLY_BIT: val->intval = POWER_SUPPLY_TYPEC_PR_SOURCE; break; case EN_SNK_ONLY_BIT: val->intval = POWER_SUPPLY_TYPEC_PR_SINK; break; default: val->intval = POWER_SUPPLY_TYPEC_PR_NONE; smblib_err(chg, "unsupported power role 0x%02lx\n", ctrl & (EN_SRC_ONLY_BIT | EN_SNK_ONLY_BIT)); return -EINVAL; } chg->power_role = val->intval; return rc; } static inline bool typec_in_src_mode(struct smb_charger *chg) { return (chg->typec_mode > POWER_SUPPLY_TYPEC_NONE && chg->typec_mode < POWER_SUPPLY_TYPEC_SOURCE_DEFAULT); } int smblib_get_prop_typec_select_rp(struct smb_charger *chg, union power_supply_propval *val) { int rc, rp; u8 stat; if (!typec_in_src_mode(chg)) return -ENODATA; rc = smblib_read(chg, TYPE_C_CURRSRC_CFG_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read TYPE_C_CURRSRC_CFG_REG rc=%d\n", rc); return rc; } switch (stat & TYPEC_SRC_RP_SEL_MASK) { case TYPEC_SRC_RP_STD: rp = POWER_SUPPLY_TYPEC_SRC_RP_STD; break; case TYPEC_SRC_RP_1P5A: rp = POWER_SUPPLY_TYPEC_SRC_RP_1P5A; break; case TYPEC_SRC_RP_3A: case TYPEC_SRC_RP_3A_DUPLICATE: rp = POWER_SUPPLY_TYPEC_SRC_RP_3A; break; default: return -EINVAL; } val->intval = rp; return 0; } int smblib_get_prop_usb_current_now(struct smb_charger *chg, union power_supply_propval *val) { union power_supply_propval pval = {0, }; int rc = 0, buck_scale = 1, boost_scale = 1; #ifdef OPLUS_FEATURE_CHG_BASIC struct oplus_chg_chip *chip = g_oplus_chip; if (chip && chip->vbatt_num == 2 && chip->chg_ops->get_charger_current){ if(oplus_vooc_get_allow_reading()){ val->intval = chip->chg_ops->get_charger_current(); val->intval = val->intval / 1000; }else{ val->intval = -1; } //pr_err("[OPLUS_CHG], ibus current: val->intval[%d]", val->intval); return rc; } #endif if (chg->iio.usbin_i_chan) { rc = iio_read_channel_processed(chg->iio.usbin_i_chan, &val->intval); if (rc < 0) { pr_err("Error in reading USBIN_I channel, rc=%d\n", rc); return rc; } /* * For PM8150B, scaling factor = reciprocal of * 0.2V/A in Buck mode, 0.4V/A in Boost mode. * For PMI632, scaling factor = reciprocal of * 0.4V/A in Buck mode, 0.8V/A in Boost mode. */ switch (chg->chg_param.smb_version) { case PMI632_SUBTYPE: buck_scale = 40; boost_scale = 80; break; default: buck_scale = 20; boost_scale = 40; break; } if (chg->otg_present || smblib_get_prop_dfp_mode(chg) != POWER_SUPPLY_TYPEC_NONE) { val->intval = DIV_ROUND_CLOSEST(val->intval * 100, boost_scale); return rc; } rc = smblib_get_prop_usb_present(chg, &pval); if (rc < 0) { smblib_err(chg, "Couldn't get usb present status,rc=%d\n", rc); return -ENODATA; } /* If USB is not present, return 0 */ if (!pval.intval) val->intval = 0; else val->intval = DIV_ROUND_CLOSEST(val->intval * 100, buck_scale); } else { val->intval = 0; rc = -ENODATA; } return rc; } #ifdef OPLUS_CUSTOM_OP_DEF int smbchg_get_charger_current(void) { struct oplus_chg_chip *chip = g_oplus_chip; struct smb_charger *chg = NULL; union power_supply_propval val = {0}; int rc = 0; if (!chip) return -1; chg = &chip->pmic_spmi.smb5_chip->chg; rc = smblib_get_prop_usb_current_now(chg, &val); if (rc < 0) return -1; return val.intval; } #endif int smblib_get_prop_low_power(struct smb_charger *chg, union power_supply_propval *val) { int rc; u8 stat; if (chg->sink_src_mode != SRC_MODE) return -ENODATA; rc = smblib_read(chg, TYPE_C_SRC_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read TYPE_C_SRC_STATUS_REG rc=%d\n", rc); return rc; } val->intval = !(stat & SRC_HIGH_BATT_BIT); return 0; } int smblib_get_prop_input_current_settled(struct smb_charger *chg, union power_supply_propval *val) { return smblib_get_charge_param(chg, &chg->param.icl_stat, &val->intval); } int smblib_get_prop_input_voltage_settled(struct smb_charger *chg, union power_supply_propval *val) { int rc, pulses; switch (chg->real_charger_type) { case POWER_SUPPLY_TYPE_USB_HVDCP_3: rc = smblib_get_pulse_cnt(chg, &pulses); if (rc < 0) { smblib_err(chg, "Couldn't read QC_PULSE_COUNT rc=%d\n", rc); return 0; } val->intval = MICRO_5V + HVDCP3_STEP_UV * pulses; break; case POWER_SUPPLY_TYPE_USB_PD: val->intval = chg->voltage_min_uv; break; default: val->intval = MICRO_5V; break; } return 0; } int smblib_get_prop_pd_in_hard_reset(struct smb_charger *chg, union power_supply_propval *val) { val->intval = chg->pd_hard_reset; return 0; } int smblib_get_pe_start(struct smb_charger *chg, union power_supply_propval *val) { val->intval = chg->ok_to_pd; return 0; } int smblib_get_prop_smb_health(struct smb_charger *chg) { int rc; u8 stat; int input_present; rc = smblib_is_input_present(chg, &input_present); if (rc < 0) return rc; if (input_present == INPUT_NOT_PRESENT) return POWER_SUPPLY_HEALTH_UNKNOWN; if (chg->wa_flags & SW_THERM_REGULATION_WA) { if (chg->smb_temp == -ENODATA) return POWER_SUPPLY_HEALTH_UNKNOWN; if (chg->smb_temp > SMB_TEMP_RST_THRESH) return POWER_SUPPLY_HEALTH_OVERHEAT; if (chg->smb_temp > SMB_TEMP_REG_H_THRESH) return POWER_SUPPLY_HEALTH_HOT; if (chg->smb_temp > SMB_TEMP_REG_L_THRESH) return POWER_SUPPLY_HEALTH_WARM; return POWER_SUPPLY_HEALTH_COOL; } rc = smblib_read(chg, SMB_TEMP_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read SMB_TEMP_STATUS_REG, rc=%d\n", rc); return POWER_SUPPLY_HEALTH_UNKNOWN; } if (stat & SMB_TEMP_RST_BIT) return POWER_SUPPLY_HEALTH_OVERHEAT; if (stat & SMB_TEMP_UB_BIT) return POWER_SUPPLY_HEALTH_HOT; if (stat & SMB_TEMP_LB_BIT) return POWER_SUPPLY_HEALTH_WARM; return POWER_SUPPLY_HEALTH_COOL; } int smblib_get_prop_die_health(struct smb_charger *chg) { int rc; u8 stat; int input_present; rc = smblib_is_input_present(chg, &input_present); if (rc < 0) return rc; if (input_present == INPUT_NOT_PRESENT) return POWER_SUPPLY_HEALTH_UNKNOWN; if (chg->wa_flags & SW_THERM_REGULATION_WA) { if (chg->die_temp == -ENODATA) return POWER_SUPPLY_HEALTH_UNKNOWN; if (chg->die_temp > DIE_TEMP_RST_THRESH) return POWER_SUPPLY_HEALTH_OVERHEAT; if (chg->die_temp > DIE_TEMP_REG_H_THRESH) return POWER_SUPPLY_HEALTH_HOT; if (chg->die_temp > DIE_TEMP_REG_L_THRESH) return POWER_SUPPLY_HEALTH_WARM; return POWER_SUPPLY_HEALTH_COOL; } rc = smblib_read(chg, DIE_TEMP_STATUS_REG, &stat); if (rc < 0) { smblib_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 smblib_get_die_health(struct smb_charger *chg, union power_supply_propval *val) { if (chg->die_health == -EINVAL) val->intval = smblib_get_prop_die_health(chg); else val->intval = chg->die_health; return 0; } int smblib_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 = smblib_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 smblib_get_typec_connector_temp_status(struct smb_charger *chg) { int rc; u8 stat; if (chg->connector_health != -EINVAL) return chg->connector_health; if (chg->wa_flags & SW_THERM_REGULATION_WA) { if (chg->connector_temp == -ENODATA) return POWER_SUPPLY_HEALTH_UNKNOWN; if (chg->connector_temp > CONNECTOR_TEMP_RST_THRESH) return POWER_SUPPLY_HEALTH_OVERHEAT; if (chg->connector_temp > CONNECTOR_TEMP_REG_H_THRESH) return POWER_SUPPLY_HEALTH_HOT; if (chg->connector_temp > CONNECTOR_TEMP_REG_L_THRESH) return POWER_SUPPLY_HEALTH_WARM; return POWER_SUPPLY_HEALTH_COOL; } rc = smblib_read(chg, CONNECTOR_TEMP_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read CONNECTOR_TEMP_STATUS_REG, rc=%d\n", rc); return POWER_SUPPLY_HEALTH_UNKNOWN; } if (stat & CONNECTOR_TEMP_RST_BIT) return POWER_SUPPLY_HEALTH_OVERHEAT; if (stat & CONNECTOR_TEMP_UB_BIT) return POWER_SUPPLY_HEALTH_HOT; if (stat & CONNECTOR_TEMP_LB_BIT) return POWER_SUPPLY_HEALTH_WARM; return POWER_SUPPLY_HEALTH_COOL; } int smblib_get_skin_temp_status(struct smb_charger *chg) { int rc; u8 stat; if (!chg->en_skin_therm_mitigation) return POWER_SUPPLY_HEALTH_UNKNOWN; rc = smblib_read(chg, SKIN_TEMP_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read SKIN_TEMP_STATUS_REG, rc=%d\n", rc); return POWER_SUPPLY_HEALTH_UNKNOWN; } if (stat & SKIN_TEMP_RST_BIT) return POWER_SUPPLY_HEALTH_OVERHEAT; if (stat & SKIN_TEMP_UB_BIT) return POWER_SUPPLY_HEALTH_HOT; if (stat & SKIN_TEMP_LB_BIT) return POWER_SUPPLY_HEALTH_WARM; return POWER_SUPPLY_HEALTH_COOL; } int smblib_get_prop_connector_health(struct smb_charger *chg) { bool dc_present, usb_present; int input_present; int rc; rc = smblib_is_input_present(chg, &input_present); if (rc < 0) return POWER_SUPPLY_HEALTH_UNKNOWN; dc_present = input_present & INPUT_PRESENT_DC; usb_present = input_present & INPUT_PRESENT_USB; if (usb_present) return smblib_get_typec_connector_temp_status(chg); /* * In PM8150B, SKIN channel measures Wireless charger receiver * temp, used to regulate DC ICL. */ if (chg->chg_param.smb_version == PM8150B_SUBTYPE && dc_present) return smblib_get_skin_temp_status(chg); return POWER_SUPPLY_HEALTH_COOL; } static int get_rp_based_dcp_current(struct smb_charger *chg, int typec_mode) { int rp_ua; switch (typec_mode) { case POWER_SUPPLY_TYPEC_SOURCE_HIGH: rp_ua = TYPEC_HIGH_CURRENT_UA; break; case POWER_SUPPLY_TYPEC_SOURCE_MEDIUM: case POWER_SUPPLY_TYPEC_SOURCE_DEFAULT: /* fall through */ default: rp_ua = DCP_CURRENT_UA; } return rp_ua; } /******************* * USB PSY SETTERS * * *****************/ int smblib_set_prop_pd_current_max(struct smb_charger *chg, const union power_supply_propval *val) { int rc, icl; if (chg->pd_active) { icl = get_client_vote(chg->usb_icl_votable, PD_VOTER); rc = vote(chg->usb_icl_votable, PD_VOTER, true, val->intval); if (val->intval != icl) power_supply_changed(chg->usb_psy); } else { rc = -EPERM; } return rc; } static int smblib_handle_usb_current(struct smb_charger *chg, int usb_current) { int rc = 0, rp_ua, typec_mode; union power_supply_propval val = {0, }; if (chg->real_charger_type == POWER_SUPPLY_TYPE_USB_FLOAT) { if (usb_current == -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_500MA); if (rc < 0) smblib_err(chg, "Couldn't set SDP ICL rc=%d\n", rc); return rc; } if (chg->connector_type == POWER_SUPPLY_CONNECTOR_TYPEC) { /* * Valid FLOAT charger, report the current * based of Rp. */ typec_mode = smblib_get_prop_typec_mode(chg); rp_ua = get_rp_based_dcp_current(chg, typec_mode); rc = vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, true, rp_ua); if (rc < 0) return rc; } else { 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, usb_current); if (rc < 0) return rc; rc = vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, false, 0); if (rc < 0) return rc; } } else { rc = smblib_get_prop_usb_present(chg, &val); if (!rc && !val.intval) return 0; /* if flash is active force 500mA */ if ((usb_current < SDP_CURRENT_UA) && is_flash_active(chg)) usb_current = SDP_CURRENT_UA; rc = vote(chg->usb_icl_votable, USB_PSY_VOTER, true, usb_current); 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; } } return 0; } int smblib_set_prop_sdp_current_max(struct smb_charger *chg, const union power_supply_propval *val) { union power_supply_propval pval; int rc = 0; if (!chg->pd_active) { rc = smblib_get_prop_usb_present(chg, &pval); if (rc < 0) { smblib_err(chg, "Couldn't get usb present rc = %d\n", rc); return rc; } /* handle the request only when USB is present */ if (pval.intval) rc = smblib_handle_usb_current(chg, val->intval); } else if (chg->system_suspend_supported) { if (val->intval <= USBIN_25MA) rc = vote(chg->usb_icl_votable, PD_SUSPEND_SUPPORTED_VOTER, true, val->intval); else rc = vote(chg->usb_icl_votable, PD_SUSPEND_SUPPORTED_VOTER, false, 0); } return rc; } int smblib_set_prop_boost_current(struct smb_charger *chg, const union power_supply_propval *val) { int rc = 0; rc = smblib_set_charge_param(chg, &chg->param.freq_switcher, val->intval <= chg->boost_threshold_ua ? chg->chg_freq.freq_below_otg_threshold : chg->chg_freq.freq_above_otg_threshold); if (rc < 0) { dev_err(chg->dev, "Error in setting freq_boost rc=%d\n", rc); return rc; } chg->boost_current_ua = val->intval; return rc; } int smblib_set_prop_usb_voltage_max_limit(struct smb_charger *chg, const union power_supply_propval *val) { union power_supply_propval pval = {0, }; /* Exit if same value is re-configured */ if (val->intval == chg->usbin_forced_max_uv) return 0; smblib_get_prop_usb_voltage_max_design(chg, &pval); if (val->intval >= MICRO_5V && val->intval <= pval.intval) { chg->usbin_forced_max_uv = val->intval; smblib_dbg(chg, PR_MISC, "Max VBUS limit changed to: %d\n", val->intval); } else if (chg->usbin_forced_max_uv) { chg->usbin_forced_max_uv = 0; } else { return 0; } power_supply_changed(chg->usb_psy); return 0; } void smblib_typec_irq_config(struct smb_charger *chg, bool en) { if (en == chg->typec_irq_en) return; if (en) { enable_irq( chg->irq_info[TYPEC_ATTACH_DETACH_IRQ].irq); enable_irq( chg->irq_info[TYPEC_CC_STATE_CHANGE_IRQ].irq); enable_irq( chg->irq_info[TYPEC_OR_RID_DETECTION_CHANGE_IRQ].irq); } else { disable_irq_nosync( chg->irq_info[TYPEC_ATTACH_DETACH_IRQ].irq); disable_irq_nosync( chg->irq_info[TYPEC_CC_STATE_CHANGE_IRQ].irq); disable_irq_nosync( chg->irq_info[TYPEC_OR_RID_DETECTION_CHANGE_IRQ].irq); } chg->typec_irq_en = en; } #ifdef OPLUS_CUSTOM_OP_DEF int smblib_set_prop_reset_rd(struct smb_charger *chg, const union power_supply_propval *val) { int rc; u8 stat; if (!(chg->typec_mode == POWER_SUPPLY_TYPEC_SOURCE_HIGH)) { smblib_err(chg, "Not in source high mode, do not reset rd!\n"); return -EINVAL; } rc = smblib_masked_write(chg, TYPE_C_CC_CURRSRC_CONTROL_REG, TYPE_C_CC_CURRSRC_CONTROL_MASK, val->intval); if (rc < 0) smblib_err(chg, "Couldn't write to TYPE_C_CC_CURRSRC_CONTROL_REG rc=%d\n", rc); rc = smblib_read(chg, TYPE_C_CC_CURRSRC_CONTROL_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read TYPE_C_CC_CURRSRC_CONTROL_REG rc=%d\n", rc); return rc; } smblib_err(chg, "0x155C value is 0x%04x\n", stat); schedule_delayed_work(&chg->reset_rd_work, msecs_to_jiffies(500)); return rc; } static void op_reset_rd_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, reset_rd_work.work); int rc; u8 stat; rc = smblib_masked_write(chg, TYPE_C_CC_CURRSRC_CONTROL_REG, TYPE_C_CC_CURRSRC_CONTROL_MASK, 0); if (rc < 0) smblib_err(chg, "Couldn't write to TYPE_C_CC_CURRSRC_CONTROL_REG rc=%d\n", rc); rc = smblib_read(chg, TYPE_C_CC_CURRSRC_CONTROL_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read TYPE_C_CC_CURRSRC_CONTROL_REG rc=%d\n", rc); } smblib_err(chg, "0x155C value is 0x%04x\n", stat); } #endif #define PR_LOCK_TIMEOUT_MS 1000 int smblib_set_prop_typec_power_role(struct smb_charger *chg, const union power_supply_propval *val) { int rc = 0; u8 power_role; enum power_supply_typec_mode typec_mode; bool snk_attached = false, src_attached = false, is_pr_lock = false; #ifdef OPLUS_FEATURE_CHG_BASIC u8 stat = 0; int level = 0; struct oplus_chg_chip *chip = g_oplus_chip; #endif if (chg->connector_type == POWER_SUPPLY_CONNECTOR_MICRO_USB) return 0; smblib_dbg(chg, PR_MISC, "power role change: %d --> %d!", chg->power_role, val->intval); if (chg->power_role == val->intval) { smblib_dbg(chg, PR_MISC, "power role already in %d, ignore!", chg->power_role); return 0; } typec_mode = smblib_get_prop_typec_mode(chg); if (typec_mode >= POWER_SUPPLY_TYPEC_SINK && typec_mode <= POWER_SUPPLY_TYPEC_SINK_AUDIO_ADAPTER) snk_attached = true; else if (typec_mode >= POWER_SUPPLY_TYPEC_SOURCE_DEFAULT && typec_mode <= POWER_SUPPLY_TYPEC_SOURCE_HIGH) src_attached = true; /* * If current power role is in DRP, and type-c is already in the * mode (source or sink) that's being requested, it means this is * a power role locking request from USBPD driver. Disable type-c * related interrupts for locking power role to avoid the redundant * notifications. */ if ((chg->power_role == POWER_SUPPLY_TYPEC_PR_DUAL) && ((src_attached && val->intval == POWER_SUPPLY_TYPEC_PR_SINK) || (snk_attached && val->intval == POWER_SUPPLY_TYPEC_PR_SOURCE))) is_pr_lock = true; smblib_dbg(chg, PR_MISC, "snk_attached = %d, src_attached = %d, is_pr_lock = %d\n", snk_attached, src_attached, is_pr_lock); cancel_delayed_work(&chg->pr_lock_clear_work); spin_lock(&chg->typec_pr_lock); if (!chg->pr_lock_in_progress && is_pr_lock) { smblib_dbg(chg, PR_MISC, "disable type-c interrupts for power role locking\n"); smblib_typec_irq_config(chg, false); schedule_delayed_work(&chg->pr_lock_clear_work, msecs_to_jiffies(PR_LOCK_TIMEOUT_MS)); } else if (chg->pr_lock_in_progress && !is_pr_lock) { smblib_dbg(chg, PR_MISC, "restore type-c interrupts after exit power role locking\n"); smblib_typec_irq_config(chg, true); } chg->pr_lock_in_progress = is_pr_lock; spin_unlock(&chg->typec_pr_lock); switch (val->intval) { case POWER_SUPPLY_TYPEC_PR_NONE: power_role = TYPEC_DISABLE_CMD_BIT; break; case POWER_SUPPLY_TYPEC_PR_DUAL: power_role = chg->typec_try_mode; break; case POWER_SUPPLY_TYPEC_PR_SINK: power_role = EN_SNK_ONLY_BIT; break; case POWER_SUPPLY_TYPEC_PR_SOURCE: power_role = EN_SRC_ONLY_BIT; break; default: smblib_err(chg, "power role %d not supported\n", val->intval); return -EINVAL; } #ifdef OPLUS_FEATURE_CHG_BASIC rc = smblib_read(chg, TYPE_C_STATE_MACHINE_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read TYPE_C_STATE_MACHINE_STATUS_REG rc=%d\n",rc); } if(oplus_ccdetect_check_is_gpio(chip) == true) { level = gpio_get_value(chg->ccdetect_gpio); if(!(stat & TYPEC_ATTACH_DETACH_STATE_BIT) && (chip->otg_switch != true) && (level == 1)){ power_role = EN_SNK_ONLY_BIT; } } else { if(!(stat & TYPEC_ATTACH_DETACH_STATE_BIT) && (chip->otg_switch != true)){ power_role = EN_SNK_ONLY_BIT; } } smblib_err(chg, " power_role=%d stat =0x%x level =%d chip->otg_switch=%d\n",power_role,stat,level,chip->otg_switch); #endif rc = smblib_masked_write(chg, TYPE_C_MODE_CFG_REG, TYPEC_POWER_ROLE_CMD_MASK | TYPEC_TRY_MODE_MASK, power_role); if (rc < 0) { smblib_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->intval; return rc; } int smblib_set_prop_typec_select_rp(struct smb_charger *chg, const union power_supply_propval *val) { int rc; if (!typec_in_src_mode(chg)) { smblib_err(chg, "Couldn't set curr src: not in SRC mode\n"); return -EINVAL; } if (val->intval < TYPEC_SRC_RP_MAX_ELEMENTS) { rc = smblib_masked_write(chg, TYPE_C_CURRSRC_CFG_REG, TYPEC_SRC_RP_SEL_MASK, val->intval); if (rc < 0) smblib_err(chg, "Couldn't write to TYPE_C_CURRSRC_CFG rc=%d\n", rc); return rc; } return -EINVAL; } int smblib_set_prop_pd_voltage_min(struct smb_charger *chg, const union power_supply_propval *val) { int rc, min_uv; min_uv = min(val->intval, chg->voltage_max_uv); if (chg->voltage_min_uv == min_uv) return 0; rc = smblib_set_usb_pd_allowed_voltage(chg, min_uv, chg->voltage_max_uv); if (rc < 0) { smblib_err(chg, "invalid min voltage %duV rc=%d\n", val->intval, rc); return rc; } chg->voltage_min_uv = min_uv; power_supply_changed(chg->usb_main_psy); return rc; } int smblib_set_prop_pd_voltage_max(struct smb_charger *chg, const union power_supply_propval *val) { int rc, max_uv; max_uv = max(val->intval, chg->voltage_min_uv); if (chg->voltage_max_uv == max_uv) return 0; rc = smblib_set_usb_pd_fsw(chg, max_uv); if (rc < 0) { smblib_err(chg, "Couldn't set FSW for voltage %duV rc=%d\n", val->intval, rc); return rc; } rc = smblib_set_usb_pd_allowed_voltage(chg, chg->voltage_min_uv, max_uv); if (rc < 0) { smblib_err(chg, "invalid max voltage %duV rc=%d\n", val->intval, rc); return rc; } chg->voltage_max_uv = max_uv; power_supply_changed(chg->usb_main_psy); return rc; } int smblib_set_prop_pd_active(struct smb_charger *chg, const union power_supply_propval *val) { const struct apsd_result *apsd = smblib_get_apsd_result(chg); int rc = 0; int sec_charger; /* * Ignore repetitive notification while PD is active, which * is caused by hard reset. */ if (chg->pd_active && chg->pd_active == val->intval) return 0; chg->pd_active = val->intval; smblib_apsd_enable(chg, !chg->pd_active); update_sw_icl_max(chg, apsd->pst); if (chg->pd_active) { vote(chg->limited_irq_disable_votable, CHARGER_TYPE_VOTER, false, 0); vote(chg->hdc_irq_disable_votable, CHARGER_TYPE_VOTER, false, 0); /* * Enforce 100mA for PD until the real vote comes in later. * It is guaranteed that pd_active is set prior to * pd_current_max */ #ifdef OPLUS_CUSTOM_OP_DEF if (!chg->wireless_present) vote(chg->usb_icl_votable, PD_VOTER, true, USBIN_100MA); #endif // OPLUS_CUSTOM_OP_DEF vote(chg->usb_icl_votable, USB_PSY_VOTER, false, 0); vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, false, 0); /* * For PPS, Charge Pump is preferred over parallel charger if * present. */ if (chg->pd_active == POWER_SUPPLY_PD_PPS_ACTIVE && chg->sec_cp_present) { rc = smblib_select_sec_charger(chg, POWER_SUPPLY_CHARGER_SEC_CP, POWER_SUPPLY_CP_PPS, false); if (rc < 0) dev_err(chg->dev, "Couldn't enable secondary charger rc=%d\n", rc); } } else { vote(chg->usb_icl_votable, PD_VOTER, false, 0); vote(chg->limited_irq_disable_votable, CHARGER_TYPE_VOTER, true, 0); vote(chg->hdc_irq_disable_votable, CHARGER_TYPE_VOTER, true, 0); sec_charger = chg->sec_pl_present ? POWER_SUPPLY_CHARGER_SEC_PL : POWER_SUPPLY_CHARGER_SEC_NONE; rc = smblib_select_sec_charger(chg, sec_charger, POWER_SUPPLY_CP_NONE, false); if (rc < 0) dev_err(chg->dev, "Couldn't enable secondary charger rc=%d\n", rc); /* PD hard resets failed, proceed to detect QC2/3 */ if (chg->ok_to_pd) { chg->ok_to_pd = false; smblib_hvdcp_detect_try_enable(chg, true); } } smblib_usb_pd_adapter_allowance_override(chg, !!chg->pd_active ? FORCE_5V : FORCE_NULL); smblib_update_usb_type(chg); #ifdef OPLUS_FEATURE_CHG_BASIC if (chg->pd_active) { u8 stat; rc = smblib_read(chg, APSD_STATUS_REG, &stat); if (rc < 0) { chg_err("Couldn't read APSD_STATUS rc=%d\n", rc); } else { chg_err("APSD_STATUS stat=0x%02x, apsd->name[%s]\n", stat, apsd->name); if (strcmp("UNKNOWN", apsd->name) == 0) { chg_err("start oplus_charger work\n"); //oplus_chg_cancel_update_work_sync(); oplus_chg_wake_update_work(); } } } #endif power_supply_changed(chg->usb_psy); return rc; } int smblib_set_prop_ship_mode(struct smb_charger *chg, const union power_supply_propval *val) { int rc; smblib_dbg(chg, PR_MISC, "Set ship mode: %d!!\n", !!val->intval); rc = smblib_masked_write(chg, SHIP_MODE_REG, SHIP_MODE_EN_BIT, !!val->intval ? SHIP_MODE_EN_BIT : 0); if (rc < 0) dev_err(chg->dev, "Couldn't %s ship mode, rc=%d\n", !!val->intval ? "enable" : "disable", rc); return rc; } int smblib_set_prop_pd_in_hard_reset(struct smb_charger *chg, const union power_supply_propval *val) { int rc = 0; if (chg->pd_hard_reset == val->intval) return rc; chg->pd_hard_reset = val->intval; rc = smblib_masked_write(chg, TYPE_C_EXIT_STATE_CFG_REG, EXIT_SNK_BASED_ON_CC_BIT, (chg->pd_hard_reset) ? EXIT_SNK_BASED_ON_CC_BIT : 0); if (rc < 0) smblib_err(chg, "Couldn't set EXIT_SNK_BASED_ON_CC rc=%d\n", rc); return rc; } #define JEITA_SOFT 0 #define JEITA_HARD 1 static int smblib_update_jeita(struct smb_charger *chg, u32 *thresholds, int type) { int rc; u16 temp, base; base = CHGR_JEITA_THRESHOLD_BASE_REG(type); temp = thresholds[1] & 0xFFFF; temp = ((temp & 0xFF00) >> 8) | ((temp & 0xFF) << 8); rc = smblib_batch_write(chg, base, (u8 *)&temp, 2); if (rc < 0) { smblib_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 = smblib_batch_write(chg, base + 2, (u8 *)&temp, 2); if (rc < 0) { smblib_err(chg, "Couldn't configure Jeita %s cold threshold rc=%d\n", (type == JEITA_SOFT) ? "Soft" : "Hard", rc); return rc; } smblib_dbg(chg, PR_MISC, "%s Jeita threshold configured\n", (type == JEITA_SOFT) ? "Soft" : "Hard"); return 0; } static int smblib_charge_inhibit_en(struct smb_charger *chg, bool enable) { int rc; rc = smblib_masked_write(chg, CHGR_CFG2_REG, CHARGER_INHIBIT_BIT, enable ? CHARGER_INHIBIT_BIT : 0); return rc; } static int smblib_soft_jeita_arb_wa(struct smb_charger *chg) { union power_supply_propval pval; int rc = 0; bool soft_jeita; rc = smblib_get_prop_batt_health(chg, &pval); if (rc < 0) { smblib_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 = smblib_charge_inhibit_en(chg, true); if (rc < 0) smblib_err(chg, "Couldn't enable charge inhibit rc=%d\n", rc); rc = smblib_update_jeita(chg, chg->jeita_soft_hys_thlds, JEITA_SOFT); if (rc < 0) smblib_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 = smblib_charge_inhibit_en(chg, false); if (rc < 0) smblib_err(chg, "Couldn't disable charge inhibit rc=%d\n", rc); rc = smblib_update_jeita(chg, chg->jeita_soft_thlds, JEITA_SOFT); if (rc < 0) smblib_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; } smblib_dbg(chg, PR_MISC, "JEITA ARB status %d, soft JEITA status %d\n", chg->jeita_arb_flag, soft_jeita); return rc; } /************************ * USB MAIN PSY GETTERS * ************************/ int smblib_get_prop_fcc_delta(struct smb_charger *chg, union power_supply_propval *val) { int rc, jeita_cc_delta_ua = 0; if (chg->sw_jeita_enabled) { val->intval = 0; return 0; } rc = smblib_get_jeita_cc_delta(chg, &jeita_cc_delta_ua); if (rc < 0) { smblib_err(chg, "Couldn't get jeita cc delta rc=%d\n", rc); jeita_cc_delta_ua = 0; } val->intval = jeita_cc_delta_ua; return 0; } /************************ * USB MAIN PSY SETTERS * ************************/ int smblib_get_charge_current(struct smb_charger *chg, int *total_current_ua) { const struct apsd_result *apsd_result = smblib_get_apsd_result(chg); union power_supply_propval val = {0, }; int rc = 0, typec_source_rd, current_ua; bool non_compliant; u8 stat; if (chg->pd_active) { *total_current_ua = get_client_vote_locked(chg->usb_icl_votable, PD_VOTER); return rc; } rc = smblib_read(chg, LEGACY_CABLE_STATUS_REG, &stat); if (rc < 0) { smblib_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 = smblib_get_prop_input_current_settled(chg, &val); if (rc < 0) { smblib_err(chg, "Couldn't get settled ICL rc=%d\n", rc); return rc; } typec_source_rd = smblib_get_prop_ufp_mode(chg); /* QC 2.0/3.0 adapter */ if (apsd_result->bit & (QC_3P0_BIT | QC_2P0_BIT)) { *total_current_ua = HVDCP_CURRENT_UA; return 0; } if (non_compliant && !chg->typec_legacy_use_rp_icl) { switch (apsd_result->bit) { case CDP_CHARGER_BIT: current_ua = CDP_CURRENT_UA; break; case DCP_CHARGER_BIT: case OCP_CHARGER_BIT: case FLOAT_CHARGER_BIT: 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 POWER_SUPPLY_TYPEC_SOURCE_DEFAULT: switch (apsd_result->bit) { case CDP_CHARGER_BIT: current_ua = CDP_CURRENT_UA; break; case DCP_CHARGER_BIT: case OCP_CHARGER_BIT: case FLOAT_CHARGER_BIT: current_ua = chg->default_icl_ua; break; default: current_ua = 0; break; } break; case POWER_SUPPLY_TYPEC_SOURCE_MEDIUM: current_ua = TYPEC_MEDIUM_CURRENT_UA; break; case POWER_SUPPLY_TYPEC_SOURCE_HIGH: current_ua = TYPEC_HIGH_CURRENT_UA; break; case POWER_SUPPLY_TYPEC_NON_COMPLIANT: case POWER_SUPPLY_TYPEC_NONE: default: current_ua = 0; break; } *total_current_ua = max(current_ua, val.intval); return 0; } /********************** * INTERRUPT HANDLERS * **********************/ irqreturn_t default_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; smblib_dbg(chg, PR_INTERRUPT, "IRQ: %s\n", irq_data->name); return IRQ_HANDLED; } irqreturn_t smb_en_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; int rc, input_present; if (!chg->cp_disable_votable) { chg->cp_disable_votable = find_votable("CP_DISABLE"); if (!chg->cp_disable_votable) return IRQ_HANDLED; } if (chg->pd_hard_reset) { vote(chg->cp_disable_votable, BOOST_BACK_VOTER, true, 0); return IRQ_HANDLED; } rc = smblib_is_input_present(chg, &input_present); if (rc < 0) { pr_err("Couldn't get usb presence status rc=%d\n", rc); return IRQ_HANDLED; } if (input_present) { /* * Add some delay to enable SMB1390 switcher after SMB_EN * pin goes high */ usleep_range(1000, 1100); vote(chg->cp_disable_votable, BOOST_BACK_VOTER, false, 0); } return IRQ_HANDLED; } irqreturn_t sdam_sts_change_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; smblib_dbg(chg, PR_INTERRUPT, "IRQ: %s\n", irq_data->name); mutex_lock(&chg->irq_status_lock); chg->irq_status |= PULSE_SKIP_IRQ_BIT; mutex_unlock(&chg->irq_status_lock); power_supply_changed(chg->usb_main_psy); return IRQ_HANDLED; } #define CHG_TERM_WA_ENTRY_DELAY_MS 300000 /* 5 min */ #define CHG_TERM_WA_EXIT_DELAY_MS 60000 /* 1 min */ static void smblib_eval_chg_termination(struct smb_charger *chg, u8 batt_status) { union power_supply_propval pval = {0, }; int rc = 0; rc = smblib_get_prop_from_bms(chg, POWER_SUPPLY_PROP_REAL_CAPACITY, &pval); if (rc < 0) { smblib_err(chg, "Couldn't read SOC value, rc=%d\n", rc); return; } /* * Post charge termination, switch to BSM mode triggers the risk of * over charging as BATFET opening may take some time post the necessity * of staying in supplemental mode, leading to unintended charging of * battery. Trigger the charge termination WA once charging is completed * to prevent overcharing. */ if ((batt_status == TERMINATE_CHARGE) && (pval.intval == 100)) { chg->cc_soc_ref = 0; chg->last_cc_soc = 0; alarm_start_relative(&chg->chg_termination_alarm, ms_to_ktime(CHG_TERM_WA_ENTRY_DELAY_MS)); } else if (pval.intval < 100) { /* * Reset CC_SOC reference value for charge termination WA once * we exit the TERMINATE_CHARGE state and soc drops below 100% */ chg->cc_soc_ref = 0; chg->last_cc_soc = 0; } } irqreturn_t 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; int rc; smblib_dbg(chg, PR_INTERRUPT, "IRQ: %s\n", irq_data->name); rc = smblib_read(chg, BATTERY_CHARGER_STATUS_1_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read BATTERY_CHARGER_STATUS_1 rc=%d\n", rc); return IRQ_HANDLED; } stat = stat & BATTERY_CHARGER_STATUS_MASK; if (chg->wa_flags & CHG_TERMINATION_WA) smblib_eval_chg_termination(chg, stat); power_supply_changed(chg->batt_psy); return IRQ_HANDLED; } irqreturn_t 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; smblib_dbg(chg, PR_INTERRUPT, "IRQ: %s\n", irq_data->name); if (chg->jeita_configured != JEITA_CFG_COMPLETE) return IRQ_HANDLED; rc = smblib_soft_jeita_arb_wa(chg); if (rc < 0) { smblib_err(chg, "Couldn't fix soft jeita arb rc=%d\n", rc); return IRQ_HANDLED; } return IRQ_HANDLED; } irqreturn_t batt_psy_changed_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; smblib_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 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; const struct apsd_result *apsd = smblib_get_apsd_result(chg); int rc; u8 stat = 0, max_pulses = 0; #ifdef OPLUS_FEATURE_CHG_BASIC if (oplus_is_use_external_boost()) { if (chg->typec_mode == POWER_SUPPLY_TYPEC_SINK || chg->typec_mode == POWER_SUPPLY_TYPEC_SINK_POWERED_CABLE) { pr_info("%s:chg->typec_mode = sink return!\n", __func__); return IRQ_HANDLED; } } #endif smblib_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) { smblib_dbg(chg, PR_MISC, "USBIN_UV storm at max AICL threshold\n"); return IRQ_HANDLED; } smblib_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 = smblib_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; rc = smblib_set_charge_param(chg, &chg->param.aicl_cont_threshold, chg->aicl_cont_threshold_mv + AICL_STEP_MV); if (rc < 0) dev_err(chg->dev, "Error in setting AICL threshold rc=%d\n", rc); else chg->aicl_cont_threshold_mv += AICL_STEP_MV; unsuspend_input: /* Force torch in boost mode to ensure it works with low ICL */ if (chg->chg_param.smb_version == PMI632_SUBTYPE) schgm_flash_torch_priority(chg, TORCH_BOOST_MODE); if (chg->aicl_max_reached) { smblib_dbg(chg, PR_MISC, "Reached max AICL threshold resctricting ICL to 100mA\n"); vote(chg->usb_icl_votable, AICL_THRESHOLD_VOTER, true, USBIN_100MA); smblib_run_aicl(chg, RESTART_AICL); } else { smblib_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); /* Workaround for non-QC2.0-compliant chargers follows */ if (!chg->qc2_unsupported_voltage && apsd->pst == POWER_SUPPLY_TYPE_USB_HVDCP) { rc = smblib_read(chg, QC_CHANGE_STATUS_REG, &stat); if (rc < 0) smblib_err(chg, "Couldn't read CHANGE_STATUS_REG rc=%d\n", rc); if (stat & QC_5V_BIT) return IRQ_HANDLED; rc = smblib_read(chg, HVDCP_PULSE_COUNT_MAX_REG, &max_pulses); if (rc < 0) smblib_err(chg, "Couldn't read QC2 max pulses rc=%d\n", rc); chg->qc2_max_pulses = (max_pulses & HVDCP_PULSE_COUNT_MAX_QC2_MASK); if (stat & QC_12V_BIT) { chg->qc2_unsupported_voltage = QC2_NON_COMPLIANT_12V; rc = smblib_masked_write(chg, HVDCP_PULSE_COUNT_MAX_REG, HVDCP_PULSE_COUNT_MAX_QC2_MASK, HVDCP_PULSE_COUNT_MAX_QC2_9V); if (rc < 0) smblib_err(chg, "Couldn't force max pulses to 9V rc=%d\n", rc); } else if (stat & QC_9V_BIT) { chg->qc2_unsupported_voltage = QC2_NON_COMPLIANT_9V; rc = smblib_masked_write(chg, HVDCP_PULSE_COUNT_MAX_REG, HVDCP_PULSE_COUNT_MAX_QC2_MASK, HVDCP_PULSE_COUNT_MAX_QC2_5V); if (rc < 0) smblib_err(chg, "Couldn't force max pulses to 5V rc=%d\n", rc); } rc = smblib_masked_write(chg, USBIN_AICL_OPTIONS_CFG_REG, SUSPEND_ON_COLLAPSE_USBIN_BIT, 0); if (rc < 0) smblib_err(chg, "Couldn't turn off SUSPEND_ON_COLLAPSE_USBIN_BIT rc=%d\n", rc); smblib_rerun_apsd(chg); } return IRQ_HANDLED; } #define USB_WEAK_INPUT_UA 1400000 #define ICL_CHANGE_DELAY_MS 1000 irqreturn_t icl_change_irq_handler(int irq, void *data) { u8 stat; 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) { /* * Ignore if change in ICL is due to DIE temp mitigation. * This is to prevent any further ICL split. */ if (chg->hw_die_temp_mitigation) { rc = smblib_read(chg, DIE_TEMP_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read DIE_TEMP rc=%d\n", rc); return IRQ_HANDLED; } if (stat & (DIE_TEMP_UB_BIT | DIE_TEMP_LB_BIT)) { smblib_dbg(chg, PR_PARALLEL, "skip ICL change DIE_TEMP %x\n", stat); return IRQ_HANDLED; } } rc = smblib_read(chg, AICL_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read AICL_STATUS rc=%d\n", rc); return IRQ_HANDLED; } rc = smblib_get_charge_param(chg, &chg->param.icl_stat, &settled_ua); if (rc < 0) { smblib_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 void smblib_micro_usb_plugin(struct smb_charger *chg, bool vbus_rising) { if (!vbus_rising) { smblib_update_usb_type(chg); smblib_notify_device_mode(chg, false); smblib_uusb_removal(chg); } } void oplus_voocphy_adapter_plugout_handler(void); void smblib_usb_plugin_hard_reset_locked(struct smb_charger *chg) { int rc; u8 stat; bool vbus_rising; struct smb_irq_data *data; struct storm_watch *wdata; rc = smblib_read(chg, USBIN_BASE + INT_RT_STS_OFFSET, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read USB_INT_RT_STS rc=%d\n", rc); return; } vbus_rising = (bool)(stat & USBIN_PLUGIN_RT_STS_BIT); #ifdef OPLUS_FEATURE_CHG_BASIC oplus_chg_track_check_wired_charging_break(vbus_rising); chg->real_chg_type = POWER_SUPPLY_TYPE_UNKNOWN; #endif #ifndef OPLUS_CUSTOM_OP_DEF if (g_oplus_chip && g_oplus_chip->wireless_support) { cancel_delayed_work_sync(&chg->switch_to_wired_work); printk(KERN_ERR "[OPLUS_CHG][%s]: scheduling wireless charger!\n", __func__); schedule_delayed_work(&chg->switch_to_wired_work, 0); } #endif 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); } else { #ifdef OPLUS_FEATURE_CHG_BASIC chg->hvdcp_detach_time = cpu_clock(smp_processor_id()) / 1000000; printk(KERN_ERR "!!! %s: the hvdcp_detach_time:%lu\n", __func__, chg->hvdcp_detach_time); if (!(chg->hvdcp_detect_ok && (chg->hvdcp_detach_time - chg->hvdcp_detect_time <= OPLUS_HVDCP_DETECT_TO_DETACH_TIME))) { smblib_hvdcp_detect_enable(chg, false); chg->hvdcp_disable = true; } else { chg->hvdcp_detect_ok = false; chg->hvdcp_detect_time = 0; schedule_delayed_work(&chg->hvdcp_disable_work, OPLUS_HVDCP_DISABLE_INTERVAL); } #endif #ifdef OPLUS_FEATURE_CHG_BASIC if (g_oplus_chip) { if(oplus_chg_get_voocphy_support() == AP_SINGLE_CP_VOOCPHY) { oplus_voocphy_adapter_plugout_handler(); } else if (g_oplus_chip->charger_type != POWER_SUPPLY_TYPE_USB && g_oplus_chip->charger_type != POWER_SUPPLY_TYPE_USB_CDP) { oplus_vooc_reset_fastchg_after_usbout(); } else { pr_info("charger_type: %d not reset mcu\n", g_oplus_chip->charger_type); } } if (oplus_vooc_get_fastchg_started() == false && g_oplus_chip) { //smbchg_set_chargerid_switch_val(0); cancel_work_sync(&chg->chargerid_switch_work); schedule_work(&chg->chargerid_switch_work); g_oplus_chip->chargerid_volt = 0; g_oplus_chip->chargerid_volt_got = false; g_oplus_chip->charger_type = POWER_SUPPLY_TYPE_UNKNOWN; cancel_delayed_work(&g_oplus_chip->update_work); oplus_chg_wake_update_work(); } chg->pre_current_ma = -1; #endif 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); } } /* Force 1500mA FCC on USB removal if fcc stepper is enabled */ if (chg->fcc_stepper_enable) vote(chg->fcc_votable, FCC_STEPPER_VOTER, true, 1500000); } #ifdef OPLUS_FEATURE_CHG_BASIC if (vbus_rising) { cancel_delayed_work_sync(&chg->chg_monitor_work); schedule_delayed_work(&chg->chg_monitor_work, OPLUS_CHG_MONITOR_INTERVAL); oplus_wake_up_usbtemp_thread(); #ifdef CONFIG_OPLUS_FEATURE_SEC_DEBUG oplus_force_panic(); #endif } else { #ifdef OPLUS_FEATURE_CHG_BASIC if (g_oplus_chip) g_oplus_chip->usbtemp_check = oplus_usbtemp_condition(); #endif fg_oplus_set_input_current = false; cancel_delayed_work_sync(&chg->chg_monitor_work); } #endif #ifdef OPLUS_FEATURE_CHG_BASIC if (chg->fake_typec_insertion == true && !vbus_rising) { printk(KERN_ERR "!!! %s: fake typec unplug\n", __func__); chg->fake_typec_insertion = false; chg->typec_mode = POWER_SUPPLY_TYPEC_NONE; } #endif #ifdef OPLUS_FEATURE_CHG_BASIC if (vbus_rising) { switch_usb_state(1); } else { switch_usb_state(0); } #endif #ifdef OPLUS_CUSTOM_OP_DEF if (vbus_rising) { if (chg->wireless_present) { vote(chg->usb_icl_votable, OTG_VOTER, false, 0); if (chg->pd_active) vote(chg->usb_icl_votable, PD_VOTER, false, 0); } } else { /* @bsp, fix the suspend current issue */ if (!chg->wireless_present) { rc = smblib_request_dpdm(chg, false); if (rc < 0) smblib_err(chg, "Couldn't disable DPDM rc=%d\n", rc); } else { if ((chg->sink_src_mode == SRC_MODE) && !chg->is_audio_adapter) vote(chg->usb_icl_votable, OTG_VOTER, true, 0); } } #endif // OPLUS_CUSTOM_OP_DEF power_supply_changed(chg->usb_psy); smblib_dbg(chg, PR_INTERRUPT, "IRQ: usbin-plugin %s\n", vbus_rising ? "attached" : "detached"); } #define PL_DELAY_MS 30000 #ifdef OPLUS_FEATURE_CHG_BASIC static int smbchg_charging_disble(void); int smblib_set_dc_suspend(struct smb_charger *chg, bool suspend); int smblib_set_usb_suspend(struct smb_charger *chg, bool suspend); #endif void smblib_usb_plugin_locked(struct smb_charger *chg) { int rc; u8 stat; bool vbus_rising; #ifdef OPLUS_CUSTOM_OP_DEF bool fastchging = false; int ccdetect_level = 0; #endif struct smb_irq_data *data; struct storm_watch *wdata; rc = smblib_read(chg, USBIN_BASE + INT_RT_STS_OFFSET, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read USB_INT_RT_STS rc=%d\n", rc); return; } vbus_rising = (bool)(stat & USBIN_PLUGIN_RT_STS_BIT); #ifdef OPLUS_FEATURE_CHG_BASIC oplus_chg_track_check_wired_charging_break(vbus_rising); chg->real_chg_type = POWER_SUPPLY_TYPE_UNKNOWN; #endif #ifdef OPLUS_CUSTOM_OP_DEF if (chg->wireless_present) { if (chg->wireless_high_vol_mode) smblib_set_opt_switcher_freq(chg, vbus_rising ? chg->chg_freq.freq_12V : chg->chg_freq.freq_removal); else smblib_set_opt_switcher_freq(chg, vbus_rising ? chg->chg_freq.freq_6V_8V : chg->chg_freq.freq_removal); } else { smblib_set_opt_switcher_freq(chg, vbus_rising ? chg->chg_freq.freq_5V : chg->chg_freq.freq_removal); if (g_oplus_chip && g_oplus_chip->charger_type == POWER_SUPPLY_TYPE_WIRELESS) { g_oplus_chip->charger_type = POWER_SUPPLY_TYPE_UNKNOWN; } } #endif // OPLUS_CUSTOM_OP_DEF #ifdef OPLUS_FEATURE_CHG_BASIC #ifdef OPLUS_CUSTOM_OP_DEF if (!chg->wireless_present) { smblib_set_dc_suspend(chg, true); smblib_set_usb_suspend(chg, true); } else { smblib_set_dc_suspend(chg, false); smblib_set_usb_suspend(chg, false); vote(chg->fcc_votable, DEFAULT_VOTER, false, 0); vote(chg->chg_disable_votable, DEFAULT_VOTER, false, 0); vote(chg->usb_icl_votable, USB_PSY_VOTER, false, 0); } #else smblib_set_dc_suspend(chg, true); smblib_set_usb_suspend(chg, true); #endif // OPLUS_CUSTOM_OP_DEF printk(KERN_ERR "!!!!! smblib_usb_plugin_locked: [%d]\n", vbus_rising); oplus_chg_check_break(vbus_rising); #endif #ifndef OPLUS_CUSTOM_OP_DEF if (g_oplus_chip && g_oplus_chip->wireless_support) { cancel_delayed_work_sync(&chg->switch_to_wired_work); printk(KERN_ERR "[OPLUS_CHG][%s]: scheduling wireless charger!\n", __func__); schedule_delayed_work(&chg->switch_to_wired_work, 0); } #endif if (vbus_rising) { cancel_delayed_work_sync(&chg->pr_swap_detach_work); vote(chg->awake_votable, DETACH_DETECT_VOTER, false, 0); #ifdef OPLUS_FEATURE_CHG_BASIC if (smblib_get_prop_dfp_mode(chg) != POWER_SUPPLY_TYPEC_NONE) { chg->fake_usb_insertion = true; return; } #endif #ifdef OPLUS_CUSTOM_OP_DEF if (!chg->wireless_present) { rc = smblib_request_dpdm(chg, true); if (rc < 0) smblib_err(chg, "Couldn't to enable DPDM rc=%d\n", rc); } else { vote(chg->usb_icl_votable, OTG_VOTER, false, 0); if (chg->pd_active) vote(chg->usb_icl_votable, PD_VOTER, false, 0); } #else rc = smblib_request_dpdm(chg, true); if (rc < 0) smblib_err(chg, "Couldn't to enable DPDM rc=%d\n", rc); #endif // OPLUS_CUSTOM_OP_DEF /* Enable SW Thermal regulation */ rc = smblib_set_sw_thermal_regulation(chg, true); if (rc < 0) smblib_err(chg, "Couldn't start SW thermal regulation WA, rc=%d\n", rc); /* 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); #ifdef OPLUS_FEATURE_CHG_BASIC schedule_delayed_work(&chg->typec_disable_cmd_work, msecs_to_jiffies(500)); #endif /* 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)); #ifdef OPLUS_FEATURE_CHG_BASIC if(g_oplus_chip->pmic_spmi.smb5_chip->chg.pd_active) { cancel_delayed_work(&g_oplus_chip->update_work); oplus_chg_wake_update_work(); } #endif } else { #ifdef OPLUS_CUSTOM_OP_DEF fastchging = oplus_vooc_get_fastchg_started(); #endif #ifdef OPLUS_FEATURE_CHG_BASIC chg->hvdcp_detach_time = cpu_clock(smp_processor_id()) / 1000000; printk(KERN_ERR "!!! %s: the hvdcp_detach_time:%lu\n", __func__, chg->hvdcp_detach_time); if (!(chg->hvdcp_detect_ok && (chg->hvdcp_detach_time - chg->hvdcp_detect_time <= OPLUS_HVDCP_DETECT_TO_DETACH_TIME))) { smblib_hvdcp_detect_enable(chg, false); chg->hvdcp_disable = true; } else { chg->hvdcp_detect_ok = false; chg->hvdcp_detect_time = 0; schedule_delayed_work(&chg->hvdcp_disable_work, OPLUS_HVDCP_DISABLE_INTERVAL); } #endif #ifdef OPLUS_FEATURE_CHG_BASIC if (chg->fake_usb_insertion) { chg->fake_usb_insertion = false; return; } if (g_oplus_chip) { if(oplus_chg_get_voocphy_support() == AP_SINGLE_CP_VOOCPHY) { oplus_voocphy_adapter_plugout_handler(); } else if ((g_oplus_chip->charger_type != POWER_SUPPLY_TYPE_USB && g_oplus_chip->charger_type != POWER_SUPPLY_TYPE_USB_CDP) || (oplus_vooc_get_fastchg_dummy_started() == true) || (oplus_vooc_get_fastchg_to_normal() == true) || (oplus_vooc_get_fastchg_to_warm() == true) || (oplus_vooc_get_btb_temp_over() == true)) { oplus_vooc_reset_fastchg_after_usbout(); } else { pr_info("charger_type: %d not reset mcu\n", g_oplus_chip->charger_type); } } if (oplus_vooc_get_fastchg_started() == false && g_oplus_chip) { ///smbchg_set_chargerid_switch_val(0); cancel_work_sync(&chg->chargerid_switch_work); schedule_work(&chg->chargerid_switch_work); g_oplus_chip->chargerid_volt = 0; g_oplus_chip->chargerid_volt_got = false; g_oplus_chip->charger_type = POWER_SUPPLY_TYPE_UNKNOWN; cancel_delayed_work(&g_oplus_chip->update_work); oplus_chg_wake_update_work(); } chg->pre_current_ma = -1; #endif #ifdef OPLUS_FEATURE_CHG_BASIC chg->uusb_apsd_rerun_done = false; #endif /* Disable SW Thermal Regulation */ rc = smblib_set_sw_thermal_regulation(chg, false); if (rc < 0) smblib_err(chg, "Couldn't stop SW thermal regulation WA, rc=%d\n", rc); 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); } } /* Force 1500mA FCC on removal if fcc stepper is enabled */ if (chg->fcc_stepper_enable) vote(chg->fcc_votable, FCC_STEPPER_VOTER, true, 1500000); if (chg->wa_flags & WEAK_ADAPTER_WA) { chg->aicl_5v_threshold_mv = chg->default_aicl_5v_threshold_mv; chg->aicl_cont_threshold_mv = chg->default_aicl_cont_threshold_mv; smblib_set_charge_param(chg, &chg->param.aicl_5v_threshold, chg->aicl_5v_threshold_mv); smblib_set_charge_param(chg, &chg->param.aicl_cont_threshold, chg->aicl_cont_threshold_mv); chg->aicl_max_reached = false; if (chg->chg_param.smb_version == PMI632_SUBTYPE) 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); } #ifdef OPLUS_CUSTOM_OP_DEF if (!chg->wireless_present) { rc = smblib_request_dpdm(chg, false); if (rc < 0) smblib_err(chg, "Couldn't disable DPDM rc=%d\n", rc); } else { if ((chg->sink_src_mode == SRC_MODE) && !chg->is_audio_adapter) vote(chg->usb_icl_votable, OTG_VOTER, true, 0); } #else rc = smblib_request_dpdm(chg, false); if (rc < 0) smblib_err(chg, "Couldn't disable DPDM rc=%d\n", rc); #endif smblib_update_usb_type(chg); } if (chg->connector_type == POWER_SUPPLY_CONNECTOR_MICRO_USB) smblib_micro_usb_plugin(chg, vbus_rising); vote(chg->temp_change_irq_disable_votable, DEFAULT_VOTER, !vbus_rising, 0); #ifdef OPLUS_FEATURE_CHG_BASIC if (vbus_rising) { cancel_delayed_work_sync(&chg->chg_monitor_work); schedule_delayed_work(&chg->chg_monitor_work, OPLUS_CHG_MONITOR_INTERVAL); oplus_wake_up_usbtemp_thread(); #ifdef CONFIG_OPLUS_FEATURE_SEC_DEBUG oplus_force_panic(); #endif } else { if (g_oplus_chip) g_oplus_chip->usbtemp_check = oplus_usbtemp_condition(); fg_oplus_set_input_current = false; opluschg_pd_sdp = false; cancel_delayed_work_sync(&chg->chg_monitor_work); } #endif #ifdef OPLUS_FEATURE_CHG_BASIC if (chg->fake_typec_insertion == true && !vbus_rising) { printk(KERN_ERR "!!! %s: fake typec unplug\n", __func__); chg->fake_typec_insertion = false; chg->typec_mode = POWER_SUPPLY_TYPEC_NONE; } #endif #ifdef OPLUS_FEATURE_CHG_BASIC if (vbus_rising) { switch_usb_state(1); } else { switch_usb_state(0); } #endif #ifdef OPLUS_FEATURE_CHG_BASIC #ifdef OPLUS_CUSTOM_OP_DEF if (g_oplus_chip->hiz_gnd_cable && !vbus_rising) { ccdetect_level = gpio_get_value(chg->ccdetect_gpio); if (!ccdetect_level && fastchging) { g_oplus_chip->icon_debounce = true; g_oplus_chip->svooc_disconnect_count++; g_oplus_chip->cool_down_bck = g_oplus_chip->cool_down; schedule_delayed_work(&chg->connect_check_work, msecs_to_jiffies(1000)); } else if (!fastchging) { g_oplus_chip->icon_debounce = false; g_oplus_chip->svooc_disconnect_count = 0; g_oplus_chip->cool_down_bck = 0; } } #endif #endif power_supply_changed(chg->usb_psy); smblib_dbg(chg, PR_INTERRUPT, "IRQ: usbin-plugin %s\n", vbus_rising ? "attached" : "detached"); } irqreturn_t usb_plugin_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; #ifdef OPLUS_FEATURE_CHG_BASIC//Fanhong.Kong@ProDrv.CHG,add 2018/06/02 for SVOOC OTG struct oplus_chg_chip *chip = g_oplus_chip; if (oplus_is_use_external_boost() || (chip->vbatt_num == 2)) { if (chg->typec_mode == POWER_SUPPLY_TYPEC_SINK || chg->typec_mode == POWER_SUPPLY_TYPEC_SINK_POWERED_CABLE) { pr_info("%s:chg->typec_mode = sink return!\n", __func__); return IRQ_HANDLED; } } #endif/*OPLUS_FEATURE_CHG_BASIC*/ if (chg->pd_hard_reset) smblib_usb_plugin_hard_reset_locked(chg); else smblib_usb_plugin_locked(chg); return IRQ_HANDLED; } static void smblib_handle_slow_plugin_timeout(struct smb_charger *chg, bool rising) { smblib_dbg(chg, PR_INTERRUPT, "IRQ: slow-plugin-timeout %s\n", rising ? "rising" : "falling"); } static void smblib_handle_sdp_enumeration_done(struct smb_charger *chg, bool rising) { smblib_dbg(chg, PR_INTERRUPT, "IRQ: sdp-enumeration-done %s\n", rising ? "rising" : "falling"); } /* triggers when HVDCP 3.0 authentication has finished */ static void smblib_handle_hvdcp_3p0_auth_done(struct smb_charger *chg, bool rising) { const struct apsd_result *apsd_result; int rc; if (!rising) return; if (chg->mode == PARALLEL_MASTER) vote(chg->pl_enable_votable_indirect, USBIN_V_VOTER, true, 0); /* the APSD done handler will set the USB supply type */ apsd_result = smblib_get_apsd_result(chg); /* for QC3, switch to CP if present */ if ((apsd_result->bit & QC_3P0_BIT) && chg->sec_cp_present) { rc = smblib_select_sec_charger(chg, POWER_SUPPLY_CHARGER_SEC_CP, POWER_SUPPLY_CP_HVDCP3, false); if (rc < 0) dev_err(chg->dev, "Couldn't enable secondary chargers rc=%d\n", rc); } smblib_dbg(chg, PR_INTERRUPT, "IRQ: hvdcp-3p0-auth-done rising; %s detected\n", apsd_result->name); } static void smblib_handle_hvdcp_check_timeout(struct smb_charger *chg, bool rising, bool qc_charger) { if (rising) { if (qc_charger) { /* enable HDC and ICL irq for QC2/3 charger */ vote(chg->limited_irq_disable_votable, CHARGER_TYPE_VOTER, false, 0); vote(chg->hdc_irq_disable_votable, CHARGER_TYPE_VOTER, false, 0); vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, true, HVDCP_CURRENT_UA); } else { /* A plain DCP, enforce DCP ICL if specified */ vote(chg->usb_icl_votable, DCP_VOTER, chg->dcp_icl_ua != -EINVAL, chg->dcp_icl_ua); } } #ifdef OPLUS_CUSTOM_OP_DEF if (chg->wireless_present) { /* enable HDC and ICL irq for QC2/3 charger */ vote(chg->limited_irq_disable_votable, CHARGER_TYPE_VOTER, false, 0); vote(chg->hdc_irq_disable_votable, CHARGER_TYPE_VOTER, false, 0); vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, true, HVDCP_CURRENT_UA); } #endif // OPLUS_CUSTOM_OP_DEF smblib_dbg(chg, PR_INTERRUPT, "IRQ: %s %s\n", __func__, rising ? "rising" : "falling"); } /* triggers when HVDCP is detected */ static void smblib_handle_hvdcp_detect_done(struct smb_charger *chg, bool rising) { smblib_dbg(chg, PR_INTERRUPT, "IRQ: hvdcp-detect-done %s\n", rising ? "rising" : "falling"); } static void update_sw_icl_max(struct smb_charger *chg, int pst) { int typec_mode; int rp_ua; /* while PD is active it should have complete ICL control */ if (chg->pd_active) return; if (chg->typec_mode == POWER_SUPPLY_TYPEC_SINK_AUDIO_ADAPTER) { vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, true, 500000); return; } /* * HVDCP 2/3, handled separately */ if (pst == POWER_SUPPLY_TYPE_USB_HVDCP || pst == POWER_SUPPLY_TYPE_USB_HVDCP_3) return; /* TypeC rp med or high, use rp value */ typec_mode = smblib_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); return; } #ifdef OPLUS_CUSTOM_OP_DEF if (chg->wireless_present) { vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, true, 1500000); return; } #endif // OPLUS_CUSTOM_OP_DEF /* rp-std or legacy, USB BC 1.2 */ switch (pst) { 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_flash_active(chg) ? SDP_CURRENT_UA : SDP_100_MA); } 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 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, SDP_100_MA); break; case POWER_SUPPLY_TYPE_UNKNOWN: default: vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, true, SDP_100_MA); break; } } static void smblib_handle_apsd_done(struct smb_charger *chg, bool rising) { const struct apsd_result *apsd_result; #ifdef OPLUS_FEATURE_CHG_BASIC int chg_type; int sub_chg_type; #endif if (!rising) return; apsd_result = smblib_update_usb_type(chg); #ifdef OPLUS_FEATURE_CHG_BASIC #ifdef OPLUS_CUSTOM_OP_DEF printk(KERN_ERR "%s: !!!fg_oplus_set_input_current[%d] wireless_present[%d]\n", __FUNCTION__, fg_oplus_set_input_current, chg->wireless_present); if((fg_oplus_set_input_current == false) && (!chg->wireless_present)) { vote(chg->usb_icl_votable, USB_PSY_VOTER, true, 500000); /*vote 500mA*/ } #else printk(KERN_ERR "%s: !!!fg_oplus_set_input_current[%d]\n", __FUNCTION__, fg_oplus_set_input_current); if(fg_oplus_set_input_current == false) { vote(chg->usb_icl_votable, USB_PSY_VOTER, true, 500000); /*vote 500mA*/ } #endif #endif update_sw_icl_max(chg, apsd_result->pst); switch (apsd_result->bit) { case SDP_CHARGER_BIT: case CDP_CHARGER_BIT: case FLOAT_CHARGER_BIT: if (chg->use_extcon) smblib_notify_device_mode(chg, true); break; case OCP_CHARGER_BIT: case DCP_CHARGER_BIT: break; default: break; } #ifdef OPLUS_FEATURE_CHG_BASIC printk(KERN_ERR "!!!IRQ: apsd-done rising; %s detected\n", apsd_result->name); #endif #ifdef OPLUS_FEATURE_CHG_BASIC if (apsd_result->bit == (DCP_CHARGER_BIT | QC_2P0_BIT)) { chg->hvdcp_detect_ok = true; chg->hvdcp_detect_time = cpu_clock(smp_processor_id()) / 1000000; printk(KERN_ERR " HVDCP2 detect: %d, the detect time: %lu\n", chg->hvdcp_detect_ok, chg->hvdcp_detect_time); } chg_type = opchg_get_charger_type(); sub_chg_type = oplus_chg_get_charger_subtype(); chg->real_chg_type = chg_type | (sub_chg_type << 8); #endif smblib_dbg(chg, PR_INTERRUPT, "IRQ: apsd-done rising; %s detected\n", apsd_result->name); } irqreturn_t 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; #ifdef OPLUS_FEATURE_CHG_BASIC u8 reg_value = 0; #endif #ifdef OPLUS_FEATURE_CHG_BASIC//Fanhong.Kong@ProDrv.CHG,add 2018/06/02 for SVOOC OTG struct oplus_chg_chip *chip = g_oplus_chip; if (oplus_is_use_external_boost() || (chip->vbatt_num == 2)) { if (chg->typec_mode == POWER_SUPPLY_TYPEC_SINK || chg->typec_mode == POWER_SUPPLY_TYPEC_SINK_POWERED_CABLE) { pr_info("%s:chg->typec_mode = sink return!\n", __func__); return IRQ_HANDLED; } } if (chg->fake_usb_insertion) return IRQ_HANDLED; #endif/*OPLUS_FEATURE_CHG_BASIC*/ /* PD session is ongoing, ignore BC1.2 and QC detection */ if (chg->pd_active) return IRQ_HANDLED; rc = smblib_read(chg, APSD_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read APSD_STATUS rc=%d\n", rc); return IRQ_HANDLED; } smblib_dbg(chg, PR_INTERRUPT, "APSD_STATUS = 0x%02x\n", stat); #ifndef OPLUS_FEATURE_CHG_BASIC if ((chg->connector_type == POWER_SUPPLY_CONNECTOR_MICRO_USB) && (stat & APSD_DTC_STATUS_DONE_BIT) && !chg->uusb_apsd_rerun_done) { #else if ((stat & APSD_DTC_STATUS_DONE_BIT) && !chg->uusb_apsd_rerun_done) { #endif /* * Force re-run APSD to handle slow insertion related * charger-mis-detection. */ #ifndef OPLUS_FEATURE_CHG_BASIC chg->uusb_apsd_rerun_done = true; smblib_rerun_apsd_if_required(chg); return IRQ_HANDLED; #else smblib_read(chg, APSD_RESULT_STATUS_REG, ®_value); #ifdef OPLUS_CUSTOM_OP_DEF if ((reg_value & (SDP_CHARGER_BIT)) || (reg_value & (CDP_CHARGER_BIT))) { chg->uusb_apsd_rerun_done = true; smblib_rerun_apsd(chg); return IRQ_HANDLED; } #else if (!(chg->early_usb_attach && (reg_value & (CDP_CHARGER_BIT)))) { if ((reg_value & (SDP_CHARGER_BIT)) || (reg_value & (CDP_CHARGER_BIT))) { chg->uusb_apsd_rerun_done = true; smblib_rerun_apsd(chg); return IRQ_HANDLED; } } #endif #endif } smblib_handle_apsd_done(chg, (bool)(stat & APSD_DTC_STATUS_DONE_BIT)); #ifdef OPLUS_FEATURE_CHG_BASIC if ((bool)(stat & APSD_DTC_STATUS_DONE_BIT)) { cancel_delayed_work(&g_oplus_chip->update_work); oplus_chg_wake_update_work(); } #endif smblib_handle_hvdcp_detect_done(chg, (bool)(stat & QC_CHARGER_BIT)); smblib_handle_hvdcp_check_timeout(chg, (bool)(stat & HVDCP_CHECK_TIMEOUT_BIT), (bool)(stat & QC_CHARGER_BIT)); smblib_handle_hvdcp_3p0_auth_done(chg, (bool)(stat & QC_AUTH_DONE_STATUS_BIT)); smblib_handle_sdp_enumeration_done(chg, (bool)(stat & ENUMERATION_DONE_BIT)); smblib_handle_slow_plugin_timeout(chg, (bool)(stat & SLOW_PLUGIN_TIMEOUT_BIT)); smblib_hvdcp_adaptive_voltage_change(chg); power_supply_changed(chg->usb_psy); rc = smblib_read(chg, APSD_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read APSD_STATUS rc=%d\n", rc); return IRQ_HANDLED; } smblib_dbg(chg, PR_INTERRUPT, "APSD_STATUS = 0x%02x\n", stat); return IRQ_HANDLED; } enum alarmtimer_restart smblib_lpd_recheck_timer(struct alarm *alarm, ktime_t time) { union power_supply_propval pval; struct smb_charger *chg = container_of(alarm, struct smb_charger, lpd_recheck_timer); int rc; if (chg->lpd_reason == LPD_MOISTURE_DETECTED) { pval.intval = POWER_SUPPLY_TYPEC_PR_DUAL; rc = smblib_set_prop_typec_power_role(chg, &pval); if (rc < 0) { smblib_err(chg, "Couldn't write 0x%02x to TYPE_C_INTRPT_ENB_SOFTWARE_CTRL rc=%d\n", pval.intval, rc); return ALARMTIMER_NORESTART; } chg->moisture_present = false; power_supply_changed(chg->usb_psy); } else { rc = smblib_masked_write(chg, TYPE_C_INTERRUPT_EN_CFG_2_REG, TYPEC_WATER_DETECTION_INT_EN_BIT, TYPEC_WATER_DETECTION_INT_EN_BIT); if (rc < 0) { smblib_err(chg, "Couldn't set TYPE_C_INTERRUPT_EN_CFG_2_REG rc=%d\n", rc); return ALARMTIMER_NORESTART; } } chg->lpd_stage = LPD_STAGE_NONE; chg->lpd_reason = LPD_NONE; #ifdef OPLUS_FEATURE_CHG_BASIC smblib_err(chg, "%s: LPD_NONE detected\n", __func__); if ((oplus_get_usb_status() & USB_WATER_DETECT) != 0 && g_oplus_chip) { oplus_clear_usb_status(USB_WATER_DETECT); oplus_vooc_set_disable_adapter_output(false); power_supply_changed(g_oplus_chip->usb_psy); } #endif return ALARMTIMER_NORESTART; } #define RSBU_K_300K_UV 3000000 static bool smblib_src_lpd(struct smb_charger *chg) { union power_supply_propval pval; bool lpd_flag = false; u8 stat; int rc; if (chg->lpd_disabled) return false; rc = smblib_read(chg, TYPE_C_SRC_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read TYPE_C_SRC_STATUS_REG rc=%d\n", rc); return false; } switch (stat & DETECTED_SNK_TYPE_MASK) { case SRC_DEBUG_ACCESS_BIT: if (smblib_rsbux_low(chg, RSBU_K_300K_UV)) lpd_flag = true; break; case SRC_RD_RA_VCONN_BIT: case SRC_RD_OPEN_BIT: case AUDIO_ACCESS_RA_RA_BIT: default: break; } if (lpd_flag) { chg->lpd_stage = LPD_STAGE_COMMIT; pval.intval = POWER_SUPPLY_TYPEC_PR_SINK; rc = smblib_set_prop_typec_power_role(chg, &pval); if (rc < 0) smblib_err(chg, "Couldn't write 0x%02x to TYPE_C_INTRPT_ENB_SOFTWARE_CTRL rc=%d\n", pval.intval, rc); chg->lpd_reason = LPD_MOISTURE_DETECTED; chg->moisture_present = true; vote(chg->usb_icl_votable, LPD_VOTER, true, 0); if(get_boot_mode() != MSM_BOOT_MODE__FACTORY) alarm_start_relative(&chg->lpd_recheck_timer, ms_to_ktime(60000)); power_supply_changed(chg->usb_psy); #ifdef OPLUS_FEATURE_CHG_BASIC smblib_err(chg, "%s: LPD_MOISTURE_DETECTED detected\n", __func__); if ((oplus_get_usb_status() & USB_WATER_DETECT) == 0 && g_oplus_chip) { oplus_vooc_set_disable_adapter_output(true); oplus_set_usb_status(USB_WATER_DETECT); power_supply_changed(g_oplus_chip->usb_psy); } #endif } else { chg->lpd_reason = LPD_NONE; chg->typec_mode = smblib_get_prop_typec_mode(chg); #ifdef OPLUS_FEATURE_CHG_BASIC smblib_err(chg, "%s: LPD_NONE detected\n", __func__); if ((oplus_get_usb_status() & USB_WATER_DETECT) != 0 && g_oplus_chip) { oplus_vooc_set_disable_adapter_output(false); oplus_clear_usb_status(USB_WATER_DETECT); power_supply_changed(g_oplus_chip->usb_psy); } #endif } return lpd_flag; } static void typec_src_fault_condition_cfg(struct smb_charger *chg, bool src) { int rc; u8 mask = USBIN_MID_COMP_FAULT_EN_BIT | USBIN_COLLAPSE_FAULT_EN_BIT; rc = smblib_masked_write(chg, OTG_FAULT_CONDITION_CFG_REG, mask, src ? 0 : mask); if (rc < 0) smblib_err(chg, "Couldn't write OTG_FAULT_CONDITION_CFG_REG rc=%d\n", rc); } static void typec_sink_insertion(struct smb_charger *chg) { int rc; #ifdef OPLUS_CUSTOM_OP_DEF if (!chg->is_audio_adapter && !chg->wireless_present) vote(chg->usb_icl_votable, OTG_VOTER, true, 0); #endif typec_src_fault_condition_cfg(chg, true); rc = smblib_set_charge_param(chg, &chg->param.freq_switcher, chg->chg_freq.freq_above_otg_threshold); if (rc < 0) dev_err(chg->dev, "Error in setting freq_boost rc=%d\n", rc); if (chg->use_extcon) { smblib_notify_usb_host(chg, true); chg->otg_present = true; } if (!chg->pr_swap_in_progress) chg->ok_to_pd = (!(chg->pd_disabled) || chg->early_usb_attach) && !chg->pd_not_supported; } static void typec_src_insertion(struct smb_charger *chg) { int rc = 0; u8 stat; if (chg->pr_swap_in_progress) { vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, false, 0); return; } rc = smblib_read(chg, LEGACY_CABLE_STATUS_REG, &stat); if (rc < 0) { smblib_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; chg->ok_to_pd = (!(chg->typec_legacy || chg->pd_disabled) || chg->early_usb_attach) && !chg->pd_not_supported; /* allow apsd proceed to detect QC2/3 */ if (!chg->ok_to_pd) smblib_hvdcp_detect_try_enable(chg, true); } 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); chg->ok_to_pd = false; #ifndef OPLUS_FEATURE_CHG_BASIC smblib_hvdcp_detect_enable(chg, true); #endif } static void typec_sink_removal(struct smb_charger *chg) { int rc; #ifdef OPLUS_CUSTOM_OP_DEF vote(chg->usb_icl_votable, OTG_VOTER, false, 0); #endif typec_src_fault_condition_cfg(chg, false); rc = smblib_set_charge_param(chg, &chg->param.freq_switcher, chg->chg_freq.freq_removal); if (rc < 0) dev_err(chg->dev, "Error in setting freq_removal rc=%d\n", rc); if (chg->use_extcon) { if (chg->otg_present) smblib_notify_usb_host(chg, false); chg->otg_present = false; } #ifdef OPLUS_CUSTOM_OP_DEF chg->is_audio_adapter = false; #endif } static void typec_src_removal(struct smb_charger *chg) { int rc; struct smb_irq_data *data; struct storm_watch *wdata; int sec_charger; sec_charger = chg->sec_pl_present ? POWER_SUPPLY_CHARGER_SEC_PL : POWER_SUPPLY_CHARGER_SEC_NONE; rc = smblib_select_sec_charger(chg, sec_charger, POWER_SUPPLY_CP_NONE, false); if (rc < 0) dev_err(chg->dev, "Couldn't disable secondary charger rc=%d\n", rc); typec_src_fault_condition_cfg(chg, false); smblib_hvdcp_detect_try_enable(chg, false); smblib_update_usb_type(chg); 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_flash_active(chg) ? SDP_CURRENT_UA : SDP_100_MA); vote(chg->usb_icl_votable, PD_VOTER, false, 0); vote(chg->usb_icl_votable, USB_PSY_VOTER, false, 0); vote(chg->usb_icl_votable, DCP_VOTER, false, 0); vote(chg->usb_icl_votable, SW_QC3_VOTER, false, 0); #ifdef OPLUS_CUSTOM_OP_DEF vote(chg->usb_icl_votable, OTG_VOTER, false, 0); #endif vote(chg->usb_icl_votable, CTM_VOTER, false, 0); vote(chg->usb_icl_votable, HVDCP2_ICL_VOTER, false, 0); vote(chg->usb_icl_votable, CHG_TERMINATION_VOTER, false, 0); vote(chg->usb_icl_votable, THERMAL_THROTTLE_VOTER, false, 0); vote(chg->usb_icl_votable, LPD_VOTER, false, 0); /* reset usb irq voters */ vote(chg->limited_irq_disable_votable, CHARGER_TYPE_VOTER, true, 0); vote(chg->hdc_irq_disable_votable, CHARGER_TYPE_VOTER, true, 0); vote(chg->hdc_irq_disable_votable, HDC_IRQ_VOTER, false, 0); /* reset parallel voters */ vote(chg->pl_disable_votable, PL_DELAY_VOTER, true, 0); vote(chg->pl_disable_votable, PL_FCC_LOW_VOTER, false, 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 WA votes */ vote(chg->usb_icl_votable, SW_THERM_REGULATION_VOTER, false, 0); vote(chg->pl_disable_votable, SW_THERM_REGULATION_VOTER, false, 0); vote(chg->dc_suspend_votable, SW_THERM_REGULATION_VOTER, false, 0); if (chg->cp_disable_votable) vote(chg->cp_disable_votable, SW_THERM_REGULATION_VOTER, false, 0); /* reset USBOV votes and cancel work */ cancel_delayed_work_sync(&chg->usbov_dbc_work); vote(chg->awake_votable, USBOV_DBC_VOTER, false, 0); chg->dbc_usbov = false; chg->pulse_cnt = 0; chg->usb_icl_delta_ua = 0; chg->voltage_min_uv = MICRO_5V; chg->voltage_max_uv = MICRO_5V; chg->usbin_forced_max_uv = 0; /* Reset all CC mode votes */ vote(chg->fcc_main_votable, MAIN_FCC_VOTER, false, 0); chg->adapter_cc_mode = 0; vote_override(chg->fcc_votable, CC_MODE_VOTER, false, 0); vote_override(chg->usb_icl_votable, CC_MODE_VOTER, false, 0); /* write back the default FLOAT charger configuration */ rc = smblib_masked_write(chg, USBIN_OPTIONS_2_CFG_REG, (u8)FLOAT_OPTIONS_MASK, chg->float_cfg); if (rc < 0) smblib_err(chg, "Couldn't write float charger options rc=%d\n", rc); if (!chg->pr_swap_in_progress) { rc = smblib_usb_pd_adapter_allowance_override(chg, FORCE_NULL); if (rc < 0) smblib_err(chg, "Couldn't set FORCE_NULL rc=%d\n", rc); rc = smblib_set_charge_param(chg, &chg->param.aicl_cont_threshold, chg->default_aicl_cont_threshold_mv); if (rc < 0) smblib_err(chg, "Couldn't restore aicl_cont_threshold, rc=%d", rc); } /* * if non-compliant charger caused UV, restore original max pulses * and turn SUSPEND_ON_COLLAPSE_USBIN_BIT back on. */ if (chg->qc2_unsupported_voltage) { rc = smblib_masked_write(chg, HVDCP_PULSE_COUNT_MAX_REG, HVDCP_PULSE_COUNT_MAX_QC2_MASK, chg->qc2_max_pulses); if (rc < 0) smblib_err(chg, "Couldn't restore max pulses rc=%d\n", rc); rc = smblib_masked_write(chg, USBIN_AICL_OPTIONS_CFG_REG, SUSPEND_ON_COLLAPSE_USBIN_BIT, SUSPEND_ON_COLLAPSE_USBIN_BIT); if (rc < 0) smblib_err(chg, "Couldn't turn on SUSPEND_ON_COLLAPSE_USBIN_BIT rc=%d\n", rc); chg->qc2_unsupported_voltage = QC2_COMPLIANT; } if (chg->use_extcon) smblib_notify_device_mode(chg, false); chg->typec_legacy = false; } static void typec_mode_unattached(struct smb_charger *chg) { int rc, input_present; rc = smblib_is_input_present(chg, &input_present); if(input_present & INPUT_PRESENT_USB) { pr_err("vbus presence, not set icl\n"); return; } vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, true, USBIN_100MA); } static void smblib_handle_rp_change(struct smb_charger *chg, int typec_mode) { const struct apsd_result *apsd = smblib_get_apsd_result(chg); /* * We want the ICL vote @ 100mA for a FLOAT charger * until the detection by the USB stack is complete. * Ignore the Rp changes unless there is a * pre-existing valid vote or FLOAT is configured for * SDP current. */ if (apsd->pst == POWER_SUPPLY_TYPE_USB_FLOAT) { if (get_client_vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER) <= USBIN_100MA || (chg->float_cfg & FLOAT_OPTIONS_MASK) == FORCE_FLOAT_SDP_CFG_BIT) return; } update_sw_icl_max(chg, apsd->pst); smblib_dbg(chg, PR_MISC, "CC change old_mode=%d new_mode=%d\n", chg->typec_mode, typec_mode); } static void smblib_lpd_launch_ra_open_work(struct smb_charger *chg) { u8 stat; int rc; if (chg->lpd_disabled) return; rc = smblib_read(chg, TYPE_C_MISC_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read TYPE_C_MISC_STATUS_REG rc=%d\n", rc); return; } if (!(stat & TYPEC_TCCDEBOUNCE_DONE_STATUS_BIT) && chg->lpd_stage == LPD_STAGE_NONE) { chg->lpd_stage = LPD_STAGE_FLOAT; cancel_delayed_work_sync(&chg->lpd_ra_open_work); vote(chg->awake_votable, LPD_VOTER, true, 0); schedule_delayed_work(&chg->lpd_ra_open_work, msecs_to_jiffies(300)); } } irqreturn_t 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; #ifndef OPLUS_FEATURE_CHG_BASIC u8 stat; int rc; #endif smblib_dbg(chg, PR_INTERRUPT, "IRQ: %s\n", irq_data->name); if (chg->connector_type == POWER_SUPPLY_CONNECTOR_MICRO_USB) { if (chg->uusb_moisture_protection_enabled) { /* * Adding pm_stay_awake as because pm_relax is called * on exit path from the work routine. */ pm_stay_awake(chg->dev); schedule_work(&chg->moisture_protection_work); } cancel_delayed_work_sync(&chg->uusb_otg_work); /* * Skip OTG enablement if RID interrupt triggers with moisture * protection still enabled. */ if (!chg->moisture_present) { vote(chg->awake_votable, OTG_DELAY_VOTER, true, 0); smblib_dbg(chg, PR_INTERRUPT, "Scheduling OTG work\n"); schedule_delayed_work(&chg->uusb_otg_work, msecs_to_jiffies(chg->otg_delay_ms)); } goto out; } if (chg->pr_swap_in_progress || chg->pd_hard_reset) goto out; #ifdef OPLUS_FEATURE_CHG_BASIC smblib_lpd_launch_ra_open_work(chg); #else rc = smblib_read(chg, TYPE_C_MISC_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read TYPE_C_MISC_STATUS_REG rc=%d\n", rc); goto out; } if (!(stat & TYPEC_TCCDEBOUNCE_DONE_STATUS_BIT) && chg->lpd_stage == LPD_STAGE_NONE) { chg->lpd_stage = LPD_STAGE_FLOAT; cancel_delayed_work_sync(&chg->lpd_ra_open_work); vote(chg->awake_votable, LPD_VOTER, true, 0); schedule_delayed_work(&chg->lpd_ra_open_work, msecs_to_jiffies(300)); } #endif if (chg->usb_psy) power_supply_changed(chg->usb_psy); out: return IRQ_HANDLED; } irqreturn_t 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; #ifdef OPLUS_CUSTOM_OP_DEF int rc; int wireless_present = 0; union power_supply_propval pval; #endif #ifdef OPLUS_FEATURE_CHG_BASIC bool current_status = 0; static bool dfp_status = 0; struct oplus_chg_chip *chip = g_oplus_chip; #endif if (chg->connector_type == POWER_SUPPLY_CONNECTOR_MICRO_USB) { smblib_dbg(chg, PR_INTERRUPT, "Ignoring for micro USB\n"); return IRQ_HANDLED; } if(oplus_chg_get_voocphy_support() == NO_VOOCPHY && oplus_vooc_get_fastchg_to_normal() == true) { chg_err("Ignoring for svooc\n"); return IRQ_HANDLED; } #ifdef OPLUS_CUSTOM_OP_DEF if (!chg->wls_psy) chg->wls_psy = power_supply_get_by_name("wireless"); if (chg->wls_psy) { rc = power_supply_get_property(chg->wls_psy, POWER_SUPPLY_PROP_PRESENT, &pval); if (rc < 0) smblib_err(chg, "Couldn't get wireless present rc=%d\n", rc); else wireless_present = pval.intval; } else { smblib_err(chg, "Couldn't find wireless psy\n"); } #endif typec_mode = smblib_get_prop_typec_mode(chg); if (chg->sink_src_mode != UNATTACHED_MODE && (typec_mode != chg->typec_mode)) smblib_handle_rp_change(chg, typec_mode); chg->typec_mode = typec_mode; #ifdef OPLUS_CUSTOM_OP_DEF if (wireless_present) { if (typec_mode == POWER_SUPPLY_TYPEC_NONE) // If nothing connected enable bypass vsafe for OTG detection smblib_bypass_vsafe0_control(chg, 1); else // Disable Bypass vsafe after cc detection smblib_bypass_vsafe0_control(chg, 0); } else { smblib_bypass_vsafe0_control(chg, 0); } #endif #ifdef OPLUS_FEATURE_CHG_BASIC//Fanhong.Kong@ProDrv.CHG,add 2018/06/02 for SVOOC OTG if (oplus_is_use_external_boost() || (chip->vbatt_num == 2)) { if (chg->typec_mode == POWER_SUPPLY_TYPEC_SINK || chg->typec_mode == POWER_SUPPLY_TYPEC_SINK_POWERED_CABLE) { pr_info("%s: chg->typec_mode = SINK,Disable APSD!\n", __func__); smblib_apsd_enable(chg, false); } } #endif/*OPLUS_FEATURE_CHG_BASIC*/ #ifdef OPLUS_FEATURE_CHG_BASIC current_status = (chg->typec_mode >= POWER_SUPPLY_TYPEC_SINK && chg->typec_mode <= POWER_SUPPLY_TYPEC_POWERED_CABLE_ONLY); if (dfp_status ^ current_status) { dfp_status = current_status; printk(KERN_ERR "!!!!! smblib_handle_typec_cc_state_change: [%d], mode[%d]\n", dfp_status, chg->typec_mode); } if (chg->typec_mode != POWER_SUPPLY_TYPEC_NONE) { oplus_wake_up_usbtemp_thread(); } else { if (chip) chip->usbtemp_check = oplus_usbtemp_condition(); } #endif #ifdef OPLUS_FEATURE_CHG_BASIC if (chg->typec_present == false && gpio_get_value(chg->ccdetect_gpio) == 1) if (oplus_ccdetect_get_power_role() != POWER_SUPPLY_TYPEC_PR_SINK && oplus_get_otg_switch_status() == false) oplus_ccdetect_disable(); #endif #ifdef OPLUS_FEATURE_CHG_BASIC if (chg->typec_mode != POWER_SUPPLY_TYPEC_NONE) { cancel_delayed_work(&chg->typec_disable_cmd_work); } #endif smblib_dbg(chg, PR_INTERRUPT, "IRQ: cc-state-change; Type-C %s detected\n", smblib_typec_mode_name[chg->typec_mode]); power_supply_changed(chg->usb_psy); return IRQ_HANDLED; } static void smblib_lpd_clear_ra_open_work(struct smb_charger *chg) { if (chg->lpd_disabled) return; cancel_delayed_work_sync(&chg->lpd_detach_work); chg->lpd_stage = LPD_STAGE_FLOAT_CANCEL; cancel_delayed_work_sync(&chg->lpd_ra_open_work); vote(chg->awake_votable, LPD_VOTER, false, 0); } irqreturn_t 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; smblib_dbg(chg, PR_INTERRUPT, "IRQ: %s\n", irq_data->name); rc = smblib_read(chg, TYPE_C_STATE_MACHINE_STATUS_REG, &stat); if (rc < 0) { smblib_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) { #ifdef OPLUS_FEATURE_CHG_BASIC smblib_lpd_clear_ra_open_work(chg); #else cancel_delayed_work_sync(&chg->lpd_detach_work); chg->lpd_stage = LPD_STAGE_FLOAT_CANCEL; cancel_delayed_work_sync(&chg->lpd_ra_open_work); vote(chg->awake_votable, LPD_VOTER, false, 0); #endif rc = smblib_read(chg, TYPE_C_MISC_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read TYPE_C_MISC_STATUS_REG rc=%d\n", rc); return IRQ_HANDLED; } if (smblib_get_prop_dfp_mode(chg) == 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) { if (smblib_src_lpd(chg)) return IRQ_HANDLED; chg->sink_src_mode = SRC_MODE; typec_sink_insertion(chg); } else { chg->sink_src_mode = SINK_MODE; typec_src_insertion(chg); } } 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->ok_to_pd = false; chg->sink_src_mode = UNATTACHED_MODE; chg->early_usb_attach = false; smblib_apsd_enable(chg, true); } if (chg->lpd_stage == LPD_STAGE_FLOAT_CANCEL) schedule_delayed_work(&chg->lpd_detach_work, msecs_to_jiffies(1000)); } rc = smblib_masked_write(chg, USB_CMD_PULLDOWN_REG, EN_PULLDOWN_USB_IN_BIT, attached ? 0 : EN_PULLDOWN_USB_IN_BIT); if (rc < 0) smblib_err(chg, "Couldn't configure pulldown on USB_IN rc=%d\n", rc); power_supply_changed(chg->usb_psy); return IRQ_HANDLED; } static void dcin_aicl(struct smb_charger *chg) { int rc, icl, icl_save; int input_present; bool aicl_done = true; /* * Hold awake votable to prevent pm_relax being called prior to * completion of this work. */ vote(chg->awake_votable, DCIN_AICL_VOTER, true, 0); increment: mutex_lock(&chg->dcin_aicl_lock); rc = smblib_get_charge_param(chg, &chg->param.dc_icl, &icl); if (rc < 0) goto err; if (icl == chg->wls_icl_ua) { /* Upper limit reached; do nothing */ smblib_dbg(chg, PR_WLS, "hit max ICL: stop\n"); rc = smblib_is_input_present(chg, &input_present); if (rc < 0 || !(input_present & INPUT_PRESENT_DC)) aicl_done = false; goto unlock; } icl = min(chg->wls_icl_ua, icl + DCIN_ICL_STEP_UA); icl_save = icl; rc = smblib_set_charge_param(chg, &chg->param.dc_icl, icl); if (rc < 0) goto err; mutex_unlock(&chg->dcin_aicl_lock); smblib_dbg(chg, PR_WLS, "icl: %d mA\n", (icl / 1000)); /* Check to see if DC is still present before and after sleep */ rc = smblib_is_input_present(chg, &input_present); if (rc < 0 || !(input_present & INPUT_PRESENT_DC)) { aicl_done = false; goto unvote; } /* * Wait awhile to check for any DCIN_UVs (the UV handler reduces the * ICL). If the adaptor collapses, the ICL read after waking up will be * lesser, indicating that the AICL process is complete. */ msleep(500); rc = smblib_is_input_present(chg, &input_present); if (rc < 0 || !(input_present & INPUT_PRESENT_DC)) { aicl_done = false; goto unvote; } mutex_lock(&chg->dcin_aicl_lock); rc = smblib_get_charge_param(chg, &chg->param.dc_icl, &icl); if (rc < 0) goto err; if (icl < icl_save) { smblib_dbg(chg, PR_WLS, "done: icl: %d mA\n", (icl / 1000)); goto unlock; } mutex_unlock(&chg->dcin_aicl_lock); goto increment; err: aicl_done = false; unlock: mutex_unlock(&chg->dcin_aicl_lock); unvote: vote(chg->awake_votable, DCIN_AICL_VOTER, false, 0); chg->dcin_aicl_done = aicl_done; } static void dcin_aicl_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, dcin_aicl_work); dcin_aicl(chg); } static enum alarmtimer_restart dcin_aicl_alarm_cb(struct alarm *alarm, ktime_t now) { struct smb_charger *chg = container_of(alarm, struct smb_charger, dcin_aicl_alarm); smblib_dbg(chg, PR_WLS, "rerunning DCIN AICL\n"); pm_stay_awake(chg->dev); schedule_work(&chg->dcin_aicl_work); return ALARMTIMER_NORESTART; } static void dcin_icl_decrement(struct smb_charger *chg) { int rc, icl; ktime_t now = ktime_get(); rc = smblib_get_charge_param(chg, &chg->param.dc_icl, &icl); if (rc < 0) { smblib_err(chg, "reading DCIN ICL failed: %d\n", rc); return; } if (icl == DCIN_ICL_MIN_UA) { /* Cannot possibly decrease ICL any further - do nothing */ smblib_dbg(chg, PR_WLS, "hit min ICL: stop\n"); return; } /* Reduce ICL by 100 mA if 3 UVs happen in a row */ if (ktime_us_delta(now, chg->dcin_uv_last_time) > (200 * 1000)) { chg->dcin_uv_count = 0; } else if (chg->dcin_uv_count >= 3) { icl -= DCIN_ICL_STEP_UA; smblib_dbg(chg, PR_WLS, "icl: %d mA\n", (icl / 1000)); rc = smblib_set_charge_param(chg, &chg->param.dc_icl, icl); if (rc < 0) { smblib_err(chg, "setting DCIN ICL failed: %d\n", rc); return; } chg->dcin_uv_count = 0; } chg->dcin_uv_last_time = now; } irqreturn_t dcin_uv_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; mutex_lock(&chg->dcin_aicl_lock); chg->dcin_uv_count++; smblib_dbg(chg, (PR_WLS | PR_INTERRUPT), "DCIN UV count: %d\n", chg->dcin_uv_count); dcin_icl_decrement(chg); mutex_unlock(&chg->dcin_aicl_lock); return IRQ_HANDLED; } static bool is_cp_topo_vbatt(struct smb_charger *chg) { int rc; bool is_vbatt; union power_supply_propval pval; if (!is_cp_available(chg)) return false; rc = power_supply_get_property(chg->cp_psy, POWER_SUPPLY_PROP_PARALLEL_OUTPUT_MODE, &pval); if (rc < 0) return false; is_vbatt = (pval.intval == POWER_SUPPLY_PL_OUTPUT_VBAT); smblib_dbg(chg, PR_WLS, "%s\n", is_vbatt ? "true" : "false"); return is_vbatt; } irqreturn_t dc_plugin_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; int input_present; bool dcin_present, vbus_present; int rc, wireless_vout = 0; int sec_charger; #ifdef OPLUS_CUSTOM_OP_DEF if (chg->wireless_present) { pr_info("Do not use the following process when wireless charging\n"); return IRQ_HANDLED; } #endif rc = smblib_get_prop_vph_voltage_now(chg, &pval); if (rc < 0) return IRQ_HANDLED; /* 2*VPH, with a granularity of 100mV */ wireless_vout = ((pval.intval * 2) / 100000) * 100000; rc = smblib_is_input_present(chg, &input_present); if (rc < 0) return IRQ_HANDLED; dcin_present = input_present & INPUT_PRESENT_DC; vbus_present = input_present & INPUT_PRESENT_USB; if (!chg->cp_ilim_votable) chg->cp_ilim_votable = find_votable("CP_ILIM"); if (dcin_present && !vbus_present) { cancel_work_sync(&chg->dcin_aicl_work); /* Reset DCIN ICL to 100 mA */ mutex_lock(&chg->dcin_aicl_lock); rc = smblib_set_charge_param(chg, &chg->param.dc_icl, DCIN_ICL_MIN_UA); mutex_unlock(&chg->dcin_aicl_lock); if (rc < 0) return IRQ_HANDLED; smblib_dbg(chg, (PR_WLS | PR_INTERRUPT), "reset: icl: 100 mA\n"); /* * Remove USB's CP ILIM vote - inapplicable for wireless * parallel charging. Also undo FCC STEPPER's 1.5 A vote. */ vote(chg->fcc_votable, FCC_STEPPER_VOTER, false, 0); if (chg->cp_ilim_votable) vote(chg->cp_ilim_votable, ICL_CHANGE_VOTER, false, 0); if (chg->sec_cp_present) { /* * If CP output topology is VBATT, limit main charger's * FCC share and let the CPs handle the rest. */ if (is_cp_topo_vbatt(chg)) vote(chg->fcc_main_votable, WLS_PL_CHARGING_VOTER, true, 800000); pval.intval = wireless_vout; rc = smblib_set_prop_voltage_wls_output(chg, &pval); if (rc < 0) dev_err(chg->dev, "Couldn't set dc voltage to 2*vph rc=%d\n", rc); rc = smblib_select_sec_charger(chg, POWER_SUPPLY_CHARGER_SEC_CP, POWER_SUPPLY_CP_WIRELESS, false); if (rc < 0) dev_err(chg->dev, "Couldn't enable secondary chargers rc=%d\n", rc); } else { /* * If no secondary charger is present, commence * wireless charging at 5 V by default. */ pval.intval = 5000000; rc = smblib_set_prop_voltage_wls_output(chg, &pval); if (rc < 0) dev_err(chg->dev, "Couldn't set dc voltage to 5 V rc=%d\n", rc); } schedule_work(&chg->dcin_aicl_work); } else { if (chg->cp_reason == POWER_SUPPLY_CP_WIRELESS) { sec_charger = chg->sec_pl_present ? POWER_SUPPLY_CHARGER_SEC_PL : POWER_SUPPLY_CHARGER_SEC_NONE; rc = smblib_select_sec_charger(chg, sec_charger, POWER_SUPPLY_CP_NONE, false); if (rc < 0) dev_err(chg->dev, "Couldn't disable secondary charger rc=%d\n", rc); } vote(chg->dc_suspend_votable, CHG_TERMINATION_VOTER, false, 0); vote(chg->fcc_main_votable, WLS_PL_CHARGING_VOTER, false, 0); /* Force 1500mA FCC on WLS removal if fcc stepper is enabled */ if (chg->fcc_stepper_enable) vote(chg->fcc_votable, FCC_STEPPER_VOTER, true, 3000000); chg->last_wls_vout = 0; chg->dcin_aicl_done = false; } #ifdef OPLUS_FEATURE_CHG_BASIC if (chg->dc_psy) #endif power_supply_changed(chg->dc_psy); #ifdef OPLUS_FEATURE_CHG_BASIC printk(KERN_ERR "!!!!! dc_plugin_irq_handler: dcin_present[%d], usbin_present[%d], cp_reason[%d]\n", dcin_present, vbus_present, chg->cp_reason); #else smblib_dbg(chg, (PR_WLS | PR_INTERRUPT), "dcin_present= %d, usbin_present= %d, cp_reason = %d\n", dcin_present, vbus_present, chg->cp_reason); #endif return IRQ_HANDLED; } irqreturn_t high_duty_cycle_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; chg->is_hdc = true; /* * Disable usb IRQs after the flag set and re-enable IRQs after * the flag cleared in the delayed work queue, to avoid any IRQ * storming during the delays */ vote(chg->hdc_irq_disable_votable, HDC_IRQ_VOTER, true, 0); schedule_delayed_work(&chg->clear_hdc_work, msecs_to_jiffies(60)); return IRQ_HANDLED; } static void smblib_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 #ifdef OPLUS_FEATURE_CHG_BASIC #define WEAK_CHG_STORM_COUNT 3 #else #define WEAK_CHG_STORM_COUNT 8 #endif irqreturn_t switcher_power_ok_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; #ifndef OPLUS_FEATURE_CHG_BASIC struct storm_watch *wdata = &irq_data->storm_data; #endif int rc, usb_icl; u8 stat; chg_err("power_ok irq happened"); if (!(chg->wa_flags & BOOST_BACK_WA)) return IRQ_HANDLED; rc = smblib_read(chg, POWER_PATH_STATUS_REG, &stat); if (rc < 0) { smblib_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_25MA) return IRQ_HANDLED; if (stat & USE_DCIN_BIT) return IRQ_HANDLED; if (is_storming(&irq_data->storm_data)) { #ifndef OPLUS_FEATURE_CHG_BASIC /* This could be a weak charger reduce ICL */ if (!is_client_vote_enabled(chg->usb_icl_votable, WEAK_CHARGER_VOTER)) { smblib_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 { smblib_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)); } #else if (printk_ratelimit()) smblib_err(chg, "Reverse boost detected: voting 0mA to suspend input\n"); if (chg->real_charger_type != POWER_SUPPLY_TYPE_USB_CDP && chg->real_charger_type != POWER_SUPPLY_TYPE_USB #ifdef OPLUS_CUSTOM_OP_DEF && !chg->wireless_present #endif ) vote(chg->usb_icl_votable, BOOST_BACK_VOTER, true, 0); #endif /* OPLUS_FEATURE_CHG_BASIC */ } return IRQ_HANDLED; } irqreturn_t wdog_snarl_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; smblib_dbg(chg, PR_INTERRUPT, "IRQ: %s\n", irq_data->name); if (chg->wa_flags & SW_THERM_REGULATION_WA) { cancel_delayed_work_sync(&chg->thermal_regulation_work); vote(chg->awake_votable, SW_THERM_REGULATION_VOTER, true, 0); schedule_delayed_work(&chg->thermal_regulation_work, 0); } if (chg->step_chg_enabled) power_supply_changed(chg->batt_psy); return IRQ_HANDLED; } irqreturn_t 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; smblib_dbg(chg, PR_INTERRUPT, "IRQ: %s\n", irq_data->name); rc = smblib_write(chg, BARK_BITE_WDOG_PET_REG, BARK_BITE_WDOG_PET_BIT); if (rc < 0) smblib_err(chg, "Couldn't pet the dog rc=%d\n", rc); return IRQ_HANDLED; } static void smblib_die_rst_icl_regulate(struct smb_charger *chg) { int rc; u8 temp; rc = smblib_read(chg, DIE_TEMP_STATUS_REG, &temp); if (rc < 0) { smblib_err(chg, "Couldn't read DIE_TEMP_STATUS_REG rc=%d\n", rc); return; } /* Regulate ICL on die temp crossing DIE_RST threshold */ vote(chg->usb_icl_votable, DIE_TEMP_VOTER, temp & DIE_TEMP_RST_BIT, 500000); } /* * triggered when DIE or SKIN or CONNECTOR temperature across * either of the _REG_L, _REG_H, _RST, or _SHDN thresholds */ irqreturn_t temp_change_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; smblib_die_rst_icl_regulate(chg); return IRQ_HANDLED; } static void smblib_usbov_dbc_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, usbov_dbc_work.work); smblib_dbg(chg, PR_MISC, "Resetting USBOV debounce\n"); chg->dbc_usbov = false; vote(chg->awake_votable, USBOV_DBC_VOTER, false, 0); } #define USB_OV_DBC_PERIOD_MS 1000 irqreturn_t usbin_ov_irq_handler(int irq, void *data) { struct smb_irq_data *irq_data = data; struct smb_charger *chg = irq_data->parent_data; u8 stat; int rc; smblib_dbg(chg, PR_INTERRUPT, "IRQ: %s\n", irq_data->name); if (!(chg->wa_flags & USBIN_OV_WA)) return IRQ_HANDLED; rc = smblib_read(chg, USBIN_BASE + INT_RT_STS_OFFSET, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read USB_INT_RT_STS rc=%d\n", rc); return IRQ_HANDLED; } /* * On specific PMICs, OV IRQ triggers for very small duration in * interim periods affecting charging status reflection. In order to * differentiate between OV IRQ glitch and real OV_IRQ, add a debounce * period for evaluation. */ if (stat & USBIN_OV_RT_STS_BIT) { chg->dbc_usbov = true; vote(chg->awake_votable, USBOV_DBC_VOTER, true, 0); schedule_delayed_work(&chg->usbov_dbc_work, msecs_to_jiffies(USB_OV_DBC_PERIOD_MS)); } else { cancel_delayed_work_sync(&chg->usbov_dbc_work); chg->dbc_usbov = false; vote(chg->awake_votable, USBOV_DBC_VOTER, false, 0); } smblib_dbg(chg, PR_MISC, "USBOV debounce status %d\n", chg->dbc_usbov); return IRQ_HANDLED; } /************** * Additional USB PSY getters/setters * that call interrupt functions ***************/ int smblib_get_prop_pr_swap_in_progress(struct smb_charger *chg, union power_supply_propval *val) { val->intval = chg->pr_swap_in_progress; return 0; } #define DETACH_DETECT_DELAY_MS 20 int smblib_set_prop_pr_swap_in_progress(struct smb_charger *chg, const union power_supply_propval *val) { int rc; u8 stat = 0, orientation; #ifdef OPLUS_FEATURE_CHG_BASIC u8 reg_val = 0; int level = 0; struct oplus_chg_chip *chip = g_oplus_chip; #endif smblib_dbg(chg, PR_MISC, "Requested PR_SWAP %d\n", val->intval); chg->pr_swap_in_progress = val->intval; /* check for cable removal during pr_swap */ if (!chg->pr_swap_in_progress) { cancel_delayed_work_sync(&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(DETACH_DETECT_DELAY_MS)); } rc = smblib_masked_write(chg, TYPE_C_DEBOUNCE_OPTION_REG, REDUCE_TCCDEBOUNCE_TO_2MS_BIT, val->intval ? REDUCE_TCCDEBOUNCE_TO_2MS_BIT : 0); if (rc < 0) smblib_err(chg, "Couldn't set tCC debounce rc=%d\n", rc); #ifdef OPLUS_CUSTOM_OP_DEF if (!chg->wireless_present) { #endif rc = smblib_masked_write(chg, TYPE_C_EXIT_STATE_CFG_REG, BYPASS_VSAFE0V_DURING_ROLE_SWAP_BIT, val->intval ? BYPASS_VSAFE0V_DURING_ROLE_SWAP_BIT : 0); if (rc < 0) smblib_err(chg, "Couldn't set exit state cfg rc=%d\n", rc); #ifdef OPLUS_CUSTOM_OP_DEF } #endif if (chg->pr_swap_in_progress) { rc = smblib_read(chg, TYPE_C_MISC_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read TYPE_C_STATUS_4 rc=%d\n", rc); } orientation = stat & CC_ORIENTATION_BIT ? TYPEC_CCOUT_VALUE_BIT : 0; rc = smblib_masked_write(chg, TYPE_C_CCOUT_CONTROL_REG, TYPEC_CCOUT_SRC_BIT | TYPEC_CCOUT_BUFFER_EN_BIT | TYPEC_CCOUT_VALUE_BIT, TYPEC_CCOUT_SRC_BIT | TYPEC_CCOUT_BUFFER_EN_BIT | orientation); if (rc < 0) { smblib_err(chg, "Couldn't read TYPE_C_CCOUT_CONTROL_REG rc=%d\n", rc); } } else { rc = smblib_masked_write(chg, TYPE_C_CCOUT_CONTROL_REG, TYPEC_CCOUT_SRC_BIT, 0); if (rc < 0) { smblib_err(chg, "Couldn't read TYPE_C_CCOUT_CONTROL_REG rc=%d\n", rc); } #ifdef OPLUS_FEATURE_CHG_BASIC rc = smblib_read(chg, TYPE_C_STATE_MACHINE_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read TYPE_C_STATE_MACHINE_STATUS_REG rc=%d\n",rc); } if(oplus_ccdetect_check_is_gpio(chip) == true) { level = gpio_get_value(chg->ccdetect_gpio); if(!(stat & TYPEC_ATTACH_DETACH_STATE_BIT) && (chip->otg_switch != true) && (level == 1)){ reg_val = EN_SNK_ONLY_BIT; } }else { if(!(stat & TYPEC_ATTACH_DETACH_STATE_BIT) && (chip->otg_switch != true)){ reg_val = EN_SNK_ONLY_BIT; } } smblib_err(chg, " reg_val=%d stat =0x%x level =%d chip->otg_switch=%d\n",reg_val,stat,level,chip->otg_switch); if((oplus_get_usb_status() & USB_TEMP_HIGH) != 0){ reg_val = EN_SNK_ONLY_BIT; } /* enable DRP */ if (reg_val != 0) rc = smblib_masked_write(chg, TYPE_C_MODE_CFG_REG, TYPEC_POWER_ROLE_CMD_MASK, reg_val); #endif if (rc < 0) { smblib_err(chg, "Couldn't enable DRP rc=%d\n", rc); return rc; } chg->power_role = POWER_SUPPLY_TYPEC_PR_DUAL; smblib_dbg(chg, PR_MISC, "restore power role: %d\n", chg->power_role); } return 0; } /*************** * Work Queues * ***************/ static void smblib_pr_lock_clear_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, pr_lock_clear_work.work); spin_lock(&chg->typec_pr_lock); if (chg->pr_lock_in_progress) { smblib_dbg(chg, PR_MISC, "restore type-c interrupts\n"); smblib_typec_irq_config(chg, true); chg->pr_lock_in_progress = false; } spin_unlock(&chg->typec_pr_lock); } #ifdef OPLUS_FEATURE_CHG_BASIC static void oplus_ccdetect_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, ccdetect_work.work); int level; level = gpio_get_value(chg->ccdetect_gpio); if (level != 1) { oplus_ccdetect_enable(); oplus_wake_up_usbtemp_thread(); } else { oplus_chg_clear_abnormal_adapter_var(); if (oplus_ccdetect_get_power_role() != POWER_SUPPLY_TYPEC_PR_SINK && oplus_get_otg_switch_status() == false) oplus_ccdetect_disable(); #ifdef OPLUS_FEATURE_CHG_BASIC if (g_oplus_chip) g_oplus_chip->usbtemp_check = oplus_usbtemp_condition(); #endif if(g_oplus_chip && g_oplus_chip->usb_status == USB_TEMP_HIGH) { schedule_delayed_work(&usbtemp_recover_work, 0); } #ifdef OPLUS_CUSTOM_OP_DEF cancel_delayed_work_sync(&chg->recovery_suspend_work); smblib_set_usb_suspend(chg, true); schedule_delayed_work(&chg->recovery_suspend_work, REC_SUSPEND_WORK_SCH_DELAY); #endif } #ifdef OPLUS_CUSTOM_OP_DEF if (g_oplus_chip->hiz_gnd_cable) { g_oplus_chip->svooc_disconnect_count = 0; g_oplus_chip->icon_debounce = false; g_oplus_chip->cool_down_bck = 0; } #endif vote(chg->awake_votable, CCDETECT_VOTER, false, 0); } void oplus_usbtemp_recover_work(struct work_struct *work) { struct oplus_chg_chip *chip = g_oplus_chip; if (!chip) { return; } oplus_usbtemp_recover_func(g_oplus_chip); } #endif /* OPLUS_FEATURE_CHG_BASIC */ static void smblib_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 = smblib_read(chg, TYPE_C_STATE_MACHINE_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read STATE_MACHINE_STS rc=%d\n", rc); goto out; } smblib_dbg(chg, PR_REGISTER, "STATE_MACHINE_STS %x\n", stat); if (!(stat & TYPEC_ATTACH_DETACH_STATE_BIT)) { rc = smblib_request_dpdm(chg, false); if (rc < 0) smblib_err(chg, "Couldn't disable DPDM rc=%d\n", rc); } out: vote(chg->awake_votable, DETACH_DETECT_VOTER, false, 0); } static void smblib_uusb_otg_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, uusb_otg_work.work); int rc; u8 stat; bool otg; rc = smblib_read(chg, TYPEC_U_USB_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read TYPE_C_STATUS_3 rc=%d\n", rc); goto out; } otg = !!(stat & U_USB_GROUND_NOVBUS_BIT); if (chg->otg_present != otg) smblib_notify_usb_host(chg, otg); else goto out; chg->otg_present = otg; if (!otg) chg->boost_current_ua = 0; rc = smblib_set_charge_param(chg, &chg->param.freq_switcher, otg ? chg->chg_freq.freq_below_otg_threshold : chg->chg_freq.freq_removal); if (rc < 0) dev_err(chg->dev, "Error in setting freq_boost rc=%d\n", rc); smblib_dbg(chg, PR_REGISTER, "TYPE_C_U_USB_STATUS = 0x%02x OTG=%d\n", stat, otg); power_supply_changed(chg->usb_psy); out: vote(chg->awake_votable, OTG_DELAY_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); smblib_suspend_on_debug_battery(chg); if (chg->batt_psy) power_supply_changed(chg->batt_psy); } static void pl_update_work(struct work_struct *work) { union power_supply_propval prop_val; struct smb_charger *chg = container_of(work, struct smb_charger, pl_update_work); int rc; if (chg->smb_temp_max == -EINVAL) { rc = smblib_get_thermal_threshold(chg, SMB_REG_H_THRESHOLD_MSB_REG, &chg->smb_temp_max); if (rc < 0) { dev_err(chg->dev, "Couldn't get charger_temp_max rc=%d\n", rc); return; } } prop_val.intval = chg->smb_temp_max; rc = power_supply_set_property(chg->pl.psy, POWER_SUPPLY_PROP_CHARGER_TEMP_MAX, &prop_val); if (rc < 0) { dev_err(chg->dev, "Couldn't set POWER_SUPPLY_PROP_CHARGER_TEMP_MAX rc=%d\n", rc); return; } if (chg->sec_chg_selected == POWER_SUPPLY_CHARGER_SEC_CP) return; smblib_select_sec_charger(chg, POWER_SUPPLY_CHARGER_SEC_PL, POWER_SUPPLY_CP_NONE, false); } static void clear_hdc_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, clear_hdc_work.work); chg->is_hdc = false; vote(chg->hdc_irq_disable_votable, HDC_IRQ_VOTER, false, 0); } static void smblib_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 = smblib_get_charge_param(chg, &chg->param.icl_stat, &settled_ua); if (rc < 0) { smblib_err(chg, "Couldn't get ICL status rc=%d\n", rc); return; } power_supply_changed(chg->usb_main_psy); smblib_dbg(chg, PR_INTERRUPT, "icl_settled=%d\n", settled_ua); } static void smblib_pl_enable_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, pl_enable_work.work); smblib_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 smblib_thermal_regulation_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, thermal_regulation_work.work); int rc; rc = smblib_update_thermal_readings(chg); if (rc < 0) smblib_err(chg, "Couldn't read current thermal values %d\n", rc); rc = smblib_process_thermal_readings(chg); if (rc < 0) smblib_err(chg, "Couldn't run sw thermal regulation %d\n", rc); } #define MOISTURE_PROTECTION_CHECK_DELAY_MS 300000 /* 5 mins */ static void smblib_moisture_protection_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, moisture_protection_work); int rc; bool usb_plugged_in; u8 stat; /* * Hold awake votable to prevent pm_relax being called prior to * completion of this work. */ vote(chg->awake_votable, MOISTURE_VOTER, true, 0); /* * Disable 1% duty cycle on CC_ID pin and enable uUSB factory mode * detection to track any change on RID, as interrupts are disable. */ rc = smblib_write(chg, ((chg->chg_param.smb_version == PMI632_SUBTYPE) ? PMI632_TYPEC_U_USB_WATER_PROTECTION_CFG_REG : TYPEC_U_USB_WATER_PROTECTION_CFG_REG), 0); if (rc < 0) { smblib_err(chg, "Couldn't disable periodic monitoring of CC_ID rc=%d\n", rc); goto out; } rc = smblib_masked_write(chg, TYPEC_U_USB_CFG_REG, EN_MICRO_USB_FACTORY_MODE_BIT, EN_MICRO_USB_FACTORY_MODE_BIT); if (rc < 0) { smblib_err(chg, "Couldn't enable uUSB factory mode detection rc=%d\n", rc); goto out; } /* * Add a delay of 100ms to allow change in rid to reflect on * status registers. */ msleep(100); rc = smblib_read(chg, USBIN_BASE + INT_RT_STS_OFFSET, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read USB_INT_RT_STS rc=%d\n", rc); goto out; } usb_plugged_in = (bool)(stat & USBIN_PLUGIN_RT_STS_BIT); /* Check uUSB status for moisture presence */ rc = smblib_read(chg, TYPEC_U_USB_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read TYPE_C_U_USB_STATUS_REG rc=%d\n", rc); goto out; } /* * Factory mode detection happens in case of USB plugged-in by using * a different current source of 2uA which can hamper moisture * detection. Since factory mode is not supported in kernel, factory * mode detection can be considered as equivalent to presence of * moisture. */ if (stat == U_USB_STATUS_WATER_PRESENT || stat == U_USB_FMB1_BIT || stat == U_USB_FMB2_BIT || (usb_plugged_in && stat == U_USB_FLOAT1_BIT)) { smblib_set_moisture_protection(chg, true); if(get_boot_mode() != MSM_BOOT_MODE__FACTORY) alarm_start_relative(&chg->moisture_protection_alarm, ms_to_ktime(MOISTURE_PROTECTION_CHECK_DELAY_MS)); } else { smblib_set_moisture_protection(chg, false); rc = alarm_cancel(&chg->moisture_protection_alarm); if (rc < 0) smblib_err(chg, "Couldn't cancel moisture protection alarm\n"); } out: vote(chg->awake_votable, MOISTURE_VOTER, false, 0); } static enum alarmtimer_restart moisture_protection_alarm_cb(struct alarm *alarm, ktime_t now) { struct smb_charger *chg = container_of(alarm, struct smb_charger, moisture_protection_alarm); smblib_dbg(chg, PR_MISC, "moisture Protection Alarm Triggered %lld\n", ktime_to_ms(now)); /* Atomic context, cannot use voter */ pm_stay_awake(chg->dev); schedule_work(&chg->moisture_protection_work); return ALARMTIMER_NORESTART; } static void smblib_chg_termination_work(struct work_struct *work) { union power_supply_propval pval; struct smb_charger *chg = container_of(work, struct smb_charger, chg_termination_work); int rc, input_present, delay = CHG_TERM_WA_ENTRY_DELAY_MS; /* * Hold awake votable to prevent pm_relax being called prior to * completion of this work. */ vote(chg->awake_votable, CHG_TERMINATION_VOTER, true, 0); rc = smblib_is_input_present(chg, &input_present); if ((rc < 0) || !input_present) goto out; rc = smblib_get_prop_from_bms(chg, POWER_SUPPLY_PROP_REAL_CAPACITY, &pval); if ((rc < 0) || (pval.intval < 100)) { vote(chg->usb_icl_votable, CHG_TERMINATION_VOTER, false, 0); vote(chg->dc_suspend_votable, CHG_TERMINATION_VOTER, false, 0); goto out; } rc = smblib_get_prop_from_bms(chg, POWER_SUPPLY_PROP_CHARGE_FULL, &pval); if (rc < 0) goto out; /* * On change in the value of learned capacity, re-initialize the * reference cc_soc value due to change in cc_soc characteristic value * at full capacity. Also, in case cc_soc_ref value is reset, * re-initialize it. */ if (pval.intval != chg->charge_full_cc || !chg->cc_soc_ref) { chg->charge_full_cc = pval.intval; rc = smblib_get_prop_from_bms(chg, POWER_SUPPLY_PROP_CC_SOC, &pval); if (rc < 0) goto out; chg->cc_soc_ref = pval.intval; } else { rc = smblib_get_prop_from_bms(chg, POWER_SUPPLY_PROP_CC_SOC, &pval); if (rc < 0) goto out; } /* * In BSM a sudden jump in CC_SOC is not expected. If seen, its a * good_ocv or updated capacity, reject it. */ if (chg->last_cc_soc && pval.intval > (chg->last_cc_soc + 100)) { /* CC_SOC has increased by 1% from last time */ chg->cc_soc_ref = pval.intval; smblib_dbg(chg, PR_MISC, "cc_soc jumped(%d->%d), reset cc_soc_ref\n", chg->last_cc_soc, pval.intval); } chg->last_cc_soc = pval.intval; /* * Suspend/Unsuspend USB input to keep cc_soc within the 0.5% to 0.75% * overshoot range of the cc_soc value at termination, to prevent * overcharging. */ if (pval.intval < DIV_ROUND_CLOSEST(chg->cc_soc_ref * 10050, 10000)) { vote(chg->usb_icl_votable, CHG_TERMINATION_VOTER, false, 0); vote(chg->dc_suspend_votable, CHG_TERMINATION_VOTER, false, 0); delay = CHG_TERM_WA_ENTRY_DELAY_MS; } else if (pval.intval > DIV_ROUND_CLOSEST(chg->cc_soc_ref * 10075, 10000)) { if (input_present & INPUT_PRESENT_USB) vote(chg->usb_icl_votable, CHG_TERMINATION_VOTER, true, 0); if (input_present & INPUT_PRESENT_DC) vote(chg->dc_suspend_votable, CHG_TERMINATION_VOTER, true, 0); delay = CHG_TERM_WA_EXIT_DELAY_MS; } smblib_dbg(chg, PR_MISC, "Chg Term WA readings: cc_soc: %d, cc_soc_ref: %d, delay: %d\n", pval.intval, chg->cc_soc_ref, delay); alarm_start_relative(&chg->chg_termination_alarm, ms_to_ktime(delay)); out: vote(chg->awake_votable, CHG_TERMINATION_VOTER, false, 0); } static enum alarmtimer_restart chg_termination_alarm_cb(struct alarm *alarm, ktime_t now) { struct smb_charger *chg = container_of(alarm, struct smb_charger, chg_termination_alarm); smblib_dbg(chg, PR_MISC, "Charge termination WA alarm triggered %lld\n", ktime_to_ms(now)); /* Atomic context, cannot use voter */ pm_stay_awake(chg->dev); schedule_work(&chg->chg_termination_work); return ALARMTIMER_NORESTART; } 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]; batt_node = of_find_node_by_name(node, "qcom,battery-data"); if (!batt_node) { smblib_err(chg, "Batterydata not available\n"); goto out; } /* if BMS is not ready, defer the work */ if (!chg->bms_psy) return; rc = smblib_get_prop_from_bms(chg, POWER_SUPPLY_PROP_RESISTANCE_ID, &val); if (rc < 0) { smblib_err(chg, "Failed 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); smblib_err(chg, "Failed 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 = smblib_update_jeita(chg, jeita_hard_thresholds, JEITA_HARD); if (rc < 0) { smblib_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 = smblib_update_jeita(chg, chg->jeita_soft_thlds, JEITA_SOFT); if (rc < 0) { smblib_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) { smblib_err(chg, "Couldn't get Soft Jeita hysteresis thresholds rc=%d\n", rc); goto out; } } 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) { smblib_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) { smblib_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) { smblib_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) { smblib_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) { smblib_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 = smblib_soft_jeita_arb_wa(chg); if (rc < 0) { smblib_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 void smblib_lpd_ra_open_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, lpd_ra_open_work.work); union power_supply_propval pval; u8 stat; int rc; if (chg->pr_swap_in_progress || chg->pd_hard_reset) { chg->lpd_stage = LPD_STAGE_NONE; goto out; } if (chg->lpd_stage != LPD_STAGE_FLOAT) goto out; rc = smblib_read(chg, TYPE_C_MISC_STATUS_REG, &stat); if (rc < 0) { smblib_err(chg, "Couldn't read TYPE_C_MISC_STATUS_REG rc=%d\n", rc); goto out; } /* quit if moisture status is gone or in attached state */ if (!(stat & TYPEC_WATER_DETECTION_STATUS_BIT) || (stat & TYPEC_TCCDEBOUNCE_DONE_STATUS_BIT)) { chg->lpd_stage = LPD_STAGE_NONE; goto out; } chg->lpd_stage = LPD_STAGE_COMMIT; /* Enable source only mode */ pval.intval = POWER_SUPPLY_TYPEC_PR_SOURCE; rc = smblib_set_prop_typec_power_role(chg, &pval); if (rc < 0) { smblib_err(chg, "Couldn't set typec source only mode rc=%d\n", rc); goto out; } /* Wait 1.5ms to get SBUx ready */ usleep_range(1500, 1510); if (smblib_rsbux_low(chg, RSBU_K_300K_UV)) { /* Moisture detected, enable sink only mode */ pval.intval = POWER_SUPPLY_TYPEC_PR_SINK; rc = smblib_set_prop_typec_power_role(chg, &pval); if (rc < 0) { smblib_err(chg, "Couldn't set typec sink only rc=%d\n", rc); goto out; } chg->lpd_reason = LPD_MOISTURE_DETECTED; chg->moisture_present = true; vote(chg->usb_icl_votable, LPD_VOTER, true, 0); #ifdef OPLUS_FEATURE_CHG_BASIC smblib_err(chg, "%s: LPD_MOISTURE_DETECTED detected\n", __func__); if ((oplus_get_usb_status() & USB_WATER_DETECT) == 0 && g_oplus_chip) { oplus_vooc_set_disable_adapter_output(true); oplus_set_usb_status(USB_WATER_DETECT); power_supply_changed(g_oplus_chip->usb_psy); } #endif } else { /* Floating cable, disable water detection irq temporarily */ rc = smblib_masked_write(chg, TYPE_C_INTERRUPT_EN_CFG_2_REG, TYPEC_WATER_DETECTION_INT_EN_BIT, 0); if (rc < 0) { smblib_err(chg, "Couldn't set TYPE_C_INTERRUPT_EN_CFG_2_REG rc=%d\n", rc); goto out; } /* restore DRP mode */ pval.intval = POWER_SUPPLY_TYPEC_PR_DUAL; rc = smblib_set_prop_typec_power_role(chg, &pval); if (rc < 0) { smblib_err(chg, "Couldn't write 0x%02x to TYPE_C_INTRPT_ENB_SOFTWARE_CTRL rc=%d\n", pval.intval, rc); goto out; } chg->lpd_reason = LPD_FLOATING_CABLE; #ifdef OPLUS_FEATURE_CHG_BASIC smblib_err(chg, "%s: LPD_NONE detected\n", __func__); if ((oplus_get_usb_status() & USB_WATER_DETECT) != 0 && g_oplus_chip) { oplus_vooc_set_disable_adapter_output(false); oplus_clear_usb_status(USB_WATER_DETECT); power_supply_changed(g_oplus_chip->usb_psy); } #endif } /* recheck in 60 seconds */ if(get_boot_mode() != MSM_BOOT_MODE__FACTORY) alarm_start_relative(&chg->lpd_recheck_timer, ms_to_ktime(60000)); out: vote(chg->awake_votable, LPD_VOTER, false, 0); } static void smblib_lpd_detach_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, lpd_detach_work.work); if (chg->lpd_stage == LPD_STAGE_FLOAT_CANCEL) chg->lpd_stage = LPD_STAGE_NONE; } static void smblib_cp_status_change_work(struct work_struct *work) { int rc; union power_supply_propval pval; struct smb_charger *chg = container_of(work, struct smb_charger, cp_status_change_work); if (!chg->cp_psy) chg->cp_psy = power_supply_get_by_name("charge_pump_master"); if (!chg->cp_psy) goto relax; if (chg->cp_topo == -EINVAL) { rc = power_supply_get_property(chg->cp_psy, POWER_SUPPLY_PROP_PARALLEL_OUTPUT_MODE, &pval); if (rc < 0) { smblib_err(chg, "Couldn't read cp topo rc=%d\n", rc); goto relax; } chg->cp_topo = pval.intval; if (chg->cp_topo == POWER_SUPPLY_PL_OUTPUT_VBAT && chg->cp_reason == POWER_SUPPLY_CP_WIRELESS) vote(chg->fcc_main_votable, WLS_PL_CHARGING_VOTER, true, 800000); } relax: pm_relax(chg->dev); } #ifdef OPLUS_FEATURE_CHG_BASIC static void oplus_chargerid_switch_work(struct work_struct *work) { smbchg_set_chargerid_switch_val(0); return; } #ifndef OPLUS_CUSTOM_OP_DEF static void oplus_switch_to_wired_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, switch_to_wired_work.work); bool vbus_rising = 0; u8 stat = 0; int rc = 0; rc = smblib_read(chg, USBIN_BASE + INT_RT_STS_OFFSET, &stat); if (rc < 0) { smblib_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) { oplus_switch_to_wired_charge(chg); } else { if (chg->otg_disable_timeout == 0) { oplus_switch_from_wired_charge(chg); } } } #endif static void typec_disable_cmd_work(struct work_struct *work) { int rc = 0; struct smb_charger *chg = container_of(work, struct smb_charger, typec_disable_cmd_work.work); #ifdef OPLUS_CUSTOM_OP_DEF if(chg->wireless_present) { return; } #endif if (smblib_get_prop_typec_mode(chg) != POWER_SUPPLY_TYPEC_NONE) { printk(KERN_ERR "!!! %s: active t-c module\n", __func__); return; } rc = smblib_masked_write(chg, TYPE_C_MODE_CFG_REG, TYPEC_DISABLE_CMD_BIT, TYPEC_DISABLE_CMD_BIT); if (rc < 0) smblib_err(chg, "Couldn't write TYPE_C_INTRPT_ENB_SOFTWARE_CTRL_REG rc=%d\n", rc); msleep(100); rc = smblib_masked_write(chg, TYPE_C_MODE_CFG_REG, TYPEC_DISABLE_CMD_BIT, 0); if (rc < 0) smblib_err(chg, "Couldn't write TYPE_C_INTRPT_ENB_SOFTWARE_CTRL_REG rc=%d\n", rc); printk(KERN_ERR "!!! %s: re-active t-c module\n", __func__); msleep(200); if (smblib_get_prop_typec_mode(chg) == POWER_SUPPLY_TYPEC_NONE) { printk(KERN_ERR "!!! %s: fake typec plug\n", __func__); rc = smblib_masked_write(chg, TYPE_C_CFG_REG, APSD_START_ON_CC_BIT, 0); if (rc < 0) smblib_err(chg, "Couldn't enable APSD_START_ON_CC rc=%d\n", rc); msleep(600); chg->fake_typec_insertion = true; chg->typec_mode = POWER_SUPPLY_TYPEC_SOURCE_DEFAULT; power_supply_changed(chg->usb_psy); } return; } #endif #ifdef OPLUS_FEATURE_CHG_BASIC static int oplus_chg_get_fv_monitor(struct oplus_chg_chip *chip) { int default_fv = 0; if (!chip) return 0; default_fv = chip->limits.temp_cold_vfloat_mv; switch(chip->tbatt_status) { case BATTERY_STATUS__INVALID: case BATTERY_STATUS__REMOVED: case BATTERY_STATUS__LOW_TEMP: case BATTERY_STATUS__HIGH_TEMP: break; case BATTERY_STATUS__COLD_TEMP: default_fv = chip->limits.temp_cold_vfloat_mv; break; case BATTERY_STATUS__LITTLE_COLD_TEMP: default_fv = chip->limits.temp_little_cold_vfloat_mv; break; case BATTERY_STATUS__COOL_TEMP: default_fv = chip->limits.temp_cool_vfloat_mv; break; case BATTERY_STATUS__LITTLE_COOL_TEMP: default_fv = chip->limits.temp_little_cool_vfloat_mv; break; case BATTERY_STATUS__NORMAL: default_fv = chip->limits.temp_normal_vfloat_mv; break; case BATTERY_STATUS__WARM_TEMP: default_fv = chip->limits.temp_warm_vfloat_mv; break; default: break; } #ifdef CONFIG_OPLUS_SHORT_C_BATT_CHECK if (oplus_short_c_batt_is_prohibit_chg(chip) && default_fv > chip->limits.short_c_bat_vfloat_mv) default_fv = chip->limits.short_c_bat_vfloat_mv; #endif return default_fv; } static int oplus_chg_get_vbatt_full_vol_sw(struct oplus_chg_chip *chip) { int default_fv = 0; if (!chip) return 0; default_fv = chip->limits.cold_vfloat_sw_limit; switch(chip->tbatt_status) { case BATTERY_STATUS__INVALID: case BATTERY_STATUS__REMOVED: case BATTERY_STATUS__LOW_TEMP: case BATTERY_STATUS__HIGH_TEMP: break; case BATTERY_STATUS__COLD_TEMP: default_fv = chip->limits.cold_vfloat_sw_limit; break; case BATTERY_STATUS__LITTLE_COLD_TEMP: default_fv = chip->limits.little_cold_vfloat_sw_limit; break; case BATTERY_STATUS__COOL_TEMP: default_fv = chip->limits.cool_vfloat_sw_limit; break; case BATTERY_STATUS__LITTLE_COOL_TEMP: default_fv = chip->limits.little_cool_vfloat_sw_limit; break; case BATTERY_STATUS__NORMAL: default_fv = chip->limits.normal_vfloat_sw_limit; break; case BATTERY_STATUS__WARM_TEMP: default_fv = chip->limits.warm_vfloat_sw_limit; break; default: break; } #ifdef CONFIG_OPLUS_SHORT_C_BATT_CHECK if (oplus_short_c_batt_is_prohibit_chg(chip) && default_fv > chip->limits.short_c_bat_vfloat_sw_limit) default_fv = chip->limits.short_c_bat_vfloat_sw_limit; #endif return default_fv; } static void oplus_hvdcp_disable_work(struct work_struct *work) { int rc; u8 stat; bool vbus_rising; struct smb_charger *chg = container_of(work, struct smb_charger, hvdcp_disable_work.work); if (chg == NULL) return; rc = smblib_read(chg, USBIN_BASE + INT_RT_STS_OFFSET, &stat); if (rc < 0) { chg_err("fail to real pmic register\n"); return; } vbus_rising = (bool)(stat & USBIN_PLUGIN_RT_STS_BIT); if (vbus_rising == true) { chg_debug("vbus_rising is true, not disable hvdcp\n"); return; } smblib_hvdcp_detect_enable(chg, false); chg->hvdcp_disable = true; } /* When charger voltage is setting to < 4.3V and then resume to 5V, cannot charge, so... */ static void oplus_chg_monitor_work(struct work_struct *work) { struct smb_charger *chg = container_of(work, struct smb_charger, chg_monitor_work.work); struct oplus_chg_chip *chip = g_oplus_chip; int boot_mode = get_boot_mode(); static int counts = 0; int rechg_vol; int rc; u8 stat; if (!chip || !chip->charger_exist || !chip->batt_exist || !chip->mmi_chg) { counts = 0; goto rerun_work; } if (chg->real_charger_type == POWER_SUPPLY_TYPE_USB || chg->real_charger_type == POWER_SUPPLY_TYPE_USB_CDP) return; if (boot_mode == MSM_BOOT_MODE__RF || boot_mode == MSM_BOOT_MODE__WLAN) return; #ifdef OPLUS_CUSTOM_OP_DEF if(chg->wireless_present) { return; } #endif #ifdef CONFIG_OPLUS_SHORT_C_BATT_CHECK if (oplus_short_c_batt_is_disable_rechg(chip)) { counts = 0; goto rerun_work; } #endif if (oplus_vooc_get_fastchg_started() == true || chip->charger_volt < 4400) { counts = 0; goto rerun_work; } if (chip->tbatt_status == BATTERY_STATUS__COLD_TEMP) rechg_vol = oplus_chg_get_fv_monitor(chip) - 300; else if (chip->tbatt_status == BATTERY_STATUS__LITTLE_COLD_TEMP) rechg_vol = oplus_chg_get_fv_monitor(chip) - 200; else rechg_vol = oplus_chg_get_fv_monitor(chip) - 100; if ((chip->batt_volt > rechg_vol - 10) && chip->batt_full) { counts = 0; goto rerun_work; } else if (chip->batt_volt > oplus_chg_get_vbatt_full_vol_sw(chip) - 10) { counts = 0; goto rerun_work; } if (chip->icharging >= 0) { counts++; } else if (chip->icharging < 0 && (chip->icharging * -1) <= chip->limits.iterm_ma / 2) { counts++; } else { counts = 0; } if (counts > 10) counts = 10; if (counts >= (chip->batt_full ? 8 : 3)) {//because rechg counts=6 rc = smblib_read(chg, BATTERY_CHARGER_STATUS_8_REG, &stat); if (rc < 0) { printk(KERN_ERR "oplus_chg_monitor_work: Couldn't get BATTERY_CHARGER_STATUS_8_REG status rc=%d\n", rc); goto rerun_work; } if (get_client_vote(chg->usb_icl_votable, BOOST_BACK_VOTER) == 0 && get_effective_result(chg->usb_icl_votable) <= USBIN_25MA) { printk(KERN_ERR "oplus_chg_monitor_work: boost back\n"); if (chg->wa_flags & BOOST_BACK_WA) vote(chg->usb_icl_votable, BOOST_BACK_VOTER, false, 0); } if (chip->charging_state == CHARGING_STATUS_FAIL) {//for TEMP > 55 or < -3 counts = 0; goto rerun_work; } if (stat & PRE_TERM_BIT) { usb_online_status = true; printk(KERN_ERR "oplus_chg_monitor_work: PRE_TERM_BIT is set[0x%x], clear it\n", stat); //rc = smblib_masked_write(chg, USBIN_CMD_IL_REG, USBIN_SUSPEND_BIT, 1); rc = smblib_set_usb_suspend(chg, true); if (rc < 0) { printk(KERN_ERR "oplus_chg_monitor_work: Couldn't set USBIN_SUSPEND_BIT rc=%d\n", rc); goto rerun_work; } msleep(50); ///rc = smblib_masked_write(chg, USBIN_CMD_IL_REG, USBIN_SUSPEND_BIT, 0); rc = smblib_set_usb_suspend(chg, false); if (rc < 0) { printk(KERN_ERR "oplus_chg_monitor_work: Couldn't clear USBIN_SUSPEND_BIT rc=%d\n", rc); goto rerun_work; } msleep(10); rc = smblib_masked_write(chg, AICL_CMD_REG, RESTART_AICL_BIT, RESTART_AICL_BIT); if (rc < 0) { printk(KERN_ERR "oplus_chg_monitor_work: Couldn't set RESTART_AICL_BIT rc=%d\n", rc); goto rerun_work; } printk(KERN_ERR "oplus_chg_monitor_work: ichg[%d], fv[%d]\n", chip->icharging, oplus_chg_get_fv_monitor(chip)); } counts = 0; } rerun_work: usb_online_status = false; schedule_delayed_work(&chg->chg_monitor_work, OPLUS_CHG_MONITOR_INTERVAL); } #ifdef OPLUS_CUSTOM_OP_DEF static void oplus_chg_connect_check_work(struct work_struct *work) { if (!oplus_chg_is_usb_present()) { chg_err("type-c unpluged."); g_oplus_chip->svooc_disconnect_count = 0; g_oplus_chip->cool_down_bck = 0; } g_oplus_chip->icon_debounce = false; if (g_oplus_chip->ac_psy) power_supply_changed(g_oplus_chip->ac_psy); } #endif #endif /* OPLUS_FEATURE_CHG_BASIC */ static int smblib_create_votables(struct smb_charger *chg) { int rc = 0; chg->fcc_votable = find_votable("FCC"); if (chg->fcc_votable == NULL) { rc = -EINVAL; smblib_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; smblib_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; smblib_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; smblib_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; smblib_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; smblib_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->smb_override_votable = create_votable("SMB_EN_OVERRIDE", VOTE_SET_ANY, smblib_smb_disable_override_vote_callback, chg); if (IS_ERR(chg->smb_override_votable)) { rc = PTR_ERR(chg->smb_override_votable); chg->smb_override_votable = NULL; return rc; } chg->dc_suspend_votable = create_votable("DC_SUSPEND", VOTE_SET_ANY, smblib_dc_suspend_vote_callback, chg); if (IS_ERR(chg->dc_suspend_votable)) { rc = PTR_ERR(chg->dc_suspend_votable); chg->dc_suspend_votable = NULL; return rc; } chg->awake_votable = create_votable("AWAKE", VOTE_SET_ANY, smblib_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, smblib_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->limited_irq_disable_votable = create_votable( "USB_LIMITED_IRQ_DISABLE", VOTE_SET_ANY, smblib_limited_irq_disable_vote_callback, chg); if (IS_ERR(chg->limited_irq_disable_votable)) { rc = PTR_ERR(chg->limited_irq_disable_votable); chg->limited_irq_disable_votable = NULL; return rc; } chg->hdc_irq_disable_votable = create_votable("USB_HDC_IRQ_DISABLE", VOTE_SET_ANY, smblib_hdc_irq_disable_vote_callback, chg); if (IS_ERR(chg->hdc_irq_disable_votable)) { rc = PTR_ERR(chg->hdc_irq_disable_votable); chg->hdc_irq_disable_votable = NULL; return rc; } chg->icl_irq_disable_votable = create_votable("USB_ICL_IRQ_DISABLE", VOTE_SET_ANY, smblib_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, smblib_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 smblib_destroy_votables(struct smb_charger *chg) { if (chg->dc_suspend_votable) destroy_votable(chg->dc_suspend_votable); 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 smblib_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.usbin_i_chan)) iio_channel_release(chg->iio.usbin_i_chan); if (!IS_ERR_OR_NULL(chg->iio.temp_chan)) iio_channel_release(chg->iio.temp_chan); if (!IS_ERR_OR_NULL(chg->iio.sbux_chan)) iio_channel_release(chg->iio.sbux_chan); if (!IS_ERR_OR_NULL(chg->iio.vph_v_chan)) iio_channel_release(chg->iio.vph_v_chan); if (!IS_ERR_OR_NULL(chg->iio.die_temp_chan)) iio_channel_release(chg->iio.die_temp_chan); if (!IS_ERR_OR_NULL(chg->iio.connector_temp_chan)) iio_channel_release(chg->iio.connector_temp_chan); if (!IS_ERR_OR_NULL(chg->iio.skin_temp_chan)) iio_channel_release(chg->iio.skin_temp_chan); if (!IS_ERR_OR_NULL(chg->iio.smb_temp_chan)) iio_channel_release(chg->iio.smb_temp_chan); #ifdef OPLUS_FEATURE_CHG_BASIC if (!IS_ERR_OR_NULL(chg->iio.chgid_v_chan)) iio_channel_release(chg->iio.chgid_v_chan); #endif } int smblib_init(struct smb_charger *chg) { union power_supply_propval prop_val; int rc = 0; mutex_init(&chg->smb_lock); mutex_init(&chg->irq_status_lock); mutex_init(&chg->dcin_aicl_lock); spin_lock_init(&chg->typec_pr_lock); INIT_WORK(&chg->bms_update_work, bms_update_work); INIT_WORK(&chg->pl_update_work, pl_update_work); INIT_WORK(&chg->jeita_update_work, jeita_update_work); INIT_WORK(&chg->dcin_aicl_work, dcin_aicl_work); INIT_WORK(&chg->cp_status_change_work, smblib_cp_status_change_work); INIT_DELAYED_WORK(&chg->clear_hdc_work, clear_hdc_work); INIT_DELAYED_WORK(&chg->icl_change_work, smblib_icl_change_work); #ifdef OPLUS_FEATURE_CHG_BASIC INIT_DELAYED_WORK(&chg->chg_monitor_work, oplus_chg_monitor_work); #endif #ifdef OPLUS_FEATURE_CHG_BASIC INIT_DELAYED_WORK(&chg->hvdcp_disable_work, oplus_hvdcp_disable_work); #endif #ifdef OPLUS_FEATURE_CHG_BASIC INIT_DELAYED_WORK(&chg->recovery_suspend_work, oplus_recovery_suspend_work); INIT_DELAYED_WORK(&chg->ccdetect_work, oplus_ccdetect_work); INIT_DELAYED_WORK(&usbtemp_recover_work, oplus_usbtemp_recover_work); INIT_DELAYED_WORK(&chg->wired_in_work, oplus_wired_conn_int_work); INIT_DELAYED_WORK(&chg->wait_wired_charge_on, oplus_wait_wired_charge_on_work); INIT_DELAYED_WORK(&chg->wait_wired_charge_off, oplus_wait_wired_charge_off_work); INIT_DELAYED_WORK(&chg->otg_disable_timeout_work, oplus_otg_disable_timeout_work); chg->wired_in_flag = 0; chg->otg_disable_timeout = 0; #endif #ifdef OPLUS_FEATURE_CHG_BASIC INIT_DELAYED_WORK(&chg->typec_disable_cmd_work, typec_disable_cmd_work); INIT_WORK(&chg->chargerid_switch_work, oplus_chargerid_switch_work); #ifndef OPLUS_CUSTOM_OP_DEF INIT_DELAYED_WORK(&chg->switch_to_wired_work, oplus_switch_to_wired_work); #endif #endif INIT_DELAYED_WORK(&chg->pl_enable_work, smblib_pl_enable_work); INIT_DELAYED_WORK(&chg->uusb_otg_work, smblib_uusb_otg_work); INIT_DELAYED_WORK(&chg->bb_removal_work, smblib_bb_removal_work); INIT_DELAYED_WORK(&chg->lpd_ra_open_work, smblib_lpd_ra_open_work); INIT_DELAYED_WORK(&chg->lpd_detach_work, smblib_lpd_detach_work); INIT_DELAYED_WORK(&chg->thermal_regulation_work, smblib_thermal_regulation_work); INIT_DELAYED_WORK(&chg->usbov_dbc_work, smblib_usbov_dbc_work); INIT_DELAYED_WORK(&chg->pr_swap_detach_work, smblib_pr_swap_detach_work); INIT_DELAYED_WORK(&chg->pr_lock_clear_work, smblib_pr_lock_clear_work); INIT_DELAYED_WORK(&chg->regist_pd, register_oplus_pdsvooc_svid); #ifdef OPLUS_CUSTOM_OP_DEF INIT_DELAYED_WORK(&chg->reset_rd_work, op_reset_rd_work); INIT_DELAYED_WORK(&chg->connect_check_work, oplus_chg_connect_check_work); #endif if (chg->wa_flags & CHG_TERMINATION_WA) { INIT_WORK(&chg->chg_termination_work, smblib_chg_termination_work); if (alarmtimer_get_rtcdev()) { alarm_init(&chg->chg_termination_alarm, ALARM_BOOTTIME, chg_termination_alarm_cb); } else { smblib_err(chg, "Couldn't get rtc device\n"); return -ENODEV; } } if (chg->uusb_moisture_protection_enabled) { INIT_WORK(&chg->moisture_protection_work, smblib_moisture_protection_work); if (alarmtimer_get_rtcdev()) { alarm_init(&chg->moisture_protection_alarm, ALARM_BOOTTIME, moisture_protection_alarm_cb); } else { smblib_err(chg, "Failed to initialize moisture protection alarm\n"); return -ENODEV; } } if (alarmtimer_get_rtcdev()) { alarm_init(&chg->dcin_aicl_alarm, ALARM_REALTIME, dcin_aicl_alarm_cb); } else { smblib_err(chg, "Failed to initialize dcin aicl alarm\n"); return -ENODEV; } #ifdef OPLUS_FEATURE_CHG_BASIC chg->hvdcp_detect_time = 0; chg->hvdcp_detach_time = 0; chg->hvdcp_detect_ok = false; #endif chg->fake_capacity = -EINVAL; chg->fake_input_current_limited = -EINVAL; chg->fake_batt_status = -EINVAL; chg->sink_src_mode = UNATTACHED_MODE; chg->jeita_configured = false; chg->sec_chg_selected = POWER_SUPPLY_CHARGER_SEC_NONE; chg->cp_reason = POWER_SUPPLY_CP_NONE; chg->thermal_status = TEMP_BELOW_RANGE; chg->typec_irq_en = true; chg->cp_topo = -EINVAL; switch (chg->mode) { case PARALLEL_MASTER: rc = qcom_batt_init(&chg->chg_param); if (rc < 0) { smblib_err(chg, "Couldn't init qcom_batt_init rc=%d\n", rc); return rc; } rc = qcom_step_chg_init(chg->dev, chg->step_chg_enabled, chg->sw_jeita_enabled, false); if (rc < 0) { smblib_err(chg, "Couldn't init qcom_step_chg_init rc=%d\n", rc); return rc; } rc = smblib_create_votables(chg); if (rc < 0) { smblib_err(chg, "Couldn't create votables rc=%d\n", rc); return rc; } chg->bms_psy = power_supply_get_by_name("bms"); if (chg->sec_pl_present) { chg->pl.psy = power_supply_get_by_name("parallel"); if (chg->pl.psy) { if (chg->sec_chg_selected != POWER_SUPPLY_CHARGER_SEC_CP) { rc = smblib_select_sec_charger(chg, POWER_SUPPLY_CHARGER_SEC_PL, POWER_SUPPLY_CP_NONE, false); if (rc < 0) smblib_err(chg, "Couldn't config pl charger rc=%d\n", rc); } if (chg->smb_temp_max == -EINVAL) { rc = smblib_get_thermal_threshold(chg, SMB_REG_H_THRESHOLD_MSB_REG, &chg->smb_temp_max); if (rc < 0) { dev_err(chg->dev, "Couldn't get charger_temp_max rc=%d\n", rc); return rc; } } prop_val.intval = chg->smb_temp_max; rc = power_supply_set_property(chg->pl.psy, POWER_SUPPLY_PROP_CHARGER_TEMP_MAX, &prop_val); if (rc < 0) { dev_err(chg->dev, "Couldn't set POWER_SUPPLY_PROP_CHARGER_TEMP_MAX rc=%d\n", rc); return rc; } } } rc = smblib_register_notifier(chg); if (rc < 0) { smblib_err(chg, "Couldn't register notifier rc=%d\n", rc); return rc; } break; case PARALLEL_SLAVE: break; default: smblib_err(chg, "Unsupported mode %d\n", chg->mode); return -EINVAL; } return rc; } int smblib_deinit(struct smb_charger *chg) { switch (chg->mode) { case PARALLEL_MASTER: if (chg->uusb_moisture_protection_enabled) { alarm_cancel(&chg->moisture_protection_alarm); cancel_work_sync(&chg->moisture_protection_work); } if (chg->wa_flags & CHG_TERMINATION_WA) { alarm_cancel(&chg->chg_termination_alarm); cancel_work_sync(&chg->chg_termination_work); } cancel_work_sync(&chg->bms_update_work); cancel_work_sync(&chg->jeita_update_work); cancel_work_sync(&chg->pl_update_work); cancel_work_sync(&chg->dcin_aicl_work); cancel_work_sync(&chg->cp_status_change_work); cancel_delayed_work_sync(&chg->clear_hdc_work); cancel_delayed_work_sync(&chg->icl_change_work); cancel_delayed_work_sync(&chg->pl_enable_work); cancel_delayed_work_sync(&chg->uusb_otg_work); cancel_delayed_work_sync(&chg->bb_removal_work); cancel_delayed_work_sync(&chg->lpd_ra_open_work); cancel_delayed_work_sync(&chg->lpd_detach_work); cancel_delayed_work_sync(&chg->thermal_regulation_work); cancel_delayed_work_sync(&chg->usbov_dbc_work); cancel_delayed_work_sync(&chg->pr_swap_detach_work); power_supply_unreg_notifier(&chg->nb); smblib_destroy_votables(chg); qcom_step_chg_deinit(); qcom_batt_deinit(); break; case PARALLEL_SLAVE: break; default: smblib_err(chg, "Unsupported mode %d\n", chg->mode); return -EINVAL; } smblib_iio_deinit(chg); return 0; } #ifdef OPLUS_FEATURE_CHG_BASIC static int oplus_chg_2uart_pinctrl_init(struct oplus_chg_chip *chip) { struct smb_charger *chg = NULL; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return -EINVAL; } if (boot_with_console() == true ) { return 0; } chg = &chip->pmic_spmi.smb5_chip->chg; chg->chg_2uart_pinctrl = devm_pinctrl_get(chip->dev); if (IS_ERR_OR_NULL(chg->chg_2uart_pinctrl)) { chg_err("get 2uart chg_2uart_pinctrl fail\n"); return -EINVAL; } chg->chg_2uart_default = pinctrl_lookup_state(chg->chg_2uart_pinctrl, "chg_qupv3_se12_2uart_default"); if (IS_ERR_OR_NULL(chg->chg_2uart_default)) { chg_err("get chg_2uart_default fail\n"); return -EINVAL; } chg->chg_2uart_sleep = pinctrl_lookup_state(chg->chg_2uart_pinctrl, "chg_qupv3_se12_2uart_sleep"); if (IS_ERR_OR_NULL(chg->chg_2uart_sleep)) { chg_err("get chg_2uart_sleep fail\n"); return -EINVAL; } pinctrl_select_state(chg->chg_2uart_pinctrl, chg->chg_2uart_default); return 0; } static int oplus_chg_set_2uart_pinctrl_chgID(struct oplus_chg_chip *chip) { struct smb_charger *chg = NULL; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return -EINVAL; } if (boot_with_console() == true) { return 0; } chg = &chip->pmic_spmi.smb5_chip->chg; if (IS_ERR_OR_NULL(chg->chg_2uart_pinctrl) || IS_ERR_OR_NULL(chg->chg_2uart_sleep)) { chg_err("get 2uart chg_2uart_pinctrl fail\n"); return -EINVAL; } mutex_lock(&chg->pinctrl_mutex); pinctrl_select_state(chg->chg_2uart_pinctrl, chg->chg_2uart_sleep); mutex_unlock(&chg->pinctrl_mutex); return 0; } static int oplus_chg_set_2uart_pinctrl_default(struct oplus_chg_chip *chip) { struct smb_charger *chg = NULL; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return -EINVAL; } if (boot_with_console() == true) { return 0; } chg = &chip->pmic_spmi.smb5_chip->chg; if (IS_ERR_OR_NULL(chg->chg_2uart_pinctrl) || IS_ERR_OR_NULL(chg->chg_2uart_default)) { chg_err("get 2uart chg_2uart_pinctrl fail\n"); return -EINVAL; } mutex_lock(&chg->pinctrl_mutex); pinctrl_select_state(chg->chg_2uart_pinctrl, chg->chg_2uart_default); mutex_unlock(&chg->pinctrl_mutex); return 0; } int smbchg_get_chargerid_volt(void) { int rc, chargerid_volt = 0; struct oplus_chg_chip *chip = g_oplus_chip; struct smb_charger *chg = NULL; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return 0; } chg = &chip->pmic_spmi.smb5_chip->chg; if (IS_ERR_OR_NULL(chg->iio.chgid_v_chan)) { printk(KERN_ERR "[OPLUS_CHG][%s]: chg->iio.chgid_v_chan is NULL !\n", __func__); return 0; } oplus_chg_set_2uart_pinctrl_chgID(chip); msleep(10); rc = iio_read_channel_processed(chg->iio.chgid_v_chan, &chargerid_volt); if (rc < 0) { chg_err("[OPLUS_CHG][%s]: iio_read_channel_processed get error\n", __func__); return 0; } chargerid_volt = chargerid_volt / 1000; chg_err("chargerid_volt: %d\n", chargerid_volt); oplus_chg_set_2uart_pinctrl_default(chip); return chargerid_volt; } static int smbchg_chargerid_switch_gpio_init(struct oplus_chg_chip *chip) { chip->normalchg_gpio.pinctrl = devm_pinctrl_get(chip->dev); if (IS_ERR_OR_NULL(chip->normalchg_gpio.pinctrl)) { chg_err("get normalchg_gpio.pinctrl fail\n"); return -EINVAL; } chip->normalchg_gpio.chargerid_switch_active = pinctrl_lookup_state(chip->normalchg_gpio.pinctrl, "chargerid_switch_active"); if (IS_ERR_OR_NULL(chip->normalchg_gpio.chargerid_switch_active)) { chg_err("get chargerid_switch_active fail\n"); return -EINVAL; } chip->normalchg_gpio.chargerid_switch_sleep = pinctrl_lookup_state(chip->normalchg_gpio.pinctrl, "chargerid_switch_sleep"); if (IS_ERR_OR_NULL(chip->normalchg_gpio.chargerid_switch_sleep)) { chg_err("get chargerid_switch_sleep fail\n"); return -EINVAL; } chip->normalchg_gpio.chargerid_switch_default = pinctrl_lookup_state(chip->normalchg_gpio.pinctrl, "chargerid_switch_default"); if (IS_ERR_OR_NULL(chip->normalchg_gpio.chargerid_switch_default)) { chg_err("get chargerid_switch_default fail\n"); return -EINVAL; } if (chip->normalchg_gpio.chargerid_switch_gpio > 0) { gpio_direction_output(chip->normalchg_gpio.chargerid_switch_gpio, 0); } pinctrl_select_state(chip->normalchg_gpio.pinctrl, chip->normalchg_gpio.chargerid_switch_default); #ifdef OPLUS_CUSTOM_OP_DEF chip->normalchg_gpio.chargerid_switch_pvt_active = pinctrl_lookup_state(chip->normalchg_gpio.pinctrl, "chargerid_switch_pvt_active"); if (IS_ERR_OR_NULL(chip->normalchg_gpio.chargerid_switch_pvt_active)) { chg_err("get chargerid_switch_pvt_active fail\n"); //return -EINVAL; } chip->normalchg_gpio.chargerid_switch_pvt_sleep = pinctrl_lookup_state(chip->normalchg_gpio.pinctrl, "chargerid_switch_pvt_sleep"); if (IS_ERR_OR_NULL(chip->normalchg_gpio.chargerid_switch_pvt_sleep)) { chg_err("get chargerid_switch_pvt_sleep fail\n"); //return -EINVAL; } chip->normalchg_gpio.chargerid_switch_pvt_default = pinctrl_lookup_state(chip->normalchg_gpio.pinctrl, "chargerid_switch_pvt_default"); if (IS_ERR_OR_NULL(chip->normalchg_gpio.chargerid_switch_pvt_default)) { chg_err("get chargerid_switch_pvt_default fail\n"); //return -EINVAL; } if (chip->normalchg_gpio.chargerid_switch_gpio_pvt > 0) { gpio_direction_output(chip->normalchg_gpio.chargerid_switch_gpio_pvt, 0); pinctrl_select_state(chip->normalchg_gpio.pinctrl, chip->normalchg_gpio.chargerid_switch_pvt_default); } #endif return 0; } void smbchg_set_chargerid_switch_val(int value) { struct oplus_chg_chip *chip = g_oplus_chip; if (chip->normalchg_gpio.chargerid_switch_gpio <= 0) { chg_err("chargerid_switch_gpio not exist, return\n"); return; } if (IS_ERR_OR_NULL(chip->normalchg_gpio.pinctrl) || IS_ERR_OR_NULL(chip->normalchg_gpio.chargerid_switch_active) || IS_ERR_OR_NULL(chip->normalchg_gpio.chargerid_switch_sleep) || IS_ERR_OR_NULL(chip->normalchg_gpio.chargerid_switch_default)) { chg_err("pinctrl null, return\n"); return; } #ifdef OPLUS_CUSTOM_OP_DEF if (chip->normalchg_gpio.chargerid_switch_gpio_pvt <= 0) { chg_err("*** chargerid_switch_gpio_pvt not exist ****\n"); } if (IS_ERR_OR_NULL(chip->normalchg_gpio.pinctrl) || IS_ERR_OR_NULL(chip->normalchg_gpio.chargerid_switch_pvt_active) || IS_ERR_OR_NULL(chip->normalchg_gpio.chargerid_switch_pvt_sleep) || IS_ERR_OR_NULL(chip->normalchg_gpio.chargerid_switch_pvt_default)) { chg_err("*** chargerid_switch_pvt pinctrl null ***\n"); } #endif if (oplus_vooc_get_adapter_update_real_status() == ADAPTER_FW_NEED_UPDATE || oplus_vooc_get_btb_temp_over() == true) { chg_err("adapter update or btb_temp_over, return\n"); return; } #if 0 if (chip->pmic_spmi.not_support_1200ma && !value && !is_usb_present(chip)) { /* BugID 879716 : Solve some situatuion ChargerID is not 0 mV when usb is not present */ chip->chargerid_volt = 0; chip->chargerid_volt_got = false; } #endif mutex_lock(&chip->pmic_spmi.smb5_chip->chg.pinctrl_mutex); if (value) { gpio_direction_output(chip->normalchg_gpio.chargerid_switch_gpio, 1); pinctrl_select_state(chip->normalchg_gpio.pinctrl, chip->normalchg_gpio.chargerid_switch_default); #ifdef OPLUS_CUSTOM_OP_DEF if (chip->normalchg_gpio.chargerid_switch_gpio_pvt > 0) { gpio_direction_output(chip->normalchg_gpio.chargerid_switch_gpio_pvt, 1); pinctrl_select_state(chip->normalchg_gpio.pinctrl, chip->normalchg_gpio.chargerid_switch_pvt_default); } #endif } else { gpio_direction_output(chip->normalchg_gpio.chargerid_switch_gpio, 0); pinctrl_select_state(chip->normalchg_gpio.pinctrl, chip->normalchg_gpio.chargerid_switch_default); #ifdef OPLUS_CUSTOM_OP_DEF if (chip->normalchg_gpio.chargerid_switch_gpio_pvt > 0) { gpio_direction_output(chip->normalchg_gpio.chargerid_switch_gpio_pvt, 0); pinctrl_select_state(chip->normalchg_gpio.pinctrl, chip->normalchg_gpio.chargerid_switch_pvt_default); } #endif } mutex_unlock(&chip->pmic_spmi.smb5_chip->chg.pinctrl_mutex); chg_err("set value:%d, gpio_val:%d\n", value, gpio_get_value(chip->normalchg_gpio.chargerid_switch_gpio)); #ifdef OPLUS_CUSTOM_OP_DEF if (chip->normalchg_gpio.chargerid_switch_gpio_pvt > 0) { chg_err("set value:%d, gpio_pvt_val:%d\n", value, gpio_get_value(chip->normalchg_gpio.chargerid_switch_gpio_pvt)); } #endif } int smbchg_get_chargerid_switch_val(void) { struct oplus_chg_chip *chip = g_oplus_chip; if (chip->normalchg_gpio.chargerid_switch_gpio <= 0) { chg_err("chargerid_switch_gpio not exist, return\n"); return -1; } if (IS_ERR_OR_NULL(chip->normalchg_gpio.pinctrl) || IS_ERR_OR_NULL(chip->normalchg_gpio.chargerid_switch_active) || IS_ERR_OR_NULL(chip->normalchg_gpio.chargerid_switch_sleep)) { chg_err("pinctrl null, return\n"); return -1; } #ifdef OPLUS_CUSTOM_OP_DEF if (chip->normalchg_gpio.chargerid_switch_gpio_pvt <= 0) { chg_err("*** chargerid_switch_gpio_pvt not exist ***\n"); } if (IS_ERR_OR_NULL(chip->normalchg_gpio.pinctrl) || IS_ERR_OR_NULL(chip->normalchg_gpio.chargerid_switch_pvt_active) || IS_ERR_OR_NULL(chip->normalchg_gpio.chargerid_switch_pvt_sleep)) { chg_err("*** chargerid_switch_pvt pinctrl null ***\n"); } #endif #ifdef OPLUS_CUSTOM_OP_DEF if (chip->normalchg_gpio.chargerid_switch_gpio_pvt > 0) return (gpio_get_value(chip->normalchg_gpio.chargerid_switch_gpio) && gpio_get_value(chip->normalchg_gpio.chargerid_switch_gpio_pvt)); else return gpio_get_value(chip->normalchg_gpio.chargerid_switch_gpio); #else return gpio_get_value(chip->normalchg_gpio.chargerid_switch_gpio); #endif } #endif #ifdef OPLUS_FEATURE_CHG_BASIC static int oplus_ship_gpio_init(struct oplus_chg_chip *chip) { if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb2_chg not ready!\n", __func__); return -EINVAL; } chip->normalchg_gpio.pinctrl = devm_pinctrl_get(chip->dev); chip->normalchg_gpio.ship_active = pinctrl_lookup_state(chip->normalchg_gpio.pinctrl, "ship_active"); if (IS_ERR_OR_NULL(chip->normalchg_gpio.ship_active)) { chg_err("get ship_active fail\n"); return -EINVAL; } chip->normalchg_gpio.ship_sleep = pinctrl_lookup_state(chip->normalchg_gpio.pinctrl, "ship_sleep"); if (IS_ERR_OR_NULL(chip->normalchg_gpio.ship_sleep)) { chg_err("get ship_sleep fail\n"); return -EINVAL; } pinctrl_select_state(chip->normalchg_gpio.pinctrl, chip->normalchg_gpio.ship_sleep); return 0; } static bool oplus_ship_check_is_gpio(struct oplus_chg_chip *chip) { if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb2_chg not ready!\n", __func__); return false; } if (gpio_is_valid(chip->normalchg_gpio.ship_gpio)) return true; return false; } #define PWM_COUNT 5 static void smbchg_enter_shipmode(struct oplus_chg_chip *chip) { int i = 0; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb2_chg not ready!\n", __func__); return; } if (oplus_ship_check_is_gpio(chip) == true) { chg_debug("select gpio control\n"); mutex_lock(&chip->pmic_spmi.smb5_chip->chg.pinctrl_mutex); if (!IS_ERR_OR_NULL(chip->normalchg_gpio.ship_sleep)) { pinctrl_select_state(chip->normalchg_gpio.pinctrl, chip->normalchg_gpio.ship_sleep); } for (i = 0; i < PWM_COUNT; i++) { //gpio_direction_output(chip->normalchg_gpio.ship_gpio, 1); pinctrl_select_state(chip->normalchg_gpio.pinctrl, chip->normalchg_gpio.ship_active); mdelay(3); //gpio_direction_output(chip->normalchg_gpio.ship_gpio, 0); pinctrl_select_state(chip->normalchg_gpio.pinctrl, chip->normalchg_gpio.ship_sleep); mdelay(3); } mutex_unlock(&chip->pmic_spmi.smb5_chip->chg.pinctrl_mutex); chg_debug("power off after 15s\n"); } } #endif /* OPLUS_FEATURE_CHG_BASIC */ #ifdef OPLUS_FEATURE_CHG_BASIC static int oplus_shortc_gpio_init(struct oplus_chg_chip *chip) { if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return -EINVAL; } chip->normalchg_gpio.pinctrl = devm_pinctrl_get(chip->dev); chip->normalchg_gpio.shortc_active = pinctrl_lookup_state(chip->normalchg_gpio.pinctrl, "shortc_active"); if (IS_ERR_OR_NULL(chip->normalchg_gpio.shortc_active)) { chg_err("get shortc_active fail\n"); return -EINVAL; } pinctrl_select_state(chip->normalchg_gpio.pinctrl, chip->normalchg_gpio.shortc_active); return 0; } static bool oplus_shortc_check_is_gpio(struct oplus_chg_chip *chip) { if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return false; } if (gpio_is_valid(chip->normalchg_gpio.shortc_gpio)) return true; return false; } static int oplus_shipmode_id_gpio_init(struct oplus_chg_chip *chip) { struct smb_charger *chg = NULL; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return -EINVAL; } chg = &chip->pmic_spmi.smb5_chip->chg; chg->shipmode_id_pinctrl = devm_pinctrl_get(chip->dev); chg->shipmode_id_active = pinctrl_lookup_state(chg->shipmode_id_pinctrl, "shipmode_id_active"); if (IS_ERR_OR_NULL(chg->shipmode_id_active)) { chg_err("get shipmode_id_active fail\n"); return -EINVAL; } pinctrl_select_state(chg->shipmode_id_pinctrl, chg->shipmode_id_active); return 0; } static bool oplus_shipmode_id_check_is_gpio(struct oplus_chg_chip *chip) { struct smb_charger *chg = NULL; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return -EINVAL; } chg = &chip->pmic_spmi.smb5_chip->chg; if (gpio_is_valid(chg->shipmode_id_gpio)) { printk(KERN_ERR "[OPLUS_CHG][%s]: tongfeng test shipmode_id_gpio true!\n", __func__); return true; } return false; } #ifdef CONFIG_OPLUS_SHORT_HW_CHECK static bool oplus_chg_get_shortc_hw_gpio_status(void) { bool shortc_hw_status = 1; struct oplus_chg_chip *chip = g_oplus_chip; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return shortc_hw_status; } if (oplus_shortc_check_is_gpio(chip) == true) { shortc_hw_status = !!(gpio_get_value(chip->normalchg_gpio.shortc_gpio)); } return shortc_hw_status; } #else static bool oplus_chg_get_shortc_hw_gpio_status(void) { bool shortc_hw_status = 1; return shortc_hw_status; } #endif /* CONFIG_OPLUS_SHORT_HW_CHECK */ #endif /* OPLUS_FEATURE_CHG_BASIC */ #ifdef OPLUS_FEATURE_CHG_BASIC int oplus_usbtemp_adc_gpio_init(struct oplus_chg_chip *chip) { struct smb_charger *chg = NULL; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return -EINVAL; } chg = &chip->pmic_spmi.smb5_chip->chg; chg->usbtemp_gpio1_adc_pinctrl = devm_pinctrl_get(chip->dev); if (IS_ERR_OR_NULL(chg->usbtemp_gpio1_adc_pinctrl)) { chg_err("get usbtemp_gpio1_adc_pinctrl fail\n"); return -EINVAL; } chg->usbtemp_gpio1_default = pinctrl_lookup_state(chg->usbtemp_gpio1_adc_pinctrl, "gpio1_adc_default"); if (IS_ERR_OR_NULL(chg->usbtemp_gpio1_default)) { chg_err("get usbtemp_gpio1_default fail\n"); return -EINVAL; } pinctrl_select_state(chg->usbtemp_gpio1_adc_pinctrl, chg->usbtemp_gpio1_default); chg->usbtemp_gpio8_adc_pinctrl = devm_pinctrl_get(chip->dev); if (IS_ERR_OR_NULL(chg->usbtemp_gpio8_adc_pinctrl)) { chg_err("get usbtemp_gpio8_adc_pinctrl fail\n"); return -EINVAL; } chg->usbtemp_gpio8_default = pinctrl_lookup_state(chg->usbtemp_gpio8_adc_pinctrl, "gpio8_adc_default"); if (IS_ERR_OR_NULL(chg->usbtemp_gpio8_default)) { chg_err("get usbtemp_gpio8_default fail\n"); return -EINVAL; } pinctrl_select_state(chg->usbtemp_gpio8_adc_pinctrl, chg->usbtemp_gpio8_default); chg->usbtemp_gpio5_adc_pinctrl = devm_pinctrl_get(chip->dev); if (IS_ERR_OR_NULL(chg->usbtemp_gpio5_adc_pinctrl)) { chg_err("get usbtemp_gpio5_adc_pinctrl fail\n"); return -EINVAL; } chg->usbtemp_gpio5_default = pinctrl_lookup_state(chg->usbtemp_gpio5_adc_pinctrl, "gpio5_adc_default"); if (IS_ERR_OR_NULL(chg->usbtemp_gpio5_default)) { chg_err("get usbtemp_gpio5_default fail\n"); return -EINVAL; } pinctrl_select_state(chg->usbtemp_gpio5_adc_pinctrl, chg->usbtemp_gpio5_default); return 0; } int oplus_charger_int_gpio_init(struct oplus_chg_chip *chip) { struct pinctrl *charger_int_pinctrl = NULL; struct pinctrl_state *charger_int_default = NULL; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return -EINVAL; } charger_int_pinctrl = devm_pinctrl_get(chip->dev); if (IS_ERR_OR_NULL(charger_int_pinctrl)) { chg_err("get charger_int_pinctrl fail\n"); return -EINVAL; } charger_int_default = pinctrl_lookup_state(charger_int_pinctrl, "charger_int_default"); if (IS_ERR_OR_NULL(charger_int_default)) { chg_err("get charger_int_default fail\n"); return -EINVAL; } pinctrl_select_state(charger_int_pinctrl, charger_int_default); return 0; } int oplus_input_pg_gpio_init(struct oplus_chg_chip *chip) { struct pinctrl *input_pg_pinctrl = NULL; struct pinctrl_state *input_pg_default = NULL; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return -EINVAL; } input_pg_pinctrl = devm_pinctrl_get(chip->dev); if (IS_ERR_OR_NULL(input_pg_pinctrl)) { chg_err("get input_pg_pinctrl fail\n"); return -EINVAL; } input_pg_default = pinctrl_lookup_state(input_pg_pinctrl, "input_pg_default"); if (IS_ERR_OR_NULL(input_pg_default)) { chg_err("get input_pg_default fail\n"); return -EINVAL; } pinctrl_select_state(input_pg_pinctrl, input_pg_default); return 0; } int oplus_charger_error_gpio_init(struct oplus_chg_chip *chip) { struct pinctrl *charger_error_pinctrl = NULL; struct pinctrl_state *charger_error_default = NULL; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return -EINVAL; } charger_error_pinctrl = devm_pinctrl_get(chip->dev); if (IS_ERR_OR_NULL(charger_error_pinctrl)) { chg_err("get charger_error_pinctrl fail\n"); return -EINVAL; } charger_error_default = pinctrl_lookup_state(charger_error_pinctrl, "charger_error_default"); if (IS_ERR_OR_NULL(charger_error_default)) { chg_err("get charger_error_default fail\n"); return -EINVAL; } pinctrl_select_state(charger_error_pinctrl, charger_error_default); return 0; } int oplus_sc_mos_gpio_init(struct oplus_chg_chip *chip) { struct pinctrl *sc_mos_pinctrl = NULL; struct pinctrl_state *sc_mos_default = NULL; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return -EINVAL; } sc_mos_pinctrl = devm_pinctrl_get(chip->dev); if (IS_ERR_OR_NULL(sc_mos_pinctrl)) { chg_err("get sc_mos_pinctrl fail\n"); return -EINVAL; } sc_mos_default = pinctrl_lookup_state(sc_mos_pinctrl, "gpio12_adc_default"); if (IS_ERR_OR_NULL(sc_mos_default)) { chg_err("get sc_mos_default fail\n"); return -EINVAL; } pinctrl_select_state(sc_mos_pinctrl, sc_mos_default); return 0; } int oplus_ccdetect_gpio_init(struct oplus_chg_chip *chip) { struct smb_charger *chg = NULL; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return -EINVAL; } chg = &chip->pmic_spmi.smb5_chip->chg; chg->ccdetect_pinctrl = devm_pinctrl_get(chip->dev); if (IS_ERR_OR_NULL(chg->ccdetect_pinctrl)) { chg_err("get ccdetect ccdetect_pinctrl fail\n"); return -EINVAL; } chg->ccdetect_active = pinctrl_lookup_state(chg->ccdetect_pinctrl, "ccdetect_active"); if (IS_ERR_OR_NULL(chg->ccdetect_active)) { chg_err("get ccdetect_active fail\n"); return -EINVAL; } chg->ccdetect_sleep = pinctrl_lookup_state(chg->ccdetect_pinctrl, "ccdetect_sleep"); if (IS_ERR_OR_NULL(chg->ccdetect_sleep)) { chg_err("get ccdetect_sleep fail\n"); return -EINVAL; } if (chg->ccdetect_gpio > 0) { gpio_direction_input(chg->ccdetect_gpio); } pinctrl_select_state(chg->ccdetect_pinctrl, chg->ccdetect_active); return 0; } void oplus_ccdetect_irq_init(struct oplus_chg_chip *chip) { struct smb_charger *chg = NULL; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return; } chg = &chip->pmic_spmi.smb5_chip->chg; chg->ccdetect_irq = gpio_to_irq(chg->ccdetect_gpio); printk(KERN_ERR "[OPLUS_CHG][%s]: chg->ccdetect_irq[%d]!\n", __func__, chg->ccdetect_irq); } void oplus_ccdetect_enable(void) { int rc; u8 stat; struct smb_charger *chg = NULL; struct oplus_chg_chip *chip = g_oplus_chip; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb2_chg not ready!\n", __func__); return; } chg = &chip->pmic_spmi.smb5_chip->chg; if (oplus_ccdetect_check_is_gpio(chip) != true) return; rc = smblib_read(chg, TYPE_C_MODE_CFG_REG, &stat); if (rc < 0) { printk(KERN_ERR "[OPLUS_CHG][%s]: 111 Couldn't read 0x1368 rc=%d\n", __func__, rc); } else { printk(KERN_ERR "[OPLUS_CHG][%s]:111 reg0x1368[0x%x], bit[2:0]=0(DRP)\n", __func__, stat); } /* set DRP mode */ rc = smblib_masked_write(chg, TYPE_C_MODE_CFG_REG, TYPEC_POWER_ROLE_CMD_MASK, 0x0);//bit[2:0]=0 if (rc < 0) { printk(KERN_ERR "[OPLUS_CHG][%s]: Couldn't clear 0x1368[0] rc=%d\n", __func__, rc); } rc = smblib_read(chg, TYPE_C_MODE_CFG_REG, &stat); if (rc < 0) { printk(KERN_ERR "[OPLUS_CHG][%s]: Couldn't read 0x1368 rc=%d\n", __func__, rc); } else { printk(KERN_ERR "[OPLUS_CHG][%s]: reg0x1368[0x%x], bit[2:0]=0(DRP)\n", __func__, stat); } } void oplus_ccdetect_disable(void) { int rc; u8 stat; struct smb_charger *chg = NULL; struct oplus_chg_chip *chip = g_oplus_chip; //return; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb2_chg not ready!\n", __func__); return; } chg = &chip->pmic_spmi.smb5_chip->chg; if (oplus_ccdetect_check_is_gpio(chip) != true) return; #ifdef OPLUS_FEATURE_CHG_BASIC /* set sink mode only */ rc = smblib_masked_write(chg, TYPE_C_MODE_CFG_REG, TYPEC_POWER_ROLE_CMD_MASK | TYPEC_TRY_MODE_MASK, EN_SNK_ONLY_BIT);//bit[4:0]=0x02 #endif if (rc < 0) { printk(KERN_ERR "[OPLUS_CHG][%s]: Couldn't set 0x1368[2] rc=%d\n", __func__, rc); } rc = smblib_read(chg, TYPE_C_MODE_CFG_REG, &stat); if (rc < 0) { printk(KERN_ERR "[OPLUS_CHG][%s]: Couldn't read 0x1368 rc=%d\n", __func__, rc); } else { printk(KERN_ERR "[OPLUS_CHG][%s]: reg0x1368[0x%x], bit[2:0]=4(UFP)\n", __func__, stat); } } int oplus_ccdetect_get_power_role(void) { int rc; struct smb_charger *chg = NULL; union power_supply_propval val = {0,}; if (!g_oplus_chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return POWER_SUPPLY_TYPEC_PR_NONE; } chg = &g_oplus_chip->pmic_spmi.smb5_chip->chg; rc = smblib_get_prop_typec_power_role(chg, &val); if (rc < 0) { printk(KERN_ERR "[OPLUS_CHG][%s]: Couldn't get typec power role, rc=%d\n", __func__, rc); return POWER_SUPPLY_TYPEC_PR_DUAL; } return val.intval; } bool oplus_ccdetect_check_is_gpio(struct oplus_chg_chip *chip) { struct smb_charger *chg = NULL; int boot_mode = get_boot_mode(); if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return false; } chg = &chip->pmic_spmi.smb5_chip->chg; /* HW engineer requirement */ if (boot_mode == MSM_BOOT_MODE__RF || boot_mode == MSM_BOOT_MODE__WLAN || boot_mode == MSM_BOOT_MODE__FACTORY) return false; if (gpio_is_valid(chg->ccdetect_gpio)) return true; return false; } int oplus_ccdetect_support_check(void) { struct smb_charger *chg = NULL; struct oplus_chg_chip *chip = g_oplus_chip; int boot_mode = get_boot_mode(); if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: g_oplus_chip not ready!\n", __func__); return OPLUS_NOT_SUPPORT_CCDETECT; } chg = &chip->pmic_spmi.smb5_chip->chg; if (boot_mode == MSM_BOOT_MODE__RF || boot_mode == MSM_BOOT_MODE__WLAN || boot_mode == MSM_BOOT_MODE__FACTORY) { return OPLUS_SUPPORT_CCDETECT_IN_FTM_MODE; } if (gpio_is_valid(chg->ccdetect_gpio)) return OPLUS_SUPPORT_CCDETECT_NOT_FTM_MODE; return OPLUS_NOT_SUPPORT_CCDETECT; } EXPORT_SYMBOL(oplus_ccdetect_support_check); #ifdef OPLUS_FEATURE_CHG_BASIC #define CCDETECT_DELAY_MS 50 irqreturn_t oplus_ccdetect_change_handler(int irq, void *data) { struct oplus_chg_chip *chip = data; struct smb_charger *chg = &chip->pmic_spmi.smb5_chip->chg; cancel_delayed_work_sync(&chg->ccdetect_work); vote(chg->awake_votable, CCDETECT_VOTER, true, 0); //smblib_dbg(chg, PR_INTERRUPT, "Scheduling ccdetect work\n"); printk(KERN_ERR "[OPLUS_CHG][%s]: Scheduling ccdetect work!\n", __func__); schedule_delayed_work(&chg->ccdetect_work, msecs_to_jiffies(CCDETECT_DELAY_MS)); return IRQ_HANDLED; } #endif /* OPLUS_FEATURE_CHG_BASIC */ static void oplus_ccdetect_irq_register(struct oplus_chg_chip *chip) { int ret = 0; struct smb_charger *chg = NULL; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return; } chg = &chip->pmic_spmi.smb5_chip->chg; ret = devm_request_threaded_irq(chip->dev, chg->ccdetect_irq, NULL, oplus_ccdetect_change_handler, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_ONESHOT, "ccdetect-change", chip); if (ret < 0) { chg_err("Unable to request ccdetect-change irq: %d\n", ret); } printk(KERN_ERR "%s: !!!!! irq register\n", __FUNCTION__); ret = enable_irq_wake(chg->ccdetect_irq); if (ret != 0) { chg_err("enable_irq_wake: ccdetect_irq failed %d\n", ret); } } #endif /* OPLUS_FEATURE_CHG_BASIC */ #ifdef OPLUS_FEATURE_CHG_BASIC static bool oplus_usbtemp_check_is_gpio(struct oplus_chg_chip *chip) { if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return false; } if (gpio_is_valid(chip->normalchg_gpio.dischg_gpio)) return true; return false; } bool oplus_usbtemp_check_is_support(void) { if (get_eng_version() == AGING) { chg_err("AGING mode, disable usbtemp\n"); return false; } if(oplus_usbtemp_check_is_gpio(g_oplus_chip) == true) return true; chg_err("dischg return false\n"); return false; } #define USBTEMP_DEFAULT_VOLT_VALUE_MV 950 void oplus_get_usbtemp_volt(struct oplus_chg_chip *chip) { int rc, usbtemp_volt = 0; struct smb_charger *chg = NULL; static int usbtemp_volt_l_pre = USBTEMP_DEFAULT_VOLT_VALUE_MV; static int usbtemp_volt_r_pre = USBTEMP_DEFAULT_VOLT_VALUE_MV; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return ; } chg = &chip->pmic_spmi.smb5_chip->chg; if (IS_ERR_OR_NULL(chg->iio.usbtemp_v_chan)) { printk(KERN_ERR "[OPLUS_CHG][%s]: chg->iio.usbtemp_v_chan is NULL !\n", __func__); chip->usbtemp_volt_l = usbtemp_volt_l_pre; goto usbtemp_next; } rc = iio_read_channel_processed(chg->iio.usbtemp_v_chan, &usbtemp_volt); if (rc < 0) { chg_err("[OPLUS_CHG][%s]: iio_read_channel_processed get error\n", __func__); chip->usbtemp_volt_l = usbtemp_volt_l_pre; goto usbtemp_next; } usbtemp_volt = usbtemp_volt / 1000; #ifndef OPLUS_CUSTOM_OP_DEF if (usbtemp_volt > USBTEMP_DEFAULT_VOLT_VALUE_MV) { usbtemp_volt = USBTEMP_DEFAULT_VOLT_VALUE_MV; } #endif chip->usbtemp_volt_l = usbtemp_volt; usbtemp_volt_l_pre = usbtemp_volt; usbtemp_next: usbtemp_volt = 0; if (IS_ERR_OR_NULL(chg->iio.usbtemp_sup_v_chan)) { printk(KERN_ERR "[OPLUS_CHG][%s]: chg->iio.usbtemp_sup_v_chan is NULL !\n", __func__); chip->usbtemp_volt_r = usbtemp_volt_r_pre; return; } rc = iio_read_channel_processed(chg->iio.usbtemp_sup_v_chan, &usbtemp_volt); if (rc < 0) { chg_err("[OPLUS_CHG][%s]: iio_read_channel_processed get error\n", __func__); chip->usbtemp_volt_r = usbtemp_volt_r_pre; return; } usbtemp_volt = usbtemp_volt / 1000; #ifndef OPLUS_CUSTOM_OP_DEF if (usbtemp_volt > USBTEMP_DEFAULT_VOLT_VALUE_MV) { usbtemp_volt = USBTEMP_DEFAULT_VOLT_VALUE_MV; } #endif chip->usbtemp_volt_r = usbtemp_volt; usbtemp_volt_r_pre = usbtemp_volt; //chg_err("usbtemp_volt_l:%d, usbtemp_volt_r:%d\n",chip->usbtemp_volt_l, chip->usbtemp_volt_r); } static int get_btb_temp(struct iio_channel *temp_chan) { int rc = 0; int i = 0; int temp = 25; rc = iio_read_channel_processed(temp_chan, &temp); if (rc < 0) { chg_err("[OPLUS_CHG][%s]: iio_read_channel_processed get error\n", __func__); return temp; } temp = temp/1000; for (i = ARRAY_SIZE(con_volt_855) - 1; i >= 0; i--) { if (con_volt_855[i] >= temp) break; else if (i == 0) break; } temp = con_temp_855[i]; return temp; } int oplus_chg_get_battery_btb_temp_cal(void) { int temp = 25; struct oplus_chg_chip *chip = g_oplus_chip; struct smb_charger *chg = NULL; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: chip not ready!\n", __func__); return temp; } chg = &chip->pmic_spmi.smb5_chip->chg; if (IS_ERR_OR_NULL(chg->iio.btbtemp_v_chan)) { printk(KERN_ERR "[OPLUS_CHG][%s]: chg->iio.btbtemp_v_chan is NULL !\n", __func__); return temp; } iio_read_channel_processed(chg->iio.btbtemp_v_chan, &temp); temp /= 1000; pr_err("%s:btb_temp=%d\n", __func__, temp); return temp; } EXPORT_SYMBOL(oplus_chg_get_battery_btb_temp_cal); int oplus_chg_get_usb_btb_temp_cal(void) { int temp = 25; struct oplus_chg_chip *chip = g_oplus_chip; struct smb_charger *chg = NULL; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: chip not ready!\n", __func__); return temp; } chg = &chip->pmic_spmi.smb5_chip->chg; if (IS_ERR_OR_NULL(chg->iio.usbtemp_v_chan)) { printk(KERN_ERR "[OPLUS_CHG][%s]: chg->iio.usbtemp_v_chan is NULL !\n", __func__); return temp; } temp = get_btb_temp(chg->iio.usbtemp_v_chan); return temp; } EXPORT_SYMBOL(oplus_chg_get_usb_btb_temp_cal); bool oplus_chg_check_pd_svooc_adapater(void) { return g_oplus_chip->pd_svooc; } EXPORT_SYMBOL(oplus_chg_check_pd_svooc_adapater); void oplus_set_typec_sinkonly(void) { int rc; struct smb_charger *chg = NULL; if (!g_oplus_chip) { return; } chg = &g_oplus_chip->pmic_spmi.smb5_chip->chg; rc = smblib_masked_write(chg, TYPE_C_MODE_CFG_REG, TYPEC_POWER_ROLE_CMD_MASK | TYPEC_TRY_MODE_MASK, EN_SNK_ONLY_BIT); if (rc < 0) chg_err("fail to set sink mode, rc = %d\n", rc); return; }; static int oplus_dischg_gpio_init(struct oplus_chg_chip *chip) { if (!chip) { chg_err("chip NULL\n"); return EINVAL; } chip->normalchg_gpio.pinctrl = devm_pinctrl_get(chip->dev); if (IS_ERR_OR_NULL(chip->normalchg_gpio.pinctrl)) { chg_err("get dischg_pinctrl fail\n"); return -EINVAL; } chip->normalchg_gpio.dischg_enable = pinctrl_lookup_state(chip->normalchg_gpio.pinctrl, "dischg_enable"); if (IS_ERR_OR_NULL(chip->normalchg_gpio.dischg_enable)) { chg_err("get dischg_enable fail\n"); return -EINVAL; } chip->normalchg_gpio.dischg_disable = pinctrl_lookup_state(chip->normalchg_gpio.pinctrl, "dischg_disable"); if (IS_ERR_OR_NULL(chip->normalchg_gpio.dischg_disable)) { chg_err("get dischg_disable fail\n"); return -EINVAL; } pinctrl_select_state(chip->normalchg_gpio.pinctrl, chip->normalchg_gpio.dischg_disable); return 0; } static int usb_status = 0; void oplus_set_usb_status(int status) { usb_status = usb_status | status; } void oplus_clear_usb_status(int status) { if(g_oplus_chip->usb_status == USB_TEMP_HIGH) { g_oplus_chip->usb_status = g_oplus_chip->usb_status & (~USB_TEMP_HIGH); } usb_status = usb_status & (~status); } int oplus_get_usb_status(void) { if(g_oplus_chip->usb_status == USB_TEMP_HIGH) { return g_oplus_chip->usb_status; } else { return usb_status; } } #define USB_40C 40 #define USB_57C 57 #define USB_50C_VOLT 467//450 #define USB_55C_VOLT 400//384 #define USB_57C_VOLT 376//327 #define USB_100C_VOLT 100 // 100C #define VBUS_VOLT_THRESHOLD 400 //#define MIN_MONITOR_INTERVAL 50//50ms //#define MAX_MONITOR_INTERVAL 200//200ms #define VBUS_MONITOR_INTERVAL 3000//3s #define MIN_MONITOR_INTERVAL 50//50ms #define MAX_MONITOR_INTERVAL 50//50ms #define RETRY_CNT_DELAY 5 //ms #define HIGH_TEMP_SHORT_CHECK_TIMEOUT 1000 /*ms*/ /* static void get_usb_temp(struct oplus_chg_chip *chg) { int i = 0; for (i = ARRAY_SIZE(con_volt_855) - 1; i >= 0; i--) { if (con_volt_855[i] >= chg->usbtemp_volt_l) break; else if (i == 0) break; } chg->usb_temp_l = con_temp_855[i]; for (i = ARRAY_SIZE(con_volt_855) - 1; i >= 0; i--) { if (con_volt_855[i] >= chg->usbtemp_volt_r) break; else if (i == 0) break; } chg->usb_temp_r = con_temp_855[i]; //chg_err("usb_temp_l:%d, usb_temp_r:%d\n",chg->usb_temp_l, chg->usb_temp_r); } static bool oplus_usb_or_otg_is_present(void) { int rc = 0; u8 stat = 0; bool vbus_rising = false; struct oplus_chg_chip *chip = g_oplus_chip; if (!chip) return false; if (chip->pmic_spmi.smb5_chip->chg.typec_mode >= POWER_SUPPLY_TYPEC_SINK && chip->pmic_spmi.smb5_chip->chg.typec_mode <= POWER_SUPPLY_TYPEC_POWERED_CABLE_ONLY){ //chg_err("chg->typec_mode = SINK,oplus_usb_or_otg_is_present return true!\n"); return true ; } rc = smblib_read(&chip->pmic_spmi.smb5_chip->chg, USBIN_BASE + INT_RT_STS_OFFSET, &stat); if (rc < 0) { chg_err("Couldn't read USB_INT_RT_STS, rc=%d\n", rc); return false; } vbus_rising = (bool)(stat & USBIN_PLUGIN_RT_STS_BIT); if (vbus_rising == false && oplus_vooc_get_fastchg_started() == true) { if (qpnp_get_prop_charger_voltage_now() > 2000 || chip->vbatt_num == 2) { chg_err("USBIN_PLUGIN_RT_STS_BIT low but fastchg started true and (chg vol > 2V or SVOOC)\n"); vbus_rising = true; } } return vbus_rising; } static int oplus_usbtemp_dischg_action(struct oplus_chg_chip *chip) { int rc = 0; struct smb_charger *chg = NULL; chg = &chip->pmic_spmi.smb5_chip->chg; //#ifndef CONFIG_HIGH_TEMP_VERSION if (get_eng_version() != HIGH_TEMP_AGING) { oplus_set_usb_status(USB_TEMP_HIGH); oplus_ccdetect_disable(); if (oplus_vooc_get_fastchg_started() == true) { oplus_chg_set_chargerid_switch_val(0); oplus_vooc_switch_mode(NORMAL_CHARGER_MODE); oplus_vooc_reset_mcu(); //msleep(20);//wait for turn-off fastchg MOS } usleep_range(10000,10000);///msleep(10); chip->chg_ops->charger_suspend(); usleep_range(10000,10000); rc = smblib_masked_write(chg, TYPE_C_MODE_CFG_REG, TYPEC_POWER_ROLE_CMD_MASK | TYPEC_TRY_MODE_MASK, EN_SNK_ONLY_BIT); if (rc < 0) chg_err("fail to set sink mode, rc = %d\n", rc); usleep_range(10000,10000); } //#endif mutex_lock(&chg->pinctrl_mutex); //#ifdef CONFIG_HIGH_TEMP_VERSION if (get_eng_version() == HIGH_TEMP_AGING) { chg_err(" CONFIG_HIGH_TEMP_VERSION enable here,do not set vbus down \n"); rc = pinctrl_select_state(chip->normalchg_gpio.pinctrl, chip->normalchg_gpio.dischg_disable); } else { //#else rc = pinctrl_select_state(chip->normalchg_gpio.pinctrl, chip->normalchg_gpio.dischg_enable); } //#endif mutex_unlock(&chg->pinctrl_mutex); return 0; } static void oplus_usbtemp_clear_dischg(struct oplus_chg_chip *chip) { int rc = 0; struct smb_charger *chg = NULL; chg_err(" oplus_usbtemp_clear_dischg \n"); chg = &chip->pmic_spmi.smb5_chip->chg; oplus_clear_usb_status(USB_TEMP_HIGH); if (oplus_usbtemp_check_is_support() == true) { mutex_lock(&chg->pinctrl_mutex); rc = pinctrl_select_state(chip->normalchg_gpio.pinctrl, chip->normalchg_gpio.dischg_disable); mutex_unlock(&chg->pinctrl_mutex); } } */ int usbtemp_get_charger_voltage_now(void) { int val = 0, rc = 0; union power_supply_propval pval = {0, }; struct smb_charger *chg = NULL; struct oplus_chg_chip *chip = g_oplus_chip; if (!chip) return 0; //if (!oplus_chg_is_usb_present()) // return 0; chg = &chip->pmic_spmi.smb5_chip->chg; rc = smblib_get_prop_usb_present(chg, &pval); if (rc < 0) { chg_err("Couldn't get usb presence status rc=%d\n", rc); return -ENODATA; } /* usb not present */ if (!pval.intval) { val = 0; return 0; } if (chg->chg_param.smb_version != PM8150B_SUBTYPE) { if (!chg->iio.usbin_v_chan || PTR_ERR(chg->iio.usbin_v_chan) == -EPROBE_DEFER) chg->iio.usbin_v_chan = iio_channel_get(chg->dev, "usbin_v"); if (IS_ERR(chg->iio.usbin_v_chan)) return PTR_ERR(chg->iio.usbin_v_chan); iio_read_channel_processed(chg->iio.usbin_v_chan, &val); } else { if (!chg->iio.mid_chan || PTR_ERR(chg->iio.mid_chan) == -EPROBE_DEFER) chg->iio.mid_chan = iio_channel_get(chg->dev, "mid_voltage"); if (IS_ERR(chg->iio.mid_chan)) return PTR_ERR(chg->iio.mid_chan); iio_read_channel_processed(chg->iio.mid_chan, &val); //if ((val / 1000) < chip->batt_volt) { //if (oplus_vooc_get_fastchg_started() == true) { //val = (chip->batt_volt + 300) * 1000 ; //} //} } //val = (val + 500) * 1000 ; if (val < 2000 * 1000) chg->pre_current_ma = -1; return val / 1000 + 320; } bool oplus_usbtemp_condition(void) { int rc; bool vbus_rising; u8 stat; int level = -1; struct smb_charger *chg = NULL; chg = &g_oplus_chip->pmic_spmi.smb5_chip->chg; if (!g_oplus_chip) { chg_err("fail to init oplus_chip\n"); return false; } /*power off charging without usbtemp detect if(qpnp_is_power_off_charging() == true){ chg_err("power off chargering return false\n"); return false; } */ #ifdef OPLUS_CUSTOM_OP_DEF if(chg->wireless_present) { return false; } #endif if (chg->typec_mode >= POWER_SUPPLY_TYPEC_SINK && chg->typec_mode <= POWER_SUPPLY_TYPEC_POWERED_CABLE_ONLY) return false; if(oplus_ccdetect_check_is_gpio(g_oplus_chip)){ level = gpio_get_value(chg->ccdetect_gpio); if(level == 1){ return false; } return true; } rc = smblib_read(chg, USBIN_BASE + INT_RT_STS_OFFSET, &stat); if (rc < 0) { chg_err("fail to read pmic register, rc = %d\n", rc); return false; } vbus_rising = (bool)(stat & USBIN_PLUGIN_RT_STS_BIT); if (vbus_rising == true) return true; return false; } static void oplus_usbtemp_thread_init(void) { struct oplus_chg_chip *chip = g_oplus_chip; struct smb_charger *chg; int rc = 0; if (!chip) { return; } chg =&chip->pmic_spmi.smb5_chip->chg; oplus_usbtemp_kthread = kthread_run(oplus_usbtemp_monitor_common, g_oplus_chip, "usbtemp_kthread"); if (IS_ERR(oplus_usbtemp_kthread)) { chg_err("failed to cread oplus_usbtemp_kthread\n"); } if(chg && chg->adc_check_pulse) { rc = smblib_masked_write(chg,ADC_CHECK_HIGH_LEVEL_1,BIT(5) | BIT(4), 0); if (rc < 0) { dev_err(chg->dev, "Couldn't configure 0x1282 rc=%d\n", rc); } rc = smblib_masked_write(chg,ADC_CHECK_HIGH_LEVEL_2,BIT(5) | BIT(4), 0); if (rc < 0) { dev_err(chg->dev, "Couldn't configure 0x1283 rc=%d\n", rc); } } } void oplus_wake_up_usbtemp_thread(void) { struct oplus_chg_chip *chip = g_oplus_chip; int rc =0; struct smb_charger *chg; u8 val; if (!chip) { return; } chg =&chip->pmic_spmi.smb5_chip->chg; if (oplus_usbtemp_check_is_support() == true) { chip->usbtemp_check = oplus_usbtemp_condition(); if (chip->usbtemp_check) wake_up_interruptible(&chip->oplus_usbtemp_wq); } if(chg && chg->adc_check_pulse) { rc = smblib_read(chg, ADC_CHECK_HIGH_LEVEL_3, &val); if (rc < 0) { dev_err(chg->dev, "Couldn't configure 0x3546 rc=%d\n", rc); } if(val != 0) { rc = smblib_masked_write(chg,ADC_CHECK_HIGH_LEVEL_3, BIT(7), 0); if (rc < 0) { dev_err(chg->dev, "Couldn't configure 0x3546 rc=%d\n", rc); } } } } static int oplus_chg_parse_custom_dt(struct oplus_chg_chip *chip) { int rc = 0; struct device_node *node = chip->dev->of_node; struct smb_charger *chg = &chip->pmic_spmi.smb5_chip->chg; if (!node) { pr_err("device tree node missing\n"); return -EINVAL; } #ifdef OPLUS_FEATURE_CHG_BASIC if (g_oplus_chip) { #ifdef OPLUS_CUSTOM_OP_DEF // PVT GPIO handling g_oplus_chip->normalchg_gpio.chargerid_switch_gpio_pvt = of_get_named_gpio(node, "qcom,chargerid_switch-gpio-pvt", 0); if (g_oplus_chip->normalchg_gpio.chargerid_switch_gpio_pvt <= 0) { chg_err("*** Couldn't read chargerid_switch-gpio-pvt ***\n"); } else { if (gpio_is_valid(g_oplus_chip->normalchg_gpio.chargerid_switch_gpio_pvt)) { rc = gpio_request(g_oplus_chip->normalchg_gpio.chargerid_switch_gpio_pvt, "chargerid_switch-gpio-pvt"); if (rc) { chg_err("unable to request chargerid_switch_gpio_pvt, rc=%d\n", rc); } } } chg_err("chargerid_switch_gpio_pvt:%d\n", g_oplus_chip->normalchg_gpio.chargerid_switch_gpio_pvt); #endif g_oplus_chip->normalchg_gpio.chargerid_switch_gpio = of_get_named_gpio(node, "qcom,chargerid_switch-gpio", 0); if (g_oplus_chip->normalchg_gpio.chargerid_switch_gpio <= 0) { chg_err("Couldn't read chargerid_switch-gpio rc = %d, chargerid_switch_gpio:%d\n", rc, g_oplus_chip->normalchg_gpio.chargerid_switch_gpio); } else { if (gpio_is_valid(g_oplus_chip->normalchg_gpio.chargerid_switch_gpio)) { rc = gpio_request(g_oplus_chip->normalchg_gpio.chargerid_switch_gpio, "chargerid-switch-gpio"); if (rc) { chg_err("unable to request chargerid_switch_gpio:%d\n", g_oplus_chip->normalchg_gpio.chargerid_switch_gpio); } else { smbchg_chargerid_switch_gpio_init(g_oplus_chip); } } chg_err("chargerid_switch_gpio:%d\n", g_oplus_chip->normalchg_gpio.chargerid_switch_gpio); } } #endif /*OPLUS_FEATURE_CHG_BASIC*/ #ifdef OPLUS_FEATURE_CHG_BASIC if (g_oplus_chip) { g_oplus_chip->normalchg_gpio.dischg_gpio = of_get_named_gpio(node, "qcom,dischg-gpio", 0); if (g_oplus_chip->normalchg_gpio.dischg_gpio <= 0) { chg_err("Couldn't read qcom,dischg-gpio rc=%d, qcom,dischg-gpio:%d\n", rc, g_oplus_chip->normalchg_gpio.dischg_gpio); } else { if (oplus_usbtemp_check_is_support() == true) { if (gpio_is_valid(g_oplus_chip->normalchg_gpio.dischg_gpio)) { rc = gpio_request(g_oplus_chip->normalchg_gpio.dischg_gpio, "dischg-gpio"); if (rc) { chg_err("unable to request dischg-gpio:%d\n", g_oplus_chip->normalchg_gpio.dischg_gpio); } else { oplus_dischg_gpio_init(g_oplus_chip); } } } chg_err("dischg-gpio:%d\n", g_oplus_chip->normalchg_gpio.dischg_gpio); } } #endif /*OPLUS_FEATURE_CHG_BASIC*/ #ifdef OPLUS_FEATURE_CHG_BASIC if (g_oplus_chip) { g_oplus_chip->normalchg_gpio.ship_gpio = of_get_named_gpio(node, "qcom,ship-gpio", 0); if (g_oplus_chip->normalchg_gpio.ship_gpio <= 0) { chg_err("Couldn't read qcom,ship-gpio rc = %d, qcom,ship-gpio:%d\n", rc, g_oplus_chip->normalchg_gpio.ship_gpio); } else { if (oplus_ship_check_is_gpio(g_oplus_chip) == true) { rc = gpio_request(g_oplus_chip->normalchg_gpio.ship_gpio, "ship-gpio"); if (rc) { chg_err("unable to request ship-gpio:%d\n", g_oplus_chip->normalchg_gpio.ship_gpio); } else { oplus_ship_gpio_init(g_oplus_chip); if (rc) chg_err("unable to init ship-gpio:%d\n", g_oplus_chip->normalchg_gpio.ship_gpio); } } chg_err("ship-gpio:%d\n", g_oplus_chip->normalchg_gpio.ship_gpio); } } #endif /*OPLUS_FEATURE_CHG_BASIC*/ #ifdef OPLUS_FEATURE_CHG_BASIC if (g_oplus_chip) { g_oplus_chip->normalchg_gpio.shortc_gpio = of_get_named_gpio(node, "qcom,shortc-gpio", 0); if (g_oplus_chip->normalchg_gpio.shortc_gpio <= 0) { chg_err("Couldn't read qcom,shortc-gpio rc = %d, qcom,shortc-gpio:%d\n", rc, g_oplus_chip->normalchg_gpio.shortc_gpio); } else { if (oplus_shortc_check_is_gpio(g_oplus_chip) == true) { rc = gpio_request(g_oplus_chip->normalchg_gpio.shortc_gpio, "shortc-gpio"); if (rc) { chg_err("unable to request shortc-gpio:%d\n", g_oplus_chip->normalchg_gpio.shortc_gpio); } else { oplus_shortc_gpio_init(g_oplus_chip); if (rc) chg_err("unable to init ship-gpio:%d\n", g_oplus_chip->normalchg_gpio.ship_gpio); } } chg_err("shortc-gpio:%d\n", g_oplus_chip->normalchg_gpio.shortc_gpio); } } #endif /* OPLUS_FEATURE_CHG_BASIC */ #ifdef OPLUS_FEATURE_CHG_BASIC if (g_oplus_chip) { chg->shipmode_id_gpio = of_get_named_gpio(node, "qcom,shipmode-id-gpio", 0); if (chg->shipmode_id_gpio <= 0) { chg_err("Couldn't read qcom,shipmode-id-gpio rc = %d, qcom,shipmode-id-gpio:%d\n", rc, chg->shipmode_id_gpio); } else { if (oplus_shipmode_id_check_is_gpio(g_oplus_chip) == true) { rc = gpio_request(chg->shipmode_id_gpio, "qcom,shipmode-id-gpio"); if (rc) { chg_err("unable to request qcom,shipmode-id-gpio:%d\n", chg->shipmode_id_gpio); } else { oplus_shipmode_id_gpio_init(g_oplus_chip); if (rc) chg_err("unable to init qcom,shipmode-id-gpio:%d\n", chg->shipmode_id_gpio); } } chg_err("qcom,shipmode-id-gpio:%d\n", chg->shipmode_id_gpio); } } #endif /* OPLUS_FEATURE_CHG_BASIC */ #ifdef OPLUS_FEATURE_CHG_BASIC if (chip) { chg->ccdetect_gpio = of_get_named_gpio(node, "qcom,ccdetect-gpio", 0); if (chg->ccdetect_gpio <= 0) { chg_err("Couldn't read qcom,ccdetect-gpio rc=%d, qcom,ccdetect-gpio:%d\n", rc, chg->ccdetect_gpio); } else { if (oplus_ccdetect_check_is_gpio(chip) == true) { rc = gpio_request(chg->ccdetect_gpio, "ccdetect-gpio"); if (rc) { chg_err("unable to request ccdetect-gpio:%d\n", chg->ccdetect_gpio); } else { rc = oplus_ccdetect_gpio_init(chip); if (rc) chg_err("unable to init ccdetect-gpio:%d\n", chg->ccdetect_gpio); else oplus_ccdetect_irq_init(chip); } } chg_err("ccdetect-gpio:%d\n", chg->ccdetect_gpio); } } #endif /*OPLUS_FEATURE_CHG_BASIC*/ #ifdef OPLUS_FEATURE_CHG_BASIC if (chip) { chg->wired_conn_gpio = of_get_named_gpio(node, "qcom,wired_conn-gpio", 0); if (chg->wired_conn_gpio <= 0) { chg_err("Couldn't read qcom,wired_conn-gpio rc=%d, qcom,wired_conn-gpio:%d\n", rc, chg->wired_conn_gpio); } else { if (oplus_wired_conn_check_is_gpio(chip) == true) { rc = gpio_request(chg->wired_conn_gpio, "wired_conn-gpio"); if (rc) { chg_err("unable to request wired_conn-gpio:%d\n", chg->wired_conn_gpio); } else { rc = oplus_wired_conn_gpio_init(chip); if (rc) chg_err("unable to init wired_conn-gpio:%d\n", chg->wired_conn_gpio); else oplus_wired_conn_irq_init(chip); } } chg_err("wired_conn-gpio:%d\n", chg->wired_conn_gpio); } chg_err("tongfeng test wired_conn-gpio\n"); } #endif /*OPLUS_FEATURE_CHG_BASIC*/ #ifdef OPLUS_FEATURE_CHG_BASIC if (chip) { chg->otg_en_gpio = of_get_named_gpio(node, "qcom,otg_en-gpio", 0); if (chg->otg_en_gpio <= 0) { chg_err("Couldn't read qcom,otg_en-gpio rc=%d, qcom,otg_en-gpio:%d\n", rc, chg->otg_en_gpio); } else { if (1){///oplus_wired_conn_check_is_gpio(chip) == true) { rc = gpio_request(chg->otg_en_gpio, "otg_en-gpio"); if (rc) { chg_err("unable to request otg_en-gpio:%d\n", chg->otg_en_gpio); } else { rc = oplus_otg_en_gpio_init(chip); if (rc) chg_err("unable to init wired_conn-gpio:%d\n", chg->otg_en_gpio); //else // oplus_wired_conn_irq_init(chip); } } chg_err("otg_en-gpio:%d\n", chg->otg_en_gpio); } chg_err("tongfeng test otg_en-gpio\n"); } #endif /*OPLUS_FEATURE_CHG_BASIC*/ #ifdef OPLUS_FEATURE_CHG_BASIC if (chip) { printk(KERN_ERR "[OPLUS_CHG][%s]:11111 tongfeng test start chg = %p!\n", __func__, chg); chg->idt_en_gpio = of_get_named_gpio(node, "qcom,idt_en-gpio", 0); if (chg->idt_en_gpio <= 0) { chg_err("Couldn't read qcom,idt_en-gpio rc=%d, qcom,idt_en-gpio:%d\n", rc, chg->idt_en_gpio); } else { if (1){//oplus_mps_otg_en_check_is_gpio(chip) == true) { rc = gpio_request(chg->idt_en_gpio, "idt_en-gpio"); if (rc) { chg_err("unable to request idt_en-gpio:%d\n", chg->idt_en_gpio); } else { rc = oplus_idt_en_gpio_init(chip); if (rc) chg_err("unable to init idt_en-gpio:%d\n", chg->idt_en_gpio); //else // oplus_wired_conn_irq_init(chip); } } chg_err("idt-gpio:%d\n", chg->idt_en_gpio); } chg_err("tongfeng test idt_en-gpio\n"); } #endif /*OPLUS_FEATURE_CHG_BASIC*/ oplus_usbtemp_adc_gpio_init(chip); oplus_charger_int_gpio_init(chip); oplus_input_pg_gpio_init(chip); oplus_charger_error_gpio_init(chip); oplus_sc_mos_gpio_init(chip); return rc; } #endif static ssize_t pd_disabled_show(struct device *dev, struct device_attribute *attr, char *buf) { struct smb5 *chip = dev_get_drvdata(dev); struct smb_charger *chg = &chip->chg; return snprintf(buf, PAGE_SIZE, "%d\n", chg->pd_disabled); } static ssize_t pd_disabled_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int val; struct smb5 *chip = dev_get_drvdata(dev); struct smb_charger *chg = &chip->chg; if (kstrtos32(buf, 0, &val)) return -EINVAL; chg->pd_disabled = val; return count; } static DEVICE_ATTR_RW(pd_disabled); static ssize_t weak_chg_icl_ua_show(struct device *dev, struct device_attribute *attr, char *buf) { struct smb5 *chip = dev_get_drvdata(dev); struct smb_charger *chg = &chip->chg; return snprintf(buf, PAGE_SIZE, "%d\n", chg->weak_chg_icl_ua); } static ssize_t weak_chg_icl_ua_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int val; struct smb5 *chip = dev_get_drvdata(dev); struct smb_charger *chg = &chip->chg; if (kstrtos32(buf, 0, &val)) return -EINVAL; chg->weak_chg_icl_ua = val; return count; } static DEVICE_ATTR_RW(weak_chg_icl_ua); static struct attribute *smb5_attrs[] = { &dev_attr_pd_disabled.attr, &dev_attr_weak_chg_icl_ua.attr, NULL, }; ATTRIBUTE_GROUPS(smb5); enum { BAT_THERM = 0, MISC_THERM, CONN_THERM, SMB_THERM, }; static const struct clamp_config clamp_levels[] = { { {0x11C6, 0x11F9, 0x13F1}, {0x60, 0x2E, 0x90} }, { {0x11C6, 0x11F9, 0x13F1}, {0x60, 0x2B, 0x9C} }, }; #define PMI632_MAX_ICL_UA 3000000 #define PM6150_MAX_FCC_UA 3000000 static int smb5_chg_config_init(struct smb5 *chip) { struct smb_charger *chg = &chip->chg; struct pmic_revid_data *pmic_rev_id; struct device_node *revid_dev_node, *node = chg->dev->of_node; int rc = 0; revid_dev_node = of_parse_phandle(node, "qcom,pmic-revid", 0); if (!revid_dev_node) { pr_err("Missing qcom,pmic-revid property\n"); return -EINVAL; } pmic_rev_id = get_revid_data(revid_dev_node); if (IS_ERR_OR_NULL(pmic_rev_id)) { /* * the revid peripheral must be registered, any failure * here only indicates that the rev-id module has not * probed yet. */ rc = -EPROBE_DEFER; goto out; } switch (pmic_rev_id->pmic_subtype) { case PM8150B_SUBTYPE: chip->chg.chg_param.smb_version = PM8150B_SUBTYPE; chg->param = smb5_pm8150b_params; chg->name = "pm8150b_charger"; #ifdef OPLUS_FEATURE_CHG_BASIC chip->chg.wa_flags |= BOOST_BACK_WA; #endif chg->wa_flags |= CHG_TERMINATION_WA; break; case PM7250B_SUBTYPE: chip->chg.chg_param.smb_version = PM7250B_SUBTYPE; chg->param = smb5_pm8150b_params; chg->name = "pm7250b_charger"; chg->wa_flags |= CHG_TERMINATION_WA; chg->uusb_moisture_protection_capable = true; break; case PM6150_SUBTYPE: chip->chg.chg_param.smb_version = PM6150_SUBTYPE; chg->param = smb5_pm8150b_params; chg->name = "pm6150_charger"; chg->wa_flags |= SW_THERM_REGULATION_WA | CHG_TERMINATION_WA; if (pmic_rev_id->rev4 >= 2) chg->uusb_moisture_protection_capable = true; chg->main_fcc_max = PM6150_MAX_FCC_UA; break; case PMI632_SUBTYPE: chip->chg.chg_param.smb_version = PMI632_SUBTYPE; chg->wa_flags |= WEAK_ADAPTER_WA | USBIN_OV_WA | CHG_TERMINATION_WA | USBIN_ADC_WA | SKIP_MISC_PBS_IRQ_WA; chg->param = smb5_pmi632_params; chg->use_extcon = true; chg->name = "pmi632_charger"; /* PMI632 does not support PD */ chg->pd_not_supported = true; chg->lpd_disabled = true; if (pmic_rev_id->rev4 >= 2) chg->uusb_moisture_protection_enabled = true; chg->hw_max_icl_ua = (chip->dt.usb_icl_ua > 0) ? chip->dt.usb_icl_ua : PMI632_MAX_ICL_UA; break; default: pr_err("PMIC subtype %d not supported\n", pmic_rev_id->pmic_subtype); rc = -EINVAL; goto out; } chg->chg_freq.freq_5V = 600; chg->chg_freq.freq_6V_8V = 800; chg->chg_freq.freq_9V = 1050; chg->chg_freq.freq_12V = 1200; chg->chg_freq.freq_removal = 1050; chg->chg_freq.freq_below_otg_threshold = 800; chg->chg_freq.freq_above_otg_threshold = 800; if (of_property_read_bool(node, "qcom,disable-sw-thermal-regulation")) chg->wa_flags &= ~SW_THERM_REGULATION_WA; if (of_property_read_bool(node, "qcom,disable-fcc-restriction")) chg->main_fcc_max = -EINVAL; out: of_node_put(revid_dev_node); return rc; } #define PULL_NO_PULL 0 #define PULL_30K 30 #define PULL_100K 100 #define PULL_400K 400 static int get_valid_pullup(int pull_up) { /* pull up can only be 0/30K/100K/400K) */ switch (pull_up) { case PULL_NO_PULL: return INTERNAL_PULL_NO_PULL; case PULL_30K: return INTERNAL_PULL_30K_PULL; case PULL_100K: return INTERNAL_PULL_100K_PULL; case PULL_400K: return INTERNAL_PULL_400K_PULL; default: return INTERNAL_PULL_100K_PULL; } } #define INTERNAL_PULL_UP_MASK 0x3 static int smb5_configure_internal_pull(struct smb_charger *chg, int type, int pull) { int rc; int shift = type * 2; u8 mask = INTERNAL_PULL_UP_MASK << shift; u8 val = pull << shift; rc = smblib_masked_write(chg, BATIF_ADC_INTERNAL_PULL_UP_REG, mask, val); if (rc < 0) dev_err(chg->dev, "Couldn't configure ADC pull-up reg rc=%d\n", rc); return rc; } #ifndef OPLUS_FEATURE_CHG_BASIC #define MICRO_1P5A 1500000 #else #define MICRO_1P5A 1000000 #endif #define MICRO_P1A 100000 #define MICRO_1PA 1000000 #ifndef OPLUS_FEATURE_CHG_BASIC #define MICRO_3PA 3000000 #else #define MICRO_3PA 1500000 #endif #define OTG_DEFAULT_DEGLITCH_TIME_MS 50 #define DEFAULT_WD_BARK_TIME 64 #define DEFAULT_WD_SNARL_TIME_8S 0x07 #define DEFAULT_FCC_STEP_SIZE_UA 100000 #define DEFAULT_FCC_STEP_UPDATE_DELAY_MS 1000 static int smb5_parse_dt_misc(struct smb5 *chip, struct device_node *node) { int rc = 0, byte_len; struct smb_charger *chg = &chip->chg; of_property_read_u32(node, "qcom,sec-charger-config", &chip->dt.sec_charger_config); chg->sec_cp_present = chip->dt.sec_charger_config == POWER_SUPPLY_CHARGER_SEC_CP || chip->dt.sec_charger_config == POWER_SUPPLY_CHARGER_SEC_CP_PL; chg->sec_pl_present = chip->dt.sec_charger_config == POWER_SUPPLY_CHARGER_SEC_PL || chip->dt.sec_charger_config == POWER_SUPPLY_CHARGER_SEC_CP_PL; chg->soc_ready_check = of_property_read_bool(node, "qcom,soc-ready-check"); chg->step_chg_enabled = of_property_read_bool(node, "qcom,step-charging-enable"); chg->typec_legacy_use_rp_icl = of_property_read_bool(node, "qcom,typec-legacy-rp-icl"); chg->sw_jeita_enabled = of_property_read_bool(node, "qcom,sw-jeita-enable"); chg->pd_not_supported = chg->pd_not_supported || of_property_read_bool(node, "qcom,usb-pd-disable"); chg->lpd_disabled = of_property_read_bool(node, "qcom,lpd-disable"); rc = of_property_read_u32(node, "qcom,wd-bark-time-secs", &chip->dt.wd_bark_time); if (rc < 0 || chip->dt.wd_bark_time < MIN_WD_BARK_TIME) chip->dt.wd_bark_time = DEFAULT_WD_BARK_TIME; rc = of_property_read_u32(node, "qcom,wd-snarl-time-config", &chip->dt.wd_snarl_time_cfg); if (rc < 0) chip->dt.wd_snarl_time_cfg = DEFAULT_WD_SNARL_TIME_8S; chip->dt.no_battery = of_property_read_bool(node, "qcom,batteryless-platform"); if (of_find_property(node, "qcom,thermal-mitigation", &byte_len)) { chg->thermal_mitigation = devm_kzalloc(chg->dev, byte_len, GFP_KERNEL); if (chg->thermal_mitigation == NULL) return -ENOMEM; chg->thermal_levels = byte_len / sizeof(u32); rc = of_property_read_u32_array(node, "qcom,thermal-mitigation", chg->thermal_mitigation, chg->thermal_levels); if (rc < 0) { dev_err(chg->dev, "Couldn't read threm limits rc = %d\n", rc); return rc; } } rc = of_property_read_u32(node, "qcom,charger-temp-max", &chg->charger_temp_max); if (rc < 0) chg->charger_temp_max = -EINVAL; rc = of_property_read_u32(node, "qcom,smb-temp-max", &chg->smb_temp_max); if (rc < 0) chg->smb_temp_max = -EINVAL; rc = of_property_read_u32(node, "qcom,float-option", &chip->dt.float_option); if (!rc && (chip->dt.float_option < 0 || chip->dt.float_option > 4)) { pr_err("qcom,float-option is out of range [0, 4]\n"); return -EINVAL; } chip->dt.hvdcp_disable = of_property_read_bool(node, "qcom,hvdcp-disable"); chg->hvdcp_disable = chip->dt.hvdcp_disable; chip->dt.hvdcp_autonomous = of_property_read_bool(node, "qcom,hvdcp-autonomous-enable"); chip->dt.auto_recharge_soc = -EINVAL; rc = of_property_read_u32(node, "qcom,auto-recharge-soc", &chip->dt.auto_recharge_soc); if (!rc && (chip->dt.auto_recharge_soc < 0 || chip->dt.auto_recharge_soc > 100)) { pr_err("qcom,auto-recharge-soc is incorrect\n"); return -EINVAL; } chg->auto_recharge_soc = chip->dt.auto_recharge_soc; chg->suspend_input_on_debug_batt = of_property_read_bool(node, "qcom,suspend-input-on-debug-batt"); rc = of_property_read_u32(node, "qcom,otg-deglitch-time-ms", &chg->otg_delay_ms); if (rc < 0) chg->otg_delay_ms = OTG_DEFAULT_DEGLITCH_TIME_MS; chg->fcc_stepper_enable = of_property_read_bool(node, "qcom,fcc-stepping-enable"); chg->adc_check_pulse = of_property_read_bool(node, "qcom,adc-check-pulse"); chg->low_voltage_charger = of_property_read_bool(node, "op,low-voltage-charger"); if (chg->uusb_moisture_protection_capable) chg->uusb_moisture_protection_enabled = of_property_read_bool(node, "qcom,uusb-moisture-protection-enable"); chg->hw_die_temp_mitigation = of_property_read_bool(node, "qcom,hw-die-temp-mitigation"); chg->hw_connector_mitigation = of_property_read_bool(node, "qcom,hw-connector-mitigation"); chg->hw_skin_temp_mitigation = of_property_read_bool(node, "qcom,hw-skin-temp-mitigation"); chg->en_skin_therm_mitigation = of_property_read_bool(node, "qcom,en-skin-therm-mitigation"); chg->connector_pull_up = -EINVAL; of_property_read_u32(node, "qcom,connector-internal-pull-kohm", &chg->connector_pull_up); chip->dt.disable_suspend_on_collapse = of_property_read_bool(node, "qcom,disable-suspend-on-collapse"); chg->smb_pull_up = -EINVAL; of_property_read_u32(node, "qcom,smb-internal-pull-kohm", &chg->smb_pull_up); chip->dt.adc_based_aicl = of_property_read_bool(node, "qcom,adc-based-aicl"); of_property_read_u32(node, "qcom,fcc-step-delay-ms", &chg->chg_param.fcc_step_delay_ms); if (chg->chg_param.fcc_step_delay_ms <= 0) chg->chg_param.fcc_step_delay_ms = DEFAULT_FCC_STEP_UPDATE_DELAY_MS; of_property_read_u32(node, "qcom,fcc-step-size-ua", &chg->chg_param.fcc_step_size_ua); if (chg->chg_param.fcc_step_size_ua <= 0) chg->chg_param.fcc_step_size_ua = DEFAULT_FCC_STEP_SIZE_UA; /* * If property is present parallel charging with CP is disabled * with HVDCP3 adapter. */ chg->hvdcp3_standalone_config = of_property_read_bool(node, "qcom,hvdcp3-standalone-config"); of_property_read_u32(node, "qcom,hvdcp3-max-icl-ua", &chg->chg_param.hvdcp3_max_icl_ua); if (chg->chg_param.hvdcp3_max_icl_ua <= 0) chg->chg_param.hvdcp3_max_icl_ua = MICRO_3PA; g_oplus_chip->usbtemp_chan_tmp = of_property_read_bool(node, "qcom,usbtemp_chan_tmp"); return 0; } static int smb5_parse_dt_adc_channels(struct smb_charger *chg) { int rc = 0; rc = smblib_get_iio_channel(chg, "mid_voltage", &chg->iio.mid_chan); if (rc < 0) return rc; rc = smblib_get_iio_channel(chg, "usb_in_voltage", &chg->iio.usbin_v_chan); if (rc < 0) return rc; rc = smblib_get_iio_channel(chg, "chg_temp", &chg->iio.temp_chan); if (rc < 0) return rc; rc = smblib_get_iio_channel(chg, "usb_in_current", &chg->iio.usbin_i_chan); if (rc < 0) return rc; rc = smblib_get_iio_channel(chg, "sbux_res", &chg->iio.sbux_chan); if (rc < 0) return rc; rc = smblib_get_iio_channel(chg, "vph_voltage", &chg->iio.vph_v_chan); if (rc < 0) return rc; rc = smblib_get_iio_channel(chg, "die_temp", &chg->iio.die_temp_chan); if (rc < 0) return rc; rc = smblib_get_iio_channel(chg, "conn_temp", &chg->iio.connector_temp_chan); if (rc < 0) return rc; rc = smblib_get_iio_channel(chg, "skin_temp", &chg->iio.skin_temp_chan); if (rc < 0) return rc; rc = smblib_get_iio_channel(chg, "smb_temp", &chg->iio.smb_temp_chan); if (rc < 0) return rc; return 0; } static int smb5_parse_dt_currents(struct smb5 *chip, struct device_node *node) { int rc = 0, tmp; struct smb_charger *chg = &chip->chg; rc = of_property_read_u32(node, "qcom,fcc-max-ua", &chip->dt.batt_profile_fcc_ua); if (rc < 0) chip->dt.batt_profile_fcc_ua = -EINVAL; rc = of_property_read_u32(node, "qcom,usb-icl-ua", &chip->dt.usb_icl_ua); if (rc < 0) chip->dt.usb_icl_ua = -EINVAL; #ifndef OPLUS_FEATURE_CHG_BASIC chg->dcp_icl_ua = chip->dt.usb_icl_ua; #else chg->dcp_icl_ua = -EINVAL; #endif rc = of_property_read_u32(node, "qcom,otg-cl-ua", &chg->otg_cl_ua); if (rc < 0) chg->otg_cl_ua = (chip->chg.chg_param.smb_version == PMI632_SUBTYPE) ? MICRO_1PA : MICRO_3PA; rc = of_property_read_u32(node, "qcom,chg-term-src", &chip->dt.term_current_src); if (rc < 0) chip->dt.term_current_src = ITERM_SRC_UNSPECIFIED; if (chip->dt.term_current_src == ITERM_SRC_ADC) rc = of_property_read_u32(node, "qcom,chg-term-base-current-ma", &chip->dt.term_current_thresh_lo_ma); rc = of_property_read_u32(node, "qcom,chg-term-current-ma", &chip->dt.term_current_thresh_hi_ma); chg->wls_icl_ua = DCIN_ICL_MAX_UA; rc = of_property_read_u32(node, "qcom,wls-current-max-ua", &tmp); if (!rc && tmp < DCIN_ICL_MAX_UA) chg->wls_icl_ua = tmp; return 0; } static int smb5_parse_dt_voltages(struct smb5 *chip, struct device_node *node) { int rc = 0; rc = of_property_read_u32(node, "qcom,fv-max-uv", &chip->dt.batt_profile_fv_uv); if (rc < 0) chip->dt.batt_profile_fv_uv = -EINVAL; rc = of_property_read_u32(node, "qcom,chg-inhibit-threshold-mv", &chip->dt.chg_inhibit_thr_mv); if (!rc && (chip->dt.chg_inhibit_thr_mv < 0 || chip->dt.chg_inhibit_thr_mv > 300)) { pr_err("qcom,chg-inhibit-threshold-mv is incorrect\n"); return -EINVAL; } chip->dt.auto_recharge_vbat_mv = -EINVAL; rc = of_property_read_u32(node, "qcom,auto-recharge-vbat-mv", &chip->dt.auto_recharge_vbat_mv); if (!rc && (chip->dt.auto_recharge_vbat_mv < 0)) { pr_err("qcom,auto-recharge-vbat-mv is incorrect\n"); return -EINVAL; } return 0; } static int smb5_parse_dt(struct smb5 *chip) { struct smb_charger *chg = &chip->chg; struct device_node *node = chg->dev->of_node; int rc = 0; if (!node) { pr_err("device tree node missing\n"); return -EINVAL; } rc = smb5_parse_dt_voltages(chip, node); if (rc < 0) return rc; rc = smb5_parse_dt_currents(chip, node); if (rc < 0) return rc; rc = smb5_parse_dt_adc_channels(chg); if (rc < 0) return rc; rc = smb5_parse_dt_misc(chip, node); if (rc < 0) return rc; return 0; } static int smb5_set_prop_comp_clamp_level(struct smb_charger *chg, const union power_supply_propval *val) { int rc = 0, i; struct clamp_config clamp_config; enum comp_clamp_levels level; level = val->intval; if (level >= MAX_CLAMP_LEVEL) { pr_err("Invalid comp clamp level=%d\n", val->intval); return -EINVAL; } for (i = 0; i < ARRAY_SIZE(clamp_config.reg); i++) { rc = smblib_write(chg, clamp_levels[level].reg[i], clamp_levels[level].val[i]); if (rc < 0) dev_err(chg->dev, "Failed to configure comp clamp settings for reg=0x%04x rc=%d\n", clamp_levels[level].reg[i], rc); } chg->comp_clamp_level = val->intval; return rc; } /************************ * USB PSY REGISTRATION * ************************/ static enum power_supply_property smb5_usb_props[] = { POWER_SUPPLY_PROP_PRESENT, POWER_SUPPLY_PROP_ONLINE, POWER_SUPPLY_PROP_VOLTAGE_NOW, POWER_SUPPLY_PROP_PD_CURRENT_MAX, POWER_SUPPLY_PROP_CURRENT_MAX, POWER_SUPPLY_PROP_TYPE, POWER_SUPPLY_PROP_TYPEC_MODE, POWER_SUPPLY_PROP_TYPEC_POWER_ROLE, POWER_SUPPLY_PROP_TYPEC_CC_ORIENTATION, POWER_SUPPLY_PROP_LOW_POWER, POWER_SUPPLY_PROP_PD_ACTIVE, POWER_SUPPLY_PROP_INPUT_CURRENT_SETTLED, POWER_SUPPLY_PROP_INPUT_CURRENT_NOW, POWER_SUPPLY_PROP_BOOST_CURRENT, POWER_SUPPLY_PROP_PE_START, POWER_SUPPLY_PROP_CTM_CURRENT_MAX, POWER_SUPPLY_PROP_HW_CURRENT_MAX, POWER_SUPPLY_PROP_REAL_TYPE, POWER_SUPPLY_PROP_PD_VOLTAGE_MAX, POWER_SUPPLY_PROP_PD_VOLTAGE_MIN, POWER_SUPPLY_PROP_CONNECTOR_TYPE, POWER_SUPPLY_PROP_CONNECTOR_HEALTH, POWER_SUPPLY_PROP_VOLTAGE_MAX, POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, POWER_SUPPLY_PROP_VOLTAGE_MAX_LIMIT, POWER_SUPPLY_PROP_SMB_EN_MODE, POWER_SUPPLY_PROP_SMB_EN_REASON, POWER_SUPPLY_PROP_ADAPTER_CC_MODE, POWER_SUPPLY_PROP_SCOPE, POWER_SUPPLY_PROP_MOISTURE_DETECTED, POWER_SUPPLY_PROP_HVDCP_OPTI_ALLOWED, POWER_SUPPLY_PROP_QC_OPTI_DISABLE, POWER_SUPPLY_PROP_VOLTAGE_VPH, POWER_SUPPLY_PROP_THERM_ICL_LIMIT, POWER_SUPPLY_PROP_SKIN_HEALTH, }; #ifdef OPLUS_FEATURE_CHG_BASIC /************************************************************** * bit[0]=0: NO standard typec device/cable connected(ccdetect gpio in high level) * bit[0]=1: standard typec device/cable connected(ccdetect gpio in low level) * bit[1]=0: NO OTG typec device/cable connected * bit[1]=1: OTG typec device/cable connected **************************************************************/ #define DISCONNECT 0 #define STANDARD_TYPEC_DEV_CONNECT BIT(0) #define OTG_DEV_CONNECT BIT(1) bool oplus_get_otg_switch_status(void) { struct oplus_chg_chip *chip = g_oplus_chip; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb2_chg not ready!\n", __func__); return false; } return chip->otg_switch; } int oplus_get_otg_online_status(void) { union power_supply_propval val; int ret; int online = 0; int level = 0; int typec_otg = 0; static int pre_level = 1; static int pre_typec_otg = 0; struct smb_charger *chg = NULL; struct oplus_chg_chip *chip = g_oplus_chip; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return false; } chg = &chip->pmic_spmi.smb5_chip->chg; if (oplus_ccdetect_check_is_gpio(chip) == true) { level = gpio_get_value(chg->ccdetect_gpio); if (level != gpio_get_value(chg->ccdetect_gpio)) { printk(KERN_ERR "[OPLUS_CHG][%s]: ccdetect_gpio is unstable, try again...\n", __func__); usleep_range(5000, 5100); level = gpio_get_value(chg->ccdetect_gpio); } } online = (level == 1) ? DISCONNECT : STANDARD_TYPEC_DEV_CONNECT; ret = power_supply_get_property(chg->usb_psy, POWER_SUPPLY_PROP_TYPEC_MODE, &val); if (ret) { printk(KERN_ERR "%s: Unable to read USB TYPEC_MODE\n", __func__); val.intval = 0; } if (val.intval >= POWER_SUPPLY_TYPEC_SINK && val.intval <= POWER_SUPPLY_TYPEC_POWERED_CABLE_ONLY) { typec_otg = 1; } else { typec_otg = 0; } online = online | ((typec_otg == 1) ? OTG_DEV_CONNECT : DISCONNECT); if ((pre_level ^ level) || (pre_typec_otg ^ typec_otg)) { pre_level = level; pre_typec_otg = typec_otg; printk(KERN_ERR "[OPLUS_CHG][%s]: gpio[%s], c-otg[%d], otg_online[%d]\n", __func__, level ? "H" : "L", typec_otg, online); } chip->otg_online = typec_otg; return online; } void oplus_set_otg_switch_status(bool value) { int level = 0; struct smb_charger *chg = NULL; struct oplus_chg_chip *chip = g_oplus_chip; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return; } chg = &chip->pmic_spmi.smb5_chip->chg; /*boot-up with newman OTG connected, android will set persist.sys.oplus.otg_support, so...*/ if (oplus_ccdetect_check_is_gpio(chip) == true) { level = gpio_get_value(chg->ccdetect_gpio); if (level != 1) { printk(KERN_ERR "[OPLUS_CHG][%s]: gpio[%s], should set, return\n", __func__, level ? "H" : "L"); return; } } chip->otg_switch = !!value; if (value) { oplus_ccdetect_enable(); } else { oplus_ccdetect_disable(); } printk(KERN_ERR "[OPLUS_CHG][%s]: otg_switch=%d, otg_online=%d\n", __func__, chip->otg_switch, chip->otg_online); } #endif /* OPLUS_FEATURE_CHG_BASIC */ #ifdef OPLUS_FEATURE_CHG_BASIC static bool use_present_status = false; #endif static int smb5_usb_get_prop(struct power_supply *psy, enum power_supply_property psp, union power_supply_propval *val) { struct smb5 *chip = power_supply_get_drvdata(psy); struct smb_charger *chg = &chip->chg; int rc = 0; val->intval = 0; switch (psp) { case POWER_SUPPLY_PROP_PRESENT: rc = smblib_get_prop_usb_present(chg, val); break; case POWER_SUPPLY_PROP_ONLINE: #ifdef OPLUS_FEATURE_CHG_BASIC if (use_present_status) rc = smblib_get_prop_usb_present(chg, val); else rc = smblib_get_usb_online(chg, val); if ((oplus_chg_get_charger_type() == POWER_SUPPLY_TYPE_USB) || (oplus_chg_get_charger_type() == POWER_SUPPLY_TYPE_USB_CDP)) { val->intval = 1; } #else rc = smblib_get_usb_online(chg, val); #endif #ifdef OPLUS_FEATURE_CHG_BASIC /* Yichun.Chen PSW.BSP.CHG 2019-08-19 for c to c */ if ((chg->real_charger_type == POWER_SUPPLY_TYPE_USB_PD) && (opluschg_pd_sdp == true)) { val->intval = 1; break; } #endif break; case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: rc = smblib_get_prop_usb_voltage_max_design(chg, val); break; case POWER_SUPPLY_PROP_VOLTAGE_MAX: rc = smblib_get_prop_usb_voltage_max(chg, val); break; case POWER_SUPPLY_PROP_VOLTAGE_MAX_LIMIT: if (chg->usbin_forced_max_uv) val->intval = chg->usbin_forced_max_uv; else smblib_get_prop_usb_voltage_max_design(chg, val); break; case POWER_SUPPLY_PROP_VOLTAGE_NOW: rc = smblib_get_prop_usb_voltage_now(chg, val); break; case POWER_SUPPLY_PROP_PD_CURRENT_MAX: val->intval = get_client_vote(chg->usb_icl_votable, PD_VOTER); break; case POWER_SUPPLY_PROP_CURRENT_MAX: rc = smblib_get_prop_input_current_settled(chg, val); break; case POWER_SUPPLY_PROP_TYPE: val->intval = POWER_SUPPLY_TYPE_USB_PD; break; case POWER_SUPPLY_PROP_REAL_TYPE: val->intval = chg->real_charger_type; break; case POWER_SUPPLY_PROP_TYPEC_MODE: rc = smblib_get_usb_prop_typec_mode(chg, val); break; case POWER_SUPPLY_PROP_TYPEC_POWER_ROLE: rc = smblib_get_prop_typec_power_role(chg, val); break; case POWER_SUPPLY_PROP_TYPEC_CC_ORIENTATION: rc = smblib_get_prop_typec_cc_orientation(chg, val); break; case POWER_SUPPLY_PROP_TYPEC_SRC_RP: rc = smblib_get_prop_typec_select_rp(chg, val); break; case POWER_SUPPLY_PROP_LOW_POWER: rc = smblib_get_prop_low_power(chg, val); break; case POWER_SUPPLY_PROP_PD_ACTIVE: val->intval = chg->pd_active; break; case POWER_SUPPLY_PROP_INPUT_CURRENT_SETTLED: rc = smblib_get_prop_input_current_settled(chg, val); break; case POWER_SUPPLY_PROP_INPUT_CURRENT_NOW: #ifdef OPLUS_CUSTOM_OP_DEF val->intval = oplus_chg_get_charger_current(); #else rc = smblib_get_prop_usb_current_now(chg, val); #endif break; case POWER_SUPPLY_PROP_BOOST_CURRENT: val->intval = chg->boost_current_ua; break; case POWER_SUPPLY_PROP_PD_IN_HARD_RESET: rc = smblib_get_prop_pd_in_hard_reset(chg, val); break; case POWER_SUPPLY_PROP_PD_USB_SUSPEND_SUPPORTED: val->intval = chg->system_suspend_supported; break; case POWER_SUPPLY_PROP_PE_START: rc = smblib_get_pe_start(chg, val); break; case POWER_SUPPLY_PROP_CTM_CURRENT_MAX: val->intval = get_client_vote(chg->usb_icl_votable, CTM_VOTER); break; case POWER_SUPPLY_PROP_HW_CURRENT_MAX: rc = smblib_get_charge_current(chg, &val->intval); break; case POWER_SUPPLY_PROP_PR_SWAP: rc = smblib_get_prop_pr_swap_in_progress(chg, val); break; case POWER_SUPPLY_PROP_PD_VOLTAGE_MAX: val->intval = chg->voltage_max_uv; break; case POWER_SUPPLY_PROP_PD_VOLTAGE_MIN: val->intval = chg->voltage_min_uv; break; case POWER_SUPPLY_PROP_SDP_CURRENT_MAX: val->intval = get_client_vote(chg->usb_icl_votable, USB_PSY_VOTER); break; case POWER_SUPPLY_PROP_CONNECTOR_TYPE: val->intval = chg->connector_type; break; case POWER_SUPPLY_PROP_CONNECTOR_HEALTH: val->intval = smblib_get_prop_connector_health(chg); break; case POWER_SUPPLY_PROP_SCOPE: rc = smblib_get_prop_scope(chg, val); break; case POWER_SUPPLY_PROP_SMB_EN_MODE: mutex_lock(&chg->smb_lock); val->intval = chg->sec_chg_selected; mutex_unlock(&chg->smb_lock); break; case POWER_SUPPLY_PROP_SMB_EN_REASON: val->intval = chg->cp_reason; break; case POWER_SUPPLY_PROP_MOISTURE_DETECTED: val->intval = chg->moisture_present; break; case POWER_SUPPLY_PROP_HVDCP_OPTI_ALLOWED: val->intval = !chg->flash_active; break; case POWER_SUPPLY_PROP_QC_OPTI_DISABLE: if (chg->hw_die_temp_mitigation) val->intval = POWER_SUPPLY_QC_THERMAL_BALANCE_DISABLE | POWER_SUPPLY_QC_INOV_THERMAL_DISABLE; if (chg->hw_connector_mitigation) val->intval |= POWER_SUPPLY_QC_CTM_DISABLE; break; case POWER_SUPPLY_PROP_VOLTAGE_VPH: rc = smblib_get_prop_vph_voltage_now(chg, val); break; case POWER_SUPPLY_PROP_THERM_ICL_LIMIT: val->intval = get_client_vote(chg->usb_icl_votable, THERMAL_THROTTLE_VOTER); break; case POWER_SUPPLY_PROP_ADAPTER_CC_MODE: val->intval = chg->adapter_cc_mode; break; case POWER_SUPPLY_PROP_SKIN_HEALTH: val->intval = smblib_get_skin_temp_status(chg); break; default: pr_err("get prop %d is not supported in usb\n", psp); rc = -EINVAL; break; } if (rc < 0) { pr_debug("Couldn't get prop %d rc = %d\n", psp, rc); return -ENODATA; } return 0; } #define MIN_THERMAL_VOTE_UA 500000 static int smb5_usb_set_prop(struct power_supply *psy, enum power_supply_property psp, const union power_supply_propval *val) { struct smb5 *chip = power_supply_get_drvdata(psy); struct smb_charger *chg = &chip->chg; int icl, rc = 0; switch (psp) { case POWER_SUPPLY_PROP_PD_CURRENT_MAX: rc = smblib_set_prop_pd_current_max(chg, val); break; #ifdef OPLUS_CUSTOM_OP_DEF case POWER_SUPPLY_PROP_RESET_RD: rc = smblib_set_prop_reset_rd(chg, val); break; #endif case POWER_SUPPLY_PROP_TYPEC_POWER_ROLE: rc = smblib_set_prop_typec_power_role(chg, val); break; case POWER_SUPPLY_PROP_TYPEC_SRC_RP: rc = smblib_set_prop_typec_select_rp(chg, val); break; case POWER_SUPPLY_PROP_PD_ACTIVE: rc = smblib_set_prop_pd_active(chg, val); break; case POWER_SUPPLY_PROP_PD_IN_HARD_RESET: rc = smblib_set_prop_pd_in_hard_reset(chg, val); break; case POWER_SUPPLY_PROP_PD_USB_SUSPEND_SUPPORTED: chg->system_suspend_supported = val->intval; break; case POWER_SUPPLY_PROP_BOOST_CURRENT: rc = smblib_set_prop_boost_current(chg, val); break; case POWER_SUPPLY_PROP_CTM_CURRENT_MAX: rc = vote(chg->usb_icl_votable, CTM_VOTER, val->intval >= 0, val->intval); break; case POWER_SUPPLY_PROP_PR_SWAP: rc = smblib_set_prop_pr_swap_in_progress(chg, val); break; case POWER_SUPPLY_PROP_PD_VOLTAGE_MAX: rc = smblib_set_prop_pd_voltage_max(chg, val); break; case POWER_SUPPLY_PROP_PD_VOLTAGE_MIN: rc = smblib_set_prop_pd_voltage_min(chg, val); break; case POWER_SUPPLY_PROP_SDP_CURRENT_MAX: rc = smblib_set_prop_sdp_current_max(chg, val); break; case POWER_SUPPLY_PROP_CONNECTOR_HEALTH: chg->connector_health = val->intval; power_supply_changed(chg->usb_psy); break; case POWER_SUPPLY_PROP_THERM_ICL_LIMIT: if (!is_client_vote_enabled(chg->usb_icl_votable, THERMAL_THROTTLE_VOTER)) { chg->init_thermal_ua = get_effective_result( chg->usb_icl_votable); icl = chg->init_thermal_ua + val->intval; } else { icl = get_client_vote(chg->usb_icl_votable, THERMAL_THROTTLE_VOTER) + val->intval; } if (icl >= MIN_THERMAL_VOTE_UA) rc = vote(chg->usb_icl_votable, THERMAL_THROTTLE_VOTER, (icl != chg->init_thermal_ua) ? true : false, icl); else rc = -EINVAL; break; case POWER_SUPPLY_PROP_VOLTAGE_MAX_LIMIT: smblib_set_prop_usb_voltage_max_limit(chg, val); break; case POWER_SUPPLY_PROP_ADAPTER_CC_MODE: chg->adapter_cc_mode = val->intval; break; default: pr_err("set prop %d is not supported\n", psp); rc = -EINVAL; break; } return rc; } static int smb5_usb_prop_is_writeable(struct power_supply *psy, enum power_supply_property psp) { switch (psp) { case POWER_SUPPLY_PROP_CTM_CURRENT_MAX: #ifdef OPLUS_CUSTOM_OP_DEF case POWER_SUPPLY_PROP_RESET_RD: #endif case POWER_SUPPLY_PROP_CONNECTOR_HEALTH: case POWER_SUPPLY_PROP_THERM_ICL_LIMIT: case POWER_SUPPLY_PROP_VOLTAGE_MAX_LIMIT: case POWER_SUPPLY_PROP_ADAPTER_CC_MODE: return 1; default: break; } return 0; } #ifndef OPLUS_FEATURE_CHG_BASIC static const struct power_supply_desc usb_psy_desc = { #else static struct power_supply_desc usb_psy_desc = { #endif .name = "usb", #ifndef OPLUS_FEATURE_CHG_BASIC .type = POWER_SUPPLY_TYPE_USB_PD, #else .type = POWER_SUPPLY_TYPE_UNKNOWN, #endif .properties = smb5_usb_props, .num_properties = ARRAY_SIZE(smb5_usb_props), .get_property = smb5_usb_get_prop, .set_property = smb5_usb_set_prop, .property_is_writeable = smb5_usb_prop_is_writeable, }; static int smb5_init_usb_psy(struct smb5 *chip) { struct power_supply_config usb_cfg = {}; struct smb_charger *chg = &chip->chg; usb_cfg.drv_data = chip; usb_cfg.of_node = chg->dev->of_node; chg->usb_psy = devm_power_supply_register(chg->dev, &usb_psy_desc, &usb_cfg); if (IS_ERR(chg->usb_psy)) { pr_err("Couldn't register USB power supply\n"); return PTR_ERR(chg->usb_psy); } return 0; } #ifdef OPLUS_FEATURE_CHG_BASIC void oplus_set_smb5_usb_props_type(enum power_supply_type type) { chg_err("old type[%d], new type[%d]\n", usb_psy_desc.type, type); usb_psy_desc.type = type; return; } #endif /******************************** * USB PC_PORT PSY REGISTRATION * ********************************/ static enum power_supply_property smb5_usb_port_props[] = { POWER_SUPPLY_PROP_TYPE, POWER_SUPPLY_PROP_ONLINE, POWER_SUPPLY_PROP_VOLTAGE_MAX, POWER_SUPPLY_PROP_CURRENT_MAX, }; static int smb5_usb_port_get_prop(struct power_supply *psy, enum power_supply_property psp, union power_supply_propval *val) { struct smb5 *chip = power_supply_get_drvdata(psy); struct smb_charger *chg = &chip->chg; int rc = 0; switch (psp) { case POWER_SUPPLY_PROP_TYPE: val->intval = POWER_SUPPLY_TYPE_USB; break; case POWER_SUPPLY_PROP_ONLINE: #ifdef OPLUS_FEATURE_CHG_BASIC if (use_present_status) rc = smblib_get_prop_usb_present(chg, val); else rc = smblib_get_prop_usb_online(chg, val); if ((oplus_chg_get_charger_type() == POWER_SUPPLY_TYPE_USB) || (oplus_chg_get_charger_type() == POWER_SUPPLY_TYPE_USB_CDP)) { val->intval = 1; } #else rc = smblib_get_prop_usb_online(chg, val); #endif #ifdef OPLUS_FEATURE_CHG_BASIC /* Yichun.Chen PSW.BSP.CHG 2019-08-19 for c to c */ if ((chg->real_charger_type == POWER_SUPPLY_TYPE_USB_PD) && (opluschg_pd_sdp == true)) { val->intval = 1; break; } #endif if (!val->intval) break; if (((chg->typec_mode == POWER_SUPPLY_TYPEC_SOURCE_DEFAULT) || (chg->typec_mode == POWER_SUPPLY_TYPEC_SOURCE_MEDIUM) || (chg->typec_mode == POWER_SUPPLY_TYPEC_SOURCE_HIGH) || (chg->connector_type == POWER_SUPPLY_CONNECTOR_MICRO_USB)) && (chg->real_charger_type == POWER_SUPPLY_TYPE_USB)) val->intval = 1; else val->intval = 0; break; case POWER_SUPPLY_PROP_VOLTAGE_MAX: val->intval = 5000000; break; case POWER_SUPPLY_PROP_CURRENT_MAX: rc = smblib_get_prop_input_current_settled(chg, val); break; default: pr_err_ratelimited("Get prop %d is not supported in pc_port\n", psp); return -EINVAL; } if (rc < 0) { pr_debug("Couldn't get prop %d rc = %d\n", psp, rc); return -ENODATA; } return 0; } static int smb5_usb_port_set_prop(struct power_supply *psy, enum power_supply_property psp, const union power_supply_propval *val) { int rc = 0; switch (psp) { default: pr_err_ratelimited("Set prop %d is not supported in pc_port\n", psp); rc = -EINVAL; break; } return rc; } static const struct power_supply_desc usb_port_psy_desc = { .name = "pc_port", .type = POWER_SUPPLY_TYPE_USB, .properties = smb5_usb_port_props, .num_properties = ARRAY_SIZE(smb5_usb_port_props), .get_property = smb5_usb_port_get_prop, .set_property = smb5_usb_port_set_prop, }; static int smb5_init_usb_port_psy(struct smb5 *chip) { struct power_supply_config usb_port_cfg = {}; struct smb_charger *chg = &chip->chg; usb_port_cfg.drv_data = chip; usb_port_cfg.of_node = chg->dev->of_node; chg->usb_port_psy = devm_power_supply_register(chg->dev, &usb_port_psy_desc, &usb_port_cfg); if (IS_ERR(chg->usb_port_psy)) { pr_err("Couldn't register USB pc_port power supply\n"); return PTR_ERR(chg->usb_port_psy); } return 0; } /***************************** * USB MAIN PSY REGISTRATION * *****************************/ static enum power_supply_property smb5_usb_main_props[] = { POWER_SUPPLY_PROP_VOLTAGE_MAX, POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, POWER_SUPPLY_PROP_TYPE, POWER_SUPPLY_PROP_INPUT_CURRENT_SETTLED, POWER_SUPPLY_PROP_INPUT_VOLTAGE_SETTLED, POWER_SUPPLY_PROP_FCC_DELTA, POWER_SUPPLY_PROP_CURRENT_MAX, POWER_SUPPLY_PROP_FLASH_ACTIVE, POWER_SUPPLY_PROP_FLASH_TRIGGER, POWER_SUPPLY_PROP_TOGGLE_STAT, POWER_SUPPLY_PROP_MAIN_FCC_MAX, POWER_SUPPLY_PROP_IRQ_STATUS, POWER_SUPPLY_PROP_FORCE_MAIN_FCC, POWER_SUPPLY_PROP_FORCE_MAIN_ICL, POWER_SUPPLY_PROP_COMP_CLAMP_LEVEL, POWER_SUPPLY_PROP_HEALTH, }; static int smb5_usb_main_get_prop(struct power_supply *psy, enum power_supply_property psp, union power_supply_propval *val) { struct smb5 *chip = power_supply_get_drvdata(psy); struct smb_charger *chg = &chip->chg; int rc = 0; switch (psp) { case POWER_SUPPLY_PROP_VOLTAGE_MAX: rc = smblib_get_charge_param(chg, &chg->param.fv, &val->intval); break; case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: rc = smblib_get_charge_param(chg, &chg->param.fcc, &val->intval); break; case POWER_SUPPLY_PROP_TYPE: val->intval = POWER_SUPPLY_TYPE_MAIN; break; case POWER_SUPPLY_PROP_INPUT_CURRENT_SETTLED: rc = smblib_get_prop_input_current_settled(chg, val); break; case POWER_SUPPLY_PROP_INPUT_VOLTAGE_SETTLED: rc = smblib_get_prop_input_voltage_settled(chg, val); break; case POWER_SUPPLY_PROP_FCC_DELTA: rc = smblib_get_prop_fcc_delta(chg, val); break; case POWER_SUPPLY_PROP_CURRENT_MAX: rc = smblib_get_icl_current(chg, &val->intval); break; case POWER_SUPPLY_PROP_FLASH_ACTIVE: val->intval = chg->flash_active; break; case POWER_SUPPLY_PROP_FLASH_TRIGGER: rc = schgm_flash_get_vreg_ok(chg, &val->intval); break; case POWER_SUPPLY_PROP_TOGGLE_STAT: val->intval = 0; break; case POWER_SUPPLY_PROP_MAIN_FCC_MAX: val->intval = chg->main_fcc_max; break; case POWER_SUPPLY_PROP_IRQ_STATUS: rc = smblib_get_irq_status(chg, val); break; case POWER_SUPPLY_PROP_FORCE_MAIN_FCC: rc = smblib_get_charge_param(chg, &chg->param.fcc, &val->intval); break; case POWER_SUPPLY_PROP_FORCE_MAIN_ICL: rc = smblib_get_charge_param(chg, &chg->param.usb_icl, &val->intval); break; case POWER_SUPPLY_PROP_COMP_CLAMP_LEVEL: val->intval = chg->comp_clamp_level; break; /* Use this property to report SMB health */ case POWER_SUPPLY_PROP_HEALTH: val->intval = smblib_get_prop_smb_health(chg); break; default: pr_debug("get prop %d is not supported in usb-main\n", psp); rc = -EINVAL; break; } if (rc < 0) { pr_debug("Couldn't get prop %d rc = %d\n", psp, rc); return -ENODATA; } return 0; } static int smb5_usb_main_set_prop(struct power_supply *psy, enum power_supply_property psp, const union power_supply_propval *val) { struct smb5 *chip = power_supply_get_drvdata(psy); struct smb_charger *chg = &chip->chg; union power_supply_propval pval = {0, }; int rc = 0, offset_ua = 0; switch (psp) { case POWER_SUPPLY_PROP_VOLTAGE_MAX: rc = smblib_set_charge_param(chg, &chg->param.fv, val->intval); break; case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: /* Adjust Main FCC for QC3.0 + SMB1390 */ rc = smblib_get_qc3_main_icl_offset(chg, &offset_ua); if (rc < 0) offset_ua = 0; rc = smblib_set_charge_param(chg, &chg->param.fcc, val->intval + offset_ua); break; case POWER_SUPPLY_PROP_CURRENT_MAX: rc = smblib_set_icl_current(chg, val->intval); break; case POWER_SUPPLY_PROP_FLASH_ACTIVE: if ((chg->chg_param.smb_version == PMI632_SUBTYPE) && (chg->flash_active != val->intval)) { chg->flash_active = val->intval; rc = smblib_get_prop_usb_present(chg, &pval); if (rc < 0) pr_err("Failed to get USB preset status rc=%d\n", rc); if (pval.intval) { rc = smblib_force_vbus_voltage(chg, chg->flash_active ? FORCE_5V_BIT : IDLE_BIT); if (rc < 0) pr_err("Failed to force 5V\n"); else chg->pulse_cnt = 0; } else { /* USB absent & flash not-active - vote 100mA */ vote(chg->usb_icl_votable, SW_ICL_MAX_VOTER, true, SDP_100_MA); } pr_debug("flash active VBUS 5V restriction %s\n", chg->flash_active ? "applied" : "removed"); /* Update userspace */ if (chg->batt_psy) power_supply_changed(chg->batt_psy); } break; case POWER_SUPPLY_PROP_TOGGLE_STAT: rc = smblib_toggle_smb_en(chg, val->intval); break; case POWER_SUPPLY_PROP_MAIN_FCC_MAX: chg->main_fcc_max = val->intval; rerun_election(chg->fcc_votable); break; case POWER_SUPPLY_PROP_FORCE_MAIN_FCC: vote_override(chg->fcc_main_votable, CC_MODE_VOTER, (val->intval < 0) ? false : true, val->intval); /* Main FCC updated re-calculate FCC */ rerun_election(chg->fcc_votable); break; case POWER_SUPPLY_PROP_FORCE_MAIN_ICL: vote_override(chg->usb_icl_votable, CC_MODE_VOTER, (val->intval < 0) ? false : true, val->intval); /* Main ICL updated re-calculate ILIM */ if (chg->real_charger_type == POWER_SUPPLY_TYPE_USB_HVDCP_3) rerun_election(chg->fcc_votable); break; case POWER_SUPPLY_PROP_COMP_CLAMP_LEVEL: rc = smb5_set_prop_comp_clamp_level(chg, val); break; default: pr_err("set prop %d is not supported\n", psp); rc = -EINVAL; break; } return rc; } static int smb5_usb_main_prop_is_writeable(struct power_supply *psy, enum power_supply_property psp) { int rc; switch (psp) { case POWER_SUPPLY_PROP_TOGGLE_STAT: case POWER_SUPPLY_PROP_MAIN_FCC_MAX: case POWER_SUPPLY_PROP_FORCE_MAIN_FCC: case POWER_SUPPLY_PROP_FORCE_MAIN_ICL: case POWER_SUPPLY_PROP_COMP_CLAMP_LEVEL: rc = 1; break; default: rc = 0; break; } return rc; } static const struct power_supply_desc usb_main_psy_desc = { .name = "main", .type = POWER_SUPPLY_TYPE_MAIN, .properties = smb5_usb_main_props, .num_properties = ARRAY_SIZE(smb5_usb_main_props), .get_property = smb5_usb_main_get_prop, .set_property = smb5_usb_main_set_prop, .property_is_writeable = smb5_usb_main_prop_is_writeable, }; static int smb5_init_usb_main_psy(struct smb5 *chip) { struct power_supply_config usb_main_cfg = {}; struct smb_charger *chg = &chip->chg; usb_main_cfg.drv_data = chip; usb_main_cfg.of_node = chg->dev->of_node; chg->usb_main_psy = devm_power_supply_register(chg->dev, &usb_main_psy_desc, &usb_main_cfg); if (IS_ERR(chg->usb_main_psy)) { pr_err("Couldn't register USB main power supply\n"); return PTR_ERR(chg->usb_main_psy); } return 0; } /************************* * DC PSY REGISTRATION * *************************/ #ifndef OPLUS_FEATURE_CHG_BASIC static enum power_supply_property smb5_dc_props[] = { POWER_SUPPLY_PROP_INPUT_SUSPEND, POWER_SUPPLY_PROP_PRESENT, POWER_SUPPLY_PROP_ONLINE, POWER_SUPPLY_PROP_VOLTAGE_NOW, POWER_SUPPLY_PROP_CURRENT_MAX, POWER_SUPPLY_PROP_VOLTAGE_MAX, POWER_SUPPLY_PROP_INPUT_VOLTAGE_REGULATION, POWER_SUPPLY_PROP_REAL_TYPE, POWER_SUPPLY_PROP_DC_RESET, POWER_SUPPLY_PROP_AICL_DONE, }; static int smb5_dc_get_prop(struct power_supply *psy, enum power_supply_property psp, union power_supply_propval *val) { struct smb5 *chip = power_supply_get_drvdata(psy); struct smb_charger *chg = &chip->chg; int rc = 0; switch (psp) { case POWER_SUPPLY_PROP_INPUT_SUSPEND: val->intval = get_effective_result(chg->dc_suspend_votable); break; case POWER_SUPPLY_PROP_PRESENT: rc = smblib_get_prop_dc_present(chg, val); break; case POWER_SUPPLY_PROP_ONLINE: rc = smblib_get_prop_dc_online(chg, val); break; case POWER_SUPPLY_PROP_VOLTAGE_NOW: rc = smblib_get_prop_dc_voltage_now(chg, val); break; case POWER_SUPPLY_PROP_CURRENT_MAX: rc = smblib_get_prop_dc_current_max(chg, val); break; case POWER_SUPPLY_PROP_VOLTAGE_MAX: rc = smblib_get_prop_dc_voltage_max(chg, val); break; case POWER_SUPPLY_PROP_REAL_TYPE: val->intval = POWER_SUPPLY_TYPE_WIRELESS; break; case POWER_SUPPLY_PROP_INPUT_VOLTAGE_REGULATION: rc = smblib_get_prop_voltage_wls_output(chg, val); break; case POWER_SUPPLY_PROP_DC_RESET: val->intval = 0; break; case POWER_SUPPLY_PROP_AICL_DONE: val->intval = chg->dcin_aicl_done; break; default: return -EINVAL; } if (rc < 0) { pr_debug("Couldn't get prop %d rc = %d\n", psp, rc); return -ENODATA; } return 0; } static int smb5_dc_set_prop(struct power_supply *psy, enum power_supply_property psp, const union power_supply_propval *val) { struct smb5 *chip = power_supply_get_drvdata(psy); struct smb_charger *chg = &chip->chg; int rc = 0; switch (psp) { case POWER_SUPPLY_PROP_INPUT_SUSPEND: rc = vote(chg->dc_suspend_votable, WBC_VOTER, (bool)val->intval, 0); break; case POWER_SUPPLY_PROP_CURRENT_MAX: rc = smblib_set_prop_dc_current_max(chg, val); break; case POWER_SUPPLY_PROP_INPUT_VOLTAGE_REGULATION: rc = smblib_set_prop_voltage_wls_output(chg, val); break; case POWER_SUPPLY_PROP_DC_RESET: rc = smblib_set_prop_dc_reset(chg); break; default: return -EINVAL; } return rc; } static int smb5_dc_prop_is_writeable(struct power_supply *psy, enum power_supply_property psp) { switch (psp) { case POWER_SUPPLY_PROP_INPUT_VOLTAGE_REGULATION: case POWER_SUPPLY_PROP_CURRENT_MAX: return 1; default: break; } return 0; } static const struct power_supply_desc dc_psy_desc = { .name = "dc", .type = POWER_SUPPLY_TYPE_WIRELESS, .properties = smb5_dc_props, .num_properties = ARRAY_SIZE(smb5_dc_props), .get_property = smb5_dc_get_prop, .set_property = smb5_dc_set_prop, .property_is_writeable = smb5_dc_prop_is_writeable, }; static int smb5_init_dc_psy(struct smb5 *chip) { struct power_supply_config dc_cfg = {}; struct smb_charger *chg = &chip->chg; dc_cfg.drv_data = chip; dc_cfg.of_node = chg->dev->of_node; chg->dc_psy = devm_power_supply_register(chg->dev, &dc_psy_desc, &dc_cfg); if (IS_ERR(chg->dc_psy)) { pr_err("Couldn't register USB power supply\n"); return PTR_ERR(chg->dc_psy); } return 0; } #endif #ifdef OPLUS_FEATURE_CHG_BASIC /************************* * AC PSY REGISTRATION * *************************/ static enum power_supply_property ac_props[] = { POWER_SUPPLY_PROP_ONLINE, }; static int smb5_ac_get_property(struct power_supply *psy, enum power_supply_property psp, union power_supply_propval *val) { int rc = 0; rc = oplus_ac_get_property(psy, psp, val); return rc; } static const struct power_supply_desc ac_psy_desc = { .name = "ac", .type = POWER_SUPPLY_TYPE_MAINS, .properties = ac_props, .num_properties = ARRAY_SIZE(ac_props), .get_property = smb5_ac_get_property, }; static int smb5_init_ac_psy(struct smb5 *chip) { struct power_supply_config ac_cfg = {}; struct smb_charger *chg = &chip->chg; ac_cfg.drv_data = chip; ac_cfg.of_node = chg->dev->of_node; chg->ac_psy = devm_power_supply_register(chg->dev, &ac_psy_desc, &ac_cfg); if (IS_ERR(chg->ac_psy)) { pr_err("Couldn't register AC power supply\n"); return PTR_ERR(chg->ac_psy); } return 0; } #endif /* OPLUS_FEATURE_CHG_BASIC */ /************************* * BATT PSY REGISTRATION * *************************/ static enum power_supply_property smb5_batt_props[] = { POWER_SUPPLY_PROP_INPUT_SUSPEND, POWER_SUPPLY_PROP_STATUS, POWER_SUPPLY_PROP_HEALTH, POWER_SUPPLY_PROP_PRESENT, POWER_SUPPLY_PROP_CHARGE_TYPE, POWER_SUPPLY_PROP_CAPACITY, POWER_SUPPLY_PROP_CHARGER_TEMP, POWER_SUPPLY_PROP_CHARGER_TEMP_MAX, POWER_SUPPLY_PROP_INPUT_CURRENT_LIMITED, POWER_SUPPLY_PROP_VOLTAGE_NOW, POWER_SUPPLY_PROP_VOLTAGE_MAX, POWER_SUPPLY_PROP_VOLTAGE_QNOVO, POWER_SUPPLY_PROP_CURRENT_NOW, POWER_SUPPLY_PROP_CURRENT_QNOVO, POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT, POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT, POWER_SUPPLY_PROP_TEMP, POWER_SUPPLY_PROP_TECHNOLOGY, POWER_SUPPLY_PROP_STEP_CHARGING_ENABLED, POWER_SUPPLY_PROP_SW_JEITA_ENABLED, POWER_SUPPLY_PROP_CHARGE_DONE, POWER_SUPPLY_PROP_PARALLEL_DISABLE, POWER_SUPPLY_PROP_SET_SHIP_MODE, POWER_SUPPLY_PROP_DIE_HEALTH, POWER_SUPPLY_PROP_RERUN_AICL, POWER_SUPPLY_PROP_DP_DM, POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX, POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT, POWER_SUPPLY_PROP_CHARGE_COUNTER, POWER_SUPPLY_PROP_CYCLE_COUNT, POWER_SUPPLY_PROP_RECHARGE_SOC, POWER_SUPPLY_PROP_CHARGE_FULL, POWER_SUPPLY_PROP_FORCE_RECHARGE, POWER_SUPPLY_PROP_FCC_STEPPER_ENABLE, #ifdef OPLUS_FEATURE_CHG_BASIC POWER_SUPPLY_PROP_VOLTAGE_MIN, POWER_SUPPLY_PROP_CHARGE_NOW, POWER_SUPPLY_PROP_CAPACITY_LEVEL, #endif }; static int smb5_batt_get_prop(struct power_supply *psy, enum power_supply_property psp, union power_supply_propval *val) { struct smb_charger *chg = power_supply_get_drvdata(psy); int rc = 0; switch (psp) { #ifndef OPLUS_FEATURE_CHG_BASIC case POWER_SUPPLY_PROP_STATUS: rc = smblib_get_prop_batt_status(chg, val); break; case POWER_SUPPLY_PROP_HEALTH: rc = smblib_get_prop_batt_health(chg, val); break; case POWER_SUPPLY_PROP_PRESENT: rc = smblib_get_prop_batt_present(chg, val); break; #endif case POWER_SUPPLY_PROP_INPUT_SUSPEND: rc = smblib_get_prop_input_suspend(chg, val); break; case POWER_SUPPLY_PROP_CHARGE_TYPE: rc = smblib_get_prop_batt_charge_type(chg, val); break; #ifndef OPLUS_FEATURE_CHG_BASIC case POWER_SUPPLY_PROP_CAPACITY: rc = smblib_get_prop_batt_capacity(chg, val); break; #endif #ifdef OPLUS_CUSTOM_OP_DEF case POWER_SUPPLY_PROP_OP_DISABLE_CHARGE: val->intval = chg->chg_disabled; break; #endif case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT: rc = smblib_get_prop_system_temp_level(chg, val); break; case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX: rc = smblib_get_prop_system_temp_level_max(chg, val); break; #ifndef OPLUS_FEATURE_CHG_BASIC /* CHARGER_TEMP and CHARGER_TEMP_MAX is dependent on FG and only for HVDCP */ case POWER_SUPPLY_PROP_CHARGER_TEMP: rc = smblib_get_prop_charger_temp(chg, val); break; case POWER_SUPPLY_PROP_CHARGER_TEMP_MAX: val->intval = chg->charger_temp_max; break; #else case POWER_SUPPLY_PROP_CHARGER_TEMP: case POWER_SUPPLY_PROP_CHARGER_TEMP_MAX: val->intval = -1; break; #endif case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMITED: rc = smblib_get_prop_input_current_limited(chg, val); break; case POWER_SUPPLY_PROP_STEP_CHARGING_ENABLED: val->intval = chg->step_chg_enabled; break; case POWER_SUPPLY_PROP_SW_JEITA_ENABLED: val->intval = chg->sw_jeita_enabled; break; #ifndef OPLUS_FEATURE_CHG_BASIC case POWER_SUPPLY_PROP_VOLTAGE_NOW: rc = smblib_get_prop_from_bms(chg, POWER_SUPPLY_PROP_VOLTAGE_NOW, val); break; #endif case POWER_SUPPLY_PROP_VOLTAGE_MAX: val->intval = get_client_vote(chg->fv_votable, BATT_PROFILE_VOTER); break; case POWER_SUPPLY_PROP_VOLTAGE_QNOVO: val->intval = get_client_vote_locked(chg->fv_votable, QNOVO_VOTER); break; #ifndef OPLUS_FEATURE_CHG_BASIC case POWER_SUPPLY_PROP_CURRENT_NOW: rc = smblib_get_batt_current_now(chg, val); break; #endif case POWER_SUPPLY_PROP_CURRENT_QNOVO: val->intval = get_client_vote_locked(chg->fcc_votable, QNOVO_VOTER); break; case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: val->intval = get_client_vote(chg->fcc_votable, BATT_PROFILE_VOTER); break; case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: val->intval = get_effective_result(chg->fcc_votable); break; #ifdef OPLUS_FEATURE_CHG_BASIC #ifndef CONFIG_OPLUS_SHORT_C_BATT_CHECK #ifndef CONFIG_OPLUS_SHORT_USERSPACE case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT: rc = smblib_get_prop_batt_iterm(chg, val); break; #endif #endif #endif #ifndef OPLUS_FEATURE_CHG_BASIC case POWER_SUPPLY_PROP_TEMP: rc = smblib_get_prop_from_bms(chg, POWER_SUPPLY_PROP_TEMP, val); break; case POWER_SUPPLY_PROP_TECHNOLOGY: val->intval = POWER_SUPPLY_TECHNOLOGY_LION; break; #endif case POWER_SUPPLY_PROP_CHARGE_DONE: rc = smblib_get_prop_batt_charge_done(chg, val); break; case POWER_SUPPLY_PROP_PARALLEL_DISABLE: val->intval = get_client_vote(chg->pl_disable_votable, USER_VOTER); break; case POWER_SUPPLY_PROP_SET_SHIP_MODE: /* Not in ship mode as long as device is active */ val->intval = 0; break; case POWER_SUPPLY_PROP_DIE_HEALTH: rc = smblib_get_die_health(chg, val); break; case POWER_SUPPLY_PROP_DP_DM: val->intval = chg->pulse_cnt; break; case POWER_SUPPLY_PROP_RERUN_AICL: val->intval = 0; break; case POWER_SUPPLY_PROP_CHARGE_COUNTER: rc = smblib_get_prop_from_bms(chg, POWER_SUPPLY_PROP_CHARGE_COUNTER, val); #ifdef OPLUS_FEATURE_CHG_BASIC if (g_oplus_chip) { val->intval = g_oplus_chip->batt_rm * 1000; } #endif break; case POWER_SUPPLY_PROP_CYCLE_COUNT: rc = smblib_get_prop_from_bms(chg, POWER_SUPPLY_PROP_CYCLE_COUNT, val); break; case POWER_SUPPLY_PROP_RECHARGE_SOC: val->intval = chg->auto_recharge_soc; break; case POWER_SUPPLY_PROP_CHARGE_QNOVO_ENABLE: val->intval = 0; break; case POWER_SUPPLY_PROP_CHARGE_FULL: rc = smblib_get_prop_from_bms(chg, POWER_SUPPLY_PROP_CHARGE_FULL, val); break; case POWER_SUPPLY_PROP_FORCE_RECHARGE: val->intval = 0; break; case POWER_SUPPLY_PROP_FCC_STEPPER_ENABLE: val->intval = chg->fcc_stepper_enable; break; #ifdef OPLUS_FEATURE_CHG_BASIC case POWER_SUPPLY_PROP_CURRENT_MAX: rc = smblib_get_prop_input_current_settled(chg, val); break; case POWER_SUPPLY_PROP_CAPACITY_LEVEL: val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL; if (g_oplus_chip && (g_oplus_chip->ui_soc == 0)) { val->intval = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL; chg_err("bat pro POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL, should shutdown!!!\n"); } break; #endif default: #ifdef OPLUS_FEATURE_CHG_BASIC rc = oplus_battery_get_property(psy, psp, val); #else pr_err("batt power supply prop %d not supported\n", psp); return -EINVAL; #endif } if (rc < 0) { pr_debug("Couldn't get prop %d rc = %d\n", psp, rc); return -ENODATA; } return 0; } static int smb5_batt_set_prop(struct power_supply *psy, enum power_supply_property prop, const union power_supply_propval *val) { int rc = 0; struct smb_charger *chg = power_supply_get_drvdata(psy); switch (prop) { case POWER_SUPPLY_PROP_STATUS: rc = smblib_set_prop_batt_status(chg, val); break; case POWER_SUPPLY_PROP_INPUT_SUSPEND: rc = smblib_set_prop_input_suspend(chg, val); break; case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT: rc = smblib_set_prop_system_temp_level(chg, val); break; case POWER_SUPPLY_PROP_CAPACITY: rc = smblib_set_prop_batt_capacity(chg, val); break; case POWER_SUPPLY_PROP_PARALLEL_DISABLE: vote(chg->pl_disable_votable, USER_VOTER, (bool)val->intval, 0); break; case POWER_SUPPLY_PROP_VOLTAGE_MAX: chg->batt_profile_fv_uv = val->intval; vote(chg->fv_votable, BATT_PROFILE_VOTER, true, val->intval); break; case POWER_SUPPLY_PROP_VOLTAGE_QNOVO: vote(chg->fv_votable, QNOVO_VOTER, (val->intval >= 0), val->intval); break; case POWER_SUPPLY_PROP_STEP_CHARGING_ENABLED: chg->step_chg_enabled = !!val->intval; break; case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: chg->batt_profile_fcc_ua = val->intval; vote(chg->fcc_votable, BATT_PROFILE_VOTER, true, val->intval); break; case POWER_SUPPLY_PROP_CURRENT_QNOVO: vote(chg->pl_disable_votable, PL_QNOVO_VOTER, val->intval != -EINVAL && val->intval < 2000000, 0); if (val->intval == -EINVAL) { vote(chg->fcc_votable, BATT_PROFILE_VOTER, true, chg->batt_profile_fcc_ua); vote(chg->fcc_votable, QNOVO_VOTER, false, 0); } else { vote(chg->fcc_votable, QNOVO_VOTER, true, val->intval); vote(chg->fcc_votable, BATT_PROFILE_VOTER, false, 0); } break; case POWER_SUPPLY_PROP_SET_SHIP_MODE: /* Not in ship mode as long as the device is active */ if (!val->intval) break; if (chg->pl.psy) power_supply_set_property(chg->pl.psy, POWER_SUPPLY_PROP_SET_SHIP_MODE, val); g_oplus_chip->enable_shipmode = val->intval; break; case POWER_SUPPLY_PROP_RERUN_AICL: rc = smblib_run_aicl(chg, RERUN_AICL); break; case POWER_SUPPLY_PROP_DP_DM: if (!chg->flash_active) rc = smblib_dp_dm(chg, val->intval); break; case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMITED: rc = smblib_set_prop_input_current_limited(chg, val); break; case POWER_SUPPLY_PROP_DIE_HEALTH: chg->die_health = val->intval; power_supply_changed(chg->batt_psy); break; case POWER_SUPPLY_PROP_RECHARGE_SOC: rc = smblib_set_prop_rechg_soc_thresh(chg, val); break; case POWER_SUPPLY_PROP_FORCE_RECHARGE: /* toggle charging to force recharge */ vote(chg->chg_disable_votable, FORCE_RECHARGE_VOTER, true, 0); /* charge disable delay */ msleep(50); vote(chg->chg_disable_votable, FORCE_RECHARGE_VOTER, false, 0); break; case POWER_SUPPLY_PROP_FCC_STEPPER_ENABLE: chg->fcc_stepper_enable = val->intval; break; default: #ifdef OPLUS_FEATURE_CHG_BASIC /*oplus own battery props*/ rc = oplus_battery_set_property(psy, prop, val); #else rc = -EINVAL; #endif } return rc; } static int smb5_batt_prop_is_writeable(struct power_supply *psy, enum power_supply_property psp) { /*oplus own battery props*/ int rc = 0; switch (psp) { case POWER_SUPPLY_PROP_STATUS: case POWER_SUPPLY_PROP_INPUT_SUSPEND: case POWER_SUPPLY_PROP_SYSTEM_TEMP_LEVEL: case POWER_SUPPLY_PROP_CAPACITY: case POWER_SUPPLY_PROP_PARALLEL_DISABLE: case POWER_SUPPLY_PROP_DP_DM: case POWER_SUPPLY_PROP_RERUN_AICL: case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMITED: case POWER_SUPPLY_PROP_STEP_CHARGING_ENABLED: case POWER_SUPPLY_PROP_DIE_HEALTH: return 1; default: #ifdef OPLUS_FEATURE_CHG_BASIC /*oplus own battery props*/ rc = oplus_battery_property_is_writeable(psy, psp); #endif break; } return rc; } static const struct power_supply_desc batt_psy_desc = { .name = "battery", .type = POWER_SUPPLY_TYPE_BATTERY, .properties = smb5_batt_props, .num_properties = ARRAY_SIZE(smb5_batt_props), .get_property = smb5_batt_get_prop, .set_property = smb5_batt_set_prop, .property_is_writeable = smb5_batt_prop_is_writeable, }; static int smb5_init_batt_psy(struct smb5 *chip) { struct power_supply_config batt_cfg = {}; struct smb_charger *chg = &chip->chg; int rc = 0; batt_cfg.drv_data = chg; batt_cfg.of_node = chg->dev->of_node; chg->batt_psy = devm_power_supply_register(chg->dev, &batt_psy_desc, &batt_cfg); if (IS_ERR(chg->batt_psy)) { pr_err("Couldn't register battery power supply\n"); return PTR_ERR(chg->batt_psy); } return rc; } #ifdef OPLUS_FEATURE_CHG_BASIC /*oplus own battery props*/ static int oplus_power_supply_init(struct smb5 *chip) { int rc = 0; rc = smb5_init_ac_psy(chip); if (rc < 0) { pr_err("Couldn't initialize ac psy rc=%d\n", rc); return rc; } rc = smb5_init_batt_psy(chip); if (rc < 0) { pr_err("Couldn't initialize batt psy rc=%d\n", rc); return rc; } rc = smb5_init_usb_psy(chip); if (rc < 0) { pr_err("Couldn't initialize usb psy rc=%d\n", rc); return rc; } return rc; } #endif /* OPLUS_FEATURE_CHG_BASIC */ /****************************** * VBUS REGULATOR REGISTRATION * ******************************/ static struct regulator_ops smb5_vbus_reg_ops = { .enable = smblib_vbus_regulator_enable, .disable = smblib_vbus_regulator_disable, .is_enabled = smblib_vbus_regulator_is_enabled, }; static int smb5_init_vbus_regulator(struct smb5 *chip) { struct smb_charger *chg = &chip->chg; struct regulator_config cfg = {}; int rc = 0; chg->vbus_vreg = devm_kzalloc(chg->dev, sizeof(*chg->vbus_vreg), GFP_KERNEL); if (!chg->vbus_vreg) return -ENOMEM; cfg.dev = chg->dev; cfg.driver_data = chip; chg->vbus_vreg->rdesc.owner = THIS_MODULE; chg->vbus_vreg->rdesc.type = REGULATOR_VOLTAGE; chg->vbus_vreg->rdesc.ops = &smb5_vbus_reg_ops; chg->vbus_vreg->rdesc.of_match = "qcom,smb5-vbus"; chg->vbus_vreg->rdesc.name = "qcom,smb5-vbus"; chg->vbus_vreg->rdev = devm_regulator_register(chg->dev, &chg->vbus_vreg->rdesc, &cfg); if (IS_ERR(chg->vbus_vreg->rdev)) { rc = PTR_ERR(chg->vbus_vreg->rdev); chg->vbus_vreg->rdev = NULL; if (rc != -EPROBE_DEFER) pr_err("Couldn't register VBUS regulator rc=%d\n", rc); } return rc; } /****************************** * VCONN REGULATOR REGISTRATION * ******************************/ static struct regulator_ops smb5_vconn_reg_ops = { .enable = smblib_vconn_regulator_enable, .disable = smblib_vconn_regulator_disable, .is_enabled = smblib_vconn_regulator_is_enabled, }; static int smb5_init_vconn_regulator(struct smb5 *chip) { struct smb_charger *chg = &chip->chg; struct regulator_config cfg = {}; int rc = 0; if (chg->connector_type == POWER_SUPPLY_CONNECTOR_MICRO_USB) return 0; chg->vconn_vreg = devm_kzalloc(chg->dev, sizeof(*chg->vconn_vreg), GFP_KERNEL); if (!chg->vconn_vreg) return -ENOMEM; cfg.dev = chg->dev; cfg.driver_data = chip; chg->vconn_vreg->rdesc.owner = THIS_MODULE; chg->vconn_vreg->rdesc.type = REGULATOR_VOLTAGE; chg->vconn_vreg->rdesc.ops = &smb5_vconn_reg_ops; chg->vconn_vreg->rdesc.of_match = "qcom,smb5-vconn"; chg->vconn_vreg->rdesc.name = "qcom,smb5-vconn"; chg->vconn_vreg->rdev = devm_regulator_register(chg->dev, &chg->vconn_vreg->rdesc, &cfg); if (IS_ERR(chg->vconn_vreg->rdev)) { rc = PTR_ERR(chg->vconn_vreg->rdev); chg->vconn_vreg->rdev = NULL; if (rc != -EPROBE_DEFER) pr_err("Couldn't register VCONN regulator rc=%d\n", rc); } return rc; } /*************************** * HARDWARE INITIALIZATION * ***************************/ static int smb5_configure_typec(struct smb_charger *chg) { union power_supply_propval pval = {0, }; int rc; u8 val = 0; rc = smblib_read(chg, LEGACY_CABLE_STATUS_REG, &val); if (rc < 0) { dev_err(chg->dev, "Couldn't read Legacy status rc=%d\n", rc); return rc; } /* * Across reboot, standard typeC cables get detected as legacy cables * due to VBUS attachment prior to CC attach/dettach. To handle this, * "early_usb_attach" flag is used, which assumes that across reboot, * the cable connected can be standard typeC. However, its jurisdiction * is limited to PD capable designs only. Hence, for non-PD type designs * reset legacy cable detection by disabling/enabling typeC mode. */ if (chg->pd_not_supported && (val & TYPEC_LEGACY_CABLE_STATUS_BIT)) { pval.intval = POWER_SUPPLY_TYPEC_PR_NONE; smblib_set_prop_typec_power_role(chg, &pval); if (rc < 0) { dev_err(chg->dev, "Couldn't disable TYPEC rc=%d\n", rc); return rc; } /* delay before enabling typeC */ msleep(50); pval.intval = POWER_SUPPLY_TYPEC_PR_DUAL; smblib_set_prop_typec_power_role(chg, &pval); if (rc < 0) { dev_err(chg->dev, "Couldn't enable TYPEC rc=%d\n", rc); return rc; } } smblib_apsd_enable(chg, true); rc = smblib_masked_write(chg, TYPE_C_CFG_REG, BC1P2_START_ON_CC_BIT, 0); if (rc < 0) { dev_err(chg->dev, "failed to write TYPE_C_CFG_REG rc=%d\n", rc); return rc; } /* Use simple write to clear interrupts */ rc = smblib_write(chg, TYPE_C_INTERRUPT_EN_CFG_1_REG, 0); if (rc < 0) { dev_err(chg->dev, "Couldn't configure Type-C interrupts rc=%d\n", rc); return rc; } val = chg->lpd_disabled ? 0 : TYPEC_WATER_DETECTION_INT_EN_BIT; /* Use simple write to enable only required interrupts */ rc = smblib_write(chg, TYPE_C_INTERRUPT_EN_CFG_2_REG, TYPEC_SRC_BATT_HPWR_INT_EN_BIT | val); if (rc < 0) { dev_err(chg->dev, "Couldn't configure Type-C interrupts rc=%d\n", rc); return rc; } /* enable try.snk and clear force sink for DRP mode */ rc = smblib_masked_write(chg, TYPE_C_MODE_CFG_REG, EN_TRY_SNK_BIT | EN_SNK_ONLY_BIT, EN_TRY_SNK_BIT); if (rc < 0) { dev_err(chg->dev, "Couldn't configure TYPE_C_MODE_CFG_REG rc=%d\n", rc); return rc; } chg->typec_try_mode |= EN_TRY_SNK_BIT; /* For PD capable targets configure VCONN for software control */ if (!chg->pd_not_supported) { rc = smblib_masked_write(chg, TYPE_C_VCONN_CONTROL_REG, VCONN_EN_SRC_BIT | VCONN_EN_VALUE_BIT, VCONN_EN_SRC_BIT); if (rc < 0) { dev_err(chg->dev, "Couldn't configure VCONN for SW control rc=%d\n", rc); return rc; } } /* Enable detection of unoriented debug accessory in source mode */ rc = smblib_masked_write(chg, DEBUG_ACCESS_SRC_CFG_REG, EN_UNORIENTED_DEBUG_ACCESS_SRC_BIT, EN_UNORIENTED_DEBUG_ACCESS_SRC_BIT); if (rc < 0) { dev_err(chg->dev, "Couldn't configure TYPE_C_DEBUG_ACCESS_SRC_CFG_REG rc=%d\n", rc); return rc; } if (chg->chg_param.smb_version != PMI632_SUBTYPE) { rc = smblib_masked_write(chg, USBIN_LOAD_CFG_REG, USBIN_IN_COLLAPSE_GF_SEL_MASK | USBIN_AICL_STEP_TIMING_SEL_MASK, 0); if (rc < 0) { dev_err(chg->dev, "Couldn't set USBIN_LOAD_CFG_REG rc=%d\n", rc); return rc; } } /* Set CC threshold to 1.6 V in source mode */ rc = smblib_masked_write(chg, TYPE_C_EXIT_STATE_CFG_REG, SEL_SRC_UPPER_REF_BIT, SEL_SRC_UPPER_REF_BIT); if (rc < 0) dev_err(chg->dev, "Couldn't configure CC threshold voltage rc=%d\n", rc); #ifdef OPLUS_FEATURE_CHG_BASIC //smblib_write(chg, 0x1152, 0x02); rc = smblib_masked_write(chg, DCDC_OTG_CURRENT_LIMIT_CFG_REG, DCDC_OTG_CURRENT_LIMIT_1000MA_BIT, DCDC_OTG_CURRENT_LIMIT_1000MA_BIT); if (rc < 0) dev_err(chg->dev, "Couldn't DCDC_OTG_CURRENT_LIMIT_CFG_REG rc=%d\n", rc); #endif /* OPLUS_FEATURE_CHG_BASIC */ #ifdef OPLUS_FEATURE_CHG_BASIC rc = smblib_masked_write(chg, USBIN_OPTIONS_2_CFG_REG, DCD_TIMEOUT_SEL_BIT, 0); if (rc < 0) dev_err(chg->dev, "Couldn't DCDC_OTG_CURRENT_LIMIT_CFG_REG rc=%d\n", rc); #endif /* OPLUS_FEATURE_CHG_BASIC */ return rc; } static int smb5_configure_micro_usb(struct smb_charger *chg) { int rc; /* For micro USB connector, use extcon by default */ chg->use_extcon = true; chg->pd_not_supported = true; rc = smblib_masked_write(chg, TYPE_C_INTERRUPT_EN_CFG_2_REG, MICRO_USB_STATE_CHANGE_INT_EN_BIT, MICRO_USB_STATE_CHANGE_INT_EN_BIT); if (rc < 0) { dev_err(chg->dev, "Couldn't configure Type-C interrupts rc=%d\n", rc); return rc; } if (chg->uusb_moisture_protection_enabled) { /* Enable moisture detection interrupt */ rc = smblib_masked_write(chg, TYPE_C_INTERRUPT_EN_CFG_2_REG, TYPEC_WATER_DETECTION_INT_EN_BIT, TYPEC_WATER_DETECTION_INT_EN_BIT); if (rc < 0) { dev_err(chg->dev, "Couldn't enable moisture detection interrupt rc=%d\n", rc); return rc; } /* Enable uUSB factory mode */ rc = smblib_masked_write(chg, TYPEC_U_USB_CFG_REG, EN_MICRO_USB_FACTORY_MODE_BIT, EN_MICRO_USB_FACTORY_MODE_BIT); if (rc < 0) { dev_err(chg->dev, "Couldn't enable uUSB factory mode c=%d\n", rc); return rc; } /* Disable periodic monitoring of CC_ID pin */ rc = smblib_write(chg, ((chg->chg_param.smb_version == PMI632_SUBTYPE) ? PMI632_TYPEC_U_USB_WATER_PROTECTION_CFG_REG : TYPEC_U_USB_WATER_PROTECTION_CFG_REG), 0); if (rc < 0) { dev_err(chg->dev, "Couldn't disable periodic monitoring of CC_ID rc=%d\n", rc); return rc; } } /* Enable HVDCP detection and authentication */ if (!chg->hvdcp_disable) smblib_hvdcp_detect_enable(chg, true); return rc; } #define RAW_ITERM(iterm_ma, max_range) \ div_s64((int64_t)iterm_ma * ADC_CHG_ITERM_MASK, max_range) static int smb5_configure_iterm_thresholds_adc(struct smb5 *chip) { u8 *buf; int rc = 0; s16 raw_hi_thresh, raw_lo_thresh, max_limit_ma; struct smb_charger *chg = &chip->chg; if (chip->chg.chg_param.smb_version == PMI632_SUBTYPE) max_limit_ma = ITERM_LIMITS_PMI632_MA; else max_limit_ma = ITERM_LIMITS_PM8150B_MA; if (chip->dt.term_current_thresh_hi_ma < (-1 * max_limit_ma) || chip->dt.term_current_thresh_hi_ma > max_limit_ma || chip->dt.term_current_thresh_lo_ma < (-1 * max_limit_ma) || chip->dt.term_current_thresh_lo_ma > max_limit_ma) { dev_err(chg->dev, "ITERM threshold out of range rc=%d\n", rc); return -EINVAL; } /* * Conversion: * raw (A) = (term_current * ADC_CHG_ITERM_MASK) / max_limit_ma * Note: raw needs to be converted to big-endian format. */ if (chip->dt.term_current_thresh_hi_ma) { raw_hi_thresh = RAW_ITERM(chip->dt.term_current_thresh_hi_ma, max_limit_ma); raw_hi_thresh = sign_extend32(raw_hi_thresh, 15); buf = (u8 *)&raw_hi_thresh; raw_hi_thresh = buf[1] | (buf[0] << 8); rc = smblib_batch_write(chg, CHGR_ADC_ITERM_UP_THD_MSB_REG, (u8 *)&raw_hi_thresh, 2); if (rc < 0) { dev_err(chg->dev, "Couldn't configure ITERM threshold HIGH rc=%d\n", rc); return rc; } } if (chip->dt.term_current_thresh_lo_ma) { raw_lo_thresh = RAW_ITERM(chip->dt.term_current_thresh_lo_ma, max_limit_ma); raw_lo_thresh = sign_extend32(raw_lo_thresh, 15); buf = (u8 *)&raw_lo_thresh; raw_lo_thresh = buf[1] | (buf[0] << 8); rc = smblib_batch_write(chg, CHGR_ADC_ITERM_LO_THD_MSB_REG, (u8 *)&raw_lo_thresh, 2); if (rc < 0) { dev_err(chg->dev, "Couldn't configure ITERM threshold LOW rc=%d\n", rc); return rc; } } return rc; } static int smb5_configure_iterm_thresholds(struct smb5 *chip) { int rc = 0; struct smb_charger *chg = &chip->chg; switch (chip->dt.term_current_src) { case ITERM_SRC_ADC: if (chip->chg.chg_param.smb_version == PM8150B_SUBTYPE) { rc = smblib_masked_write(chg, CHGR_ADC_TERM_CFG_REG, TERM_BASED_ON_SYNC_CONV_OR_SAMPLE_CNT, TERM_BASED_ON_SAMPLE_CNT); if (rc < 0) { dev_err(chg->dev, "Couldn't configure ADC_ITERM_CFG rc=%d\n", rc); return rc; } } rc = smb5_configure_iterm_thresholds_adc(chip); break; default: break; } return rc; } static int smb5_configure_mitigation(struct smb_charger *chg) { int rc; u8 chan = 0, src_cfg = 0; if (!chg->hw_die_temp_mitigation && !chg->hw_connector_mitigation && !chg->hw_skin_temp_mitigation) { src_cfg = THERMREG_SW_ICL_ADJUST_BIT; } else { if (chg->hw_die_temp_mitigation) { chan = DIE_TEMP_CHANNEL_EN_BIT; src_cfg = THERMREG_DIE_ADC_SRC_EN_BIT | THERMREG_DIE_CMP_SRC_EN_BIT; } if (chg->hw_connector_mitigation) { chan |= CONN_THM_CHANNEL_EN_BIT; src_cfg |= THERMREG_CONNECTOR_ADC_SRC_EN_BIT; } if (chg->hw_skin_temp_mitigation) { chan |= MISC_THM_CHANNEL_EN_BIT; src_cfg |= THERMREG_SKIN_ADC_SRC_EN_BIT; } rc = smblib_masked_write(chg, BATIF_ADC_CHANNEL_EN_REG, CONN_THM_CHANNEL_EN_BIT | DIE_TEMP_CHANNEL_EN_BIT | MISC_THM_CHANNEL_EN_BIT, chan); if (rc < 0) { dev_err(chg->dev, "Couldn't enable ADC channel rc=%d\n", rc); return rc; } } rc = smblib_masked_write(chg, MISC_THERMREG_SRC_CFG_REG, THERMREG_SW_ICL_ADJUST_BIT | THERMREG_DIE_ADC_SRC_EN_BIT | THERMREG_DIE_CMP_SRC_EN_BIT | THERMREG_SKIN_ADC_SRC_EN_BIT | SKIN_ADC_CFG_BIT | THERMREG_CONNECTOR_ADC_SRC_EN_BIT, src_cfg); if (rc < 0) { dev_err(chg->dev, "Couldn't configure THERM_SRC reg rc=%d\n", rc); return rc; } return 0; } static int smb5_init_dc_peripheral(struct smb_charger *chg) { int rc = 0; /* PMI632 does not have DC peripheral */ if (chg->chg_param.smb_version == PMI632_SUBTYPE) return 0; /* Set DCIN ICL to 100 mA */ rc = smblib_set_charge_param(chg, &chg->param.dc_icl, DCIN_ICL_MIN_UA); if (rc < 0) { dev_err(chg->dev, "Couldn't set dc_icl rc=%d\n", rc); return rc; } /* Disable DC Input missing poller function */ rc = smblib_masked_write(chg, DCIN_LOAD_CFG_REG, INPUT_MISS_POLL_EN_BIT, 0); if (rc < 0) { dev_err(chg->dev, "Couldn't disable DC Input missing poller rc=%d\n", rc); return rc; } return rc; } static int smb5_configure_recharging(struct smb5 *chip) { int rc = 0; struct smb_charger *chg = &chip->chg; union power_supply_propval pval; /* Configure VBATT-based or automatic recharging */ rc = smblib_masked_write(chg, CHGR_CFG2_REG, RECHG_MASK, (chip->dt.auto_recharge_vbat_mv != -EINVAL) ? VBAT_BASED_RECHG_BIT : 0); if (rc < 0) { dev_err(chg->dev, "Couldn't configure VBAT-rechg CHG_CFG2_REG rc=%d\n", rc); return rc; } /* program the auto-recharge VBAT threshold */ if (chip->dt.auto_recharge_vbat_mv != -EINVAL) { u32 temp = VBAT_TO_VRAW_ADC(chip->dt.auto_recharge_vbat_mv); temp = ((temp & 0xFF00) >> 8) | ((temp & 0xFF) << 8); rc = smblib_batch_write(chg, CHGR_ADC_RECHARGE_THRESHOLD_MSB_REG, (u8 *)&temp, 2); if (rc < 0) { dev_err(chg->dev, "Couldn't configure ADC_RECHARGE_THRESHOLD REG rc=%d\n", rc); return rc; } /* Program the sample count for VBAT based recharge to 3 */ rc = smblib_masked_write(chg, CHGR_NO_SAMPLE_TERM_RCHG_CFG_REG, NO_OF_SAMPLE_FOR_RCHG, 2 << NO_OF_SAMPLE_FOR_RCHG_SHIFT); if (rc < 0) { dev_err(chg->dev, "Couldn't configure CHGR_NO_SAMPLE_FOR_TERM_RCHG_CFG rc=%d\n", rc); return rc; } } rc = smblib_masked_write(chg, CHGR_CFG2_REG, RECHG_MASK, (chip->dt.auto_recharge_soc != -EINVAL) ? SOC_BASED_RECHG_BIT : VBAT_BASED_RECHG_BIT); if (rc < 0) { dev_err(chg->dev, "Couldn't configure SOC-rechg CHG_CFG2_REG rc=%d\n", rc); return rc; } /* program the auto-recharge threshold */ if (chip->dt.auto_recharge_soc != -EINVAL) { pval.intval = chip->dt.auto_recharge_soc; rc = smblib_set_prop_rechg_soc_thresh(chg, &pval); if (rc < 0) { dev_err(chg->dev, "Couldn't configure CHG_RCHG_SOC_REG rc=%d\n", rc); return rc; } /* Program the sample count for SOC based recharge to 1 */ rc = smblib_masked_write(chg, CHGR_NO_SAMPLE_TERM_RCHG_CFG_REG, NO_OF_SAMPLE_FOR_RCHG, 0); if (rc < 0) { dev_err(chg->dev, "Couldn't configure CHGR_NO_SAMPLE_FOR_TERM_RCHG_CFG rc=%d\n", rc); return rc; } } return 0; } static int smb5_configure_float_charger(struct smb5 *chip) { int rc = 0; u8 val = 0; struct smb_charger *chg = &chip->chg; /* configure float charger options */ switch (chip->dt.float_option) { case FLOAT_SDP: val = FORCE_FLOAT_SDP_CFG_BIT; break; case DISABLE_CHARGING: val = FLOAT_DIS_CHGING_CFG_BIT; break; case SUSPEND_INPUT: val = SUSPEND_FLOAT_CFG_BIT; break; case FLOAT_DCP: default: val = 0; break; } chg->float_cfg = val; /* Update float charger setting and set DCD timeout 300ms */ rc = smblib_masked_write(chg, USBIN_OPTIONS_2_CFG_REG, FLOAT_OPTIONS_MASK | DCD_TIMEOUT_SEL_BIT, val); if (rc < 0) { dev_err(chg->dev, "Couldn't change float charger setting rc=%d\n", rc); return rc; } return 0; } static int smb5_init_connector_type(struct smb_charger *chg) { int rc, type = 0; u8 val = 0; /* * PMI632 can have the connector type defined by a dedicated register * PMI632_TYPEC_MICRO_USB_MODE_REG or by a common TYPEC_U_USB_CFG_REG. */ if (chg->chg_param.smb_version == PMI632_SUBTYPE) { rc = smblib_read(chg, PMI632_TYPEC_MICRO_USB_MODE_REG, &val); if (rc < 0) { dev_err(chg->dev, "Couldn't read USB mode rc=%d\n", rc); return rc; } type = !!(val & MICRO_USB_MODE_ONLY_BIT); } /* * If PMI632_TYPEC_MICRO_USB_MODE_REG is not set and for all non-PMI632 * check the connector type using TYPEC_U_USB_CFG_REG. */ if (!type) { rc = smblib_read(chg, TYPEC_U_USB_CFG_REG, &val); if (rc < 0) { dev_err(chg->dev, "Couldn't read U_USB config rc=%d\n", rc); return rc; } type = !!(val & EN_MICRO_USB_MODE_BIT); } pr_debug("Connector type=%s\n", type ? "Micro USB" : "TypeC"); if (type) { chg->connector_type = POWER_SUPPLY_CONNECTOR_MICRO_USB; rc = smb5_configure_micro_usb(chg); } else { chg->connector_type = POWER_SUPPLY_CONNECTOR_TYPEC; rc = smb5_configure_typec(chg); } if (rc < 0) { dev_err(chg->dev, "Couldn't configure TypeC/micro-USB mode rc=%d\n", rc); return rc; } /* * PMI632 based hw init: * - Rerun APSD to ensure proper charger detection if device * boots with charger connected. * - Initialize flash module for PMI632 */ if (chg->chg_param.smb_version == PMI632_SUBTYPE) { schgm_flash_init(chg); smblib_rerun_apsd_if_required(chg); } return 0; } #ifndef OPLUS_FEATURE_CHG_BASIC static void otg_enable_pmic_id_value (void) { int rc; u8 stat; struct smb_charger *chg = NULL; struct oplus_chg_chip *chip = g_oplus_chip; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return; } chg = &chip->pmic_spmi.smb5_chip->chg; /* set DRP mode */ rc = smblib_masked_write(chg, TYPE_C_INTRPT_ENB_SOFTWARE_CTRL_REG, TYPEC_POWER_ROLE_CMD_MASK, 0x0);//bit[2:0]=0 if (rc < 0) { printk(KERN_ERR "[OPLUS_CHG][%s]: Couldn't clear 0x1368[0] rc=%d\n", __func__, rc); } rc = smblib_read(chg, TYPE_C_INTRPT_ENB_SOFTWARE_CTRL_REG, &stat); if (rc < 0) { printk(KERN_ERR "[OPLUS_CHG][%s]: Couldn't read 0x1368 rc=%d\n", __func__, rc); } else { printk(KERN_ERR "[OPLUS_CHG][%s]: reg0x1368[0x%x], bit[2:0]=0(DRP)\n", __func__, stat); } } static void otg_disable_pmic_id_value (void) { int rc; u8 stat; struct smb_charger *chg = NULL; struct oplus_chg_chip *chip = g_oplus_chip; if (!chip) { printk(KERN_ERR "[OPLUS_CHG][%s]: smb5_chg not ready!\n", __func__); return; } chg = &chip->pmic_spmi.smb5_chip->chg; /* set sink mode only */ rc = smblib_masked_write(chg, TYPE_C_INTRPT_ENB_SOFTWARE_CTRL_REG, TYPEC_POWER_ROLE_CMD_MASK, UFP_EN_CMD_BIT);//bit[2:0]=0x4 if (rc < 0) { printk(KERN_ERR "[OPLUS_CHG][%s]: Couldn't set 0x1368[2] rc=%d\n", __func__, rc); } rc = smblib_read(chg, TYPE_C_INTRPT_ENB_SOFTWARE_CTRL_REG, &stat); if (rc < 0) { printk(KERN_ERR "[OPLUS_CHG][%s]: Couldn't read 0x1368 rc=%d\n", __func__, rc); } else { printk(KERN_ERR "[OPLUS_CHG][%s]: reg0x1368[0x%x], bit[2:0]=4(UFP)\n", __func__, stat); } } void otg_enable_id_value (void) { otg_enable_pmic_id_value(); } void otg_disable_id_value (void) { otg_disable_pmic_id_value(); } #endif /* OPLUS_FEATURE_CHG_BASIC */ static int smb5_init_hw(struct smb5 *chip) { struct smb_charger *chg = &chip->chg; int rc; #ifndef OPLUS_FEATURE_CHG_BASIC u8 val = 0, mask = 0; #endif if (chip->dt.no_battery) chg->fake_capacity = 50; if (chip->dt.batt_profile_fcc_ua < 0) smblib_get_charge_param(chg, &chg->param.fcc, &chg->batt_profile_fcc_ua); if (chip->dt.batt_profile_fv_uv < 0) smblib_get_charge_param(chg, &chg->param.fv, &chg->batt_profile_fv_uv); smblib_get_charge_param(chg, &chg->param.usb_icl, &chg->default_icl_ua); smblib_get_charge_param(chg, &chg->param.aicl_5v_threshold, &chg->default_aicl_5v_threshold_mv); chg->aicl_5v_threshold_mv = chg->default_aicl_5v_threshold_mv; smblib_get_charge_param(chg, &chg->param.aicl_cont_threshold, &chg->default_aicl_cont_threshold_mv); chg->aicl_cont_threshold_mv = chg->default_aicl_cont_threshold_mv; if (chg->charger_temp_max == -EINVAL) { rc = smblib_get_thermal_threshold(chg, DIE_REG_H_THRESHOLD_MSB_REG, &chg->charger_temp_max); if (rc < 0) { dev_err(chg->dev, "Couldn't get charger_temp_max rc=%d\n", rc); return rc; } } /* * If SW thermal regulation WA is active then all the HW temperature * comparators need to be disabled to prevent HW thermal regulation, * apart from DIE_TEMP analog comparator for SHDN regulation. */ if (chg->wa_flags & SW_THERM_REGULATION_WA) { rc = smblib_write(chg, MISC_THERMREG_SRC_CFG_REG, THERMREG_SW_ICL_ADJUST_BIT | THERMREG_DIE_CMP_SRC_EN_BIT); if (rc < 0) { dev_err(chg->dev, "Couldn't disable HW thermal regulation rc=%d\n", rc); return rc; } } else { /* configure temperature mitigation */ rc = smb5_configure_mitigation(chg); if (rc < 0) { dev_err(chg->dev, "Couldn't configure mitigation rc=%d\n", rc); return rc; } } /* Set HVDCP autonomous mode per DT option */ smblib_hvdcp_hw_inov_enable(chg, chip->dt.hvdcp_autonomous); /* Disable HVDCP and authentication algorithm if specified in DT */ if (chg->hvdcp_disable) smblib_hvdcp_detect_enable(chg, false); rc = smb5_init_connector_type(chg); if (rc < 0) { dev_err(chg->dev, "Couldn't configure connector type rc=%d\n", rc); return rc; } /* Use ICL results from HW */ rc = smblib_icl_override(chg, HW_AUTO_MODE); if (rc < 0) { pr_err("Couldn't disable ICL override rc=%d\n", rc); return rc; } /* set OTG current limit */ rc = smblib_set_charge_param(chg, &chg->param.otg_cl, chg->otg_cl_ua); if (rc < 0) { pr_err("Couldn't set otg current limit rc=%d\n", rc); return rc; } /* vote 0mA on usb_icl for non battery platforms */ vote(chg->usb_icl_votable, DEFAULT_VOTER, chip->dt.no_battery, 0); vote(chg->dc_suspend_votable, DEFAULT_VOTER, chip->dt.no_battery, 0); vote(chg->fcc_votable, HW_LIMIT_VOTER, chip->dt.batt_profile_fcc_ua > 0, chip->dt.batt_profile_fcc_ua); vote(chg->fv_votable, HW_LIMIT_VOTER, chip->dt.batt_profile_fv_uv > 0, chip->dt.batt_profile_fv_uv); vote(chg->fcc_votable, BATT_PROFILE_VOTER, chg->batt_profile_fcc_ua > 0, chg->batt_profile_fcc_ua); vote(chg->fv_votable, BATT_PROFILE_VOTER, chg->batt_profile_fv_uv > 0, chg->batt_profile_fv_uv); /* Some h/w limit maximum supported ICL */ vote(chg->usb_icl_votable, HW_LIMIT_VOTER, chg->hw_max_icl_ua > 0, chg->hw_max_icl_ua); /* Initialize DC peripheral configurations */ rc = smb5_init_dc_peripheral(chg); if (rc < 0) return rc; /* * AICL configuration: enable aicl and aicl rerun and based on DT * configuration enable/disable ADB based AICL and Suspend on collapse. */ #ifndef OPLUS_FEATURE_CHG_BASIC mask = USBIN_AICL_PERIODIC_RERUN_EN_BIT | USBIN_AICL_ADC_EN_BIT | USBIN_AICL_EN_BIT | SUSPEND_ON_COLLAPSE_USBIN_BIT; val = USBIN_AICL_PERIODIC_RERUN_EN_BIT | USBIN_AICL_EN_BIT; if (!chip->dt.disable_suspend_on_collapse) val |= SUSPEND_ON_COLLAPSE_USBIN_BIT; if (chip->dt.adc_based_aicl) val |= USBIN_AICL_ADC_EN_BIT; rc = smblib_masked_write(chg, USBIN_AICL_OPTIONS_CFG_REG, mask, val); if (rc < 0) { dev_err(chg->dev, "Couldn't config AICL rc=%d\n", rc); return rc; } rc = smblib_write(chg, AICL_RERUN_TIME_CFG_REG, AICL_RERUN_TIME_12S_VAL); if (rc < 0) { dev_err(chg->dev, "Couldn't configure AICL rerun interval rc=%d\n", rc); return rc; } #endif /* enable the charging path */ rc = vote(chg->chg_disable_votable, DEFAULT_VOTER, false, 0); if (rc < 0) { dev_err(chg->dev, "Couldn't enable charging rc=%d\n", rc); return rc; } /* configure VBUS for software control */ rc = smblib_masked_write(chg, DCDC_OTG_CFG_REG, OTG_EN_SRC_CFG_BIT, 0); if (rc < 0) { dev_err(chg->dev, "Couldn't configure VBUS for SW control rc=%d\n", rc); return rc; } #ifndef OPLUS_FEATURE_CHG_BASIC val = (ilog2(chip->dt.wd_bark_time / 16) << BARK_WDOG_TIMEOUT_SHIFT) & BARK_WDOG_TIMEOUT_MASK; val |= (BITE_WDOG_TIMEOUT_8S | BITE_WDOG_DISABLE_CHARGING_CFG_BIT); val |= (chip->dt.wd_snarl_time_cfg << SNARL_WDOG_TIMEOUT_SHIFT) & SNARL_WDOG_TIMEOUT_MASK; rc = smblib_masked_write(chg, SNARL_BARK_BITE_WD_CFG_REG, BITE_WDOG_DISABLE_CHARGING_CFG_BIT | SNARL_WDOG_TIMEOUT_MASK | BARK_WDOG_TIMEOUT_MASK | BITE_WDOG_TIMEOUT_MASK, val); if (rc < 0) { pr_err("Couldn't configue WD config rc=%d\n", rc); return rc; } /* enable WD BARK and enable it on plugin */ val = WDOG_TIMER_EN_ON_PLUGIN_BIT | BARK_WDOG_INT_EN_BIT; rc = smblib_masked_write(chg, WD_CFG_REG, WATCHDOG_TRIGGER_AFP_EN_BIT | WDOG_TIMER_EN_ON_PLUGIN_BIT | BARK_WDOG_INT_EN_BIT, val); if (rc < 0) { pr_err("Couldn't configue WD config rc=%d\n", rc); return rc; } #endif /* set termination current threshold values */ rc = smb5_configure_iterm_thresholds(chip); if (rc < 0) { pr_err("Couldn't configure ITERM thresholds rc=%d\n", rc); return rc; } #ifndef OPLUS_FEATURE_CHG_BASIC /* disable FG default iterm */ rc = smblib_masked_write(chg, FG_UPDATE_CFG_2_SEL_REG, IBT_LT_CHG_TERM_THRESH_SEL_BIT, 1); if (rc < 0) { dev_err(chg->dev, "Couldn't disable FG iterm override rc=%d\n", rc); } rc = smblib_masked_write(chg, CHGR_CFG2_REG, I_TERM_BIT, 1); if (rc < 0) { dev_err(chg->dev, "Couldn't disable PM660 iterm override rc=%d\n", rc); } #endif #ifdef OPLUS_FEATURE_CHG_BASIC smblib_masked_write(chg, 0x1380, 0xff, 0x00); #ifdef OPLUS_CUSTOM_OP_DEF #ifdef OPLUS_FEATURE_CHG_BASIC #else #ifndef OPLUS_FEATURE_CHG_BASIC #endif smblib_masked_write(chg, 0x1365, 0x03, 0x3); #endif #endif #ifdef OPLUS_FEATURE_CHG_BASIC smblib_masked_write(chg, 0x1363, 0x20, 0); #endif #ifdef OPLUS_FEATURE_CHG_BASIC smblib_masked_write(chg, 0x1052, 0x02, 0); smblib_masked_write(chg, 0x1053, 0x40, 0); #endif #ifdef OPLUS_FEATURE_CHG_BASIC smblib_masked_write(chg, 0x1670, 0xff, 0); #endif /*OPLUS_FEATURE_CHG_BASIC*/ #ifdef OPLUS_FEATURE_CHG_BASIC rc = smblib_masked_write(chg, DEBUG_ACCESS_SNK_CFG_REG, 0xff, 0x7); if (rc < 0) pr_err("Couldn't enable at bootup rc=%d\n", rc); #endif #ifdef OPLUS_FEATURE_CHG_BASIC fg_oplus_set_input_current = false; #endif /*OPLUS_FEATURE_CHG_BASIC*/ rc = smb5_configure_float_charger(chip); if (rc < 0) return rc; switch (chip->dt.chg_inhibit_thr_mv) { case 50: rc = smblib_masked_write(chg, CHARGE_INHIBIT_THRESHOLD_CFG_REG, CHARGE_INHIBIT_THRESHOLD_MASK, INHIBIT_ANALOG_VFLT_MINUS_50MV); break; case 100: rc = smblib_masked_write(chg, CHARGE_INHIBIT_THRESHOLD_CFG_REG, CHARGE_INHIBIT_THRESHOLD_MASK, INHIBIT_ANALOG_VFLT_MINUS_100MV); break; case 200: rc = smblib_masked_write(chg, CHARGE_INHIBIT_THRESHOLD_CFG_REG, CHARGE_INHIBIT_THRESHOLD_MASK, INHIBIT_ANALOG_VFLT_MINUS_200MV); break; case 300: rc = smblib_masked_write(chg, CHARGE_INHIBIT_THRESHOLD_CFG_REG, CHARGE_INHIBIT_THRESHOLD_MASK, INHIBIT_ANALOG_VFLT_MINUS_300MV); break; case 0: rc = smblib_masked_write(chg, CHGR_CFG2_REG, CHARGER_INHIBIT_BIT, 0); default: break; } if (rc < 0) { dev_err(chg->dev, "Couldn't configure charge inhibit threshold rc=%d\n", rc); return rc; } rc = smblib_write(chg, CHGR_FAST_CHARGE_SAFETY_TIMER_CFG_REG, FAST_CHARGE_SAFETY_TIMER_1536_MIN); if (rc < 0) { dev_err(chg->dev, "Couldn't set CHGR_FAST_CHARGE_SAFETY_TIMER_CFG_REG rc=%d\n", rc); return rc; } rc = smb5_configure_recharging(chip); if (rc < 0) return rc; rc = smblib_disable_hw_jeita(chg, true); if (rc < 0) { dev_err(chg->dev, "Couldn't set hw jeita rc=%d\n", rc); return rc; } rc = smblib_masked_write(chg, DCDC_ENG_SDCDC_CFG5_REG, ENG_SDCDC_BAT_HPWR_MASK, BOOST_MODE_THRESH_3P6_V); if (rc < 0) { dev_err(chg->dev, "Couldn't configure DCDC_ENG_SDCDC_CFG5 rc=%d\n", rc); return rc; } if (chg->connector_pull_up != -EINVAL) { rc = smb5_configure_internal_pull(chg, CONN_THERM, get_valid_pullup(chg->connector_pull_up)); if (rc < 0) { dev_err(chg->dev, "Couldn't configure CONN_THERM pull-up rc=%d\n", rc); return rc; } } if (chg->smb_pull_up != -EINVAL) { rc = smb5_configure_internal_pull(chg, SMB_THERM, get_valid_pullup(chg->smb_pull_up)); if (rc < 0) { dev_err(chg->dev, "Couldn't configure SMB pull-up rc=%d\n", rc); return rc; } } return rc; } static int smb5_post_init(struct smb5 *chip) { struct smb_charger *chg = &chip->chg; union power_supply_propval pval; int rc; #ifdef OPLUS_FEATURE_CHG_BASIC int level = 0; #endif /* * In case the usb path is suspended, we would have missed disabling * the icl change interrupt because the interrupt could have been * not requested */ rerun_election(chg->usb_icl_votable); #ifdef OPLUS_FEATURE_CHG_BASIC if (g_oplus_chip && oplus_ccdetect_check_is_gpio(g_oplus_chip) == true) { level = gpio_get_value(chg->ccdetect_gpio); usleep_range(2000, 2100); if (level != gpio_get_value(chg->ccdetect_gpio)) { printk(KERN_ERR "[OPLUS_CHG][%s]: ccdetect_gpio is unstable, try again...\n", __func__); usleep_range(10000, 11000); level = gpio_get_value(chg->ccdetect_gpio); } if (level <= 0) { oplus_ccdetect_enable(); } } else { /* configure power role for dual-role */ pval.intval = POWER_SUPPLY_TYPEC_PR_DUAL; rc = smblib_set_prop_typec_power_role(chg, &pval); if (rc < 0) { dev_err(chg->dev, "Couldn't configure DRP role rc=%d\n", rc); return rc; } } //oplus_ccdetect_enable(); #else /* configure power role for dual-role */ pval.intval = POWER_SUPPLY_TYPEC_PR_DUAL; rc = smblib_set_prop_typec_power_role(chg, &pval); if (rc < 0) { dev_err(chg->dev, "Couldn't configure DRP role rc=%d\n", rc); return rc; } #endif rerun_election(chg->temp_change_irq_disable_votable); return 0; } /**************************** * DETERMINE INITIAL STATUS * ****************************/ static int smb5_determine_initial_status(struct smb5 *chip) { struct smb_irq_data irq_data = {chip, "determine-initial-status"}; struct smb_charger *chg = &chip->chg; union power_supply_propval val; int rc; #ifdef OPLUS_FEATURE_CHG_BASIC msleep(200); #endif rc = smblib_get_prop_usb_present(chg, &val); if (rc < 0) { pr_err("Couldn't get usb present rc=%d\n", rc); return rc; } chg->early_usb_attach = val.intval; if (chg->bms_psy) smblib_suspend_on_debug_battery(chg); usb_plugin_irq_handler(0, &irq_data); dc_plugin_irq_handler(0, &irq_data); typec_attach_detach_irq_handler(0, &irq_data); typec_state_change_irq_handler(0, &irq_data); usb_source_change_irq_handler(0, &irq_data); chg_state_change_irq_handler(0, &irq_data); icl_change_irq_handler(0, &irq_data); batt_temp_changed_irq_handler(0, &irq_data); wdog_bark_irq_handler(0, &irq_data); typec_or_rid_detection_change_irq_handler(0, &irq_data); wdog_snarl_irq_handler(0, &irq_data); #ifdef OPLUS_FEATURE_CHG_BASIC if (chg->early_usb_attach) schedule_delayed_work(&chg->typec_disable_cmd_work, msecs_to_jiffies(1000)); #endif return 0; } /************************** * INTERRUPT REGISTRATION * **************************/ static struct smb_irq_info smb5_irqs[] = { /* CHARGER IRQs */ [CHGR_ERROR_IRQ] = { .name = "chgr-error", .handler = default_irq_handler, }, [CHG_STATE_CHANGE_IRQ] = { .name = "chg-state-change", .handler = chg_state_change_irq_handler, .wake = true, }, [STEP_CHG_STATE_CHANGE_IRQ] = { .name = "step-chg-state-change", }, [STEP_CHG_SOC_UPDATE_FAIL_IRQ] = { .name = "step-chg-soc-update-fail", }, [STEP_CHG_SOC_UPDATE_REQ_IRQ] = { .name = "step-chg-soc-update-req", }, [FG_FVCAL_QUALIFIED_IRQ] = { .name = "fg-fvcal-qualified", }, [VPH_ALARM_IRQ] = { .name = "vph-alarm", }, [VPH_DROP_PRECHG_IRQ] = { .name = "vph-drop-prechg", }, /* DCDC IRQs */ [OTG_FAIL_IRQ] = { .name = "otg-fail", .handler = default_irq_handler, }, [OTG_OC_DISABLE_SW_IRQ] = { .name = "otg-oc-disable-sw", }, [OTG_OC_HICCUP_IRQ] = { .name = "otg-oc-hiccup", }, [BSM_ACTIVE_IRQ] = { .name = "bsm-active", }, [HIGH_DUTY_CYCLE_IRQ] = { .name = "high-duty-cycle", .handler = high_duty_cycle_irq_handler, .wake = true, }, [INPUT_CURRENT_LIMITING_IRQ] = { .name = "input-current-limiting", .handler = default_irq_handler, }, [CONCURRENT_MODE_DISABLE_IRQ] = { .name = "concurrent-mode-disable", }, [SWITCHER_POWER_OK_IRQ] = { .name = "switcher-power-ok", .handler = switcher_power_ok_irq_handler, #ifdef OPLUS_FEATURE_CHG_BASIC .storm_data = {true, 1000, 3}, #endif }, /* BATTERY IRQs */ [BAT_TEMP_IRQ] = { .name = "bat-temp", .handler = batt_temp_changed_irq_handler, .wake = true, }, [ALL_CHNL_CONV_DONE_IRQ] = { .name = "all-chnl-conv-done", }, [BAT_OV_IRQ] = { .name = "bat-ov", .handler = batt_psy_changed_irq_handler, }, [BAT_LOW_IRQ] = { .name = "bat-low", .handler = batt_psy_changed_irq_handler, }, [BAT_THERM_OR_ID_MISSING_IRQ] = { .name = "bat-therm-or-id-missing", .handler = batt_psy_changed_irq_handler, }, [BAT_TERMINAL_MISSING_IRQ] = { .name = "bat-terminal-missing", .handler = batt_psy_changed_irq_handler, }, [BUCK_OC_IRQ] = { .name = "buck-oc", }, [VPH_OV_IRQ] = { .name = "vph-ov", }, /* USB INPUT IRQs */ [USBIN_COLLAPSE_IRQ] = { .name = "usbin-collapse", .handler = default_irq_handler, }, [USBIN_VASHDN_IRQ] = { .name = "usbin-vashdn", .handler = default_irq_handler, }, [USBIN_UV_IRQ] = { .name = "usbin-uv", .handler = usbin_uv_irq_handler, .wake = true, .storm_data = {true, 3000, 5}, }, [USBIN_OV_IRQ] = { .name = "usbin-ov", .handler = usbin_ov_irq_handler, }, [USBIN_PLUGIN_IRQ] = { .name = "usbin-plugin", .handler = usb_plugin_irq_handler, .wake = true, }, [USBIN_REVI_CHANGE_IRQ] = { .name = "usbin-revi-change", }, [USBIN_SRC_CHANGE_IRQ] = { .name = "usbin-src-change", .handler = usb_source_change_irq_handler, .wake = true, }, [USBIN_ICL_CHANGE_IRQ] = { .name = "usbin-icl-change", .handler = icl_change_irq_handler, .wake = true, }, /* DC INPUT IRQs */ [DCIN_VASHDN_IRQ] = { .name = "dcin-vashdn", }, [DCIN_UV_IRQ] = { .name = "dcin-uv", .handler = dcin_uv_irq_handler, .wake = true, }, [DCIN_OV_IRQ] = { .name = "dcin-ov", .handler = default_irq_handler, }, [DCIN_PLUGIN_IRQ] = { .name = "dcin-plugin", .handler = dc_plugin_irq_handler, .wake = true, }, [DCIN_REVI_IRQ] = { .name = "dcin-revi", }, [DCIN_PON_IRQ] = { .name = "dcin-pon", .handler = default_irq_handler, }, [DCIN_EN_IRQ] = { .name = "dcin-en", .handler = default_irq_handler, }, /* TYPEC IRQs */ [TYPEC_OR_RID_DETECTION_CHANGE_IRQ] = { .name = "typec-or-rid-detect-change", .handler = typec_or_rid_detection_change_irq_handler, .wake = true, }, [TYPEC_VPD_DETECT_IRQ] = { .name = "typec-vpd-detect", }, [TYPEC_CC_STATE_CHANGE_IRQ] = { .name = "typec-cc-state-change", .handler = typec_state_change_irq_handler, .wake = true, }, [TYPEC_VCONN_OC_IRQ] = { .name = "typec-vconn-oc", .handler = default_irq_handler, }, [TYPEC_VBUS_CHANGE_IRQ] = { .name = "typec-vbus-change", }, [TYPEC_ATTACH_DETACH_IRQ] = { .name = "typec-attach-detach", .handler = typec_attach_detach_irq_handler, .wake = true, }, [TYPEC_LEGACY_CABLE_DETECT_IRQ] = { .name = "typec-legacy-cable-detect", .handler = default_irq_handler, }, [TYPEC_TRY_SNK_SRC_DETECT_IRQ] = { .name = "typec-try-snk-src-detect", }, /* MISCELLANEOUS IRQs */ [WDOG_SNARL_IRQ] = { .name = "wdog-snarl", .handler = wdog_snarl_irq_handler, .wake = true, }, [WDOG_BARK_IRQ] = { .name = "wdog-bark", .handler = wdog_bark_irq_handler, .wake = true, }, [AICL_FAIL_IRQ] = { .name = "aicl-fail", }, [AICL_DONE_IRQ] = { .name = "aicl-done", .handler = default_irq_handler, }, [SMB_EN_IRQ] = { .name = "smb-en", .handler = smb_en_irq_handler, }, [IMP_TRIGGER_IRQ] = { .name = "imp-trigger", }, /* * triggered when DIE or SKIN or CONNECTOR temperature across * either of the _REG_L, _REG_H, _RST, or _SHDN thresholds */ [TEMP_CHANGE_IRQ] = { .name = "temp-change", .handler = temp_change_irq_handler, .wake = true, }, [TEMP_CHANGE_SMB_IRQ] = { .name = "temp-change-smb", }, /* FLASH */ [VREG_OK_IRQ] = { .name = "vreg-ok", }, [ILIM_S2_IRQ] = { .name = "ilim2-s2", .handler = schgm_flash_ilim2_irq_handler, }, [ILIM_S1_IRQ] = { .name = "ilim1-s1", }, [VOUT_DOWN_IRQ] = { .name = "vout-down", }, [VOUT_UP_IRQ] = { .name = "vout-up", }, [FLASH_STATE_CHANGE_IRQ] = { .name = "flash-state-change", .handler = schgm_flash_state_change_irq_handler, }, [TORCH_REQ_IRQ] = { .name = "torch-req", }, [FLASH_EN_IRQ] = { .name = "flash-en", }, /* SDAM */ [SDAM_STS_IRQ] = { .name = "sdam-sts", .handler = sdam_sts_change_irq_handler, }, }; static int smb5_get_irq_index_byname(const char *irq_name) { int i; for (i = 0; i < ARRAY_SIZE(smb5_irqs); i++) { if (strcmp(smb5_irqs[i].name, irq_name) == 0) return i; } return -ENOENT; } static int smb5_request_interrupt(struct smb5 *chip, struct device_node *node, const char *irq_name) { struct smb_charger *chg = &chip->chg; int rc, irq, irq_index; struct smb_irq_data *irq_data; irq = of_irq_get_byname(node, irq_name); if (irq < 0) { pr_err("Couldn't get irq %s byname\n", irq_name); return irq; } irq_index = smb5_get_irq_index_byname(irq_name); if (irq_index < 0) { pr_err("%s is not a defined irq\n", irq_name); return irq_index; } if (!smb5_irqs[irq_index].handler) return 0; irq_data = devm_kzalloc(chg->dev, sizeof(*irq_data), GFP_KERNEL); if (!irq_data) return -ENOMEM; irq_data->parent_data = chip; irq_data->name = irq_name; irq_data->storm_data = smb5_irqs[irq_index].storm_data; mutex_init(&irq_data->storm_data.storm_lock); smb5_irqs[irq_index].enabled = true; rc = devm_request_threaded_irq(chg->dev, irq, NULL, smb5_irqs[irq_index].handler, IRQF_ONESHOT, irq_name, irq_data); if (rc < 0) { pr_err("Couldn't request irq %d\n", irq); return rc; } smb5_irqs[irq_index].irq = irq; smb5_irqs[irq_index].irq_data = irq_data; if (smb5_irqs[irq_index].wake) enable_irq_wake(irq); return rc; } static int smb5_request_interrupts(struct smb5 *chip) { struct smb_charger *chg = &chip->chg; struct device_node *node = chg->dev->of_node; struct device_node *child; int rc = 0; const char *name; struct property *prop; for_each_available_child_of_node(node, child) { of_property_for_each_string(child, "interrupt-names", prop, name) { rc = smb5_request_interrupt(chip, child, name); if (rc < 0) return rc; } } vote(chg->limited_irq_disable_votable, CHARGER_TYPE_VOTER, true, 0); vote(chg->hdc_irq_disable_votable, CHARGER_TYPE_VOTER, true, 0); return rc; } static void smb5_free_interrupts(struct smb_charger *chg) { int i; for (i = 0; i < ARRAY_SIZE(smb5_irqs); i++) { if (smb5_irqs[i].irq > 0) { if (smb5_irqs[i].wake) disable_irq_wake(smb5_irqs[i].irq); devm_free_irq(chg->dev, smb5_irqs[i].irq, smb5_irqs[i].irq_data); } } } static void smb5_disable_interrupts(struct smb_charger *chg) { int i; for (i = 0; i < ARRAY_SIZE(smb5_irqs); i++) { if (smb5_irqs[i].irq > 0) disable_irq(smb5_irqs[i].irq); } } #if defined(CONFIG_DEBUG_FS) static int force_batt_psy_update_write(void *data, u64 val) { struct smb_charger *chg = data; power_supply_changed(chg->batt_psy); return 0; } DEFINE_DEBUGFS_ATTRIBUTE(force_batt_psy_update_ops, NULL, force_batt_psy_update_write, "0x%02llx\n"); static int force_usb_psy_update_write(void *data, u64 val) { struct smb_charger *chg = data; power_supply_changed(chg->usb_psy); return 0; } DEFINE_DEBUGFS_ATTRIBUTE(force_usb_psy_update_ops, NULL, force_usb_psy_update_write, "0x%02llx\n"); static int force_dc_psy_update_write(void *data, u64 val) { struct smb_charger *chg = data; #ifdef OPLUS_FEATURE_CHG_BASIC if (chg->dc_psy) #endif power_supply_changed(chg->dc_psy); return 0; } DEFINE_DEBUGFS_ATTRIBUTE(force_dc_psy_update_ops, NULL, force_dc_psy_update_write, "0x%02llx\n"); static void smb5_create_debugfs(struct smb5 *chip) { struct dentry *file; chip->dfs_root = debugfs_create_dir("charger", NULL); if (IS_ERR_OR_NULL(chip->dfs_root)) { pr_err("Couldn't create charger debugfs rc=%ld\n", (long)chip->dfs_root); return; } file = debugfs_create_file("force_batt_psy_update", 0600, chip->dfs_root, chip, &force_batt_psy_update_ops); if (IS_ERR_OR_NULL(file)) pr_err("Couldn't create force_batt_psy_update file rc=%ld\n", (long)file); file = debugfs_create_file("force_usb_psy_update", 0600, chip->dfs_root, chip, &force_usb_psy_update_ops); if (IS_ERR_OR_NULL(file)) pr_err("Couldn't create force_usb_psy_update file rc=%ld\n", (long)file); file = debugfs_create_file("force_dc_psy_update", 0600, chip->dfs_root, chip, &force_dc_psy_update_ops); if (IS_ERR_OR_NULL(file)) pr_err("Couldn't create force_dc_psy_update file rc=%ld\n", (long)file); file = debugfs_create_u32("debug_mask", 0600, chip->dfs_root, &__debug_mask); if (IS_ERR_OR_NULL(file)) pr_err("Couldn't create debug_mask file rc=%ld\n", (long)file); } #else static void smb5_create_debugfs(struct smb5 *chip) {} #endif #ifdef OPLUS_FEATURE_CHG_BASIC static bool d_reg_mask = false; static ssize_t dump_registers_mask_write(struct file *file, const char __user *buff, size_t count, loff_t *ppos) { char mask[16]; if (count > 16) { return -EFAULT; } if (copy_from_user(&mask, buff, count)) { printk(KERN_ERR "dump_registers_mask_write error.\n"); return -EFAULT; } if (strncmp(mask, "dump808", 7) == 0) { d_reg_mask = true; printk(KERN_ERR "dump registers mask enable.\n"); } else { d_reg_mask = false; return -EFAULT; } return count; } static const struct file_operations dump_registers_mask_fops = { .write = dump_registers_mask_write, .llseek = noop_llseek, }; static void init_proc_dump_registers_mask(void) { if (!proc_create("d_reg_mask", S_IWUSR | S_IWGRP | S_IWOTH, NULL, &dump_registers_mask_fops)) { printk(KERN_ERR "proc_create dump_registers_mask_fops fail\n"); } } #endif /* OPLUS_FEATURE_CHG_BASIC */ #ifdef OPLUS_FEATURE_CHG_BASIC //static int get_boot_mode(void); static int smbchg_usb_suspend_disable(void); static int smbchg_usb_suspend_enable(void); static int smbchg_charging_enble(void); bool oplus_chg_is_usb_present(void); int qpnp_get_prop_charger_voltage_now(void); static void dump_regs(void) { int i; int j; int rc; u8 stat; int base[] = {0x1000, 0x1100, 0x1200, 0x1300, 0x1400, 0x1600, 0x1800, 0x1900}; struct smb_charger *chg = NULL; if (!g_oplus_chip || !d_reg_mask) return; chg = &g_oplus_chip->pmic_spmi.smb5_chip->chg; if (!chg) return; pr_err("================= %s: begin ======================\n", __func__); for (j = 0; j < 8; j++) { for (i = 0; i < 255; i++) { rc = smblib_read(chg, base[j] + i, &stat); if (rc < 0) { pr_err("Couldn't read %x rc=%d\n", base[j] + i, rc); } else { pr_err("%x : %x\n", base[j] + i, stat); } } msleep(1000); } pr_err("================= %s: end ======================\n", __func__); d_reg_mask = false; } static int smbchg_kick_wdt(void) { return 0; } static int oplus_chg_hw_init(void) { int boot_mode = get_boot_mode(); if (boot_mode != MSM_BOOT_MODE__RF && boot_mode != MSM_BOOT_MODE__WLAN) { smbchg_usb_suspend_disable(); } else { smbchg_usb_suspend_enable(); } smbchg_charging_enble(); return 0; } static int smbchg_set_fastchg_current_raw(int current_ma) { int rc = 0; struct oplus_chg_chip *chip = g_oplus_chip; #ifdef OPLUS_CUSTOM_OP_DEF if(chip->pmic_spmi.smb5_chip->chg.wireless_present) { chg_err("Wirelss on not set fastchg current\n"); return rc; } #endif rc = vote(chip->pmic_spmi.smb5_chip->chg.fcc_votable, DEFAULT_VOTER, true, current_ma * 1000); if (rc < 0) chg_err("Couldn't vote fcc_votable[%d], rc=%d\n", current_ma, rc); return rc; } static void smbchg_set_aicl_point(int vol) { //DO Nothing } static void smbchg_aicl_enable(bool enable) { int rc = 0; u8 aicl_op; struct oplus_chg_chip *chip = g_oplus_chip; rc = smblib_masked_write(&chip->pmic_spmi.smb5_chip->chg, USBIN_AICL_OPTIONS_CFG_REG, USBIN_AICL_EN_BIT, enable ? USBIN_AICL_EN_BIT : 0); if (rc < 0) chg_err("Couldn't write USBIN_AICL_OPTIONS_CFG_REG rc=%d\n", rc); rc = smblib_read(&chip->pmic_spmi.smb5_chip->chg, 0x1380, &aicl_op); if (!rc) chg_err("AICL_OPTIONS 0x1380 = 0x%02x\n", aicl_op); //dump 0x1380 } static void smbchg_usbin_collapse_irq_enable(bool enable) { static bool collapse_en = true; struct oplus_chg_chip *chip = g_oplus_chip; if (enable && !collapse_en){ enable_irq(chip->pmic_spmi.smb5_chip->chg.irq_info[USBIN_COLLAPSE_IRQ].irq); }else if (!enable && collapse_en){ disable_irq(chip->pmic_spmi.smb5_chip->chg.irq_info[USBIN_COLLAPSE_IRQ].irq); } collapse_en = enable; } static void smbchg_rerun_aicl(void) { smbchg_aicl_enable(false); /* Add a delay so that AICL successfully clears */ msleep(50); smbchg_aicl_enable(true); } static bool oplus_chg_is_normal_mode(void) { int boot_mode = get_boot_mode(); if (boot_mode == MSM_BOOT_MODE__RF || boot_mode == MSM_BOOT_MODE__WLAN) return false; return true; } static bool oplus_chg_is_suspend_status(void) { int rc = 0; u8 stat; struct smb_charger *chg = NULL; if (!g_oplus_chip) return false; chg = &g_oplus_chip->pmic_spmi.smb5_chip->chg; rc = smblib_read(chg, POWER_PATH_STATUS_REG, &stat); if (rc < 0) { printk(KERN_ERR "oplus_chg_is_suspend_status: Couldn't read POWER_PATH_STATUS rc=%d\n", rc); return false; } return (bool)(stat & USBIN_SUSPEND_STS_BIT); } static void oplus_chg_clear_suspend(void) { int rc; int boot_mode = get_boot_mode(); struct smb_charger *chg = NULL; if (!g_oplus_chip) return; if (boot_mode == MSM_BOOT_MODE__RF || boot_mode == MSM_BOOT_MODE__WLAN) return; chg = &g_oplus_chip->pmic_spmi.smb5_chip->chg; //rc = smblib_masked_write(chg, USBIN_CMD_IL_REG, USBIN_SUSPEND_BIT, 1); rc = smblib_set_usb_suspend(chg, true); if (rc < 0) { printk(KERN_ERR "oplus_chg_monitor_work: Couldn't set USBIN_SUSPEND_BIT rc=%d\n", rc); } msleep(50); //rc = smblib_masked_write(chg, USBIN_CMD_IL_REG, USBIN_SUSPEND_BIT, 0); rc = smblib_set_usb_suspend(chg, false); if (rc < 0) { printk(KERN_ERR "oplus_chg_monitor_work: Couldn't clear USBIN_SUSPEND_BIT rc=%d\n", rc); } } static void oplus_chg_check_clear_suspend(void) { use_present_status = true; oplus_chg_clear_suspend(); use_present_status = false; } static int usb_icl[] = { 300, 500, 900, 1200, 1350, 1500, 1750, 2000, 3000, }; #define USBIN_25MA 25000 static int oplus_chg_set_input_current(int current_ma) { int rc = 0, i = 0; #ifdef OPLUS_CUSTOM_OP_DEF int n = 0; #endif int chg_vol = 0; int aicl_point = 0; u8 stat = 0; int pre_current = 0; struct oplus_chg_chip *chip = g_oplus_chip; if (chip->mmi_chg == 0) { /*for charger cycle test*/ chg_debug( "mmi_chg, return\n"); return rc; } if (get_client_vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, BOOST_BACK_VOTER) == 0 && get_effective_result(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable) <= USBIN_25MA) { vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, BOOST_BACK_VOTER, false, 0); } if (chip->pmic_spmi.smb5_chip->chg.pre_current_ma == current_ma) return rc; else { pre_current = chip->pmic_spmi.smb5_chip->chg.pre_current_ma; chip->pmic_spmi.smb5_chip->chg.pre_current_ma = current_ma; } fg_oplus_set_input_current = true; chg_debug( "usb input max current limit=%d setting %02x, pre_current[%d]\n", current_ma, i, pre_current); if (chip->batt_volt > 4100 ) aicl_point = 4550; else aicl_point = 4500; smbchg_aicl_enable(false); smbchg_usbin_collapse_irq_enable(false); #ifdef OPLUS_CUSTOM_OP_DEF if (pre_current != -1) { for (n = sizeof(usb_icl)/sizeof(int); n > 0; n--) { if (pre_current > usb_icl[n]) { break; } } chg_debug("downTo: usb input max current limit = %d setting %d\n", current_ma, n); if (usb_icl[n] > 1200) { rc = vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, USB_PSY_VOTER, true, usb_icl[n] * 1000); msleep(90); n--; if (usb_icl[n] >= 1200) { rc = vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, USB_PSY_VOTER, true, usb_icl[n] * 1000); msleep(90); n--; if (usb_icl[n] >= 1200) { rc = vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, USB_PSY_VOTER, true, usb_icl[n] * 1000); msleep(90); n--; if (usb_icl[n] >= 1200) { rc = vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, USB_PSY_VOTER, true, usb_icl[n] * 1000); msleep(90); n--; if (usb_icl[n] >= 1200) { rc = vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, USB_PSY_VOTER, true, usb_icl[n] * 1000); msleep(90); n--; } } } } } } #endif if (current_ma < 500) { i = 0; goto aicl_end; } i = 1; /* 500 */ rc = vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, USB_PSY_VOTER, true, usb_icl[i] * 1000); msleep(90); if (get_client_vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, BOOST_BACK_VOTER) == 0 && get_effective_result(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable) <= USBIN_25MA) { chg_debug( "use 500 here\n"); goto aicl_boost_back; } chg_vol = qpnp_get_prop_charger_voltage_now(); if (get_client_vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, BOOST_BACK_VOTER) == 0 && get_effective_result(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable) <= USBIN_25MA) { chg_debug( "use 500 here\n"); goto aicl_boost_back; } if (chg_vol < aicl_point) { chg_debug( "use 500 here\n"); goto aicl_end; } else if (current_ma < 900) goto aicl_end; i = 2; /* 900 */ rc = vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, USB_PSY_VOTER, true, usb_icl[i] * 1000); msleep(90); if (get_client_vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, BOOST_BACK_VOTER) == 0 && get_effective_result(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable) <= USBIN_25MA) { i = i - 1; goto aicl_boost_back; } if (oplus_chg_is_suspend_status() && oplus_chg_is_usb_present() && oplus_chg_is_normal_mode()) { i = i - 1; goto aicl_suspend; } chg_vol = qpnp_get_prop_charger_voltage_now(); if (get_client_vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, BOOST_BACK_VOTER) == 0 && get_effective_result(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable) <= USBIN_25MA) { i = i - 1; goto aicl_boost_back; } if (chg_vol < aicl_point) { i = i - 1; goto aicl_pre_step; } else if (current_ma < 1200) goto aicl_end; i = 3; /* 1200 */ rc = vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, USB_PSY_VOTER, true, usb_icl[i] * 1000); msleep(90); if (get_client_vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, BOOST_BACK_VOTER) == 0 && get_effective_result(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable) <= USBIN_25MA) { i = i - 1; goto aicl_boost_back; } if (oplus_chg_is_suspend_status() && oplus_chg_is_usb_present() && oplus_chg_is_normal_mode()) { i = i - 1; goto aicl_suspend; } chg_vol = qpnp_get_prop_charger_voltage_now(); if (get_client_vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, BOOST_BACK_VOTER) == 0 && get_effective_result(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable) <= USBIN_25MA) { i = i - 1; goto aicl_boost_back; } if (chg_vol < aicl_point) { i = i - 1; goto aicl_pre_step; } i = 4; /* 1350 */ rc = vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, USB_PSY_VOTER, true, usb_icl[i] * 1000); msleep(130); if (get_client_vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, BOOST_BACK_VOTER) == 0 && get_effective_result(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable) <= USBIN_25MA) { i = i - 2; goto aicl_boost_back; } if (oplus_chg_is_suspend_status() && oplus_chg_is_usb_present() && oplus_chg_is_normal_mode()) { i = i - 2; goto aicl_suspend; } chg_vol = qpnp_get_prop_charger_voltage_now(); if (get_client_vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, BOOST_BACK_VOTER) == 0 && get_effective_result(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable) <= USBIN_25MA) { i = i - 2; goto aicl_boost_back; } if (chg_vol < aicl_point) { i = i - 2; goto aicl_pre_step; } i = 5; /* 1500 */ rc = vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, USB_PSY_VOTER, true, usb_icl[i] * 1000); msleep(120); if (get_client_vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, BOOST_BACK_VOTER) == 0 && get_effective_result(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable) <= USBIN_25MA) { i = i - 3; goto aicl_boost_back; } if (oplus_chg_is_suspend_status() && oplus_chg_is_usb_present() && oplus_chg_is_normal_mode()) { i = i - 3; goto aicl_suspend; } chg_vol = qpnp_get_prop_charger_voltage_now(); if (get_client_vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, BOOST_BACK_VOTER) == 0 && get_effective_result(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable) <= USBIN_25MA) { i = i - 3; goto aicl_boost_back; } if (chg_vol < aicl_point) { i = i - 3; //We DO NOT use 1.2A here goto aicl_pre_step; } else if (current_ma < 1500) { i = i - 2; //We use 1.2A here goto aicl_end; } else if (current_ma < 2000) goto aicl_end; i = 6; /* 1750 */ rc = vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, USB_PSY_VOTER, true, usb_icl[i] * 1000); msleep(120); if (get_client_vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, BOOST_BACK_VOTER) == 0 && get_effective_result(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable) <= USBIN_25MA) { i = i - 3; goto aicl_boost_back; } if (oplus_chg_is_suspend_status() && oplus_chg_is_usb_present() && oplus_chg_is_normal_mode()) { i = i - 3; goto aicl_suspend; } chg_vol = qpnp_get_prop_charger_voltage_now(); if (get_client_vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, BOOST_BACK_VOTER) == 0 && get_effective_result(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable) <= USBIN_25MA) { i = i - 3; goto aicl_boost_back; } if (chg_vol < aicl_point) { i = i - 3; //1.2 goto aicl_pre_step; } i = 7; /* 2000 */ rc = vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, USB_PSY_VOTER, true, usb_icl[i] * 1000); msleep(90); if (get_client_vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, BOOST_BACK_VOTER) == 0 && get_effective_result(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable) <= USBIN_25MA) { i = i - 2; goto aicl_boost_back; } if (oplus_chg_is_suspend_status() && oplus_chg_is_usb_present() && oplus_chg_is_normal_mode()) { i = i - 2; goto aicl_suspend; } chg_vol = qpnp_get_prop_charger_voltage_now(); if (get_client_vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, BOOST_BACK_VOTER) == 0 && get_effective_result(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable) <= USBIN_25MA) { i = i - 2; goto aicl_boost_back; } if (chg_vol < aicl_point) { i = i - 2;//1.5 goto aicl_pre_step; } else if (current_ma < 3000) goto aicl_end; i = 8; /* 3000 */ rc = vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, USB_PSY_VOTER, true, usb_icl[i] * 1000); msleep(90); if (get_client_vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, BOOST_BACK_VOTER) == 0 && get_effective_result(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable) <= USBIN_25MA) { i = i - 1; goto aicl_boost_back; } if (oplus_chg_is_suspend_status() && oplus_chg_is_usb_present() && oplus_chg_is_normal_mode()) { i = i - 1; goto aicl_suspend; } chg_vol = qpnp_get_prop_charger_voltage_now(); if (chg_vol < aicl_point) { i = i - 1; goto aicl_pre_step; } else if (current_ma >= 3000) goto aicl_end; aicl_pre_step: rc = vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, USB_PSY_VOTER, true, usb_icl[i] * 1000); chg_debug( "usb input max current limit aicl chg_vol=%d j[%d]=%d sw_aicl_point:%d aicl_pre_step\n", chg_vol, i, usb_icl[i], aicl_point); smbchg_rerun_aicl(); smbchg_usbin_collapse_irq_enable(true); goto aicl_return; aicl_end: rc = vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, USB_PSY_VOTER, true, usb_icl[i] * 1000); chg_debug( "usb input max current limit aicl chg_vol=%d j[%d]=%d sw_aicl_point:%d aicl_end\n", chg_vol, i, usb_icl[i], aicl_point); smbchg_rerun_aicl(); smbchg_usbin_collapse_irq_enable(true); goto aicl_return; aicl_boost_back: rc = vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, USB_PSY_VOTER, true, usb_icl[i] * 1000); chg_debug( "usb input max current limit aicl chg_vol=%d j[%d]=%d sw_aicl_point:%d aicl_boost_back\n", chg_vol, i, usb_icl[i], aicl_point); if (chip->pmic_spmi.smb5_chip->chg.wa_flags & BOOST_BACK_WA) vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, BOOST_BACK_VOTER, false, 0); smbchg_rerun_aicl(); smbchg_usbin_collapse_irq_enable(true); goto aicl_return; aicl_suspend: rc = vote(chip->pmic_spmi.smb5_chip->chg.usb_icl_votable, USB_PSY_VOTER, true, usb_icl[i] * 1000); chg_debug( "usb input max current limit aicl chg_vol=%d j[%d]=%d sw_aicl_point:%d aicl_suspend\n", chg_vol, i, usb_icl[i], aicl_point); oplus_chg_check_clear_suspend(); smbchg_rerun_aicl(); smbchg_usbin_collapse_irq_enable(true); goto aicl_return; aicl_return: /*FORCE icl 500mA for AUDIO_ADAPTER combo cable*/ if (chip->pmic_spmi.smb5_chip->chg.typec_mode == POWER_SUPPLY_TYPEC_SINK_AUDIO_ADAPTER) { chg_debug( "AUDIO ADAPTER MODE\n"); rc = smblib_read(&chip->pmic_spmi.smb5_chip->chg, USBIN_LOAD_CFG_REG, &stat); if (rc < 0) { chg_debug( "read USBIN_LOAD_CFG_REG, failed rc=%d\n", rc); } if ((bool)(stat& ICL_OVERRIDE_AFTER_APSD_BIT)) { rc = smblib_write(&chip->pmic_spmi.smb5_chip->chg, USBIN_CURRENT_LIMIT_CFG_REG, 0x14); if (rc < 0) { chg_debug( "Couldn't write USBIN_CURRENT_LIMIT_CFG_REG rc=%d\n", rc); } else { chg_debug( "FORCE icl 500\n"); } } } return rc; } static int smbchg_float_voltage_set(int vfloat_mv) { int rc = 0; struct oplus_chg_chip *chip = g_oplus_chip; rc = vote(chip->pmic_spmi.smb5_chip->chg.fv_votable, BATT_PROFILE_VOTER/*DEFAULT_VOTER*/, true, vfloat_mv * 1000); if (rc < 0) chg_err("Couldn't vote fv_votable[%d], rc=%d\n", vfloat_mv, rc); return rc; } static int smbchg_term_current_set(int term_current) { int rc = 0; u8 val_raw = 0; struct oplus_chg_chip *chip = g_oplus_chip; if (term_current < 0 || term_current > 750) term_current = 150; val_raw = term_current / 50; rc = smblib_masked_write(&chip->pmic_spmi.smb5_chip->chg, TCCC_CHARGE_CURRENT_TERMINATION_CFG_REG, TCCC_CHARGE_CURRENT_TERMINATION_SETTING_MASK, val_raw); if (rc < 0) chg_err("Couldn't write TCCC_CHARGE_CURRENT_TERMINATION_CFG_REG rc=%d\n", rc); return rc; } static int smbchg_charging_enble(void) { int rc = 0; struct oplus_chg_chip *chip = g_oplus_chip; rc = vote(chip->pmic_spmi.smb5_chip->chg.chg_disable_votable, DEFAULT_VOTER, false, 0); if (rc < 0) chg_err("Couldn't enable charging, rc=%d\n", rc); return rc; } static int smbchg_charging_disble(void) { int rc = 0; struct oplus_chg_chip *chip = g_oplus_chip; rc = vote(chip->pmic_spmi.smb5_chip->chg.chg_disable_votable, DEFAULT_VOTER, true, 0); if (rc < 0) chg_err("Couldn't disable charging, rc=%d\n", rc); chip->pmic_spmi.smb5_chip->chg.pre_current_ma = -1; return rc; } static int smbchg_get_charge_enable(void) { int rc = 0; u8 temp = 0; struct oplus_chg_chip *chip = g_oplus_chip; rc = smblib_read(&chip->pmic_spmi.smb5_chip->chg, CHARGING_ENABLE_CMD_REG, &temp); if (rc < 0) { chg_err("Couldn't read CHARGING_ENABLE_CMD_REG rc=%d\n", rc); return 0; } rc = temp & CHARGING_ENABLE_CMD_BIT; return rc; } static int smbchg_usb_suspend_enable(void) { int rc = 0; struct oplus_chg_chip *chip = g_oplus_chip; rc = smblib_set_usb_suspend(&chip->pmic_spmi.smb5_chip->chg, true); if (rc < 0) chg_err("Couldn't write enable to USBIN_SUSPEND_BIT rc=%d\n", rc); chip->pmic_spmi.smb5_chip->chg.pre_current_ma = -1; return rc; } static int smbchg_usb_suspend_disable(void) { int rc = 0; int boot_mode = get_boot_mode(); struct oplus_chg_chip *chip = g_oplus_chip; if (boot_mode == MSM_BOOT_MODE__RF || boot_mode == MSM_BOOT_MODE__WLAN) { chg_err("RF/WLAN, suspending...\n"); rc = smblib_set_usb_suspend(&chip->pmic_spmi.smb5_chip->chg, true); if (rc < 0) chg_err("Couldn't write enable to USBIN_SUSPEND_BIT rc=%d\n", rc); return rc; } rc = smblib_set_usb_suspend(&chip->pmic_spmi.smb5_chip->chg, false); if (rc < 0) chg_err("Couldn't write disable to USBIN_SUSPEND_BIT rc=%d\n", rc); return rc; } static int smbchg_set_rechg_vol(int rechg_vol) { return 0; } static int smbchg_reset_charger(void) { return 0; } static int smbchg_read_full(void) { int rc = 0; u8 stat = 0; struct oplus_chg_chip *chip = g_oplus_chip; if (!oplus_chg_is_usb_present()) return 0; rc = smblib_read(&chip->pmic_spmi.smb5_chip->chg, BATTERY_CHARGER_STATUS_1_REG, &stat); if (rc < 0) { chg_err("Couldn't read BATTERY_CHARGER_STATUS_1 rc=%d\n", rc); return 0; } stat = stat & BATTERY_CHARGER_STATUS_MASK; if (stat == TERMINATE_CHARGE || stat == INHIBIT_CHARGE) return 1; return 0; } static int smbchg_otg_enable(void) { return 0; } static int smbchg_otg_disable(void) { return 0; } static int oplus_set_chging_term_disable(void) { return 0; } static bool qcom_check_charger_resume(void) { return true; } bool smbchg_need_to_check_ibatt(void) { return false; } static int smbchg_get_chg_current_step(void) { return 25; } extern int opchg_get_charger_type(void); int qpnp_get_prop_charger_voltage_now(void) { int val = 0, rc = 0; union power_supply_propval pval = {0, }; struct smb_charger *chg = NULL; struct oplus_chg_chip *chip = g_oplus_chip; if (!chip) return 0; #ifdef OPLUS_FEATURE_CHG_BASIC #ifndef OPLUS_CUSTOM_OP_DEF if(!oplus_charger_ic_chip_is_null()) { #else if(!oplus_charger_ic_chip_is_null() && chip->vbatt_num == 2) { #endif val = oplus_chg_get_charger_voltage(); if (val < 2000 && val != -500) { chip->pmic_spmi.smb5_chip->chg.pre_current_ma = -1; return val; } else if (val != -500) { return val; } } #endif #endif //if (!oplus_chg_is_usb_present()) // return 0; chg = &chip->pmic_spmi.smb5_chip->chg; rc = smblib_get_prop_usb_present(chg, &pval); if (rc < 0) { chg_err("Couldn't get usb presence status rc=%d\n", rc); return -ENODATA; } /* usb not present */ if (!pval.intval) { val = 0; return 0; } #ifdef OPLUS_CUSTOM_OP_DEF if (chg->chg_param.smb_version != PM8150B_SUBTYPE || chg->low_voltage_charger) { #else if (chg->chg_param.smb_version != PM8150B_SUBTYPE) { #endif if (!chg->iio.usbin_v_chan || PTR_ERR(chg->iio.usbin_v_chan) == -EPROBE_DEFER) chg->iio.usbin_v_chan = iio_channel_get(chg->dev, "usbin_v"); if (IS_ERR(chg->iio.usbin_v_chan)) return PTR_ERR(chg->iio.usbin_v_chan); iio_read_channel_processed(chg->iio.usbin_v_chan, &val); } else { if (!chg->iio.mid_chan || PTR_ERR(chg->iio.mid_chan) == -EPROBE_DEFER) chg->iio.mid_chan = iio_channel_get(chg->dev, "mid_voltage"); if (IS_ERR(chg->iio.mid_chan)) return PTR_ERR(chg->iio.mid_chan); iio_read_channel_processed(chg->iio.mid_chan, &val); //if ((val / 1000) < chip->batt_volt) { //if (oplus_vooc_get_fastchg_started() == true) { //val = (chip->batt_volt + 300) * 1000 ; //} //} } //val = (val + 500) * 1000 ; if (val < 2000 * 1000) chg->pre_current_ma = -1; return val / 1000; } bool oplus_chg_is_usb_present(void) { int rc = 0; u8 stat = 0; bool vbus_rising = false; struct oplus_chg_chip *chip = g_oplus_chip; if (!chip) return false; #ifdef OPLUS_FEATURE_CHG_BASIC//Fanhong.Kong@ProDrv.CHG,add 2018/06/02 for SVOOC OTG if ((chip->pmic_spmi.smb5_chip->chg.typec_mode == POWER_SUPPLY_TYPEC_SINK || chip->pmic_spmi.smb5_chip->chg.typec_mode == POWER_SUPPLY_TYPEC_SINK_POWERED_CABLE) && chip->vbatt_num == 2 && oplus_wpc_get_wireless_charge_start() == false && oplus_vooc_get_fastchg_started() == false && oplus_vooc_get_fastchg_to_normal() == false) { chg_err("chg->typec_mode = SINK,oplus_chg_is_usb_present return false!\n"); rc = false; return rc ; } #endif/*OPLUS_FEATURE_CHG_BASIC*/ rc = smblib_read(&chip->pmic_spmi.smb5_chip->chg, USBIN_BASE + INT_RT_STS_OFFSET, &stat); if (rc < 0) { chg_err("Couldn't read USB_INT_RT_STS, rc=%d\n", rc); return false; } vbus_rising = (bool)(stat & USBIN_PLUGIN_RT_STS_BIT); if (vbus_rising == false && oplus_vooc_get_fastchg_started() == true) { #ifdef OPLUS_CUSTOM_OP_DEF if (oplus_chg_get_charger_voltage() > 2000) { #else if (qpnp_get_prop_charger_voltage_now() > 2000) { #endif chg_err("USBIN_PLUGIN_RT_STS_BIT low but fastchg started true and chg vol > 2V\n"); vbus_rising = true; } } #ifdef OPLUS_FEATURE_CHG_BASIC//Fanhong.Kong@ProDrv.CHG,add 2018/04/20 for SVOOC if (vbus_rising == false && (oplus_vooc_get_fastchg_started() == true && (chip->vbatt_num == 2))) { chg_err("USBIN_PLUGIN_RT_STS_BIT low but fastchg started true and SVOOC\n"); vbus_rising = true; } #endif/*OPLUS_FEATURE_CHG_BASIC*/ if (vbus_rising == false && oplus_wpc_get_wireless_charge_start()) { chg_err("USBIN_PLUGIN_RT_STS_BIT low but wpc has started\n"); vbus_rising = true; } if (vbus_rising == false) chip->pmic_spmi.smb5_chip->chg.pre_current_ma = -1; return vbus_rising; } int qpnp_get_battery_voltage(void) { return 3800;//Not use anymore } #if 0 static int get_boot_mode(void) { return 0; } #endif int smbchg_get_boot_reason(void) { return 0; } int oplus_chg_get_shutdown_soc(void) { u8 val; int rc; struct smb_charger *chg = &g_oplus_chip->pmic_spmi.smb5_chip->chg; if (!g_oplus_chip || !chg) { chg_err("chip not ready\n"); } rc = smblib_read(chg, 0x88D, &val); /*chg_err("val = %d\n", val);*/ if (rc < 0) { smblib_err(chg, "Couldn't read 0x88d rc=%d\n", rc); return rc; } /*chg_err("get shutdown soc = %d\n", val);*/ return val; } int oplus_chg_backup_soc(int backup_soc) { int rc; struct smb_charger *chg = &g_oplus_chip->pmic_spmi.smb5_chip->chg; if (!g_oplus_chip || !chg) { chg_err("chip not ready\n"); } /*chg_err("backup_soc = %d\n", backup_soc);*/ rc = smblib_masked_write(chg, 0x88D, 0xFF, backup_soc); if (rc < 0) { smblib_err(chg, "Couldn't set 0x88D rc=%d\n", rc); return rc; } /*chg_err("set shutdown soc = %d\n", rc);*/ return rc; } static int smbchg_get_aicl_level_ma(void) { return 0; } static int smbchg_force_tlim_en(bool enable) { return 0; } static int smbchg_system_temp_level_set(int lvl_sel) { return 0; } static int smbchg_set_prop_flash_active(enum skip_reason reason, bool disable) { return 0; } static int smbchg_dp_dm(int val) { return 0; } static int smbchg_calc_max_flash_current(void) { return 0; } static int oplus_chg_get_fv(struct oplus_chg_chip *chip) { int flv = chip->limits.temp_normal_vfloat_mv; int batt_temp = chip->temperature; if (batt_temp > chip->limits.hot_bat_decidegc) {//53C //default } else if (batt_temp >= chip->limits.warm_bat_decidegc) {//45C flv = chip->limits.temp_warm_vfloat_mv; } else if (batt_temp >= chip->limits.normal_bat_decidegc) {//16C flv = chip->limits.temp_normal_vfloat_mv; } else if (batt_temp >= chip->limits.little_cool_bat_decidegc) {//12C flv = chip->limits.temp_little_cool_vfloat_mv; } else if (batt_temp >= chip->limits.cool_bat_decidegc) {//5C flv = chip->limits.temp_cool_vfloat_mv; } else if (batt_temp >= chip->limits.little_cold_bat_decidegc) {//0C flv = chip->limits.temp_little_cold_vfloat_mv; } else if (batt_temp >= chip->limits.cold_bat_decidegc) {//-3C flv = chip->limits.temp_cold_vfloat_mv; } else { //default } return flv; } static int oplus_chg_get_charging_current(struct oplus_chg_chip *chip) { int charging_current = 0; int batt_temp = chip->temperature; if (batt_temp > chip->limits.hot_bat_decidegc) {//53C charging_current = 0; } else if (batt_temp >= chip->limits.warm_bat_decidegc) {//45C charging_current = chip->limits.temp_warm_fastchg_current_ma; } else if (batt_temp >= chip->limits.normal_bat_decidegc) {//16C charging_current = chip->limits.temp_normal_fastchg_current_ma; } else if (batt_temp >= chip->limits.little_cool_bat_decidegc) {//12C charging_current = chip->limits.temp_little_cool_fastchg_current_ma; } else if (batt_temp >= chip->limits.cool_bat_decidegc) {//5C if (chip->batt_volt > 4180) charging_current = chip->limits.temp_cool_fastchg_current_ma_low; else charging_current = chip->limits.temp_cool_fastchg_current_ma_high; } else if (batt_temp >= chip->limits.little_cold_bat_decidegc) {//0C charging_current = chip->limits.temp_little_cold_fastchg_current_ma; } else if (batt_temp >= chip->limits.cold_bat_decidegc) {//-3C charging_current = chip->limits.temp_cold_fastchg_current_ma; } else { charging_current = 0; } return charging_current; } #ifdef CONFIG_OPLUS_RTC_DET_SUPPORT static int rtc_reset_check(void) { struct rtc_time tm; struct rtc_device *rtc; int rc = 0; rtc = rtc_class_open(CONFIG_RTC_HCTOSYS_DEVICE); if (rtc == NULL) { pr_err("%s: unable to open rtc device (%s)\n", __FILE__, CONFIG_RTC_HCTOSYS_DEVICE); return 0; } rc = rtc_read_time(rtc, &tm); if (rc) { pr_err("Error reading rtc device (%s) : %d\n", CONFIG_RTC_HCTOSYS_DEVICE, rc); goto close_time; } rc = rtc_valid_tm(&tm); if (rc) { pr_err("Invalid RTC time (%s): %d\n", CONFIG_RTC_HCTOSYS_DEVICE, rc); goto close_time; } if ((tm.tm_year == 70) && (tm.tm_mon == 0) && (tm.tm_mday <= 1)) { chg_debug(": Sec: %d, Min: %d, Hour: %d, Day: %d, Mon: %d, Year: %d @@@ wday: %d, yday: %d, isdst: %d\n", tm.tm_sec, tm.tm_min, tm.tm_hour, tm.tm_mday, tm.tm_mon, tm.tm_year, tm.tm_wday, tm.tm_yday, tm.tm_isdst); rtc_class_close(rtc); return 1; } chg_debug(": Sec: %d, Min: %d, Hour: %d, Day: %d, Mon: %d, Year: %d ### wday: %d, yday: %d, isdst: %d\n", tm.tm_sec, tm.tm_min, tm.tm_hour, tm.tm_mday, tm.tm_mon, tm.tm_year, tm.tm_wday, tm.tm_yday, tm.tm_isdst); close_time: rtc_class_close(rtc); return 0; } #endif /* CONFIG_OPLUS_RTC_DET_SUPPORT */ #ifdef CONFIG_OPLUS_SHORT_C_BATT_CHECK /* This function is getting the dynamic aicl result/input limited in mA. * If charger was suspended, it must return 0(mA). * It meets the requirements in SDM660 platform. */ static int oplus_chg_get_dyna_aicl_result(void) { struct power_supply *usb_psy = NULL; union power_supply_propval pval = {0, }; usb_psy = power_supply_get_by_name("usb"); if (usb_psy) { power_supply_get_property(usb_psy, POWER_SUPPLY_PROP_INPUT_CURRENT_SETTLED, &pval); return pval.intval / 1000; } return 1000; } #endif /* CONFIG_OPLUS_SHORT_C_BATT_CHECK */ #ifdef OPLUS_FEATURE_CHG_BASIC int oplus_chg_get_charger_subtype(void) { struct smb_charger *chg = NULL; const struct apsd_result *apsd_result = NULL; if (!g_oplus_chip) return CHARGER_SUBTYPE_DEFAULT; chg = &g_oplus_chip->pmic_spmi.smb5_chip->chg; if(opluschg_pd_sdp) return CHARGER_SUBTYPE_DEFAULT; if (chg->pd_active) return CHARGER_SUBTYPE_PD; apsd_result = smblib_get_apsd_result(chg); if (apsd_result->pst == POWER_SUPPLY_TYPE_USB_HVDCP || apsd_result->pst == POWER_SUPPLY_TYPE_USB_HVDCP_3) return CHARGER_SUBTYPE_QC; return CHARGER_SUBTYPE_DEFAULT; } #ifdef OPLUS_FEATURE_CHG_BASIC void oplus_set_flash_screen_ctrl_by_pcb_version(struct oplus_chg_chip *chip) { if (!chip) return; if (get_PCB_Version() >= MP1) { chip->flash_screen_ctrl_status &= ~FLASH_SCREEN_CTRL_DTSI; } chg_err("flash_screen_ctrl_dtsi=%d\n", chip->flash_screen_ctrl_status); } #endif extern int oplus_pdo_select(int vbus_mv, int ibus_ma); int oplus_chg_set_pd_config(void) { int ret = 0; struct oplus_chg_chip *chip = g_oplus_chip; if (!chip) { return -1; } if(chip->pd_svooc){ return 0; } mutex_lock(&pd_select_pdo_v); #ifdef OPLUS_CUSTOM_OP_DEF if (chip->vbatt_num == 1) { ret = oplus_pdo_select(5000, 3000); printk(KERN_ERR "%s: vbus[%d], ibus[%d], ret[%d]\n", __func__, 5000, 3000, ret); } else #endif if (chip->limits.vbatt_pdqc_to_5v_thr > 0 && chip->charger_volt > 7500 && chip->batt_volt > chip->limits.vbatt_pdqc_to_5v_thr) { chip->chg_ops->input_current_write(500); oplus_chg_suspend_charger(); oplus_chg_config_charger_vsys_threshold(0x03);//set Vsys Skip threshold 101% ret = oplus_pdo_select(5000, 2000); printk(KERN_ERR "%s: vbus[%d], ibus[%d], ret[%d]\n", __func__, 5000, 2000, ret); msleep(300); printk(KERN_ERR "%s: charger voltage=%d", __func__, usbtemp_get_charger_voltage_now()); oplus_chg_unsuspend_charger(); } else if (chip->batt_volt < chip->limits.vbatt_pdqc_to_9v_thr){ if(oplus_chg_get_voocphy_support() == AP_SINGLE_CP_VOOCPHY) oplus_voocphy_set_pdqc_config(); oplus_chg_suspend_charger(); oplus_chg_config_charger_vsys_threshold(0x02);//set Vsys Skip threshold 104% oplus_chg_enable_burst_mode(false); ret = oplus_pdo_select(9000, 2000); printk(KERN_ERR "%s: vbus[%d], ibus[%d], ret[%d]\n", __func__, 9000, 2000, ret); msleep(300); oplus_chg_unsuspend_charger(); } mutex_unlock(&pd_select_pdo_v); return ret; } static bool oplus_hvdcp_is_enable(struct smb_charger *chg) { int rc = 0; u8 stat = 0; bool hvdcp_enable = false; rc = smblib_read(chg, USBIN_OPTIONS_1_CFG_REG, &stat); if (rc < 0) { chg_err("Couldn't read USBIN_OPTIONS_1_CFG_REG, rc=%d\n", rc); return false; } hvdcp_enable = (bool)(stat & HVDCP_EN_BIT); return hvdcp_enable; } int oplus_chg_enable_qc_detect(void) { int ret = 0; struct smb_charger *chg = NULL; struct oplus_chg_chip *chip = g_oplus_chip; if (!chip) { return -1; } chg = &chip->pmic_spmi.smb5_chip->chg; chg->hvdcp_disable = false; if (oplus_hvdcp_is_enable(chg) == false) { printk(KERN_ERR "%s: hvdcp enable\n", __func__); smblib_hvdcp_detect_enable(chg, true); smblib_request_dpdm(chg, true); smblib_rerun_apsd(chg); } return ret; } int oplus_chg_set_qc_config(void) { int ret = 0; struct smb_charger *chg = NULL; struct oplus_chg_chip *chip = g_oplus_chip; if (!chip) { return -1; } chg = &chip->pmic_spmi.smb5_chip->chg; if (chip->limits.vbatt_pdqc_to_5v_thr > 0 && chip->charger_volt > 7500 && chip->batt_volt > chip->limits.vbatt_pdqc_to_5v_thr) { chip->chg_ops->input_current_write(500); oplus_chg_suspend_charger(); oplus_chg_config_charger_vsys_threshold(0x03);//set Vsys Skip threshold 101% ret = smblib_masked_write(chg, CMD_HVDCP_2_REG, FORCE_5V_BIT, FORCE_5V_BIT); printk(KERN_ERR "%s: set qc to 5V", __func__); msleep(400); printk(KERN_ERR "%s: charger voltage=%d", __func__, usbtemp_get_charger_voltage_now()); oplus_chg_unsuspend_charger(); } else if(chip->batt_volt < chip->limits.vbatt_pdqc_to_9v_thr){ // 9v smblib_dbg(chg, PR_INTERRUPT, "Force output 9V\n"); if(oplus_chg_get_voocphy_support() == AP_SINGLE_CP_VOOCPHY) oplus_voocphy_set_pdqc_config(); smblib_masked_write(chg, CMD_HVDCP_2_REG, FORCE_5V_BIT, FORCE_5V_BIT); //Before request 9V, need to force 5V first. msleep(300); oplus_chg_suspend_charger(); oplus_chg_config_charger_vsys_threshold(0x02);//set Vsys Skip threshold 104% oplus_chg_enable_burst_mode(false); smblib_masked_write(chg, CMD_HVDCP_2_REG, FORCE_9V_BIT, FORCE_9V_BIT); msleep(300); oplus_chg_unsuspend_charger(); } return ret; } int oplus_sm8150_get_pd_type(void) { struct smb_charger *chg = NULL; if (!g_oplus_chip) return CHARGER_SUBTYPE_DEFAULT; chg = &g_oplus_chip->pmic_spmi.smb5_chip->chg; if (chg->pd_active) return true; return false; } #endif /* OPLUS_FEATURE_CHG_BASIC */ static int get_current_time(unsigned long *now_tm_sec) { struct rtc_time tm; struct rtc_device *rtc; int rc; rtc = rtc_class_open(CONFIG_RTC_HCTOSYS_DEVICE); if (rtc == NULL) { pr_err("%s: unable to open rtc device (%s)\n", __FILE__, CONFIG_RTC_HCTOSYS_DEVICE); return -EINVAL; } rc = rtc_read_time(rtc, &tm); if (rc) { pr_err("Error reading rtc device (%s) : %d\n", CONFIG_RTC_HCTOSYS_DEVICE, rc); goto close_time; } rc = rtc_valid_tm(&tm); if (rc) { pr_err("Invalid RTC time (%s): %d\n", CONFIG_RTC_HCTOSYS_DEVICE, rc); goto close_time; } rtc_tm_to_time(&tm, now_tm_sec); close_time: rtc_class_close(rtc); return rc; } static unsigned long suspend_tm_sec = 0; static int smb5_pm_resume(struct device *dev) { int rc = 0; unsigned long resume_tm_sec = 0; unsigned long sleep_time = 0; if (!g_oplus_chip) return 0; rc = get_current_time(&resume_tm_sec); if (rc || suspend_tm_sec == -1) { chg_err("RTC read failed\n"); sleep_time = 0; } else { sleep_time = resume_tm_sec - suspend_tm_sec; } if (sleep_time < 0) { sleep_time = 0; } oplus_chg_soc_update_when_resume(sleep_time); return 0; } static int smb5_pm_suspend(struct device *dev) { if (!g_oplus_chip) return 0; if (get_current_time(&suspend_tm_sec)) { chg_err("RTC read failed\n"); suspend_tm_sec = -1; } return 0; } static const struct dev_pm_ops smb5_pm_ops = { .resume = smb5_pm_resume, .suspend = smb5_pm_suspend, }; struct oplus_chg_operations smb5_chg_ops = { .enable_qc_detect = oplus_chg_enable_qc_detect, .oplus_chg_pd_setup = oplus_chg_set_pd_config, .set_qc_config = oplus_chg_set_qc_config, .dump_registers = dump_regs, .kick_wdt = smbchg_kick_wdt, .hardware_init = oplus_chg_hw_init, .charging_current_write_fast = smbchg_set_fastchg_current_raw, .set_aicl_point = smbchg_set_aicl_point, .input_current_write = oplus_chg_set_input_current, .float_voltage_write = smbchg_float_voltage_set, .term_current_set = smbchg_term_current_set, .charging_enable = smbchg_charging_enble, .charging_disable = smbchg_charging_disble, .get_charging_enable = smbchg_get_charge_enable, .charger_suspend = smbchg_usb_suspend_enable, .charger_unsuspend = smbchg_usb_suspend_disable, .set_rechg_vol = smbchg_set_rechg_vol, .reset_charger = smbchg_reset_charger, .read_full = smbchg_read_full, .otg_enable = smbchg_otg_enable, .otg_disable = smbchg_otg_disable, .set_charging_term_disable = oplus_set_chging_term_disable, .check_charger_resume = qcom_check_charger_resume, .get_chargerid_volt = smbchg_get_chargerid_volt, .set_chargerid_switch_val = smbchg_set_chargerid_switch_val, .get_chargerid_switch_val = smbchg_get_chargerid_switch_val, .need_to_check_ibatt = smbchg_need_to_check_ibatt, .get_chg_current_step = smbchg_get_chg_current_step, .oplus_chg_get_pd_type = oplus_sm8150_get_pd_type, #ifdef CONFIG_OPLUS_CHARGER_MTK .get_charger_type = mt_power_supply_type_check, .get_charger_volt = battery_meter_get_charger_voltage, .check_chrdet_status = pmic_chrdet_status, .get_instant_vbatt = battery_meter_get_battery_voltage, .get_boot_mode = get_boot_mode, .get_boot_reason = get_boot_reason, #ifdef CONFIG_MTK_HAFG_20 .get_rtc_soc = get_rtc_spare_oplus_fg_value, .set_rtc_soc = set_rtc_spare_oplus_fg_value, #else .get_rtc_soc = get_rtc_spare_fg_value, .set_rtc_soc = set_rtc_spare_fg_value, #endif /* CONFIG_MTK_HAFG_20 */ .set_power_off = mt_power_off, .usb_connect = mt_usb_connect, .usb_disconnect = mt_usb_disconnect, #else .get_charger_type = opchg_get_charger_type, .get_charger_subtype = oplus_chg_get_charger_subtype, .get_real_charger_type = opchg_get_real_charger_type, .get_charger_volt = qpnp_get_prop_charger_voltage_now, .check_chrdet_status = oplus_chg_is_usb_present, .get_instant_vbatt = qpnp_get_battery_voltage, .get_boot_mode = get_boot_mode, .get_boot_reason = smbchg_get_boot_reason, .get_rtc_soc = oplus_chg_get_shutdown_soc, .set_rtc_soc = oplus_chg_backup_soc, .get_aicl_ma = smbchg_get_aicl_level_ma, .rerun_aicl = smbchg_rerun_aicl, .tlim_en = smbchg_force_tlim_en, .set_system_temp_level = smbchg_system_temp_level_set, .otg_pulse_skip_disable = smbchg_set_prop_flash_active, .set_dp_dm = smbchg_dp_dm, .calc_flash_current = smbchg_calc_max_flash_current, #endif /* CONFIG_OPLUS_CHARGER_MTK */ #ifdef CONFIG_OPLUS_RTC_DET_SUPPORT .check_rtc_reset = rtc_reset_check, #endif #ifdef CONFIG_OPLUS_SHORT_C_BATT_CHECK .get_dyna_aicl_result = oplus_chg_get_dyna_aicl_result, #endif .get_shortc_hw_gpio_status = oplus_chg_get_shortc_hw_gpio_status, .check_pdphy_ready = oplus_check_pdphy_ready, .get_usbtemp_volt = oplus_get_usbtemp_volt, .set_typec_sinkonly = oplus_set_typec_sinkonly, .oplus_usbtemp_monitor_condition = oplus_usbtemp_condition, #ifdef OPLUS_CUSTOM_OP_DEF .get_charger_current = smbchg_get_charger_current, .get_charger_subtype = oplus_chg_get_charger_subtype, .oplus_chg_get_pd_type = oplus_sm8150_get_pd_type, .oplus_chg_pd_setup = oplus_chg_set_pd_config, #endif }; #endif /* OPLUS_FEATURE_CHG_BASIC */ static int smb5_show_charger_status(struct smb5 *chip) { struct smb_charger *chg = &chip->chg; union power_supply_propval val; int usb_present, batt_present, batt_health, batt_charge_type; int rc; rc = smblib_get_prop_usb_present(chg, &val); if (rc < 0) { pr_err("Couldn't get usb present rc=%d\n", rc); return rc; } usb_present = val.intval; rc = smblib_get_prop_batt_present(chg, &val); if (rc < 0) { pr_err("Couldn't get batt present rc=%d\n", rc); return rc; } batt_present = val.intval; #ifndef OPLUS_FEATURE_CHG_BASIC rc = smblib_get_prop_batt_health(chg, &val); if (rc < 0) { pr_err("Couldn't get batt health rc=%d\n", rc); val.intval = POWER_SUPPLY_HEALTH_UNKNOWN; } batt_health = val.intval; #else if(g_oplus_chip) batt_health = oplus_chg_get_prop_batt_health(g_oplus_chip); #endif rc = smblib_get_prop_batt_charge_type(chg, &val); if (rc < 0) { pr_err("Couldn't get batt charge type rc=%d\n", rc); return rc; } batt_charge_type = val.intval; pr_info("SMB5 status - usb:present=%d type=%d batt:present = %d health = %d charge = %d\n", usb_present, chg->real_charger_type, batt_present, batt_health, batt_charge_type); return rc; } uint32_t pd_svooc_abnormal_adapter[] = { 0x20002, 0x10002, }; static void oplus_usbpd_response_cb(struct usbpd_svid_handler *hdlr, u8 cmd, enum usbpd_svdm_cmd_type cmd_type, const u32 *vdos, int num_vdos) { int i = 0; chg_err("dp_usbpd_response_cb\n"); for (i = 0; i < ARRAY_SIZE(pd_svooc_abnormal_adapter); i++) { if (pd_svooc_abnormal_adapter[i] == vdos[2]) { chg_err("This is oplus gnd abnormal adapter %x %x \n", vdos[1], vdos[2]); g_oplus_chip->is_abnormal_adapter = true; break; } } return; } static void oplus_usbpd_connect_cb(struct usbpd_svid_handler *hdlr, bool peer_usb_comm) { if (!g_oplus_chip) { return ; } else { g_oplus_chip->pd_svooc = true; pr_err("[OPLUS_CHG] SVID"); } } static void oplus_usbpd_disconnect_cb(struct usbpd_svid_handler *hdlr) { chg_err("dp_usbpd_disconnect_cb\n"); } static bool oplus_check_pdphy_ready(void){ struct oplus_chg_chip *chip = g_oplus_chip; if(!chip){ return false; } if(chip->pmic_spmi.smb5_chip->chg.pd_active){ return oplus_check_pd_state_ready(); } else { return true; } } #define OPLUS_SVID 0x22D9 #define PD_SVOOC_SVID_MS 300 static void register_oplus_pdsvooc_svid(struct work_struct *work) { int rc = 0; struct oplus_chg_chip *chip = g_oplus_chip; const char *pd_phandle = "qcom,oplus-pps-usbpd-detection"; struct smb_charger *chg; struct usbpd *pd = NULL; if(g_oplus_chip == NULL){ return; } chg = &chip->pmic_spmi.smb5_chip->chg; if(chg == NULL){ pr_err("YGYG chg NULL "); return; } if(chg->dev == NULL){ pr_err("YGYG dev NULL "); return; } pd = devm_usbpd_get_by_phandle(chg->dev, pd_phandle); if( pd == NULL){ pr_err("YGYG pd NULL "); return; } pr_err("YGYG pd NULhei "); if (IS_ERR(pd)) { chg_err("YGYG oplus pps usbpd phandle failed (%ld)\n", PTR_ERR(pd)); rc = PTR_ERR(pd); chg->oplus_pd = NULL; //chg->oplus_svid_handler = NULL; schedule_delayed_work(&chg->regist_pd, msecs_to_jiffies(PD_SVOOC_SVID_MS)); } else { //msleep(1500); chg_err("YGYG2 oplus pps usbpd phandle failed (%ld)\n", PTR_ERR(pd)); chg->oplus_pd = pd; chg->oplus_svid_handler.svid = OPLUS_SVID; chg->oplus_svid_handler.vdm_received = NULL; chg->oplus_svid_handler.connect = oplus_usbpd_connect_cb; chg->oplus_svid_handler.svdm_received = oplus_usbpd_response_cb; chg->oplus_svid_handler.disconnect = oplus_usbpd_disconnect_cb; rc = usbpd_register_svid(chg->oplus_pd, &chg->oplus_svid_handler); if (rc){ //chg->oplus_svid_handler = NULL; chg_err("YGYG pps pd registration failed\n"); } chg_err("YGYG pps pd registration success\n"); //oplus_chg_wake_update_work(); } } static int smb5_probe(struct platform_device *pdev) { #ifdef OPLUS_FEATURE_CHG_BASIC struct oplus_chg_chip *oplus_chip; struct power_supply *main_psy = NULL; struct power_supply *bms_psy = NULL; union power_supply_propval pval = {0, }; static int reporting_not_ready_count = 0; #endif struct smb5 *chip; struct smb_charger *chg; int rc = 0; #ifdef OPLUS_FEATURE_CHG_BASIC//Fanhong.Kong@ProDrv.CHG,add 2018/04/20 for SVOOC oplus_chip = devm_kzalloc(&pdev->dev, sizeof(*oplus_chip), GFP_KERNEL); if (!oplus_chip) return -ENOMEM; oplus_chip->dev = &pdev->dev; rc = oplus_chg_parse_svooc_dt(oplus_chip); if (oplus_chip->vbatt_num == 1) { if (oplus_gauge_check_chip_is_null()) { chg_err("gauge chip null, will do after bettery init.\n"); return -EPROBE_DEFER; } oplus_chip->chg_ops = &smb5_chg_ops; } else { if (oplus_gauge_ic_chip_is_null() || oplus_vooc_check_chip_is_null() || oplus_charger_ic_chip_is_null() || oplus_adapter_check_chip_is_null()) { chg_err("[oplus_chg_init] vooc || gauge || chg not ready, will do after bettery init.\n"); return -EPROBE_DEFER; } oplus_chip->chg_ops = (oplus_get_chg_ops()); } g_oplus_chip = oplus_chip; chg_debug("smb5_Probe Start----\n"); #endif chip = devm_kzalloc(&pdev->dev, sizeof(*chip), GFP_KERNEL); if (!chip) return -ENOMEM; #ifdef OPLUS_FEATURE_CHG_BASIC oplus_chip->pmic_spmi.smb5_chip = chip; #endif chg = &chip->chg; chg->dev = &pdev->dev; chg->debug_mask = &__debug_mask; chg->pd_disabled = 0; chg->weak_chg_icl_ua = 500000; #ifdef OPLUS_CUSTOM_OP_DEF chg->wireless_present = false; chg->apsd_delayed = false; g_chg = chg; #endif chg->mode = PARALLEL_MASTER; chg->irq_info = smb5_irqs; chg->die_health = -EINVAL; chg->connector_health = -EINVAL; chg->otg_present = false; chg->main_fcc_max = -EINVAL; mutex_init(&chg->adc_lock); chg->regmap = dev_get_regmap(chg->dev->parent, NULL); if (!chg->regmap) { pr_err("parent regmap is missing\n"); return -EINVAL; } rc = smb5_chg_config_init(chip); if (rc < 0) { if (rc != -EPROBE_DEFER) pr_err("Couldn't setup chg_config rc=%d\n", rc); return rc; } #ifdef OPLUS_FEATURE_CHG_BASIC mutex_init(&chg->pinctrl_mutex); chg->pre_current_ma = -1; #endif #ifdef OPLUS_FEATURE_CHG_BASIC rc = of_property_match_string(chg->dev->of_node, "io-channel-names", "chgID_voltage_adc"); if (rc >= 0) { chg->iio.chgid_v_chan = iio_channel_get(chg->dev, "chgID_voltage_adc"); if (IS_ERR(chg->iio.chgid_v_chan)) { rc = PTR_ERR(chg->iio.chgid_v_chan); if (rc != -EPROBE_DEFER) dev_err(chg->dev, "chgid_v_chan get error, %ld\n", rc); chg->iio.chgid_v_chan = NULL; return rc; } pr_err("[OPLUS_CHG] test chg->iio.chgid_v_chan \n"); } #endif #ifdef OPLUS_FEATURE_CHG_BASIC rc = of_property_match_string(chg->dev->of_node, "io-channel-names", "usb_temp_adc"); if (rc >= 0) { chg->iio.usbtemp_v_chan = iio_channel_get(chg->dev, "usb_temp_adc"); if (IS_ERR(chg->iio.usbtemp_v_chan)) { rc = PTR_ERR(chg->iio.usbtemp_v_chan); if (rc != -EPROBE_DEFER) dev_err(chg->dev, "usb_temp_adc get error, %ld\n", rc); chg->iio.usbtemp_v_chan = NULL; return rc; } pr_err("[OPLUS_CHG] test chg->iio.usb_temp_adc \n"); } pr_err("[OPLUS_CHG] test chg->iio.usb_temp_adc out here\n"); rc = of_property_match_string(chg->dev->of_node, "io-channel-names", "btb_temp_therm"); if (rc >= 0) { chg->iio.btbtemp_v_chan = iio_channel_get(chg->dev, "btb_temp_therm"); if (IS_ERR(chg->iio.btbtemp_v_chan)) { rc = PTR_ERR(chg->iio.btbtemp_v_chan); if (rc != -EPROBE_DEFER) dev_err(chg->dev, "btb_temp_therm get error, %ld\n", rc); chg->iio.btbtemp_v_chan = NULL; return rc; } pr_err("[OPLUS_CHG] test chg->iio.btb_temp_therm \n"); } pr_err("[OPLUS_CHG] test chg->iio.btb_temp_therm out here\n"); rc = of_property_match_string(chg->dev->of_node, "io-channel-names", "usb_supplementary_temp_adc"); if (rc >= 0) { chg->iio.usbtemp_sup_v_chan = iio_channel_get(chg->dev, "usb_supplementary_temp_adc"); if (IS_ERR(chg->iio.usbtemp_sup_v_chan)) { rc = PTR_ERR(chg->iio.usbtemp_sup_v_chan); if (rc != -EPROBE_DEFER) dev_err(chg->dev, "usb_supplementary_temp_adc get error, %ld\n", rc); chg->iio.usbtemp_sup_v_chan = NULL; return rc; } pr_err("[OPLUS_CHG] test chg->iio.usb_supplementary_temp_adc\n"); } pr_err("[OPLUS_CHG] test chg->iio.usb_supplementary_temp_adc out here\n"); #endif #ifdef OPLUS_FEATURE_CHG_BASIC #ifdef OPLUS_CUSTOM_OP_DEF rc = of_property_match_string(chg->dev->of_node, "io-channel-names", "skin_therm"); if (rc >= 0) { chg->iio.op_skin_therm_chan = iio_channel_get(chg->dev, "skin_therm"); if (IS_ERR(chg->iio.op_skin_therm_chan)) { rc = PTR_ERR(chg->iio.op_skin_therm_chan); if (rc != -EPROBE_DEFER) dev_err(chg->dev, "skin_therm get error, %ld\n", rc); chg->iio.op_skin_therm_chan = NULL; return rc; } pr_err("[OPLUS_CHG] test chg->iio.op_skin_therm_chan\n"); } pr_err("[OPLUS_CHG] test chg->iio.op_skin_therm_chan out here\n"); #endif #endif rc = smb5_parse_dt(chip); if (rc < 0) { pr_err("Couldn't parse device tree rc=%d\n", rc); return rc; } if (chg->soc_ready_check == true) { bms_psy = power_supply_get_by_name("bms"); if (bms_psy == NULL) return -EPROBE_DEFER; power_supply_get_property(bms_psy, POWER_SUPPLY_PROP_SOC_REPORTING_READY, &pval); pr_err("%s:ready_flag=%d\n",__func__,pval.intval); if (pval.intval == SOC_CHECK_NOT_READY) { reporting_not_ready_count++; if (reporting_not_ready_count <= SOC_READY_RETRY_COUNT) { pr_err("%s:soc_reporting_ready not ready,count=%d\n",__func__,reporting_not_ready_count); mdelay(SOC_READY_WAITING_TIME); return -EPROBE_DEFER; } } } if (alarmtimer_get_rtcdev()) alarm_init(&chg->lpd_recheck_timer, ALARM_REALTIME, smblib_lpd_recheck_timer); else return -EPROBE_DEFER; rc = smblib_init(chg); if (rc < 0) { pr_err("Smblib_init failed rc=%d\n", rc); return rc; } /* set driver data before resources request it */ platform_set_drvdata(pdev, chip); /* extcon registration */ chg->extcon = devm_extcon_dev_allocate(chg->dev, smblib_extcon_cable); if (IS_ERR(chg->extcon)) { rc = PTR_ERR(chg->extcon); dev_err(chg->dev, "failed to allocate extcon device rc=%d\n", rc); goto cleanup; } rc = devm_extcon_dev_register(chg->dev, chg->extcon); if (rc < 0) { dev_err(chg->dev, "failed to register extcon device rc=%d\n", rc); goto cleanup; } /* Support reporting polarity and speed via properties */ rc = extcon_set_property_capability(chg->extcon, EXTCON_USB, EXTCON_PROP_USB_TYPEC_POLARITY); rc |= extcon_set_property_capability(chg->extcon, EXTCON_USB, EXTCON_PROP_USB_SS); rc |= extcon_set_property_capability(chg->extcon, EXTCON_USB_HOST, EXTCON_PROP_USB_TYPEC_POLARITY); rc |= extcon_set_property_capability(chg->extcon, EXTCON_USB_HOST, EXTCON_PROP_USB_SS); if (rc < 0) { dev_err(chg->dev, "failed to configure extcon capabilities\n"); goto cleanup; } rc = smb5_init_hw(chip); if (rc < 0) { pr_err("Couldn't initialize hardware rc=%d\n", rc); goto cleanup; } /* * VBUS regulator enablement/disablement for host mode is handled * by USB-PD driver only. For micro-USB and non-PD typeC designs, * the VBUS regulator is enabled/disabled by the smb driver itself * before sending extcon notifications. * Hence, register vbus and vconn regulators for PD supported designs * only. */ if (!chg->pd_not_supported) { rc = smb5_init_vbus_regulator(chip); if (rc < 0) { pr_err("Couldn't initialize vbus regulator rc=%d\n", rc); goto cleanup; } rc = smb5_init_vconn_regulator(chip); if (rc < 0) { pr_err("Couldn't initialize vconn regulator rc=%d\n", rc); goto cleanup; } } switch (chg->chg_param.smb_version) { case PM8150B_SUBTYPE: case PM6150_SUBTYPE: case PM7250B_SUBTYPE: #ifndef OPLUS_FEATURE_CHG_BASIC rc = smb5_init_dc_psy(chip); if (rc < 0) { pr_err("Couldn't initialize dc psy rc=%d\n", rc); goto cleanup; } #endif break; default: break; } //kong rc = oplus_power_supply_init(chip); if (rc < 0) { pr_err("Couldn't initialize usb main psy rc=%d\n", rc); goto cleanup; } rc = smb5_init_usb_main_psy(chip); if (rc < 0) { pr_err("Couldn't initialize usb main psy rc=%d\n", rc); goto cleanup; } rc = smb5_init_usb_port_psy(chip); if (rc < 0) { pr_err("Couldn't initialize usb pc_port psy rc=%d\n", rc); goto cleanup; } #ifdef OPLUS_FEATURE_CHG_BASIC if (oplus_chg_is_usb_present()) { rc = smblib_masked_write(chg, CHARGING_ENABLE_CMD_REG, CHARGING_ENABLE_CMD_BIT, 0); if (rc < 0) pr_err("Couldn't disable at bootup rc=%d\n", rc); msleep(100); rc = smblib_masked_write(chg, CHARGING_ENABLE_CMD_REG, CHARGING_ENABLE_CMD_BIT, CHARGING_ENABLE_CMD_BIT); if (rc < 0) pr_err("Couldn't enable at bootup rc=%d\n", rc); } #endif #ifdef OPLUS_FEATURE_CHG_BASIC oplus_chg_parse_custom_dt(oplus_chip); oplus_chg_parse_charger_dt(oplus_chip); /* wangjiayuan_wt, BSP.CHG.Basic, 2021/9/7, Add for fg platform for 21027 */ if (g_oplus_chip->external_gauge) { rc = smblib_masked_write(chg, 0x4046, 0xff, 0); if (rc < 0) pr_err("Couldn't disable fg rc=%d\n", rc); } oplus_set_flash_screen_ctrl_by_pcb_version(oplus_chip); oplus_chg_2uart_pinctrl_init(oplus_chip); oplus_chg_init(oplus_chip); schedule_delayed_work(&chg->regist_pd, 0); main_psy = power_supply_get_by_name("main"); if (main_psy) { pval.intval = 1000 * oplus_chg_get_fv(oplus_chip); power_supply_set_property(main_psy, POWER_SUPPLY_PROP_VOLTAGE_MAX, &pval); pval.intval = 1000 * oplus_chg_get_charging_current(oplus_chip); power_supply_set_property(main_psy, POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, &pval); } #endif #ifndef OPLUS_FEATURE_CHG_BASIC rc = smb5_init_usb_psy(chip); if (rc < 0) { pr_err("Couldn't initialize usb psy rc=%d\n", rc); goto cleanup; } rc = smb5_init_usb_main_psy(chip); if (rc < 0) { pr_err("Couldn't initialize usb main psy rc=%d\n", rc); goto cleanup; } rc = smb5_init_usb_port_psy(chip); if (rc < 0) { pr_err("Couldn't initialize usb pc_port psy rc=%d\n", rc); goto cleanup; } rc = smb5_init_batt_psy(chip); if (rc < 0) { pr_err("Couldn't initialize batt psy rc=%d\n", rc); goto cleanup; } #endif rc = smb5_determine_initial_status(chip); if (rc < 0) { pr_err("Couldn't determine initial status rc=%d\n", rc); goto cleanup; } rc = smb5_request_interrupts(chip); if (rc < 0) { pr_err("Couldn't request interrupts rc=%d\n", rc); goto cleanup; } rc = smb5_post_init(chip); if (rc < 0) { pr_err("Failed in post init rc=%d\n", rc); goto free_irq; } #ifdef OPLUS_FEATURE_CHG_BASIC if (oplus_ccdetect_check_is_gpio(oplus_chip) == true) oplus_ccdetect_irq_register(oplus_chip); #endif #ifdef OPLUS_FEATURE_CHG_BASIC if (oplus_wired_conn_check_is_gpio(oplus_chip) == true) { //pr_err("tongfeng test \n"); oplus_wired_conn_irq_register(oplus_chip); } #endif #ifdef OPLUS_FEATURE_CHG_BASIC // g_oplus_chip->authenticate = oplus_gauge_get_batt_authenticate(); // if(!g_oplus_chip->authenticate) // smbchg_charging_disble(); oplus_chg_wake_update_work(); if (qpnp_is_power_off_charging() == false) { oplus_tbatt_power_off_task_init(oplus_chip); } #endif #ifdef OPLUS_FEATURE_CHG_BASIC init_proc_dump_registers_mask(); #endif #ifdef OPLUS_FEATURE_CHG_BASIC #ifdef OPLUS_CUSTOM_OP_DEF oplus_chip->con_volt = con_volt_30k; oplus_chip->con_temp = con_temp_30k; oplus_chip->len_array = ARRAY_SIZE(con_temp_30k); #else oplus_chip->con_volt = con_volt_855; oplus_chip->con_temp = con_temp_855; oplus_chip->len_array = ARRAY_SIZE(con_temp_855); #endif if (oplus_usbtemp_check_is_support() == true) oplus_usbtemp_thread_init(); oplus_chg_configfs_init(oplus_chip); #endif smb5_create_debugfs(chip); rc = sysfs_create_groups(&chg->dev->kobj, smb5_groups); if (rc < 0) { pr_err("Couldn't create sysfs files rc=%d\n", rc); goto free_irq; } rc = smb5_show_charger_status(chip); if (rc < 0) { pr_err("Failed in getting charger status rc=%d\n", rc); goto free_irq; } device_init_wakeup(chg->dev, true); #ifdef OPLUS_CUSTOM_OP_DEF exchg_information_register(chg); #endif pr_info("QPNP SMB5 probed successfully\n"); return rc; free_irq: smb5_free_interrupts(chg); cleanup: smblib_deinit(chg); platform_set_drvdata(pdev, NULL); return rc; } static int smb5_remove(struct platform_device *pdev) { struct smb5 *chip = platform_get_drvdata(pdev); struct smb_charger *chg = &chip->chg; /* force enable APSD */ smblib_masked_write(chg, USBIN_OPTIONS_1_CFG_REG, BC1P2_SRC_DETECT_BIT, BC1P2_SRC_DETECT_BIT); smb5_free_interrupts(chg); smblib_deinit(chg); sysfs_remove_groups(&chg->dev->kobj, smb5_groups); platform_set_drvdata(pdev, NULL); return 0; } static void smb5_shutdown(struct platform_device *pdev) { struct smb5 *chip = platform_get_drvdata(pdev); struct smb_charger *chg = &chip->chg; #ifdef OPLUS_FEATURE_CHG_BASIC int level = 0; #endif #ifdef OPLUS_FEATURE_CHG_BASIC if (g_oplus_chip) { oplus_vooc_reset_mcu(); smbchg_set_chargerid_switch_val(0); oplus_vooc_switch_mode(NORMAL_CHARGER_MODE); msleep(30); } #endif if(g_oplus_chip && g_oplus_chip->enable_shipmode){ smblib_dbg(chg, PR_MISC, "Set ship mode: %d!!\n", !!g_oplus_chip->enable_shipmode); smblib_masked_write(chg, SHIP_MODE_REG, SHIP_MODE_EN_BIT, g_oplus_chip->enable_shipmode ? SHIP_MODE_EN_BIT : 0); } /* disable all interrupts */ smb5_disable_interrupts(chg); /* configure power role for UFP */ if (chg->connector_type == POWER_SUPPLY_CONNECTOR_TYPEC) smblib_masked_write(chg, TYPE_C_MODE_CFG_REG, TYPEC_POWER_ROLE_CMD_MASK, EN_SNK_ONLY_BIT); /* force enable and rerun APSD */ smblib_apsd_enable(chg, true); smblib_hvdcp_exit_config(chg); #ifdef OPLUS_FEATURE_CHG_BASIC if (oplus_shipmode_id_check_is_gpio(g_oplus_chip) == true) { level = gpio_get_value(chg->shipmode_id_gpio); } if (g_oplus_chip && g_oplus_chip->enable_shipmode && level != 1) { msleep(1000); smbchg_enter_shipmode(g_oplus_chip); } #endif /* OPLUS_FEATURE_CHG_BASIC */ } static const struct of_device_id match_table[] = { { .compatible = "qcom,qpnp-smb5", }, { }, }; static struct platform_driver smb5_driver = { .driver = { .name = "qcom,qpnp-smb5", .of_match_table = match_table, #ifdef OPLUS_FEATURE_CHG_BASIC .pm = &smb5_pm_ops, #endif }, .probe = smb5_probe, .remove = smb5_remove, .shutdown = smb5_shutdown, }; module_platform_driver(smb5_driver); MODULE_DESCRIPTION("QPNP SMB5 Charger Driver"); MODULE_LICENSE("GPL v2");