| 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: | |