X-Git-Url: https://git.proxmox.com/?a=blobdiff_plain;f=BaseTools%2FSource%2FPython%2FAutoGen%2FGenVar.py;h=3675be8de994fac0c7bf26714d8fdb7207c8db1f;hb=58cf30f71f03bcf2fbf369d51e05c8f17176e129;hp=b8f40da9a39c87d6f5a458be26aed0e232463739;hpb=dea5ef9dc41c5d7a1a6b20a9457433faf92cc623;p=mirror_edk2.git diff --git a/BaseTools/Source/Python/AutoGen/GenVar.py b/BaseTools/Source/Python/AutoGen/GenVar.py index b8f40da9a3..3675be8de9 100644 --- a/BaseTools/Source/Python/AutoGen/GenVar.py +++ b/BaseTools/Source/Python/AutoGen/GenVar.py @@ -26,27 +26,6 @@ var_info = collections.namedtuple("uefi_var", "pcdindex,pcdname,defaultstoragena NvStorageHeaderSize = 28 VariableHeaderSize = 32 -def StringArrayToList(StringArray): - StringArray = StringArray[1:-1] - StringArray = '[' + StringArray + ']' - return eval(StringArray) - -def PackGUID(Guid): - GuidBuffer = pack('=LHHBBBBBBBB', - int(Guid[0], 16), - int(Guid[1], 16), - int(Guid[2], 16), - int(Guid[3][-4:-2], 16), - int(Guid[3][-2:], 16), - int(Guid[4][-12:-10], 16), - int(Guid[4][-10:-8], 16), - int(Guid[4][-8:-6], 16), - int(Guid[4][-6:-4], 16), - int(Guid[4][-4:-2], 16), - int(Guid[4][-2:], 16) - ) - return GuidBuffer - class VariableMgr(object): def __init__(self, DefaultStoreMap,SkuIdMap): self.VarInfo = [] @@ -71,7 +50,7 @@ class VariableMgr(object): if not self.NVHeaderBuff: return "" self.NVHeaderBuff = self.NVHeaderBuff[:8] + pack("=Q",maxsize) - default_var_bin = self.format_data(self.NVHeaderBuff + self.VarDefaultBuff + self.VarDeltaBuff) + default_var_bin = VariableMgr.format_data(self.NVHeaderBuff + self.VarDefaultBuff + self.VarDeltaBuff) value_str = "{" default_var_bin_strip = [ data.strip("""'""") for data in default_var_bin] value_str += ",".join(default_var_bin_strip) @@ -92,40 +71,30 @@ class VariableMgr(object): data_type = item.data_type value_list = item.default_value.strip("{").strip("}").split(",") if data_type in DataType.TAB_PCD_NUMERIC_TYPES: - if data_type == ["BOOLEAN", DataType.TAB_UINT8]: - data_flag = "=B" - elif data_type == DataType.TAB_UINT16: - data_flag = "=H" - elif data_type == DataType.TAB_UINT32: - data_flag = "=L" - elif data_type == DataType.TAB_UINT64: - data_flag = "=Q" + data_flag = DataType.PACK_CODE_BY_SIZE[MAX_SIZE_TYPE[data_type]] data = value_list[0] value_list = [] for data_byte in pack(data_flag,int(data,16) if data.upper().startswith('0X') else int(data)): - value_list += [hex(unpack("B",data_byte)[0])] + value_list.append(hex(unpack("B",data_byte)[0])) newvalue[int(item.var_offset,16) if item.var_offset.upper().startswith("0X") else int(item.var_offset)] = value_list try: - newvaluestr = "{" + ",".join(self.assemble_variable(newvalue)) +"}" + newvaluestr = "{" + ",".join(VariableMgr.assemble_variable(newvalue)) +"}" except: - EdkLogger.error("build", AUTOGEN_ERROR, "Variable offset conflict in PCDs: %s \n" % (" and ".join([item.pcdname for item in sku_var_info_offset_list]))) + EdkLogger.error("build", AUTOGEN_ERROR, "Variable offset conflict in PCDs: %s \n" % (" and ".join(item.pcdname for item in sku_var_info_offset_list))) n = sku_var_info_offset_list[0] indexedvarinfo[key] = [var_info(n.pcdindex,n.pcdname,n.defaultstoragename,n.skuname,n.var_name, n.var_guid, "0x00",n.var_attribute,newvaluestr , newvaluestr , DataType.TAB_VOID)] self.VarInfo = [item[0] for item in indexedvarinfo.values()] @staticmethod def assemble_variable(valuedict): - ordered_offset = sorted(valuedict.keys()) - ordered_value = [valuedict[k] for k in ordered_offset] + ordered_valuedict_keys = sorted(valuedict.keys()) var_value = [] - num = 0 - for offset in ordered_offset: - if offset < len(var_value): + for current_valuedict_key in ordered_valuedict_keys: + if current_valuedict_key < len(var_value): raise - for _ in xrange(offset - len(var_value)): + for _ in xrange(current_valuedict_key - len(var_value)): var_value.append('0x00') - var_value += ordered_value[num] - num +=1 + var_value += valuedict[current_valuedict_key] return var_value def process_variable_data(self): @@ -144,14 +113,14 @@ class VariableMgr(object): default_data_buffer = "" others_data_buffer = "" tail = None - default_sku_default = indexedvarinfo.get(index).get((DataType.TAB_DEFAULT,DataType.TAB_DEFAULT_STORES_DEFAULT)) + default_sku_default = indexedvarinfo[index].get((DataType.TAB_DEFAULT,DataType.TAB_DEFAULT_STORES_DEFAULT)) if default_sku_default.data_type not in DataType.TAB_PCD_NUMERIC_TYPES: - var_max_len = max([len(var_item.default_value.split(",")) for var_item in sku_var_info.values()]) + var_max_len = max(len(var_item.default_value.split(",")) for var_item in sku_var_info.values()) if len(default_sku_default.default_value.split(",")) < var_max_len: - tail = ",".join([ "0x00" for i in range(var_max_len-len(default_sku_default.default_value.split(",")))]) + tail = ",".join("0x00" for i in range(var_max_len-len(default_sku_default.default_value.split(",")))) - default_data_buffer = self.PACK_VARIABLES_DATA(default_sku_default.default_value,default_sku_default.data_type,tail) + default_data_buffer = VariableMgr.PACK_VARIABLES_DATA(default_sku_default.default_value,default_sku_default.data_type,tail) default_data_array = () for item in default_data_buffer: @@ -159,23 +128,23 @@ class VariableMgr(object): var_data[(DataType.TAB_DEFAULT,DataType.TAB_DEFAULT_STORES_DEFAULT)][index] = (default_data_buffer,sku_var_info[(DataType.TAB_DEFAULT,DataType.TAB_DEFAULT_STORES_DEFAULT)]) - for (skuid,defaultstoragename) in indexedvarinfo.get(index): + for (skuid,defaultstoragename) in indexedvarinfo[index]: tail = None if (skuid,defaultstoragename) == (DataType.TAB_DEFAULT,DataType.TAB_DEFAULT_STORES_DEFAULT): continue - other_sku_other = indexedvarinfo.get(index).get((skuid,defaultstoragename)) + other_sku_other = indexedvarinfo[index][(skuid,defaultstoragename)] if default_sku_default.data_type not in DataType.TAB_PCD_NUMERIC_TYPES: if len(other_sku_other.default_value.split(",")) < var_max_len: - tail = ",".join([ "0x00" for i in range(var_max_len-len(other_sku_other.default_value.split(",")))]) + tail = ",".join("0x00" for i in range(var_max_len-len(other_sku_other.default_value.split(",")))) - others_data_buffer = self.PACK_VARIABLES_DATA(other_sku_other.default_value,other_sku_other.data_type,tail) + others_data_buffer = VariableMgr.PACK_VARIABLES_DATA(other_sku_other.default_value,other_sku_other.data_type,tail) others_data_array = () for item in others_data_buffer: others_data_array += unpack("B",item) - data_delta = self.calculate_delta(default_data_array, others_data_array) + data_delta = VariableMgr.calculate_delta(default_data_array, others_data_array) var_data[(skuid,defaultstoragename)][index] = (data_delta,sku_var_info[(skuid,defaultstoragename)]) return var_data @@ -193,7 +162,7 @@ class VariableMgr(object): var_data_offset = collections.OrderedDict() offset = NvStorageHeaderSize for default_data,default_info in pcds_default_data.values(): - var_name_buffer = self.PACK_VARIABLE_NAME(default_info.var_name) + var_name_buffer = VariableMgr.PACK_VARIABLE_NAME(default_info.var_name) vendorguid = default_info.var_guid.split('-') @@ -202,25 +171,25 @@ class VariableMgr(object): else: var_attr_value = 0x07 - DataBuffer = self.AlignData(var_name_buffer + default_data) + DataBuffer = VariableMgr.AlignData(var_name_buffer + default_data) data_size = len(DataBuffer) offset += VariableHeaderSize + len(default_info.var_name.split(",")) var_data_offset[default_info.pcdindex] = offset offset += data_size - len(default_info.var_name.split(",")) - var_header_buffer = self.PACK_VARIABLE_HEADER(var_attr_value, len(default_info.var_name.split(",")), len (default_data), vendorguid) + var_header_buffer = VariableMgr.PACK_VARIABLE_HEADER(var_attr_value, len(default_info.var_name.split(",")), len (default_data), vendorguid) NvStoreDataBuffer += (var_header_buffer + DataBuffer) - variable_storage_header_buffer = self.PACK_VARIABLE_STORE_HEADER(len(NvStoreDataBuffer) + 28) + variable_storage_header_buffer = VariableMgr.PACK_VARIABLE_STORE_HEADER(len(NvStoreDataBuffer) + 28) - nv_default_part = self.AlignData(self.PACK_DEFAULT_DATA(0, 0, self.unpack_data(variable_storage_header_buffer+NvStoreDataBuffer)), 8) + nv_default_part = VariableMgr.AlignData(VariableMgr.PACK_DEFAULT_DATA(0, 0, VariableMgr.unpack_data(variable_storage_header_buffer+NvStoreDataBuffer)), 8) data_delta_structure_buffer = "" for skuname,defaultstore in var_data: if (skuname,defaultstore) == (DataType.TAB_DEFAULT,DataType.TAB_DEFAULT_STORES_DEFAULT): continue - pcds_sku_data = var_data.get((skuname,defaultstore)) + pcds_sku_data = var_data[(skuname,defaultstore)] delta_data_set = [] for pcdindex in pcds_sku_data: offset = var_data_offset[pcdindex] @@ -228,29 +197,31 @@ class VariableMgr(object): delta_data = [(item[0] + offset, item[1]) for item in delta_data] delta_data_set.extend(delta_data) - data_delta_structure_buffer += self.AlignData(self.PACK_DELTA_DATA(skuname,defaultstore,delta_data_set), 8) + data_delta_structure_buffer += VariableMgr.AlignData(self.PACK_DELTA_DATA(skuname,defaultstore,delta_data_set), 8) size = len(nv_default_part + data_delta_structure_buffer) + 16 maxsize = self.VpdRegionSize if self.VpdRegionSize else size - NV_Store_Default_Header = self.PACK_NV_STORE_DEFAULT_HEADER(size,maxsize) + NV_Store_Default_Header = VariableMgr.PACK_NV_STORE_DEFAULT_HEADER(size,maxsize) self.NVHeaderBuff = NV_Store_Default_Header self.VarDefaultBuff =nv_default_part self.VarDeltaBuff = data_delta_structure_buffer - return self.format_data(NV_Store_Default_Header + nv_default_part + data_delta_structure_buffer) - + return VariableMgr.format_data(NV_Store_Default_Header + nv_default_part + data_delta_structure_buffer) - def format_data(self,data): - return [hex(item) for item in self.unpack_data(data)] + @staticmethod + def format_data(data): + return [hex(item) for item in VariableMgr.unpack_data(data)] - def unpack_data(self,data): + @staticmethod + def unpack_data(data): final_data = () for item in data: final_data += unpack("B",item) return final_data - def calculate_delta(self, default, theother): + @staticmethod + def calculate_delta(default, theother): if len(default) - len(theother) != 0: EdkLogger.error("build", FORMAT_INVALID, 'The variable data length is not the same for the same PCD.') data_delta = [] @@ -270,7 +241,8 @@ class VariableMgr(object): return value_str return "" - def PACK_VARIABLE_STORE_HEADER(self,size): + @staticmethod + def PACK_VARIABLE_STORE_HEADER(size): #Signature: gEfiVariableGuid Guid = "{ 0xddcf3616, 0x3275, 0x4164, { 0x98, 0xb6, 0xfe, 0x85, 0x70, 0x7f, 0xfe, 0x7d }}" Guid = GuidStructureStringToGuidString(Guid) @@ -284,7 +256,8 @@ class VariableMgr(object): return GuidBuffer + SizeBuffer + FormatBuffer + StateBuffer + reservedBuffer - def PACK_NV_STORE_DEFAULT_HEADER(self,size,maxsize): + @staticmethod + def PACK_NV_STORE_DEFAULT_HEADER(size,maxsize): Signature = pack('=B',ord('N')) Signature += pack("=B",ord('S')) Signature += pack("=B",ord('D')) @@ -295,7 +268,8 @@ class VariableMgr(object): return Signature + SizeBuffer + MaxSizeBuffer - def PACK_VARIABLE_HEADER(self,attribute,namesize,datasize,vendorguid): + @staticmethod + def PACK_VARIABLE_HEADER(attribute,namesize,datasize,vendorguid): Buffer = pack('=H',0x55AA) # pack StartID Buffer += pack('=B',0x3F) # pack State @@ -309,7 +283,8 @@ class VariableMgr(object): return Buffer - def PACK_VARIABLES_DATA(self, var_value,data_type, tail = None): + @staticmethod + def PACK_VARIABLES_DATA(var_value,data_type, tail = None): Buffer = "" data_len = 0 if data_type == DataType.TAB_VOID: @@ -338,7 +313,8 @@ class VariableMgr(object): return Buffer - def PACK_DEFAULT_DATA(self, defaultstoragename,skuid,var_value): + @staticmethod + def PACK_DEFAULT_DATA(defaultstoragename,skuid,var_value): Buffer = "" Buffer += pack("=L",4+8+8) Buffer += pack("=Q",int(skuid)) @@ -355,10 +331,12 @@ class VariableMgr(object): if skuname not in self.SkuIdMap: return None return self.SkuIdMap.get(skuname)[0] + def GetDefaultStoreId(self,dname): if dname not in self.DefaultStoreMap: return None return self.DefaultStoreMap.get(dname)[0] + def PACK_DELTA_DATA(self,skuname,defaultstoragename,delta_list): skuid = self.GetSkuId(skuname) defaultstorageid = self.GetDefaultStoreId(defaultstoragename) @@ -374,7 +352,8 @@ class VariableMgr(object): return Buffer - def AlignData(self,data, align = 4): + @staticmethod + def AlignData(data, align = 4): mybuffer = data if (len(data) % align) > 0: for i in range(align - (len(data) % align)): @@ -382,7 +361,8 @@ class VariableMgr(object): return mybuffer - def PACK_VARIABLE_NAME(self, var_name): + @staticmethod + def PACK_VARIABLE_NAME(var_name): Buffer = "" for name_char in var_name.strip("{").strip("}").split(","): Buffer += pack("=B",int(name_char,16))