]> git.proxmox.com Git - mirror_edk2.git/blame_incremental - BaseTools/Source/Python/BPDG/GenVpd.py
projects / mirror_edk2.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
BaseTools: Remove the "from __future__ import" items
[mirror_edk2.git] / BaseTools / Source / Python / BPDG / GenVpd.py
... / ...
CommitLineData
1## @file\r
2# This file include GenVpd class for fix the Vpd type PCD offset, and PcdEntry for describe\r
3# and process each entry of vpd type PCD.\r
4#\r
5# Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved.<BR>\r
6#\r
7# This program and the accompanying materials\r
8# are licensed and made available under the terms and conditions of the BSD License\r
9# which accompanies this distribution. The full text of the license may be found at\r
10# http://opensource.org/licenses/bsd-license.php\r
11#\r
12# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
13# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
14#\r
15\r
16import Common.LongFilePathOs as os\r
17from io import BytesIO\r
18from . import StringTable as st\r
19import array\r
20import re\r
21from Common.LongFilePathSupport import OpenLongFilePath as open\r
22from struct import *\r
23from Common.DataType import MAX_SIZE_TYPE, MAX_VAL_TYPE\r
24import Common.EdkLogger as EdkLogger\r
25import Common.BuildToolError as BuildToolError\r
26\r
27_FORMAT_CHAR = {1: 'B',\r
28 2: 'H',\r
29 4: 'I',\r
30 8: 'Q'\r
31 }\r
32\r
33## The VPD PCD data structure for store and process each VPD PCD entry.\r
34#\r
35# This class contain method to format and pack pcd's value.\r
36#\r
37class PcdEntry:\r
38 def __init__(self, PcdCName, SkuId,PcdOffset, PcdSize, PcdValue, Lineno=None, FileName=None, PcdUnpackValue=None,\r
39 PcdBinOffset=None, PcdBinSize=None, Alignment=None):\r
40 self.PcdCName = PcdCName.strip()\r
41 self.SkuId = SkuId.strip()\r
42 self.PcdOffset = PcdOffset.strip()\r
43 self.PcdSize = PcdSize.strip()\r
44 self.PcdValue = PcdValue.strip()\r
45 self.Lineno = Lineno.strip()\r
46 self.FileName = FileName.strip()\r
47 self.PcdUnpackValue = PcdUnpackValue\r
48 self.PcdBinOffset = PcdBinOffset\r
49 self.PcdBinSize = PcdBinSize\r
50 self.Alignment = Alignment\r
51\r
52 if self.PcdValue == '' :\r
53 EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
54 "Invalid PCD format(Name: %s File: %s line: %s) , no Value specified!" % (self.PcdCName, self.FileName, self.Lineno))\r
55\r
56 if self.PcdOffset == '' :\r
57 EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
58 "Invalid PCD format(Name: %s File: %s Line: %s) , no Offset specified!" % (self.PcdCName, self.FileName, self.Lineno))\r
59\r
60 if self.PcdSize == '' :\r
61 EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
62 "Invalid PCD format(Name: %s File: %s Line: %s), no PcdSize specified!" % (self.PcdCName, self.FileName, self.Lineno))\r
63\r
64 self._GenOffsetValue ()\r
65\r
66 ## Analyze the string value to judge the PCD's datum type equal to Boolean or not.\r
67 #\r
68 # @param ValueString PCD's value\r
69 # @param Size PCD's size\r
70 #\r
71 # @retval True PCD's datum type is Boolean\r
72 # @retval False PCD's datum type is not Boolean.\r
73 #\r
74 def _IsBoolean(self, ValueString, Size):\r
75 if (Size == "1"):\r
76 if ValueString.upper() in ["TRUE", "FALSE"]:\r
77 return True\r
78 elif ValueString in ["0", "1", "0x0", "0x1", "0x00", "0x01"]:\r
79 return True\r
80\r
81 return False\r
82\r
83 ## Convert the PCD's value from string to integer.\r
84 #\r
85 # This function will try to convert the Offset value form string to integer\r
86 # for both hexadecimal and decimal.\r
87 #\r
88 def _GenOffsetValue(self):\r
89 if self.PcdOffset != "*" :\r
90 try:\r
91 self.PcdBinOffset = int (self.PcdOffset)\r
92 except:\r
93 try:\r
94 self.PcdBinOffset = int(self.PcdOffset, 16)\r
95 except:\r
96 EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
97 "Invalid offset value %s for PCD %s (File: %s Line: %s)" % (self.PcdOffset, self.PcdCName, self.FileName, self.Lineno))\r
98\r
99 ## Pack Boolean type VPD PCD's value form string to binary type.\r
100 #\r
101 # @param ValueString The boolean type string for pack.\r
102 #\r
103 #\r
104 def _PackBooleanValue(self, ValueString):\r
105 if ValueString.upper() == "TRUE" or ValueString in ["1", "0x1", "0x01"]:\r
106 try:\r
107 self.PcdValue = pack(_FORMAT_CHAR[1], 1)\r
108 except:\r
109 EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
110 "Invalid size or value for PCD %s to pack(File: %s Line: %s)." % (self.PcdCName, self.FileName, self.Lineno))\r
111 else:\r
112 try:\r
113 self.PcdValue = pack(_FORMAT_CHAR[1], 0)\r
114 except:\r
115 EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
116 "Invalid size or value for PCD %s to pack(File: %s Line: %s)." % (self.PcdCName, self.FileName, self.Lineno))\r
117\r
118 ## Pack Integer type VPD PCD's value form string to binary type.\r
119 #\r
120 # @param ValueString The Integer type string for pack.\r
121 #\r
122 #\r
123 def _PackIntValue(self, IntValue, Size):\r
124 if Size not in _FORMAT_CHAR:\r
125 EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
126 "Invalid size %d for PCD %s in integer datum size(File: %s Line: %s)." % (Size, self.PcdCName, self.FileName, self.Lineno))\r
127\r
128 for Type, MaxSize in MAX_SIZE_TYPE.items():\r
129 if Type == 'BOOLEAN':\r
130 continue\r
131 if Size == MaxSize:\r
132 if IntValue < 0:\r
133 EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
134 "PCD can't be set to negative value %d for PCD %s in %s datum type(File: %s Line: %s)." % (\r
135 IntValue, self.PcdCName, Type, self.FileName, self.Lineno))\r
136 elif IntValue > MAX_VAL_TYPE[Type]:\r
137 EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
138 "Too large PCD value %d for datum type %s for PCD %s(File: %s Line: %s)." % (\r
139 IntValue, Type, self.PcdCName, self.FileName, self.Lineno))\r
140\r
141 try:\r
142 self.PcdValue = pack(_FORMAT_CHAR[Size], IntValue)\r
143 except:\r
144 EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
145 "Invalid size or value for PCD %s to pack(File: %s Line: %s)." % (self.PcdCName, self.FileName, self.Lineno))\r
146\r
147 ## Pack VOID* type VPD PCD's value form string to binary type.\r
148 #\r
149 # The VOID* type of string divided into 3 sub-type:\r
150 # 1: L"String"/L'String', Unicode type string.\r
151 # 2: "String"/'String', Ascii type string.\r
152 # 3: {bytearray}, only support byte-array.\r
153 #\r
154 # @param ValueString The Integer type string for pack.\r
155 #\r
156 def _PackPtrValue(self, ValueString, Size):\r
157 if ValueString.startswith('L"') or ValueString.startswith("L'"):\r
158 self._PackUnicode(ValueString, Size)\r
159 elif ValueString.startswith('{') and ValueString.endswith('}'):\r
160 self._PackByteArray(ValueString, Size)\r
161 elif (ValueString.startswith('"') and ValueString.endswith('"')) or (ValueString.startswith("'") and ValueString.endswith("'")):\r
162 self._PackString(ValueString, Size)\r
163 else:\r
164 EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
165 "Invalid VOID* type PCD %s value %s (File: %s Line: %s)" % (self.PcdCName, ValueString, self.FileName, self.Lineno))\r
166\r
167 ## Pack an Ascii PCD value.\r
168 #\r
169 # An Ascii string for a PCD should be in format as ""/''.\r
170 #\r
171 def _PackString(self, ValueString, Size):\r
172 if (Size < 0):\r
173 EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
174 "Invalid parameter Size %s of PCD %s!(File: %s Line: %s)" % (self.PcdBinSize, self.PcdCName, self.FileName, self.Lineno))\r
175 if (ValueString == ""):\r
176 EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID, "Invalid parameter ValueString %s of PCD %s!(File: %s Line: %s)" % (self.PcdUnpackValue, self.PcdCName, self.FileName, self.Lineno))\r
177\r
178 QuotedFlag = True\r
179 if ValueString.startswith("'"):\r
180 QuotedFlag = False\r
181\r
182 ValueString = ValueString[1:-1]\r
183 # No null-terminator in 'string'\r
184 if (QuotedFlag and len(ValueString) + 1 > Size) or (not QuotedFlag and len(ValueString) > Size):\r
185 EdkLogger.error("BPDG", BuildToolError.RESOURCE_OVERFLOW,\r
186 "PCD value string %s is exceed to size %d(File: %s Line: %s)" % (ValueString, Size, self.FileName, self.Lineno))\r
187 try:\r
188 self.PcdValue = pack('%ds' % Size, ValueString)\r
189 except:\r
190 EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
191 "Invalid size or value for PCD %s to pack(File: %s Line: %s)." % (self.PcdCName, self.FileName, self.Lineno))\r
192\r
193 ## Pack a byte-array PCD value.\r
194 #\r
195 # A byte-array for a PCD should be in format as {0x01, 0x02, ...}.\r
196 #\r
197 def _PackByteArray(self, ValueString, Size):\r
198 if (Size < 0):\r
199 EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID, "Invalid parameter Size %s of PCD %s!(File: %s Line: %s)" % (self.PcdBinSize, self.PcdCName, self.FileName, self.Lineno))\r
200 if (ValueString == ""):\r
201 EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID, "Invalid parameter ValueString %s of PCD %s!(File: %s Line: %s)" % (self.PcdUnpackValue, self.PcdCName, self.FileName, self.Lineno))\r
202\r
203 ValueString = ValueString.strip()\r
204 ValueString = ValueString.lstrip('{').strip('}')\r
205 ValueList = ValueString.split(',')\r
206 ValueList = [item.strip() for item in ValueList]\r
207\r
208 if len(ValueList) > Size:\r
209 EdkLogger.error("BPDG", BuildToolError.RESOURCE_OVERFLOW,\r
210 "The byte array %s is too large for size %d(File: %s Line: %s)" % (ValueString, Size, self.FileName, self.Lineno))\r
211\r
212 ReturnArray = array.array('B')\r
213\r
214 for Index in xrange(len(ValueList)):\r
215 Value = None\r
216 if ValueList[Index].lower().startswith('0x'):\r
217 # translate hex value\r
218 try:\r
219 Value = int(ValueList[Index], 16)\r
220 except:\r
221 EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
222 "The value item %s in byte array %s is an invalid HEX value.(File: %s Line: %s)" % \\r
223 (ValueList[Index], ValueString, self.FileName, self.Lineno))\r
224 else:\r
225 # translate decimal value\r
226 try:\r
227 Value = int(ValueList[Index], 10)\r
228 except:\r
229 EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
230 "The value item %s in byte array %s is an invalid DECIMAL value.(File: %s Line: %s)" % \\r
231 (ValueList[Index], ValueString, self.FileName, self.Lineno))\r
232\r
233 if Value > 255:\r
234 EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
235 "The value item %s in byte array %s do not in range 0 ~ 0xFF(File: %s Line: %s)" % \\r
236 (ValueList[Index], ValueString, self.FileName, self.Lineno))\r
237\r
238 ReturnArray.append(Value)\r
239\r
240 for Index in xrange(len(ValueList), Size):\r
241 ReturnArray.append(0)\r
242\r
243 self.PcdValue = ReturnArray.tolist()\r
244\r
245 ## Pack a unicode PCD value into byte array.\r
246 #\r
247 # A unicode string for a PCD should be in format as L""/L''.\r
248 #\r
249 def _PackUnicode(self, UnicodeString, Size):\r
250 if (Size < 0):\r
251 EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID, "Invalid parameter Size %s of PCD %s!(File: %s Line: %s)" % \\r
252 (self.PcdBinSize, self.PcdCName, self.FileName, self.Lineno))\r
253\r
254 QuotedFlag = True\r
255 if UnicodeString.startswith("L'"):\r
256 QuotedFlag = False\r
257 UnicodeString = UnicodeString[2:-1]\r
258\r
259 # No null-terminator in L'string'\r
260 if (QuotedFlag and (len(UnicodeString) + 1) * 2 > Size) or (not QuotedFlag and len(UnicodeString) * 2 > Size):\r
261 EdkLogger.error("BPDG", BuildToolError.RESOURCE_OVERFLOW,\r
262 "The size of unicode string %s is too larger for size %s(File: %s Line: %s)" % \\r
263 (UnicodeString, Size, self.FileName, self.Lineno))\r
264\r
265 ReturnArray = array.array('B')\r
266 for Value in UnicodeString:\r
267 try:\r
268 ReturnArray.append(ord(Value))\r
269 ReturnArray.append(0)\r
270 except:\r
271 EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
272 "Invalid unicode character %s in unicode string %s(File: %s Line: %s)" % \\r
273 (Value, UnicodeString, self.FileName, self.Lineno))\r
274\r
275 for Index in xrange(len(UnicodeString) * 2, Size):\r
276 ReturnArray.append(0)\r
277\r
278 self.PcdValue = ReturnArray.tolist()\r
279\r
280\r
281\r
282## The class implementing the BPDG VPD PCD offset fix process\r
283#\r
284# The VPD PCD offset fix process includes:\r
285# 1. Parse the input guided.txt file and store it in the data structure;\r
286# 2. Format the input file data to remove unused lines;\r
287# 3. Fixed offset if needed;\r
288# 4. Generate output file, including guided.map and guided.bin file;\r
289#\r
290class GenVPD :\r
291 ## Constructor of DscBuildData\r
292 #\r
293 # Initialize object of GenVPD\r
294 # @Param InputFileName The filename include the vpd type pcd information\r
295 # @param MapFileName The filename of map file that stores vpd type pcd information.\r
296 # This file will be generated by the BPDG tool after fix the offset\r
297 # and adjust the offset to make the pcd data aligned.\r
298 # @param VpdFileName The filename of Vpd file that hold vpd pcd information.\r
299 #\r
300 def __init__(self, InputFileName, MapFileName, VpdFileName):\r
301 self.InputFileName = InputFileName\r
302 self.MapFileName = MapFileName\r
303 self.VpdFileName = VpdFileName\r
304 self.FileLinesList = []\r
305 self.PcdFixedOffsetSizeList = []\r
306 self.PcdUnknownOffsetList = []\r
307 try:\r
308 fInputfile = open(InputFileName, "r", 0)\r
309 try:\r
310 self.FileLinesList = fInputfile.readlines()\r
311 except:\r
312 EdkLogger.error("BPDG", BuildToolError.FILE_READ_FAILURE, "File read failed for %s" % InputFileName, None)\r
313 finally:\r
314 fInputfile.close()\r
315 except:\r
316 EdkLogger.error("BPDG", BuildToolError.FILE_OPEN_FAILURE, "File open failed for %s" % InputFileName, None)\r
317\r
318 ##\r
319 # Parser the input file which is generated by the build tool. Convert the value of each pcd's\r
320 # from string to it's real format. Also remove the useless line in the input file.\r
321 #\r
322 def ParserInputFile (self):\r
323 count = 0\r
324 for line in self.FileLinesList:\r
325 # Strip "\r\n" generated by readlines ().\r
326 line = line.strip()\r
327 line = line.rstrip(os.linesep)\r
328\r
329 # Skip the comment line\r
330 if (not line.startswith("#")) and len(line) > 1 :\r
331 #\r
332 # Enhanced for support "|" character in the string.\r
333 #\r
334 ValueList = ['', '', '', '', '']\r
335\r
336 ValueRe = re.compile(r'\s*L?\".*\|.*\"\s*$')\r
337 PtrValue = ValueRe.findall(line)\r
338\r
339 ValueUpdateFlag = False\r
340\r
341 if len(PtrValue) >= 1:\r
342 line = re.sub(ValueRe, '', line)\r
343 ValueUpdateFlag = True\r
344\r
345 TokenList = line.split('|')\r
346 ValueList[0:len(TokenList)] = TokenList\r
347\r
348 if ValueUpdateFlag:\r
349 ValueList[4] = PtrValue[0]\r
350 self.FileLinesList[count] = ValueList\r
351 # Store the line number\r
352 self.FileLinesList[count].append(str(count + 1))\r
353 elif len(line) <= 1 :\r
354 # Set the blank line to "None"\r
355 self.FileLinesList[count] = None\r
356 else :\r
357 # Set the comment line to "None"\r
358 self.FileLinesList[count] = None\r
359 count += 1\r
360\r
361 # The line count contain usage information\r
362 count = 0\r
363 # Delete useless lines\r
364 while (True) :\r
365 try :\r
366 if (self.FileLinesList[count] is None) :\r
367 del(self.FileLinesList[count])\r
368 else :\r
369 count += 1\r
370 except :\r
371 break\r
372 #\r
373 # After remove the useless line, if there are no data remain in the file line list,\r
374 # Report warning messages to user's.\r
375 #\r
376 if len(self.FileLinesList) == 0 :\r
377 EdkLogger.warn('BPDG', BuildToolError.RESOURCE_NOT_AVAILABLE,\r
378 "There are no VPD type pcds defined in DSC file, Please check it.")\r
379\r
380 # Process the pcds one by one base on the pcd's value and size\r
381 count = 0\r
382 for line in self.FileLinesList:\r
383 if line is not None :\r
384 PCD = PcdEntry(line[0], line[1], line[2], line[3], line[4], line[5], self.InputFileName)\r
385 # Strip the space char\r
386 PCD.PcdCName = PCD.PcdCName.strip(' ')\r
387 PCD.SkuId = PCD.SkuId.strip(' ')\r
388 PCD.PcdOffset = PCD.PcdOffset.strip(' ')\r
389 PCD.PcdSize = PCD.PcdSize.strip(' ')\r
390 PCD.PcdValue = PCD.PcdValue.strip(' ')\r
391 PCD.Lineno = PCD.Lineno.strip(' ')\r
392\r
393 #\r
394 # Store the original pcd value.\r
395 # This information will be useful while generate the output map file.\r
396 #\r
397 PCD.PcdUnpackValue = str(PCD.PcdValue)\r
398\r
399 #\r
400 # Translate PCD size string to an integer value.\r
401 PackSize = None\r
402 try:\r
403 PackSize = int(PCD.PcdSize, 10)\r
404 PCD.PcdBinSize = PackSize\r
405 except:\r
406 try:\r
407 PackSize = int(PCD.PcdSize, 16)\r
408 PCD.PcdBinSize = PackSize\r
409 except:\r
410 EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID, "Invalid PCD size value %s at file: %s line: %s" % (PCD.PcdSize, self.InputFileName, PCD.Lineno))\r
411\r
412 #\r
413 # If value is Unicode string (e.g. L""), then use 2-byte alignment\r
414 # If value is byte array (e.g. {}), then use 8-byte alignment\r
415 #\r
416 PCD.PcdOccupySize = PCD.PcdBinSize\r
417 if PCD.PcdUnpackValue.startswith("{"):\r
418 Alignment = 8\r
419 elif PCD.PcdUnpackValue.startswith("L"):\r
420 Alignment = 2\r
421 else:\r
422 Alignment = 1\r
423\r
424 PCD.Alignment = Alignment\r
425 if PCD.PcdOffset != '*':\r
426 if PCD.PcdOccupySize % Alignment != 0:\r
427 if PCD.PcdUnpackValue.startswith("{"):\r
428 EdkLogger.warn("BPDG", "The offset value of PCD %s is not 8-byte aligned!" %(PCD.PcdCName), File=self.InputFileName)\r
429 else:\r
430 EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID, 'The offset value of PCD %s should be %s-byte aligned.' % (PCD.PcdCName, Alignment))\r
431 else:\r
432 if PCD.PcdOccupySize % Alignment != 0:\r
433 PCD.PcdOccupySize = (PCD.PcdOccupySize / Alignment + 1) * Alignment\r
434\r
435 PackSize = PCD.PcdOccupySize\r
436 if PCD._IsBoolean(PCD.PcdValue, PCD.PcdSize):\r
437 PCD._PackBooleanValue(PCD.PcdValue)\r
438 self.FileLinesList[count] = PCD\r
439 count += 1\r
440 continue\r
441 #\r
442 # Try to translate value to an integer firstly.\r
443 #\r
444 IsInteger = True\r
445 PackValue = None\r
446 try:\r
447 PackValue = int(PCD.PcdValue)\r
448 except:\r
449 try:\r
450 PackValue = int(PCD.PcdValue, 16)\r
451 except:\r
452 IsInteger = False\r
453\r
454 if IsInteger:\r
455 PCD._PackIntValue(PackValue, PackSize)\r
456 else:\r
457 PCD._PackPtrValue(PCD.PcdValue, PackSize)\r
458\r
459 self.FileLinesList[count] = PCD\r
460 count += 1\r
461 else :\r
462 continue\r
463\r
464 ##\r
465 # This function used to create a clean list only contain useful information and reorganized to make it\r
466 # easy to be sorted\r
467 #\r
468 def FormatFileLine (self) :\r
469\r
470 for eachPcd in self.FileLinesList :\r
471 if eachPcd.PcdOffset != '*' :\r
472 # Use pcd's Offset value as key, and pcd's Value as value\r
473 self.PcdFixedOffsetSizeList.append(eachPcd)\r
474 else :\r
475 # Use pcd's CName as key, and pcd's Size as value\r
476 self.PcdUnknownOffsetList.append(eachPcd)\r
477\r
478\r
479 ##\r
480 # This function is use to fix the offset value which the not specified in the map file.\r
481 # Usually it use the star (meaning any offset) character in the offset field\r
482 #\r
483 def FixVpdOffset (self):\r
484 # At first, the offset should start at 0\r
485 # Sort fixed offset list in order to find out where has free spaces for the pcd's offset\r
486 # value is "*" to insert into.\r
487\r
488 self.PcdFixedOffsetSizeList.sort(key=lambda x: x.PcdBinOffset)\r
489\r
490 #\r
491 # Sort the un-fixed pcd's offset by it's size.\r
492 #\r
493 self.PcdUnknownOffsetList.sort(key=lambda x: x.PcdBinSize)\r
494\r
495 index =0\r
496 for pcd in self.PcdUnknownOffsetList:\r
497 index += 1\r
498 if pcd.PcdCName == ".".join(("gEfiMdeModulePkgTokenSpaceGuid", "PcdNvStoreDefaultValueBuffer")):\r
499 if index != len(self.PcdUnknownOffsetList):\r
500 for i in range(len(self.PcdUnknownOffsetList) - index):\r
501 self.PcdUnknownOffsetList[index+i -1 ], self.PcdUnknownOffsetList[index+i] = self.PcdUnknownOffsetList[index+i], self.PcdUnknownOffsetList[index+i -1]\r
502\r
503 #\r
504 # Process all Offset value are "*"\r
505 #\r
506 if (len(self.PcdFixedOffsetSizeList) == 0) and (len(self.PcdUnknownOffsetList) != 0) :\r
507 # The offset start from 0\r
508 NowOffset = 0\r
509 for Pcd in self.PcdUnknownOffsetList :\r
510 if NowOffset % Pcd.Alignment != 0:\r
511 NowOffset = (NowOffset/ Pcd.Alignment + 1) * Pcd.Alignment\r
512 Pcd.PcdBinOffset = NowOffset\r
513 Pcd.PcdOffset = str(hex(Pcd.PcdBinOffset))\r
514 NowOffset += Pcd.PcdOccupySize\r
515\r
516 self.PcdFixedOffsetSizeList = self.PcdUnknownOffsetList\r
517 return\r
518\r
519 # Check the offset of VPD type pcd's offset start from 0.\r
520 if self.PcdFixedOffsetSizeList[0].PcdBinOffset != 0 :\r
521 EdkLogger.warn("BPDG", "The offset of VPD type pcd should start with 0, please check it.",\r
522 None)\r
523\r
524 # Judge whether the offset in fixed pcd offset list is overlapped or not.\r
525 lenOfList = len(self.PcdFixedOffsetSizeList)\r
526 count = 0\r
527 while (count < lenOfList - 1) :\r
528 PcdNow = self.PcdFixedOffsetSizeList[count]\r
529 PcdNext = self.PcdFixedOffsetSizeList[count+1]\r
530 # Two pcd's offset is same\r
531 if PcdNow.PcdBinOffset == PcdNext.PcdBinOffset :\r
532 EdkLogger.error("BPDG", BuildToolError.ATTRIBUTE_GET_FAILURE,\r
533 "The offset of %s at line: %s is same with %s at line: %s in file %s" % \\r
534 (PcdNow.PcdCName, PcdNow.Lineno, PcdNext.PcdCName, PcdNext.Lineno, PcdNext.FileName),\r
535 None)\r
536\r
537 # Overlapped\r
538 if PcdNow.PcdBinOffset + PcdNow.PcdOccupySize > PcdNext.PcdBinOffset :\r
539 EdkLogger.error("BPDG", BuildToolError.ATTRIBUTE_GET_FAILURE,\r
540 "The offset of %s at line: %s is overlapped with %s at line: %s in file %s" % \\r
541 (PcdNow.PcdCName, PcdNow.Lineno, PcdNext.PcdCName, PcdNext.Lineno, PcdNext.FileName),\r
542 None)\r
543\r
544 # Has free space, raise a warning message\r
545 if PcdNow.PcdBinOffset + PcdNow.PcdOccupySize < PcdNext.PcdBinOffset :\r
546 EdkLogger.warn("BPDG", BuildToolError.ATTRIBUTE_GET_FAILURE,\r
547 "The offsets have free space of between %s at line: %s and %s at line: %s in file %s" % \\r
548 (PcdNow.PcdCName, PcdNow.Lineno, PcdNext.PcdCName, PcdNext.Lineno, PcdNext.FileName),\r
549 None)\r
550 count += 1\r
551\r
552 LastOffset = self.PcdFixedOffsetSizeList[0].PcdBinOffset\r
553 FixOffsetSizeListCount = 0\r
554 lenOfList = len(self.PcdFixedOffsetSizeList)\r
555 lenOfUnfixedList = len(self.PcdUnknownOffsetList)\r
556\r
557 ##\r
558 # Insert the un-fixed offset pcd's list into fixed offset pcd's list if has free space between those pcds.\r
559 #\r
560 while (FixOffsetSizeListCount < lenOfList) :\r
561\r
562 eachFixedPcd = self.PcdFixedOffsetSizeList[FixOffsetSizeListCount]\r
563 NowOffset = eachFixedPcd.PcdBinOffset\r
564\r
565 # Has free space\r
566 if LastOffset < NowOffset :\r
567 if lenOfUnfixedList != 0 :\r
568 countOfUnfixedList = 0\r
569 while(countOfUnfixedList < lenOfUnfixedList) :\r
570 eachUnfixedPcd = self.PcdUnknownOffsetList[countOfUnfixedList]\r
571 needFixPcdSize = eachUnfixedPcd.PcdOccupySize\r
572 # Not been fixed\r
573 if eachUnfixedPcd.PcdOffset == '*' :\r
574 if LastOffset % eachUnfixedPcd.Alignment != 0:\r
575 LastOffset = (LastOffset / eachUnfixedPcd.Alignment + 1) * eachUnfixedPcd.Alignment\r
576 # The offset un-fixed pcd can write into this free space\r
577 if needFixPcdSize <= (NowOffset - LastOffset) :\r
578 # Change the offset value of un-fixed pcd\r
579 eachUnfixedPcd.PcdOffset = str(hex(LastOffset))\r
580 eachUnfixedPcd.PcdBinOffset = LastOffset\r
581 # Insert this pcd into fixed offset pcd list.\r
582 self.PcdFixedOffsetSizeList.insert(FixOffsetSizeListCount, eachUnfixedPcd)\r
583\r
584 # Delete the item's offset that has been fixed and added into fixed offset list\r
585 self.PcdUnknownOffsetList.pop(countOfUnfixedList)\r
586\r
587 # After item added, should enlarge the length of fixed pcd offset list\r
588 lenOfList += 1\r
589 FixOffsetSizeListCount += 1\r
590\r
591 # Decrease the un-fixed pcd offset list's length\r
592 lenOfUnfixedList -= 1\r
593\r
594 # Modify the last offset value\r
595 LastOffset += needFixPcdSize\r
596 else :\r
597 # It can not insert into those two pcds, need to check still has other space can store it.\r
598 LastOffset = NowOffset + self.PcdFixedOffsetSizeList[FixOffsetSizeListCount].PcdOccupySize\r
599 FixOffsetSizeListCount += 1\r
600 break\r
601\r
602 # Set the FixOffsetSizeListCount = lenOfList for quit the loop\r
603 else :\r
604 FixOffsetSizeListCount = lenOfList\r
605\r
606 # No free space, smoothly connect with previous pcd.\r
607 elif LastOffset == NowOffset :\r
608 LastOffset = NowOffset + eachFixedPcd.PcdOccupySize\r
609 FixOffsetSizeListCount += 1\r
610 # Usually it will not enter into this thunk, if so, means it overlapped.\r
611 else :\r
612 EdkLogger.error("BPDG", BuildToolError.ATTRIBUTE_NOT_AVAILABLE,\r
613 "The offset value definition has overlapped at pcd: %s, it's offset is: %s, in file: %s line: %s" % \\r
614 (eachFixedPcd.PcdCName, eachFixedPcd.PcdOffset, eachFixedPcd.InputFileName, eachFixedPcd.Lineno),\r
615 None)\r
616 FixOffsetSizeListCount += 1\r
617\r
618 # Continue to process the un-fixed offset pcd's list, add this time, just append them behind the fixed pcd's offset list.\r
619 lenOfUnfixedList = len(self.PcdUnknownOffsetList)\r
620 lenOfList = len(self.PcdFixedOffsetSizeList)\r
621 while (lenOfUnfixedList > 0) :\r
622 # Still has items need to process\r
623 # The last pcd instance\r
624 LastPcd = self.PcdFixedOffsetSizeList[lenOfList-1]\r
625 NeedFixPcd = self.PcdUnknownOffsetList[0]\r
626\r
627 NeedFixPcd.PcdBinOffset = LastPcd.PcdBinOffset + LastPcd.PcdOccupySize\r
628 if NeedFixPcd.PcdBinOffset % NeedFixPcd.Alignment != 0:\r
629 NeedFixPcd.PcdBinOffset = (NeedFixPcd.PcdBinOffset / NeedFixPcd.Alignment + 1) * NeedFixPcd.Alignment\r
630\r
631 NeedFixPcd.PcdOffset = str(hex(NeedFixPcd.PcdBinOffset))\r
632\r
633 # Insert this pcd into fixed offset pcd list's tail.\r
634 self.PcdFixedOffsetSizeList.insert(lenOfList, NeedFixPcd)\r
635 # Delete the item's offset that has been fixed and added into fixed offset list\r
636 self.PcdUnknownOffsetList.pop(0)\r
637\r
638 lenOfList += 1\r
639 lenOfUnfixedList -= 1\r
640 ##\r
641 # Write the final data into output files.\r
642 #\r
643 def GenerateVpdFile (self, MapFileName, BinFileName):\r
644 #Open an VPD file to process\r
645\r
646 try:\r
647 fVpdFile = open(BinFileName, "wb", 0)\r
648 except:\r
649 # Open failed\r
650 EdkLogger.error("BPDG", BuildToolError.FILE_OPEN_FAILURE, "File open failed for %s" % self.VpdFileName, None)\r
651\r
652 try :\r
653 fMapFile = open(MapFileName, "w", 0)\r
654 except:\r
655 # Open failed\r
656 EdkLogger.error("BPDG", BuildToolError.FILE_OPEN_FAILURE, "File open failed for %s" % self.MapFileName, None)\r
657\r
658 # Use a instance of BytesIO to cache data\r
659 fStringIO = BytesIO('')\r
660\r
661 # Write the header of map file.\r
662 try :\r
663 fMapFile.write (st.MAP_FILE_COMMENT_TEMPLATE + "\n")\r
664 except:\r
665 EdkLogger.error("BPDG", BuildToolError.FILE_WRITE_FAILURE, "Write data to file %s failed, please check whether the file been locked or using by other applications." % self.MapFileName, None)\r
666\r
667 for eachPcd in self.PcdFixedOffsetSizeList :\r
668 # write map file\r
669 try :\r
670 fMapFile.write("%s | %s | %s | %s | %s \n" % (eachPcd.PcdCName, eachPcd.SkuId, eachPcd.PcdOffset, eachPcd.PcdSize, eachPcd.PcdUnpackValue))\r
671 except:\r
672 EdkLogger.error("BPDG", BuildToolError.FILE_WRITE_FAILURE, "Write data to file %s failed, please check whether the file been locked or using by other applications." % self.MapFileName, None)\r
673\r
674 # Write Vpd binary file\r
675 fStringIO.seek (eachPcd.PcdBinOffset)\r
676 if isinstance(eachPcd.PcdValue, list):\r
677 ValueList = [chr(Item) for Item in eachPcd.PcdValue]\r
678 fStringIO.write(''.join(ValueList))\r
679 else:\r
680 fStringIO.write (eachPcd.PcdValue)\r
681\r
682 try :\r
683 fVpdFile.write (fStringIO.getvalue())\r
684 except:\r
685 EdkLogger.error("BPDG", BuildToolError.FILE_WRITE_FAILURE, "Write data to file %s failed, please check whether the file been locked or using by other applications." % self.VpdFileName, None)\r
686\r
687 fStringIO.close ()\r
688 fVpdFile.close ()\r
689 fMapFile.close ()\r
690\r
EFI Development Kit II mirror for PVE