| plans: | |
| - name: servo | |
| criticalactions: | |
| - name: Set state:MISSING_CONFIG (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:MISSING_CONFIG | |
| - name: Servo is know in the setup (RUN_ONCE) | |
| exec_name: dut_servo_host_present | |
| docs: | |
| - Verify if setup data has any data related to servo-host which mean servo is present in setup. | |
| dependencies: | |
| - name: Set state:WRONG_CONFIG (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:WRONG_CONFIG | |
| - name: Servod port specified (RUN_ONCE) | |
| exec_name: servo_servod_port_present | |
| docs: | |
| - Verify that servod port is present in servo data. | |
| dependencies: | |
| - name: Set state:WRONG_CONFIG (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:WRONG_CONFIG | |
| - name: Servo serial is specified (RUN_ONCE) | |
| exec_name: dut_servo_has_serial | |
| docs: | |
| - Check if root servo serial is present. | |
| dependencies: | |
| - name: Set state:WRONG_CONFIG (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:WRONG_CONFIG | |
| - name: Initialize docker container (time:'6m0s') | |
| exec_name: servo_host_servod_init | |
| exec_args: | |
| - no_servod:true | |
| docs: | |
| - Initiate docker to have access to the host. | |
| - Servod is not needed as on this stage we just verify that servo host is good. | |
| - If start container with servod and root servo device is not connected it will fail. | |
| conditions: | |
| - name: Uses servod container | |
| exec_name: servo_uses_servod_container | |
| docs: | |
| - Condition to check if servo uses servod container. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| recoveries: | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| recoveries: | |
| - name: Wait for labstation to load (time:'2m0s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Sometimes we can try to connect when labstation is the middle of reboot, so we wait. | |
| - Labstation is expected to complete the reboot within 2 minutes. | |
| - name: Mark labstation as servod is in-use | |
| exec_name: cros_create_servo_in_use | |
| docs: | |
| - Create lock file is_in_use. | |
| conditions: | |
| - name: Is labstation | |
| exec_name: servo_host_is_labstation | |
| docs: | |
| - Condition to check if the servohost is a labstation. | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| recoveries: | |
| - name: Wait for labstation to load (time:'2m0s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Sometimes we can try to connect when labstation is the middle of reboot, so we wait. | |
| - Labstation is expected to complete the reboot within 2 minutes. | |
| - name: Set state:SERVO_HOST_ISSUE (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:SERVO_HOST_ISSUE | |
| recoveries: | |
| - name: Sleep 1s (Allow to fail) (ALWAYS_RUN) | |
| exec_name: sample_sleep | |
| exec_args: | |
| - sleep:1 | |
| - name: Create request to reboot labstation (ALWAYS_RUN) | |
| exec_name: sample_fail | |
| docs: | |
| - Try to create reboot flag file request. | |
| - The action always fails as Servo will be fixed after reboot. | |
| conditions: | |
| - name: Is labstation | |
| exec_name: servo_host_is_labstation | |
| docs: | |
| - Condition to check if the servohost is a labstation. | |
| dependencies: | |
| - name: cros_create_reboot_request | |
| exec_name: cros_create_reboot_request | |
| - name: Read release info (Allow to fail) (RUN_ONCE) | |
| exec_name: cros_run_command | |
| exec_args: | |
| - 'host:' | |
| - command:cat /etc/lsb-release | |
| docs: | |
| - Read host release data for future analysis. | |
| conditions: | |
| - name: Servod container is not used | |
| exec_name: servo_uses_servod_container | |
| exec_args: | |
| - reverse:true | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| recoveries: | |
| - name: Wait for labstation to load (time:'2m0s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Sometimes we can try to connect when labstation is the middle of reboot, so we wait. | |
| - Labstation is expected to complete the reboot within 2 minutes. | |
| - name: Set state:SERVO_HOST_ISSUE (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:SERVO_HOST_ISSUE | |
| - name: Power-cycle by smart-hub (Allow to fail) (RUN_ONCE) (time:'2m0s') | |
| exec_name: servo_power_cycle_root_servo | |
| exec_args: | |
| - reset_timeout:60 | |
| - wait_timeout:20 | |
| - reset_authorized:false | |
| docs: | |
| - Try to reset(power-cycle) the servo via smart usbhub. | |
| conditions: | |
| - name: DUT is not SSHable (ALWAYS_RUN) | |
| exec_name: sample_fail | |
| docs: | |
| - Verify if DUT is not SSH-able | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| recoveries: | |
| - name: Wait for labstation to load (time:'2m0s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Sometimes we can try to connect when labstation is the middle of reboot, so we wait. | |
| - Labstation is expected to complete the reboot within 2 minutes. | |
| - name: Has enough free disk space | |
| exec_name: cros_has_enough_storage_space | |
| exec_args: | |
| - /mnt/stateful_partition:0.5 | |
| docs: | |
| - Check if stateful partition have enough disk space that is at least 0.5GB. | |
| conditions: | |
| - name: Servod container is not used | |
| exec_name: servo_uses_servod_container | |
| exec_args: | |
| - reverse:true | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| recoveries: | |
| - name: Wait for labstation to load (time:'2m0s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Sometimes we can try to connect when labstation is the middle of reboot, so we wait. | |
| - Labstation is expected to complete the reboot within 2 minutes. | |
| - name: Set state:BROKEN (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:BROKEN | |
| recoveries: | |
| - name: Remove logs and other files | |
| exec_name: sample_pass | |
| docs: | |
| - Clean up the old servod files as well as labstation. | |
| conditions: | |
| - name: Is labstation | |
| exec_name: servo_host_is_labstation | |
| docs: | |
| - Condition to check if the servohost is a labstation. | |
| dependencies: | |
| - name: servo_labstation_disk_cleanup | |
| exec_name: servo_labstation_disk_cleanup | |
| - name: Remove logs older 5 days | |
| exec_name: servo_servod_old_logs_cleanup | |
| exec_args: | |
| - max_days:5 | |
| docs: | |
| - Clean up the old servod logs which older than 5 days. | |
| - name: Create request to reboot labstation (ALWAYS_RUN) | |
| exec_name: sample_fail | |
| docs: | |
| - Try to create reboot flag file request. | |
| - The action always fails as Servo will be fixed after reboot. | |
| conditions: | |
| - name: Is labstation | |
| exec_name: servo_host_is_labstation | |
| docs: | |
| - Condition to check if the servohost is a labstation. | |
| dependencies: | |
| - name: cros_create_reboot_request | |
| exec_name: cros_create_reboot_request | |
| - name: Cache latest servod start time (Allow to fail) | |
| exec_name: cros_register_servod_logs_start | |
| docs: | |
| - Cache servod start time based on previous runs. | |
| - If we fail all logs will be collected | |
| conditions: | |
| - name: Servod container is not used | |
| exec_name: servo_uses_servod_container | |
| exec_args: | |
| - reverse:true | |
| - name: Servo_v4(p1) main present | |
| exec_name: servo_v4_root_present | |
| exec_args: | |
| - update_topology:true | |
| docs: | |
| - Verify that servo_v4(p1) board is present | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| recoveries: | |
| - name: Wait for labstation to load (time:'2m0s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Sometimes we can try to connect when labstation is the middle of reboot, so we wait. | |
| - Labstation is expected to complete the reboot within 2 minutes. | |
| - name: Set state:NOT_CONNECTED (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NOT_CONNECTED | |
| recoveries: | |
| - name: Recover servo with Power-cycle by smart-hub (ALWAYS_RUN) (time:'2m0s') | |
| exec_name: servo_power_cycle_root_servo | |
| exec_args: | |
| - reset_timeout:60 | |
| - wait_timeout:20 | |
| - reset_authorized:false | |
| docs: | |
| - Try to power-cycle the servo via smart usbhub to recover it. | |
| - name: Create request to reboot labstation (ALWAYS_RUN) | |
| exec_name: sample_fail | |
| docs: | |
| - Try to create reboot flag file request. | |
| - The action always fails as Servo will be fixed after reboot. | |
| conditions: | |
| - name: Is labstation | |
| exec_name: servo_host_is_labstation | |
| docs: | |
| - Condition to check if the servohost is a labstation. | |
| dependencies: | |
| - name: cros_create_reboot_request | |
| exec_name: cros_create_reboot_request | |
| - name: All servo's fw updated (time:'5m0s') | |
| exec_name: servo_fw_need_update | |
| docs: | |
| - Check whether servo devices required firmware update. | |
| - Check running agains version specified by servo_updater channel. | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| recoveries: | |
| - name: Wait for labstation to load (time:'2m0s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Sometimes we can try to connect when labstation is the middle of reboot, so we wait. | |
| - Labstation is expected to complete the reboot within 2 minutes. | |
| - name: Set state:SERVO_UPDATER_ISSUE (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:SERVO_UPDATER_ISSUE | |
| recoveries: | |
| - name: Sleep 1s (Allow to fail) (ALWAYS_RUN) | |
| exec_name: sample_sleep | |
| exec_args: | |
| - sleep:1 | |
| - name: Update all servo's firmware (RUN_ONCE) (time:'10m0s') | |
| exec_name: servo_update_servo_firmware | |
| exec_args: | |
| - try_attempt_count:3 | |
| - try_force_update_after_fail:true | |
| docs: | |
| - Try to update in normal ways 3 times, if fail allow run force update. | |
| dependencies: | |
| - name: Stop servod daemon on servo-host (time:'6m0s') | |
| exec_name: servo_host_servod_init | |
| exec_args: | |
| - no_servod:true | |
| docs: | |
| - Make sure servod daemon is not running on servo-host. | |
| - If container then run without daemon. | |
| - If daemon is running it will be stopped. | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Start servod daemon (time:'2m0s') | |
| exec_name: servo_host_servod_init | |
| docs: | |
| - Start servod daemon on servo-host | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| recoveries: | |
| - name: Wait for labstation to load (time:'2m0s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Sometimes we can try to connect when labstation is the middle of reboot, so we wait. | |
| - Labstation is expected to complete the reboot within 2 minutes. | |
| - name: Set state:SERVO_HOST_ISSUE (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:SERVO_HOST_ISSUE | |
| recoveries: | |
| - name: Reboot servo device (RUN_ONCE) (time:'1m10s') | |
| exec_name: servo_reboot | |
| exec_args: | |
| - reboot_timeout:30 | |
| - wait_timeout:30 | |
| docs: | |
| - Reboot servo device via servodtool | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Stop servod and request to use recovery-mode for servod (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - This recovery action to made adjust how we start servod. | |
| - Specify to start servod with REC_MODE=1. | |
| dependencies: | |
| - name: Specify to use REC_MODE=1 for servo (RUN_ONCE) | |
| exec_name: servo_create_flag_to_use_recovery_mode | |
| docs: | |
| - Create a file to specify use REC_MODE=1 when start servod. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset EC from DUT and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset EC from DUT side to wake CR50 up and then stop the servod. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: cros_reset_ec (ALWAYS_RUN) | |
| exec_name: cros_reset_ec | |
| exec_args: | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reset EC from DUT side by running connads wake up the device as it will trigger recovering ec, cr50, and other fw. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reflash Cr50 fw and stop (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Is reflash Cr50 was done more 24 hours ago | |
| exec_name: sample_fail | |
| docs: | |
| - Verify that it is time when we can try to re-flash fw on cr50 (H1). | |
| - Re-flashing limited to once per once per day to avoid over-flashing the device. | |
| conditions: | |
| - name: Is reflash Cr50 was done within 24 hours | |
| exec_name: metrics_found_at_last_time | |
| exec_args: | |
| - metrics_kind:cr50_flash | |
| - time_frame_hours:24 | |
| docs: | |
| - Confirm that no cr50 reflash action has occurred in the past 24 hours. | |
| dependencies: | |
| - name: Reflash Cr50 fw on DUT (RUN_ONCE) (time:'2m30s') | |
| exec_name: cros_reflash_cr50_fw | |
| exec_args: | |
| - flash_timeout:120 | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| - Reboot after the fw flash is successful. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset GSC from DUT and stop servod (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset GSC from DUT side to wake it up. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| dependencies: | |
| - name: Reset GSC on DUT (Allow to fail) (RUN_ONCE) | |
| exec_name: cros_run_command | |
| exec_args: | |
| - host:dut | |
| - command:trunks_send --raw 80010000000c200000000013 | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| - The command recommended by cr50 team http://b/241161724#comment24. | |
| - Reboot after the fw flash is successful. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Create request to reboot labstation (ALWAYS_RUN) | |
| exec_name: sample_fail | |
| docs: | |
| - Try to create reboot flag file request. | |
| - The action always fails as Servo will be fixed after reboot. | |
| conditions: | |
| - name: Is labstation | |
| exec_name: servo_host_is_labstation | |
| docs: | |
| - Condition to check if the servohost is a labstation. | |
| dependencies: | |
| - name: cros_create_reboot_request | |
| exec_name: cros_create_reboot_request | |
| - name: Start UART capture (Allow to fail) | |
| exec_name: servod_start_uart_capture | |
| - name: Servod is responsive to dut-control (time:'30s') | |
| exec_name: servo_servod_echo_host | |
| docs: | |
| - Uses a servod control to check whether the servod daemon is responsive. | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| recoveries: | |
| - name: Wait for labstation to load (time:'2m0s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Sometimes we can try to connect when labstation is the middle of reboot, so we wait. | |
| - Labstation is expected to complete the reboot within 2 minutes. | |
| - name: Set state:SERVOD_ISSUE (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:SERVOD_ISSUE | |
| recoveries: | |
| - name: Stop servod and request to use recovery-mode for servod (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - This recovery action to made adjust how we start servod. | |
| - Specify to start servod with REC_MODE=1. | |
| dependencies: | |
| - name: Specify to use REC_MODE=1 for servo (RUN_ONCE) | |
| exec_name: servo_create_flag_to_use_recovery_mode | |
| docs: | |
| - Create a file to specify use REC_MODE=1 when start servod. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot servo device (RUN_ONCE) (time:'1m10s') | |
| exec_name: servo_reboot | |
| exec_args: | |
| - reboot_timeout:30 | |
| - wait_timeout:30 | |
| docs: | |
| - Reboot servo device via servodtool | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot by EC console and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT's EC by servod UART console and stop servod after that. | |
| dependencies: | |
| - name: Reboot by DUT's EC UART (ALWAYS_RUN) | |
| exec_name: servo_set_ec_uart_cmd | |
| exec_args: | |
| - wait_timeout:1 | |
| - value:reboot | |
| docs: | |
| - Try to reboot EC on DUT using servod command. | |
| - It reboots just the embedded controllers on the DUT. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Cold reset the DUT by servod and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| dependencies: | |
| - name: Cold reset by servod (ALWAYS_RUN) | |
| exec_name: servo_power_state_reset | |
| exec_args: | |
| - wait_timeout:1 | |
| - more_logs:true | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset EC from DUT and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset EC from DUT side to wake CR50 up and then stop the servod. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: cros_reset_ec (ALWAYS_RUN) | |
| exec_name: cros_reset_ec | |
| exec_args: | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reset EC from DUT side by running connads wake up the device as it will trigger recovering ec, cr50, and other fw. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Create request to reboot labstation (ALWAYS_RUN) | |
| exec_name: sample_fail | |
| docs: | |
| - Try to create reboot flag file request. | |
| - The action always fails as Servo will be fixed after reboot. | |
| conditions: | |
| - name: Is labstation | |
| exec_name: servo_host_is_labstation | |
| docs: | |
| - Condition to check if the servohost is a labstation. | |
| dependencies: | |
| - name: cros_create_reboot_request | |
| exec_name: cros_create_reboot_request | |
| - name: Read servo serial by servod harness | |
| exec_name: servod_echo | |
| docs: | |
| - Try to read servo serial by XMLRPC request to servod. | |
| dependencies: | |
| - name: Set state:SERVOD_PROXY_ISSUE (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:SERVOD_PROXY_ISSUE | |
| recoveries: | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot servo device (RUN_ONCE) (time:'1m10s') | |
| exec_name: servo_reboot | |
| exec_args: | |
| - reboot_timeout:30 | |
| - wait_timeout:30 | |
| docs: | |
| - Reboot servo device via servodtool | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle DTS Mode and Servo Role (ALWAYS_RUN) | |
| exec_name: servo_servod_dts_and_servo_role_toggle_exec | |
| docs: | |
| - Toggle dts mode and servo role to try and recover CCD. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Toggle PD once and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Toggle the servod command servo_pd_role only once. And then stop the servod afterwards. | |
| - 'TODO(otabek): Add dependency for servo initialize.' | |
| dependencies: | |
| - name: Toggle PD once (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:1 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role only once. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Try fake disconnect and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by mimic reconnection of servo. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: Try fake disconnect | |
| exec_name: servo_fake_disconnect_dut | |
| exec_args: | |
| - delay_in_ms:100 | |
| - timeout_in_ms:2000 | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle CC line and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by toggling cc and stop servod after. | |
| dependencies: | |
| - name: Toggle CC lines (ALWAYS_RUN) | |
| exec_name: servo_servod_cc_toggle | |
| exec_args: | |
| - cc_off_timeout:10 | |
| - cc_on_timeout:30 | |
| docs: | |
| - Toggle cc line connected between servo and DUT to wake up the connection. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot by EC console and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT's EC by servod UART console and stop servod after that. | |
| dependencies: | |
| - name: Reboot by DUT's EC UART (ALWAYS_RUN) | |
| exec_name: servo_set_ec_uart_cmd | |
| exec_args: | |
| - wait_timeout:1 | |
| - value:reboot | |
| docs: | |
| - Try to reboot EC on DUT using servod command. | |
| - It reboots just the embedded controllers on the DUT. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Cold reset the DUT by servod and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| dependencies: | |
| - name: Cold reset by servod (ALWAYS_RUN) | |
| exec_name: servo_power_state_reset | |
| exec_args: | |
| - wait_timeout:1 | |
| - more_logs:true | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reflash Cr50 fw and stop (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Is reflash Cr50 was done more 24 hours ago | |
| exec_name: sample_fail | |
| docs: | |
| - Verify that it is time when we can try to re-flash fw on cr50 (H1). | |
| - Re-flashing limited to once per once per day to avoid over-flashing the device. | |
| conditions: | |
| - name: Is reflash Cr50 was done within 24 hours | |
| exec_name: metrics_found_at_last_time | |
| exec_args: | |
| - metrics_kind:cr50_flash | |
| - time_frame_hours:24 | |
| docs: | |
| - Confirm that no cr50 reflash action has occurred in the past 24 hours. | |
| dependencies: | |
| - name: Reflash Cr50 fw on DUT (RUN_ONCE) (time:'2m30s') | |
| exec_name: cros_reflash_cr50_fw | |
| exec_args: | |
| - flash_timeout:120 | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| - Reboot after the fw flash is successful. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset EC from DUT and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset EC from DUT side to wake CR50 up and then stop the servod. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: cros_reset_ec (ALWAYS_RUN) | |
| exec_name: cros_reset_ec | |
| exec_args: | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reset EC from DUT side by running connads wake up the device as it will trigger recovering ec, cr50, and other fw. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Set cold_reset for c2d2 (Allow to fail) | |
| exec_name: servo_set | |
| exec_args: | |
| - command:cold_reset_select | |
| - string_value:gsc_ec_reset | |
| docs: | |
| - https://issuetracker.google.com/302370064 Use gsc_ec_reset instead of gsc_reset for c2d2 devices. | |
| - This is faft ccd should be open and in factory mode, so gsc_ec_reset should be accessible. | |
| conditions: | |
| - name: Servo used c2d2 | |
| exec_name: servo_type_regex_match | |
| exec_args: | |
| - regex:c2d2 | |
| docs: | |
| - Verify that servo uses c2d2 | |
| - name: Verify servo connected to the DUT | |
| exec_name: servo_low_ppdut5 | |
| docs: | |
| - Verify if servo connected to the DUTand received required voltage from it. | |
| conditions: | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Verify that the device is a Chromebook by checking for non-Chromebook boards | |
| - name: Is servo_v4(p1) with type-a connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-a | |
| docs: | |
| - Verify whether servo V4(p1) device is connect to DUT using Type-A connection. | |
| - name: DUT has CrOS EC | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:supports_cros_ec_communication | |
| - expected_string_value:yes | |
| docs: | |
| - Verify if DUT has ChromeOS firmware for EC | |
| dependencies: | |
| - name: Set state:DUT_NOT_CONNECTED (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:DUT_NOT_CONNECTED | |
| recoveries: | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot servo device (RUN_ONCE) (time:'1m10s') | |
| exec_name: servo_reboot | |
| exec_args: | |
| - reboot_timeout:30 | |
| - wait_timeout:30 | |
| docs: | |
| - Reboot servo device via servodtool | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Power cycle by RPM with delay and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Perform RPM cycle and wait to device to boot back. | |
| - RPM applicable only for servo-micro testbeds. | |
| conditions: | |
| - name: is_servo_micro | |
| exec_name: is_servo_micro | |
| - name: RPM config present | |
| exec_name: device_has_rpm_info | |
| exec_args: | |
| - device_type:dut | |
| docs: | |
| - Verifies that the RPM configuration provided. | |
| dependencies: | |
| - name: Set RPM OFF (ALWAYS_RUN) | |
| exec_name: device_rpm_power_off | |
| exec_args: | |
| - device_type:dut | |
| - name: Sleep 35s (Allow to fail) (ALWAYS_RUN) | |
| exec_name: sample_sleep | |
| exec_args: | |
| - sleep:35 | |
| - name: Set RPM ON (ALWAYS_RUN) | |
| exec_name: device_rpm_power_on | |
| exec_args: | |
| - device_type:dut | |
| - name: Try Cold reset by servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_power_state_reset | |
| exec_args: | |
| - wait_timeout:1 | |
| - more_logs:true | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle PD (5 times) and stop (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. And then stop the servod afterwards. | |
| conditions: | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| dependencies: | |
| - name: Toggle PD 5 times (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:5 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. | |
| - name: Try fake disconnect and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by mimic reconnection of servo. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: Try fake disconnect | |
| exec_name: servo_fake_disconnect_dut | |
| exec_args: | |
| - delay_in_ms:100 | |
| - timeout_in_ms:2000 | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle CC line and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by toggling cc and stop servod after. | |
| dependencies: | |
| - name: Toggle CC lines (ALWAYS_RUN) | |
| exec_name: servo_servod_cc_toggle | |
| exec_args: | |
| - cc_off_timeout:10 | |
| - cc_on_timeout:30 | |
| docs: | |
| - Toggle cc line connected between servo and DUT to wake up the connection. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot by EC console and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT's EC by servod UART console and stop servod after that. | |
| dependencies: | |
| - name: Reboot by DUT's EC UART (ALWAYS_RUN) | |
| exec_name: servo_set_ec_uart_cmd | |
| exec_args: | |
| - wait_timeout:1 | |
| - value:reboot | |
| docs: | |
| - Try to reboot EC on DUT using servod command. | |
| - It reboots just the embedded controllers on the DUT. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Cold reset the DUT by servod and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| dependencies: | |
| - name: Cold reset by servod (ALWAYS_RUN) | |
| exec_name: servo_power_state_reset | |
| exec_args: | |
| - wait_timeout:1 | |
| - more_logs:true | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset EC from DUT and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset EC from DUT side to wake CR50 up and then stop the servod. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: cros_reset_ec (ALWAYS_RUN) | |
| exec_name: cros_reset_ec | |
| exec_args: | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reset EC from DUT side by running connads wake up the device as it will trigger recovering ec, cr50, and other fw. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Force reflash servo_micro fw and stop | |
| exec_name: sample_pass | |
| docs: | |
| - Try to update servo micro firmware | |
| conditions: | |
| - name: Is labstation | |
| exec_name: servo_host_is_labstation | |
| docs: | |
| - Condition to check if the servohost is a labstation. | |
| - name: is_servo_micro | |
| exec_name: is_servo_micro | |
| - name: Is ok to force update servo_micro firmware | |
| exec_name: sample_fail | |
| docs: | |
| - Verify that it is time when we can try to re-flash fw on servo micro. | |
| - Re-flashing limited to once per once per 2 weeks to avoid over-flashing the servo device. | |
| conditions: | |
| - name: Last servo_micro fw updated within 2 weeks | |
| exec_name: metrics_found_at_last_time | |
| exec_args: | |
| - metrics_kind:servo_firmware_update_servo_micro | |
| - time_frame_hours:336 | |
| docs: | |
| - Confirm that servo micro fw update action has occurred in the past 2 weeks. (336 hours) | |
| dependencies: | |
| - name: Force update servo_micro firmware (time:'3m0s') | |
| exec_name: servo_update_servo_firmware | |
| exec_args: | |
| - force_update:true | |
| - ignore_version:true | |
| - servo_board:servo_micro | |
| docs: | |
| - Try to update servo micro firmware | |
| conditions: | |
| - name: Is labstation | |
| exec_name: servo_host_is_labstation | |
| docs: | |
| - Condition to check if the servohost is a labstation. | |
| - name: is_servo_micro | |
| exec_name: is_servo_micro | |
| - name: Is ok to force update servo_micro firmware | |
| exec_name: sample_fail | |
| docs: | |
| - Verify that it is time when we can try to re-flash fw on servo micro. | |
| - Re-flashing limited to once per once per 2 weeks to avoid over-flashing the servo device. | |
| conditions: | |
| - name: Last servo_micro fw updated within 2 weeks | |
| exec_name: metrics_found_at_last_time | |
| exec_args: | |
| - metrics_kind:servo_firmware_update_servo_micro | |
| - time_frame_hours:336 | |
| docs: | |
| - Confirm that servo micro fw update action has occurred in the past 2 weeks. (336 hours) | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Debug header servo present | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:dut_controller_missing_fault | |
| - expected_string_value:off | |
| docs: | |
| - Check if servod detected debug header components as expected. | |
| conditions: | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Verify that the device is a Chromebook by checking for non-Chromebook boards | |
| - name: Servo uses debug header components | |
| exec_name: servo_has_debug_header | |
| docs: | |
| - Verify that servo has components which are not started from ccd_. | |
| dependencies: | |
| - name: Set state:DEBUG_HEADER_SERVO_MISSING (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:DEBUG_HEADER_SERVO_MISSING | |
| recoveries: | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot servo device (RUN_ONCE) (time:'1m10s') | |
| exec_name: servo_reboot | |
| exec_args: | |
| - reboot_timeout:30 | |
| - wait_timeout:30 | |
| docs: | |
| - Reboot servo device via servodtool | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset EC from DUT and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset EC from DUT side to wake CR50 up and then stop the servod. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: cros_reset_ec (ALWAYS_RUN) | |
| exec_name: cros_reset_ec | |
| exec_args: | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reset EC from DUT side by running connads wake up the device as it will trigger recovering ec, cr50, and other fw. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Create request to reboot labstation (ALWAYS_RUN) | |
| exec_name: sample_fail | |
| docs: | |
| - Try to create reboot flag file request. | |
| - The action always fails as Servo will be fixed after reboot. | |
| conditions: | |
| - name: Is labstation | |
| exec_name: servo_host_is_labstation | |
| docs: | |
| - Condition to check if the servohost is a labstation. | |
| dependencies: | |
| - name: cros_create_reboot_request | |
| exec_name: cros_create_reboot_request | |
| - name: Cold reset pin is detected | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:cold_reset | |
| - expected_string_value:off | |
| conditions: | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Verify that the device is a Chromebook by checking for non-Chromebook boards | |
| - name: Is servo_v4(p1) with type-a connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-a | |
| docs: | |
| - Verify whether servo V4(p1) device is connect to DUT using Type-A connection. | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| recoveries: | |
| - name: Wait for labstation to load (time:'2m0s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Sometimes we can try to connect when labstation is the middle of reboot, so we wait. | |
| - Labstation is expected to complete the reboot within 2 minutes. | |
| - name: Set state:COLD_RESET_PIN_ISSUE (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:COLD_RESET_PIN_ISSUE | |
| recoveries: | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot by EC console and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT's EC by servod UART console and stop servod after that. | |
| dependencies: | |
| - name: Reboot by DUT's EC UART (ALWAYS_RUN) | |
| exec_name: servo_set_ec_uart_cmd | |
| exec_args: | |
| - wait_timeout:1 | |
| - value:reboot | |
| docs: | |
| - Try to reboot EC on DUT using servod command. | |
| - It reboots just the embedded controllers on the DUT. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset EC from DUT and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset EC from DUT side to wake CR50 up and then stop the servod. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: cros_reset_ec (ALWAYS_RUN) | |
| exec_name: cros_reset_ec | |
| exec_args: | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reset EC from DUT side by running connads wake up the device as it will trigger recovering ec, cr50, and other fw. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Warm reset pin is detected (servo_micro) (Allow to fail) | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:warm_reset | |
| - expected_string_value:off | |
| docs: | |
| - Verify that warm_reset pin is detected by servod. | |
| - If pin is not present then issue can be related to incorrect connected servo or issue with connector. | |
| conditions: | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Verify that the device is a Chromebook by checking for non-Chromebook boards | |
| - name: is_servo_micro | |
| exec_name: is_servo_micro | |
| - name: Warm reset control known by servo | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:warm_reset | |
| docs: | |
| - Verify is servod expected to have warm_reset control | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| recoveries: | |
| - name: Wait for labstation to load (time:'2m0s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Sometimes we can try to connect when labstation is the middle of reboot, so we wait. | |
| - Labstation is expected to complete the reboot within 2 minutes. | |
| - name: Set state:WARM_RESET_PIN_ISSUE (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:WARM_RESET_PIN_ISSUE | |
| - name: Charger connected (Allow to fail) | |
| exec_name: servo_control_min_double_value | |
| exec_args: | |
| - control:ppchg5_mv | |
| - min_value:4000 | |
| docs: | |
| - Verify that power for servo is provided. | |
| - Applicable when we use type-c servo and RPM. | |
| conditions: | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| - name: Has ppchg5_mv control | |
| exec_name: servod_has | |
| exec_args: | |
| - command:ppchg5_mv | |
| docs: | |
| - Read and print ppchg5_mv control value to logs. | |
| dependencies: | |
| - name: Read ppdut5_mv value | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:ppdut5_mv | |
| docs: | |
| - Read and print ppdut5_mv control value to logs. | |
| - name: Read ppchg5_mv value | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:ppchg5_mv | |
| docs: | |
| - Read and print ppchg5_mv control value to logs. | |
| recoveries: | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Set state:SERVOD_ISSUE (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:SERVOD_ISSUE | |
| recoveries: | |
| - name: Power on DUT by RPM | |
| exec_name: rpm_power_on | |
| docs: | |
| - Power ON the RPM outlet. | |
| conditions: | |
| - name: has_rpm_info | |
| exec_name: has_rpm_info | |
| - name: Check if PD is src state (Allow to fail) | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:servo_pd_role | |
| - expected_string_value:src | |
| docs: | |
| - Verify that PD is src power to the DUT. | |
| - Action can fail as not always the power is delivered by servo. | |
| conditions: | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| - name: Has ppchg5_mv control | |
| exec_name: servod_has | |
| exec_args: | |
| - command:ppchg5_mv | |
| docs: | |
| - Read and print ppchg5_mv control value to logs. | |
| dependencies: | |
| - name: Set state:SERVOD_ISSUE (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:SERVOD_ISSUE | |
| - name: Read ppdut5_mv value | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:ppdut5_mv | |
| docs: | |
| - Read and print ppdut5_mv control value to logs. | |
| - name: Read ppchg5_mv value | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:ppchg5_mv | |
| docs: | |
| - Read and print ppchg5_mv control value to logs. | |
| recoveries: | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Charger connected (Allow to fail) | |
| exec_name: servo_control_min_double_value | |
| exec_args: | |
| - control:ppchg5_mv | |
| - min_value:4000 | |
| docs: | |
| - Verify that power for servo is provided. | |
| - Applicable when we use type-c servo and RPM. | |
| conditions: | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| - name: Has ppchg5_mv control | |
| exec_name: servod_has | |
| exec_args: | |
| - command:ppchg5_mv | |
| docs: | |
| - Read and print ppchg5_mv control value to logs. | |
| dependencies: | |
| - name: Read ppdut5_mv value | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:ppdut5_mv | |
| docs: | |
| - Read and print ppdut5_mv control value to logs. | |
| - name: Read ppchg5_mv value | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:ppchg5_mv | |
| docs: | |
| - Read and print ppchg5_mv control value to logs. | |
| recoveries: | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Set state:SERVOD_ISSUE (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:SERVOD_ISSUE | |
| recoveries: | |
| - name: Power on DUT by RPM | |
| exec_name: rpm_power_on | |
| docs: | |
| - Power ON the RPM outlet. | |
| conditions: | |
| - name: has_rpm_info | |
| exec_name: has_rpm_info | |
| recoveries: | |
| - name: Toggle PD once and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Toggle the servod command servo_pd_role only once. And then stop the servod afterwards. | |
| - 'TODO(otabek): Add dependency for servo initialize.' | |
| dependencies: | |
| - name: Toggle PD once (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:1 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role only once. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle PD (5 times) and stop (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. And then stop the servod afterwards. | |
| conditions: | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| dependencies: | |
| - name: Toggle PD 5 times (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:5 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. | |
| - name: Try fake disconnect and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by mimic reconnection of servo. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: Try fake disconnect | |
| exec_name: servo_fake_disconnect_dut | |
| exec_args: | |
| - delay_in_ms:100 | |
| - timeout_in_ms:2000 | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle CC line and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by toggling cc and stop servod after. | |
| dependencies: | |
| - name: Toggle CC lines (ALWAYS_RUN) | |
| exec_name: servo_servod_cc_toggle | |
| exec_args: | |
| - cc_off_timeout:10 | |
| - cc_on_timeout:30 | |
| docs: | |
| - Toggle cc line connected between servo and DUT to wake up the connection. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle DTS Mode and Servo Role (ALWAYS_RUN) | |
| exec_name: servo_servod_dts_and_servo_role_toggle_exec | |
| docs: | |
| - Toggle dts mode and servo role to try and recover CCD. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Verify CCD GSC connection detected | |
| exec_name: sample_pass | |
| docs: | |
| - Run basic cr50/ti50 detections checks. | |
| conditions: | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Verify that the device is a Chromebook by checking for non-Chromebook boards | |
| - name: Servo main device is CCD | |
| exec_name: servo_main_device_is_ccd | |
| docs: | |
| - Verify that main device is CCD | |
| dependencies: | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| dependencies: | |
| - name: Set state:SBU_LOW_VOLTAGE (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:SBU_LOW_VOLTAGE | |
| - name: Servo SBU voltage is good | |
| exec_name: servo_cr50_low_sbu | |
| docs: | |
| - Verify that SBU voltage is in expected range (2500mv). | |
| conditions: | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| - name: Servod detect voltage issue | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:dut_sbu_voltage_float_fault | |
| - expected_string_value:on | |
| docs: | |
| - Verify that servod is detected required children. | |
| recoveries: | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot servo device (RUN_ONCE) (time:'1m10s') | |
| exec_name: servo_reboot | |
| exec_args: | |
| - reboot_timeout:30 | |
| - wait_timeout:30 | |
| docs: | |
| - Reboot servo device via servodtool | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle DTS Mode and Servo Role (ALWAYS_RUN) | |
| exec_name: servo_servod_dts_and_servo_role_toggle_exec | |
| docs: | |
| - Toggle dts mode and servo role to try and recover CCD. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Toggle PD once and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Toggle the servod command servo_pd_role only once. And then stop the servod afterwards. | |
| - 'TODO(otabek): Add dependency for servo initialize.' | |
| dependencies: | |
| - name: Toggle PD once (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:1 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role only once. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle PD (5 times) and stop (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. And then stop the servod afterwards. | |
| conditions: | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| dependencies: | |
| - name: Toggle PD 5 times (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:5 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. | |
| - name: Try fake disconnect and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by mimic reconnection of servo. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: Try fake disconnect | |
| exec_name: servo_fake_disconnect_dut | |
| exec_args: | |
| - delay_in_ms:100 | |
| - timeout_in_ms:2000 | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle CC line and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by toggling cc and stop servod after. | |
| dependencies: | |
| - name: Toggle CC lines (ALWAYS_RUN) | |
| exec_name: servo_servod_cc_toggle | |
| exec_args: | |
| - cc_off_timeout:10 | |
| - cc_on_timeout:30 | |
| docs: | |
| - Toggle cc line connected between servo and DUT to wake up the connection. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot by EC console and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT's EC by servod UART console and stop servod after that. | |
| dependencies: | |
| - name: Reboot by DUT's EC UART (ALWAYS_RUN) | |
| exec_name: servo_set_ec_uart_cmd | |
| exec_args: | |
| - wait_timeout:1 | |
| - value:reboot | |
| docs: | |
| - Try to reboot EC on DUT using servod command. | |
| - It reboots just the embedded controllers on the DUT. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Cold reset the DUT by servod and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| dependencies: | |
| - name: Cold reset by servod (ALWAYS_RUN) | |
| exec_name: servo_power_state_reset | |
| exec_args: | |
| - wait_timeout:1 | |
| - more_logs:true | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reflash Cr50 fw and stop (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Is reflash Cr50 was done more 24 hours ago | |
| exec_name: sample_fail | |
| docs: | |
| - Verify that it is time when we can try to re-flash fw on cr50 (H1). | |
| - Re-flashing limited to once per once per day to avoid over-flashing the device. | |
| conditions: | |
| - name: Is reflash Cr50 was done within 24 hours | |
| exec_name: metrics_found_at_last_time | |
| exec_args: | |
| - metrics_kind:cr50_flash | |
| - time_frame_hours:24 | |
| docs: | |
| - Confirm that no cr50 reflash action has occurred in the past 24 hours. | |
| dependencies: | |
| - name: Reflash Cr50 fw on DUT (RUN_ONCE) (time:'2m30s') | |
| exec_name: cros_reflash_cr50_fw | |
| exec_args: | |
| - flash_timeout:120 | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| - Reboot after the fw flash is successful. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset EC from DUT and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset EC from DUT side to wake CR50 up and then stop the servod. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: cros_reset_ec (ALWAYS_RUN) | |
| exec_name: cros_reset_ec | |
| exec_args: | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reset EC from DUT side by running connads wake up the device as it will trigger recovering ec, cr50, and other fw. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset GSC from DUT and stop servod (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset GSC from DUT side to wake it up. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| dependencies: | |
| - name: Reset GSC on DUT (Allow to fail) (RUN_ONCE) | |
| exec_name: cros_run_command | |
| exec_args: | |
| - host:dut | |
| - command:trunks_send --raw 80010000000c200000000013 | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| - The command recommended by cr50 team http://b/241161724#comment24. | |
| - Reboot after the fw flash is successful. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Create request to reboot labstation (ALWAYS_RUN) | |
| exec_name: sample_fail | |
| docs: | |
| - Try to create reboot flag file request. | |
| - The action always fails as Servo will be fixed after reboot. | |
| conditions: | |
| - name: Is labstation | |
| exec_name: servo_host_is_labstation | |
| docs: | |
| - Condition to check if the servohost is a labstation. | |
| dependencies: | |
| - name: cros_create_reboot_request | |
| exec_name: cros_create_reboot_request | |
| - name: Set state:CR50_NOT_ENUMERATED (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:CR50_NOT_ENUMERATED | |
| - name: Servo Cr50 enumerated | |
| exec_name: sample_fail | |
| docs: | |
| - Verify that Cr50/GSC is enumerated or not. | |
| conditions: | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| - name: Servod detect voltage issue | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:dut_sbu_voltage_float_fault | |
| - expected_string_value:on | |
| docs: | |
| - Verify that servod is detected required children. | |
| recoveries: | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot servo device (RUN_ONCE) (time:'1m10s') | |
| exec_name: servo_reboot | |
| exec_args: | |
| - reboot_timeout:30 | |
| - wait_timeout:30 | |
| docs: | |
| - Reboot servo device via servodtool | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle DTS Mode and Servo Role (ALWAYS_RUN) | |
| exec_name: servo_servod_dts_and_servo_role_toggle_exec | |
| docs: | |
| - Toggle dts mode and servo role to try and recover CCD. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Toggle PD once and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Toggle the servod command servo_pd_role only once. And then stop the servod afterwards. | |
| - 'TODO(otabek): Add dependency for servo initialize.' | |
| dependencies: | |
| - name: Toggle PD once (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:1 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role only once. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle PD (5 times) and stop (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. And then stop the servod afterwards. | |
| conditions: | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| dependencies: | |
| - name: Toggle PD 5 times (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:5 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. | |
| - name: Try fake disconnect and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by mimic reconnection of servo. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: Try fake disconnect | |
| exec_name: servo_fake_disconnect_dut | |
| exec_args: | |
| - delay_in_ms:100 | |
| - timeout_in_ms:2000 | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle CC line and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by toggling cc and stop servod after. | |
| dependencies: | |
| - name: Toggle CC lines (ALWAYS_RUN) | |
| exec_name: servo_servod_cc_toggle | |
| exec_args: | |
| - cc_off_timeout:10 | |
| - cc_on_timeout:30 | |
| docs: | |
| - Toggle cc line connected between servo and DUT to wake up the connection. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot by EC console and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT's EC by servod UART console and stop servod after that. | |
| dependencies: | |
| - name: Reboot by DUT's EC UART (ALWAYS_RUN) | |
| exec_name: servo_set_ec_uart_cmd | |
| exec_args: | |
| - wait_timeout:1 | |
| - value:reboot | |
| docs: | |
| - Try to reboot EC on DUT using servod command. | |
| - It reboots just the embedded controllers on the DUT. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset EC from DUT and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset EC from DUT side to wake CR50 up and then stop the servod. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: cros_reset_ec (ALWAYS_RUN) | |
| exec_name: cros_reset_ec | |
| exec_args: | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reset EC from DUT side by running connads wake up the device as it will trigger recovering ec, cr50, and other fw. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Cold reset the DUT by servod and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| dependencies: | |
| - name: Cold reset by servod (ALWAYS_RUN) | |
| exec_name: servo_power_state_reset | |
| exec_args: | |
| - wait_timeout:1 | |
| - more_logs:true | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reflash Cr50 fw and stop (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Is reflash Cr50 was done more 24 hours ago | |
| exec_name: sample_fail | |
| docs: | |
| - Verify that it is time when we can try to re-flash fw on cr50 (H1). | |
| - Re-flashing limited to once per once per day to avoid over-flashing the device. | |
| conditions: | |
| - name: Is reflash Cr50 was done within 24 hours | |
| exec_name: metrics_found_at_last_time | |
| exec_args: | |
| - metrics_kind:cr50_flash | |
| - time_frame_hours:24 | |
| docs: | |
| - Confirm that no cr50 reflash action has occurred in the past 24 hours. | |
| dependencies: | |
| - name: Reflash Cr50 fw on DUT (RUN_ONCE) (time:'2m30s') | |
| exec_name: cros_reflash_cr50_fw | |
| exec_args: | |
| - flash_timeout:120 | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| - Reboot after the fw flash is successful. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset GSC from DUT and stop servod (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset GSC from DUT side to wake it up. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| dependencies: | |
| - name: Reset GSC on DUT (Allow to fail) (RUN_ONCE) | |
| exec_name: cros_run_command | |
| exec_args: | |
| - host:dut | |
| - command:trunks_send --raw 80010000000c200000000013 | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| - The command recommended by cr50 team http://b/241161724#comment24. | |
| - Reboot after the fw flash is successful. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Servod detect all children components | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:dut_controller_missing_fault | |
| - expected_string_value:off | |
| docs: | |
| - Check if servod detected all required children components. | |
| conditions: | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Verify that the device is a Chromebook by checking for non-Chromebook boards | |
| dependencies: | |
| - name: Set state:SERVOD_DUT_CONTROLLER_MISSING (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:SERVOD_DUT_CONTROLLER_MISSING | |
| recoveries: | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot servo device (RUN_ONCE) (time:'1m10s') | |
| exec_name: servo_reboot | |
| exec_args: | |
| - reboot_timeout:30 | |
| - wait_timeout:30 | |
| docs: | |
| - Reboot servo device via servodtool | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle DTS Mode and Servo Role (ALWAYS_RUN) | |
| exec_name: servo_servod_dts_and_servo_role_toggle_exec | |
| docs: | |
| - Toggle dts mode and servo role to try and recover CCD. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Toggle PD once and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Toggle the servod command servo_pd_role only once. And then stop the servod afterwards. | |
| - 'TODO(otabek): Add dependency for servo initialize.' | |
| dependencies: | |
| - name: Toggle PD once (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:1 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role only once. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle PD (5 times) and stop (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. And then stop the servod afterwards. | |
| conditions: | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| dependencies: | |
| - name: Toggle PD 5 times (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:5 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. | |
| - name: Try fake disconnect and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by mimic reconnection of servo. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: Try fake disconnect | |
| exec_name: servo_fake_disconnect_dut | |
| exec_args: | |
| - delay_in_ms:100 | |
| - timeout_in_ms:2000 | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle CC line and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by toggling cc and stop servod after. | |
| dependencies: | |
| - name: Toggle CC lines (ALWAYS_RUN) | |
| exec_name: servo_servod_cc_toggle | |
| exec_args: | |
| - cc_off_timeout:10 | |
| - cc_on_timeout:30 | |
| docs: | |
| - Toggle cc line connected between servo and DUT to wake up the connection. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot by EC console and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT's EC by servod UART console and stop servod after that. | |
| dependencies: | |
| - name: Reboot by DUT's EC UART (ALWAYS_RUN) | |
| exec_name: servo_set_ec_uart_cmd | |
| exec_args: | |
| - wait_timeout:1 | |
| - value:reboot | |
| docs: | |
| - Try to reboot EC on DUT using servod command. | |
| - It reboots just the embedded controllers on the DUT. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Cold reset the DUT by servod and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| dependencies: | |
| - name: Cold reset by servod (ALWAYS_RUN) | |
| exec_name: servo_power_state_reset | |
| exec_args: | |
| - wait_timeout:1 | |
| - more_logs:true | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset EC from DUT and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset EC from DUT side to wake CR50 up and then stop the servod. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: cros_reset_ec (ALWAYS_RUN) | |
| exec_name: cros_reset_ec | |
| exec_args: | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reset EC from DUT side by running connads wake up the device as it will trigger recovering ec, cr50, and other fw. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reflash Cr50 fw and stop (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Is reflash Cr50 was done more 24 hours ago | |
| exec_name: sample_fail | |
| docs: | |
| - Verify that it is time when we can try to re-flash fw on cr50 (H1). | |
| - Re-flashing limited to once per once per day to avoid over-flashing the device. | |
| conditions: | |
| - name: Is reflash Cr50 was done within 24 hours | |
| exec_name: metrics_found_at_last_time | |
| exec_args: | |
| - metrics_kind:cr50_flash | |
| - time_frame_hours:24 | |
| docs: | |
| - Confirm that no cr50 reflash action has occurred in the past 24 hours. | |
| dependencies: | |
| - name: Reflash Cr50 fw on DUT (RUN_ONCE) (time:'2m30s') | |
| exec_name: cros_reflash_cr50_fw | |
| exec_args: | |
| - flash_timeout:120 | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| - Reboot after the fw flash is successful. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset GSC from DUT and stop servod (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset GSC from DUT side to wake it up. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| dependencies: | |
| - name: Reset GSC on DUT (Allow to fail) (RUN_ONCE) | |
| exec_name: cros_run_command | |
| exec_args: | |
| - host:dut | |
| - command:trunks_send --raw 80010000000c200000000013 | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| - The command recommended by cr50 team http://b/241161724#comment24. | |
| - Reboot after the fw flash is successful. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Create request to reboot labstation (ALWAYS_RUN) | |
| exec_name: sample_fail | |
| docs: | |
| - Try to create reboot flag file request. | |
| - The action always fails as Servo will be fixed after reboot. | |
| conditions: | |
| - name: Is labstation | |
| exec_name: servo_host_is_labstation | |
| docs: | |
| - Condition to check if the servohost is a labstation. | |
| dependencies: | |
| - name: cros_create_reboot_request | |
| exec_name: cros_create_reboot_request | |
| - name: Servo topology | |
| exec_name: sample_pass | |
| docs: | |
| - Make sure the servo has the required number of servo components. | |
| conditions: | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Verify that the device is a Chromebook by checking for non-Chromebook boards | |
| dependencies: | |
| - name: Servo topology min one child | |
| exec_name: servo_topology_update | |
| exec_args: | |
| - min_child:1 | |
| - persist_topology:true | |
| docs: | |
| - Verify that setup has at least one servo child. | |
| - Usually that is ccd_gsc|cr50 or servo_micro or c2d2. | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| recoveries: | |
| - name: Wait for labstation to load (time:'2m0s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Sometimes we can try to connect when labstation is the middle of reboot, so we wait. | |
| - Labstation is expected to complete the reboot within 2 minutes. | |
| - name: Set state:TOPOLOGY_ISSUE (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:TOPOLOGY_ISSUE | |
| recoveries: | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot servo device (RUN_ONCE) (time:'1m10s') | |
| exec_name: servo_reboot | |
| exec_args: | |
| - reboot_timeout:30 | |
| - wait_timeout:30 | |
| docs: | |
| - Reboot servo device via servodtool | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle DTS Mode and Servo Role (ALWAYS_RUN) | |
| exec_name: servo_servod_dts_and_servo_role_toggle_exec | |
| docs: | |
| - Toggle dts mode and servo role to try and recover CCD. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Toggle PD once and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Toggle the servod command servo_pd_role only once. And then stop the servod afterwards. | |
| - 'TODO(otabek): Add dependency for servo initialize.' | |
| dependencies: | |
| - name: Toggle PD once (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:1 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role only once. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle PD (5 times) and stop (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. And then stop the servod afterwards. | |
| conditions: | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| dependencies: | |
| - name: Toggle PD 5 times (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:5 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. | |
| - name: Try fake disconnect and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by mimic reconnection of servo. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: Try fake disconnect | |
| exec_name: servo_fake_disconnect_dut | |
| exec_args: | |
| - delay_in_ms:100 | |
| - timeout_in_ms:2000 | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle CC line and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by toggling cc and stop servod after. | |
| dependencies: | |
| - name: Toggle CC lines (ALWAYS_RUN) | |
| exec_name: servo_servod_cc_toggle | |
| exec_args: | |
| - cc_off_timeout:10 | |
| - cc_on_timeout:30 | |
| docs: | |
| - Toggle cc line connected between servo and DUT to wake up the connection. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot by EC console and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT's EC by servod UART console and stop servod after that. | |
| dependencies: | |
| - name: Reboot by DUT's EC UART (ALWAYS_RUN) | |
| exec_name: servo_set_ec_uart_cmd | |
| exec_args: | |
| - wait_timeout:1 | |
| - value:reboot | |
| docs: | |
| - Try to reboot EC on DUT using servod command. | |
| - It reboots just the embedded controllers on the DUT. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Cold reset the DUT by servod and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| dependencies: | |
| - name: Cold reset by servod (ALWAYS_RUN) | |
| exec_name: servo_power_state_reset | |
| exec_args: | |
| - wait_timeout:1 | |
| - more_logs:true | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset GSC from DUT and stop servod (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset GSC from DUT side to wake it up. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| dependencies: | |
| - name: Reset GSC on DUT (Allow to fail) (RUN_ONCE) | |
| exec_name: cros_run_command | |
| exec_args: | |
| - host:dut | |
| - command:trunks_send --raw 80010000000c200000000013 | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| - The command recommended by cr50 team http://b/241161724#comment24. | |
| - Reboot after the fw flash is successful. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset EC from DUT and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset EC from DUT side to wake CR50 up and then stop the servod. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: cros_reset_ec (ALWAYS_RUN) | |
| exec_name: cros_reset_ec | |
| exec_args: | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reset EC from DUT side by running connads wake up the device as it will trigger recovering ec, cr50, and other fw. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset GSC from DUT and stop servod (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset GSC from DUT side to wake it up. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| dependencies: | |
| - name: Reset GSC on DUT (Allow to fail) (RUN_ONCE) | |
| exec_name: cros_run_command | |
| exec_args: | |
| - host:dut | |
| - command:trunks_send --raw 80010000000c200000000013 | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| - The command recommended by cr50 team http://b/241161724#comment24. | |
| - Reboot after the fw flash is successful. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Create request to reboot labstation (ALWAYS_RUN) | |
| exec_name: sample_fail | |
| docs: | |
| - Try to create reboot flag file request. | |
| - The action always fails as Servo will be fixed after reboot. | |
| conditions: | |
| - name: Is labstation | |
| exec_name: servo_host_is_labstation | |
| docs: | |
| - Condition to check if the servohost is a labstation. | |
| dependencies: | |
| - name: cros_create_reboot_request | |
| exec_name: cros_create_reboot_request | |
| - name: Servo topology min two children | |
| exec_name: servo_topology_update | |
| exec_args: | |
| - min_child:2 | |
| - persist_topology:true | |
| docs: | |
| - Verify that setup has two servo children. | |
| - Usually that is ccd_gsc|cr50 with servo_micro or c2d2. | |
| conditions: | |
| - name: is_dual_setup | |
| exec_name: is_dual_setup_configured | |
| docs: | |
| - Check whether the servo device has dual setup. This check only applies to the devices that have the dual setup configured on them. | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| recoveries: | |
| - name: Wait for labstation to load (time:'2m0s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Sometimes we can try to connect when labstation is the middle of reboot, so we wait. | |
| - Labstation is expected to complete the reboot within 2 minutes. | |
| - name: Set state:TOPOLOGY_ISSUE (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:TOPOLOGY_ISSUE | |
| recoveries: | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot servo device (RUN_ONCE) (time:'1m10s') | |
| exec_name: servo_reboot | |
| exec_args: | |
| - reboot_timeout:30 | |
| - wait_timeout:30 | |
| docs: | |
| - Reboot servo device via servodtool | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle DTS Mode and Servo Role (ALWAYS_RUN) | |
| exec_name: servo_servod_dts_and_servo_role_toggle_exec | |
| docs: | |
| - Toggle dts mode and servo role to try and recover CCD. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Toggle PD once and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Toggle the servod command servo_pd_role only once. And then stop the servod afterwards. | |
| - 'TODO(otabek): Add dependency for servo initialize.' | |
| dependencies: | |
| - name: Toggle PD once (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:1 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role only once. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle PD (5 times) and stop (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. And then stop the servod afterwards. | |
| conditions: | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| dependencies: | |
| - name: Toggle PD 5 times (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:5 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. | |
| - name: Try fake disconnect and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by mimic reconnection of servo. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: Try fake disconnect | |
| exec_name: servo_fake_disconnect_dut | |
| exec_args: | |
| - delay_in_ms:100 | |
| - timeout_in_ms:2000 | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle CC line and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by toggling cc and stop servod after. | |
| dependencies: | |
| - name: Toggle CC lines (ALWAYS_RUN) | |
| exec_name: servo_servod_cc_toggle | |
| exec_args: | |
| - cc_off_timeout:10 | |
| - cc_on_timeout:30 | |
| docs: | |
| - Toggle cc line connected between servo and DUT to wake up the connection. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot by EC console and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT's EC by servod UART console and stop servod after that. | |
| dependencies: | |
| - name: Reboot by DUT's EC UART (ALWAYS_RUN) | |
| exec_name: servo_set_ec_uart_cmd | |
| exec_args: | |
| - wait_timeout:1 | |
| - value:reboot | |
| docs: | |
| - Try to reboot EC on DUT using servod command. | |
| - It reboots just the embedded controllers on the DUT. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Cold reset the DUT by servod and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| dependencies: | |
| - name: Cold reset by servod (ALWAYS_RUN) | |
| exec_name: servo_power_state_reset | |
| exec_args: | |
| - wait_timeout:1 | |
| - more_logs:true | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reflash Cr50 fw and stop (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Is reflash Cr50 was done more 24 hours ago | |
| exec_name: sample_fail | |
| docs: | |
| - Verify that it is time when we can try to re-flash fw on cr50 (H1). | |
| - Re-flashing limited to once per once per day to avoid over-flashing the device. | |
| conditions: | |
| - name: Is reflash Cr50 was done within 24 hours | |
| exec_name: metrics_found_at_last_time | |
| exec_args: | |
| - metrics_kind:cr50_flash | |
| - time_frame_hours:24 | |
| docs: | |
| - Confirm that no cr50 reflash action has occurred in the past 24 hours. | |
| dependencies: | |
| - name: Reflash Cr50 fw on DUT (RUN_ONCE) (time:'2m30s') | |
| exec_name: cros_reflash_cr50_fw | |
| exec_args: | |
| - flash_timeout:120 | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| - Reboot after the fw flash is successful. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset EC from DUT and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset EC from DUT side to wake CR50 up and then stop the servod. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: cros_reset_ec (ALWAYS_RUN) | |
| exec_name: cros_reset_ec | |
| exec_args: | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reset EC from DUT side by running connads wake up the device as it will trigger recovering ec, cr50, and other fw. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset GSC from DUT and stop servod (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset GSC from DUT side to wake it up. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| dependencies: | |
| - name: Reset GSC on DUT (Allow to fail) (RUN_ONCE) | |
| exec_name: cros_run_command | |
| exec_args: | |
| - host:dut | |
| - command:trunks_send --raw 80010000000c200000000013 | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| - The command recommended by cr50 team http://b/241161724#comment24. | |
| - Reboot after the fw flash is successful. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Create request to reboot labstation (ALWAYS_RUN) | |
| exec_name: sample_fail | |
| docs: | |
| - Try to create reboot flag file request. | |
| - The action always fails as Servo will be fixed after reboot. | |
| conditions: | |
| - name: Is labstation | |
| exec_name: servo_host_is_labstation | |
| docs: | |
| - Condition to check if the servohost is a labstation. | |
| dependencies: | |
| - name: cros_create_reboot_request | |
| exec_name: cros_create_reboot_request | |
| - name: Update USB drive info (Allow to fail) | |
| exec_name: servo_update_usbkey_history | |
| docs: | |
| - Try to update the information of the servo usbkey in inventory and karte. | |
| dependencies: | |
| - name: Verify that USB drive is detectable (Allow to fail) | |
| exec_name: servo_usbkey_is_detected | |
| exec_args: | |
| - file_check:true | |
| docs: | |
| - Will detect the path to USB Drive on servo-host. | |
| - Verify that usb-key is responsive | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| recoveries: | |
| - name: Wait for labstation to load (time:'2m0s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Sometimes we can try to connect when labstation is the middle of reboot, so we wait. | |
| - Labstation is expected to complete the reboot within 2 minutes. | |
| recoveries: | |
| - name: Recover servo with Power-cycle by smart-hub (ALWAYS_RUN) (time:'2m0s') | |
| exec_name: servo_power_cycle_root_servo | |
| exec_args: | |
| - reset_timeout:60 | |
| - wait_timeout:20 | |
| - reset_authorized:false | |
| docs: | |
| - Try to power-cycle the servo via smart usbhub to recover it. | |
| - name: Initialize DUT part for servo (time:'2m0s') | |
| exec_name: init_dut_for_servo | |
| docs: | |
| - Call servod to init dependencies for DUT | |
| dependencies: | |
| - name: Set state:BROKEN (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:BROKEN | |
| - name: Set main servo device | |
| exec_name: servod_set_main_device | |
| docs: | |
| - Set main device is it not set before. | |
| - Applicable if we have more than one child servo device. | |
| conditions: | |
| - name: Servod knows about active_dut_controller control | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:active_dut_controller | |
| recoveries: | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle PD (5 times) and stop (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. And then stop the servod afterwards. | |
| conditions: | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| dependencies: | |
| - name: Toggle PD 5 times (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:5 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. | |
| - name: Toggle CC line and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by toggling cc and stop servod after. | |
| dependencies: | |
| - name: Toggle CC lines (ALWAYS_RUN) | |
| exec_name: servo_servod_cc_toggle | |
| exec_args: | |
| - cc_off_timeout:10 | |
| - cc_on_timeout:30 | |
| docs: | |
| - Toggle cc line connected between servo and DUT to wake up the connection. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot by EC console and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT's EC by servod UART console and stop servod after that. | |
| dependencies: | |
| - name: Reboot by DUT's EC UART (ALWAYS_RUN) | |
| exec_name: servo_set_ec_uart_cmd | |
| exec_args: | |
| - wait_timeout:1 | |
| - value:reboot | |
| docs: | |
| - Try to reboot EC on DUT using servod command. | |
| - It reboots just the embedded controllers on the DUT. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Cold reset the DUT by servod and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| dependencies: | |
| - name: Cold reset by servod (ALWAYS_RUN) | |
| exec_name: servo_power_state_reset | |
| exec_args: | |
| - wait_timeout:1 | |
| - more_logs:true | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset EC from DUT and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset EC from DUT side to wake CR50 up and then stop the servod. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: cros_reset_ec (ALWAYS_RUN) | |
| exec_name: cros_reset_ec | |
| exec_args: | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reset EC from DUT side by running connads wake up the device as it will trigger recovering ec, cr50, and other fw. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Open gsc testlab (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_set | |
| exec_args: | |
| - command:cr50_testlab | |
| - string_value:open | |
| docs: | |
| - If servo uses c2d2/cr50/gsc to control the DUT, open testlab will allowed to work (cr50_reboot, cold_reset, warm_reset) | |
| conditions: | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Verify that the device is a Chromebook by checking for non-Chromebook boards | |
| - name: Expected CCD factory settings | |
| exec_name: servo_ccd_expect_have_factory_reset | |
| docs: | |
| - This devices should use testlab to open CCD and reset capabilities to factory settings. | |
| dependencies: | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Verify that the device is a Chromebook by checking for non-Chromebook boards | |
| - name: Reset CCD to factory settings (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_set | |
| exec_args: | |
| - command:cr50_uart_cmd | |
| - string_value:ccd reset factory | |
| docs: | |
| - Reset CCD to the factory settings. | |
| conditions: | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Verify that the device is a Chromebook by checking for non-Chromebook boards | |
| - name: Expected CCD factory settings | |
| exec_name: servo_ccd_expect_have_factory_reset | |
| docs: | |
| - This devices should use testlab to open CCD and reset capabilities to factory settings. | |
| dependencies: | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Verify that the device is a Chromebook by checking for non-Chromebook boards | |
| recoveries: | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot servo device (RUN_ONCE) (time:'1m10s') | |
| exec_name: servo_reboot | |
| exec_args: | |
| - reboot_timeout:30 | |
| - wait_timeout:30 | |
| docs: | |
| - Reboot servo device via servodtool | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle DTS Mode and Servo Role (ALWAYS_RUN) | |
| exec_name: servo_servod_dts_and_servo_role_toggle_exec | |
| docs: | |
| - Toggle dts mode and servo role to try and recover CCD. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Toggle PD once and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Toggle the servod command servo_pd_role only once. And then stop the servod afterwards. | |
| - 'TODO(otabek): Add dependency for servo initialize.' | |
| dependencies: | |
| - name: Toggle PD once (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:1 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role only once. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle PD (5 times) and stop (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. And then stop the servod afterwards. | |
| conditions: | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| dependencies: | |
| - name: Toggle PD 5 times (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:5 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. | |
| - name: Try fake disconnect and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by mimic reconnection of servo. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: Try fake disconnect | |
| exec_name: servo_fake_disconnect_dut | |
| exec_args: | |
| - delay_in_ms:100 | |
| - timeout_in_ms:2000 | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle CC line and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by toggling cc and stop servod after. | |
| dependencies: | |
| - name: Toggle CC lines (ALWAYS_RUN) | |
| exec_name: servo_servod_cc_toggle | |
| exec_args: | |
| - cc_off_timeout:10 | |
| - cc_on_timeout:30 | |
| docs: | |
| - Toggle cc line connected between servo and DUT to wake up the connection. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot by EC console and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT's EC by servod UART console and stop servod after that. | |
| dependencies: | |
| - name: Reboot by DUT's EC UART (ALWAYS_RUN) | |
| exec_name: servo_set_ec_uart_cmd | |
| exec_args: | |
| - wait_timeout:1 | |
| - value:reboot | |
| docs: | |
| - Try to reboot EC on DUT using servod command. | |
| - It reboots just the embedded controllers on the DUT. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Cold reset the DUT by servod and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| dependencies: | |
| - name: Cold reset by servod (ALWAYS_RUN) | |
| exec_name: servo_power_state_reset | |
| exec_args: | |
| - wait_timeout:1 | |
| - more_logs:true | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reflash Cr50 fw and stop (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Is reflash Cr50 was done more 24 hours ago | |
| exec_name: sample_fail | |
| docs: | |
| - Verify that it is time when we can try to re-flash fw on cr50 (H1). | |
| - Re-flashing limited to once per once per day to avoid over-flashing the device. | |
| conditions: | |
| - name: Is reflash Cr50 was done within 24 hours | |
| exec_name: metrics_found_at_last_time | |
| exec_args: | |
| - metrics_kind:cr50_flash | |
| - time_frame_hours:24 | |
| docs: | |
| - Confirm that no cr50 reflash action has occurred in the past 24 hours. | |
| dependencies: | |
| - name: Reflash Cr50 fw on DUT (RUN_ONCE) (time:'2m30s') | |
| exec_name: cros_reflash_cr50_fw | |
| exec_args: | |
| - flash_timeout:120 | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| - Reboot after the fw flash is successful. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset EC from DUT and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset EC from DUT side to wake CR50 up and then stop the servod. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: cros_reset_ec (ALWAYS_RUN) | |
| exec_name: cros_reset_ec | |
| exec_args: | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reset EC from DUT side by running connads wake up the device as it will trigger recovering ec, cr50, and other fw. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset GSC from DUT and stop servod (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset GSC from DUT side to wake it up. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| dependencies: | |
| - name: Reset GSC on DUT (Allow to fail) (RUN_ONCE) | |
| exec_name: cros_run_command | |
| exec_args: | |
| - host:dut | |
| - command:trunks_send --raw 80010000000c200000000013 | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| - The command recommended by cr50 team http://b/241161724#comment24. | |
| - Reboot after the fw flash is successful. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Verify cr50 console | |
| exec_name: servod_can_read_all | |
| exec_args: | |
| - commands:cr50_ccd_level,cr50_testlab,cr50_ccd_state_flags | |
| - any_one:true | |
| docs: | |
| - Verify that Cr50 console is responsive. | |
| conditions: | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Verify that the device is a Chromebook by checking for non-Chromebook boards | |
| - name: Expected CCD factory settings | |
| exec_name: servo_ccd_expect_have_factory_reset | |
| docs: | |
| - This devices should use testlab to open CCD and reset capabilities to factory settings. | |
| dependencies: | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Verify that the device is a Chromebook by checking for non-Chromebook boards | |
| dependencies: | |
| - name: Initialize DUT part for servo (time:'2m0s') | |
| exec_name: init_dut_for_servo | |
| docs: | |
| - Call servod to init dependencies for DUT | |
| dependencies: | |
| - name: Set state:BROKEN (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:BROKEN | |
| - name: Set main servo device | |
| exec_name: servod_set_main_device | |
| docs: | |
| - Set main device is it not set before. | |
| - Applicable if we have more than one child servo device. | |
| conditions: | |
| - name: Servod knows about active_dut_controller control | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:active_dut_controller | |
| recoveries: | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle PD (5 times) and stop (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. And then stop the servod afterwards. | |
| conditions: | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| dependencies: | |
| - name: Toggle PD 5 times (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:5 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. | |
| - name: Toggle CC line and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by toggling cc and stop servod after. | |
| dependencies: | |
| - name: Toggle CC lines (ALWAYS_RUN) | |
| exec_name: servo_servod_cc_toggle | |
| exec_args: | |
| - cc_off_timeout:10 | |
| - cc_on_timeout:30 | |
| docs: | |
| - Toggle cc line connected between servo and DUT to wake up the connection. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot by EC console and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT's EC by servod UART console and stop servod after that. | |
| dependencies: | |
| - name: Reboot by DUT's EC UART (ALWAYS_RUN) | |
| exec_name: servo_set_ec_uart_cmd | |
| exec_args: | |
| - wait_timeout:1 | |
| - value:reboot | |
| docs: | |
| - Try to reboot EC on DUT using servod command. | |
| - It reboots just the embedded controllers on the DUT. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Cold reset the DUT by servod and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| dependencies: | |
| - name: Cold reset by servod (ALWAYS_RUN) | |
| exec_name: servo_power_state_reset | |
| exec_args: | |
| - wait_timeout:1 | |
| - more_logs:true | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset EC from DUT and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset EC from DUT side to wake CR50 up and then stop the servod. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: cros_reset_ec (ALWAYS_RUN) | |
| exec_name: cros_reset_ec | |
| exec_args: | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reset EC from DUT side by running connads wake up the device as it will trigger recovering ec, cr50, and other fw. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Open gsc testlab (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_set | |
| exec_args: | |
| - command:cr50_testlab | |
| - string_value:open | |
| docs: | |
| - If servo uses c2d2/cr50/gsc to control the DUT, open testlab will allowed to work (cr50_reboot, cold_reset, warm_reset) | |
| conditions: | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Verify that the device is a Chromebook by checking for non-Chromebook boards | |
| - name: Expected CCD factory settings | |
| exec_name: servo_ccd_expect_have_factory_reset | |
| docs: | |
| - This devices should use testlab to open CCD and reset capabilities to factory settings. | |
| dependencies: | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Verify that the device is a Chromebook by checking for non-Chromebook boards | |
| - name: Reset CCD to factory settings (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_set | |
| exec_args: | |
| - command:cr50_uart_cmd | |
| - string_value:ccd reset factory | |
| docs: | |
| - Reset CCD to the factory settings. | |
| conditions: | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Verify that the device is a Chromebook by checking for non-Chromebook boards | |
| - name: Expected CCD factory settings | |
| exec_name: servo_ccd_expect_have_factory_reset | |
| docs: | |
| - This devices should use testlab to open CCD and reset capabilities to factory settings. | |
| dependencies: | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Verify that the device is a Chromebook by checking for non-Chromebook boards | |
| recoveries: | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot servo device (RUN_ONCE) (time:'1m10s') | |
| exec_name: servo_reboot | |
| exec_args: | |
| - reboot_timeout:30 | |
| - wait_timeout:30 | |
| docs: | |
| - Reboot servo device via servodtool | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle DTS Mode and Servo Role (ALWAYS_RUN) | |
| exec_name: servo_servod_dts_and_servo_role_toggle_exec | |
| docs: | |
| - Toggle dts mode and servo role to try and recover CCD. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Toggle PD once and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Toggle the servod command servo_pd_role only once. And then stop the servod afterwards. | |
| - 'TODO(otabek): Add dependency for servo initialize.' | |
| dependencies: | |
| - name: Toggle PD once (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:1 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role only once. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle PD (5 times) and stop (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. And then stop the servod afterwards. | |
| conditions: | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| dependencies: | |
| - name: Toggle PD 5 times (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:5 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. | |
| - name: Try fake disconnect and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by mimic reconnection of servo. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: Try fake disconnect | |
| exec_name: servo_fake_disconnect_dut | |
| exec_args: | |
| - delay_in_ms:100 | |
| - timeout_in_ms:2000 | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle CC line and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by toggling cc and stop servod after. | |
| dependencies: | |
| - name: Toggle CC lines (ALWAYS_RUN) | |
| exec_name: servo_servod_cc_toggle | |
| exec_args: | |
| - cc_off_timeout:10 | |
| - cc_on_timeout:30 | |
| docs: | |
| - Toggle cc line connected between servo and DUT to wake up the connection. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot by EC console and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT's EC by servod UART console and stop servod after that. | |
| dependencies: | |
| - name: Reboot by DUT's EC UART (ALWAYS_RUN) | |
| exec_name: servo_set_ec_uart_cmd | |
| exec_args: | |
| - wait_timeout:1 | |
| - value:reboot | |
| docs: | |
| - Try to reboot EC on DUT using servod command. | |
| - It reboots just the embedded controllers on the DUT. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Cold reset the DUT by servod and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| dependencies: | |
| - name: Cold reset by servod (ALWAYS_RUN) | |
| exec_name: servo_power_state_reset | |
| exec_args: | |
| - wait_timeout:1 | |
| - more_logs:true | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reflash Cr50 fw and stop (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Is reflash Cr50 was done more 24 hours ago | |
| exec_name: sample_fail | |
| docs: | |
| - Verify that it is time when we can try to re-flash fw on cr50 (H1). | |
| - Re-flashing limited to once per once per day to avoid over-flashing the device. | |
| conditions: | |
| - name: Is reflash Cr50 was done within 24 hours | |
| exec_name: metrics_found_at_last_time | |
| exec_args: | |
| - metrics_kind:cr50_flash | |
| - time_frame_hours:24 | |
| docs: | |
| - Confirm that no cr50 reflash action has occurred in the past 24 hours. | |
| dependencies: | |
| - name: Reflash Cr50 fw on DUT (RUN_ONCE) (time:'2m30s') | |
| exec_name: cros_reflash_cr50_fw | |
| exec_args: | |
| - flash_timeout:120 | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| - Reboot after the fw flash is successful. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset EC from DUT and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset EC from DUT side to wake CR50 up and then stop the servod. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: cros_reset_ec (ALWAYS_RUN) | |
| exec_name: cros_reset_ec | |
| exec_args: | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reset EC from DUT side by running connads wake up the device as it will trigger recovering ec, cr50, and other fw. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset GSC from DUT and stop servod (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset GSC from DUT side to wake it up. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| dependencies: | |
| - name: Reset GSC on DUT (Allow to fail) (RUN_ONCE) | |
| exec_name: cros_run_command | |
| exec_args: | |
| - host:dut | |
| - command:trunks_send --raw 80010000000c200000000013 | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| - The command recommended by cr50 team http://b/241161724#comment24. | |
| - Reboot after the fw flash is successful. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Set state:CR50_CONSOLE_MISSING (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:CR50_CONSOLE_MISSING | |
| recoveries: | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot servo device (RUN_ONCE) (time:'1m10s') | |
| exec_name: servo_reboot | |
| exec_args: | |
| - reboot_timeout:30 | |
| - wait_timeout:30 | |
| docs: | |
| - Reboot servo device via servodtool | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle DTS Mode and Servo Role (ALWAYS_RUN) | |
| exec_name: servo_servod_dts_and_servo_role_toggle_exec | |
| docs: | |
| - Toggle dts mode and servo role to try and recover CCD. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Toggle PD once and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Toggle the servod command servo_pd_role only once. And then stop the servod afterwards. | |
| - 'TODO(otabek): Add dependency for servo initialize.' | |
| dependencies: | |
| - name: Toggle PD once (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:1 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role only once. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle PD (5 times) and stop (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. And then stop the servod afterwards. | |
| conditions: | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| dependencies: | |
| - name: Toggle PD 5 times (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:5 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. | |
| - name: Try fake disconnect and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by mimic reconnection of servo. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: Try fake disconnect | |
| exec_name: servo_fake_disconnect_dut | |
| exec_args: | |
| - delay_in_ms:100 | |
| - timeout_in_ms:2000 | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle CC line and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by toggling cc and stop servod after. | |
| dependencies: | |
| - name: Toggle CC lines (ALWAYS_RUN) | |
| exec_name: servo_servod_cc_toggle | |
| exec_args: | |
| - cc_off_timeout:10 | |
| - cc_on_timeout:30 | |
| docs: | |
| - Toggle cc line connected between servo and DUT to wake up the connection. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot by EC console and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT's EC by servod UART console and stop servod after that. | |
| dependencies: | |
| - name: Reboot by DUT's EC UART (ALWAYS_RUN) | |
| exec_name: servo_set_ec_uart_cmd | |
| exec_args: | |
| - wait_timeout:1 | |
| - value:reboot | |
| docs: | |
| - Try to reboot EC on DUT using servod command. | |
| - It reboots just the embedded controllers on the DUT. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Cold reset the DUT by servod and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| dependencies: | |
| - name: Cold reset by servod (ALWAYS_RUN) | |
| exec_name: servo_power_state_reset | |
| exec_args: | |
| - wait_timeout:1 | |
| - more_logs:true | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reflash Cr50 fw and stop (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Is reflash Cr50 was done more 24 hours ago | |
| exec_name: sample_fail | |
| docs: | |
| - Verify that it is time when we can try to re-flash fw on cr50 (H1). | |
| - Re-flashing limited to once per once per day to avoid over-flashing the device. | |
| conditions: | |
| - name: Is reflash Cr50 was done within 24 hours | |
| exec_name: metrics_found_at_last_time | |
| exec_args: | |
| - metrics_kind:cr50_flash | |
| - time_frame_hours:24 | |
| docs: | |
| - Confirm that no cr50 reflash action has occurred in the past 24 hours. | |
| dependencies: | |
| - name: Reflash Cr50 fw on DUT (RUN_ONCE) (time:'2m30s') | |
| exec_name: cros_reflash_cr50_fw | |
| exec_args: | |
| - flash_timeout:120 | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| - Reboot after the fw flash is successful. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset EC from DUT and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset EC from DUT side to wake CR50 up and then stop the servod. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: cros_reset_ec (ALWAYS_RUN) | |
| exec_name: cros_reset_ec | |
| exec_args: | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reset EC from DUT side by running connads wake up the device as it will trigger recovering ec, cr50, and other fw. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset GSC from DUT and stop servod (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset GSC from DUT side to wake it up. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| dependencies: | |
| - name: Reset GSC on DUT (Allow to fail) (RUN_ONCE) | |
| exec_name: cros_run_command | |
| exec_args: | |
| - host:dut | |
| - command:trunks_send --raw 80010000000c200000000013 | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| - The command recommended by cr50 team http://b/241161724#comment24. | |
| - Reboot after the fw flash is successful. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Cr50 testlab is enabled | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:cr50_testlab | |
| - expected_string_value:on | |
| docs: | |
| - Verify that testlab flag is enabled in GSC chip. | |
| - Expect that cr50/GSC will required to set cr50 testlab is enabled. | |
| conditions: | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Verify that the device is a Chromebook by checking for non-Chromebook boards | |
| - name: Is not in cr50 pools | |
| exec_name: dut_not_in_pool_regex | |
| exec_args: | |
| - regex:(?i)^faft-cr50 | |
| docs: | |
| - Verify that DUT is not in a cr-50 pools. | |
| - name: Expected CCD factory settings | |
| exec_name: servo_ccd_expect_have_factory_reset | |
| docs: | |
| - This devices should use testlab to open CCD and reset capabilities to factory settings. | |
| dependencies: | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Verify that the device is a Chromebook by checking for non-Chromebook boards | |
| dependencies: | |
| - name: Set state:CCD_TESTLAB_ISSUE (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:CCD_TESTLAB_ISSUE | |
| recoveries: | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot servo device (RUN_ONCE) (time:'1m10s') | |
| exec_name: servo_reboot | |
| exec_args: | |
| - reboot_timeout:30 | |
| - wait_timeout:30 | |
| docs: | |
| - Reboot servo device via servodtool | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Try fake disconnect and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by mimic reconnection of servo. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: Try fake disconnect | |
| exec_name: servo_fake_disconnect_dut | |
| exec_args: | |
| - delay_in_ms:100 | |
| - timeout_in_ms:2000 | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle CC line and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by toggling cc and stop servod after. | |
| dependencies: | |
| - name: Toggle CC lines (ALWAYS_RUN) | |
| exec_name: servo_servod_cc_toggle | |
| exec_args: | |
| - cc_off_timeout:10 | |
| - cc_on_timeout:30 | |
| docs: | |
| - Toggle cc line connected between servo and DUT to wake up the connection. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Verify EC | |
| exec_name: sample_pass | |
| conditions: | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Verify that the device is a Chromebook by checking for non-Chromebook boards | |
| - name: DUT has CrOS EC | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:supports_cros_ec_communication | |
| - expected_string_value:yes | |
| docs: | |
| - Verify if DUT has ChromeOS firmware for EC | |
| dependencies: | |
| - name: Set state:EC_BROKEN (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:EC_BROKEN | |
| - name: Verify EC console | |
| exec_name: servod_can_read_all | |
| exec_args: | |
| - commands:ec_system_powerstate,ec_board | |
| - any_one:true | |
| conditions: | |
| - name: DUT has CrOS EC | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:supports_cros_ec_communication | |
| - expected_string_value:yes | |
| docs: | |
| - Verify if DUT has ChromeOS firmware for EC | |
| recoveries: | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Try fake disconnect and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by mimic reconnection of servo. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: Try fake disconnect | |
| exec_name: servo_fake_disconnect_dut | |
| exec_args: | |
| - delay_in_ms:100 | |
| - timeout_in_ms:2000 | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle CC line and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by toggling cc and stop servod after. | |
| dependencies: | |
| - name: Toggle CC lines (ALWAYS_RUN) | |
| exec_name: servo_servod_cc_toggle | |
| exec_args: | |
| - cc_off_timeout:10 | |
| - cc_on_timeout:30 | |
| docs: | |
| - Toggle cc line connected between servo and DUT to wake up the connection. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle PD once and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Toggle the servod command servo_pd_role only once. And then stop the servod afterwards. | |
| - 'TODO(otabek): Add dependency for servo initialize.' | |
| dependencies: | |
| - name: Toggle PD once (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:1 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role only once. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot by EC console and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT's EC by servod UART console and stop servod after that. | |
| dependencies: | |
| - name: Reboot by DUT's EC UART (ALWAYS_RUN) | |
| exec_name: servo_set_ec_uart_cmd | |
| exec_args: | |
| - wait_timeout:1 | |
| - value:reboot | |
| docs: | |
| - Try to reboot EC on DUT using servod command. | |
| - It reboots just the embedded controllers on the DUT. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Cold reset the DUT by servod and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| dependencies: | |
| - name: Cold reset by servod (ALWAYS_RUN) | |
| exec_name: servo_power_state_reset | |
| exec_args: | |
| - wait_timeout:1 | |
| - more_logs:true | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset EC from DUT and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset EC from DUT side to wake CR50 up and then stop the servod. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: cros_reset_ec (ALWAYS_RUN) | |
| exec_name: cros_reset_ec | |
| exec_args: | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reset EC from DUT side by running connads wake up the device as it will trigger recovering ec, cr50, and other fw. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Set state:BAD_RIBBON_CABLE (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:BAD_RIBBON_CABLE | |
| - name: Verify power button signal (Allow to fail) | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:pwr_button | |
| - expected_string_value:release | |
| docs: | |
| - verify that pwr_button signal is present. | |
| - If signal is not present then probably we have issue with servo connection. | |
| conditions: | |
| - name: pwr_button_supported_models (RUN_ONCE) | |
| exec_name: dut_check_model | |
| exec_args: | |
| - string_values:arkham,gale,mistral,storm,whirlwind | |
| - invert_result:true | |
| docs: | |
| - power button check is not applicable for these models | |
| recoveries: | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot servo device (RUN_ONCE) (time:'1m10s') | |
| exec_name: servo_reboot | |
| exec_args: | |
| - reboot_timeout:30 | |
| - wait_timeout:30 | |
| docs: | |
| - Reboot servo device via servodtool | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Set state:NO_SSH (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:NO_SSH | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle DTS Mode and Servo Role (ALWAYS_RUN) | |
| exec_name: servo_servod_dts_and_servo_role_toggle_exec | |
| docs: | |
| - Toggle dts mode and servo role to try and recover CCD. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Toggle PD once and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Toggle the servod command servo_pd_role only once. And then stop the servod afterwards. | |
| - 'TODO(otabek): Add dependency for servo initialize.' | |
| dependencies: | |
| - name: Toggle PD once (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:1 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role only once. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle PD (5 times) and stop (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. And then stop the servod afterwards. | |
| conditions: | |
| - name: Is servo_v4(p1) used with type-c connector | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:root.dut_connection_type | |
| - expected_string_value:type-c | |
| docs: | |
| - Verify whether servo_V4(p1) device is connect to DUT using Type-C connection. | |
| dependencies: | |
| - name: Toggle PD 5 times (ALWAYS_RUN) | |
| exec_name: servo_servod_toggle_pd_role | |
| exec_args: | |
| - toggle_times:5 | |
| - wait_in_retry:5 | |
| - wait_before_retry:1 | |
| docs: | |
| - Toggle the servod command servo_pd_role 5 times. | |
| - name: Try fake disconnect and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by mimic reconnection of servo. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: Try fake disconnect | |
| exec_name: servo_fake_disconnect_dut | |
| exec_args: | |
| - delay_in_ms:100 | |
| - timeout_in_ms:2000 | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Toggle CC line and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to repair servod by toggling cc and stop servod after. | |
| dependencies: | |
| - name: Toggle CC lines (ALWAYS_RUN) | |
| exec_name: servo_servod_cc_toggle | |
| exec_args: | |
| - cc_off_timeout:10 | |
| - cc_on_timeout:30 | |
| docs: | |
| - Toggle cc line connected between servo and DUT to wake up the connection. | |
| conditions: | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot by EC console and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT's EC by servod UART console and stop servod after that. | |
| dependencies: | |
| - name: Reboot by DUT's EC UART (ALWAYS_RUN) | |
| exec_name: servo_set_ec_uart_cmd | |
| exec_args: | |
| - wait_timeout:1 | |
| - value:reboot | |
| docs: | |
| - Try to reboot EC on DUT using servod command. | |
| - It reboots just the embedded controllers on the DUT. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Cold reset the DUT by servod and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| dependencies: | |
| - name: Cold reset by servod (ALWAYS_RUN) | |
| exec_name: servo_power_state_reset | |
| exec_args: | |
| - wait_timeout:1 | |
| - more_logs:true | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset EC from DUT and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset EC from DUT side to wake CR50 up and then stop the servod. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: cros_reset_ec (ALWAYS_RUN) | |
| exec_name: cros_reset_ec | |
| exec_args: | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reset EC from DUT side by running connads wake up the device as it will trigger recovering ec, cr50, and other fw. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Force reflash servo_micro fw and stop | |
| exec_name: sample_pass | |
| docs: | |
| - Try to update servo micro firmware | |
| conditions: | |
| - name: Is labstation | |
| exec_name: servo_host_is_labstation | |
| docs: | |
| - Condition to check if the servohost is a labstation. | |
| - name: is_servo_micro | |
| exec_name: is_servo_micro | |
| - name: Is ok to force update servo_micro firmware | |
| exec_name: sample_fail | |
| docs: | |
| - Verify that it is time when we can try to re-flash fw on servo micro. | |
| - Re-flashing limited to once per once per 2 weeks to avoid over-flashing the servo device. | |
| conditions: | |
| - name: Last servo_micro fw updated within 2 weeks | |
| exec_name: metrics_found_at_last_time | |
| exec_args: | |
| - metrics_kind:servo_firmware_update_servo_micro | |
| - time_frame_hours:336 | |
| docs: | |
| - Confirm that servo micro fw update action has occurred in the past 2 weeks. (336 hours) | |
| dependencies: | |
| - name: Force update servo_micro firmware (time:'3m0s') | |
| exec_name: servo_update_servo_firmware | |
| exec_args: | |
| - force_update:true | |
| - ignore_version:true | |
| - servo_board:servo_micro | |
| docs: | |
| - Try to update servo micro firmware | |
| conditions: | |
| - name: Is labstation | |
| exec_name: servo_host_is_labstation | |
| docs: | |
| - Condition to check if the servohost is a labstation. | |
| - name: is_servo_micro | |
| exec_name: is_servo_micro | |
| - name: Is ok to force update servo_micro firmware | |
| exec_name: sample_fail | |
| docs: | |
| - Verify that it is time when we can try to re-flash fw on servo micro. | |
| - Re-flashing limited to once per once per 2 weeks to avoid over-flashing the servo device. | |
| conditions: | |
| - name: Last servo_micro fw updated within 2 weeks | |
| exec_name: metrics_found_at_last_time | |
| exec_args: | |
| - metrics_kind:servo_firmware_update_servo_micro | |
| - time_frame_hours:336 | |
| docs: | |
| - Confirm that servo micro fw update action has occurred in the past 2 weeks. (336 hours) | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reflash Cr50 fw and stop (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Is reflash Cr50 was done more 24 hours ago | |
| exec_name: sample_fail | |
| docs: | |
| - Verify that it is time when we can try to re-flash fw on cr50 (H1). | |
| - Re-flashing limited to once per once per day to avoid over-flashing the device. | |
| conditions: | |
| - name: Is reflash Cr50 was done within 24 hours | |
| exec_name: metrics_found_at_last_time | |
| exec_args: | |
| - metrics_kind:cr50_flash | |
| - time_frame_hours:24 | |
| docs: | |
| - Confirm that no cr50 reflash action has occurred in the past 24 hours. | |
| dependencies: | |
| - name: Reflash Cr50 fw on DUT (RUN_ONCE) (time:'2m30s') | |
| exec_name: cros_reflash_cr50_fw | |
| exec_args: | |
| - flash_timeout:120 | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| - Reboot after the fw flash is successful. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Set state:LID_OPEN_FAILED (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:LID_OPEN_FAILED | |
| - name: Is lid open (Allow to fail) | |
| exec_name: servod_lidopen | |
| docs: | |
| - Verify lid of the is open | |
| - Allowed to fail as check if ont effect the servo functionality. | |
| recoveries: | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reboot by EC console and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT's EC by servod UART console and stop servod after that. | |
| dependencies: | |
| - name: Reboot by DUT's EC UART (ALWAYS_RUN) | |
| exec_name: servo_set_ec_uart_cmd | |
| exec_args: | |
| - wait_timeout:1 | |
| - value:reboot | |
| docs: | |
| - Try to reboot EC on DUT using servod command. | |
| - It reboots just the embedded controllers on the DUT. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Cold reset the DUT by servod and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| dependencies: | |
| - name: Cold reset by servod (ALWAYS_RUN) | |
| exec_name: servo_power_state_reset | |
| exec_args: | |
| - wait_timeout:1 | |
| - more_logs:true | |
| docs: | |
| - Try to reboot DUT by resetting power state command on servod. | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reflash Cr50 fw and stop (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| - name: Is reflash Cr50 was done more 24 hours ago | |
| exec_name: sample_fail | |
| docs: | |
| - Verify that it is time when we can try to re-flash fw on cr50 (H1). | |
| - Re-flashing limited to once per once per day to avoid over-flashing the device. | |
| conditions: | |
| - name: Is reflash Cr50 was done within 24 hours | |
| exec_name: metrics_found_at_last_time | |
| exec_args: | |
| - metrics_kind:cr50_flash | |
| - time_frame_hours:24 | |
| docs: | |
| - Confirm that no cr50 reflash action has occurred in the past 24 hours. | |
| dependencies: | |
| - name: Reflash Cr50 fw on DUT (RUN_ONCE) (time:'2m30s') | |
| exec_name: cros_reflash_cr50_fw | |
| exec_args: | |
| - flash_timeout:120 | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reflash cr50 firmware and reboot AP from DUT side to wake it up. | |
| - Reboot after the fw flash is successful. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Reset EC from DUT and stop (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Try to reset EC from DUT side to wake CR50 up and then stop the servod. | |
| conditions: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: is_servo_type_ccd | |
| exec_name: is_servo_type_ccd | |
| dependencies: | |
| - name: cros_reset_ec (ALWAYS_RUN) | |
| exec_name: cros_reset_ec | |
| exec_args: | |
| - wait_timeout:30 | |
| docs: | |
| - Try to reset EC from DUT side by running connads wake up the device as it will trigger recovering ec, cr50, and other fw. | |
| dependencies: | |
| - name: DUT is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh_dut | |
| docs: | |
| - verify if DUT is SSH-able | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture | |
| - name: Verify battery by servo (Allow to fail) | |
| exec_name: servo_battery_charging | |
| docs: | |
| - Audit battery via servod | |
| conditions: | |
| - name: DUT has CrOS EC | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:supports_cros_ec_communication | |
| - expected_string_value:yes | |
| docs: | |
| - Verify if DUT has ChromeOS firmware for EC | |
| - name: battery_last_charge_readable | |
| exec_name: servo_check_servod_control | |
| exec_args: | |
| - command:battery_full_charge_mah | |
| - name: Record good servo type | |
| exec_name: servo_update_servo_type_label | |
| docs: | |
| - Record servo type information. | |
| - The action need always work if not then we have issue. | |
| dependencies: | |
| - name: Set state:BROKEN (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:BROKEN | |
| - name: Set state:WORKING (ALWAYS_RUN) | |
| exec_name: servo_set_servo_state | |
| exec_args: | |
| - state:WORKING | |
| - name: cros_audit | |
| criticalactions: | |
| - name: 'Set state: needs_repair (ALWAYS_RUN)' | |
| exec_name: dut_set_state | |
| exec_args: | |
| - state:needs_repair | |
| docs: | |
| - The action set devices with state means that repair tsk did not success to recover the devices. | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| recoveries: | |
| - name: Cold reset by servo and wait for SSH (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - This repair action will use servod command to reset power_state on the DUT. | |
| - 'TODO: (blocked by: b/221083688) Collect logs from a successfully repaired DUT.' | |
| conditions: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| dependencies: | |
| - name: Cold reset DUT by servo (ALWAYS_RUN) | |
| exec_name: servo_power_state_reset | |
| exec_args: | |
| - timeout:30 | |
| - more_logs:true | |
| docs: | |
| - Cold reset device by servo and do not wait. | |
| dependencies: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Wait to be SSHable (normal boot) (ALWAYS_RUN) (time:'2m30s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Try to wait device to be sshable after the device being rebooted. | |
| - Waiting time 150 seconds. | |
| - name: Install OS in recovery mode by booting from servo USB-drive (no storage check) (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - This action installs the test image on DUT utilizing the features of servo. | |
| - DUT will be booted in recovery mode. | |
| conditions: | |
| - name: Recovery version has OS image path | |
| exec_name: has_stable_version_cros_image | |
| docs: | |
| - Verify that recovery version has OS image path. | |
| dependencies: | |
| - name: Has a stable-version service (RUN_ONCE) | |
| exec_name: has_stable_version_service_path | |
| docs: | |
| - Verify if we have access to the service provided access to the stable version | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Check that DUT is a Chromebook by checking for non-Chromebook boards | |
| - name: Is servo USB key detected | |
| exec_name: servo_usbkey_is_detected | |
| exec_args: | |
| - file_check:true | |
| docs: | |
| - The action used as codiion. | |
| - The action verify that USB-key is detected and readable. | |
| dependencies: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| dependencies: | |
| - name: Servo USB-Key needs to be reflashed | |
| exec_name: sample_pass | |
| docs: | |
| - Check if it is time to download image to servo usbkey. | |
| - If so, then download the stable image to usbkey. | |
| conditions: | |
| - name: It is time to update USB-drive image | |
| exec_name: cros_is_time_to_force_download_image_to_usbkey | |
| exec_args: | |
| - task_name:recovery | |
| - repair_failed_count:1 | |
| - repair_failed_interval:10 | |
| docs: | |
| - Check if it is time to force download image to usbkey | |
| - from the number of failed recoveries since last successful PARIS repair task. | |
| dependencies: | |
| - name: Download stable image to USB-key (Allow to fail) (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Download lab stable image on servo USB-key | |
| - Download the image can take longer if labstation download parallel a few images. | |
| - This step is allowed to complete successfully even if some | |
| - ' errors happen during download because the image can already' | |
| - ' be present on the USB-drive.' | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Is servo USB key detected | |
| exec_name: servo_usbkey_is_detected | |
| exec_args: | |
| - file_check:true | |
| docs: | |
| - The action used as codiion. | |
| - The action verify that USB-key is detected and readable. | |
| dependencies: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Call servod to download image to USB-key (ALWAYS_RUN) (time:'50m0s') | |
| exec_name: servo_download_image_to_usb | |
| docs: | |
| - This action calls servod to download stable version OS image to servo USB-key. | |
| - name: Remove UPDATE_USBKEY_IMAGE repair-request (ALWAYS_RUN) | |
| exec_name: dut_remove_repair_requests | |
| exec_args: | |
| - requests:UPDATE_USBKEY_IMAGE | |
| docs: | |
| - Remove UPDATE_USBKEY_IMAGE from repair-requests. | |
| - name: Download stable version OS image to servo usbkey if necessary (allow fail) (Allow to fail) (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - This action will download model specific stable version OS image to servo usbkey. | |
| - The action will be skipped if the required image is already loaded. | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Has a stable-version service (RUN_ONCE) | |
| exec_name: has_stable_version_service_path | |
| docs: | |
| - Verify if we have access to the service provided access to the stable version | |
| - name: Stable version image is missing from servo usbkey | |
| exec_name: sample_fail | |
| docs: | |
| - This is a reverse action which fails when required image is already cached in servo usbkey. | |
| - The purpose is to serve as a condition of Download stable image to USB-key action, so that we don't do duplicate download. | |
| - If this action fails, it means the servo usbkey already have required stable_version OS image cached. | |
| conditions: | |
| - name: Servo usbkey has stable image | |
| exec_name: servo_usbkey_has_stable_image | |
| exec_args: | |
| - retry_count:3 | |
| - retry_interval:1 | |
| - usb_file_check:true | |
| docs: | |
| - Check if the usbkey has the stable_version OS image. | |
| - 'TODO: Collect data on the usual number of retries and tweak the default' | |
| dependencies: | |
| - name: servo_servod_echo_host | |
| exec_name: servo_servod_echo_host | |
| - name: Is servo USB key detected | |
| exec_name: servo_usbkey_is_detected | |
| exec_args: | |
| - file_check:true | |
| docs: | |
| - The action used as codiion. | |
| - The action verify that USB-key is detected and readable. | |
| dependencies: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Call servod to download image to USB-key (ALWAYS_RUN) (time:'50m0s') | |
| exec_name: servo_download_image_to_usb | |
| docs: | |
| - This action calls servod to download stable version OS image to servo USB-key. | |
| - name: Remove UPDATE_USBKEY_IMAGE repair-request (ALWAYS_RUN) | |
| exec_name: dut_remove_repair_requests | |
| exec_args: | |
| - requests:UPDATE_USBKEY_IMAGE | |
| docs: | |
| - Remove UPDATE_USBKEY_IMAGE from repair-requests. | |
| - name: Boot DUT in recovery and install from USB-drive (no storage check) (ALWAYS_RUN) (time:'2h13m20s') | |
| exec_name: cros_install_in_recovery_mode | |
| exec_args: | |
| - run_tpm_reset:true | |
| - run_os_install:true | |
| - boot_timeout:480 | |
| - boot_interval:10 | |
| - boot_retry:2 | |
| - halt_timeout:120 | |
| - install_timeout:1200 | |
| - tpm_reset_timeout:60 | |
| - post_install_boot_time:15 | |
| - ignore_reboot_failure:true | |
| - run_storage_checks:false | |
| - badblocks_mode:not | |
| - rw_badblocks_timeout:5400 | |
| - ro_badblocks_timeout:3600 | |
| - after_reboot_check:true | |
| - after_reboot_timeout:150 | |
| - after_reboot_allow_use_servo_reset:true | |
| docs: | |
| - 'This action installs the test image on DUT utilizing ' | |
| - 'the features of servo. DUT will be booted in recovery ' | |
| - 'mode. In some cases RO FW is not allowed to boot in ' | |
| - 'recovery mode with active PD, so we will change it to ' | |
| - sink-mode if required. | |
| - name: Wait to be SSHable (normal boot) (ALWAYS_RUN) (time:'2m30s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Try to wait device to be sshable after the device being rebooted. | |
| - Waiting time 150 seconds. | |
| - name: Remove REIMAGE_BY_USBKEY repair-request (ALWAYS_RUN) | |
| exec_name: dut_remove_repair_requests | |
| exec_args: | |
| - requests:PROVISION,REIMAGE_BY_USBKEY | |
| docs: | |
| - Remove REIMAGE_BY_USBKEY and PROVISION repair-requests. | |
| - name: Update FW from fw-image by servo and wait for boot | |
| exec_name: sample_pass | |
| docs: | |
| - 'This action will repair the firmware on the DUT, and ' | |
| - 'then reboot and wait for the DUT to again become ' | |
| - 'available. This action exists to wrap these component ' | |
| - actions into a single repair action. | |
| conditions: | |
| - name: Recovery version has firmware image path | |
| exec_name: has_stable_version_fw_image | |
| docs: | |
| - Verify that recovery version has firmware image path. | |
| dependencies: | |
| - name: Has a stable-version service (RUN_ONCE) | |
| exec_name: has_stable_version_service_path | |
| docs: | |
| - Verify if we have access to the service provided access to the stable version | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Check that DUT is a Chromebook by checking for non-Chromebook boards | |
| dependencies: | |
| - name: Flash EC (FW) by servo (allowed failed) (Allow to fail) (time:'1h50m0s') | |
| exec_name: cros_update_fw_with_fw_image_by_servo | |
| exec_args: | |
| - update_ec_attempt_count:5 | |
| - download_timeout:600 | |
| - use_cache_extractor:true | |
| - use_fw_targets_from_inventory:true | |
| docs: | |
| - Download fw-image specified in stable version and flash EC to the DUT by servo | |
| - Set timeout for 110 minutes for now as = 10m(download)+4*20m(find/extract file)+20m(ec-update with retry). | |
| - We will retry up to 5 times since there is flakiness on flash EC. | |
| conditions: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| dependencies: | |
| - name: Recovery version has firmware image path | |
| exec_name: has_stable_version_fw_image | |
| docs: | |
| - Verify that recovery version has firmware image path. | |
| dependencies: | |
| - name: Has a stable-version service (RUN_ONCE) | |
| exec_name: has_stable_version_service_path | |
| docs: | |
| - Verify if we have access to the service provided access to the stable version | |
| - name: Sleep 60 seconds (Allow to fail) (ALWAYS_RUN) (time:'1m10s') | |
| exec_name: sample_sleep | |
| exec_args: | |
| - sleep:60 | |
| - name: Disable software write protection via servo (Allow to fail) (time:'1m0s') | |
| exec_name: cros_disable_software_write_protection_by_servo | |
| docs: | |
| - Disable software write protection(for flash firmware) via servo. | |
| dependencies: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Flash AP (FW) with GBB 0x18 by servo (Allow to fail) (time:'1h30m0s') | |
| exec_name: cros_update_fw_with_fw_image_by_servo | |
| exec_args: | |
| - update_ap_attempt_count:3 | |
| - download_timeout:600 | |
| - gbb_flags:0x18 | |
| - use_cache_extractor:true | |
| - use_fw_targets_from_inventory:true | |
| docs: | |
| - Download fw-image specified in stable version and flash AP to the DUT by servo | |
| - Set timeout for 90 minutes for now as = 10m(download)+2*20m(find/extract file)+40m(ap-update with retry). | |
| - We will retry up to 3 times since there may be flakiness on flash AP via servo. | |
| conditions: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| dependencies: | |
| - name: Recovery version has firmware image path | |
| exec_name: has_stable_version_fw_image | |
| docs: | |
| - Verify that recovery version has firmware image path. | |
| dependencies: | |
| - name: Has a stable-version service (RUN_ONCE) | |
| exec_name: has_stable_version_service_path | |
| docs: | |
| - Verify if we have access to the service provided access to the stable version | |
| - name: Wait to be SSHable (normal boot) (ALWAYS_RUN) (time:'2m30s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Try to wait device to be sshable after the device being rebooted. | |
| - Waiting time 150 seconds. | |
| - name: Update fingerpprint FW from USB drive (ALWAYS_RUN) (time:'16m40s') | |
| exec_name: cros_install_in_recovery_mode | |
| exec_args: | |
| - badblocks_mode:not | |
| - run_custom_commands:true | |
| - boot_timeout:480 | |
| - boot_interval:10 | |
| - boot_retry:1 | |
| - halt_timeout:120 | |
| - custom_command_allowed_to_fail:true | |
| - custom_command_timeout:60 | |
| - custom_commands:flash_fp_mcu /opt/google/biod/fw/$(cros_config /fingerprint board)*.bin | |
| - ignore_reboot_failure:true | |
| - after_reboot_check:true | |
| - after_reboot_timeout:150 | |
| - after_reboot_allow_use_servo_reset:true | |
| docs: | |
| - The goal to force update fingerprint fw when devices booted from USB-stick | |
| conditions: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Check that DUT is a Chromebook by checking for non-Chromebook boards | |
| - name: Is servo USB key detected | |
| exec_name: servo_usbkey_is_detected | |
| exec_args: | |
| - file_check:true | |
| docs: | |
| - The action used as codiion. | |
| - The action verify that USB-key is detected and readable. | |
| dependencies: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| dependencies: | |
| - name: Set fw_wp_state to force_off | |
| exec_name: servo_set | |
| exec_args: | |
| - command:fw_wp_state | |
| - string_value:force_off | |
| docs: | |
| - Force disable wp of FW by servo. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Install OS in recovery mode by booting from servo USB-drive (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - This action installs the test image on DUT utilizing the features of servo. | |
| - DUT will be booted in recovery mode. | |
| conditions: | |
| - name: Recovery version has OS image path | |
| exec_name: has_stable_version_cros_image | |
| docs: | |
| - Verify that recovery version has OS image path. | |
| dependencies: | |
| - name: Has a stable-version service (RUN_ONCE) | |
| exec_name: has_stable_version_service_path | |
| docs: | |
| - Verify if we have access to the service provided access to the stable version | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Check that DUT is a Chromebook by checking for non-Chromebook boards | |
| - name: Is servo USB key detected | |
| exec_name: servo_usbkey_is_detected | |
| exec_args: | |
| - file_check:true | |
| docs: | |
| - The action used as codiion. | |
| - The action verify that USB-key is detected and readable. | |
| dependencies: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| dependencies: | |
| - name: Servo USB-Key needs to be reflashed | |
| exec_name: sample_pass | |
| docs: | |
| - Check if it is time to download image to servo usbkey. | |
| - If so, then download the stable image to usbkey. | |
| conditions: | |
| - name: It is time to update USB-drive image | |
| exec_name: cros_is_time_to_force_download_image_to_usbkey | |
| exec_args: | |
| - task_name:recovery | |
| - repair_failed_count:1 | |
| - repair_failed_interval:10 | |
| docs: | |
| - Check if it is time to force download image to usbkey | |
| - from the number of failed recoveries since last successful PARIS repair task. | |
| dependencies: | |
| - name: Download stable image to USB-key (Allow to fail) (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Download lab stable image on servo USB-key | |
| - Download the image can take longer if labstation download parallel a few images. | |
| - This step is allowed to complete successfully even if some | |
| - ' errors happen during download because the image can already' | |
| - ' be present on the USB-drive.' | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Is servo USB key detected | |
| exec_name: servo_usbkey_is_detected | |
| exec_args: | |
| - file_check:true | |
| docs: | |
| - The action used as codiion. | |
| - The action verify that USB-key is detected and readable. | |
| dependencies: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Call servod to download image to USB-key (ALWAYS_RUN) (time:'50m0s') | |
| exec_name: servo_download_image_to_usb | |
| docs: | |
| - This action calls servod to download stable version OS image to servo USB-key. | |
| - name: Remove UPDATE_USBKEY_IMAGE repair-request (ALWAYS_RUN) | |
| exec_name: dut_remove_repair_requests | |
| exec_args: | |
| - requests:UPDATE_USBKEY_IMAGE | |
| docs: | |
| - Remove UPDATE_USBKEY_IMAGE from repair-requests. | |
| - name: Download stable version OS image to servo usbkey if necessary (allow fail) (Allow to fail) (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - This action will download model specific stable version OS image to servo usbkey. | |
| - The action will be skipped if the required image is already loaded. | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Has a stable-version service (RUN_ONCE) | |
| exec_name: has_stable_version_service_path | |
| docs: | |
| - Verify if we have access to the service provided access to the stable version | |
| - name: Stable version image is missing from servo usbkey | |
| exec_name: sample_fail | |
| docs: | |
| - This is a reverse action which fails when required image is already cached in servo usbkey. | |
| - The purpose is to serve as a condition of Download stable image to USB-key action, so that we don't do duplicate download. | |
| - If this action fails, it means the servo usbkey already have required stable_version OS image cached. | |
| conditions: | |
| - name: Servo usbkey has stable image | |
| exec_name: servo_usbkey_has_stable_image | |
| exec_args: | |
| - retry_count:3 | |
| - retry_interval:1 | |
| - usb_file_check:true | |
| docs: | |
| - Check if the usbkey has the stable_version OS image. | |
| - 'TODO: Collect data on the usual number of retries and tweak the default' | |
| dependencies: | |
| - name: servo_servod_echo_host | |
| exec_name: servo_servod_echo_host | |
| - name: Is servo USB key detected | |
| exec_name: servo_usbkey_is_detected | |
| exec_args: | |
| - file_check:true | |
| docs: | |
| - The action used as codiion. | |
| - The action verify that USB-key is detected and readable. | |
| dependencies: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Call servod to download image to USB-key (ALWAYS_RUN) (time:'50m0s') | |
| exec_name: servo_download_image_to_usb | |
| docs: | |
| - This action calls servod to download stable version OS image to servo USB-key. | |
| - name: Remove UPDATE_USBKEY_IMAGE repair-request (ALWAYS_RUN) | |
| exec_name: dut_remove_repair_requests | |
| exec_args: | |
| - requests:UPDATE_USBKEY_IMAGE | |
| docs: | |
| - Remove UPDATE_USBKEY_IMAGE from repair-requests. | |
| - name: Boot DUT in recovery and install from USB-drive (ALWAYS_RUN) (time:'2h13m20s') | |
| exec_name: cros_install_in_recovery_mode | |
| exec_args: | |
| - run_tpm_reset:true | |
| - run_os_install:true | |
| - boot_timeout:480 | |
| - boot_interval:10 | |
| - boot_retry:2 | |
| - halt_timeout:120 | |
| - install_timeout:1200 | |
| - tpm_reset_timeout:60 | |
| - post_install_boot_time:15 | |
| - ignore_reboot_failure:true | |
| - badblocks_mode:auto | |
| - rw_badblocks_timeout:5400 | |
| - ro_badblocks_timeout:3600 | |
| - after_reboot_check:true | |
| - after_reboot_timeout:150 | |
| - after_reboot_allow_use_servo_reset:true | |
| docs: | |
| - 'This action installs the test image on DUT utilizing ' | |
| - 'the features of servo. DUT will be booted in recovery ' | |
| - 'mode. In some cases RO FW is not allowed to boot in ' | |
| - 'recovery mode with active PD, so we will change it to ' | |
| - sink-mode if required. | |
| - name: Wait to be SSHable (normal boot) (ALWAYS_RUN) (time:'2m30s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Try to wait device to be sshable after the device being rebooted. | |
| - Waiting time 150 seconds. | |
| - name: Remove REIMAGE_BY_USBKEY repair-request (ALWAYS_RUN) | |
| exec_name: dut_remove_repair_requests | |
| exec_args: | |
| - requests:PROVISION,REIMAGE_BY_USBKEY | |
| docs: | |
| - Remove REIMAGE_BY_USBKEY and PROVISION repair-requests. | |
| - name: Install OS in recovery mode by booting from servo USB-drive (Flex) (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - The action design only for Flex devices. | |
| - This action installs the test image on DUT utilizing the features of servo. | |
| - When DUT sees USB-key it will always try to boot from it. | |
| conditions: | |
| - name: Is Flex device (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:false | |
| docs: | |
| - Check that DUT is a Flex board | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Is servo USB key detected | |
| exec_name: servo_usbkey_is_detected | |
| exec_args: | |
| - file_check:true | |
| docs: | |
| - The action used as codiion. | |
| - The action verify that USB-key is detected and readable. | |
| dependencies: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Device does not have Intel AMT | |
| exec_name: sample_fail | |
| docs: | |
| - Verify that the device does not have Intel AMT (vPro). | |
| dependencies: | |
| - name: Is Flex device (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:false | |
| docs: | |
| - Check that DUT is a Flex board | |
| - name: Intel AMT is present (ALWAYS_RUN) | |
| exec_name: cros_flex_amt_present | |
| docs: | |
| - Check if Intel AMT (vPro) is present. | |
| conditions: | |
| - name: Is Flex device (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:false | |
| docs: | |
| - Check that DUT is a Flex board | |
| dependencies: | |
| - name: Servo USB-Key needs to be reflashed | |
| exec_name: sample_pass | |
| docs: | |
| - Check if it is time to download image to servo usbkey. | |
| - If so, then download the stable image to usbkey. | |
| conditions: | |
| - name: It is time to update USB-drive image | |
| exec_name: cros_is_time_to_force_download_image_to_usbkey | |
| exec_args: | |
| - task_name:recovery | |
| - repair_failed_count:1 | |
| - repair_failed_interval:10 | |
| docs: | |
| - Check if it is time to force download image to usbkey | |
| - from the number of failed recoveries since last successful PARIS repair task. | |
| dependencies: | |
| - name: Download stable image to USB-key (Allow to fail) (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Download lab stable image on servo USB-key | |
| - Download the image can take longer if labstation download parallel a few images. | |
| - This step is allowed to complete successfully even if some | |
| - ' errors happen during download because the image can already' | |
| - ' be present on the USB-drive.' | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Is servo USB key detected | |
| exec_name: servo_usbkey_is_detected | |
| exec_args: | |
| - file_check:true | |
| docs: | |
| - The action used as codiion. | |
| - The action verify that USB-key is detected and readable. | |
| dependencies: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Call servod to download image to USB-key (ALWAYS_RUN) (time:'50m0s') | |
| exec_name: servo_download_image_to_usb | |
| docs: | |
| - This action calls servod to download stable version OS image to servo USB-key. | |
| - name: Remove UPDATE_USBKEY_IMAGE repair-request (ALWAYS_RUN) | |
| exec_name: dut_remove_repair_requests | |
| exec_args: | |
| - requests:UPDATE_USBKEY_IMAGE | |
| docs: | |
| - Remove UPDATE_USBKEY_IMAGE from repair-requests. | |
| - name: Download stable version OS image to servo usbkey if necessary (allow fail) (Allow to fail) (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - This action will download model specific stable version OS image to servo usbkey. | |
| - The action will be skipped if the required image is already loaded. | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Has a stable-version service (RUN_ONCE) | |
| exec_name: has_stable_version_service_path | |
| docs: | |
| - Verify if we have access to the service provided access to the stable version | |
| - name: Stable version image is missing from servo usbkey | |
| exec_name: sample_fail | |
| docs: | |
| - This is a reverse action which fails when required image is already cached in servo usbkey. | |
| - The purpose is to serve as a condition of Download stable image to USB-key action, so that we don't do duplicate download. | |
| - If this action fails, it means the servo usbkey already have required stable_version OS image cached. | |
| conditions: | |
| - name: Servo usbkey has stable image | |
| exec_name: servo_usbkey_has_stable_image | |
| exec_args: | |
| - retry_count:3 | |
| - retry_interval:1 | |
| - usb_file_check:true | |
| docs: | |
| - Check if the usbkey has the stable_version OS image. | |
| - 'TODO: Collect data on the usual number of retries and tweak the default' | |
| dependencies: | |
| - name: servo_servod_echo_host | |
| exec_name: servo_servod_echo_host | |
| - name: Is servo USB key detected | |
| exec_name: servo_usbkey_is_detected | |
| exec_args: | |
| - file_check:true | |
| docs: | |
| - The action used as codiion. | |
| - The action verify that USB-key is detected and readable. | |
| dependencies: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Call servod to download image to USB-key (ALWAYS_RUN) (time:'50m0s') | |
| exec_name: servo_download_image_to_usb | |
| docs: | |
| - This action calls servod to download stable version OS image to servo USB-key. | |
| - name: Remove UPDATE_USBKEY_IMAGE repair-request (ALWAYS_RUN) | |
| exec_name: dut_remove_repair_requests | |
| exec_args: | |
| - requests:UPDATE_USBKEY_IMAGE | |
| docs: | |
| - Remove UPDATE_USBKEY_IMAGE from repair-requests. | |
| - name: Direct USB-drive to DUT (ALWAYS_RUN) (time:'20s') | |
| exec_name: servo_set | |
| exec_args: | |
| - command:image_usbkey_direction | |
| - string_value:dut_sees_usbkey | |
| docs: | |
| - Switch servo's USB-drive to point to DUT. | |
| dependencies: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Boot Flex from USB on next boot (ALWAYS_RUN) | |
| exec_name: cros_flex_usb_nextboot | |
| docs: | |
| - Use efibootmgr to boot from USB on the next boot. | |
| conditions: | |
| - name: Device has UEFI firmware (ALWAYS_RUN) | |
| exec_name: cros_run_command | |
| exec_args: | |
| - host:dut | |
| - command:test -d /sys/firmware/efi | |
| - background:false | |
| docs: | |
| - Check if the device has UEFI firmware. | |
| - name: Power OFF DUT by servo (ALWAYS_RUN) | |
| exec_name: servo_set | |
| exec_args: | |
| - command:power_state | |
| - string_value:off | |
| - timeout:30 | |
| docs: | |
| - Turn DUT OFF by servo and do not wait. | |
| dependencies: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Sleep 10 seconds (Allow to fail) (ALWAYS_RUN) (time:'11s') | |
| exec_name: sample_sleep | |
| exec_args: | |
| - sleep:10 | |
| - name: Power ON DUT by servo (ALWAYS_RUN) | |
| exec_name: servo_set | |
| exec_args: | |
| - command:power_state | |
| - string_value:on | |
| docs: | |
| - Turn DUT ON by servo and do not wait. | |
| dependencies: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Sleep 10 seconds (Allow to fail) (ALWAYS_RUN) (time:'11s') | |
| exec_name: sample_sleep | |
| exec_args: | |
| - sleep:10 | |
| - name: Wait to be SSHable (normal boot) (ALWAYS_RUN) (time:'2m30s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Try to wait device to be sshable after the device being rebooted. | |
| - Waiting time 150 seconds. | |
| - name: Print active devices (Allow to fail) (ALWAYS_RUN) | |
| exec_name: cros_run_command | |
| exec_args: | |
| - host:dut | |
| - command:lsblk | |
| - background:false | |
| docs: | |
| - Print active devices visible for DUT. | |
| - name: Is Flex booted from USB-drive (ALWAYS_RUN) | |
| exec_name: cros_run_command | |
| exec_args: | |
| - host:dut | |
| - command:is_running_from_installer |grep yes | |
| - background:false | |
| docs: | |
| - Check if device booted from USB in installer mode. | |
| conditions: | |
| - name: Is Flex device (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:false | |
| docs: | |
| - Check that DUT is a Flex board | |
| - name: Run chromeos-install for Flex (ALWAYS_RUN) (time:'10m0s') | |
| exec_name: cros_run_command | |
| exec_args: | |
| - host:dut | |
| - command:chromeos-install --dst $(lsblk --bytes --output NAME --paths -I 259 -n -d) --yes | |
| - background:false | |
| docs: | |
| - Run chromeos-install for Flex DUTs with detecting destination. | |
| - Flex device does not detect destination as part of chromeos-install script. | |
| dependencies: | |
| - name: Is Flex device (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:false | |
| docs: | |
| - Check that DUT is a Flex board | |
| - name: Sleep 10 seconds (Allow to fail) (ALWAYS_RUN) (time:'11s') | |
| exec_name: sample_sleep | |
| exec_args: | |
| - sleep:10 | |
| - name: Power-off the DUT using AMT (ALWAYS_RUN) | |
| exec_name: cros_flex_amt_power_off | |
| docs: | |
| - Power the DUT off using Intel AMT (vPro). | |
| conditions: | |
| - name: Is Flex device (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:false | |
| docs: | |
| - Check that DUT is a Flex board | |
| - name: Intel AMT is present (ALWAYS_RUN) | |
| exec_name: cros_flex_amt_present | |
| docs: | |
| - Check if Intel AMT (vPro) is present. | |
| conditions: | |
| - name: Is Flex device (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:false | |
| docs: | |
| - Check that DUT is a Flex board | |
| - name: Direct USB-drive to servo host (ALWAYS_RUN) (time:'20s') | |
| exec_name: servo_set | |
| exec_args: | |
| - command:image_usbkey_direction | |
| - string_value:servo_sees_usbkey | |
| docs: | |
| - Switch servo's USB-drive to point to servo-host. | |
| dependencies: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Power-on the DUT using AMT (ALWAYS_RUN) | |
| exec_name: cros_flex_amt_power_on | |
| docs: | |
| - Power the DUT on using Intel AMT (vPro). | |
| conditions: | |
| - name: Is Flex device (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:false | |
| docs: | |
| - Check that DUT is a Flex board | |
| - name: Intel AMT is present (ALWAYS_RUN) | |
| exec_name: cros_flex_amt_present | |
| docs: | |
| - Check if Intel AMT (vPro) is present. | |
| conditions: | |
| - name: Is Flex device (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:false | |
| docs: | |
| - Check that DUT is a Flex board | |
| - name: Wait to be SSHable (normal boot) (ALWAYS_RUN) (time:'2m30s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Try to wait device to be sshable after the device being rebooted. | |
| - Waiting time 150 seconds. | |
| - name: Remove REIMAGE_BY_USBKEY repair-request (ALWAYS_RUN) | |
| exec_name: dut_remove_repair_requests | |
| exec_args: | |
| - requests:PROVISION,REIMAGE_BY_USBKEY | |
| docs: | |
| - Remove REIMAGE_BY_USBKEY and PROVISION repair-requests. | |
| - name: Install OS in recovery mode by booting from servo USB-drive (Flex with AMT) (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - The action design only for Flex devices. | |
| - This action installs the test image on DUT utilizing the features of servo. | |
| - Uses Intel AMT (vPro) to power off and power on the DUT. | |
| - When DUT sees USB-key it will always try to boot from it. | |
| conditions: | |
| - name: Is Flex device (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:false | |
| docs: | |
| - Check that DUT is a Flex board | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Is servo USB key detected | |
| exec_name: servo_usbkey_is_detected | |
| exec_args: | |
| - file_check:true | |
| docs: | |
| - The action used as codiion. | |
| - The action verify that USB-key is detected and readable. | |
| dependencies: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Device has Intel AMT | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that the device has Intel AMT (vPro). | |
| dependencies: | |
| - name: Is Flex device (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:false | |
| docs: | |
| - Check that DUT is a Flex board | |
| - name: Intel AMT is present (ALWAYS_RUN) | |
| exec_name: cros_flex_amt_present | |
| docs: | |
| - Check if Intel AMT (vPro) is present. | |
| conditions: | |
| - name: Is Flex device (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:false | |
| docs: | |
| - Check that DUT is a Flex board | |
| dependencies: | |
| - name: Servo USB-Key needs to be reflashed | |
| exec_name: sample_pass | |
| docs: | |
| - Check if it is time to download image to servo usbkey. | |
| - If so, then download the stable image to usbkey. | |
| conditions: | |
| - name: It is time to update USB-drive image | |
| exec_name: cros_is_time_to_force_download_image_to_usbkey | |
| exec_args: | |
| - task_name:recovery | |
| - repair_failed_count:1 | |
| - repair_failed_interval:10 | |
| docs: | |
| - Check if it is time to force download image to usbkey | |
| - from the number of failed recoveries since last successful PARIS repair task. | |
| dependencies: | |
| - name: Download stable image to USB-key (Allow to fail) (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Download lab stable image on servo USB-key | |
| - Download the image can take longer if labstation download parallel a few images. | |
| - This step is allowed to complete successfully even if some | |
| - ' errors happen during download because the image can already' | |
| - ' be present on the USB-drive.' | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Is servo USB key detected | |
| exec_name: servo_usbkey_is_detected | |
| exec_args: | |
| - file_check:true | |
| docs: | |
| - The action used as codiion. | |
| - The action verify that USB-key is detected and readable. | |
| dependencies: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Call servod to download image to USB-key (ALWAYS_RUN) (time:'50m0s') | |
| exec_name: servo_download_image_to_usb | |
| docs: | |
| - This action calls servod to download stable version OS image to servo USB-key. | |
| - name: Remove UPDATE_USBKEY_IMAGE repair-request (ALWAYS_RUN) | |
| exec_name: dut_remove_repair_requests | |
| exec_args: | |
| - requests:UPDATE_USBKEY_IMAGE | |
| docs: | |
| - Remove UPDATE_USBKEY_IMAGE from repair-requests. | |
| - name: Download stable version OS image to servo usbkey if necessary (allow fail) (Allow to fail) (RUN_ONCE) | |
| exec_name: sample_pass | |
| docs: | |
| - This action will download model specific stable version OS image to servo usbkey. | |
| - The action will be skipped if the required image is already loaded. | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Has a stable-version service (RUN_ONCE) | |
| exec_name: has_stable_version_service_path | |
| docs: | |
| - Verify if we have access to the service provided access to the stable version | |
| - name: Stable version image is missing from servo usbkey | |
| exec_name: sample_fail | |
| docs: | |
| - This is a reverse action which fails when required image is already cached in servo usbkey. | |
| - The purpose is to serve as a condition of Download stable image to USB-key action, so that we don't do duplicate download. | |
| - If this action fails, it means the servo usbkey already have required stable_version OS image cached. | |
| conditions: | |
| - name: Servo usbkey has stable image | |
| exec_name: servo_usbkey_has_stable_image | |
| exec_args: | |
| - retry_count:3 | |
| - retry_interval:1 | |
| - usb_file_check:true | |
| docs: | |
| - Check if the usbkey has the stable_version OS image. | |
| - 'TODO: Collect data on the usual number of retries and tweak the default' | |
| dependencies: | |
| - name: servo_servod_echo_host | |
| exec_name: servo_servod_echo_host | |
| - name: Is servo USB key detected | |
| exec_name: servo_usbkey_is_detected | |
| exec_args: | |
| - file_check:true | |
| docs: | |
| - The action used as codiion. | |
| - The action verify that USB-key is detected and readable. | |
| dependencies: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Call servod to download image to USB-key (ALWAYS_RUN) (time:'50m0s') | |
| exec_name: servo_download_image_to_usb | |
| docs: | |
| - This action calls servod to download stable version OS image to servo USB-key. | |
| - name: Remove UPDATE_USBKEY_IMAGE repair-request (ALWAYS_RUN) | |
| exec_name: dut_remove_repair_requests | |
| exec_args: | |
| - requests:UPDATE_USBKEY_IMAGE | |
| docs: | |
| - Remove UPDATE_USBKEY_IMAGE from repair-requests. | |
| - name: Direct USB-drive to DUT (ALWAYS_RUN) (time:'20s') | |
| exec_name: servo_set | |
| exec_args: | |
| - command:image_usbkey_direction | |
| - string_value:dut_sees_usbkey | |
| docs: | |
| - Switch servo's USB-drive to point to DUT. | |
| dependencies: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Power-off the DUT using AMT (ALWAYS_RUN) | |
| exec_name: cros_flex_amt_power_off | |
| docs: | |
| - Power the DUT off using Intel AMT (vPro). | |
| conditions: | |
| - name: Is Flex device (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:false | |
| docs: | |
| - Check that DUT is a Flex board | |
| - name: Intel AMT is present (ALWAYS_RUN) | |
| exec_name: cros_flex_amt_present | |
| docs: | |
| - Check if Intel AMT (vPro) is present. | |
| conditions: | |
| - name: Is Flex device (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:false | |
| docs: | |
| - Check that DUT is a Flex board | |
| - name: Sleep 10 seconds (Allow to fail) (ALWAYS_RUN) (time:'11s') | |
| exec_name: sample_sleep | |
| exec_args: | |
| - sleep:10 | |
| - name: Power-on the DUT using AMT (ALWAYS_RUN) | |
| exec_name: cros_flex_amt_power_on | |
| docs: | |
| - Power the DUT on using Intel AMT (vPro). | |
| conditions: | |
| - name: Is Flex device (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:false | |
| docs: | |
| - Check that DUT is a Flex board | |
| - name: Intel AMT is present (ALWAYS_RUN) | |
| exec_name: cros_flex_amt_present | |
| docs: | |
| - Check if Intel AMT (vPro) is present. | |
| conditions: | |
| - name: Is Flex device (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:false | |
| docs: | |
| - Check that DUT is a Flex board | |
| - name: Sleep 10 seconds (Allow to fail) (ALWAYS_RUN) (time:'11s') | |
| exec_name: sample_sleep | |
| exec_args: | |
| - sleep:10 | |
| - name: Wait to be SSHable (normal boot) (ALWAYS_RUN) (time:'2m30s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Try to wait device to be sshable after the device being rebooted. | |
| - Waiting time 150 seconds. | |
| - name: Print active devices (Allow to fail) (ALWAYS_RUN) | |
| exec_name: cros_run_command | |
| exec_args: | |
| - host:dut | |
| - command:lsblk | |
| - background:false | |
| docs: | |
| - Print active devices visible for DUT. | |
| - name: Is Flex booted from USB-drive (ALWAYS_RUN) | |
| exec_name: cros_run_command | |
| exec_args: | |
| - host:dut | |
| - command:is_running_from_installer |grep yes | |
| - background:false | |
| docs: | |
| - Check if device booted from USB in installer mode. | |
| conditions: | |
| - name: Is Flex device (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:false | |
| docs: | |
| - Check that DUT is a Flex board | |
| - name: Run chromeos-install for Flex (ALWAYS_RUN) (time:'10m0s') | |
| exec_name: cros_run_command | |
| exec_args: | |
| - host:dut | |
| - command:chromeos-install --dst $(lsblk --bytes --output NAME --paths -I 259 -n -d) --yes | |
| - background:false | |
| docs: | |
| - Run chromeos-install for Flex DUTs with detecting destination. | |
| - Flex device does not detect destination as part of chromeos-install script. | |
| dependencies: | |
| - name: Is Flex device (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:false | |
| docs: | |
| - Check that DUT is a Flex board | |
| - name: Sleep 10 seconds (Allow to fail) (ALWAYS_RUN) (time:'11s') | |
| exec_name: sample_sleep | |
| exec_args: | |
| - sleep:10 | |
| - name: Power-off the DUT using AMT (ALWAYS_RUN) | |
| exec_name: cros_flex_amt_power_off | |
| docs: | |
| - Power the DUT off using Intel AMT (vPro). | |
| conditions: | |
| - name: Is Flex device (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:false | |
| docs: | |
| - Check that DUT is a Flex board | |
| - name: Intel AMT is present (ALWAYS_RUN) | |
| exec_name: cros_flex_amt_present | |
| docs: | |
| - Check if Intel AMT (vPro) is present. | |
| conditions: | |
| - name: Is Flex device (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:false | |
| docs: | |
| - Check that DUT is a Flex board | |
| - name: Direct USB-drive to servo host (ALWAYS_RUN) (time:'20s') | |
| exec_name: servo_set | |
| exec_args: | |
| - command:image_usbkey_direction | |
| - string_value:servo_sees_usbkey | |
| docs: | |
| - Switch servo's USB-drive to point to servo-host. | |
| dependencies: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Power-on the DUT using AMT (ALWAYS_RUN) | |
| exec_name: cros_flex_amt_power_on | |
| docs: | |
| - Power the DUT on using Intel AMT (vPro). | |
| conditions: | |
| - name: Is Flex device (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:false | |
| docs: | |
| - Check that DUT is a Flex board | |
| - name: Intel AMT is present (ALWAYS_RUN) | |
| exec_name: cros_flex_amt_present | |
| docs: | |
| - Check if Intel AMT (vPro) is present. | |
| conditions: | |
| - name: Is Flex device (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:false | |
| docs: | |
| - Check that DUT is a Flex board | |
| - name: Wait to be SSHable (normal boot) (ALWAYS_RUN) (time:'2m30s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Try to wait device to be sshable after the device being rebooted. | |
| - Waiting time 150 seconds. | |
| - name: Remove REIMAGE_BY_USBKEY repair-request (ALWAYS_RUN) | |
| exec_name: dut_remove_repair_requests | |
| exec_args: | |
| - requests:PROVISION,REIMAGE_BY_USBKEY | |
| docs: | |
| - Remove REIMAGE_BY_USBKEY and PROVISION repair-requests. | |
| - name: Install OS in DEV mode by USB-drive (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - This action installs the test image on DUT after booking the DUT in dev mode. | |
| conditions: | |
| - name: Recovery version has OS image path | |
| exec_name: has_stable_version_cros_image | |
| docs: | |
| - Verify that recovery version has OS image path. | |
| dependencies: | |
| - name: Has a stable-version service (RUN_ONCE) | |
| exec_name: has_stable_version_service_path | |
| docs: | |
| - Verify if we have access to the service provided access to the stable version | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Check that DUT is a Chromebook by checking for non-Chromebook boards | |
| - name: Is servo USB key detected | |
| exec_name: servo_usbkey_is_detected | |
| exec_args: | |
| - file_check:true | |
| docs: | |
| - The action used as codiion. | |
| - The action verify that USB-key is detected and readable. | |
| dependencies: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| dependencies: | |
| - name: Boot DUT from USB in DEV mode (ALWAYS_RUN) (time:'10m50s') | |
| exec_name: cros_dev_mode_boot_from_servo_usb_drive | |
| exec_args: | |
| - boot_retry:2 | |
| - boot_timeout:600 | |
| - retry_interval:1 | |
| - verify_usbkey_boot:true | |
| docs: | |
| - Restart and try to boot from USB-drive | |
| - First boot in dev mode can take time so set boot time to 10 minutes. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Run install after boot from USB-drive (ALWAYS_RUN) (time:'20m0s') | |
| exec_name: cros_run_chromeos_install_command_after_boot_usbdrive | |
| docs: | |
| - Perform install process when device booted from USB-drive. | |
| - name: Cold reset DUT by servo and wait to boot (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Cold reset device by servo and wait for DUT to become ping-able. | |
| conditions: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| dependencies: | |
| - name: Cold reset DUT by servo (ALWAYS_RUN) | |
| exec_name: servo_power_state_reset | |
| exec_args: | |
| - timeout:30 | |
| - more_logs:true | |
| docs: | |
| - Cold reset device by servo and do not wait. | |
| dependencies: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Wait to be pingable (normal boot) (ALWAYS_RUN) (time:'2m30s') | |
| exec_name: cros_ping | |
| docs: | |
| - Wait DUT to be pingable after some action on it. | |
| - Waiting time 150 seconds. | |
| - name: Wait to be SSHable (normal boot) (ALWAYS_RUN) (time:'2m30s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Try to wait device to be sshable after the device being rebooted. | |
| - Waiting time 150 seconds. | |
| - name: Remove REIMAGE_BY_USBKEY repair-request (ALWAYS_RUN) | |
| exec_name: dut_remove_repair_requests | |
| exec_args: | |
| - requests:PROVISION,REIMAGE_BY_USBKEY | |
| docs: | |
| - Remove REIMAGE_BY_USBKEY and PROVISION repair-requests. | |
| - name: Reset power using servo if booted from USB | |
| exec_name: sample_pass | |
| docs: | |
| - 'This action will reboot the DUT using servo if device ' | |
| - 'is not booted after off/on performed as part of ' | |
| - re-imaging the device from USB device. | |
| conditions: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| dependencies: | |
| - name: Cold reset DUT by servo (ALWAYS_RUN) | |
| exec_name: servo_power_state_reset | |
| exec_args: | |
| - timeout:30 | |
| - more_logs:true | |
| docs: | |
| - Cold reset device by servo and do not wait. | |
| dependencies: | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Wait to be SSHable (normal boot) (ALWAYS_RUN) (time:'2m30s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Try to wait device to be sshable after the device being rebooted. | |
| - Waiting time 150 seconds. | |
| - name: Audit USB-drive from DUT (time:'1h0m0s') | |
| exec_name: audit_usb_from_dut_side | |
| exec_args: | |
| - audit_timeout_min:58 | |
| docs: | |
| - Audit the USB drive. | |
| - Run badblocks to test USB-drive from DUT side. | |
| - Timeout is 1 hour. | |
| dependencies: | |
| - name: Servo state is working | |
| exec_name: servo_match_state | |
| exec_args: | |
| - state:WORKING | |
| docs: | |
| - check the servo's state is WORKING. | |
| - name: Is servod running (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Verify that servo host specified in setup and servod is running. | |
| dependencies: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Verify servod is responsive (ALWAYS_RUN) (time:'10s') | |
| exec_name: servod_echo | |
| exec_args: | |
| - ssh_check:false | |
| conditions: | |
| - name: Setup has servo info | |
| exec_name: dut_servo_host_present | |
| - name: Device NOT booted from USB-drive (ALWAYS_RUN) | |
| exec_name: sample_fail | |
| docs: | |
| - Verify that device was not booted from USB-drive. | |
| conditions: | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Check that DUT is a Chromebook by checking for non-Chromebook boards | |
| - name: Device booted from USB-drive (ALWAYS_RUN) | |
| exec_name: cros_booted_from_external_storage | |
| docs: | |
| - Verify that device was booted from USB-drive. | |
| recoveries: | |
| - name: Set default boot as disk and reboot (ALWAYS_RUN) | |
| exec_name: sample_pass | |
| docs: | |
| - Set default boot from disk and reboot. | |
| dependencies: | |
| - name: Set default boot as disk | |
| exec_name: cros_update_crossystem | |
| exec_args: | |
| - command:dev_default_boot | |
| - value:disk | |
| - check_after_update:true | |
| docs: | |
| - Set default boot from disk by crossystem. | |
| - name: Simple reboot (ALWAYS_RUN) | |
| exec_name: cros_run_command | |
| exec_args: | |
| - host:dut | |
| - command:reboot | |
| - background:true | |
| docs: | |
| - Simple un-blocker reboot. | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| - name: Print block devices of the DUT (Allow to fail) | |
| exec_name: cros_run_command | |
| exec_args: | |
| - host:dut | |
| - command:lsblk | |
| docs: | |
| - Lsblk is used to display details about block devices and these blocks. | |
| - name: Check if USB-key drop connection after sleep (time:'3m20s') | |
| exec_name: servo_usbkey_is_detected | |
| exec_args: | |
| - file_check:true | |
| - check_drop_connection:true | |
| - check_drop_connection_timeout:120 | |
| docs: | |
| - The action verify that USB-key is detected and readable. | |
| - The check is performed with sleep for 2 minutes to verify that USB-key would stay and be able detected | |
| recoveries: | |
| - name: Quick provision OS | |
| exec_name: sample_pass | |
| docs: | |
| - Install stable OS on the device. | |
| conditions: | |
| - name: Recovery version has OS image path | |
| exec_name: has_stable_version_cros_image | |
| docs: | |
| - Verify that recovery version has OS image path. | |
| dependencies: | |
| - name: Has a stable-version service (RUN_ONCE) | |
| exec_name: has_stable_version_service_path | |
| docs: | |
| - Verify if we have access to the service provided access to the stable version | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| - name: Internal storage is responsive | |
| exec_name: cros_is_file_system_writable | |
| exec_args: | |
| - paths:/mnt/stateful_partition,/var/tmp,/mnt/stateful_partition/encrypted | |
| docs: | |
| - Verify that internal storage is responsive | |
| dependencies: | |
| - name: Device is SSHable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| docs: | |
| - Verify that device is reachable by SSH. | |
| - Limited to 15 seconds. | |
| dependencies: | |
| - name: Call provision for DUT (ALWAYS_RUN) (time:'1h0m0s') | |
| exec_name: cros_provision | |
| docs: | |
| - Call provision OS of the DUT. | |
| - name: Remove PROVISION repair-request (ALWAYS_RUN) | |
| exec_name: dut_remove_repair_requests | |
| exec_args: | |
| - requests:PROVISION | |
| docs: | |
| - Remove a PROVISION repair-request. | |
| - name: close (Allow to fail) | |
| criticalactions: | |
| - name: Close Servo-host (Allow to fail) | |
| exec_name: sample_pass | |
| conditions: | |
| - name: Servo-host known | |
| exec_name: dut_servo_host_present | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Verify that the device is a Chromebook by checking for non-Chromebook boards | |
| - name: Servo-host is sshable (ALWAYS_RUN) (time:'15s') | |
| exec_name: cros_ssh | |
| exec_args: | |
| - device_type:servo | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Copy messages from servo-host (Allow to fail) | |
| exec_name: cros_copy_to_logs | |
| exec_args: | |
| - src_host_type:servo_host | |
| - src_path:/var/log/messages | |
| - src_type:file | |
| - use_host_dir:true | |
| docs: | |
| - Try to collect /var/log/messages from servo-host. | |
| conditions: | |
| - name: Servo-host known | |
| exec_name: dut_servo_host_present | |
| - name: Copy eventlog.txt from servo-host (Allow to fail) | |
| exec_name: cros_copy_to_logs | |
| exec_args: | |
| - src_host_type:servo_host | |
| - src_path:/var/log/eventlog.txt | |
| - src_type:file | |
| - use_host_dir:true | |
| docs: | |
| - Try to collect /var/log/eventlog.txt from servo-host. | |
| conditions: | |
| - name: Servo-host known | |
| exec_name: dut_servo_host_present | |
| - name: Collect dmesg logs from Servo-host (Allow to fail) | |
| exec_name: cros_dmesg | |
| exec_args: | |
| - device_type:servo_host | |
| - use_host_dir:true | |
| docs: | |
| - Collect the entire output of dmesg | |
| - name: Collect servod logs (Allow to fail) | |
| exec_name: cros_collect_servod_logs | |
| docs: | |
| - Try to collect all servod logs since latest start time. | |
| conditions: | |
| - name: Servo-host known | |
| exec_name: dut_servo_host_present | |
| - name: Remove in-use flag on servo-host (Allow to fail) | |
| exec_name: cros_remove_servo_in_use | |
| conditions: | |
| - name: Servo-host known | |
| exec_name: dut_servo_host_present | |
| - name: Remove request to reboot if servo is good (Allow to fail) | |
| exec_name: cros_remove_reboot_request | |
| conditions: | |
| - name: Is a Chromebook (RUN_ONCE) | |
| exec_name: dut_check_board | |
| exec_args: | |
| - string_values:aurora,reven | |
| - invert_result:true | |
| docs: | |
| - Verify that the device is a Chromebook by checking for non-Chromebook boards | |
| - name: Servo-host known | |
| exec_name: dut_servo_host_present | |
| - name: Is servo_state:working | |
| exec_name: servo_match_state | |
| exec_args: | |
| - state:WORKING | |
| docs: | |
| - check the servo's state is ServoStateWorking. | |
| - name: Turn off servo usbkey power (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_set | |
| exec_args: | |
| - command:image_usbkey_pwr | |
| - string_value:off | |
| docs: | |
| - Ensure that servo usbkey power is in off state. | |
| conditions: | |
| - name: Servo-host known | |
| exec_name: dut_servo_host_present | |
| - name: Stop servod (Allow to fail) (ALWAYS_RUN) | |
| exec_name: servo_host_servod_stop | |
| docs: | |
| - Stop the servod daemon. | |
| - Allowed to fail as can be run when servod is not running. | |
| dependencies: | |
| - name: Save UART capture (Allow to fail) | |
| exec_name: servod_save_uart_capture | |
| dependencies: | |
| - name: Stop UART capture (Allow to fail) | |
| exec_name: servod_stop_uart_capture |