soc/x86/intel_ish/utils/build_ish_firmware.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-"

# Copyright 2019 The Chromium OS Authors. All rights reserved.
# SPDX-License-Identifier: Apache-2.0

"""Script to pack EC binary with manifest header.

Package ecos main FW binary (kernel) and AON task binary into final EC binary
image with a manifest header, ISH shim loader will parse this header and load
each binaries into right memory location.
"""

import argparse
import struct
import os

MANIFEST_ENTRY_SIZE = 0x80
HEADER_SIZE = 0x1000
PAGE_SIZE = 0x1000

def parseargs():
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument("-k", "--kernel",
                        help="EC kernel binary to pack, \
                        usually ec.RW.bin or ec.RW.flat.",
                        required=True)
    parser.add_argument("-a", "--aon",
                        help="EC aontask binary to pack, \
                        usually ish_aontask.bin.",
                        required=False)
    parser.add_argument("-o", "--output",
                        help="Output flash binary file")

    return parser.parse_args()

def gen_manifest(ext_id, comp_app_name, code_offset, module_size):
    """Returns a binary blob that represents a manifest entry"""
    m = bytearray(MANIFEST_ENTRY_SIZE)

    # 4 bytes of ASCII encode ID (little endian)
    struct.pack_into('<4s', m, 0, ext_id)
    # 8 bytes of ASCII encode ID (little endian)
    struct.pack_into('<8s', m, 32, comp_app_name)
    # 4 bytes of code offset (little endian)
    struct.pack_into('<I', m, 96, code_offset)
    # 2 bytes of module in page size increments (little endian)
    struct.pack_into('<H', m, 100, module_size)

    return m

def roundup_page(size):
    """Returns roundup-ed page size from size of bytes"""
    return int(size / PAGE_SIZE) + (size % PAGE_SIZE > 0)

def main():
    args = parseargs()
    print("    Packing EC image file for ISH")

    with open(args.output, 'wb') as f:
        kernel_size = os.path.getsize(args.kernel)

        if args.aon is not None:
            aon_size = os.path.getsize(args.aon)

        print("      kernel binary size:", kernel_size)
        kern_rdup_pg_size = roundup_page(kernel_size)
        # Add manifest for main ISH binary
        f.write(gen_manifest(b'ISHM', b'ISH_KERN', HEADER_SIZE, kern_rdup_pg_size))

        if args.aon is not None:
            print("      AON binary size:   ", aon_size)
            aon_rdup_pg_size = roundup_page(aon_size)
            # Add manifest for aontask binary
            f.write(gen_manifest(b'ISHM', b'AON_TASK',
                                 (HEADER_SIZE + kern_rdup_pg_size * PAGE_SIZE -
                                  MANIFEST_ENTRY_SIZE), aon_rdup_pg_size))

        # Add manifest that signals end of manifests
        f.write(gen_manifest(b'ISHE', b'', 0, 0))

        # Pad the remaining HEADER with 0s
        if args.aon is not None:
            f.write(b'\x00' * (HEADER_SIZE - (MANIFEST_ENTRY_SIZE * 3)))
        else:
            f.write(b'\x00' * (HEADER_SIZE - (MANIFEST_ENTRY_SIZE * 2)))

        # Append original kernel image
        with open(args.kernel, 'rb') as in_file:
            f.write(in_file.read())
            # Filling padings due to size round up as pages
            f.write(b'\x00' * (kern_rdup_pg_size * PAGE_SIZE - kernel_size))

            if args.aon is not None:
                # Append original aon image
                with open(args.aon, 'rb') as in_file:
                    f.write(in_file.read())
                # Filling padings due to size round up as pages
                f.write(b'\x00' * (aon_rdup_pg_size * PAGE_SIZE - aon_size))

if __name__ == '__main__':
    main()