Add components which is requried to generate a GBB during factory.

client/site_tests/hardware_Components/hardware_Components.py

 # Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import glob, hashlib, logging, os, pprint, re, sys
 from autotest_lib.client.bin import factory
 from autotest_lib.client.bin import test, utils
 from autotest_lib.client.common_lib import error
 from autotest_lib.client.common_lib import flashrom_util
+from autotest_lib.client.common_lib import gbb_util
 from autotest_lib.client.common_lib import site_vblock
 
 
 class hardware_Components(test.test):
     version = 1
     _cids = [
         'hash_ro_firmware',
         'part_id_audio_codec',
         'part_id_cpu',
         'part_id_display_panel',
@@ skipping 12 matching lines @@
         'part_id_vga',
     ]
     _usb_cids = [
         'part_id_bluetooth',
         'part_id_cardreader',
         'part_id_webcam',
         'part_id_3g',
         'part_id_gps',
     ]
     _check_existence_cids = [
+        'key_recovery',
+        'key_root',
         'part_id_chrontel',
     ]
+    _non_check_cids = [
+        'data_bitmap_fv',
+        'data_display_geometry',
+        'data_recovery_url',
+    ]
     _not_present = 'Not Present'
 
 
     def check_component(self, comp_key, comp_id):
         if comp_key in self._ignored:
             return
 
         self._system[comp_key] = [ comp_id ]
 
         if not self._approved.has_key(comp_key):
@@ skipping 38 matching lines @@
             elif type == 'others':
                 present = getattr(self, 'check_existence_' + cid)(device)
 
             if present:
                 self._system[cid] = [ device ]
                 return
 
         self._failures[cid] = [ 'No match' ]
 
 
+    def check_existence_key_recovery(self, part_id):
+        current_key = self._gbb.get_recoverykey()
+        target_key = utils.read_file(part_id)
+        return current_key == target_key
+
+
+    def check_existence_key_root(self, part_id):
+        current_key = self._gbb.get_rootkey()
+        target_key = utils.read_file(part_id)
+        return current_key == target_key
+
+
     def check_existence_part_id_chrontel(self, part_id):
         if part_id == self._not_present:
             return True
 
         if part_id == 'ch7036':
             grep_cmd = 'grep i2c_dev /proc/modules'
             i2c_loaded = (utils.system(grep_cmd, ignore_status=True) == 0)
             if not i2c_loaded:
                 utils.system('modprobe i2c_dev')
 
@@ skipping 117 matching lines @@
         hash_ro_list = ['FV_BSTUB', 'FV_GBB', 'FVDEV']
         flashrom = flashrom_util.flashrom_util()
         if not flashrom.select_bios_flashrom():
             raise error.TestError('Cannot select BIOS flashrom')
         base_img = flashrom.read_whole()
         flashrom_size = len(base_img)
         # XXX we can NOT trust base image here for layout, otherwise firmware
         # can provide fake (non-used) GBB/BSTUB in garbage area.
         layout = flashrom.detect_chromeos_bios_layout(flashrom_size, None)
         if not layout:
-            raise error.TestError('Cannot detect ChromeOS flashrom laout')
+            raise error.TestError('Cannot detect ChromeOS flashrom layout')
         hash_src = ''
         for section in hash_ro_list:
             src = flashrom.get_section(base_img, layout, section)
             if not src:
                 raise error.TestError('Cannot get section [%s] from flashrom' %
                                       section)
             hash_src = hash_src + src
         if not hash_src:
             raise error.TestError('Invalid hash source from flashrom.')
         return hashlib.sha256(hash_src).hexdigest()
 
 
     def get_version_rw_firmware(self):
         """
         Returns the version of Read-Write (writable) firmware from VBOOT
         section. If A/B has different version, that means this system
         needs a reboot + firmwar update so return value is a "error report"
         in the form "A=x, B=y".
         """
         versions = [None, None]
         section_names = ['VBOOTA', 'VBOOTB']
         flashrom = flashrom_util.flashrom_util()
         if not flashrom.select_bios_flashrom():
             raise error.TestError('Cannot select BIOS flashrom')
         base_img = flashrom.read_whole()
         flashrom_size = len(base_img)
         # we can trust base image for layout, since it's only RW.
-        layout = flashrom.detect_chromeos_bios_layout(flashrom_size, base_imge)
+        layout = flashrom.detect_chromeos_bios_layout(flashrom_size, base_img)
         if not layout:
-            raise error.TestError('Cannot detect ChromeOS flashrom laout')
+            raise error.TestError('Cannot detect ChromeOS flashrom layout')
         for index, name in enumerate(section_names):
             data = flashrom.get_section(base_img, layout, name)
             block = site_vblock.unpack_verification_block(data)
             ver = block['VbFirmwarePreambleHeader']['firmware_version']
             versions[index] = ver
         # we embed error reports in return value.
         assert len(versions) == 2
         if versions[0] != versions[1]:
             return 'A=%d, B=%d' % (versions[0], versions[1])
         return '%d' % (versions[0])
@@ skipping 11 matching lines @@
             logging.error("Exception getting property %s", property_name,
                           exc_info=1)
             return ''
 
 
     def pformat(self, obj):
         return "\n" + self._pp.pformat(obj) + "\n"
 
 
     def initialize(self):
+        self._gbb = gbb_util.GBBUtility()
         self._pp = pprint.PrettyPrinter()
 
 
     def run_once(self, approved_dbs='approved_components', ignored_cids=[],
             shared_dict={}):
         self._ignored = ignored_cids
         all_failures = ''
         os.chdir(self.bindir)
 
         # If found the HwQual ID in shared_dict, use the list with the same ID.
@@ skipping 34 matching lines @@
                 all_failures += 'Approved DB: %s' % db
                 all_failures += self.pformat(self._failures)
             else:
                 # If one of DBs is matched, record some data in shared_dict.
                 cids_need_to_be_record = ['part_id_hwqual']
                 for cid in cids_need_to_be_record:
                     factory.log_shared_data(cid, self._approved[cid][0])
                 return
 
         raise error.TestFail(all_failures)