A-Team_Digital_Solutions/android_kernel_motorola_sm6375
Watch
2
0
Fork
You've already forked android_kernel_motorola_sm6375
 0
mirror of https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git synced 2026-10-25 22:23:14 -04:00
Code Issues Projects Releases Packages Wiki Activity

charging: add SW QC3+ 33W turbo charging

Browse source 
add SW QC3+ 33W turbo charging
for Rhodep

Change-Id: I89ba55d628a811d9951c9321941416db10b94ecb
Signed-off-by: mahj8 <mahj8@motorola.com>
Reviewed-on: https://gerrit.mot.com/2145169
SME-Granted: SME Approvals Granted
SLTApproved: Slta Waiver
Tested-by: Jira Key
Reviewed-by: Huosheng Liao <liaohs@motorola.com>
Submit-Approved: Jira Key
This commit is contained in:
mahj8 2022-01-07 15:56:55 +08:00 • committed by Haijian Ma
commit 75c52cae5a
16 changed files with 339 additions and 39 deletions
Download patch file Download diff file Expand all files Collapse all files

10
drivers/power/mmi_discrete_charger/mmi_discrete_charger_class.c
View file

@ -221,6 +221,16 @@ int charger_dev_get_real_charger_type(struct charger_device *chg_dev, int *charg
}
EXPORT_SYMBOL(charger_dev_get_real_charger_type);
int charger_dev_get_qc3p_power(struct charger_device *chg_dev, int *qc3p_power)
{
if (chg_dev != NULL && chg_dev->ops != NULL &&
chg_dev->ops->get_qc3p_power)
return chg_dev->ops->get_qc3p_power(chg_dev, qc3p_power);
return -ENOTSUPP;
}
EXPORT_SYMBOL(charger_dev_get_qc3p_power);
int charger_dev_notify(struct charger_device *chg_dev)
{
return srcu_notifier_call_chain(

42
drivers/power/mmi_discrete_charger/mmi_discrete_charger_core.c
View file

@ -1980,15 +1980,53 @@ int mmi_discrete_get_charging_enabled(struct mmi_discrete_charger *chip, bool *v
{
int rc = 0;
mmi_dbg(chip, "mmi_discrete_get_charging_enabled val:%d\n",*val);
rc = charger_dev_is_enabled_charging(chip->master_chg_dev, val);
if (rc)
mmi_err(chip, "Couldn't get charging status rc=%d\n", rc);
mmi_dbg(chip, "mmi_discrete_get_charging_enabled val:%d\n",*val);
return rc;
}
int mmi_discrete_get_qc3p_power(struct mmi_discrete_charger *chip, int *val)
{
int rc = 0;
rc = charger_dev_get_qc3p_power(chip->master_chg_dev, val);
if (rc)
mmi_err(chip, "Couldn't get qc3p power rc=%d\n", rc);
mmi_dbg(chip, "mmi_discrete_get_qc3p_power val:%d\n",*val);
return rc;
}
int mmi_discrete_get_pulse_cnt(struct mmi_discrete_charger *chip, int *count)
{
int rc = 0;
rc = charger_dev_get_pulse_cnt(chip->master_chg_dev, count);
if (rc)
mmi_err(chip, "Couldn't get pulse cnt rc=%d\n", rc);
mmi_dbg(chip, "mmi_discrete_get_pulse_cnt count:%d\n",*count);
return rc;
}
int mmi_discrete_set_dp_dm(struct mmi_discrete_charger *chip, int val)
{
int rc = 0;
rc = charger_dev_set_dp_dm(chip->master_chg_dev, val);
if (rc)
mmi_err(chip, "Couldn't set dp dm rc=%d\n", rc);
mmi_dbg(chip, "mmi_discrete_set_dp_dm val:%d\n",val);
return rc;
}
int mmi_discrete_config_input_current_settled(struct mmi_discrete_charger *chip, int val)
{

3
drivers/power/mmi_discrete_charger/mmi_discrete_charger_core.h
View file

@ -138,5 +138,8 @@ int mmi_discrete_config_charging_enabled(struct mmi_discrete_charger *chip, int
int mmi_discrete_get_charging_enabled(struct mmi_discrete_charger *chip, bool *val);
int mmi_discrete_config_input_current_settled(struct mmi_discrete_charger *chip, int val);
int mmi_discrete_config_termination_enabled(struct mmi_discrete_charger *chip, int val);
int mmi_discrete_get_qc3p_power(struct mmi_discrete_charger *chip, int *val);
int mmi_discrete_get_pulse_cnt(struct mmi_discrete_charger *chip, int *count);
int mmi_discrete_set_dp_dm(struct mmi_discrete_charger *chip, int val);
#endif

13
drivers/power/mmi_discrete_charger/mmi_discrete_charger_iio.c
View file

@ -10,6 +10,7 @@
* GNU General Public License for more details.
*/
#include <linux/power_supply.h>
#include "mmi_discrete_charger_iio.h"
static int mmi_discrete_iio_write_raw(struct iio_dev *indio_dev,
@ -38,6 +39,12 @@ static int mmi_discrete_iio_write_raw(struct iio_dev *indio_dev,
case PSY_IIO_USB_TERMINATION_ENABLED:
rc = mmi_discrete_config_termination_enabled(chip, val1);
break;
case PSY_IIO_DP_DM:
if (chip->real_charger_type == POWER_SUPPLY_TYPE_USB_HVDCP_3
|| chip->real_charger_type == POWER_SUPPLY_TYPE_USB_HVDCP_3P5) {
rc = mmi_discrete_set_dp_dm(chip, val1);
}
break;
default:
pr_err("Unsupported mmi_discrete IIO chan %d\n", chan->channel);
rc = -EINVAL;
@ -71,6 +78,12 @@ static int mmi_discrete_iio_read_raw(struct iio_dev *indio_dev,
rc = mmi_discrete_get_charging_enabled(chip, &val_bool);
*val1 = val_bool?1:0;
break;
case PSY_IIO_MMI_QC3P_POWER:
rc = mmi_discrete_get_qc3p_power(chip, val1);
break;
case PSY_IIO_DP_DM:
rc = mmi_discrete_get_pulse_cnt(chip, val1);
break;
default:
pr_err("Unsupported mmi_discrete IIO chan %d\n", chan->channel);
rc = -EINVAL;

6
drivers/power/mmi_discrete_charger/mmi_discrete_charger_iio.h
View file

@ -35,6 +35,10 @@ struct mmi_discrete_iio_channels {
.info_mask = _mask, \
},
#define MMI_DISCRETE_CHAN_COUNT(_name, _num) \
MMI_DISCRETE_IIO_CHAN(_name, _num,IIO_COUNT, \
BIT(IIO_CHAN_INFO_PROCESSED))
#define MMI_DISCRETE_CHAN_INDEX(_name, _num) \
MMI_DISCRETE_IIO_CHAN(_name, _num, IIO_INDEX, \
BIT(IIO_CHAN_INFO_PROCESSED))
@ -48,6 +52,8 @@ static const struct mmi_discrete_iio_channels mmi_discrete_iio_psy_channels[] =
MMI_DISCRETE_CHAN_INDEX("charging_enabled", PSY_IIO_USB_CHARGING_ENABLED)
MMI_DISCRETE_CHAN_INDEX("input_current_settled", PSY_IIO_INPUT_CURRENT_SETTLED)
MMI_DISCRETE_CHAN_INDEX("termination_enabled", PSY_IIO_USB_TERMINATION_ENABLED)
MMI_DISCRETE_CHAN_COUNT("battery_dp_dm", PSY_IIO_DP_DM)
MMI_DISCRETE_CHAN_INDEX("usb_qc3p_power", PSY_IIO_MMI_QC3P_POWER)
};
int mmi_discrete_init_iio_psy(struct mmi_discrete_charger *chip,

4
drivers/power/mmi_discrete_turbo_charger/Android.mk
View file

@ -5,6 +5,10 @@ include $(CLEAR_VARS)
LOCAL_MODULE := mmi_discrete_turbo_charger.ko
LOCAL_MODULE_TAGS := optional
ifeq ($(MMI_QC3P_WT6670_DETECTED),true)
KERNEL_CFLAGS += CONFIG_MMI_QC3P_WT6670_DETECTED=y
endif
ifeq ($(DLKM_INSTALL_TO_VENDOR_OUT),true)
LOCAL_MODULE_PATH := $(TARGET_OUT_VENDOR)/lib/modules/
else

4
drivers/power/mmi_discrete_turbo_charger/Kbuild
View file

@ -3,6 +3,10 @@ EXTRA_CFLAGS += -Wall
EXTRA_CFLAGS += -I$(ANDROID_BUILD_TOP)/motorola/kernel/modules/include \
-I$(ANDROID_BUILD_TOP)/motorola/kernel/modules/drivers/power/mmi_discrete_turbo_charger
ifneq ($(filter m y,$(CONFIG_MMI_QC3P_WT6670_DETECTED)),)
EXTRA_CFLAGS += -DCONFIG_MMI_QC3P_WT6670_DETECTED
endif
obj-m += mmi_discrete_turbo_charger.o
mmi_discrete_turbo_charger-objs += mmi_charger_class.o
mmi_discrete_turbo_charger-objs += mmi_charger_core.o

2
drivers/power/mmi_discrete_turbo_charger/mmi_charger_core.c
View file

@ -751,7 +751,9 @@ static int psy_changed(struct notifier_block *nb, unsigned long evt, void *ptr)
struct mmi_charger_manager *chip =
container_of(nb, struct mmi_charger_manager, psy_nb);
#ifdef CONFIG_MMI_QC3P_WT6670_DETECTED
return NOTIFY_OK;
#endif
if (!chip->usb_psy) {
mmi_chrg_err(chip, "usb psy is NULL, direct return\n");

4
drivers/power/mmi_discrete_turbo_charger/mmi_charger_core.h
View file

@ -79,7 +79,11 @@ enum print_reason {
enum mmi_qc3p_power {
QTI_POWER_SUPPLY_QC3P_NONE,
#ifdef CONFIG_MMI_QC3P_WT6670_DETECTED
QTI_POWER_SUPPLY_QC3P_18W = 0x8,
#else
QTI_POWER_SUPPLY_QC3P_18W,
#endif
QTI_POWER_SUPPLY_QC3P_27W,
QTI_POWER_SUPPLY_QC3P_45W,
};

8
drivers/power/mmi_discrete_turbo_charger/mmi_charger_core_iio.h
View file

@ -49,7 +49,6 @@ enum mmi_charger_ext_iio_channels {
CP_INPUT_VOLTAGE_NOW,
CP_STATUS1,
CP_CLEAR_ERROR,
SMB5_QC3P_START_DETECT,
/*mmi-smb5charger-iio*/
MMI_CP_ENABLE_STATUS,
MMI_USB_TERMINATION_ENABLED,
@ -64,10 +63,15 @@ static const char * const mmi_charger_ext_iio_chan_name[] = {
[SMB5_USB_PD_ACTIVE] = "pd_active",
[MMI_USB_TERMINATION_ENABLED] = "termination_enabled",
/*qc3p*/
#ifdef CONFIG_MMI_QC3P_WT6670_DETECTED
[SMB5_USB_REAL_TYPE] = "wt6670_usb_real_type",
[SMB5_DP_DM] = "wt6670_battery_dp_dm",
[SMB5_QC3P_POWER] = "wt6670_usb_qc3p_power",
[SMB5_QC3P_START_DETECT] = "wt6670_start_detection",
#else
[SMB5_USB_REAL_TYPE] = "usb_real_type",
[SMB5_DP_DM] = "battery_dp_dm",
[SMB5_QC3P_POWER] = "usb_qc3p_power",
#endif
/*cp*/
[CP_ENABLE] = "bq2597x_cp_enabled",
[CP_INPUT_CURRENT_NOW] = "bq2597x_input_current_now",

87
drivers/power/mmi_discrete_turbo_charger/mmi_qc3p.c
View file

@ -42,17 +42,6 @@
#include <linux/kernel.h>
#include <linux/types.h>
bool mmi_qc3p_start_detection(struct mmi_charger_manager *chg)
{
int ret, iio_val;
ret = mmi_charger_read_iio_chan(chg, SMB5_QC3P_START_DETECT, &iio_val);
if (ret < 0) {
mmi_chrg_err(chg, "Couldn't operate qc3p detection rc=%d\n", ret);
return false;
}
return true;
}
bool mmi_qc3p_power_active(struct mmi_charger_manager *chg)
{
@ -63,9 +52,13 @@ bool mmi_qc3p_power_active(struct mmi_charger_manager *chg)
mmi_chrg_err(chg, "Couldn't read charger type rc=%d\n", ret);
return false;
}
#ifdef CONFIG_MMI_QC3P_WT6670_DETECTED
if (iio_val != QTI_POWER_SUPPLY_QC3P_27W && iio_val != QTI_POWER_SUPPLY_QC3P_45W)
return false;
#else
if (iio_val != POWER_SUPPLY_TYPE_USB_HVDCP_3P5)
return false;
#endif
ret = mmi_charger_read_iio_chan(chg, SMB5_QC3P_POWER, &iio_val);
if (ret < 0) {
mmi_chrg_err(chg, "Couldn't read qc3p power rc=%d\n", ret);
@ -81,6 +74,7 @@ bool mmi_qc3p_power_active(struct mmi_charger_manager *chg)
return false;
}
#ifdef CONFIG_MMI_QC3P_WT6670_DETECTED
int mmi_qc3p_set_vbus_voltage(struct mmi_charger_manager *chg, int target_mv)
{
int rc = -EINVAL;
@ -132,4 +126,71 @@ int mmi_qc3p_set_vbus_voltage(struct mmi_charger_manager *chg, int target_mv)
}
mmi_chrg_info(chg, "result_vbus= %d\n",curr_vbus_mv);
return curr_vbus_mv;
}
}
#else
enum {
MMI_POWER_SUPPLY_DP_DM_UNKNOWN = 0,
MMI_POWER_SUPPLY_DP_DM_DP_PULSE = 1,
MMI_POWER_SUPPLY_DP_DM_DM_PULSE = 2,
};
#define QC3P_PULSE_COUNT_MAX ((11000 - 5000) / 20 + 10)
int mmi_qc3p_set_vbus_voltage(struct mmi_charger_manager *chg, int target_mv)
{
int rc = -EINVAL;
union power_supply_propval val = {0, };
int pulse_cnt, curr_vbus_mv, step, i;
rc = mmi_charger_read_iio_chan(chg, SMB5_DP_DM, &val.intval);
if (rc < 0) {
mmi_chrg_err(chg, "Couldn't read dpdm pulse count rc=%d\n", rc);
return -EINVAL;
} else {
mmi_chrg_info(chg, "DP DM pulse count = %d\n", val.intval);
pulse_cnt = val.intval;
}
rc = mmi_get_vbus(chg->chrg_list[CP_MASTER],
&curr_vbus_mv);
if (rc) {
mmi_chrg_err(chg, "Unable to read USB voltage: %d\n", rc);
return -EINVAL;
}
if(target_mv < curr_vbus_mv) {
step = (curr_vbus_mv - target_mv) / 20;
val.intval = MMI_POWER_SUPPLY_DP_DM_DM_PULSE;
if (pulse_cnt <= step)
step = pulse_cnt;
} else {
step = (target_mv - curr_vbus_mv) / 20;
val.intval = MMI_POWER_SUPPLY_DP_DM_DP_PULSE;
if (step + pulse_cnt > QC3P_PULSE_COUNT_MAX)
step = QC3P_PULSE_COUNT_MAX - pulse_cnt;
}
mmi_chrg_info(chg, "curr_vbus= %d, target_vbus = %d, step = %d\n",curr_vbus_mv, target_mv, step);
for (i = 0; i < step; i++) {
rc = mmi_charger_write_iio_chan(chg, SMB5_DP_DM, val.intval);
if (rc < 0) {
mmi_chrg_err(chg, "Couldn't set dpdm pulse rc=%d\n", rc);
break;
}
if (i < step - 1)
udelay(5000);
}
rc = mmi_get_vbus(chg->chrg_list[CP_MASTER],
&curr_vbus_mv);
if (rc) {
mmi_chrg_err(chg, "Unable to read VBUS: %d\n", rc);
return -EINVAL;
}
mmi_chrg_info(chg, "result_vbus= %d\n",curr_vbus_mv);
return curr_vbus_mv;
}
#endif

4
drivers/power/sgm4154x_chg_mmi/Android.mk
View file

@ -9,6 +9,10 @@ ifeq ($(MMI_QC3P_TURBO_CHARGER),true)
KERNEL_CFLAGS += CONFIG_MMI_QC3P_TURBO_CHARGER=y
endif
ifeq ($(MMI_QC3P_WT6670_DETECTED),true)
KERNEL_CFLAGS += CONFIG_MMI_QC3P_WT6670_DETECTED=y
endif
LOCAL_MODULE_PATH := $(KERNEL_MODULES_OUT)
LOCAL_ADDITIONAL_DEPENDENCIES := $(KERNEL_MODULES_OUT)/mmi_discrete_charger_class.ko

4
drivers/power/sgm4154x_chg_mmi/Kbuild
View file

@ -7,6 +7,10 @@ ifneq ($(filter m y,$(CONFIG_MMI_QC3P_TURBO_CHARGER)),)
EXTRA_CFLAGS += -DCONFIG_MMI_QC3P_TURBO_CHARGER
endif
ifneq ($(filter m y,$(CONFIG_MMI_QC3P_WT6670_DETECTED)),)
EXTRA_CFLAGS += -DCONFIG_MMI_QC3P_WT6670_DETECTED
endif
obj-m += sgm4154x_charger.o
KBUILD_EXTRA_SYMBOLS += $(CURDIR)/$(KBUILD_EXTMOD)/../mmi_discrete_charger/$(GKI_OBJ_MODULE_DIR)/Module.symvers

169
drivers/power/sgm4154x_chg_mmi/sgm4154x_charger.c
View file

@ -24,10 +24,6 @@
#include <uapi/linux/sched/types.h>
#include <linux/kthread.h>
#ifdef CONFIG_MMI_QC3P_TURBO_CHARGER
static bool g_qc3p_detected = false;
#endif
static struct power_supply_desc sgm4154x_power_supply_desc;
/* SGM4154x REG06 BOOST_LIM[5:4], uV */
@ -322,7 +318,7 @@ static int sgm4154x_get_usb_voltage_now(struct sgm4154x_device *sgm, int *val)
return 0;
}
#ifndef CONFIG_MMI_QC3P_TURBO_CHARGER
#ifndef CONFIG_MMI_QC3P_WT6670_DETECTED
static int sgm4154x_adjust_qc20_hvdcp_5v(struct sgm4154x_device *sgm)
{
int ret;
@ -673,7 +669,6 @@ static int sgm4154x_get_icl(struct charger_device *chg_dev, u32 *uA)
return 0;
}
#ifdef CONFIG_MMI_QC3P_TURBO_CHARGER
static int sgm4154x_is_enabled_charging(struct charger_device *chg_dev, bool *en)
{
struct sgm4154x_device *sgm = dev_get_drvdata(&chg_dev->dev);
@ -690,7 +685,6 @@ static int sgm4154x_is_enabled_charging(struct charger_device *chg_dev, bool *en
return 0;
}
#endif
/*mahj:for build
static int sgm4154x_set_watchdog_timer(struct sgm4154x_device *sgm, int time)
@ -1396,7 +1390,13 @@ OUT:
schedule_delayed_work(&sgm->charge_monitor_work, 10*HZ);
}
#ifndef CONFIG_MMI_QC3P_TURBO_CHARGER
#ifndef CONFIG_MMI_QC3P_WT6670_DETECTED
#define QC3P_AUTHEN_LOW_THR_MV 5500000
#define QC3P_AUTHEN_HIGH_THR_MV 6500000
#define QC3P_AUTHEN_NONE_THR_MV 9000000
#define QC3P_AUTHEN_45W_THR_MV 8000000
#define QC3P_AUTHEN_27W_THR_MV 7000000
#define QC3P_AUTHEN_18W_THR_MV 6000000
static int sgm4154x_detected_qc30_hvdcp(struct sgm4154x_device *sgm, int *charger_type)
{
int ret = 0;
@ -1440,14 +1440,125 @@ static int sgm4154x_detected_qc30_hvdcp(struct sgm4154x_device *sgm, int *charge
dev_err(sgm->dev, "%s qc30 step down vbus error\n", __func__);
}
#ifndef CONFIG_MMI_QC3P_TURBO_CHARGER
sgm4154x_get_usb_voltage_now(sgm, &vbus_voltage);
dev_info(sgm->dev, "%s vbus voltage now = %d after detected qc30\n", __func__,vbus_voltage);
#endif
return ret;
}
static int sgm4154x_detected_qc3p_hvdcp(struct sgm4154x_device *sgm, int *charger_type)
{
int ret = 0;
int dp_val, dm_val;
int i=0, vbus_voltage;
mdelay(100);//need tunning
sgm4154x_get_usb_voltage_now(sgm, &vbus_voltage);
if (vbus_voltage < QC3P_AUTHEN_LOW_THR_MV
|| vbus_voltage > QC3P_AUTHEN_HIGH_THR_MV) {
sgm->mmi_qc3p_power = MMI_POWER_SUPPLY_QC3P_NONE;
/*do qc3p rerun*/
if (!sgm->mmi_qc3p_rerun_done) {
sgm->mmi_qc3p_rerun_done = true;
dp_val = 0x0<<3;
ret = regmap_update_bits(sgm->regmap, SGM4154x_CHRG_CTRL_d,
SGM4154x_DP_VSEL_MASK, dp_val); //dp HIZ
if (ret)
return ret;
dm_val = 0x0<<1;
ret = regmap_update_bits(sgm->regmap, SGM4154x_CHRG_CTRL_d,
SGM4154x_DM_VSEL_MASK, dm_val); //dm HIZ
if (ret)
return ret;
msleep(30);//need tunning
schedule_work(&sgm->rerun_apsd_work);
}
return 0;
}
for (i = 0;i < 3; i++) {
ret = sgm4154x_qc30_step_up_vbus(sgm);
if (ret)
dev_err(sgm->dev, "%s qc3p step up vbus error\n", __func__);
ret = sgm4154x_qc30_step_down_vbus(sgm);
if (ret)
dev_err(sgm->dev, "%s qc3p step down vbus error\n", __func__);
}
mdelay(30);//need tuning
sgm4154x_get_usb_voltage_now(sgm, &vbus_voltage);
for (i = 0; i < 2; i++) {
ret = sgm4154x_qc30_step_up_vbus(sgm);
if (ret)
dev_err(sgm->dev, "%s qc3p step up vbus error\n", __func__);
}
for (i = 0; i < 2; i++) {
ret = sgm4154x_qc30_step_down_vbus(sgm);
if (ret)
dev_err(sgm->dev, "%s qc3p step down vbus error\n", __func__);
}
msleep(30);
dev_info(sgm->dev, "%s vbus voltage now = %d after detected qc3p\n", __func__,vbus_voltage);
if (vbus_voltage > QC3P_AUTHEN_NONE_THR_MV)
sgm->mmi_qc3p_power = MMI_POWER_SUPPLY_QC3P_NONE;
else if (vbus_voltage > QC3P_AUTHEN_45W_THR_MV)
sgm->mmi_qc3p_power = MMI_POWER_SUPPLY_QC3P_45W;
else if (vbus_voltage > QC3P_AUTHEN_27W_THR_MV)
sgm->mmi_qc3p_power = MMI_POWER_SUPPLY_QC3P_27W;
else if (vbus_voltage > QC3P_AUTHEN_18W_THR_MV)
sgm->mmi_qc3p_power = MMI_POWER_SUPPLY_QC3P_18W;
else
sgm->mmi_qc3p_power = MMI_POWER_SUPPLY_QC3P_NONE;
if (sgm->mmi_qc3p_power != MMI_POWER_SUPPLY_QC3P_NONE) {
*charger_type = POWER_SUPPLY_TYPE_USB_HVDCP_3P5;
dev_info(sgm->dev, "%s detected qc3p, qc3p power = %d\n",
__func__,sgm->mmi_qc3p_power);
} else {
dev_err(sgm->dev, "qc3p power is invalid, rerun qc3p detect\n");
//do rerun qc3p
if (!sgm->mmi_qc3p_rerun_done) {
sgm->mmi_qc3p_rerun_done = true;
dp_val = 0x0<<3;
ret = regmap_update_bits(sgm->regmap, SGM4154x_CHRG_CTRL_d,
SGM4154x_DP_VSEL_MASK, dp_val); //dp HIZ
if (ret)
return ret;
dm_val = 0x0<<1;
ret = regmap_update_bits(sgm->regmap, SGM4154x_CHRG_CTRL_d,
SGM4154x_DM_VSEL_MASK, dm_val); //dm HIZ
if (ret)
return ret;
msleep(30);//need tunning
schedule_work(&sgm->rerun_apsd_work);
}
}
return ret;
}
#endif
#ifdef CONFIG_MMI_QC3P_TURBO_CHARGER
#ifdef CONFIG_MMI_QC3P_WT6670_DETECTED
bool is_chan_valid(struct sgm4154x_device *chip,
enum mmi_qc3p_ext_iio_channels chan)
{
@ -1590,7 +1701,7 @@ static int mmi_hvdcp_detect_kthread(void *param)
sgm->mmi_is_qc3_authen = true;
sgm4154x_set_input_curr_lim(sgm, MMI_HVDCP_DETECT_ICL_LIMIT);
#ifndef CONFIG_MMI_QC3P_TURBO_CHARGER
#ifndef CONFIG_MMI_QC3P_WT6670_DETECTED
//do qc2.0 detected
ret = sgm4154x_detected_qc20_hvdcp(sgm, &charger_type);
if (ret) {
@ -1605,7 +1716,19 @@ static int mmi_hvdcp_detect_kthread(void *param)
ret = sgm4154x_detected_qc30_hvdcp(sgm, &charger_type);
if (ret) {
dev_err(sgm->dev, "Cann't detected qc30 hvdcp\n");
goto out;
}
#ifdef CONFIG_MMI_QC3P_TURBO_CHARGER
//do qc3p detected
if (charger_type == POWER_SUPPLY_TYPE_USB_HVDCP_3) {
ret = sgm4154x_detected_qc3p_hvdcp(sgm, &charger_type);
if (ret) {
dev_err(sgm->dev, "Cann't detected qc3p hvdcp\n");
goto out;
}
}
#endif
#else
sgm4154x_enable_termination(sgm->chg_dev, true);
qc3p_start_detection(sgm);
@ -1626,7 +1749,6 @@ static int mmi_hvdcp_detect_kthread(void *param)
dev_err(sgm->dev, "QC3P 27W have been detected !\n");
charger_type = POWER_SUPPLY_TYPE_USB_HVDCP_3P5;
qc3p_update_policy(sgm);
g_qc3p_detected = true;
break;
default:
dev_info(sgm->dev, "No HDVCP detected\n");
@ -1670,16 +1792,18 @@ static void sgm4154x_vbus_remove(struct sgm4154x_device * sgm)
#ifdef CONFIG_MMI_QC3P_TURBO_CHARGER
sgm4154x_enable_termination(sgm->chg_dev, true);
g_qc3p_detected = false;
#ifdef CONFIG_MMI_QC3P_WT6670_DETECTED
qc3p_update_policy(sgm);
#endif
#endif
cancel_delayed_work_sync(&sgm->charge_monitor_work);
sgm->pulse_cnt = 0;
sgm->mmi_qc3p_rerun_done = false;
sgm->typec_apsd_rerun_done = false;
sgm->chg_dev->noti.apsd_done = false;
sgm->chg_dev->noti.hvdcp_done = false;
sgm->real_charger_type = POWER_SUPPLY_TYPE_UNKNOWN;
sgm->mmi_qc3p_power = MMI_POWER_SUPPLY_QC3P_NONE;
sgm4154x_request_dpdm(sgm, false);
charger_dev_notify(sgm->chg_dev);
}
@ -1713,10 +1837,7 @@ static void sgm4154x_vbus_plugin(struct sgm4154x_device * sgm)
case SGM4154x_USB_DCP:
pr_err("SGM4154x charger type: DCP\n");
sgm->real_charger_type = POWER_SUPPLY_TYPE_USB_DCP;
#ifdef CONFIG_MMI_QC3P_TURBO_CHARGER
if(g_qc3p_detected == false)
#endif
mmi_start_hvdcp_detect(sgm);
mmi_start_hvdcp_detect(sgm);
break;
case SGM4154x_UNKNOWN:
@ -2459,6 +2580,15 @@ static int sgm4154x_set_boost_current_limit(struct charger_device *chg_dev, u32
return rc;
}
static int sgm4154x_get_qc3p_power(struct charger_device *chg_dev, int *qc3p_power)
{
struct sgm4154x_device *sgm = dev_get_drvdata(&chg_dev->dev);
*qc3p_power = sgm->mmi_qc3p_power;
return 0;
}
static int sgm4154x_get_pulse_cnt(struct charger_device *chg_dev, int *count)
{
struct sgm4154x_device *sgm = dev_get_drvdata(&chg_dev->dev);
@ -2544,10 +2674,9 @@ static struct charger_ops sgm4154x_chg_ops = {
.is_charge_halted = sgm4154x_is_charging_halted,
.dump_registers = sgm4154x_dump_registers,
#ifdef CONFIG_MMI_QC3P_TURBO_CHARGER
.is_enabled_charging = sgm4154x_is_enabled_charging,
#endif
.enable_termination = sgm4154x_enable_termination,
.get_qc3p_power = sgm4154x_get_qc3p_power,
};
static int sgm4154x_probe(struct i2c_client *client,
@ -2675,7 +2804,7 @@ static int sgm4154x_probe(struct i2c_client *client,
enable_irq_wake(client->irq);
}
#ifdef CONFIG_MMI_QC3P_TURBO_CHARGER
#ifdef CONFIG_MMI_QC3P_WT6670_DETECTED
ret = mmi_init_iio_psy(sgm, dev);
if (ret) {
dev_err(dev,

15
drivers/power/sgm4154x_chg_mmi/sgm4154x_charger.h
View file

@ -233,6 +233,13 @@ enum {
MMI_POWER_SUPPLY_DP_DM_DM_PULSE = 2,
};
enum mmi_qc3p_power {
MMI_POWER_SUPPLY_QC3P_NONE,
MMI_POWER_SUPPLY_QC3P_18W,
MMI_POWER_SUPPLY_QC3P_27W,
MMI_POWER_SUPPLY_QC3P_45W,
};
struct sgm4154x_iio {
struct iio_channel *usbin_v_chan;
};
@ -347,13 +354,17 @@ struct sgm4154x_device {
u32 input_current_cache;
int pulse_cnt;
/*mmi qc3p*/
bool mmi_qc3p_rerun_done;
int mmi_qc3p_power;
struct sgm4154x_iio iio;
#ifdef CONFIG_MMI_QC3P_TURBO_CHARGER
#ifdef CONFIG_MMI_QC3P_WT6670_DETECTED
struct iio_channel **ext_iio_chans;
#endif
};
#ifdef CONFIG_MMI_QC3P_TURBO_CHARGER
#ifdef CONFIG_MMI_QC3P_WT6670_DETECTED
enum WT_charger_type{
WT_CHG_TYPE_BEGIN = 0,
WT_CHG_TYPE_FC,

3
include/linux/mmi_discrete_charger_class.h
View file

@ -47,6 +47,7 @@ struct charger_ops {
int (*get_pulse_cnt)(struct charger_device *dev, int *count);
int (*get_real_charger_type)(struct charger_device *dev, int *charger_type);
int (*get_qc3p_power)(struct charger_device *dev, int *qc3p_power);
/* enable/disable charger */
int (*enable_charging)(struct charger_device *dev, bool en);
@ -137,6 +138,8 @@ extern int charger_dev_set_dp_dm(struct charger_device *chg_dev, int val);
extern int charger_dev_get_real_charger_type(struct charger_device *chg_dev, int *charger_type);
extern int charger_dev_get_qc3p_power(struct charger_device *chg_dev, int *qc3p_power);
extern int register_charger_device_notifier(
struct charger_device *charger_dev,
struct notifier_block *nb);