# Copyright 2017 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.
"""This is a FAFT test to check if TCPCs are up-to-date.
This test figures out which TCPCs exist on a DUT and matches
these up with corresponding firmware blobs in the system
image shellball. If mismatches are detected, the test fails.
The test can optionally be invoked with --args bios=... to
specify an alternate reference firmware image.
"""
import logging
import os
from autotest_lib.client.common_lib import error
from autotest_lib.client.common_lib import utils
from autotest_lib.client.common_lib.cros import chip_utils
from autotest_lib.server.cros.faft.firmware_test import FirmwareTest
class firmware_CompareChipFwToShellBall(FirmwareTest):
"""Compares the active DUT chip firmware with reference.
FAFT test to verify that a DUT runs the expected chip
firmware based on the system shellball or a specified
reference image.
"""
version = 1
BIOS = 'bios.bin'
MAXPORTS = 100
def initialize(self, host, cmdline_args):
super(firmware_CompareChipFwToShellBall,
self).initialize(host, cmdline_args)
dict_args = utils.args_to_dict(cmdline_args)
self.new_bios_path = dict_args['bios'] if 'bios' in dict_args else None
self.cbfs_work_dir = None
self.dut_bios_path = None
def cleanup(self):
try:
if self.cbfs_work_dir:
self.faft_client.system.remove_dir(self.cbfs_work_dir)
except Exception as e:
logging.error("Caught exception: %s", str(e))
super(firmware_CompareChipFwToShellBall, self).cleanup()
def dut_get_chip(self, port):
"""Gets the chip info for a port.
Args:
port: TCPC port number on DUT
Returns:
A chip object if available, else None.
"""
cmd = 'mosys -s product_id pd chip %d' % port
chip_id = self.faft_client.system.run_shell_command_get_output(cmd)
if not chip_id:
# chip probably does not exist
return None
chip_id = chip_id[0]
if chip_id not in chip_utils.chip_id_map:
logging.info('chip type %s not recognized', chip_id)
return chip_utils.generic_chip()
chip = chip_utils.chip_id_map[chip_id]()
cmd = 'mosys -s fw_version pd chip %d' % port
fw_rev = self.faft_client.system.run_shell_command_get_output(cmd)
if not fw_rev:
# chip probably does not exist
return None
fw_rev = fw_rev[0]
chip.set_fw_ver_from_string(fw_rev)
return chip
def dut_scan_chips(self):
"""Scans for TCPC chips on DUT.
Returns:
A tuple (S, L) consisting of a set S of chip types and a list L
of chips indexed by port number found on on the DUT.
Raises:
TestFail: DUT has >= MAXPORTS pd ports.
"""
chip_types = set()
port2chip = []
for port in xrange(self.MAXPORTS):
chip = self.dut_get_chip(port)
if not chip:
return (chip_types, port2chip)
port2chip.append(chip)
chip_types.add(type(chip))
logging.error('found at least %u TCPC ports '
'- please update test to handle more ports '
'if this is expected.', self.MAXPORTS)
raise error.TestFail('MAXPORTS exceeded' % self.MAXPORTS)
def dut_locate_bios_bin(self):
"""Finds bios.bin on DUT.
Figures out where FAFT unpacked the shellball
and return path to extracted bios.bin.
Returns:
Full path of bios.bin on DUT.
"""
work_path = self.faft_client.updater.get_work_path()
bios_relative_path = self.faft_client.updater.get_bios_relative_path()
bios_bin = os.path.join(work_path, bios_relative_path)
return bios_bin
def dut_prep_cbfs(self):
"""Sets up cbfs on DUT.
Finds bios.bin on the DUT and sets up a temp dir to operate on
bios.bin. If a bios.bin was specified, it is copied to the DUT
and used instead of the native bios.bin.
"""
cbfs_path = self.faft_client.updater.cbfs_setup_work_dir()
bios_relative_path = self.faft_client.updater.get_bios_relative_path()
self.cbfs_work_dir = cbfs_path
self.dut_bios_path = os.path.join(cbfs_path, bios_relative_path)
def dut_cbfs_extract_chips(self, chip_types):
"""Extracts firmware hash blobs from cbfs.
Iterates over requested chip types and looks for corresponding
firmware hash blobs in cbfs. These firmware hash blobs are
extracted into cbfs_work_dir.
Args:
chip_types:
A set of chip types for which the hash blobs will be
extracted.
Returns:
A dict mapping found chip names to chip instances.
"""
cbfs_chip_info = {}
for chip_type in chip_types:
chip = chip_type()
fw = chip.fw_name
if not fw:
# must be an unfamiliar chip
continue
if not self.faft_client.updater.cbfs_extract_chip(chip.fw_name):
logging.warning('%s firmware not bundled in %s',
chip.chip_name, self.BIOS)
continue
hashblob = self.faft_client.updater.cbfs_get_chip_hash(
chip.fw_name)
if not hashblob:
logging.warning('%s firmware hash not extracted from %s',
chip.chip_name, self.BIOS)
continue
bundled_fw_ver = chip.fw_ver_from_hash(hashblob)
if not bundled_fw_ver:
raise error.TestFail(
'could not decode %s firmware hash: %s' % (
chip.chip_name, hashblob))
chip.set_fw_ver_from_string(bundled_fw_ver)
cbfs_chip_info[chip.chip_name] = chip
logging.info('%s bundled firmware for %s is version %s',
self.BIOS, chip.chip_name, bundled_fw_ver)
return cbfs_chip_info
def check_chip_versions(self, port2chip, ref_chip_info):
"""Verifies DUT chips have expected firmware.
Iterates over found DUT chips and verifies their firmware version
matches the chips found in the reference ref_chip_info map.
Args:
port2chip: A list of chips to verify against ref_chip_info.
ref_chip_info: A dict of reference chip chip instances indexed
by chip name.
"""
for p, pinfo in enumerate(port2chip):
if not pinfo.fw_ver:
# must be an unknown chip
continue
msg = 'DUT port %s is a %s running firmware 0x%02x' % (
p, pinfo.chip_name, pinfo.fw_ver)
if pinfo.chip_name not in ref_chip_info:
logging.warning('%s but there is no reference version', msg)
continue
expected_fw_ver = ref_chip_info[pinfo.chip_name].fw_ver
logging.info('%s%s', msg,
('' if pinfo.fw_ver == expected_fw_ver else
' (expected 0x%02x)' % expected_fw_ver))
if pinfo.fw_ver != expected_fw_ver:
msg = '%s firmware was not updated to 0x%02x' % (
pinfo.chip_name, expected_fw_ver)
raise error.TestFail(msg)
def run_once(self, host):
# Make sure the client library is on the device so that the proxy
# code is there when we try to call it.
(dut_chip_types, dut_chips) = self.dut_scan_chips()
if not dut_chip_types:
logging.info('mosys reported no chips on DUT, skipping test')
return
self.dut_prep_cbfs()
if self.new_bios_path:
host.send_file(self.new_bios_path, self.dut_bios_path)
ref_chip_info = self.dut_cbfs_extract_chips(dut_chip_types)
self.check_chip_versions(dut_chips, ref_chip_info)