473 lines
9.8 KiB
C
473 lines
9.8 KiB
C
/* 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 pd_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 pd_dpm_request(int port, enum pd_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(int argc, char **argv)
|
|
{
|
|
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();
|
|
}
|
|
|