| # 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 Plankton test board. It requires that the DUT support |
| dualrole (SRC or SNK) operation. VBUS change requests occur in two |
| methods. First, with the DUT in SNK mode, it uses the pd console command |
| 'pd 0/1 dev V' command where V is the desired voltage 5/12/20. The 2nd |
| test initiates the VBUS change by using special Plankton feature to |
| send new SRC CAP message. This causes the DUT to request a new VBUS |
| voltage mathcing what's in the SRC CAP message. |
| |
| Pass critera is all voltage transitions are successful. |
| |
| """ |
| version = 1 |
| |
| PD_SETTLE_DELAY = 4 |
| USBC_SINK_VOLTAGE = 5 |
| USBC_MAX_VOLTAGE = 20 |
| VBUS_TOLERANCE = 0.12 |
| |
| VOLTAGE_SEQUENCE = [5, 12, 20, 12, 5, 20, 5, 5, 12, 12, 20] |
| |
| def _compare_vbus(self, expected_vbus_voltage): |
| """Check VBUS using plankton |
| |
| @param expected_vbus_voltage: nominal VBUS level (in volts) |
| |
| @returns: a tuple containing pass/fail indication and logging string |
| """ |
| # Get Vbus voltage and current |
| vbus_voltage = self.plankton.vbus_voltage |
| vbus_current = self.plankton.vbus_current |
| # Compute voltage tolerance range |
| tolerance = self.VBUS_TOLERANCE * 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 |
| voltage_difference = math.fabs(expected_vbus_voltage - vbus_voltage) |
| if voltage_difference > tolerance: |
| result = 'FAIL' |
| else: |
| result = 'PASS' |
| return result, result_str |
| |
| def initialize(self, host, cmdline_args): |
| super(firmware_PDVbusRequest, self).initialize(host, cmdline_args) |
| # Only run in normal mode |
| self.switcher.setup_mode('normal') |
| self.usbpd.send_command('chan 0') |
| |
| def cleanup(self): |
| self.usbpd.send_command('chan 0xffffffff') |
| super(firmware_PDVbusRequest, self).cleanup() |
| |
| def run_once(self): |
| """Exectue VBUS request test. |
| |
| """ |
| |
| # create objects for pd utilities |
| pd_dut_utils = pd_console.PDConsoleUtils(self.usbpd) |
| pd_plankton_utils = pd_console.PDConsoleUtils(self.plankton) |
| |
| # 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() |
| logging.info('DUT PD connection state: %r', dut_state) |
| if dut_state['connect'] == False: |
| raise error.TestFail("pd connection not found") |
| if dut_state['role'] != pd_dut_utils.SNK_CONNECT: |
| # DUT needs to be in SINK Mode, attempt to force change |
| pd_dut_utils.set_pd_dualrole('snk') |
| time.sleep(self.PD_SETTLE_DELAY) |
| if pd_dut_utils.get_pd_state(dut_state['port']) != pd_dut_utils.SNK_CONNECT: |
| raise error.TestFail("DUT not able to connect in SINK mode") |
| |
| # Plankton must be set to 20V SRC mode in order for the DUT |
| # to be able to request all 3 possible voltage levels (5, 12, 20). |
| # The DUT must be in SNK mode for the pd <port> dev <voltage> |
| # command to have an effect. |
| self.plankton.charge(self.USBC_MAX_VOLTAGE) |
| time.sleep(self.PD_SETTLE_DELAY) |
| logging.info('Start of DUT initiated tests') |
| dut_failures = [] |
| for v in self.VOLTAGE_SEQUENCE: |
| # Build 'pd <port> dev <voltage> command |
| cmd = 'pd %d dev %d' % (dut_state['port'], v) |
| pd_dut_utils.send_pd_command(cmd) |
| time.sleep(self.PD_SETTLE_DELAY) |
| result, result_str = self._compare_vbus(v) |
| logging.info('%s, %s', result_str, result) |
| if result == 'FAIL': |
| dut_failures.append(result_str) |
| |
| # Make sure Plankton is set back to 20VSRC so DUT will accept all options |
| cmd = 'pd %d dev %d' % (dut_state['port'], self.USBC_MAX_VOLTAGE) |
| time.sleep(self.PD_SETTLE_DELAY) |
| # The next group of tests need DUT to connect in SNK and SRC modes |
| pd_dut_utils.set_pd_dualrole('on') |
| |
| plankton_failures = [] |
| logging.info('Start Plankton initiated tests') |
| for voltage in self.plankton.get_charging_voltages(): |
| logging.info('********* %r *********', voltage) |
| # Set charging voltage |
| self.plankton.charge(voltage) |
| # Wait for new PD contract to be established |
| time.sleep(self.PD_SETTLE_DELAY) |
| # Get current Plankton PD state |
| plankton_state = pd_plankton_utils.get_pd_state(0) |
| expected_vbus_voltage = self.plankton.charging_voltage |
| # If Plankton is sink, then Vbus_exp = 5v |
| if plankton_state == pd_plankton_utils.SNK_CONNECT: |
| expected_vbus_voltage = self.USBC_SINK_VOLTAGE |
| result, result_str = self._compare_vbus(expected_vbus_voltage) |
| logging.info('%s, %s', result_str, result) |
| if result == 'FAIL': |
| plankton_failures.append(result_str) |
| |
| if dut_failures: |
| logging.error('DUT voltage request failures') |
| for fail in dut_failures: |
| logging.error('%s', fail) |
| |
| if plankton_failures: |
| logging.error('Plankton voltage source cap failures') |
| for fail in plankton_failures: |
| logging.error('%s', fail) |
| |
| if dut_failures or plankton_failures: |
| if dut_failures and plankton_failures: |
| test = 'DUT and Plankton' |
| number = len(dut_failures) + len(plankton_failures) |
| elif dut_failures: |
| test = 'DUT' |
| number = len(dut_failures) |
| else: |
| test = 'Plankton' |
| number = len(plankton_failures) |
| raise error.TestFail('%s failed %d times' % (test, number)) |
