2 Implementation for EFI_HII_DATABASE_PROTOCOL.
4 Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>
5 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
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.
16 #include "HiiDatabase.h"
18 #define BASE_NUMBER 10
20 EFI_HII_PACKAGE_LIST_HEADER
*gRTDatabaseInfoBuffer
= NULL
;
21 EFI_STRING gRTConfigRespBuffer
= NULL
;
22 UINTN gDatabaseInfoSize
= 0;
23 UINTN gConfigRespSize
= 0;
24 BOOLEAN gExportConfigResp
= TRUE
;
25 UINTN gNvDefaultStoreSize
= 0;
26 SKU_ID gSkuId
= 0xFFFFFFFFFFFFFFFF;
27 LIST_ENTRY gVarStorageList
= INITIALIZE_LIST_HEAD_VARIABLE (gVarStorageList
);
30 This function generates a HII_DATABASE_RECORD node and adds into hii database.
31 This is a internal function.
33 @param Private hii database private structure
34 @param DatabaseNode HII_DATABASE_RECORD node which is used to store a
37 @retval EFI_SUCCESS A database record is generated successfully.
38 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
40 @retval EFI_INVALID_PARAMETER Private is NULL or DatabaseRecord is NULL.
44 GenerateHiiDatabaseRecord (
45 IN HII_DATABASE_PRIVATE_DATA
*Private
,
46 OUT HII_DATABASE_RECORD
**DatabaseNode
49 HII_DATABASE_RECORD
*DatabaseRecord
;
50 HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
;
51 HII_HANDLE
*HiiHandle
;
53 if (Private
== NULL
|| DatabaseNode
== NULL
) {
54 return EFI_INVALID_PARAMETER
;
57 DatabaseRecord
= (HII_DATABASE_RECORD
*) AllocateZeroPool (sizeof (HII_DATABASE_RECORD
));
58 if (DatabaseRecord
== NULL
) {
59 return EFI_OUT_OF_RESOURCES
;
61 DatabaseRecord
->Signature
= HII_DATABASE_RECORD_SIGNATURE
;
63 DatabaseRecord
->PackageList
= AllocateZeroPool (sizeof (HII_DATABASE_PACKAGE_LIST_INSTANCE
));
64 if (DatabaseRecord
->PackageList
== NULL
) {
65 FreePool (DatabaseRecord
);
66 return EFI_OUT_OF_RESOURCES
;
69 PackageList
= DatabaseRecord
->PackageList
;
71 InitializeListHead (&PackageList
->GuidPkgHdr
);
72 InitializeListHead (&PackageList
->FormPkgHdr
);
73 InitializeListHead (&PackageList
->KeyboardLayoutHdr
);
74 InitializeListHead (&PackageList
->StringPkgHdr
);
75 InitializeListHead (&PackageList
->FontPkgHdr
);
76 InitializeListHead (&PackageList
->SimpleFontPkgHdr
);
77 PackageList
->ImagePkg
= NULL
;
78 PackageList
->DevicePathPkg
= NULL
;
81 // Create a new hii handle
83 HiiHandle
= (HII_HANDLE
*) AllocateZeroPool (sizeof (HII_HANDLE
));
84 if (HiiHandle
== NULL
) {
85 FreePool (DatabaseRecord
->PackageList
);
86 FreePool (DatabaseRecord
);
87 return EFI_OUT_OF_RESOURCES
;
89 HiiHandle
->Signature
= HII_HANDLE_SIGNATURE
;
91 // Backup the number of Hii handles
93 Private
->HiiHandleCount
++;
94 HiiHandle
->Key
= (UINTN
) Private
->HiiHandleCount
;
96 // Insert the handle to hii handle list of the whole database.
98 InsertTailList (&Private
->HiiHandleList
, &HiiHandle
->Handle
);
100 DatabaseRecord
->Handle
= (EFI_HII_HANDLE
) HiiHandle
;
103 // Insert the Package List node to Package List link of the whole database.
105 InsertTailList (&Private
->DatabaseList
, &DatabaseRecord
->DatabaseEntry
);
107 *DatabaseNode
= DatabaseRecord
;
115 This function checks whether a handle is a valid EFI_HII_HANDLE
116 This is a internal function.
118 @param Handle Pointer to a EFI_HII_HANDLE
121 @retval FALSE Invalid
126 EFI_HII_HANDLE Handle
129 HII_HANDLE
*HiiHandle
;
131 HiiHandle
= (HII_HANDLE
*) Handle
;
133 if (HiiHandle
== NULL
) {
137 if (HiiHandle
->Signature
!= HII_HANDLE_SIGNATURE
) {
146 This function invokes the matching registered function.
147 This is a internal function.
149 @param Private HII Database driver private structure.
150 @param NotifyType The type of change concerning the database.
151 @param PackageInstance Points to the package referred to by the
153 @param PackageType Package type
154 @param Handle The handle of the package list which contains the
157 @retval EFI_SUCCESS Already checked all registered function and
159 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
163 InvokeRegisteredFunction (
164 IN HII_DATABASE_PRIVATE_DATA
*Private
,
165 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType
,
166 IN VOID
*PackageInstance
,
167 IN UINT8 PackageType
,
168 IN EFI_HII_HANDLE Handle
171 HII_DATABASE_NOTIFY
*Notify
;
173 EFI_HII_PACKAGE_HEADER
*Package
;
177 UINT32 ImageBlockSize
;
178 UINT32 PaletteInfoSize
;
180 if (Private
== NULL
|| (NotifyType
& 0xF) == 0 || PackageInstance
== NULL
) {
181 return EFI_INVALID_PARAMETER
;
183 if (Private
->Signature
!= HII_DATABASE_PRIVATE_DATA_SIGNATURE
) {
184 return EFI_INVALID_PARAMETER
;
186 if (!IsHiiHandleValid (Handle
)) {
187 return EFI_INVALID_PARAMETER
;
194 // Convert the incoming package from hii database storage format to UEFI
195 // storage format. e.g. HII_GUID_PACKAGE_INSTANCE to EFI_HII_GUID_PACKAGE_HDR.
197 switch (PackageType
) {
198 case EFI_HII_PACKAGE_TYPE_GUID
:
199 Package
= (EFI_HII_PACKAGE_HEADER
*) (((HII_GUID_PACKAGE_INSTANCE
*) PackageInstance
)->GuidPkg
);
202 case EFI_HII_PACKAGE_FORMS
:
203 BufferSize
= ((HII_IFR_PACKAGE_INSTANCE
*) PackageInstance
)->FormPkgHdr
.Length
;
204 Buffer
= (UINT8
*) AllocateZeroPool (BufferSize
);
205 ASSERT (Buffer
!= NULL
);
208 &((HII_IFR_PACKAGE_INSTANCE
*) PackageInstance
)->FormPkgHdr
,
209 sizeof (EFI_HII_PACKAGE_HEADER
)
212 Buffer
+ sizeof (EFI_HII_PACKAGE_HEADER
),
213 ((HII_IFR_PACKAGE_INSTANCE
*) PackageInstance
)->IfrData
,
214 BufferSize
- sizeof (EFI_HII_PACKAGE_HEADER
)
216 Package
= (EFI_HII_PACKAGE_HEADER
*) Buffer
;
219 case EFI_HII_PACKAGE_KEYBOARD_LAYOUT
:
220 Package
= (EFI_HII_PACKAGE_HEADER
*) (((HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE
*) PackageInstance
)->KeyboardPkg
);
223 case EFI_HII_PACKAGE_STRINGS
:
224 BufferSize
= ((HII_STRING_PACKAGE_INSTANCE
*) PackageInstance
)->StringPkgHdr
->Header
.Length
;
225 HeaderSize
= ((HII_STRING_PACKAGE_INSTANCE
*) PackageInstance
)->StringPkgHdr
->HdrSize
;
226 Buffer
= (UINT8
*) AllocateZeroPool (BufferSize
);
227 ASSERT (Buffer
!= NULL
);
230 ((HII_STRING_PACKAGE_INSTANCE
*) PackageInstance
)->StringPkgHdr
,
235 ((HII_STRING_PACKAGE_INSTANCE
*) PackageInstance
)->StringBlock
,
236 BufferSize
- HeaderSize
238 Package
= (EFI_HII_PACKAGE_HEADER
*) Buffer
;
241 case EFI_HII_PACKAGE_FONTS
:
242 BufferSize
= ((HII_FONT_PACKAGE_INSTANCE
*) PackageInstance
)->FontPkgHdr
->Header
.Length
;
243 HeaderSize
= ((HII_FONT_PACKAGE_INSTANCE
*) PackageInstance
)->FontPkgHdr
->HdrSize
;
244 Buffer
= (UINT8
*) AllocateZeroPool (BufferSize
);
245 ASSERT (Buffer
!= NULL
);
248 ((HII_FONT_PACKAGE_INSTANCE
*) PackageInstance
)->FontPkgHdr
,
253 ((HII_FONT_PACKAGE_INSTANCE
*) PackageInstance
)->GlyphBlock
,
254 BufferSize
- HeaderSize
256 Package
= (EFI_HII_PACKAGE_HEADER
*) Buffer
;
259 case EFI_HII_PACKAGE_IMAGES
:
260 BufferSize
= ((HII_IMAGE_PACKAGE_INSTANCE
*) PackageInstance
)->ImagePkgHdr
.Header
.Length
;
261 HeaderSize
= sizeof (EFI_HII_IMAGE_PACKAGE_HDR
);
262 Buffer
= (UINT8
*) AllocateZeroPool (BufferSize
);
263 ASSERT (Buffer
!= NULL
);
267 &((HII_IMAGE_PACKAGE_INSTANCE
*) PackageInstance
)->ImagePkgHdr
,
271 Buffer
+ sizeof (EFI_HII_PACKAGE_HEADER
),
276 ImageBlockSize
= ((HII_IMAGE_PACKAGE_INSTANCE
*) PackageInstance
)->ImageBlockSize
;
277 if (ImageBlockSize
!= 0) {
280 ((HII_IMAGE_PACKAGE_INSTANCE
*) PackageInstance
)->ImageBlock
,
285 PaletteInfoSize
= ((HII_IMAGE_PACKAGE_INSTANCE
*) PackageInstance
)->PaletteInfoSize
;
286 if (PaletteInfoSize
!= 0) {
288 Buffer
+ HeaderSize
+ ImageBlockSize
,
289 ((HII_IMAGE_PACKAGE_INSTANCE
*) PackageInstance
)->PaletteBlock
,
292 HeaderSize
+= ImageBlockSize
;
294 Buffer
+ sizeof (EFI_HII_PACKAGE_HEADER
) + sizeof (UINT32
),
299 Package
= (EFI_HII_PACKAGE_HEADER
*) Buffer
;
302 case EFI_HII_PACKAGE_SIMPLE_FONTS
:
303 BufferSize
= ((HII_SIMPLE_FONT_PACKAGE_INSTANCE
*) PackageInstance
)->SimpleFontPkgHdr
->Header
.Length
;
304 Buffer
= (UINT8
*) AllocateZeroPool (BufferSize
);
305 ASSERT (Buffer
!= NULL
);
308 ((HII_SIMPLE_FONT_PACKAGE_INSTANCE
*) PackageInstance
)->SimpleFontPkgHdr
,
311 Package
= (EFI_HII_PACKAGE_HEADER
*) Buffer
;
314 case EFI_HII_PACKAGE_DEVICE_PATH
:
315 Package
= (EFI_HII_PACKAGE_HEADER
*) PackageInstance
;
319 return EFI_INVALID_PARAMETER
;
322 for (Link
= Private
->DatabaseNotifyList
.ForwardLink
;
323 Link
!= &Private
->DatabaseNotifyList
;
324 Link
= Link
->ForwardLink
326 Notify
= CR (Link
, HII_DATABASE_NOTIFY
, DatabaseNotifyEntry
, HII_DATABASE_NOTIFY_SIGNATURE
);
327 if (Notify
->NotifyType
== NotifyType
&& Notify
->PackageType
== PackageType
) {
329 // Check in case PackageGuid is not NULL when Package is GUID package
331 if (PackageType
!= EFI_HII_PACKAGE_TYPE_GUID
) {
332 Notify
->PackageGuid
= NULL
;
335 // Status of Registered Function is unknown so did not check it
337 Notify
->PackageNotifyFn (
347 if (Buffer
!= NULL
) {
356 This function insert a GUID package to a package list node.
357 This is a internal function.
359 @param PackageHdr Pointer to a buffer stored with GUID package
361 @param NotifyType The type of change concerning the database.
362 @param PackageList Pointer to a package list which will be inserted
364 @param Package Created GUID package
366 @retval EFI_SUCCESS Guid Package is inserted successfully.
367 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
369 @retval EFI_INVALID_PARAMETER PackageHdr is NULL or PackageList is NULL.
375 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType
,
376 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
,
377 OUT HII_GUID_PACKAGE_INSTANCE
**Package
380 HII_GUID_PACKAGE_INSTANCE
*GuidPackage
;
381 EFI_HII_PACKAGE_HEADER PackageHeader
;
383 if (PackageHdr
== NULL
|| PackageList
== NULL
) {
384 return EFI_INVALID_PARAMETER
;
387 CopyMem (&PackageHeader
, PackageHdr
, sizeof (EFI_HII_PACKAGE_HEADER
));
390 // Create a GUID package node
392 GuidPackage
= (HII_GUID_PACKAGE_INSTANCE
*) AllocateZeroPool (sizeof (HII_GUID_PACKAGE_INSTANCE
));
393 if (GuidPackage
== NULL
) {
394 return EFI_OUT_OF_RESOURCES
;
396 GuidPackage
->GuidPkg
= (UINT8
*) AllocateZeroPool (PackageHeader
.Length
);
397 if (GuidPackage
->GuidPkg
== NULL
) {
398 FreePool (GuidPackage
);
399 return EFI_OUT_OF_RESOURCES
;
402 GuidPackage
->Signature
= HII_GUID_PACKAGE_SIGNATURE
;
403 CopyMem (GuidPackage
->GuidPkg
, PackageHdr
, PackageHeader
.Length
);
404 InsertTailList (&PackageList
->GuidPkgHdr
, &GuidPackage
->GuidEntry
);
405 *Package
= GuidPackage
;
407 if (NotifyType
== EFI_HII_DATABASE_NOTIFY_ADD_PACK
) {
408 PackageList
->PackageListHdr
.PackageLength
+= PackageHeader
.Length
;
416 This function exports GUID packages to a buffer.
417 This is a internal function.
419 @param Private Hii database private structure.
420 @param Handle Identification of a package list.
421 @param PackageList Pointer to a package list which will be exported.
422 @param UsedSize The length of buffer be used.
423 @param BufferSize Length of the Buffer.
424 @param Buffer Allocated space for storing exported data.
425 @param ResultSize The size of the already exported content of this
428 @retval EFI_SUCCESS Guid Packages are exported successfully.
429 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
434 IN HII_DATABASE_PRIVATE_DATA
*Private
,
435 IN EFI_HII_HANDLE Handle
,
436 IN HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
,
440 IN OUT UINTN
*ResultSize
443 HII_GUID_PACKAGE_INSTANCE
*GuidPackage
;
446 EFI_HII_PACKAGE_HEADER PackageHeader
;
449 if (PackageList
== NULL
|| ResultSize
== NULL
) {
450 return EFI_INVALID_PARAMETER
;
453 if (BufferSize
> 0 && Buffer
== NULL
) {
454 return EFI_INVALID_PARAMETER
;
458 Status
= EFI_SUCCESS
;
460 for (Link
= PackageList
->GuidPkgHdr
.ForwardLink
; Link
!= &PackageList
->GuidPkgHdr
; Link
= Link
->ForwardLink
) {
461 GuidPackage
= CR (Link
, HII_GUID_PACKAGE_INSTANCE
, GuidEntry
, HII_GUID_PACKAGE_SIGNATURE
);
462 CopyMem (&PackageHeader
, GuidPackage
->GuidPkg
, sizeof (EFI_HII_PACKAGE_HEADER
));
463 PackageLength
+= PackageHeader
.Length
;
464 if (PackageLength
+ *ResultSize
+ UsedSize
<= BufferSize
) {
465 Status
= InvokeRegisteredFunction (
467 EFI_HII_DATABASE_NOTIFY_EXPORT_PACK
,
468 (VOID
*) GuidPackage
,
469 EFI_HII_PACKAGE_TYPE_GUID
,
472 ASSERT_EFI_ERROR (Status
);
473 CopyMem (Buffer
, GuidPackage
->GuidPkg
, PackageHeader
.Length
);
474 Buffer
= (UINT8
*) Buffer
+ PackageHeader
.Length
;
478 *ResultSize
+= PackageLength
;
484 This function deletes all GUID packages from a package list node.
485 This is a internal function.
487 @param Private Hii database private data.
488 @param Handle Handle of the package list which contains the to
489 be removed GUID packages.
490 @param PackageList Pointer to a package list that contains removing
493 @retval EFI_SUCCESS GUID Package(s) is deleted successfully.
494 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
499 IN HII_DATABASE_PRIVATE_DATA
*Private
,
500 IN EFI_HII_HANDLE Handle
,
501 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
504 LIST_ENTRY
*ListHead
;
505 HII_GUID_PACKAGE_INSTANCE
*Package
;
507 EFI_HII_PACKAGE_HEADER PackageHeader
;
509 ListHead
= &PackageList
->GuidPkgHdr
;
511 while (!IsListEmpty (ListHead
)) {
513 ListHead
->ForwardLink
,
514 HII_GUID_PACKAGE_INSTANCE
,
516 HII_GUID_PACKAGE_SIGNATURE
518 Status
= InvokeRegisteredFunction (
520 EFI_HII_DATABASE_NOTIFY_REMOVE_PACK
,
522 EFI_HII_PACKAGE_TYPE_GUID
,
525 if (EFI_ERROR (Status
)) {
529 RemoveEntryList (&Package
->GuidEntry
);
530 CopyMem (&PackageHeader
, Package
->GuidPkg
, sizeof (EFI_HII_PACKAGE_HEADER
));
531 PackageList
->PackageListHdr
.PackageLength
-= PackageHeader
.Length
;
532 FreePool (Package
->GuidPkg
);
540 Check the input question related to EFI variable
542 @param IfrQuestionHdr Point to Question header
543 @param EfiVarStoreList Point to EFI VarStore List
544 @param EfiVarStoreNumber The number of EFI VarStore
546 @retval Index The index of the found EFI varstore in EFI varstore list
547 EfiVarStoreNumber will return if no EFI varstore is found.
550 IsEfiVarStoreQuestion (
551 EFI_IFR_QUESTION_HEADER
*IfrQuestionHdr
,
552 EFI_IFR_VARSTORE_EFI
**EfiVarStoreList
,
553 UINTN EfiVarStoreNumber
557 for (Index
= 0; Index
< EfiVarStoreNumber
; Index
++) {
558 if (IfrQuestionHdr
->VarStoreId
== EfiVarStoreList
[Index
]->VarStoreId
) {
563 return EfiVarStoreNumber
;
567 Find the matched variable from the input variable storage.
569 @param[in] VariableStorage Point to the variable storage header.
570 @param[in] VarGuid A unique identifier for the variable.
571 @param[in] VarAttribute The attributes bitmask for the variable.
572 @param[in] VarName A Null-terminated ascii string that is the name of the variable.
574 @return Pointer to the matched variable header or NULL if not found.
578 IN VARIABLE_STORE_HEADER
*VariableStorage
,
579 IN EFI_GUID
*VarGuid
,
580 IN UINT32 VarAttribute
,
584 VARIABLE_HEADER
*VariableHeader
;
585 VARIABLE_HEADER
*VariableEnd
;
587 VariableEnd
= (VARIABLE_HEADER
*) ((UINT8
*) VariableStorage
+ VariableStorage
->Size
);
588 VariableHeader
= (VARIABLE_HEADER
*) (VariableStorage
+ 1);
589 VariableHeader
= (VARIABLE_HEADER
*) HEADER_ALIGN (VariableHeader
);
590 while (VariableHeader
< VariableEnd
) {
591 if (CompareGuid (&VariableHeader
->VendorGuid
, VarGuid
) &&
592 VariableHeader
->Attributes
== VarAttribute
&&
593 StrCmp (VarName
, (CHAR16
*) (VariableHeader
+ 1)) == 0) {
594 return VariableHeader
;
596 VariableHeader
= (VARIABLE_HEADER
*) ((UINT8
*) VariableHeader
+ sizeof (VARIABLE_HEADER
) + VariableHeader
->NameSize
+ VariableHeader
->DataSize
);
597 VariableHeader
= (VARIABLE_HEADER
*) HEADER_ALIGN (VariableHeader
);
604 Find question default value from PcdNvStoreDefaultValueBuffer
606 @param DefaultId Default store ID
607 @param EfiVarStore Point to EFI VarStore header
608 @param IfrQuestionHdr Point to Question header
609 @param ValueBuffer Point to Buffer includes the found default setting
610 @param Width Width of the default value
611 @param BitFieldQuestion Whether the Question is stored in Bit field.
613 @retval EFI_SUCCESS Question default value is found.
614 @retval EFI_NOT_FOUND Question default value is not found.
617 FindQuestionDefaultSetting (
619 IN EFI_IFR_VARSTORE_EFI
*EfiVarStore
,
620 IN EFI_IFR_QUESTION_HEADER
*IfrQuestionHdr
,
621 OUT VOID
*ValueBuffer
,
623 IN BOOLEAN BitFieldQuestion
626 VARIABLE_HEADER
*VariableHeader
;
627 VARIABLE_STORE_HEADER
*VariableStorage
;
629 VARSTORAGE_DEFAULT_DATA
*Entry
;
630 VARIABLE_STORE_HEADER
*NvStoreBuffer
;
642 PCD_DEFAULT_DATA
*DataHeader
;
643 PCD_DEFAULT_INFO
*DefaultInfo
;
644 PCD_DATA_DELTA
*DeltaData
;
646 if (gSkuId
== 0xFFFFFFFFFFFFFFFF) {
647 gSkuId
= LibPcdGetSku ();
651 // Find the DefaultId setting from the full DefaultSetting
653 VariableStorage
= NULL
;
654 Link
= gVarStorageList
.ForwardLink
;
655 while (Link
!= &gVarStorageList
) {
656 Entry
= BASE_CR (Link
, VARSTORAGE_DEFAULT_DATA
, Entry
);
657 if (Entry
->DefaultId
== DefaultId
) {
658 VariableStorage
= Entry
->VariableStorage
;
661 Link
= Link
->ForwardLink
;
664 if (Link
== &gVarStorageList
) {
665 DataBuffer
= (UINT8
*) PcdGetPtr (PcdNvStoreDefaultValueBuffer
);
666 gNvDefaultStoreSize
= ((PCD_NV_STORE_DEFAULT_BUFFER_HEADER
*)DataBuffer
)->Length
;
668 // The first section data includes NV storage default setting.
670 DataHeader
= (PCD_DEFAULT_DATA
*) (DataBuffer
+ sizeof (PCD_NV_STORE_DEFAULT_BUFFER_HEADER
));
671 NvStoreBuffer
= (VARIABLE_STORE_HEADER
*) ((UINT8
*) DataHeader
+ sizeof (DataHeader
->DataSize
) + DataHeader
->HeaderSize
);
672 VariableStorage
= AllocatePool (NvStoreBuffer
->Size
);
673 ASSERT (VariableStorage
!= NULL
);
674 CopyMem (VariableStorage
, NvStoreBuffer
, NvStoreBuffer
->Size
);
677 // Find the matched SkuId and DefaultId in the first section
680 DefaultInfo
= &(DataHeader
->DefaultInfo
[0]);
681 BufferEnd
= (UINT8
*) DataHeader
+ sizeof (DataHeader
->DataSize
) + DataHeader
->HeaderSize
;
682 while ((UINT8
*) DefaultInfo
< BufferEnd
) {
683 if (DefaultInfo
->DefaultId
== DefaultId
&& DefaultInfo
->SkuId
== gSkuId
) {
690 // Find the matched SkuId and DefaultId in the remaining section
692 Index
= sizeof (PCD_NV_STORE_DEFAULT_BUFFER_HEADER
) + ((DataHeader
->DataSize
+ 7) & (~7));
693 DataHeader
= (PCD_DEFAULT_DATA
*) (DataBuffer
+ Index
);
694 while (!IsFound
&& Index
< gNvDefaultStoreSize
&& DataHeader
->DataSize
!= 0xFFFF) {
695 DefaultInfo
= &(DataHeader
->DefaultInfo
[0]);
696 BufferEnd
= (UINT8
*) DataHeader
+ sizeof (DataHeader
->DataSize
) + DataHeader
->HeaderSize
;
697 while ((UINT8
*) DefaultInfo
< BufferEnd
) {
698 if (DefaultInfo
->DefaultId
== DefaultId
&& DefaultInfo
->SkuId
== gSkuId
) {
705 DeltaData
= (PCD_DATA_DELTA
*) BufferEnd
;
706 BufferEnd
= (UINT8
*) DataHeader
+ DataHeader
->DataSize
;
707 while ((UINT8
*) DeltaData
< BufferEnd
) {
708 *((UINT8
*) VariableStorage
+ DeltaData
->Offset
) = (UINT8
) DeltaData
->Value
;
713 Index
= (Index
+ DataHeader
->DataSize
+ 7) & (~7);
714 DataHeader
= (PCD_DEFAULT_DATA
*) (DataBuffer
+ Index
);
717 // Cache the found result in VarStorageList
720 FreePool (VariableStorage
);
721 VariableStorage
= NULL
;
723 Entry
= AllocatePool (sizeof (VARSTORAGE_DEFAULT_DATA
));
725 Entry
->DefaultId
= DefaultId
;
726 Entry
->VariableStorage
= VariableStorage
;
727 InsertTailList (&gVarStorageList
, &Entry
->Entry
);
728 } else if (VariableStorage
!= NULL
) {
729 FreePool (VariableStorage
);
730 VariableStorage
= NULL
;
734 // The matched variable storage is not found.
736 if (VariableStorage
== NULL
) {
737 return EFI_NOT_FOUND
;
741 // Find the question default value from the variable storage
743 VariableHeader
= FindVariableData (VariableStorage
, &EfiVarStore
->Guid
, EfiVarStore
->Attributes
, (CHAR16
*) EfiVarStore
->Name
);
744 if (VariableHeader
== NULL
) {
745 return EFI_NOT_FOUND
;
749 ByteOffset
= IfrQuestionHdr
->VarStoreInfo
.VarOffset
;
750 if (BitFieldQuestion
) {
751 BitOffset
= IfrQuestionHdr
->VarStoreInfo
.VarOffset
;
752 ByteOffset
= BitOffset
/ 8;
754 StartBit
= BitOffset
% 8;
755 EndBit
= StartBit
+ BitWidth
- 1;
756 Width
= EndBit
/ 8 + 1;
758 if (VariableHeader
->DataSize
< ByteOffset
+ Width
) {
759 return EFI_INVALID_PARAMETER
;
763 // Copy the question value
765 if (ValueBuffer
!= NULL
) {
766 if (BitFieldQuestion
) {
767 CopyMem (&BufferValue
, (UINT8
*) VariableHeader
+ sizeof (VARIABLE_HEADER
) + VariableHeader
->NameSize
+ ByteOffset
, Width
);
768 BitFieldVal
= BitFieldRead32 (BufferValue
, StartBit
, EndBit
);
769 CopyMem (ValueBuffer
, &BitFieldVal
, Width
);
771 CopyMem (ValueBuffer
, (UINT8
*) VariableHeader
+ sizeof (VARIABLE_HEADER
) + VariableHeader
->NameSize
+ IfrQuestionHdr
->VarStoreInfo
.VarOffset
, Width
);
779 Update IFR default setting in Form Package.
781 @param FormPackage Form Package to be updated
785 UpdateDefaultSettingInFormPackage (
786 HII_IFR_PACKAGE_INSTANCE
*FormPackage
791 EFI_IFR_VARSTORE_EFI
*IfrEfiVarStore
;
792 EFI_IFR_OP_HEADER
*IfrOpHdr
;
793 EFI_IFR_ONE_OF_OPTION
*IfrOneOfOption
;
794 UINT8 IfrQuestionType
;
796 EFI_IFR_QUESTION_HEADER
*IfrQuestionHdr
;
797 EFI_IFR_VARSTORE_EFI
**EfiVarStoreList
;
798 UINTN EfiVarStoreMaxNum
;
799 UINTN EfiVarStoreNumber
;
800 UINT16
*DefaultIdList
;
801 UINTN DefaultIdNumber
;
802 UINTN DefaultIdMaxNum
;
804 UINTN EfiVarStoreIndex
;
805 EFI_IFR_TYPE_VALUE IfrValue
;
806 EFI_IFR_TYPE_VALUE IfrManufactValue
;
807 BOOLEAN StandardDefaultIsSet
;
808 BOOLEAN ManufactDefaultIsSet
;
809 EFI_IFR_CHECKBOX
*IfrCheckBox
;
811 EFI_IFR_DEFAULT
*IfrDefault
;
813 EFI_IFR_QUESTION_HEADER VarStoreQuestionHeader
;
814 BOOLEAN QuestionReferBitField
;
817 // If no default setting, do nothing
819 if (gNvDefaultStoreSize
== 0) {
820 gNvDefaultStoreSize
= PcdGetSize (PcdNvStoreDefaultValueBuffer
);
822 if (gNvDefaultStoreSize
< sizeof (PCD_NV_STORE_DEFAULT_BUFFER_HEADER
)) {
826 ZeroMem (&VarStoreQuestionHeader
, sizeof (VarStoreQuestionHeader
));
827 PackageLength
= FormPackage
->FormPkgHdr
.Length
- sizeof (EFI_HII_PACKAGE_HEADER
);
831 IfrOpHdr
= (EFI_IFR_OP_HEADER
*) FormPackage
->IfrData
;
832 IfrQuestionHdr
= NULL
;
834 EfiVarStoreMaxNum
= 0;
835 EfiVarStoreNumber
= 0;
838 EfiVarStoreList
= NULL
;
839 DefaultIdList
= NULL
;
840 StandardDefaultIsSet
= FALSE
;
841 ManufactDefaultIsSet
= FALSE
;
842 QuestionReferBitField
= FALSE
;
844 while (IfrOffset
< PackageLength
) {
845 switch (IfrOpHdr
->OpCode
) {
846 case EFI_IFR_VARSTORE_EFI_OP
:
847 if (EfiVarStoreNumber
>= EfiVarStoreMaxNum
) {
849 // Reallocate EFI VarStore Buffer
851 EfiVarStoreList
= ReallocatePool (EfiVarStoreMaxNum
* sizeof (UINTN
), (EfiVarStoreMaxNum
+ BASE_NUMBER
) * sizeof (UINTN
), EfiVarStoreList
);
852 if (EfiVarStoreList
== NULL
) {
855 EfiVarStoreMaxNum
= EfiVarStoreMaxNum
+ BASE_NUMBER
;
857 IfrEfiVarStore
= (EFI_IFR_VARSTORE_EFI
*) IfrOpHdr
;
859 // Convert VarStore Name from ASCII string to Unicode string.
861 EfiVarStoreList
[EfiVarStoreNumber
] = AllocatePool (IfrEfiVarStore
->Header
.Length
+ AsciiStrSize ((CHAR8
*)IfrEfiVarStore
->Name
));
862 if (EfiVarStoreList
[EfiVarStoreNumber
] == NULL
) {
865 CopyMem (EfiVarStoreList
[EfiVarStoreNumber
], IfrEfiVarStore
, IfrEfiVarStore
->Header
.Length
);
866 AsciiStrToUnicodeStrS ((CHAR8
*)IfrEfiVarStore
->Name
, (CHAR16
*) &(EfiVarStoreList
[EfiVarStoreNumber
]->Name
[0]), AsciiStrSize ((CHAR8
*)IfrEfiVarStore
->Name
) * sizeof (CHAR16
));
867 Status
= FindQuestionDefaultSetting (EFI_HII_DEFAULT_CLASS_STANDARD
, EfiVarStoreList
[EfiVarStoreNumber
], &VarStoreQuestionHeader
, NULL
, IfrEfiVarStore
->Size
, FALSE
);
868 if (!EFI_ERROR (Status
)) {
869 EfiVarStoreNumber
++;
871 FreePool (EfiVarStoreList
[EfiVarStoreNumber
]);
872 EfiVarStoreList
[EfiVarStoreNumber
] = NULL
;
875 case EFI_IFR_DEFAULTSTORE_OP
:
876 if (DefaultIdNumber
>= DefaultIdMaxNum
) {
878 // Reallocate DefaultIdNumber
880 DefaultIdList
= ReallocatePool (DefaultIdMaxNum
* sizeof (UINT16
), (DefaultIdMaxNum
+ BASE_NUMBER
) * sizeof (UINT16
), DefaultIdList
);
881 if (DefaultIdList
== NULL
) {
884 DefaultIdMaxNum
= DefaultIdMaxNum
+ BASE_NUMBER
;
886 DefaultIdList
[DefaultIdNumber
++] = ((EFI_IFR_DEFAULTSTORE
*) IfrOpHdr
)->DefaultId
;
888 case EFI_IFR_FORM_OP
:
889 case EFI_IFR_FORM_MAP_OP
:
891 // No EFI varstore is found and directly return.
893 if (EfiVarStoreNumber
== 0 || DefaultIdNumber
== 0) {
897 case EFI_IFR_CHECKBOX_OP
:
898 IfrScope
= IfrOpHdr
->Scope
;
899 IfrQuestionType
= IfrOpHdr
->OpCode
;
900 IfrQuestionHdr
= (EFI_IFR_QUESTION_HEADER
*) (IfrOpHdr
+ 1);
901 IfrCheckBox
= (EFI_IFR_CHECKBOX
*) (IfrOpHdr
+ 1);
902 EfiVarStoreIndex
= IsEfiVarStoreQuestion (IfrQuestionHdr
, EfiVarStoreList
, EfiVarStoreNumber
);
903 Width
= sizeof (BOOLEAN
);
904 if (EfiVarStoreIndex
< EfiVarStoreNumber
) {
905 for (Index
= 0; Index
< DefaultIdNumber
; Index
++) {
906 if (DefaultIdList
[Index
] == EFI_HII_DEFAULT_CLASS_STANDARD
) {
907 Status
= FindQuestionDefaultSetting (DefaultIdList
[Index
], EfiVarStoreList
[EfiVarStoreIndex
], IfrQuestionHdr
, &IfrValue
, sizeof (BOOLEAN
), QuestionReferBitField
);
908 if (!EFI_ERROR (Status
)) {
910 IfrCheckBox
->Flags
= IfrCheckBox
->Flags
| EFI_IFR_CHECKBOX_DEFAULT
;
912 IfrCheckBox
->Flags
= IfrCheckBox
->Flags
& (~EFI_IFR_CHECKBOX_DEFAULT
);
915 } else if (DefaultIdList
[Index
] == EFI_HII_DEFAULT_CLASS_MANUFACTURING
) {
916 Status
= FindQuestionDefaultSetting (DefaultIdList
[Index
], EfiVarStoreList
[EfiVarStoreIndex
], IfrQuestionHdr
, &IfrValue
, sizeof (BOOLEAN
), QuestionReferBitField
);
917 if (!EFI_ERROR (Status
)) {
919 IfrCheckBox
->Flags
= IfrCheckBox
->Flags
| EFI_IFR_CHECKBOX_DEFAULT_MFG
;
921 IfrCheckBox
->Flags
= IfrCheckBox
->Flags
& (~EFI_IFR_CHECKBOX_DEFAULT_MFG
);
928 case EFI_IFR_NUMERIC_OP
:
929 IfrScope
= IfrOpHdr
->Scope
;
930 IfrQuestionType
= IfrOpHdr
->OpCode
;
931 IfrQuestionHdr
= (EFI_IFR_QUESTION_HEADER
*) (IfrOpHdr
+ 1);
932 if (QuestionReferBitField
) {
933 Width
= (UINTN
) (((EFI_IFR_ONE_OF
*) IfrOpHdr
)->Flags
& EDKII_IFR_NUMERIC_SIZE_BIT
);
935 Width
= (UINTN
) ((UINT32
) 1 << (((EFI_IFR_ONE_OF
*) IfrOpHdr
)->Flags
& EFI_IFR_NUMERIC_SIZE
));
938 case EFI_IFR_ONE_OF_OP
:
939 IfrScope
= IfrOpHdr
->Scope
;
940 IfrQuestionType
= IfrOpHdr
->OpCode
;
941 IfrQuestionHdr
= (EFI_IFR_QUESTION_HEADER
*) (IfrOpHdr
+ 1);
942 if (QuestionReferBitField
) {
943 Width
= (UINTN
) (((EFI_IFR_ONE_OF
*) IfrOpHdr
)->Flags
& EDKII_IFR_NUMERIC_SIZE_BIT
);
945 Width
= (UINTN
) ((UINT32
) 1 << (((EFI_IFR_ONE_OF
*) IfrOpHdr
)->Flags
& EFI_IFR_NUMERIC_SIZE
));
947 EfiVarStoreIndex
= IsEfiVarStoreQuestion (IfrQuestionHdr
, EfiVarStoreList
, EfiVarStoreNumber
);
948 StandardDefaultIsSet
= FALSE
;
949 ManufactDefaultIsSet
= FALSE
;
951 // Find Default and Manufacturing default for OneOf question
953 if (EfiVarStoreIndex
< EfiVarStoreNumber
) {
954 for (Index
= 0; Index
< DefaultIdNumber
; Index
++) {
955 if (DefaultIdList
[Index
] == EFI_HII_DEFAULT_CLASS_STANDARD
) {
956 Status
= FindQuestionDefaultSetting (EFI_HII_DEFAULT_CLASS_STANDARD
, EfiVarStoreList
[EfiVarStoreIndex
], IfrQuestionHdr
, &IfrValue
, Width
, QuestionReferBitField
);
957 if (!EFI_ERROR (Status
)) {
958 StandardDefaultIsSet
= TRUE
;
960 } else if (DefaultIdList
[Index
] == EFI_HII_DEFAULT_CLASS_MANUFACTURING
) {
961 Status
= FindQuestionDefaultSetting (EFI_HII_DEFAULT_CLASS_MANUFACTURING
, EfiVarStoreList
[EfiVarStoreIndex
], IfrQuestionHdr
, &IfrManufactValue
, Width
, QuestionReferBitField
);
962 if (!EFI_ERROR (Status
)) {
963 ManufactDefaultIsSet
= TRUE
;
969 case EFI_IFR_ORDERED_LIST_OP
:
970 IfrScope
= IfrOpHdr
->Scope
;
971 IfrQuestionType
= IfrOpHdr
->OpCode
;
972 IfrQuestionHdr
= (EFI_IFR_QUESTION_HEADER
*) (IfrOpHdr
+ 1);
974 case EFI_IFR_ONE_OF_OPTION_OP
:
975 if (IfrQuestionHdr
!= NULL
&& IfrScope
> 0) {
976 IfrOneOfOption
= (EFI_IFR_ONE_OF_OPTION
*) IfrOpHdr
;
977 if (IfrQuestionType
== EFI_IFR_ONE_OF_OP
) {
978 Width
= (UINTN
) ((UINT32
) 1 << (IfrOneOfOption
->Flags
& EFI_IFR_NUMERIC_SIZE
));
979 if (StandardDefaultIsSet
) {
980 if (CompareMem (&IfrOneOfOption
->Value
, &IfrValue
, Width
) == 0) {
981 IfrOneOfOption
->Flags
|= EFI_IFR_OPTION_DEFAULT
;
983 IfrOneOfOption
->Flags
&= ~EFI_IFR_OPTION_DEFAULT
;
986 if (ManufactDefaultIsSet
) {
987 if (CompareMem (&IfrOneOfOption
->Value
, &IfrManufactValue
, Width
) == 0) {
988 IfrOneOfOption
->Flags
|= EFI_IFR_OPTION_DEFAULT_MFG
;
990 IfrOneOfOption
->Flags
&= ~EFI_IFR_OPTION_DEFAULT_MFG
;
996 case EFI_IFR_DEFAULT_OP
:
997 if (IfrQuestionHdr
!= NULL
&& IfrScope
> 0) {
998 IfrDefault
= (EFI_IFR_DEFAULT
*) IfrOpHdr
;
1000 // Collect default value width
1002 if (!QuestionReferBitField
) {
1004 if (IfrDefault
->Type
== EFI_IFR_TYPE_NUM_SIZE_8
|| IfrDefault
->Type
== EFI_IFR_TYPE_BOOLEAN
) {
1006 } else if (IfrDefault
->Type
== EFI_IFR_TYPE_NUM_SIZE_16
) {
1008 } else if (IfrDefault
->Type
== EFI_IFR_TYPE_NUM_SIZE_32
) {
1010 } else if (IfrDefault
->Type
== EFI_IFR_TYPE_NUM_SIZE_64
) {
1012 } else if (IfrDefault
->Type
== EFI_IFR_TYPE_BUFFER
) {
1013 Width
= IfrDefault
->Header
.Length
- OFFSET_OF (EFI_IFR_DEFAULT
, Value
);
1017 // Update the default value
1020 EfiVarStoreIndex
= IsEfiVarStoreQuestion (IfrQuestionHdr
, EfiVarStoreList
, EfiVarStoreNumber
);
1021 if (EfiVarStoreIndex
< EfiVarStoreNumber
) {
1022 Status
= FindQuestionDefaultSetting (IfrDefault
->DefaultId
, EfiVarStoreList
[EfiVarStoreIndex
], IfrQuestionHdr
, &IfrDefault
->Value
, Width
, QuestionReferBitField
);
1027 case EFI_IFR_END_OP
:
1028 if (IfrQuestionHdr
!= NULL
) {
1032 if (IfrScope
== 0) {
1033 IfrQuestionHdr
= NULL
;
1034 QuestionReferBitField
= FALSE
;
1038 case EFI_IFR_GUID_OP
:
1039 if (CompareGuid ((EFI_GUID
*)((UINT8
*)IfrOpHdr
+ sizeof (EFI_IFR_OP_HEADER
)), &gEdkiiIfrBitVarstoreGuid
)) {
1040 QuestionReferBitField
= TRUE
;
1046 IfrOffset
= IfrOffset
+ IfrOpHdr
->Length
;
1047 IfrOpHdr
= (EFI_IFR_OP_HEADER
*) ((UINT8
*) IfrOpHdr
+ IfrOpHdr
->Length
);
1049 IfrScope
+= IfrOpHdr
->Scope
;
1054 if (EfiVarStoreList
!= NULL
) {
1055 for (Index
= 0; Index
< EfiVarStoreNumber
; Index
++) {
1056 FreePool (EfiVarStoreList
[Index
]);
1063 This function insert a Form package to a package list node.
1064 This is a internal function.
1066 @param PackageHdr Pointer to a buffer stored with Form package
1068 @param NotifyType The type of change concerning the database.
1069 @param PackageList Pointer to a package list which will be inserted
1071 @param Package Created Form package
1073 @retval EFI_SUCCESS Form Package is inserted successfully.
1074 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
1076 @retval EFI_INVALID_PARAMETER PackageHdr is NULL or PackageList is NULL.
1081 IN VOID
*PackageHdr
,
1082 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType
,
1083 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
,
1084 OUT HII_IFR_PACKAGE_INSTANCE
**Package
1087 HII_IFR_PACKAGE_INSTANCE
*FormPackage
;
1088 EFI_HII_PACKAGE_HEADER PackageHeader
;
1090 if (PackageHdr
== NULL
|| PackageList
== NULL
) {
1091 return EFI_INVALID_PARAMETER
;
1095 // Get the length of the package, including package header itself
1097 CopyMem (&PackageHeader
, PackageHdr
, sizeof (EFI_HII_PACKAGE_HEADER
));
1100 // Create a Form package node
1102 FormPackage
= (HII_IFR_PACKAGE_INSTANCE
*) AllocateZeroPool (sizeof (HII_IFR_PACKAGE_INSTANCE
));
1103 if (FormPackage
== NULL
) {
1104 return EFI_OUT_OF_RESOURCES
;
1107 FormPackage
->IfrData
= (UINT8
*) AllocateZeroPool (PackageHeader
.Length
- sizeof (EFI_HII_PACKAGE_HEADER
));
1108 if (FormPackage
->IfrData
== NULL
) {
1109 FreePool (FormPackage
);
1110 return EFI_OUT_OF_RESOURCES
;
1113 FormPackage
->Signature
= HII_IFR_PACKAGE_SIGNATURE
;
1115 // Copy Package Header
1117 CopyMem (&FormPackage
->FormPkgHdr
, &PackageHeader
, sizeof (EFI_HII_PACKAGE_HEADER
));
1120 // Copy Ifr contents
1123 FormPackage
->IfrData
,
1124 (UINT8
*) PackageHdr
+ sizeof (EFI_HII_PACKAGE_HEADER
),
1125 PackageHeader
.Length
- sizeof (EFI_HII_PACKAGE_HEADER
)
1128 InsertTailList (&PackageList
->FormPkgHdr
, &FormPackage
->IfrEntry
);
1129 *Package
= FormPackage
;
1132 // Update FormPackage with the default setting
1134 UpdateDefaultSettingInFormPackage (FormPackage
);
1136 if (NotifyType
== EFI_HII_DATABASE_NOTIFY_ADD_PACK
) {
1137 PackageList
->PackageListHdr
.PackageLength
+= FormPackage
->FormPkgHdr
.Length
;
1144 This function exports Form packages to a buffer.
1145 This is a internal function.
1147 @param Private Hii database private structure.
1148 @param Handle Identification of a package list.
1149 @param PackageList Pointer to a package list which will be exported.
1150 @param UsedSize The length of buffer be used.
1151 @param BufferSize Length of the Buffer.
1152 @param Buffer Allocated space for storing exported data.
1153 @param ResultSize The size of the already exported content of this
1156 @retval EFI_SUCCESS Form Packages are exported successfully.
1157 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
1161 ExportFormPackages (
1162 IN HII_DATABASE_PRIVATE_DATA
*Private
,
1163 IN EFI_HII_HANDLE Handle
,
1164 IN HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
,
1166 IN UINTN BufferSize
,
1167 IN OUT VOID
*Buffer
,
1168 IN OUT UINTN
*ResultSize
1171 HII_IFR_PACKAGE_INSTANCE
*FormPackage
;
1172 UINTN PackageLength
;
1176 if (Private
== NULL
|| PackageList
== NULL
|| ResultSize
== NULL
) {
1177 return EFI_INVALID_PARAMETER
;
1180 if (BufferSize
> 0 && Buffer
== NULL
) {
1181 return EFI_INVALID_PARAMETER
;
1185 Status
= EFI_SUCCESS
;
1188 // Export Form packages.
1190 for (Link
= PackageList
->FormPkgHdr
.ForwardLink
; Link
!= &PackageList
->FormPkgHdr
; Link
= Link
->ForwardLink
) {
1191 FormPackage
= CR (Link
, HII_IFR_PACKAGE_INSTANCE
, IfrEntry
, HII_IFR_PACKAGE_SIGNATURE
);
1192 PackageLength
+= FormPackage
->FormPkgHdr
.Length
;
1193 if ((Buffer
!= NULL
) && (PackageLength
+ *ResultSize
+ UsedSize
<= BufferSize
)) {
1195 // Invoke registered notification if exists
1197 Status
= InvokeRegisteredFunction (
1199 EFI_HII_DATABASE_NOTIFY_EXPORT_PACK
,
1200 (VOID
*) FormPackage
,
1201 EFI_HII_PACKAGE_FORMS
,
1204 ASSERT_EFI_ERROR (Status
);
1206 // Copy the Form package content.
1208 CopyMem (Buffer
, (VOID
*) (&FormPackage
->FormPkgHdr
), sizeof (EFI_HII_PACKAGE_HEADER
));
1209 Buffer
= (UINT8
*) Buffer
+ sizeof (EFI_HII_PACKAGE_HEADER
);
1212 (VOID
*) FormPackage
->IfrData
,
1213 FormPackage
->FormPkgHdr
.Length
- sizeof (EFI_HII_PACKAGE_HEADER
)
1215 Buffer
= (UINT8
*) Buffer
+ FormPackage
->FormPkgHdr
.Length
- sizeof (EFI_HII_PACKAGE_HEADER
);
1219 *ResultSize
+= PackageLength
;
1227 This function deletes all Form packages from a package list node.
1228 This is a internal function.
1230 @param Private Hii database private data.
1231 @param Handle Handle of the package list which contains the to
1232 be removed Form packages.
1233 @param PackageList Pointer to a package list that contains removing
1236 @retval EFI_SUCCESS Form Package(s) is deleted successfully.
1237 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
1241 RemoveFormPackages (
1242 IN HII_DATABASE_PRIVATE_DATA
*Private
,
1243 IN EFI_HII_HANDLE Handle
,
1244 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
1247 LIST_ENTRY
*ListHead
;
1248 HII_IFR_PACKAGE_INSTANCE
*Package
;
1251 ListHead
= &PackageList
->FormPkgHdr
;
1253 while (!IsListEmpty (ListHead
)) {
1255 ListHead
->ForwardLink
,
1256 HII_IFR_PACKAGE_INSTANCE
,
1258 HII_IFR_PACKAGE_SIGNATURE
1260 Status
= InvokeRegisteredFunction (
1262 EFI_HII_DATABASE_NOTIFY_REMOVE_PACK
,
1264 EFI_HII_PACKAGE_FORMS
,
1267 if (EFI_ERROR (Status
)) {
1271 RemoveEntryList (&Package
->IfrEntry
);
1272 PackageList
->PackageListHdr
.PackageLength
-= Package
->FormPkgHdr
.Length
;
1273 FreePool (Package
->IfrData
);
1276 // If Hii runtime support feature is enabled,
1277 // will export Hii info for runtime use after ReadyToBoot event triggered.
1278 // If some driver add/update/remove packages from HiiDatabase after ReadyToBoot,
1279 // will need to export the content of HiiDatabase.
1280 // But if form packages removed, also need to export the ConfigResp string
1282 if (gExportAfterReadyToBoot
) {
1283 gExportConfigResp
= TRUE
;
1293 This function insert a String package to a package list node.
1294 This is a internal function.
1296 @param Private Hii database private structure.
1297 @param PackageHdr Pointer to a buffer stored with String package
1299 @param NotifyType The type of change concerning the database.
1300 @param PackageList Pointer to a package list which will be inserted
1302 @param Package Created String package
1304 @retval EFI_SUCCESS String Package is inserted successfully.
1305 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
1307 @retval EFI_INVALID_PARAMETER PackageHdr is NULL or PackageList is NULL.
1308 @retval EFI_UNSUPPORTED A string package with the same language already
1309 exists in current package list.
1313 InsertStringPackage (
1314 IN HII_DATABASE_PRIVATE_DATA
*Private
,
1315 IN VOID
*PackageHdr
,
1316 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType
,
1317 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
,
1318 OUT HII_STRING_PACKAGE_INSTANCE
**Package
1321 HII_STRING_PACKAGE_INSTANCE
*StringPackage
;
1324 EFI_HII_PACKAGE_HEADER PackageHeader
;
1326 UINT32 LanguageSize
;
1329 if (Private
== NULL
|| PackageHdr
== NULL
|| PackageList
== NULL
) {
1330 return EFI_INVALID_PARAMETER
;
1332 if (Private
->Signature
!= HII_DATABASE_PRIVATE_DATA_SIGNATURE
) {
1333 return EFI_INVALID_PARAMETER
;
1336 CopyMem (&PackageHeader
, PackageHdr
, sizeof (EFI_HII_PACKAGE_HEADER
));
1337 CopyMem (&HeaderSize
, (UINT8
*) PackageHdr
+ sizeof (EFI_HII_PACKAGE_HEADER
), sizeof (UINT32
));
1340 // It is illegal to have two string packages with same language within one packagelist
1341 // since the stringid will be duplicate if so. Check it to avoid this potential issue.
1343 LanguageSize
= HeaderSize
- sizeof (EFI_HII_STRING_PACKAGE_HDR
) + sizeof (CHAR8
);
1344 Language
= (CHAR8
*) AllocateZeroPool (LanguageSize
);
1345 if (Language
== NULL
) {
1346 return EFI_OUT_OF_RESOURCES
;
1348 AsciiStrCpyS (Language
, LanguageSize
/ sizeof (CHAR8
), (CHAR8
*) PackageHdr
+ HeaderSize
- LanguageSize
);
1349 for (Link
= PackageList
->StringPkgHdr
.ForwardLink
; Link
!= &PackageList
->StringPkgHdr
; Link
= Link
->ForwardLink
) {
1350 StringPackage
= CR (Link
, HII_STRING_PACKAGE_INSTANCE
, StringEntry
, HII_STRING_PACKAGE_SIGNATURE
);
1351 if (HiiCompareLanguage (Language
, StringPackage
->StringPkgHdr
->Language
)) {
1352 FreePool (Language
);
1353 return EFI_UNSUPPORTED
;
1356 FreePool (Language
);
1359 // Create a String package node
1361 StringPackage
= (HII_STRING_PACKAGE_INSTANCE
*) AllocateZeroPool (sizeof (HII_STRING_PACKAGE_INSTANCE
));
1362 if (StringPackage
== NULL
) {
1363 Status
= EFI_OUT_OF_RESOURCES
;
1367 StringPackage
->StringPkgHdr
= (EFI_HII_STRING_PACKAGE_HDR
*) AllocateZeroPool (HeaderSize
);
1368 if (StringPackage
->StringPkgHdr
== NULL
) {
1369 Status
= EFI_OUT_OF_RESOURCES
;
1373 StringPackage
->StringBlock
= (UINT8
*) AllocateZeroPool (PackageHeader
.Length
- HeaderSize
);
1374 if (StringPackage
->StringBlock
== NULL
) {
1375 Status
= EFI_OUT_OF_RESOURCES
;
1379 StringPackage
->Signature
= HII_STRING_PACKAGE_SIGNATURE
;
1380 StringPackage
->FontId
= 0;
1381 InitializeListHead (&StringPackage
->FontInfoList
);
1384 // Copy the String package header.
1386 CopyMem (StringPackage
->StringPkgHdr
, PackageHdr
, HeaderSize
);
1389 // Copy the String blocks
1392 StringPackage
->StringBlock
,
1393 (UINT8
*) PackageHdr
+ HeaderSize
,
1394 PackageHeader
.Length
- HeaderSize
1398 // Collect all font block info
1400 Status
= FindStringBlock (Private
, StringPackage
, (EFI_STRING_ID
) (-1), NULL
, NULL
, NULL
, &StringPackage
->MaxStringId
, NULL
);
1401 if (EFI_ERROR (Status
)) {
1406 // Insert to String package array
1408 InsertTailList (&PackageList
->StringPkgHdr
, &StringPackage
->StringEntry
);
1409 *Package
= StringPackage
;
1411 if (NotifyType
== EFI_HII_DATABASE_NOTIFY_ADD_PACK
) {
1412 PackageList
->PackageListHdr
.PackageLength
+= StringPackage
->StringPkgHdr
->Header
.Length
;
1419 if (StringPackage
!= NULL
) {
1420 if (StringPackage
->StringBlock
!= NULL
) {
1421 FreePool (StringPackage
->StringBlock
);
1423 if (StringPackage
->StringPkgHdr
!= NULL
) {
1424 FreePool (StringPackage
->StringPkgHdr
);
1426 FreePool (StringPackage
);
1433 Adjust all string packages in a single package list to have the same max string ID.
1435 @param PackageList Pointer to a package list which will be adjusted.
1437 @retval EFI_SUCCESS Adjust all string packages successfully.
1438 @retval others Can't adjust string packages.
1442 AdjustStringPackage (
1443 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
1447 HII_STRING_PACKAGE_INSTANCE
*StringPackage
;
1448 UINT32 Skip2BlockSize
;
1449 UINT32 OldBlockSize
;
1452 EFI_STRING_ID MaxStringId
;
1456 for (Link
= PackageList
->StringPkgHdr
.ForwardLink
;
1457 Link
!= &PackageList
->StringPkgHdr
;
1458 Link
= Link
->ForwardLink
1460 StringPackage
= CR (Link
, HII_STRING_PACKAGE_INSTANCE
, StringEntry
, HII_STRING_PACKAGE_SIGNATURE
);
1461 if (MaxStringId
< StringPackage
->MaxStringId
) {
1462 MaxStringId
= StringPackage
->MaxStringId
;
1466 for (Link
= PackageList
->StringPkgHdr
.ForwardLink
;
1467 Link
!= &PackageList
->StringPkgHdr
;
1468 Link
= Link
->ForwardLink
1470 StringPackage
= CR (Link
, HII_STRING_PACKAGE_INSTANCE
, StringEntry
, HII_STRING_PACKAGE_SIGNATURE
);
1471 if (StringPackage
->MaxStringId
< MaxStringId
) {
1472 OldBlockSize
= StringPackage
->StringPkgHdr
->Header
.Length
- StringPackage
->StringPkgHdr
->HdrSize
;
1474 // Create SKIP2 EFI_HII_SIBT_SKIP2_BLOCKs to reserve the missing string IDs.
1476 SkipCount
= (UINT16
) (MaxStringId
- StringPackage
->MaxStringId
);
1477 Skip2BlockSize
= (UINT32
) sizeof (EFI_HII_SIBT_SKIP2_BLOCK
);
1479 StringBlock
= (UINT8
*) AllocateZeroPool (OldBlockSize
+ Skip2BlockSize
);
1480 if (StringBlock
== NULL
) {
1481 return EFI_OUT_OF_RESOURCES
;
1484 // Copy original string blocks, except the EFI_HII_SIBT_END.
1486 CopyMem (StringBlock
, StringPackage
->StringBlock
, OldBlockSize
- sizeof (EFI_HII_SIBT_END_BLOCK
));
1488 // Create SKIP2 EFI_HII_SIBT_SKIP2_BLOCK blocks
1490 BlockPtr
= StringBlock
+ OldBlockSize
- sizeof (EFI_HII_SIBT_END_BLOCK
);
1491 *BlockPtr
= EFI_HII_SIBT_SKIP2
;
1492 CopyMem (BlockPtr
+ 1, &SkipCount
, sizeof (UINT16
));
1493 BlockPtr
+= sizeof (EFI_HII_SIBT_SKIP2_BLOCK
);
1496 // Append a EFI_HII_SIBT_END block to the end.
1498 *BlockPtr
= EFI_HII_SIBT_END
;
1499 FreePool (StringPackage
->StringBlock
);
1500 StringPackage
->StringBlock
= StringBlock
;
1501 StringPackage
->StringPkgHdr
->Header
.Length
+= Skip2BlockSize
;
1502 PackageList
->PackageListHdr
.PackageLength
+= Skip2BlockSize
;
1503 StringPackage
->MaxStringId
= MaxStringId
;
1511 This function exports String packages to a buffer.
1512 This is a internal function.
1514 @param Private Hii database private structure.
1515 @param Handle Identification of a package list.
1516 @param PackageList Pointer to a package list which will be exported.
1517 @param UsedSize The length of buffer be used.
1518 @param BufferSize Length of the Buffer.
1519 @param Buffer Allocated space for storing exported data.
1520 @param ResultSize The size of the already exported content of this
1523 @retval EFI_SUCCESS String Packages are exported successfully.
1524 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
1528 ExportStringPackages (
1529 IN HII_DATABASE_PRIVATE_DATA
*Private
,
1530 IN EFI_HII_HANDLE Handle
,
1531 IN HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
,
1533 IN UINTN BufferSize
,
1534 IN OUT VOID
*Buffer
,
1535 IN OUT UINTN
*ResultSize
1539 UINTN PackageLength
;
1541 HII_STRING_PACKAGE_INSTANCE
*StringPackage
;
1543 if (Private
== NULL
|| PackageList
== NULL
|| ResultSize
== NULL
) {
1544 return EFI_INVALID_PARAMETER
;
1547 if (BufferSize
> 0 && Buffer
== NULL
) {
1548 return EFI_INVALID_PARAMETER
;
1552 Status
= EFI_SUCCESS
;
1554 for (Link
= PackageList
->StringPkgHdr
.ForwardLink
; Link
!= &PackageList
->StringPkgHdr
; Link
= Link
->ForwardLink
) {
1555 StringPackage
= CR (Link
, HII_STRING_PACKAGE_INSTANCE
, StringEntry
, HII_STRING_PACKAGE_SIGNATURE
);
1556 PackageLength
+= StringPackage
->StringPkgHdr
->Header
.Length
;
1557 if (PackageLength
+ *ResultSize
+ UsedSize
<= BufferSize
) {
1559 // Invoke registered notification function with EXPORT_PACK notify type
1561 Status
= InvokeRegisteredFunction (
1563 EFI_HII_DATABASE_NOTIFY_EXPORT_PACK
,
1564 (VOID
*) StringPackage
,
1565 EFI_HII_PACKAGE_STRINGS
,
1568 ASSERT_EFI_ERROR (Status
);
1570 // Copy String package header
1572 CopyMem (Buffer
, StringPackage
->StringPkgHdr
, StringPackage
->StringPkgHdr
->HdrSize
);
1573 Buffer
= (UINT8
*) Buffer
+ StringPackage
->StringPkgHdr
->HdrSize
;
1576 // Copy String blocks information
1580 StringPackage
->StringBlock
,
1581 StringPackage
->StringPkgHdr
->Header
.Length
- StringPackage
->StringPkgHdr
->HdrSize
1583 Buffer
= (UINT8
*) Buffer
+ StringPackage
->StringPkgHdr
->Header
.Length
- StringPackage
->StringPkgHdr
->HdrSize
;
1587 *ResultSize
+= PackageLength
;
1593 This function deletes all String packages from a package list node.
1594 This is a internal function.
1596 @param Private Hii database private data.
1597 @param Handle Handle of the package list which contains the to
1598 be removed String packages.
1599 @param PackageList Pointer to a package list that contains removing
1602 @retval EFI_SUCCESS String Package(s) is deleted successfully.
1603 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
1607 RemoveStringPackages (
1608 IN HII_DATABASE_PRIVATE_DATA
*Private
,
1609 IN EFI_HII_HANDLE Handle
,
1610 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
1613 LIST_ENTRY
*ListHead
;
1614 HII_STRING_PACKAGE_INSTANCE
*Package
;
1615 HII_FONT_INFO
*FontInfo
;
1618 ListHead
= &PackageList
->StringPkgHdr
;
1620 while (!IsListEmpty (ListHead
)) {
1622 ListHead
->ForwardLink
,
1623 HII_STRING_PACKAGE_INSTANCE
,
1625 HII_STRING_PACKAGE_SIGNATURE
1627 Status
= InvokeRegisteredFunction (
1629 EFI_HII_DATABASE_NOTIFY_REMOVE_PACK
,
1631 EFI_HII_PACKAGE_STRINGS
,
1634 if (EFI_ERROR (Status
)) {
1638 RemoveEntryList (&Package
->StringEntry
);
1639 PackageList
->PackageListHdr
.PackageLength
-= Package
->StringPkgHdr
->Header
.Length
;
1640 FreePool (Package
->StringBlock
);
1641 FreePool (Package
->StringPkgHdr
);
1643 // Delete font information
1645 while (!IsListEmpty (&Package
->FontInfoList
)) {
1647 Package
->FontInfoList
.ForwardLink
,
1650 HII_FONT_INFO_SIGNATURE
1652 RemoveEntryList (&FontInfo
->Entry
);
1653 FreePool (FontInfo
);
1664 This function insert a Font package to a package list node.
1665 This is a internal function.
1667 @param Private Hii database private structure.
1668 @param PackageHdr Pointer to a buffer stored with Font package
1670 @param NotifyType The type of change concerning the database.
1671 @param PackageList Pointer to a package list which will be inserted
1673 @param Package Created Font package
1675 @retval EFI_SUCCESS Font Package is inserted successfully.
1676 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
1678 @retval EFI_INVALID_PARAMETER PackageHdr is NULL or PackageList is NULL.
1679 @retval EFI_UNSUPPORTED A font package with same EFI_FONT_INFO already
1680 exists in current hii database.
1685 IN HII_DATABASE_PRIVATE_DATA
*Private
,
1686 IN VOID
*PackageHdr
,
1687 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType
,
1688 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
,
1689 OUT HII_FONT_PACKAGE_INSTANCE
**Package
1692 HII_FONT_PACKAGE_INSTANCE
*FontPackage
;
1693 EFI_HII_FONT_PACKAGE_HDR
*FontPkgHdr
;
1696 EFI_HII_PACKAGE_HEADER PackageHeader
;
1697 EFI_FONT_INFO
*FontInfo
;
1698 UINT32 FontInfoSize
;
1699 HII_GLOBAL_FONT_INFO
*GlobalFont
;
1701 if (Private
== NULL
|| PackageHdr
== NULL
|| PackageList
== NULL
) {
1702 return EFI_INVALID_PARAMETER
;
1705 CopyMem (&PackageHeader
, PackageHdr
, sizeof (EFI_HII_PACKAGE_HEADER
));
1706 CopyMem (&HeaderSize
, (UINT8
*) PackageHdr
+ sizeof (EFI_HII_PACKAGE_HEADER
), sizeof (UINT32
));
1713 // It is illegal to have two font packages with same EFI_FONT_INFO within hii
1714 // database. EFI_FONT_INFO (FontName, FontSize, FontStyle) describes font's
1715 // attributes and identify a font uniquely.
1717 FontPkgHdr
= (EFI_HII_FONT_PACKAGE_HDR
*) AllocateZeroPool (HeaderSize
);
1718 if (FontPkgHdr
== NULL
) {
1719 Status
= EFI_OUT_OF_RESOURCES
;
1722 CopyMem (FontPkgHdr
, PackageHdr
, HeaderSize
);
1724 FontInfoSize
= sizeof (EFI_FONT_INFO
) + HeaderSize
- sizeof (EFI_HII_FONT_PACKAGE_HDR
);
1725 FontInfo
= (EFI_FONT_INFO
*) AllocateZeroPool (FontInfoSize
);
1726 if (FontInfo
== NULL
) {
1727 Status
= EFI_OUT_OF_RESOURCES
;
1730 FontInfo
->FontStyle
= FontPkgHdr
->FontStyle
;
1731 FontInfo
->FontSize
= FontPkgHdr
->Cell
.Height
;
1732 StrCpyS (FontInfo
->FontName
, (FontInfoSize
- OFFSET_OF(EFI_FONT_INFO
,FontName
)) / sizeof (CHAR16
), FontPkgHdr
->FontFamily
);
1734 if (IsFontInfoExisted (Private
, FontInfo
, NULL
, NULL
, NULL
)) {
1735 Status
= EFI_UNSUPPORTED
;
1740 // Create a Font package node
1742 FontPackage
= (HII_FONT_PACKAGE_INSTANCE
*) AllocateZeroPool (sizeof (HII_FONT_PACKAGE_INSTANCE
));
1743 if (FontPackage
== NULL
) {
1744 Status
= EFI_OUT_OF_RESOURCES
;
1747 FontPackage
->Signature
= HII_FONT_PACKAGE_SIGNATURE
;
1748 FontPackage
->FontPkgHdr
= FontPkgHdr
;
1749 InitializeListHead (&FontPackage
->GlyphInfoList
);
1751 FontPackage
->GlyphBlock
= (UINT8
*) AllocateZeroPool (PackageHeader
.Length
- HeaderSize
);
1752 if (FontPackage
->GlyphBlock
== NULL
) {
1753 Status
= EFI_OUT_OF_RESOURCES
;
1756 CopyMem (FontPackage
->GlyphBlock
, (UINT8
*) PackageHdr
+ HeaderSize
, PackageHeader
.Length
- HeaderSize
);
1759 // Collect all default character cell information and backup in GlyphInfoList.
1761 Status
= FindGlyphBlock (FontPackage
, (CHAR16
) (-1), NULL
, NULL
, NULL
);
1762 if (EFI_ERROR (Status
)) {
1767 // This font package describes an unique EFI_FONT_INFO. Backup it in global
1770 GlobalFont
= (HII_GLOBAL_FONT_INFO
*) AllocateZeroPool (sizeof (HII_GLOBAL_FONT_INFO
));
1771 if (GlobalFont
== NULL
) {
1772 Status
= EFI_OUT_OF_RESOURCES
;
1775 GlobalFont
->Signature
= HII_GLOBAL_FONT_INFO_SIGNATURE
;
1776 GlobalFont
->FontPackage
= FontPackage
;
1777 GlobalFont
->FontInfoSize
= FontInfoSize
;
1778 GlobalFont
->FontInfo
= FontInfo
;
1779 InsertTailList (&Private
->FontInfoList
, &GlobalFont
->Entry
);
1782 // Insert this font package to Font package array
1784 InsertTailList (&PackageList
->FontPkgHdr
, &FontPackage
->FontEntry
);
1785 *Package
= FontPackage
;
1787 if (NotifyType
== EFI_HII_DATABASE_NOTIFY_ADD_PACK
) {
1788 PackageList
->PackageListHdr
.PackageLength
+= FontPackage
->FontPkgHdr
->Header
.Length
;
1795 if (FontPkgHdr
!= NULL
) {
1796 FreePool (FontPkgHdr
);
1798 if (FontInfo
!= NULL
) {
1799 FreePool (FontInfo
);
1801 if (FontPackage
!= NULL
) {
1802 if (FontPackage
->GlyphBlock
!= NULL
) {
1803 FreePool (FontPackage
->GlyphBlock
);
1805 FreePool (FontPackage
);
1807 if (GlobalFont
!= NULL
) {
1808 FreePool (GlobalFont
);
1817 This function exports Font packages to a buffer.
1818 This is a internal function.
1820 @param Private Hii database private structure.
1821 @param Handle Identification of a package list.
1822 @param PackageList Pointer to a package list which will be exported.
1823 @param UsedSize The length of buffer be used.
1824 @param BufferSize Length of the Buffer.
1825 @param Buffer Allocated space for storing exported data.
1826 @param ResultSize The size of the already exported content of this
1829 @retval EFI_SUCCESS Font Packages are exported successfully.
1830 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
1834 ExportFontPackages (
1835 IN HII_DATABASE_PRIVATE_DATA
*Private
,
1836 IN EFI_HII_HANDLE Handle
,
1837 IN HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
,
1839 IN UINTN BufferSize
,
1840 IN OUT VOID
*Buffer
,
1841 IN OUT UINTN
*ResultSize
1845 UINTN PackageLength
;
1847 HII_FONT_PACKAGE_INSTANCE
*Package
;
1850 if (Private
== NULL
|| PackageList
== NULL
|| ResultSize
== NULL
) {
1851 return EFI_INVALID_PARAMETER
;
1854 if (BufferSize
> 0 && Buffer
== NULL
) {
1855 return EFI_INVALID_PARAMETER
;
1859 Status
= EFI_SUCCESS
;
1861 for (Link
= PackageList
->FontPkgHdr
.ForwardLink
; Link
!= &PackageList
->FontPkgHdr
; Link
= Link
->ForwardLink
) {
1862 Package
= CR (Link
, HII_FONT_PACKAGE_INSTANCE
, FontEntry
, HII_FONT_PACKAGE_SIGNATURE
);
1863 PackageLength
+= Package
->FontPkgHdr
->Header
.Length
;
1864 if (PackageLength
+ *ResultSize
+ UsedSize
<= BufferSize
) {
1866 // Invoke registered notification function with EXPORT_PACK notify type
1868 Status
= InvokeRegisteredFunction (
1870 EFI_HII_DATABASE_NOTIFY_EXPORT_PACK
,
1872 EFI_HII_PACKAGE_FONTS
,
1875 ASSERT_EFI_ERROR (Status
);
1877 // Copy Font package header
1879 CopyMem (Buffer
, Package
->FontPkgHdr
, Package
->FontPkgHdr
->HdrSize
);
1880 Buffer
= (UINT8
*) Buffer
+ Package
->FontPkgHdr
->HdrSize
;
1883 // Copy Glyph blocks information
1887 Package
->GlyphBlock
,
1888 Package
->FontPkgHdr
->Header
.Length
- Package
->FontPkgHdr
->HdrSize
1890 Buffer
= (UINT8
*) Buffer
+ Package
->FontPkgHdr
->Header
.Length
- Package
->FontPkgHdr
->HdrSize
;
1894 *ResultSize
+= PackageLength
;
1900 This function deletes all Font packages from a package list node.
1901 This is a internal function.
1903 @param Private Hii database private data.
1904 @param Handle Handle of the package list which contains the to
1905 be removed Font packages.
1906 @param PackageList Pointer to a package list that contains removing
1909 @retval EFI_SUCCESS Font Package(s) is deleted successfully.
1910 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
1914 RemoveFontPackages (
1915 IN HII_DATABASE_PRIVATE_DATA
*Private
,
1916 IN EFI_HII_HANDLE Handle
,
1917 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
1920 LIST_ENTRY
*ListHead
;
1921 HII_FONT_PACKAGE_INSTANCE
*Package
;
1923 HII_GLYPH_INFO
*GlyphInfo
;
1925 HII_GLOBAL_FONT_INFO
*GlobalFont
;
1927 ListHead
= &PackageList
->FontPkgHdr
;
1929 while (!IsListEmpty (ListHead
)) {
1931 ListHead
->ForwardLink
,
1932 HII_FONT_PACKAGE_INSTANCE
,
1934 HII_FONT_PACKAGE_SIGNATURE
1936 Status
= InvokeRegisteredFunction (
1938 EFI_HII_DATABASE_NOTIFY_REMOVE_PACK
,
1940 EFI_HII_PACKAGE_FONTS
,
1943 if (EFI_ERROR (Status
)) {
1947 RemoveEntryList (&Package
->FontEntry
);
1948 PackageList
->PackageListHdr
.PackageLength
-= Package
->FontPkgHdr
->Header
.Length
;
1950 if (Package
->GlyphBlock
!= NULL
) {
1951 FreePool (Package
->GlyphBlock
);
1953 FreePool (Package
->FontPkgHdr
);
1955 // Delete default character cell information
1957 while (!IsListEmpty (&Package
->GlyphInfoList
)) {
1959 Package
->GlyphInfoList
.ForwardLink
,
1962 HII_GLYPH_INFO_SIGNATURE
1964 RemoveEntryList (&GlyphInfo
->Entry
);
1965 FreePool (GlyphInfo
);
1969 // Remove corresponding global font info
1971 for (Link
= Private
->FontInfoList
.ForwardLink
; Link
!= &Private
->FontInfoList
; Link
= Link
->ForwardLink
) {
1972 GlobalFont
= CR (Link
, HII_GLOBAL_FONT_INFO
, Entry
, HII_GLOBAL_FONT_INFO_SIGNATURE
);
1973 if (GlobalFont
->FontPackage
== Package
) {
1974 RemoveEntryList (&GlobalFont
->Entry
);
1975 FreePool (GlobalFont
->FontInfo
);
1976 FreePool (GlobalFont
);
1989 This function insert a Image package to a package list node.
1990 This is a internal function.
1992 @param PackageHdr Pointer to a buffer stored with Image package
1994 @param NotifyType The type of change concerning the database.
1995 @param PackageList Pointer to a package list which will be inserted
1997 @param Package Created Image package
1999 @retval EFI_SUCCESS Image Package is inserted successfully.
2000 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
2002 @retval EFI_INVALID_PARAMETER PackageHdr is NULL or PackageList is NULL.
2006 InsertImagePackage (
2007 IN VOID
*PackageHdr
,
2008 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType
,
2009 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
,
2010 OUT HII_IMAGE_PACKAGE_INSTANCE
**Package
2013 HII_IMAGE_PACKAGE_INSTANCE
*ImagePackage
;
2017 EFI_HII_IMAGE_PALETTE_INFO_HEADER
*PaletteHdr
;
2018 EFI_HII_IMAGE_PALETTE_INFO
*PaletteInfo
;
2019 UINT32 PaletteInfoOffset
;
2020 UINT32 ImageInfoOffset
;
2023 if (PackageHdr
== NULL
|| PackageList
== NULL
) {
2024 return EFI_INVALID_PARAMETER
;
2028 // Less than one image package is allowed in one package list.
2030 if (PackageList
->ImagePkg
!= NULL
) {
2031 return EFI_INVALID_PARAMETER
;
2035 // Create a Image package node
2037 ImagePackage
= (HII_IMAGE_PACKAGE_INSTANCE
*) AllocateZeroPool (sizeof (HII_IMAGE_PACKAGE_INSTANCE
));
2038 if (ImagePackage
== NULL
) {
2039 return EFI_OUT_OF_RESOURCES
;
2043 // Copy the Image package header.
2045 CopyMem (&ImagePackage
->ImagePkgHdr
, PackageHdr
, sizeof (EFI_HII_IMAGE_PACKAGE_HDR
));
2047 PaletteInfoOffset
= ImagePackage
->ImagePkgHdr
.PaletteInfoOffset
;
2048 ImageInfoOffset
= ImagePackage
->ImagePkgHdr
.ImageInfoOffset
;
2051 // If PaletteInfoOffset is zero, there are no palettes in this image package.
2054 ImagePackage
->PaletteBlock
= NULL
;
2055 if (PaletteInfoOffset
!= 0) {
2056 PaletteHdr
= (EFI_HII_IMAGE_PALETTE_INFO_HEADER
*) ((UINT8
*) PackageHdr
+ PaletteInfoOffset
);
2057 PaletteSize
= sizeof (EFI_HII_IMAGE_PALETTE_INFO_HEADER
);
2058 PaletteInfo
= (EFI_HII_IMAGE_PALETTE_INFO
*) ((UINT8
*) PaletteHdr
+ PaletteSize
);
2060 for (Index
= 0; Index
< PaletteHdr
->PaletteCount
; Index
++) {
2061 CopyMem (&CurrentSize
, PaletteInfo
, sizeof (UINT16
));
2062 CurrentSize
+= sizeof (UINT16
);
2063 PaletteSize
+= (UINT32
) CurrentSize
;
2064 PaletteInfo
= (EFI_HII_IMAGE_PALETTE_INFO
*) ((UINT8
*) PaletteInfo
+ CurrentSize
);
2067 ImagePackage
->PaletteBlock
= (UINT8
*) AllocateZeroPool (PaletteSize
);
2068 if (ImagePackage
->PaletteBlock
== NULL
) {
2069 FreePool (ImagePackage
);
2070 return EFI_OUT_OF_RESOURCES
;
2073 ImagePackage
->PaletteBlock
,
2074 (UINT8
*) PackageHdr
+ PaletteInfoOffset
,
2080 // If ImageInfoOffset is zero, there are no images in this package.
2083 ImagePackage
->ImageBlock
= NULL
;
2084 if (ImageInfoOffset
!= 0) {
2085 ImageSize
= ImagePackage
->ImagePkgHdr
.Header
.Length
-
2086 sizeof (EFI_HII_IMAGE_PACKAGE_HDR
) - PaletteSize
;
2087 ImagePackage
->ImageBlock
= AllocateZeroPool (ImageSize
);
2088 if (ImagePackage
->ImageBlock
== NULL
) {
2089 FreePool (ImagePackage
->PaletteBlock
);
2090 FreePool (ImagePackage
);
2091 return EFI_OUT_OF_RESOURCES
;
2094 ImagePackage
->ImageBlock
,
2095 (UINT8
*) PackageHdr
+ ImageInfoOffset
,
2100 ImagePackage
->ImageBlockSize
= ImageSize
;
2101 ImagePackage
->PaletteInfoSize
= PaletteSize
;
2102 PackageList
->ImagePkg
= ImagePackage
;
2103 *Package
= ImagePackage
;
2105 if (NotifyType
== EFI_HII_DATABASE_NOTIFY_ADD_PACK
) {
2106 PackageList
->PackageListHdr
.PackageLength
+= ImagePackage
->ImagePkgHdr
.Header
.Length
;
2114 This function exports Image packages to a buffer.
2115 This is a internal function.
2117 @param Private Hii database private structure.
2118 @param Handle Identification of a package list.
2119 @param PackageList Pointer to a package list which will be exported.
2120 @param UsedSize The length of buffer be used.
2121 @param BufferSize Length of the Buffer.
2122 @param Buffer Allocated space for storing exported data.
2123 @param ResultSize The size of the already exported content of this
2126 @retval EFI_SUCCESS Image Packages are exported successfully.
2127 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
2131 ExportImagePackages (
2132 IN HII_DATABASE_PRIVATE_DATA
*Private
,
2133 IN EFI_HII_HANDLE Handle
,
2134 IN HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
,
2136 IN UINTN BufferSize
,
2137 IN OUT VOID
*Buffer
,
2138 IN OUT UINTN
*ResultSize
2141 UINTN PackageLength
;
2143 HII_IMAGE_PACKAGE_INSTANCE
*Package
;
2146 if (Private
== NULL
|| PackageList
== NULL
|| ResultSize
== NULL
) {
2147 return EFI_INVALID_PARAMETER
;
2150 if (BufferSize
> 0 && Buffer
== NULL
) {
2151 return EFI_INVALID_PARAMETER
;
2154 Package
= PackageList
->ImagePkg
;
2156 if (Package
== NULL
) {
2160 PackageLength
= Package
->ImagePkgHdr
.Header
.Length
;
2162 if (PackageLength
+ *ResultSize
+ UsedSize
<= BufferSize
) {
2164 // Invoke registered notification function with EXPORT_PACK notify type
2166 Status
= InvokeRegisteredFunction (
2168 EFI_HII_DATABASE_NOTIFY_EXPORT_PACK
,
2170 EFI_HII_PACKAGE_IMAGES
,
2173 ASSERT_EFI_ERROR (Status
);
2174 ASSERT (Package
->ImagePkgHdr
.Header
.Length
==
2175 sizeof (EFI_HII_IMAGE_PACKAGE_HDR
) + Package
->ImageBlockSize
+ Package
->PaletteInfoSize
);
2177 // Copy Image package header,
2178 // then justify the offset for image info and palette info in the header.
2180 CopyMem (Buffer
, &Package
->ImagePkgHdr
, sizeof (EFI_HII_IMAGE_PACKAGE_HDR
));
2181 Buffer
= (UINT8
*) Buffer
+ sizeof (EFI_HII_IMAGE_PACKAGE_HDR
);
2184 // Copy Image blocks information
2186 if (Package
->ImageBlockSize
!= 0) {
2187 CopyMem (Buffer
, Package
->ImageBlock
, Package
->ImageBlockSize
);
2188 Buffer
= (UINT8
*) Buffer
+ Package
->ImageBlockSize
;
2191 // Copy Palette information
2193 if (Package
->PaletteInfoSize
!= 0) {
2194 CopyMem (Buffer
, Package
->PaletteBlock
, Package
->PaletteInfoSize
);
2195 Buffer
= (UINT8
*) Buffer
+ Package
->PaletteInfoSize
;
2199 *ResultSize
+= PackageLength
;
2205 This function deletes Image package from a package list node.
2206 This is a internal function.
2208 @param Private Hii database private data.
2209 @param Handle Handle of the package list which contains the to
2210 be removed Image packages.
2211 @param PackageList Package List which contains the to be removed
2214 @retval EFI_SUCCESS Image Package(s) is deleted successfully.
2215 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
2219 RemoveImagePackages (
2220 IN HII_DATABASE_PRIVATE_DATA
*Private
,
2221 IN EFI_HII_HANDLE Handle
,
2222 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
2225 HII_IMAGE_PACKAGE_INSTANCE
*Package
;
2228 Package
= PackageList
->ImagePkg
;
2231 // Image package does not exist, return directly.
2233 if (Package
== NULL
) {
2237 Status
= InvokeRegisteredFunction (
2239 EFI_HII_DATABASE_NOTIFY_REMOVE_PACK
,
2241 EFI_HII_PACKAGE_IMAGES
,
2244 if (EFI_ERROR (Status
)) {
2248 PackageList
->PackageListHdr
.PackageLength
-= Package
->ImagePkgHdr
.Header
.Length
;
2250 FreePool (Package
->ImageBlock
);
2251 if (Package
->PaletteBlock
!= NULL
) {
2252 FreePool (Package
->PaletteBlock
);
2256 PackageList
->ImagePkg
= NULL
;
2263 This function insert a Simple Font package to a package list node.
2264 This is a internal function.
2266 @param PackageHdr Pointer to a buffer stored with Simple Font
2267 package information.
2268 @param NotifyType The type of change concerning the database.
2269 @param PackageList Pointer to a package list which will be inserted
2271 @param Package Created Simple Font package
2273 @retval EFI_SUCCESS Simple Font Package is inserted successfully.
2274 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
2275 Simple Font package.
2276 @retval EFI_INVALID_PARAMETER PackageHdr is NULL or PackageList is NULL.
2280 InsertSimpleFontPackage (
2281 IN VOID
*PackageHdr
,
2282 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType
,
2283 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
,
2284 OUT HII_SIMPLE_FONT_PACKAGE_INSTANCE
**Package
2287 HII_SIMPLE_FONT_PACKAGE_INSTANCE
*SimpleFontPackage
;
2289 EFI_HII_PACKAGE_HEADER Header
;
2291 if (PackageHdr
== NULL
|| PackageList
== NULL
) {
2292 return EFI_INVALID_PARAMETER
;
2296 // Create a Simple Font package node
2298 SimpleFontPackage
= AllocateZeroPool (sizeof (HII_SIMPLE_FONT_PACKAGE_INSTANCE
));
2299 if (SimpleFontPackage
== NULL
) {
2300 Status
= EFI_OUT_OF_RESOURCES
;
2303 SimpleFontPackage
->Signature
= HII_S_FONT_PACKAGE_SIGNATURE
;
2306 // Copy the Simple Font package.
2308 CopyMem (&Header
, PackageHdr
, sizeof (EFI_HII_PACKAGE_HEADER
));
2310 SimpleFontPackage
->SimpleFontPkgHdr
= AllocateZeroPool (Header
.Length
);
2311 if (SimpleFontPackage
->SimpleFontPkgHdr
== NULL
) {
2312 Status
= EFI_OUT_OF_RESOURCES
;
2316 CopyMem (SimpleFontPackage
->SimpleFontPkgHdr
, PackageHdr
, Header
.Length
);
2319 // Insert to Simple Font package array
2321 InsertTailList (&PackageList
->SimpleFontPkgHdr
, &SimpleFontPackage
->SimpleFontEntry
);
2322 *Package
= SimpleFontPackage
;
2324 if (NotifyType
== EFI_HII_DATABASE_NOTIFY_ADD_PACK
) {
2325 PackageList
->PackageListHdr
.PackageLength
+= Header
.Length
;
2332 if (SimpleFontPackage
!= NULL
) {
2333 if (SimpleFontPackage
->SimpleFontPkgHdr
!= NULL
) {
2334 FreePool (SimpleFontPackage
->SimpleFontPkgHdr
);
2336 FreePool (SimpleFontPackage
);
2343 This function exports SimpleFont packages to a buffer.
2344 This is a internal function.
2346 @param Private Hii database private structure.
2347 @param Handle Identification of a package list.
2348 @param PackageList Pointer to a package list which will be exported.
2349 @param UsedSize The length of buffer be used.
2350 @param BufferSize Length of the Buffer.
2351 @param Buffer Allocated space for storing exported data.
2352 @param ResultSize The size of the already exported content of this
2355 @retval EFI_SUCCESS SimpleFont Packages are exported successfully.
2356 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
2360 ExportSimpleFontPackages (
2361 IN HII_DATABASE_PRIVATE_DATA
*Private
,
2362 IN EFI_HII_HANDLE Handle
,
2363 IN HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
,
2365 IN UINTN BufferSize
,
2366 IN OUT VOID
*Buffer
,
2367 IN OUT UINTN
*ResultSize
2371 UINTN PackageLength
;
2373 HII_SIMPLE_FONT_PACKAGE_INSTANCE
*Package
;
2375 if (Private
== NULL
|| PackageList
== NULL
|| ResultSize
== NULL
) {
2376 return EFI_INVALID_PARAMETER
;
2379 if (BufferSize
> 0 && Buffer
== NULL
) {
2380 return EFI_INVALID_PARAMETER
;
2384 Status
= EFI_SUCCESS
;
2386 for (Link
= PackageList
->SimpleFontPkgHdr
.ForwardLink
; Link
!= &PackageList
->SimpleFontPkgHdr
; Link
= Link
->ForwardLink
) {
2387 Package
= CR (Link
, HII_SIMPLE_FONT_PACKAGE_INSTANCE
, SimpleFontEntry
, HII_S_FONT_PACKAGE_SIGNATURE
);
2388 PackageLength
+= Package
->SimpleFontPkgHdr
->Header
.Length
;
2389 if (PackageLength
+ *ResultSize
+ UsedSize
<= BufferSize
) {
2391 // Invoke registered notification function with EXPORT_PACK notify type
2393 Status
= InvokeRegisteredFunction (
2395 EFI_HII_DATABASE_NOTIFY_EXPORT_PACK
,
2397 EFI_HII_PACKAGE_SIMPLE_FONTS
,
2400 ASSERT_EFI_ERROR (Status
);
2403 // Copy SimpleFont package
2405 CopyMem (Buffer
, Package
->SimpleFontPkgHdr
, Package
->SimpleFontPkgHdr
->Header
.Length
);
2406 Buffer
= (UINT8
*) Buffer
+ Package
->SimpleFontPkgHdr
->Header
.Length
;
2410 *ResultSize
+= PackageLength
;
2416 This function deletes all Simple Font packages from a package list node.
2417 This is a internal function.
2419 @param Private Hii database private data.
2420 @param Handle Handle of the package list which contains the to
2421 be removed Simple Font packages.
2422 @param PackageList Pointer to a package list that contains removing
2425 @retval EFI_SUCCESS Simple Font Package(s) is deleted successfully.
2426 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
2430 RemoveSimpleFontPackages (
2431 IN HII_DATABASE_PRIVATE_DATA
*Private
,
2432 IN EFI_HII_HANDLE Handle
,
2433 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
2436 LIST_ENTRY
*ListHead
;
2437 HII_SIMPLE_FONT_PACKAGE_INSTANCE
*Package
;
2440 ListHead
= &PackageList
->SimpleFontPkgHdr
;
2442 while (!IsListEmpty (ListHead
)) {
2444 ListHead
->ForwardLink
,
2445 HII_SIMPLE_FONT_PACKAGE_INSTANCE
,
2447 HII_S_FONT_PACKAGE_SIGNATURE
2449 Status
= InvokeRegisteredFunction (
2451 EFI_HII_DATABASE_NOTIFY_REMOVE_PACK
,
2453 EFI_HII_PACKAGE_SIMPLE_FONTS
,
2456 if (EFI_ERROR (Status
)) {
2460 RemoveEntryList (&Package
->SimpleFontEntry
);
2461 PackageList
->PackageListHdr
.PackageLength
-= Package
->SimpleFontPkgHdr
->Header
.Length
;
2462 FreePool (Package
->SimpleFontPkgHdr
);
2471 This function insert a Device path package to a package list node.
2472 This is a internal function.
2474 @param DevicePath Pointer to a EFI_DEVICE_PATH_PROTOCOL protocol
2476 @param NotifyType The type of change concerning the database.
2477 @param PackageList Pointer to a package list which will be inserted
2480 @retval EFI_SUCCESS Device path Package is inserted successfully.
2481 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
2482 Device path package.
2483 @retval EFI_INVALID_PARAMETER DevicePath is NULL or PackageList is NULL.
2487 InsertDevicePathPackage (
2488 IN EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
2489 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType
,
2490 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
2493 UINT32 PackageLength
;
2494 EFI_HII_PACKAGE_HEADER Header
;
2496 if (DevicePath
== NULL
|| PackageList
== NULL
) {
2497 return EFI_INVALID_PARAMETER
;
2500 // Less than one device path package is allowed in one package list.
2502 if (PackageList
->DevicePathPkg
!= NULL
) {
2503 return EFI_INVALID_PARAMETER
;
2506 PackageLength
= (UINT32
) GetDevicePathSize (DevicePath
) + sizeof (EFI_HII_PACKAGE_HEADER
);
2507 PackageList
->DevicePathPkg
= (UINT8
*) AllocateZeroPool (PackageLength
);
2508 if (PackageList
->DevicePathPkg
== NULL
) {
2509 return EFI_OUT_OF_RESOURCES
;
2512 Header
.Length
= PackageLength
;
2513 Header
.Type
= EFI_HII_PACKAGE_DEVICE_PATH
;
2514 CopyMem (PackageList
->DevicePathPkg
, &Header
, sizeof (EFI_HII_PACKAGE_HEADER
));
2516 PackageList
->DevicePathPkg
+ sizeof (EFI_HII_PACKAGE_HEADER
),
2518 PackageLength
- sizeof (EFI_HII_PACKAGE_HEADER
)
2522 // Since Device Path package is created by NewPackageList, either NEW_PACK
2523 // or ADD_PACK should increase the length of package list.
2525 PackageList
->PackageListHdr
.PackageLength
+= PackageLength
;
2531 This function exports device path package to a buffer.
2532 This is a internal function.
2534 @param Private Hii database private structure.
2535 @param Handle Identification of a package list.
2536 @param PackageList Pointer to a package list which will be exported.
2537 @param UsedSize The length of buffer be used.
2538 @param BufferSize Length of the Buffer.
2539 @param Buffer Allocated space for storing exported data.
2540 @param ResultSize The size of the already exported content of this
2543 @retval EFI_SUCCESS Device path Package is exported successfully.
2544 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
2548 ExportDevicePathPackage (
2549 IN HII_DATABASE_PRIVATE_DATA
*Private
,
2550 IN EFI_HII_HANDLE Handle
,
2551 IN HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
,
2553 IN UINTN BufferSize
,
2554 IN OUT VOID
*Buffer
,
2555 IN OUT UINTN
*ResultSize
2560 EFI_HII_PACKAGE_HEADER Header
;
2562 if (Private
== NULL
|| PackageList
== NULL
|| ResultSize
== NULL
) {
2563 return EFI_INVALID_PARAMETER
;
2565 if (BufferSize
> 0 && Buffer
== NULL
) {
2566 return EFI_INVALID_PARAMETER
;
2569 Package
= PackageList
->DevicePathPkg
;
2571 if (Package
== NULL
) {
2575 CopyMem (&Header
, Package
, sizeof (EFI_HII_PACKAGE_HEADER
));
2577 if (Header
.Length
+ *ResultSize
+ UsedSize
<= BufferSize
) {
2579 // Invoke registered notification function with EXPORT_PACK notify type
2581 Status
= InvokeRegisteredFunction (
2583 EFI_HII_DATABASE_NOTIFY_EXPORT_PACK
,
2585 EFI_HII_PACKAGE_DEVICE_PATH
,
2588 ASSERT_EFI_ERROR (Status
);
2591 // Copy Device path package
2593 CopyMem (Buffer
, Package
, Header
.Length
);
2596 *ResultSize
+= Header
.Length
;
2602 This function deletes Device Path package from a package list node.
2603 This is a internal function.
2605 @param Private Hii database private data.
2606 @param Handle Handle of the package list.
2607 @param PackageList Package List which contains the to be removed
2608 Device Path package.
2610 @retval EFI_SUCCESS Device Path Package is deleted successfully.
2611 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
2615 RemoveDevicePathPackage (
2616 IN HII_DATABASE_PRIVATE_DATA
*Private
,
2617 IN EFI_HII_HANDLE Handle
,
2618 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
2623 EFI_HII_PACKAGE_HEADER Header
;
2625 Package
= PackageList
->DevicePathPkg
;
2628 // No device path, return directly.
2630 if (Package
== NULL
) {
2634 Status
= InvokeRegisteredFunction (
2636 EFI_HII_DATABASE_NOTIFY_REMOVE_PACK
,
2638 EFI_HII_PACKAGE_DEVICE_PATH
,
2641 if (EFI_ERROR (Status
)) {
2645 CopyMem (&Header
, Package
, sizeof (EFI_HII_PACKAGE_HEADER
));
2646 PackageList
->PackageListHdr
.PackageLength
-= Header
.Length
;
2650 PackageList
->DevicePathPkg
= NULL
;
2657 This function will insert a device path package to package list firstly then
2658 invoke notification functions if any.
2659 This is a internal function.
2661 @param Private Hii database private structure.
2662 @param NotifyType The type of change concerning the database.
2663 @param DevicePath Pointer to a EFI_DEVICE_PATH_PROTOCOL protocol
2665 @param DatabaseRecord Pointer to a database record contains a package
2666 list which will be inserted to.
2668 @retval EFI_SUCCESS Device path Package is inserted successfully.
2669 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
2670 Device path package.
2671 @retval EFI_INVALID_PARAMETER DevicePath is NULL or PackageList is NULL.
2675 AddDevicePathPackage (
2676 IN HII_DATABASE_PRIVATE_DATA
*Private
,
2677 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType
,
2678 IN EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
2679 IN OUT HII_DATABASE_RECORD
*DatabaseRecord
2684 if (DevicePath
== NULL
) {
2688 ASSERT (Private
!= NULL
);
2689 ASSERT (DatabaseRecord
!= NULL
);
2692 // Create a device path package and insert to packagelist
2694 Status
= InsertDevicePathPackage (
2697 DatabaseRecord
->PackageList
2699 if (EFI_ERROR (Status
)) {
2703 return InvokeRegisteredFunction (
2706 (VOID
*) DatabaseRecord
->PackageList
->DevicePathPkg
,
2707 EFI_HII_PACKAGE_DEVICE_PATH
,
2708 DatabaseRecord
->Handle
2714 This function insert a Keyboard Layout package to a package list node.
2715 This is a internal function.
2717 @param PackageHdr Pointer to a buffer stored with Keyboard Layout
2718 package information.
2719 @param NotifyType The type of change concerning the database.
2720 @param PackageList Pointer to a package list which will be inserted
2722 @param Package Created Keyboard Layout package
2724 @retval EFI_SUCCESS Keyboard Layout Package is inserted successfully.
2725 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
2726 Keyboard Layout package.
2727 @retval EFI_INVALID_PARAMETER PackageHdr is NULL or PackageList is NULL.
2731 InsertKeyboardLayoutPackage (
2732 IN VOID
*PackageHdr
,
2733 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType
,
2734 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
,
2735 OUT HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE
**Package
2738 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE
*KeyboardLayoutPackage
;
2739 EFI_HII_PACKAGE_HEADER PackageHeader
;
2742 if (PackageHdr
== NULL
|| PackageList
== NULL
) {
2743 return EFI_INVALID_PARAMETER
;
2746 CopyMem (&PackageHeader
, PackageHdr
, sizeof (EFI_HII_PACKAGE_HEADER
));
2749 // Create a Keyboard Layout package node
2751 KeyboardLayoutPackage
= AllocateZeroPool (sizeof (HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE
));
2752 if (KeyboardLayoutPackage
== NULL
) {
2753 Status
= EFI_OUT_OF_RESOURCES
;
2756 KeyboardLayoutPackage
->Signature
= HII_KB_LAYOUT_PACKAGE_SIGNATURE
;
2758 KeyboardLayoutPackage
->KeyboardPkg
= (UINT8
*) AllocateZeroPool (PackageHeader
.Length
);
2759 if (KeyboardLayoutPackage
->KeyboardPkg
== NULL
) {
2760 Status
= EFI_OUT_OF_RESOURCES
;
2764 CopyMem (KeyboardLayoutPackage
->KeyboardPkg
, PackageHdr
, PackageHeader
.Length
);
2765 InsertTailList (&PackageList
->KeyboardLayoutHdr
, &KeyboardLayoutPackage
->KeyboardEntry
);
2767 *Package
= KeyboardLayoutPackage
;
2769 if (NotifyType
== EFI_HII_DATABASE_NOTIFY_ADD_PACK
) {
2770 PackageList
->PackageListHdr
.PackageLength
+= PackageHeader
.Length
;
2778 if (KeyboardLayoutPackage
!= NULL
) {
2779 if (KeyboardLayoutPackage
->KeyboardPkg
!= NULL
) {
2780 FreePool (KeyboardLayoutPackage
->KeyboardPkg
);
2782 FreePool (KeyboardLayoutPackage
);
2790 This function exports Keyboard Layout packages to a buffer.
2791 This is a internal function.
2793 @param Private Hii database private structure.
2794 @param Handle Identification of a package list.
2795 @param PackageList Pointer to a package list which will be exported.
2796 @param UsedSize The length of buffer be used.
2797 @param BufferSize Length of the Buffer.
2798 @param Buffer Allocated space for storing exported data.
2799 @param ResultSize The size of the already exported content of this
2802 @retval EFI_SUCCESS Keyboard Layout Packages are exported
2804 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
2808 ExportKeyboardLayoutPackages (
2809 IN HII_DATABASE_PRIVATE_DATA
*Private
,
2810 IN EFI_HII_HANDLE Handle
,
2811 IN HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
,
2813 IN UINTN BufferSize
,
2814 IN OUT VOID
*Buffer
,
2815 IN OUT UINTN
*ResultSize
2819 UINTN PackageLength
;
2821 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE
*Package
;
2822 EFI_HII_PACKAGE_HEADER PackageHeader
;
2824 if (Private
== NULL
|| PackageList
== NULL
|| ResultSize
== NULL
) {
2825 return EFI_INVALID_PARAMETER
;
2828 if (BufferSize
> 0 && Buffer
== NULL
) {
2829 return EFI_INVALID_PARAMETER
;
2833 Status
= EFI_SUCCESS
;
2835 for (Link
= PackageList
->KeyboardLayoutHdr
.ForwardLink
; Link
!= &PackageList
->KeyboardLayoutHdr
; Link
= Link
->ForwardLink
) {
2836 Package
= CR (Link
, HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE
, KeyboardEntry
, HII_KB_LAYOUT_PACKAGE_SIGNATURE
);
2837 CopyMem (&PackageHeader
, Package
->KeyboardPkg
, sizeof (EFI_HII_PACKAGE_HEADER
));
2838 PackageLength
+= PackageHeader
.Length
;
2839 if (PackageLength
+ *ResultSize
+ UsedSize
<= BufferSize
) {
2841 // Invoke registered notification function with EXPORT_PACK notify type
2843 Status
= InvokeRegisteredFunction (
2845 EFI_HII_DATABASE_NOTIFY_EXPORT_PACK
,
2846 (EFI_HII_PACKAGE_HEADER
*) Package
,
2847 EFI_HII_PACKAGE_KEYBOARD_LAYOUT
,
2850 ASSERT_EFI_ERROR (Status
);
2853 // Copy Keyboard Layout package
2855 CopyMem (Buffer
, Package
->KeyboardPkg
, PackageHeader
.Length
);
2856 Buffer
= (UINT8
*) Buffer
+ PackageHeader
.Length
;
2860 *ResultSize
+= PackageLength
;
2866 This function deletes all Keyboard Layout packages from a package list node.
2867 This is a internal function.
2869 @param Private Hii database private data.
2870 @param Handle Handle of the package list which contains the to
2871 be removed Keyboard Layout packages.
2872 @param PackageList Pointer to a package list that contains removing
2875 @retval EFI_SUCCESS Keyboard Layout Package(s) is deleted
2877 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
2881 RemoveKeyboardLayoutPackages (
2882 IN HII_DATABASE_PRIVATE_DATA
*Private
,
2883 IN EFI_HII_HANDLE Handle
,
2884 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
2887 LIST_ENTRY
*ListHead
;
2888 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE
*Package
;
2889 EFI_HII_PACKAGE_HEADER PackageHeader
;
2892 ListHead
= &PackageList
->KeyboardLayoutHdr
;
2894 while (!IsListEmpty (ListHead
)) {
2896 ListHead
->ForwardLink
,
2897 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE
,
2899 HII_KB_LAYOUT_PACKAGE_SIGNATURE
2901 Status
= InvokeRegisteredFunction (
2903 EFI_HII_DATABASE_NOTIFY_REMOVE_PACK
,
2905 EFI_HII_PACKAGE_KEYBOARD_LAYOUT
,
2908 if (EFI_ERROR (Status
)) {
2912 RemoveEntryList (&Package
->KeyboardEntry
);
2913 CopyMem (&PackageHeader
, Package
->KeyboardPkg
, sizeof (EFI_HII_PACKAGE_HEADER
));
2914 PackageList
->PackageListHdr
.PackageLength
-= PackageHeader
.Length
;
2915 FreePool (Package
->KeyboardPkg
);
2924 This function will insert a package list to hii database firstly then
2925 invoke notification functions if any. It is the worker function of
2926 HiiNewPackageList and HiiUpdatePackageList.
2928 This is a internal function.
2930 @param Private Hii database private structure.
2931 @param NotifyType The type of change concerning the database.
2932 @param PackageList Pointer to a package list.
2933 @param DatabaseRecord Pointer to a database record contains a package
2934 list instance which will be inserted to.
2936 @retval EFI_SUCCESS All incoming packages are inserted to current
2938 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
2939 Device path package.
2940 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
2945 IN HII_DATABASE_PRIVATE_DATA
*Private
,
2946 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType
,
2947 IN CONST EFI_HII_PACKAGE_LIST_HEADER
*PackageList
,
2948 IN OUT HII_DATABASE_RECORD
*DatabaseRecord
2952 HII_GUID_PACKAGE_INSTANCE
*GuidPackage
;
2953 HII_IFR_PACKAGE_INSTANCE
*FormPackage
;
2954 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE
*KeyboardLayoutPackage
;
2955 HII_STRING_PACKAGE_INSTANCE
*StringPackage
;
2956 HII_FONT_PACKAGE_INSTANCE
*FontPackage
;
2957 HII_SIMPLE_FONT_PACKAGE_INSTANCE
*SimpleFontPackage
;
2958 HII_IMAGE_PACKAGE_INSTANCE
*ImagePackage
;
2959 EFI_HII_PACKAGE_HEADER
*PackageHdrPtr
;
2960 EFI_HII_PACKAGE_HEADER PackageHeader
;
2961 UINT32 OldPackageListLen
;
2962 BOOLEAN StringPkgIsAdd
;
2965 // Initialize Variables
2967 StringPkgIsAdd
= FALSE
;
2969 StringPackage
= NULL
;
2972 ImagePackage
= NULL
;
2973 SimpleFontPackage
= NULL
;
2974 KeyboardLayoutPackage
= NULL
;
2977 // Process the package list header
2979 OldPackageListLen
= DatabaseRecord
->PackageList
->PackageListHdr
.PackageLength
;
2981 &DatabaseRecord
->PackageList
->PackageListHdr
,
2982 (VOID
*) PackageList
,
2983 sizeof (EFI_HII_PACKAGE_LIST_HEADER
)
2985 if (NotifyType
== EFI_HII_DATABASE_NOTIFY_ADD_PACK
) {
2986 DatabaseRecord
->PackageList
->PackageListHdr
.PackageLength
= OldPackageListLen
;
2989 PackageHdrPtr
= (EFI_HII_PACKAGE_HEADER
*) ((UINT8
*) PackageList
+ sizeof (EFI_HII_PACKAGE_LIST_HEADER
));
2990 CopyMem (&PackageHeader
, PackageHdrPtr
, sizeof (EFI_HII_PACKAGE_HEADER
));
2992 Status
= EFI_SUCCESS
;
2994 while (PackageHeader
.Type
!= EFI_HII_PACKAGE_END
) {
2995 switch (PackageHeader
.Type
) {
2996 case EFI_HII_PACKAGE_TYPE_GUID
:
2997 Status
= InsertGuidPackage (
3000 DatabaseRecord
->PackageList
,
3003 if (EFI_ERROR (Status
)) {
3006 Status
= InvokeRegisteredFunction (
3009 (VOID
*) GuidPackage
,
3010 (UINT8
) (PackageHeader
.Type
),
3011 DatabaseRecord
->Handle
3014 case EFI_HII_PACKAGE_FORMS
:
3015 Status
= InsertFormPackage (
3018 DatabaseRecord
->PackageList
,
3021 if (EFI_ERROR (Status
)) {
3024 Status
= InvokeRegisteredFunction (
3027 (VOID
*) FormPackage
,
3028 (UINT8
) (PackageHeader
.Type
),
3029 DatabaseRecord
->Handle
3032 // If Hii runtime support feature is enabled,
3033 // will export Hii info for runtime use after ReadyToBoot event triggered.
3034 // If some driver add/update/remove packages from HiiDatabase after ReadyToBoot,
3035 // will need to export the content of HiiDatabase.
3036 // But if form packages added/updated, also need to export the ConfigResp string.
3038 if (gExportAfterReadyToBoot
) {
3039 gExportConfigResp
= TRUE
;
3042 case EFI_HII_PACKAGE_KEYBOARD_LAYOUT
:
3043 Status
= InsertKeyboardLayoutPackage (
3046 DatabaseRecord
->PackageList
,
3047 &KeyboardLayoutPackage
3049 if (EFI_ERROR (Status
)) {
3052 Status
= InvokeRegisteredFunction (
3055 (VOID
*) KeyboardLayoutPackage
,
3056 (UINT8
) (PackageHeader
.Type
),
3057 DatabaseRecord
->Handle
3060 case EFI_HII_PACKAGE_STRINGS
:
3061 Status
= InsertStringPackage (
3065 DatabaseRecord
->PackageList
,
3068 if (EFI_ERROR (Status
)) {
3071 ASSERT (StringPackage
!= NULL
);
3072 Status
= InvokeRegisteredFunction (
3075 (VOID
*) StringPackage
,
3076 (UINT8
) (PackageHeader
.Type
),
3077 DatabaseRecord
->Handle
3079 StringPkgIsAdd
= TRUE
;
3081 case EFI_HII_PACKAGE_FONTS
:
3082 Status
= InsertFontPackage (
3086 DatabaseRecord
->PackageList
,
3089 if (EFI_ERROR (Status
)) {
3092 Status
= InvokeRegisteredFunction (
3095 (VOID
*) FontPackage
,
3096 (UINT8
) (PackageHeader
.Type
),
3097 DatabaseRecord
->Handle
3100 case EFI_HII_PACKAGE_IMAGES
:
3101 Status
= InsertImagePackage (
3104 DatabaseRecord
->PackageList
,
3107 if (EFI_ERROR (Status
)) {
3110 Status
= InvokeRegisteredFunction (
3113 (VOID
*) ImagePackage
,
3114 (UINT8
) (PackageHeader
.Type
),
3115 DatabaseRecord
->Handle
3118 case EFI_HII_PACKAGE_SIMPLE_FONTS
:
3119 Status
= InsertSimpleFontPackage (
3122 DatabaseRecord
->PackageList
,
3125 if (EFI_ERROR (Status
)) {
3128 Status
= InvokeRegisteredFunction (
3131 (VOID
*) SimpleFontPackage
,
3132 (UINT8
) (PackageHeader
.Type
),
3133 DatabaseRecord
->Handle
3136 case EFI_HII_PACKAGE_DEVICE_PATH
:
3137 Status
= AddDevicePathPackage (
3140 (EFI_DEVICE_PATH_PROTOCOL
*) ((UINT8
*) PackageHdrPtr
+ sizeof (EFI_HII_PACKAGE_HEADER
)),
3148 if (EFI_ERROR (Status
)) {
3152 // goto header of next package
3154 PackageHdrPtr
= (EFI_HII_PACKAGE_HEADER
*) ((UINT8
*) PackageHdrPtr
+ PackageHeader
.Length
);
3155 CopyMem (&PackageHeader
, PackageHdrPtr
, sizeof (EFI_HII_PACKAGE_HEADER
));
3159 // Adjust String Package to make sure all string packages have the same max string ID.
3161 if (!EFI_ERROR (Status
) && StringPkgIsAdd
) {
3162 Status
= AdjustStringPackage (DatabaseRecord
->PackageList
);
3170 This function exports a package list to a buffer. It is the worker function
3171 of HiiExportPackageList.
3173 This is a internal function.
3175 @param Private Hii database private structure.
3176 @param Handle Identification of a package list.
3177 @param PackageList Pointer to a package list which will be exported.
3178 @param UsedSize The length of buffer has been used by exporting
3179 package lists when Handle is NULL.
3180 @param BufferSize Length of the Buffer.
3181 @param Buffer Allocated space for storing exported data.
3183 @retval EFI_SUCCESS Keyboard Layout Packages are exported
3185 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
3190 IN HII_DATABASE_PRIVATE_DATA
*Private
,
3191 IN EFI_HII_HANDLE Handle
,
3192 IN HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
,
3193 IN OUT UINTN
*UsedSize
,
3194 IN UINTN BufferSize
,
3195 OUT EFI_HII_PACKAGE_LIST_HEADER
*Buffer
3200 EFI_HII_PACKAGE_HEADER EndofPackageList
;
3202 ASSERT (Private
!= NULL
&& PackageList
!= NULL
&& UsedSize
!= NULL
);
3203 ASSERT (Private
->Signature
== HII_DATABASE_PRIVATE_DATA_SIGNATURE
);
3204 ASSERT (IsHiiHandleValid (Handle
));
3206 if (BufferSize
> 0 && Buffer
== NULL
) {
3207 return EFI_INVALID_PARAMETER
;
3211 // Copy the package list header
3212 // ResultSize indicates the length of the exported bytes of this package list
3214 ResultSize
= sizeof (EFI_HII_PACKAGE_LIST_HEADER
);
3215 if (ResultSize
+ *UsedSize
<= BufferSize
) {
3216 CopyMem ((VOID
*) Buffer
, PackageList
, ResultSize
);
3219 // Copy the packages and invoke EXPORT_PACK notify functions if exists.
3221 Status
= ExportGuidPackages (
3227 (VOID
*) ((UINT8
*) Buffer
+ ResultSize
),
3230 if (EFI_ERROR (Status
)) {
3233 Status
= ExportFormPackages (
3239 (VOID
*) ((UINT8
*) Buffer
+ ResultSize
),
3242 if (EFI_ERROR (Status
)) {
3245 Status
= ExportKeyboardLayoutPackages (
3251 (VOID
*) ((UINT8
*) Buffer
+ ResultSize
),
3254 if (EFI_ERROR (Status
)) {
3257 Status
= ExportStringPackages (
3263 (VOID
*) ((UINT8
*) Buffer
+ ResultSize
),
3266 if (EFI_ERROR (Status
)) {
3269 Status
= ExportFontPackages (
3275 (VOID
*) ((UINT8
*) Buffer
+ ResultSize
),
3278 if (EFI_ERROR (Status
)) {
3281 Status
= ExportImagePackages (
3287 (VOID
*) ((UINT8
*) Buffer
+ ResultSize
),
3290 if (EFI_ERROR (Status
)) {
3293 Status
= ExportSimpleFontPackages (
3299 (VOID
*) ((UINT8
*) Buffer
+ ResultSize
),
3302 if (EFI_ERROR (Status
)) {
3305 Status
= ExportDevicePathPackage (
3311 (VOID
*) ((UINT8
*) Buffer
+ ResultSize
),
3314 if (EFI_ERROR (Status
)) {
3318 // Append the package list end.
3320 EndofPackageList
.Length
= sizeof (EFI_HII_PACKAGE_HEADER
);
3321 EndofPackageList
.Type
= EFI_HII_PACKAGE_END
;
3322 if (ResultSize
+ *UsedSize
+ sizeof (EFI_HII_PACKAGE_HEADER
) <= BufferSize
) {
3324 (VOID
*) ((UINT8
*) Buffer
+ ResultSize
),
3325 (VOID
*) &EndofPackageList
,
3326 sizeof (EFI_HII_PACKAGE_HEADER
)
3330 *UsedSize
+= ResultSize
+ sizeof (EFI_HII_PACKAGE_HEADER
);
3336 This function mainly use to get and update ConfigResp string.
3338 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL instance.
3340 @retval EFI_SUCCESS Get the information successfully.
3341 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the Configuration Setting data.
3345 HiiGetConfigRespInfo(
3346 IN CONST EFI_HII_DATABASE_PROTOCOL
*This
3350 HII_DATABASE_PRIVATE_DATA
*Private
;
3351 EFI_STRING ConfigAltResp
;
3354 ConfigAltResp
= NULL
;
3357 Private
= HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This
);
3360 // Get ConfigResp string
3362 Status
= HiiConfigRoutingExportConfig(&Private
->ConfigRouting
,&ConfigAltResp
);
3364 if (!EFI_ERROR (Status
)){
3365 ConfigSize
= StrSize(ConfigAltResp
);
3366 if (ConfigSize
> gConfigRespSize
){
3367 gConfigRespSize
= ConfigSize
;
3368 if (gRTConfigRespBuffer
!= NULL
){
3369 FreePool(gRTConfigRespBuffer
);
3371 gRTConfigRespBuffer
= (EFI_STRING
)AllocateRuntimeZeroPool(ConfigSize
);
3372 if (gRTConfigRespBuffer
== NULL
){
3373 FreePool(ConfigAltResp
);
3374 DEBUG ((DEBUG_ERROR
, "Not enough memory resource to get the ConfigResp string.\n"));
3375 return EFI_OUT_OF_RESOURCES
;
3378 ZeroMem(gRTConfigRespBuffer
,gConfigRespSize
);
3380 CopyMem(gRTConfigRespBuffer
,ConfigAltResp
,ConfigSize
);
3381 gBS
->InstallConfigurationTable (&gEfiHiiConfigRoutingProtocolGuid
, gRTConfigRespBuffer
);
3382 FreePool(ConfigAltResp
);
3390 This is an internal function,mainly use to get HiiDatabase information.
3392 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL instance.
3394 @retval EFI_SUCCESS Get the information successfully.
3395 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the Hiidatabase data.
3400 IN CONST EFI_HII_DATABASE_PROTOCOL
*This
3404 EFI_HII_PACKAGE_LIST_HEADER
*DatabaseInfo
;
3405 UINTN DatabaseInfoSize
;
3407 DatabaseInfo
= NULL
;
3408 DatabaseInfoSize
= 0;
3411 // Get HiiDatabase information.
3413 Status
= HiiExportPackageLists(This
, NULL
, &DatabaseInfoSize
, DatabaseInfo
);
3415 ASSERT(Status
== EFI_BUFFER_TOO_SMALL
);
3417 if(DatabaseInfoSize
> gDatabaseInfoSize
) {
3418 gDatabaseInfoSize
= DatabaseInfoSize
;
3419 if (gRTDatabaseInfoBuffer
!= NULL
){
3420 FreePool(gRTDatabaseInfoBuffer
);
3422 gRTDatabaseInfoBuffer
= AllocateRuntimeZeroPool(DatabaseInfoSize
);
3423 if (gRTDatabaseInfoBuffer
== NULL
){
3424 DEBUG ((DEBUG_ERROR
, "Not enough memory resource to get the HiiDatabase info.\n"));
3425 return EFI_OUT_OF_RESOURCES
;
3428 ZeroMem(gRTDatabaseInfoBuffer
,gDatabaseInfoSize
);
3430 Status
= HiiExportPackageLists(This
, NULL
, &DatabaseInfoSize
, gRTDatabaseInfoBuffer
);
3431 ASSERT_EFI_ERROR (Status
);
3432 gBS
->InstallConfigurationTable (&gEfiHiiDatabaseProtocolGuid
, gRTDatabaseInfoBuffer
);
3439 This function mainly use to get and update configuration settings information.
3441 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL instance.
3443 @retval EFI_SUCCESS Get the information successfully.
3444 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the Configuration Setting data.
3448 HiiGetConfigurationSetting(
3449 IN CONST EFI_HII_DATABASE_PROTOCOL
*This
3455 // Get the HiiDatabase info.
3457 Status
= HiiGetDatabaseInfo(This
);
3460 // Get ConfigResp string
3462 if (gExportConfigResp
) {
3463 Status
= HiiGetConfigRespInfo (This
);
3464 gExportConfigResp
= FALSE
;
3472 This function adds the packages in the package list to the database and returns a handle. If there is a
3473 EFI_DEVICE_PATH_PROTOCOL associated with the DriverHandle, then this function will
3474 create a package of type EFI_PACKAGE_TYPE_DEVICE_PATH and add it to the package list.
3476 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
3478 @param PackageList A pointer to an EFI_HII_PACKAGE_LIST_HEADER
3480 @param DriverHandle Associate the package list with this EFI handle.
3481 If a NULL is specified, this data will not be associate
3482 with any drivers and cannot have a callback induced.
3483 @param Handle A pointer to the EFI_HII_HANDLE instance.
3485 @retval EFI_SUCCESS The package list associated with the Handle was
3486 added to the HII database.
3487 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
3489 @retval EFI_INVALID_PARAMETER PackageList is NULL or Handle is NULL.
3490 @retval EFI_INVALID_PARAMETER PackageListGuid already exists in database.
3496 IN CONST EFI_HII_DATABASE_PROTOCOL
*This
,
3497 IN CONST EFI_HII_PACKAGE_LIST_HEADER
*PackageList
,
3498 IN CONST EFI_HANDLE DriverHandle
, OPTIONAL
3499 OUT EFI_HII_HANDLE
*Handle
3503 HII_DATABASE_PRIVATE_DATA
*Private
;
3504 HII_DATABASE_RECORD
*DatabaseRecord
;
3505 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
3507 EFI_GUID PackageListGuid
;
3509 if (This
== NULL
|| PackageList
== NULL
|| Handle
== NULL
) {
3510 return EFI_INVALID_PARAMETER
;
3513 Private
= HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This
);
3514 CopyMem (&PackageListGuid
, (VOID
*) PackageList
, sizeof (EFI_GUID
));
3517 // Check the Package list GUID to guarantee this GUID is unique in database.
3519 for (Link
= Private
->DatabaseList
.ForwardLink
; Link
!= &Private
->DatabaseList
; Link
= Link
->ForwardLink
) {
3520 DatabaseRecord
= CR (Link
, HII_DATABASE_RECORD
, DatabaseEntry
, HII_DATABASE_RECORD_SIGNATURE
);
3522 &(DatabaseRecord
->PackageList
->PackageListHdr
.PackageListGuid
),
3523 &PackageListGuid
) &&
3524 DatabaseRecord
->DriverHandle
== DriverHandle
) {
3525 return EFI_INVALID_PARAMETER
;
3530 // Build a PackageList node
3532 Status
= GenerateHiiDatabaseRecord (Private
, &DatabaseRecord
);
3533 if (EFI_ERROR (Status
)) {
3538 // Fill in information of the created Package List node
3539 // according to incoming package list.
3541 Status
= AddPackages (Private
, EFI_HII_DATABASE_NOTIFY_NEW_PACK
, PackageList
, DatabaseRecord
);
3542 if (EFI_ERROR (Status
)) {
3546 DatabaseRecord
->DriverHandle
= DriverHandle
;
3549 // Create a Device path package and add into the package list if exists.
3551 Status
= gBS
->HandleProtocol (
3553 &gEfiDevicePathProtocolGuid
,
3554 (VOID
**) &DevicePath
3556 if (!EFI_ERROR (Status
)) {
3557 Status
= AddDevicePathPackage (Private
, EFI_HII_DATABASE_NOTIFY_NEW_PACK
, DevicePath
, DatabaseRecord
);
3558 ASSERT_EFI_ERROR (Status
);
3561 *Handle
= DatabaseRecord
->Handle
;
3564 // Check whether need to get the Database and configuration setting info.
3565 // Only after ReadyToBoot, need to do the export.
3567 if (gExportAfterReadyToBoot
) {
3568 HiiGetConfigurationSetting(This
);
3576 This function removes the package list that is associated with Handle
3577 from the HII database. Before removing the package, any registered functions
3578 with the notification type REMOVE_PACK and the same package type will be called.
3580 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
3582 @param Handle The handle that was registered to the data that is
3583 requested for removal.
3585 @retval EFI_SUCCESS The data associated with the Handle was removed
3586 from the HII database.
3587 @retval EFI_NOT_FOUND The specified handle is not in database.
3588 @retval EFI_INVALID_PARAMETER The Handle was not valid.
3593 HiiRemovePackageList (
3594 IN CONST EFI_HII_DATABASE_PROTOCOL
*This
,
3595 IN EFI_HII_HANDLE Handle
3599 HII_DATABASE_PRIVATE_DATA
*Private
;
3601 HII_DATABASE_RECORD
*Node
;
3602 HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
;
3603 HII_HANDLE
*HiiHandle
;
3606 return EFI_INVALID_PARAMETER
;
3609 if (!IsHiiHandleValid (Handle
)) {
3610 return EFI_NOT_FOUND
;
3613 Private
= HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This
);
3616 // Get the packagelist to be removed.
3618 for (Link
= Private
->DatabaseList
.ForwardLink
; Link
!= &Private
->DatabaseList
; Link
= Link
->ForwardLink
) {
3619 Node
= CR (Link
, HII_DATABASE_RECORD
, DatabaseEntry
, HII_DATABASE_RECORD_SIGNATURE
);
3620 if (Node
->Handle
== Handle
) {
3621 PackageList
= (HII_DATABASE_PACKAGE_LIST_INSTANCE
*) (Node
->PackageList
);
3622 ASSERT (PackageList
!= NULL
);
3625 // Call registered functions with REMOVE_PACK before removing packages
3626 // then remove them.
3628 Status
= RemoveGuidPackages (Private
, Handle
, PackageList
);
3629 if (EFI_ERROR (Status
)) {
3632 Status
= RemoveFormPackages (Private
, Handle
, PackageList
);
3633 if (EFI_ERROR (Status
)) {
3636 Status
= RemoveKeyboardLayoutPackages (Private
, Handle
, PackageList
);
3637 if (EFI_ERROR (Status
)) {
3640 Status
= RemoveStringPackages (Private
, Handle
, PackageList
);
3641 if (EFI_ERROR (Status
)) {
3644 Status
= RemoveFontPackages (Private
, Handle
, PackageList
);
3645 if (EFI_ERROR (Status
)) {
3648 Status
= RemoveImagePackages (Private
, Handle
, PackageList
);
3649 if (EFI_ERROR (Status
)) {
3652 Status
= RemoveSimpleFontPackages (Private
, Handle
, PackageList
);
3653 if (EFI_ERROR (Status
)) {
3656 Status
= RemoveDevicePathPackage (Private
, Handle
, PackageList
);
3657 if (EFI_ERROR (Status
)) {
3662 // Free resources of the package list
3664 RemoveEntryList (&Node
->DatabaseEntry
);
3666 HiiHandle
= (HII_HANDLE
*) Handle
;
3667 RemoveEntryList (&HiiHandle
->Handle
);
3668 Private
->HiiHandleCount
--;
3669 ASSERT (Private
->HiiHandleCount
>= 0);
3671 HiiHandle
->Signature
= 0;
3672 FreePool (HiiHandle
);
3673 FreePool (Node
->PackageList
);
3677 // Check whether need to get the Database and configuration setting info.
3678 // Only after ReadyToBoot, need to do the export.
3680 if (gExportAfterReadyToBoot
) {
3681 HiiGetConfigurationSetting(This
);
3687 return EFI_NOT_FOUND
;
3692 This function updates the existing package list (which has the specified Handle)
3693 in the HII databases, using the new package list specified by PackageList.
3695 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
3697 @param Handle The handle that was registered to the data that is
3698 requested to be updated.
3699 @param PackageList A pointer to an EFI_HII_PACKAGE_LIST_HEADER
3702 @retval EFI_SUCCESS The HII database was successfully updated.
3703 @retval EFI_OUT_OF_RESOURCES Unable to allocate enough memory for the updated
3705 @retval EFI_INVALID_PARAMETER PackageList was NULL.
3706 @retval EFI_NOT_FOUND The specified Handle is not in database.
3711 HiiUpdatePackageList (
3712 IN CONST EFI_HII_DATABASE_PROTOCOL
*This
,
3713 IN EFI_HII_HANDLE Handle
,
3714 IN CONST EFI_HII_PACKAGE_LIST_HEADER
*PackageList
3718 HII_DATABASE_PRIVATE_DATA
*Private
;
3720 HII_DATABASE_RECORD
*Node
;
3721 EFI_HII_PACKAGE_HEADER
*PackageHdrPtr
;
3722 HII_DATABASE_PACKAGE_LIST_INSTANCE
*OldPackageList
;
3723 EFI_HII_PACKAGE_HEADER PackageHeader
;
3725 if (This
== NULL
|| PackageList
== NULL
) {
3726 return EFI_INVALID_PARAMETER
;
3729 if (!IsHiiHandleValid (Handle
)) {
3730 return EFI_NOT_FOUND
;
3733 Private
= HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This
);
3735 PackageHdrPtr
= (EFI_HII_PACKAGE_HEADER
*) ((UINT8
*) PackageList
+ sizeof (EFI_HII_PACKAGE_LIST_HEADER
));
3737 Status
= EFI_SUCCESS
;
3740 // Get original packagelist to be updated
3742 for (Link
= Private
->DatabaseList
.ForwardLink
; Link
!= &Private
->DatabaseList
; Link
= Link
->ForwardLink
) {
3743 Node
= CR (Link
, HII_DATABASE_RECORD
, DatabaseEntry
, HII_DATABASE_RECORD_SIGNATURE
);
3744 if (Node
->Handle
== Handle
) {
3745 OldPackageList
= Node
->PackageList
;
3747 // Remove the package if its type matches one of the package types which is
3748 // contained in the new package list.
3750 CopyMem (&PackageHeader
, PackageHdrPtr
, sizeof (EFI_HII_PACKAGE_HEADER
));
3751 while (PackageHeader
.Type
!= EFI_HII_PACKAGE_END
) {
3752 switch (PackageHeader
.Type
) {
3753 case EFI_HII_PACKAGE_TYPE_GUID
:
3754 Status
= RemoveGuidPackages (Private
, Handle
, OldPackageList
);
3756 case EFI_HII_PACKAGE_FORMS
:
3757 Status
= RemoveFormPackages (Private
, Handle
, OldPackageList
);
3759 case EFI_HII_PACKAGE_KEYBOARD_LAYOUT
:
3760 Status
= RemoveKeyboardLayoutPackages (Private
, Handle
, OldPackageList
);
3762 case EFI_HII_PACKAGE_STRINGS
:
3763 Status
= RemoveStringPackages (Private
, Handle
, OldPackageList
);
3765 case EFI_HII_PACKAGE_FONTS
:
3766 Status
= RemoveFontPackages (Private
, Handle
, OldPackageList
);
3768 case EFI_HII_PACKAGE_IMAGES
:
3769 Status
= RemoveImagePackages (Private
, Handle
, OldPackageList
);
3771 case EFI_HII_PACKAGE_SIMPLE_FONTS
:
3772 Status
= RemoveSimpleFontPackages (Private
, Handle
, OldPackageList
);
3774 case EFI_HII_PACKAGE_DEVICE_PATH
:
3775 Status
= RemoveDevicePathPackage (Private
, Handle
, OldPackageList
);
3779 if (EFI_ERROR (Status
)) {
3783 PackageHdrPtr
= (EFI_HII_PACKAGE_HEADER
*) ((UINT8
*) PackageHdrPtr
+ PackageHeader
.Length
);
3784 CopyMem (&PackageHeader
, PackageHdrPtr
, sizeof (EFI_HII_PACKAGE_HEADER
));
3788 // Add all of the packages within the new package list
3790 Status
= AddPackages (Private
, EFI_HII_DATABASE_NOTIFY_ADD_PACK
, PackageList
, Node
);
3793 // Check whether need to get the Database and configuration setting info.
3794 // Only after ReadyToBoot, need to do the export.
3796 if (gExportAfterReadyToBoot
) {
3797 if (Status
== EFI_SUCCESS
){
3798 HiiGetConfigurationSetting(This
);
3806 return EFI_NOT_FOUND
;
3811 This function returns a list of the package handles of the specified type
3812 that are currently active in the database. The pseudo-type
3813 EFI_HII_PACKAGE_TYPE_ALL will cause all package handles to be listed.
3815 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
3817 @param PackageType Specifies the package type of the packages to list
3818 or EFI_HII_PACKAGE_TYPE_ALL for all packages to be
3820 @param PackageGuid If PackageType is EFI_HII_PACKAGE_TYPE_GUID, then
3821 this is the pointer to the GUID which must match
3822 the Guid field of EFI_HII_GUID_PACKAGE_GUID_HDR.
3823 Otherwise, it must be NULL.
3824 @param HandleBufferLength On input, a pointer to the length of the handle
3825 buffer. On output, the length of the handle
3826 buffer that is required for the handles found.
3827 @param Handle An array of EFI_HII_HANDLE instances returned.
3829 @retval EFI_SUCCESS The matching handles are outputted successfully.
3830 HandleBufferLength is updated with the actual length.
3831 @retval EFI_BUFFER_TO_SMALL The HandleBufferLength parameter indicates that
3832 Handle is too small to support the number of
3833 handles. HandleBufferLength is updated with a
3834 value that will enable the data to fit.
3835 @retval EFI_NOT_FOUND No matching handle could not be found in database.
3836 @retval EFI_INVALID_PARAMETER HandleBufferLength was NULL.
3837 @retval EFI_INVALID_PARAMETER The value referenced by HandleBufferLength was not
3838 zero and Handle was NULL.
3839 @retval EFI_INVALID_PARAMETER PackageType is not a EFI_HII_PACKAGE_TYPE_GUID but
3840 PackageGuid is not NULL, PackageType is a EFI_HII_
3841 PACKAGE_TYPE_GUID but PackageGuid is NULL.
3846 HiiListPackageLists (
3847 IN CONST EFI_HII_DATABASE_PROTOCOL
*This
,
3848 IN UINT8 PackageType
,
3849 IN CONST EFI_GUID
*PackageGuid
,
3850 IN OUT UINTN
*HandleBufferLength
,
3851 OUT EFI_HII_HANDLE
*Handle
3854 HII_GUID_PACKAGE_INSTANCE
*GuidPackage
;
3855 HII_DATABASE_PRIVATE_DATA
*Private
;
3856 HII_DATABASE_RECORD
*Node
;
3859 HII_HANDLE
**Result
;
3861 HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
;
3865 // Check input parameters
3867 if (This
== NULL
|| HandleBufferLength
== NULL
) {
3868 return EFI_INVALID_PARAMETER
;
3870 if (*HandleBufferLength
> 0 && Handle
== NULL
) {
3871 return EFI_INVALID_PARAMETER
;
3873 if ((PackageType
== EFI_HII_PACKAGE_TYPE_GUID
&& PackageGuid
== NULL
) ||
3874 (PackageType
!= EFI_HII_PACKAGE_TYPE_GUID
&& PackageGuid
!= NULL
)) {
3875 return EFI_INVALID_PARAMETER
;
3878 Private
= HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This
);
3880 Result
= (HII_HANDLE
**) Handle
;
3883 for (Link
= Private
->DatabaseList
.ForwardLink
; Link
!= &Private
->DatabaseList
; Link
= Link
->ForwardLink
) {
3884 Node
= CR (Link
, HII_DATABASE_RECORD
, DatabaseEntry
, HII_DATABASE_RECORD_SIGNATURE
);
3885 PackageList
= (HII_DATABASE_PACKAGE_LIST_INSTANCE
*) (Node
->PackageList
);
3886 switch (PackageType
) {
3887 case EFI_HII_PACKAGE_TYPE_GUID
:
3888 for (Link1
= PackageList
->GuidPkgHdr
.ForwardLink
; Link1
!= &PackageList
->GuidPkgHdr
; Link1
= Link1
->ForwardLink
) {
3889 GuidPackage
= CR (Link1
, HII_GUID_PACKAGE_INSTANCE
, GuidEntry
, HII_GUID_PACKAGE_SIGNATURE
);
3891 (EFI_GUID
*) PackageGuid
,
3892 (EFI_GUID
*) (GuidPackage
->GuidPkg
+ sizeof (EFI_HII_PACKAGE_HEADER
))
3899 case EFI_HII_PACKAGE_FORMS
:
3900 if (!IsListEmpty (&PackageList
->FormPkgHdr
)) {
3904 case EFI_HII_PACKAGE_KEYBOARD_LAYOUT
:
3905 if (!IsListEmpty (&PackageList
->KeyboardLayoutHdr
)) {
3909 case EFI_HII_PACKAGE_STRINGS
:
3910 if (!IsListEmpty (&PackageList
->StringPkgHdr
)) {
3914 case EFI_HII_PACKAGE_FONTS
:
3915 if (!IsListEmpty (&PackageList
->FontPkgHdr
)) {
3919 case EFI_HII_PACKAGE_IMAGES
:
3920 if (PackageList
->ImagePkg
!= NULL
) {
3924 case EFI_HII_PACKAGE_SIMPLE_FONTS
:
3925 if (!IsListEmpty (&PackageList
->SimpleFontPkgHdr
)) {
3929 case EFI_HII_PACKAGE_DEVICE_PATH
:
3930 if (PackageList
->DevicePathPkg
!= NULL
) {
3935 // Pseudo-type EFI_HII_PACKAGE_TYPE_ALL will cause all package handles
3938 case EFI_HII_PACKAGE_TYPE_ALL
:
3946 // This active package list has the specified package type, list it.
3949 ResultSize
+= sizeof (EFI_HII_HANDLE
);
3950 if (ResultSize
<= *HandleBufferLength
) {
3951 *Result
++ = Node
->Handle
;
3957 if (ResultSize
== 0) {
3958 return EFI_NOT_FOUND
;
3961 if (*HandleBufferLength
< ResultSize
) {
3962 *HandleBufferLength
= ResultSize
;
3963 return EFI_BUFFER_TOO_SMALL
;
3966 *HandleBufferLength
= ResultSize
;
3972 This function will export one or all package lists in the database to a buffer.
3973 For each package list exported, this function will call functions registered
3974 with EXPORT_PACK and then copy the package list to the buffer.
3976 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
3978 @param Handle An EFI_HII_HANDLE that corresponds to the desired
3979 package list in the HII database to export or NULL
3980 to indicate all package lists should be exported.
3981 @param BufferSize On input, a pointer to the length of the buffer.
3982 On output, the length of the buffer that is
3983 required for the exported data.
3984 @param Buffer A pointer to a buffer that will contain the
3985 results of the export function.
3987 @retval EFI_SUCCESS Package exported.
3988 @retval EFI_BUFFER_TO_SMALL The HandleBufferLength parameter indicates that
3989 Handle is too small to support the number of
3990 handles. HandleBufferLength is updated with a
3991 value that will enable the data to fit.
3992 @retval EFI_NOT_FOUND The specified Handle could not be found in the
3994 @retval EFI_INVALID_PARAMETER BufferSize was NULL.
3995 @retval EFI_INVALID_PARAMETER The value referenced by BufferSize was not zero
3996 and Buffer was NULL.
4001 HiiExportPackageLists (
4002 IN CONST EFI_HII_DATABASE_PROTOCOL
*This
,
4003 IN EFI_HII_HANDLE Handle
,
4004 IN OUT UINTN
*BufferSize
,
4005 OUT EFI_HII_PACKAGE_LIST_HEADER
*Buffer
4010 HII_DATABASE_PRIVATE_DATA
*Private
;
4011 HII_DATABASE_RECORD
*Node
;
4014 if (This
== NULL
|| BufferSize
== NULL
) {
4015 return EFI_INVALID_PARAMETER
;
4017 if (*BufferSize
> 0 && Buffer
== NULL
) {
4018 return EFI_INVALID_PARAMETER
;
4020 if ((Handle
!= NULL
) && (!IsHiiHandleValid (Handle
))) {
4021 return EFI_NOT_FOUND
;
4024 Private
= HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This
);
4027 for (Link
= Private
->DatabaseList
.ForwardLink
; Link
!= &Private
->DatabaseList
; Link
= Link
->ForwardLink
) {
4028 Node
= CR (Link
, HII_DATABASE_RECORD
, DatabaseEntry
, HII_DATABASE_RECORD_SIGNATURE
);
4029 if (Handle
== NULL
) {
4031 // Export all package lists in current hii database.
4033 Status
= ExportPackageList (
4036 (HII_DATABASE_PACKAGE_LIST_INSTANCE
*) (Node
->PackageList
),
4039 (EFI_HII_PACKAGE_LIST_HEADER
*)((UINT8
*) Buffer
+ UsedSize
)
4041 ASSERT_EFI_ERROR (Status
);
4042 } else if (Handle
!= NULL
&& Node
->Handle
== Handle
) {
4043 Status
= ExportPackageList (
4046 (HII_DATABASE_PACKAGE_LIST_INSTANCE
*) (Node
->PackageList
),
4051 ASSERT_EFI_ERROR (Status
);
4052 if (*BufferSize
< UsedSize
) {
4053 *BufferSize
= UsedSize
;
4054 return EFI_BUFFER_TOO_SMALL
;
4060 if (Handle
== NULL
&& UsedSize
!= 0) {
4061 if (*BufferSize
< UsedSize
) {
4062 *BufferSize
= UsedSize
;
4063 return EFI_BUFFER_TOO_SMALL
;
4068 return EFI_NOT_FOUND
;
4073 This function registers a function which will be called when specified actions related to packages of
4074 the specified type occur in the HII database. By registering a function, other HII-related drivers are
4075 notified when specific package types are added, removed or updated in the HII database.
4076 Each driver or application which registers a notification should use
4077 EFI_HII_DATABASE_PROTOCOL.UnregisterPackageNotify() before exiting.
4079 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
4081 @param PackageType Specifies the package type of the packages to list
4082 or EFI_HII_PACKAGE_TYPE_ALL for all packages to be
4084 @param PackageGuid If PackageType is EFI_HII_PACKAGE_TYPE_GUID, then
4085 this is the pointer to the GUID which must match
4087 EFI_HII_GUID_PACKAGE_GUID_HDR. Otherwise, it must
4089 @param PackageNotifyFn Points to the function to be called when the event
4091 NotificationType occurs.
4092 @param NotifyType Describes the types of notification which this
4093 function will be receiving.
4094 @param NotifyHandle Points to the unique handle assigned to the
4095 registered notification. Can be used in
4096 EFI_HII_DATABASE_PROTOCOL.UnregisterPackageNotify()
4097 to stop notifications.
4099 @retval EFI_SUCCESS Notification registered successfully.
4100 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary data structures
4101 @retval EFI_INVALID_PARAMETER NotifyHandle is NULL.
4102 @retval EFI_INVALID_PARAMETER PackageGuid is not NULL when PackageType is not
4103 EFI_HII_PACKAGE_TYPE_GUID.
4104 @retval EFI_INVALID_PARAMETER PackageGuid is NULL when PackageType is
4105 EFI_HII_PACKAGE_TYPE_GUID.
4110 HiiRegisterPackageNotify (
4111 IN CONST EFI_HII_DATABASE_PROTOCOL
*This
,
4112 IN UINT8 PackageType
,
4113 IN CONST EFI_GUID
*PackageGuid
,
4114 IN CONST EFI_HII_DATABASE_NOTIFY PackageNotifyFn
,
4115 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType
,
4116 OUT EFI_HANDLE
*NotifyHandle
4119 HII_DATABASE_PRIVATE_DATA
*Private
;
4120 HII_DATABASE_NOTIFY
*Notify
;
4123 if (This
== NULL
|| NotifyHandle
== NULL
) {
4124 return EFI_INVALID_PARAMETER
;
4126 if ((PackageType
== EFI_HII_PACKAGE_TYPE_GUID
&& PackageGuid
== NULL
) ||
4127 (PackageType
!= EFI_HII_PACKAGE_TYPE_GUID
&& PackageGuid
!= NULL
)) {
4128 return EFI_INVALID_PARAMETER
;
4131 Private
= HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This
);
4134 // Allocate a notification node
4136 Notify
= (HII_DATABASE_NOTIFY
*) AllocateZeroPool (sizeof (HII_DATABASE_NOTIFY
));
4137 if (Notify
== NULL
) {
4138 return EFI_OUT_OF_RESOURCES
;
4142 // Generate a notify handle
4144 Status
= gBS
->InstallMultipleProtocolInterfaces (
4145 &Notify
->NotifyHandle
,
4150 ASSERT_EFI_ERROR (Status
);
4153 // Fill in the information to the notification node
4155 Notify
->Signature
= HII_DATABASE_NOTIFY_SIGNATURE
;
4156 Notify
->PackageType
= PackageType
;
4157 Notify
->PackageGuid
= (EFI_GUID
*) PackageGuid
;
4158 Notify
->PackageNotifyFn
= (EFI_HII_DATABASE_NOTIFY
) PackageNotifyFn
;
4159 Notify
->NotifyType
= NotifyType
;
4161 InsertTailList (&Private
->DatabaseNotifyList
, &Notify
->DatabaseNotifyEntry
);
4162 *NotifyHandle
= Notify
->NotifyHandle
;
4169 Removes the specified HII database package-related notification.
4171 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
4173 @param NotificationHandle The handle of the notification function being
4176 @retval EFI_SUCCESS Notification is unregistered successfully.
4177 @retval EFI_INVALID_PARAMETER The Handle is invalid.
4178 @retval EFI_NOT_FOUND The incoming notification handle does not exist
4179 in current hii database.
4184 HiiUnregisterPackageNotify (
4185 IN CONST EFI_HII_DATABASE_PROTOCOL
*This
,
4186 IN EFI_HANDLE NotificationHandle
4189 HII_DATABASE_PRIVATE_DATA
*Private
;
4190 HII_DATABASE_NOTIFY
*Notify
;
4195 return EFI_INVALID_PARAMETER
;
4198 if (NotificationHandle
== NULL
) {
4199 return EFI_NOT_FOUND
;
4202 Status
= gBS
->OpenProtocol (
4208 EFI_OPEN_PROTOCOL_TEST_PROTOCOL
4210 if (EFI_ERROR (Status
)) {
4211 return EFI_NOT_FOUND
;
4214 Private
= HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This
);
4216 for (Link
= Private
->DatabaseNotifyList
.ForwardLink
; Link
!= &Private
->DatabaseNotifyList
; Link
= Link
->ForwardLink
) {
4217 Notify
= CR (Link
, HII_DATABASE_NOTIFY
, DatabaseNotifyEntry
, HII_DATABASE_NOTIFY_SIGNATURE
);
4218 if (Notify
->NotifyHandle
== NotificationHandle
) {
4220 // Remove the matching notification node
4222 RemoveEntryList (&Notify
->DatabaseNotifyEntry
);
4223 Status
= gBS
->UninstallMultipleProtocolInterfaces (
4224 Notify
->NotifyHandle
,
4229 ASSERT_EFI_ERROR (Status
);
4236 return EFI_NOT_FOUND
;
4241 This routine retrieves an array of GUID values for each keyboard layout that
4242 was previously registered in the system.
4244 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
4246 @param KeyGuidBufferLength On input, a pointer to the length of the keyboard
4247 GUID buffer. On output, the length of the handle
4248 buffer that is required for the handles found.
4249 @param KeyGuidBuffer An array of keyboard layout GUID instances
4252 @retval EFI_SUCCESS KeyGuidBuffer was updated successfully.
4253 @retval EFI_BUFFER_TOO_SMALL The KeyGuidBufferLength parameter indicates
4254 that KeyGuidBuffer is too small to support the
4255 number of GUIDs. KeyGuidBufferLength is
4256 updated with a value that will enable the data to
4258 @retval EFI_INVALID_PARAMETER The KeyGuidBufferLength is NULL.
4259 @retval EFI_INVALID_PARAMETER The value referenced by KeyGuidBufferLength is not
4260 zero and KeyGuidBuffer is NULL.
4261 @retval EFI_NOT_FOUND There was no keyboard layout.
4266 HiiFindKeyboardLayouts (
4267 IN CONST EFI_HII_DATABASE_PROTOCOL
*This
,
4268 IN OUT UINT16
*KeyGuidBufferLength
,
4269 OUT EFI_GUID
*KeyGuidBuffer
4272 HII_DATABASE_PRIVATE_DATA
*Private
;
4273 HII_DATABASE_RECORD
*Node
;
4274 HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
;
4280 UINT16 LayoutLength
;
4282 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE
*Package
;
4284 if (This
== NULL
|| KeyGuidBufferLength
== NULL
) {
4285 return EFI_INVALID_PARAMETER
;
4288 if (*KeyGuidBufferLength
> 0 && KeyGuidBuffer
== NULL
) {
4289 return EFI_INVALID_PARAMETER
;
4292 Private
= HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This
);
4296 // Search all package lists in whole database to retrieve keyboard layout.
4298 for (Link
= Private
->DatabaseList
.ForwardLink
; Link
!= &Private
->DatabaseList
; Link
= Link
->ForwardLink
) {
4299 Node
= CR (Link
, HII_DATABASE_RECORD
, DatabaseEntry
, HII_DATABASE_RECORD_SIGNATURE
);
4300 PackageList
= Node
->PackageList
;
4301 for (Link1
= PackageList
->KeyboardLayoutHdr
.ForwardLink
;
4302 Link1
!= &PackageList
->KeyboardLayoutHdr
;
4303 Link1
= Link1
->ForwardLink
4306 // Find out all Keyboard Layout packages in this package list.
4310 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE
,
4312 HII_KB_LAYOUT_PACKAGE_SIGNATURE
4314 Layout
= (UINT8
*) Package
->KeyboardPkg
+ sizeof (EFI_HII_PACKAGE_HEADER
) + sizeof (UINT16
);
4317 (UINT8
*) Package
->KeyboardPkg
+ sizeof (EFI_HII_PACKAGE_HEADER
),
4320 for (Index
= 0; Index
< LayoutCount
; Index
++) {
4321 ResultSize
+= sizeof (EFI_GUID
);
4322 if (ResultSize
<= *KeyGuidBufferLength
) {
4323 CopyMem (KeyGuidBuffer
+ (ResultSize
/ sizeof (EFI_GUID
) - 1), Layout
+ sizeof (UINT16
), sizeof (EFI_GUID
));
4324 CopyMem (&LayoutLength
, Layout
, sizeof (UINT16
));
4325 Layout
= Layout
+ LayoutLength
;
4331 if (ResultSize
== 0) {
4332 return EFI_NOT_FOUND
;
4335 if (*KeyGuidBufferLength
< ResultSize
) {
4336 *KeyGuidBufferLength
= ResultSize
;
4337 return EFI_BUFFER_TOO_SMALL
;
4340 *KeyGuidBufferLength
= ResultSize
;
4346 This routine retrieves the requested keyboard layout. The layout is a physical description of the keys
4347 on a keyboard and the character(s) that are associated with a particular set of key strokes.
4349 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
4351 @param KeyGuid A pointer to the unique ID associated with a given
4352 keyboard layout. If KeyGuid is NULL then the
4353 current layout will be retrieved.
4354 @param KeyboardLayoutLength On input, a pointer to the length of the
4355 KeyboardLayout buffer. On output, the length of
4356 the data placed into KeyboardLayout.
4357 @param KeyboardLayout A pointer to a buffer containing the retrieved
4360 @retval EFI_SUCCESS The keyboard layout was retrieved successfully.
4361 @retval EFI_NOT_FOUND The requested keyboard layout was not found.
4362 @retval EFI_INVALID_PARAMETER The KeyboardLayout or KeyboardLayoutLength was
4364 @retval EFI_BUFFER_TOO_SMALL The KeyboardLayoutLength parameter indicates
4365 that KeyboardLayout is too small to support the
4366 requested keyboard layout. KeyboardLayoutLength is
4367 updated with a value that will enable the
4373 HiiGetKeyboardLayout (
4374 IN CONST EFI_HII_DATABASE_PROTOCOL
*This
,
4375 IN CONST EFI_GUID
*KeyGuid
,
4376 IN OUT UINT16
*KeyboardLayoutLength
,
4377 OUT EFI_HII_KEYBOARD_LAYOUT
*KeyboardLayout
4380 HII_DATABASE_PRIVATE_DATA
*Private
;
4381 HII_DATABASE_RECORD
*Node
;
4382 HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageList
;
4388 UINT16 LayoutLength
;
4389 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE
*Package
;
4391 if (This
== NULL
|| KeyboardLayoutLength
== NULL
) {
4392 return EFI_INVALID_PARAMETER
;
4394 if (*KeyboardLayoutLength
> 0 && KeyboardLayout
== NULL
) {
4395 return EFI_INVALID_PARAMETER
;
4398 Private
= HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This
);
4400 // Retrieve the current keyboard layout.
4402 if (KeyGuid
== NULL
) {
4403 if (Private
->CurrentLayout
== NULL
) {
4404 return EFI_NOT_FOUND
;
4406 CopyMem (&LayoutLength
, Private
->CurrentLayout
, sizeof (UINT16
));
4407 if (*KeyboardLayoutLength
< LayoutLength
) {
4408 *KeyboardLayoutLength
= LayoutLength
;
4409 return EFI_BUFFER_TOO_SMALL
;
4411 CopyMem (KeyboardLayout
, Private
->CurrentLayout
, LayoutLength
);
4415 for (Link
= Private
->DatabaseList
.ForwardLink
; Link
!= &Private
->DatabaseList
; Link
= Link
->ForwardLink
) {
4416 Node
= CR (Link
, HII_DATABASE_RECORD
, DatabaseEntry
, HII_DATABASE_RECORD_SIGNATURE
);
4417 PackageList
= (HII_DATABASE_PACKAGE_LIST_INSTANCE
*) (Node
->PackageList
);
4418 for (Link1
= PackageList
->KeyboardLayoutHdr
.ForwardLink
;
4419 Link1
!= &PackageList
->KeyboardLayoutHdr
;
4420 Link1
= Link1
->ForwardLink
4424 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE
,
4426 HII_KB_LAYOUT_PACKAGE_SIGNATURE
4429 Layout
= (UINT8
*) Package
->KeyboardPkg
+
4430 sizeof (EFI_HII_PACKAGE_HEADER
) + sizeof (UINT16
);
4431 CopyMem (&LayoutCount
, Layout
- sizeof (UINT16
), sizeof (UINT16
));
4432 for (Index
= 0; Index
< LayoutCount
; Index
++) {
4433 CopyMem (&LayoutLength
, Layout
, sizeof (UINT16
));
4434 if (CompareMem (Layout
+ sizeof (UINT16
), KeyGuid
, sizeof (EFI_GUID
)) == 0) {
4435 if (LayoutLength
<= *KeyboardLayoutLength
) {
4436 CopyMem (KeyboardLayout
, Layout
, LayoutLength
);
4439 *KeyboardLayoutLength
= LayoutLength
;
4440 return EFI_BUFFER_TOO_SMALL
;
4443 Layout
= Layout
+ LayoutLength
;
4448 return EFI_NOT_FOUND
;
4453 This routine sets the default keyboard layout to the one referenced by KeyGuid. When this routine
4454 is called, an event will be signaled of the EFI_HII_SET_KEYBOARD_LAYOUT_EVENT_GUID
4455 group type. This is so that agents which are sensitive to the current keyboard layout being changed
4456 can be notified of this change.
4458 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
4460 @param KeyGuid A pointer to the unique ID associated with a given
4463 @retval EFI_SUCCESS The current keyboard layout was successfully set.
4464 @retval EFI_NOT_FOUND The referenced keyboard layout was not found, so
4466 @retval EFI_INVALID_PARAMETER The KeyGuid was NULL.
4471 HiiSetKeyboardLayout (
4472 IN CONST EFI_HII_DATABASE_PROTOCOL
*This
,
4473 IN CONST EFI_GUID
*KeyGuid
4476 HII_DATABASE_PRIVATE_DATA
*Private
;
4477 EFI_HII_KEYBOARD_LAYOUT
*KeyboardLayout
;
4478 UINT16 KeyboardLayoutLength
;
4481 if (This
== NULL
|| KeyGuid
== NULL
) {
4482 return EFI_INVALID_PARAMETER
;
4485 Private
= HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This
);
4488 // The specified GUID equals the current keyboard layout GUID,
4491 if (CompareGuid (&Private
->CurrentLayoutGuid
, KeyGuid
)) {
4496 // Try to find the incoming keyboard layout data in current database.
4498 KeyboardLayoutLength
= 0;
4499 KeyboardLayout
= NULL
;
4500 Status
= HiiGetKeyboardLayout (This
, KeyGuid
, &KeyboardLayoutLength
, KeyboardLayout
);
4501 if (Status
!= EFI_BUFFER_TOO_SMALL
) {
4505 KeyboardLayout
= (EFI_HII_KEYBOARD_LAYOUT
*) AllocateZeroPool (KeyboardLayoutLength
);
4506 ASSERT (KeyboardLayout
!= NULL
);
4507 Status
= HiiGetKeyboardLayout (This
, KeyGuid
, &KeyboardLayoutLength
, KeyboardLayout
);
4508 ASSERT_EFI_ERROR (Status
);
4511 // Backup current keyboard layout.
4513 CopyMem (&Private
->CurrentLayoutGuid
, KeyGuid
, sizeof (EFI_GUID
));
4514 if (Private
->CurrentLayout
!= NULL
) {
4515 FreePool(Private
->CurrentLayout
);
4517 Private
->CurrentLayout
= KeyboardLayout
;
4520 // Signal EFI_HII_SET_KEYBOARD_LAYOUT_EVENT_GUID group to notify
4521 // current keyboard layout is changed.
4523 Status
= gBS
->SignalEvent (gHiiKeyboardLayoutChanged
);
4524 ASSERT_EFI_ERROR (Status
);
4531 Return the EFI handle associated with a package list.
4533 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
4535 @param PackageListHandle An EFI_HII_HANDLE that corresponds to the desired
4536 package list in the HIIdatabase.
4537 @param DriverHandle On return, contains the EFI_HANDLE which was
4538 registered with the package list in
4541 @retval EFI_SUCCESS The DriverHandle was returned successfully.
4542 @retval EFI_INVALID_PARAMETER The PackageListHandle was not valid or
4543 DriverHandle was NULL.
4544 @retval EFI_NOT_FOUND This PackageList handle can not be found in
4550 HiiGetPackageListHandle (
4551 IN CONST EFI_HII_DATABASE_PROTOCOL
*This
,
4552 IN EFI_HII_HANDLE PackageListHandle
,
4553 OUT EFI_HANDLE
*DriverHandle
4556 HII_DATABASE_PRIVATE_DATA
*Private
;
4557 HII_DATABASE_RECORD
*Node
;
4560 if (This
== NULL
|| DriverHandle
== NULL
) {
4561 return EFI_INVALID_PARAMETER
;
4564 if (!IsHiiHandleValid (PackageListHandle
)) {
4565 return EFI_INVALID_PARAMETER
;
4568 Private
= HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This
);
4570 for (Link
= Private
->DatabaseList
.ForwardLink
; Link
!= &Private
->DatabaseList
; Link
= Link
->ForwardLink
) {
4571 Node
= CR (Link
, HII_DATABASE_RECORD
, DatabaseEntry
, HII_DATABASE_RECORD_SIGNATURE
);
4572 if (Node
->Handle
== PackageListHandle
) {
4573 *DriverHandle
= Node
->DriverHandle
;
4578 return EFI_NOT_FOUND
;