pd: USB Power Delivery State Machine based on Revision 3.0 of the spec.

Adds Power Delivery to the TypeC state machine as detailed in
Revision 3.0, Version 1.2 of the specification.

This CL passes the PD2.0 compliance tests and has been tested on
several devices. Some areas such as handling Electronically Marked
Cable information, creation of PIDs, and Host commands will be
addressed in later CLs.

BUG=b:130895206
BRANCH=none
TEST=manual
  Port 0 on Hatch was used to run this CL, merged with PD functionality,
  on the PD2.0 Compliance tester. All tests pass except for a few
  physical layer tests. The test report has been added to the bug.

  Atlas was verified to work with Apple, Amazon, StarTech, MKDGO and
  several other generic docks.

  Atlas was verified to work with Google's and Apple's CTVPD.

Signed-off-by: Sam Hurst <shurst@chromium.org>

Change-Id: Ia5e1988b0d81ec4cf9a7175e273197bd5a0865e4
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/ec/+/1737899
Reviewed-by: Jett Rink <jettrink@chromium.org>
Reviewed-by: Denis Brockus <dbrockus@chromium.org>
Tested-by: Jett Rink <jettrink@chromium.org>
Commit-Queue: Denis Brockus <dbrockus@chromium.org>

1 files changed, 190 insertions, 0 deletions

diff --git a/common/usb_common.c b/common/usb_common.c
index 86c85898dd..c060a5e006 100644
--- a/common/usb_common.c
+++ b/common/usb_common.c
@@ -12,6 +12,7 @@
 #include "charge_state.h"
 #include "usb_pd.h"
 #include "usb_pd_tcpm.h"
+#include "util.h"
 
 int usb_get_battery_soc(void)
 {
@@ -81,3 +82,192 @@ enum pd_cc_polarity_type get_snk_polarity(enum tcpc_cc_voltage_status cc1,
 	 */
 	return cc2 > cc1;
 }
+
+/*
+ * Zinger implements a board specific usb policy that does not define
+ * PD_MAX_VOLTAGE_MV and PD_OPERATING_POWER_MW. And in turn, does not
+ * use the following functions.
+ */
+#if defined(PD_MAX_VOLTAGE_MV) && defined(PD_OPERATING_POWER_MW)
+int pd_find_pdo_index(uint32_t src_cap_cnt, const uint32_t * const src_caps,
+					int max_mv, uint32_t *selected_pdo)
+{
+	int i, uw, mv;
+	int ret = 0;
+	int cur_uw = 0;
+	int prefer_cur;
+
+	int __attribute__((unused)) cur_mv = 0;
+
+	/* max voltage is always limited by this boards max request */
+	max_mv = MIN(max_mv, PD_MAX_VOLTAGE_MV);
+
+	/* Get max power that is under our max voltage input */
+	for (i = 0; i < src_cap_cnt; i++) {
+		/* its an unsupported Augmented PDO (PD3.0) */
+		if ((src_caps[i] & PDO_TYPE_MASK) == PDO_TYPE_AUGMENTED)
+			continue;
+
+		mv = ((src_caps[i] >> 10) & 0x3FF) * 50;
+		/* Skip invalid voltage */
+		if (!mv)
+			continue;
+		/* Skip any voltage not supported by this board */
+		if (!pd_is_valid_input_voltage(mv))
+			continue;
+
+		if ((src_caps[i] & PDO_TYPE_MASK) == PDO_TYPE_BATTERY) {
+			uw = 250000 * (src_caps[i] & 0x3FF);
+		} else {
+			int ma = (src_caps[i] & 0x3FF) * 10;
+
+			ma = MIN(ma, PD_MAX_CURRENT_MA);
+			uw = ma * mv;
+		}
+
+		if (mv > max_mv)
+			continue;
+		uw = MIN(uw, PD_MAX_POWER_MW * 1000);
+		prefer_cur = 0;
+
+		/* Apply special rules in case of 'tie' */
+		if (IS_ENABLED(PD_PREFER_LOW_VOLTAGE)) {
+			if (uw == cur_uw && mv < cur_mv)
+				prefer_cur = 1;
+		} else if (IS_ENABLED(PD_PREFER_HIGH_VOLTAGE)) {
+			if (uw == cur_uw && mv > cur_mv)
+				prefer_cur = 1;
+		}
+
+		/* Prefer higher power, except for tiebreaker */
+		if (uw > cur_uw || prefer_cur) {
+			ret = i;
+			cur_uw = uw;
+			cur_mv = mv;
+		}
+	}
+
+	if (selected_pdo)
+		*selected_pdo = src_caps[ret];
+
+	return ret;
+}
+
+void pd_extract_pdo_power(uint32_t pdo, uint32_t *ma, uint32_t *mv)
+{
+	int max_ma, uw;
+
+	*mv = ((pdo >> 10) & 0x3FF) * 50;
+
+	if (*mv == 0) {
+		*ma = 0;
+		return;
+	}
+
+	if ((pdo & PDO_TYPE_MASK) == PDO_TYPE_BATTERY) {
+		uw = 250000 * (pdo & 0x3FF);
+		max_ma = 1000 * MIN(1000 * uw, PD_MAX_POWER_MW) / *mv;
+	} else {
+		max_ma = 10 * (pdo & 0x3FF);
+		max_ma = MIN(max_ma, PD_MAX_POWER_MW * 1000 / *mv);
+	}
+
+	*ma = MIN(max_ma, PD_MAX_CURRENT_MA);
+}
+
+void pd_build_request(uint32_t src_cap_cnt, const uint32_t * const src_caps,
+			int32_t vpd_vdo, uint32_t *rdo, uint32_t *ma,
+			uint32_t *mv, enum pd_request_type req_type,
+			uint32_t max_request_mv)
+{
+	uint32_t pdo;
+	int pdo_index, flags = 0;
+	int uw;
+	int max_or_min_ma;
+	int max_or_min_mw;
+	int max_vbus;
+	int vpd_vbus_dcr;
+	int vpd_gnd_dcr;
+
+	if (req_type == PD_REQUEST_VSAFE5V) {
+		/* src cap 0 should be vSafe5V */
+		pdo_index = 0;
+		pdo = src_caps[0];
+	} else {
+		/* find pdo index for max voltage we can request */
+		pdo_index = pd_find_pdo_index(src_cap_cnt, src_caps,
+						max_request_mv, &pdo);
+	}
+
+	pd_extract_pdo_power(pdo, ma, mv);
+
+	/*
+	 * Adjust VBUS current if CTVPD device was detected.
+	 */
+	if (vpd_vdo > 0) {
+		max_vbus = VPD_VDO_MAX_VBUS(vpd_vdo);
+		vpd_vbus_dcr = VPD_VDO_VBUS_IMP(vpd_vdo) << 1;
+		vpd_gnd_dcr = VPD_VDO_GND_IMP(vpd_vdo);
+
+		if (max_vbus > VPD_MAX_VBUS_50V)
+			max_vbus = VPD_MAX_VBUS_20V;
+
+		/*
+		 * Valid max_vbus values:
+		 *   20000 mV
+		 *   30000 mV
+		 *   40000 mV
+		 *   50000 mV
+		 */
+		max_vbus = 20000 + max_vbus * 10000;
+		if (*mv > max_vbus)
+			*mv = max_vbus;
+
+		/*
+		 * 5000 mA cable: 150 = 750000 / 50000
+		 * 3000 mA cable: 250 = 750000 / 30000
+		 */
+		if (*ma > 3000)
+			*ma = 750000 / (150 + vpd_vbus_dcr + vpd_gnd_dcr);
+		else
+			*ma = 750000 / (250 + vpd_vbus_dcr + vpd_gnd_dcr);
+	}
+
+	uw = *ma * *mv;
+	/* Mismatch bit set if less power offered than the operating power */
+	if (uw < (1000 * PD_OPERATING_POWER_MW))
+		flags |= RDO_CAP_MISMATCH;
+
+#ifdef CONFIG_USB_PD_GIVE_BACK
+		/* Tell source we are give back capable. */
+		flags |= RDO_GIVE_BACK;
+
+		/*
+		 * BATTERY PDO: Inform the source that the sink will reduce
+		 * power to this minimum level on receipt of a GotoMin Request.
+		 */
+		max_or_min_mw = PD_MIN_POWER_MW;
+
+		/*
+		 * FIXED or VARIABLE PDO: Inform the source that the sink will
+		 * reduce current to this minimum level on receipt of a GotoMin
+		 * Request.
+		 */
+		max_or_min_ma = PD_MIN_CURRENT_MA;
+#else
+		/*
+		 * Can't give back, so set maximum current and power to
+		 * operating level.
+		 */
+		max_or_min_ma = *ma;
+		max_or_min_mw = uw / 1000;
+#endif
+
+	if ((pdo & PDO_TYPE_MASK) == PDO_TYPE_BATTERY) {
+		int mw = uw / 1000;
+		*rdo = RDO_BATT(pdo_index + 1, mw, max_or_min_mw, flags);
+	} else {
+		*rdo = RDO_FIXED(pdo_index + 1, *ma, max_or_min_ma, flags);
+	}
+}
+#endif