# 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')