BaseTools/Source/Python/GenFds/Region.py

   1 ## @file
   2 # process FD Region generation
   3 #
   4 #  Copyright (c) 2007, Intel Corporation
   5 #
   6 #  All rights reserved. This program and the accompanying materials
   7 #  are licensed and made available under the terms and conditions of the BSD License
   8 #  which accompanies this distribution.  The full text of the license may be found at
   9 #  http://opensource.org/licenses/bsd-license.php
  10 #
  11 #  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 #  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13 #
  14
  15 ##
  16 # Import Modules
  17 #
  18 from struct import *
  19 from GenFdsGlobalVariable import GenFdsGlobalVariable
  20 import StringIO
  21 from CommonDataClass.FdfClass import RegionClassObject
  22 import os
  23 from stat import *
  24 from Common import EdkLogger
  25 from Common.BuildToolError import *
  26
  27 ## generate Region
  28 #
  29 #
  30 class Region(RegionClassObject):
  31
  32     ## The constructor
  33     #
  34     #   @param  self        The object pointer
  35     #
  36     def __init__(self):
  37         RegionClassObject.__init__(self)
  38
  39
  40     ## AddToBuffer()
  41     #
  42     #   Add region data to the Buffer
  43     #
  44     #   @param  self        The object pointer
  45     #   @param  Buffer      The buffer generated region data will be put
  46     #   @param  BaseAddress base address of region
  47     #   @param  BlockSize   block size of region
  48     #   @param  BlockNum    How many blocks in region
  49     #   @param  ErasePolarity      Flash erase polarity
  50     #   @param  VtfDict     VTF objects
  51     #   @param  MacroDict   macro value pair
  52     #   @retval string      Generated FV file path
  53     #
  54
  55     def AddToBuffer(self, Buffer, BaseAddress, BlockSizeList, ErasePolarity, ImageBinDict, vtfDict = None, MacroDict = {}):
  56         Size = self.Size
  57         GenFdsGlobalVariable.InfLogger('\nGenerate Region at Offset 0x%X' % self.Offset)
  58         GenFdsGlobalVariable.InfLogger("   Region Size = 0x%X" %Size)
  59         GenFdsGlobalVariable.SharpCounter = 0
  60
  61         if self.RegionType == 'FV':
  62             #
  63             # Get Fv from FvDict
  64             #
  65             RegionBlockSize = self.BlockSizeOfRegion(BlockSizeList)
  66             RegionBlockNum = self.BlockNumOfRegion(RegionBlockSize)
  67
  68             self.FvAddress = int(BaseAddress, 16) + self.Offset
  69             FvBaseAddress  = '0x%X' %self.FvAddress
  70             FvOffset       = 0
  71             for RegionData in self.RegionDataList:
  72                 FileName = None
  73                 if RegionData.endswith(".fv"):
  74                     RegionData = GenFdsGlobalVariable.MacroExtend(RegionData, MacroDict)
  75                     GenFdsGlobalVariable.InfLogger('   Region FV File Name = .fv : %s'%RegionData)
  76                     if RegionData[1] != ':' :
  77                         RegionData = os.path.join (GenFdsGlobalVariable.WorkSpaceDir, RegionData)
  78                     if not os.path.exists(RegionData):
  79                         EdkLogger.error("GenFds", FILE_NOT_FOUND, ExtraData=RegionData)
  80
  81                     FileName = RegionData
  82                 elif RegionData.upper() + 'fv' in ImageBinDict.keys():
  83                     GenFdsGlobalVariable.InfLogger('   Region Name = FV')
  84                     FileName = ImageBinDict[RegionData.upper() + 'fv']
  85                 else:
  86                     #
  87                     # Generate FvImage.
  88                     #
  89                     FvObj = None
  90                     if RegionData.upper() in GenFdsGlobalVariable.FdfParser.Profile.FvDict.keys():
  91                         FvObj = GenFdsGlobalVariable.FdfParser.Profile.FvDict.get(RegionData.upper())
  92
  93                     if FvObj != None :
  94                         GenFdsGlobalVariable.InfLogger('   Region Name = FV')
  95                         #
  96                         # Call GenFv tool
  97                         #
  98                         BlockSize = RegionBlockSize
  99                         BlockNum = RegionBlockNum
 100                         if FvObj.BlockSizeList != []:
 101                             if FvObj.BlockSizeList[0][0] != None:
 102                                 BlockSize = FvObj.BlockSizeList[0][0]
 103                             if FvObj.BlockSizeList[0][1] != None:
 104                                 BlockNum = FvObj.BlockSizeList[0][1]
 105                         self.FvAddress = self.FvAddress + FvOffset
 106                         FvAlignValue = self.GetFvAlignValue(FvObj.FvAlignment)
 107                         if self.FvAddress % FvAlignValue != 0:
 108                             EdkLogger.error("GenFds", GENFDS_ERROR,
 109                                             "FV (%s) is NOT %s Aligned!" % (FvObj.UiFvName, FvObj.FvAlignment))
 110                         FvBuffer = StringIO.StringIO('')
 111                         FvBaseAddress = '0x%X' %self.FvAddress
 112                         FvObj.AddToBuffer(FvBuffer, FvBaseAddress, BlockSize, BlockNum, ErasePolarity, vtfDict)
 113                         if FvBuffer.len > Size:
 114                             FvBuffer.close()
 115                             EdkLogger.error("GenFds", GENFDS_ERROR,
 116                                             "Size of FV (%s) is larger than Region Size 0x%X specified." % (RegionData, Size))
 117                         #
 118                         # Put the generated image into FD buffer.
 119                         #
 120                         Buffer.write(FvBuffer.getvalue())
 121                         FvBuffer.close()
 122                         FvOffset = FvOffset + FvBuffer.len
 123                         Size = Size - FvBuffer.len
 124                         continue
 125                     else:
 126                         EdkLogger.error("GenFds", GENFDS_ERROR, "FV (%s) is NOT described in FDF file!" % (RegionData))
 127                 #
 128                 # Add the exist Fv image into FD buffer
 129                 #
 130                 if FileName != None:
 131                     FileLength = os.stat(FileName)[ST_SIZE]
 132                     if FileLength > Size:
 133                         EdkLogger.error("GenFds", GENFDS_ERROR,
 134                                         "Size of FV File (%s) is larger than Region Size 0x%X specified." \
 135                                         % (RegionData, Size))
 136                     BinFile = open (FileName, 'r+b')
 137                     Buffer.write(BinFile.read())
 138                     BinFile.close()
 139                     Size = Size - FileLength
 140             #
 141             # Pad the left buffer
 142             #
 143             if Size > 0:
 144                 if (ErasePolarity == '1') :
 145                     PadData = 0xFF
 146                 else :
 147                     PadData = 0
 148                 for i in range(0, Size):
 149                     Buffer.write(pack('B', PadData))
 150
 151         if self.RegionType == 'CAPSULE':
 152             #
 153             # Get Capsule from Capsule Dict
 154             #
 155             for RegionData in self.RegionDataList:
 156                 if RegionData.endswith(".cap"):
 157                     RegionData = GenFdsGlobalVariable.MacroExtend(RegionData, MacroDict)
 158                     GenFdsGlobalVariable.InfLogger('   Region CAPSULE Image Name = .cap : %s'%RegionData)
 159                     if RegionData[1] != ':' :
 160                         RegionData = os.path.join (GenFdsGlobalVariable.WorkSpaceDir, RegionData)
 161                     if not os.path.exists(RegionData):
 162                         EdkLogger.error("GenFds", FILE_NOT_FOUND, ExtraData=RegionData)
 163
 164                     FileName = RegionData
 165                 elif RegionData.upper() + 'cap' in ImageBinDict.keys():
 166                     GenFdsGlobalVariable.InfLogger('   Region Name = CAPSULE')
 167                     FileName = ImageBinDict[RegionData.upper() + 'cap']
 168                 else:
 169                     #
 170                     # Generate Capsule image and Put it into FD buffer
 171                     #
 172                     CapsuleObj = None
 173                     if RegionData.upper() in GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict.keys():
 174                         CapsuleObj = GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict[RegionData.upper()]
 175
 176                     if CapsuleObj != None :
 177                         CapsuleObj.CapsuleName = RegionData.upper()
 178                         GenFdsGlobalVariable.InfLogger('   Region Name = CAPSULE')
 179                         #
 180                         # Call GenFv tool to generate Capsule Image
 181                         #
 182                         FileName = CapsuleObj.GenCapsule()
 183                         CapsuleObj.CapsuleName = None
 184                     else:
 185                         EdkLogger.error("GenFds", GENFDS_ERROR, "Capsule (%s) is NOT described in FDF file!" % (RegionData))
 186
 187                 #
 188                 # Add the capsule image into FD buffer
 189                 #
 190                 FileLength = os.stat(FileName)[ST_SIZE]
 191                 if FileLength > Size:
 192                     EdkLogger.error("GenFds", GENFDS_ERROR,
 193                                     "Size 0x%X of Capsule File (%s) is larger than Region Size 0x%X specified." \
 194                                     % (FileLength, RegionData, Size))
 195                 BinFile = open (FileName, 'r+b')
 196                 Buffer.write(BinFile.read())
 197                 BinFile.close()
 198                 Size = Size - FileLength
 199             #
 200             # Pad the left buffer
 201             #
 202             if Size > 0:
 203                 if (ErasePolarity == '1') :
 204                     PadData = 0xFF
 205                 else :
 206                     PadData = 0
 207                 for i in range(0, Size):
 208                     Buffer.write(pack('B', PadData))
 209
 210         if self.RegionType == 'FILE':
 211             for RegionData in self.RegionDataList:
 212                 RegionData = GenFdsGlobalVariable.MacroExtend(RegionData, MacroDict)
 213                 if RegionData[1] != ':' :
 214                     RegionData = os.path.join (GenFdsGlobalVariable.WorkSpaceDir, RegionData)
 215                 if not os.path.exists(RegionData):
 216                     EdkLogger.error("GenFds", FILE_NOT_FOUND, ExtraData=RegionData)
 217                 #
 218                 # Add the file image into FD buffer
 219                 #
 220                 FileLength = os.stat(RegionData)[ST_SIZE]
 221                 if FileLength > Size:
 222                     EdkLogger.error("GenFds", GENFDS_ERROR,
 223                                     "Size of File (%s) is larger than Region Size 0x%X specified." \
 224                                     % (RegionData, Size))
 225                 GenFdsGlobalVariable.InfLogger('   Region File Name = %s'%RegionData)
 226                 BinFile = open (RegionData, 'r+b')
 227                 Buffer.write(BinFile.read())
 228                 BinFile.close()
 229                 Size = Size - FileLength
 230             #
 231             # Pad the left buffer
 232             #
 233             if Size > 0:
 234                 if (ErasePolarity == '1') :
 235                     PadData = 0xFF
 236                 else :
 237                     PadData = 0
 238                 for i in range(0, Size):
 239                     Buffer.write(pack('B', PadData))
 240
 241         if self.RegionType == 'DATA' :
 242             GenFdsGlobalVariable.InfLogger('   Region Name = DATA')
 243             DataSize = 0
 244             for RegionData in self.RegionDataList:
 245                 Data = RegionData.split(',')
 246                 DataSize = DataSize + len(Data)
 247                 if DataSize > Size:
 248                    EdkLogger.error("GenFds", GENFDS_ERROR, "Size of DATA is larger than Region Size ")
 249                 else:
 250                     for item in Data :
 251                         Buffer.write(pack('B', int(item, 16)))
 252                 Size = Size - DataSize
 253             #
 254             # Pad the left buffer
 255             #
 256             if Size > 0:
 257                 if (ErasePolarity == '1') :
 258                     PadData = 0xFF
 259                 else :
 260                     PadData = 0
 261                 for i in range(0, Size):
 262                     Buffer.write(pack('B', PadData))
 263
 264         if self.RegionType == None:
 265             GenFdsGlobalVariable.InfLogger('   Region Name = None')
 266             if (ErasePolarity == '1') :
 267                 PadData = 0xFF
 268             else :
 269                 PadData = 0
 270             for i in range(0, Size):
 271                 Buffer.write(pack('B', PadData))
 272
 273     def GetFvAlignValue(self, Str):
 274         AlignValue = 1
 275         Granu = 1
 276         Str = Str.strip().upper()
 277         if Str.endswith('K'):
 278             Granu = 1024
 279             Str = Str[:-1]
 280         elif Str.endswith('M'):
 281             Granu = 1024*1024
 282             Str = Str[:-1]
 283         elif Str.endswith('G'):
 284             Granu = 1024*1024*1024
 285             Str = Str[:-1]
 286         else:
 287             pass
 288
 289         AlignValue = int(Str)*Granu
 290         return AlignValue
 291     ## BlockSizeOfRegion()
 292     #
 293     #   @param  BlockSizeList        List of block information
 294     #   @retval int                  Block size of region
 295     #
 296     def BlockSizeOfRegion(self, BlockSizeList):
 297         Offset = 0x00
 298         BlockSize = 0
 299         for item in BlockSizeList:
 300             Offset = Offset + item[0]  * item[1]
 301             GenFdsGlobalVariable.VerboseLogger ("Offset = 0x%X" %Offset)
 302             GenFdsGlobalVariable.VerboseLogger ("self.Offset 0x%X" %self.Offset)
 303
 304             if self.Offset < Offset :
 305                 if Offset - self.Offset < self.Size:
 306                     EdkLogger.error("GenFds", GENFDS_ERROR,
 307                                     "Region at Offset 0x%X can NOT fit into Block array with BlockSize %X" \
 308                                     % (self.Offset, item[0]))
 309                 BlockSize = item[0]
 310                 GenFdsGlobalVariable.VerboseLogger ("BlockSize = %X" %BlockSize)
 311                 return BlockSize
 312         return BlockSize
 313
 314     ## BlockNumOfRegion()
 315     #
 316     #   @param  BlockSize            block size of region
 317     #   @retval int                  Block number of region
 318     #
 319     def BlockNumOfRegion (self, BlockSize):
 320         if BlockSize == 0 :
 321             EdkLogger.error("GenFds", GENFDS_ERROR, "Region: %s is not in the FD address scope!" % self.Offset)
 322         BlockNum = self.Size / BlockSize
 323         GenFdsGlobalVariable.VerboseLogger ("BlockNum = 0x%X" %BlockNum)
 324         return BlockNum
 325