| # Copyright (c) 2013 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 time |
| |
| from autotest_lib.server.cros.servo import chrome_ec |
| |
| |
| def _inherit_docstring(cls): |
| """Decorator to propagate a docstring to a subclass's method. |
| |
| @param cls Class with the method whose docstring is to be |
| inherited. The class must contain a method with |
| the same name as the name of the function to be |
| decorated. |
| |
| """ |
| def _copy_docstring(methfunc): |
| """Actually copy the parent docstring to the child. |
| |
| @param methfunc Function that will inherit the docstring. |
| |
| """ |
| methfunc.__doc__ = getattr(cls, methfunc.__name__).__doc__ |
| return methfunc |
| return _copy_docstring |
| |
| |
| # Constants acceptable to be passed for the `rec_mode` parameter |
| # to power_on(). |
| # |
| # REC_ON: Boot the DUT in recovery mode, i.e. boot from USB or |
| # SD card. |
| # REC_OFF: Boot in normal mode, i.e. boot from internal storage. |
| |
| REC_ON = 'on' |
| REC_OFF = 'off' |
| |
| |
| class _PowerStateController(object): |
| |
| """Class to provide board-specific power operations. |
| |
| This class is responsible for "power on" and "power off" |
| operations that can operate without making assumptions in |
| advance about board state. It offers an interface that |
| abstracts out the different sequences required for different |
| board types. |
| |
| """ |
| |
| # Delay in seconds needed between asserting and de-asserting cold |
| # or warm reset. Subclasses will normally override this constant |
| # with a board-specific value. |
| _RESET_HOLD_TIME = 0.5 |
| |
| # _EC_RESET_DELAY: Time required before the EC will be working |
| # after cold reset. Five seconds is at least twice as long as |
| # necessary for Alex, and is presumably good enough for all other |
| # systems. |
| _EC_RESET_DELAY = 5.0 |
| |
| def __init__(self, servo): |
| """Initialize the power state control. |
| |
| @param servo Servo object providing the underlying `set` and `get` |
| methods for the target controls. |
| |
| """ |
| self._servo = servo |
| |
| def cold_reset(self): |
| """Apply cold reset to the DUT. |
| |
| This asserts, then de-asserts the 'cold_reset' signal. |
| The exact affect on the hardware varies depending on |
| the board type. |
| |
| """ |
| self._servo.set_get_all(['cold_reset:on', |
| 'sleep:%.4f' % self._RESET_HOLD_TIME, |
| 'cold_reset:off']) |
| # After the reset, give the EC the time it needs to |
| # re-initialize. |
| time.sleep(self._EC_RESET_DELAY) |
| |
| def warm_reset(self): |
| """Apply warm reset to the DUT. |
| |
| This asserts, then de-asserts the 'warm_reset' signal. |
| Generally, this causes the board to restart. |
| |
| """ |
| self._servo.set_get_all(['warm_reset:on', |
| 'sleep:%.4f' % self._RESET_HOLD_TIME, |
| 'warm_reset:off']) |
| |
| def recovery_supported(self): |
| """Return whether the power on/off methods are supported. |
| |
| @return True means the power_on() and power_off() methods will |
| not raise a NotImplementedError. False means they will. |
| |
| """ |
| return False |
| |
| def power_off(self): |
| """Force the DUT to power off. |
| |
| The DUT is guaranteed to be off at the end of this call, |
| regardless of its previous state, provided that there is |
| working EC and boot firmware. There is no requirement for |
| working OS software. |
| |
| """ |
| raise NotImplementedError() |
| |
| def power_on(self, rec_mode=REC_OFF): |
| """Force the DUT to power on. |
| |
| Prior to calling this function, the DUT must be powered off, |
| e.g. with a call to `power_off()`. |
| |
| At power on, recovery mode is set as specified by the |
| corresponding argument. When booting with recovery mode on, it |
| is the caller's responsibility to unplug/plug in a bootable |
| external storage device. |
| |
| If the DUT requires a delay after powering on but before |
| processing inputs such as USB stick insertion, the delay is |
| handled by this method; the caller is not responsible for such |
| delays. |
| |
| @param rec_mode Setting of recovery mode to be applied at |
| power on. default: REC_OFF aka 'off' |
| |
| """ |
| raise NotImplementedError() |
| |
| class _PantherController(_PowerStateController): |
| |
| """Power-state controller for Pantherand compatible boards. |
| |
| For Panther, the 'cold_reset' signal is not connected |
| """ |
| |
| # TODO(@moch): rename and modify appropriately |
| _TIME_TO_SWITCH_OFF = 10.0 |
| _TIME_TO_BOOT = 10.0 |
| _TIME_TO_HOLD_POWER_BUTTON = 1.2 |
| |
| @_inherit_docstring(_PowerStateController) |
| def cold_reset(self): |
| self._servo.set('pwr_button', 'press') |
| time.sleep(self._TIME_TO_HOLD_POWER_BUTTON) |
| self._servo.set('pwr_button', 'release') |
| time.sleep(self._TIME_TO_SWITCH_OFF) |
| |
| self._servo.set('pwr_button', 'press') |
| time.sleep(self._TIME_TO_HOLD_POWER_BUTTON) |
| self._servo.set('pwr_button', 'release') |
| time.sleep(self._TIME_TO_BOOT) |
| |
| |
| class _AlexController(_PowerStateController): |
| |
| """Power-state controller for Alex and compatible boards. |
| |
| For Alex, Lumpy, et al., the 'cold_reset' signal forces the unit |
| off, and leaves it off. Recovery mode and developer mode are |
| controlled by signals from the Servo board. |
| |
| """ |
| |
| # Time in seconds to allow the firmware to initialize itself and |
| # present the "INSERT" screen in recovery mode before actually |
| # inserting a USB stick to boot from. |
| _RECOVERY_INSERT_DELAY = 10.0 |
| |
| @_inherit_docstring(_PowerStateController) |
| def recovery_supported(self): |
| return True |
| |
| @_inherit_docstring(_PowerStateController) |
| def power_off(self): |
| self.cold_reset() |
| |
| @_inherit_docstring(_PowerStateController) |
| def power_on(self, rec_mode=REC_OFF): |
| self._servo.set_nocheck('rec_mode', rec_mode) |
| self._servo.power_short_press() |
| if rec_mode == REC_ON: |
| time.sleep(self._RECOVERY_INSERT_DELAY) |
| self._servo.set('rec_mode', REC_OFF) |
| |
| |
| class _LumpyController(_AlexController): |
| |
| """Power-state controller for Lumpy.""" |
| |
| @_inherit_docstring(_AlexController) |
| def power_off(self): |
| # The debug header for MP Lumpy's are missing a resistor to support |
| # cold_reset. Therefore to do a power off we simply long hold the |
| # power button. This should cover the most common types of failures |
| # in the lab. However if the unit is already off this will cause it to |
| # power on instead. In this case, re-run repair a second time to |
| # recover the device. |
| self._servo.power_long_press() |
| |
| |
| class _StumpyController(_AlexController): |
| |
| """Power-state controller for Stumpy.""" |
| |
| @_inherit_docstring(_AlexController) |
| def power_off(self): |
| # In test images in the lab, the 'autoreboot' upstart job will |
| # commonly configure the unit so that it reboots after cold |
| # reset. Since we mustn't rely on the OS, we can't know for |
| # sure whether the unit will be on or off after cold reset. |
| # |
| # Fortunately, the autoreboot setting only applies through one |
| # reset. So, after one reset, the unit may be on or off, but |
| # autoreboot is disabled. We can be sure to be off after a |
| # second reset as long as it happens before the unit has a |
| # chance to run the autoreboot job. |
| self.cold_reset() |
| self.cold_reset() |
| |
| |
| class _ParrotController(_PowerStateController): |
| |
| """Power-state controller for Parrot. |
| |
| On Parrot, uncontrolled assertion of `cold_reset` sometimes |
| leaves the DUT unresponsive. The `cold_reset()` method |
| implemented in this class is the only known, reliable way to |
| assert the `cold_reset` signal on Parrot. |
| |
| The `rec_mode` signal on Parrot is finicky. These are the |
| rules: |
| 1. You can't read or write the signal unless the DUT is on. |
| 2. The setting of the signal is only sampled during a cold |
| reset. The sampled setting applies to every boot until the |
| next cold reset. |
| 3. After cold reset, the signal is turned off. |
| N.B. Rule 3 is subtle. Although `rec_mode` is off after reset, |
| because of rule 2, the DUT will continue to boot with the prior |
| recovery mode setting until the next cold reset. |
| |
| """ |
| |
| _RESET_HOLD_TIME = 0.0 |
| _EC_RESET_DELAY = 0.5 |
| |
| # _PWR_BUTTON_READY_TIME: This represents the time after cold |
| # reset until the EC will be able to see a power button press. |
| # Used in power_off(). |
| _PWR_BUTTON_READY_TIME = 4 |
| |
| # _REC_MODE_READY_TIME: This represents the time after power on |
| # until the EC will be able to see changes to rec_mode. Used |
| # in power_on(). |
| _REC_MODE_READY_TIME = 0.75 |
| |
| @_inherit_docstring(_PowerStateController) |
| def recovery_supported(self): |
| return True |
| |
| @_inherit_docstring(_PowerStateController) |
| def cold_reset(self): |
| # The sequence here leaves the DUT powered on, similar to |
| # Chrome EC devices. |
| self._servo.set_nocheck('pwr_button', 'press') |
| super(_ParrotController, self).cold_reset() |
| self._servo.set_nocheck('pwr_button', 'release') |
| |
| @_inherit_docstring(_PowerStateController) |
| def power_off(self): |
| self.cold_reset() |
| time.sleep(self._PWR_BUTTON_READY_TIME) |
| self._servo.power_short_press() |
| |
| @_inherit_docstring(_PowerStateController) |
| def power_on(self, rec_mode=REC_OFF): |
| self._servo.power_short_press() |
| time.sleep(self._REC_MODE_READY_TIME) |
| self._servo.set_nocheck('rec_mode', rec_mode) |
| self.cold_reset() |
| |
| |
| class _ChromeECController(_PowerStateController): |
| |
| """Power-state controller for systems with a Chrome EC. |
| |
| For these systems, after releasing 'cold_reset' the DUT is left |
| powered on. Recovery mode is triggered by simulating keyboard |
| recovery by issuing commands to the EC. |
| |
| """ |
| |
| _RESET_HOLD_TIME = 0.1 |
| _EC_RESET_DELAY = 0.0 |
| |
| _EC_CONSOLE_DELAY = 1.2 |
| |
| @_inherit_docstring(_PowerStateController) |
| def __init__(self, servo): |
| super(_ChromeECController, self).__init__(servo) |
| self._ec = chrome_ec.ChromeEC(servo) |
| |
| @_inherit_docstring(_PowerStateController) |
| def recovery_supported(self): |
| return True |
| |
| @_inherit_docstring(_PowerStateController) |
| def power_off(self): |
| self.cold_reset() |
| time.sleep(self._EC_CONSOLE_DELAY) |
| self._servo.power_long_press() |
| |
| @_inherit_docstring(_PowerStateController) |
| def power_on(self, rec_mode=REC_OFF): |
| if rec_mode == REC_ON: |
| # Reset the EC to force it back into RO code; this clears |
| # the EC_IN_RW signal, so the system CPU will trust the |
| # upcoming recovery mode request. |
| self.cold_reset() |
| # Restart the EC, but leave the system CPU off... |
| self._ec.reboot('ap-off') |
| time.sleep(self._EC_CONSOLE_DELAY) |
| # ... and tell the EC to tell the CPU we're in recovery mode. |
| self._ec.set_hostevent(chrome_ec.HOSTEVENT_KEYBOARD_RECOVERY) |
| self._servo.power_short_press() |
| |
| |
| class _DaisyController(_ChromeECController): |
| """Power-state controller for Snow/Daisy systems.""" |
| _EC_CONSOLE_DELAY = 0.4 |
| |
| |
| class _LinkController(_ChromeECController): |
| |
| """Power-state controller for Link. |
| |
| Link has a Chrome EC, but the hardware supports the rec_mode |
| signal. |
| |
| """ |
| |
| # Time in seconds to allow the BIOS and EC to detect the |
| # 'rec_mode' signal after cold reset. |
| _RECOVERY_DETECTION_DELAY = 2.5 |
| |
| @_inherit_docstring(_ChromeECController) |
| def power_off(self): |
| self._ec.send_command('x86shutdown') |
| |
| @_inherit_docstring(_ChromeECController) |
| def power_on(self, rec_mode=REC_OFF): |
| if rec_mode == REC_ON: |
| self._servo.set('rec_mode', REC_ON) |
| self.cold_reset() |
| time.sleep(self._RECOVERY_DETECTION_DELAY) |
| self._servo.set('rec_mode', REC_OFF) |
| else: |
| self._servo.power_short_press() |
| |
| |
| _CONTROLLER_BOARD_MAP = { |
| 'daisy': _DaisyController, |
| 'spring': _DaisyController, |
| 'link': _LinkController, |
| 'lumpy': _LumpyController, |
| 'parrot': _ParrotController, |
| 'stumpy': _StumpyController, |
| 'x86-alex': _AlexController, |
| 'panther':_PantherController |
| } |
| |
| |
| def create_controller(servo, board): |
| """Create a power state controller instance. |
| |
| The controller class will be selected based on the provided |
| board type, and instantiated with the provided servo instance. |
| |
| @param servo Servo object that will be used to manipulate DUT |
| power states. |
| @param board Board name of the DUT to be controlled. |
| |
| @returns An instance of a power state controller appropriate to |
| the given board type, or `None` if the board is |
| unsupported. |
| |
| """ |
| return _CONTROLLER_BOARD_MAP.get(board, _PowerStateController)(servo) |
