[mirror_edk2.git] / BaseTools / Source / Python / GenFds / Region.py

## @file\r
# process FD Region generation\r
#\r
#  Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>\r
#\r
#  This program and the accompanying materials\r
#  are licensed and made available under the terms and conditions of the BSD License\r
#  which accompanies this distribution.  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 Modules\r
#\r
from struct import *\r
from GenFdsGlobalVariable import GenFdsGlobalVariable\r
from io import BytesIO\r
import string\r
from CommonDataClass.FdfClass import RegionClassObject\r
import Common.LongFilePathOs as os\r
from stat import *\r
from Common import EdkLogger\r
from Common.BuildToolError import *\r
from Common.LongFilePathSupport import OpenLongFilePath as open\r
from Common.MultipleWorkspace import MultipleWorkspace as mws\r
from Common.DataType import BINARY_FILE_TYPE_FV\r
\r
## generate Region\r
#\r
#\r
class Region(RegionClassObject):\r
\r
    ## The constructor\r
    #\r
    #   @param  self        The object pointer\r
    #\r
    def __init__(self):\r
        RegionClassObject.__init__(self)\r
\r
\r
    ## PadBuffer()\r
    #\r
    #   Add padding bytes to the Buffer\r
    #\r
    #   @param Buffer         The buffer the generated region data will be put\r
    #                         in\r
    #   @param ErasePolarity  Flash erase polarity\r
    #   @param Size           Number of padding bytes requested\r
    #\r
\r
    def PadBuffer(self, Buffer, ErasePolarity, Size):\r
        if Size > 0:\r
            if (ErasePolarity == '1') :\r
                PadByte = pack('B', 0xFF)\r
            else:\r
                PadByte = pack('B', 0)\r
            PadData = ''.join(PadByte for i in xrange(0, Size))\r
            Buffer.write(PadData)\r
\r
    ## AddToBuffer()\r
    #\r
    #   Add region data to the Buffer\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  Buffer      The buffer generated region data will be put\r
    #   @param  BaseAddress base address of region\r
    #   @param  BlockSize   block size of region\r
    #   @param  BlockNum    How many blocks in region\r
    #   @param  ErasePolarity      Flash erase polarity\r
    #   @param  VtfDict     VTF objects\r
    #   @param  MacroDict   macro value pair\r
    #   @retval string      Generated FV file path\r
    #\r
\r
    def AddToBuffer(self, Buffer, BaseAddress, BlockSizeList, ErasePolarity, ImageBinDict, vtfDict=None, MacroDict={}, Flag=False):\r
        Size = self.Size\r
        if not Flag:\r
            GenFdsGlobalVariable.InfLogger('\nGenerate Region at Offset 0x%X' % self.Offset)\r
            GenFdsGlobalVariable.InfLogger("   Region Size = 0x%X" % Size)\r
        GenFdsGlobalVariable.SharpCounter = 0\r
        if Flag and (self.RegionType != BINARY_FILE_TYPE_FV):\r
            return\r
\r
        if self.RegionType == BINARY_FILE_TYPE_FV:\r
            #\r
            # Get Fv from FvDict\r
            #\r
            self.FvAddress = int(BaseAddress, 16) + self.Offset\r
            FvBaseAddress = '0x%X' % self.FvAddress\r
            FvOffset = 0\r
            for RegionData in self.RegionDataList:\r
                FileName = None\r
                if RegionData.endswith(".fv"):\r
                    RegionData = GenFdsGlobalVariable.MacroExtend(RegionData, MacroDict)\r
                    if not Flag:\r
                        GenFdsGlobalVariable.InfLogger('   Region FV File Name = .fv : %s' % RegionData)\r
                    if RegionData[1] != ':' :\r
                        RegionData = mws.join (GenFdsGlobalVariable.WorkSpaceDir, RegionData)\r
                    if not os.path.exists(RegionData):\r
                        EdkLogger.error("GenFds", FILE_NOT_FOUND, ExtraData=RegionData)\r
\r
                    FileName = RegionData\r
                elif RegionData.upper() + 'fv' in ImageBinDict:\r
                    if not Flag:\r
                        GenFdsGlobalVariable.InfLogger('   Region Name = FV')\r
                    FileName = ImageBinDict[RegionData.upper() + 'fv']\r
                else:\r
                    #\r
                    # Generate FvImage.\r
                    #\r
                    FvObj = None\r
                    if RegionData.upper() in GenFdsGlobalVariable.FdfParser.Profile.FvDict:\r
                        FvObj = GenFdsGlobalVariable.FdfParser.Profile.FvDict[RegionData.upper()]\r
\r
                    if FvObj is not None :\r
                        if not Flag:\r
                            GenFdsGlobalVariable.InfLogger('   Region Name = FV')\r
                        #\r
                        # Call GenFv tool\r
                        #\r
                        self.BlockInfoOfRegion(BlockSizeList, FvObj)\r
                        self.FvAddress = self.FvAddress + FvOffset\r
                        FvAlignValue = self.GetFvAlignValue(FvObj.FvAlignment)\r
                        if self.FvAddress % FvAlignValue != 0:\r
                            EdkLogger.error("GenFds", GENFDS_ERROR,\r
                                            "FV (%s) is NOT %s Aligned!" % (FvObj.UiFvName, FvObj.FvAlignment))\r
                        FvBuffer = BytesIO('')\r
                        FvBaseAddress = '0x%X' % self.FvAddress\r
                        BlockSize = None\r
                        BlockNum = None\r
                        FvObj.AddToBuffer(FvBuffer, FvBaseAddress, BlockSize, BlockNum, ErasePolarity, vtfDict, Flag=Flag)\r
                        if Flag:\r
                            continue\r
\r
                        FvBufferLen = len(FvBuffer.getvalue())\r
                        if FvBufferLen > Size:\r
                            FvBuffer.close()\r
                            EdkLogger.error("GenFds", GENFDS_ERROR,\r
                                            "Size of FV (%s) is larger than Region Size 0x%X specified." % (RegionData, Size))\r
                        #\r
                        # Put the generated image into FD buffer.\r
                        #\r
                        Buffer.write(FvBuffer.getvalue())\r
                        FvBuffer.close()\r
                        FvOffset = FvOffset + FvBufferLen\r
                        Size = Size - FvBufferLen\r
                        continue\r
                    else:\r
                        EdkLogger.error("GenFds", GENFDS_ERROR, "FV (%s) is NOT described in FDF file!" % (RegionData))\r
                #\r
                # Add the exist Fv image into FD buffer\r
                #\r
                if not Flag:\r
                    if FileName is not None:\r
                        FileLength = os.stat(FileName)[ST_SIZE]\r
                        if FileLength > Size:\r
                            EdkLogger.error("GenFds", GENFDS_ERROR,\r
                                            "Size of FV File (%s) is larger than Region Size 0x%X specified." \\r
                                            % (RegionData, Size))\r
                        BinFile = open(FileName, 'rb')\r
                        Buffer.write(BinFile.read())\r
                        BinFile.close()\r
                        Size = Size - FileLength\r
            #\r
            # Pad the left buffer\r
            #\r
            if not Flag:\r
                self.PadBuffer(Buffer, ErasePolarity, Size)\r
\r
        if self.RegionType == 'CAPSULE':\r
            #\r
            # Get Capsule from Capsule Dict\r
            #\r
            for RegionData in self.RegionDataList:\r
                if RegionData.endswith(".cap"):\r
                    RegionData = GenFdsGlobalVariable.MacroExtend(RegionData, MacroDict)\r
                    GenFdsGlobalVariable.InfLogger('   Region CAPSULE Image Name = .cap : %s' % RegionData)\r
                    if RegionData[1] != ':' :\r
                        RegionData = mws.join (GenFdsGlobalVariable.WorkSpaceDir, RegionData)\r
                    if not os.path.exists(RegionData):\r
                        EdkLogger.error("GenFds", FILE_NOT_FOUND, ExtraData=RegionData)\r
\r
                    FileName = RegionData\r
                elif RegionData.upper() + 'cap' in ImageBinDict:\r
                    GenFdsGlobalVariable.InfLogger('   Region Name = CAPSULE')\r
                    FileName = ImageBinDict[RegionData.upper() + 'cap']\r
                else:\r
                    #\r
                    # Generate Capsule image and Put it into FD buffer\r
                    #\r
                    CapsuleObj = None\r
                    if RegionData.upper() in GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict:\r
                        CapsuleObj = GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict[RegionData.upper()]\r
\r
                    if CapsuleObj is not None :\r
                        CapsuleObj.CapsuleName = RegionData.upper()\r
                        GenFdsGlobalVariable.InfLogger('   Region Name = CAPSULE')\r
                        #\r
                        # Call GenFv tool to generate Capsule Image\r
                        #\r
                        FileName = CapsuleObj.GenCapsule()\r
                        CapsuleObj.CapsuleName = None\r
                    else:\r
                        EdkLogger.error("GenFds", GENFDS_ERROR, "Capsule (%s) is NOT described in FDF file!" % (RegionData))\r
\r
                #\r
                # Add the capsule image into FD buffer\r
                #\r
                FileLength = os.stat(FileName)[ST_SIZE]\r
                if FileLength > Size:\r
                    EdkLogger.error("GenFds", GENFDS_ERROR,\r
                                    "Size 0x%X of Capsule File (%s) is larger than Region Size 0x%X specified." \\r
                                    % (FileLength, RegionData, Size))\r
                BinFile = open(FileName, 'rb')\r
                Buffer.write(BinFile.read())\r
                BinFile.close()\r
                Size = Size - FileLength\r
            #\r
            # Pad the left buffer\r
            #\r
            self.PadBuffer(Buffer, ErasePolarity, Size)\r
\r
        if self.RegionType in ('FILE', 'INF'):\r
            for RegionData in self.RegionDataList:\r
                if self.RegionType == 'INF':\r
                    RegionData.__InfParse__(None)\r
                    if len(RegionData.BinFileList) != 1:\r
                        EdkLogger.error('GenFds', GENFDS_ERROR, 'INF in FD region can only contain one binary: %s' % RegionData)\r
                    File = RegionData.BinFileList[0]\r
                    RegionData = RegionData.PatchEfiFile(File.Path, File.Type)\r
                else:\r
                    RegionData = GenFdsGlobalVariable.MacroExtend(RegionData, MacroDict)\r
                    if RegionData[1] != ':' :\r
                        RegionData = mws.join (GenFdsGlobalVariable.WorkSpaceDir, RegionData)\r
                    if not os.path.exists(RegionData):\r
                        EdkLogger.error("GenFds", FILE_NOT_FOUND, ExtraData=RegionData)\r
                #\r
                # Add the file image into FD buffer\r
                #\r
                FileLength = os.stat(RegionData)[ST_SIZE]\r
                if FileLength > Size:\r
                    EdkLogger.error("GenFds", GENFDS_ERROR,\r
                                    "Size of File (%s) is larger than Region Size 0x%X specified." \\r
                                    % (RegionData, Size))\r
                GenFdsGlobalVariable.InfLogger('   Region File Name = %s' % RegionData)\r
                BinFile = open(RegionData, 'rb')\r
                Buffer.write(BinFile.read())\r
                BinFile.close()\r
                Size = Size - FileLength\r
            #\r
            # Pad the left buffer\r
            #\r
            self.PadBuffer(Buffer, ErasePolarity, Size)\r
\r
        if self.RegionType == 'DATA' :\r
            GenFdsGlobalVariable.InfLogger('   Region Name = DATA')\r
            DataSize = 0\r
            for RegionData in self.RegionDataList:\r
                Data = RegionData.split(',')\r
                DataSize = DataSize + len(Data)\r
                if DataSize > Size:\r
                   EdkLogger.error("GenFds", GENFDS_ERROR, "Size of DATA is larger than Region Size ")\r
                else:\r
                    for item in Data :\r
                        Buffer.write(pack('B', int(item, 16)))\r
                Size = Size - DataSize\r
            #\r
            # Pad the left buffer\r
            #\r
            self.PadBuffer(Buffer, ErasePolarity, Size)\r
\r
        if self.RegionType is None:\r
            GenFdsGlobalVariable.InfLogger('   Region Name = None')\r
            self.PadBuffer(Buffer, ErasePolarity, Size)\r
\r
    def GetFvAlignValue(self, Str):\r
        AlignValue = 1\r
        Granu = 1\r
        Str = Str.strip().upper()\r
        if Str.endswith('K'):\r
            Granu = 1024\r
            Str = Str[:-1]\r
        elif Str.endswith('M'):\r
            Granu = 1024 * 1024\r
            Str = Str[:-1]\r
        elif Str.endswith('G'):\r
            Granu = 1024 * 1024 * 1024\r
            Str = Str[:-1]\r
        else:\r
            pass\r
\r
        AlignValue = int(Str) * Granu\r
        return AlignValue\r
\r
    ## BlockSizeOfRegion()\r
    #\r
    #   @param  BlockSizeList        List of block information\r
    #   @param  FvObj                The object for FV\r
    #\r
    def BlockInfoOfRegion(self, BlockSizeList, FvObj):\r
        Start = 0\r
        End = 0\r
        RemindingSize = self.Size\r
        ExpectedList = []\r
        for (BlockSize, BlockNum, pcd) in BlockSizeList:\r
            End = Start + BlockSize * BlockNum\r
            # region not started yet\r
            if self.Offset >= End:\r
                Start = End\r
                continue\r
            # region located in current blocks\r
            else:\r
                # region ended within current blocks\r
                if self.Offset + self.Size <= End:\r
                    ExpectedList.append((BlockSize, (RemindingSize + BlockSize - 1) / BlockSize))\r
                    break\r
                # region not ended yet\r
                else:\r
                    # region not started in middle of current blocks\r
                    if self.Offset <= Start:\r
                        UsedBlockNum = BlockNum\r
                    # region started in middle of current blocks\r
                    else:\r
                        UsedBlockNum = (End - self.Offset) / BlockSize\r
                    Start = End\r
                    ExpectedList.append((BlockSize, UsedBlockNum))\r
                    RemindingSize -= BlockSize * UsedBlockNum\r
\r
        if FvObj.BlockSizeList == []:\r
            FvObj.BlockSizeList = ExpectedList\r
        else:\r
            # first check whether FvObj.BlockSizeList items have only "BlockSize" or "NumBlocks",\r
            # if so, use ExpectedList\r
            for Item in FvObj.BlockSizeList:\r
                if Item[0] is None or Item[1] is None:\r
                    FvObj.BlockSizeList = ExpectedList\r
                    break\r
            # make sure region size is no smaller than the summed block size in FV\r
            Sum = 0\r
            for Item in FvObj.BlockSizeList:\r
                Sum += Item[0] * Item[1]\r
            if self.Size < Sum:\r
                EdkLogger.error("GenFds", GENFDS_ERROR, "Total Size of FV %s 0x%x is larger than Region Size 0x%x "\r
                                % (FvObj.UiFvName, Sum, self.Size))\r
            # check whether the BlockStatements in FV section is appropriate\r
            ExpectedListData = ''\r
            for Item in ExpectedList:\r
                ExpectedListData += "BlockSize = 0x%x\n\tNumBlocks = 0x%x\n\t" % Item\r
            Index = 0\r
            for Item in FvObj.BlockSizeList:\r
                if Item[0] != ExpectedList[Index][0]:\r
                    EdkLogger.error("GenFds", GENFDS_ERROR, "BlockStatements of FV %s are not align with FD's, suggested FV BlockStatement"\r
                                    % FvObj.UiFvName, ExtraData=ExpectedListData)\r
                elif Item[1] != ExpectedList[Index][1]:\r
                    if (Item[1] < ExpectedList[Index][1]) and (Index == len(FvObj.BlockSizeList) - 1):\r
                        break;\r
                    else:\r
                        EdkLogger.error("GenFds", GENFDS_ERROR, "BlockStatements of FV %s are not align with FD's, suggested FV BlockStatement"\r
                                        % FvObj.UiFvName, ExtraData=ExpectedListData)\r
                else:\r
                    Index += 1\r
\r
\r
\r
Commit	Line	Data
30fdf114 LG	1	## @file\r
	2	# process FD Region generation\r
	3	#\r
9eb87141	4	# Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>\r
30fdf114	5	#\r
40d841f6	6	# This program and the accompanying materials\r
30fdf114 LG	7	# are licensed and made available under the terms and conditions of the BSD License\r
	8	# which accompanies this distribution. The full text of the license may be found at\r
	9	# http://opensource.org/licenses/bsd-license.php\r
	10	#\r
	11	# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
	12	# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
	13	#\r
	14	\r
	15	##\r
	16	# Import Modules\r
	17	#\r
	18	from struct import *\r
	19	from GenFdsGlobalVariable import GenFdsGlobalVariable\r
86379ac4	20	from io import BytesIO\r
bd907fb6	21	import string\r
30fdf114	22	from CommonDataClass.FdfClass import RegionClassObject\r
1be2ed90	23	import Common.LongFilePathOs as os\r
fd171542	24	from stat import *\r
30fdf114 LG	25	from Common import EdkLogger\r
30fdf114 LG	26	from Common.BuildToolError import *\r
1be2ed90	27	from Common.LongFilePathSupport import OpenLongFilePath as open\r
05cc51ad	28	from Common.MultipleWorkspace import MultipleWorkspace as mws\r
91fa33ee	29	from Common.DataType import BINARY_FILE_TYPE_FV\r
30fdf114	30	\r
30fdf114 LG	31	## generate Region\r
	32	#\r
	33	#\r
	34	class Region(RegionClassObject):\r
	35	\r
	36	## The constructor\r
	37	#\r
	38	# @param self The object pointer\r
	39	#\r
	40	def __init__(self):\r
	41	RegionClassObject.__init__(self)\r
	42	\r
	43	\r
5588565f LE	44	## PadBuffer()\r
	45	#\r
	46	# Add padding bytes to the Buffer\r
	47	#\r
	48	# @param Buffer The buffer the generated region data will be put\r
	49	# in\r
	50	# @param ErasePolarity Flash erase polarity\r
	51	# @param Size Number of padding bytes requested\r
	52	#\r
	53	\r
	54	def PadBuffer(self, Buffer, ErasePolarity, Size):\r
	55	if Size > 0:\r
	56	if (ErasePolarity == '1') :\r
bd907fb6	57	PadByte = pack('B', 0xFF)\r
5588565f	58	else:\r
bd907fb6	59	PadByte = pack('B', 0)\r
a78b518b	60	PadData = ''.join(PadByte for i in xrange(0, Size))\r
bd907fb6	61	Buffer.write(PadData)\r
5588565f	62	\r
30fdf114 LG	63	## AddToBuffer()\r
	64	#\r
	65	# Add region data to the Buffer\r
	66	#\r
	67	# @param self The object pointer\r
	68	# @param Buffer The buffer generated region data will be put\r
	69	# @param BaseAddress base address of region\r
	70	# @param BlockSize block size of region\r
	71	# @param BlockNum How many blocks in region\r
	72	# @param ErasePolarity Flash erase polarity\r
	73	# @param VtfDict VTF objects\r
	74	# @param MacroDict macro value pair\r
	75	# @retval string Generated FV file path\r
	76	#\r
	77	\r
37de70b7	78	def AddToBuffer(self, Buffer, BaseAddress, BlockSizeList, ErasePolarity, ImageBinDict, vtfDict=None, MacroDict={}, Flag=False):\r
30fdf114	79	Size = self.Size\r
37de70b7 YZ	80	if not Flag:\r
	81	GenFdsGlobalVariable.InfLogger('\nGenerate Region at Offset 0x%X' % self.Offset)\r
	82	GenFdsGlobalVariable.InfLogger(" Region Size = 0x%X" % Size)\r
30fdf114	83	GenFdsGlobalVariable.SharpCounter = 0\r
91fa33ee	84	if Flag and (self.RegionType != BINARY_FILE_TYPE_FV):\r
37de70b7	85	return\r
30fdf114	86	\r
91fa33ee	87	if self.RegionType == BINARY_FILE_TYPE_FV:\r
30fdf114 LG	88	#\r
	89	# Get Fv from FvDict\r
	90	#\r
30fdf114	91	self.FvAddress = int(BaseAddress, 16) + self.Offset\r
47fea6af YZ	92	FvBaseAddress = '0x%X' % self.FvAddress\r
47fea6af YZ	93	FvOffset = 0\r
30fdf114	94	for RegionData in self.RegionDataList:\r
fd171542	95	FileName = None\r
30fdf114 LG	96	if RegionData.endswith(".fv"):\r
30fdf114 LG	97	RegionData = GenFdsGlobalVariable.MacroExtend(RegionData, MacroDict)\r
37de70b7 YZ	98	if not Flag:\r
37de70b7 YZ	99	GenFdsGlobalVariable.InfLogger(' Region FV File Name = .fv : %s' % RegionData)\r
30fdf114	100	if RegionData[1] != ':' :\r
534ef50c	101	RegionData = mws.join (GenFdsGlobalVariable.WorkSpaceDir, RegionData)\r
30fdf114 LG	102	if not os.path.exists(RegionData):\r
	103	EdkLogger.error("GenFds", FILE_NOT_FOUND, ExtraData=RegionData)\r
	104	\r
fd171542	105	FileName = RegionData\r
9eb87141	106	elif RegionData.upper() + 'fv' in ImageBinDict:\r
37de70b7 YZ	107	if not Flag:\r
37de70b7 YZ	108	GenFdsGlobalVariable.InfLogger(' Region Name = FV')\r
fd171542	109	FileName = ImageBinDict[RegionData.upper() + 'fv']\r
	110	else:\r
	111	#\r
	112	# Generate FvImage.\r
	113	#\r
	114	FvObj = None\r
9eb87141 CJ	115	if RegionData.upper() in GenFdsGlobalVariable.FdfParser.Profile.FvDict:\r
9eb87141 CJ	116	FvObj = GenFdsGlobalVariable.FdfParser.Profile.FvDict[RegionData.upper()]\r
fd171542	117	\r
4231a819	118	if FvObj is not None :\r
37de70b7 YZ	119	if not Flag:\r
37de70b7 YZ	120	GenFdsGlobalVariable.InfLogger(' Region Name = FV')\r
fd171542	121	#\r
	122	# Call GenFv tool\r
	123	#\r
6780eef1	124	self.BlockInfoOfRegion(BlockSizeList, FvObj)\r
fd171542	125	self.FvAddress = self.FvAddress + FvOffset\r
	126	FvAlignValue = self.GetFvAlignValue(FvObj.FvAlignment)\r
	127	if self.FvAddress % FvAlignValue != 0:\r
	128	EdkLogger.error("GenFds", GENFDS_ERROR,\r
	129	"FV (%s) is NOT %s Aligned!" % (FvObj.UiFvName, FvObj.FvAlignment))\r
86379ac4	130	FvBuffer = BytesIO('')\r
47fea6af	131	FvBaseAddress = '0x%X' % self.FvAddress\r
6780eef1 LG	132	BlockSize = None\r
6780eef1 LG	133	BlockNum = None\r
37de70b7 YZ	134	FvObj.AddToBuffer(FvBuffer, FvBaseAddress, BlockSize, BlockNum, ErasePolarity, vtfDict, Flag=Flag)\r
	135	if Flag:\r
	136	continue\r
	137	\r
86379ac4 GL	138	FvBufferLen = len(FvBuffer.getvalue())\r
86379ac4 GL	139	if FvBufferLen > Size:\r
fd171542	140	FvBuffer.close()\r
	141	EdkLogger.error("GenFds", GENFDS_ERROR,\r
	142	"Size of FV (%s) is larger than Region Size 0x%X specified." % (RegionData, Size))\r
	143	#\r
	144	# Put the generated image into FD buffer.\r
	145	#\r
	146	Buffer.write(FvBuffer.getvalue())\r
	147	FvBuffer.close()\r
86379ac4 GL	148	FvOffset = FvOffset + FvBufferLen\r
86379ac4 GL	149	Size = Size - FvBufferLen\r
fd171542	150	continue\r
	151	else:\r
	152	EdkLogger.error("GenFds", GENFDS_ERROR, "FV (%s) is NOT described in FDF file!" % (RegionData))\r
	153	#\r
	154	# Add the exist Fv image into FD buffer\r
	155	#\r
37de70b7	156	if not Flag:\r
4231a819	157	if FileName is not None:\r
37de70b7 YZ	158	FileLength = os.stat(FileName)[ST_SIZE]\r
	159	if FileLength > Size:\r
	160	EdkLogger.error("GenFds", GENFDS_ERROR,\r
	161	"Size of FV File (%s) is larger than Region Size 0x%X specified." \\r
	162	% (RegionData, Size))\r
	163	BinFile = open(FileName, 'rb')\r
	164	Buffer.write(BinFile.read())\r
	165	BinFile.close()\r
	166	Size = Size - FileLength\r
fd171542	167	#\r
	168	# Pad the left buffer\r
	169	#\r
37de70b7 YZ	170	if not Flag:\r
37de70b7 YZ	171	self.PadBuffer(Buffer, ErasePolarity, Size)\r
30fdf114	172	\r
fd171542	173	if self.RegionType == 'CAPSULE':\r
	174	#\r
	175	# Get Capsule from Capsule Dict\r
	176	#\r
	177	for RegionData in self.RegionDataList:\r
	178	if RegionData.endswith(".cap"):\r
	179	RegionData = GenFdsGlobalVariable.MacroExtend(RegionData, MacroDict)\r
47fea6af	180	GenFdsGlobalVariable.InfLogger(' Region CAPSULE Image Name = .cap : %s' % RegionData)\r
fd171542	181	if RegionData[1] != ':' :\r
534ef50c	182	RegionData = mws.join (GenFdsGlobalVariable.WorkSpaceDir, RegionData)\r
fd171542	183	if not os.path.exists(RegionData):\r
fd171542	184	EdkLogger.error("GenFds", FILE_NOT_FOUND, ExtraData=RegionData)\r
30fdf114	185	\r
fd171542	186	FileName = RegionData\r
9eb87141	187	elif RegionData.upper() + 'cap' in ImageBinDict:\r
fd171542	188	GenFdsGlobalVariable.InfLogger(' Region Name = CAPSULE')\r
	189	FileName = ImageBinDict[RegionData.upper() + 'cap']\r
	190	else:\r
30fdf114	191	#\r
fd171542	192	# Generate Capsule image and Put it into FD buffer\r
30fdf114	193	#\r
fd171542	194	CapsuleObj = None\r
9eb87141	195	if RegionData.upper() in GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict:\r
fd171542	196	CapsuleObj = GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict[RegionData.upper()]\r
30fdf114	197	\r
4231a819	198	if CapsuleObj is not None :\r
fd171542	199	CapsuleObj.CapsuleName = RegionData.upper()\r
	200	GenFdsGlobalVariable.InfLogger(' Region Name = CAPSULE')\r
	201	#\r
	202	# Call GenFv tool to generate Capsule Image\r
	203	#\r
	204	FileName = CapsuleObj.GenCapsule()\r
	205	CapsuleObj.CapsuleName = None\r
	206	else:\r
	207	EdkLogger.error("GenFds", GENFDS_ERROR, "Capsule (%s) is NOT described in FDF file!" % (RegionData))\r
30fdf114	208	\r
fd171542	209	#\r
	210	# Add the capsule image into FD buffer\r
	211	#\r
	212	FileLength = os.stat(FileName)[ST_SIZE]\r
	213	if FileLength > Size:\r
	214	EdkLogger.error("GenFds", GENFDS_ERROR,\r
	215	"Size 0x%X of Capsule File (%s) is larger than Region Size 0x%X specified." \\r
	216	% (FileLength, RegionData, Size))\r
f8db6527	217	BinFile = open(FileName, 'rb')\r
30fdf114	218	Buffer.write(BinFile.read())\r
fd171542	219	BinFile.close()\r
	220	Size = Size - FileLength\r
	221	#\r
	222	# Pad the left buffer\r
	223	#\r
5588565f	224	self.PadBuffer(Buffer, ErasePolarity, Size)\r
30fdf114	225	\r
b21a13fb	226	if self.RegionType in ('FILE', 'INF'):\r
30fdf114	227	for RegionData in self.RegionDataList:\r
b21a13fb YZ	228	if self.RegionType == 'INF':\r
	229	RegionData.__InfParse__(None)\r
	230	if len(RegionData.BinFileList) != 1:\r
	231	EdkLogger.error('GenFds', GENFDS_ERROR, 'INF in FD region can only contain one binary: %s' % RegionData)\r
	232	File = RegionData.BinFileList[0]\r
	233	RegionData = RegionData.PatchEfiFile(File.Path, File.Type)\r
	234	else:\r
	235	RegionData = GenFdsGlobalVariable.MacroExtend(RegionData, MacroDict)\r
	236	if RegionData[1] != ':' :\r
534ef50c	237	RegionData = mws.join (GenFdsGlobalVariable.WorkSpaceDir, RegionData)\r
b21a13fb YZ	238	if not os.path.exists(RegionData):\r
b21a13fb YZ	239	EdkLogger.error("GenFds", FILE_NOT_FOUND, ExtraData=RegionData)\r
fd171542	240	#\r
	241	# Add the file image into FD buffer\r
	242	#\r
	243	FileLength = os.stat(RegionData)[ST_SIZE]\r
	244	if FileLength > Size:\r
30fdf114	245	EdkLogger.error("GenFds", GENFDS_ERROR,\r
fd171542	246	"Size of File (%s) is larger than Region Size 0x%X specified." \\r
fd171542	247	% (RegionData, Size))\r
47fea6af YZ	248	GenFdsGlobalVariable.InfLogger(' Region File Name = %s' % RegionData)\r
47fea6af YZ	249	BinFile = open(RegionData, 'rb')\r
fd171542	250	Buffer.write(BinFile.read())\r
	251	BinFile.close()\r
	252	Size = Size - FileLength\r
30fdf114	253	#\r
fd171542	254	# Pad the left buffer\r
30fdf114	255	#\r
5588565f	256	self.PadBuffer(Buffer, ErasePolarity, Size)\r
30fdf114 LG	257	\r
	258	if self.RegionType == 'DATA' :\r
	259	GenFdsGlobalVariable.InfLogger(' Region Name = DATA')\r
	260	DataSize = 0\r
	261	for RegionData in self.RegionDataList:\r
	262	Data = RegionData.split(',')\r
	263	DataSize = DataSize + len(Data)\r
	264	if DataSize > Size:\r
	265	EdkLogger.error("GenFds", GENFDS_ERROR, "Size of DATA is larger than Region Size ")\r
	266	else:\r
	267	for item in Data :\r
	268	Buffer.write(pack('B', int(item, 16)))\r
fd171542	269	Size = Size - DataSize\r
	270	#\r
	271	# Pad the left buffer\r
	272	#\r
5588565f	273	self.PadBuffer(Buffer, ErasePolarity, Size)\r
30fdf114	274	\r
4231a819	275	if self.RegionType is None:\r
30fdf114	276	GenFdsGlobalVariable.InfLogger(' Region Name = None')\r
5588565f	277	self.PadBuffer(Buffer, ErasePolarity, Size)\r
30fdf114 LG	278	\r
	279	def GetFvAlignValue(self, Str):\r
	280	AlignValue = 1\r
	281	Granu = 1\r
	282	Str = Str.strip().upper()\r
	283	if Str.endswith('K'):\r
	284	Granu = 1024\r
	285	Str = Str[:-1]\r
	286	elif Str.endswith('M'):\r
47fea6af	287	Granu = 1024 * 1024\r
30fdf114 LG	288	Str = Str[:-1]\r
30fdf114 LG	289	elif Str.endswith('G'):\r
47fea6af	290	Granu = 1024 * 1024 * 1024\r
30fdf114 LG	291	Str = Str[:-1]\r
	292	else:\r
	293	pass\r
	294	\r
47fea6af	295	AlignValue = int(Str) * Granu\r
30fdf114	296	return AlignValue\r
47fea6af	297	\r
30fdf114 LG	298	## BlockSizeOfRegion()\r
	299	#\r
	300	# @param BlockSizeList List of block information\r
6780eef1	301	# @param FvObj The object for FV\r
30fdf114	302	#\r
6780eef1 LG	303	def BlockInfoOfRegion(self, BlockSizeList, FvObj):\r
	304	Start = 0\r
	305	End = 0\r
	306	RemindingSize = self.Size\r
	307	ExpectedList = []\r
	308	for (BlockSize, BlockNum, pcd) in BlockSizeList:\r
	309	End = Start + BlockSize * BlockNum\r
	310	# region not started yet\r
	311	if self.Offset >= End:\r
	312	Start = End\r
	313	continue\r
f7496d71	314	# region located in current blocks\r
6780eef1 LG	315	else:\r
	316	# region ended within current blocks\r
	317	if self.Offset + self.Size <= End:\r
47fea6af	318	ExpectedList.append((BlockSize, (RemindingSize + BlockSize - 1) / BlockSize))\r
6780eef1 LG	319	break\r
	320	# region not ended yet\r
	321	else:\r
	322	# region not started in middle of current blocks\r
	323	if self.Offset <= Start:\r
	324	UsedBlockNum = BlockNum\r
	325	# region started in middle of current blocks\r
	326	else:\r
47fea6af	327	UsedBlockNum = (End - self.Offset) / BlockSize\r
6780eef1 LG	328	Start = End\r
	329	ExpectedList.append((BlockSize, UsedBlockNum))\r
	330	RemindingSize -= BlockSize * UsedBlockNum\r
47fea6af	331	\r
6780eef1 LG	332	if FvObj.BlockSizeList == []:\r
	333	FvObj.BlockSizeList = ExpectedList\r
	334	else:\r
	335	# first check whether FvObj.BlockSizeList items have only "BlockSize" or "NumBlocks",\r
	336	# if so, use ExpectedList\r
	337	for Item in FvObj.BlockSizeList:\r
4231a819	338	if Item[0] is None or Item[1] is None:\r
6780eef1 LG	339	FvObj.BlockSizeList = ExpectedList\r
	340	break\r
	341	# make sure region size is no smaller than the summed block size in FV\r
	342	Sum = 0\r
	343	for Item in FvObj.BlockSizeList:\r
	344	Sum += Item[0] * Item[1]\r
	345	if self.Size < Sum:\r
	346	EdkLogger.error("GenFds", GENFDS_ERROR, "Total Size of FV %s 0x%x is larger than Region Size 0x%x "\r
47fea6af	347	% (FvObj.UiFvName, Sum, self.Size))\r
6780eef1 LG	348	# check whether the BlockStatements in FV section is appropriate\r
	349	ExpectedListData = ''\r
	350	for Item in ExpectedList:\r
47fea6af	351	ExpectedListData += "BlockSize = 0x%x\n\tNumBlocks = 0x%x\n\t" % Item\r
6780eef1 LG	352	Index = 0\r
	353	for Item in FvObj.BlockSizeList:\r
	354	if Item[0] != ExpectedList[Index][0]:\r
	355	EdkLogger.error("GenFds", GENFDS_ERROR, "BlockStatements of FV %s are not align with FD's, suggested FV BlockStatement"\r
47fea6af	356	% FvObj.UiFvName, ExtraData=ExpectedListData)\r
6780eef1 LG	357	elif Item[1] != ExpectedList[Index][1]:\r
	358	if (Item[1] < ExpectedList[Index][1]) and (Index == len(FvObj.BlockSizeList) - 1):\r
	359	break;\r
	360	else:\r
	361	EdkLogger.error("GenFds", GENFDS_ERROR, "BlockStatements of FV %s are not align with FD's, suggested FV BlockStatement"\r
47fea6af	362	% FvObj.UiFvName, ExtraData=ExpectedListData)\r
6780eef1 LG	363	else:\r
6780eef1 LG	364	Index += 1\r
30fdf114	365	\r
f7496d71	366	\r
30fdf114	367	\r