| # 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 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_PDPowerSwap(FirmwareTest): |
| """ |
| Servo based USB PD power role swap test. |
| |
| Pass critera is all power role swaps are successful if the DUT |
| is dualrole capable. If not dualrole, then pass criteria is |
| the DUT sending a reject message in response to swap request. |
| |
| """ |
| |
| version = 1 |
| PD_ROLE_DELAY = 1 |
| PD_CONNECT_DELAY = 10 |
| # Should be an even number; back to the original state at the end |
| POWER_SWAP_ITERATIONS = 10 |
| |
| def _set_pdtester_power_role_to_src(self): |
| """Force PDTester to act as a source |
| |
| @returns True if PDTester power role is source, false otherwise |
| """ |
| PDTESTER_SRC_VOLTAGE = 20 |
| self.pdtester.charge(PDTESTER_SRC_VOLTAGE) |
| # Wait for change to take place |
| time.sleep(self.PD_CONNECT_DELAY) |
| # Current PDTester power role should be source |
| return self.pdtester_port.is_src() |
| |
| def _send_power_swap_get_reply(self, port): |
| """Send power swap request, get PD control msg reply |
| |
| The PD console debug mode is enabled prior to sending |
| a pd power role swap request message. This allows the |
| control message reply to be extracted. The debug mode |
| is disabled prior to exiting. |
| |
| @param port: pd device object |
| |
| @returns: PD control header message |
| """ |
| # Enable PD console debug mode to show control messages |
| port.utils.enable_pd_console_debug() |
| cmd = 'pd %d swap power' % port.port |
| m = port.utils.send_pd_command_get_output(cmd, ['RECV\s([\w]+)']) |
| ctrl_msg = int(m[0][1], 16) & port.utils.PD_CONTROL_MSG_MASK |
| port.utils.disable_pd_console_debug() |
| return ctrl_msg |
| |
| def _attempt_power_swap(self, direction): |
| """Perform a power role swap request |
| |
| Initiate a power role swap request on either the DUT or |
| PDTester depending on the direction parameter. The power |
| role swap is then verified to have taken place. |
| |
| @param direction: rx or tx from the DUT perspective |
| |
| @returns True if power swap is successful |
| """ |
| # Get DUT current power role |
| dut_pr = self.dut_port.get_pd_state() |
| if direction == 'rx': |
| port = self.pdtester_port |
| else: |
| port = self.dut_port |
| # Send power swap request |
| self._send_power_swap_get_reply(port) |
| time.sleep(self.PD_CONNECT_DELAY) |
| # Get PDTester power role |
| pdtester_pr = self.pdtester_port.get_pd_state() |
| if self.dut_port.is_src(dut_pr) and self.pdtester_port.is_src(pdtester_pr): |
| return True |
| elif self.dut_port.is_snk(dut_pr) and self.pdtester_port.is_snk(pdtester_pr): |
| return True |
| else: |
| return False |
| |
| def _test_power_swap_reject(self): |
| """Verify that a power swap request is rejected |
| |
| This tests the case where the DUT isn't in dualrole mode. |
| A power swap request is sent by PDTester, and then |
| the control message checked to ensure the request was rejected. |
| In addition, the connection state is verified to not have |
| changed. |
| """ |
| # Get current DUT power role |
| dut_power_role = self.dut_port.get_pd_state() |
| # Send swap command from PDTester and get reply |
| ctrl_msg = self._send_power_swap_get_reply(self.pdtester_port) |
| if ctrl_msg != self.dut_port.utils.PD_CONTROL_MSG_DICT['Reject']: |
| raise error.TestFail('Power Swap Req not rejected, returned %r' % |
| ctrl_msg) |
| # Get DUT current state |
| pd_state = self.dut_port.get_pd_state() |
| if pd_state != dut_power_role: |
| raise error.TestFail('PD not connected! pd_state = %r' % |
| pd_state) |
| |
| def _test_one_way_power_swap_in_suspend(self): |
| """Verify SRC-to-SNK power role swap on DUT PD port in S0ix/S3 |
| |
| Set the DUT power role to source and then suspend the DUT. |
| Verify SRC-to-SNK power role request from the PD tester works, |
| while SNK-to-SRC power role request fails. Note that this is |
| Chrome OS policy decision, not part of the PD spec. |
| |
| When DUT doesn't provide power in suspend, set DUT power role |
| to sink, supend DUT and check if SNK-to-SRC power role request fails. |
| |
| """ |
| # Ensure DUT PD port is sourcing power. |
| time.sleep(self.PD_CONNECT_DELAY) |
| if self.faft_config.dut_can_source_power_in_suspend: |
| if not self.dut_port.is_src(): |
| if self._attempt_power_swap('rx') == False or not self.dut_port.is_src(): |
| raise error.TestFail('Fail to set DUT power role to source.') |
| |
| self.set_ap_off_power_mode('suspend') |
| |
| new_state = self.dut_port.get_pd_state() |
| if not self.dut_port.is_src(new_state): |
| raise error.TestFail('DUT power role changed to %s ' |
| 'during S0-to-S3 transition!' % new_state) |
| |
| # If the DUT PD port supports DRP in S0, it should supports SRC-to-SNK |
| # power role swap in suspend mode. The other way around (SNK-to-SRC) in |
| # suspend mode should fail. |
| logging.info('Request a SRC-to-SNK power role swap to DUT PD port ' |
| 'in suspend mode. Expect to succeed.') |
| if self._attempt_power_swap('rx') == False: |
| raise error.TestFail('SRC-to-SNK power role swap failed.') |
| |
| # If we define AC insertion as a wake source for this board, the |
| # SRC-to-SNK power role swap would wake up the DUT. In this case, |
| # we need to suspend the DUT again to proceed the test. |
| if self.wait_power_state(self.POWER_STATE_S0, |
| self.DEFAULT_PWR_RETRIES): |
| self.set_ap_off_power_mode('suspend') |
| else: |
| # If DUT can't source power in suspend we are going to test only if |
| # SNK-to-SRC transition fails, so make sure that port acts as sink |
| logging.info('DUT is not sourcing power in suspend - ' |
| 'skip verification if SRC-to-SNK power swap works') |
| if not self.dut_port.is_snk(): |
| if self._attempt_power_swap('rx') == False or not self.dut_port.is_snk(): |
| raise error.TestFail('Fail to set DUT power role to sink.') |
| |
| self.set_ap_off_power_mode('suspend') |
| |
| new_state = self.dut_port.get_pd_state() |
| if not self.dut_port.is_snk(new_state): |
| raise error.TestFail('DUT power role changed to %s ' |
| 'during S0-to-S3 transition!' % new_state) |
| |
| logging.info('Request a SNK-to-SRC power role swap to DUT PD port ' |
| 'in suspend mode. Expect to fail.') |
| self._test_power_swap_reject() |
| |
| self.restore_ap_on_power_mode() |
| |
| def initialize(self, host, cmdline_args, flip_cc=False, dts_mode=False, |
| init_power_mode=None): |
| super(firmware_PDPowerSwap, self).initialize(host, cmdline_args) |
| self.setup_pdtester(flip_cc, dts_mode, min_batt_level=10) |
| # Only run in normal mode |
| self.switcher.setup_mode('normal') |
| if init_power_mode: |
| # Set the DUT to suspend (S3) or shutdown (G3/S5) mode |
| self.set_ap_off_power_mode(init_power_mode) |
| # Turn off console prints, except for USBPD. |
| self.usbpd.enable_console_channel('usbpd') |
| |
| def cleanup(self): |
| if hasattr(self, 'pd_port'): |
| # Restore DUT dual role operation |
| self.dut_port.drp_set('on') |
| if hasattr(self, 'pdtester_port'): |
| # Set connection back to default arrangement |
| self.pdtester_port.drp_set('off') |
| |
| if hasattr(self, 'pd_port') and hasattr(self, 'pdtester_port'): |
| # Fake-disconnect to restore the original power role |
| self.pdtester_port.utils.send_pd_command('fakedisconnect 100 1000') |
| |
| self.usbpd.send_command('chan 0xffffffff') |
| self.restore_ap_on_power_mode() |
| super(firmware_PDPowerSwap, self).cleanup() |
| |
| def run_once(self): |
| """Execute Power Role swap test. |
| |
| 1. Verify that pd console is accessible |
| 2. Verify that DUT has a valid PD contract and connected to PDTester |
| 3. Determine if DUT is in dualrole mode |
| 4. If dualrole mode is not supported, verify DUT rejects power swap |
| request. If dualrole mode is supported, test power swap (tx/rx) in |
| S0 and one-way power swap (SRC-to-SNK on DUT PD port) in S3/S0ix. |
| Then force DUT to be sink or source only and verify rejection of |
| power swap request. |
| |
| """ |
| # Create list of available UART consoles |
| consoles = [self.usbpd, self.pdtester] |
| port_partner = pd_device.PDPortPartner(consoles) |
| |
| # Identify a valid test port pair |
| port_pair = port_partner.identify_pd_devices() |
| if not port_pair: |
| raise error.TestFail('No PD connection found!') |
| |
| for port in port_pair: |
| if port.is_pdtester: |
| self.pdtester_port = port |
| else: |
| self.dut_port = port |
| |
| dut_connect_state = self.dut_port.get_pd_state() |
| logging.info('Initial DUT connect state = %s', dut_connect_state) |
| |
| # Get DUT dualrole status |
| if self.dut_port.is_drp() == False: |
| # DUT does not support dualrole mode, power swap |
| # requests to the DUT should be rejected. |
| logging.info('Power Swap support not advertised by DUT') |
| self._test_power_swap_reject() |
| logging.info('Power Swap request rejected by DUT as expected') |
| else: |
| if self.get_power_state() != 'S0': |
| raise error.TestFail('If the DUT is not is S0, the DUT port ' |
| 'shouldn\'t claim dualrole is enabled.') |
| # Start with PDTester as source |
| if self._set_pdtester_power_role_to_src() == False: |
| raise error.TestFail('PDTester not set to source') |
| # DUT is dualrole in dual role mode. Test power role swap |
| # operation intiated both by the DUT and PDTester. |
| success = 0 |
| for attempt in xrange(self.POWER_SWAP_ITERATIONS): |
| if attempt & 1: |
| direction = 'rx' |
| else: |
| direction = 'tx' |
| if self._attempt_power_swap(direction): |
| success += 1 |
| new_state = self.dut_port.get_pd_state() |
| logging.info('New DUT power role = %s', new_state) |
| |
| if success != self.POWER_SWAP_ITERATIONS: |
| raise error.TestFail('Failed %r power swap attempts' % |
| (self.POWER_SWAP_ITERATIONS - success)) |
| |
| self._test_one_way_power_swap_in_suspend() |
| |
| # Force DUT to only support current power role |
| if self.dut_port.is_src(new_state): |
| dual_mode = 'src' |
| else: |
| dual_mode = 'snk' |
| |
| # Save current dual role setting |
| current_dual_role = self.dut_port.drp_get() |
| |
| try: |
| logging.info('Setting dualrole mode to %s', dual_mode) |
| self.dut_port.drp_set(dual_mode) |
| time.sleep(self.PD_ROLE_DELAY) |
| # Expect behavior now is that DUT will reject power swap |
| self._test_power_swap_reject() |
| logging.info('Power Swap request rejected by DUT as expected') |
| finally: |
| # Restore dual role setting |
| self.dut_port.drp_set(current_dual_role) |
