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