Add IntelFsp2Pkg and IntelFsp2WrapperPkg.

[mirror_edk2.git] / IntelFsp2Pkg / Tools / SplitFspBin.py

## @ FspTool.py\r
#\r
# Copyright (c) 2015 - 2016, Intel Corporation. All rights reserved.<BR>\r
# This program and the accompanying materials are licensed and made available under\r
# the terms and conditions of the BSD License that accompanies this distribution.\r
# The full text of the license may be found at\r
# http://opensource.org/licenses/bsd-license.php.\r
#\r
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
#\r
##\r
\r
import os\r
import sys\r
import uuid\r
import copy\r
import struct\r
import argparse\r
from   ctypes import *\r
\r
"""\r
This utility supports some operations for Intel FSP image.\r
It supports:\r
    - Split a FSP 2.0 compatibale image into individual FSP-T/M/S/C\r
        and generate the mapping header file.\r
"""\r
\r
class c_uint24(Structure):\r
    """Little-Endian 24-bit Unsigned Integer"""\r
    _pack_   = 1\r
    _fields_ = [\r
        ('Data', (c_uint8 * 3))\r
        ]\r
\r
    def __init__(self, val=0):\r
        self.set_value(val)\r
\r
    def __str__(self, indent=0):\r
        return '0x%.6x' % self.value\r
\r
    def get_value(self):\r
        return (\r
            (self.Data[0]      ) +\r
            (self.Data[1] <<  8) +\r
            (self.Data[2] << 16)\r
            )\r
\r
    def set_value(self, val):\r
        self.Data[0] = (val      ) & 0xff\r
        self.Data[1] = (val >>  8) & 0xff\r
        self.Data[2] = (val >> 16) & 0xff\r
\r
    value = property(get_value, set_value)\r
\r
class EFI_FIRMWARE_VOLUME_HEADER(Structure):\r
    _fields_ = [\r
        ('ZeroVector',                 ARRAY(c_uint8, 16)),\r
        ('FileSystemGuid',             ARRAY(c_char, 16)),\r
        ('FvLength',                   c_uint64),\r
        ('Signature',                  c_uint32),\r
        ('Attributes',                 c_uint32),\r
        ('HeaderLength',               c_uint16),\r
        ('Checksum',                   c_uint16),\r
        ('ExtHeaderOffset',            c_uint16),\r
        ('Reserved',                   c_uint8),\r
        ('Revision',                   c_uint8)\r
        ]\r
\r
class EFI_FIRMWARE_VOLUME_EXT_HEADER(Structure):\r
    _fields_ = [\r
        ('FvName',                     ARRAY(c_char, 16)),\r
        ('ExtHeaderSize',              c_uint32)\r
        ]\r
\r
class EFI_FFS_INTEGRITY_CHECK(Structure):\r
    _fields_ = [\r
        ('Header',                     c_uint8),\r
        ('File',                       c_uint8)\r
        ]\r
\r
class EFI_FFS_FILE_HEADER(Structure):\r
    _fields_ = [\r
        ('Name',                       ARRAY(c_char, 16)),\r
        ('IntegrityCheck',             EFI_FFS_INTEGRITY_CHECK),\r
        ('Type',                       c_uint8),\r
        ('Attributes',                 c_uint8),\r
        ('Size',                       c_uint24),\r
        ('State',                      c_uint8)\r
        ]\r
\r
class EFI_COMMON_SECTION_HEADER(Structure):\r
    _fields_ = [\r
        ('Size',                       c_uint24),\r
        ('Type',                       c_uint8)\r
        ]\r
\r
class FSP_INFORMATION_HEADER(Structure):\r
     _fields_ = [\r
        ('Signature',                   c_uint32),\r
        ('HeaderLength',                c_uint32),\r
        ('Reserved1',                   ARRAY(c_uint8, 3)),\r
        ('HeaderRevision',              c_uint8),\r
        ('ImageRevision',               c_uint32),\r
        ('ImageId',                     c_uint64),\r
        ('ImageSize',                   c_uint32),\r
        ('ImageBase',                   c_uint32),\r
        ('ImageAttribute',              c_uint32),\r
        ('CfgRegionOffset',             c_uint32),\r
        ('CfgRegionSize',               c_uint32),\r
        ('ApiEntryNum',                 c_uint32),\r
        ('NemInitEntry',                c_uint32),\r
        ('FspInitEntry',                c_uint32),\r
        ('NotifyPhaseEntry',            c_uint32),\r
        ('FspMemoryInitEntry',          c_uint32),\r
        ('TempRamExitEntry',            c_uint32),\r
        ('FspSiliconInitEntry',         c_uint32)\r
    ]\r
\r
class FspFv:\r
    HeaderFile = """/*\r
 *\r
 * Automatically generated file; DO NOT EDIT.\r
 * FSP mapping file\r
 *\r
 */\r
"""\r
    FspNameDict = {\r
        "0" : "-C.Fv",\r
        "1" : "-T.Fv",\r
        "2" : "-M.Fv",\r
        "3" : "-S.Fv",\r
    }\r
\r
    def __init__(self, FvBin):\r
        self.FspFv  = {}\r
        self.FvList = []\r
        self.FspBin = FvBin\r
        hfsp = open (self.FspBin, 'r+b')\r
        self.FspDat = bytearray(hfsp.read())\r
        hfsp.close()\r
\r
    def OutputStruct (self, obj, indent = 0):\r
        max_key_len = 20\r
        pstr = ('  ' * indent + '{0:<%d} = {1}\n') % max_key_len\r
        if indent:\r
            s = ''\r
        else:\r
            s = ('  ' * indent + '<%s>:\n') % obj.__class__.__name__\r
        for field in obj._fields_:\r
            key = field[0]\r
            val = getattr(obj, key)\r
            rep = ''\r
            \r
            if not isinstance(val, c_uint24) and isinstance(val, Structure):                \r
                s += pstr.format(key, val.__class__.__name__)\r
                s += self.OutputStruct (val, indent + 1)                \r
            else:\r
                if type(val) in (int, long):\r
                    rep = hex(val)\r
                elif isinstance(val, str) and (len(val) == 16):\r
                    rep = str(uuid.UUID(bytes = val))\r
                elif isinstance(val, c_uint24):                    \r
                    rep = hex(val.get_value())\r
                elif 'c_ubyte_Array' in str(type(val)):                \r
                    rep = str(list(bytearray(val)))\r
                else:\r
                    rep = str(val)\r
                s += pstr.format(key, rep)\r
        return s\r
    \r
    def PrintFv (self):\r
        print ("FV LIST:")\r
        idx = 0\r
        for (fvh, fvhe, offset) in self.FvList:            \r
            guid = uuid.UUID(bytes = fvhe.FvName)\r
            print ("FV%d FV GUID:%s  Offset:0x%08X  Length:0x%08X" % (idx, str(guid), offset, fvh.FvLength))\r
            idx = idx + 1\r
        print ("\nFSP LIST:")\r
        for fsp in self.FspFv:\r
            print "FSP%s contains FV%s" % (fsp, str(self.FspFv[fsp][1]))\r
            print "\nFSP%s Info Header:" % fsp\r
            fih = self.FspFv[fsp][0]            \r
\r
    def AlaignPtr (self, offset, alignment = 8):\r
        return (offset + alignment - 1) & ~(alignment - 1)\r
\r
    def GetFspInfoHdr (self, fvh, fvhe, fvoffset):\r
        if fvhe:\r
            offset = fvh.ExtHeaderOffset + fvhe.ExtHeaderSize\r
        else:\r
            offset = fvh.HeaderLength\r
        offset = self.AlaignPtr(offset)\r
\r
        # Now it should be 1st FFS\r
        ffs = EFI_FFS_FILE_HEADER.from_buffer (self.FspDat, offset)        \r
        offset += sizeof(ffs)\r
        offset = self.AlaignPtr(offset)\r
\r
        # Now it should be 1st Section\r
        sec = EFI_COMMON_SECTION_HEADER.from_buffer (self.FspDat, offset)\r
        offset += sizeof(sec)\r
\r
        # Now it should be FSP_INFO_HEADER\r
        offset += fvoffset\r
        fih = FSP_INFORMATION_HEADER.from_buffer (self.FspDat, offset)\r
        if 'FSPH' != bytearray.fromhex('%08X' % fih.Signature)[::-1]:\r
            return None\r
\r
        return fih\r
\r
    def GetFvHdr (self, offset):\r
        fvh = EFI_FIRMWARE_VOLUME_HEADER.from_buffer (self.FspDat, offset)\r
        if '_FVH' != bytearray.fromhex('%08X' % fvh.Signature)[::-1]:\r
            return None, None\r
        if fvh.ExtHeaderOffset > 0:\r
            offset += fvh.ExtHeaderOffset\r
            fvhe = EFI_FIRMWARE_VOLUME_EXT_HEADER.from_buffer (self.FspDat, offset)\r
        else:\r
            fvhe = None\r
        return fvh, fvhe\r
\r
    def GetFvData(self, idx):\r
        (fvh, fvhe, offset) = self.FvList[idx]\r
        return self.FspDat[offset:offset+fvh.FvLength]\r
\r
    def CheckFsp (self):\r
        if len(self.FspFv) == 0:\r
            return\r
\r
        fih = None\r
        for fv in self.FspFv:\r
            if not fih:\r
                fih = self.FspFv[fv][0]\r
            else:\r
                newfih = self.FspFv[fv][0]\r
                if (newfih.ImageId != fih.ImageId) or (newfih.ImageRevision != fih.ImageRevision):\r
                    raise Exception("Inconsistent FSP ImageId or ImageRevision detected !")\r
        return\r
\r
    def WriteFsp(self, dir, name):\r
        if not name:\r
            name = self.FspBin\r
        fspname, ext = os.path.splitext(os.path.basename(name))\r
        for fv in self.FspFv:\r
            filename = os.path.join(dir, fspname + fv + ext)\r
            hfsp = open(filename, 'w+b')\r
            for fvidx in self.FspFv[fv][1]:\r
                hfsp.write (self.GetFvData(fvidx))\r
            hfsp.close()\r
\r
    def WriteMap(self, dir, hfile):\r
        if not hfile:\r
            hfile = os.path.splitext(os.path.basename(self.FspBin))[0] + '.h'\r
        fspname, ext = os.path.splitext(os.path.basename(hfile))\r
        filename = os.path.join(dir, fspname + ext)\r
        hfsp   = open(filename, 'w')\r
        hfsp.write ('%s\n\n' % self.HeaderFile)\r
\r
        firstfv = True\r
        for fsp in self.FspFv:\r
            fih = self.FspFv[fsp][0]\r
            fvs = self.FspFv[fsp][1]\r
            if firstfv:\r
                IdStr = str(bytearray.fromhex('%016X' % fih.ImageId)[::-1])\r
                hfsp.write("#define  FSP_IMAGE_ID    0x%016X        /* '%s' */\n" % (fih.ImageId, IdStr))\r
                hfsp.write("#define  FSP_IMAGE_REV   0x%08X \n\n" % fih.ImageRevision)\r
                firstfv = False\r
            hfsp.write ('#define  FSP%s_BASE      0x%08X\n'   % (fsp, fih.ImageBase))\r
            hfsp.write ('#define  FSP%s_OFFSET    0x%08X\n'   % (fsp, self.FvList[fvs[0]][-1]))\r
            hfsp.write ('#define  FSP%s_LENGTH    0x%08X\n\n' % (fsp, fih.ImageSize))\r
        hfsp.close()\r
\r
    def ParseFsp (self):\r
        self.FspFv  = {}\r
        flen = 0\r
        for (fvh, fvhe, offset) in self.FvList:\r
            fih = self.GetFspInfoHdr (fvh, fvhe, offset)\r
            if fih:\r
                if flen != 0:\r
                    raise Exception("Incorrect FV size in image !")\r
                ftype = str((fih.ImageAttribute >> 28) & 0xF)\r
                if ftype not in self.FspNameDict:\r
                    raise Exception("Unknown Attribute in image !")\r
                fname = self.FspNameDict[str(ftype)]\r
                if fname in self.FspFv:\r
                    raise Exception("Multiple '%s' in image !" % fname)\r
                self.FspFv[fname] = (copy.deepcopy(fih), [])\r
                flen = fih.ImageSize\r
            if flen > 0:\r
                flen = flen - fvh.FvLength\r
                if flen < 0:\r
                    raise Exception("Incorrect FV size in image !")\r
                self.FspFv[fname][1].append(self.FvList.index((fvh, fvhe, offset)))\r
\r
    def AddFv(self, offset):\r
        fvh, fvhe = self.GetFvHdr (offset)\r
        if fvh is None:\r
            raise Exception('FV signature is not valid !')\r
        fvitem = (copy.deepcopy(fvh), copy.deepcopy(fvhe), offset)\r
        self.FvList.append(fvitem)\r
        return fvh.FvLength\r
\r
    def ParseFv(self):\r
        offset = 0\r
        while (offset < len(self.FspDat)):\r
            fv_len  = self.AddFv (offset)\r
            offset += fv_len\r
\r
def GenFspHdr (fspfile, outdir, hfile, show):\r
    fsp_fv = FspFv(fspfile)\r
    fsp_fv.ParseFv()\r
    fsp_fv.ParseFsp()\r
    fsp_fv.CheckFsp()\r
    if show:\r
        fsp_fv.PrintFv()\r
    fsp_fv.WriteMap(outdir, hfile)\r
\r
def SplitFspBin (fspfile, outdir, nametemplate, show):\r
    fsp_fv = FspFv(fspfile)\r
    fsp_fv.ParseFv()\r
    fsp_fv.ParseFsp()\r
    if show:\r
        fsp_fv.PrintFv()\r
    fsp_fv.WriteFsp(outdir, nametemplate)\r
\r
def main ():\r
    parser = argparse.ArgumentParser()\r
    subparsers    = parser.add_subparsers(title='commands')\r
\r
    parser_split  = subparsers.add_parser('split',  help='split a FSP into multiple components')\r
    parser_split.set_defaults(which='split')\r
    parser_split.add_argument('-f',  '--fspbin' , dest='FspBinary', type=str, help='FSP binary file path', required = True)\r
    parser_split.add_argument('-o',  '--outdir' , dest='OutputDir', type=str, help='Output directory path',   default = '.')\r
    parser_split.add_argument('-n',  '--nametpl', dest='NameTemplate', type=str, help='Output name template', default = '')\r
    parser_split.add_argument('-p', action='store_true', help='Print FSP FV information', default = False)\r
\r
    parser_genhdr = subparsers.add_parser('genhdr',  help='generate a header file for FSP binary')\r
    parser_genhdr.set_defaults(which='genhdr')\r
    parser_genhdr.add_argument('-f',  '--fspbin' , dest='FspBinary', type=str, help='FSP binary file path', required = True)\r
    parser_genhdr.add_argument('-o',  '--outdir' , dest='OutputDir', type=str, help='Output directory path',   default = '.')\r
    parser_genhdr.add_argument('-n',  '--hfile',   dest='HFileName', type=str, help='Output header file name', default = '')\r
    parser_genhdr.add_argument('-p', action='store_true', help='Print FSP FV information', default = False)\r
\r
    args = parser.parse_args()\r
    if args.which in ['split', 'genhdr']:\r
        if not os.path.exists(args.FspBinary):\r
            raise Exception ("Could not locate FSP binary file '%s' !" % args.FspBinary)\r
        if not os.path.exists(args.OutputDir):\r
            raise Exception ("Invalid output directory '%s' !" % args.OutputDir)\r
\r
    if args.which == 'split':\r
        SplitFspBin (args.FspBinary, args.OutputDir, args.NameTemplate, args.p)\r
    elif args.which == 'genhdr':\r
        GenFspHdr   (args.FspBinary, args.OutputDir, args.HFileName, args.p)\r
    else:\r
        pass\r
\r
    print 'Done!'\r
    return 0\r
\r
if __name__ == '__main__':\r
    sys.exit(main())\r