mirror of https://github.com/acidanthera/audk.git
1792 lines
76 KiB
Python
1792 lines
76 KiB
Python
## @ GenCfgOpt.py
|
|
#
|
|
# Copyright (c) 2014 - 2021, Intel Corporation. All rights reserved.<BR>
|
|
# SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
#
|
|
##
|
|
|
|
import os
|
|
import re
|
|
import sys
|
|
import struct
|
|
from datetime import date
|
|
from functools import reduce
|
|
|
|
# Generated file copyright header
|
|
|
|
__copyright_txt__ = """## @file
|
|
#
|
|
# THIS IS AUTO-GENERATED FILE BY BUILD TOOLS AND PLEASE DO NOT MAKE MODIFICATION.
|
|
#
|
|
# This file lists all VPD informations for a platform collected by build.exe.
|
|
#
|
|
# Copyright (c) %4d, Intel Corporation. All rights reserved.<BR>
|
|
# This program and the accompanying materials
|
|
# are licensed and made available under the terms and conditions of the BSD License
|
|
# which accompanies this distribution. The full text of the license may be found at
|
|
# http://opensource.org/licenses/bsd-license.php
|
|
#
|
|
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
|
#
|
|
"""
|
|
|
|
__copyright_bsf__ = """/** @file
|
|
|
|
Boot Setting File for Platform Configuration.
|
|
|
|
Copyright (c) %4d, Intel Corporation. All rights reserved.<BR>
|
|
This program and the accompanying materials
|
|
are licensed and made available under the terms and conditions of the BSD License
|
|
which accompanies this distribution. The full text of the license may be found at
|
|
http://opensource.org/licenses/bsd-license.php
|
|
|
|
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
|
|
|
This file is automatically generated. Please do NOT modify !!!
|
|
|
|
**/
|
|
|
|
"""
|
|
|
|
__copyright_h__ = """/** @file
|
|
|
|
Copyright (c) %4d, Intel Corporation. All rights reserved.<BR>
|
|
|
|
Redistribution and use in source and binary forms, with or without modification,
|
|
are permitted provided that the following conditions are met:
|
|
|
|
* Redistributions of source code must retain the above copyright notice, this
|
|
list of conditions and the following disclaimer.
|
|
* Redistributions in binary form must reproduce the above copyright notice, this
|
|
list of conditions and the following disclaimer in the documentation and/or
|
|
other materials provided with the distribution.
|
|
* Neither the name of Intel Corporation nor the names of its contributors may
|
|
be used to endorse or promote products derived from this software without
|
|
specific prior written permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
|
|
THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
This file is automatically generated. Please do NOT modify !!!
|
|
|
|
**/
|
|
"""
|
|
|
|
BuildOptionPcd = []
|
|
|
|
class CLogicalExpression:
|
|
def __init__(self):
|
|
self.index = 0
|
|
self.string = ''
|
|
|
|
def errExit(self, err = ''):
|
|
print ("ERROR: Express parsing for:")
|
|
print (" %s" % self.string)
|
|
print (" %s^" % (' ' * self.index))
|
|
if err:
|
|
print ("INFO : %s" % err)
|
|
raise SystemExit
|
|
|
|
def getNonNumber (self, n1, n2):
|
|
if not n1.isdigit():
|
|
return n1
|
|
if not n2.isdigit():
|
|
return n2
|
|
return None
|
|
|
|
def getCurr(self, lens = 1):
|
|
try:
|
|
if lens == -1:
|
|
return self.string[self.index :]
|
|
else:
|
|
if self.index + lens > len(self.string):
|
|
lens = len(self.string) - self.index
|
|
return self.string[self.index : self.index + lens]
|
|
except Exception:
|
|
return ''
|
|
|
|
def isLast(self):
|
|
return self.index == len(self.string)
|
|
|
|
def moveNext(self, len = 1):
|
|
self.index += len
|
|
|
|
def skipSpace(self):
|
|
while not self.isLast():
|
|
if self.getCurr() in ' \t':
|
|
self.moveNext()
|
|
else:
|
|
return
|
|
|
|
def normNumber (self, val):
|
|
return True if val else False
|
|
|
|
def getNumber(self, var):
|
|
var = var.strip()
|
|
if re.match('^0x[a-fA-F0-9]+$', var):
|
|
value = int(var, 16)
|
|
elif re.match('^[+-]?\d+$', var):
|
|
value = int(var, 10)
|
|
else:
|
|
value = None
|
|
return value
|
|
|
|
def parseValue(self):
|
|
self.skipSpace()
|
|
var = ''
|
|
while not self.isLast():
|
|
char = self.getCurr()
|
|
if re.match('^[\w.]', char):
|
|
var += char
|
|
self.moveNext()
|
|
else:
|
|
break
|
|
val = self.getNumber(var)
|
|
if val is None:
|
|
value = var
|
|
else:
|
|
value = "%d" % val
|
|
return value
|
|
|
|
def parseSingleOp(self):
|
|
self.skipSpace()
|
|
if re.match('^NOT\W', self.getCurr(-1)):
|
|
self.moveNext(3)
|
|
op = self.parseBrace()
|
|
val = self.getNumber (op)
|
|
if val is None:
|
|
self.errExit ("'%s' is not a number" % op)
|
|
return "%d" % (not self.normNumber(int(op)))
|
|
else:
|
|
return self.parseValue()
|
|
|
|
def parseBrace(self):
|
|
self.skipSpace()
|
|
char = self.getCurr()
|
|
if char == '(':
|
|
self.moveNext()
|
|
value = self.parseExpr()
|
|
self.skipSpace()
|
|
if self.getCurr() != ')':
|
|
self.errExit ("Expecting closing brace or operator")
|
|
self.moveNext()
|
|
return value
|
|
else:
|
|
value = self.parseSingleOp()
|
|
return value
|
|
|
|
def parseCompare(self):
|
|
value = self.parseBrace()
|
|
while True:
|
|
self.skipSpace()
|
|
char = self.getCurr()
|
|
if char in ['<', '>']:
|
|
self.moveNext()
|
|
next = self.getCurr()
|
|
if next == '=':
|
|
op = char + next
|
|
self.moveNext()
|
|
else:
|
|
op = char
|
|
result = self.parseBrace()
|
|
test = self.getNonNumber(result, value)
|
|
if test is None:
|
|
value = "%d" % self.normNumber(eval (value + op + result))
|
|
else:
|
|
self.errExit ("'%s' is not a valid number for comparision" % test)
|
|
elif char in ['=', '!']:
|
|
op = self.getCurr(2)
|
|
if op in ['==', '!=']:
|
|
self.moveNext(2)
|
|
result = self.parseBrace()
|
|
test = self.getNonNumber(result, value)
|
|
if test is None:
|
|
value = "%d" % self.normNumber((eval (value + op + result)))
|
|
else:
|
|
value = "%d" % self.normNumber(eval ("'" + value + "'" + op + "'" + result + "'"))
|
|
else:
|
|
break
|
|
else:
|
|
break
|
|
return value
|
|
|
|
def parseAnd(self):
|
|
value = self.parseCompare()
|
|
while True:
|
|
self.skipSpace()
|
|
if re.match('^AND\W', self.getCurr(-1)):
|
|
self.moveNext(3)
|
|
result = self.parseCompare()
|
|
test = self.getNonNumber(result, value)
|
|
if test is None:
|
|
value = "%d" % self.normNumber(int(value) & int(result))
|
|
else:
|
|
self.errExit ("'%s' is not a valid op number for AND" % test)
|
|
else:
|
|
break
|
|
return value
|
|
|
|
def parseOrXor(self):
|
|
value = self.parseAnd()
|
|
op = None
|
|
while True:
|
|
self.skipSpace()
|
|
op = None
|
|
if re.match('^XOR\W', self.getCurr(-1)):
|
|
self.moveNext(3)
|
|
op = '^'
|
|
elif re.match('^OR\W', self.getCurr(-1)):
|
|
self.moveNext(2)
|
|
op = '|'
|
|
else:
|
|
break
|
|
if op:
|
|
result = self.parseAnd()
|
|
test = self.getNonNumber(result, value)
|
|
if test is None:
|
|
value = "%d" % self.normNumber(eval (value + op + result))
|
|
else:
|
|
self.errExit ("'%s' is not a valid op number for XOR/OR" % test)
|
|
return value
|
|
|
|
def parseExpr(self):
|
|
return self.parseOrXor()
|
|
|
|
def getResult(self):
|
|
value = self.parseExpr()
|
|
self.skipSpace()
|
|
if not self.isLast():
|
|
self.errExit ("Unexpected character found '%s'" % self.getCurr())
|
|
test = self.getNumber(value)
|
|
if test is None:
|
|
self.errExit ("Result '%s' is not a number" % value)
|
|
return int(value)
|
|
|
|
def evaluateExpress (self, Expr):
|
|
self.index = 0
|
|
self.string = Expr
|
|
if self.getResult():
|
|
Result = True
|
|
else:
|
|
Result = False
|
|
return Result
|
|
|
|
class CGenCfgOpt:
|
|
def __init__(self, Mode = ''):
|
|
self.Debug = False
|
|
self.Error = ''
|
|
self.Mode = Mode
|
|
self._GlobalDataDef = """
|
|
GlobalDataDef
|
|
SKUID = 0, "DEFAULT"
|
|
EndGlobalData
|
|
|
|
"""
|
|
self._BuidinOptionTxt = """
|
|
List &EN_DIS
|
|
Selection 0x1 , "Enabled"
|
|
Selection 0x0 , "Disabled"
|
|
EndList
|
|
|
|
"""
|
|
self._BsfKeyList = ['FIND','NAME','HELP','TYPE','PAGE', 'PAGES', 'BLOCK', 'OPTION','CONDITION','ORDER', 'MARKER', 'SUBT']
|
|
self._HdrKeyList = ['HEADER','STRUCT', 'EMBED', 'COMMENT']
|
|
self._BuidinOption = {'$EN_DIS' : 'EN_DIS'}
|
|
|
|
self._MacroDict = {}
|
|
self._VarDict = {}
|
|
self._PcdsDict = {}
|
|
self._CfgBlkDict = {}
|
|
self._CfgPageDict = {}
|
|
self._BsfTempDict = {}
|
|
self._CfgItemList = []
|
|
self._DscLines = []
|
|
self._DscFile = ''
|
|
|
|
self._MapVer = 0
|
|
self._DscTime = 0
|
|
|
|
def ParseMacros (self, MacroDefStr):
|
|
# ['-DABC=1', '-D', 'CFG_DEBUG=1', '-D', 'CFG_OUTDIR=Build']
|
|
self._MacroDict = {}
|
|
IsExpression = False
|
|
for Macro in MacroDefStr:
|
|
if Macro.startswith('-D'):
|
|
IsExpression = True
|
|
if len(Macro) > 2:
|
|
Macro = Macro[2:]
|
|
else :
|
|
continue
|
|
if IsExpression:
|
|
IsExpression = False
|
|
Match = re.match("(\w+)=(.+)", Macro)
|
|
if Match:
|
|
self._MacroDict[Match.group(1)] = Match.group(2)
|
|
else:
|
|
Match = re.match("(\w+)", Macro)
|
|
if Match:
|
|
self._MacroDict[Match.group(1)] = ''
|
|
if len(self._MacroDict) == 0:
|
|
Error = 1
|
|
else:
|
|
Error = 0
|
|
if self.Debug:
|
|
print ("INFO : Macro dictionary:")
|
|
for Each in self._MacroDict:
|
|
print (" $(%s) = [ %s ]" % (Each , self._MacroDict[Each]))
|
|
return Error
|
|
|
|
def EvaulateIfdef (self, Macro):
|
|
Result = Macro in self._MacroDict
|
|
if self.Debug:
|
|
print ("INFO : Eval Ifdef [%s] : %s" % (Macro, Result))
|
|
return Result
|
|
|
|
def ExpandMacros (self, Input, Preserve = False):
|
|
Line = Input
|
|
Match = re.findall("\$\(\w+\)", Input)
|
|
if Match:
|
|
for Each in Match:
|
|
Variable = Each[2:-1]
|
|
if Variable in self._MacroDict:
|
|
Line = Line.replace(Each, self._MacroDict[Variable])
|
|
else:
|
|
if self.Debug:
|
|
print ("WARN : %s is not defined" % Each)
|
|
if not Preserve:
|
|
Line = Line.replace(Each, Each[2:-1])
|
|
return Line
|
|
|
|
def ExpandPcds (self, Input):
|
|
Line = Input
|
|
Match = re.findall("(\w+\.\w+)", Input)
|
|
if Match:
|
|
for PcdName in Match:
|
|
if PcdName in self._PcdsDict:
|
|
Line = Line.replace(PcdName, self._PcdsDict[PcdName])
|
|
else:
|
|
if self.Debug:
|
|
print ("WARN : %s is not defined" % PcdName)
|
|
return Line
|
|
|
|
def EvaluateExpress (self, Expr):
|
|
ExpExpr = self.ExpandPcds(Expr)
|
|
ExpExpr = self.ExpandMacros(ExpExpr)
|
|
LogExpr = CLogicalExpression()
|
|
Result = LogExpr.evaluateExpress (ExpExpr)
|
|
if self.Debug:
|
|
print ("INFO : Eval Express [%s] : %s" % (Expr, Result))
|
|
return Result
|
|
|
|
def ValueToByteArray (self, ValueStr, Length):
|
|
Match = re.match("\{\s*FILE:(.+)\}", ValueStr)
|
|
if Match:
|
|
FileList = Match.group(1).split(',')
|
|
Result = bytearray()
|
|
for File in FileList:
|
|
File = File.strip()
|
|
BinPath = os.path.join(os.path.dirname(self._DscFile), File)
|
|
Result.extend(bytearray(open(BinPath, 'rb').read()))
|
|
else:
|
|
try:
|
|
Result = bytearray(self.ValueToList(ValueStr, Length))
|
|
except ValueError as e:
|
|
raise Exception ("Bytes in '%s' must be in range 0~255 !" % ValueStr)
|
|
if len(Result) < Length:
|
|
Result.extend(b'\x00' * (Length - len(Result)))
|
|
elif len(Result) > Length:
|
|
raise Exception ("Value '%s' is too big to fit into %d bytes !" % (ValueStr, Length))
|
|
|
|
return Result[:Length]
|
|
|
|
def ValueToList (self, ValueStr, Length):
|
|
if ValueStr[0] == '{':
|
|
Result = []
|
|
BinList = ValueStr[1:-1].split(',')
|
|
InBitField = False
|
|
LastInBitField = False
|
|
Value = 0
|
|
BitLen = 0
|
|
for Element in BinList:
|
|
InBitField = False
|
|
Each = Element.strip()
|
|
if len(Each) == 0:
|
|
pass
|
|
else:
|
|
if Each[0] in ['"', "'"]:
|
|
Result.extend(list(bytearray(Each[1:-1], 'utf-8')))
|
|
elif ':' in Each:
|
|
Match = re.match("(.+):(\d+)b", Each)
|
|
if Match is None:
|
|
raise Exception("Invald value list format '%s' !" % Each)
|
|
InBitField = True
|
|
CurrentBitLen = int(Match.group(2))
|
|
CurrentValue = ((self.EvaluateExpress(Match.group(1)) & (1<<CurrentBitLen) - 1)) << BitLen
|
|
else:
|
|
Result.append(self.EvaluateExpress(Each.strip()))
|
|
if InBitField:
|
|
Value += CurrentValue
|
|
BitLen += CurrentBitLen
|
|
if LastInBitField and ((not InBitField) or (Element == BinList[-1])):
|
|
if BitLen % 8 != 0:
|
|
raise Exception("Invald bit field length!")
|
|
Result.extend(Val2Bytes(Value, BitLen // 8))
|
|
Value = 0
|
|
BitLen = 0
|
|
LastInBitField = InBitField
|
|
elif ValueStr.startswith("'") and ValueStr.endswith("'"):
|
|
Result = Str2Bytes (ValueStr, Length)
|
|
elif ValueStr.startswith('"') and ValueStr.endswith('"'):
|
|
Result = Str2Bytes (ValueStr, Length)
|
|
else:
|
|
Result = Val2Bytes (self.EvaluateExpress(ValueStr), Length)
|
|
return Result
|
|
|
|
def FormatListValue(self, ConfigDict):
|
|
Struct = ConfigDict['struct']
|
|
if Struct not in ['UINT8','UINT16','UINT32','UINT64']:
|
|
return
|
|
|
|
dataarray = []
|
|
binlist = ConfigDict['value'][1:-1].split(',')
|
|
for each in binlist:
|
|
each = each.strip()
|
|
if each.startswith('0x'):
|
|
value = int(each, 16)
|
|
else:
|
|
value = int(each)
|
|
dataarray.append(value)
|
|
|
|
unit = int(Struct[4:]) / 8
|
|
if int(ConfigDict['length']) != unit * len(dataarray):
|
|
raise Exception("Array size is not proper for '%s' !" % ConfigDict['cname'])
|
|
|
|
bytearray = []
|
|
for each in dataarray:
|
|
value = each
|
|
for loop in range(int(unit)):
|
|
bytearray.append("0x%02X" % (value & 0xFF))
|
|
value = value >> 8
|
|
newvalue = '{' + ','.join(bytearray) + '}'
|
|
ConfigDict['value'] = newvalue
|
|
return ""
|
|
|
|
def ParseDscFile (self, DscFile, FvDir):
|
|
Hardcode = False
|
|
AutoAlign = False
|
|
self._CfgItemList = []
|
|
self._CfgPageDict = {}
|
|
self._CfgBlkDict = {}
|
|
self._DscFile = DscFile
|
|
self._FvDir = FvDir
|
|
|
|
self._DscLines = []
|
|
self._BsfTempDict = {}
|
|
|
|
# Initial DSC time is parent DSC time.
|
|
self._DscTime = os.path.getmtime(DscFile)
|
|
|
|
CfgDict = {}
|
|
|
|
IsDefSect = False
|
|
IsPcdSect = False
|
|
IsUpdSect = False
|
|
IsVpdSect = False
|
|
IsTmpSect = False
|
|
|
|
TemplateName = ''
|
|
|
|
IfStack = []
|
|
ElifStack = []
|
|
Error = 0
|
|
ConfigDict = {}
|
|
|
|
|
|
if type(DscFile) is list:
|
|
# it is DSC lines already
|
|
DscLines = DscFile
|
|
self._DscFile = '.'
|
|
else:
|
|
DscFd = open(DscFile, "r")
|
|
DscLines = DscFd.readlines()
|
|
DscFd.close()
|
|
self._DscFile = DscFile
|
|
|
|
SkipLines = 0
|
|
|
|
MaxAlign = 32 #Default align to 32, but if there are 64 bit unit, align to 64
|
|
SizeAlign = 0 #record the struct max align
|
|
Base = 0 #Starting offset of sub-structure.
|
|
|
|
while len(DscLines):
|
|
DscLine = DscLines.pop(0).strip()
|
|
if SkipLines == 0:
|
|
self._DscLines.append (DscLine)
|
|
else:
|
|
SkipLines = SkipLines - 1
|
|
if len(DscLine) == 0:
|
|
continue
|
|
|
|
Handle = False
|
|
Match = re.match("^\[(.+)\]", DscLine)
|
|
if Match is not None:
|
|
IsDefSect = False
|
|
IsPcdSect = False
|
|
IsVpdSect = False
|
|
IsUpdSect = False
|
|
IsTmpSect = False
|
|
SectionName = Match.group(1).lower()
|
|
if SectionName == "Defines".lower():
|
|
IsDefSect = True
|
|
if (SectionName == "PcdsFeatureFlag".lower() or SectionName == "PcdsFixedAtBuild".lower()):
|
|
IsPcdSect = True
|
|
elif SectionName == "PcdsDynamicVpd.Tmp".lower():
|
|
IsTmpSect = True
|
|
elif SectionName == "PcdsDynamicVpd.Upd".lower():
|
|
ConfigDict = {}
|
|
ConfigDict['header'] = 'ON'
|
|
ConfigDict['region'] = 'UPD'
|
|
ConfigDict['order'] = -1
|
|
ConfigDict['page'] = ''
|
|
ConfigDict['name'] = ''
|
|
ConfigDict['find'] = ''
|
|
ConfigDict['marker'] = ''
|
|
ConfigDict['struct'] = ''
|
|
ConfigDict['embed'] = ''
|
|
ConfigDict['comment'] = ''
|
|
ConfigDict['subreg'] = []
|
|
ConfigDict['condition'] = ''
|
|
ConfigDict['option'] = ''
|
|
IsUpdSect = True
|
|
Offset = 0
|
|
else:
|
|
if IsDefSect or IsPcdSect or IsUpdSect or IsVpdSect or IsTmpSect:
|
|
|
|
Match = False if DscLine[0] != '!' else True
|
|
if Match:
|
|
Match = re.match("^!(else|endif|ifdef|ifndef|if|elseif|include)\s*(.+)?$", DscLine.split("#")[0])
|
|
Keyword = Match.group(1) if Match else ''
|
|
Remaining = Match.group(2) if Match else ''
|
|
Remaining = '' if Remaining is None else Remaining.strip()
|
|
|
|
if Keyword in ['if', 'elseif', 'ifdef', 'ifndef', 'include'] and not Remaining:
|
|
raise Exception ("ERROR: Expression is expected after '!if' or !elseif' for line '%s'" % DscLine)
|
|
|
|
if Keyword == 'else':
|
|
if IfStack:
|
|
IfStack[-1] = not IfStack[-1]
|
|
else:
|
|
raise Exception ("ERROR: No paired '!if' found for '!else' for line '%s'" % DscLine)
|
|
elif Keyword == 'endif':
|
|
if IfStack:
|
|
IfStack.pop()
|
|
Level = ElifStack.pop()
|
|
if Level > 0:
|
|
del IfStack[-Level:]
|
|
else:
|
|
raise Exception ("ERROR: No paired '!if' found for '!endif' for line '%s'" % DscLine)
|
|
elif Keyword == 'ifdef' or Keyword == 'ifndef':
|
|
Result = self.EvaulateIfdef (Remaining)
|
|
if Keyword == 'ifndef':
|
|
Result = not Result
|
|
IfStack.append(Result)
|
|
ElifStack.append(0)
|
|
elif Keyword == 'if' or Keyword == 'elseif':
|
|
Result = self.EvaluateExpress(Remaining)
|
|
if Keyword == "if":
|
|
ElifStack.append(0)
|
|
IfStack.append(Result)
|
|
else: #elseif
|
|
if IfStack:
|
|
IfStack[-1] = not IfStack[-1]
|
|
IfStack.append(Result)
|
|
ElifStack[-1] = ElifStack[-1] + 1
|
|
else:
|
|
raise Exception ("ERROR: No paired '!if' found for '!elif' for line '%s'" % DscLine)
|
|
else:
|
|
if IfStack:
|
|
Handle = reduce(lambda x,y: x and y, IfStack)
|
|
else:
|
|
Handle = True
|
|
if Handle:
|
|
Match = re.match("!include\s+(.+)", DscLine)
|
|
if Match:
|
|
IncludeFilePath = Match.group(1)
|
|
IncludeFilePath = self.ExpandMacros(IncludeFilePath)
|
|
PackagesPath = os.getenv("PACKAGES_PATH")
|
|
if PackagesPath:
|
|
for PackagePath in PackagesPath.split(os.pathsep):
|
|
IncludeFilePathAbs = os.path.join(os.path.normpath(PackagePath), os.path.normpath(IncludeFilePath))
|
|
if os.path.exists(IncludeFilePathAbs):
|
|
IncludeDsc = open(IncludeFilePathAbs, "r")
|
|
break
|
|
else:
|
|
IncludeDsc = open(IncludeFilePath, "r")
|
|
if IncludeDsc == None:
|
|
print("ERROR: Cannot open file '%s'" % IncludeFilePath)
|
|
raise SystemExit
|
|
|
|
# Update DscTime when newer DSC time found.
|
|
CurrentDscTime = os.path.getmtime(os.path.realpath(IncludeDsc.name))
|
|
if CurrentDscTime > self._DscTime:
|
|
self._DscTime = CurrentDscTime
|
|
|
|
NewDscLines = IncludeDsc.readlines()
|
|
IncludeDsc.close()
|
|
DscLines = NewDscLines + DscLines
|
|
del self._DscLines[-1]
|
|
Offset = 0
|
|
else:
|
|
if DscLine.startswith('!'):
|
|
print("ERROR: Unrecognized directive for line '%s'" % DscLine)
|
|
raise SystemExit
|
|
if not Handle:
|
|
del self._DscLines[-1]
|
|
continue
|
|
|
|
if IsDefSect:
|
|
#DEFINE UPD_TOOL_GUID = 8C3D856A-9BE6-468E-850A-24F7A8D38E09
|
|
#DEFINE FSP_T_UPD_TOOL_GUID = 34686CA3-34F9-4901-B82A-BA630F0714C6
|
|
#DEFINE FSP_M_UPD_TOOL_GUID = 39A250DB-E465-4DD1-A2AC-E2BD3C0E2385
|
|
#DEFINE FSP_S_UPD_TOOL_GUID = CAE3605B-5B34-4C85-B3D7-27D54273C40F
|
|
Match = re.match("^\s*(?:DEFINE\s+)*(\w+)\s*=\s*(.+)", DscLine)
|
|
if Match:
|
|
self._MacroDict[Match.group(1)] = self.ExpandMacros(Match.group(2))
|
|
if self.Debug:
|
|
print ("INFO : DEFINE %s = [ %s ]" % (Match.group(1), self.ExpandMacros(Match.group(2))))
|
|
elif IsPcdSect:
|
|
#gSiPkgTokenSpaceGuid.PcdTxtEnable|FALSE
|
|
#gSiPkgTokenSpaceGuid.PcdOverclockEnable|TRUE
|
|
Match = re.match("^\s*([\w\.]+)\s*\|\s*(\w+)", DscLine)
|
|
if Match:
|
|
self._PcdsDict[Match.group(1)] = Match.group(2)
|
|
if self.Debug:
|
|
print ("INFO : PCD %s = [ %s ]" % (Match.group(1), Match.group(2)))
|
|
i = 0
|
|
while i < len(BuildOptionPcd):
|
|
Match = re.match("\s*([\w\.]+)\s*\=\s*(\w+)", BuildOptionPcd[i])
|
|
if Match:
|
|
self._PcdsDict[Match.group(1)] = Match.group(2)
|
|
i += 1
|
|
|
|
elif IsTmpSect:
|
|
# !BSF DEFT:{GPIO_TMPL:START}
|
|
Match = re.match("^\s*#\s+(!BSF)\s+DEFT:{(.+?):(START|END)}", DscLine)
|
|
if Match:
|
|
if Match.group(3) == 'START' and not TemplateName:
|
|
TemplateName = Match.group(2).strip()
|
|
self._BsfTempDict[TemplateName] = []
|
|
if Match.group(3) == 'END' and (TemplateName == Match.group(2).strip()) and TemplateName:
|
|
TemplateName = ''
|
|
else:
|
|
if TemplateName:
|
|
Match = re.match("^!include\s*(.+)?$", DscLine)
|
|
if Match:
|
|
continue
|
|
self._BsfTempDict[TemplateName].append(DscLine)
|
|
|
|
else:
|
|
Match = re.match("^\s*#\s+(!BSF|@Bsf|!HDR)\s+(.+)", DscLine)
|
|
if Match:
|
|
Remaining = Match.group(2)
|
|
if Match.group(1) == '!BSF' or Match.group(1) == '@Bsf':
|
|
Match = re.match("(?:^|.+\s+)PAGES:{(.+?)}", Remaining)
|
|
if Match:
|
|
# !BSF PAGES:{HSW:"Haswell System Agent", LPT:"Lynx Point PCH"}
|
|
PageList = Match.group(1).split(',')
|
|
for Page in PageList:
|
|
Page = Page.strip()
|
|
Match = re.match("(\w+):\"(.+)\"", Page)
|
|
if Match != None:
|
|
self._CfgPageDict[Match.group(1)] = Match.group(2)
|
|
|
|
Match = re.match("(?:^|.+\s+)BLOCK:{NAME:\"(.+)\"\s*,\s*VER:\"(.+)\"\s*}", Remaining)
|
|
if Match:
|
|
self._CfgBlkDict['name'] = Match.group(1)
|
|
self._CfgBlkDict['ver'] = Match.group(2)
|
|
|
|
for Key in self._BsfKeyList:
|
|
Match = re.match("(?:^|.+\s+)%s:{(.+?)}" % Key, Remaining)
|
|
if Match:
|
|
if Key in ['NAME', 'HELP', 'OPTION'] and Match.group(1).startswith('+'):
|
|
ConfigDict[Key.lower()] += Match.group(1)[1:]
|
|
else:
|
|
ConfigDict[Key.lower()] = Match.group(1)
|
|
else:
|
|
for Key in self._HdrKeyList:
|
|
Match = re.match("(?:^|.+\s+)%s:{(.+?)}" % Key, Remaining)
|
|
if Match:
|
|
ConfigDict[Key.lower()] = Match.group(1)
|
|
|
|
Match = re.match("^\s*#\s+@Prompt\s+(.+)", DscLine)
|
|
if Match:
|
|
ConfigDict['name'] = Match.group(1)
|
|
|
|
Match = re.match("^\s*#\s*@ValidList\s*(.+)\s*\|\s*(.+)\s*\|\s*(.+)\s*", DscLine)
|
|
if Match:
|
|
if Match.group(2).strip() in self._BuidinOption:
|
|
ConfigDict['option'] = Match.group(2).strip()
|
|
else:
|
|
OptionValueList = Match.group(2).split(',')
|
|
OptionStringList = Match.group(3).split(',')
|
|
Index = 0
|
|
for Option in OptionValueList:
|
|
Option = Option.strip()
|
|
ConfigDict['option'] = ConfigDict['option'] + str(Option) + ':' + OptionStringList[Index].strip()
|
|
Index += 1
|
|
if Index in range(len(OptionValueList)):
|
|
ConfigDict['option'] += ', '
|
|
ConfigDict['type'] = "Combo"
|
|
|
|
Match = re.match("^\s*#\s*@ValidRange\s*(.+)\s*\|\s*(.+)\s*-\s*(.+)\s*", DscLine)
|
|
if Match:
|
|
if "0x" in Match.group(2) or "0x" in Match.group(3):
|
|
ConfigDict['type'] = "EditNum, HEX, (%s,%s)" % (Match.group(2), Match.group(3))
|
|
else:
|
|
ConfigDict['type'] = "EditNum, DEC, (%s,%s)" % (Match.group(2), Match.group(3))
|
|
|
|
Match = re.match("^\s*##\s+(.+)", DscLine)
|
|
if Match:
|
|
ConfigDict['help'] = Match.group(1)
|
|
|
|
# Check VPD/UPD
|
|
if IsUpdSect:
|
|
Match = re.match("^([_a-zA-Z0-9]+).([_a-zA-Z0-9]+)\s*\|\s*(0x[0-9A-F]+|\*)\s*\|\s*(\d+|0x[0-9a-fA-F]+)\s*\|\s*(.+)",DscLine)
|
|
else:
|
|
Match = re.match("^([_a-zA-Z0-9]+).([_a-zA-Z0-9]+)\s*\|\s*(0x[0-9A-F]+)(?:\s*\|\s*(.+))?", DscLine)
|
|
if Match:
|
|
ConfigDict['space'] = Match.group(1)
|
|
ConfigDict['cname'] = Match.group(2)
|
|
if Match.group(3) != '*':
|
|
Hardcode = True
|
|
Offset = int (Match.group(3), 16)
|
|
else:
|
|
AutoAlign = True
|
|
|
|
if Hardcode and AutoAlign:
|
|
print("Hardcode and auto-align mixed mode is not supported by GenCfgOpt")
|
|
raise SystemExit
|
|
ConfigDict['offset'] = Offset
|
|
if ConfigDict['order'] == -1:
|
|
ConfigDict['order'] = ConfigDict['offset'] << 8
|
|
else:
|
|
(Major, Minor) = ConfigDict['order'].split('.')
|
|
ConfigDict['order'] = (int (Major, 16) << 8 ) + int (Minor, 16)
|
|
if IsUpdSect:
|
|
Value = Match.group(5).strip()
|
|
if Match.group(4).startswith("0x"):
|
|
Length = int (Match.group(4), 16)
|
|
else :
|
|
Length = int (Match.group(4))
|
|
Offset += Length
|
|
else:
|
|
Value = Match.group(4)
|
|
if Value is None:
|
|
Value = ''
|
|
Value = Value.strip()
|
|
if '|' in Value:
|
|
Match = re.match("^.+\s*\|\s*(.+)", Value)
|
|
if Match:
|
|
Value = Match.group(1)
|
|
Length = -1
|
|
|
|
ConfigDict['length'] = Length
|
|
Match = re.match("\$\((\w+)\)", Value)
|
|
if Match:
|
|
if Match.group(1) in self._MacroDict:
|
|
Value = self._MacroDict[Match.group(1)]
|
|
|
|
ConfigDict['value'] = Value
|
|
if (len(Value) > 0) and (Value[0] == '{'):
|
|
Value = self.FormatListValue(ConfigDict)
|
|
|
|
if ConfigDict['name'] == '':
|
|
# Clear BSF specific items
|
|
ConfigDict['bsfname'] = ''
|
|
ConfigDict['help'] = ''
|
|
ConfigDict['type'] = ''
|
|
ConfigDict['option'] = ''
|
|
if IsUpdSect and AutoAlign:
|
|
ItemLength = int(ConfigDict['length'])
|
|
ItemOffset = int(ConfigDict['offset'])
|
|
ItemStruct = ConfigDict['struct']
|
|
Unit = 1
|
|
if ItemLength in [1, 2, 4, 8] and not ConfigDict['value'].startswith('{'):
|
|
Unit = ItemLength
|
|
# If there are 64 bit unit, align to 64
|
|
if Unit == 8:
|
|
MaxAlign = 64
|
|
SizeAlign = 8
|
|
if ItemStruct != '':
|
|
UnitDict = {'UINT8':1, 'UINT16':2, 'UINT32':4, 'UINT64':8}
|
|
if ItemStruct in ['UINT8', 'UINT16', 'UINT32', 'UINT64']:
|
|
Unit = UnitDict[ItemStruct]
|
|
# If there are 64 bit unit, align to 64
|
|
if Unit == 8:
|
|
MaxAlign = 64
|
|
SizeAlign = max(SizeAlign, Unit)
|
|
if (ConfigDict['embed'].find(':START') != -1):
|
|
Base = ItemOffset
|
|
SubOffset = ItemOffset - Base
|
|
SubRemainder = SubOffset % Unit
|
|
if SubRemainder:
|
|
Diff = Unit - SubRemainder
|
|
Offset = Offset + Diff
|
|
ItemOffset = ItemOffset + Diff
|
|
|
|
if (ConfigDict['embed'].find(':END') != -1):
|
|
Remainder = Offset % (MaxAlign/8) # MaxAlign is either 32 or 64
|
|
if Remainder:
|
|
Diff = int((MaxAlign/8) - Remainder)
|
|
Offset = Offset + Diff
|
|
ItemOffset = ItemOffset + Diff
|
|
MaxAlign = 32 # Reset to default 32 align when struct end
|
|
if (ConfigDict['cname'] == 'UpdTerminator'):
|
|
# ItemLength is the size of UpdTerminator
|
|
# Itemlength might be 16, 32, or 64
|
|
# Struct align to 64 if UpdTerminator
|
|
# or struct size is 64 bit, else align to 32
|
|
Remainder = Offset % max(ItemLength/8, 4, SizeAlign)
|
|
Offset = Offset + ItemLength
|
|
if Remainder:
|
|
Diff = int(max(ItemLength/8, 4, SizeAlign) - Remainder)
|
|
ItemOffset = ItemOffset + Diff
|
|
ConfigDict['offset'] = ItemOffset
|
|
|
|
self._CfgItemList.append(ConfigDict.copy())
|
|
ConfigDict['name'] = ''
|
|
ConfigDict['find'] = ''
|
|
ConfigDict['struct'] = ''
|
|
ConfigDict['embed'] = ''
|
|
ConfigDict['comment'] = ''
|
|
ConfigDict['marker'] = ''
|
|
ConfigDict['order'] = -1
|
|
ConfigDict['subreg'] = []
|
|
ConfigDict['option'] = ''
|
|
else:
|
|
# It could be a virtual item as below
|
|
# !BSF FIELD:{SerialDebugPortAddress0:1}
|
|
# or
|
|
# @Bsf FIELD:{SerialDebugPortAddress0:1b}
|
|
Match = re.match("^\s*#\s+(!BSF|@Bsf)\s+FIELD:{(.+):(\d+)([Bb])?}", DscLine)
|
|
if Match:
|
|
SubCfgDict = ConfigDict.copy()
|
|
if (Match.group(4) == None) or (Match.group(4) == 'B'):
|
|
UnitBitLen = 8
|
|
elif Match.group(4) == 'b':
|
|
UnitBitLen = 1
|
|
else:
|
|
print("ERROR: Invalide BSF FIELD length for line '%s'" % DscLine)
|
|
raise SystemExit
|
|
SubCfgDict['cname'] = Match.group(2)
|
|
SubCfgDict['bitlength'] = int (Match.group(3)) * UnitBitLen
|
|
if SubCfgDict['bitlength'] > 0:
|
|
LastItem = self._CfgItemList[-1]
|
|
if len(LastItem['subreg']) == 0:
|
|
SubOffset = 0
|
|
else:
|
|
SubOffset = LastItem['subreg'][-1]['bitoffset'] + LastItem['subreg'][-1]['bitlength']
|
|
SubCfgDict['bitoffset'] = SubOffset
|
|
LastItem['subreg'].append (SubCfgDict.copy())
|
|
ConfigDict['name'] = ''
|
|
return Error
|
|
|
|
def GetBsfBitFields (self, subitem, bytes):
|
|
start = subitem['bitoffset']
|
|
end = start + subitem['bitlength']
|
|
bitsvalue = ''.join('{0:08b}'.format(i) for i in bytes[::-1])
|
|
bitsvalue = bitsvalue[::-1]
|
|
bitslen = len(bitsvalue)
|
|
if start > bitslen or end > bitslen:
|
|
raise Exception ("Invalid bits offset [%d,%d] %d for %s" % (start, end, bitslen, subitem['name']))
|
|
return '0x%X' % (int(bitsvalue[start:end][::-1], 2))
|
|
|
|
def UpdateSubRegionDefaultValue (self):
|
|
Error = 0
|
|
for Item in self._CfgItemList:
|
|
if len(Item['subreg']) == 0:
|
|
continue
|
|
bytearray = []
|
|
if Item['value'][0] == '{':
|
|
binlist = Item['value'][1:-1].split(',')
|
|
for each in binlist:
|
|
each = each.strip()
|
|
if each.startswith('0x'):
|
|
value = int(each, 16)
|
|
else:
|
|
value = int(each)
|
|
bytearray.append(value)
|
|
else:
|
|
if Item['value'].startswith('0x'):
|
|
value = int(Item['value'], 16)
|
|
else:
|
|
value = int(Item['value'])
|
|
idx = 0
|
|
while idx < Item['length']:
|
|
bytearray.append(value & 0xFF)
|
|
value = value >> 8
|
|
idx = idx + 1
|
|
for SubItem in Item['subreg']:
|
|
valuestr = self.GetBsfBitFields(SubItem, bytearray)
|
|
SubItem['value'] = valuestr
|
|
return Error
|
|
|
|
def NoDscFileChange (self, OutPutFile):
|
|
NoFileChange = True
|
|
if not os.path.exists(OutPutFile):
|
|
NoFileChange = False
|
|
else:
|
|
OutputTime = os.path.getmtime(OutPutFile)
|
|
if self._DscTime > OutputTime:
|
|
NoFileChange = False
|
|
return NoFileChange
|
|
|
|
def CreateSplitUpdTxt (self, UpdTxtFile):
|
|
GuidList = ['FSP_T_UPD_TOOL_GUID','FSP_M_UPD_TOOL_GUID','FSP_S_UPD_TOOL_GUID']
|
|
SignatureList = ['0x545F', '0x4D5F','0x535F'] # _T, _M, and _S signature for FSPT, FSPM, FSPS
|
|
for Index in range(len(GuidList)):
|
|
UpdTxtFile = ''
|
|
FvDir = self._FvDir
|
|
if GuidList[Index] not in self._MacroDict:
|
|
self.Error = "%s definition is missing in DSC file" % (GuidList[Index])
|
|
return 1
|
|
|
|
if UpdTxtFile == '':
|
|
UpdTxtFile = os.path.join(FvDir, self._MacroDict[GuidList[Index]] + '.txt')
|
|
|
|
if (self.NoDscFileChange (UpdTxtFile)):
|
|
# DSC has not been modified yet
|
|
# So don't have to re-generate other files
|
|
self.Error = 'No DSC file change, skip to create UPD TXT file'
|
|
return 256
|
|
|
|
TxtFd = open(UpdTxtFile, "w")
|
|
TxtFd.write("%s\n" % (__copyright_txt__ % date.today().year))
|
|
|
|
NextOffset = 0
|
|
SpaceIdx = 0
|
|
StartAddr = 0
|
|
EndAddr = 0
|
|
Default = 'DEFAULT|'
|
|
InRange = False
|
|
for Item in self._CfgItemList:
|
|
if Item['cname'] == 'Signature' and str(Item['value'])[0:6] == SignatureList[Index]:
|
|
StartAddr = Item['offset']
|
|
NextOffset = StartAddr
|
|
InRange = True
|
|
if Item['cname'] == 'UpdTerminator' and InRange == True:
|
|
EndAddr = Item['offset']
|
|
InRange = False
|
|
InRange = False
|
|
for Item in self._CfgItemList:
|
|
if Item['cname'] == 'Signature' and str(Item['value'])[0:6] == SignatureList[Index]:
|
|
InRange = True
|
|
if InRange != True:
|
|
continue
|
|
if Item['cname'] == 'UpdTerminator':
|
|
InRange = False
|
|
if Item['region'] != 'UPD':
|
|
continue
|
|
Offset = Item['offset']
|
|
if StartAddr > Offset or EndAddr < Offset:
|
|
continue
|
|
if NextOffset < Offset:
|
|
# insert one line
|
|
TxtFd.write("%s.UnusedUpdSpace%d|%s0x%04X|0x%04X|{0}\n" % (Item['space'], SpaceIdx, Default, NextOffset - StartAddr, Offset - NextOffset))
|
|
SpaceIdx = SpaceIdx + 1
|
|
NextOffset = Offset + Item['length']
|
|
TxtFd.write("%s.%s|%s0x%04X|%s|%s\n" % (Item['space'],Item['cname'],Default,Item['offset'] - StartAddr,Item['length'],Item['value']))
|
|
TxtFd.close()
|
|
return 0
|
|
|
|
def CreateVarDict (self):
|
|
Error = 0
|
|
self._VarDict = {}
|
|
if len(self._CfgItemList) > 0:
|
|
Item = self._CfgItemList[-1]
|
|
self._VarDict['_LENGTH_'] = '%d' % (Item['offset'] + Item['length'])
|
|
for Item in self._CfgItemList:
|
|
Embed = Item['embed']
|
|
Match = re.match("^(\w+):(\w+):(START|END)", Embed)
|
|
if Match:
|
|
StructName = Match.group(1)
|
|
VarName = '_%s_%s_' % (Match.group(3), StructName)
|
|
if Match.group(3) == 'END':
|
|
self._VarDict[VarName] = Item['offset'] + Item['length']
|
|
self._VarDict['_LENGTH_%s_' % StructName] = \
|
|
self._VarDict['_END_%s_' % StructName] - self._VarDict['_START_%s_' % StructName]
|
|
if Match.group(2).startswith('TAG_'):
|
|
if (self.Mode != 'FSP') and (self._VarDict['_LENGTH_%s_' % StructName] % 4):
|
|
raise Exception("Size of structure '%s' is %d, not DWORD aligned !" % (StructName, self._VarDict['_LENGTH_%s_' % StructName]))
|
|
self._VarDict['_TAG_%s_' % StructName] = int (Match.group(2)[4:], 16) & 0xFFF
|
|
else:
|
|
self._VarDict[VarName] = Item['offset']
|
|
if Item['marker']:
|
|
self._VarDict['_OFFSET_%s_' % Item['marker'].strip()] = Item['offset']
|
|
return Error
|
|
|
|
def UpdateBsfBitUnit (self, Item):
|
|
BitTotal = 0
|
|
BitOffset = 0
|
|
StartIdx = 0
|
|
Unit = None
|
|
UnitDec = {1:'BYTE', 2:'WORD', 4:'DWORD', 8:'QWORD'}
|
|
for Idx, SubItem in enumerate(Item['subreg']):
|
|
if Unit is None:
|
|
Unit = SubItem['bitunit']
|
|
BitLength = SubItem['bitlength']
|
|
BitTotal += BitLength
|
|
BitOffset += BitLength
|
|
|
|
if BitOffset > 64 or BitOffset > Unit * 8:
|
|
break
|
|
|
|
if BitOffset == Unit * 8:
|
|
for SubIdx in range (StartIdx, Idx + 1):
|
|
Item['subreg'][SubIdx]['bitunit'] = Unit
|
|
BitOffset = 0
|
|
StartIdx = Idx + 1
|
|
Unit = None
|
|
|
|
if BitOffset > 0:
|
|
raise Exception ("Bit fields cannot fit into %s for '%s.%s' !" % (UnitDec[Unit], Item['cname'], SubItem['cname']))
|
|
|
|
ExpectedTotal = Item['length'] * 8
|
|
if Item['length'] * 8 != BitTotal:
|
|
raise Exception ("Bit fields total length (%d) does not match length (%d) of '%s' !" % (BitTotal, ExpectedTotal, Item['cname']))
|
|
|
|
def UpdateDefaultValue (self):
|
|
Error = 0
|
|
for Idx, Item in enumerate(self._CfgItemList):
|
|
if len(Item['subreg']) == 0:
|
|
Value = Item['value']
|
|
if (len(Value) > 0) and (Value[0] == '{' or Value[0] == "'" or Value[0] == '"'):
|
|
# {XXX} or 'XXX' strings
|
|
self.FormatListValue(self._CfgItemList[Idx])
|
|
else:
|
|
Match = re.match("(0x[0-9a-fA-F]+|[0-9]+)", Value)
|
|
if not Match:
|
|
NumValue = self.EvaluateExpress (Value)
|
|
Item['value'] = '0x%X' % NumValue
|
|
else:
|
|
ValArray = self.ValueToByteArray (Item['value'], Item['length'])
|
|
for SubItem in Item['subreg']:
|
|
SubItem['value'] = self.GetBsfBitFields(SubItem, ValArray)
|
|
self.UpdateBsfBitUnit (Item)
|
|
return Error
|
|
|
|
def ProcessMultilines (self, String, MaxCharLength):
|
|
Multilines = ''
|
|
StringLength = len(String)
|
|
CurrentStringStart = 0
|
|
StringOffset = 0
|
|
BreakLineDict = []
|
|
if len(String) <= MaxCharLength:
|
|
while (StringOffset < StringLength):
|
|
if StringOffset >= 1:
|
|
if String[StringOffset - 1] == '\\' and String[StringOffset] == 'n':
|
|
BreakLineDict.append (StringOffset + 1)
|
|
StringOffset += 1
|
|
if BreakLineDict != []:
|
|
for Each in BreakLineDict:
|
|
Multilines += " %s\n" % String[CurrentStringStart:Each].lstrip()
|
|
CurrentStringStart = Each
|
|
if StringLength - CurrentStringStart > 0:
|
|
Multilines += " %s\n" % String[CurrentStringStart:].lstrip()
|
|
else:
|
|
Multilines = " %s\n" % String
|
|
else:
|
|
NewLineStart = 0
|
|
NewLineCount = 0
|
|
FoundSpaceChar = False
|
|
while (StringOffset < StringLength):
|
|
if StringOffset >= 1:
|
|
if NewLineCount >= MaxCharLength - 1:
|
|
if String[StringOffset] == ' ' and StringLength - StringOffset > 10:
|
|
BreakLineDict.append (NewLineStart + NewLineCount)
|
|
NewLineStart = NewLineStart + NewLineCount
|
|
NewLineCount = 0
|
|
FoundSpaceChar = True
|
|
elif StringOffset == StringLength - 1 and FoundSpaceChar == False:
|
|
BreakLineDict.append (0)
|
|
if String[StringOffset - 1] == '\\' and String[StringOffset] == 'n':
|
|
BreakLineDict.append (StringOffset + 1)
|
|
NewLineStart = StringOffset + 1
|
|
NewLineCount = 0
|
|
StringOffset += 1
|
|
NewLineCount += 1
|
|
if BreakLineDict != []:
|
|
BreakLineDict.sort ()
|
|
for Each in BreakLineDict:
|
|
if Each > 0:
|
|
Multilines += " %s\n" % String[CurrentStringStart:Each].lstrip()
|
|
CurrentStringStart = Each
|
|
if StringLength - CurrentStringStart > 0:
|
|
Multilines += " %s\n" % String[CurrentStringStart:].lstrip()
|
|
return Multilines
|
|
|
|
def CreateField (self, Item, Name, Length, Offset, Struct, BsfName, Help, Option, BitsLength = None):
|
|
PosName = 28
|
|
PosComment = 30
|
|
NameLine=''
|
|
HelpLine=''
|
|
OptionLine=''
|
|
|
|
if Length == 0 and Name == 'Dummy':
|
|
return '\n'
|
|
|
|
IsArray = False
|
|
if Length in [1,2,4,8]:
|
|
Type = "UINT%d" % (Length * 8)
|
|
if Name.startswith("UnusedUpdSpace") and Length != 1:
|
|
IsArray = True
|
|
Type = "UINT8"
|
|
else:
|
|
IsArray = True
|
|
Type = "UINT8"
|
|
|
|
if Item and Item['value'].startswith('{'):
|
|
Type = "UINT8"
|
|
IsArray = True
|
|
|
|
if Struct != '':
|
|
Type = Struct
|
|
if Struct in ['UINT8','UINT16','UINT32','UINT64']:
|
|
IsArray = True
|
|
Unit = int(Type[4:]) / 8
|
|
Length = Length / Unit
|
|
else:
|
|
IsArray = False
|
|
|
|
if IsArray:
|
|
Name = Name + '[%d]' % Length
|
|
|
|
if len(Type) < PosName:
|
|
Space1 = PosName - len(Type)
|
|
else:
|
|
Space1 = 1
|
|
|
|
if BsfName != '':
|
|
NameLine=" - %s\n" % BsfName
|
|
else:
|
|
NameLine="\n"
|
|
|
|
if Help != '':
|
|
HelpLine = self.ProcessMultilines (Help, 80)
|
|
|
|
if Option != '':
|
|
OptionLine = self.ProcessMultilines (Option, 80)
|
|
|
|
if Offset is None:
|
|
OffsetStr = '????'
|
|
else:
|
|
OffsetStr = '0x%04X' % Offset
|
|
|
|
if BitsLength is None:
|
|
BitsLength = ''
|
|
else:
|
|
BitsLength = ' : %d' % BitsLength
|
|
|
|
return "\n/** Offset %s%s%s%s**/\n %s%s%s%s;\n" % (OffsetStr, NameLine, HelpLine, OptionLine, Type, ' ' * Space1, Name, BitsLength)
|
|
|
|
def PostProcessBody (self, TextBody):
|
|
NewTextBody = []
|
|
OldTextBody = []
|
|
IncludeLine = False
|
|
StructName = ''
|
|
VariableName = ''
|
|
IsUpdHdrDefined = False
|
|
IsUpdHeader = False
|
|
for Line in TextBody:
|
|
SplitToLines = Line.splitlines()
|
|
MatchComment = re.match("^/\*\sCOMMENT:(\w+):([\w|\W|\s]+)\s\*/\s([\s\S]*)", SplitToLines[0])
|
|
if MatchComment:
|
|
if MatchComment.group(1) == 'FSP_UPD_HEADER':
|
|
IsUpdHeader = True
|
|
else:
|
|
IsUpdHeader = False
|
|
if IsUpdHdrDefined != True or IsUpdHeader != True:
|
|
CommentLine = " " + MatchComment.group(2) + "\n"
|
|
NewTextBody.append("/**" + CommentLine + "**/\n")
|
|
Line = Line[(len(SplitToLines[0]) + 1):]
|
|
|
|
Match = re.match("^/\*\sEMBED_STRUCT:(\w+):(\w+):(START|END)\s\*/\s([\s\S]*)", Line)
|
|
if Match:
|
|
Line = Match.group(4)
|
|
if Match.group(1) == 'FSP_UPD_HEADER':
|
|
IsUpdHeader = True
|
|
else:
|
|
IsUpdHeader = False
|
|
|
|
if Match and Match.group(3) == 'START':
|
|
if IsUpdHdrDefined != True or IsUpdHeader != True:
|
|
NewTextBody.append ('typedef struct {\n')
|
|
StructName = Match.group(1)
|
|
VariableName = Match.group(2)
|
|
MatchOffset = re.search('/\*\*\sOffset\s0x([a-fA-F0-9]+)', Line)
|
|
if MatchOffset:
|
|
Offset = int(MatchOffset.group(1), 16)
|
|
else:
|
|
Offset = None
|
|
Line
|
|
IncludeLine = True
|
|
OldTextBody.append (self.CreateField (None, VariableName, 0, Offset, StructName, '', '', ''))
|
|
if IncludeLine:
|
|
if IsUpdHdrDefined != True or IsUpdHeader != True:
|
|
NewTextBody.append (Line)
|
|
else:
|
|
OldTextBody.append (Line)
|
|
|
|
if Match and Match.group(3) == 'END':
|
|
if (StructName != Match.group(1)) or (VariableName != Match.group(2)):
|
|
print ("Unmatched struct name '%s' and '%s' !" % (StructName, Match.group(1)))
|
|
else:
|
|
if IsUpdHdrDefined != True or IsUpdHeader != True:
|
|
NewTextBody.append ('} %s;\n\n' % StructName)
|
|
IsUpdHdrDefined = True
|
|
IncludeLine = False
|
|
NewTextBody.extend(OldTextBody)
|
|
return NewTextBody
|
|
|
|
def WriteLinesWithoutTailingSpace (self, HeaderFd, Line):
|
|
TxtBody2 = Line.splitlines(True)
|
|
for Line2 in TxtBody2:
|
|
Line2 = Line2.rstrip()
|
|
Line2 += '\n'
|
|
HeaderFd.write (Line2)
|
|
return 0
|
|
def CreateHeaderFile (self, InputHeaderFile):
|
|
FvDir = self._FvDir
|
|
|
|
HeaderFileName = 'FspUpd.h'
|
|
HeaderFile = os.path.join(FvDir, HeaderFileName)
|
|
|
|
# Check if header needs to be recreated
|
|
if (self.NoDscFileChange (HeaderFile)):
|
|
# DSC has not been modified yet
|
|
# So don't have to re-generate other files
|
|
self.Error = 'No DSC file change, skip to create UPD header file'
|
|
return 256
|
|
|
|
TxtBody = []
|
|
for Item in self._CfgItemList:
|
|
if str(Item['cname']) == 'Signature' and Item['length'] == 8:
|
|
Value = int(Item['value'], 16)
|
|
Chars = []
|
|
while Value != 0x0:
|
|
Chars.append(chr(Value & 0xFF))
|
|
Value = Value >> 8
|
|
SignatureStr = ''.join(Chars)
|
|
# Signature will be _T / _M / _S for FSPT / FSPM / FSPS accordingly
|
|
if '_T' in SignatureStr[6:6+2]:
|
|
TxtBody.append("#define FSPT_UPD_SIGNATURE %s /* '%s' */\n\n" % (Item['value'], SignatureStr))
|
|
elif '_M' in SignatureStr[6:6+2]:
|
|
TxtBody.append("#define FSPM_UPD_SIGNATURE %s /* '%s' */\n\n" % (Item['value'], SignatureStr))
|
|
elif '_S' in SignatureStr[6:6+2]:
|
|
TxtBody.append("#define FSPS_UPD_SIGNATURE %s /* '%s' */\n\n" % (Item['value'], SignatureStr))
|
|
TxtBody.append("\n")
|
|
|
|
for Region in ['UPD']:
|
|
UpdOffsetTable = []
|
|
UpdSignature = ['0x545F', '0x4D5F', '0x535F'] #['_T', '_M', '_S'] signature for FSPT, FSPM, FSPS
|
|
UpdStructure = ['FSPT_UPD', 'FSPM_UPD', 'FSPS_UPD']
|
|
for Item in self._CfgItemList:
|
|
if Item["cname"] == 'Signature' and Item["value"][0:6] in UpdSignature:
|
|
Item["offset"] = 0 # re-initialize offset to 0 when new UPD structure starting
|
|
UpdOffsetTable.append (Item["offset"])
|
|
|
|
for UpdIdx in range(len(UpdOffsetTable)):
|
|
CommentLine = ""
|
|
for Item in self._CfgItemList:
|
|
if Item["comment"] != '' and Item["offset"] >= UpdOffsetTable[UpdIdx]:
|
|
MatchComment = re.match("^(U|V)PD_DATA_REGION:([\w|\W|\s]+)", Item["comment"])
|
|
if MatchComment and MatchComment.group(1) == Region[0]:
|
|
CommentLine = " " + MatchComment.group(2) + "\n"
|
|
TxtBody.append("/**" + CommentLine + "**/\n")
|
|
elif Item["offset"] >= UpdOffsetTable[UpdIdx] and Item["comment"] == '':
|
|
Match = re.match("^FSP([\w|\W|\s])_UPD", UpdStructure[UpdIdx])
|
|
if Match:
|
|
TxtBody.append("/** Fsp " + Match.group(1) + " UPD Configuration\n**/\n")
|
|
TxtBody.append("typedef struct {\n")
|
|
NextOffset = 0
|
|
SpaceIdx = 0
|
|
Offset = 0
|
|
|
|
LastVisible = True
|
|
ResvOffset = 0
|
|
ResvIdx = 0
|
|
LineBuffer = []
|
|
InRange = False
|
|
for Item in self._CfgItemList:
|
|
if Item['cname'] == 'Signature' and str(Item['value'])[0:6] == UpdSignature[UpdIdx] or Region[0] == 'V':
|
|
InRange = True
|
|
if InRange != True:
|
|
continue
|
|
if Item['cname'] == 'UpdTerminator':
|
|
InRange = False
|
|
|
|
if Item['region'] != Region:
|
|
continue
|
|
|
|
if Item["offset"] < UpdOffsetTable[UpdIdx]:
|
|
continue
|
|
|
|
NextVisible = LastVisible
|
|
|
|
if LastVisible and (Item['header'] == 'OFF'):
|
|
NextVisible = False
|
|
ResvOffset = Item['offset']
|
|
elif (not LastVisible) and Item['header'] == 'ON':
|
|
NextVisible = True
|
|
Name = "Reserved" + Region[0] + "pdSpace%d" % ResvIdx
|
|
ResvIdx = ResvIdx + 1
|
|
TxtBody.append(self.CreateField (Item, Name, Item["offset"] - ResvOffset, ResvOffset, '', '', '', ''))
|
|
|
|
if Offset < Item["offset"]:
|
|
if LastVisible:
|
|
Name = "Unused" + Region[0] + "pdSpace%d" % SpaceIdx
|
|
LineBuffer.append(self.CreateField (Item, Name, Item["offset"] - Offset, Offset, '', '', '', ''))
|
|
SpaceIdx = SpaceIdx + 1
|
|
Offset = Item["offset"]
|
|
|
|
LastVisible = NextVisible
|
|
|
|
Offset = Offset + Item["length"]
|
|
if LastVisible:
|
|
for Each in LineBuffer:
|
|
TxtBody.append (Each)
|
|
LineBuffer = []
|
|
Comment = Item["comment"]
|
|
Embed = Item["embed"].upper()
|
|
if Embed.endswith(':START') or Embed.endswith(':END'):
|
|
if not Comment == '' and Embed.endswith(':START'):
|
|
Marker = '/* COMMENT:%s */ \n' % Item["comment"]
|
|
Marker = Marker + '/* EMBED_STRUCT:%s */ ' % Item["embed"]
|
|
else:
|
|
Marker = '/* EMBED_STRUCT:%s */ ' % Item["embed"]
|
|
else:
|
|
if Embed == '':
|
|
Marker = ''
|
|
else:
|
|
self.Error = "Invalid embedded structure format '%s'!\n" % Item["embed"]
|
|
return 4
|
|
Line = Marker + self.CreateField (Item, Item["cname"], Item["length"], Item["offset"], Item['struct'], Item['name'], Item['help'], Item['option'])
|
|
TxtBody.append(Line)
|
|
if Item['cname'] == 'UpdTerminator':
|
|
break
|
|
TxtBody.append("} " + UpdStructure[UpdIdx] + ";\n\n")
|
|
|
|
# Handle the embedded data structure
|
|
TxtBody = self.PostProcessBody (TxtBody)
|
|
|
|
HeaderTFileName = 'FsptUpd.h'
|
|
HeaderMFileName = 'FspmUpd.h'
|
|
HeaderSFileName = 'FspsUpd.h'
|
|
|
|
UpdRegionCheck = ['FSPT', 'FSPM', 'FSPS'] # FSPX_UPD_REGION
|
|
UpdConfigCheck = ['FSP_T', 'FSP_M', 'FSP_S'] # FSP_X_CONFIG, FSP_X_TEST_CONFIG, FSP_X_RESTRICTED_CONFIG
|
|
UpdSignatureCheck = ['FSPT_UPD_SIGNATURE', 'FSPM_UPD_SIGNATURE', 'FSPS_UPD_SIGNATURE']
|
|
ExcludedSpecificUpd = ['FSPT_ARCH_UPD', 'FSPM_ARCH_UPD', 'FSPS_ARCH_UPD']
|
|
|
|
IncLines = []
|
|
if InputHeaderFile != '':
|
|
if not os.path.exists(InputHeaderFile):
|
|
self.Error = "Input header file '%s' does not exist" % InputHeaderFile
|
|
return 6
|
|
|
|
InFd = open(InputHeaderFile, "r")
|
|
IncLines = InFd.readlines()
|
|
InFd.close()
|
|
|
|
for item in range(len(UpdRegionCheck)):
|
|
if UpdRegionCheck[item] == 'FSPT':
|
|
HeaderFd = open(os.path.join(FvDir, HeaderTFileName), "w")
|
|
FileBase = os.path.basename(os.path.join(FvDir, HeaderTFileName))
|
|
elif UpdRegionCheck[item] == 'FSPM':
|
|
HeaderFd = open(os.path.join(FvDir, HeaderMFileName), "w")
|
|
FileBase = os.path.basename(os.path.join(FvDir, HeaderMFileName))
|
|
elif UpdRegionCheck[item] == 'FSPS':
|
|
HeaderFd = open(os.path.join(FvDir, HeaderSFileName), "w")
|
|
FileBase = os.path.basename(os.path.join(FvDir, HeaderSFileName))
|
|
FileName = FileBase.replace(".", "_").upper()
|
|
HeaderFd.write("%s\n" % (__copyright_h__ % date.today().year))
|
|
HeaderFd.write("#ifndef __%s__\n" % FileName)
|
|
HeaderFd.write("#define __%s__\n\n" % FileName)
|
|
HeaderFd.write("#include <%s>\n\n" % HeaderFileName)
|
|
HeaderFd.write("#pragma pack(1)\n\n")
|
|
|
|
Export = False
|
|
for Line in IncLines:
|
|
Match = re.search ("!EXPORT\s+([A-Z]+)\s+EXTERNAL_BOOTLOADER_STRUCT_(BEGIN|END)\s+", Line)
|
|
if Match:
|
|
if Match.group(2) == "BEGIN" and Match.group(1) == UpdRegionCheck[item]:
|
|
Export = True
|
|
continue
|
|
else:
|
|
Export = False
|
|
continue
|
|
if Export:
|
|
HeaderFd.write(Line)
|
|
HeaderFd.write("\n")
|
|
|
|
Index = 0
|
|
StartIndex = 0
|
|
EndIndex = 0
|
|
StructStart = []
|
|
StructStartWithComment = []
|
|
StructEnd = []
|
|
for Line in TxtBody:
|
|
Index += 1
|
|
Match = re.match("(typedef struct {)", Line)
|
|
if Match:
|
|
StartIndex = Index - 1
|
|
Match = re.match("}\s([_A-Z0-9]+);", Line)
|
|
if Match and (UpdRegionCheck[item] in Match.group(1) or UpdConfigCheck[item] in Match.group(1)) and (ExcludedSpecificUpd[item] not in Match.group(1)):
|
|
EndIndex = Index
|
|
StructStart.append(StartIndex)
|
|
StructEnd.append(EndIndex)
|
|
Index = 0
|
|
for Line in TxtBody:
|
|
Index += 1
|
|
for Item in range(len(StructStart)):
|
|
if Index == StructStart[Item]:
|
|
Match = re.match("^(/\*\*\s*)", Line)
|
|
if Match:
|
|
StructStartWithComment.append(StructStart[Item])
|
|
else:
|
|
StructStartWithComment.append(StructStart[Item] + 1)
|
|
Index = 0
|
|
for Line in TxtBody:
|
|
Index += 1
|
|
for Item in range(len(StructStart)):
|
|
if Index >= StructStartWithComment[Item] and Index <= StructEnd[Item]:
|
|
self.WriteLinesWithoutTailingSpace(HeaderFd, Line)
|
|
HeaderFd.write("#pragma pack()\n\n")
|
|
HeaderFd.write("#endif\n")
|
|
HeaderFd.close()
|
|
|
|
HeaderFd = open(HeaderFile, "w")
|
|
FileBase = os.path.basename(HeaderFile)
|
|
FileName = FileBase.replace(".", "_").upper()
|
|
HeaderFd.write("%s\n" % (__copyright_h__ % date.today().year))
|
|
HeaderFd.write("#ifndef __%s__\n" % FileName)
|
|
HeaderFd.write("#define __%s__\n\n" % FileName)
|
|
HeaderFd.write("#include <FspEas.h>\n\n")
|
|
HeaderFd.write("#pragma pack(1)\n\n")
|
|
|
|
for item in range(len(UpdRegionCheck)):
|
|
Index = 0
|
|
StartIndex = 0
|
|
EndIndex = 0
|
|
StructStart = []
|
|
StructStartWithComment = []
|
|
StructEnd = []
|
|
for Line in TxtBody:
|
|
Index += 1
|
|
Match = re.match("(typedef struct {)", Line)
|
|
if Match:
|
|
StartIndex = Index - 1
|
|
Match = re.match("#define\s([_A-Z0-9]+)\s*", Line)
|
|
if Match and (UpdSignatureCheck[item] in Match.group(1) or UpdSignatureCheck[item] in Match.group(1)):
|
|
StructStart.append(Index - 1)
|
|
StructEnd.append(Index)
|
|
Index = 0
|
|
for Line in TxtBody:
|
|
Index += 1
|
|
for Item in range(len(StructStart)):
|
|
if Index == StructStart[Item]:
|
|
Match = re.match("^(/\*\*\s*)", Line)
|
|
if Match:
|
|
StructStartWithComment.append(StructStart[Item])
|
|
else:
|
|
StructStartWithComment.append(StructStart[Item] + 1)
|
|
Index = 0
|
|
for Line in TxtBody:
|
|
Index += 1
|
|
for Item in range(len(StructStart)):
|
|
if Index >= StructStartWithComment[Item] and Index <= StructEnd[Item]:
|
|
self.WriteLinesWithoutTailingSpace(HeaderFd, Line)
|
|
HeaderFd.write("#pragma pack()\n\n")
|
|
HeaderFd.write("#endif\n")
|
|
HeaderFd.close()
|
|
|
|
return 0
|
|
|
|
def WriteBsfStruct (self, BsfFd, Item):
|
|
LogExpr = CLogicalExpression()
|
|
if Item['type'] == "None":
|
|
Space = "gPlatformFspPkgTokenSpaceGuid"
|
|
else:
|
|
Space = Item['space']
|
|
Line = " $%s_%s" % (Space, Item['cname'])
|
|
Match = re.match("\s*\{([x0-9a-fA-F,\s]+)\}\s*", Item['value'])
|
|
if Match:
|
|
DefaultValue = Match.group(1).strip()
|
|
else:
|
|
DefaultValue = Item['value'].strip()
|
|
if 'bitlength' in Item:
|
|
BsfFd.write(" %s%s%4d bits $_DEFAULT_ = %s\n" % (Line, ' ' * (64 - len(Line)), Item['bitlength'], DefaultValue))
|
|
else:
|
|
BsfFd.write(" %s%s%4d bytes $_DEFAULT_ = %s\n" % (Line, ' ' * (64 - len(Line)), Item['length'], DefaultValue))
|
|
TmpList = []
|
|
if Item['type'] == "Combo":
|
|
if not Item['option'] in self._BuidinOption:
|
|
OptList = Item['option'].split(',')
|
|
for Option in OptList:
|
|
Option = Option.strip()
|
|
(OpVal, OpStr) = Option.split(':')
|
|
test = LogExpr.getNumber (OpVal)
|
|
if test is None:
|
|
raise Exception("Selection Index '%s' is not a number" % OpVal)
|
|
TmpList.append((OpVal, OpStr))
|
|
return TmpList
|
|
|
|
def WriteBsfOption (self, BsfFd, Item):
|
|
PcdName = Item['space'] + '_' + Item['cname']
|
|
WriteHelp = 0
|
|
if Item['type'] == "Combo":
|
|
if Item['option'] in self._BuidinOption:
|
|
Options = self._BuidinOption[Item['option']]
|
|
else:
|
|
Options = PcdName
|
|
BsfFd.write(' %s $%s, "%s", &%s,\n' % (Item['type'], PcdName, Item['name'], Options))
|
|
WriteHelp = 1
|
|
elif Item['type'].startswith("EditNum"):
|
|
Match = re.match("EditNum\s*,\s*(HEX|DEC)\s*,\s*\((\d+|0x[0-9A-Fa-f]+)\s*,\s*(\d+|0x[0-9A-Fa-f]+)\)", Item['type'])
|
|
if Match:
|
|
BsfFd.write(' EditNum $%s, "%s", %s,\n' % (PcdName, Item['name'], Match.group(1)))
|
|
WriteHelp = 2
|
|
elif Item['type'].startswith("EditText"):
|
|
BsfFd.write(' %s $%s, "%s",\n' % (Item['type'], PcdName, Item['name']))
|
|
WriteHelp = 1
|
|
elif Item['type'] == "Table":
|
|
Columns = Item['option'].split(',')
|
|
if len(Columns) != 0:
|
|
BsfFd.write(' %s $%s "%s",' % (Item['type'], PcdName, Item['name']))
|
|
for Col in Columns:
|
|
Fmt = Col.split(':')
|
|
if len(Fmt) != 3:
|
|
raise Exception("Column format '%s' is invalid !" % Fmt)
|
|
try:
|
|
Dtype = int(Fmt[1].strip())
|
|
except:
|
|
raise Exception("Column size '%s' is invalid !" % Fmt[1])
|
|
BsfFd.write('\n Column "%s", %d bytes, %s' % (Fmt[0].strip(), Dtype, Fmt[2].strip()))
|
|
BsfFd.write(',\n')
|
|
WriteHelp = 1
|
|
|
|
if WriteHelp > 0:
|
|
HelpLines = Item['help'].split('\\n\\r')
|
|
FirstLine = True
|
|
for HelpLine in HelpLines:
|
|
if FirstLine:
|
|
FirstLine = False
|
|
BsfFd.write(' Help "%s"\n' % (HelpLine))
|
|
else:
|
|
BsfFd.write(' "%s"\n' % (HelpLine))
|
|
if WriteHelp == 2:
|
|
BsfFd.write(' "Valid range: %s ~ %s"\n' % (Match.group(2), Match.group(3)))
|
|
|
|
def GenerateBsfFile (self, BsfFile):
|
|
|
|
if BsfFile == '':
|
|
self.Error = "BSF output file '%s' is invalid" % BsfFile
|
|
return 1
|
|
|
|
if (self.NoDscFileChange (BsfFile)):
|
|
# DSC has not been modified yet
|
|
# So don't have to re-generate other files
|
|
self.Error = 'No DSC file change, skip to create UPD BSF file'
|
|
return 256
|
|
|
|
Error = 0
|
|
OptionDict = {}
|
|
BsfFd = open(BsfFile, "w")
|
|
BsfFd.write("%s\n" % (__copyright_bsf__ % date.today().year))
|
|
BsfFd.write("%s\n" % self._GlobalDataDef)
|
|
BsfFd.write("StructDef\n")
|
|
NextOffset = -1
|
|
for Item in self._CfgItemList:
|
|
if Item['find'] != '':
|
|
BsfFd.write('\n Find "%s"\n' % Item['find'])
|
|
NextOffset = Item['offset'] + Item['length']
|
|
if Item['name'] != '':
|
|
if NextOffset != Item['offset']:
|
|
BsfFd.write(" Skip %d bytes\n" % (Item['offset'] - NextOffset))
|
|
if len(Item['subreg']) > 0:
|
|
NextOffset = Item['offset']
|
|
BitsOffset = NextOffset * 8
|
|
for SubItem in Item['subreg']:
|
|
BitsOffset += SubItem['bitlength']
|
|
if SubItem['name'] == '':
|
|
if 'bitlength' in SubItem:
|
|
BsfFd.write(" Skip %d bits\n" % (SubItem['bitlength']))
|
|
else:
|
|
BsfFd.write(" Skip %d bytes\n" % (SubItem['length']))
|
|
else:
|
|
Options = self.WriteBsfStruct(BsfFd, SubItem)
|
|
if len(Options) > 0:
|
|
OptionDict[SubItem['space']+'_'+SubItem['cname']] = Options
|
|
|
|
NextBitsOffset = (Item['offset'] + Item['length']) * 8
|
|
if NextBitsOffset > BitsOffset:
|
|
BitsGap = NextBitsOffset - BitsOffset
|
|
BitsRemain = BitsGap % 8
|
|
if BitsRemain:
|
|
BsfFd.write(" Skip %d bits\n" % BitsRemain)
|
|
BitsGap -= BitsRemain
|
|
BytesRemain = int(BitsGap / 8)
|
|
if BytesRemain:
|
|
BsfFd.write(" Skip %d bytes\n" % BytesRemain)
|
|
NextOffset = Item['offset'] + Item['length']
|
|
else:
|
|
NextOffset = Item['offset'] + Item['length']
|
|
Options = self.WriteBsfStruct(BsfFd, Item)
|
|
if len(Options) > 0:
|
|
OptionDict[Item['space']+'_'+Item['cname']] = Options
|
|
BsfFd.write("\nEndStruct\n\n")
|
|
|
|
BsfFd.write("%s" % self._BuidinOptionTxt)
|
|
|
|
for Each in OptionDict:
|
|
BsfFd.write("List &%s\n" % Each)
|
|
for Item in OptionDict[Each]:
|
|
BsfFd.write(' Selection %s , "%s"\n' % (Item[0], Item[1]))
|
|
BsfFd.write("EndList\n\n")
|
|
|
|
BsfFd.write("BeginInfoBlock\n")
|
|
BsfFd.write(' PPVer "%s"\n' % (self._CfgBlkDict['ver']))
|
|
BsfFd.write(' Description "%s"\n' % (self._CfgBlkDict['name']))
|
|
BsfFd.write("EndInfoBlock\n\n")
|
|
|
|
for Each in self._CfgPageDict:
|
|
BsfFd.write('Page "%s"\n' % self._CfgPageDict[Each])
|
|
BsfItems = []
|
|
for Item in self._CfgItemList:
|
|
if Item['name'] != '':
|
|
if Item['page'] != Each:
|
|
continue
|
|
if len(Item['subreg']) > 0:
|
|
for SubItem in Item['subreg']:
|
|
if SubItem['name'] != '':
|
|
BsfItems.append(SubItem)
|
|
else:
|
|
BsfItems.append(Item)
|
|
|
|
BsfItems.sort(key=lambda x: x['order'])
|
|
|
|
for Item in BsfItems:
|
|
self.WriteBsfOption (BsfFd, Item)
|
|
BsfFd.write("EndPage\n\n")
|
|
|
|
BsfFd.close()
|
|
return Error
|
|
|
|
|
|
def Usage():
|
|
print ("GenCfgOpt Version 0.56")
|
|
print ("Usage:")
|
|
print (" GenCfgOpt UPDTXT PlatformDscFile BuildFvDir [-D Macros]")
|
|
print (" GenCfgOpt HEADER PlatformDscFile BuildFvDir InputHFile [-D Macros]")
|
|
print (" GenCfgOpt GENBSF PlatformDscFile BuildFvDir BsfOutFile [-D Macros]")
|
|
|
|
def Main():
|
|
#
|
|
# Parse the options and args
|
|
#
|
|
i = 1
|
|
|
|
GenCfgOpt = CGenCfgOpt()
|
|
while i < len(sys.argv):
|
|
if sys.argv[i].strip().lower() == "--pcd":
|
|
BuildOptionPcd.append(sys.argv[i+1])
|
|
i += 1
|
|
i += 1
|
|
argc = len(sys.argv)
|
|
if argc < 4:
|
|
Usage()
|
|
return 1
|
|
else:
|
|
DscFile = sys.argv[2]
|
|
if not os.path.exists(DscFile):
|
|
print ("ERROR: Cannot open DSC file '%s' !" % DscFile)
|
|
return 2
|
|
|
|
OutFile = ''
|
|
if argc > 4:
|
|
if sys.argv[4][0] == '-':
|
|
Start = 4
|
|
else:
|
|
OutFile = sys.argv[4]
|
|
Start = 5
|
|
if argc > Start:
|
|
if GenCfgOpt.ParseMacros(sys.argv[Start:]) != 0:
|
|
print ("ERROR: Macro parsing failed !")
|
|
return 3
|
|
|
|
FvDir = sys.argv[3]
|
|
if not os.path.exists(FvDir):
|
|
os.makedirs(FvDir)
|
|
|
|
if GenCfgOpt.ParseDscFile(DscFile, FvDir) != 0:
|
|
print ("ERROR: %s !" % GenCfgOpt.Error)
|
|
return 5
|
|
|
|
if GenCfgOpt.UpdateSubRegionDefaultValue() != 0:
|
|
print ("ERROR: %s !" % GenCfgOpt.Error)
|
|
return 7
|
|
|
|
if sys.argv[1] == "UPDTXT":
|
|
Ret = GenCfgOpt.CreateSplitUpdTxt(OutFile)
|
|
if Ret != 0:
|
|
# No change is detected
|
|
if Ret == 256:
|
|
print ("INFO: %s !" % (GenCfgOpt.Error))
|
|
else :
|
|
print ("ERROR: %s !" % (GenCfgOpt.Error))
|
|
return Ret
|
|
elif sys.argv[1] == "HEADER":
|
|
Ret = GenCfgOpt.CreateHeaderFile(OutFile)
|
|
if Ret != 0:
|
|
# No change is detected
|
|
if Ret == 256:
|
|
print ("INFO: %s !" % (GenCfgOpt.Error))
|
|
else :
|
|
print ("ERROR: %s !" % (GenCfgOpt.Error))
|
|
return 8
|
|
return Ret
|
|
elif sys.argv[1] == "GENBSF":
|
|
Ret = GenCfgOpt.GenerateBsfFile(OutFile)
|
|
if Ret != 0:
|
|
# No change is detected
|
|
if Ret == 256:
|
|
print ("INFO: %s !" % (GenCfgOpt.Error))
|
|
else :
|
|
print ("ERROR: %s !" % (GenCfgOpt.Error))
|
|
return 9
|
|
return Ret
|
|
else:
|
|
if argc < 5:
|
|
Usage()
|
|
return 1
|
|
print ("ERROR: Unknown command '%s' !" % sys.argv[1])
|
|
Usage()
|
|
return 1
|
|
return 0
|
|
return 0
|
|
|
|
|
|
if __name__ == '__main__':
|
|
sys.exit(Main())
|