]> git.proxmox.com Git - mirror_edk2.git/blob - EdkCompatibilityPkg/Compatibility/FrameworkHiiToUefiHiiThunk/UefiIfrDefault.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
1) Use 0xFFEE as the VarId the reason is as follows:
[mirror_edk2.git] / EdkCompatibilityPkg / Compatibility / FrameworkHiiToUefiHiiThunk / UefiIfrDefault.c
1 /** @file
2 Function and Macro defintions for to extract default values from UEFI Form package.
3
4 Copyright (c) 2008, Intel Corporation
5 All rights reserved. This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 **/
14
15
16 #include <FrameworkDxe.h>
17
18 #include <Protocol/FrameworkHii.h>
19 #include <Protocol/HiiDatabase.h>
20
21 #include <Library/BaseLib.h>
22 #include <Library/BaseMemoryLib.h>
23 #include <Library/DebugLib.h>
24 #include <Library/MemoryAllocationLib.h>
25 #include <Library/UefiBootServicesTableLib.h>
26
27 #include "UefiIfrParser.h"
28 #include "UefiIfrDefault.h"
29
30 //
31 // Extern Variables
32 //
33 extern CONST EFI_HII_DATABASE_PROTOCOL *mHiiDatabase;
34 extern CONST EFI_HII_FONT_PROTOCOL *mHiiFontProtocol;
35 extern CONST EFI_HII_IMAGE_PROTOCOL *mHiiImageProtocol;
36 extern CONST EFI_HII_STRING_PROTOCOL *mHiiStringProtocol;
37 extern CONST EFI_HII_CONFIG_ROUTING_PROTOCOL *mHiiConfigRoutingProtocol;
38
39 extern EFI_GUID gZeroGuid;
40
41 /**
42 Fetch the Ifr binary data of a FormSet.
43
44 @param Handle PackageList Handle
45 @param FormSetGuid GUID of a formset. If not specified (NULL or zero
46 GUID), take the first FormSet found in package
47 list.
48 @param BinaryLength The length of the FormSet IFR binary.
49 @param BinaryData The buffer designed to receive the FormSet.
50
51 @retval EFI_SUCCESS Buffer filled with the requested FormSet.
52 BufferLength was updated.
53 @retval EFI_INVALID_PARAMETER The handle is unknown.
54 @retval EFI_NOT_FOUND A form or FormSet on the requested handle cannot
55 be found with the requested FormId.
56
57 **/
58 EFI_STATUS
59 GetIfrBinaryData (
60 IN EFI_HII_HANDLE Handle,
61 IN OUT EFI_GUID *FormSetGuid,
62 OUT UINTN *BinaryLength,
63 OUT UINT8 **BinaryData
64 )
65 {
66 EFI_STATUS Status;
67 EFI_HII_PACKAGE_LIST_HEADER *HiiPackageList;
68 UINTN BufferSize;
69 UINT8 *Package;
70 UINT8 *OpCodeData;
71 UINT32 Offset;
72 UINT32 Offset2;
73 BOOLEAN ReturnDefault;
74 UINT32 PackageListLength;
75 EFI_HII_PACKAGE_HEADER PackageHeader;
76
77 OpCodeData = NULL;
78 Package = NULL;
79 ZeroMem (&PackageHeader, sizeof (EFI_HII_PACKAGE_HEADER));;
80
81 //
82 // if FormSetGuid is NULL or zero GUID, return first FormSet in the package list
83 //
84 if (FormSetGuid == NULL || CompareGuid (FormSetGuid, &gZeroGuid)) {
85 ReturnDefault = TRUE;
86 } else {
87 ReturnDefault = FALSE;
88 }
89
90 //
91 // Get HII PackageList
92 //
93 BufferSize = 0;
94 HiiPackageList = NULL;
95 Status = mHiiDatabase->ExportPackageLists (mHiiDatabase, Handle, &BufferSize, HiiPackageList);
96 if (Status == EFI_BUFFER_TOO_SMALL) {
97 HiiPackageList = AllocatePool (BufferSize);
98 ASSERT (HiiPackageList != NULL);
99
100 Status = mHiiDatabase->ExportPackageLists (mHiiDatabase, Handle, &BufferSize, HiiPackageList);
101 }
102 if (EFI_ERROR (Status)) {
103 return Status;
104 }
105
106 //
107 // Get Form package from this HII package List
108 //
109 Offset = sizeof (EFI_HII_PACKAGE_LIST_HEADER);
110 Offset2 = 0;
111 CopyMem (&PackageListLength, &HiiPackageList->PackageLength, sizeof (UINT32));
112
113 while (Offset < PackageListLength) {
114 Package = ((UINT8 *) HiiPackageList) + Offset;
115 CopyMem (&PackageHeader, Package, sizeof (EFI_HII_PACKAGE_HEADER));
116
117 if (PackageHeader.Type == EFI_HII_PACKAGE_FORM) {
118 //
119 // Search FormSet in this Form Package
120 //
121 Offset2 = sizeof (EFI_HII_PACKAGE_HEADER);
122 while (Offset2 < PackageHeader.Length) {
123 OpCodeData = Package + Offset2;
124
125 if (((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode == EFI_IFR_FORM_SET_OP) {
126 //
127 // Check whether return default FormSet
128 //
129 if (ReturnDefault) {
130 break;
131 }
132
133 //
134 // FormSet GUID is specified, check it
135 //
136 if (CompareGuid (FormSetGuid, (EFI_GUID *)(OpCodeData + sizeof (EFI_IFR_OP_HEADER)))) {
137 break;
138 }
139 }
140
141 Offset2 += ((EFI_IFR_OP_HEADER *) OpCodeData)->Length;
142 }
143
144 if (Offset2 < PackageHeader.Length) {
145 //
146 // Target formset found
147 //
148 break;
149 }
150 }
151
152 Offset += PackageHeader.Length;
153 }
154
155 if (Offset >= PackageListLength) {
156 //
157 // Form package not found in this Package List
158 //
159 gBS->FreePool (HiiPackageList);
160 return EFI_NOT_FOUND;
161 }
162
163 if (ReturnDefault && FormSetGuid != NULL) {
164 //
165 // Return the default FormSet GUID
166 //
167 CopyMem (FormSetGuid, &((EFI_IFR_FORM_SET *) OpCodeData)->Guid, sizeof (EFI_GUID));
168 }
169
170 //
171 // To determine the length of a whole FormSet IFR binary, one have to parse all the Opcodes
172 // in this FormSet; So, here just simply copy the data from start of a FormSet to the end
173 // of the Form Package.
174 //
175 *BinaryLength = PackageHeader.Length - Offset2;
176 *BinaryData = AllocateCopyPool (*BinaryLength, OpCodeData);
177
178 gBS->FreePool (HiiPackageList);
179
180 if (*BinaryData == NULL) {
181 return EFI_OUT_OF_RESOURCES;
182 }
183
184 return EFI_SUCCESS;
185 }
186
187 /**
188 Initialize the internal data structure of a FormSet.
189
190 @param Handle PackageList Handle
191 @param FormSetGuid GUID of a formset. If not specified (NULL or zero
192 GUID), take the first FormSet found in package
193 list.
194 @param FormSet FormSet data structure.
195
196 @retval EFI_SUCCESS The function completed successfully.
197 @retval EFI_NOT_FOUND The specified FormSet could not be found.
198
199 **/
200 EFI_STATUS
201 InitializeFormSet (
202 IN EFI_HII_HANDLE Handle,
203 IN OUT EFI_GUID *FormSetGuid,
204 OUT FORM_BROWSER_FORMSET *FormSet
205 )
206 {
207 EFI_STATUS Status;
208 EFI_HANDLE DriverHandle;
209
210 Status = GetIfrBinaryData (Handle, FormSetGuid, &FormSet->IfrBinaryLength, &FormSet->IfrBinaryData);
211 if (EFI_ERROR (Status)) {
212 return Status;
213 }
214
215 FormSet->HiiHandle = Handle;
216 CopyMem (&FormSet->Guid, FormSetGuid, sizeof (EFI_GUID));
217
218 //
219 // Retrieve ConfigAccess Protocol associated with this HiiPackageList
220 //
221 Status = mHiiDatabase->GetPackageListHandle (mHiiDatabase, Handle, &DriverHandle);
222 if (EFI_ERROR (Status)) {
223 return Status;
224 }
225 FormSet->DriverHandle = DriverHandle;
226 Status = gBS->HandleProtocol (
227 DriverHandle,
228 &gEfiHiiConfigAccessProtocolGuid,
229 (VOID **) &FormSet->ConfigAccess
230 );
231 if (EFI_ERROR (Status)) {
232 //
233 // Configuration Driver don't attach ConfigAccess protocol to its HII package
234 // list, then there will be no configuration action required
235 //
236 FormSet->ConfigAccess = NULL;
237 }
238
239 //
240 // Parse the IFR binary OpCodes
241 //
242 Status = ParseOpCodes (FormSet);
243 if (EFI_ERROR (Status)) {
244 return Status;
245 }
246 return Status;
247 }
248
249 /**
250 Set the data position at Offset with Width in Node->Buffer based
251 the value passed in.
252
253 @param Node The Buffer Storage Node.
254 @param Value The input value.
255 @param Offset The offset in Node->Buffer for the update.
256 @param Width The length of the Value.
257
258 @retval VOID
259
260 **/
261 VOID
262 SetNodeBuffer (
263 OUT UEFI_IFR_BUFFER_STORAGE_NODE *Node,
264 IN CONST EFI_HII_VALUE *Value,
265 IN UINTN Offset,
266 IN UINTN Width
267 )
268 {
269 ASSERT (Node->Signature == UEFI_IFR_BUFFER_STORAGE_NODE_SIGNATURE);
270 ASSERT (Offset + Width <= Node->Size);
271
272 CopyMem (Node->Buffer + Offset, &Value->Value.u8, Width);
273 }
274
275
276 /**
277 Reset Question to its default value.
278
279 @param FormSet FormSet data structure.
280 @param DefaultId The Class of the default.
281
282 @retval EFI_SUCCESS Question is reset to default value.
283
284 **/
285 EFI_STATUS
286 GetQuestionDefault (
287 IN FORM_BROWSER_FORMSET *FormSet,
288 IN FORM_BROWSER_FORM *Form,
289 IN FORM_BROWSER_STATEMENT *Question,
290 IN UINT16 DefaultId,
291 IN UINT16 VarStoreId,
292 OUT UEFI_IFR_BUFFER_STORAGE_NODE *Node
293 )
294 {
295 EFI_STATUS Status;
296 LIST_ENTRY *Link;
297 QUESTION_DEFAULT *Default;
298 QUESTION_OPTION *Option;
299 EFI_HII_VALUE *HiiValue;
300
301 Status = EFI_SUCCESS;
302
303 //
304 // Statement don't have storage, skip them
305 //
306 if (Question->QuestionId == 0) {
307 return Status;
308 }
309
310 if (Question->VarStoreId != VarStoreId) {
311 return Status;
312 }
313
314 ASSERT (Question->Storage->Type == EFI_HII_VARSTORE_BUFFER);
315
316 //
317 // There are three ways to specify default value for a Question:
318 // 1, use nested EFI_IFR_DEFAULT (highest priority)
319 // 2, set flags of EFI_ONE_OF_OPTION (provide Standard and Manufacturing default)
320 // 3, set flags of EFI_IFR_CHECKBOX (provide Standard and Manufacturing default) (lowest priority)
321 //
322 HiiValue = &Question->HiiValue;
323
324 //
325 // EFI_IFR_DEFAULT has highest priority
326 //
327 if (!IsListEmpty (&Question->DefaultListHead)) {
328 Link = GetFirstNode (&Question->DefaultListHead);
329 while (!IsNull (&Question->DefaultListHead, Link)) {
330 Default = QUESTION_DEFAULT_FROM_LINK (Link);
331
332 if (Default->DefaultId == DefaultId) {
333 if (Default->ValueExpression != NULL) {
334 //
335 // Default is provided by an Expression, evaluate it
336 //
337 Status = EvaluateExpression (FormSet, Form, Default->ValueExpression);
338 if (EFI_ERROR (Status)) {
339 return Status;
340 }
341
342 CopyMem (HiiValue, &Default->ValueExpression->Result, sizeof (EFI_HII_VALUE));
343 } else {
344 //
345 // Default value is embedded in EFI_IFR_DEFAULT
346 //
347 CopyMem (HiiValue, &Default->Value, sizeof (EFI_HII_VALUE));
348 }
349
350 SetNodeBuffer (Node, HiiValue, Question->VarStoreInfo.VarOffset, Question->StorageWidth);
351 return EFI_SUCCESS;
352 }
353
354 Link = GetNextNode (&Question->DefaultListHead, Link);
355 }
356 }
357
358 //
359 // EFI_ONE_OF_OPTION
360 //
361 if ((Question->Operand == EFI_IFR_ONE_OF_OP) && !IsListEmpty (&Question->OptionListHead)) {
362 if (DefaultId <= EFI_HII_DEFAULT_CLASS_MANUFACTURING) {
363 //
364 // OneOfOption could only provide Standard and Manufacturing default
365 //
366 Link = GetFirstNode (&Question->OptionListHead);
367 while (!IsNull (&Question->OptionListHead, Link)) {
368 Option = QUESTION_OPTION_FROM_LINK (Link);
369
370 if (((DefaultId == EFI_HII_DEFAULT_CLASS_STANDARD) && (Option->Flags & EFI_IFR_OPTION_DEFAULT)) ||
371 ((DefaultId == EFI_HII_DEFAULT_CLASS_MANUFACTURING) && (Option->Flags & EFI_IFR_OPTION_DEFAULT_MFG))
372 ) {
373 CopyMem (HiiValue, &Option->Value, sizeof (EFI_HII_VALUE));
374
375 SetNodeBuffer (Node, HiiValue, Question->VarStoreInfo.VarOffset, Question->StorageWidth);
376 return EFI_SUCCESS;
377 }
378
379 Link = GetNextNode (&Question->OptionListHead, Link);
380 }
381 }
382 }
383
384 //
385 // EFI_IFR_CHECKBOX - lowest priority
386 //
387 if (Question->Operand == EFI_IFR_CHECKBOX_OP) {
388 if (DefaultId <= EFI_HII_DEFAULT_CLASS_MANUFACTURING) {
389 //
390 // Checkbox could only provide Standard and Manufacturing default
391 //
392 if (((DefaultId == EFI_HII_DEFAULT_CLASS_STANDARD) && (Question->Flags & EFI_IFR_CHECKBOX_DEFAULT)) ||
393 ((DefaultId == EFI_HII_DEFAULT_CLASS_MANUFACTURING) && (Question->Flags & EFI_IFR_CHECKBOX_DEFAULT_MFG))
394 ) {
395 HiiValue->Value.b = TRUE;
396 } else {
397 HiiValue->Value.b = FALSE;
398 }
399
400 SetNodeBuffer (Node, HiiValue, Question->VarStoreInfo.VarOffset, Question->StorageWidth);
401 return EFI_SUCCESS;
402 }
403 }
404
405 return Status;
406 }
407
408
409 /**
410 Reset Questions in a Form to their default value.
411
412 @param FormSet FormSet data structure.
413 @param Form The Form which to be reset.
414 @param DefaultId The Class of the default.
415
416 @retval EFI_SUCCESS The function completed successfully.
417
418 **/
419 EFI_STATUS
420 ExtractFormDefault (
421 IN FORM_BROWSER_FORMSET *FormSet,
422 IN FORM_BROWSER_FORM *Form,
423 IN UINT16 DefaultId,
424 IN UINT16 VarStoreId,
425 OUT UEFI_IFR_BUFFER_STORAGE_NODE *Node
426 )
427 {
428 EFI_STATUS Status;
429 LIST_ENTRY *Link;
430 FORM_BROWSER_STATEMENT *Question;
431
432 Link = GetFirstNode (&Form->StatementListHead);
433 while (!IsNull (&Form->StatementListHead, Link)) {
434 Question = FORM_BROWSER_STATEMENT_FROM_LINK (Link);
435 Link = GetNextNode (&Form->StatementListHead, Link);
436
437 //
438 // Reset Question to its default value
439 //
440 Status = GetQuestionDefault (FormSet, Form, Question, DefaultId, VarStoreId, Node);
441 if (EFI_ERROR (Status)) {
442 continue;
443 }
444
445 }
446 return EFI_SUCCESS;
447 }
448
449
450 /**
451 Destroy all the buffer allocated for the fileds of
452 UEFI_IFR_BUFFER_STORAGE_NODE. The Node itself
453 will be freed too.
454
455 @param FormSet FormSet data structure.
456 @param DefaultId The Class of the default.
457
458 @retval VOID
459
460 **/
461 VOID
462 DestroyDefaultNode (
463 IN UEFI_IFR_BUFFER_STORAGE_NODE *Node
464 )
465 {
466 SafeFreePool (Node->Buffer);
467 SafeFreePool (Node->Name);
468 SafeFreePool (Node);
469 }
470
471
472 /**
473 Get the default value for Buffer Type storage named by
474 a Default Store and a Storage Store from a FormSet.
475 The result is in the a instance of UEFI_IFR_BUFFER_STORAGE_NODE
476 allocated by this function. It is inserted to the link list.
477
478 @param DefaultStore The Default Store.
479 @param Storage The Storage.
480 @param FormSet The Form Set.
481 @param UefiDefaultsListHead The head of link list for the output.
482
483 @retval EFI_SUCCESS Successful.
484
485 **/
486 EFI_STATUS
487 GetBufferTypeDefaultIdAndStorageId (
488 IN FORMSET_DEFAULTSTORE *DefaultStore,
489 IN FORMSET_STORAGE *Storage,
490 IN FORM_BROWSER_FORMSET *FormSet,
491 OUT LIST_ENTRY *UefiDefaultsListHead
492 )
493 {
494 UEFI_IFR_BUFFER_STORAGE_NODE *Node;
495 LIST_ENTRY *Link;
496 FORM_BROWSER_FORM *Form;
497 EFI_STATUS Status;
498
499 Node = AllocateZeroPool (sizeof (UEFI_IFR_BUFFER_STORAGE_NODE));
500 ASSERT (Node != NULL);
501
502 Node->Signature = UEFI_IFR_BUFFER_STORAGE_NODE_SIGNATURE;
503 Node->Name = AllocateCopyPool (StrSize (Storage->Name), Storage->Name);
504 Node->DefaultId = DefaultStore->DefaultId;
505 Node->StoreId = Storage->VarStoreId;
506 CopyGuid (&Node->Guid, &Storage->Guid);
507 Node->Size = Storage->Size;
508 Node->Buffer = AllocateZeroPool (Node->Size);
509 //
510 // Extract default from IFR binary
511 //
512 Link = GetFirstNode (&FormSet->FormListHead);
513 while (!IsNull (&FormSet->FormListHead, Link)) {
514 Form = FORM_BROWSER_FORM_FROM_LINK (Link);
515
516 Status = ExtractFormDefault (FormSet, Form, DefaultStore->DefaultId, Storage->VarStoreId, Node);
517 ASSERT_EFI_ERROR (Status);
518
519 Link = GetNextNode (&FormSet->FormListHead, Link);
520 }
521
522 InsertTailList (UefiDefaultsListHead, &Node->List);
523
524 return EFI_SUCCESS;
525 }
526
527
528 /**
529 Get the default value for Buffer Type storage named by
530 a Default Store from a FormSet.
531 The result is in the a instance of UEFI_IFR_BUFFER_STORAGE_NODE
532 allocated by this function. The output can be multiple instances
533 of UEFI_IFR_BUFFER_STORAGE_NODE. It is inserted to the link list.
534
535 @param DefaultStore The Default Store.
536 @param FormSet The Form Set.
537 @param UefiDefaultsListHead The head of link list for the output.
538
539 @retval EFI_SUCCESS Successful.
540
541 **/
542 EFI_STATUS
543 GetBufferTypeDefaultId (
544 IN FORMSET_DEFAULTSTORE *DefaultStore,
545 IN FORM_BROWSER_FORMSET *FormSet,
546 OUT LIST_ENTRY *UefiDefaultsListHead
547 )
548 {
549 LIST_ENTRY *StorageListEntry;
550 FORMSET_STORAGE *Storage;
551 EFI_STATUS Status;
552
553 StorageListEntry = GetFirstNode (&FormSet->StorageListHead);
554
555 while (!IsNull (&FormSet->StorageListHead, StorageListEntry)) {
556 Storage = FORMSET_STORAGE_FROM_LINK(StorageListEntry);
557
558 if (Storage->Type == EFI_HII_VARSTORE_BUFFER) {
559 Status = GetBufferTypeDefaultIdAndStorageId (DefaultStore, Storage, FormSet, UefiDefaultsListHead);
560 }
561
562 StorageListEntry = GetNextNode (&FormSet->StorageListHead, StorageListEntry);
563 }
564
565 return EFI_SUCCESS;
566 }
567
568
569 /**
570 Get the default value for Buffer Type storage from the first FormSet
571 in the Package List specified by a EFI_HII_HANDLE.
572
573 The results can be multiple instances of UEFI_IFR_BUFFER_STORAGE_NODE.
574 They are inserted to the link list.
575
576 @param UefiHiiHandle The handle for the package list.
577 @param UefiDefaultsListHead The head of link list for the output.
578
579 @retval EFI_SUCCESS Successful.
580
581 **/
582 EFI_STATUS
583 UefiIfrGetBufferTypeDefaults (
584 IN EFI_HII_HANDLE UefiHiiHandle,
585 OUT LIST_ENTRY **UefiDefaults
586 )
587 {
588 FORM_BROWSER_FORMSET *FormSet;
589 EFI_GUID FormSetGuid;
590 LIST_ENTRY *DefaultListEntry;
591 FORMSET_DEFAULTSTORE *DefaultStore;
592 EFI_STATUS Status;
593
594 ASSERT (UefiDefaults != NULL);
595
596 FormSet = AllocateZeroPool (sizeof (FORM_BROWSER_FORMSET));
597 ASSERT (FormSet != NULL);
598
599 CopyGuid (&FormSetGuid, &gZeroGuid);
600 Status = InitializeFormSet (UefiHiiHandle, &FormSetGuid, FormSet);
601 ASSERT_EFI_ERROR (Status);
602
603 *UefiDefaults = AllocateZeroPool (sizeof (LIST_ENTRY));
604 ASSERT (UefiDefaults != NULL);
605 InitializeListHead (*UefiDefaults);
606
607 DefaultListEntry = GetFirstNode (&FormSet->DefaultStoreListHead);
608 while (!IsNull (&FormSet->DefaultStoreListHead, DefaultListEntry)) {
609 DefaultStore = FORMSET_DEFAULTSTORE_FROM_LINK(DefaultListEntry);
610
611 Status = GetBufferTypeDefaultId (DefaultStore, FormSet, *UefiDefaults);
612 ASSERT_EFI_ERROR (Status);
613
614 DefaultListEntry = GetNextNode (&FormSet->DefaultStoreListHead, DefaultListEntry);
615 }
616
617 DestroyFormSet (FormSet);
618
619 return EFI_SUCCESS;
620 }
621
622
623 /**
624 Convert the UEFI Buffer Type default values to a Framework HII default
625 values specified by a EFI_HII_VARIABLE_PACK_LIST structure.
626
627 @param ListHead The link list of UEFI_IFR_BUFFER_STORAGE_NODE
628 which contains the default values retrived from
629 a UEFI form set.
630 @param DefaultMask The default mask.
631 The valid values are FRAMEWORK_EFI_IFR_FLAG_DEFAULT
632 and FRAMEWORK_EFI_IFR_FLAG_MANUFACTURING.
633 UEFI spec only map FRAMEWORK_EFI_IFR_FLAG_DEFAULT and FRAMEWORK_EFI_IFR_FLAG_MANUFACTURING
634 from specification to valid default class.
635 @param VariablePackList The output default value in a format defined in Framework.
636
637
638 @retval EFI_SUCCESS Successful.
639 @retval EFI_INVALID_PARAMETER The default mask is not FRAMEWORK_EFI_IFR_FLAG_DEFAULT or
640 FRAMEWORK_EFI_IFR_FLAG_MANUFACTURING.
641 **/
642 EFI_STATUS
643 UefiDefaultsToFrameworkDefaults (
644 IN LIST_ENTRY *ListHead,
645 IN UINTN DefaultMask,
646 OUT EFI_HII_VARIABLE_PACK_LIST **VariablePackList
647 )
648 {
649 LIST_ENTRY *List;
650 UEFI_IFR_BUFFER_STORAGE_NODE *Node;
651 UINTN Size;
652 UINTN Count;
653 UINT16 DefaultId;
654 EFI_HII_VARIABLE_PACK *Pack;
655 EFI_HII_VARIABLE_PACK_LIST *PackList;
656
657 if (DefaultMask == FRAMEWORK_EFI_IFR_FLAG_DEFAULT) {
658 DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD;
659 } else if (DefaultMask == FRAMEWORK_EFI_IFR_FLAG_MANUFACTURING) {
660 DefaultId = EFI_HII_DEFAULT_CLASS_MANUFACTURING;
661 } else {
662 //
663 // UEFI spec only map FRAMEWORK_EFI_IFR_FLAG_DEFAULT and FRAMEWORK_EFI_IFR_FLAG_MANUFACTURING
664 // from specification to valid default class.
665 //
666 ASSERT (FALSE);
667 return EFI_INVALID_PARAMETER;
668 }
669
670 //
671 // Calculate the size of the output EFI_HII_VARIABLE_PACK_LIST structure
672 //
673 Size = 0;
674 Count = 0;
675 List = GetFirstNode (ListHead);
676 while (!IsNull (ListHead, List)) {
677 Node = UEFI_IFR_BUFFER_STORAGE_NODE_FROM_LIST(List);
678
679 if (Node->DefaultId == DefaultId) {
680 Size += Node->Size;
681 Size += StrSize (Node->Name);
682
683 Count++;
684 }
685
686 List = GetNextNode (ListHead, List);
687 }
688
689 Size = Size + Count * (sizeof (EFI_HII_VARIABLE_PACK_LIST) + sizeof (EFI_HII_VARIABLE_PACK));
690
691 *VariablePackList = AllocateZeroPool (Size);
692 ASSERT (*VariablePackList != NULL);
693
694 List = GetFirstNode (ListHead);
695
696 PackList = (EFI_HII_VARIABLE_PACK_LIST *) *VariablePackList;
697 Pack = (EFI_HII_VARIABLE_PACK *) (PackList + 1);
698 while (!IsNull (ListHead, List)) {
699 Node = UEFI_IFR_BUFFER_STORAGE_NODE_FROM_LIST(List);
700
701 Size = 0;
702 if (Node->DefaultId == DefaultId) {
703 Size += Node->Size;
704 Size += StrSize (Node->Name);
705 Size += sizeof (EFI_HII_VARIABLE_PACK);
706
707 //
708 // In UEFI, 0 is defined to be invalid for EFI_IFR_VARSTORE.VarStoreId.
709 // So the default storage of Var Store in VFR from a Framework module
710 // should be translated to 0xFFEE.
711 //
712 if (Node->StoreId == RESERVED_VARSTORE_ID) {
713 Pack->VariableId = 0;
714 } else {
715 Pack->VariableId = Node->StoreId;
716 }
717 //
718 // Initialize EFI_HII_VARIABLE_PACK
719 //
720 Pack->Header.Type = 0;
721 Pack->Header.Length = Size;
722 Pack->VariableNameLength = StrSize (Node->Name);
723 CopyMem (&Pack->VariableGuid, &Node->Guid, sizeof (EFI_GUID));
724
725 CopyMem ((UINT8 *) Pack + sizeof (EFI_HII_VARIABLE_PACK), Node->Name, StrSize (Node->Name));
726 CopyMem ((UINT8 *) Pack + sizeof (EFI_HII_VARIABLE_PACK) + Pack->VariableNameLength, Node->Buffer, Node->Size);
727
728 Size += sizeof (EFI_HII_VARIABLE_PACK_LIST);
729
730 //
731 // initialize EFI_HII_VARIABLE_PACK_LIST
732 //
733 PackList->VariablePack = Pack;
734 PackList->NextVariablePack = (EFI_HII_VARIABLE_PACK_LIST *)((UINT8 *) PackList + Size);
735
736 }
737
738 List = GetNextNode (ListHead, List);
739 }
740
741
742 return EFI_SUCCESS;
743 }
744
745
746 /**
747 Free up all buffer allocated for the link list of UEFI_IFR_BUFFER_STORAGE_NODE.
748
749 @param ListHead The link list of UEFI_IFR_BUFFER_STORAGE_NODE
750 which contains the default values retrived from
751 a UEFI form set.
752
753
754 @retval VOID
755 **/
756 VOID
757 FreeDefaultList (
758 IN LIST_ENTRY *ListHead
759 )
760 {
761 LIST_ENTRY *Node;
762 UEFI_IFR_BUFFER_STORAGE_NODE *Default;
763
764 Node = GetFirstNode (ListHead);
765
766 while (!IsNull (ListHead, Node)) {
767 Default = UEFI_IFR_BUFFER_STORAGE_NODE_FROM_LIST(Node);
768
769 RemoveEntryList (Node);
770
771 DestroyDefaultNode (Default);
772
773 Node = GetFirstNode (ListHead);
774 }
775
776 FreePool (ListHead);
777 }
778
EFI Development Kit II mirror for PVE