| # 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_console |
| |
| |
| 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 = 0.5 |
| PD_CONNECT_DELAY = 4 |
| PLANKTON_PORT = 0 |
| POWER_SWAP_ITERATIONS = 5 |
| # Source power role |
| SRC ='SRC_READY' |
| # Sink power role |
| SNK = 'SNK_READY' |
| |
| def _set_plankton_power_role_to_src(self): |
| """Force Plankton to act as a source |
| |
| @returns True if Plankton power role is source, false otherwise |
| """ |
| PLANKTON_SRC_VOLTAGE = 20 |
| self.plankton.charge(PLANKTON_SRC_VOLTAGE) |
| # Wait for change to take place |
| time.sleep(self.PD_CONNECT_DELAY) |
| plankton_state = self.plankton_pd_utils.get_pd_state(self.PLANKTON_PORT) |
| # Current Plankton power role should be source |
| return bool(plankton_state == self.SRC) |
| |
| def _send_power_swap_get_reply(self, console, 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 console: pd console object for uart access |
| |
| @returns: PD control header message |
| """ |
| # Enable PD console debug mode to show control messages |
| console.enable_pd_console_debug() |
| cmd = 'pd %d swap power' % port |
| m = console.send_pd_command_get_output(cmd, ['RECV\s([\w]+)']) |
| ctrl_msg = int(m[0][1], 16) & console.PD_CONTROL_MSG_MASK |
| console.disable_pd_console_debug() |
| return ctrl_msg |
| |
| def _attempt_power_swap(self, pd_port, direction): |
| """Perform a power role swap request |
| |
| Initiate a power role swap request on either the DUT or |
| Plankton depending on the direction parameter. The power |
| role swap is then verified to have taken place. |
| |
| @param pd_port: DUT pd port value 0/1 |
| @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_pd_utils.get_pd_state(pd_port) |
| if direction == 'rx': |
| console = self.plankton_pd_utils |
| port = self.PLANKTON_PORT |
| else: |
| console = self.dut_pd_utils |
| port = pd_port |
| # Send power swap request |
| self._send_power_swap_get_reply(console, port) |
| time.sleep(self.PD_CONNECT_DELAY) |
| # Get Plankton power role |
| plankton_pr = self.plankton_pd_utils.get_pd_state(self.PLANKTON_PORT) |
| return bool(dut_pr == plankton_pr) |
| |
| def _test_power_swap_reject(self, pd_port): |
| """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 Plankton, and then |
| the control message checked to ensure the request was rejected. |
| In addition, the connection state is verified to not have |
| changed. |
| |
| @param pd_port: port for DUT pd connection |
| """ |
| # Get current DUT power role |
| dut_power_role = self.dut_pd_utils.get_pd_state(pd_port) |
| # Send swap command from Plankton and get reply |
| ctrl_msg = self._send_power_swap_get_reply(self.plankton_pd_utils, |
| self.PLANKTON_PORT) |
| if ctrl_msg != self.dut_pd_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_pd_utils.get_pd_state(pd_port) |
| if pd_state != dut_power_role: |
| raise error.TestFail('PD not connected! pd_state = %r' % |
| pd_state) |
| |
| def initialize(self, host, cmdline_args): |
| super(firmware_PDPowerSwap, 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_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 Plankton |
| 3. Determine if DUT is in dualrole mode |
| 4. If not dualrole mode, verify DUT rejects power swap request |
| Else test power swap (tx/rx), then Force DUT to be sink or |
| source only and verify rejecttion of power swap request. |
| |
| """ |
| # create objects for pd utilities |
| self.dut_pd_utils = pd_console.PDConsoleUtils(self.usbpd) |
| self.plankton_pd_utils = pd_console.PDConsoleUtils(self.plankton) |
| self.connect_utils = pd_console.PDConnectionUtils(self.dut_pd_utils, |
| self.plankton_pd_utils) |
| |
| # Make sure PD support exists in the UART console |
| if self.dut_pd_utils.verify_pd_console() == False: |
| raise error.TestFail("pd command not present on console!") |
| |
| # Type C connection (PD contract) should exist at this point |
| # For this test, the DUT must be connected to a Plankton. |
| pd_port = self.connect_utils.find_dut_to_plankton_connection() |
| if pd_port is None: |
| raise error.TestFail("DUT to Plankton PD connection not found") |
| dut_connect_state = self.dut_pd_utils.get_pd_state(pd_port) |
| logging.info('Initial DUT connect state = %s', dut_connect_state) |
| |
| # Get DUT dualrole status |
| if self.dut_pd_utils.is_pd_dual_role_enabled() == 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(pd_port) |
| logging.info('Power Swap request rejected by DUT as expected') |
| else: |
| # Start with Plankton as source |
| if self._set_plankton_power_role_to_src() == False: |
| raise error.TestFail('Plankton not set to source') |
| # DUT is dualrole in dual role mode. Test power role swap |
| # operation intiated both by the DUT and Plankton. |
| success = 0 |
| for attempt in xrange(self.POWER_SWAP_ITERATIONS): |
| if attempt & 1: |
| direction = 'rx' |
| else: |
| direction = 'tx' |
| if self._attempt_power_swap(pd_port, direction): |
| success += 1 |
| new_state = self.dut_pd_utils.get_pd_state(pd_port) |
| 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)) |
| |
| # Force DUT to only support current power role |
| if new_state == self.SRC: |
| dual_mode = 'src' |
| else: |
| dual_mode = 'snk' |
| logging.info('Setting dualrole mode to %s', dual_mode) |
| self.dut_pd_utils.set_pd_dualrole(dual_mode) |
| time.sleep(self.PD_ROLE_DELAY) |
| # Expect behavior now is that DUT will reject power swap |
| self._test_power_swap_reject(pd_port) |
| logging.info('Power Swap request rejected by DUT as expected') |
| # Restore DUT dual role operation |
| self.dut_pd_utils.set_pd_dualrole('on') |
| # Set connection back to default arrangement |
| self.plankton_pd_utils.set_pd_dualrole('off') |
| self.plankton_pd_utils.send_pd_command('fake disconnect 100 1000') |
| |
