SSFC: Framework to support two charger sources

Many platforms have requirements to support more than one charge
source (eg. pirika). It can't be supported by just enabling two
different CONFIGS as that can lead to conflicts.
Eg.USD_PD_VBUS_DETECT_TCPC vs USB_PD_VBUS_DETECT_DISCHARGE.
This change provides a framework that supports two different charger
sources in the same build. Please see the CL for relevant logs.

BRANCH=None
BUG=b:194375840
TEST=make -j buildall

Signed-off-by: Parth Malkan <parthmalkan@google.com>
Change-Id: I309cc5930233983e615d90a4290fc749abf7aa2d
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/ec/+/3088232
Reviewed-by: Aseda Aboagye <aaboagye@chromium.org>

5 files changed, 130 insertions, 43 deletions

diff --git a/common/build.mk b/common/build.mk
index 867dcf465f..a1a956f9ab 100644
--- a/common/build.mk
+++ b/common/build.mk
@@ -52,6 +52,7 @@ common-$(CONFIG_BODY_DETECTION)+=body_detection.o
 common-$(CONFIG_CAPSENSE)+=capsense.o
 common-$(CONFIG_CEC)+=cec.o
 common-$(CONFIG_CBI_EEPROM)+=cbi.o cbi_eeprom.o
+common-$(CONFIG_USB_PD_FLAGS)+=usb_pd_flags.o
 common-$(CONFIG_CBI_GPIO)+=cbi.o cbi_gpio.o
 ifeq ($(HAS_MOCK_CHARGE_MANAGER),)
 common-$(CONFIG_CHARGE_MANAGER)+=charge_manager.o
diff --git a/common/usb_charger.c b/common/usb_charger.c
index 20031a9469..b8e8038811 100644
--- a/common/usb_charger.c
+++ b/common/usb_charger.c
@@ -22,6 +22,7 @@
 #include "task.h"
 #include "usb_charge.h"
 #include "usb_pd.h"
+#include "usb_pd_flags.h"
 #include "usbc_ppc.h"
 #include "util.h"
 
@@ -81,11 +82,11 @@ void usb_charger_vbus_change(int port, int vbus_level)
 		usb_charger_reset_charge(port);
 #endif
 
-#if (defined(CONFIG_USB_PD_VBUS_DETECT_CHARGER) \
-	|| defined(CONFIG_USB_PD_VBUS_DETECT_PPC))
-	/* USB PD task */
-	task_wake(PD_PORT_TO_TASK_ID(port));
-#endif
+	if ((get_usb_pd_vbus_detect() == USB_PD_VBUS_DETECT_CHARGER) ||
+		(get_usb_pd_vbus_detect() == USB_PD_VBUS_DETECT_PPC)) {
+		/* USB PD task */
+		task_wake(PD_PORT_TO_TASK_ID(port));
+	}
 }
 
 void usb_charger_reset_charge(int port)
diff --git a/common/usb_common.c b/common/usb_common.c
index 2515caf287..786bd118cf 100644
--- a/common/usb_common.c
+++ b/common/usb_common.c
@@ -25,6 +25,7 @@
 #include "usb_mux.h"
 #include "usb_pd.h"
 #include "usb_pd_dpm.h"
+#include "usb_pd_flags.h"
 #include "usb_pd_tcpm.h"
 #include "usbc_ocp.h"
 #include "usbc_ppc.h"
@@ -851,12 +852,17 @@ void pd_set_vbus_discharge(int port, int enable)
 	mutex_lock(&discharge_lock[port]);
 	enable &= !board_vbus_source_enabled(port);
 
-	if (IS_ENABLED(CONFIG_USB_PD_DISCHARGE_GPIO))
+	if (get_usb_pd_discharge() == USB_PD_DISCHARGE_GPIO) {
 		gpio_discharge_vbus(port, enable);
-	else if (IS_ENABLED(CONFIG_USB_PD_DISCHARGE_TCPC))
+	} else if (get_usb_pd_discharge() == USB_PD_DISCHARGE_TCPC) {
+#ifdef CONFIG_USB_PD_DISCHARGE_PPC
 		tcpc_discharge_vbus(port, enable);
-	else if (IS_ENABLED(CONFIG_USB_PD_DISCHARGE_PPC))
+#endif
+	} else if (get_usb_pd_discharge() == USB_PD_DISCHARGE_PPC) {
+#ifdef CONFIG_USB_PD_DISCHARGE_PPC
 		ppc_discharge_vbus(port, enable);
+#endif
+	}
 
 	mutex_unlock(&discharge_lock[port]);
 }
@@ -884,6 +890,10 @@ void pd_deferred_resume(int port)
 }
 #endif /* CONFIG_USB_PD_TCPM_TCPCI */
 
+__overridable int pd_snk_is_vbus_provided(int port)
+{
+	return EC_SUCCESS;
+}
 
 /*
  * Check the specified Vbus level
@@ -893,8 +903,10 @@ void pd_deferred_resume(int port)
  */
 __overridable bool pd_check_vbus_level(int port, enum vbus_level level)
 {
-	if (IS_ENABLED(CONFIG_USB_PD_VBUS_DETECT_TCPC))
+	if (IS_ENABLED(CONFIG_USB_PD_VBUS_DETECT_TCPC) &&
+		(get_usb_pd_vbus_detect() == USB_PD_VBUS_DETECT_TCPC)) {
 		return tcpm_check_vbus_level(port, level);
+	}
 	else if (level == VBUS_PRESENT)
 		return pd_snk_is_vbus_provided(port);
 	else
diff --git a/common/usb_pd_flags.c b/common/usb_pd_flags.c
new file mode 100644
index 0000000000..9328c03346
--- /dev/null
+++ b/common/usb_pd_flags.c
@@ -0,0 +1,65 @@
+/* Copyright 2021 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+/*
+ * Contains USB PD accessors definition
+ */
+
+#include "common.h"
+#include "config.h"
+#include "usb_pd_flags.h"
+
+static union usb_pd_runtime_flags usb_pd_flags;
+BUILD_ASSERT(sizeof(usb_pd_flags) == sizeof(uint32_t));
+
+enum usb_pd_vbus_detect get_usb_pd_vbus_detect(void)
+{
+	if (IS_ENABLED(CONFIG_USB_PD_RUNTIME_FLAGS))
+		return (enum usb_pd_vbus_detect) usb_pd_flags.vbus_detect;
+	else if (IS_ENABLED(CONFIG_USB_PD_VBUS_DETECT_TCPC))
+		return (enum usb_pd_vbus_detect)USB_PD_VBUS_DETECT_TCPC;
+	else if (IS_ENABLED(CONFIG_USD_PD_VBUS_DETECT_GPIO))
+		return (enum usb_pd_vbus_detect)USB_PD_VBUS_DETECT_GPIO;
+	else if (IS_ENABLED(CONFIG_USB_PD_VBUS_DETECT_PPC))
+		return (enum usb_pd_vbus_detect)USB_PD_VBUS_DETECT_PPC;
+	else if (IS_ENABLED(CONFIG_USB_PD_VBUS_DETECT_CHARGER))
+		return (enum usb_pd_vbus_detect)USB_PD_VBUS_DETECT_CHARGER;
+	else
+		return (enum usb_pd_vbus_detect)USB_PD_VBUS_DETECT_NONE;
+}
+
+enum usb_pd_discharge get_usb_pd_discharge(void)
+{
+	if (IS_ENABLED(CONFIG_USB_PD_RUNTIME_FLAGS))
+		return (enum usb_pd_discharge)usb_pd_flags.discharge;
+	else if (IS_ENABLED(CONFIG_USB_PD_DISCHARGE_TCPC))
+		return (enum usb_pd_discharge)USB_PD_DISCHARGE_TCPC;
+	else if (IS_ENABLED(CONFIG_USD_PD_DISCHARGE_GPIO))
+		return (enum usb_pd_discharge)USB_PD_DISCHARGE_GPIO;
+	else if (IS_ENABLED(CONFIG_USB_PD_DISCHARGE_PPC))
+		return (enum usb_pd_discharge)USB_PD_DISCHARGE_PPC;
+	else
+		return (enum usb_pd_discharge)USB_PD_DISCHARGE_NONE;
+}
+
+enum usb_pd_charger_otg get_usb_pd_charger_otg(void)
+{
+	return usb_pd_flags.charger_otg;
+}
+
+void set_usb_pd_vbus_detect(enum usb_pd_vbus_detect vbus_detect)
+{
+	usb_pd_flags.vbus_detect = vbus_detect;
+}
+
+void set_usb_pd_discharge(enum usb_pd_discharge discharge)
+{
+	usb_pd_flags.discharge = discharge;
+}
+
+void set_usb_pd_charger_otg(enum usb_pd_charger_otg charger_otg)
+{
+	usb_pd_flags.charger_otg = charger_otg;
+}
diff --git a/common/usb_pd_protocol.c b/common/usb_pd_protocol.c
index 07b50363b9..abf75e8004 100644
--- a/common/usb_pd_protocol.c
+++ b/common/usb_pd_protocol.c
@@ -29,6 +29,7 @@
 #include "usb_common.h"
 #include "usb_mux.h"
 #include "usb_pd.h"
+#include "usb_pd_flags.h"
 #include "usb_pd_tcpm.h"
 #include "usb_pd_tcpc.h"
 #include "usbc_ocp.h"
@@ -1570,10 +1571,10 @@ static void handle_data_request(int port, uint32_t head,
 		if ((pd[port].task_state == PD_STATE_SNK_DISCOVERY)
 			|| (pd[port].task_state == PD_STATE_SNK_TRANSITION)
 			|| (pd[port].task_state == PD_STATE_SNK_REQUESTED)
-#ifdef CONFIG_USB_PD_VBUS_DETECT_NONE
-			|| (pd[port].task_state ==
-			    PD_STATE_SNK_HARD_RESET_RECOVER)
-#endif
+			|| ((get_usb_pd_vbus_detect() ==
+					USB_PD_VBUS_DETECT_NONE)
+				&& (pd[port].task_state ==
+					PD_STATE_SNK_HARD_RESET_RECOVER))
 			|| (pd[port].task_state == PD_STATE_SNK_READY)) {
 #ifdef CONFIG_USB_PD_REV30
 			/*
@@ -4098,52 +4099,58 @@ void pd_task(void *u)
 		case PD_STATE_SNK_HARD_RESET_RECOVER:
 			if (pd[port].last_state != pd[port].task_state)
 				pd[port].flags |= PD_FLAGS_CHECK_IDENTITY;
-#ifdef CONFIG_USB_PD_VBUS_DETECT_NONE
-			/*
-			 * Can't measure vbus state so this is the maximum
-			 * recovery time for the source.
-			 */
-			if (pd[port].last_state != pd[port].task_state)
-				set_state_timeout(port, get_time().val +
+
+			if (get_usb_pd_vbus_detect() ==
+					USB_PD_VBUS_DETECT_NONE) {
+				/*
+				 * Can't measure vbus state so this is the
+				 * maximum recovery time for the source.
+				 */
+				if (pd[port].last_state != pd[port].task_state)
+					set_state_timeout(port, get_time().val +
 						  PD_T_SAFE_0V +
 						  PD_T_SRC_RECOVER_MAX +
 						  PD_T_SRC_TURN_ON,
 						  PD_STATE_SNK_DISCONNECTED);
-#else
-			/* Wait for VBUS to go low and then high*/
-			if (pd[port].last_state != pd[port].task_state) {
-				snk_hard_reset_vbus_off = 0;
-				set_state_timeout(port,
+			} else {
+#ifndef CONFIG_USB_PD_VBUS_DETECT_NONE
+				/* Wait for VBUS to go low and then high*/
+				if (pd[port].last_state !=
+						pd[port].task_state) {
+					snk_hard_reset_vbus_off = 0;
+					set_state_timeout(port,
 						  get_time().val +
 						  PD_T_SAFE_0V,
 						  hard_reset_count <
 						    PD_HARD_RESET_COUNT ?
 						     PD_STATE_HARD_RESET_SEND :
 						     PD_STATE_SNK_DISCOVERY);
-			}
+				}
 
-			if (!pd_is_vbus_present(port) &&
-			    !snk_hard_reset_vbus_off) {
-				/* VBUS has gone low, reset timeout */
-				snk_hard_reset_vbus_off = 1;
-				set_state_timeout(port,
+				if (!pd_is_vbus_present(port) &&
+				    !snk_hard_reset_vbus_off) {
+					/* VBUS has gone low, reset timeout */
+					snk_hard_reset_vbus_off = 1;
+					set_state_timeout(port,
 						  get_time().val +
 						  PD_T_SRC_RECOVER_MAX +
 						  PD_T_SRC_TURN_ON,
 						  PD_STATE_SNK_DISCONNECTED);
-			}
-			if (pd_is_vbus_present(port) &&
-			    snk_hard_reset_vbus_off) {
-				/* VBUS went high again */
-				set_state(port, PD_STATE_SNK_DISCOVERY);
-				timeout = 10*MSEC;
-			}
+				}
+				if (pd_is_vbus_present(port) &&
+				    snk_hard_reset_vbus_off) {
+					/* VBUS went high again */
+					set_state(port, PD_STATE_SNK_DISCOVERY);
+					timeout = 10*MSEC;
+				}
 
-			/*
-			 * Don't need to set timeout because VBUS changing
-			 * will trigger an interrupt and wake us up.
-			 */
+				/*
+				 * Don't need to set timeout because VBUS
+				 * changing will trigger an interrupt and
+				 * wake us up.
+				 */
 #endif
+			}
 			break;
 		case PD_STATE_SNK_DISCOVERY:
 			/* Wait for source cap expired only if we are enabled */
@@ -4172,7 +4179,8 @@ void pd_task(void *u)
 				int batt_soc = usb_get_battery_soc();
 
 				if (batt_soc < CONFIG_USB_PD_RESET_MIN_BATT_SOC ||
-				    battery_get_disconnect_state() != BATTERY_NOT_DISCONNECTED)
+				    battery_get_disconnect_state() !=
+						BATTERY_NOT_DISCONNECTED)
 					pd[port].flags |=
 						    PD_FLAGS_SNK_WAITING_BATT;
 				else