| # Copyright (c) 2018 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| """Autotest for Aver VC520/CAM520 camera firmware updater.""" |
| |
| import logging |
| import os |
| import re |
| import time |
| |
| |
| from autotest_lib.client.common_lib import error |
| from autotest_lib.client.common_lib.cros import power_cycle_usb_util |
| from autotest_lib.client.common_lib.cros.cfm.usb import usb_device_collector |
| from autotest_lib.server import test |
| from autotest_lib.server.cros import filesystem_util |
| |
| |
| FW_PATH_BASE = '/lib/firmware' |
| FW_PKG_ORIGIN = 'aver' |
| FW_PKG_BACKUP = 'aver_backup' |
| FW_PKG_TEST = 'aver_520_18.02' |
| LOG_FILE = '/tmp/aver-updater.log' |
| POWER_CYCLE_WAIT_TIME_SEC = 240 |
| |
| |
| class enterprise_CFM_Aver520Updater(test.test): |
| """ |
| Aver camera firmware test on Chrome For Meeting devices |
| This test works for both Aver VC520 and CAM520. |
| The test follows the following steps |
| 1) Check if the filesystem is writable |
| If not make the filesystem writable and reboot |
| 2) Backup the existing firmware file on DUT |
| 3) Copy the older firmware files to DUT |
| 4) Force update older firmware on Aver Camera |
| 5) Restore the original firmware files on DUT |
| 4) Power cycle usb port to simulate unplug/replug of device which |
| should initiate a firmware update |
| 5) Wait for firmware update to finish and check firmware version |
| 6) Cleanup |
| |
| """ |
| |
| version = 1 |
| |
| def initialize(self, host, camera): |
| """ |
| Initializes the class. |
| |
| Stores the firmware file path. |
| Gets the board type. |
| Reads the current firmware versions. |
| """ |
| |
| self.host = host |
| self.camera = camera |
| self.fw_path_test = os.path.join(FW_PATH_BASE, |
| FW_PKG_TEST) |
| self.fw_path_origin = os.path.join(FW_PATH_BASE, |
| FW_PKG_ORIGIN) |
| self.fw_path_backup = os.path.join(FW_PATH_BASE, |
| FW_PKG_BACKUP) |
| self.board = self.host.get_board().split(':')[1] |
| |
| self.device_collector = usb_device_collector.UsbDeviceCollector( |
| self.host) |
| |
| self.vid_pid = self.camera.vid_pid |
| self.usb_spec = self.camera.get_usb_device_spec(self.vid_pid) |
| |
| self.org_fw_ver = self.get_image_fw_ver() |
| |
| def cleanup(self): |
| """ |
| Cleanups after tests. |
| |
| Removes the test firmware. |
| Restores the original firmware files. |
| Flashes the camera to original firmware if needed. |
| """ |
| |
| # Delete test firmware package. |
| cmd = 'rm -rf {}'.format(self.fw_path_test) |
| self.host.run(cmd) |
| |
| # Delete the symlink created. |
| cmd = 'rm {}'.format(self.fw_path_origin) |
| self.host.run(cmd) |
| |
| # Move the backup package back. |
| cmd = 'mv {} {}'.format(self.fw_path_backup, self.fw_path_origin) |
| self.host.run(cmd) |
| |
| # Do not leave the camera with test (older) firmware. |
| if not self.is_device_firmware_equal_to(self.org_fw_ver): |
| logging.debug('Aver 520 camera has old firmware after test' |
| 'Flashing new firmware') |
| self.flash_fw() |
| |
| super(enterprise_CFM_Aver520Updater, self).cleanup() |
| |
| def _run_cmd(self, command): |
| """ |
| Runs command line on DUT, wait for completion and return the output. |
| |
| @param command: command line to run in dut. |
| |
| @returns the command output |
| """ |
| |
| logging.debug('Execute: %s', command) |
| |
| result = self.host.run(command, ignore_status=True) |
| output = result.stderr if result.stderr else result.stdout |
| logging.debug('Output: %s', output) |
| return output |
| |
| def fw_ver_from_output_str(self, cmd_output): |
| """ |
| Parse firmware version of aver-updater output. |
| |
| aver-updater output differs slightly for image_version and |
| device_version. |
| For image_version strip ".dat" from output |
| This function will fail if version is not in the format |
| x.x.xxxx.xx where x is in [0-9] |
| |
| The actual output is given below. |
| |
| aver-updater --image_version |
| [INFO:main.cc(79)] image_version: 0.0.0018.07.dat |
| |
| aver-updater --device_version |
| [INFO:main.cc(71)] device_version: 0.0.0018.08 |
| |
| """ |
| |
| logging.debug('Parsing output from updater %s', cmd_output) |
| if 'Error(2) opening /lib/firmware/aver/' in cmd_output: |
| raise error.TestFail('Aver firmware image not found on DUT') |
| |
| if ('device_version' not in cmd_output and |
| 'image_version' not in cmd_output): |
| raise error.TestFail('Parsing aver firmware version output failed') |
| |
| version = '' |
| output = cmd_output.split('\n') |
| for line in output: |
| logging.debug('parsing line %s from output', line) |
| if 'device_version' not in line and 'image_version' not in line: |
| continue |
| parts = line.split(' ') |
| |
| if parts[1] == 'device_version:': |
| version = parts[2] |
| elif parts[1] == 'image_version:': |
| version = parts[2].strip('.dat') |
| else: |
| raise error.TestFail('Unexpected output from updater %s' |
| % parts) |
| |
| version = version.strip('\0') # Remove null characters |
| logging.debug('Version parsed from output is %s', version) |
| |
| if not bool(re.match(r'^\d\.\d\.\d\d\d\d\.\d\d$', version)): |
| logging.debug('parsed version is %s ', version) |
| raise error.TestFail('Version %s not in' |
| 'expected format' % version) |
| |
| logging.debug('Version is %s', str(version)) |
| return version |
| |
| def get_updater_output(self, cmd): |
| """Get updater output while avoiding transient failures.""" |
| |
| NUM_RETRIES = 5 |
| WAIT_TIME_SEC = 20 |
| for _ in range(NUM_RETRIES): |
| output = self._run_cmd(cmd) |
| if ('Open hid fd fail' in output or |
| 'query data size fail' in output or |
| 'There is another aver-updater running.' in output or |
| 'Failed to open the device' in output): |
| time.sleep(WAIT_TIME_SEC) |
| continue |
| return output |
| |
| def get_image_fw_ver(self): |
| """Get the version of firmware on DUT.""" |
| |
| output = self.get_updater_output('aver-updater --image_version' |
| ' --log_to=stdout --lock') |
| return self.fw_ver_from_output_str(output) |
| |
| def get_device_fw_ver(self): |
| """Get the version of firmware on Aver 520 camera.""" |
| |
| output = self.get_updater_output('aver-updater --device_version' |
| ' --log_to=stdout --lock') |
| return self.fw_ver_from_output_str(output) |
| |
| def copy_test_firmware(self): |
| """Copy test firmware from server to DUT.""" |
| |
| current_dir = os.path.dirname(os.path.realpath(__file__)) |
| src_firmware_path = os.path.join(current_dir, FW_PKG_TEST) |
| dst_firmware_path = FW_PATH_BASE |
| logging.info('Copy firmware from (%s) to (%s).', src_firmware_path, |
| dst_firmware_path) |
| self.host.send_file(src_firmware_path, dst_firmware_path, |
| delete_dest=True) |
| |
| def trigger_updater(self): |
| """Trigger udev rule to run fw updater by power cycling the usb.""" |
| |
| try: |
| vid = self.camera.vendor_id |
| pid = self.camera.product_id |
| power_cycle_usb_util.power_cycle_usb_vidpid(self.host, self.board, |
| vid, pid) |
| except KeyError: |
| raise error.TestFail('Could not find target device: ' |
| '{}'.format(self.camera)) |
| |
| def wait_for_aver_camera(self, wait_time=30): |
| """ |
| Wait for Aver 520 camera to be enumerated. |
| |
| Check if a device with given (vid,pid) is present. |
| Timeout after wait_time seconds. Default 30 seconds |
| """ |
| |
| TIME_SLEEP = 10 |
| NUM_ITERATIONS = max(wait_time / TIME_SLEEP, 1) |
| |
| logging.debug('Waiting for Aver 520 camera') |
| for _ in range(NUM_ITERATIONS): |
| if self.device_collector.get_devices_by_spec(self.usb_spec): |
| logging.debug('Aver 520 camera detected') |
| return |
| else: |
| logging.debug('Aver 520 camera not detected.' |
| 'Waiting for (%s) seconds', TIME_SLEEP) |
| time.sleep(TIME_SLEEP) |
| |
| logging.error('Unable to detect the device after (%s) seconds.' |
| 'Timing out...\n Target device %s not detected', |
| wait_time, self.camera) |
| raise error.TestFail('Target device not detected') |
| |
| def setup_fw(self, firmware_package): |
| """Setup firmware package that is going to be used for updating.""" |
| |
| firmware_path = os.path.join(FW_PATH_BASE, firmware_package) |
| cmd = 'ln -sfn {} {}'.format(firmware_path, self.fw_path_origin) |
| logging.debug('executing cmd %s ', cmd) |
| self.host.run(cmd) |
| |
| def flash_fw(self, force=False): |
| """Flash certain firmware to device. |
| |
| Run logitech firmware updater on DUT to flash the firmware setuped |
| to target device (PTZ Pro 2). |
| |
| @param force: run with force update, will bypass fw version check. |
| |
| """ |
| |
| cmd = ('/usr/sbin/aver-updater --log_to=stdout --update' |
| ' --lock') |
| if force: |
| cmd += ' --force' |
| output = self.get_updater_output(cmd) |
| return output |
| |
| def print_fw_version(self, version, info_str=''): |
| """Pretty print Aver 520 camera firmware version.""" |
| |
| if info_str: |
| print info_str, |
| print ' Firmware version:', version |
| |
| def is_device_firmware_equal_to(self, expected_ver): |
| """Check that the device fw version is equal to given version.""" |
| |
| device_fw_version = self.get_device_fw_ver() |
| if device_fw_version != expected_ver: |
| logging.error('Device firmware version is not the expected version') |
| self.print_fw_version(device_fw_version, 'Device firmware version') |
| self.print_fw_version(expected_ver, 'Expected firmware version') |
| return False |
| |
| return True |
| |
| def flash_old_firmware(self): |
| """Flash old (test) version of firmware on the device.""" |
| |
| # Flash old FW to device. |
| self.setup_fw(FW_PKG_TEST) |
| test_fw_ver = self.get_image_fw_ver() |
| self.print_fw_version(test_fw_ver, 'Test firmware version') |
| logging.debug('flashing test firmware on the device') |
| output = self.flash_fw(force=True) |
| time.sleep(POWER_CYCLE_WAIT_TIME_SEC) |
| with open(LOG_FILE, 'w') as f: |
| delim = '-' * 8 |
| f.write('{}Log info for writing old firmware{}' |
| '\n'.format(delim, delim)) |
| f.write(output) |
| if not self.is_device_firmware_equal_to(test_fw_ver): |
| raise error.TestFail('Flashing old firmware failed') |
| logging.info('Device flashed with test firmware') |
| |
| def backup_original_firmware(self): |
| """Backup existing firmware on DUT.""" |
| # Copy old FW to device. |
| cmd = 'mv {} {}'.format(self.fw_path_origin, self.fw_path_backup) |
| self.host.run(cmd) |
| |
| def is_updater_running(self): |
| """Checks if the aver-updater is running.""" |
| |
| cmd = 'aver-updater --lock --device_version --log_to=stdout' |
| output = self._run_cmd(cmd) |
| return 'There is another aver-updater running. Exiting now...' in output |
| |
| def wait_for_updater(self): |
| """Wait aver-updater to stop or timeout after 6 minutes.""" |
| |
| NUM_ITERATION = 12 |
| WAIT_TIME_SEC = 30 |
| logging.debug('Wait for any currently running updater to finish') |
| for _ in range(NUM_ITERATION): |
| if self.is_updater_running(): |
| logging.debug('aver-updater is running.' |
| 'Waiting for %s seconds', WAIT_TIME_SEC) |
| time.sleep(WAIT_TIME_SEC) |
| else: |
| logging.debug('aver-updater not running') |
| return |
| logging.error('aver-updater is still running after 6 minutes') |
| |
| def test_firmware_update(self): |
| """Trigger firmware updater and check device firmware version.""" |
| |
| # Simulate hotplug to run FW updater. |
| logging.info('Setup original firmware') |
| self.setup_fw(FW_PKG_BACKUP) |
| self.print_fw_version(self.get_image_fw_ver(), 'Firmware on disk') |
| logging.info('Simulate hot plugging the device') |
| self.trigger_updater() |
| self.wait_for_aver_camera() |
| |
| # The firmware check will fail if the check runs in a short window |
| # between the device being detected and the firmware updater starting. |
| # Adding a delay to reduce the chance of that scenerio. |
| logging.info('Waiting for the updater to update the firmware') |
| time.sleep(POWER_CYCLE_WAIT_TIME_SEC) |
| |
| self.wait_for_updater() |
| |
| if not self.is_device_firmware_equal_to(self.org_fw_ver): |
| raise error.TestFail('Camera not updated to new firmware') |
| logging.info('Firmware update was completed successfully') |
| |
| def run_once(self): |
| """ |
| Entry point for test. |
| |
| The following actions are performed in this test. |
| - Device is flashed with older firmware. |
| - Powercycle usb port to simulate hotplug inorder to start the updater. |
| - Check that the device is updated with newer firmware. |
| """ |
| |
| # Check if updater is already running |
| logging.info('Testing firmware update on Aver %s camera', |
| self.camera) |
| logging.info('Confirm that camera is present') |
| |
| self.wait_for_aver_camera(wait_time=0) |
| |
| self.wait_for_updater() |
| |
| self.print_fw_version(self.org_fw_ver, |
| 'Original firmware version on DUT') |
| self.print_fw_version(self.get_device_fw_ver(), |
| 'Firmware version on device') |
| |
| filesystem_util.make_rootfs_writable(self.host) |
| self.backup_original_firmware() |
| |
| # Flash test firmware version |
| self.copy_test_firmware() |
| self.flash_old_firmware() |
| |
| # Test firmware update |
| self.test_firmware_update() |
| logging.info('Aver %s camera firmware updater' |
| 'test was successful', self.camera) |
