process_pbkey(processed_xml)
if (args.bypass):
allowable_fw_list = []
else:
allowable_fw_list = generate_allowable_fw_list(processed_xml)
allowable_fw_header = generate_allowable_fw_header(allowable_fw_list)
if (args.bypass):
keys_list = []
else:
keys_list = generate_pbkey_list()
keys_header = generate_pbkey_header(keys_list)
platform_id = get_platform_id(processed_xml)
platform_header = generate_platform_info(platform_id)
pfm_header_instance = manifest_common.generate_manifest_header(pfm_id, key_size, manifest_types.PFM)
pfm_header_instance.length = ctypes.sizeof(pfm_header_instance) + keys_header.length + \
allowable_fw_header.length + pfm_header_instance.sig_length + platform_header.header.length
pfm = generate_pfm(pfm_header_instance, allowable_fw_header, allowable_fw_list, keys_header,
keys_list, platform_header)
manifest_common.write_manifest(sign, pfm, key, output,
pfm_header_instance.length - pfm_header_instance.sig_length,
pfm_header_instance.sig_length)
print("Completed PFM generation: {0}".format(output))
processed_xml, sign, key_size, key, key_type, hash_type, pcd_id, output, xml_version, empty = \
manifest_common.load_xmls (args.config, 1, manifest_types.PCD)
hash_engine = manifest_common.get_hash_engine(hash_type)
processed_xml = list(processed_xml.items())[0][1]
num_components = 0
num_ports = 0
pcd_len = 0
elements_list = []
toc_list = []
hash_list = []
manifest_header = manifest_common.generate_manifest_header(
pcd_id, key_size, manifest_types.PCD, hash_type, key_type, xml_version)
manifest_header_len = ctypes.sizeof(manifest_header)
pcd_len += manifest_header_len
platform_id, platform_id_toc_entry, platform_id_hash = manifest_common.generate_platform_id_buf(
processed_xml, hash_engine)
pcd_len += ctypes.sizeof(platform_id)
elements_list.append(platform_id)
toc_list.append(platform_id_toc_entry)
hash_list.append(platform_id_hash)
if not empty:
if "power_controller" in processed_xml:
power_controller, power_controller_toc_entry, power_controller_hash = \
generate_power_controller (processed_xml["power_controller"], hash_engine)
parser.add_argument('config',
nargs='?',
default=default_config,
help='Path to configuration file')
parser.add_argument('--bypass',
action='store_true',
help='Create a bypass mode PFM')
args = parser.parse_args()
platform_header = None
allowable_fw_list = None
pfm = None
processed_xml, sign, key_size, key, key_type, hash_type, pfm_id, output, xml_version, empty = \
manifest_common.load_xmls (args.config, None, manifest_types.PFM)
pfm_header_instance = manifest_common.generate_manifest_header(
pfm_id, key_size, manifest_types.PFM, hash_type, key_type, xml_version)
platform_id = manifest_common.get_platform_id(processed_xml)
if xml_version == manifest_types.VERSION_2:
flash_device = None
if (args.bypass):
allowable_fw_list = {}
fw_types = {}
fw_flags = {}
else:
allowable_fw_list, fw_types, fw_flags, unused_byte = generate_allowable_fw_list_v2(
processed_xml, xml_version)
flash_device = pfm_v2_flash_device_element(unused_byte, len(fw_types),
0)
if "components" in processed_xml:
components, num_components = generate_components_buf(
processed_xml["components"])
components_header = generate_components_header(ctypes.sizeof(components),
num_components)
rot_header = generate_rot_header(processed_xml["rot"],
processed_xml["rot"]["interface"],
processed_xml["cpld"],
processed_xml["policy"], num_ports)
platform_id_header = generate_platform_id_header(
len(processed_xml["platform_id"]))
header = generate_pcd_header (rot_header.length + components_header.length + \
platform_id_header.length)
manifest_header = manifest_common.generate_manifest_header(
id, key_size, manifest_types.PCD)
manifest_header.length = ctypes.sizeof (manifest_header) + header.length + \
manifest_header.sig_length
pcd = generate_pcd(manifest_header, header, rot_header, ports,
components_header, components, platform_id_header,
processed_xml["platform_id"])
manifest_common.write_manifest (sign, pcd, key, output, manifest_header.length - \
manifest_header.sig_length, manifest_header.sig_length)
print("Completed PCD generation: {0}".format(output))