[edk2-devel] [PATCH v11] IntelFsp2Pkg: Add Config Editor tool support
Chiu, Chasel
chasel.chiu at intel.com
Tue Jun 29 04:45:38 UTC 2021
Reviewed-by: Chasel Chiu <chasel.chiu at intel.com>
> -----Original Message-----
> From: Loo, Tung Lun <tung.lun.loo at intel.com>
> Sent: Tuesday, June 29, 2021 12:33 PM
> To: devel at edk2.groups.io
> Cc: Loo, Tung Lun <tung.lun.loo at intel.com>; Ma, Maurice
> <maurice.ma at intel.com>; Desimone, Nathaniel L
> <nathaniel.l.desimone at intel.com>; Zeng, Star <star.zeng at intel.com>; Chiu,
> Chasel <chasel.chiu at intel.com>
> Subject: [PATCH v11] IntelFsp2Pkg: Add Config Editor tool support
>
> BZ: https://bugzilla.tianocore.org/show_bug.cgi?id=3396
>
> This is a GUI interface that can be used by users who
> would like to change configuration settings directly
> from the interface without having to modify the source.
>
> This tool depends on Python GUI tool kit Tkinter.
> It runs on both Windows and Linux.
>
> The user needs to load the YAML file along with DLT file
> for a specific board into the ConfigEditor, change the desired
> configuration values. Finally, generate a new configuration delta
> file or a config binary blob for the newly changed values to take
> effect. These will be the inputs to the merge tool or the stitch
> tool so that new config changes can be merged and stitched into
> the final configuration blob.
>
> This tool also supports binary update directly and display FSP
> information. It is also backward compatible for BSF file format.
>
> Running Configuration Editor:
> python ConfigEditor.py
>
> Co-authored-by: Maurice Ma <maurice.ma at intel.com>
> Cc: Maurice Ma <maurice.ma at intel.com>
> Cc: Nate DeSimone <nathaniel.l.desimone at intel.com>
> Cc: Star Zeng <star.zeng at intel.com>
> Cc: Chasel Chiu <chasel.chiu at intel.com>
> Signed-off-by: Loo Tung Lun <tung.lun.loo at intel.com>
> ---
> IntelFsp2Pkg/Tools/ConfigEditor/CommonUtility.py | 504
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++
> IntelFsp2Pkg/Tools/ConfigEditor/ConfigEditor.py | 1499
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++
> IntelFsp2Pkg/Tools/ConfigEditor/GenYamlCfg.py | 2252
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++
> IntelFsp2Pkg/Tools/ConfigEditor/SingleSign.py | 324
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++
> IntelFsp2Pkg/Tools/FspDscBsf2Yaml.py | 369
> +++++++++++++++++++++++++++---------------------------------------------------------
> -----------------------------------------------
> IntelFsp2Pkg/Tools/FspGenCfgData.py | 2637
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++
> IntelFsp2Pkg/Tools/UserManuals/ConfigEditorUserManual.md | 45
> ++++++++++++++++
> 7 files changed, 7337 insertions(+), 293 deletions(-)
>
> diff --git a/IntelFsp2Pkg/Tools/ConfigEditor/CommonUtility.py
> b/IntelFsp2Pkg/Tools/ConfigEditor/CommonUtility.py
> new file mode 100644
> index 0000000000..1229279116
> --- /dev/null
> +++ b/IntelFsp2Pkg/Tools/ConfigEditor/CommonUtility.py
> @@ -0,0 +1,504 @@
> +#!/usr/bin/env python
>
> +# @ CommonUtility.py
>
> +# Common utility script
>
> +#
>
> +# Copyright (c) 2016 - 2021, Intel Corporation. All rights reserved.<BR>
>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
>
> +#
>
> +##
>
> +
>
> +import os
>
> +import sys
>
> +import shutil
>
> +import subprocess
>
> +import string
>
> +from ctypes import ARRAY, c_char, c_uint16, c_uint32, \
>
> + c_uint8, Structure, sizeof
>
> +from importlib.machinery import SourceFileLoader
>
> +from SingleSign import single_sign_gen_pub_key
>
> +
>
> +
>
> +# Key types defined should match with cryptolib.h
>
> +PUB_KEY_TYPE = {
>
> + "RSA": 1,
>
> + "ECC": 2,
>
> + "DSA": 3,
>
> + }
>
> +
>
> +# Signing type schemes defined should match with cryptolib.h
>
> +SIGN_TYPE_SCHEME = {
>
> + "RSA_PKCS1": 1,
>
> + "RSA_PSS": 2,
>
> + "ECC": 3,
>
> + "DSA": 4,
>
> + }
>
> +
>
> +# Hash values defined should match with cryptolib.h
>
> +HASH_TYPE_VALUE = {
>
> + "SHA2_256": 1,
>
> + "SHA2_384": 2,
>
> + "SHA2_512": 3,
>
> + "SM3_256": 4,
>
> + }
>
> +
>
> +# Hash values defined should match with cryptolib.h
>
> +HASH_VAL_STRING = dict(map(reversed, HASH_TYPE_VALUE.items()))
>
> +
>
> +AUTH_TYPE_HASH_VALUE = {
>
> + "SHA2_256": 1,
>
> + "SHA2_384": 2,
>
> + "SHA2_512": 3,
>
> + "SM3_256": 4,
>
> + "RSA2048SHA256": 1,
>
> + "RSA3072SHA384": 2,
>
> + }
>
> +
>
> +HASH_DIGEST_SIZE = {
>
> + "SHA2_256": 32,
>
> + "SHA2_384": 48,
>
> + "SHA2_512": 64,
>
> + "SM3_256": 32,
>
> + }
>
> +
>
> +
>
> +class PUB_KEY_HDR (Structure):
>
> + _pack_ = 1
>
> + _fields_ = [
>
> + ('Identifier', ARRAY(c_char, 4)), # signature ('P', 'U', 'B', 'K')
>
> + ('KeySize', c_uint16), # Length of Public Key
>
> + ('KeyType', c_uint8), # RSA or ECC
>
> + ('Reserved', ARRAY(c_uint8, 1)),
>
> + ('KeyData', ARRAY(c_uint8, 0)),
>
> + ]
>
> +
>
> + def __init__(self):
>
> + self.Identifier = b'PUBK'
>
> +
>
> +
>
> +class SIGNATURE_HDR (Structure):
>
> + _pack_ = 1
>
> + _fields_ = [
>
> + ('Identifier', ARRAY(c_char, 4)),
>
> + ('SigSize', c_uint16),
>
> + ('SigType', c_uint8),
>
> + ('HashAlg', c_uint8),
>
> + ('Signature', ARRAY(c_uint8, 0)),
>
> + ]
>
> +
>
> + def __init__(self):
>
> + self.Identifier = b'SIGN'
>
> +
>
> +
>
> +class LZ_HEADER(Structure):
>
> + _pack_ = 1
>
> + _fields_ = [
>
> + ('signature', ARRAY(c_char, 4)),
>
> + ('compressed_len', c_uint32),
>
> + ('length', c_uint32),
>
> + ('version', c_uint16),
>
> + ('svn', c_uint8),
>
> + ('attribute', c_uint8)
>
> + ]
>
> + _compress_alg = {
>
> + b'LZDM': 'Dummy',
>
> + b'LZ4 ': 'Lz4',
>
> + b'LZMA': 'Lzma',
>
> + }
>
> +
>
> +
>
> +def print_bytes(data, indent=0, offset=0, show_ascii=False):
>
> + bytes_per_line = 16
>
> + printable = ' ' + string.ascii_letters + string.digits + string.punctuation
>
> + str_fmt = '{:s}{:04x}: {:%ds} {:s}' % (bytes_per_line * 3)
>
> + bytes_per_line
>
> + data_array = bytearray(data)
>
> + for idx in range(0, len(data_array), bytes_per_line):
>
> + hex_str = ' '.join(
>
> + '%02X' % val for val in data_array[idx:idx + bytes_per_line])
>
> + asc_str = ''.join('%c' % (val if (chr(val) in printable) else '.')
>
> + for val in data_array[idx:idx + bytes_per_line])
>
> + print(str_fmt.format(
>
> + indent * ' ',
>
> + offset + idx, hex_str,
>
> + ' ' + asc_str if show_ascii else ''))
>
> +
>
> +
>
> +def get_bits_from_bytes(bytes, start, length):
>
> + if length == 0:
>
> + return 0
>
> + byte_start = (start) // 8
>
> + byte_end = (start + length - 1) // 8
>
> + bit_start = start & 7
>
> + mask = (1 << length) - 1
>
> + val = bytes_to_value(bytes[byte_start:byte_end + 1])
>
> + val = (val >> bit_start) & mask
>
> + return val
>
> +
>
> +
>
> +def set_bits_to_bytes(bytes, start, length, bvalue):
>
> + if length == 0:
>
> + return
>
> + byte_start = (start) // 8
>
> + byte_end = (start + length - 1) // 8
>
> + bit_start = start & 7
>
> + mask = (1 << length) - 1
>
> + val = bytes_to_value(bytes[byte_start:byte_end + 1])
>
> + val &= ~(mask << bit_start)
>
> + val |= ((bvalue & mask) << bit_start)
>
> + bytes[byte_start:byte_end+1] = value_to_bytearray(
>
> + val,
>
> + byte_end + 1 - byte_start)
>
> +
>
> +
>
> +def value_to_bytes(value, length):
>
> + return value.to_bytes(length, 'little')
>
> +
>
> +
>
> +def bytes_to_value(bytes):
>
> + return int.from_bytes(bytes, 'little')
>
> +
>
> +
>
> +def value_to_bytearray(value, length):
>
> + return bytearray(value_to_bytes(value, length))
>
> +
>
> +# def value_to_bytearray (value, length):
>
> + return bytearray(value_to_bytes(value, length))
>
> +
>
> +
>
> +def get_aligned_value(value, alignment=4):
>
> + if alignment != (1 << (alignment.bit_length() - 1)):
>
> + raise Exception(
>
> + 'Alignment (0x%x) should to be power of 2 !' % alignment)
>
> + value = (value + (alignment - 1)) & ~(alignment - 1)
>
> + return value
>
> +
>
> +
>
> +def get_padding_length(data_len, alignment=4):
>
> + new_data_len = get_aligned_value(data_len, alignment)
>
> + return new_data_len - data_len
>
> +
>
> +
>
> +def get_file_data(file, mode='rb'):
>
> + return open(file, mode).read()
>
> +
>
> +
>
> +def gen_file_from_object(file, object):
>
> + open(file, 'wb').write(object)
>
> +
>
> +
>
> +def gen_file_with_size(file, size):
>
> + open(file, 'wb').write(b'\xFF' * size)
>
> +
>
> +
>
> +def check_files_exist(base_name_list, dir='', ext=''):
>
> + for each in base_name_list:
>
> + if not os.path.exists(os.path.join(dir, each + ext)):
>
> + return False
>
> + return True
>
> +
>
> +
>
> +def load_source(name, filepath):
>
> + mod = SourceFileLoader(name, filepath).load_module()
>
> + return mod
>
> +
>
> +
>
> +def get_openssl_path():
>
> + if os.name == 'nt':
>
> + if 'OPENSSL_PATH' not in os.environ:
>
> + openssl_dir = "C:\\Openssl\\bin\\"
>
> + if os.path.exists(openssl_dir):
>
> + os.environ['OPENSSL_PATH'] = openssl_dir
>
> + else:
>
> + os.environ['OPENSSL_PATH'] = "C:\\Openssl\\"
>
> + if 'OPENSSL_CONF' not in os.environ:
>
> + openssl_cfg = "C:\\Openssl\\openssl.cfg"
>
> + if os.path.exists(openssl_cfg):
>
> + os.environ['OPENSSL_CONF'] = openssl_cfg
>
> + openssl = os.path.join(
>
> + os.environ.get('OPENSSL_PATH', ''),
>
> + 'openssl.exe')
>
> + else:
>
> + # Get openssl path for Linux cases
>
> + openssl = shutil.which('openssl')
>
> +
>
> + return openssl
>
> +
>
> +
>
> +def run_process(arg_list, print_cmd=False, capture_out=False):
>
> + sys.stdout.flush()
>
> + if os.name == 'nt' and os.path.splitext(arg_list[0])[1] == '' and \
>
> + os.path.exists(arg_list[0] + '.exe'):
>
> + arg_list[0] += '.exe'
>
> + if print_cmd:
>
> + print(' '.join(arg_list))
>
> +
>
> + exc = None
>
> + result = 0
>
> + output = ''
>
> + try:
>
> + if capture_out:
>
> + output = subprocess.check_output(arg_list).decode()
>
> + else:
>
> + result = subprocess.call(arg_list)
>
> + except Exception as ex:
>
> + result = 1
>
> + exc = ex
>
> +
>
> + if result:
>
> + if not print_cmd:
>
> + print('Error in running process:\n %s' % ' '.join(arg_list))
>
> + if exc is None:
>
> + sys.exit(1)
>
> + else:
>
> + raise exc
>
> +
>
> + return output
>
> +
>
> +
>
> +# Adjust hash type algorithm based on Public key file
>
> +def adjust_hash_type(pub_key_file):
>
> + key_type = get_key_type(pub_key_file)
>
> + if key_type == 'RSA2048':
>
> + hash_type = 'SHA2_256'
>
> + elif key_type == 'RSA3072':
>
> + hash_type = 'SHA2_384'
>
> + else:
>
> + hash_type = None
>
> +
>
> + return hash_type
>
> +
>
> +
>
> +def rsa_sign_file(
>
> + priv_key, pub_key, hash_type, sign_scheme,
>
> + in_file, out_file, inc_dat=False, inc_key=False):
>
> +
>
> + bins = bytearray()
>
> + if inc_dat:
>
> + bins.extend(get_file_data(in_file))
>
> +
>
> +
>
> +# def single_sign_file(priv_key, hash_type, sign_scheme, in_file, out_file):
>
> +
>
> + out_data = get_file_data(out_file)
>
> +
>
> + sign = SIGNATURE_HDR()
>
> + sign.SigSize = len(out_data)
>
> + sign.SigType = SIGN_TYPE_SCHEME[sign_scheme]
>
> + sign.HashAlg = HASH_TYPE_VALUE[hash_type]
>
> +
>
> + bins.extend(bytearray(sign) + out_data)
>
> + if inc_key:
>
> + key = gen_pub_key(priv_key, pub_key)
>
> + bins.extend(key)
>
> +
>
> + if len(bins) != len(out_data):
>
> + gen_file_from_object(out_file, bins)
>
> +
>
> +
>
> +def get_key_type(in_key):
>
> +
>
> + # Check in_key is file or key Id
>
> + if not os.path.exists(in_key):
>
> + key = bytearray(gen_pub_key(in_key))
>
> + else:
>
> + # Check for public key in binary format.
>
> + key = bytearray(get_file_data(in_key))
>
> +
>
> + pub_key_hdr = PUB_KEY_HDR.from_buffer(key)
>
> + if pub_key_hdr.Identifier != b'PUBK':
>
> + pub_key = gen_pub_key(in_key)
>
> + pub_key_hdr = PUB_KEY_HDR.from_buffer(pub_key)
>
> +
>
> + key_type = next(
>
> + (key for key,
>
> + value in PUB_KEY_TYPE.items() if value == pub_key_hdr.KeyType))
>
> + return '%s%d' % (key_type, (pub_key_hdr.KeySize - 4) * 8)
>
> +
>
> +
>
> +def get_auth_hash_type(key_type, sign_scheme):
>
> + if key_type == "RSA2048" and sign_scheme == "RSA_PKCS1":
>
> + hash_type = 'SHA2_256'
>
> + auth_type = 'RSA2048_PKCS1_SHA2_256'
>
> + elif key_type == "RSA3072" and sign_scheme == "RSA_PKCS1":
>
> + hash_type = 'SHA2_384'
>
> + auth_type = 'RSA3072_PKCS1_SHA2_384'
>
> + elif key_type == "RSA2048" and sign_scheme == "RSA_PSS":
>
> + hash_type = 'SHA2_256'
>
> + auth_type = 'RSA2048_PSS_SHA2_256'
>
> + elif key_type == "RSA3072" and sign_scheme == "RSA_PSS":
>
> + hash_type = 'SHA2_384'
>
> + auth_type = 'RSA3072_PSS_SHA2_384'
>
> + else:
>
> + hash_type = ''
>
> + auth_type = ''
>
> + return auth_type, hash_type
>
> +
>
> +
>
> +# def single_sign_gen_pub_key(in_key, pub_key_file=None):
>
> +
>
> +
>
> +def gen_pub_key(in_key, pub_key=None):
>
> +
>
> + keydata = single_sign_gen_pub_key(in_key, pub_key)
>
> +
>
> + publickey = PUB_KEY_HDR()
>
> + publickey.KeySize = len(keydata)
>
> + publickey.KeyType = PUB_KEY_TYPE['RSA']
>
> +
>
> + key = bytearray(publickey) + keydata
>
> +
>
> + if pub_key:
>
> + gen_file_from_object(pub_key, key)
>
> +
>
> + return key
>
> +
>
> +
>
> +def decompress(in_file, out_file, tool_dir=''):
>
> + if not os.path.isfile(in_file):
>
> + raise Exception("Invalid input file '%s' !" % in_file)
>
> +
>
> + # Remove the Lz Header
>
> + fi = open(in_file, 'rb')
>
> + di = bytearray(fi.read())
>
> + fi.close()
>
> +
>
> + lz_hdr = LZ_HEADER.from_buffer(di)
>
> + offset = sizeof(lz_hdr)
>
> + if lz_hdr.signature == b"LZDM" or lz_hdr.compressed_len == 0:
>
> + fo = open(out_file, 'wb')
>
> + fo.write(di[offset:offset + lz_hdr.compressed_len])
>
> + fo.close()
>
> + return
>
> +
>
> + temp = os.path.splitext(out_file)[0] + '.tmp'
>
> + if lz_hdr.signature == b"LZMA":
>
> + alg = "Lzma"
>
> + elif lz_hdr.signature == b"LZ4 ":
>
> + alg = "Lz4"
>
> + else:
>
> + raise Exception("Unsupported compression '%s' !" % lz_hdr.signature)
>
> +
>
> + fo = open(temp, 'wb')
>
> + fo.write(di[offset:offset + lz_hdr.compressed_len])
>
> + fo.close()
>
> +
>
> + compress_tool = "%sCompress" % alg
>
> + if alg == "Lz4":
>
> + try:
>
> + cmdline = [
>
> + os.path.join(tool_dir, compress_tool),
>
> + "-d",
>
> + "-o", out_file,
>
> + temp]
>
> + run_process(cmdline, False, True)
>
> + except Exception:
>
> + msg_string = "Could not find/use CompressLz4 tool, " \
>
> + "trying with python lz4..."
>
> + print(msg_string)
>
> + try:
>
> + import lz4.block
>
> + if lz4.VERSION != '3.1.1':
>
> + msg_string = "Recommended lz4 module version " \
>
> + "is '3.1.1'," + lz4.VERSION \
>
> + + " is currently installed."
>
> + print(msg_string)
>
> + except ImportError:
>
> + msg_string = "Could not import lz4, use " \
>
> + "'python -m pip install lz4==3.1.1' " \
>
> + "to install it."
>
> + print(msg_string)
>
> + exit(1)
>
> + decompress_data = lz4.block.decompress(get_file_data(temp))
>
> + with open(out_file, "wb") as lz4bin:
>
> + lz4bin.write(decompress_data)
>
> + else:
>
> + cmdline = [
>
> + os.path.join(tool_dir, compress_tool),
>
> + "-d",
>
> + "-o", out_file,
>
> + temp]
>
> + run_process(cmdline, False, True)
>
> + os.remove(temp)
>
> +
>
> +
>
> +def compress(in_file, alg, svn=0, out_path='', tool_dir=''):
>
> + if not os.path.isfile(in_file):
>
> + raise Exception("Invalid input file '%s' !" % in_file)
>
> +
>
> + basename, ext = os.path.splitext(os.path.basename(in_file))
>
> + if out_path:
>
> + if os.path.isdir(out_path):
>
> + out_file = os.path.join(out_path, basename + '.lz')
>
> + else:
>
> + out_file = os.path.join(out_path)
>
> + else:
>
> + out_file = os.path.splitext(in_file)[0] + '.lz'
>
> +
>
> + if alg == "Lzma":
>
> + sig = "LZMA"
>
> + elif alg == "Tiano":
>
> + sig = "LZUF"
>
> + elif alg == "Lz4":
>
> + sig = "LZ4 "
>
> + elif alg == "Dummy":
>
> + sig = "LZDM"
>
> + else:
>
> + raise Exception("Unsupported compression '%s' !" % alg)
>
> +
>
> + in_len = os.path.getsize(in_file)
>
> + if in_len > 0:
>
> + compress_tool = "%sCompress" % alg
>
> + if sig == "LZDM":
>
> + shutil.copy(in_file, out_file)
>
> + compress_data = get_file_data(out_file)
>
> + elif sig == "LZ4 ":
>
> + try:
>
> + cmdline = [
>
> + os.path.join(tool_dir, compress_tool),
>
> + "-e",
>
> + "-o", out_file,
>
> + in_file]
>
> + run_process(cmdline, False, True)
>
> + compress_data = get_file_data(out_file)
>
> + except Exception:
>
> + msg_string = "Could not find/use CompressLz4 tool, " \
>
> + "trying with python lz4..."
>
> + print(msg_string)
>
> + try:
>
> + import lz4.block
>
> + if lz4.VERSION != '3.1.1':
>
> + msg_string = "Recommended lz4 module version " \
>
> + "is '3.1.1', " + lz4.VERSION \
>
> + + " is currently installed."
>
> + print(msg_string)
>
> + except ImportError:
>
> + msg_string = "Could not import lz4, use " \
>
> + "'python -m pip install lz4==3.1.1' " \
>
> + "to install it."
>
> + print(msg_string)
>
> + exit(1)
>
> + compress_data = lz4.block.compress(
>
> + get_file_data(in_file),
>
> + mode='high_compression')
>
> + elif sig == "LZMA":
>
> + cmdline = [
>
> + os.path.join(tool_dir, compress_tool),
>
> + "-e",
>
> + "-o", out_file,
>
> + in_file]
>
> + run_process(cmdline, False, True)
>
> + compress_data = get_file_data(out_file)
>
> + else:
>
> + compress_data = bytearray()
>
> +
>
> + lz_hdr = LZ_HEADER()
>
> + lz_hdr.signature = sig.encode()
>
> + lz_hdr.svn = svn
>
> + lz_hdr.compressed_len = len(compress_data)
>
> + lz_hdr.length = os.path.getsize(in_file)
>
> + data = bytearray()
>
> + data.extend(lz_hdr)
>
> + data.extend(compress_data)
>
> + gen_file_from_object(out_file, data)
>
> +
>
> + return out_file
>
> diff --git a/IntelFsp2Pkg/Tools/ConfigEditor/ConfigEditor.py
> b/IntelFsp2Pkg/Tools/ConfigEditor/ConfigEditor.py
> new file mode 100644
> index 0000000000..a7f79bbc96
> --- /dev/null
> +++ b/IntelFsp2Pkg/Tools/ConfigEditor/ConfigEditor.py
> @@ -0,0 +1,1499 @@
> +# @ ConfigEditor.py
>
> +#
>
> +# Copyright(c) 2018 - 2021, Intel Corporation. All rights reserved.<BR>
>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
>
> +#
>
> +##
>
> +
>
> +import os
>
> +import sys
>
> +import marshal
>
> +import tkinter
>
> +import tkinter.ttk as ttk
>
> +import tkinter.messagebox as messagebox
>
> +import tkinter.filedialog as filedialog
>
> +
>
> +from pathlib import Path
>
> +from GenYamlCfg import CGenYamlCfg, bytes_to_value, \
>
> + bytes_to_bracket_str, value_to_bytes, array_str_to_value
>
> +from ctypes import sizeof, Structure, ARRAY, c_uint8, c_uint64, c_char, \
>
> + c_uint32, c_uint16
>
> +from functools import reduce
>
> +
>
> +sys.path.insert(0, '..')
>
> +from FspDscBsf2Yaml import bsf_to_dsc, dsc_to_yaml # noqa
>
> +
>
> +
>
> +sys.dont_write_bytecode = True
>
> +
>
> +
>
> +class create_tool_tip(object):
>
> + '''
>
> + create a tooltip for a given widget
>
> + '''
>
> + in_progress = False
>
> +
>
> + def __init__(self, widget, text=''):
>
> + self.top_win = None
>
> + self.widget = widget
>
> + self.text = text
>
> + self.widget.bind("<Enter>", self.enter)
>
> + self.widget.bind("<Leave>", self.leave)
>
> +
>
> + def enter(self, event=None):
>
> + if self.in_progress:
>
> + return
>
> + if self.widget.winfo_class() == 'Treeview':
>
> + # Only show help when cursor is on row header.
>
> + rowid = self.widget.identify_row(event.y)
>
> + if rowid != '':
>
> + return
>
> + else:
>
> + x, y, cx, cy = self.widget.bbox("insert")
>
> +
>
> + cursor = self.widget.winfo_pointerxy()
>
> + x = self.widget.winfo_rootx() + 35
>
> + y = self.widget.winfo_rooty() + 20
>
> + if cursor[1] > y and cursor[1] < y + 20:
>
> + y += 20
>
> +
>
> + # creates a toplevel window
>
> + self.top_win = tkinter.Toplevel(self.widget)
>
> + # Leaves only the label and removes the app window
>
> + self.top_win.wm_overrideredirect(True)
>
> + self.top_win.wm_geometry("+%d+%d" % (x, y))
>
> + label = tkinter.Message(self.top_win,
>
> + text=self.text,
>
> + justify='left',
>
> + background='bisque',
>
> + relief='solid',
>
> + borderwidth=1,
>
> + font=("times", "10", "normal"))
>
> + label.pack(ipadx=1)
>
> + self.in_progress = True
>
> +
>
> + def leave(self, event=None):
>
> + if self.top_win:
>
> + self.top_win.destroy()
>
> + self.in_progress = False
>
> +
>
> +
>
> +class validating_entry(tkinter.Entry):
>
> + def __init__(self, master, **kw):
>
> + tkinter.Entry.__init__(*(self, master), **kw)
>
> + self.parent = master
>
> + self.old_value = ''
>
> + self.last_value = ''
>
> + self.variable = tkinter.StringVar()
>
> + self.variable.trace("w", self.callback)
>
> + self.config(textvariable=self.variable)
>
> + self.config({"background": "#c0c0c0"})
>
> + self.bind("<Return>", self.move_next)
>
> + self.bind("<Tab>", self.move_next)
>
> + self.bind("<Escape>", self.cancel)
>
> + for each in ['BackSpace', 'Delete']:
>
> + self.bind("<%s>" % each, self.ignore)
>
> + self.display(None)
>
> +
>
> + def ignore(self, even):
>
> + return "break"
>
> +
>
> + def move_next(self, event):
>
> + if self.row < 0:
>
> + return
>
> + row, col = self.row, self.col
>
> + txt, row_id, col_id = self.parent.get_next_cell(row, col)
>
> + self.display(txt, row_id, col_id)
>
> + return "break"
>
> +
>
> + def cancel(self, event):
>
> + self.variable.set(self.old_value)
>
> + self.display(None)
>
> +
>
> + def display(self, txt, row_id='', col_id=''):
>
> + if txt is None:
>
> + self.row = -1
>
> + self.col = -1
>
> + self.place_forget()
>
> + else:
>
> + row = int('0x' + row_id[1:], 0) - 1
>
> + col = int(col_id[1:]) - 1
>
> + self.row = row
>
> + self.col = col
>
> + self.old_value = txt
>
> + self.last_value = txt
>
> + x, y, width, height = self.parent.bbox(row_id, col)
>
> + self.place(x=x, y=y, w=width)
>
> + self.variable.set(txt)
>
> + self.focus_set()
>
> + self.icursor(0)
>
> +
>
> + def callback(self, *Args):
>
> + cur_val = self.variable.get()
>
> + new_val = self.validate(cur_val)
>
> + if new_val is not None and self.row >= 0:
>
> + self.last_value = new_val
>
> + self.parent.set_cell(self.row, self.col, new_val)
>
> + self.variable.set(self.last_value)
>
> +
>
> + def validate(self, value):
>
> + if len(value) > 0:
>
> + try:
>
> + int(value, 16)
>
> + except Exception:
>
> + return None
>
> +
>
> + # Normalize the cell format
>
> + self.update()
>
> + cell_width = self.winfo_width()
>
> + max_len = custom_table.to_byte_length(cell_width) * 2
>
> + cur_pos = self.index("insert")
>
> + if cur_pos == max_len + 1:
>
> + value = value[-max_len:]
>
> + else:
>
> + value = value[:max_len]
>
> + if value == '':
>
> + value = '0'
>
> + fmt = '%%0%dX' % max_len
>
> + return fmt % int(value, 16)
>
> +
>
> +
>
> +class custom_table(ttk.Treeview):
>
> + _Padding = 20
>
> + _Char_width = 6
>
> +
>
> + def __init__(self, parent, col_hdr, bins):
>
> + cols = len(col_hdr)
>
> +
>
> + col_byte_len = []
>
> + for col in range(cols): # Columns
>
> + col_byte_len.append(int(col_hdr[col].split(':')[1]))
>
> +
>
> + byte_len = sum(col_byte_len)
>
> + rows = (len(bins) + byte_len - 1) // byte_len
>
> +
>
> + self.rows = rows
>
> + self.cols = cols
>
> + self.col_byte_len = col_byte_len
>
> + self.col_hdr = col_hdr
>
> +
>
> + self.size = len(bins)
>
> + self.last_dir = ''
>
> +
>
> + style = ttk.Style()
>
> + style.configure("Custom.Treeview.Heading",
>
> + font=('calibri', 10, 'bold'),
>
> + foreground="blue")
>
> + ttk.Treeview.__init__(self, parent, height=rows,
>
> + columns=[''] + col_hdr, show='headings',
>
> + style="Custom.Treeview",
>
> + selectmode='none')
>
> + self.bind("<Button-1>", self.click)
>
> + self.bind("<FocusOut>", self.focus_out)
>
> + self.entry = validating_entry(self, width=4, justify=tkinter.CENTER)
>
> +
>
> + self.heading(0, text='LOAD')
>
> + self.column(0, width=60, stretch=0, anchor=tkinter.CENTER)
>
> +
>
> + for col in range(cols): # Columns
>
> + text = col_hdr[col].split(':')[0]
>
> + byte_len = int(col_hdr[col].split(':')[1])
>
> + self.heading(col+1, text=text)
>
> + self.column(col+1, width=self.to_cell_width(byte_len),
>
> + stretch=0, anchor=tkinter.CENTER)
>
> + idx = 0
>
> + for row in range(rows): # Rows
>
> + text = '%04X' % (row * len(col_hdr))
>
> + vals = ['%04X:' % (cols * row)]
>
> + for col in range(cols): # Columns
>
> + if idx >= len(bins):
>
> + break
>
> + byte_len = int(col_hdr[col].split(':')[1])
>
> + value = bytes_to_value(bins[idx:idx+byte_len])
>
> + hex = ("%%0%dX" % (byte_len * 2)) % value
>
> + vals.append(hex)
>
> + idx += byte_len
>
> + self.insert('', 'end', values=tuple(vals))
>
> + if idx >= len(bins):
>
> + break
>
> +
>
> + @staticmethod
>
> + def to_cell_width(byte_len):
>
> + return byte_len * 2 * custom_table._Char_width + custom_table._Padding
>
> +
>
> + @staticmethod
>
> + def to_byte_length(cell_width):
>
> + return(cell_width - custom_table._Padding) \
>
> + // (2 * custom_table._Char_width)
>
> +
>
> + def focus_out(self, event):
>
> + self.entry.display(None)
>
> +
>
> + def refresh_bin(self, bins):
>
> + if not bins:
>
> + return
>
> +
>
> + # Reload binary into widget
>
> + bin_len = len(bins)
>
> + for row in range(self.rows):
>
> + iid = self.get_children()[row]
>
> + for col in range(self.cols):
>
> + idx = row * sum(self.col_byte_len) + \
>
> + sum(self.col_byte_len[:col])
>
> + byte_len = self.col_byte_len[col]
>
> + if idx + byte_len <= self.size:
>
> + byte_len = int(self.col_hdr[col].split(':')[1])
>
> + if idx + byte_len > bin_len:
>
> + val = 0
>
> + else:
>
> + val = bytes_to_value(bins[idx:idx+byte_len])
>
> + hex_val = ("%%0%dX" % (byte_len * 2)) % val
>
> + self.set(iid, col + 1, hex_val)
>
> +
>
> + def get_cell(self, row, col):
>
> + iid = self.get_children()[row]
>
> + txt = self.item(iid, 'values')[col]
>
> + return txt
>
> +
>
> + def get_next_cell(self, row, col):
>
> + rows = self.get_children()
>
> + col += 1
>
> + if col > self.cols:
>
> + col = 1
>
> + row += 1
>
> + cnt = row * sum(self.col_byte_len) + sum(self.col_byte_len[:col])
>
> + if cnt > self.size:
>
> + # Reached the last cell, so roll back to beginning
>
> + row = 0
>
> + col = 1
>
> +
>
> + txt = self.get_cell(row, col)
>
> + row_id = rows[row]
>
> + col_id = '#%d' % (col + 1)
>
> + return(txt, row_id, col_id)
>
> +
>
> + def set_cell(self, row, col, val):
>
> + iid = self.get_children()[row]
>
> + self.set(iid, col, val)
>
> +
>
> + def load_bin(self):
>
> + # Load binary from file
>
> + path = filedialog.askopenfilename(
>
> + initialdir=self.last_dir,
>
> + title="Load binary file",
>
> + filetypes=(("Binary files", "*.bin"), (
>
> + "binary files", "*.bin")))
>
> + if path:
>
> + self.last_dir = os.path.dirname(path)
>
> + fd = open(path, 'rb')
>
> + bins = bytearray(fd.read())[:self.size]
>
> + fd.close()
>
> + bins.extend(b'\x00' * (self.size - len(bins)))
>
> + return bins
>
> +
>
> + return None
>
> +
>
> + def click(self, event):
>
> + row_id = self.identify_row(event.y)
>
> + col_id = self.identify_column(event.x)
>
> + if row_id == '' and col_id == '#1':
>
> + # Clicked on "LOAD" cell
>
> + bins = self.load_bin()
>
> + self.refresh_bin(bins)
>
> + return
>
> +
>
> + if col_id == '#1':
>
> + # Clicked on column 1(Offset column)
>
> + return
>
> +
>
> + item = self.identify('item', event.x, event.y)
>
> + if not item or not col_id:
>
> + # Not clicked on valid cell
>
> + return
>
> +
>
> + # Clicked cell
>
> + row = int('0x' + row_id[1:], 0) - 1
>
> + col = int(col_id[1:]) - 1
>
> + if row * self.cols + col > self.size:
>
> + return
>
> +
>
> + vals = self.item(item, 'values')
>
> + if col < len(vals):
>
> + txt = self.item(item, 'values')[col]
>
> + self.entry.display(txt, row_id, col_id)
>
> +
>
> + def get(self):
>
> + bins = bytearray()
>
> + row_ids = self.get_children()
>
> + for row_id in row_ids:
>
> + row = int('0x' + row_id[1:], 0) - 1
>
> + for col in range(self.cols):
>
> + idx = row * sum(self.col_byte_len) + \
>
> + sum(self.col_byte_len[:col])
>
> + byte_len = self.col_byte_len[col]
>
> + if idx + byte_len > self.size:
>
> + break
>
> + hex = self.item(row_id, 'values')[col + 1]
>
> + values = value_to_bytes(int(hex, 16)
>
> + & ((1 << byte_len * 8) - 1), byte_len)
>
> + bins.extend(values)
>
> + return bins
>
> +
>
> +
>
> +class c_uint24(Structure):
>
> + """Little-Endian 24-bit Unsigned Integer"""
>
> + _pack_ = 1
>
> + _fields_ = [('Data', (c_uint8 * 3))]
>
> +
>
> + def __init__(self, val=0):
>
> + self.set_value(val)
>
> +
>
> + def __str__(self, indent=0):
>
> + return '0x%.6x' % self.value
>
> +
>
> + def __int__(self):
>
> + return self.get_value()
>
> +
>
> + def set_value(self, val):
>
> + self.Data[0:3] = Val2Bytes(val, 3)
>
> +
>
> + def get_value(self):
>
> + return Bytes2Val(self.Data[0:3])
>
> +
>
> + value = property(get_value, set_value)
>
> +
>
> +
>
> +class EFI_FIRMWARE_VOLUME_HEADER(Structure):
>
> + _fields_ = [
>
> + ('ZeroVector', ARRAY(c_uint8, 16)),
>
> + ('FileSystemGuid', ARRAY(c_uint8, 16)),
>
> + ('FvLength', c_uint64),
>
> + ('Signature', ARRAY(c_char, 4)),
>
> + ('Attributes', c_uint32),
>
> + ('HeaderLength', c_uint16),
>
> + ('Checksum', c_uint16),
>
> + ('ExtHeaderOffset', c_uint16),
>
> + ('Reserved', c_uint8),
>
> + ('Revision', c_uint8)
>
> + ]
>
> +
>
> +
>
> +class EFI_FIRMWARE_VOLUME_EXT_HEADER(Structure):
>
> + _fields_ = [
>
> + ('FvName', ARRAY(c_uint8, 16)),
>
> + ('ExtHeaderSize', c_uint32)
>
> + ]
>
> +
>
> +
>
> +class EFI_FFS_INTEGRITY_CHECK(Structure):
>
> + _fields_ = [
>
> + ('Header', c_uint8),
>
> + ('File', c_uint8)
>
> + ]
>
> +
>
> +
>
> +class EFI_FFS_FILE_HEADER(Structure):
>
> + _fields_ = [
>
> + ('Name', ARRAY(c_uint8, 16)),
>
> + ('IntegrityCheck', EFI_FFS_INTEGRITY_CHECK),
>
> + ('Type', c_uint8),
>
> + ('Attributes', c_uint8),
>
> + ('Size', c_uint24),
>
> + ('State', c_uint8)
>
> + ]
>
> +
>
> +
>
> +class EFI_COMMON_SECTION_HEADER(Structure):
>
> + _fields_ = [
>
> + ('Size', c_uint24),
>
> + ('Type', c_uint8)
>
> + ]
>
> +
>
> +
>
> +class EFI_SECTION_TYPE:
>
> + """Enumeration of all valid firmware file section types."""
>
> + ALL = 0x00
>
> + COMPRESSION = 0x01
>
> + GUID_DEFINED = 0x02
>
> + DISPOSABLE = 0x03
>
> + PE32 = 0x10
>
> + PIC = 0x11
>
> + TE = 0x12
>
> + DXE_DEPEX = 0x13
>
> + VERSION = 0x14
>
> + USER_INTERFACE = 0x15
>
> + COMPATIBILITY16 = 0x16
>
> + FIRMWARE_VOLUME_IMAGE = 0x17
>
> + FREEFORM_SUBTYPE_GUID = 0x18
>
> + RAW = 0x19
>
> + PEI_DEPEX = 0x1b
>
> + SMM_DEPEX = 0x1c
>
> +
>
> +
>
> +class FSP_COMMON_HEADER(Structure):
>
> + _fields_ = [
>
> + ('Signature', ARRAY(c_char, 4)),
>
> + ('HeaderLength', c_uint32)
>
> + ]
>
> +
>
> +
>
> +class FSP_INFORMATION_HEADER(Structure):
>
> + _fields_ = [
>
> + ('Signature', ARRAY(c_char, 4)),
>
> + ('HeaderLength', c_uint32),
>
> + ('Reserved1', c_uint16),
>
> + ('SpecVersion', c_uint8),
>
> + ('HeaderRevision', c_uint8),
>
> + ('ImageRevision', c_uint32),
>
> + ('ImageId', ARRAY(c_char, 8)),
>
> + ('ImageSize', c_uint32),
>
> + ('ImageBase', c_uint32),
>
> + ('ImageAttribute', c_uint16),
>
> + ('ComponentAttribute', c_uint16),
>
> + ('CfgRegionOffset', c_uint32),
>
> + ('CfgRegionSize', c_uint32),
>
> + ('Reserved2', c_uint32),
>
> + ('TempRamInitEntryOffset', c_uint32),
>
> + ('Reserved3', c_uint32),
>
> + ('NotifyPhaseEntryOffset', c_uint32),
>
> + ('FspMemoryInitEntryOffset', c_uint32),
>
> + ('TempRamExitEntryOffset', c_uint32),
>
> + ('FspSiliconInitEntryOffset', c_uint32)
>
> + ]
>
> +
>
> +
>
> +class FSP_EXTENDED_HEADER(Structure):
>
> + _fields_ = [
>
> + ('Signature', ARRAY(c_char, 4)),
>
> + ('HeaderLength', c_uint32),
>
> + ('Revision', c_uint8),
>
> + ('Reserved', c_uint8),
>
> + ('FspProducerId', ARRAY(c_char, 6)),
>
> + ('FspProducerRevision', c_uint32),
>
> + ('FspProducerDataSize', c_uint32)
>
> + ]
>
> +
>
> +
>
> +class FSP_PATCH_TABLE(Structure):
>
> + _fields_ = [
>
> + ('Signature', ARRAY(c_char, 4)),
>
> + ('HeaderLength', c_uint16),
>
> + ('HeaderRevision', c_uint8),
>
> + ('Reserved', c_uint8),
>
> + ('PatchEntryNum', c_uint32)
>
> + ]
>
> +
>
> +
>
> +class Section:
>
> + def __init__(self, offset, secdata):
>
> + self.SecHdr = EFI_COMMON_SECTION_HEADER.from_buffer(secdata, 0)
>
> + self.SecData = secdata[0:int(self.SecHdr.Size)]
>
> + self.Offset = offset
>
> +
>
> +
>
> +def AlignPtr(offset, alignment=8):
>
> + return (offset + alignment - 1) & ~(alignment - 1)
>
> +
>
> +
>
> +def Bytes2Val(bytes):
>
> + return reduce(lambda x, y: (x << 8) | y, bytes[:: -1])
>
> +
>
> +
>
> +def Val2Bytes(value, blen):
>
> + return [(value >> (i*8) & 0xff) for i in range(blen)]
>
> +
>
> +
>
> +class FirmwareFile:
>
> + def __init__(self, offset, filedata):
>
> + self.FfsHdr = EFI_FFS_FILE_HEADER.from_buffer(filedata, 0)
>
> + self.FfsData = filedata[0:int(self.FfsHdr.Size)]
>
> + self.Offset = offset
>
> + self.SecList = []
>
> +
>
> + def ParseFfs(self):
>
> + ffssize = len(self.FfsData)
>
> + offset = sizeof(self.FfsHdr)
>
> + if self.FfsHdr.Name != '\xff' * 16:
>
> + while offset < (ffssize - sizeof(EFI_COMMON_SECTION_HEADER)):
>
> + sechdr = EFI_COMMON_SECTION_HEADER.from_buffer(
>
> + self.FfsData, offset)
>
> + sec = Section(
>
> + offset, self.FfsData[offset:offset + int(sechdr.Size)])
>
> + self.SecList.append(sec)
>
> + offset += int(sechdr.Size)
>
> + offset = AlignPtr(offset, 4)
>
> +
>
> +
>
> +class FirmwareVolume:
>
> + def __init__(self, offset, fvdata):
>
> + self.FvHdr = EFI_FIRMWARE_VOLUME_HEADER.from_buffer(fvdata, 0)
>
> + self.FvData = fvdata[0: self.FvHdr.FvLength]
>
> + self.Offset = offset
>
> + if self.FvHdr.ExtHeaderOffset > 0:
>
> + self.FvExtHdr = EFI_FIRMWARE_VOLUME_EXT_HEADER.from_buffer(
>
> + self.FvData, self.FvHdr.ExtHeaderOffset)
>
> + else:
>
> + self.FvExtHdr = None
>
> + self.FfsList = []
>
> +
>
> + def ParseFv(self):
>
> + fvsize = len(self.FvData)
>
> + if self.FvExtHdr:
>
> + offset = self.FvHdr.ExtHeaderOffset + self.FvExtHdr.ExtHeaderSize
>
> + else:
>
> + offset = self.FvHdr.HeaderLength
>
> + offset = AlignPtr(offset)
>
> + while offset < (fvsize - sizeof(EFI_FFS_FILE_HEADER)):
>
> + ffshdr = EFI_FFS_FILE_HEADER.from_buffer(self.FvData, offset)
>
> + if (ffshdr.Name == '\xff' * 16) and \
>
> + (int(ffshdr.Size) == 0xFFFFFF):
>
> + offset = fvsize
>
> + else:
>
> + ffs = FirmwareFile(
>
> + offset, self.FvData[offset:offset + int(ffshdr.Size)])
>
> + ffs.ParseFfs()
>
> + self.FfsList.append(ffs)
>
> + offset += int(ffshdr.Size)
>
> + offset = AlignPtr(offset)
>
> +
>
> +
>
> +class FspImage:
>
> + def __init__(self, offset, fih, fihoff, patch):
>
> + self.Fih = fih
>
> + self.FihOffset = fihoff
>
> + self.Offset = offset
>
> + self.FvIdxList = []
>
> + self.Type = "XTMSXXXXOXXXXXXX"[(fih.ComponentAttribute >> 12) & 0x0F]
>
> + self.PatchList = patch
>
> + self.PatchList.append(fihoff + 0x1C)
>
> +
>
> + def AppendFv(self, FvIdx):
>
> + self.FvIdxList.append(FvIdx)
>
> +
>
> + def Patch(self, delta, fdbin):
>
> + count = 0
>
> + applied = 0
>
> + for idx, patch in enumerate(self.PatchList):
>
> + ptype = (patch >> 24) & 0x0F
>
> + if ptype not in [0x00, 0x0F]:
>
> + raise Exception('ERROR: Invalid patch type %d !' % ptype)
>
> + if patch & 0x80000000:
>
> + patch = self.Fih.ImageSize - (0x1000000 - (patch & 0xFFFFFF))
>
> + else:
>
> + patch = patch & 0xFFFFFF
>
> + if (patch < self.Fih.ImageSize) and \
>
> + (patch + sizeof(c_uint32) <= self.Fih.ImageSize):
>
> + offset = patch + self.Offset
>
> + value = Bytes2Val(fdbin[offset:offset+sizeof(c_uint32)])
>
> + value += delta
>
> + fdbin[offset:offset+sizeof(c_uint32)] = Val2Bytes(
>
> + value, sizeof(c_uint32))
>
> + applied += 1
>
> + count += 1
>
> + # Don't count the FSP base address patch entry appended at the end
>
> + if count != 0:
>
> + count -= 1
>
> + applied -= 1
>
> + return (count, applied)
>
> +
>
> +
>
> +class FirmwareDevice:
>
> + def __init__(self, offset, FdData):
>
> + self.FvList = []
>
> + self.FspList = []
>
> + self.FspExtList = []
>
> + self.FihList = []
>
> + self.BuildList = []
>
> + self.OutputText = ""
>
> + self.Offset = 0
>
> + self.FdData = FdData
>
> +
>
> + def ParseFd(self):
>
> + offset = 0
>
> + fdsize = len(self.FdData)
>
> + self.FvList = []
>
> + while offset < (fdsize - sizeof(EFI_FIRMWARE_VOLUME_HEADER)):
>
> + fvh = EFI_FIRMWARE_VOLUME_HEADER.from_buffer(self.FdData,
> offset)
>
> + if b'_FVH' != fvh.Signature:
>
> + raise Exception("ERROR: Invalid FV header !")
>
> + fv = FirmwareVolume(
>
> + offset, self.FdData[offset:offset + fvh.FvLength])
>
> + fv.ParseFv()
>
> + self.FvList.append(fv)
>
> + offset += fv.FvHdr.FvLength
>
> +
>
> + def CheckFsp(self):
>
> + if len(self.FspList) == 0:
>
> + return
>
> +
>
> + fih = None
>
> + for fsp in self.FspList:
>
> + if not fih:
>
> + fih = fsp.Fih
>
> + else:
>
> + newfih = fsp.Fih
>
> + if (newfih.ImageId != fih.ImageId) or \
>
> + (newfih.ImageRevision != fih.ImageRevision):
>
> + raise Exception(
>
> + "ERROR: Inconsistent FSP ImageId or "
>
> + "ImageRevision detected !")
>
> +
>
> + def ParseFsp(self):
>
> + flen = 0
>
> + for idx, fv in enumerate(self.FvList):
>
> + # Check if this FV contains FSP header
>
> + if flen == 0:
>
> + if len(fv.FfsList) == 0:
>
> + continue
>
> + ffs = fv.FfsList[0]
>
> + if len(ffs.SecList) == 0:
>
> + continue
>
> + sec = ffs.SecList[0]
>
> + if sec.SecHdr.Type != EFI_SECTION_TYPE.RAW:
>
> + continue
>
> + fihoffset = ffs.Offset + sec.Offset + sizeof(sec.SecHdr)
>
> + fspoffset = fv.Offset
>
> + offset = fspoffset + fihoffset
>
> + fih = FSP_INFORMATION_HEADER.from_buffer(self.FdData, offset)
>
> + self.FihList.append(fih)
>
> + if b'FSPH' != fih.Signature:
>
> + continue
>
> +
>
> + offset += fih.HeaderLength
>
> +
>
> + offset = AlignPtr(offset, 2)
>
> + Extfih = FSP_EXTENDED_HEADER.from_buffer(self.FdData, offset)
>
> + self.FspExtList.append(Extfih)
>
> + offset = AlignPtr(offset, 4)
>
> + plist = []
>
> + while True:
>
> + fch = FSP_COMMON_HEADER.from_buffer(self.FdData, offset)
>
> + if b'FSPP' != fch.Signature:
>
> + offset += fch.HeaderLength
>
> + offset = AlignPtr(offset, 4)
>
> + else:
>
> + fspp = FSP_PATCH_TABLE.from_buffer(
>
> + self.FdData, offset)
>
> + offset += sizeof(fspp)
>
> + start_offset = offset + 32
>
> + end_offset = offset + 32
>
> + while True:
>
> + end_offset += 1
>
> + if(self.FdData[
>
> + end_offset: end_offset + 1] == b'\xff'):
>
> + break
>
> + self.BuildList.append(
>
> + self.FdData[start_offset:end_offset])
>
> + pdata = (c_uint32 * fspp.PatchEntryNum).from_buffer(
>
> + self.FdData, offset)
>
> + plist = list(pdata)
>
> + break
>
> +
>
> + fsp = FspImage(fspoffset, fih, fihoffset, plist)
>
> + fsp.AppendFv(idx)
>
> + self.FspList.append(fsp)
>
> + flen = fsp.Fih.ImageSize - fv.FvHdr.FvLength
>
> + else:
>
> + fsp.AppendFv(idx)
>
> + flen -= fv.FvHdr.FvLength
>
> + if flen < 0:
>
> + raise Exception("ERROR: Incorrect FV size in image !")
>
> + self.CheckFsp()
>
> +
>
> + def OutputFsp(self):
>
> + def copy_text_to_clipboard():
>
> + window.clipboard_clear()
>
> + window.clipboard_append(self.OutputText)
>
> +
>
> + window = tkinter.Tk()
>
> + window.title("Fsp Headers")
>
> + window.resizable(0, 0)
>
> + # Window Size
>
> + window.geometry("300x400+350+150")
>
> + frame = tkinter.Frame(window)
>
> + frame.pack(side=tkinter.BOTTOM)
>
> + # Vertical (y) Scroll Bar
>
> + scroll = tkinter.Scrollbar(window)
>
> + scroll.pack(side=tkinter.RIGHT, fill=tkinter.Y)
>
> + text = tkinter.Text(window,
>
> + wrap=tkinter.NONE, yscrollcommand=scroll.set)
>
> + i = 0
>
> + self.OutputText = self.OutputText + "Fsp Header Details \n\n"
>
> + while i < len(self.FihList):
>
> + try:
>
> + self.OutputText += str(self.BuildList[i].decode()) + "\n"
>
> + except Exception:
>
> + self.OutputText += "No description found\n"
>
> + self.OutputText += "FSP Header :\n "
>
> + self.OutputText += "Signature : " + \
>
> + str(self.FihList[i].Signature.decode('utf-8')) + "\n "
>
> + self.OutputText += "Header Length : " + \
>
> + str(hex(self.FihList[i].HeaderLength)) + "\n "
>
> + self.OutputText += "Header Revision : " + \
>
> + str(hex(self.FihList[i].HeaderRevision)) + "\n "
>
> + self.OutputText += "Spec Version : " + \
>
> + str(hex(self.FihList[i].SpecVersion)) + "\n "
>
> + self.OutputText += "Image Revision : " + \
>
> + str(hex(self.FihList[i].ImageRevision)) + "\n "
>
> + self.OutputText += "Image Id : " + \
>
> + str(self.FihList[i].ImageId.decode('utf-8')) + "\n "
>
> + self.OutputText += "Image Size : " + \
>
> + str(hex(self.FihList[i].ImageSize)) + "\n "
>
> + self.OutputText += "Image Base : " + \
>
> + str(hex(self.FihList[i].ImageBase)) + "\n "
>
> + self.OutputText += "Image Attribute : " + \
>
> + str(hex(self.FihList[i].ImageAttribute)) + "\n "
>
> + self.OutputText += "Cfg Region Offset : " + \
>
> + str(hex(self.FihList[i].CfgRegionOffset)) + "\n "
>
> + self.OutputText += "Cfg Region Size : " + \
>
> + str(hex(self.FihList[i].CfgRegionSize)) + "\n "
>
> + self.OutputText += "API Entry Num : " + \
>
> + str(hex(self.FihList[i].Reserved2)) + "\n "
>
> + self.OutputText += "Temp Ram Init Entry : " + \
>
> + str(hex(self.FihList[i].TempRamInitEntryOffset)) + "\n "
>
> + self.OutputText += "FSP Init Entry : " + \
>
> + str(hex(self.FihList[i].Reserved3)) + "\n "
>
> + self.OutputText += "Notify Phase Entry : " + \
>
> + str(hex(self.FihList[i].NotifyPhaseEntryOffset)) + "\n "
>
> + self.OutputText += "Fsp Memory Init Entry : " + \
>
> + str(hex(self.FihList[i].FspMemoryInitEntryOffset)) + "\n "
>
> + self.OutputText += "Temp Ram Exit Entry : " + \
>
> + str(hex(self.FihList[i].TempRamExitEntryOffset)) + "\n "
>
> + self.OutputText += "Fsp Silicon Init Entry : " + \
>
> + str(hex(self.FihList[i].FspSiliconInitEntryOffset)) + "\n\n"
>
> + self.OutputText += "FSP Extended Header:\n "
>
> + self.OutputText += "Signature : " + \
>
> + str(self.FspExtList[i].Signature.decode('utf-8')) + "\n "
>
> + self.OutputText += "Header Length : " + \
>
> + str(hex(self.FspExtList[i].HeaderLength)) + "\n "
>
> + self.OutputText += "Header Revision : " + \
>
> + str(hex(self.FspExtList[i].Revision)) + "\n "
>
> + self.OutputText += "Fsp Producer Id : " + \
>
> + str(self.FspExtList[i].FspProducerId.decode('utf-8')) + "\n "
>
> + self.OutputText += "FspProducerRevision : " + \
>
> + str(hex(self.FspExtList[i].FspProducerRevision)) + "\n\n"
>
> + i += 1
>
> + text.insert(tkinter.INSERT, self.OutputText)
>
> + text.pack()
>
> + # Configure the scrollbars
>
> + scroll.config(command=text.yview)
>
> + copy_button = tkinter.Button(
>
> + window, text="Copy to Clipboard", command=copy_text_to_clipboard)
>
> + copy_button.pack(in_=frame, side=tkinter.LEFT, padx=20, pady=10)
>
> + exit_button = tkinter.Button(
>
> + window, text="Close", command=window.destroy)
>
> + exit_button.pack(in_=frame, side=tkinter.RIGHT, padx=20, pady=10)
>
> + window.mainloop()
>
> +
>
> +
>
> +class state:
>
> + def __init__(self):
>
> + self.state = False
>
> +
>
> + def set(self, value):
>
> + self.state = value
>
> +
>
> + def get(self):
>
> + return self.state
>
> +
>
> +
>
> +class application(tkinter.Frame):
>
> + def __init__(self, master=None):
>
> + root = master
>
> +
>
> + self.debug = True
>
> + self.mode = 'FSP'
>
> + self.last_dir = '.'
>
> + self.page_id = ''
>
> + self.page_list = {}
>
> + self.conf_list = {}
>
> + self.cfg_data_obj = None
>
> + self.org_cfg_data_bin = None
>
> + self.in_left = state()
>
> + self.in_right = state()
>
> +
>
> + # Check if current directory contains a file with a .yaml extension
>
> + # if not default self.last_dir to a Platform directory where it is
>
> + # easier to locate *BoardPkg\CfgData\*Def.yaml files
>
> + self.last_dir = '.'
>
> + if not any(fname.endswith('.yaml') for fname in os.listdir('.')):
>
> + platform_path = Path(os.path.realpath(__file__)).parents[2].\
>
> + joinpath('Platform')
>
> + if platform_path.exists():
>
> + self.last_dir = platform_path
>
> +
>
> + tkinter.Frame.__init__(self, master, borderwidth=2)
>
> +
>
> + self.menu_string = [
>
> + 'Save Config Data to Binary', 'Load Config Data from Binary',
>
> + 'Show Binary Information',
>
> + 'Load Config Changes from Delta File',
>
> + 'Save Config Changes to Delta File',
>
> + 'Save Full Config Data to Delta File',
>
> + 'Open Config BSF file'
>
> + ]
>
> +
>
> + root.geometry("1200x800")
>
> +
>
> + paned = ttk.Panedwindow(root, orient=tkinter.HORIZONTAL)
>
> + paned.pack(fill=tkinter.BOTH, expand=True, padx=(4, 4))
>
> +
>
> + status = tkinter.Label(master, text="", bd=1, relief=tkinter.SUNKEN,
>
> + anchor=tkinter.W)
>
> + status.pack(side=tkinter.BOTTOM, fill=tkinter.X)
>
> +
>
> + frame_left = ttk.Frame(paned, height=800, relief="groove")
>
> +
>
> + self.left = ttk.Treeview(frame_left, show="tree")
>
> +
>
> + # Set up tree HScroller
>
> + pady = (10, 10)
>
> + self.tree_scroll = ttk.Scrollbar(frame_left,
>
> + orient="vertical",
>
> + command=self.left.yview)
>
> + self.left.configure(yscrollcommand=self.tree_scroll.set)
>
> + self.left.bind("<<TreeviewSelect>>", self.on_config_page_select_change)
>
> + self.left.bind("<Enter>", lambda e: self.in_left.set(True))
>
> + self.left.bind("<Leave>", lambda e: self.in_left.set(False))
>
> + self.left.bind("<MouseWheel>", self.on_tree_scroll)
>
> +
>
> + self.left.pack(side='left',
>
> + fill=tkinter.BOTH,
>
> + expand=True,
>
> + padx=(5, 0),
>
> + pady=pady)
>
> + self.tree_scroll.pack(side='right', fill=tkinter.Y,
>
> + pady=pady, padx=(0, 5))
>
> +
>
> + frame_right = ttk.Frame(paned, relief="groove")
>
> + self.frame_right = frame_right
>
> +
>
> + self.conf_canvas = tkinter.Canvas(frame_right, highlightthickness=0)
>
> + self.page_scroll = ttk.Scrollbar(frame_right,
>
> + orient="vertical",
>
> + command=self.conf_canvas.yview)
>
> + self.right_grid = ttk.Frame(self.conf_canvas)
>
> + self.conf_canvas.configure(yscrollcommand=self.page_scroll.set)
>
> + self.conf_canvas.pack(side='left',
>
> + fill=tkinter.BOTH,
>
> + expand=True,
>
> + pady=pady,
>
> + padx=(5, 0))
>
> + self.page_scroll.pack(side='right', fill=tkinter.Y,
>
> + pady=pady, padx=(0, 5))
>
> + self.conf_canvas.create_window(0, 0, window=self.right_grid,
>
> + anchor='nw')
>
> + self.conf_canvas.bind('<Enter>', lambda e: self.in_right.set(True))
>
> + self.conf_canvas.bind('<Leave>', lambda e: self.in_right.set(False))
>
> + self.conf_canvas.bind("<Configure>", self.on_canvas_configure)
>
> + self.conf_canvas.bind_all("<MouseWheel>", self.on_page_scroll)
>
> +
>
> + paned.add(frame_left, weight=2)
>
> + paned.add(frame_right, weight=10)
>
> +
>
> + style = ttk.Style()
>
> + style.layout("Treeview", [('Treeview.treearea', {'sticky': 'nswe'})])
>
> +
>
> + menubar = tkinter.Menu(root)
>
> + file_menu = tkinter.Menu(menubar, tearoff=0)
>
> + file_menu.add_command(label="Open Config YAML file",
>
> + command=self.load_from_yaml)
>
> + file_menu.add_command(label=self.menu_string[6],
>
> + command=self.load_from_bsf_file)
>
> + file_menu.add_command(label=self.menu_string[2],
>
> + command=self.load_from_fd)
>
> + file_menu.add_command(label=self.menu_string[0],
>
> + command=self.save_to_bin,
>
> + state='disabled')
>
> + file_menu.add_command(label=self.menu_string[1],
>
> + command=self.load_from_bin,
>
> + state='disabled')
>
> + file_menu.add_command(label=self.menu_string[3],
>
> + command=self.load_from_delta,
>
> + state='disabled')
>
> + file_menu.add_command(label=self.menu_string[4],
>
> + command=self.save_to_delta,
>
> + state='disabled')
>
> + file_menu.add_command(label=self.menu_string[5],
>
> + command=self.save_full_to_delta,
>
> + state='disabled')
>
> + file_menu.add_command(label="About", command=self.about)
>
> + menubar.add_cascade(label="File", menu=file_menu)
>
> + self.file_menu = file_menu
>
> +
>
> + root.config(menu=menubar)
>
> +
>
> + if len(sys.argv) > 1:
>
> + path = sys.argv[1]
>
> + if not path.endswith('.yaml') and not path.endswith('.pkl'):
>
> + messagebox.showerror('LOADING ERROR',
>
> + "Unsupported file '%s' !" % path)
>
> + return
>
> + else:
>
> + self.load_cfg_file(path)
>
> +
>
> + if len(sys.argv) > 2:
>
> + path = sys.argv[2]
>
> + if path.endswith('.dlt'):
>
> + self.load_delta_file(path)
>
> + elif path.endswith('.bin'):
>
> + self.load_bin_file(path)
>
> + else:
>
> + messagebox.showerror('LOADING ERROR',
>
> + "Unsupported file '%s' !" % path)
>
> + return
>
> +
>
> + def set_object_name(self, widget, name):
>
> + self.conf_list[id(widget)] = name
>
> +
>
> + def get_object_name(self, widget):
>
> + if id(widget) in self.conf_list:
>
> + return self.conf_list[id(widget)]
>
> + else:
>
> + return None
>
> +
>
> + def limit_entry_size(self, variable, limit):
>
> + value = variable.get()
>
> + if len(value) > limit:
>
> + variable.set(value[:limit])
>
> +
>
> + def on_canvas_configure(self, event):
>
> + self.right_grid.grid_columnconfigure(0, minsize=event.width)
>
> +
>
> + def on_tree_scroll(self, event):
>
> + if not self.in_left.get() and self.in_right.get():
>
> + # This prevents scroll event from being handled by both left and
>
> + # right frame at the same time.
>
> + self.on_page_scroll(event)
>
> + return 'break'
>
> +
>
> + def on_page_scroll(self, event):
>
> + if self.in_right.get():
>
> + # Only scroll when it is in active area
>
> + min, max = self.page_scroll.get()
>
> + if not((min == 0.0) and (max == 1.0)):
>
> + self.conf_canvas.yview_scroll(-1 * int(event.delta / 120),
>
> + 'units')
>
> +
>
> + def update_visibility_for_widget(self, widget, args):
>
> +
>
> + visible = True
>
> + item = self.get_config_data_item_from_widget(widget, True)
>
> + if item is None:
>
> + return visible
>
> + elif not item:
>
> + return visible
>
> +
>
> + result = 1
>
> + if item['condition']:
>
> + result = self.evaluate_condition(item)
>
> + if result == 2:
>
> + # Gray
>
> + widget.configure(state='disabled')
>
> + elif result == 0:
>
> + # Hide
>
> + visible = False
>
> + widget.grid_remove()
>
> + else:
>
> + # Show
>
> + widget.grid()
>
> + widget.configure(state='normal')
>
> +
>
> + return visible
>
> +
>
> + def update_widgets_visibility_on_page(self):
>
> + self.walk_widgets_in_layout(self.right_grid,
>
> + self.update_visibility_for_widget)
>
> +
>
> + def combo_select_changed(self, event):
>
> + self.update_config_data_from_widget(event.widget, None)
>
> + self.update_widgets_visibility_on_page()
>
> +
>
> + def edit_num_finished(self, event):
>
> + widget = event.widget
>
> + item = self.get_config_data_item_from_widget(widget)
>
> + if not item:
>
> + return
>
> + parts = item['type'].split(',')
>
> + if len(parts) > 3:
>
> + min = parts[2].lstrip()[1:]
>
> + max = parts[3].rstrip()[:-1]
>
> + min_val = array_str_to_value(min)
>
> + max_val = array_str_to_value(max)
>
> + text = widget.get()
>
> + if ',' in text:
>
> + text = '{ %s }' % text
>
> + try:
>
> + value = array_str_to_value(text)
>
> + if value < min_val or value > max_val:
>
> + raise Exception('Invalid input!')
>
> + self.set_config_item_value(item, text)
>
> + except Exception:
>
> + pass
>
> +
>
> + text = item['value'].strip('{').strip('}').strip()
>
> + widget.delete(0, tkinter.END)
>
> + widget.insert(0, text)
>
> +
>
> + self.update_widgets_visibility_on_page()
>
> +
>
> + def update_page_scroll_bar(self):
>
> + # Update scrollbar
>
> + self.frame_right.update()
>
> + self.conf_canvas.config(scrollregion=self.conf_canvas.bbox("all"))
>
> +
>
> + def on_config_page_select_change(self, event):
>
> + self.update_config_data_on_page()
>
> + sel = self.left.selection()
>
> + if len(sel) > 0:
>
> + page_id = sel[0]
>
> + self.build_config_data_page(page_id)
>
> + self.update_widgets_visibility_on_page()
>
> + self.update_page_scroll_bar()
>
> +
>
> + def walk_widgets_in_layout(self, parent, callback_function, args=None):
>
> + for widget in parent.winfo_children():
>
> + callback_function(widget, args)
>
> +
>
> + def clear_widgets_inLayout(self, parent=None):
>
> + if parent is None:
>
> + parent = self.right_grid
>
> +
>
> + for widget in parent.winfo_children():
>
> + widget.destroy()
>
> +
>
> + parent.grid_forget()
>
> + self.conf_list.clear()
>
> +
>
> + def build_config_page_tree(self, cfg_page, parent):
>
> + for page in cfg_page['child']:
>
> + page_id = next(iter(page))
>
> + # Put CFG items into related page list
>
> + self.page_list[page_id] = self.cfg_data_obj.get_cfg_list(page_id)
>
> + self.page_list[page_id].sort(key=lambda x: x['order'])
>
> + page_name = self.cfg_data_obj.get_page_title(page_id)
>
> + child = self.left.insert(
>
> + parent, 'end',
>
> + iid=page_id, text=page_name,
>
> + value=0)
>
> + if len(page[page_id]) > 0:
>
> + self.build_config_page_tree(page[page_id], child)
>
> +
>
> + def is_config_data_loaded(self):
>
> + return True if len(self.page_list) else False
>
> +
>
> + def set_current_config_page(self, page_id):
>
> + self.page_id = page_id
>
> +
>
> + def get_current_config_page(self):
>
> + return self.page_id
>
> +
>
> + def get_current_config_data(self):
>
> + page_id = self.get_current_config_page()
>
> + if page_id in self.page_list:
>
> + return self.page_list[page_id]
>
> + else:
>
> + return []
>
> +
>
> + invalid_values = {}
>
> +
>
> + def build_config_data_page(self, page_id):
>
> + self.clear_widgets_inLayout()
>
> + self.set_current_config_page(page_id)
>
> + disp_list = []
>
> + for item in self.get_current_config_data():
>
> + disp_list.append(item)
>
> + row = 0
>
> + disp_list.sort(key=lambda x: x['order'])
>
> + for item in disp_list:
>
> + self.add_config_item(item, row)
>
> + row += 2
>
> + if self.invalid_values:
>
> + string = 'The following contails invalid options/values \n\n'
>
> + for i in self.invalid_values:
>
> + string += i + ": " + str(self.invalid_values[i]) + "\n"
>
> + reply = messagebox.showwarning('Warning!', string)
>
> + if reply == 'ok':
>
> + self.invalid_values.clear()
>
> +
>
> + fsp_version = ''
>
> +
>
> + def load_config_data(self, file_name):
>
> + gen_cfg_data = CGenYamlCfg()
>
> + if file_name.endswith('.pkl'):
>
> + with open(file_name, "rb") as pkl_file:
>
> + gen_cfg_data.__dict__ = marshal.load(pkl_file)
>
> + gen_cfg_data.prepare_marshal(False)
>
> + elif file_name.endswith('.yaml'):
>
> + if gen_cfg_data.load_yaml(file_name) != 0:
>
> + raise Exception(gen_cfg_data.get_last_error())
>
> + else:
>
> + raise Exception('Unsupported file "%s" !' % file_name)
>
> + # checking fsp version
>
> + if gen_cfg_data.detect_fsp():
>
> + self.fsp_version = '2.X'
>
> + else:
>
> + self.fsp_version = '1.X'
>
> + return gen_cfg_data
>
> +
>
> + def about(self):
>
> + msg = 'Configuration Editor\n--------------------------------\n \
>
> + Version 0.8\n2021'
>
> + lines = msg.split('\n')
>
> + width = 30
>
> + text = []
>
> + for line in lines:
>
> + text.append(line.center(width, ' '))
>
> + messagebox.showinfo('Config Editor', '\n'.join(text))
>
> +
>
> + def update_last_dir(self, path):
>
> + self.last_dir = os.path.dirname(path)
>
> +
>
> + def get_open_file_name(self, ftype):
>
> + if self.is_config_data_loaded():
>
> + if ftype == 'dlt':
>
> + question = ''
>
> + elif ftype == 'bin':
>
> + question = 'All configuration will be reloaded from BIN file, \
>
> + continue ?'
>
> + elif ftype == 'yaml':
>
> + question = ''
>
> + elif ftype == 'bsf':
>
> + question = ''
>
> + else:
>
> + raise Exception('Unsupported file type !')
>
> + if question:
>
> + reply = messagebox.askquestion('', question, icon='warning')
>
> + if reply == 'no':
>
> + return None
>
> +
>
> + if ftype == 'yaml':
>
> + if self.mode == 'FSP':
>
> + file_type = 'YAML'
>
> + file_ext = 'yaml'
>
> + else:
>
> + file_type = 'YAML or PKL'
>
> + file_ext = 'pkl *.yaml'
>
> + else:
>
> + file_type = ftype.upper()
>
> + file_ext = ftype
>
> +
>
> + path = filedialog.askopenfilename(
>
> + initialdir=self.last_dir,
>
> + title="Load file",
>
> + filetypes=(("%s files" % file_type, "*.%s" % file_ext), (
>
> + "all files", "*.*")))
>
> + if path:
>
> + self.update_last_dir(path)
>
> + return path
>
> + else:
>
> + return None
>
> +
>
> + def load_from_delta(self):
>
> + path = self.get_open_file_name('dlt')
>
> + if not path:
>
> + return
>
> + self.load_delta_file(path)
>
> +
>
> + def load_delta_file(self, path):
>
> + self.reload_config_data_from_bin(self.org_cfg_data_bin)
>
> + try:
>
> + self.cfg_data_obj.override_default_value(path)
>
> + except Exception as e:
>
> + messagebox.showerror('LOADING ERROR', str(e))
>
> + return
>
> + self.update_last_dir(path)
>
> + self.refresh_config_data_page()
>
> +
>
> + def load_from_bin(self):
>
> + path = filedialog.askopenfilename(
>
> + initialdir=self.last_dir,
>
> + title="Load file",
>
> + filetypes={("Binaries", "*.fv *.fd *.bin *.rom")})
>
> + if not path:
>
> + return
>
> + self.load_bin_file(path)
>
> +
>
> + def load_bin_file(self, path):
>
> + with open(path, 'rb') as fd:
>
> + bin_data = bytearray(fd.read())
>
> + if len(bin_data) < len(self.org_cfg_data_bin):
>
> + messagebox.showerror('Binary file size is smaller than what \
>
> + YAML requires !')
>
> + return
>
> +
>
> + try:
>
> + self.reload_config_data_from_bin(bin_data)
>
> + except Exception as e:
>
> + messagebox.showerror('LOADING ERROR', str(e))
>
> + return
>
> +
>
> + def load_from_bsf_file(self):
>
> + path = self.get_open_file_name('bsf')
>
> + if not path:
>
> + return
>
> + self.load_bsf_file(path)
>
> +
>
> + def load_bsf_file(self, path):
>
> + bsf_file = path
>
> + dsc_file = os.path.splitext(bsf_file)[0] + '.dsc'
>
> + yaml_file = os.path.splitext(bsf_file)[0] + '.yaml'
>
> + bsf_to_dsc(bsf_file, dsc_file)
>
> + dsc_to_yaml(dsc_file, yaml_file)
>
> +
>
> + self.load_cfg_file(yaml_file)
>
> + return
>
> +
>
> + def load_from_fd(self):
>
> + path = filedialog.askopenfilename(
>
> + initialdir=self.last_dir,
>
> + title="Load file",
>
> + filetypes={("Binaries", "*.fv *.fd *.bin *.rom")})
>
> + if not path:
>
> + return
>
> + self.load_fd_file(path)
>
> +
>
> + def load_fd_file(self, path):
>
> + with open(path, 'rb') as fd:
>
> + bin_data = bytearray(fd.read())
>
> +
>
> + fd = FirmwareDevice(0, bin_data)
>
> + fd.ParseFd()
>
> + fd.ParseFsp()
>
> + fd.OutputFsp()
>
> +
>
> + def load_cfg_file(self, path):
>
> + # Save current values in widget and clear database
>
> + self.clear_widgets_inLayout()
>
> + self.left.delete(*self.left.get_children())
>
> +
>
> + self.cfg_data_obj = self.load_config_data(path)
>
> +
>
> + self.update_last_dir(path)
>
> + self.org_cfg_data_bin = self.cfg_data_obj.generate_binary_array()
>
> + self.build_config_page_tree(self.cfg_data_obj.get_cfg_page()['root'],
>
> + '')
>
> +
>
> + msg_string = 'Click YES if it is FULL FSP '\
>
> + + self.fsp_version + ' Binary'
>
> + reply = messagebox.askquestion('Form', msg_string)
>
> + if reply == 'yes':
>
> + self.load_from_bin()
>
> +
>
> + for menu in self.menu_string:
>
> + self.file_menu.entryconfig(menu, state="normal")
>
> +
>
> + return 0
>
> +
>
> + def load_from_yaml(self):
>
> + path = self.get_open_file_name('yaml')
>
> + if not path:
>
> + return
>
> +
>
> + self.load_cfg_file(path)
>
> +
>
> + def get_save_file_name(self, extension):
>
> + path = filedialog.asksaveasfilename(
>
> + initialdir=self.last_dir,
>
> + title="Save file",
>
> + defaultextension=extension)
>
> + if path:
>
> + self.last_dir = os.path.dirname(path)
>
> + return path
>
> + else:
>
> + return None
>
> +
>
> + def save_delta_file(self, full=False):
>
> + path = self.get_save_file_name(".dlt")
>
> + if not path:
>
> + return
>
> +
>
> + self.update_config_data_on_page()
>
> + new_data = self.cfg_data_obj.generate_binary_array()
>
> + self.cfg_data_obj.generate_delta_file_from_bin(path,
>
> + self.org_cfg_data_bin,
>
> + new_data, full)
>
> +
>
> + def save_to_delta(self):
>
> + self.save_delta_file()
>
> +
>
> + def save_full_to_delta(self):
>
> + self.save_delta_file(True)
>
> +
>
> + def save_to_bin(self):
>
> + path = self.get_save_file_name(".bin")
>
> + if not path:
>
> + return
>
> +
>
> + self.update_config_data_on_page()
>
> + bins = self.cfg_data_obj.save_current_to_bin()
>
> +
>
> + with open(path, 'wb') as fd:
>
> + fd.write(bins)
>
> +
>
> + def refresh_config_data_page(self):
>
> + self.clear_widgets_inLayout()
>
> + self.on_config_page_select_change(None)
>
> +
>
> + def reload_config_data_from_bin(self, bin_dat):
>
> + self.cfg_data_obj.load_default_from_bin(bin_dat)
>
> + self.refresh_config_data_page()
>
> +
>
> + def set_config_item_value(self, item, value_str):
>
> + itype = item['type'].split(',')[0]
>
> + if itype == "Table":
>
> + new_value = value_str
>
> + elif itype == "EditText":
>
> + length = (self.cfg_data_obj.get_cfg_item_length(item) + 7) // 8
>
> + new_value = value_str[:length]
>
> + if item['value'].startswith("'"):
>
> + new_value = "'%s'" % new_value
>
> + else:
>
> + try:
>
> + new_value = self.cfg_data_obj.reformat_value_str(
>
> + value_str,
>
> + self.cfg_data_obj.get_cfg_item_length(item),
>
> + item['value'])
>
> + except Exception:
>
> + print("WARNING: Failed to format value string '%s' for '%s' !"
>
> + % (value_str, item['path']))
>
> + new_value = item['value']
>
> +
>
> + if item['value'] != new_value:
>
> + if self.debug:
>
> + print('Update %s from %s to %s !'
>
> + % (item['cname'], item['value'], new_value))
>
> + item['value'] = new_value
>
> +
>
> + def get_config_data_item_from_widget(self, widget, label=False):
>
> + name = self.get_object_name(widget)
>
> + if not name or not len(self.page_list):
>
> + return None
>
> +
>
> + if name.startswith('LABEL_'):
>
> + if label:
>
> + path = name[6:]
>
> + else:
>
> + return None
>
> + else:
>
> + path = name
>
> + item = self.cfg_data_obj.get_item_by_path(path)
>
> + return item
>
> +
>
> + def update_config_data_from_widget(self, widget, args):
>
> + item = self.get_config_data_item_from_widget(widget)
>
> + if item is None:
>
> + return
>
> + elif not item:
>
> + if isinstance(widget, tkinter.Label):
>
> + return
>
> + raise Exception('Failed to find "%s" !' %
>
> + self.get_object_name(widget))
>
> +
>
> + itype = item['type'].split(',')[0]
>
> + if itype == "Combo":
>
> + opt_list = self.cfg_data_obj.get_cfg_item_options(item)
>
> + tmp_list = [opt[0] for opt in opt_list]
>
> + idx = widget.current()
>
> + if idx != -1:
>
> + self.set_config_item_value(item, tmp_list[idx])
>
> + elif itype in ["EditNum", "EditText"]:
>
> + self.set_config_item_value(item, widget.get())
>
> + elif itype in ["Table"]:
>
> + new_value = bytes_to_bracket_str(widget.get())
>
> + self.set_config_item_value(item, new_value)
>
> +
>
> + def evaluate_condition(self, item):
>
> + try:
>
> + result = self.cfg_data_obj.evaluate_condition(item)
>
> + except Exception:
>
> + print("WARNING: Condition '%s' is invalid for '%s' !"
>
> + % (item['condition'], item['path']))
>
> + result = 1
>
> + return result
>
> +
>
> + def add_config_item(self, item, row):
>
> + parent = self.right_grid
>
> +
>
> + name = tkinter.Label(parent, text=item['name'], anchor="w")
>
> +
>
> + parts = item['type'].split(',')
>
> + itype = parts[0]
>
> + widget = None
>
> +
>
> + if itype == "Combo":
>
> + # Build
>
> + opt_list = self.cfg_data_obj.get_cfg_item_options(item)
>
> + current_value = self.cfg_data_obj.get_cfg_item_value(item, False)
>
> + option_list = []
>
> + current = None
>
> +
>
> + for idx, option in enumerate(opt_list):
>
> + option_str = option[0]
>
> + try:
>
> + option_value = self.cfg_data_obj.get_value(
>
> + option_str,
>
> + len(option_str), False)
>
> + except Exception:
>
> + option_value = 0
>
> + print('WARNING: Option "%s" has invalid format for "%s" !'
>
> + % (option_str, item['path']))
>
> + if option_value == current_value:
>
> + current = idx
>
> + option_list.append(option[1])
>
> +
>
> + widget = ttk.Combobox(parent, value=option_list, state="readonly")
>
> + widget.bind("<<ComboboxSelected>>", self.combo_select_changed)
>
> + widget.unbind_class("TCombobox", "<MouseWheel>")
>
> +
>
> + if current is None:
>
> + print('WARNING: Value "%s" is an invalid option for "%s" !' %
>
> + (current_value, item['path']))
>
> + self.invalid_values[item['path']] = current_value
>
> + else:
>
> + widget.current(current)
>
> +
>
> + elif itype in ["EditNum", "EditText"]:
>
> + txt_val = tkinter.StringVar()
>
> + widget = tkinter.Entry(parent, textvariable=txt_val)
>
> + value = item['value'].strip("'")
>
> + if itype in ["EditText"]:
>
> + txt_val.trace(
>
> + 'w',
>
> + lambda *args: self.limit_entry_size
>
> + (txt_val, (self.cfg_data_obj.get_cfg_item_length(item)
>
> + + 7) // 8))
>
> + elif itype in ["EditNum"]:
>
> + value = item['value'].strip("{").strip("}").strip()
>
> + widget.bind("<FocusOut>", self.edit_num_finished)
>
> + txt_val.set(value)
>
> +
>
> + elif itype in ["Table"]:
>
> + bins = self.cfg_data_obj.get_cfg_item_value(item, True)
>
> + col_hdr = item['option'].split(',')
>
> + widget = custom_table(parent, col_hdr, bins)
>
> +
>
> + else:
>
> + if itype and itype not in ["Reserved"]:
>
> + print("WARNING: Type '%s' is invalid for '%s' !" %
>
> + (itype, item['path']))
>
> + self.invalid_values[item['path']] = itype
>
> +
>
> + if widget:
>
> + create_tool_tip(widget, item['help'])
>
> + self.set_object_name(name, 'LABEL_' + item['path'])
>
> + self.set_object_name(widget, item['path'])
>
> + name.grid(row=row, column=0, padx=10, pady=5, sticky="nsew")
>
> + widget.grid(row=row + 1, rowspan=1, column=0,
>
> + padx=10, pady=5, sticky="nsew")
>
> +
>
> + def update_config_data_on_page(self):
>
> + self.walk_widgets_in_layout(self.right_grid,
>
> + self.update_config_data_from_widget)
>
> +
>
> +
>
> +if __name__ == '__main__':
>
> + root = tkinter.Tk()
>
> + app = application(master=root)
>
> + root.title("Config Editor")
>
> + root.mainloop()
>
> diff --git a/IntelFsp2Pkg/Tools/ConfigEditor/GenYamlCfg.py
> b/IntelFsp2Pkg/Tools/ConfigEditor/GenYamlCfg.py
> new file mode 100644
> index 0000000000..25fd9c547e
> --- /dev/null
> +++ b/IntelFsp2Pkg/Tools/ConfigEditor/GenYamlCfg.py
> @@ -0,0 +1,2252 @@
> +# @ GenYamlCfg.py
>
> +#
>
> +# Copyright (c) 2020 - 2021, Intel Corporation. All rights reserved.<BR>
>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
>
> +#
>
> +#
>
> +
>
> +import os
>
> +import sys
>
> +import re
>
> +import marshal
>
> +import string
>
> +import operator as op
>
> +import ast
>
> +import tkinter.messagebox as messagebox
>
> +
>
> +from datetime import date
>
> +from collections import OrderedDict
>
> +from CommonUtility import value_to_bytearray, value_to_bytes, \
>
> + bytes_to_value, get_bits_from_bytes, set_bits_to_bytes
>
> +
>
> +# Generated file copyright header
>
> +__copyright_tmp__ = """/** @file
>
> +
>
> + Platform Configuration %s File.
>
> +
>
> + Copyright (c) %4d, Intel Corporation. All rights reserved.<BR>
>
> + SPDX-License-Identifier: BSD-2-Clause-Patent
>
> +
>
> + This file is automatically generated. Please do NOT modify !!!
>
> +
>
> +**/
>
> +"""
>
> +
>
> +
>
> +def get_copyright_header(file_type, allow_modify=False):
>
> + file_description = {
>
> + 'yaml': 'Boot Setting',
>
> + 'dlt': 'Delta',
>
> + 'inc': 'C Binary Blob',
>
> + 'h': 'C Struct Header'
>
> + }
>
> + if file_type in ['yaml', 'dlt']:
>
> + comment_char = '#'
>
> + else:
>
> + comment_char = ''
>
> + lines = __copyright_tmp__.split('\n')
>
> + if allow_modify:
>
> + lines = [line for line in lines if 'Please do NOT modify' not in line]
>
> + copyright_hdr = '\n'.join('%s%s' % (comment_char, line)
>
> + for line in lines)[:-1] + '\n'
>
> + return copyright_hdr % (file_description[file_type], date.today().year)
>
> +
>
> +
>
> +def check_quote(text):
>
> + if (text[0] == "'" and text[-1] == "'") or (text[0] == '"'
>
> + and text[-1] == '"'):
>
> + return True
>
> + return False
>
> +
>
> +
>
> +def strip_quote(text):
>
> + new_text = text.strip()
>
> + if check_quote(new_text):
>
> + return new_text[1:-1]
>
> + return text
>
> +
>
> +
>
> +def strip_delimiter(text, delim):
>
> + new_text = text.strip()
>
> + if new_text:
>
> + if new_text[0] == delim[0] and new_text[-1] == delim[-1]:
>
> + return new_text[1:-1]
>
> + return text
>
> +
>
> +
>
> +def bytes_to_bracket_str(bytes):
>
> + return '{ %s }' % (', '.join('0x%02x' % i for i in bytes))
>
> +
>
> +
>
> +def array_str_to_value(val_str):
>
> + val_str = val_str.strip()
>
> + val_str = strip_delimiter(val_str, '{}')
>
> + val_str = strip_quote(val_str)
>
> + value = 0
>
> + for each in val_str.split(',')[::-1]:
>
> + each = each.strip()
>
> + value = (value << 8) | int(each, 0)
>
> + return value
>
> +
>
> +
>
> +def write_lines(lines, file):
>
> + fo = open(file, "w")
>
> + fo.write(''.join([x[0] for x in lines]))
>
> + fo.close()
>
> +
>
> +
>
> +def read_lines(file):
>
> + if not os.path.exists(file):
>
> + test_file = os.path.basename(file)
>
> + if os.path.exists(test_file):
>
> + file = test_file
>
> + fi = open(file, 'r')
>
> + lines = fi.readlines()
>
> + fi.close()
>
> + return lines
>
> +
>
> +
>
> +def expand_file_value(path, value_str):
>
> + result = bytearray()
>
> + match = re.match("\\{\\s*FILE:(.+)\\}", value_str)
>
> + if match:
>
> + file_list = match.group(1).split(',')
>
> + for file in file_list:
>
> + file = file.strip()
>
> + bin_path = os.path.join(path, file)
>
> + result.extend(bytearray(open(bin_path, 'rb').read()))
>
> + print('\n\n result ', result)
>
> + return result
>
> +
>
> +
>
> +class ExpressionEval(ast.NodeVisitor):
>
> + operators = {
>
> + ast.Add: op.add,
>
> + ast.Sub: op.sub,
>
> + ast.Mult: op.mul,
>
> + ast.Div: op.floordiv,
>
> + ast.Mod: op.mod,
>
> + ast.Eq: op.eq,
>
> + ast.NotEq: op.ne,
>
> + ast.Gt: op.gt,
>
> + ast.Lt: op.lt,
>
> + ast.GtE: op.ge,
>
> + ast.LtE: op.le,
>
> + ast.BitXor: op.xor,
>
> + ast.BitAnd: op.and_,
>
> + ast.BitOr: op.or_,
>
> + ast.Invert: op.invert,
>
> + ast.USub: op.neg
>
> + }
>
> +
>
> + def __init__(self):
>
> + self._debug = False
>
> + self._expression = ''
>
> + self._namespace = {}
>
> + self._get_variable = None
>
> +
>
> + def eval(self, expr, vars={}):
>
> + self._expression = expr
>
> + if type(vars) is dict:
>
> + self._namespace = vars
>
> + self._get_variable = None
>
> + else:
>
> + self._namespace = {}
>
> + self._get_variable = vars
>
> + node = ast.parse(self._expression, mode='eval')
>
> + result = self.visit(node.body)
>
> + if self._debug:
>
> + print('EVAL [ %s ] = %s' % (expr, str(result)))
>
> + return result
>
> +
>
> + def visit_Name(self, node):
>
> + if self._get_variable is not None:
>
> + return self._get_variable(node.id)
>
> + else:
>
> + return self._namespace[node.id]
>
> +
>
> + def visit_Num(self, node):
>
> + return node.n
>
> +
>
> + def visit_NameConstant(self, node):
>
> + return node.value
>
> +
>
> + def visit_BoolOp(self, node):
>
> + result = False
>
> + if isinstance(node.op, ast.And):
>
> + for value in node.values:
>
> + result = self.visit(value)
>
> + if not result:
>
> + break
>
> + elif isinstance(node.op, ast.Or):
>
> + for value in node.values:
>
> + result = self.visit(value)
>
> + if result:
>
> + break
>
> + return True if result else False
>
> +
>
> + def visit_UnaryOp(self, node):
>
> + val = self.visit(node.operand)
>
> + return ExpressionEval.operators[type(node.op)](val)
>
> +
>
> + def visit_BinOp(self, node):
>
> + lhs = self.visit(node.left)
>
> + rhs = self.visit(node.right)
>
> + return ExpressionEval.operators[type(node.op)](lhs, rhs)
>
> +
>
> + def visit_Compare(self, node):
>
> + right = self.visit(node.left)
>
> + result = True
>
> + for operation, comp in zip(node.ops, node.comparators):
>
> + if not result:
>
> + break
>
> + left = right
>
> + right = self.visit(comp)
>
> + result = ExpressionEval.operators[type(operation)](left, right)
>
> + return result
>
> +
>
> + def visit_Call(self, node):
>
> + if node.func.id in ['ternary']:
>
> + condition = self.visit(node.args[0])
>
> + val_true = self.visit(node.args[1])
>
> + val_false = self.visit(node.args[2])
>
> + return val_true if condition else val_false
>
> + elif node.func.id in ['offset', 'length']:
>
> + if self._get_variable is not None:
>
> + return self._get_variable(node.args[0].s, node.func.id)
>
> + else:
>
> + raise ValueError("Unsupported function: " + repr(node))
>
> +
>
> + def generic_visit(self, node):
>
> + raise ValueError("malformed node or string: " + repr(node))
>
> +
>
> +
>
> +class CFG_YAML():
>
> + TEMPLATE = 'template'
>
> + CONFIGS = 'configs'
>
> + VARIABLE = 'variable'
>
> +
>
> + def __init__(self):
>
> + self.log_line = False
>
> + self.allow_template = False
>
> + self.cfg_tree = None
>
> + self.tmp_tree = None
>
> + self.var_dict = None
>
> + self.def_dict = {}
>
> + self.yaml_path = ''
>
> + self.lines = []
>
> + self.full_lines = []
>
> + self.index = 0
>
> + self.re_expand = re.compile(
>
> + r'(.+:\s+|\s*\-\s*)!expand\s+\{\s*(\w+_TMPL)\s*:\s*\[(.+)]\s*\}')
>
> + self.re_include = re.compile(r'(.+:\s+|\s*\-\s*)!include\s+(.+)')
>
> +
>
> + @staticmethod
>
> + def count_indent(line):
>
> + return next((i for i, c in enumerate(line) if not c.isspace()),
>
> + len(line))
>
> +
>
> + @staticmethod
>
> + def substitue_args(text, arg_dict):
>
> + for arg in arg_dict:
>
> + text = text.replace('$' + arg, arg_dict[arg])
>
> + return text
>
> +
>
> + @staticmethod
>
> + def dprint(*args):
>
> + pass
>
> +
>
> + def process_include(self, line, insert=True):
>
> + match = self.re_include.match(line)
>
> + if not match:
>
> + raise Exception("Invalid !include format '%s' !" % line.strip())
>
> +
>
> + prefix = match.group(1)
>
> + include = match.group(2)
>
> + if prefix.strip() == '-':
>
> + prefix = ''
>
> + adjust = 0
>
> + else:
>
> + adjust = 2
>
> +
>
> + include = strip_quote(include)
>
> + request = CFG_YAML.count_indent(line) + adjust
>
> +
>
> + if self.log_line:
>
> + # remove the include line itself
>
> + del self.full_lines[-1]
>
> +
>
> + inc_path = os.path.join(self.yaml_path, include)
>
> + if not os.path.exists(inc_path):
>
> + # try relative path to project root
>
> + try_path = os.path.join(os.path.dirname(os.path.realpath(__file__)
>
> + ), "../..", include)
>
> + if os.path.exists(try_path):
>
> + inc_path = try_path
>
> + else:
>
> + raise Exception("ERROR: Cannot open file '%s'." % inc_path)
>
> +
>
> + lines = read_lines(inc_path)
>
> + current = 0
>
> + same_line = False
>
> + for idx, each in enumerate(lines):
>
> + start = each.lstrip()
>
> + if start == '' or start[0] == '#':
>
> + continue
>
> +
>
> + if start[0] == '>':
>
> + # append the content directly at the same line
>
> + same_line = True
>
> +
>
> + start = idx
>
> + current = CFG_YAML.count_indent(each)
>
> + break
>
> +
>
> + lines = lines[start+1:] if same_line else lines[start:]
>
> + leading = ''
>
> + if same_line:
>
> + request = len(prefix)
>
> + leading = '>'
>
> +
>
> + lines = [prefix + '%s\n' % leading] + [' ' * request +
>
> + i[current:] for i in lines]
>
> + if insert:
>
> + self.lines = lines + self.lines
>
> +
>
> + return lines
>
> +
>
> + def process_expand(self, line):
>
> + match = self.re_expand.match(line)
>
> + if not match:
>
> + raise Exception("Invalid !expand format '%s' !" % line.strip())
>
> + lines = []
>
> + prefix = match.group(1)
>
> + temp_name = match.group(2)
>
> + args = match.group(3)
>
> +
>
> + if prefix.strip() == '-':
>
> + indent = 0
>
> + else:
>
> + indent = 2
>
> + lines = self.process_expand_template(temp_name, prefix, args, indent)
>
> + self.lines = lines + self.lines
>
> +
>
> + def process_expand_template(self, temp_name, prefix, args, indent=2):
>
> + # expand text with arg substitution
>
> + if temp_name not in self.tmp_tree:
>
> + raise Exception("Could not find template '%s' !" % temp_name)
>
> + parts = args.split(',')
>
> + parts = [i.strip() for i in parts]
>
> + num = len(parts)
>
> + arg_dict = dict(zip(['(%d)' % (i + 1) for i in range(num)], parts))
>
> + str_data = self.tmp_tree[temp_name]
>
> + text = DefTemplate(str_data).safe_substitute(self.def_dict)
>
> + text = CFG_YAML.substitue_args(text, arg_dict)
>
> + target = CFG_YAML.count_indent(prefix) + indent
>
> + current = CFG_YAML.count_indent(text)
>
> + padding = target * ' '
>
> + if indent == 0:
>
> + leading = []
>
> + else:
>
> + leading = [prefix + '\n']
>
> + text = leading + [(padding + i + '\n')[current:]
>
> + for i in text.splitlines()]
>
> + return text
>
> +
>
> + def load_file(self, yaml_file):
>
> + self.index = 0
>
> + self.lines = read_lines(yaml_file)
>
> +
>
> + def peek_line(self):
>
> + if len(self.lines) == 0:
>
> + return None
>
> + else:
>
> + return self.lines[0]
>
> +
>
> + def put_line(self, line):
>
> + self.lines.insert(0, line)
>
> + if self.log_line:
>
> + del self.full_lines[-1]
>
> +
>
> + def get_line(self):
>
> + if len(self.lines) == 0:
>
> + return None
>
> + else:
>
> + line = self.lines.pop(0)
>
> + if self.log_line:
>
> + self.full_lines.append(line.rstrip())
>
> + return line
>
> +
>
> + def get_multiple_line(self, indent):
>
> + text = ''
>
> + newind = indent + 1
>
> + while True:
>
> + line = self.peek_line()
>
> + if line is None:
>
> + break
>
> + sline = line.strip()
>
> + if sline != '':
>
> + newind = CFG_YAML.count_indent(line)
>
> + if newind <= indent:
>
> + break
>
> + self.get_line()
>
> + if sline != '':
>
> + text = text + line
>
> + return text
>
> +
>
> + def traverse_cfg_tree(self, handler):
>
> + def _traverse_cfg_tree(root, level=0):
>
> + # config structure
>
> + for key in root:
>
> + if type(root[key]) is OrderedDict:
>
> + level += 1
>
> + handler(key, root[key], level)
>
> + _traverse_cfg_tree(root[key], level)
>
> + level -= 1
>
> + _traverse_cfg_tree(self.cfg_tree)
>
> +
>
> + def count(self):
>
> + def _count(name, cfgs, level):
>
> + num[0] += 1
>
> + num = [0]
>
> + self.traverse_cfg_tree(_count)
>
> + return num[0]
>
> +
>
> + def parse(self, parent_name='', curr=None, level=0):
>
> + child = None
>
> + last_indent = None
>
> + key = ''
>
> + temp_chk = {}
>
> +
>
> + while True:
>
> + line = self.get_line()
>
> + if line is None:
>
> + break
>
> +
>
> + curr_line = line.strip()
>
> + if curr_line == '' or curr_line[0] == '#':
>
> + continue
>
> +
>
> + indent = CFG_YAML.count_indent(line)
>
> + if last_indent is None:
>
> + last_indent = indent
>
> +
>
> + if indent != last_indent:
>
> + # outside of current block, put the line back to queue
>
> + self.put_line(' ' * indent + curr_line)
>
> +
>
> + if curr_line.endswith(': >'):
>
> + # multiline marker
>
> + old_count = len(self.full_lines)
>
> + line = self.get_multiple_line(indent)
>
> + if self.log_line and not self.allow_template \
>
> + and '!include ' in line:
>
> + # expand include in template
>
> + new_lines = []
>
> + lines = line.splitlines()
>
> + for idx, each in enumerate(lines):
>
> + if '!include ' in each:
>
> + new_line = ''.join(self.process_include(each,
>
> + False))
>
> + new_lines.append(new_line)
>
> + else:
>
> + new_lines.append(each)
>
> + self.full_lines = self.full_lines[:old_count] + new_lines
>
> + curr_line = curr_line + line
>
> +
>
> + if indent > last_indent:
>
> + # child nodes
>
> + if child is None:
>
> + raise Exception('Unexpected format at line: %s'
>
> + % (curr_line))
>
> +
>
> + level += 1
>
> + self.parse(key, child, level)
>
> + level -= 1
>
> + line = self.peek_line()
>
> + if line is not None:
>
> + curr_line = line.strip()
>
> + indent = CFG_YAML.count_indent(line)
>
> + if indent >= last_indent:
>
> + # consume the line
>
> + self.get_line()
>
> + else:
>
> + # end of file
>
> + indent = -1
>
> +
>
> + if curr is None:
>
> + curr = OrderedDict()
>
> +
>
> + if indent < last_indent:
>
> + return curr
>
> +
>
> + marker1 = curr_line[0]
>
> + marker2 = curr_line[-1]
>
> + start = 1 if marker1 == '-' else 0
>
> + pos = curr_line.find(': ')
>
> + if pos > 0:
>
> + child = None
>
> + key = curr_line[start:pos].strip()
>
> + if curr_line[pos + 2] == '>':
>
> + curr[key] = curr_line[pos + 3:]
>
> + else:
>
> + # XXXX: !include / !expand
>
> + if '!include ' in curr_line:
>
> + self.process_include(line)
>
> + elif '!expand ' in curr_line:
>
> + if self.allow_template and not self.log_line:
>
> + self.process_expand(line)
>
> + else:
>
> + value_str = curr_line[pos + 2:].strip()
>
> + curr[key] = value_str
>
> + if self.log_line and value_str[0] == '{':
>
> + # expand {FILE: xxxx} format in the log line
>
> + if value_str[1:].rstrip().startswith('FILE:'):
>
> + value_bytes = expand_file_value(
>
> + self.yaml_path, value_str)
>
> + value_str = bytes_to_bracket_str(value_bytes)
>
> + self.full_lines[-1] = line[
>
> + :indent] + curr_line[:pos + 2] + value_str
>
> +
>
> + elif marker2 == ':':
>
> + child = OrderedDict()
>
> + key = curr_line[start:-1].strip()
>
> + if key == '$ACTION':
>
> + # special virtual nodes, rename to ensure unique key
>
> + key = '$ACTION_%04X' % self.index
>
> + self.index += 1
>
> + if key in curr:
>
> + if key not in temp_chk:
>
> + # check for duplicated keys at same level
>
> + temp_chk[key] = 1
>
> + else:
>
> + raise Exception("Duplicated item '%s:%s' found !"
>
> + % (parent_name, key))
>
> +
>
> + curr[key] = child
>
> + if self.var_dict is None and key == CFG_YAML.VARIABLE:
>
> + self.var_dict = child
>
> + if self.tmp_tree is None and key == CFG_YAML.TEMPLATE:
>
> + self.tmp_tree = child
>
> + if self.var_dict:
>
> + for each in self.var_dict:
>
> + txt = self.var_dict[each]
>
> + if type(txt) is str:
>
> + self.def_dict['(%s)' % each] = txt
>
> + if self.tmp_tree and key == CFG_YAML.CONFIGS:
>
> + # apply template for the main configs
>
> + self.allow_template = True
>
> + else:
>
> + child = None
>
> + # - !include cfg_opt.yaml
>
> + if '!include ' in curr_line:
>
> + self.process_include(line)
>
> +
>
> + return curr
>
> +
>
> + def load_yaml(self, opt_file):
>
> + self.var_dict = None
>
> + self.yaml_path = os.path.dirname(opt_file)
>
> + self.load_file(opt_file)
>
> + yaml_tree = self.parse()
>
> + self.tmp_tree = yaml_tree[CFG_YAML.TEMPLATE]
>
> + self.cfg_tree = yaml_tree[CFG_YAML.CONFIGS]
>
> + return self.cfg_tree
>
> +
>
> + def expand_yaml(self, opt_file):
>
> + self.log_line = True
>
> + self.load_yaml(opt_file)
>
> + self.log_line = False
>
> + text = '\n'.join(self.full_lines)
>
> + self.full_lines = []
>
> + return text
>
> +
>
> +
>
> +class DefTemplate(string.Template):
>
> + idpattern = '\\([_A-Z][_A-Z0-9]*\\)|[_A-Z][_A-Z0-9]*'
>
> +
>
> +
>
> +class CGenYamlCfg:
>
> + STRUCT = '$STRUCT'
>
> + bits_width = {'b': 1, 'B': 8, 'W': 16, 'D': 32, 'Q': 64}
>
> + builtin_option = {'$EN_DIS': [('0', 'Disable'), ('1', 'Enable')]}
>
> + exclude_struct = ['FSP_UPD_HEADER', 'FSPT_ARCH_UPD',
>
> + 'FSPM_ARCH_UPD', 'FSPS_ARCH_UPD',
>
> + 'GPIO_GPP_*', 'GPIO_CFG_DATA',
>
> + 'GpioConfPad*', 'GpioPinConfig',
>
> + 'BOOT_OPTION*', 'PLATFORMID_CFG_DATA', '\\w+_Half[01]']
>
> + include_tag = ['GPIO_CFG_DATA']
>
> + keyword_set = set(['name', 'type', 'option', 'help', 'length',
>
> + 'value', 'order', 'struct', 'condition'])
>
> +
>
> + def __init__(self):
>
> + self._mode = ''
>
> + self._debug = False
>
> + self._macro_dict = {}
>
> + self.initialize()
>
> +
>
> + def initialize(self):
>
> + self._old_bin = None
>
> + self._cfg_tree = {}
>
> + self._tmp_tree = {}
>
> + self._cfg_list = []
>
> + self._cfg_page = {'root': {'title': '', 'child': []}}
>
> + self._cur_page = ''
>
> + self._var_dict = {}
>
> + self._def_dict = {}
>
> + self._yaml_path = ''
>
> +
>
> + @staticmethod
>
> + def deep_convert_dict(layer):
>
> + # convert OrderedDict to list + dict
>
> + new_list = layer
>
> + if isinstance(layer, OrderedDict):
>
> + new_list = list(layer.items())
>
> + for idx, pair in enumerate(new_list):
>
> + new_node = CGenYamlCfg.deep_convert_dict(pair[1])
>
> + new_list[idx] = dict({pair[0]: new_node})
>
> + return new_list
>
> +
>
> + @staticmethod
>
> + def deep_convert_list(layer):
>
> + if isinstance(layer, list):
>
> + od = OrderedDict({})
>
> + for each in layer:
>
> + if isinstance(each, dict):
>
> + key = next(iter(each))
>
> + od[key] = CGenYamlCfg.deep_convert_list(each[key])
>
> + return od
>
> + else:
>
> + return layer
>
> +
>
> + @staticmethod
>
> + def expand_include_files(file_path, cur_dir=''):
>
> + if cur_dir == '':
>
> + cur_dir = os.path.dirname(file_path)
>
> + file_path = os.path.basename(file_path)
>
> +
>
> + input_file_path = os.path.join(cur_dir, file_path)
>
> + file = open(input_file_path, "r")
>
> + lines = file.readlines()
>
> + file.close()
>
> + new_lines = []
>
> + for line_num, line in enumerate(lines):
>
> + match = re.match("^!include\\s*(.+)?$", line.strip())
>
> + if match:
>
> + inc_path = match.group(1)
>
> + tmp_path = os.path.join(cur_dir, inc_path)
>
> + org_path = tmp_path
>
> + if not os.path.exists(tmp_path):
>
> + cur_dir = os.path.join(os.path.dirname
>
> + (os.path.realpath(__file__)
>
> + ), "..", "..")
>
> + tmp_path = os.path.join(cur_dir, inc_path)
>
> + if not os.path.exists(tmp_path):
>
> + raise Exception("ERROR: Cannot open include\
>
> + file '%s'." % org_path)
>
> + else:
>
> + new_lines.append(('# Included from file: %s\n' % inc_path,
>
> + tmp_path, 0))
>
> + new_lines.append(('# %s\n' % ('=' * 80), tmp_path, 0))
>
> + new_lines.extend(CGenYamlCfg.expand_include_files
>
> + (inc_path, cur_dir))
>
> + else:
>
> + new_lines.append((line, input_file_path, line_num))
>
> +
>
> + return new_lines
>
> +
>
> + @staticmethod
>
> + def format_struct_field_name(input, count=0):
>
> + name = ''
>
> + cap = True
>
> + if '_' in input:
>
> + input = input.lower()
>
> + for each in input:
>
> + if each == '_':
>
> + cap = True
>
> + continue
>
> + elif cap:
>
> + each = each.upper()
>
> + cap = False
>
> + name = name + each
>
> +
>
> + if count > 1:
>
> + name = '%s[%d]' % (name, count)
>
> +
>
> + return name
>
> +
>
> + def get_mode(self):
>
> + return self._mode
>
> +
>
> + def set_mode(self, mode):
>
> + self._mode = mode
>
> +
>
> + def get_last_error(self):
>
> + return ''
>
> +
>
> + def get_variable(self, var, attr='value'):
>
> + if var in self._var_dict:
>
> + var = self._var_dict[var]
>
> + return var
>
> +
>
> + item = self.locate_cfg_item(var, False)
>
> + if item is None:
>
> + raise ValueError("Cannot find variable '%s' !" % var)
>
> +
>
> + if item:
>
> + if 'indx' in item:
>
> + item = self.get_item_by_index(item['indx'])
>
> + if attr == 'offset':
>
> + var = item['offset']
>
> + elif attr == 'length':
>
> + var = item['length']
>
> + elif attr == 'value':
>
> + var = self.get_cfg_item_value(item)
>
> + else:
>
> + raise ValueError("Unsupported variable attribute '%s' !" %
>
> + attr)
>
> + return var
>
> +
>
> + def eval(self, expr):
>
> + def _handler(pattern):
>
> + if pattern.group(1):
>
> + target = 1
>
> + else:
>
> + target = 2
>
> + result = self.get_variable(pattern.group(target))
>
> + if result is None:
>
> + raise ValueError('Unknown variable $(%s) !' %
>
> + pattern.group(target))
>
> + return hex(result)
>
> +
>
> + expr_eval = ExpressionEval()
>
> + if '$' in expr:
>
> + # replace known variable first
>
> + expr = re.sub(r'\$\(([_a-zA-Z][\w\.]*)\)|\$([_a-zA-Z][\w\.]*)',
>
> + _handler, expr)
>
> + return expr_eval.eval(expr, self.get_variable)
>
> +
>
> + def parse_macros(self, macro_def_str):
>
> + # ['-DABC=1', '-D', 'CFG_DEBUG=1', '-D', 'CFG_OUTDIR=Build']
>
> + self._macro_dict = {}
>
> + is_expression = False
>
> + for macro in macro_def_str:
>
> + if macro.startswith('-D'):
>
> + is_expression = True
>
> + if len(macro) > 2:
>
> + macro = macro[2:]
>
> + else:
>
> + continue
>
> + if is_expression:
>
> + is_expression = False
>
> + match = re.match("(\\w+)=(.+)", macro)
>
> + if match:
>
> + self._macro_dict[match.group(1)] = match.group(2)
>
> + else:
>
> + match = re.match("(\\w+)", macro)
>
> + if match:
>
> + self._macro_dict[match.group(1)] = ''
>
> + if len(self._macro_dict) == 0:
>
> + error = 1
>
> + else:
>
> + error = 0
>
> + if self._debug:
>
> + print("INFO : Macro dictionary:")
>
> + for each in self._macro_dict:
>
> + print(" $(%s) = [ %s ]"
>
> + % (each, self._macro_dict[each]))
>
> + return error
>
> +
>
> + def get_cfg_list(self, page_id=None):
>
> + if page_id is None:
>
> + # return full list
>
> + return self._cfg_list
>
> + else:
>
> + # build a new list for items under a page ID
>
> + cfgs = [i for i in self._cfg_list if i['cname'] and
>
> + (i['page'] == page_id)]
>
> + return cfgs
>
> +
>
> + def get_cfg_page(self):
>
> + return self._cfg_page
>
> +
>
> + def get_cfg_item_length(self, item):
>
> + return item['length']
>
> +
>
> + def get_cfg_item_value(self, item, array=False):
>
> + value_str = item['value']
>
> + length = item['length']
>
> + return self.get_value(value_str, length, array)
>
> +
>
> + def format_value_to_str(self, value, bit_length, old_value=''):
>
> + # value is always int
>
> + length = (bit_length + 7) // 8
>
> + fmt = ''
>
> + if old_value.startswith('0x'):
>
> + fmt = '0x'
>
> + elif old_value and (old_value[0] in ['"', "'", '{']):
>
> + fmt = old_value[0]
>
> + else:
>
> + fmt = ''
>
> +
>
> + bvalue = value_to_bytearray(value, length)
>
> + if fmt in ['"', "'"]:
>
> + svalue = bvalue.rstrip(b'\x00').decode()
>
> + value_str = fmt + svalue + fmt
>
> + elif fmt == "{":
>
> + value_str = '{ ' + ', '.join(['0x%02x' % i for i in bvalue]) + ' }'
>
> + elif fmt == '0x':
>
> + hex_len = length * 2
>
> + if len(old_value) == hex_len + 2:
>
> + fstr = '0x%%0%dx' % hex_len
>
> + else:
>
> + fstr = '0x%x'
>
> + value_str = fstr % value
>
> + else:
>
> + if length <= 2:
>
> + value_str = '%d' % value
>
> + elif length <= 8:
>
> + value_str = '0x%x' % value
>
> + else:
>
> + value_str = '{ ' + ', '.join(['0x%02x' % i for i in
>
> + bvalue]) + ' }'
>
> + return value_str
>
> +
>
> + def reformat_value_str(self, value_str, bit_length, old_value=None):
>
> + value = self.parse_value(value_str, bit_length, False)
>
> + if old_value is None:
>
> + old_value = value_str
>
> + new_value = self.format_value_to_str(value, bit_length, old_value)
>
> + return new_value
>
> +
>
> + def get_value(self, value_str, bit_length, array=True):
>
> + value_str = value_str.strip()
>
> + if value_str[0] == "'" and value_str[-1] == "'" or \
>
> + value_str[0] == '"' and value_str[-1] == '"':
>
> + value_str = value_str[1:-1]
>
> + bvalue = bytearray(value_str.encode())
>
> + if len(bvalue) == 0:
>
> + bvalue = bytearray(b'\x00')
>
> + if array:
>
> + return bvalue
>
> + else:
>
> + return bytes_to_value(bvalue)
>
> + else:
>
> + if value_str[0] in '{':
>
> + value_str = value_str[1:-1].strip()
>
> + value = 0
>
> + for each in value_str.split(',')[::-1]:
>
> + each = each.strip()
>
> + value = (value << 8) | int(each, 0)
>
> + if array:
>
> + length = (bit_length + 7) // 8
>
> + return value_to_bytearray(value, length)
>
> + else:
>
> + return value
>
> +
>
> + def parse_value(self, value_str, bit_length, array=True):
>
> + length = (bit_length + 7) // 8
>
> + if check_quote(value_str):
>
> + value_str = bytes_to_bracket_str(value_str[1:-1].encode())
>
> + elif (',' in value_str) and (value_str[0] != '{'):
>
> + value_str = '{ %s }' % value_str
>
> + if value_str[0] == '{':
>
> + result = expand_file_value(self._yaml_path, value_str)
>
> + if len(result) == 0:
>
> + bin_list = value_str[1:-1].split(',')
>
> + value = 0
>
> + bit_len = 0
>
> + unit_len = 1
>
> + for idx, element in enumerate(bin_list):
>
> + each = element.strip()
>
> + if len(each) == 0:
>
> + continue
>
> +
>
> + in_bit_field = False
>
> + if each[0] in "'" + '"':
>
> + each_value = bytearray(each[1:-1], 'utf-8')
>
> + elif ':' in each:
>
> + match = re.match("^(.+):(\\d+)([b|B|W|D|Q])$", each)
>
> + if match is None:
>
> + raise SystemExit("Exception: Invald value\
>
> +list format '%s' !" % each)
>
> + if match.group(1) == '0' and match.group(2) == '0':
>
> + unit_len = CGenYamlCfg.bits_width[match.group(3)
>
> + ] // 8
>
> + cur_bit_len = int(match.group(2)
>
> + ) * CGenYamlCfg.bits_width[
>
> + match.group(3)]
>
> + value += ((self.eval(match.group(1)) & (
>
> + 1 << cur_bit_len) - 1)) << bit_len
>
> + bit_len += cur_bit_len
>
> + each_value = bytearray()
>
> + if idx + 1 < len(bin_list):
>
> + in_bit_field = True
>
> + else:
>
> + try:
>
> + each_value = value_to_bytearray(
>
> + self.eval(each.strip()), unit_len)
>
> + except Exception:
>
> + raise SystemExit("Exception: Value %d cannot \
>
> +fit into %s bytes !" % (each, unit_len))
>
> +
>
> + if not in_bit_field:
>
> + if bit_len > 0:
>
> + if bit_len % 8 != 0:
>
> + raise SystemExit("Exception: Invalid bit \
>
> +field alignment '%s' !" % value_str)
>
> + result.extend(value_to_bytes(value, bit_len // 8))
>
> + value = 0
>
> + bit_len = 0
>
> +
>
> + result.extend(each_value)
>
> +
>
> + elif check_quote(value_str):
>
> + result = bytearray(value_str[1:-1], 'utf-8') # Excluding quotes
>
> + else:
>
> + result = value_to_bytearray(self.eval(value_str), length)
>
> +
>
> + if len(result) < length:
>
> + result.extend(b'\x00' * (length - len(result)))
>
> + elif len(result) > length:
>
> + raise SystemExit("Exception: Value '%s' is too big to fit \
>
> +into %d bytes !" % (value_str, length))
>
> +
>
> + if array:
>
> + return result
>
> + else:
>
> + return bytes_to_value(result)
>
> +
>
> + return result
>
> +
>
> + def get_cfg_item_options(self, item):
>
> + tmp_list = []
>
> + if item['type'] == "Combo":
>
> + if item['option'] in CGenYamlCfg.builtin_option:
>
> + for op_val, op_str in CGenYamlCfg.builtin_option[item['option'
>
> + ]]:
>
> + tmp_list.append((op_val, op_str))
>
> + else:
>
> + opt_list = item['option'].split(',')
>
> + for option in opt_list:
>
> + option = option.strip()
>
> + try:
>
> + (op_val, op_str) = option.split(':')
>
> + except Exception:
>
> + raise SystemExit("Exception: Invalide \
>
> +option format '%s' !" % option)
>
> + tmp_list.append((op_val, op_str))
>
> + return tmp_list
>
> +
>
> + def get_page_title(self, page_id, top=None):
>
> + if top is None:
>
> + top = self.get_cfg_page()['root']
>
> + for node in top['child']:
>
> + page_key = next(iter(node))
>
> + if page_id == page_key:
>
> + return node[page_key]['title']
>
> + else:
>
> + result = self.get_page_title(page_id, node[page_key])
>
> + if result is not None:
>
> + return result
>
> + return None
>
> +
>
> + def print_pages(self, top=None, level=0):
>
> + if top is None:
>
> + top = self.get_cfg_page()['root']
>
> + for node in top['child']:
>
> + page_id = next(iter(node))
>
> + print('%s%s: %s' % (' ' * level, page_id, node[page_id]['title']))
>
> + level += 1
>
> + self.print_pages(node[page_id], level)
>
> + level -= 1
>
> +
>
> + def get_item_by_index(self, index):
>
> + return self._cfg_list[index]
>
> +
>
> + def get_item_by_path(self, path):
>
> + node = self.locate_cfg_item(path)
>
> + if node:
>
> + return self.get_item_by_index(node['indx'])
>
> + else:
>
> + return None
>
> +
>
> + def locate_cfg_path(self, item):
>
> + def _locate_cfg_path(root, level=0):
>
> + # config structure
>
> + if item is root:
>
> + return path
>
> + for key in root:
>
> + if type(root[key]) is OrderedDict:
>
> + level += 1
>
> + path.append(key)
>
> + ret = _locate_cfg_path(root[key], level)
>
> + if ret:
>
> + return ret
>
> + path.pop()
>
> + return None
>
> + path = []
>
> + return _locate_cfg_path(self._cfg_tree)
>
> +
>
> + def locate_cfg_item(self, path, allow_exp=True):
>
> + def _locate_cfg_item(root, path, level=0):
>
> + if len(path) == level:
>
> + return root
>
> + next_root = root.get(path[level], None)
>
> + if next_root is None:
>
> + if allow_exp:
>
> + raise Exception('Not a valid CFG config option path: %s' %
>
> + '.'.join(path[:level+1]))
>
> + else:
>
> + return None
>
> + return _locate_cfg_item(next_root, path, level + 1)
>
> +
>
> + path_nodes = path.split('.')
>
> + return _locate_cfg_item(self._cfg_tree, path_nodes)
>
> +
>
> + def traverse_cfg_tree(self, handler, top=None):
>
> + def _traverse_cfg_tree(root, level=0):
>
> + # config structure
>
> + for key in root:
>
> + if type(root[key]) is OrderedDict:
>
> + level += 1
>
> + handler(key, root[key], level)
>
> + _traverse_cfg_tree(root[key], level)
>
> + level -= 1
>
> +
>
> + if top is None:
>
> + top = self._cfg_tree
>
> + _traverse_cfg_tree(top)
>
> +
>
> + def print_cfgs(self, root=None, short=True, print_level=256):
>
> + def _print_cfgs(name, cfgs, level):
>
> +
>
> + if 'indx' in cfgs:
>
> + act_cfg = self.get_item_by_index(cfgs['indx'])
>
> + else:
>
> + offset = 0
>
> + length = 0
>
> + value = ''
>
> + if CGenYamlCfg.STRUCT in cfgs:
>
> + cfg = cfgs[CGenYamlCfg.STRUCT]
>
> + offset = int(cfg['offset'])
>
> + length = int(cfg['length'])
>
> + if 'value' in cfg:
>
> + value = cfg['value']
>
> + if length == 0:
>
> + return
>
> + act_cfg = dict({'value': value, 'offset': offset,
>
> + 'length': length})
>
> + value = act_cfg['value']
>
> + bit_len = act_cfg['length']
>
> + offset = (act_cfg['offset'] + 7) // 8
>
> + if value != '':
>
> + try:
>
> + value = self.reformat_value_str(act_cfg['value'],
>
> + act_cfg['length'])
>
> + except Exception:
>
> + value = act_cfg['value']
>
> + length = bit_len // 8
>
> + bit_len = '(%db)' % bit_len if bit_len % 8 else '' * 4
>
> + if level <= print_level:
>
> + if short and len(value) > 40:
>
> + value = '%s ... %s' % (value[:20], value[-20:])
>
> + print('%04X:%04X%-6s %s%s : %s' % (offset, length, bit_len,
>
> + ' ' * level, name, value))
>
> +
>
> + self.traverse_cfg_tree(_print_cfgs)
>
> +
>
> + def build_var_dict(self):
>
> + def _build_var_dict(name, cfgs, level):
>
> + if level <= 2:
>
> + if CGenYamlCfg.STRUCT in cfgs:
>
> + struct_info = cfgs[CGenYamlCfg.STRUCT]
>
> + self._var_dict['_LENGTH_%s_' % name] = struct_info[
>
> + 'length'] // 8
>
> + self._var_dict['_OFFSET_%s_' % name] = struct_info[
>
> + 'offset'] // 8
>
> +
>
> + self._var_dict = {}
>
> + self.traverse_cfg_tree(_build_var_dict)
>
> + self._var_dict['_LENGTH_'] = self._cfg_tree[CGenYamlCfg.STRUCT][
>
> + 'length'] // 8
>
> + return 0
>
> +
>
> + def add_cfg_page(self, child, parent, title=''):
>
> + def _add_cfg_page(cfg_page, child, parent):
>
> + key = next(iter(cfg_page))
>
> + if parent == key:
>
> + cfg_page[key]['child'].append({child: {'title': title,
>
> + 'child': []}})
>
> + return True
>
> + else:
>
> + result = False
>
> + for each in cfg_page[key]['child']:
>
> + if _add_cfg_page(each, child, parent):
>
> + result = True
>
> + break
>
> + return result
>
> +
>
> + return _add_cfg_page(self._cfg_page, child, parent)
>
> +
>
> + def set_cur_page(self, page_str):
>
> + if not page_str:
>
> + return
>
> +
>
> + if ',' in page_str:
>
> + page_list = page_str.split(',')
>
> + else:
>
> + page_list = [page_str]
>
> + for page_str in page_list:
>
> + parts = page_str.split(':')
>
> + if len(parts) in [1, 3]:
>
> + page = parts[0].strip()
>
> + if len(parts) == 3:
>
> + # it is a new page definition, add it into tree
>
> + parent = parts[1] if parts[1] else 'root'
>
> + parent = parent.strip()
>
> + if parts[2][0] == '"' and parts[2][-1] == '"':
>
> + parts[2] = parts[2][1:-1]
>
> +
>
> + if not self.add_cfg_page(page, parent, parts[2]):
>
> + raise SystemExit("Error: Cannot find parent page \
>
> +'%s'!" % parent)
>
> + else:
>
> + raise SystemExit("Error: Invalid page format '%s' !"
>
> + % page_str)
>
> + self._cur_page = page
>
> +
>
> + def extend_variable(self, line):
>
> + # replace all variables
>
> + if line == '':
>
> + return line
>
> + loop = 2
>
> + while loop > 0:
>
> + line_after = DefTemplate(line).safe_substitute(self._def_dict)
>
> + if line == line_after:
>
> + break
>
> + loop -= 1
>
> + line = line_after
>
> + return line_after
>
> +
>
> + def reformat_number_per_type(self, itype, value):
>
> + if check_quote(value) or value.startswith('{'):
>
> + return value
>
> + parts = itype.split(',')
>
> + if len(parts) > 3 and parts[0] == 'EditNum':
>
> + num_fmt = parts[1].strip()
>
> + else:
>
> + num_fmt = ''
>
> + if num_fmt == 'HEX' and not value.startswith('0x'):
>
> + value = '0x%X' % int(value, 10)
>
> + elif num_fmt == 'DEC' and value.startswith('0x'):
>
> + value = '%d' % int(value, 16)
>
> + return value
>
> +
>
> + def add_cfg_item(self, name, item, offset, path):
>
> +
>
> + self.set_cur_page(item.get('page', ''))
>
> +
>
> + if name[0] == '$':
>
> + # skip all virtual node
>
> + return 0
>
> +
>
> + if not set(item).issubset(CGenYamlCfg.keyword_set):
>
> + for each in list(item):
>
> + if each not in CGenYamlCfg.keyword_set:
>
> + raise Exception("Invalid attribute '%s' for '%s'!" %
>
> + (each, '.'.join(path)))
>
> +
>
> + length = item.get('length', 0)
>
> + if type(length) is str:
>
> + match = re.match("^(\\d+)([b|B|W|D|Q])([B|W|D|Q]?)\\s*$", length)
>
> + if match:
>
> + unit_len = CGenYamlCfg.bits_width[match.group(2)]
>
> + length = int(match.group(1), 10) * unit_len
>
> + else:
>
> + try:
>
> + length = int(length, 0) * 8
>
> + except Exception:
>
> + raise Exception("Invalid length field '%s' for '%s' !" %
>
> + (length, '.'.join(path)))
>
> +
>
> + if offset % 8 > 0:
>
> + raise Exception("Invalid alignment for field '%s' for \
>
> +'%s' !" % (name, '.'.join(path)))
>
> + else:
>
> + # define is length in bytes
>
> + length = length * 8
>
> +
>
> + if not name.isidentifier():
>
> + raise Exception("Invalid config name '%s' for '%s' !" %
>
> + (name, '.'.join(path)))
>
> +
>
> + itype = str(item.get('type', 'Reserved'))
>
> + value = str(item.get('value', ''))
>
> + if value:
>
> + if not (check_quote(value) or value.startswith('{')):
>
> + if ',' in value:
>
> + value = '{ %s }' % value
>
> + else:
>
> + value = self.reformat_number_per_type(itype, value)
>
> +
>
> + help = str(item.get('help', ''))
>
> + if '\n' in help:
>
> + help = ' '.join([i.strip() for i in help.splitlines()])
>
> +
>
> + option = str(item.get('option', ''))
>
> + if '\n' in option:
>
> + option = ' '.join([i.strip() for i in option.splitlines()])
>
> +
>
> + # extend variables for value and condition
>
> + condition = str(item.get('condition', ''))
>
> + if condition:
>
> + condition = self.extend_variable(condition)
>
> + value = self.extend_variable(value)
>
> +
>
> + order = str(item.get('order', ''))
>
> + if order:
>
> + if '.' in order:
>
> + (major, minor) = order.split('.')
>
> + order = int(major, 16)
>
> + else:
>
> + order = int(order, 16)
>
> + else:
>
> + order = offset
>
> +
>
> + cfg_item = dict()
>
> + cfg_item['length'] = length
>
> + cfg_item['offset'] = offset
>
> + cfg_item['value'] = value
>
> + cfg_item['type'] = itype
>
> + cfg_item['cname'] = str(name)
>
> + cfg_item['name'] = str(item.get('name', ''))
>
> + cfg_item['help'] = help
>
> + cfg_item['option'] = option
>
> + cfg_item['page'] = self._cur_page
>
> + cfg_item['order'] = order
>
> + cfg_item['path'] = '.'.join(path)
>
> + cfg_item['condition'] = condition
>
> + if 'struct' in item:
>
> + cfg_item['struct'] = item['struct']
>
> + self._cfg_list.append(cfg_item)
>
> +
>
> + item['indx'] = len(self._cfg_list) - 1
>
> +
>
> + # remove used info for reducing pkl size
>
> + item.pop('option', None)
>
> + item.pop('condition', None)
>
> + item.pop('help', None)
>
> + item.pop('name', None)
>
> + item.pop('page', None)
>
> +
>
> + return length
>
> +
>
> + def build_cfg_list(self, cfg_name='', top=None, path=[],
>
> + info={'offset': 0}):
>
> + if top is None:
>
> + top = self._cfg_tree
>
> + info.clear()
>
> + info = {'offset': 0}
>
> +
>
> + start = info['offset']
>
> + is_leaf = True
>
> + for key in top:
>
> + path.append(key)
>
> + if type(top[key]) is OrderedDict:
>
> + is_leaf = False
>
> + self.build_cfg_list(key, top[key], path, info)
>
> + path.pop()
>
> +
>
> + if is_leaf:
>
> + length = self.add_cfg_item(cfg_name, top, info['offset'], path)
>
> + info['offset'] += length
>
> + elif cfg_name == '' or (cfg_name and cfg_name[0] != '$'):
>
> + # check first element for struct
>
> + first = next(iter(top))
>
> + struct_str = CGenYamlCfg.STRUCT
>
> + if first != struct_str:
>
> + struct_node = OrderedDict({})
>
> + top[struct_str] = struct_node
>
> + top.move_to_end(struct_str, False)
>
> + else:
>
> + struct_node = top[struct_str]
>
> + struct_node['offset'] = start
>
> + struct_node['length'] = info['offset'] - start
>
> + if struct_node['length'] % 8 != 0:
>
> + raise SystemExit("Error: Bits length not aligned for %s !" %
>
> + str(path))
>
> +
>
> + def get_field_value(self, top=None):
>
> + def _get_field_value(name, cfgs, level):
>
> + if 'indx' in cfgs:
>
> + act_cfg = self.get_item_by_index(cfgs['indx'])
>
> + if act_cfg['length'] == 0:
>
> + return
>
> + value = self.get_value(act_cfg['value'], act_cfg['length'],
>
> + False)
>
> + set_bits_to_bytes(result, act_cfg['offset'] -
>
> + struct_info['offset'], act_cfg['length'],
>
> + value)
>
> +
>
> + if top is None:
>
> + top = self._cfg_tree
>
> + struct_info = top[CGenYamlCfg.STRUCT]
>
> + result = bytearray((struct_info['length'] + 7) // 8)
>
> + self.traverse_cfg_tree(_get_field_value, top)
>
> + return result
>
> +
>
> + def set_field_value(self, top, value_bytes, force=False):
>
> + def _set_field_value(name, cfgs, level):
>
> + if 'indx' not in cfgs:
>
> + return
>
> + act_cfg = self.get_item_by_index(cfgs['indx'])
>
> + if force or act_cfg['value'] == '':
>
> + value = get_bits_from_bytes(full_bytes,
>
> + act_cfg['offset'] -
>
> + struct_info['offset'],
>
> + act_cfg['length'])
>
> + act_val = act_cfg['value']
>
> + if act_val == '':
>
> + act_val = '%d' % value
>
> + act_val = self.reformat_number_per_type(act_cfg
>
> + ['type'],
>
> + act_val)
>
> + act_cfg['value'] = self.format_value_to_str(
>
> + value, act_cfg['length'], act_val)
>
> +
>
> + if 'indx' in top:
>
> + # it is config option
>
> + value = bytes_to_value(value_bytes)
>
> + act_cfg = self.get_item_by_index(top['indx'])
>
> + act_cfg['value'] = self.format_value_to_str(
>
> + value, act_cfg['length'], act_cfg['value'])
>
> + else:
>
> + # it is structure
>
> + struct_info = top[CGenYamlCfg.STRUCT]
>
> + length = struct_info['length'] // 8
>
> + full_bytes = bytearray(value_bytes[:length])
>
> + if len(full_bytes) < length:
>
> + full_bytes.extend(bytearray(length - len(value_bytes)))
>
> + self.traverse_cfg_tree(_set_field_value, top)
>
> +
>
> + def update_def_value(self):
>
> + def _update_def_value(name, cfgs, level):
>
> + if 'indx' in cfgs:
>
> + act_cfg = self.get_item_by_index(cfgs['indx'])
>
> + if act_cfg['value'] != '' and act_cfg['length'] > 0:
>
> + try:
>
> + act_cfg['value'] = self.reformat_value_str(
>
> + act_cfg['value'], act_cfg['length'])
>
> + except Exception:
>
> + raise Exception("Invalid value expression '%s' \
>
> +for '%s' !" % (act_cfg['value'], act_cfg['path']))
>
> + else:
>
> + if CGenYamlCfg.STRUCT in cfgs and 'value' in \
>
> + cfgs[CGenYamlCfg.STRUCT]:
>
> + curr = cfgs[CGenYamlCfg.STRUCT]
>
> + value_bytes = self.get_value(curr['value'],
>
> + curr['length'], True)
>
> + self.set_field_value(cfgs, value_bytes)
>
> +
>
> + self.traverse_cfg_tree(_update_def_value, self._cfg_tree)
>
> +
>
> + def evaluate_condition(self, item):
>
> + expr = item['condition']
>
> + result = self.parse_value(expr, 1, False)
>
> + return result
>
> +
>
> + def detect_fsp(self):
>
> + cfg_segs = self.get_cfg_segment()
>
> + if len(cfg_segs) == 3:
>
> + fsp = True
>
> + for idx, seg in enumerate(cfg_segs):
>
> + if not seg[0].endswith('UPD_%s' % 'TMS'[idx]):
>
> + fsp = False
>
> + break
>
> + else:
>
> + fsp = False
>
> + if fsp:
>
> + self.set_mode('FSP')
>
> + return fsp
>
> +
>
> + def get_cfg_segment(self):
>
> + def _get_cfg_segment(name, cfgs, level):
>
> + if 'indx' not in cfgs:
>
> + if name.startswith('$ACTION_'):
>
> + if 'find' in cfgs:
>
> + find[0] = cfgs['find']
>
> + else:
>
> + if find[0]:
>
> + act_cfg = self.get_item_by_index(cfgs['indx'])
>
> + segments.append([find[0], act_cfg['offset'] // 8, 0])
>
> + find[0] = ''
>
> + return
>
> +
>
> + find = ['']
>
> + segments = []
>
> + self.traverse_cfg_tree(_get_cfg_segment, self._cfg_tree)
>
> + cfg_len = self._cfg_tree[CGenYamlCfg.STRUCT]['length'] // 8
>
> + if len(segments) == 0:
>
> + segments.append(['', 0, cfg_len])
>
> +
>
> + segments.append(['', cfg_len, 0])
>
> + cfg_segs = []
>
> + for idx, each in enumerate(segments[:-1]):
>
> + cfg_segs.append((each[0], each[1],
>
> + segments[idx+1][1] - each[1]))
>
> +
>
> + return cfg_segs
>
> +
>
> + def get_bin_segment(self, bin_data):
>
> + cfg_segs = self.get_cfg_segment()
>
> + bin_segs = []
>
> + for seg in cfg_segs:
>
> + key = seg[0].encode()
>
> + if key == 0:
>
> + bin_segs.append([seg[0], 0, len(bin_data)])
>
> + break
>
> + pos = bin_data.find(key)
>
> + if pos >= 0:
>
> + # ensure no other match for the key
>
> + next_pos = bin_data.find(key, pos + len(seg[0]))
>
> + if next_pos >= 0:
>
> + if key == b'$SKLFSP$' or key == b'$BSWFSP$':
>
> + string = ('Warning: Multiple matches for %s in '
>
> + 'binary!\n\nA workaround applied to such '
>
> + 'FSP 1.x binary to use second'
>
> + ' match instead of first match!' % key)
>
> + messagebox.showwarning('Warning!', string)
>
> + pos = next_pos
>
> + else:
>
> + print("Warning: Multiple matches for '%s' "
>
> + "in binary, the 1st instance will be used !"
>
> + % seg[0])
>
> + bin_segs.append([seg[0], pos, seg[2]])
>
> + else:
>
> + raise Exception("Could not find '%s' in binary !"
>
> + % seg[0])
>
> +
>
> + return bin_segs
>
> +
>
> + def extract_cfg_from_bin(self, bin_data):
>
> + # get cfg bin length
>
> + cfg_bins = bytearray()
>
> + bin_segs = self.get_bin_segment(bin_data)
>
> + for each in bin_segs:
>
> + cfg_bins.extend(bin_data[each[1]:each[1] + each[2]])
>
> + return cfg_bins
>
> +
>
> + def save_current_to_bin(self):
>
> + cfg_bins = self.generate_binary_array()
>
> + if self._old_bin is None:
>
> + return cfg_bins
>
> +
>
> + bin_data = bytearray(self._old_bin)
>
> + bin_segs = self.get_bin_segment(self._old_bin)
>
> + cfg_off = 0
>
> + for each in bin_segs:
>
> + length = each[2]
>
> + bin_data[each[1]:each[1] + length] = cfg_bins[cfg_off:
>
> + cfg_off
>
> + + length]
>
> + cfg_off += length
>
> + print('Patched the loaded binary successfully !')
>
> +
>
> + return bin_data
>
> +
>
> + def load_default_from_bin(self, bin_data):
>
> + self._old_bin = bin_data
>
> + cfg_bins = self.extract_cfg_from_bin(bin_data)
>
> + self.set_field_value(self._cfg_tree, cfg_bins, True)
>
> + return cfg_bins
>
> +
>
> + def generate_binary_array(self, path=''):
>
> + if path == '':
>
> + top = None
>
> + else:
>
> + top = self.locate_cfg_item(path)
>
> + if not top:
>
> + raise Exception("Invalid configuration path '%s' !"
>
> + % path)
>
> + return self.get_field_value(top)
>
> +
>
> + def generate_binary(self, bin_file_name, path=''):
>
> + bin_file = open(bin_file_name, "wb")
>
> + bin_file.write(self.generate_binary_array(path))
>
> + bin_file.close()
>
> + return 0
>
> +
>
> + def write_delta_file(self, out_file, platform_id, out_lines):
>
> + dlt_fd = open(out_file, "w")
>
> + dlt_fd.write("%s\n" % get_copyright_header('dlt', True))
>
> + if platform_id is not None:
>
> + dlt_fd.write('#\n')
>
> + dlt_fd.write('# Delta configuration values for '
>
> + 'platform ID 0x%04X\n'
>
> + % platform_id)
>
> + dlt_fd.write('#\n\n')
>
> + for line in out_lines:
>
> + dlt_fd.write('%s\n' % line)
>
> + dlt_fd.close()
>
> +
>
> + def override_default_value(self, dlt_file):
>
> + error = 0
>
> + dlt_lines = CGenYamlCfg.expand_include_files(dlt_file)
>
> +
>
> + platform_id = None
>
> + for line, file_path, line_num in dlt_lines:
>
> + line = line.strip()
>
> + if not line or line.startswith('#'):
>
> + continue
>
> + match = re.match("\\s*([\\w\\.]+)\\s*\\|\\s*(.+)", line)
>
> + if not match:
>
> + raise Exception("Unrecognized line '%s' "
>
> + "(File:'%s' Line:%d) !"
>
> + % (line, file_path, line_num + 1))
>
> +
>
> + path = match.group(1)
>
> + value_str = match.group(2)
>
> + top = self.locate_cfg_item(path)
>
> + if not top:
>
> + raise Exception(
>
> + "Invalid configuration '%s' (File:'%s' Line:%d) !" %
>
> + (path, file_path, line_num + 1))
>
> +
>
> + if 'indx' in top:
>
> + act_cfg = self.get_item_by_index(top['indx'])
>
> + bit_len = act_cfg['length']
>
> + else:
>
> + struct_info = top[CGenYamlCfg.STRUCT]
>
> + bit_len = struct_info['length']
>
> +
>
> + value_bytes = self.parse_value(value_str, bit_len)
>
> + self.set_field_value(top, value_bytes, True)
>
> +
>
> + if path == 'PLATFORMID_CFG_DATA.PlatformId':
>
> + platform_id = value_str
>
> +
>
> + if platform_id is None:
>
> + raise Exception(
>
> + "PLATFORMID_CFG_DATA.PlatformId is missing "
>
> + "in file '%s' !" %
>
> + (dlt_file))
>
> +
>
> + return error
>
> +
>
> + def generate_delta_file_from_bin(self, delta_file, old_data,
>
> + new_data, full=False):
>
> + new_data = self.load_default_from_bin(new_data)
>
> + lines = []
>
> + platform_id = None
>
> + def_platform_id = 0
>
> +
>
> + for item in self._cfg_list:
>
> + if not full and (item['type'] in ['Reserved']):
>
> + continue
>
> + old_val = get_bits_from_bytes(old_data, item['offset'],
>
> + item['length'])
>
> + new_val = get_bits_from_bytes(new_data, item['offset'],
>
> + item['length'])
>
> +
>
> + full_name = item['path']
>
> + if 'PLATFORMID_CFG_DATA.PlatformId' == full_name:
>
> + def_platform_id = old_val
>
> + if new_val != old_val or full:
>
> + val_str = self.reformat_value_str(item['value'],
>
> + item['length'])
>
> + text = '%-40s | %s' % (full_name, val_str)
>
> + lines.append(text)
>
> +
>
> + if self.get_mode() != 'FSP':
>
> + if platform_id is None or def_platform_id == platform_id:
>
> + platform_id = def_platform_id
>
> + print("WARNING: 'PlatformId' configuration is "
>
> + "same as default %d!" % platform_id)
>
> +
>
> + lines.insert(0, '%-40s | %s\n\n' %
>
> + ('PLATFORMID_CFG_DATA.PlatformId',
>
> + '0x%04X' % platform_id))
>
> + else:
>
> + platform_id = None
>
> +
>
> + self.write_delta_file(delta_file, platform_id, lines)
>
> +
>
> + return 0
>
> +
>
> + def generate_delta_file(self, delta_file, bin_file, bin_file2, full=False):
>
> + fd = open(bin_file, 'rb')
>
> + new_data = self.extract_cfg_from_bin(bytearray(fd.read()))
>
> + fd.close()
>
> +
>
> + if bin_file2 == '':
>
> + old_data = self.generate_binary_array()
>
> + else:
>
> + old_data = new_data
>
> + fd = open(bin_file2, 'rb')
>
> + new_data = self.extract_cfg_from_bin(bytearray(fd.read()))
>
> + fd.close()
>
> +
>
> + return self.generate_delta_file_from_bin(delta_file,
>
> + old_data, new_data, full)
>
> +
>
> + def prepare_marshal(self, is_save):
>
> + if is_save:
>
> + # Ordered dict is not marshallable, convert to list
>
> + self._cfg_tree = CGenYamlCfg.deep_convert_dict(self._cfg_tree)
>
> + else:
>
> + # Revert it back
>
> + self._cfg_tree = CGenYamlCfg.deep_convert_list(self._cfg_tree)
>
> +
>
> + def generate_yml_file(self, in_file, out_file):
>
> + cfg_yaml = CFG_YAML()
>
> + text = cfg_yaml.expand_yaml(in_file)
>
> + yml_fd = open(out_file, "w")
>
> + yml_fd.write(text)
>
> + yml_fd.close()
>
> + return 0
>
> +
>
> + def write_cfg_header_file(self, hdr_file_name, tag_mode,
>
> + tag_dict, struct_list):
>
> + lines = []
>
> + lines.append('\n\n')
>
> + if self.get_mode() == 'FSP':
>
> + lines.append('#include <FspUpd.h>\n')
>
> +
>
> + tag_mode = tag_mode & 0x7F
>
> + tag_list = sorted(list(tag_dict.items()), key=lambda x: x[1])
>
> + for tagname, tagval in tag_list:
>
> + if (tag_mode == 0 and tagval >= 0x100) or \
>
> + (tag_mode == 1 and tagval < 0x100):
>
> + continue
>
> + lines.append('#define %-30s 0x%03X\n' % (
>
> + 'CDATA_%s_TAG' % tagname[:-9], tagval))
>
> + lines.append('\n\n')
>
> +
>
> + name_dict = {}
>
> + new_dict = {}
>
> + for each in struct_list:
>
> + if (tag_mode == 0 and each['tag'] >= 0x100) or \
>
> + (tag_mode == 1 and each['tag'] < 0x100):
>
> + continue
>
> + new_dict[each['name']] = (each['alias'], each['count'])
>
> + if each['alias'] not in name_dict:
>
> + name_dict[each['alias']] = 1
>
> + lines.extend(self.create_struct(each['alias'],
>
> + each['node'], new_dict))
>
> + lines.append('#pragma pack()\n\n')
>
> +
>
> + self.write_header_file(lines, hdr_file_name)
>
> +
>
> + def write_header_file(self, txt_body, file_name, type='h'):
>
> + file_name_def = os.path.basename(file_name).replace('.', '_')
>
> + file_name_def = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', file_name_def)
>
> + file_name_def = re.sub('([a-z0-9])([A-Z])', r'\1_\2',
>
> + file_name_def).upper()
>
> +
>
> + lines = []
>
> + lines.append("%s\n" % get_copyright_header(type))
>
> + lines.append("#ifndef __%s__\n" % file_name_def)
>
> + lines.append("#define __%s__\n\n" % file_name_def)
>
> + if type == 'h':
>
> + lines.append("#pragma pack(1)\n\n")
>
> + lines.extend(txt_body)
>
> + if type == 'h':
>
> + lines.append("#pragma pack()\n\n")
>
> + lines.append("#endif\n")
>
> +
>
> + # Don't rewrite if the contents are the same
>
> + create = True
>
> + if os.path.exists(file_name):
>
> + hdr_file = open(file_name, "r")
>
> + org_txt = hdr_file.read()
>
> + hdr_file.close()
>
> +
>
> + new_txt = ''.join(lines)
>
> + if org_txt == new_txt:
>
> + create = False
>
> +
>
> + if create:
>
> + hdr_file = open(file_name, "w")
>
> + hdr_file.write(''.join(lines))
>
> + hdr_file.close()
>
> +
>
> + def generate_data_inc_file(self, dat_inc_file_name, bin_file=None):
>
> + # Put a prefix GUID before CFGDATA so that it can be located later on
>
> + prefix = b'\xa7\xbd\x7f\x73\x20\x1e\x46\xd6\
>
> +xbe\x8f\x64\x12\x05\x8d\x0a\xa8'
>
> + if bin_file:
>
> + fin = open(bin_file, 'rb')
>
> + bin_dat = prefix + bytearray(fin.read())
>
> + fin.close()
>
> + else:
>
> + bin_dat = prefix + self.generate_binary_array()
>
> +
>
> + file_name = os.path.basename(dat_inc_file_name).upper()
>
> + file_name = file_name.replace('.', '_')
>
> +
>
> + txt_lines = []
>
> +
>
> + txt_lines.append("UINT8 mConfigDataBlob[%d] = {\n" % len(bin_dat))
>
> + count = 0
>
> + line = [' ']
>
> + for each in bin_dat:
>
> + line.append('0x%02X, ' % each)
>
> + count = count + 1
>
> + if (count & 0x0F) == 0:
>
> + line.append('\n')
>
> + txt_lines.append(''.join(line))
>
> + line = [' ']
>
> + if len(line) > 1:
>
> + txt_lines.append(''.join(line) + '\n')
>
> +
>
> + txt_lines.append("};\n\n")
>
> + self.write_header_file(txt_lines, dat_inc_file_name, 'inc')
>
> +
>
> + return 0
>
> +
>
> + def get_struct_array_info(self, input):
>
> + parts = input.split(':')
>
> + if len(parts) > 1:
>
> + var = parts[1]
>
> + input = parts[0]
>
> + else:
>
> + var = ''
>
> + array_str = input.split('[')
>
> + name = array_str[0]
>
> + if len(array_str) > 1:
>
> + num_str = ''.join(c for c in array_str[-1] if c.isdigit())
>
> + num_str = '1000' if len(num_str) == 0 else num_str
>
> + array_num = int(num_str)
>
> + else:
>
> + array_num = 0
>
> + return name, array_num, var
>
> +
>
> + def process_multilines(self, string, max_char_length):
>
> + multilines = ''
>
> + string_length = len(string)
>
> + current_string_start = 0
>
> + string_offset = 0
>
> + break_line_dict = []
>
> + if len(string) <= max_char_length:
>
> + while (string_offset < string_length):
>
> + if string_offset >= 1:
>
> + if string[string_offset - 1] == '\\' and string[
>
> + string_offset] == 'n':
>
> + break_line_dict.append(string_offset + 1)
>
> + string_offset += 1
>
> + if break_line_dict != []:
>
> + for each in break_line_dict:
>
> + multilines += " %s\n" % string[
>
> + current_string_start:each].lstrip()
>
> + current_string_start = each
>
> + if string_length - current_string_start > 0:
>
> + multilines += " %s\n" % string[
>
> + current_string_start:].lstrip()
>
> + else:
>
> + multilines = " %s\n" % string
>
> + else:
>
> + new_line_start = 0
>
> + new_line_count = 0
>
> + found_space_char = False
>
> + while (string_offset < string_length):
>
> + if string_offset >= 1:
>
> + if new_line_count >= max_char_length - 1:
>
> + if string[string_offset] == ' ' and \
>
> + string_length - string_offset > 10:
>
> + break_line_dict.append(new_line_start
>
> + + new_line_count)
>
> + new_line_start = new_line_start + new_line_count
>
> + new_line_count = 0
>
> + found_space_char = True
>
> + elif string_offset == string_length - 1 and \
>
> + found_space_char is False:
>
> + break_line_dict.append(0)
>
> + if string[string_offset - 1] == '\\' and string[
>
> + string_offset] == 'n':
>
> + break_line_dict.append(string_offset + 1)
>
> + new_line_start = string_offset + 1
>
> + new_line_count = 0
>
> + string_offset += 1
>
> + new_line_count += 1
>
> + if break_line_dict != []:
>
> + break_line_dict.sort()
>
> + for each in break_line_dict:
>
> + if each > 0:
>
> + multilines += " %s\n" % string[
>
> + current_string_start:each].lstrip()
>
> + current_string_start = each
>
> + if string_length - current_string_start > 0:
>
> + multilines += " %s\n" % \
>
> + string[current_string_start:].lstrip()
>
> + return multilines
>
> +
>
> + def create_field(self, item, name, length, offset, struct,
>
> + bsf_name, help, option, bits_length=None):
>
> + pos_name = 28
>
> + name_line = ''
>
> + # help_line = ''
>
> + # option_line = ''
>
> +
>
> + if length == 0 and name == 'dummy':
>
> + return '\n'
>
> +
>
> + if bits_length == 0:
>
> + return '\n'
>
> +
>
> + is_array = False
>
> + if length in [1, 2, 4, 8]:
>
> + type = "UINT%d" % (length * 8)
>
> + else:
>
> + is_array = True
>
> + type = "UINT8"
>
> +
>
> + if item and item['value'].startswith('{'):
>
> + type = "UINT8"
>
> + is_array = True
>
> +
>
> + if struct != '':
>
> + struct_base = struct.rstrip('*')
>
> + name = '*' * (len(struct) - len(struct_base)) + name
>
> + struct = struct_base
>
> + type = struct
>
> + if struct in ['UINT8', 'UINT16', 'UINT32', 'UINT64']:
>
> + is_array = True
>
> + unit = int(type[4:]) // 8
>
> + length = length / unit
>
> + else:
>
> + is_array = False
>
> +
>
> + if is_array:
>
> + name = name + '[%d]' % length
>
> +
>
> + if len(type) < pos_name:
>
> + space1 = pos_name - len(type)
>
> + else:
>
> + space1 = 1
>
> +
>
> + if bsf_name != '':
>
> + name_line = " %s\n" % bsf_name
>
> + else:
>
> + name_line = "N/A\n"
>
> +
>
> + # if help != '':
>
> + # help_line = self.process_multilines(help, 80)
>
> +
>
> + # if option != '':
>
> + # option_line = self.process_multilines(option, 80)
>
> +
>
> + if offset is None:
>
> + offset_str = '????'
>
> + else:
>
> + offset_str = '0x%04X' % offset
>
> +
>
> + if bits_length is None:
>
> + bits_length = ''
>
> + else:
>
> + bits_length = ' : %d' % bits_length
>
> +
>
> + # return "\n/** %s%s%s**/\n %s%s%s%s;\n" % (name_line, help_line,
>
> + # option_line, type, ' ' * space1, name, bits_length)
>
> + return "\n /* Offset %s: %s */\n %s%s%s%s;\n" % (
>
> + offset_str, name_line.strip(), type, ' ' * space1,
>
> + name, bits_length)
>
> +
>
> + def create_struct(self, cname, top, struct_dict):
>
> + index = 0
>
> + last = ''
>
> + lines = []
>
> + off_base = -1
>
> +
>
> + if cname in struct_dict:
>
> + if struct_dict[cname][2]:
>
> + return []
>
> + lines.append('\ntypedef struct {\n')
>
> + for field in top:
>
> + if field[0] == '$':
>
> + continue
>
> +
>
> + index += 1
>
> +
>
> + t_item = top[field]
>
> + if 'indx' not in t_item:
>
> + if CGenYamlCfg.STRUCT not in top[field]:
>
> + continue
>
> +
>
> + if struct_dict[field][1] == 0:
>
> + continue
>
> +
>
> + append = True
>
> + struct_info = top[field][CGenYamlCfg.STRUCT]
>
> +
>
> + if 'struct' in struct_info:
>
> + struct, array_num, var = self.get_struct_array_info(
>
> + struct_info['struct'])
>
> + if array_num > 0:
>
> + if last == struct:
>
> + append = False
>
> + last = struct
>
> + if var == '':
>
> + var = field
>
> +
>
> + field = CGenYamlCfg.format_struct_field_name(
>
> + var, struct_dict[field][1])
>
> + else:
>
> + struct = struct_dict[field][0]
>
> + field = CGenYamlCfg.format_struct_field_name(
>
> + field, struct_dict[field][1])
>
> +
>
> + if append:
>
> + offset = t_item['$STRUCT']['offset'] // 8
>
> + if off_base == -1:
>
> + off_base = offset
>
> + line = self.create_field(None, field, 0, 0, struct,
>
> + '', '', '')
>
> + lines.append(' %s' % line)
>
> + last = struct
>
> + continue
>
> +
>
> + item = self.get_item_by_index(t_item['indx'])
>
> + if item['cname'] == 'CfgHeader' and index == 1 or \
>
> + (item['cname'] == 'CondValue' and index == 2):
>
> + continue
>
> +
>
> + bit_length = None
>
> + length = (item['length'] + 7) // 8
>
> + match = re.match("^(\\d+)([b|B|W|D|Q])([B|W|D|Q]?)",
>
> + t_item['length'])
>
> + if match and match.group(2) == 'b':
>
> + bit_length = int(match.group(1))
>
> + if match.group(3) != '':
>
> + length = CGenYamlCfg.bits_width[match.group(3)] // 8
>
> + else:
>
> + length = 4
>
> + offset = item['offset'] // 8
>
> + if off_base == -1:
>
> + off_base = offset
>
> + struct = item.get('struct', '')
>
> + name = field
>
> + prompt = item['name']
>
> + help = item['help']
>
> + option = item['option']
>
> + line = self.create_field(item, name, length, offset, struct,
>
> + prompt, help, option, bit_length)
>
> + lines.append(' %s' % line)
>
> + last = struct
>
> +
>
> + lines.append('\n} %s;\n\n' % cname)
>
> +
>
> + return lines
>
> +
>
> + def write_fsp_sig_header_file(self, hdr_file_name):
>
> + hdr_fd = open(hdr_file_name, 'w')
>
> + hdr_fd.write("%s\n" % get_copyright_header('h'))
>
> + hdr_fd.write("#ifndef __FSPUPD_H__\n"
>
> + "#define __FSPUPD_H__\n\n"
>
> + "#include <FspEas.h>\n\n"
>
> + "#pragma pack(1)\n\n")
>
> + lines = []
>
> + for fsp_comp in 'TMS':
>
> + top = self.locate_cfg_item('FSP%s_UPD' % fsp_comp)
>
> + if not top:
>
> + raise Exception('Could not find FSP UPD definition !')
>
> + bins = self.get_field_value(top)
>
> + lines.append("#define FSP%s_UPD_SIGNATURE"
>
> + " 0x%016X /* '%s' */\n\n"
>
> + % (fsp_comp, bytes_to_value(bins[:8]),
>
> + bins[:8].decode()))
>
> + hdr_fd.write(''.join(lines))
>
> + hdr_fd.write("#pragma pack()\n\n"
>
> + "#endif\n")
>
> + hdr_fd.close()
>
> +
>
> + def create_header_file(self, hdr_file_name, com_hdr_file_name='', path=''):
>
> +
>
> + def _build_header_struct(name, cfgs, level):
>
> + if CGenYamlCfg.STRUCT in cfgs:
>
> + if 'CfgHeader' in cfgs:
>
> + # collect CFGDATA TAG IDs
>
> + cfghdr = self.get_item_by_index(cfgs['CfgHeader']['indx'])
>
> + tag_val = array_str_to_value(cfghdr['value']) >> 20
>
> + tag_dict[name] = tag_val
>
> + if level == 1:
>
> + tag_curr[0] = tag_val
>
> + struct_dict[name] = (level, tag_curr[0], cfgs)
>
> + if path == 'FSP_SIG':
>
> + self.write_fsp_sig_header_file(hdr_file_name)
>
> + return
>
> + tag_curr = [0]
>
> + tag_dict = {}
>
> + struct_dict = {}
>
> +
>
> + if path == '':
>
> + top = None
>
> + else:
>
> + top = self.locate_cfg_item(path)
>
> + if not top:
>
> + raise Exception("Invalid configuration path '%s' !" % path)
>
> + _build_header_struct(path, top, 0)
>
> + self.traverse_cfg_tree(_build_header_struct, top)
>
> +
>
> + if tag_curr[0] == 0:
>
> + hdr_mode = 2
>
> + else:
>
> + hdr_mode = 1
>
> +
>
> + if re.match('FSP[TMS]_UPD', path):
>
> + hdr_mode |= 0x80
>
> +
>
> + # filter out the items to be built for tags and structures
>
> + struct_list = []
>
> + for each in struct_dict:
>
> + match = False
>
> + for check in CGenYamlCfg.exclude_struct:
>
> + if re.match(check, each):
>
> + match = True
>
> + if each in tag_dict:
>
> + if each not in CGenYamlCfg.include_tag:
>
> + del tag_dict[each]
>
> + break
>
> + if not match:
>
> + struct_list.append({'name': each, 'alias': '', 'count': 0,
>
> + 'level': struct_dict[each][0],
>
> + 'tag': struct_dict[each][1],
>
> + 'node': struct_dict[each][2]})
>
> +
>
> + # sort by level so that the bottom level struct
>
> + # will be build first to satisfy dependencies
>
> + struct_list = sorted(struct_list, key=lambda x: x['level'],
>
> + reverse=True)
>
> +
>
> + # Convert XXX_[0-9]+ to XXX as an array hint
>
> + for each in struct_list:
>
> + cfgs = each['node']
>
> + if 'struct' in cfgs['$STRUCT']:
>
> + each['alias'], array_num, var = self.get_struct_array_info(
>
> + cfgs['$STRUCT']['struct'])
>
> + else:
>
> + match = re.match('(\\w+)(_\\d+)', each['name'])
>
> + if match:
>
> + each['alias'] = match.group(1)
>
> + else:
>
> + each['alias'] = each['name']
>
> +
>
> + # count items for array build
>
> + for idx, each in enumerate(struct_list):
>
> + if idx > 0:
>
> + last_struct = struct_list[idx-1]['node']['$STRUCT']
>
> + curr_struct = each['node']['$STRUCT']
>
> + if struct_list[idx-1]['alias'] == each['alias'] and \
>
> + curr_struct['length'] == last_struct['length'] and \
>
> + curr_struct['offset'] == last_struct['offset'] + \
>
> + last_struct['length']:
>
> + for idx2 in range(idx-1, -1, -1):
>
> + if struct_list[idx2]['count'] > 0:
>
> + struct_list[idx2]['count'] += 1
>
> + break
>
> + continue
>
> + each['count'] = 1
>
> +
>
> + # generate common header
>
> + if com_hdr_file_name:
>
> + self.write_cfg_header_file(com_hdr_file_name, 0, tag_dict,
>
> + struct_list)
>
> +
>
> + # generate platform header
>
> + self.write_cfg_header_file(hdr_file_name, hdr_mode, tag_dict,
>
> + struct_list)
>
> +
>
> + return 0
>
> +
>
> + def load_yaml(self, cfg_file):
>
> + cfg_yaml = CFG_YAML()
>
> + self.initialize()
>
> + self._cfg_tree = cfg_yaml.load_yaml(cfg_file)
>
> + self._def_dict = cfg_yaml.def_dict
>
> + self._yaml_path = os.path.dirname(cfg_file)
>
> + self.build_cfg_list()
>
> + self.build_var_dict()
>
> + self.update_def_value()
>
> + return 0
>
> +
>
> +
>
> +def usage():
>
> + print('\n'.join([
>
> + "GenYamlCfg Version 0.50",
>
> + "Usage:",
>
> + " GenYamlCfg GENINC BinFile IncOutFile "
>
> + " [-D Macros]",
>
> +
>
> + " GenYamlCfg GENPKL YamlFile PklOutFile "
>
> + " [-D Macros]",
>
> + " GenYamlCfg GENBIN YamlFile[;DltFile] BinOutFile "
>
> + " [-D Macros]",
>
> + " GenYamlCfg GENDLT YamlFile[;BinFile] DltOutFile "
>
> + " [-D Macros]",
>
> + " GenYamlCfg GENYML YamlFile YamlOutFile"
>
> + " [-D Macros]",
>
> + " GenYamlCfg GENHDR YamlFile HdrOutFile "
>
> + " [-D Macros]"
>
> + ]))
>
> +
>
> +
>
> +def main():
>
> + # Parse the options and args
>
> + argc = len(sys.argv)
>
> + if argc < 4:
>
> + usage()
>
> + return 1
>
> +
>
> + gen_cfg_data = CGenYamlCfg()
>
> + command = sys.argv[1].upper()
>
> + out_file = sys.argv[3]
>
> + if argc >= 5 and gen_cfg_data.parse_macros(sys.argv[4:]) != 0:
>
> + raise Exception("ERROR: Macro parsing failed !")
>
> +
>
> + file_list = sys.argv[2].split(';')
>
> + if len(file_list) >= 2:
>
> + yml_file = file_list[0]
>
> + dlt_file = file_list[1]
>
> + elif len(file_list) == 1:
>
> + yml_file = file_list[0]
>
> + dlt_file = ''
>
> + else:
>
> + raise Exception("ERROR: Invalid parameter '%s' !" % sys.argv[2])
>
> + yml_scope = ''
>
> + if '@' in yml_file:
>
> + parts = yml_file.split('@')
>
> + yml_file = parts[0]
>
> + yml_scope = parts[1]
>
> +
>
> + if command == "GENDLT" and yml_file.endswith('.dlt'):
>
> + # It needs to expand an existing DLT file
>
> + dlt_file = yml_file
>
> + lines = gen_cfg_data.expand_include_files(dlt_file)
>
> + write_lines(lines, out_file)
>
> + return 0
>
> +
>
> + if command == "GENYML":
>
> + if not yml_file.lower().endswith('.yaml'):
>
> + raise Exception('Only YAML file is supported !')
>
> + gen_cfg_data.generate_yml_file(yml_file, out_file)
>
> + return 0
>
> +
>
> + bin_file = ''
>
> + if (yml_file.lower().endswith('.bin')) and (command == "GENINC"):
>
> + # It is binary file
>
> + bin_file = yml_file
>
> + yml_file = ''
>
> +
>
> + if bin_file:
>
> + gen_cfg_data.generate_data_inc_file(out_file, bin_file)
>
> + return 0
>
> +
>
> + cfg_bin_file = ''
>
> + cfg_bin_file2 = ''
>
> + if dlt_file:
>
> + if command == "GENDLT":
>
> + cfg_bin_file = dlt_file
>
> + dlt_file = ''
>
> + if len(file_list) >= 3:
>
> + cfg_bin_file2 = file_list[2]
>
> +
>
> + if yml_file.lower().endswith('.pkl'):
>
> + with open(yml_file, "rb") as pkl_file:
>
> + gen_cfg_data.__dict__ = marshal.load(pkl_file)
>
> + gen_cfg_data.prepare_marshal(False)
>
> +
>
> + # Override macro definition again for Pickle file
>
> + if argc >= 5:
>
> + gen_cfg_data.parse_macros(sys.argv[4:])
>
> + else:
>
> + gen_cfg_data.load_yaml(yml_file)
>
> + if command == 'GENPKL':
>
> + gen_cfg_data.prepare_marshal(True)
>
> + with open(out_file, "wb") as pkl_file:
>
> + marshal.dump(gen_cfg_data.__dict__, pkl_file)
>
> + json_file = os.path.splitext(out_file)[0] + '.json'
>
> + fo = open(json_file, 'w')
>
> + path_list = []
>
> + cfgs = {'_cfg_page': gen_cfg_data._cfg_page,
>
> + '_cfg_list': gen_cfg_data._cfg_list,
>
> + '_path_list': path_list}
>
> + # optimize to reduce size
>
> + path = None
>
> + for each in cfgs['_cfg_list']:
>
> + new_path = each['path'][:-len(each['cname'])-1]
>
> + if path != new_path:
>
> + path = new_path
>
> + each['path'] = path
>
> + path_list.append(path)
>
> + else:
>
> + del each['path']
>
> + if each['order'] == each['offset']:
>
> + del each['order']
>
> + del each['offset']
>
> +
>
> + # value is just used to indicate display type
>
> + value = each['value']
>
> + if value.startswith('0x'):
>
> + hex_len = ((each['length'] + 7) // 8) * 2
>
> + if len(value) == hex_len:
>
> + value = 'x%d' % hex_len
>
> + else:
>
> + value = 'x'
>
> + each['value'] = value
>
> + elif value and value[0] in ['"', "'", '{']:
>
> + each['value'] = value[0]
>
> + else:
>
> + del each['value']
>
> +
>
> + fo.write(repr(cfgs))
>
> + fo.close()
>
> + return 0
>
> +
>
> + if dlt_file:
>
> + gen_cfg_data.override_default_value(dlt_file)
>
> +
>
> + gen_cfg_data.detect_fsp()
>
> +
>
> + if command == "GENBIN":
>
> + if len(file_list) == 3:
>
> + old_data = gen_cfg_data.generate_binary_array()
>
> + fi = open(file_list[2], 'rb')
>
> + new_data = bytearray(fi.read())
>
> + fi.close()
>
> + if len(new_data) != len(old_data):
>
> + raise Exception("Binary file '%s' length does not match, \
>
> +ignored !" % file_list[2])
>
> + else:
>
> + gen_cfg_data.load_default_from_bin(new_data)
>
> + gen_cfg_data.override_default_value(dlt_file)
>
> +
>
> + gen_cfg_data.generate_binary(out_file, yml_scope)
>
> +
>
> + elif command == "GENDLT":
>
> + full = True if 'FULL' in gen_cfg_data._macro_dict else False
>
> + gen_cfg_data.generate_delta_file(out_file, cfg_bin_file,
>
> + cfg_bin_file2, full)
>
> +
>
> + elif command == "GENHDR":
>
> + out_files = out_file.split(';')
>
> + brd_out_file = out_files[0].strip()
>
> + if len(out_files) > 1:
>
> + com_out_file = out_files[1].strip()
>
> + else:
>
> + com_out_file = ''
>
> + gen_cfg_data.create_header_file(brd_out_file, com_out_file, yml_scope)
>
> +
>
> + elif command == "GENINC":
>
> + gen_cfg_data.generate_data_inc_file(out_file)
>
> +
>
> + elif command == "DEBUG":
>
> + gen_cfg_data.print_cfgs()
>
> +
>
> + else:
>
> + raise Exception("Unsuported command '%s' !" % command)
>
> +
>
> + return 0
>
> +
>
> +
>
> +if __name__ == '__main__':
>
> + sys.exit(main())
>
> diff --git a/IntelFsp2Pkg/Tools/ConfigEditor/SingleSign.py
> b/IntelFsp2Pkg/Tools/ConfigEditor/SingleSign.py
> new file mode 100644
> index 0000000000..7e008aa68a
> --- /dev/null
> +++ b/IntelFsp2Pkg/Tools/ConfigEditor/SingleSign.py
> @@ -0,0 +1,324 @@
> +#!/usr/bin/env python
>
> +# @ SingleSign.py
>
> +# Single signing script
>
> +#
>
> +# Copyright (c) 2020 - 2021, Intel Corporation. All rights reserved.<BR>
>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
>
> +#
>
> +##
>
> +
>
> +import os
>
> +import sys
>
> +import re
>
> +import shutil
>
> +import subprocess
>
> +
>
> +SIGNING_KEY = {
>
> + # Key Id | Key File Name start |
>
> + #
> =================================================================
>
> + # KEY_ID_MASTER is used for signing Slimboot Key Hash Manifest \
>
> + # container (KEYH Component)
>
> + "KEY_ID_MASTER_RSA2048": "MasterTestKey_Priv_RSA2048.pem",
>
> + "KEY_ID_MASTER_RSA3072": "MasterTestKey_Priv_RSA3072.pem",
>
> +
>
> + # KEY_ID_CFGDATA is used for signing external Config data blob)
>
> + "KEY_ID_CFGDATA_RSA2048": "ConfigTestKey_Priv_RSA2048.pem",
>
> + "KEY_ID_CFGDATA_RSA3072": "ConfigTestKey_Priv_RSA3072.pem",
>
> +
>
> + # KEY_ID_FIRMWAREUPDATE is used for signing capsule firmware update
> image)
>
> + "KEY_ID_FIRMWAREUPDATE_RSA2048":
> "FirmwareUpdateTestKey_Priv_RSA2048.pem",
>
> + "KEY_ID_FIRMWAREUPDATE_RSA3072":
> "FirmwareUpdateTestKey_Priv_RSA3072.pem",
>
> +
>
> + # KEY_ID_CONTAINER is used for signing container header with mono
> signature
>
> + "KEY_ID_CONTAINER_RSA2048": "ContainerTestKey_Priv_RSA2048.pem",
>
> + "KEY_ID_CONTAINER_RSA3072": "ContainerTestKey_Priv_RSA3072.pem",
>
> +
>
> + # CONTAINER_COMP1_KEY_ID is used for signing container components
>
> + "KEY_ID_CONTAINER_COMP_RSA2048":
> "ContainerCompTestKey_Priv_RSA2048.pem",
>
> + "KEY_ID_CONTAINER_COMP_RSA3072":
> "ContainerCompTestKey_Priv_RSA3072.pem",
>
> +
>
> + # KEY_ID_OS1_PUBLIC, KEY_ID_OS2_PUBLIC is used for referencing \
>
> + # Boot OS public keys
>
> + "KEY_ID_OS1_PUBLIC_RSA2048": "OS1_TestKey_Pub_RSA2048.pem",
>
> + "KEY_ID_OS1_PUBLIC_RSA3072": "OS1_TestKey_Pub_RSA3072.pem",
>
> +
>
> + "KEY_ID_OS2_PUBLIC_RSA2048": "OS2_TestKey_Pub_RSA2048.pem",
>
> + "KEY_ID_OS2_PUBLIC_RSA3072": "OS2_TestKey_Pub_RSA3072.pem",
>
> +
>
> + }
>
> +
>
> +MESSAGE_SBL_KEY_DIR = """!!! PRE-REQUISITE: Path to SBL_KEY_DIR has.
>
> +to be set with SBL KEYS DIRECTORY !!! \n!!! Generate keys.
>
> +using GenerateKeys.py available in BootloaderCorePkg/Tools.
>
> +directory !!! \n !!! Run $python.
>
> +BootloaderCorePkg/Tools/GenerateKeys.py -k $PATH_TO_SBL_KEY_DIR !!!\n
>
> +!!! Set SBL_KEY_DIR environ with path to SBL KEYS DIR !!!\n"
>
> +!!! Windows $set SBL_KEY_DIR=$PATH_TO_SBL_KEY_DIR !!!\n
>
> +!!! Linux $export SBL_KEY_DIR=$PATH_TO_SBL_KEY_DIR !!!\n"""
>
> +
>
> +
>
> +def get_openssl_path():
>
> + if os.name == 'nt':
>
> + if 'OPENSSL_PATH' not in os.environ:
>
> + openssl_dir = "C:\\Openssl\\bin\\"
>
> + if os.path.exists(openssl_dir):
>
> + os.environ['OPENSSL_PATH'] = openssl_dir
>
> + else:
>
> + os.environ['OPENSSL_PATH'] = "C:\\Openssl\\"
>
> + if 'OPENSSL_CONF' not in os.environ:
>
> + openssl_cfg = "C:\\Openssl\\openssl.cfg"
>
> + if os.path.exists(openssl_cfg):
>
> + os.environ['OPENSSL_CONF'] = openssl_cfg
>
> + openssl = os.path.join(
>
> + os.environ.get('OPENSSL_PATH', ''),
>
> + 'openssl.exe')
>
> + else:
>
> + # Get openssl path for Linux cases
>
> + openssl = shutil.which('openssl')
>
> +
>
> + return openssl
>
> +
>
> +
>
> +def run_process(arg_list, print_cmd=False, capture_out=False):
>
> + sys.stdout.flush()
>
> + if print_cmd:
>
> + print(' '.join(arg_list))
>
> +
>
> + exc = None
>
> + result = 0
>
> + output = ''
>
> + try:
>
> + if capture_out:
>
> + output = subprocess.check_output(arg_list).decode()
>
> + else:
>
> + result = subprocess.call(arg_list)
>
> + except Exception as ex:
>
> + result = 1
>
> + exc = ex
>
> +
>
> + if result:
>
> + if not print_cmd:
>
> + print('Error in running process:\n %s' % ' '.join(arg_list))
>
> + if exc is None:
>
> + sys.exit(1)
>
> + else:
>
> + raise exc
>
> +
>
> + return output
>
> +
>
> +
>
> +def check_file_pem_format(priv_key):
>
> + # Check for file .pem format
>
> + key_name = os.path.basename(priv_key)
>
> + if os.path.splitext(key_name)[1] == ".pem":
>
> + return True
>
> + else:
>
> + return False
>
> +
>
> +
>
> +def get_key_id(priv_key):
>
> + # Extract base name if path is provided.
>
> + key_name = os.path.basename(priv_key)
>
> + # Check for KEY_ID in key naming.
>
> + if key_name.startswith('KEY_ID'):
>
> + return key_name
>
> + else:
>
> + return None
>
> +
>
> +
>
> +def get_sbl_key_dir():
>
> + # Check Key store setting SBL_KEY_DIR path
>
> + if 'SBL_KEY_DIR' not in os.environ:
>
> + exception_string = "ERROR: SBL_KEY_DIR is not defined." \
>
> + " Set SBL_KEY_DIR with SBL Keys directory!!\n"
>
> + raise Exception(exception_string + MESSAGE_SBL_KEY_DIR)
>
> +
>
> + sbl_key_dir = os.environ.get('SBL_KEY_DIR')
>
> + if not os.path.exists(sbl_key_dir):
>
> + exception_string = "ERROR:SBL_KEY_DIR set " + sbl_key_dir \
>
> + + " is not valid." \
>
> + " Set the correct SBL_KEY_DIR path !!\n" \
>
> + + MESSAGE_SBL_KEY_DIR
>
> + raise Exception(exception_string)
>
> + else:
>
> + return sbl_key_dir
>
> +
>
> +
>
> +def get_key_from_store(in_key):
>
> +
>
> + # Check in_key is path to key
>
> + if os.path.exists(in_key):
>
> + return in_key
>
> +
>
> + # Get Slimboot key dir path
>
> + sbl_key_dir = get_sbl_key_dir()
>
> +
>
> + # Extract if in_key is key_id
>
> + priv_key = get_key_id(in_key)
>
> + if priv_key is not None:
>
> + if (priv_key in SIGNING_KEY):
>
> + # Generate key file name from key id
>
> + priv_key_file = SIGNING_KEY[priv_key]
>
> + else:
>
> + exception_string = "KEY_ID" + priv_key + "is not found " \
>
> + "is not found in supported KEY IDs!!"
>
> + raise Exception(exception_string)
>
> + elif check_file_pem_format(in_key):
>
> + # check if file name is provided in pem format
>
> + priv_key_file = in_key
>
> + else:
>
> + priv_key_file = None
>
> + raise Exception('key provided %s is not valid!' % in_key)
>
> +
>
> + # Create a file path
>
> + # Join Key Dir and priv_key_file
>
> + try:
>
> + priv_key = os.path.join(sbl_key_dir, priv_key_file)
>
> + except Exception:
>
> + raise Exception('priv_key is not found %s!' % priv_key)
>
> +
>
> + # Check for priv_key construted based on KEY ID exists in specified path
>
> + if not os.path.isfile(priv_key):
>
> + exception_string = "!!! ERROR: Key file corresponding to" \
>
> + + in_key + "do not exist in Sbl key " \
>
> + "directory at" + sbl_key_dir + "!!! \n" \
>
> + + MESSAGE_SBL_KEY_DIR
>
> + raise Exception(exception_string)
>
> +
>
> + return priv_key
>
> +
>
> +#
>
> +# Sign an file using openssl
>
> +#
>
> +# priv_key [Input] Key Id or Path to Private key
>
> +# hash_type [Input] Signing hash
>
> +# sign_scheme[Input] Sign/padding scheme
>
> +# in_file [Input] Input file to be signed
>
> +# out_file [Input/Output] Signed data file
>
> +#
>
> +
>
> +
>
> +def single_sign_file(priv_key, hash_type, sign_scheme, in_file, out_file):
>
> +
>
> + _hash_type_string = {
>
> + "SHA2_256": 'sha256',
>
> + "SHA2_384": 'sha384',
>
> + "SHA2_512": 'sha512',
>
> + }
>
> +
>
> + _hash_digest_Size = {
>
> + # Hash_string : Hash_Size
>
> + "SHA2_256": 32,
>
> + "SHA2_384": 48,
>
> + "SHA2_512": 64,
>
> + "SM3_256": 32,
>
> + }
>
> +
>
> + _sign_scheme_string = {
>
> + "RSA_PKCS1": 'pkcs1',
>
> + "RSA_PSS": 'pss',
>
> + }
>
> +
>
> + priv_key = get_key_from_store(priv_key)
>
> +
>
> + # Temporary files to store hash generated
>
> + hash_file_tmp = out_file+'.hash.tmp'
>
> + hash_file = out_file+'.hash'
>
> +
>
> + # Generate hash using openssl dgst in hex format
>
> + cmdargs = [get_openssl_path(),
>
> + 'dgst',
>
> + '-'+'%s' % _hash_type_string[hash_type],
>
> + '-out', '%s' % hash_file_tmp, '%s' % in_file]
>
> + run_process(cmdargs)
>
> +
>
> + # Extract hash form dgst command output and convert to ascii
>
> + with open(hash_file_tmp, 'r') as fin:
>
> + hashdata = fin.read()
>
> + fin.close()
>
> +
>
> + try:
>
> + hashdata = hashdata.rsplit('=', 1)[1].strip()
>
> + except Exception:
>
> + raise Exception('Hash Data not found for signing!')
>
> +
>
> + if len(hashdata) != (_hash_digest_Size[hash_type] * 2):
>
> + raise Exception('Hash Data size do match with for hash type!')
>
> +
>
> + hashdata_bytes = bytearray.fromhex(hashdata)
>
> + open(hash_file, 'wb').write(hashdata_bytes)
>
> +
>
> + print("Key used for Singing %s !!" % priv_key)
>
> +
>
> + # sign using Openssl pkeyutl
>
> + cmdargs = [get_openssl_path(),
>
> + 'pkeyutl', '-sign', '-in', '%s' % hash_file,
>
> + '-inkey', '%s' % priv_key, '-out',
>
> + '%s' % out_file, '-pkeyopt',
>
> + 'digest:%s' % _hash_type_string[hash_type],
>
> + '-pkeyopt', 'rsa_padding_mode:%s' %
>
> + _sign_scheme_string[sign_scheme]]
>
> +
>
> + run_process(cmdargs)
>
> +
>
> + return
>
> +
>
> +#
>
> +# Extract public key using openssl
>
> +#
>
> +# in_key [Input] Private key or public key in pem format
>
> +# pub_key_file [Input/Output] Public Key to a file
>
> +#
>
> +# return keydata (mod, exp) in bin format
>
> +#
>
> +
>
> +
>
> +def single_sign_gen_pub_key(in_key, pub_key_file=None):
>
> +
>
> + in_key = get_key_from_store(in_key)
>
> +
>
> + # Expect key to be in PEM format
>
> + is_prv_key = False
>
> + cmdline = [get_openssl_path(), 'rsa', '-pubout', '-text', '-noout',
>
> + '-in', '%s' % in_key]
>
> + # Check if it is public key or private key
>
> + text = open(in_key, 'r').read()
>
> + if '-BEGIN RSA PRIVATE KEY-' in text:
>
> + is_prv_key = True
>
> + elif '-BEGIN PUBLIC KEY-' in text:
>
> + cmdline.extend(['-pubin'])
>
> + else:
>
> + raise Exception('Unknown key format "%s" !' % in_key)
>
> +
>
> + if pub_key_file:
>
> + cmdline.extend(['-out', '%s' % pub_key_file])
>
> + capture = False
>
> + else:
>
> + capture = True
>
> +
>
> + output = run_process(cmdline, capture_out=capture)
>
> + if not capture:
>
> + output = text = open(pub_key_file, 'r').read()
>
> + data = output.replace('\r', '')
>
> + data = data.replace('\n', '')
>
> + data = data.replace(' ', '')
>
> +
>
> + # Extract the modulus
>
> + if is_prv_key:
>
> + match = re.search('modulus(.*)publicExponent:\\s+(\\d+)\\s+', data)
>
> + else:
>
> + match = re.search('Modulus(?:.*?):(.*)Exponent:\\s+(\\d+)\\s+', data)
>
> + if not match:
>
> + raise Exception('Public key not found!')
>
> + modulus = match.group(1).replace(':', '')
>
> + exponent = int(match.group(2))
>
> +
>
> + mod = bytearray.fromhex(modulus)
>
> + # Remove the '00' from the front if the MSB is 1
>
> + if mod[0] == 0 and (mod[1] & 0x80):
>
> + mod = mod[1:]
>
> + exp = bytearray.fromhex('{:08x}'.format(exponent))
>
> +
>
> + keydata = mod + exp
>
> +
>
> + return keydata
>
> diff --git a/IntelFsp2Pkg/Tools/FspDscBsf2Yaml.py
> b/IntelFsp2Pkg/Tools/FspDscBsf2Yaml.py
> index d2ca7145ae..923fa6eead 100644
> --- a/IntelFsp2Pkg/Tools/FspDscBsf2Yaml.py
> +++ b/IntelFsp2Pkg/Tools/FspDscBsf2Yaml.py
> @@ -10,277 +10,38 @@
> import os
>
> import re
>
> import sys
>
> -from datetime import date
>
> +
>
> from collections import OrderedDict
>
> -from functools import reduce
>
> +from datetime import date
>
>
>
> -from GenCfgOpt import CGenCfgOpt
>
> +from FspGenCfgData import CFspBsf2Dsc, CGenCfgData
>
>
>
> __copyright_tmp__ = """## @file
>
> #
>
> -# YAML CFGDATA %s File.
>
> +# Slim Bootloader CFGDATA %s File.
>
> #
>
> -# Copyright(c) %4d, Intel Corporation. All rights reserved.<BR>
>
> +# Copyright (c) %4d, Intel Corporation. All rights reserved.<BR>
>
> # SPDX-License-Identifier: BSD-2-Clause-Patent
>
> #
>
> ##
>
> """
>
>
>
> -__copyright_dsc__ = """## @file
>
> -#
>
> -# Copyright (c) %04d, Intel Corporation. All rights reserved.<BR>
>
> -# SPDX-License-Identifier: BSD-2-Clause-Patent
>
> -#
>
> -##
>
> -
>
> -[PcdsDynamicVpd.Upd]
>
> - #
>
> - # Global definitions in BSF
>
> - # !BSF BLOCK:{NAME:"FSP UPD Configuration", VER:"0.1"}
>
> - #
>
> -
>
> -"""
>
> -
>
> -
>
> -def Bytes2Val(Bytes):
>
> - return reduce(lambda x, y: (x << 8) | y, Bytes[::-1])
>
> -
>
> -
>
> -def Str2Bytes(Value, Blen):
>
> - Result = bytearray(Value[1:-1], 'utf-8') # Excluding quotes
>
> - if len(Result) < Blen:
>
> - Result.extend(b'\x00' * (Blen - len(Result)))
>
> - return Result
>
> -
>
> -
>
> -class CFspBsf2Dsc:
>
> -
>
> - def __init__(self, bsf_file):
>
> - self.cfg_list = CFspBsf2Dsc.parse_bsf(bsf_file)
>
> -
>
> - def get_dsc_lines(self):
>
> - return CFspBsf2Dsc.generate_dsc(self.cfg_list)
>
> -
>
> - def save_dsc(self, dsc_file):
>
> - return CFspBsf2Dsc.generate_dsc(self.cfg_list, dsc_file)
>
> -
>
> - @staticmethod
>
> - def parse_bsf(bsf_file):
>
> -
>
> - fd = open(bsf_file, 'r')
>
> - bsf_txt = fd.read()
>
> - fd.close()
>
> -
>
> - find_list = []
>
> - regex = re.compile(r'\s+Find\s+"(.*?)"(.*?)^\s+\$(.*?)\s+', re.S |
> re.MULTILINE)
>
> - for match in regex.finditer(bsf_txt):
>
> - find = match.group(1)
>
> - name = match.group(3)
>
> - if not name.endswith('_Revision'):
>
> - raise Exception("Unexpected CFG item following 'Find' !")
>
> - find_list.append((name, find))
>
> -
>
> - idx = 0
>
> - count = 0
>
> - prefix = ''
>
> - chk_dict = {}
>
> - cfg_list = []
>
> - cfg_temp = {'find': '', 'cname': '', 'length': 0, 'value': '0', 'type': 'Reserved',
>
> - 'embed': '', 'page': '', 'option': '', 'instance': 0}
>
> - regex =
> re.compile(r'^\s+(\$(.*?)|Skip)\s+(\d+)\s+bytes(\s+\$_DEFAULT_\s+=\s+(.+?))?$',
>
> - re.S | re.MULTILINE)
>
> -
>
> - for match in regex.finditer(bsf_txt):
>
> - dlen = int(match.group(3))
>
> - if match.group(1) == 'Skip':
>
> - key = 'gPlatformFspPkgTokenSpaceGuid_BsfSkip%d' % idx
>
> - val = ', '.join(['%02X' % ord(i) for i in '\x00' * dlen])
>
> - idx += 1
>
> - option = '$SKIP'
>
> - else:
>
> - key = match.group(2)
>
> - val = match.group(5)
>
> - option = ''
>
> -
>
> - cfg_item = dict(cfg_temp)
>
> - finds = [i for i in find_list if i[0] == key]
>
> - if len(finds) > 0:
>
> - if count >= 1:
>
> - # Append a dummy one
>
> - cfg_item['cname'] = 'Dummy'
>
> - cfg_list.append(dict(cfg_item))
>
> - cfg_list[-1]['embed'] = '%s:TAG_%03X:END' % (prefix, ord(prefix[-1]))
>
> - prefix = finds[0][1]
>
> - cfg_item['embed'] = '%s:TAG_%03X:START' % (prefix, ord(prefix[-1]))
>
> - cfg_item['find'] = prefix
>
> - cfg_item['cname'] = 'Signature'
>
> - cfg_item['length'] = len(finds[0][1])
>
> - str2byte = Str2Bytes("'" + finds[0][1] + "'", len(finds[0][1]))
>
> - cfg_item['value'] = '0x%X' % Bytes2Val(str2byte)
>
> - cfg_list.append(dict(cfg_item))
>
> - cfg_item = dict(cfg_temp)
>
> - find_list.pop(0)
>
> - count = 0
>
> -
>
> - cfg_item['cname'] = key
>
> - cfg_item['length'] = dlen
>
> - cfg_item['value'] = val
>
> - cfg_item['option'] = option
>
> -
>
> - if key not in chk_dict.keys():
>
> - chk_dict[key] = 0
>
> - else:
>
> - chk_dict[key] += 1
>
> - cfg_item['instance'] = chk_dict[key]
>
> -
>
> - cfg_list.append(cfg_item)
>
> - count += 1
>
> -
>
> - if prefix:
>
> - cfg_item = dict(cfg_temp)
>
> - cfg_item['cname'] = 'Dummy'
>
> - cfg_item['embed'] = '%s:%03X:END' % (prefix, ord(prefix[-1]))
>
> - cfg_list.append(cfg_item)
>
> -
>
> - option_dict = {}
>
> - selreg = re.compile(r'\s+Selection\s*(.+?)\s*,\s*"(.*?)"$', re.S |
> re.MULTILINE)
>
> - regex = re.compile(r'^List\s&(.+?)$(.+?)^EndList$', re.S | re.MULTILINE)
>
> - for match in regex.finditer(bsf_txt):
>
> - key = match.group(1)
>
> - option_dict[key] = []
>
> - for select in selreg.finditer(match.group(2)):
>
> - option_dict[key].append((int(select.group(1), 0), select.group(2)))
>
> -
>
> - chk_dict = {}
>
> - pagereg = re.compile(r'^Page\s"(.*?)"$(.+?)^EndPage$', re.S |
> re.MULTILINE)
>
> - for match in pagereg.finditer(bsf_txt):
>
> - page = match.group(1)
>
> - for line in match.group(2).splitlines():
>
> - match = re.match(r'\s+(Combo|EditNum)\s\$(.+?),\s"(.*?)",\s(.+?),$',
> line)
>
> - if match:
>
> - cname = match.group(2)
>
> - if cname not in chk_dict.keys():
>
> - chk_dict[cname] = 0
>
> - else:
>
> - chk_dict[cname] += 1
>
> - instance = chk_dict[cname]
>
> - cfg_idxs = [i for i, j in enumerate(cfg_list) if j['cname'] == cname and
> j['instance'] == instance]
>
> - if len(cfg_idxs) != 1:
>
> - raise Exception("Multiple CFG item '%s' found !" % cname)
>
> - cfg_item = cfg_list[cfg_idxs[0]]
>
> - cfg_item['page'] = page
>
> - cfg_item['type'] = match.group(1)
>
> - cfg_item['prompt'] = match.group(3)
>
> - cfg_item['range'] = None
>
> - if cfg_item['type'] == 'Combo':
>
> - cfg_item['option'] = option_dict[match.group(4)[1:]]
>
> - elif cfg_item['type'] == 'EditNum':
>
> - cfg_item['option'] = match.group(4)
>
> - match = re.match(r'\s+ Help\s"(.*?)"$', line)
>
> - if match:
>
> - cfg_item['help'] = match.group(1)
>
> -
>
> - match = re.match(r'\s+"Valid\srange:\s(.*)"$', line)
>
> - if match:
>
> - parts = match.group(1).split()
>
> - cfg_item['option'] = (
>
> - (int(parts[0], 0), int(parts[2], 0), cfg_item['option']))
>
> -
>
> - return cfg_list
>
> -
>
> - @staticmethod
>
> - def generate_dsc(option_list, dsc_file=None):
>
> - dsc_lines = []
>
> - header = '%s' % (__copyright_dsc__ % date.today().year)
>
> - dsc_lines.extend(header.splitlines())
>
> -
>
> - pages = []
>
> - for cfg_item in option_list:
>
> - if cfg_item['page'] and (cfg_item['page'] not in pages):
>
> - pages.append(cfg_item['page'])
>
> -
>
> - page_id = 0
>
> - for page in pages:
>
> - dsc_lines.append(' # !BSF PAGES:{PG%02X::"%s"}' % (page_id, page))
>
> - page_id += 1
>
> - dsc_lines.append('')
>
> -
>
> - last_page = ''
>
> - for option in option_list:
>
> - dsc_lines.append('')
>
> - default = option['value']
>
> - pos = option['cname'].find('_')
>
> - name = option['cname'][pos + 1:]
>
> -
>
> - if option['find']:
>
> - dsc_lines.append(' # !BSF FIND:{%s}' % option['find'])
>
> - dsc_lines.append('')
>
> -
>
> - if option['instance'] > 0:
>
> - name = name + '_%s' % option['instance']
>
> -
>
> - if option['embed']:
>
> - dsc_lines.append(' # !HDR EMBED:{%s}' % option['embed'])
>
> -
>
> - if option['type'] == 'Reserved':
>
> - dsc_lines.append(' # !BSF NAME:{Reserved} TYPE:{Reserved}')
>
> - if option['option'] == '$SKIP':
>
> - dsc_lines.append(' # !BSF OPTION:{$SKIP}')
>
> - else:
>
> - prompt = option['prompt']
>
> -
>
> - if last_page != option['page']:
>
> - last_page = option['page']
>
> - dsc_lines.append(' # !BSF PAGE:{PG%02X}' %
> (pages.index(option['page'])))
>
> -
>
> - if option['type'] == 'Combo':
>
> - dsc_lines.append(' # !BSF NAME:{%s} TYPE:{%s}' %
>
> - (prompt, option['type']))
>
> - ops = []
>
> - for val, text in option['option']:
>
> - ops.append('0x%x:%s' % (val, text))
>
> - dsc_lines.append(' # !BSF OPTION:{%s}' % (', '.join(ops)))
>
> - elif option['type'] == 'EditNum':
>
> - cfg_len = option['length']
>
> - if ',' in default and cfg_len > 8:
>
> - dsc_lines.append(' # !BSF NAME:{%s} TYPE:{Table}' % (prompt))
>
> - if cfg_len > 16:
>
> - cfg_len = 16
>
> - ops = []
>
> - for i in range(cfg_len):
>
> - ops.append('%X:1:HEX' % i)
>
> - dsc_lines.append(' # !BSF OPTION:{%s}' % (', '.join(ops)))
>
> - else:
>
> - dsc_lines.append(
>
> - ' # !BSF NAME:{%s} TYPE:{%s, %s,(0x%X, 0x%X)}' %
>
> - (prompt, option['type'], option['option'][2],
>
> - option['option'][0], option['option'][1]))
>
> - dsc_lines.append(' # !BSF HELP:{%s}' % option['help'])
>
> -
>
> - if ',' in default:
>
> - default = '{%s}' % default
>
> - dsc_lines.append(' gCfgData.%-30s | * | 0x%04X | %s' %
>
> - (name, option['length'], default))
>
> -
>
> - if dsc_file:
>
> - fd = open(dsc_file, 'w')
>
> - fd.write('\n'.join(dsc_lines))
>
> - fd.close()
>
> -
>
> - return dsc_lines
>
> -
>
>
>
> class CFspDsc2Yaml():
>
>
>
> def __init__(self):
>
> self._Hdr_key_list = ['EMBED', 'STRUCT']
>
> - self._Bsf_key_list = ['NAME', 'HELP', 'TYPE', 'PAGE', 'PAGES', 'OPTION',
>
> - 'CONDITION', 'ORDER', 'MARKER', 'SUBT', 'FIELD', 'FIND']
>
> + self._Bsf_key_list = ['NAME', 'HELP', 'TYPE', 'PAGE', 'PAGES',
>
> + 'OPTION', 'CONDITION', 'ORDER', 'MARKER',
>
> + 'SUBT', 'FIELD', 'FIND']
>
> self.gen_cfg_data = None
>
> - self.cfg_reg_exp = re.compile(r"^([_a-zA-Z0-9$\(\)]+)\s*\|\s*(0x[0-9A-
> F]+|\*)\s*\|"
>
> - + r"\s*(\d+|0x[0-9a-fA-F]+)\s*\|\s*(.+)")
>
> - self.bsf_reg_exp = re.compile(r"(%s):{(.+?)}(?:$|\s+)" %
> '|'.join(self._Bsf_key_list))
>
> - self.hdr_reg_exp = re.compile(r"(%s):{(.+?)}" % '|'.join(self._Hdr_key_list))
>
> + self.cfg_reg_exp = re.compile(
>
> + "^([_a-zA-Z0-9$\\(\\)]+)\\s*\\|\\s*(0x[0-9A-F]+|\\*)"
>
> + "\\s*\\|\\s*(\\d+|0x[0-9a-fA-F]+)\\s*\\|\\s*(.+)")
>
> + self.bsf_reg_exp = re.compile("(%s):{(.+?)}(?:$|\\s+)"
>
> + % '|'.join(self._Bsf_key_list))
>
> + self.hdr_reg_exp = re.compile("(%s):{(.+?)}"
>
> + % '|'.join(self._Hdr_key_list))
>
> self.prefix = ''
>
> self.unused_idx = 0
>
> self.offset = 0
>
> @@ -290,15 +51,15 @@ class CFspDsc2Yaml():
> """
>
> Load and parse a DSC CFGDATA file.
>
> """
>
> - gen_cfg_data = CGenCfgOpt('FSP')
>
> + gen_cfg_data = CGenCfgData('FSP')
>
> if file_name.endswith('.dsc'):
>
> - # if gen_cfg_data.ParseDscFileYaml(file_name, '') != 0:
>
> - if gen_cfg_data.ParseDscFile(file_name, '') != 0:
>
> + if gen_cfg_data.ParseDscFile(file_name) != 0:
>
> raise Exception('DSC file parsing error !')
>
> if gen_cfg_data.CreateVarDict() != 0:
>
> raise Exception('DSC variable creation error !')
>
> else:
>
> raise Exception('Unsupported file "%s" !' % file_name)
>
> + gen_cfg_data.UpdateDefaultValue()
>
> self.gen_cfg_data = gen_cfg_data
>
>
>
> def print_dsc_line(self):
>
> @@ -312,14 +73,15 @@ class CFspDsc2Yaml():
> """
>
> Format a CFGDATA item into YAML format.
>
> """
>
> - if(not text.startswith('!expand')) and (': ' in text):
>
> + if (not text.startswith('!expand')) and (': ' in text):
>
> tgt = ':' if field == 'option' else '- '
>
> text = text.replace(': ', tgt)
>
> lines = text.splitlines()
>
> if len(lines) == 1 and field != 'help':
>
> return text
>
> else:
>
> - return '>\n ' + '\n '.join([indent + i.lstrip() for i in lines])
>
> + return '>\n ' + '\n '.join(
>
> + [indent + i.lstrip() for i in lines])
>
>
>
> def reformat_pages(self, val):
>
> # Convert XXX:YYY into XXX::YYY format for page definition
>
> @@ -355,14 +117,16 @@ class CFspDsc2Yaml():
> cfg['page'] = self.reformat_pages(cfg['page'])
>
>
>
> if 'struct' in cfg:
>
> - cfg['value'] = self.reformat_struct_value(cfg['struct'], cfg['value'])
>
> + cfg['value'] = self.reformat_struct_value(
>
> + cfg['struct'], cfg['value'])
>
>
>
> def parse_dsc_line(self, dsc_line, config_dict, init_dict, include):
>
> """
>
> Parse a line in DSC and update the config dictionary accordingly.
>
> """
>
> init_dict.clear()
>
> - match = re.match(r'g(CfgData|\w+FspPkgTokenSpaceGuid)\.(.+)', dsc_line)
>
> + match = re.match('g(CfgData|\\w+FspPkgTokenSpaceGuid)\\.(.+)',
>
> + dsc_line)
>
> if match:
>
> match = self.cfg_reg_exp.match(match.group(2))
>
> if not match:
>
> @@ -385,7 +149,7 @@ class CFspDsc2Yaml():
> self.offset = offset + int(length, 0)
>
> return True
>
>
>
> - match = re.match(r"^\s*#\s+!([<>])\s+include\s+(.+)", dsc_line)
>
> + match = re.match("^\\s*#\\s+!([<>])\\s+include\\s+(.+)", dsc_line)
>
> if match and len(config_dict) == 0:
>
> # !include should not be inside a config field
>
> # if so, do not convert include into YAML
>
> @@ -398,7 +162,7 @@ class CFspDsc2Yaml():
> config_dict['include'] = ''
>
> return True
>
>
>
> - match = re.match(r"^\s*#\s+(!BSF|!HDR)\s+(.+)", dsc_line)
>
> + match = re.match("^\\s*#\\s+(!BSF|!HDR)\\s+(.+)", dsc_line)
>
> if not match:
>
> return False
>
>
>
> @@ -434,16 +198,19 @@ class CFspDsc2Yaml():
> tmp_name = parts[0][:-5]
>
> if tmp_name == 'CFGHDR':
>
> cfg_tag = '_$FFF_'
>
> - sval = '!expand { %s_TMPL : [ ' % tmp_name + '%s, %s, ' % (parts[1],
> cfg_tag) \
>
> - + ', '.join(parts[2:]) + ' ] }'
>
> + sval = '!expand { %s_TMPL : [ ' % \
>
> + tmp_name + '%s, %s, ' % (parts[1], cfg_tag) + \
>
> + ', '.join(parts[2:]) + ' ] }'
>
> else:
>
> - sval = '!expand { %s_TMPL : [ ' % tmp_name + ', '.join(parts[1:]) +
> ' ] }'
>
> + sval = '!expand { %s_TMPL : [ ' % \
>
> + tmp_name + ', '.join(parts[1:]) + ' ] }'
>
> config_dict.clear()
>
> config_dict['cname'] = tmp_name
>
> config_dict['expand'] = sval
>
> return True
>
> else:
>
> - if key in ['name', 'help', 'option'] and val.startswith('+'):
>
> + if key in ['name', 'help', 'option'] and \
>
> + val.startswith('+'):
>
> val = config_dict[key] + '\n' + val[1:]
>
> if val.strip() == '':
>
> val = "''"
>
> @@ -493,21 +260,23 @@ class CFspDsc2Yaml():
> include_file = ['.']
>
>
>
> for line in lines:
>
> - match = re.match(r"^\s*#\s+!([<>])\s+include\s+(.+)", line)
>
> + match = re.match("^\\s*#\\s+!([<>])\\s+include\\s+(.+)", line)
>
> if match:
>
> if match.group(1) == '<':
>
> include_file.append(match.group(2))
>
> else:
>
> include_file.pop()
>
>
>
> - match = re.match(r"^\s*#\s+(!BSF)\s+DEFT:{(.+?):(START|END)}", line)
>
> + match = re.match(
>
> + "^\\s*#\\s+(!BSF)\\s+DEFT:{(.+?):(START|END)}", line)
>
> if match:
>
> if match.group(3) == 'START' and not template_name:
>
> template_name = match.group(2).strip()
>
> temp_file_dict[template_name] = list(include_file)
>
> bsf_temp_dict[template_name] = []
>
> - if match.group(3) == 'END' and (template_name ==
> match.group(2).strip()) \
>
> - and template_name:
>
> + if match.group(3) == 'END' and \
>
> + (template_name == match.group(2).strip()) and \
>
> + template_name:
>
> template_name = ''
>
> else:
>
> if template_name:
>
> @@ -531,12 +300,14 @@ class CFspDsc2Yaml():
> init_dict.clear()
>
> padding_dict = {}
>
> cfgs.append(padding_dict)
>
> - padding_dict['cname'] = 'UnusedUpdSpace%d' % self.unused_idx
>
> + padding_dict['cname'] = 'UnusedUpdSpace%d' % \
>
> + self.unused_idx
>
> padding_dict['length'] = '0x%x' % num
>
> padding_dict['value'] = '{ 0 }'
>
> self.unused_idx += 1
>
>
>
> - if cfgs and cfgs[-1]['cname'][0] != '@' and config_dict['cname'][0] ==
> '@':
>
> + if cfgs and cfgs[-1]['cname'][0] != '@' and \
>
> + config_dict['cname'][0] == '@':
>
> # it is a bit field, mark the previous one as virtual
>
> cname = cfgs[-1]['cname']
>
> new_cfg = dict(cfgs[-1])
>
> @@ -545,7 +316,8 @@ class CFspDsc2Yaml():
> cfgs[-1]['cname'] = cname
>
> cfgs.append(new_cfg)
>
>
>
> - if cfgs and cfgs[-1]['cname'] == 'CFGHDR' and config_dict['cname'][0]
> == '<':
>
> + if cfgs and cfgs[-1]['cname'] == 'CFGHDR' and \
>
> + config_dict['cname'][0] == '<':
>
> # swap CfgHeader and the CFG_DATA order
>
> if ':' in config_dict['cname']:
>
> # replace the real TAG for CFG_DATA
>
> @@ -661,7 +433,7 @@ class CFspDsc2Yaml():
> lines = []
>
> for each in self.gen_cfg_data._MacroDict:
>
> key, value = self.variable_fixup(each)
>
> - lines.append('%-30s : %s' % (key, value))
>
> + lines.append('%-30s : %s' % (key, value))
>
> return lines
>
>
>
> def output_template(self):
>
> @@ -671,7 +443,8 @@ class CFspDsc2Yaml():
> self.offset = 0
>
> self.base_offset = 0
>
> start, end = self.get_section_range('PcdsDynamicVpd.Tmp')
>
> - bsf_temp_dict, temp_file_dict =
> self.process_template_lines(self.gen_cfg_data._DscLines[start:end])
>
> + bsf_temp_dict, temp_file_dict = self.process_template_lines(
>
> + self.gen_cfg_data._DscLines[start:end])
>
> template_dict = dict()
>
> lines = []
>
> file_lines = {}
>
> @@ -679,15 +452,18 @@ class CFspDsc2Yaml():
> file_lines[last_file] = []
>
>
>
> for tmp_name in temp_file_dict:
>
> - temp_file_dict[tmp_name][-1] =
> self.normalize_file_name(temp_file_dict[tmp_name][-1], True)
>
> + temp_file_dict[tmp_name][-1] = self.normalize_file_name(
>
> + temp_file_dict[tmp_name][-1], True)
>
> if len(temp_file_dict[tmp_name]) > 1:
>
> - temp_file_dict[tmp_name][-2] =
> self.normalize_file_name(temp_file_dict[tmp_name][-2], True)
>
> + temp_file_dict[tmp_name][-2] = self.normalize_file_name(
>
> + temp_file_dict[tmp_name][-2], True)
>
>
>
> for tmp_name in bsf_temp_dict:
>
> file = temp_file_dict[tmp_name][-1]
>
> if last_file != file and len(temp_file_dict[tmp_name]) > 1:
>
> inc_file = temp_file_dict[tmp_name][-2]
>
> - file_lines[inc_file].extend(['', '- !include %s' %
> temp_file_dict[tmp_name][-1], ''])
>
> + file_lines[inc_file].extend(
>
> + ['', '- !include %s' % temp_file_dict[tmp_name][-1], ''])
>
> last_file = file
>
> if file not in file_lines:
>
> file_lines[file] = []
>
> @@ -708,7 +484,8 @@ class CFspDsc2Yaml():
> self.offset = 0
>
> self.base_offset = 0
>
> start, end = self.get_section_range('PcdsDynamicVpd.Upd')
>
> - cfgs = self.process_option_lines(self.gen_cfg_data._DscLines[start:end])
>
> + cfgs = self.process_option_lines(
>
> + self.gen_cfg_data._DscLines[start:end])
>
> self.config_fixup(cfgs)
>
> file_lines = self.output_dict(cfgs, True)
>
> return file_lines
>
> @@ -721,13 +498,17 @@ class CFspDsc2Yaml():
> level = 0
>
> file = '.'
>
> for each in cfgs:
>
> - if 'length' in each and int(each['length'], 0) == 0:
>
> - continue
>
> + if 'length' in each:
>
> + if not each['length'].endswith('b') and int(each['length'],
>
> + 0) == 0:
>
> + continue
>
>
>
> if 'include' in each:
>
> if each['include']:
>
> - each['include'] = self.normalize_file_name(each['include'])
>
> - file_lines[file].extend(['', '- !include %s' % each['include'], ''])
>
> + each['include'] = self.normalize_file_name(
>
> + each['include'])
>
> + file_lines[file].extend(
>
> + ['', '- !include %s' % each['include'], ''])
>
> file = each['include']
>
> else:
>
> file = '.'
>
> @@ -766,7 +547,8 @@ class CFspDsc2Yaml():
> for field in each:
>
> if field in ['cname', 'expand', 'include']:
>
> continue
>
> - value_str = self.format_value(field, each[field], padding + ' ' * 16)
>
> + value_str = self.format_value(
>
> + field, each[field], padding + ' ' * 16)
>
> full_line = ' %s %-12s : %s' % (padding, field, value_str)
>
> lines.extend(full_line.splitlines())
>
>
>
> @@ -802,11 +584,13 @@ def dsc_to_yaml(dsc_file, yaml_file):
> if file == '.':
>
> cfgs[cfg] = lines
>
> else:
>
> - if('/' in file or '\\' in file):
>
> + if ('/' in file or '\\' in file):
>
> continue
>
> file = os.path.basename(file)
>
> - fo = open(os.path.join(file), 'w')
>
> - fo.write(__copyright_tmp__ % (cfg, date.today().year) + '\n\n')
>
> + out_dir = os.path.dirname(file)
>
> + fo = open(os.path.join(out_dir, file), 'w')
>
> + fo.write(__copyright_tmp__ % (
>
> + cfg, date.today().year) + '\n\n')
>
> for line in lines:
>
> fo.write(line + '\n')
>
> fo.close()
>
> @@ -821,13 +605,11 @@ def dsc_to_yaml(dsc_file, yaml_file):
>
>
> fo.write('\n\ntemplate:\n')
>
> for line in cfgs['Template']:
>
> - if line != '':
>
> - fo.write(' ' + line + '\n')
>
> + fo.write(' ' + line + '\n')
>
>
>
> fo.write('\n\nconfigs:\n')
>
> for line in cfgs['Option']:
>
> - if line != '':
>
> - fo.write(' ' + line + '\n')
>
> + fo.write(' ' + line + '\n')
>
>
>
> fo.close()
>
>
>
> @@ -864,7 +646,8 @@ def main():
> bsf_file = sys.argv[1]
>
> yaml_file = sys.argv[2]
>
> if os.path.isdir(yaml_file):
>
> - yaml_file = os.path.join(yaml_file, get_fsp_name_from_path(bsf_file) +
> '.yaml')
>
> + yaml_file = os.path.join(
>
> + yaml_file, get_fsp_name_from_path(bsf_file) + '.yaml')
>
>
>
> if bsf_file.endswith('.dsc'):
>
> dsc_file = bsf_file
>
> diff --git a/IntelFsp2Pkg/Tools/FspGenCfgData.py
> b/IntelFsp2Pkg/Tools/FspGenCfgData.py
> new file mode 100644
> index 0000000000..8d4e49c8d2
> --- /dev/null
> +++ b/IntelFsp2Pkg/Tools/FspGenCfgData.py
> @@ -0,0 +1,2637 @@
> +# @ GenCfgData.py
>
> +#
>
> +# Copyright (c) 2014 - 2021, Intel Corporation. All rights reserved.<BR>
>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
>
> +#
>
> +##
>
> +
>
> +import os
>
> +import re
>
> +import sys
>
> +import marshal
>
> +from functools import reduce
>
> +from datetime import date
>
> +
>
> +# Generated file copyright header
>
> +
>
> +__copyright_tmp__ = """/** @file
>
> +
>
> + Configuration %s File.
>
> +
>
> + Copyright (c) %4d, Intel Corporation. All rights reserved.<BR>
>
> + SPDX-License-Identifier: BSD-2-Clause-Patent
>
> +
>
> + This file is automatically generated. Please do NOT modify !!!
>
> +
>
> +**/
>
> +"""
>
> +
>
> +__copyright_dsc__ = """## @file
>
> +#
>
> +# Copyright (c) %04d, Intel Corporation. All rights reserved.<BR>
>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
>
> +#
>
> +##
>
> +
>
> +[PcdsDynamicVpd.Upd]
>
> + #
>
> + # Global definitions in BSF
>
> + # !BSF BLOCK:{NAME:"FSP UPD Configuration", VER:"0.1"}
>
> + #
>
> +
>
> +"""
>
> +
>
> +
>
> +def Bytes2Val(Bytes):
>
> + return reduce(lambda x, y: (x << 8) | y, Bytes[::-1])
>
> +
>
> +
>
> +def Bytes2Str(Bytes):
>
> + return '{ %s }' % (', '.join('0x%02X' % i for i in Bytes))
>
> +
>
> +
>
> +def Str2Bytes(Value, Blen):
>
> + Result = bytearray(Value[1:-1], 'utf-8') # Excluding quotes
>
> + if len(Result) < Blen:
>
> + Result.extend(b'\x00' * (Blen - len(Result)))
>
> + return Result
>
> +
>
> +
>
> +def Val2Bytes(Value, Blen):
>
> + return [(Value >> (i * 8) & 0xff) for i in range(Blen)]
>
> +
>
> +
>
> +def Array2Val(ValStr):
>
> + ValStr = ValStr.strip()
>
> + if ValStr.startswith('{'):
>
> + ValStr = ValStr[1:]
>
> + if ValStr.endswith('}'):
>
> + ValStr = ValStr[:-1]
>
> + if ValStr.startswith("'"):
>
> + ValStr = ValStr[1:]
>
> + if ValStr.endswith("'"):
>
> + ValStr = ValStr[:-1]
>
> + Value = 0
>
> + for Each in ValStr.split(',')[::-1]:
>
> + Each = Each.strip()
>
> + if Each.startswith('0x'):
>
> + Base = 16
>
> + else:
>
> + Base = 10
>
> + Value = (Value << 8) | int(Each, Base)
>
> + return Value
>
> +
>
> +
>
> +def GetCopyrightHeader(FileType, AllowModify=False):
>
> + FileDescription = {
>
> + 'bsf': 'Boot Setting',
>
> + 'dsc': 'Definition',
>
> + 'dlt': 'Delta',
>
> + 'inc': 'C Binary Blob',
>
> + 'h': 'C Struct Header'
>
> + }
>
> + if FileType in ['bsf', 'dsc', 'dlt']:
>
> + CommentChar = '#'
>
> + else:
>
> + CommentChar = ''
>
> + Lines = __copyright_tmp__.split('\n')
>
> +
>
> + if AllowModify:
>
> + Lines = [Line for Line in Lines if 'Please do NOT modify' not in Line]
>
> +
>
> + CopyrightHdr = '\n'.join('%s%s' % (
>
> + CommentChar, Line) for Line in Lines)[:-1] + '\n'
>
> +
>
> + return CopyrightHdr % (FileDescription[FileType], date.today().year)
>
> +
>
> +
>
> +class CLogicalExpression:
>
> + def __init__(self):
>
> + self.index = 0
>
> + self.string = ''
>
> +
>
> + def errExit(self, err=''):
>
> + print("ERROR: Express parsing for:")
>
> + print(" %s" % self.string)
>
> + print(" %s^" % (' ' * self.index))
>
> + if err:
>
> + print("INFO : %s" % err)
>
> + raise SystemExit
>
> +
>
> + def getNonNumber(self, n1, n2):
>
> + if not n1.isdigit():
>
> + return n1
>
> + if not n2.isdigit():
>
> + return n2
>
> + return None
>
> +
>
> + def getCurr(self, lens=1):
>
> + try:
>
> + if lens == -1:
>
> + return self.string[self.index:]
>
> + else:
>
> + if self.index + lens > len(self.string):
>
> + lens = len(self.string) - self.index
>
> + return self.string[self.index: self.index + lens]
>
> + except Exception:
>
> + return ''
>
> +
>
> + def isLast(self):
>
> + return self.index == len(self.string)
>
> +
>
> + def moveNext(self, len=1):
>
> + self.index += len
>
> +
>
> + def skipSpace(self):
>
> + while not self.isLast():
>
> + if self.getCurr() in ' \t':
>
> + self.moveNext()
>
> + else:
>
> + return
>
> +
>
> + def normNumber(self, val):
>
> + return True if val else False
>
> +
>
> + def getNumber(self, var):
>
> + var = var.strip()
>
> + if re.match('^0x[a-fA-F0-9]+$', var):
>
> + value = int(var, 16)
>
> + elif re.match('^[+-]?\\d+$', var):
>
> + value = int(var, 10)
>
> + else:
>
> + value = None
>
> + return value
>
> +
>
> + def parseValue(self):
>
> + self.skipSpace()
>
> + var = ''
>
> + while not self.isLast():
>
> + char = self.getCurr()
>
> + if re.match('^[\\w.]', char):
>
> + var += char
>
> + self.moveNext()
>
> + else:
>
> + break
>
> + val = self.getNumber(var)
>
> + if val is None:
>
> + value = var
>
> + else:
>
> + value = "%d" % val
>
> + return value
>
> +
>
> + def parseSingleOp(self):
>
> + self.skipSpace()
>
> + if re.match('^NOT\\W', self.getCurr(-1)):
>
> + self.moveNext(3)
>
> + op = self.parseBrace()
>
> + val = self.getNumber(op)
>
> + if val is None:
>
> + self.errExit("'%s' is not a number" % op)
>
> + return "%d" % (not self.normNumber(int(op)))
>
> + else:
>
> + return self.parseValue()
>
> +
>
> + def parseBrace(self):
>
> + self.skipSpace()
>
> + char = self.getCurr()
>
> + if char == '(':
>
> + self.moveNext()
>
> + value = self.parseExpr()
>
> + self.skipSpace()
>
> + if self.getCurr() != ')':
>
> + self.errExit("Expecting closing brace or operator")
>
> + self.moveNext()
>
> + return value
>
> + else:
>
> + value = self.parseSingleOp()
>
> + return value
>
> +
>
> + def parseCompare(self):
>
> + value = self.parseBrace()
>
> + while True:
>
> + self.skipSpace()
>
> + char = self.getCurr()
>
> + if char in ['<', '>']:
>
> + self.moveNext()
>
> + next = self.getCurr()
>
> + if next == '=':
>
> + op = char + next
>
> + self.moveNext()
>
> + else:
>
> + op = char
>
> + result = self.parseBrace()
>
> + test = self.getNonNumber(result, value)
>
> + if test is None:
>
> + value = "%d" % self.normNumber(eval(value + op + result))
>
> + else:
>
> + self.errExit("'%s' is not a valid number for comparision"
>
> + % test)
>
> + elif char in ['=', '!']:
>
> + op = self.getCurr(2)
>
> + if op in ['==', '!=']:
>
> + self.moveNext(2)
>
> + result = self.parseBrace()
>
> + test = self.getNonNumber(result, value)
>
> + if test is None:
>
> + value = "%d" % self.normNumber((eval(value + op
>
> + + result)))
>
> + else:
>
> + value = "%d" % self.normNumber(eval("'" + value +
>
> + "'" + op + "'" +
>
> + result + "'"))
>
> + else:
>
> + break
>
> + else:
>
> + break
>
> + return value
>
> +
>
> + def parseAnd(self):
>
> + value = self.parseCompare()
>
> + while True:
>
> + self.skipSpace()
>
> + if re.match('^AND\\W', self.getCurr(-1)):
>
> + self.moveNext(3)
>
> + result = self.parseCompare()
>
> + test = self.getNonNumber(result, value)
>
> + if test is None:
>
> + value = "%d" % self.normNumber(int(value) & int(result))
>
> + else:
>
> + self.errExit("'%s' is not a valid op number for AND" %
>
> + test)
>
> + else:
>
> + break
>
> + return value
>
> +
>
> + def parseOrXor(self):
>
> + value = self.parseAnd()
>
> + op = None
>
> + while True:
>
> + self.skipSpace()
>
> + op = None
>
> + if re.match('^XOR\\W', self.getCurr(-1)):
>
> + self.moveNext(3)
>
> + op = '^'
>
> + elif re.match('^OR\\W', self.getCurr(-1)):
>
> + self.moveNext(2)
>
> + op = '|'
>
> + else:
>
> + break
>
> + if op:
>
> + result = self.parseAnd()
>
> + test = self.getNonNumber(result, value)
>
> + if test is None:
>
> + value = "%d" % self.normNumber(eval(value + op + result))
>
> + else:
>
> + self.errExit("'%s' is not a valid op number for XOR/OR" %
>
> + test)
>
> + return value
>
> +
>
> + def parseExpr(self):
>
> + return self.parseOrXor()
>
> +
>
> + def getResult(self):
>
> + value = self.parseExpr()
>
> + self.skipSpace()
>
> + if not self.isLast():
>
> + self.errExit("Unexpected character found '%s'" % self.getCurr())
>
> + test = self.getNumber(value)
>
> + if test is None:
>
> + self.errExit("Result '%s' is not a number" % value)
>
> + return int(value)
>
> +
>
> + def evaluateExpress(self, Expr):
>
> + self.index = 0
>
> + self.string = Expr
>
> + if self.getResult():
>
> + Result = True
>
> + else:
>
> + Result = False
>
> + return Result
>
> +
>
> +
>
> +class CFspBsf2Dsc:
>
> +
>
> + def __init__(self, bsf_file):
>
> + self.cfg_list = CFspBsf2Dsc.parse_bsf(bsf_file)
>
> +
>
> + def get_dsc_lines(self):
>
> + return CFspBsf2Dsc.generate_dsc(self.cfg_list)
>
> +
>
> + def save_dsc(self, dsc_file):
>
> + return CFspBsf2Dsc.generate_dsc(self.cfg_list, dsc_file)
>
> +
>
> + @staticmethod
>
> + def parse_bsf(bsf_file):
>
> +
>
> + fd = open(bsf_file, 'r')
>
> + bsf_txt = fd.read()
>
> + fd.close()
>
> +
>
> + find_list = []
>
> + regex = re.compile(r'\s+Find\s+"(.*?)"(.*?)^\s+(\$(.*?)|Skip)\s+',
>
> + re.S | re.MULTILINE)
>
> + for match in regex.finditer(bsf_txt):
>
> + find = match.group(1)
>
> + name = match.group(3)
>
> + line = bsf_txt[:match.end()].count("\n")
>
> + find_list.append((name, find, line))
>
> +
>
> + idx = 0
>
> + count = 0
>
> + prefix = ''
>
> + chk_dict = {}
>
> + cfg_list = []
>
> + cfg_temp = {'find': '', 'cname': '', 'length': 0, 'value': '0',
>
> + 'type': 'Reserved', 'isbit': False,
>
> + 'embed': '', 'page': '', 'option': '', 'instance': 0}
>
> + regex = re.compile(
>
> + r'^\s+(\$(.*?)|Skip)\s+(\d+)\s+(bits|bytes)(\s+\$_DEFAULT_\s'
>
> + r'+=\s+(.+?))?$', re.S |
>
> + re.MULTILINE)
>
> +
>
> + for match in regex.finditer(bsf_txt):
>
> + dlen = int(match.group(3))
>
> + if match.group(1) == 'Skip':
>
> + key = 'gPlatformFspPkgTokenSpaceGuid_BsfSkip%d' % idx
>
> + val = ', '.join(['%02X' % ord(i) for i in '\x00' * dlen])
>
> + idx += 1
>
> + option = '$SKIP'
>
> + else:
>
> + key = match.group(2)
>
> + val = match.group(6)
>
> + option = ''
>
> + is_bit = True if match.group(4) == 'bits' else False
>
> +
>
> + cfg_item = dict(cfg_temp)
>
> + line = bsf_txt[:match.end()].count("\n")
>
> + finds = [i for i in find_list if line >= i[2]]
>
> + if len(finds) > 0:
>
> + prefix = finds[0][1]
>
> + cfg_item['embed'] = '%s:TAG_%03X:START' % \
>
> + (prefix, ord(prefix[-1]))
>
> + cfg_item['find'] = prefix
>
> + cfg_item['cname'] = 'Signature'
>
> + cfg_item['length'] = len(finds[0][1])
>
> + str2byte = Str2Bytes("'" + finds[0][1] + "'",
>
> + len(finds[0][1]))
>
> + cfg_item['value'] = '0x%X' % Bytes2Val(str2byte)
>
> +
>
> + cfg_list.append(dict(cfg_item))
>
> + cfg_item = dict(cfg_temp)
>
> + find_list.pop(0)
>
> + count = 0
>
> +
>
> + cfg_item['cname'] = key
>
> + cfg_item['length'] = dlen
>
> + cfg_item['value'] = val
>
> + cfg_item['option'] = option
>
> + cfg_item['isbit'] = is_bit
>
> +
>
> + if key not in chk_dict.keys():
>
> + chk_dict[key] = 0
>
> + else:
>
> + chk_dict[key] += 1
>
> + cfg_item['instance'] = chk_dict[key]
>
> +
>
> + cfg_list.append(cfg_item)
>
> + count += 1
>
> +
>
> + if prefix:
>
> + cfg_item = dict(cfg_temp)
>
> + cfg_item['cname'] = 'Dummy'
>
> + cfg_item['embed'] = '%s:%03X:END' % (prefix, ord(prefix[-1]))
>
> + cfg_list.append(cfg_item)
>
> +
>
> + option_dict = {}
>
> + selreg = re.compile(
>
> + r'\s+Selection\s*(.+?)\s*,\s*"(.*?)"$', re.S |
>
> + re.MULTILINE)
>
> + regex = re.compile(
>
> + r'^List\s&(.+?)$(.+?)^EndList$', re.S | re.MULTILINE)
>
> + for match in regex.finditer(bsf_txt):
>
> + key = match.group(1)
>
> + option_dict[key] = []
>
> + for select in selreg.finditer(match.group(2)):
>
> + option_dict[key].append(
>
> + (int(select.group(1), 0), select.group(2)))
>
> +
>
> + chk_dict = {}
>
> + pagereg = re.compile(
>
> + r'^Page\s"(.*?)"$(.+?)^EndPage$', re.S | re.MULTILINE)
>
> + for match in pagereg.finditer(bsf_txt):
>
> + page = match.group(1)
>
> + for line in match.group(2).splitlines():
>
> + match = re.match(
>
> + r'\s+(Combo|EditNum)\s\$(.+?),\s"(.*?)",\s(.+?),$', line)
>
> + if match:
>
> + cname = match.group(2)
>
> + if cname not in chk_dict.keys():
>
> + chk_dict[cname] = 0
>
> + else:
>
> + chk_dict[cname] += 1
>
> + instance = chk_dict[cname]
>
> + cfg_idxs = [i for i, j in enumerate(cfg_list)
>
> + if j['cname'] == cname and
>
> + j['instance'] == instance]
>
> + if len(cfg_idxs) != 1:
>
> + raise Exception(
>
> + "Multiple CFG item '%s' found !" % cname)
>
> + cfg_item = cfg_list[cfg_idxs[0]]
>
> + cfg_item['page'] = page
>
> + cfg_item['type'] = match.group(1)
>
> + cfg_item['prompt'] = match.group(3)
>
> + cfg_item['range'] = None
>
> + if cfg_item['type'] == 'Combo':
>
> + cfg_item['option'] = option_dict[match.group(4)[1:]]
>
> + elif cfg_item['type'] == 'EditNum':
>
> + cfg_item['option'] = match.group(4)
>
> + match = re.match(r'\s+ Help\s"(.*?)"$', line)
>
> + if match:
>
> + cfg_item['help'] = match.group(1)
>
> +
>
> + match = re.match(r'\s+"Valid\srange:\s(.*)"$', line)
>
> + if match:
>
> + parts = match.group(1).split()
>
> + cfg_item['option'] = (
>
> + (int(parts[0], 0), int(parts[2], 0),
>
> + cfg_item['option']))
>
> +
>
> + return cfg_list
>
> +
>
> + @staticmethod
>
> + def generate_dsc(option_list, dsc_file=None):
>
> + dsc_lines = []
>
> + header = '%s' % (__copyright_dsc__ % date.today().year)
>
> + dsc_lines.extend(header.splitlines())
>
> +
>
> + pages = []
>
> + for cfg_item in option_list:
>
> + if cfg_item['page'] and (cfg_item['page'] not in pages):
>
> + pages.append(cfg_item['page'])
>
> +
>
> + page_id = 0
>
> + for page in pages:
>
> + dsc_lines.append(' # !BSF PAGES:{PG%02X::"%s"}' % (page_id, page))
>
> + page_id += 1
>
> + dsc_lines.append('')
>
> +
>
> + last_page = ''
>
> +
>
> + is_bit = False
>
> + dlen = 0
>
> + dval = 0
>
> + bit_fields = []
>
> + for idx, option in enumerate(option_list):
>
> + if not is_bit and option['isbit']:
>
> + is_bit = True
>
> + dlen = 0
>
> + dval = 0
>
> + idxs = idx
>
> + if is_bit and not option['isbit']:
>
> + is_bit = False
>
> + if dlen % 8 != 0:
>
> + raise Exception("Bit fields are not aligned at "
>
> + "byte boundary !")
>
> + bit_fields.append((idxs, idx, dlen, dval))
>
> + if is_bit:
>
> + blen = option['length']
>
> + bval = int(option['value'], 0)
>
> + dval = dval + ((bval & ((1 << blen) - 1)) << dlen)
>
> + print(dlen, blen, bval, hex(dval))
>
> + dlen += blen
>
> +
>
> + struct_idx = 0
>
> + for idx, option in enumerate(option_list):
>
> + dsc_lines.append('')
>
> + default = option['value']
>
> + pos = option['cname'].find('_')
>
> + name = option['cname'][pos + 1:]
>
> +
>
> + for start_idx, end_idx, bits_len, bits_val in bit_fields:
>
> + if idx == start_idx:
>
> + val_str = Bytes2Str(Val2Bytes(bits_val, bits_len // 8))
>
> + dsc_lines.append(' # !HDR STRUCT:{BIT_FIELD_DATA_%d}'
>
> + % struct_idx)
>
> + dsc_lines.append(' # !BSF NAME:{BIT_FIELD_STRUCT}')
>
> + dsc_lines.append(' gCfgData.BitFiledStruct%d '
>
> + ' | * | 0x%04X | %s' %
>
> + (struct_idx, bits_len // 8, val_str))
>
> + dsc_lines.append('')
>
> + struct_idx += 1
>
> +
>
> + if option['find']:
>
> + dsc_lines.append(' # !BSF FIND:{%s}' % option['find'])
>
> + dsc_lines.append('')
>
> +
>
> + if option['instance'] > 0:
>
> + name = name + '_%s' % option['instance']
>
> +
>
> + if option['embed']:
>
> + dsc_lines.append(' # !HDR EMBED:{%s}' % option['embed'])
>
> +
>
> + if option['type'] == 'Reserved':
>
> + dsc_lines.append(' # !BSF NAME:{Reserved} TYPE:{Reserved}')
>
> + if option['option'] == '$SKIP':
>
> + dsc_lines.append(' # !BSF OPTION:{$SKIP}')
>
> + else:
>
> + prompt = option['prompt']
>
> +
>
> + if last_page != option['page']:
>
> + last_page = option['page']
>
> + dsc_lines.append(' # !BSF PAGE:{PG%02X}' %
>
> + (pages.index(option['page'])))
>
> +
>
> + if option['type'] == 'Combo':
>
> + dsc_lines.append(' # !BSF NAME:{%s} TYPE:{%s}' %
>
> + (prompt, option['type']))
>
> + ops = []
>
> + for val, text in option['option']:
>
> + ops.append('0x%x:%s' % (val, text))
>
> + dsc_lines.append(' # !BSF OPTION:{%s}' % (', '.join(ops)))
>
> + elif option['type'] == 'EditNum':
>
> + cfg_len = option['length']
>
> + if ',' in default and cfg_len > 8:
>
> + dsc_lines.append(' # !BSF NAME:{%s} TYPE:{Table}' %
>
> + (prompt))
>
> + if cfg_len > 16:
>
> + cfg_len = 16
>
> + ops = []
>
> + for i in range(cfg_len):
>
> + ops.append('%X:1:HEX' % i)
>
> + dsc_lines.append(' # !BSF OPTION:{%s}' %
>
> + (', '.join(ops)))
>
> + else:
>
> + dsc_lines.append(
>
> + ' # !BSF NAME:{%s} TYPE:{%s, %s, (0x%X, 0x%X)}' %
>
> + (prompt, option['type'], option['option'][2],
>
> + option['option'][0], option['option'][1]))
>
> + dsc_lines.append(' # !BSF HELP:{%s}' % option['help'])
>
> +
>
> + if ',' in default:
>
> + default = '{%s}' % default
>
> +
>
> + if option['isbit']:
>
> + dsc_lines.append(' # !BSF FIELD:{%s:%db}'
>
> + % (name, option['length']))
>
> + else:
>
> + dsc_lines.append(' gCfgData.%-30s | * | 0x%04X | %s' %
>
> + (name, option['length'], default))
>
> +
>
> + if dsc_file:
>
> + fd = open(dsc_file, 'w')
>
> + fd.write('\n'.join(dsc_lines))
>
> + fd.close()
>
> +
>
> + return dsc_lines
>
> +
>
> +
>
> +class CGenCfgData:
>
> + def __init__(self, Mode=''):
>
> + self.Debug = False
>
> + self.Error = ''
>
> + self.ReleaseMode = True
>
> + self.Mode = Mode
>
> + self._GlobalDataDef = """
>
> +GlobalDataDef
>
> + SKUID = 0, "DEFAULT"
>
> +EndGlobalData
>
> +
>
> +"""
>
> + self._BuidinOptionTxt = """
>
> +List &EN_DIS
>
> + Selection 0x1 , "Enabled"
>
> + Selection 0x0 , "Disabled"
>
> +EndList
>
> +
>
> +"""
>
> + self._StructType = ['UINT8', 'UINT16', 'UINT32', 'UINT64']
>
> + self._BsfKeyList = ['FIND', 'NAME', 'HELP', 'TYPE', 'PAGE', 'PAGES',
>
> + 'BLOCK', 'OPTION', 'CONDITION', 'ORDER', 'MARKER',
>
> + 'SUBT']
>
> + self._HdrKeyList = ['HEADER', 'STRUCT', 'EMBED', 'COMMENT']
>
> + self._BuidinOption = {'$EN_DIS': 'EN_DIS'}
>
> +
>
> + self._MacroDict = {}
>
> + self._VarDict = {}
>
> + self._PcdsDict = {}
>
> + self._CfgBlkDict = {}
>
> + self._CfgPageDict = {}
>
> + self._CfgOptsDict = {}
>
> + self._BsfTempDict = {}
>
> + self._CfgItemList = []
>
> + self._DscLines = []
>
> + self._DscFile = ''
>
> + self._CfgPageTree = {}
>
> +
>
> + self._MapVer = 0
>
> + self._MinCfgTagId = 0x100
>
> +
>
> + def ParseMacros(self, MacroDefStr):
>
> + # ['-DABC=1', '-D', 'CFG_DEBUG=1', '-D', 'CFG_OUTDIR=Build']
>
> + self._MacroDict = {}
>
> + IsExpression = False
>
> + for Macro in MacroDefStr:
>
> + if Macro.startswith('-D'):
>
> + IsExpression = True
>
> + if len(Macro) > 2:
>
> + Macro = Macro[2:]
>
> + else:
>
> + continue
>
> + if IsExpression:
>
> + IsExpression = False
>
> + Match = re.match("(\\w+)=(.+)", Macro)
>
> + if Match:
>
> + self._MacroDict[Match.group(1)] = Match.group(2)
>
> + else:
>
> + Match = re.match("(\\w+)", Macro)
>
> + if Match:
>
> + self._MacroDict[Match.group(1)] = ''
>
> + if len(self._MacroDict) == 0:
>
> + Error = 1
>
> + else:
>
> + Error = 0
>
> + if self.Debug:
>
> + print("INFO : Macro dictionary:")
>
> + for Each in self._MacroDict:
>
> + print(" $(%s) = [ %s ]" % (Each,
>
> + self._MacroDict[Each]))
>
> + return Error
>
> +
>
> + def EvaulateIfdef(self, Macro):
>
> + Result = Macro in self._MacroDict
>
> + if self.Debug:
>
> + print("INFO : Eval Ifdef [%s] : %s" % (Macro, Result))
>
> + return Result
>
> +
>
> + def ExpandMacros(self, Input, Preserve=False):
>
> + Line = Input
>
> + Match = re.findall("\\$\\(\\w+\\)", Input)
>
> + if Match:
>
> + for Each in Match:
>
> + Variable = Each[2:-1]
>
> + if Variable in self._MacroDict:
>
> + Line = Line.replace(Each, self._MacroDict[Variable])
>
> + else:
>
> + if self.Debug:
>
> + print("WARN : %s is not defined" % Each)
>
> + if not Preserve:
>
> + Line = Line.replace(Each, Each[2:-1])
>
> + return Line
>
> +
>
> + def ExpandPcds(self, Input):
>
> + Line = Input
>
> + Match = re.findall("(\\w+\\.\\w+)", Input)
>
> + if Match:
>
> + for PcdName in Match:
>
> + if PcdName in self._PcdsDict:
>
> + Line = Line.replace(PcdName, self._PcdsDict[PcdName])
>
> + else:
>
> + if self.Debug:
>
> + print("WARN : %s is not defined" % PcdName)
>
> + return Line
>
> +
>
> + def EvaluateExpress(self, Expr):
>
> + ExpExpr = self.ExpandPcds(Expr)
>
> + ExpExpr = self.ExpandMacros(ExpExpr)
>
> + LogExpr = CLogicalExpression()
>
> + Result = LogExpr.evaluateExpress(ExpExpr)
>
> + if self.Debug:
>
> + print("INFO : Eval Express [%s] : %s" % (Expr, Result))
>
> + return Result
>
> +
>
> + def ValueToByteArray(self, ValueStr, Length):
>
> + Match = re.match("\\{\\s*FILE:(.+)\\}", ValueStr)
>
> + if Match:
>
> + FileList = Match.group(1).split(',')
>
> + Result = bytearray()
>
> + for File in FileList:
>
> + File = File.strip()
>
> + BinPath = os.path.join(os.path.dirname(self._DscFile), File)
>
> + Result.extend(bytearray(open(BinPath, 'rb').read()))
>
> + else:
>
> + try:
>
> + Result = bytearray(self.ValueToList(ValueStr, Length))
>
> + except ValueError:
>
> + raise Exception("Bytes in '%s' must be in range 0~255 !" %
>
> + ValueStr)
>
> + if len(Result) < Length:
>
> + Result.extend(b'\x00' * (Length - len(Result)))
>
> + elif len(Result) > Length:
>
> + raise Exception("Value '%s' is too big to fit into %d bytes !" %
>
> + (ValueStr, Length))
>
> +
>
> + return Result[:Length]
>
> +
>
> + def ValueToList(self, ValueStr, Length):
>
> + if ValueStr[0] == '{':
>
> + Result = []
>
> + BinList = ValueStr[1:-1].split(',')
>
> + InBitField = False
>
> + LastInBitField = False
>
> + Value = 0
>
> + BitLen = 0
>
> + for Element in BinList:
>
> + InBitField = False
>
> + Each = Element.strip()
>
> + if len(Each) == 0:
>
> + pass
>
> + else:
>
> + if Each[0] in ['"', "'"]:
>
> + Result.extend(list(bytearray(Each[1:-1], 'utf-8')))
>
> + elif ':' in Each:
>
> + Match = re.match("(.+):(\\d+)b", Each)
>
> + if Match is None:
>
> + raise Exception("Invald value list format '%s' !"
>
> + % Each)
>
> + InBitField = True
>
> + CurrentBitLen = int(Match.group(2))
>
> + CurrentValue = ((self.EvaluateExpress(Match.group(1))
>
> + & (1 << CurrentBitLen) - 1)) << BitLen
>
> + else:
>
> + Result.append(self.EvaluateExpress(Each.strip()))
>
> + if InBitField:
>
> + Value += CurrentValue
>
> + BitLen += CurrentBitLen
>
> + if LastInBitField and ((not InBitField) or (Element ==
>
> + BinList[-1])):
>
> + if BitLen % 8 != 0:
>
> + raise Exception("Invald bit field length!")
>
> + Result.extend(Val2Bytes(Value, BitLen // 8))
>
> + Value = 0
>
> + BitLen = 0
>
> + LastInBitField = InBitField
>
> + elif ValueStr.startswith("'") and ValueStr.endswith("'"):
>
> + Result = Str2Bytes(ValueStr, Length)
>
> + elif ValueStr.startswith('"') and ValueStr.endswith('"'):
>
> + Result = Str2Bytes(ValueStr, Length)
>
> + else:
>
> + Result = Val2Bytes(self.EvaluateExpress(ValueStr), Length)
>
> + return Result
>
> +
>
> + def FormatDeltaValue(self, ConfigDict):
>
> + ValStr = ConfigDict['value']
>
> + if ValStr[0] == "'":
>
> + # Remove padding \x00 in the value string
>
> + ValStr = "'%s'" % ValStr[1:-1].rstrip('\x00')
>
> +
>
> + Struct = ConfigDict['struct']
>
> + if Struct in self._StructType:
>
> + # Format the array using its struct type
>
> + Unit = int(Struct[4:]) // 8
>
> + Value = Array2Val(ConfigDict['value'])
>
> + Loop = ConfigDict['length'] // Unit
>
> + Values = []
>
> + for Each in range(Loop):
>
> + Values.append(Value & ((1 << (Unit * 8)) - 1))
>
> + Value = Value >> (Unit * 8)
>
> + ValStr = '{ ' + ', '.join([('0x%%0%dX' % (Unit * 2)) %
>
> + x for x in Values]) + ' }'
>
> +
>
> + return ValStr
>
> +
>
> + def FormatListValue(self, ConfigDict):
>
> + Struct = ConfigDict['struct']
>
> + if Struct not in self._StructType:
>
> + return
>
> +
>
> + DataList = self.ValueToList(ConfigDict['value'], ConfigDict['length'])
>
> + Unit = int(Struct[4:]) // 8
>
> + if int(ConfigDict['length']) != Unit * len(DataList):
>
> + # Fallback to byte array
>
> + Unit = 1
>
> + if int(ConfigDict['length']) != len(DataList):
>
> + raise Exception("Array size is not proper for '%s' !" %
>
> + ConfigDict['cname'])
>
> +
>
> + ByteArray = []
>
> + for Value in DataList:
>
> + for Loop in range(Unit):
>
> + ByteArray.append("0x%02X" % (Value & 0xFF))
>
> + Value = Value >> 8
>
> + NewValue = '{' + ','.join(ByteArray) + '}'
>
> + ConfigDict['value'] = NewValue
>
> +
>
> + return ""
>
> +
>
> + def GetOrderNumber(self, Offset, Order, BitOff=0):
>
> + if isinstance(Order, int):
>
> + if Order == -1:
>
> + Order = Offset << 16
>
> + else:
>
> + (Major, Minor) = Order.split('.')
>
> + Order = (int(Major, 16) << 16) + ((int(Minor, 16) & 0xFF) << 8)
>
> + return Order + (BitOff & 0xFF)
>
> +
>
> + def SubtituteLine(self, Line, Args):
>
> + Args = Args.strip()
>
> + Vars = Args.split(':')
>
> + Line = self.ExpandMacros(Line, True)
>
> + for Idx in range(len(Vars)-1, 0, -1):
>
> + Line = Line.replace('$(%d)' % Idx, Vars[Idx].strip())
>
> + return Line
>
> +
>
> + def CfgDuplicationCheck(self, CfgDict, Name):
>
> + if not self.Debug:
>
> + return
>
> +
>
> + if Name == 'Dummy':
>
> + return
>
> +
>
> + if Name not in CfgDict:
>
> + CfgDict[Name] = 1
>
> + else:
>
> + print("WARNING: Duplicated item found '%s' !" %
>
> + CfgDict['cname'])
>
> +
>
> + def AddBsfChildPage(self, Child, Parent='root'):
>
> + def AddBsfChildPageRecursive(PageTree, Parent, Child):
>
> + Key = next(iter(PageTree))
>
> + if Parent == Key:
>
> + PageTree[Key].append({Child: []})
>
> + return True
>
> + else:
>
> + Result = False
>
> + for Each in PageTree[Key]:
>
> + if AddBsfChildPageRecursive(Each, Parent, Child):
>
> + Result = True
>
> + break
>
> + return Result
>
> +
>
> + return AddBsfChildPageRecursive(self._CfgPageTree, Parent, Child)
>
> +
>
> + def ParseDscFile(self, DscFile):
>
> + self._DscLines = []
>
> + self._CfgItemList = []
>
> + self._CfgPageDict = {}
>
> + self._CfgBlkDict = {}
>
> + self._BsfTempDict = {}
>
> + self._CfgPageTree = {'root': []}
>
> +
>
> + CfgDict = {}
>
> +
>
> + SectionNameList = ["Defines".lower(), "PcdsFeatureFlag".lower(),
>
> + "PcdsDynamicVpd.Tmp".lower(),
>
> + "PcdsDynamicVpd.Upd".lower()]
>
> +
>
> + IsDefSect = False
>
> + IsPcdSect = False
>
> + IsUpdSect = False
>
> + IsTmpSect = False
>
> +
>
> + TemplateName = ''
>
> +
>
> + IfStack = []
>
> + ElifStack = []
>
> + Error = 0
>
> + ConfigDict = {}
>
> +
>
> + if type(DscFile) is list:
>
> + # it is DSC lines already
>
> + DscLines = DscFile
>
> + self._DscFile = '.'
>
> + else:
>
> + DscFd = open(DscFile, "r")
>
> + DscLines = DscFd.readlines()
>
> + DscFd.close()
>
> + self._DscFile = DscFile
>
> +
>
> + BsfRegExp = re.compile("(%s):{(.+?)}(?:$|\\s+)" % '|'.
>
> + join(self._BsfKeyList))
>
> + HdrRegExp = re.compile("(%s):{(.+?)}" % '|'.join(self._HdrKeyList))
>
> + CfgRegExp = re.compile("^([_a-zA-Z0-9]+)\\s*\\|\\s*\
>
> +(0x[0-9A-F]+|\\*)\\s*\\|\\s*(\\d+|0x[0-9a-fA-F]+)\\s*\\|\\s*(.+)")
>
> + TksRegExp = re.compile("^(g[_a-zA-Z0-9]+\\.)(.+)")
>
> + SkipLines = 0
>
> + while len(DscLines):
>
> + DscLine = DscLines.pop(0).strip()
>
> + if SkipLines == 0:
>
> + self._DscLines.append(DscLine)
>
> + else:
>
> + SkipLines = SkipLines - 1
>
> + if len(DscLine) == 0:
>
> + continue
>
> +
>
> + Handle = False
>
> + Match = re.match("^\\[(.+)\\]", DscLine)
>
> + if Match is not None:
>
> + IsDefSect = False
>
> + IsPcdSect = False
>
> + IsUpdSect = False
>
> + IsTmpSect = False
>
> + SectionName = Match.group(1).lower()
>
> + if SectionName == SectionNameList[0]:
>
> + IsDefSect = True
>
> + if SectionName == SectionNameList[1]:
>
> + IsPcdSect = True
>
> + elif SectionName == SectionNameList[2]:
>
> + IsTmpSect = True
>
> + elif SectionName == SectionNameList[3]:
>
> + ConfigDict = {
>
> + 'header': 'ON',
>
> + 'page': '',
>
> + 'name': '',
>
> + 'find': '',
>
> + 'struct': '',
>
> + 'embed': '',
>
> + 'marker': '',
>
> + 'option': '',
>
> + 'comment': '',
>
> + 'condition': '',
>
> + 'order': -1,
>
> + 'subreg': []
>
> + }
>
> + IsUpdSect = True
>
> + Offset = 0
>
> + else:
>
> + if IsDefSect or IsPcdSect or IsUpdSect or IsTmpSect:
>
> + Match = False if DscLine[0] != '!' else True
>
> + if Match:
>
> + Match = re.match("^!(else|endif|ifdef|ifndef|if|elseif\
>
> +|include)\\s*(.+)?$", DscLine.split("#")[0])
>
> + Keyword = Match.group(1) if Match else ''
>
> + Remaining = Match.group(2) if Match else ''
>
> + Remaining = '' if Remaining is None else Remaining.strip()
>
> +
>
> + if Keyword in ['if', 'elseif', 'ifdef', 'ifndef', 'include'
>
> + ] and not Remaining:
>
> + raise Exception("ERROR: Expression is expected after \
>
> +'!if' or !elseif' for line '%s'" % DscLine)
>
> +
>
> + if Keyword == 'else':
>
> + if IfStack:
>
> + IfStack[-1] = not IfStack[-1]
>
> + else:
>
> + raise Exception("ERROR: No paired '!if' found for \
>
> +'!else' for line '%s'" % DscLine)
>
> + elif Keyword == 'endif':
>
> + if IfStack:
>
> + IfStack.pop()
>
> + Level = ElifStack.pop()
>
> + if Level > 0:
>
> + del IfStack[-Level:]
>
> + else:
>
> + raise Exception("ERROR: No paired '!if' found for \
>
> +'!endif' for line '%s'" % DscLine)
>
> + elif Keyword == 'ifdef' or Keyword == 'ifndef':
>
> + Result = self.EvaulateIfdef(Remaining)
>
> + if Keyword == 'ifndef':
>
> + Result = not Result
>
> + IfStack.append(Result)
>
> + ElifStack.append(0)
>
> + elif Keyword == 'if' or Keyword == 'elseif':
>
> + Result = self.EvaluateExpress(Remaining)
>
> + if Keyword == "if":
>
> + ElifStack.append(0)
>
> + IfStack.append(Result)
>
> + else: # elseif
>
> + if IfStack:
>
> + IfStack[-1] = not IfStack[-1]
>
> + IfStack.append(Result)
>
> + ElifStack[-1] = ElifStack[-1] + 1
>
> + else:
>
> + raise Exception("ERROR: No paired '!if' found for \
>
> +'!elif' for line '%s'" % DscLine)
>
> + else:
>
> + if IfStack:
>
> + Handle = reduce(lambda x, y: x and y, IfStack)
>
> + else:
>
> + Handle = True
>
> + if Handle:
>
> + if Keyword == 'include':
>
> + Remaining = self.ExpandMacros(Remaining)
>
> + # Relative to DSC filepath
>
> + IncludeFilePath = os.path.join(
>
> + os.path.dirname(self._DscFile), Remaining)
>
> + if not os.path.exists(IncludeFilePath):
>
> + # Relative to repository to find \
>
> + # dsc in common platform
>
> + IncludeFilePath = os.path.join(
>
> + os.path.dirname(self._DscFile), "..",
>
> + Remaining)
>
> +
>
> + try:
>
> + IncludeDsc = open(IncludeFilePath, "r")
>
> + except Exception:
>
> + raise Exception("ERROR: Cannot open \
>
> +file '%s'." % IncludeFilePath)
>
> + NewDscLines = IncludeDsc.readlines()
>
> + IncludeDsc.close()
>
> + DscLines = NewDscLines + DscLines
>
> + del self._DscLines[-1]
>
> + else:
>
> + if DscLine.startswith('!'):
>
> + raise Exception("ERROR: Unrecoginized \
>
> +directive for line '%s'" % DscLine)
>
> +
>
> + if not Handle:
>
> + del self._DscLines[-1]
>
> + continue
>
> +
>
> + if IsDefSect:
>
> + Match = re.match("^\\s*(?:DEFINE\\s+)*(\\w+)\\s*=\\s*(.+)",
>
> + DscLine)
>
> + if Match:
>
> + self._MacroDict[Match.group(1)] = Match.group(2)
>
> + if self.Debug:
>
> + print("INFO : DEFINE %s = [ %s ]" % (Match.group(1),
>
> + Match.group(2)))
>
> +
>
> + elif IsPcdSect:
>
> + Match = re.match("^\\s*([\\w\\.]+)\\s*\\|\\s*(\\w+)", DscLine)
>
> + if Match:
>
> + self._PcdsDict[Match.group(1)] = Match.group(2)
>
> + if self.Debug:
>
> + print("INFO : PCD %s = [ %s ]" % (Match.group(1),
>
> + Match.group(2)))
>
> +
>
> + elif IsTmpSect:
>
> + # !BSF DEFT:{GPIO_TMPL:START}
>
> + Match = re.match("^\\s*#\\s+(!BSF)\\s+DEFT:{(.+?):\
>
> +(START|END)}", DscLine)
>
> + if Match:
>
> + if Match.group(3) == 'START' and not TemplateName:
>
> + TemplateName = Match.group(2).strip()
>
> + self._BsfTempDict[TemplateName] = []
>
> + if Match.group(3) == 'END' and (
>
> + TemplateName == Match.group(2).strip()
>
> + ) and TemplateName:
>
> + TemplateName = ''
>
> + else:
>
> + if TemplateName:
>
> + Match = re.match("^!include\\s*(.+)?$", DscLine)
>
> + if Match:
>
> + continue
>
> + self._BsfTempDict[TemplateName].append(DscLine)
>
> +
>
> + else:
>
> + Match = re.match("^\\s*#\\s+(!BSF|!HDR)\\s+(.+)", DscLine)
>
> + if Match:
>
> + Remaining = Match.group(2)
>
> + if Match.group(1) == '!BSF':
>
> + Result = BsfRegExp.findall(Remaining)
>
> + if Result:
>
> + for Each in Result:
>
> + Key = Each[0]
>
> + Remaining = Each[1]
>
> +
>
> + if Key == 'BLOCK':
>
> + Match = re.match(
>
> + "NAME:\"(.+)\"\\s*,\\s*\
>
> +VER:\"(.+)\"\\s*", Remaining)
>
> + if Match:
>
> + self._CfgBlkDict['name'] = \
>
> + Match.group(1)
>
> + self._CfgBlkDict['ver'] = Match.group(2
>
> + )
>
> +
>
> + elif Key == 'SUBT':
>
> + # GPIO_TMPL:1:2:3
>
> + Remaining = Remaining.strip()
>
> + Match = re.match("(\\w+)\\s*:", Remaining)
>
> + if Match:
>
> + TemplateName = Match.group(1)
>
> + for Line in self._BsfTempDict[
>
> + TemplateName][::-1]:
>
> + NewLine = self.SubtituteLine(
>
> + Line, Remaining)
>
> + DscLines.insert(0, NewLine)
>
> + SkipLines += 1
>
> +
>
> + elif Key == 'PAGES':
>
> + # !BSF PAGES:{HSW:"Haswell System Agent", \
>
> + # LPT:"Lynx Point PCH"}
>
> + PageList = Remaining.split(',')
>
> + for Page in PageList:
>
> + Page = Page.strip()
>
> + Match = re.match('(\\w+):\
>
> +(\\w*:)?\\"(.+)\\"', Page)
>
> + if Match:
>
> + PageName = Match.group(1)
>
> + ParentName = Match.group(2)
>
> + if not ParentName or \
>
> + ParentName == ':':
>
> + ParentName = 'root'
>
> + else:
>
> + ParentName = ParentName[:-1]
>
> + if not self.AddBsfChildPage(
>
> + PageName, ParentName):
>
> + raise Exception("Cannot find \
>
> +parent page '%s'!" % ParentName)
>
> + self._CfgPageDict[
>
> + PageName] = Match.group(3)
>
> + else:
>
> + raise Exception("Invalid page \
>
> +definitions '%s'!" % Page)
>
> +
>
> + elif Key in ['NAME', 'HELP', 'OPTION'
>
> + ] and Remaining.startswith('+'):
>
> + # Allow certain options to be extended \
>
> + # to multiple lines
>
> + ConfigDict[Key.lower()] += Remaining[1:]
>
> +
>
> + else:
>
> + if Key == 'NAME':
>
> + Remaining = Remaining.strip()
>
> + elif Key == 'CONDITION':
>
> + Remaining = self.ExpandMacros(
>
> + Remaining.strip())
>
> + ConfigDict[Key.lower()] = Remaining
>
> + else:
>
> + Match = HdrRegExp.match(Remaining)
>
> + if Match:
>
> + Key = Match.group(1)
>
> + Remaining = Match.group(2)
>
> + if Key == 'EMBED':
>
> + Parts = Remaining.split(':')
>
> + Names = Parts[0].split(',')
>
> + DummyDict = ConfigDict.copy()
>
> + if len(Names) > 1:
>
> + Remaining = Names[0] + ':' + ':'.join(
>
> + Parts[1:])
>
> + DummyDict['struct'] = Names[1]
>
> + else:
>
> + DummyDict['struct'] = Names[0]
>
> + DummyDict['cname'] = 'Dummy'
>
> + DummyDict['name'] = ''
>
> + DummyDict['embed'] = Remaining
>
> + DummyDict['offset'] = Offset
>
> + DummyDict['length'] = 0
>
> + DummyDict['value'] = '0'
>
> + DummyDict['type'] = 'Reserved'
>
> + DummyDict['help'] = ''
>
> + DummyDict['subreg'] = []
>
> + self._CfgItemList.append(DummyDict)
>
> + else:
>
> + ConfigDict[Key.lower()] = Remaining
>
> + # Check CFG line
>
> + # gCfgData.VariableName | * | 0x01 | 0x1
>
> + Clear = False
>
> +
>
> + Match = TksRegExp.match(DscLine)
>
> + if Match:
>
> + DscLine = 'gCfgData.%s' % Match.group(2)
>
> +
>
> + if DscLine.startswith('gCfgData.'):
>
> + Match = CfgRegExp.match(DscLine[9:])
>
> + else:
>
> + Match = None
>
> + if Match:
>
> + ConfigDict['space'] = 'gCfgData'
>
> + ConfigDict['cname'] = Match.group(1)
>
> + if Match.group(2) != '*':
>
> + Offset = int(Match.group(2), 16)
>
> + ConfigDict['offset'] = Offset
>
> + ConfigDict['order'] = self.GetOrderNumber(
>
> + ConfigDict['offset'], ConfigDict['order'])
>
> +
>
> + Value = Match.group(4).strip()
>
> + if Match.group(3).startswith("0x"):
>
> + Length = int(Match.group(3), 16)
>
> + else:
>
> + Length = int(Match.group(3))
>
> +
>
> + Offset += Length
>
> +
>
> + ConfigDict['length'] = Length
>
> + Match = re.match("\\$\\((\\w+)\\)", Value)
>
> + if Match:
>
> + if Match.group(1) in self._MacroDict:
>
> + Value = self._MacroDict[Match.group(1)]
>
> +
>
> + ConfigDict['value'] = Value
>
> + if re.match("\\{\\s*FILE:(.+)\\}", Value):
>
> + # Expand embedded binary file
>
> + ValArray = self.ValueToByteArray(ConfigDict['value'],
>
> + ConfigDict['length'])
>
> + NewValue = Bytes2Str(ValArray)
>
> + self._DscLines[-1] = re.sub(r'(.*)(\{\s*FILE:.+\})',
>
> + r'\1 %s' % NewValue,
>
> + self._DscLines[-1])
>
> + ConfigDict['value'] = NewValue
>
> +
>
> + if ConfigDict['name'] == '':
>
> + # Clear BSF specific items
>
> + ConfigDict['bsfname'] = ''
>
> + ConfigDict['help'] = ''
>
> + ConfigDict['type'] = ''
>
> + ConfigDict['option'] = ''
>
> +
>
> + self.CfgDuplicationCheck(CfgDict, ConfigDict['cname'])
>
> + self._CfgItemList.append(ConfigDict.copy())
>
> + Clear = True
>
> +
>
> + else:
>
> + # It could be a virtual item as below
>
> + # !BSF FIELD:{SerialDebugPortAddress0:1}
>
> + # or
>
> + # @Bsf FIELD:{SerialDebugPortAddress0:1b}
>
> + Match = re.match(r"^\s*#\s+(!BSF)\s+FIELD:{(.+)}", DscLine)
>
> + if Match:
>
> + BitFieldTxt = Match.group(2)
>
> + Match = re.match("(.+):(\\d+)b([BWDQ])?", BitFieldTxt)
>
> + if not Match:
>
> + raise Exception("Incorrect bit field \
>
> +format '%s' !" % BitFieldTxt)
>
> + UnitBitLen = 1
>
> + SubCfgDict = ConfigDict.copy()
>
> + SubCfgDict['cname'] = Match.group(1)
>
> + SubCfgDict['bitlength'] = int(
>
> + Match.group(2)) * UnitBitLen
>
> + if SubCfgDict['bitlength'] > 0:
>
> + LastItem = self._CfgItemList[-1]
>
> + if len(LastItem['subreg']) == 0:
>
> + SubOffset = 0
>
> + else:
>
> + SubOffset = \
>
> + LastItem['subreg'][-1]['bitoffset'] \
>
> + + LastItem['subreg'][-1]['bitlength']
>
> + if Match.group(3) == 'B':
>
> + SubCfgDict['bitunit'] = 1
>
> + elif Match.group(3) == 'W':
>
> + SubCfgDict['bitunit'] = 2
>
> + elif Match.group(3) == 'Q':
>
> + SubCfgDict['bitunit'] = 8
>
> + else:
>
> + SubCfgDict['bitunit'] = 4
>
> + SubCfgDict['bitoffset'] = SubOffset
>
> + SubCfgDict['order'] = self.GetOrderNumber(
>
> + SubCfgDict['offset'], SubCfgDict['order'],
>
> + SubOffset)
>
> + SubCfgDict['value'] = ''
>
> + SubCfgDict['cname'] = '%s_%s' % (LastItem['cname'],
>
> + Match.group(1))
>
> + self.CfgDuplicationCheck(CfgDict,
>
> + SubCfgDict['cname'])
>
> + LastItem['subreg'].append(SubCfgDict.copy())
>
> + Clear = True
>
> +
>
> + if Clear:
>
> + ConfigDict['name'] = ''
>
> + ConfigDict['find'] = ''
>
> + ConfigDict['struct'] = ''
>
> + ConfigDict['embed'] = ''
>
> + ConfigDict['marker'] = ''
>
> + ConfigDict['comment'] = ''
>
> + ConfigDict['order'] = -1
>
> + ConfigDict['subreg'] = []
>
> + ConfigDict['option'] = ''
>
> + ConfigDict['condition'] = ''
>
> +
>
> + return Error
>
> +
>
> + def GetBsfBitFields(self, subitem, bytes):
>
> + start = subitem['bitoffset']
>
> + end = start + subitem['bitlength']
>
> + bitsvalue = ''.join('{0:08b}'.format(i) for i in bytes[::-1])
>
> + bitsvalue = bitsvalue[::-1]
>
> + bitslen = len(bitsvalue)
>
> + if start > bitslen or end > bitslen:
>
> + raise Exception("Invalid bits offset [%d,%d] %d for %s" %
>
> + (start, end, bitslen, subitem['name']))
>
> + return '0x%X' % (int(bitsvalue[start:end][::-1], 2))
>
> +
>
> + def UpdateBsfBitFields(self, SubItem, NewValue, ValueArray):
>
> + Start = SubItem['bitoffset']
>
> + End = Start + SubItem['bitlength']
>
> + Blen = len(ValueArray)
>
> + BitsValue = ''.join('{0:08b}'.format(i) for i in ValueArray[::-1])
>
> + BitsValue = BitsValue[::-1]
>
> + BitsLen = len(BitsValue)
>
> + if Start > BitsLen or End > BitsLen:
>
> + raise Exception("Invalid bits offset [%d,%d] %d for %s" %
>
> + (Start, End, BitsLen, SubItem['name']))
>
> + BitsValue = BitsValue[:Start] + '{0:0{1}b}'.format(
>
> + NewValue, SubItem['bitlength'])[::-1] + BitsValue[End:]
>
> + ValueArray[:] = bytearray.fromhex(
>
> + '{0:0{1}x}'.format(int(BitsValue[::-1], 2), Blen * 2))[::-1]
>
> +
>
> + def CreateVarDict(self):
>
> + Error = 0
>
> + self._VarDict = {}
>
> + if len(self._CfgItemList) > 0:
>
> + Item = self._CfgItemList[-1]
>
> + self._VarDict['_LENGTH_'] = '%d' % (Item['offset'] +
>
> + Item['length'])
>
> + for Item in self._CfgItemList:
>
> + Embed = Item['embed']
>
> + Match = re.match("^(\\w+):(\\w+):(START|END)", Embed)
>
> + if Match:
>
> + StructName = Match.group(1)
>
> + VarName = '_%s_%s_' % (Match.group(3), StructName)
>
> + if Match.group(3) == 'END':
>
> + self._VarDict[VarName] = Item['offset'] + Item['length']
>
> + self._VarDict['_LENGTH_%s_' % StructName] = \
>
> + self._VarDict['_END_%s_' % StructName] - \
>
> + self._VarDict['_START_%s_' % StructName]
>
> + if Match.group(2).startswith('TAG_'):
>
> + if (self.Mode != 'FSP') and (self._VarDict
>
> + ['_LENGTH_%s_' %
>
> + StructName] % 4):
>
> + raise Exception("Size of structure '%s' is %d, \
>
> +not DWORD aligned !" % (StructName, self._VarDict['_LENGTH_%s_' %
> StructName]))
>
> + self._VarDict['_TAG_%s_' % StructName] = int(
>
> + Match.group(2)[4:], 16) & 0xFFF
>
> + else:
>
> + self._VarDict[VarName] = Item['offset']
>
> + if Item['marker']:
>
> + self._VarDict['_OFFSET_%s_' % Item['marker'].strip()] = \
>
> + Item['offset']
>
> + return Error
>
> +
>
> + def UpdateBsfBitUnit(self, Item):
>
> + BitTotal = 0
>
> + BitOffset = 0
>
> + StartIdx = 0
>
> + Unit = None
>
> + UnitDec = {1: 'BYTE', 2: 'WORD', 4: 'DWORD', 8: 'QWORD'}
>
> + for Idx, SubItem in enumerate(Item['subreg']):
>
> + if Unit is None:
>
> + Unit = SubItem['bitunit']
>
> + BitLength = SubItem['bitlength']
>
> + BitTotal += BitLength
>
> + BitOffset += BitLength
>
> +
>
> + if BitOffset > 64 or BitOffset > Unit * 8:
>
> + break
>
> +
>
> + if BitOffset == Unit * 8:
>
> + for SubIdx in range(StartIdx, Idx + 1):
>
> + Item['subreg'][SubIdx]['bitunit'] = Unit
>
> + BitOffset = 0
>
> + StartIdx = Idx + 1
>
> + Unit = None
>
> +
>
> + if BitOffset > 0:
>
> + raise Exception("Bit fields cannot fit into %s for \
>
> +'%s.%s' !" % (UnitDec[Unit], Item['cname'], SubItem['cname']))
>
> +
>
> + ExpectedTotal = Item['length'] * 8
>
> + if Item['length'] * 8 != BitTotal:
>
> + raise Exception("Bit fields total length (%d) does not match \
>
> +length (%d) of '%s' !" % (BitTotal, ExpectedTotal, Item['cname']))
>
> +
>
> + def UpdateDefaultValue(self):
>
> + Error = 0
>
> + for Idx, Item in enumerate(self._CfgItemList):
>
> + if len(Item['subreg']) == 0:
>
> + Value = Item['value']
>
> + if (len(Value) > 0) and (Value[0] == '{' or Value[0] == "'" or
>
> + Value[0] == '"'):
>
> + # {XXX} or 'XXX' strings
>
> + self.FormatListValue(self._CfgItemList[Idx])
>
> + else:
>
> + Match = re.match("(0x[0-9a-fA-F]+|[0-9]+)", Value)
>
> + if not Match:
>
> + NumValue = self.EvaluateExpress(Value)
>
> + Item['value'] = '0x%X' % NumValue
>
> + else:
>
> + ValArray = self.ValueToByteArray(Item['value'], Item['length'])
>
> + for SubItem in Item['subreg']:
>
> + SubItem['value'] = self.GetBsfBitFields(SubItem, ValArray)
>
> + self.UpdateBsfBitUnit(Item)
>
> + return Error
>
> +
>
> + @staticmethod
>
> + def ExpandIncludeFiles(FilePath, CurDir=''):
>
> + if CurDir == '':
>
> + CurDir = os.path.dirname(FilePath)
>
> + FilePath = os.path.basename(FilePath)
>
> +
>
> + InputFilePath = os.path.join(CurDir, FilePath)
>
> + File = open(InputFilePath, "r")
>
> + Lines = File.readlines()
>
> + File.close()
>
> +
>
> + NewLines = []
>
> + for LineNum, Line in enumerate(Lines):
>
> + Match = re.match("^!include\\s*(.+)?$", Line)
>
> + if Match:
>
> + IncPath = Match.group(1)
>
> + TmpPath = os.path.join(CurDir, IncPath)
>
> + OrgPath = TmpPath
>
> + if not os.path.exists(TmpPath):
>
> + CurDir = os.path.join(os.path.dirname(
>
> + os.path.realpath(__file__)), "..", "..")
>
> + TmpPath = os.path.join(CurDir, IncPath)
>
> + if not os.path.exists(TmpPath):
>
> + raise Exception("ERROR: Cannot open include file '%s'." %
>
> + OrgPath)
>
> + else:
>
> + NewLines.append(('# Included from file: %s\n' %
>
> + IncPath, TmpPath, 0))
>
> + NewLines.append(('# %s\n' % ('=' * 80), TmpPath, 0))
>
> + NewLines.extend(CGenCfgData.ExpandIncludeFiles
>
> + (IncPath, CurDir))
>
> + else:
>
> + NewLines.append((Line, InputFilePath, LineNum))
>
> +
>
> + return NewLines
>
> +
>
> + def OverrideDefaultValue(self, DltFile):
>
> + Error = 0
>
> + DltLines = CGenCfgData.ExpandIncludeFiles(DltFile)
>
> +
>
> + PlatformId = None
>
> + for Line, FilePath, LineNum in DltLines:
>
> + Line = Line.strip()
>
> + if not Line or Line.startswith('#'):
>
> + continue
>
> + Match = re.match("\\s*(\\w+)\\.(\\w+)(\\.\\w+)?\\s*\\|\\s*(.+)",
>
> + Line)
>
> + if not Match:
>
> + raise Exception("Unrecognized line '%s' (File:'%s' Line:%d) !"
>
> + % (Line, FilePath, LineNum + 1))
>
> +
>
> + Found = False
>
> + InScope = False
>
> + for Idx, Item in enumerate(self._CfgItemList):
>
> + if not InScope:
>
> + if not (Item['embed'].endswith(':START') and
>
> + Item['embed'].startswith(Match.group(1))):
>
> + continue
>
> + InScope = True
>
> + if Item['cname'] == Match.group(2):
>
> + Found = True
>
> + break
>
> + if Item['embed'].endswith(':END') and \
>
> + Item['embed'].startswith(Match.group(1)):
>
> + break
>
> + Name = '%s.%s' % (Match.group(1), Match.group(2))
>
> + if not Found:
>
> + ErrItem = Match.group(2) if InScope else Match.group(1)
>
> + raise Exception("Invalid configuration '%s' in '%s' \
>
> +(File:'%s' Line:%d) !" % (ErrItem, Name, FilePath, LineNum + 1))
>
> +
>
> + ValueStr = Match.group(4).strip()
>
> + if Match.group(3) is not None:
>
> + # This is a subregion item
>
> + BitField = Match.group(3)[1:]
>
> + Found = False
>
> + if len(Item['subreg']) > 0:
>
> + for SubItem in Item['subreg']:
>
> + if SubItem['cname'] == '%s_%s' % \
>
> + (Item['cname'], BitField):
>
> + Found = True
>
> + break
>
> + if not Found:
>
> + raise Exception("Invalid configuration bit field \
>
> +'%s' in '%s.%s' (File:'%s' Line:%d) !" % (BitField, Name, BitField,
>
> + FilePath, LineNum + 1))
>
> +
>
> + try:
>
> + Value = int(ValueStr, 16) if ValueStr.startswith('0x') \
>
> + else int(ValueStr, 10)
>
> + except Exception:
>
> + raise Exception("Invalid value '%s' for bit field '%s.%s' \
>
> +(File:'%s' Line:%d) !" % (ValueStr, Name, BitField, FilePath, LineNum + 1))
>
> +
>
> + if Value >= 2 ** SubItem['bitlength']:
>
> + raise Exception("Invalid configuration bit field value \
>
> +'%s' for '%s.%s' (File:'%s' Line:%d) !" % (Value, Name, BitField,
>
> + FilePath, LineNum + 1))
>
> +
>
> + ValArray = self.ValueToByteArray(Item['value'], Item['length'])
>
> + self.UpdateBsfBitFields(SubItem, Value, ValArray)
>
> +
>
> + if Item['value'].startswith('{'):
>
> + Item['value'] = '{' + ', '.join('0x%02X' % i
>
> + for i in ValArray) + '}'
>
> + else:
>
> + BitsValue = ''.join('{0:08b}'.format(i)
>
> + for i in ValArray[::-1])
>
> + Item['value'] = '0x%X' % (int(BitsValue, 2))
>
> + else:
>
> + if Item['value'].startswith('{') and \
>
> + not ValueStr.startswith('{'):
>
> + raise Exception("Data array required for '%s' \
>
> +(File:'%s' Line:%d) !" % (Name, FilePath, LineNum + 1))
>
> + Item['value'] = ValueStr
>
> +
>
> + if Name == 'PLATFORMID_CFG_DATA.PlatformId':
>
> + PlatformId = ValueStr
>
> +
>
> + if (PlatformId is None) and (self.Mode != 'FSP'):
>
> + raise Exception("PLATFORMID_CFG_DATA.PlatformId is missing \
>
> +in file '%s' !" % (DltFile))
>
> +
>
> + return Error
>
> +
>
> + def ProcessMultilines(self, String, MaxCharLength):
>
> + Multilines = ''
>
> + StringLength = len(String)
>
> + CurrentStringStart = 0
>
> + StringOffset = 0
>
> + BreakLineDict = []
>
> + if len(String) <= MaxCharLength:
>
> + while (StringOffset < StringLength):
>
> + if StringOffset >= 1:
>
> + if String[StringOffset - 1] == '\\' and \
>
> + String[StringOffset] == 'n':
>
> + BreakLineDict.append(StringOffset + 1)
>
> + StringOffset += 1
>
> + if BreakLineDict != []:
>
> + for Each in BreakLineDict:
>
> + Multilines += " %s\n" % String[CurrentStringStart:Each].\
>
> + lstrip()
>
> + CurrentStringStart = Each
>
> + if StringLength - CurrentStringStart > 0:
>
> + Multilines += " %s\n" % String[CurrentStringStart:].\
>
> + lstrip()
>
> + else:
>
> + Multilines = " %s\n" % String
>
> + else:
>
> + NewLineStart = 0
>
> + NewLineCount = 0
>
> + FoundSpaceChar = False
>
> + while(StringOffset < StringLength):
>
> + if StringOffset >= 1:
>
> + if NewLineCount >= MaxCharLength - 1:
>
> + if String[StringOffset] == ' ' and \
>
> + StringLength - StringOffset > 10:
>
> + BreakLineDict.append(NewLineStart + NewLineCount)
>
> + NewLineStart = NewLineStart + NewLineCount
>
> + NewLineCount = 0
>
> + FoundSpaceChar = True
>
> + elif StringOffset == StringLength - 1 \
>
> + and FoundSpaceChar is False:
>
> + BreakLineDict.append(0)
>
> + if String[StringOffset - 1] == '\\' and \
>
> + String[StringOffset] == 'n':
>
> + BreakLineDict.append(StringOffset + 1)
>
> + NewLineStart = StringOffset + 1
>
> + NewLineCount = 0
>
> + StringOffset += 1
>
> + NewLineCount += 1
>
> + if BreakLineDict != []:
>
> + BreakLineDict.sort()
>
> + for Each in BreakLineDict:
>
> + if Each > 0:
>
> + Multilines += " %s\n" % String[
>
> + CurrentStringStart:Each].lstrip()
>
> + CurrentStringStart = Each
>
> + if StringLength - CurrentStringStart > 0:
>
> + Multilines += " %s\n" % String[CurrentStringStart:].\
>
> + lstrip()
>
> + return Multilines
>
> +
>
> + def CreateField(self, Item, Name, Length, Offset, Struct,
>
> + BsfName, Help, Option, BitsLength=None):
>
> + PosName = 28
>
> + NameLine = ''
>
> + HelpLine = ''
>
> + OptionLine = ''
>
> +
>
> + if Length == 0 and Name == 'Dummy':
>
> + return '\n'
>
> +
>
> + IsArray = False
>
> + if Length in [1, 2, 4, 8]:
>
> + Type = "UINT%d" % (Length * 8)
>
> + else:
>
> + IsArray = True
>
> + Type = "UINT8"
>
> +
>
> + if Item and Item['value'].startswith('{'):
>
> + Type = "UINT8"
>
> + IsArray = True
>
> +
>
> + if Struct != '':
>
> + Type = Struct
>
> + if Struct in ['UINT8', 'UINT16', 'UINT32', 'UINT64']:
>
> + IsArray = True
>
> + Unit = int(Type[4:]) // 8
>
> + Length = Length / Unit
>
> + else:
>
> + IsArray = False
>
> +
>
> + if IsArray:
>
> + Name = Name + '[%d]' % Length
>
> +
>
> + if len(Type) < PosName:
>
> + Space1 = PosName - len(Type)
>
> + else:
>
> + Space1 = 1
>
> +
>
> + if BsfName != '':
>
> + NameLine = " %s\n" % BsfName
>
> + else:
>
> + NameLine = "\n"
>
> +
>
> + if Help != '':
>
> + HelpLine = self.ProcessMultilines(Help, 80)
>
> +
>
> + if Option != '':
>
> + OptionLine = self.ProcessMultilines(Option, 80)
>
> +
>
> + if BitsLength is None:
>
> + BitsLength = ''
>
> + else:
>
> + BitsLength = ' : %d' % BitsLength
>
> +
>
> + return "\n/** %s%s%s**/\n %s%s%s%s;\n" % \
>
> + (NameLine, HelpLine, OptionLine, Type, ' ' * Space1, Name,
>
> + BitsLength)
>
> +
>
> + def SplitTextBody(self, TextBody):
>
> + Marker1 = '{ /* _COMMON_STRUCT_START_ */'
>
> + Marker2 = '; /* _COMMON_STRUCT_END_ */'
>
> + ComBody = []
>
> + TxtBody = []
>
> + IsCommon = False
>
> + for Line in TextBody:
>
> + if Line.strip().endswith(Marker1):
>
> + Line = Line.replace(Marker1[1:], '')
>
> + IsCommon = True
>
> + if Line.strip().endswith(Marker2):
>
> + Line = Line.replace(Marker2[1:], '')
>
> + if IsCommon:
>
> + ComBody.append(Line)
>
> + IsCommon = False
>
> + continue
>
> + if IsCommon:
>
> + ComBody.append(Line)
>
> + else:
>
> + TxtBody.append(Line)
>
> + return ComBody, TxtBody
>
> +
>
> + def GetStructArrayInfo(self, Input):
>
> + ArrayStr = Input.split('[')
>
> + Name = ArrayStr[0]
>
> + if len(ArrayStr) > 1:
>
> + NumStr = ''.join(c for c in ArrayStr[-1] if c.isdigit())
>
> + NumStr = '1000' if len(NumStr) == 0 else NumStr
>
> + ArrayNum = int(NumStr)
>
> + else:
>
> + ArrayNum = 0
>
> + return Name, ArrayNum
>
> +
>
> + def PostProcessBody(self, TextBody, IncludeEmbedOnly=True):
>
> + NewTextBody = []
>
> + OldTextBody = []
>
> + IncTextBody = []
>
> + StructBody = []
>
> + IncludeLine = False
>
> + EmbedFound = False
>
> + StructName = ''
>
> + ArrayVarName = ''
>
> + VariableName = ''
>
> + Count = 0
>
> + Level = 0
>
> + IsCommonStruct = False
>
> +
>
> + for Line in TextBody:
>
> + if Line.startswith('#define '):
>
> + IncTextBody.append(Line)
>
> + continue
>
> +
>
> + if not Line.startswith('/* EMBED_STRUCT:'):
>
> + Match = False
>
> + else:
>
> + Match = re.match("^/\\*\\sEMBED_STRUCT:([\\w\\[\\]\\*]+):\
>
> +([\\w\\[\\]\\*]+):(\\w+):(START|END)([\\s\\d]+)\\*/([\\s\\S]*)", Line)
>
> +
>
> + if Match:
>
> + ArrayMarker = Match.group(5)
>
> + if Match.group(4) == 'END':
>
> + Level -= 1
>
> + if Level == 0:
>
> + Line = Match.group(6)
>
> + else: # 'START'
>
> + Level += 1
>
> + if Level == 1:
>
> + Line = Match.group(6)
>
> + else:
>
> + EmbedFound = True
>
> + TagStr = Match.group(3)
>
> + if TagStr.startswith('TAG_'):
>
> + try:
>
> + TagVal = int(TagStr[4:], 16)
>
> + except Exception:
>
> + TagVal = -1
>
> + if (TagVal >= 0) and (TagVal < self._MinCfgTagId):
>
> + IsCommonStruct = True
>
> +
>
> + if Level == 1:
>
> + if IsCommonStruct:
>
> + Suffix = ' /* _COMMON_STRUCT_START_ */'
>
> + else:
>
> + Suffix = ''
>
> + StructBody = ['typedef struct {%s' % Suffix]
>
> + StructName = Match.group(1)
>
> + StructType = Match.group(2)
>
> + VariableName = Match.group(3)
>
> + MatchOffset = re.search('/\\*\\*\\sOffset\\s0x\
>
> +([a-fA-F0-9]+)', Line)
>
> + if MatchOffset:
>
> + Offset = int(MatchOffset.group(1), 16)
>
> + else:
>
> + Offset = None
>
> + IncludeLine = True
>
> +
>
> + ModifiedStructType = StructType.rstrip()
>
> + if ModifiedStructType.endswith(']'):
>
> + Idx = ModifiedStructType.index('[')
>
> + if ArrayMarker != ' ':
>
> + # Auto array size
>
> + OldTextBody.append('')
>
> + ArrayVarName = VariableName
>
> + if int(ArrayMarker) == 1000:
>
> + Count = 1
>
> + else:
>
> + Count = int(ArrayMarker) + 1000
>
> + else:
>
> + if Count < 1000:
>
> + Count += 1
>
> +
>
> + VariableTemp = ArrayVarName + '[%d]' % (
>
> + Count if Count < 1000 else Count - 1000)
>
> + OldTextBody[-1] = self.CreateField(
>
> + None, VariableTemp, 0, Offset,
>
> + ModifiedStructType[:Idx], '',
>
> + 'Structure Array', '')
>
> + else:
>
> + ArrayVarName = ''
>
> + OldTextBody.append(self.CreateField(
>
> + None, VariableName, 0, Offset,
>
> + ModifiedStructType, '', '', ''))
>
> +
>
> + if IncludeLine:
>
> + StructBody.append(Line)
>
> + else:
>
> + OldTextBody.append(Line)
>
> +
>
> + if Match and Match.group(4) == 'END':
>
> + if Level == 0:
>
> + if (StructType != Match.group(2)) or \
>
> + (VariableName != Match.group(3)):
>
> + print("Unmatched struct name '%s' and '%s' !" %
>
> + (StructName, Match.group(2)))
>
> + else:
>
> + if IsCommonStruct:
>
> + Suffix = ' /* _COMMON_STRUCT_END_ */'
>
> + else:
>
> + Suffix = ''
>
> + Line = '} %s;%s\n\n\n' % (StructName, Suffix)
>
> + StructBody.append(Line)
>
> + if (Line not in NewTextBody) and \
>
> + (Line not in OldTextBody):
>
> + NewTextBody.extend(StructBody)
>
> + IncludeLine = False
>
> + IsCommonStruct = False
>
> +
>
> + if not IncludeEmbedOnly:
>
> + NewTextBody.extend(OldTextBody)
>
> +
>
> + if EmbedFound:
>
> + NewTextBody = self.PostProcessBody(NewTextBody, False)
>
> +
>
> + NewTextBody = IncTextBody + NewTextBody
>
> + return NewTextBody
>
> +
>
> + def WriteHeaderFile(self, TxtBody, FileName, Type='h'):
>
> + FileNameDef = os.path.basename(FileName).replace('.', '_')
>
> + FileNameDef = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', FileNameDef)
>
> + FileNameDef = re.sub('([a-z0-9])([A-Z])', r'\1_\2',
>
> + FileNameDef).upper()
>
> +
>
> + Lines = []
>
> + Lines.append("%s\n" % GetCopyrightHeader(Type))
>
> + Lines.append("#ifndef __%s__\n" % FileNameDef)
>
> + Lines.append("#define __%s__\n\n" % FileNameDef)
>
> + if Type == 'h':
>
> + Lines.append("#pragma pack(1)\n\n")
>
> + Lines.extend(TxtBody)
>
> + if Type == 'h':
>
> + Lines.append("#pragma pack()\n\n")
>
> + Lines.append("#endif\n")
>
> +
>
> + # Don't rewrite if the contents are the same
>
> + Create = True
>
> + if os.path.exists(FileName):
>
> + HdrFile = open(FileName, "r")
>
> + OrgTxt = HdrFile.read()
>
> + HdrFile.close()
>
> +
>
> + NewTxt = ''.join(Lines)
>
> + if OrgTxt == NewTxt:
>
> + Create = False
>
> +
>
> + if Create:
>
> + HdrFile = open(FileName, "w")
>
> + HdrFile.write(''.join(Lines))
>
> + HdrFile.close()
>
> +
>
> + def CreateHeaderFile(self, HdrFileName, ComHdrFileName=''):
>
> + LastStruct = ''
>
> + SpaceIdx = 0
>
> + Offset = 0
>
> + FieldIdx = 0
>
> + LastFieldIdx = 0
>
> + ResvOffset = 0
>
> + ResvIdx = 0
>
> + TxtBody = []
>
> + LineBuffer = []
>
> + CfgTags = []
>
> + LastVisible = True
>
> +
>
> + TxtBody.append("typedef struct {\n")
>
> + for Item in self._CfgItemList:
>
> + # Search for CFGDATA tags
>
> + Embed = Item["embed"].upper()
>
> + if Embed.endswith(':START'):
>
> + Match = re.match(r'(\w+)_CFG_DATA:TAG_([0-9A-F]+):START',
>
> + Embed)
>
> + if Match:
>
> + TagName = Match.group(1)
>
> + TagId = int(Match.group(2), 16)
>
> + CfgTags.append((TagId, TagName))
>
> +
>
> + # Only process visible items
>
> + NextVisible = LastVisible
>
> +
>
> + if LastVisible and (Item['header'] == 'OFF'):
>
> + NextVisible = False
>
> + ResvOffset = Item['offset']
>
> + elif (not LastVisible) and Item['header'] == 'ON':
>
> + NextVisible = True
>
> + Name = "ReservedUpdSpace%d" % ResvIdx
>
> + ResvIdx = ResvIdx + 1
>
> + TxtBody.append(self.CreateField(
>
> + Item, Name, Item["offset"] - ResvOffset,
>
> + ResvOffset, '', '', '', ''))
>
> + FieldIdx += 1
>
> +
>
> + if Offset < Item["offset"]:
>
> + if LastVisible:
>
> + Name = "UnusedUpdSpace%d" % SpaceIdx
>
> + LineBuffer.append(self.CreateField
>
> + (Item, Name, Item["offset"] -
>
> + Offset, Offset, '', '', '', ''))
>
> + FieldIdx += 1
>
> + SpaceIdx = SpaceIdx + 1
>
> + Offset = Item["offset"]
>
> +
>
> + LastVisible = NextVisible
>
> +
>
> + Offset = Offset + Item["length"]
>
> + if LastVisible:
>
> + for Each in LineBuffer:
>
> + TxtBody.append(Each)
>
> + LineBuffer = []
>
> + Embed = Item["embed"].upper()
>
> + if Embed.endswith(':START') or Embed.endswith(':END'):
>
> + # EMBED_STRUCT: StructName : \
>
> + # ItemName : VariableName : START|END
>
> + Name, ArrayNum = self.GetStructArrayInfo(Item["struct"])
>
> + Remaining = Item["embed"]
>
> + if (LastFieldIdx + 1 == FieldIdx) and (LastStruct == Name):
>
> + ArrayMarker = ' '
>
> + else:
>
> + ArrayMarker = '%d' % ArrayNum
>
> + LastFieldIdx = FieldIdx
>
> + LastStruct = Name
>
> + Marker = '/* EMBED_STRUCT:%s:%s%s*/ ' % (Name, Remaining,
>
> + ArrayMarker)
>
> + # if Embed.endswith(':START') and Comment != '':
>
> + # Marker = '/* COMMENT:%s */ \n' % Item["comment"] + Marker
>
> + else:
>
> + if Embed == '':
>
> + Marker = ''
>
> + else:
>
> + self.Error = "Invalid embedded structure \
>
> +format '%s'!\n" % Item["embed"]
>
> + return 4
>
> +
>
> + # Generate bit fields for structure
>
> + if len(Item['subreg']) > 0 and Item["struct"]:
>
> + StructType = Item["struct"]
>
> + StructName, ArrayNum = self.GetStructArrayInfo(StructType)
>
> + if (LastFieldIdx + 1 == FieldIdx) and \
>
> + (LastStruct == Item["struct"]):
>
> + ArrayMarker = ' '
>
> + else:
>
> + ArrayMarker = '%d' % ArrayNum
>
> + TxtBody.append('/* EMBED_STRUCT:%s:%s:%s:START%s*/\n' %
>
> + (StructName, StructType, Item["cname"],
>
> + ArrayMarker))
>
> + for SubItem in Item['subreg']:
>
> + Name = SubItem["cname"]
>
> + if Name.startswith(Item["cname"]):
>
> + Name = Name[len(Item["cname"]) + 1:]
>
> + Line = self.CreateField(
>
> + SubItem, Name, SubItem["bitunit"],
>
> + SubItem["offset"], SubItem['struct'],
>
> + SubItem['name'], SubItem['help'],
>
> + SubItem['option'], SubItem['bitlength'])
>
> + TxtBody.append(Line)
>
> + TxtBody.append('/* EMBED_STRUCT:%s:%s:%s:END%s*/\n' %
>
> + (StructName, StructType, Item["cname"],
>
> + ArrayMarker))
>
> + LastFieldIdx = FieldIdx
>
> + LastStruct = Item["struct"]
>
> + FieldIdx += 1
>
> + else:
>
> + FieldIdx += 1
>
> + Line = Marker + self.CreateField(
>
> + Item, Item["cname"], Item["length"], Item["offset"],
>
> + Item['struct'], Item['name'], Item['help'],
>
> + Item['option'])
>
> + TxtBody.append(Line)
>
> +
>
> + TxtBody.append("}\n\n")
>
> +
>
> + # Handle the embedded data structure
>
> + TxtBody = self.PostProcessBody(TxtBody)
>
> + ComBody, TxtBody = self.SplitTextBody(TxtBody)
>
> +
>
> + # Prepare TAG defines
>
> + PltTagDefTxt = ['\n']
>
> + ComTagDefTxt = ['\n']
>
> + for TagId, TagName in sorted(CfgTags):
>
> + TagLine = '#define %-30s 0x%03X\n' % ('CDATA_%s_TAG' %
>
> + TagName, TagId)
>
> + if TagId < self._MinCfgTagId:
>
> + # TAG ID < 0x100, it is a generic TAG
>
> + ComTagDefTxt.append(TagLine)
>
> + else:
>
> + PltTagDefTxt.append(TagLine)
>
> + PltTagDefTxt.append('\n\n')
>
> + ComTagDefTxt.append('\n\n')
>
> +
>
> + # Write file back
>
> + self.WriteHeaderFile(PltTagDefTxt + TxtBody, HdrFileName)
>
> + if ComHdrFileName:
>
> + self.WriteHeaderFile(ComTagDefTxt + ComBody, ComHdrFileName)
>
> +
>
> + return 0
>
> +
>
> + def UpdateConfigItemValue(self, Item, ValueStr):
>
> + IsArray = True if Item['value'].startswith('{') else False
>
> + IsString = True if Item['value'].startswith("'") else False
>
> + Bytes = self.ValueToByteArray(ValueStr, Item['length'])
>
> + if IsString:
>
> + NewValue = "'%s'" % Bytes.decode("utf-8")
>
> + elif IsArray:
>
> + NewValue = Bytes2Str(Bytes)
>
> + else:
>
> + Fmt = '0x%X' if Item['value'].startswith('0x') else '%d'
>
> + NewValue = Fmt % Bytes2Val(Bytes)
>
> + Item['value'] = NewValue
>
> +
>
> + def LoadDefaultFromBinaryArray(self, BinDat, IgnoreFind=False):
>
> + FindOff = 0
>
> + StartOff = 0
>
> + for Item in self._CfgItemList:
>
> + if Item['length'] == 0:
>
> + continue
>
> + if not IgnoreFind and Item['find']:
>
> + FindBin = Item['find'].encode()
>
> + Offset = BinDat.find(FindBin)
>
> + if Offset >= 0:
>
> + TestOff = BinDat[Offset+len(FindBin):].find(FindBin)
>
> + if TestOff >= 0:
>
> + raise Exception('Multiple match found for "%s" !' %
>
> + Item['find'])
>
> + FindOff = Offset + len(FindBin)
>
> + StartOff = Item['offset']
>
> + else:
>
> + raise Exception('Could not find "%s" !' % Item['find'])
>
> + if Item['offset'] + Item['length'] > len(BinDat):
>
> + raise Exception('Mismatching format between DSC \
>
> +and BIN files !')
>
> + Offset = FindOff + (Item['offset'] - StartOff)
>
> + ValStr = Bytes2Str(BinDat[Offset: Offset + Item['length']])
>
> + self.UpdateConfigItemValue(Item, ValStr)
>
> +
>
> + self.UpdateDefaultValue()
>
> +
>
> + def PatchBinaryArray(self, BinDat):
>
> + FileOff = 0
>
> + Offset = 0
>
> + FindOff = 0
>
> +
>
> + PatchList = []
>
> + CfgBin = bytearray()
>
> + for Item in self._CfgItemList:
>
> + if Item['length'] == 0:
>
> + continue
>
> +
>
> + if Item['find']:
>
> + if len(CfgBin) > 0:
>
> + PatchList.append((FileOff, CfgBin))
>
> + FindBin = Item['find'].encode()
>
> + FileOff = BinDat.find(FindBin)
>
> + if FileOff < 0:
>
> + raise Exception('Could not find "%s" !' % Item['find'])
>
> + else:
>
> + TestOff = BinDat[FileOff+len(FindBin):].find(FindBin)
>
> + if TestOff >= 0:
>
> + raise Exception('Multiple match found for "%s" !' %
>
> + Item['find'])
>
> + FileOff += len(FindBin)
>
> + Offset = Item['offset']
>
> + FindOff = Offset
>
> + CfgBin = bytearray()
>
> +
>
> + if Item['offset'] > Offset:
>
> + Gap = Item['offset'] - Offset
>
> + CfgBin.extend(b'\x00' * Gap)
>
> +
>
> + if Item['type'] == 'Reserved' and Item['option'] == '$SKIP':
>
> + # keep old data
>
> + NewOff = FileOff + (Offset - FindOff)
>
> + FileData = bytearray(BinDat[NewOff: NewOff + Item['length']])
>
> + CfgBin.extend(FileData)
>
> + else:
>
> + CfgBin.extend(self.ValueToByteArray(Item['value'],
>
> + Item['length']))
>
> + Offset = Item['offset'] + Item['length']
>
> +
>
> + if len(CfgBin) > 0:
>
> + PatchList.append((FileOff, CfgBin))
>
> +
>
> + for FileOff, CfgBin in PatchList:
>
> + Length = len(CfgBin)
>
> + if FileOff + Length < len(BinDat):
>
> + BinDat[FileOff:FileOff+Length] = CfgBin[:]
>
> +
>
> + return BinDat
>
> +
>
> + def GenerateBinaryArray(self):
>
> + Offset = 0
>
> + BinDat = bytearray()
>
> + for Item in self._CfgItemList:
>
> + if Item['offset'] > Offset:
>
> + Gap = Item['offset'] - Offset
>
> + BinDat.extend(b'\x00' * Gap)
>
> + BinDat.extend(self.ValueToByteArray(Item['value'], Item['length']))
>
> + Offset = Item['offset'] + Item['length']
>
> + return BinDat
>
> +
>
> + def GenerateBinary(self, BinFileName):
>
> + BinFile = open(BinFileName, "wb")
>
> + BinFile.write(self.GenerateBinaryArray())
>
> + BinFile.close()
>
> + return 0
>
> +
>
> + def GenerateDataIncFile(self, DatIncFileName, BinFile=None):
>
> + # Put a prefix GUID before CFGDATA so that it can be located later on
>
> + Prefix = b'\xa7\xbd\x7f\x73\x20\x1e\x46\xd6\xbe\x8f\
>
> +x64\x12\x05\x8d\x0a\xa8'
>
> + if BinFile:
>
> + Fin = open(BinFile, 'rb')
>
> + BinDat = Prefix + bytearray(Fin.read())
>
> + Fin.close()
>
> + else:
>
> + BinDat = Prefix + self.GenerateBinaryArray()
>
> +
>
> + FileName = os.path.basename(DatIncFileName).upper()
>
> + FileName = FileName.replace('.', '_')
>
> +
>
> + TxtLines = []
>
> +
>
> + TxtLines.append("UINT8 mConfigDataBlob[%d] = {\n" % len(BinDat))
>
> + Count = 0
>
> + Line = [' ']
>
> + for Each in BinDat:
>
> + Line.append('0x%02X, ' % Each)
>
> + Count = Count + 1
>
> + if (Count & 0x0F) == 0:
>
> + Line.append('\n')
>
> + TxtLines.append(''.join(Line))
>
> + Line = [' ']
>
> + if len(Line) > 1:
>
> + TxtLines.append(''.join(Line) + '\n')
>
> +
>
> + TxtLines.append("};\n\n")
>
> +
>
> + self.WriteHeaderFile(TxtLines, DatIncFileName, 'inc')
>
> +
>
> + return 0
>
> +
>
> + def CheckCfgData(self):
>
> + # Check if CfgData contains any duplicated name
>
> + def AddItem(Item, ChkList):
>
> + Name = Item['cname']
>
> + if Name in ChkList:
>
> + return Item
>
> + if Name not in ['Dummy', 'Reserved', 'CfgHeader', 'CondValue']:
>
> + ChkList.append(Name)
>
> + return None
>
> +
>
> + Duplicate = None
>
> + ChkList = []
>
> + for Item in self._CfgItemList:
>
> + Duplicate = AddItem(Item, ChkList)
>
> + if not Duplicate:
>
> + for SubItem in Item['subreg']:
>
> + Duplicate = AddItem(SubItem, ChkList)
>
> + if Duplicate:
>
> + break
>
> + if Duplicate:
>
> + break
>
> + if Duplicate:
>
> + self.Error = "Duplicated CFGDATA '%s' found !\n" % \
>
> + Duplicate['cname']
>
> + return -1
>
> + return 0
>
> +
>
> + def PrintData(self):
>
> + for Item in self._CfgItemList:
>
> + if not Item['length']:
>
> + continue
>
> + print("%-10s @Offset:0x%04X Len:%3d Val:%s" %
>
> + (Item['cname'], Item['offset'], Item['length'],
>
> + Item['value']))
>
> + for SubItem in Item['subreg']:
>
> + print(" %-20s BitOff:0x%04X BitLen:%-3d Val:%s" %
>
> + (SubItem['cname'], SubItem['bitoffset'],
>
> + SubItem['bitlength'], SubItem['value']))
>
> +
>
> + def FormatArrayValue(self, Input, Length):
>
> + Dat = self.ValueToByteArray(Input, Length)
>
> + return ','.join('0x%02X' % Each for Each in Dat)
>
> +
>
> + def GetItemOptionList(self, Item):
>
> + TmpList = []
>
> + if Item['type'] == "Combo":
>
> + if not Item['option'] in self._BuidinOption:
>
> + OptList = Item['option'].split(',')
>
> + for Option in OptList:
>
> + Option = Option.strip()
>
> + try:
>
> + (OpVal, OpStr) = Option.split(':')
>
> + except Exception:
>
> + raise Exception("Invalide option format '%s' !" %
>
> + Option)
>
> + TmpList.append((OpVal, OpStr))
>
> + return TmpList
>
> +
>
> + def WriteBsfStruct(self, BsfFd, Item):
>
> + if Item['type'] == "None":
>
> + Space = "gPlatformFspPkgTokenSpaceGuid"
>
> + else:
>
> + Space = Item['space']
>
> + Line = " $%s_%s" % (Space, Item['cname'])
>
> + Match = re.match("\\s*(\\{.+\\})\\s*", Item['value'])
>
> + if Match:
>
> + DefaultValue = self.FormatArrayValue(Match.group(1).strip(),
>
> + Item['length'])
>
> + else:
>
> + DefaultValue = Item['value'].strip()
>
> + if 'bitlength' in Item:
>
> + if Item['bitlength']:
>
> + BsfFd.write(" %s%s%4d bits $_DEFAULT_ = %s\n" %
>
> + (Line, ' ' * (64 - len(Line)), Item['bitlength'],
>
> + DefaultValue))
>
> + else:
>
> + if Item['length']:
>
> + BsfFd.write(" %s%s%4d bytes $_DEFAULT_ = %s\n" %
>
> + (Line, ' ' * (64 - len(Line)), Item['length'],
>
> + DefaultValue))
>
> +
>
> + return self.GetItemOptionList(Item)
>
> +
>
> + def GetBsfOption(self, OptionName):
>
> + if OptionName in self._CfgOptsDict:
>
> + return self._CfgOptsDict[OptionName]
>
> + else:
>
> + return OptionName
>
> +
>
> + def WriteBsfOption(self, BsfFd, Item):
>
> + PcdName = Item['space'] + '_' + Item['cname']
>
> + WriteHelp = 0
>
> + BsfLines = []
>
> + if Item['type'] == "Combo":
>
> + if Item['option'] in self._BuidinOption:
>
> + Options = self._BuidinOption[Item['option']]
>
> + else:
>
> + Options = self.GetBsfOption(PcdName)
>
> + BsfLines.append(' %s $%s, "%s", &%s,\n' % (
>
> + Item['type'], PcdName, Item['name'], Options))
>
> + WriteHelp = 1
>
> + elif Item['type'].startswith("EditNum"):
>
> + Match = re.match("EditNum\\s*,\\s*(HEX|DEC)\\s*,\\s*\\(\
>
> +(\\d+|0x[0-9A-Fa-f]+)\\s*,\\s*(\\d+|0x[0-9A-Fa-f]+)\\)", Item['type'])
>
> + if Match:
>
> + BsfLines.append(' EditNum $%s, "%s", %s,\n' % (
>
> + PcdName, Item['name'], Match.group(1)))
>
> + WriteHelp = 2
>
> + elif Item['type'].startswith("EditText"):
>
> + BsfLines.append(' %s $%s, "%s",\n' % (Item['type'], PcdName,
>
> + Item['name']))
>
> + WriteHelp = 1
>
> + elif Item['type'] == "Table":
>
> + Columns = Item['option'].split(',')
>
> + if len(Columns) != 0:
>
> + BsfLines.append(' %s $%s "%s",' % (Item['type'], PcdName,
>
> + Item['name']))
>
> + for Col in Columns:
>
> + Fmt = Col.split(':')
>
> + if len(Fmt) != 3:
>
> + raise Exception("Column format '%s' is invalid !" %
>
> + Fmt)
>
> + try:
>
> + Dtype = int(Fmt[1].strip())
>
> + except Exception:
>
> + raise Exception("Column size '%s' is invalid !" %
>
> + Fmt[1])
>
> + BsfLines.append('\n Column "%s", %d bytes, %s' %
>
> + (Fmt[0].strip(), Dtype, Fmt[2].strip()))
>
> + BsfLines.append(',\n')
>
> + WriteHelp = 1
>
> +
>
> + if WriteHelp > 0:
>
> + HelpLines = Item['help'].split('\\n\\r')
>
> + FirstLine = True
>
> + for HelpLine in HelpLines:
>
> + if FirstLine:
>
> + FirstLine = False
>
> + BsfLines.append(' Help "%s"\n' % (HelpLine))
>
> + else:
>
> + BsfLines.append(' "%s"\n' % (HelpLine))
>
> + if WriteHelp == 2:
>
> + BsfLines.append(' "Valid range: %s ~ %s"\n' %
>
> + (Match.group(2), Match.group(3)))
>
> +
>
> + if len(Item['condition']) > 4:
>
> + CondList = Item['condition'].split(',')
>
> + Idx = 0
>
> + for Cond in CondList:
>
> + Cond = Cond.strip()
>
> + if Cond.startswith('#'):
>
> + BsfLines.insert(Idx, Cond + '\n')
>
> + Idx += 1
>
> + elif Cond.startswith('@#'):
>
> + BsfLines.append(Cond[1:] + '\n')
>
> +
>
> + for Line in BsfLines:
>
> + BsfFd.write(Line)
>
> +
>
> + def WriteBsfPages(self, PageTree, BsfFd):
>
> + BsfFd.write('\n')
>
> + Key = next(iter(PageTree))
>
> + for Page in PageTree[Key]:
>
> + PageName = next(iter(Page))
>
> + BsfFd.write('Page "%s"\n' % self._CfgPageDict[PageName])
>
> + if len(PageTree[Key]):
>
> + self.WriteBsfPages(Page, BsfFd)
>
> +
>
> + BsfItems = []
>
> + for Item in self._CfgItemList:
>
> + if Item['name'] != '':
>
> + if Item['page'] != PageName:
>
> + continue
>
> + if len(Item['subreg']) > 0:
>
> + for SubItem in Item['subreg']:
>
> + if SubItem['name'] != '':
>
> + BsfItems.append(SubItem)
>
> + else:
>
> + BsfItems.append(Item)
>
> +
>
> + BsfItems.sort(key=lambda x: x['order'])
>
> +
>
> + for Item in BsfItems:
>
> + self.WriteBsfOption(BsfFd, Item)
>
> + BsfFd.write("EndPage\n\n")
>
> +
>
> + def GenerateBsfFile(self, BsfFile):
>
> +
>
> + if BsfFile == '':
>
> + self.Error = "BSF output file '%s' is invalid" % BsfFile
>
> + return 1
>
> +
>
> + Error = 0
>
> + OptionDict = {}
>
> + BsfFd = open(BsfFile, "w")
>
> + BsfFd.write("%s\n" % GetCopyrightHeader('bsf'))
>
> + BsfFd.write("%s\n" % self._GlobalDataDef)
>
> + BsfFd.write("StructDef\n")
>
> + NextOffset = -1
>
> + for Item in self._CfgItemList:
>
> + if Item['find'] != '':
>
> + BsfFd.write('\n Find "%s"\n' % Item['find'])
>
> + NextOffset = Item['offset'] + Item['length']
>
> + if Item['name'] != '':
>
> + if NextOffset != Item['offset']:
>
> + BsfFd.write(" Skip %d bytes\n" %
>
> + (Item['offset'] - NextOffset))
>
> + if len(Item['subreg']) > 0:
>
> + NextOffset = Item['offset']
>
> + BitsOffset = NextOffset * 8
>
> + for SubItem in Item['subreg']:
>
> + BitsOffset += SubItem['bitlength']
>
> + if SubItem['name'] == '':
>
> + if 'bitlength' in SubItem:
>
> + BsfFd.write(" Skip %d bits\n" %
>
> + (SubItem['bitlength']))
>
> + else:
>
> + BsfFd.write(" Skip %d bytes\n" %
>
> + (SubItem['length']))
>
> + else:
>
> + Options = self.WriteBsfStruct(BsfFd, SubItem)
>
> + if len(Options) > 0:
>
> + OptionDict[SubItem
>
> + ['space']+'_'+SubItem
>
> + ['cname']] = Options
>
> +
>
> + NextBitsOffset = (Item['offset'] + Item['length']) * 8
>
> + if NextBitsOffset > BitsOffset:
>
> + BitsGap = NextBitsOffset - BitsOffset
>
> + BitsRemain = BitsGap % 8
>
> + if BitsRemain:
>
> + BsfFd.write(" Skip %d bits\n" % BitsRemain)
>
> + BitsGap -= BitsRemain
>
> + BytesRemain = BitsGap // 8
>
> + if BytesRemain:
>
> + BsfFd.write(" Skip %d bytes\n" %
>
> + BytesRemain)
>
> + NextOffset = Item['offset'] + Item['length']
>
> + else:
>
> + NextOffset = Item['offset'] + Item['length']
>
> + Options = self.WriteBsfStruct(BsfFd, Item)
>
> + if len(Options) > 0:
>
> + OptionDict[Item['space']+'_'+Item['cname']] = Options
>
> + BsfFd.write("\nEndStruct\n\n")
>
> +
>
> + BsfFd.write("%s" % self._BuidinOptionTxt)
>
> +
>
> + NameList = []
>
> + OptionList = []
>
> + for Each in sorted(OptionDict):
>
> + if OptionDict[Each] not in OptionList:
>
> + NameList.append(Each)
>
> + OptionList.append(OptionDict[Each])
>
> + BsfFd.write("List &%s\n" % Each)
>
> + for Item in OptionDict[Each]:
>
> + BsfFd.write(' Selection %s , "%s"\n' %
>
> + (self.EvaluateExpress(Item[0]), Item[1]))
>
> + BsfFd.write("EndList\n\n")
>
> + else:
>
> + # Item has idential options as other item
>
> + # Try to reuse the previous options instead
>
> + Idx = OptionList.index(OptionDict[Each])
>
> + self._CfgOptsDict[Each] = NameList[Idx]
>
> +
>
> + BsfFd.write("BeginInfoBlock\n")
>
> + BsfFd.write(' PPVer "%s"\n' % (self._CfgBlkDict['ver']))
>
> + BsfFd.write(' Description "%s"\n' % (self._CfgBlkDict['name']))
>
> + BsfFd.write("EndInfoBlock\n\n")
>
> +
>
> + self.WriteBsfPages(self._CfgPageTree, BsfFd)
>
> +
>
> + BsfFd.close()
>
> + return Error
>
> +
>
> + def WriteDeltaLine(self, OutLines, Name, ValStr, IsArray):
>
> + if IsArray:
>
> + Output = '%s | { %s }' % (Name, ValStr)
>
> + else:
>
> + Output = '%s | 0x%X' % (Name, Array2Val(ValStr))
>
> + OutLines.append(Output)
>
> +
>
> + def WriteDeltaFile(self, OutFile, PlatformId, OutLines):
>
> + DltFd = open(OutFile, "w")
>
> + DltFd.write("%s\n" % GetCopyrightHeader('dlt', True))
>
> + if PlatformId is not None:
>
> + DltFd.write('#\n')
>
> + DltFd.write('# Delta configuration values \
>
> +for platform ID 0x%04X\n' % PlatformId)
>
> + DltFd.write('#\n\n')
>
> + for Line in OutLines:
>
> + DltFd.write('%s\n' % Line)
>
> + DltFd.close()
>
> +
>
> + def GenerateDeltaFile(self, OutFile, AbsfFile):
>
> + # Parse ABSF Build in dict
>
> + if not os.path.exists(AbsfFile):
>
> + Lines = []
>
> + else:
>
> + with open(AbsfFile) as Fin:
>
> + Lines = Fin.readlines()
>
> +
>
> + AbsfBuiltValDict = {}
>
> + Process = False
>
> + for Line in Lines:
>
> + Line = Line.strip()
>
> + if Line.startswith('StructDef'):
>
> + Process = True
>
> + if Line.startswith('EndStruct'):
>
> + break
>
> + if not Process:
>
> + continue
>
> + Match = re.match('\\s*\\$gCfgData_(\\w+)\\s+\
>
> +(\\d+)\\s+(bits|bytes)\\s+\\$_AS_BUILT_\\s+=\\s+(.+)\\$', Line)
>
> + if Match:
>
> + if Match.group(1) not in AbsfBuiltValDict:
>
> + AbsfBuiltValDict[Match.group(1)] = Match.group(4).strip()
>
> + else:
>
> + raise Exception("Duplicated configuration \
>
> +name '%s' found !", Match.group(1))
>
> +
>
> + # Match config item in DSC
>
> + PlatformId = None
>
> + OutLines = []
>
> + TagName = ''
>
> + Level = 0
>
> + for Item in self._CfgItemList:
>
> + Name = None
>
> + if Level == 0 and Item['embed'].endswith(':START'):
>
> + TagName = Item['embed'].split(':')[0]
>
> + Level += 1
>
> + if Item['cname'] in AbsfBuiltValDict:
>
> + ValStr = AbsfBuiltValDict[Item['cname']]
>
> + Name = '%s.%s' % (TagName, Item['cname'])
>
> + if not Item['subreg'] and Item['value'].startswith('{'):
>
> + Value = Array2Val(Item['value'])
>
> + IsArray = True
>
> + else:
>
> + Value = int(Item['value'], 16)
>
> + IsArray = False
>
> + AbsfVal = Array2Val(ValStr)
>
> + if AbsfVal != Value:
>
> + if 'PLATFORMID_CFG_DATA.PlatformId' == Name:
>
> + PlatformId = AbsfVal
>
> + self.WriteDeltaLine(OutLines, Name, ValStr, IsArray)
>
> + else:
>
> + if 'PLATFORMID_CFG_DATA.PlatformId' == Name:
>
> + raise Exception("'PlatformId' has the \
>
> +same value as DSC default !")
>
> +
>
> + if Item['subreg']:
>
> + for SubItem in Item['subreg']:
>
> + if SubItem['cname'] in AbsfBuiltValDict:
>
> + ValStr = AbsfBuiltValDict[SubItem['cname']]
>
> + if Array2Val(ValStr) == int(SubItem['value'], 16):
>
> + continue
>
> + Name = '%s.%s.%s' % (TagName, Item['cname'],
>
> + SubItem['cname'])
>
> + self.WriteDeltaLine(OutLines, Name, ValStr, False)
>
> +
>
> + if Item['embed'].endswith(':END'):
>
> + Level -= 1
>
> +
>
> + if PlatformId is None and Lines:
>
> + raise Exception("'PlatformId' configuration \
>
> +is missing in ABSF file!")
>
> + else:
>
> + PlatformId = 0
>
> +
>
> + self.WriteDeltaFile(OutFile, PlatformId, Lines)
>
> +
>
> + return 0
>
> +
>
> + def GenerateDscFile(self, OutFile):
>
> + DscFd = open(OutFile, "w")
>
> + for Line in self._DscLines:
>
> + DscFd.write(Line + '\n')
>
> + DscFd.close()
>
> + return 0
>
> +
>
> +
>
> +def Usage():
>
> + print('\n'.join([
>
> + "GenCfgData Version 0.01",
>
> + "Usage:",
>
> + " GenCfgData GENINC BinFile \
>
> +IncOutFile [-D Macros]",
>
> + " GenCfgData GENPKL DscFile \
>
> +PklOutFile [-D Macros]",
>
> + " GenCfgData GENINC DscFile[;DltFile] \
>
> +IncOutFile [-D Macros]",
>
> + " GenCfgData GENBIN DscFile[;DltFile] \
>
> +BinOutFile [-D Macros]",
>
> + " GenCfgData GENBSF DscFile[;DltFile] \
>
> +BsfOutFile [-D Macros]",
>
> + " GenCfgData GENDLT DscFile[;AbsfFile] \
>
> +DltOutFile [-D Macros]",
>
> + " GenCfgData GENDSC DscFile \
>
> +DscOutFile [-D Macros]",
>
> + " GenCfgData GENHDR DscFile[;DltFile] \
>
> +HdrOutFile[;ComHdrOutFile] [-D Macros]"
>
> + ]))
>
> +
>
> +
>
> +def Main():
>
> + #
>
> + # Parse the options and args
>
> + #
>
> + argc = len(sys.argv)
>
> + if argc < 4:
>
> + Usage()
>
> + return 1
>
> +
>
> + GenCfgData = CGenCfgData()
>
> + Command = sys.argv[1].upper()
>
> + OutFile = sys.argv[3]
>
> +
>
> + if argc > 5 and GenCfgData.ParseMacros(sys.argv[4:]) != 0:
>
> + raise Exception("ERROR: Macro parsing failed !")
>
> +
>
> + FileList = sys.argv[2].split(';')
>
> + if len(FileList) == 2:
>
> + DscFile = FileList[0]
>
> + DltFile = FileList[1]
>
> + elif len(FileList) == 1:
>
> + DscFile = FileList[0]
>
> + DltFile = ''
>
> + else:
>
> + raise Exception("ERROR: Invalid parameter '%s' !" % sys.argv[2])
>
> +
>
> + if Command == "GENDLT" and DscFile.endswith('.dlt'):
>
> + # It needs to expand an existing DLT file
>
> + DltFile = DscFile
>
> + Lines = CGenCfgData.ExpandIncludeFiles(DltFile)
>
> + OutTxt = ''.join([x[0] for x in Lines])
>
> + OutFile = open(OutFile, "w")
>
> + OutFile.write(OutTxt)
>
> + OutFile.close()
>
> + return 0
>
> +
>
> + if not os.path.exists(DscFile):
>
> + raise Exception("ERROR: Cannot open file '%s' !" % DscFile)
>
> +
>
> + CfgBinFile = ''
>
> + if DltFile:
>
> + if not os.path.exists(DltFile):
>
> + raise Exception("ERROR: Cannot open file '%s' !" % DltFile)
>
> + if Command == "GENDLT":
>
> + CfgBinFile = DltFile
>
> + DltFile = ''
>
> +
>
> + BinFile = ''
>
> + if (DscFile.lower().endswith('.bin')) and (Command == "GENINC"):
>
> + # It is binary file
>
> + BinFile = DscFile
>
> + DscFile = ''
>
> +
>
> + if BinFile:
>
> + if GenCfgData.GenerateDataIncFile(OutFile, BinFile) != 0:
>
> + raise Exception(GenCfgData.Error)
>
> + return 0
>
> +
>
> + if DscFile.lower().endswith('.pkl'):
>
> + with open(DscFile, "rb") as PklFile:
>
> + GenCfgData.__dict__ = marshal.load(PklFile)
>
> + else:
>
> + if GenCfgData.ParseDscFile(DscFile) != 0:
>
> + raise Exception(GenCfgData.Error)
>
> +
>
> + # if GenCfgData.CheckCfgData() != 0:
>
> + # raise Exception(GenCfgData.Error)
>
> +
>
> + if GenCfgData.CreateVarDict() != 0:
>
> + raise Exception(GenCfgData.Error)
>
> +
>
> + if Command == 'GENPKL':
>
> + with open(OutFile, "wb") as PklFile:
>
> + marshal.dump(GenCfgData.__dict__, PklFile)
>
> + return 0
>
> +
>
> + if DltFile and Command in ['GENHDR', 'GENBIN', 'GENINC', 'GENBSF']:
>
> + if GenCfgData.OverrideDefaultValue(DltFile) != 0:
>
> + raise Exception(GenCfgData.Error)
>
> +
>
> + if GenCfgData.UpdateDefaultValue() != 0:
>
> + raise Exception(GenCfgData.Error)
>
> +
>
> + # GenCfgData.PrintData ()
>
> +
>
> + if sys.argv[1] == "GENBIN":
>
> + if GenCfgData.GenerateBinary(OutFile) != 0:
>
> + raise Exception(GenCfgData.Error)
>
> +
>
> + elif sys.argv[1] == "GENHDR":
>
> + OutFiles = OutFile.split(';')
>
> + BrdOutFile = OutFiles[0].strip()
>
> + if len(OutFiles) > 1:
>
> + ComOutFile = OutFiles[1].strip()
>
> + else:
>
> + ComOutFile = ''
>
> + if GenCfgData.CreateHeaderFile(BrdOutFile, ComOutFile) != 0:
>
> + raise Exception(GenCfgData.Error)
>
> +
>
> + elif sys.argv[1] == "GENBSF":
>
> + if GenCfgData.GenerateBsfFile(OutFile) != 0:
>
> + raise Exception(GenCfgData.Error)
>
> +
>
> + elif sys.argv[1] == "GENINC":
>
> + if GenCfgData.GenerateDataIncFile(OutFile) != 0:
>
> + raise Exception(GenCfgData.Error)
>
> +
>
> + elif sys.argv[1] == "GENDLT":
>
> + if GenCfgData.GenerateDeltaFile(OutFile, CfgBinFile) != 0:
>
> + raise Exception(GenCfgData.Error)
>
> +
>
> + elif sys.argv[1] == "GENDSC":
>
> + if GenCfgData.GenerateDscFile(OutFile) != 0:
>
> + raise Exception(GenCfgData.Error)
>
> +
>
> + else:
>
> + raise Exception("Unsuported command '%s' !" % Command)
>
> +
>
> + return 0
>
> +
>
> +
>
> +if __name__ == '__main__':
>
> + sys.exit(Main())
>
> diff --git a/IntelFsp2Pkg/Tools/UserManuals/ConfigEditorUserManual.md
> b/IntelFsp2Pkg/Tools/UserManuals/ConfigEditorUserManual.md
> new file mode 100644
> index 0000000000..08a815133c
> --- /dev/null
> +++ b/IntelFsp2Pkg/Tools/UserManuals/ConfigEditorUserManual.md
> @@ -0,0 +1,45 @@
> +#Name
>
> +**ConfigEditor.py** is a python script with a GUI interface that can support
> changing configuration settings directly from the interface without having to
> modify the source.
>
> +
>
> +#Description
>
> +This is a GUI interface that can be used by users who would like to change
> configuration settings directly from the interface without having to modify the
> SBL source.
>
> +This tool depends on Python GUI tool kit Tkinter. It runs on both Windows and
> Linux.
>
> +The user needs to load the YAML file along with DLT file for a specific board
> into the ConfigEditor, change the desired configuration values. Finally, generate
> a new configuration delta file or a config binary blob for the newly changed
> values to take effect. These will be the inputs to the merge tool or the stitch tool
> so that new config changes can be merged and stitched into the final
> configuration blob.
>
> +
>
> +
>
> +It supports the following options:
>
> +
>
> +## 1. Open Config YAML file
>
> +This option loads the YAML file for a FSP UPD into the ConfigEditor to change
> the desired configuration values.
>
> +
>
> +#####Example:
>
> +```
>
> +
>
> +
>
> +
>
> +```
>
> +
>
> +## 2. Open Config BSF file
>
> +This option loads the BSF file for a FSP UPD into the ConfigEditor to change the
> desired configuration values. It works as a similar fashion with Binary
> Configuration Tool (BCT)
>
> +
>
> +## 3. Show Binary Information
>
> +This option loads configuration data from FD file and displays it in the
> ConfigEditor.
>
> +
>
> +## 4. Save Config Data to Binary
>
> +This option generates a config binary blob for the newly changed values to take
> effect.
>
> +
>
> +## 5. Load Config Data from Binary
>
> +This option reloads changed configuration from BIN file into the ConfigEditor.
>
> +
>
> +## 6. Load Config Changes from Delta File
>
> +This option loads the changed configuration values from Delta file into the
> ConfigEditor.
>
> +
>
> +## 7. Save Config Changes to Delta File
>
> +This option generates a new configuration delta file for the newly changed
> values to take effect.
>
> +
>
> +## 8. Save Full Config Data to Delta File
>
> +This option saves all the changed configuration values into a Delta file.
>
> +
>
> +## Running Configuration Editor:
>
> +
>
> + **python ConfigEditor.py**
>
> --
> 2.28.0.windows.1
-=-=-=-=-=-=-=-=-=-=-=-
Groups.io Links: You receive all messages sent to this group.
View/Reply Online (#77244): https://edk2.groups.io/g/devel/message/77244
Mute This Topic: https://groups.io/mt/83862375/1813853
Group Owner: devel+owner at edk2.groups.io
Unsubscribe: https://edk2.groups.io/g/devel/unsub [edk2-devel-archive at redhat.com]
-=-=-=-=-=-=-=-=-=-=-=-
More information about the edk2-devel-archive
mailing list