blob: 8ffad56652c9ca757ae7916cc15b35e9c128a45d [file] [log] [blame]
# Copyright 2016 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.
import logging
import math
import time
from autotest_lib.client.common_lib import error
from autotest_lib.server.cros.faft.firmware_test import FirmwareTest
from autotest_lib.server.cros.servo import pd_console
class firmware_PDVbusRequest(FirmwareTest):
Servo based USB PD VBUS level test. This test is written to use both
the DUT and PDTester test board. It requires that the DUT support
dualrole (SRC or SNK) operation. VBUS change requests occur in two
The 1st test initiates the VBUS change by using special PDTester
feature to send new SRC CAP message. This causes the DUT to request
a new VBUS voltage matching what's in the SRC CAP message.
The 2nd test configures the DUT in SNK mode and uses the pd console
command 'pd 0/1 dev V' command where V is the desired voltage
5/12/20. This test is more risky and won't be executed if the 1st
test is failed. If the DUT max input voltage is not 20V, like 12V,
and the FAFT config is set wrong, it may negotiate to a voltage
higher than it can support, that may damage the DUT.
Pass critera is all voltage transitions are successful.
version = 1
VOLTAGE_SEQUENCE = [5, 9, 10, 12, 15, 20, 15, 12, 9, 5, 20,
5, 5, 9, 9, 10, 10, 12, 12, 15, 15, 20]
def _compare_vbus(self, expected_vbus_voltage, ok_to_fail):
"""Check VBUS using pdtester
@param expected_vbus_voltage: nominal VBUS level (in volts)
@param ok_to_fail: True to not treat voltage-not-matched as failure.
@returns: a tuple containing pass/fail indication and logging string
# Get Vbus voltage and current
vbus_voltage = self.pdtester.vbus_voltage
# Compute voltage tolerance range. To handle the case where VBUS is
# off, set the minimal tolerance to USBC_SINK_VOLTAGE * VBUS_TOLERANCE.
tolerance = (self.VBUS_TOLERANCE * max(expected_vbus_voltage,
voltage_difference = math.fabs(expected_vbus_voltage - vbus_voltage)
result_str = 'Target = %02dV:\tAct = %.2f\tDelta = %.2f' % \
(expected_vbus_voltage, vbus_voltage, voltage_difference)
# Verify that measured Vbus voltage is within expected range
if voltage_difference > tolerance:
result = 'ALLOWED_FAIL' if ok_to_fail else 'FAIL'
result = 'PASS'
return result, result_str
def initialize(self, host, cmdline_args, flip_cc=False, dts_mode=False,
super(firmware_PDVbusRequest, self).initialize(host, cmdline_args)
self.setup_pdtester(flip_cc, dts_mode)
# Only run in normal mode
if init_power_mode:
# Set the DUT to suspend or shutdown mode
self.usbpd.send_command('chan 0')
def cleanup(self):
# Set back to the max 20V SRC mode at the end.
self.usbpd.send_command('chan 0xffffffff')
super(firmware_PDVbusRequest, self).cleanup()
def run_once(self):
"""Exectue VBUS request test.
# TODO(b/35573842): Refactor to use PDPortPartner to probe the port
self.pdtester_port = 1 if 'servo_v4' in self.pdtester.servo_type else 0
# create objects for pd utilities
pd_dut_utils = pd_console.create_pd_console_utils(self.usbpd)
pd_pdtester_utils = pd_console.create_pd_console_utils(self.pdtester)
# Make sure PD support exists in the UART console
if pd_dut_utils.verify_pd_console() == False:
raise error.TestFail("pd command not present on console!")
# Type C connection (PD contract) should exist at this point
dut_state = pd_dut_utils.query_pd_connection()'DUT PD connection state: %r', dut_state)
if dut_state['connect'] == False:
raise error.TestFail("pd connection not found")
dut_voltage_limit = self.faft_config.usbc_input_voltage_limit
is_override = self.faft_config.charger_profile_override
if is_override:'*** Custom charger profile takes over, which may '
'cause voltage-not-matched. It is OK to fail. *** ')
pdtester_failures = []'Start PDTester initiated tests')
charging_voltages = self.pdtester.get_charging_voltages()
if dut_voltage_limit not in charging_voltages:
raise error.TestError('Plugged a wrong charger to servo v4? '
'%dV not in supported voltages %s.' %
(dut_voltage_limit, str(charging_voltages)))
for voltage in charging_voltages:'********* %r *********', voltage)
# Set charging voltage
# Wait for new PD contract to be established
# Get current PDTester PD state
pdtester_state = pd_pdtester_utils.get_pd_state(self.pdtester_port)
# If PDTester is in SNK mode and the DUT is in S0, the DUT should
# source VBUS = USBC_SINK_VOLTAGE. If PDTester is in SNK mode, and
# the DUT is not in S0, the DUT shouldn't source VBUS, which means
# VBUS = 0.
if pdtester_state == pd_pdtester_utils.SNK_CONNECT:
expected_vbus_voltage = (self.USBC_SINK_VOLTAGE
if self.get_power_state() == 'S0' else 0)
ok_to_fail = False
expected_vbus_voltage = min(voltage, dut_voltage_limit)
ok_to_fail = is_override
result, result_str = self._compare_vbus(expected_vbus_voltage,
ok_to_fail)'%s, %s', result_str, result)
if result == 'FAIL':
# PDTester is set back to 20V SRC mode.
if pdtester_failures:
logging.error('PDTester voltage source cap failures')
for fail in pdtester_failures:
logging.error('%s', fail)
number = len(pdtester_failures)
raise error.TestFail('PDTester failed %d times' % number)
# The DUT must be in SNK mode for the pd <port> dev <voltage>
# command to have an effect.
if not pd_dut_utils.is_snk_connected(dut_state['port']):
# DUT needs to be in SINK Mode, attempt to force change
pd_dut_utils.set_pd_dualrole(dut_state['port'], 'snk')
if not pd_dut_utils.is_snk_connected(dut_state['port']):
raise error.TestFail("DUT not able to connect in SINK mode")'Start of DUT initiated tests')
dut_failures = []
for v in self.VOLTAGE_SEQUENCE:
if v > dut_voltage_limit:'Target = %02dV: skipped, over the limit %0dV',
v, dut_voltage_limit)
if v not in charging_voltages:'Target = %02dV: skipped, voltage unsupported, '
'update hdctools and servo_v4 firmware', v)
# Build 'pd <port> dev <voltage> command
cmd = 'pd %d dev %d' % (dut_state['port'], v)
result, result_str = self._compare_vbus(v, ok_to_fail=is_override)'%s, %s', result_str, result)
if result == 'FAIL':
# Make sure DUT is set back to its max voltage so DUT will accept all
# options
cmd = 'pd %d dev %d' % (dut_state['port'], dut_voltage_limit)
# The next group of tests need DUT to connect in SNK and SRC modes
pd_dut_utils.set_pd_dualrole(dut_state['port'], 'on')
if dut_failures:
logging.error('DUT voltage request failures')
for fail in dut_failures:
logging.error('%s', fail)
number = len(dut_failures)
raise error.TestFail('DUT failed %d times' % number)