| # 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 random |
| 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_device |
| |
| |
| class firmware_PDTrySrc(FirmwareTest): |
| """ |
| Servo based USB PD Try.SRC protocol test. |
| |
| When a PD device supports Try.SRC mode and it's enabled, it will attempt |
| to always connect as a SRC device. This test is therefore only applicable |
| if both devices support dualrole and at least one device supports Try.SRC. |
| |
| Pass criteria is that when Try.SRC is enabled the device connects > 95% of |
| the time in SRC mode. When it is disabled, there must be at least 25% |
| variation in connecting as SRC and SNK. |
| """ |
| version = 1 |
| |
| CONNECT_ITERATIONS = 20 |
| PD_DISCONNECT_TIME = 1 |
| PD_CONNECT_DELAY = 4 |
| SNK = 0 |
| SRC = 1 |
| TRYSRC_OFF_THRESHOLD = 15.0 |
| TRYSRC_ON_THRESHOLD = 96.0 |
| |
| def _execute_connect_sequence(self, device): |
| """Execute mulitple connections and track power role |
| |
| This method will disconnect/connect a TypeC PD port and |
| collect the power role statistics of each connection. The time |
| delay for reconnect adds a random delay so that test to increase |
| randomness for dualrole swaps. |
| |
| @param device: PD device object |
| |
| @returns list with number of SNK and SRC connections |
| """ |
| stats = [0, 0] |
| random.seed() |
| # Try N disconnect/connects |
| for attempt in xrange(self.CONNECT_ITERATIONS): |
| try: |
| # Disconnect time from 1 to 2 seconds |
| disc_time = self.PD_DISCONNECT_TIME + random.random() |
| logging.info('Disconnect time = %.2f seconds', disc_time) |
| # Force disconnect/connect |
| device.cc_disconnect_connect(disc_time) |
| # Wait for connection to be reestablished |
| time.sleep(self.PD_DISCONNECT_TIME + self.PD_CONNECT_DELAY) |
| # Check power role and update connection stats |
| if device.is_snk(): |
| stats[self.SNK] += 1; |
| logging.info('Power Role = SNK') |
| elif device.is_src(): |
| stats[self.SRC] += 1; |
| logging.info('Power Role = SRC') |
| except NotImplementedError: |
| raise error.TestFail('TrySRC disconnect requires Plankton') |
| logging.info('SNK = %d: SRC = %d: Total = %d', |
| stats[0], stats[1], self.CONNECT_ITERATIONS) |
| return stats |
| |
| def initialize(self, host, cmdline_args): |
| super(firmware_PDTrySrc, self).initialize(host, cmdline_args) |
| # Only run in normal mode |
| self.switcher.setup_mode('normal') |
| # Turn off console prints, except for USBPD. |
| self.usbpd.send_command('chan 0x08000000') |
| |
| def cleanup(self): |
| self.usbpd.send_command('chan 0xffffffff') |
| super(firmware_PDTrySrc, self).cleanup() |
| |
| def run_once(self): |
| """Execute Try.SRC PD protocol test |
| |
| 1. Verify that DUT <-> Plankton device pair exists |
| 2. Verify that DUT supports dualrole |
| 3. Verify that DUT supports Try.SRC mode |
| 4. Enable Try.SRC mode, execute disc/connect sequences |
| 5. Disable Try.SRC mode, execute disc/connect sequences |
| 6. Compute DUT SRC/SNK connect ratios for both modes |
| 7. Compare SRC connect ratio to threholds to determine pass/fail |
| """ |
| |
| # Create list of available UART consoles |
| consoles = [self.usbpd, self.plankton] |
| port_partner = pd_device.PDPortPartner(consoles) |
| # Identify Plankton <-> DUT PD device pair |
| port_pair = port_partner.identify_pd_devices() |
| if not port_pair: |
| raise error.TestFail('No DUT to Plankton connection found!') |
| |
| # TODO Device pair must have Plankton so that the disconnect/connect |
| # sequence does not affect the SRC/SNK connection. Plankton provides |
| # a 'fake_disconnect' feature which more closely resembles unplugging |
| # and replugging a Type C cable. |
| |
| # Both devices must support dualrole mode for this test. In addtion, |
| # at least one device must support Try.SRC mode. |
| for side in xrange(len(port_pair)): |
| try: |
| if not port_pair[side].drp_set('on'): |
| raise error.TestFail('Could not enable DRP') |
| except NotImplementedError: |
| raise error.TestFail('Both devices must support DRP') |
| if port_pair[side].is_plankton: |
| # Identify Plankton and DUT device |
| p_idx = side |
| d_idx = side ^ 1 |
| |
| # Make sure that DUT supports Try.SRC mode |
| if not port_pair[d_idx].try_src(True): |
| raise error.TestFail('DUT does not support Try.SRC feature') |
| # Run disconnect/connect sequence with Try.SRC enabled |
| stats_on = self._execute_connect_sequence(port_pair[p_idx]) |
| # Disable Try.SRC mode |
| port_pair[d_idx].try_src(False) |
| # Run disconnect/connect sequence with Try.SRC disabled |
| stats_off = self._execute_connect_sequence(port_pair[p_idx]) |
| # Reenable Try.SRC mode |
| port_pair[d_idx].try_src(True) |
| |
| # Compute SRC connect ratio/percent for Try.SRC on and off cases |
| total_on = float(stats_on[self.SNK] + stats_on[self.SRC]) |
| total_off = float(stats_off[self.SNK] + stats_off[self.SRC]) |
| trysrc_on = float(stats_on[self.SNK]) / total_on * 100.0 |
| trysrc_off = float(stats_off[self.SNK]) / total_off * 100.0 |
| logging.info('DUT Try.SRC on = %.1f%%: off = %.1f%%', |
| trysrc_off, trysrc_on) |
| |
| # When Try.SRC is off, ideally the SNK/SRC ratio will be close to |
| # 50%. However, in practice there is a wide range related to the |
| # dualrole swap timers in firmware. |
| if (trysrc_off < self.TRYSRC_OFF_THRESHOLD or |
| trysrc_off > 100 - self.TRYSRC_OFF_THRESHOLD): |
| raise error.TestFail('SRC %% = %.1f: Must be > %.1f & < %.1f' % |
| (trysrc_off, self.TRYSRC_OFF_THRESHOLD, |
| 100 - self.TRYSRC_OFF_THRESHOLD)) |
| # When Try.SRC is on, the SRC/SNK, the DUT should connect in SRC |
| # mode nearly 100% of the time. |
| if trysrc_on < self.TRYSRC_ON_THRESHOLD: |
| raise error.TestFail('SRC %% = %.1f: Must be > %.1f' % |
| (trysrc_on, self.TRYSRC_ON_THRESHOLD)) |
| |
