TCPMv2: Add pd console command

Add pd console commands that enables the device
to work with PD FAFT. Other pd commands such as
bist, vdm and ping will be added in another CL.

BUG=b:151481791
BUG=chromium:1021235
BRANCH=none
TEST=make -j buildall
	manual:
			Verified that system:
	pd tryscr 0  -  did not trysrc
	pd tryscr 1  -  did trysrc
	pd tryscr 2  -  normal trysrc operation
	pd 0 tx      -  started as snk
	pd 0 charger -  started as src
	pd 0 dev 5   -  charged at 5V
	pd 0 dev 12  -  charged at 12V
	pd 0 dev 15  -  charged at 15V
	pd 0 dev 20  -  charged at 20V
	pd 0 disable -  pd was disabled
	pd 0 enable  -  pd was enabled
	pd 0 soft    -  sent soft reset
	pd 0 hard    -  sent hard reset
	pd 0 dualrole off -    stayed in src and switched to snk on disconnect
	pd 0 dualrole on  -    toggled from snk to src and vice versa
	pd 0 dualrole sink -   was a sink only
	pd 0 dualrole source - was a source only
	pd 0 dualrole freeze - stayed in current power role and switched
			       to snk on disconnect
	pd 0 swap power - initiated a power role swap
	pd 0 swap vconn - initiated a vconn swap
	pd 0 swap data  - initiated a data role swap

Change-Id: Id1542001c0e52d1d5bfbc5b9cb826b9a204e5b2e
Signed-off-by: Sam Hurst <shurst@google.com>
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/ec/+/1962506
Commit-Queue: Denis Brockus <dbrockus@chromium.org>
Reviewed-by: Denis Brockus <dbrockus@chromium.org>

6 files changed, 648 insertions, 4 deletions

diff --git a/board/chocodile_vpdmcu/board.h b/board/chocodile_vpdmcu/board.h
index 962a4935f1..6a3c632773 100644
--- a/board/chocodile_vpdmcu/board.h
+++ b/board/chocodile_vpdmcu/board.h
@@ -40,6 +40,8 @@
 /* Optional features */
 #undef CONFIG_USB_PD_CONSOLE_CMD
 #undef CONFIG_USB_PD_HOST_CMD
+#undef CONFIG_CMD_PD
+#undef CONFIG_USBC_VCONN
 #define CONFIG_ADC
 #undef  CONFIG_ADC_WATCHDOG
 #define CONFIG_ADC_SAMPLE_TIME STM32_ADC_SMPR_41_5_CY
diff --git a/board/host/board.h b/board/host/board.h
index 6c0da164b3..1e5d14476f 100644
--- a/board/host/board.h
+++ b/board/host/board.h
@@ -11,6 +11,7 @@
 /* Optional features */
 /* Default-yes, override to no by including fake_battery module. */
 #define CONFIG_BATTERY_PRESENT_CUSTOM
+#undef CONFIG_CMD_PD
 #define CONFIG_EXTPOWER_GPIO
 #undef CONFIG_FMAP
 #define CONFIG_POWER_BUTTON
diff --git a/common/usbc/build.mk b/common/usbc/build.mk
index f8f6f5aa33..3b29d5d9ad 100644
--- a/common/usbc/build.mk
+++ b/common/usbc/build.mk
@@ -28,6 +28,7 @@ ifneq ($(CONFIG_USB_PE_SM),)
 all-obj-$(CONFIG_USB_VPD)+=$(_usbc_dir)usb_pe_ctvpd_sm.o
 all-obj-$(CONFIG_USB_CTVPD)+=$(_usbc_dir)usb_pe_ctvpd_sm.o
 all-obj-$(CONFIG_USB_DRP_ACC_TRYSRC)+=$(_usbc_dir)usb_pe_drp_sm.o
+all-obj-$(CONFIG_CMD_PD)+=$(_usbc_dir)usb_pd_console.o
 endif # CONFIG_USB_PE_SM
 
 endif # CONFIG_USB_PD_TCPMV2
diff --git a/common/usbc/usb_pd_console.c b/common/usbc/usb_pd_console.c
new file mode 100644
index 0000000000..ba2b6efeb9
--- /dev/null
+++ b/common/usbc/usb_pd_console.c
@@ -0,0 +1,163 @@
+/* Copyright 2020 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.
+ */
+
+#include "common.h"
+#include "console.h"
+#include "usb_common.h"
+#include "usb_pe_sm.h"
+#include "usb_tc_sm.h"
+#include "usb_pd.h"
+#include "util.h"
+
+test_export_static int command_pd(int argc, char **argv)
+{
+	int port;
+	char *e;
+
+	if (argc < 2)
+		return EC_ERROR_PARAM_COUNT;
+	else if (IS_ENABLED(CONFIG_USB_PD_TRY_SRC) &&
+				!strcasecmp(argv[1], "trysrc")) {
+		enum try_src_override_t ov = tc_get_try_src_override();
+
+		if (argc >= 3) {
+			ov = strtoi(argv[2], &e, 10);
+			if (*e || ov > TRY_SRC_NO_OVERRIDE)
+				return EC_ERROR_PARAM3;
+			tc_try_src_override(ov);
+		}
+
+		if (ov == TRY_SRC_NO_OVERRIDE)
+			ccprintf("Try.SRC System controlled\n");
+		else
+			ccprintf("Try.SRC Forced %s\n", ov ? "ON" : "OFF");
+
+		return EC_SUCCESS;
+	}
+
+	/* command: pd <port> <subcmd> [args] */
+	port = strtoi(argv[1], &e, 10);
+	if (argc < 3)
+		return EC_ERROR_PARAM_COUNT;
+
+	if (*e || port >= CONFIG_USB_PD_PORT_MAX_COUNT)
+		return EC_ERROR_PARAM2;
+
+	if (IS_ENABLED(CONFIG_USB_PD_DUAL_ROLE)) {
+		if (!strcasecmp(argv[2], "tx")) {
+			pe_dpm_request(port, DPM_REQUEST_SNK_STARTUP);
+		} else if (!strcasecmp(argv[2], "charger")) {
+			pe_dpm_request(port, DPM_REQUEST_SRC_STARTUP);
+		} else if (!strcasecmp(argv[2], "dev")) {
+			int max_volt;
+
+			if (argc >= 4) {
+				max_volt = strtoi(argv[3], &e, 10) * 1000;
+				if (*e)
+					return EC_ERROR_PARAM3;
+			} else {
+				max_volt = pd_get_max_voltage();
+			}
+			pd_request_source_voltage(port, max_volt);
+			pe_dpm_request(port, DPM_REQUEST_NEW_POWER_LEVEL);
+			ccprintf("max req: %dmV\n", max_volt);
+		} else if (!strcasecmp(argv[2], "disable")) {
+			pd_comm_enable(port, 0);
+			ccprintf("Port C%d disable\n", port);
+			return EC_SUCCESS;
+		} else if (!strcasecmp(argv[2], "enable")) {
+			pd_comm_enable(port, 1);
+			ccprintf("Port C%d enabled\n", port);
+			return EC_SUCCESS;
+		} else if (!strcasecmp(argv[2], "hard")) {
+			pe_dpm_request(port, DPM_REQUEST_HARD_RESET_SEND);
+		} else if (!strcasecmp(argv[2], "soft")) {
+			pe_dpm_request(port, DPM_REQUEST_SOFT_RESET_SEND);
+		} else if (!strcasecmp(argv[2], "swap")) {
+			if (argc < 4)
+				return EC_ERROR_PARAM_COUNT;
+
+			if (!strcasecmp(argv[3], "power"))
+				pe_dpm_request(port, DPM_REQUEST_PR_SWAP);
+			else if (!strcasecmp(argv[3], "data"))
+				pe_dpm_request(port, DPM_REQUEST_DR_SWAP);
+			else if (IS_ENABLED(CONFIG_USBC_VCONN_SWAP) &&
+					!strcasecmp(argv[3], "vconn"))
+				pe_dpm_request(port, DPM_REQUEST_VCONN_SWAP);
+			else
+				return EC_ERROR_PARAM3;
+		} else if (!strcasecmp(argv[2], "dualrole")) {
+			if (argc < 4) {
+				ccprintf("dual-role toggling: ");
+				switch (pd_get_dual_role(port)) {
+				case PD_DRP_TOGGLE_ON:
+					ccprintf("on\n");
+					break;
+				case PD_DRP_TOGGLE_OFF:
+					ccprintf("off\n");
+					break;
+				case PD_DRP_FREEZE:
+					ccprintf("freeze\n");
+					break;
+				case PD_DRP_FORCE_SINK:
+					ccprintf("force sink\n");
+					break;
+				case PD_DRP_FORCE_SOURCE:
+					ccprintf("force source\n");
+					break;
+				}
+			} else {
+				if (!strcasecmp(argv[3], "on"))
+					pd_set_dual_role(port,
+							PD_DRP_TOGGLE_ON);
+				else if (!strcasecmp(argv[3], "off"))
+					pd_set_dual_role(port,
+							PD_DRP_TOGGLE_OFF);
+				else if (!strcasecmp(argv[3], "freeze"))
+					pd_set_dual_role(port, PD_DRP_FREEZE);
+				else if (!strcasecmp(argv[3], "sink"))
+					pd_set_dual_role(port,
+							PD_DRP_FORCE_SINK);
+				else if (!strcasecmp(argv[3], "source"))
+					pd_set_dual_role(port,
+							PD_DRP_FORCE_SOURCE);
+				else
+					return EC_ERROR_PARAM4;
+			}
+			return EC_SUCCESS;
+		}
+	}
+
+	if (!strcasecmp(argv[2], "state")) {
+		ccprintf("Port C%d CC%d, %s - Role: %s-%s",
+		port, pd_get_polarity(port) + 1,
+		pd_comm_is_enabled(port) ? "Enable" : "Disable",
+		pd_get_power_role(port) ==
+					PD_ROLE_SOURCE ? "SRC" : "SNK",
+		pd_get_data_role(port) == PD_ROLE_DFP ? "DFP" : "UFP");
+
+		if (IS_ENABLED(CONFIG_USBC_VCONN))
+			ccprintf("%s ", tc_is_vconn_src(port) ? "-VC" : "");
+
+		ccprintf("TC State: %s, Flags: 0x%04x\n",
+			tc_get_current_state(port),
+			tc_get_flags(port));
+	}
+
+	return EC_SUCCESS;
+}
+DECLARE_CONSOLE_COMMAND(pd, command_pd,
+#ifdef CONFIG_USB_PD_TRY_SRC
+	"trysrc [0|1|2]"
+#endif
+	"\n\t<port> state"
+#ifdef CONFIG_USB_PD_DUAL_ROLE
+	"|tx|charger|dev"
+	"\n\t<port> disable|enable|soft|hard"
+	"\n\t<port> dualrole [on|off|freeze|sink|source]"
+	"\n\t<port> swap [power|data|vconn]"
+#endif /* CONFIG_USB_PD_DUAL_ROLE */
+	,
+	"USB PD");
diff --git a/test/fake_usbc.c b/test/fake_usbc.c
index e62fa5ac62..d98e7017f9 100644
--- a/test/fake_usbc.c
+++ b/test/fake_usbc.c
@@ -130,12 +130,17 @@ __overridable void pe_invalidate_explicit_contract(int port)
 {
 }
 
-enum pd_dual_role_states pd_get_dual_role(int port)
+__overridable enum pd_dual_role_states pd_get_dual_role(int port)
 {
 	return PD_DRP_TOGGLE_ON;
 }
 
-int pd_comm_is_enabled(int port)
+__overridable void pd_dev_get_rw_hash(int port, uint16_t *dev_id,
+		uint8_t *rw_hash, uint32_t *current_image)
+{
+}
+
+__overridable int pd_comm_is_enabled(int port)
 {
 	return 0;
 }
@@ -190,11 +195,11 @@ void dfp_consume_cable_response(int port, int cnt, uint32_t *payload,
 {
 }
 
-void pd_set_dual_role(int port, enum pd_dual_role_states state)
+__overridable void pd_set_dual_role(int port, enum pd_dual_role_states state)
 {
 }
 
-enum tcpc_cc_polarity pd_get_polarity(int port)
+__overridable enum tcpc_cc_polarity pd_get_polarity(int port)
 {
 	return POLARITY_CC1;
 }
diff --git a/test/usb_pd_console.c b/test/usb_pd_console.c
new file mode 100644
index 0000000000..82b34d8109
--- /dev/null
+++ b/test/usb_pd_console.c
@@ -0,0 +1,472 @@
+/* Copyright 2020 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.
+ *
+ * Test usb_pd_console
+ */
+
+#include "common.h"
+#include "math.h"
+#include "stdio.h"
+#include "stdlib.h"
+#include "string.h"
+#include "usb_pe_sm.h"
+#include "usb_pd.h"
+#include "usb_tc_sm.h"
+#include "util.h"
+#include "test_util.h"
+
+/* Defined in implementation */
+int hex8tou32(char *str, uint32_t *val);
+int command_pd(int argc, char **argv);
+int remote_flashing(int argc, char **argv);
+
+static enum try_src_override_t try_src_override;
+static int test_port;
+static enum pe_dpm_request request;
+static int max_volt;
+static int comm_enable;
+static int dev_info;
+static int vdm_cmd;
+static int vdm_count;
+static int vdm_vid;
+static uint32_t vdm_data[10];
+static enum pd_dual_role_states dr_state;
+
+/* Mock functions */
+void pe_send_vdm(int port, uint32_t vid, int cmd, const uint32_t *data,
+					int count)
+{
+	int i;
+
+	test_port = port;
+	vdm_cmd = cmd;
+	vdm_count = count;
+	vdm_vid = vid;
+
+	if (data == NULL)
+		for (i = 0; i < 10; i++)
+			vdm_data[i] = -1;
+	else
+		for (i = 0; i < count; i++)
+			vdm_data[i] = data[i];
+}
+
+void pe_dpm_request(int port, enum pe_dpm_request req)
+{
+	test_port = port;
+	request = req;
+}
+
+unsigned int pd_get_max_voltage(void)
+{
+	return 10000;
+}
+
+void pd_request_source_voltage(int port, int mv)
+{
+	test_port = port;
+	max_volt = mv;
+}
+
+void pd_comm_enable(int port, int enable)
+{
+	test_port = port;
+	comm_enable = enable;
+}
+
+void tc_print_dev_info(int port)
+{
+	test_port = port;
+	dev_info = 1;
+}
+
+void pd_set_dual_role(int port, enum pd_dual_role_states state)
+{
+	test_port = port;
+	dr_state = state;
+}
+
+int pd_comm_is_enabled(int port)
+{
+	test_port = port;
+	return 0;
+}
+
+int pd_get_polarity(int port)
+{
+	test_port = port;
+	return 0;
+}
+
+uint32_t tc_get_flags(int port)
+{
+	test_port = port;
+	return 0;
+}
+
+const char *tc_get_current_state(int port)
+{
+	test_port = port;
+	return 0;
+}
+
+void tc_try_src_override(enum try_src_override_t ov)
+{
+	if (IS_ENABLED(CONFIG_USB_PD_TRY_SRC)) {
+		switch (ov) {
+		case TRY_SRC_OVERRIDE_OFF: /* 0 */
+			try_src_override = TRY_SRC_OVERRIDE_OFF;
+			break;
+		case TRY_SRC_OVERRIDE_ON: /* 1 */
+			try_src_override = TRY_SRC_OVERRIDE_ON;
+			break;
+		default:
+			try_src_override = TRY_SRC_NO_OVERRIDE;
+		}
+	}
+}
+
+enum try_src_override_t tc_get_try_src_override(void)
+{
+	return try_src_override;
+}
+
+static int test_hex8tou32(void)
+{
+	char const *tst_str[] = {"01234567", "89abcdef",
+					"AABBCCDD", "EEFF0011"};
+	uint32_t const tst_int[] = {0x01234567, 0x89abcdef,
+					0xaabbccdd, 0xeeff0011};
+	uint32_t val;
+	int i;
+
+	for (i = 0; i < 4; i++) {
+		hex8tou32(tst_str[i], &val);
+		TEST_ASSERT(val == tst_int[i]);
+	}
+
+	return EC_SUCCESS;
+}
+
+static int test_command_pd_arg_count(void)
+{
+	int argc;
+	char const *argv[] = {"pd", "", 0, 0, 0};
+
+	for (argc = 0; argc < 3; argc++)
+		TEST_ASSERT(command_pd(argc, argv) == EC_ERROR_PARAM_COUNT);
+
+	return EC_SUCCESS;
+}
+
+static int test_command_pd_port_num(void)
+{
+	int argc = 3;
+	char const *argv[10] = {"pd", "5", 0, 0, 0};
+
+	TEST_ASSERT(command_pd(argc, argv) == EC_ERROR_PARAM2);
+
+	return EC_SUCCESS;
+}
+
+static int test_command_pd_try_src(void)
+{
+	int argc = 3;
+	char const *argv[] = {"pd", "trysrc", "2", 0, 0};
+
+	try_src_override = 0;
+	TEST_ASSERT(command_pd(argc, argv) == EC_SUCCESS);
+	TEST_ASSERT(try_src_override == TRY_SRC_NO_OVERRIDE);
+
+	argv[2] = "1";
+	TEST_ASSERT(command_pd(argc, argv) == EC_SUCCESS);
+	TEST_ASSERT(try_src_override == TRY_SRC_OVERRIDE_ON);
+
+	argv[2] = "0";
+	TEST_ASSERT(command_pd(argc, argv) == EC_SUCCESS);
+	TEST_ASSERT(try_src_override == TRY_SRC_OVERRIDE_OFF);
+
+	return EC_SUCCESS;
+}
+
+static int test_command_pd_tx(void)
+{
+	int argc = 3;
+	char const *argv[] = {"pd", "0", "tx", 0, 0};
+
+	request = 0;
+	TEST_ASSERT(command_pd(argc, argv) == EC_SUCCESS);
+	TEST_ASSERT(test_port == 0);
+	TEST_ASSERT(request == DPM_REQUEST_SNK_STARTUP);
+
+	return EC_SUCCESS;
+}
+
+static int test_command_pd_charger(void)
+{
+	int argc = 3;
+	char const *argv[] = {"pd", "1", "charger", 0, 0};
+
+	request = 0;
+	TEST_ASSERT(command_pd(argc, argv) == EC_SUCCESS);
+	TEST_ASSERT(test_port == 1);
+	TEST_ASSERT(request == DPM_REQUEST_SRC_STARTUP);
+
+	return EC_SUCCESS;
+}
+
+static int test_command_pd_dev1(void)
+{
+	int argc = 4;
+	char const *argv[] = {"pd", "0", "dev", "20", 0};
+
+	request = 0;
+	max_volt = 0;
+	TEST_ASSERT(command_pd(argc, argv) == EC_SUCCESS);
+	TEST_ASSERT(test_port == 0);
+	TEST_ASSERT(request == DPM_REQUEST_NEW_POWER_LEVEL);
+	TEST_ASSERT(max_volt == 20000);
+
+	return EC_SUCCESS;
+}
+
+static int test_command_pd_dev2(void)
+{
+	int argc = 3;
+	char const *argv[] = {"pd", "1", "dev", 0, 0};
+
+	request = 0;
+	TEST_ASSERT(command_pd(argc, argv) == EC_SUCCESS);
+	TEST_ASSERT(test_port == 1);
+	TEST_ASSERT(request == DPM_REQUEST_NEW_POWER_LEVEL);
+	TEST_ASSERT(max_volt == 10000);
+
+	return EC_SUCCESS;
+}
+
+static int test_command_pd_disable(void)
+{
+	int argc = 3;
+	char const *argv[] = {"pd", "0", "disable", 0, 0};
+
+	comm_enable = 1;
+	TEST_ASSERT(command_pd(argc, argv) == EC_SUCCESS);
+	TEST_ASSERT(test_port == 0);
+	TEST_ASSERT(comm_enable == 0);
+
+	return EC_SUCCESS;
+}
+
+static int test_command_pd_enable(void)
+{
+	int argc = 3;
+	char const *argv[] = {"pd", "1", "enable", 0, 0};
+
+	comm_enable = 0;
+	TEST_ASSERT(command_pd(argc, argv) == EC_SUCCESS);
+	TEST_ASSERT(test_port == 1);
+	TEST_ASSERT(comm_enable == 1);
+
+	return EC_SUCCESS;
+}
+
+static int test_command_pd_hard(void)
+{
+	int argc = 3;
+	char const *argv[] = {"pd", "0", "hard", 0, 0};
+
+	request = 0;
+	TEST_ASSERT(command_pd(argc, argv) == EC_SUCCESS);
+	TEST_ASSERT(test_port == 0);
+	TEST_ASSERT(request == DPM_REQUEST_HARD_RESET_SEND);
+
+	return EC_SUCCESS;
+}
+
+static int test_command_pd_soft(void)
+{
+	int argc = 3;
+	char const *argv[] = {"pd", "0", "soft", 0, 0};
+
+	request = 0;
+	TEST_ASSERT(command_pd(argc, argv) == EC_SUCCESS);
+	TEST_ASSERT(test_port == 0);
+	TEST_ASSERT(request == DPM_REQUEST_SOFT_RESET_SEND);
+
+	return EC_SUCCESS;
+}
+
+static int test_command_pd_swap1(void)
+{
+	int argc = 3;
+	char const *argv[] = {"pd", "0", "swap", 0, 0};
+
+	TEST_ASSERT(command_pd(argc, argv) == EC_ERROR_PARAM_COUNT);
+
+	return EC_SUCCESS;
+}
+
+static int test_command_pd_swap2(void)
+{
+	int argc = 4;
+	char const *argv[] = {"pd", "0", "swap", "power", 0};
+
+	request = 0;
+	TEST_ASSERT(command_pd(argc, argv) == EC_SUCCESS);
+	TEST_ASSERT(test_port == 0);
+	TEST_ASSERT(request == DPM_REQUEST_PR_SWAP);
+
+	return EC_SUCCESS;
+}
+
+static int test_command_pd_swap3(void)
+{
+	int argc = 4;
+	char const *argv[] = {"pd", "1", "swap", "data", 0};
+
+	request = 0;
+	TEST_ASSERT(command_pd(argc, argv) == EC_SUCCESS);
+	TEST_ASSERT(test_port == 1);
+	TEST_ASSERT(request == DPM_REQUEST_DR_SWAP);
+
+	return EC_SUCCESS;
+}
+
+static int test_command_pd_swap4(void)
+{
+	int argc = 4;
+	char const *argv[] = {"pd", "0", "swap", "vconn", 0};
+
+	request = 0;
+	TEST_ASSERT(command_pd(argc, argv) == EC_SUCCESS);
+	TEST_ASSERT(test_port == 0);
+	TEST_ASSERT(request == DPM_REQUEST_VCONN_SWAP);
+
+	return EC_SUCCESS;
+}
+
+static int test_command_pd_swap5(void)
+{
+	int argc = 4;
+	char const *argv[] = {"pd", "0", "swap", "xyz", 0};
+
+	TEST_ASSERT(command_pd(argc, argv) == EC_ERROR_PARAM3);
+
+	return EC_SUCCESS;
+}
+
+static int test_command_pd_dualrole1(void)
+{
+	int argc = 4;
+	char const *argv[] = {"pd", "0", "dualrole", "on", 0};
+
+	dr_state = 0;
+	TEST_ASSERT(command_pd(argc, argv) == EC_SUCCESS);
+	TEST_ASSERT(test_port == 0);
+	TEST_ASSERT(dr_state == PD_DRP_TOGGLE_ON);
+
+	return EC_SUCCESS;
+}
+
+static int test_command_pd_dualrole2(void)
+{
+	int argc = 4;
+	char const *argv[] = {"pd", "0", "dualrole", "off", 0};
+
+	dr_state = 0;
+	TEST_ASSERT(command_pd(argc, argv) == EC_SUCCESS);
+	TEST_ASSERT(test_port == 0);
+	TEST_ASSERT(dr_state == PD_DRP_TOGGLE_OFF);
+
+	return EC_SUCCESS;
+}
+
+static int test_command_pd_dualrole3(void)
+{
+	int argc = 4;
+	char const *argv[] = {"pd", "0", "dualrole", "freeze", 0};
+
+	dr_state = 0;
+	TEST_ASSERT(command_pd(argc, argv) == EC_SUCCESS);
+	TEST_ASSERT(test_port == 0);
+	TEST_ASSERT(dr_state == PD_DRP_FREEZE);
+
+	return EC_SUCCESS;
+}
+
+static int test_command_pd_dualrole4(void)
+{
+	int argc = 4;
+	char const *argv[] = {"pd", "0", "dualrole", "sink", 0};
+
+	dr_state = 0;
+	TEST_ASSERT(command_pd(argc, argv) == EC_SUCCESS);
+	TEST_ASSERT(test_port == 0);
+	TEST_ASSERT(dr_state == PD_DRP_FORCE_SINK);
+
+	return EC_SUCCESS;
+}
+
+static int test_command_pd_dualrole5(void)
+{
+	int argc = 4;
+	char const *argv[] = {"pd", "0", "dualrole", "source", 0};
+
+	dr_state = 0;
+	TEST_ASSERT(command_pd(argc, argv) == EC_SUCCESS);
+	TEST_ASSERT(test_port == 0);
+	TEST_ASSERT(dr_state == PD_DRP_FORCE_SOURCE);
+
+	return EC_SUCCESS;
+}
+
+
+void run_test(void)
+{
+	test_reset();
+
+	RUN_TEST(test_hex8tou32);
+	RUN_TEST(test_command_pd_arg_count);
+	RUN_TEST(test_command_pd_port_num);
+	RUN_TEST(test_command_pd_try_src);
+	RUN_TEST(test_command_pd_tx);
+	RUN_TEST(test_command_pd_bist_tx);
+	RUN_TEST(test_command_pd_bist_rx);
+	RUN_TEST(test_command_pd_charger);
+	RUN_TEST(test_command_pd_dev1);
+	RUN_TEST(test_command_pd_dev2);
+	RUN_TEST(test_command_pd_disable);
+	RUN_TEST(test_command_pd_enable);
+	RUN_TEST(test_command_pd_hard);
+	RUN_TEST(test_command_pd_info);
+	RUN_TEST(test_command_pd_soft);
+	RUN_TEST(test_command_pd_swap1);
+	RUN_TEST(test_command_pd_swap2);
+	RUN_TEST(test_command_pd_swap3);
+	RUN_TEST(test_command_pd_swap4);
+	RUN_TEST(test_command_pd_swap5);
+	RUN_TEST(test_command_pd_ping);
+	RUN_TEST(test_command_pd_vdm1);
+	RUN_TEST(test_command_pd_vdm2);
+	RUN_TEST(test_command_pd_vdm3);
+	RUN_TEST(test_command_pd_vdm4);
+	RUN_TEST(test_command_pd_vdm5);
+	RUN_TEST(test_command_pd_vdm6);
+	RUN_TEST(test_command_pd_flash1);
+	RUN_TEST(test_command_pd_flash2);
+	RUN_TEST(test_command_pd_flash3);
+	RUN_TEST(test_command_pd_flash4);
+	RUN_TEST(test_command_pd_flash5);
+	RUN_TEST(test_command_pd_flash6);
+	RUN_TEST(test_command_pd_flash7);
+	RUN_TEST(test_command_pd_flash8);
+	RUN_TEST(test_command_pd_dualrole1);
+	RUN_TEST(test_command_pd_dualrole2);
+	RUN_TEST(test_command_pd_dualrole3);
+	RUN_TEST(test_command_pd_dualrole4);
+	RUN_TEST(test_command_pd_dualrole5);
+
+	test_print_result();
+}
+