2 HII Library implementation that uses DXE protocols and services.
4 Copyright (c) 2006 - 2008, Intel Corporation<BR>
5 All rights reserved. This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
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.
15 #include "InternalHiiLib.h"
18 // <ConfigHdr> Template
20 GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR16 mConfigHdrTemplate
[] = L
"GUID=00000000000000000000000000000000&NAME=0000&PATH=00";
23 // Form Browser2 Protocol
25 EFI_FORM_BROWSER2_PROTOCOL
*mUefiFormBrowser2
= NULL
;
28 This funciton build the package list based on the package number,
29 the GUID of the package list and the list of pointer which point to
30 package header that defined by UEFI VFR compiler and StringGather
33 #pragma pack (push, 1)
36 EFI_HII_PACKAGE_HEADER PackageHeader;
37 } EDKII_AUTOGEN_PACKAGES_HEADER;
40 If there is not enough resource for the new package list,
41 the function will ASSERT.
43 @param NumberOfPackages The number of packages be
44 @param GuidId The GUID for the package list to be generated.
45 @param Marker The variable argument list. Each entry represent a specific package header that is
46 generated by VFR compiler and StrGather tool. The first 4 bytes is a UINT32 value
47 that indicate the overall length of the package.
49 @return The pointer to the package list header.
52 EFI_HII_PACKAGE_LIST_HEADER
*
53 InternalHiiLibPreparePackages (
54 IN UINTN NumberOfPackages
,
55 IN CONST EFI_GUID
*GuidId
,
59 EFI_HII_PACKAGE_LIST_HEADER
*PackageListHeader
;
60 UINT8
*PackageListData
;
61 UINT32 PackageListLength
;
63 EFI_HII_PACKAGE_HEADER PackageHeader
;
68 PackageListLength
= sizeof (EFI_HII_PACKAGE_LIST_HEADER
);
70 MarkerBackup
= Marker
;
73 // Count the length of the final package list.
75 for (Index
= 0; Index
< NumberOfPackages
; Index
++) {
76 CopyMem (&PackageLength
, VA_ARG (Marker
, VOID
*), sizeof (UINT32
));
78 // Do not count the BinaryLength field.
80 PackageListLength
+= (PackageLength
- sizeof (UINT32
));
84 // Include the length of EFI_HII_PACKAGE_END
86 PackageListLength
+= sizeof (EFI_HII_PACKAGE_HEADER
);
87 PackageListHeader
= AllocateZeroPool (PackageListLength
);
88 ASSERT (PackageListHeader
!= NULL
);
90 CopyGuid (&PackageListHeader
->PackageListGuid
, GuidId
);
91 PackageListHeader
->PackageLength
= PackageListLength
;
93 PackageListData
= ((UINT8
*) PackageListHeader
) + sizeof (EFI_HII_PACKAGE_LIST_HEADER
);
95 Marker
= MarkerBackup
;
97 // Prepare the final package list.
99 for (Index
= 0; Index
< NumberOfPackages
; Index
++) {
100 PackageArray
= (UINT8
*) VA_ARG (Marker
, VOID
*);
102 // CopyMem is used for UINT32 to cover the unaligned address access.
104 CopyMem (&PackageLength
, PackageArray
, sizeof (UINT32
));
105 PackageLength
-= sizeof (UINT32
);
106 PackageArray
+= sizeof (UINT32
);
107 CopyMem (PackageListData
, PackageArray
, PackageLength
);
108 PackageListData
+= PackageLength
;
112 // Append EFI_HII_PACKAGE_END
114 PackageHeader
.Type
= EFI_HII_PACKAGE_END
;
115 PackageHeader
.Length
= sizeof (EFI_HII_PACKAGE_HEADER
);
116 CopyMem (PackageListData
, &PackageHeader
, PackageHeader
.Length
);
118 return PackageListHeader
;
122 Assemble EFI_HII_PACKAGE_LIST according to the passed in packages.
124 If GuidId is NULL, then ASSERT.
125 If not enough resource to complete the operation, then ASSERT.
127 @param NumberOfPackages Number of packages.
128 @param GuidId Package GUID.
129 @param ... Variable argument list for packages to be assembled.
131 @return Pointer of EFI_HII_PACKAGE_LIST_HEADER.
134 EFI_HII_PACKAGE_LIST_HEADER
*
136 HiiLibPreparePackageList (
137 IN UINTN NumberOfPackages
,
138 IN CONST EFI_GUID
*GuidId
,
142 EFI_HII_PACKAGE_LIST_HEADER
*PackageListHeader
;
145 ASSERT (GuidId
!= NULL
);
147 VA_START (Marker
, GuidId
);
148 PackageListHeader
= InternalHiiLibPreparePackages (NumberOfPackages
, GuidId
, Marker
);
151 return PackageListHeader
;
156 This function allocates pool for an EFI_HII_PACKAGE_LIST structure
157 with additional space that is big enough to host all packages described by the variable
158 argument list of package pointers. The allocated structure is initialized using NumberOfPackages,
159 GuidId, and the variable length argument list of package pointers.
161 Then, EFI_HII_PACKAGE_LIST will be register to the default System HII Database. The
162 Handle to the newly registered Package List is returned through HiiHandle.
164 If HiiHandle is NULL, then ASSERT.
166 @param NumberOfPackages The number of HII packages to register.
167 @param GuidId Package List GUID ID.
168 @param DriverHandle Optional. If not NULL, the DriverHandle on which an instance of DEVICE_PATH_PROTOCOL is installed.
169 This DriverHandle uniquely defines the device that the added packages are associated with.
170 @param HiiHandle On output, the HiiHandle is update with the handle which can be used to retrieve the Package
171 List later. If the functions failed to add the package to the default HII database, this value will
173 @param ... The variable argument list describing all HII Package.
175 @return EFI_SUCCESS If the packages are successfully added to the default HII database.
176 @return EFI_OUT_OF_RESOURCE Not enough resource to complete the operation.
182 IN UINTN NumberOfPackages
,
183 IN CONST EFI_GUID
*GuidId
,
184 IN EFI_HANDLE DriverHandle
, OPTIONAL
185 OUT EFI_HII_HANDLE
*HiiHandle
,
190 EFI_HII_PACKAGE_LIST_HEADER
*PackageListHeader
;
193 ASSERT (HiiHandle
!= NULL
);
195 VA_START (Args
, HiiHandle
);
196 PackageListHeader
= InternalHiiLibPreparePackages (NumberOfPackages
, GuidId
, Args
);
198 Status
= gHiiDatabase
->NewPackageList (gHiiDatabase
, PackageListHeader
, DriverHandle
, HiiHandle
);
199 if (HiiHandle
!= NULL
) {
200 if (EFI_ERROR (Status
)) {
205 FreePool (PackageListHeader
);
212 Removes a package list from the default HII database.
214 If HiiHandle is NULL, then ASSERT.
215 If HiiHandle is not a valid EFI_HII_HANDLE in the default HII database, then ASSERT.
217 @param HiiHandle The handle that was previously registered to the data base that is requested for removal.
223 HiiLibRemovePackages (
224 IN EFI_HII_HANDLE HiiHandle
228 ASSERT (IsHiiHandleRegistered (HiiHandle
));
230 Status
= gHiiDatabase
->RemovePackageList (gHiiDatabase
, HiiHandle
);
231 ASSERT_EFI_ERROR (Status
);
236 Determines the handles that are currently active in the database.
237 It's the caller's responsibility to free handle buffer.
239 If HandleBufferLength is NULL, then ASSERT.
240 If HiiHandleBuffer is NULL, then ASSERT.
242 @param HandleBufferLength On input, a pointer to the length of the handle
243 buffer. On output, the length of the handle buffer
244 that is required for the handles found.
245 @param HiiHandleBuffer Pointer to an array of Hii Handles returned.
247 @retval EFI_SUCCESS Get an array of Hii Handles successfully.
252 HiiLibGetHiiHandles (
253 IN OUT UINTN
*HandleBufferLength
,
254 OUT EFI_HII_HANDLE
**HiiHandleBuffer
259 ASSERT (HandleBufferLength
!= NULL
);
260 ASSERT (HiiHandleBuffer
!= NULL
);
262 *HandleBufferLength
= 0;
263 *HiiHandleBuffer
= NULL
;
266 // Try to find the actual buffer size for HiiHandle Buffer.
268 Status
= gHiiDatabase
->ListPackageLists (
270 EFI_HII_PACKAGE_TYPE_ALL
,
276 if (Status
== EFI_BUFFER_TOO_SMALL
) {
277 *HiiHandleBuffer
= AllocateZeroPool (*HandleBufferLength
);
278 ASSERT (*HiiHandleBuffer
!= NULL
);
279 Status
= gHiiDatabase
->ListPackageLists (
281 EFI_HII_PACKAGE_TYPE_ALL
,
287 if (EFI_ERROR (Status
)) {
288 FreePool (*HiiHandleBuffer
);
289 *HiiHandleBuffer
= NULL
;
297 Extract Hii package list GUID for given HII handle.
299 If HiiHandle could not be found in the default HII database, then ASSERT.
300 If Guid is NULL, then ASSERT.
302 @param Handle Hii handle
303 @param Guid Package list GUID
305 @retval EFI_SUCCESS Successfully extract GUID from Hii database.
310 HiiLibExtractGuidFromHiiHandle (
311 IN EFI_HII_HANDLE Handle
,
317 EFI_HII_PACKAGE_LIST_HEADER
*HiiPackageList
;
319 ASSERT (Guid
!= NULL
);
320 ASSERT (IsHiiHandleRegistered (Handle
));
323 // Get HII PackageList
326 HiiPackageList
= NULL
;
328 Status
= gHiiDatabase
->ExportPackageLists (gHiiDatabase
, Handle
, &BufferSize
, HiiPackageList
);
329 ASSERT (Status
!= EFI_NOT_FOUND
);
331 if (Status
== EFI_BUFFER_TOO_SMALL
) {
332 HiiPackageList
= AllocatePool (BufferSize
);
333 ASSERT (HiiPackageList
!= NULL
);
335 Status
= gHiiDatabase
->ExportPackageLists (gHiiDatabase
, Handle
, &BufferSize
, HiiPackageList
);
337 if (EFI_ERROR (Status
)) {
338 FreePool (HiiPackageList
);
345 CopyGuid (Guid
, &HiiPackageList
->PackageListGuid
);
347 FreePool (HiiPackageList
);
353 Find HII Handle in the default HII database associated with given Device Path.
355 If DevicePath is NULL, then ASSERT.
357 @param DevicePath Device Path associated with the HII package list
360 @retval Handle HII package list Handle associated with the Device
362 @retval NULL Hii Package list handle is not found.
367 HiiLibDevicePathToHiiHandle (
368 IN EFI_DEVICE_PATH_PROTOCOL
*DevicePath
372 EFI_DEVICE_PATH_PROTOCOL
*TmpDevicePath
;
379 EFI_HANDLE DriverHandle
;
380 EFI_HII_HANDLE
*HiiHandles
;
381 EFI_HII_HANDLE HiiHandle
;
383 ASSERT (DevicePath
!= NULL
);
386 // Locate Device Path Protocol handle buffer
388 Status
= gBS
->LocateHandleBuffer (
390 &gEfiDevicePathProtocolGuid
,
395 if (EFI_ERROR (Status
)) {
400 // Search Driver Handle by Device Path
403 BufferSize
= GetDevicePathSize (DevicePath
);
404 for(Index
= 0; Index
< HandleCount
; Index
++) {
405 Handle
= Handles
[Index
];
406 gBS
->HandleProtocol (Handle
, &gEfiDevicePathProtocolGuid
, (VOID
**) &TmpDevicePath
);
409 // Check whether DevicePath match
411 Size
= GetDevicePathSize (TmpDevicePath
);
412 if ((Size
== BufferSize
) && CompareMem (DevicePath
, TmpDevicePath
, Size
) == 0) {
413 DriverHandle
= Handle
;
419 if (DriverHandle
== NULL
) {
424 // Retrieve all Hii Handles from HII database
427 HiiHandles
= AllocatePool (BufferSize
);
428 ASSERT (HiiHandles
!= NULL
);
429 Status
= gHiiDatabase
->ListPackageLists (
431 EFI_HII_PACKAGE_TYPE_ALL
,
436 if (Status
== EFI_BUFFER_TOO_SMALL
) {
437 FreePool (HiiHandles
);
438 HiiHandles
= AllocatePool (BufferSize
);
439 ASSERT (HiiHandles
!= NULL
);
441 Status
= gHiiDatabase
->ListPackageLists (
443 EFI_HII_PACKAGE_TYPE_ALL
,
450 if (EFI_ERROR (Status
)) {
451 FreePool (HiiHandles
);
456 // Search Hii Handle by Driver Handle
459 HandleCount
= BufferSize
/ sizeof (EFI_HII_HANDLE
);
460 for (Index
= 0; Index
< HandleCount
; Index
++) {
461 Status
= gHiiDatabase
->GetPackageListHandle (
466 if (!EFI_ERROR (Status
) && (Handle
== DriverHandle
)) {
467 HiiHandle
= HiiHandles
[Index
];
472 FreePool (HiiHandles
);
477 Exports the contents of one or all package lists in the HII database into a buffer.
479 If Handle is not NULL and not a valid EFI_HII_HANDLE registered in the database,
481 If PackageListHeader is NULL, then ASSERT.
482 If PackageListSize is NULL, then ASSERT.
484 @param Handle The HII Handle.
485 @param PackageListHeader A pointer to a buffer that will contain the results of
487 @param PackageListSize On output, the length of the buffer that is required for the exported data.
489 @retval EFI_SUCCESS Package exported.
491 @retval EFI_OUT_OF_RESOURCES Not enought memory to complete the operations.
496 HiiLibExportPackageLists (
497 IN EFI_HII_HANDLE Handle
,
498 OUT EFI_HII_PACKAGE_LIST_HEADER
**PackageListHeader
,
499 OUT UINTN
*PackageListSize
504 EFI_HII_PACKAGE_LIST_HEADER
*PackageListHdr
;
506 ASSERT (PackageListSize
!= NULL
);
507 ASSERT (PackageListHeader
!= NULL
);
509 if (Handle
!= NULL
) {
510 ASSERT (IsHiiHandleRegistered (Handle
));
514 PackageListHdr
= NULL
;
515 Status
= gHiiDatabase
->ExportPackageLists (
521 ASSERT_EFI_ERROR (Status
!= EFI_BUFFER_TOO_SMALL
);
523 if (Status
== EFI_BUFFER_TOO_SMALL
) {
524 PackageListHdr
= AllocateZeroPool (Size
);
526 if (PackageListHeader
== NULL
) {
527 return EFI_OUT_OF_RESOURCES
;
529 Status
= gHiiDatabase
->ExportPackageLists (
538 if (!EFI_ERROR (Status
)) {
539 *PackageListHeader
= PackageListHdr
;
540 *PackageListSize
= Size
;
542 FreePool (PackageListHdr
);
550 This function returns a list of the package handles of the
551 specified type that are currently active in the HII database. The
552 pseudo-type EFI_HII_PACKAGE_TYPE_ALL will cause all package
553 handles to be listed.
555 If HandleBufferLength is NULL, then ASSERT.
556 If HandleBuffer is NULL, the ASSERT.
557 If PackageType is EFI_HII_PACKAGE_TYPE_GUID and PackageGuid is
559 If PackageType is not EFI_HII_PACKAGE_TYPE_GUID and PackageGuid is not
563 @param PackageType Specifies the package type of the packages
564 to list or EFI_HII_PACKAGE_TYPE_ALL for
565 all packages to be listed.
567 @param PackageGuid If PackageType is
568 EFI_HII_PACKAGE_TYPE_GUID, then this is
569 the pointer to the GUID which must match
571 EFI_HII_PACKAGE_GUID_HEADER. Otherwise, it
574 @param HandleBufferLength On output, the length of the handle buffer
575 that is required for the handles found.
577 @param HandleBuffer On output, an array of EFI_HII_HANDLE instances returned.
578 The caller is responcible to free this pointer allocated.
580 @retval EFI_SUCCESS The matching handles are outputed successfully.
581 HandleBufferLength is updated with the actual length.
582 @retval EFI_OUT_OF_RESOURCES Not enough resource to complete the operation.
583 @retval EFI_NOT_FOUND No matching handle could not be found in database.
587 HiiLibListPackageLists (
588 IN UINT8 PackageType
,
589 IN CONST EFI_GUID
*PackageGuid
,
590 IN OUT UINTN
*HandleBufferLength
,
591 OUT EFI_HII_HANDLE
**HandleBuffer
596 ASSERT (HandleBufferLength
!= NULL
);
597 ASSERT (HandleBuffer
!= NULL
);
599 *HandleBufferLength
= 0;
600 *HandleBuffer
= NULL
;
602 if (PackageType
== EFI_HII_PACKAGE_TYPE_GUID
) {
603 ASSERT (PackageGuid
!= NULL
);
605 ASSERT (PackageGuid
== NULL
);
608 Status
= gHiiDatabase
->ListPackageLists (
615 if (EFI_ERROR (Status
) && (Status
!= EFI_BUFFER_TOO_SMALL
)) {
617 // No packages is registered to UEFI HII Database, just return.
623 *HandleBuffer
= AllocateZeroPool (*HandleBufferLength
);
625 if (*HandleBuffer
== NULL
) {
626 return EFI_OUT_OF_RESOURCES
;
629 return gHiiDatabase
->ListPackageLists (
639 This function check if the Hii Handle is a valid handle registered
642 @param HiiHandle The HII Handle.
644 @retval TRUE If it is a valid HII handle.
645 @retval FALSE If it is a invalid HII handle.
648 IsHiiHandleRegistered (
649 EFI_HII_HANDLE HiiHandle
654 EFI_HII_PACKAGE_LIST_HEADER
*HiiPackageList
;
656 ASSERT (HiiHandle
!= NULL
);
658 HiiPackageList
= NULL
;
661 Status
= gHiiDatabase
->ExportPackageLists (
668 return (BOOLEAN
) (Status
== EFI_BUFFER_TOO_SMALL
);
673 Converts all hex dtring characters in range ['A'..'F'] to ['a'..'f'] for
674 hex digits that appear between a '=' and a '&' in a config string.
676 If String is NULL, then ASSERT().
678 @param[in] String Pointer to a Null-terminated Unicode string.
680 @return Pointer to the Null-terminated Unicode result string.
685 InternalHiiLowerConfigString (
686 IN EFI_STRING ConfigString
692 ASSERT (ConfigString
!= NULL
);
695 // Convert all hex digits in range [A-F] in the configuration header to [a-f]
697 for (String
= ConfigString
, Lower
= FALSE
; *String
!= L
'\0'; String
++) {
698 if (*String
== L
'=') {
700 } else if (*String
== L
'&') {
702 } else if (Lower
&& *String
> L
'A' && *String
<= L
'F') {
703 *String
= (CHAR16
) (*String
- L
'A' + L
'a');
711 Uses the BlockToConfig() service of the Config Routing Protocol to
712 convert <ConfigRequest> and a buffer to a <ConfigResp>
714 If ConfigRequest is NULL, then ASSERT().
715 If Block is NULL, then ASSERT().
717 @param[in] ConfigRequest Pointer to a Null-terminated Unicode string.
718 @param[in] Block Pointer to a block of data.
719 @param[in] BlockSize The zie, in bytes, of Block.
721 @retval NULL The <ConfigResp> string could not be generated.
722 @retval Other Pointer to the Null-terminated Unicode <ConfigResp> string.
727 InternalHiiBlockToConfig (
728 IN CONST EFI_STRING ConfigRequest
,
729 IN CONST UINT8
*Block
,
734 EFI_STRING ConfigResp
;
737 ASSERT (ConfigRequest
!= NULL
);
738 ASSERT (Block
!= NULL
);
741 // Convert <ConfigRequest> to <ConfigResp>
743 Status
= gHiiConfigRouting
->BlockToConfig (
751 if (EFI_ERROR (Status
)) {
758 Uses the ConfigToBlock() service of the Config Routing Protocol to
759 convert <ConfigResp> to a block. The block is allocated using
760 AllocatePool(). The caller is responsible for freeing the block
763 If ConfigResp is NULL, then ASSERT().
765 @param[in] ConfigResp Pointer to a Null-terminated Unicode string.
766 @param[in] BufferSize Length in bytes of buffer to hold retrived data.
768 @retval NULL The block could not be generated..
769 @retval Other Pointer to the allocated block.
774 InternalHiiConfigToBlock (
775 IN EFI_STRING ConfigResp
,
783 ASSERT (ConfigResp
!= NULL
);
786 // Allocate a buffer to hold the <ConfigResp> conversion
788 Block
= AllocateZeroPool (BlockSize
);
794 // Convert <ConfigResp> to a buffer
796 Status
= gHiiConfigRouting
->ConfigToBlock (
803 if (EFI_ERROR (Status
)) {
809 // Return converted buffer
815 Uses the BrowserCallback() service of the Form Browser Protocol to retrieve
816 or set uncommitted data. If sata i being retrieved, then the buffer is
817 allocated using AllocatePool(). The caller is then responsible for freeing
818 the buffer using FreePool().
820 @param[in] VariableName Pointer to a Null-terminated Unicode string. This
821 is an optional parameter that may be NULL.
822 @param[in] VariableGuid Pointer to an EFI_GUID structure. This is an optional
823 parameter that may be NULL.
824 @param[in] SetResultsData If not NULL, then this parameter specified the buffer
825 of uncommited data to set. If this parameter is NULL,
826 then the caller is requesting to get the uncommited data
827 from the Form Browser.
829 @retval NULL The uncommitted data could not be retrieved.
830 @retval Other A pointer to a buffer containing the uncommitted data.
835 InternalHiiBrowserCallback (
836 IN CONST EFI_GUID
*VariableGuid
, OPTIONAL
837 IN CONST CHAR16
*VariableName
, OPTIONAL
838 IN CONST EFI_STRING SetResultsData OPTIONAL
842 UINTN ResultsDataSize
;
843 EFI_STRING ResultsData
;
844 CHAR16 TempResultsData
;
849 if (mUefiFormBrowser2
== NULL
) {
850 Status
= gBS
->LocateProtocol (&gEfiFormBrowser2ProtocolGuid
, NULL
, (VOID
**) &mUefiFormBrowser2
);
851 if (EFI_ERROR (Status
) || mUefiFormBrowser2
== NULL
) {
858 if (SetResultsData
!= NULL
) {
860 // Request to to set data in the uncommitted browser state information
862 ResultsData
= SetResultsData
;
865 // Retrieve the length of the buffer required ResultsData from the Browser Callback
867 Status
= mUefiFormBrowser2
->BrowserCallback (
875 if (Status
!= EFI_BUFFER_TOO_SMALL
) {
880 // Allocate the ResultsData buffer
882 ResultsData
= AllocateZeroPool (ResultsDataSize
);
883 if (ResultsData
== NULL
) {
889 // Retrieve or set the ResultsData from the Browser Callback
891 Status
= mUefiFormBrowser2
->BrowserCallback (
895 (BOOLEAN
)(SetResultsData
== NULL
),
899 if (EFI_ERROR (Status
)) {
907 Allocates and returns a Null-terminated Unicode <ConfigHdr> string using routing
908 information that includes a GUID, an optional Unicode string name, and a device
909 path. The string returned is allocated with AllocatePool(). The caller is
910 responsible for freeing the allocated string with FreePool().
912 The format of a <ConfigHdr> is as follows:
914 GUID=<HexCh>32&NAME=<Char>NameLength&PATH=<HexChar>DevicePathSize<Null>
916 @param[in] Guid Pointer to an EFI_GUID that is the routing information
917 GUID. Each of the 16 bytes in Guid is converted to
918 a 2 Unicode character hexidecimal string. This is
919 an optional parameter that may be NULL.
920 @param[in] Name Pointer to a Null-terminated Unicode string that is
921 the routing information NAME. This is an optional
922 parameter that may be NULL. Each 16-bit Unicode
923 character in Name is converted to a 4 character Unicode
925 @param[in] DriverHandle The driver handle which supports a Device Path Protocol
926 that is the routing information PATH. Each byte of
927 the Device Path associated with DriverHandle is converted
928 to a 2 Unicode character hexidecimal string.
930 @retval NULL DriverHandle does not support the Device Path Protocol.
931 @retval NULL DriverHandle does not support the Device Path Protocol.
932 @retval Other A pointer to the Null-terminate Unicode <ConfigHdr> string
937 HiiConstructConfigHdr (
938 IN CONST EFI_GUID
*Guid
, OPTIONAL
939 IN CONST CHAR16
*Name
, OPTIONAL
940 IN EFI_HANDLE DriverHandle
944 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
945 UINTN DevicePathSize
;
947 CHAR16
*ReturnString
;
952 // Compute the length of Name in Unicode characters.
953 // If Name is NULL, then the length is 0.
957 NameLength
= StrLen (Name
);
961 // Retrieve DevicePath Protocol associated with DriverHandle
963 DevicePath
= DevicePathFromHandle (DriverHandle
);
964 if (DevicePath
== NULL
) {
969 // Compute the size of the device path in bytes
971 DevicePathSize
= GetDevicePathSize (DevicePath
);
974 // GUID=<HexCh>32&NAME=<Char>NameLength&PATH=<HexChar>DevicePathSize <Null>
975 // | 5 | sizeof (EFI_GUID) * 2 | 6 | NameStrLen*4 | 6 | DevicePathSize * 2 | 1 |
977 String
= AllocateZeroPool ((5 + sizeof (EFI_GUID
) * 2 + 6 + NameLength
* 4 + 6 + DevicePathSize
* 2 + 1) * sizeof (CHAR16
));
978 if (String
== NULL
) {
983 // Start with L"GUID="
985 ReturnString
= StrCpy (String
, L
"GUID=");
986 String
+= StrLen (String
);
990 // Append Guid converted to <HexCh>32
992 for (Index
= 0, Buffer
= (UINT8
*)Guid
; Index
< sizeof (EFI_GUID
); Index
++) {
993 String
+= UnicodeValueToString (String
, PREFIX_ZERO
| RADIX_HEX
, *(Buffer
++), 2);
1000 StrCpy (String
, L
"&NAME=");
1001 String
+= StrLen (String
);
1005 // Append Name converted to <Char>NameLength
1007 for (; *Name
!= L
'\0'; Name
++) {
1008 String
+= UnicodeValueToString (String
, PREFIX_ZERO
| RADIX_HEX
, *Name
, 4);
1015 StrCpy (String
, L
"&PATH=");
1016 String
+= StrLen (String
);
1019 // Append the device path associated with DriverHandle converted to <HexChar>DevicePathSize
1021 for (Index
= 0, Buffer
= (UINT8
*)DevicePath
; Index
< DevicePathSize
; Index
++) {
1022 String
+= UnicodeValueToString (String
, PREFIX_ZERO
| RADIX_HEX
, *(Buffer
++), 2);
1026 // Null terminate the Unicode string
1031 // Convert all hex digits in range [A-F] in the configuration header to [a-f]
1033 return InternalHiiLowerConfigString (ReturnString
);
1037 Allocates and returns a Null-terminated Unicode <ConfigAltResp> string.
1039 If Guid is NULL, then ASSERT().
1040 If Name is NULL, then ASSERT().
1041 If BlockNameArray is NULL, then ASSERT().
1043 @param[in] Guid GUID of the buffer storage.
1044 @param[in] Name Name of the buffer storage.
1045 @param[in] DriverHandle The DriverHandle that support a Device Path
1047 @param[in] BufferStorage Content of the buffer storage.
1048 @param[in] BufferStorageSize Length in bytes of the buffer storage.
1049 @param[in] BlockNameArray Array generated by VFR compiler. This array
1050 contains a UINT32 value that is the length
1051 of BlockNameArray in bytes, followed by pairs
1052 of 16-bit values that are the offset and length
1053 values used to contruct a <ConfigRequest> string.
1054 @param[in] ... A variable argument list that contains pairs of 16-bit
1055 ALTCFG identifiers and pointers to DefaultValueArrays.
1056 The variable argument list is terminated by a NULL
1057 DefaultValueArray pointer. A DefaultValueArray
1058 contains a UINT32 value that is the length, in bytes,
1059 of the DefaultValueArray. The UINT32 length value
1060 is followed by a series of records that contain
1061 a 16-bit WIDTH value followed by a byte array with
1062 WIDTH entries. The records must be parsed from
1063 beginning to end until the UINT32 length limit
1066 @retval NULL There are not enough resources to process the request.
1067 @retval NULL A <ConfigResp> could not be retrieved from the Config
1069 @retval Other A pointer to the Null-terminate Unicode <ConfigAltResp>
1075 HiiConstructConfigAltResp (
1076 IN CONST EFI_GUID
*Guid
,
1077 IN CONST CHAR16
*Name
,
1078 IN EFI_HANDLE DriverHandle
,
1079 IN CONST VOID
*BufferStorage
,
1080 IN UINTN BufferStorageSize
,
1081 IN CONST VOID
*BlockNameArray
,
1090 CHAR16
*ConfigRequest
;
1091 EFI_STRING ConfigResp
;
1092 EFI_STRING ConfigAltResp
;
1099 ASSERT (Guid
!= NULL
);
1100 ASSERT (Name
!= NULL
);
1101 ASSERT (BlockNameArray
!= NULL
);
1104 // Initialize local variables
1107 ConfigRequest
= NULL
;
1111 // Construct <ConfigHdr> : "GUID=...&NAME=...&PATH=..."
1113 ConfigHdr
= HiiConstructConfigHdr (Guid
, Name
, DriverHandle
);
1114 if (ConfigHdr
== NULL
) {
1119 // Compute the length of the entire request starting with <ConfigHdr> and a
1122 Length
= StrLen (ConfigHdr
) + 1;
1125 // Determine the size <BlockName> Offset/Width pairs
1127 Buffer
= (UINT8
*)BlockNameArray
;
1128 BufferEnd
= Buffer
+ ReadUnaligned32 ((UINT32
*)Buffer
);
1129 Buffer
+= sizeof (UINT32
);
1132 // Add <BlockName> length that is composed of one or more Offset/Width pairs
1134 // <BlockName> ::= &OFFSET=1234&WIDTH=1234
1135 // | 8 | 4 | 7 | 4 |
1137 Length
+= (((BufferEnd
- Buffer
) / (sizeof (UINT16
) + sizeof (UINT16
))) * (8 + 4 + 7 + 4));
1140 // Allocate buffer for the entire <ConfigRequest>
1142 ConfigRequest
= AllocateZeroPool (Length
* sizeof (CHAR16
));
1143 if (ConfigRequest
== NULL
) {
1146 String
= ConfigRequest
;
1149 // Start with <ConfigHdr>
1151 StrCpy (String
, ConfigHdr
);
1152 String
+= StrLen (String
);
1155 // Loop through all the Offset/Width pairs and append them to ConfigRequest
1157 while (Buffer
< BufferEnd
) {
1159 // Append &OFFSET=XXXX&WIDTH=YYYY
1161 OffsetValue
= ReadUnaligned16 ((UINT16
*)Buffer
);
1162 WidthValue
= ReadUnaligned16 ((UINT16
*)(Buffer
+ sizeof (UINT16
)));
1165 (8 + 4 + 7 + 4) * sizeof (CHAR16
),
1166 L
"&OFFSET=%04X&WIDTH=%04X",
1171 String
+= StrLen (String
);
1172 Buffer
+= (sizeof (UINT16
) + sizeof (UINT16
));
1176 // Get the <ConfigResp>
1178 ConfigResp
= InternalHiiBlockToConfig (ConfigRequest
, BufferStorage
, BufferStorageSize
);
1179 if (ConfigResp
== NULL
) {
1184 // Compute the length of the entire response starting with <ConfigResp> and a
1187 Length
= StrLen (ConfigResp
) + 1;
1190 // Add the length associated with each pair of variable argument parameters
1192 VA_START (Args
, BlockNameArray
);
1194 AltCfgId
= VA_ARG (Args
, UINT16
);
1195 Buffer
= VA_ARG (Args
, UINT8
*);
1196 if (Buffer
== NULL
) {
1201 // Add length for "&<ConfigHdr>&ALTCFG=XXXX"
1202 // |1| StrLen (ConfigHdr) | 8 | 4 |
1204 Length
+= (1 + StrLen (ConfigHdr
) + 8 + 4);
1206 BufferEnd
= Buffer
+ ReadUnaligned32 ((UINT32
*)Buffer
);
1207 Buffer
+= sizeof (UINT32
);
1208 while (Buffer
< BufferEnd
) {
1210 // Extract Width field
1212 Width
= ReadUnaligned16 ((UINT16
*)(Buffer
+ sizeof (UINT16
)));
1215 // Add length for "&OFFSET=XXXX&WIDTH=YYYY&VALUE=zzzzzzzzzzzz"
1216 // | 8 | 4 | 7 | 4 | 7 | Width * 2 |
1218 Length
+= (8 + 4 + 7 + 4 + 7 + Width
* 2);
1221 // Update Buffer to the next record
1223 Buffer
+= (sizeof (UINT16
) + sizeof (UINT16
) + Width
);
1229 // Allocate a buffer for the entire response
1231 ConfigAltResp
= AllocateZeroPool (Length
* sizeof (CHAR16
));
1232 if (ConfigAltResp
== NULL
) {
1235 String
= ConfigAltResp
;
1240 StrCpy (String
, ConfigResp
);
1241 String
+= StrLen (String
);
1244 // Add <AltResp> for each pair of variable argument parameters
1246 VA_START (Args
, BlockNameArray
);
1248 AltCfgId
= VA_ARG (Args
, UINT16
);
1249 Buffer
= VA_ARG (Args
, UINT8
*);
1250 if (Buffer
== NULL
) {
1255 // Add <AltConfigHdr> of the form "&<ConfigHdr>&ALTCFG=XXXX"
1256 // |1| StrLen (ConfigHdr) | 8 | 4 |
1260 (1 + StrLen (ConfigHdr
) + 8 + 4) * sizeof (CHAR16
),
1265 String
+= StrLen (String
);
1268 // Add <ConfigBody> ::= <ConfigElement>*
1270 BufferEnd
= Buffer
+ ReadUnaligned32 ((UINT32
*)Buffer
);
1271 Buffer
+= sizeof (UINT32
);
1272 while (Buffer
< BufferEnd
) {
1274 // Extract Width field
1276 Width
= ReadUnaligned16 ((UINT16
*)(Buffer
+ sizeof (UINT16
)));
1279 // Add <BlockConfig>
1283 (8 + 4 + 7 + 4 + 7 + Width
* 2) * sizeof (CHAR16
),
1284 L
"&OFFSET=%04X&WIDTH=%04X&VALUE=",
1285 ReadUnaligned16 ((UINT16
*)Buffer
),
1288 String
+= StrLen (String
);
1291 // Update Buffer to point to the value in the current record
1293 Buffer
+= (sizeof (UINT16
) + sizeof (UINT16
));
1296 // Convert Value to a hex string in "%x" format
1297 // NOTE: This is in the opposite byte that GUID and PATH use
1299 for (; Width
> 0; Width
--) {
1300 String
+= UnicodeValueToString (String
, PREFIX_ZERO
| RADIX_HEX
, Buffer
[Width
- 1], 2);
1303 // Update Buffer to the next record
1311 // Convert all hex digits in range [A-F] in the configuration header to [a-f]
1313 return InternalHiiLowerConfigString (ConfigAltResp
);
1316 if (ConfigHdr
!= NULL
) {
1317 FreePool (ConfigHdr
);
1319 if (ConfigRequest
!= NULL
) {
1320 FreePool (ConfigRequest
);
1322 if (ConfigResp
!= NULL
) {
1323 FreePool (ConfigResp
);
1330 Determines if two values in config strings match.
1332 Compares the substring between StartSearchString and StopSearchString in
1333 FirstString to the substring between StartSearchString and StopSearchString
1334 in SecondString. If the two substrings match, then TRUE is returned. If the
1335 two substrings do not match, then FALSE is returned.
1337 If FirstString is NULL, then ASSERT().
1338 If SecondString is NULL, then ASSERT().
1339 If StartSearchString is NULL, then ASSERT().
1340 If StopSearchString is NULL, then ASSERT().
1342 @param FirstString Pointer to the first Null-terminated Unicode string.
1343 @param SecondString Pointer to the second Null-terminated Unicode string.
1344 @param StartSearchString Pointer to the Null-terminated Unicode string that
1345 marks the start of the value string to compare.
1346 @param StopSearchString Pointer to the Null-terminated Unicode string that
1347 marks the end of the vakue string to compare.
1349 @retval FALSE StartSearchString is not present in FirstString.
1350 @retval FALSE StartSearchString is not present in SecondString.
1351 @retval FALSE StopSearchString is not present in FirstString.
1352 @retval FALSE StopSearchString is not present in SecondString.
1353 @retval FALSE The length of the substring in FirstString is not the
1354 same length as the substring in SecondString.
1355 @retval FALSE The value string in FirstString does not matche the
1356 value string in SecondString.
1357 @retval TRUE The value string in FirstString matches the value
1358 string in SecondString.
1363 InternalHiiCompareSubString (
1364 IN CHAR16
*FirstString
,
1365 IN CHAR16
*SecondString
,
1366 IN CHAR16
*StartSearchString
,
1367 IN CHAR16
*StopSearchString
1370 CHAR16
*EndFirstString
;
1371 CHAR16
*EndSecondString
;
1373 ASSERT (FirstString
!= NULL
);
1374 ASSERT (SecondString
!= NULL
);
1375 ASSERT (StartSearchString
!= NULL
);
1376 ASSERT (StopSearchString
!= NULL
);
1378 FirstString
= StrStr (FirstString
, StartSearchString
);
1379 if (FirstString
== NULL
) {
1383 SecondString
= StrStr (SecondString
, StartSearchString
);
1384 if (SecondString
== NULL
) {
1388 EndFirstString
= StrStr (FirstString
, StopSearchString
);
1389 if (EndFirstString
== NULL
) {
1393 EndSecondString
= StrStr (SecondString
, StopSearchString
);
1394 if (EndSecondString
== NULL
) {
1398 if ((EndFirstString
- FirstString
) != (EndSecondString
- SecondString
)) {
1402 return (BOOLEAN
)(StrnCmp (FirstString
, SecondString
, EndFirstString
- FirstString
) == 0);
1406 Determines if the routing data specified by GUID and NAME match a <ConfigHdr>.
1408 If ConfigHdr is NULL, then ASSERT().
1410 @param[in] ConfigHdr Either <ConfigRequest> or <ConfigResp>.
1411 @param[in] Guid GUID of the storage.
1412 @param[in] Name NAME of the storage.
1414 @retval TRUE Routing information matches <ConfigHdr>.
1415 @retval FALSE Routing information does not match <ConfigHdr>.
1420 HiiIsConfigHdrMatch (
1421 IN CONST EFI_STRING ConfigHdr
,
1422 IN CONST EFI_GUID
*Guid
, OPTIONAL
1423 IN CONST CHAR16
*Name OPTIONAL
1426 EFI_STRING CompareConfigHdr
;
1429 ASSERT (ConfigHdr
!= NULL
);
1432 // Use Guid and Name to generate a <ConfigHdr> string
1434 CompareConfigHdr
= HiiConstructConfigHdr (Guid
, Name
, NULL
);
1435 if (CompareConfigHdr
== NULL
) {
1442 // Compare GUID value strings
1444 Result
= InternalHiiCompareSubString (ConfigHdr
, CompareConfigHdr
, L
"GUID=", L
"&NAME=");
1447 if (Result
&& Name
!= NULL
) {
1449 // Compare NAME value strings
1451 Result
= InternalHiiCompareSubString (ConfigHdr
, CompareConfigHdr
, L
"&NAME=", L
"&PATH=");
1455 // Free the <ConfigHdr> string
1457 FreePool (CompareConfigHdr
);
1463 Retrieves uncommited data from the Form Browser and converts it to a binary
1464 buffer. The returned buffer is allocated using AllocatePool(). The caller
1465 is responsible for freeing the returned buffer using FreePool().
1467 @param[in] VariableName Pointer to a Null-terminated Unicode string. This
1468 is an optional parameter that may be NULL.
1469 @param[in] VariableGuid Pointer to an EFI_GUID structure. This is an optional
1470 parameter that may be NULL.
1471 @param[in] BufferSize Length in bytes of buffer to hold retrived data.
1473 @retval NULL The uncommitted data could not be retrieved.
1474 @retval Other A pointer to a buffer containing the uncommitted data.
1480 IN CONST EFI_GUID
*VariableGuid
, OPTIONAL
1481 IN CONST CHAR16
*VariableName
, OPTIONAL
1485 EFI_STRING ResultsData
;
1487 EFI_STRING ConfigResp
;
1491 // Retrieve the results data from the Browser Callback
1493 ResultsData
= InternalHiiBrowserCallback (VariableGuid
, VariableName
, NULL
);
1494 if (ResultsData
== NULL
) {
1499 // Construct <ConfigResp> mConfigHdrTemplate L'&' ResultsData L'\0'
1501 Size
= (StrLen (mConfigHdrTemplate
) + 1) * sizeof (CHAR16
);
1502 Size
= Size
+ (StrLen (ResultsData
) + 1) * sizeof (CHAR16
);
1503 ConfigResp
= AllocateZeroPool (Size
);
1504 UnicodeSPrint (ConfigResp
, Size
, L
"%s&%s", mConfigHdrTemplate
, ResultsData
);
1507 // Free the allocated buffer
1509 FreePool (ResultsData
);
1510 if (ConfigResp
== NULL
) {
1515 // Convert <ConfigResp> to a buffer
1517 Block
= InternalHiiConfigToBlock (ConfigResp
, BlockSize
);
1518 FreePool (ConfigResp
);
1524 Updates uncommitted data in the Form Browser.
1526 If Buffer is NULL, then ASSERT().
1528 @param[in] VariableName Pointer to a Null-terminated Unicode string. This
1529 is an optional parameter that may be NULL.
1530 @param[in] VariableGuid Pointer to an EFI_GUID structure. This is an optional
1531 parameter that may be NULL.
1532 @param[in] BufferSize Length, in bytes, of Buffer.
1533 @param[in] Buffer Buffer of data to commit.
1534 @param[in] RequestElement An optional field to specify which part of the
1535 buffer data will be send back to Browser. If NULL,
1536 the whole buffer of data will be committed to
1538 <RequestElement> ::= &OFFSET=<Number>&WIDTH=<Number>*
1540 @retval FALSE The uncommitted data could not be updated.
1541 @retval TRUE The uncommitted data was updated.
1547 IN CONST EFI_GUID
*VariableGuid
, OPTIONAL
1548 IN CONST CHAR16
*VariableName
, OPTIONAL
1549 IN UINTN BufferSize
,
1550 IN CONST UINT8
*Buffer
,
1551 IN CONST CHAR16
*RequestElement OPTIONAL
1555 EFI_STRING ConfigRequest
;
1556 EFI_STRING ConfigResp
;
1557 EFI_STRING ResultsData
;
1559 ASSERT (Buffer
!= NULL
);
1562 // Construct <ConfigRequest>
1564 if (RequestElement
== NULL
) {
1566 // Allocate and fill a buffer large enough to hold the <ConfigHdr> template
1567 // followed by "&OFFSET=0&WIDTH=WWWWWWWWWWWWWWWW" followed by a Null-terminator
1569 Size
= (StrLen (mConfigHdrTemplate
) + 32 + 1) * sizeof (CHAR16
);
1570 ConfigRequest
= AllocateZeroPool (Size
);
1571 UnicodeSPrint (ConfigRequest
, Size
, L
"%s&OFFSET=0&WIDTH=%016LX", mConfigHdrTemplate
, (UINT64
)BufferSize
);
1574 // Allocate and fill a buffer large enough to hold the <ConfigHdr> template
1575 // followed by <RequestElement> followed by a Null-terminator
1577 Size
= StrLen (mConfigHdrTemplate
) * sizeof (CHAR16
);
1578 Size
= Size
+ (StrLen (RequestElement
) + 1) * sizeof (CHAR16
);
1579 ConfigRequest
= AllocateZeroPool (Size
);
1580 UnicodeSPrint (ConfigRequest
, Size
, L
"%s%s", mConfigHdrTemplate
, RequestElement
);
1582 if (ConfigRequest
== NULL
) {
1587 // Convert <ConfigRequest> to <ConfigResp>
1589 ConfigResp
= InternalHiiBlockToConfig (ConfigRequest
, Buffer
, BufferSize
);
1590 FreePool (ConfigRequest
);
1591 if (ConfigResp
== NULL
) {
1596 // Set data in the uncommitted browser state information
1598 ResultsData
= InternalHiiBrowserCallback (VariableGuid
, VariableName
, ConfigResp
+ StrLen(mConfigHdrTemplate
) + 1);
1599 FreePool (ConfigResp
);
1601 return (BOOLEAN
)(ResultsData
!= NULL
);
1604 /////////////////////////////////////////
1605 /////////////////////////////////////////
1607 /////////////////////////////////////////
1608 /////////////////////////////////////////
1610 #define HII_LIB_OPCODE_ALLOCATION_SIZE 0x200
1616 } HII_LIB_OPCODE_BUFFER
;
1619 /// Lookup table that converts EFI_IFR_TYPE_X enum values to a width in bytes
1621 GLOBAL_REMOVE_IF_UNREFERENCED CONST UINT8 mHiiDefaultTypeToWidth
[] = {
1622 1, // EFI_IFR_TYPE_NUM_SIZE_8
1623 2, // EFI_IFR_TYPE_NUM_SIZE_16
1624 4, // EFI_IFR_TYPE_NUM_SIZE_32
1625 8, // EFI_IFR_TYPE_NUM_SIZE_64
1626 1, // EFI_IFR_TYPE_BOOLEAN
1627 3, // EFI_IFR_TYPE_TIME
1628 4, // EFI_IFR_TYPE_DATE
1629 2 // EFI_IFR_TYPE_STRING
1633 Allocates and returns a new OpCode Handle. OpCode Handles must be freed with
1634 HiiFreeOpCodeHandle().
1636 @retval NULL There are not enough resources to allocate a new OpCode Handle.
1637 @retval Other A new OpCode handle.
1642 HiiAllocateOpCodeHandle (
1646 HII_LIB_OPCODE_BUFFER
*OpCodeBuffer
;
1648 OpCodeBuffer
= (HII_LIB_OPCODE_BUFFER
*)AllocatePool (sizeof (HII_LIB_OPCODE_BUFFER
));
1649 if (OpCodeBuffer
== NULL
) {
1652 OpCodeBuffer
->Buffer
= (UINT8
*)AllocatePool (HII_LIB_OPCODE_ALLOCATION_SIZE
);
1653 if (OpCodeBuffer
->Buffer
== NULL
) {
1654 FreePool (OpCodeBuffer
);
1657 OpCodeBuffer
->BufferSize
= HII_LIB_OPCODE_ALLOCATION_SIZE
;
1658 OpCodeBuffer
->Position
= 0;
1659 return (VOID
*)OpCodeBuffer
;
1663 Frees an OpCode Handle that was peviously allocated with HiiAllocateOpCodeHandle().
1664 When an OpCode Handle is freed, all of the opcodes associated with the OpCode
1665 Handle are also freed.
1667 If OpCodeHandle is NULL, then ASSERT().
1672 HiiFreeOpCodeHandle (
1676 HII_LIB_OPCODE_BUFFER
*OpCodeBuffer
;
1678 ASSERT (OpCodeHandle
!= NULL
);
1680 OpCodeBuffer
= (HII_LIB_OPCODE_BUFFER
*)OpCodeHandle
;
1681 if (OpCodeBuffer
->Buffer
!= NULL
) {
1682 FreePool (OpCodeBuffer
->Buffer
);
1684 FreePool (OpCodeBuffer
);
1689 InternalHiiOpCodeHandlePosition (
1690 IN VOID
*OpCodeHandle
1693 return ((HII_LIB_OPCODE_BUFFER
*)OpCodeHandle
)->Position
;
1698 InternalHiiOpCodeHandleBuffer (
1699 IN VOID
*OpCodeHandle
1702 return ((HII_LIB_OPCODE_BUFFER
*)OpCodeHandle
)->Buffer
;
1707 InternalHiiGrowOpCodeHandle (
1712 HII_LIB_OPCODE_BUFFER
*OpCodeBuffer
;
1715 ASSERT (OpCodeHandle
!= NULL
);
1717 OpCodeBuffer
= (HII_LIB_OPCODE_BUFFER
*)OpCodeHandle
;
1718 if (OpCodeBuffer
->Position
+ Size
> OpCodeBuffer
->BufferSize
) {
1719 Buffer
= ReallocatePool (
1720 OpCodeBuffer
->BufferSize
,
1721 OpCodeBuffer
->BufferSize
+ (Size
+ HII_LIB_OPCODE_ALLOCATION_SIZE
),
1722 OpCodeBuffer
->Buffer
1724 if (Buffer
== NULL
) {
1727 OpCodeBuffer
->Buffer
= Buffer
;
1728 OpCodeBuffer
->BufferSize
+= (Size
+ HII_LIB_OPCODE_ALLOCATION_SIZE
);
1730 Buffer
= OpCodeBuffer
->Buffer
+ OpCodeBuffer
->Position
;
1731 OpCodeBuffer
->Position
+= Size
;
1737 InternalHiiCreateOpCodeExtended (
1738 IN VOID
*OpCodeHandle
,
1739 IN VOID
*OpCodeTemplate
,
1741 IN UINTN OpCodeSize
,
1742 IN UINTN ExtensionSize
,
1746 EFI_IFR_OP_HEADER
*Header
;
1749 ASSERT (OpCodeTemplate
!= NULL
);
1750 ASSERT ((OpCodeSize
+ ExtensionSize
) <= 0x7F);
1752 Header
= (EFI_IFR_OP_HEADER
*)OpCodeTemplate
;
1753 Header
->OpCode
= OpCode
;
1754 Header
->Scope
= Scope
;
1755 Header
->Length
= (UINT8
)(OpCodeSize
+ ExtensionSize
);
1756 Buffer
= InternalHiiGrowOpCodeHandle (OpCodeHandle
, Header
->Length
);
1757 return (UINT8
*)CopyMem (Buffer
, Header
, OpCodeSize
);
1762 InternalHiiCreateOpCode (
1763 IN VOID
*OpCodeHandle
,
1764 IN VOID
*OpCodeTemplate
,
1769 return InternalHiiCreateOpCodeExtended (OpCodeHandle
, OpCodeTemplate
, OpCode
, OpCodeSize
, 0, 0);
1773 Append raw opcodes to an OpCodeHandle.
1775 If OpCodeHandle is NULL, then ASSERT().
1776 If RawBuffer is NULL, then ASSERT();
1778 @param[in] OpCodeHandle Handle to the buffer of opcodes.
1779 @param[in] RawBuffer Buffer of opcodes to append.
1780 @param[in] RawBufferSize The size, in bytes, of Buffer.
1782 @retval NULL There is not enough space left in Buffer to add the opcode.
1783 @retval Other A pointer to the appended opcodes.
1788 InternalHiiCreateRawOpCodes (
1789 IN VOID
*OpCodeHandle
,
1790 IN UINT8
*RawBuffer
,
1791 IN UINTN RawBufferSize
1796 ASSERT (RawBuffer
!= NULL
);
1798 Buffer
= InternalHiiGrowOpCodeHandle (OpCodeHandle
, RawBufferSize
);
1799 return (UINT8
*)CopyMem (Buffer
, RawBuffer
, RawBufferSize
);
1803 Append opcodes from one OpCode Handle to another OpCode handle.
1805 If OpCodeHandle is NULL, then ASSERT().
1806 If RawOpCodeHandle is NULL, then ASSERT();
1808 @param[in] OpCodeHandle Handle to the buffer of opcodes.
1809 @param[in] RawOpCodeHandle Handle to the buffer of opcodes.
1811 @retval NULL There is not enough space left in Buffer to add the opcode.
1812 @retval Other A pointer to the appended opcodes.
1817 InternalHiiAppendOpCodes (
1818 IN VOID
*OpCodeHandle
,
1819 IN VOID
*RawOpCodeHandle
1822 HII_LIB_OPCODE_BUFFER
*RawOpCodeBuffer
;
1824 ASSERT (RawOpCodeHandle
!= NULL
);
1826 RawOpCodeBuffer
= (HII_LIB_OPCODE_BUFFER
*)RawOpCodeHandle
;
1827 return InternalHiiCreateRawOpCodes (OpCodeHandle
, RawOpCodeBuffer
->Buffer
, RawOpCodeBuffer
->Position
);
1831 Create EFI_IFR_END_OP opcode.
1833 If OpCodeHandle is NULL, then ASSERT().
1835 @param[in] OpCodeHandle Handle to the buffer of opcodes.
1837 @retval NULL There is not enough space left in Buffer to add the opcode.
1838 @retval Other A pointer to the created opcode.
1843 HiiCreateEndOpCode (
1844 IN VOID
*OpCodeHandle
1849 return InternalHiiCreateOpCode (OpCodeHandle
, &OpCode
, EFI_IFR_END_OP
, sizeof (OpCode
));
1853 Create EFI_IFR_ONE_OF_OPTION_OP opcode.
1855 If OpCodeHandle is NULL, then ASSERT().
1856 If Type is invalid, then ASSERT().
1857 If Flags is invalid, then ASSERT().
1859 @param[in] OpCodeHandle Handle to the buffer of opcodes.
1860 @param[in] StringId StringId for the option
1861 @param[in] Flags Flags for the option
1862 @param[in] Type Type for the option
1863 @param[in] Value Value for the option
1865 @retval NULL There is not enough space left in Buffer to add the opcode.
1866 @retval Other A pointer to the created opcode.
1871 HiiCreateOneOfOptionOpCode (
1872 IN VOID
*OpCodeHandle
,
1879 EFI_IFR_ONE_OF_OPTION OpCode
;
1881 ASSERT (Type
< EFI_IFR_TYPE_OTHER
);
1883 ZeroMem (&OpCode
, sizeof (OpCode
));
1884 OpCode
.Option
= StringId
;
1885 OpCode
.Flags
= (UINT8
) (Flags
& (EFI_IFR_OPTION_DEFAULT
| EFI_IFR_OPTION_DEFAULT_MFG
));
1887 CopyMem (&OpCode
.Value
, &Value
, mHiiDefaultTypeToWidth
[Type
]);
1889 return InternalHiiCreateOpCode (OpCodeHandle
, &OpCode
, EFI_IFR_ONE_OF_OPTION_OP
, sizeof (OpCode
));
1893 Create EFI_IFR_DEFAULT_OP opcode.
1895 If OpCodeHandle is NULL, then ASSERT().
1896 If Type is invalid, then ASSERT().
1898 @param[in] OpCodeHandle Handle to the buffer of opcodes.
1899 @param[in] DefaultId DefaultId for the default
1900 @param[in] Type Type for the default
1901 @param[in] Value Value for the default
1903 @retval NULL There is not enough space left in Buffer to add the opcode.
1904 @retval Other A pointer to the created opcode.
1909 HiiCreateDefaultOpCode (
1910 IN VOID
*OpCodeHandle
,
1911 IN UINT16 DefaultId
,
1916 EFI_IFR_DEFAULT OpCode
;
1918 ASSERT (Type
< EFI_IFR_TYPE_OTHER
);
1920 ZeroMem (&OpCode
, sizeof (OpCode
));
1922 OpCode
.DefaultId
= DefaultId
;
1923 CopyMem (&OpCode
.Value
, &Value
, mHiiDefaultTypeToWidth
[Type
]);
1925 return InternalHiiCreateOpCode (OpCodeHandle
, &OpCode
, EFI_IFR_DEFAULT_OP
, sizeof (OpCode
));
1929 Create EFI_IFR_GUID opcode.
1931 If OpCodeHandle is NULL, then ASSERT().
1932 If Guid is NULL, then ASSERT().
1933 If OpCodeSize < sizeof (EFI_IFR_GUID), then ASSERT().
1935 @param[in] OpCodeHandle Handle to the buffer of opcodes.
1936 @param[in] Guid Pointer to EFI_GUID of this guided opcode.
1937 @param[in] GuidOpCode Pointer to an EFI_IFR_GUID opcode. This is an
1938 optional parameter that may be NULL. If this
1939 parameter is NULL, then the GUID extension
1940 region of the created opcode is filled with zeros.
1941 If this parameter is not NULL, then the GUID
1942 extension region of GuidData will be copied to
1943 the GUID extension region of the created opcode.
1944 @param[in] OpCodeSize The size, in bytes, of created opcode. This value
1945 must be >= sizeof(EFI_IFR_GUID).
1947 @retval NULL There is not enough space left in Buffer to add the opcode.
1948 @retval Other A pointer to the created opcode.
1953 HiiCreateGuidOpCode (
1954 IN VOID
*OpCodeHandle
,
1955 IN CONST EFI_GUID
*Guid
,
1956 IN CONST VOID
*GuidOpCode
, OPTIONAL
1960 EFI_IFR_GUID OpCode
;
1961 EFI_IFR_GUID
*OpCodePointer
;
1963 ASSERT (Guid
!= NULL
);
1964 ASSERT (OpCodeSize
>= sizeof (OpCode
));
1966 ZeroMem (&OpCode
, sizeof (OpCode
));
1967 CopyGuid ((EFI_GUID
*)(VOID
*)&OpCode
.Guid
, Guid
);
1969 OpCodePointer
= (EFI_IFR_GUID
*)InternalHiiCreateOpCodeExtended (
1974 OpCodeSize
- sizeof (OpCode
),
1977 if (OpCodePointer
!= NULL
&& GuidOpCode
!= NULL
) {
1978 CopyMem (OpCodePointer
+ 1, (EFI_IFR_GUID
*)GuidOpCode
+ 1, OpCodeSize
- sizeof (OpCode
));
1980 return (UINT8
*)OpCodePointer
;
1984 Create EFI_IFR_ACTION_OP opcode.
1986 If OpCodeHandle is NULL, then ASSERT().
1987 If any reserved bits are set in QuestionFlags, then ASSERT().
1989 @param[in] OpCodeHandle Handle to the buffer of opcodes.
1990 @param[in] QuestionId Question ID
1991 @param[in] Prompt String ID for Prompt
1992 @param[in] Help String ID for Help
1993 @param[in] QuestionFlags Flags in Question Header
1994 @param[in] QuestionConfig String ID for configuration
1996 @retval NULL There is not enough space left in Buffer to add the opcode.
1997 @retval Other A pointer to the created opcode.
2002 HiiCreateActionOpCode (
2003 IN VOID
*OpCodeHandle
,
2004 IN EFI_QUESTION_ID QuestionId
,
2005 IN EFI_STRING_ID Prompt
,
2006 IN EFI_STRING_ID Help
,
2007 IN UINT8 QuestionFlags
,
2008 IN EFI_STRING_ID QuestionConfig
2011 EFI_IFR_ACTION OpCode
;
2013 ASSERT ((QuestionFlags
& (~(EFI_IFR_FLAG_READ_ONLY
| EFI_IFR_FLAG_CALLBACK
| EFI_IFR_FLAG_RESET_REQUIRED
| EFI_IFR_FLAG_OPTIONS_ONLY
))) == 0);
2015 ZeroMem (&OpCode
, sizeof (OpCode
));
2016 OpCode
.Question
.QuestionId
= QuestionId
;
2017 OpCode
.Question
.Header
.Prompt
= Prompt
;
2018 OpCode
.Question
.Header
.Help
= Help
;
2019 OpCode
.Question
.Flags
= QuestionFlags
;
2020 OpCode
.QuestionConfig
= QuestionConfig
;
2022 return InternalHiiCreateOpCode (OpCodeHandle
, &OpCode
, EFI_IFR_ACTION_OP
, sizeof (OpCode
));
2026 Create EFI_IFR_SUBTITLE_OP opcode.
2028 If OpCodeHandle is NULL, then ASSERT().
2029 If any reserved bits are set in Flags, then ASSERT().
2030 If Scope > 1, then ASSERT().
2032 @param[in] OpCodeHandle Handle to the buffer of opcodes.
2033 @param[in] Prompt String ID for Prompt
2034 @param[in] Help String ID for Help
2035 @param[in] Flags Subtitle opcode flags
2036 @param[in] Scope 1 if this opcpde is the beginning of a new scope.
2037 0 if this opcode is within the current scope.
2039 @retval NULL There is not enough space left in Buffer to add the opcode.
2040 @retval Other A pointer to the created opcode.
2045 HiiCreateSubTitleOpCode (
2046 IN VOID
*OpCodeHandle
,
2047 IN EFI_STRING_ID Prompt
,
2048 IN EFI_STRING_ID Help
,
2053 EFI_IFR_SUBTITLE OpCode
;
2055 ASSERT (Scope
<= 1);
2056 ASSERT ((Flags
& (~(EFI_IFR_FLAGS_HORIZONTAL
))) == 0);
2058 ZeroMem (&OpCode
, sizeof (OpCode
));
2059 OpCode
.Statement
.Prompt
= Prompt
;
2060 OpCode
.Statement
.Help
= Help
;
2061 OpCode
.Flags
= Flags
;
2063 return InternalHiiCreateOpCodeExtended (
2066 EFI_IFR_SUBTITLE_OP
,
2074 Create EFI_IFR_REF_OP opcode.
2076 If OpCodeHandle is NULL, then ASSERT().
2077 If any reserved bits are set in QuestionFlags, then ASSERT().
2079 @param[in] OpCodeHandle Handle to the buffer of opcodes.
2080 @param[in] FormId Destination Form ID
2081 @param[in] Prompt String ID for Prompt
2082 @param[in] Help String ID for Help
2083 @param[in] QuestionFlags Flags in Question Header
2084 @param[in] QuestionId Question ID
2086 @retval NULL There is not enough space left in Buffer to add the opcode.
2087 @retval Other A pointer to the created opcode.
2092 HiiCreateGotoOpCode (
2093 IN VOID
*OpCodeHandle
,
2094 IN EFI_FORM_ID FormId
,
2095 IN EFI_STRING_ID Prompt
,
2096 IN EFI_STRING_ID Help
,
2097 IN UINT8 QuestionFlags
,
2098 IN EFI_QUESTION_ID QuestionId
2103 ASSERT ((QuestionFlags
& (~(EFI_IFR_FLAG_READ_ONLY
| EFI_IFR_FLAG_CALLBACK
| EFI_IFR_FLAG_RESET_REQUIRED
| EFI_IFR_FLAG_OPTIONS_ONLY
))) == 0);
2105 ZeroMem (&OpCode
, sizeof (OpCode
));
2106 OpCode
.Question
.Header
.Prompt
= Prompt
;
2107 OpCode
.Question
.Header
.Help
= Help
;
2108 OpCode
.Question
.QuestionId
= QuestionId
;
2109 OpCode
.Question
.Flags
= QuestionFlags
;
2110 OpCode
.FormId
= FormId
;
2112 return InternalHiiCreateOpCode (OpCodeHandle
, &OpCode
, EFI_IFR_REF_OP
, sizeof (OpCode
));
2116 Create EFI_IFR_CHECKBOX_OP opcode.
2118 If OpCodeHandle is NULL, then ASSERT().
2119 If any reserved bits are set in QuestionFlags, then ASSERT().
2120 If any reserved bits are set in CheckBoxFlags, then ASSERT().
2122 @param[in] OpCodeHandle Handle to the buffer of opcodes.
2123 @param[in] QuestionId Question ID
2124 @param[in] VarStoreId Storage ID
2125 @param[in] VarOffset Offset in Storage
2126 @param[in] Prompt String ID for Prompt
2127 @param[in] Help String ID for Help
2128 @param[in] QuestionFlags Flags in Question Header
2129 @param[in] CheckBoxFlags Flags for checkbox opcode
2130 @param[in] DefaultsOpCodeHandle Handle for a buffer of DEFAULT opcodes. This
2131 is an optional parameter that may be NULL.
2133 @retval NULL There is not enough space left in Buffer to add the opcode.
2134 @retval Other A pointer to the created opcode.
2139 HiiCreateCheckBoxOpCode (
2140 IN VOID
*OpCodeHandle
,
2141 IN EFI_QUESTION_ID QuestionId
,
2142 IN EFI_VARSTORE_ID VarStoreId
,
2143 IN UINT16 VarOffset
,
2144 IN EFI_STRING_ID Prompt
,
2145 IN EFI_STRING_ID Help
,
2146 IN UINT8 QuestionFlags
,
2147 IN UINT8 CheckBoxFlags
,
2148 IN VOID
*DefaultsOpCodeHandle OPTIONAL
2151 EFI_IFR_CHECKBOX OpCode
;
2154 ASSERT ((QuestionFlags
& (~(EFI_IFR_FLAG_READ_ONLY
| EFI_IFR_FLAG_CALLBACK
| EFI_IFR_FLAG_RESET_REQUIRED
| EFI_IFR_FLAG_OPTIONS_ONLY
))) == 0);
2156 ZeroMem (&OpCode
, sizeof (OpCode
));
2157 OpCode
.Question
.QuestionId
= QuestionId
;
2158 OpCode
.Question
.VarStoreId
= VarStoreId
;
2159 OpCode
.Question
.VarStoreInfo
.VarOffset
= VarOffset
;
2160 OpCode
.Question
.Header
.Prompt
= Prompt
;
2161 OpCode
.Question
.Header
.Help
= Help
;
2162 OpCode
.Question
.Flags
= QuestionFlags
;
2163 OpCode
.Flags
= CheckBoxFlags
;
2165 if (DefaultsOpCodeHandle
== NULL
) {
2166 return InternalHiiCreateOpCode (OpCodeHandle
, &OpCode
, EFI_IFR_CHECKBOX_OP
, sizeof (OpCode
));
2169 Position
= InternalHiiOpCodeHandlePosition (OpCodeHandle
);
2170 InternalHiiCreateOpCodeExtended (OpCodeHandle
, &OpCode
, EFI_IFR_CHECKBOX_OP
, sizeof (OpCode
), 0, 1);
2171 InternalHiiAppendOpCodes (OpCodeHandle
, DefaultsOpCodeHandle
);
2172 HiiCreateEndOpCode (OpCodeHandle
);
2173 return InternalHiiOpCodeHandleBuffer (OpCodeHandle
) + Position
;
2177 Create EFI_IFR_NUMERIC_OP opcode.
2179 If OpCodeHandle is NULL, then ASSERT().
2180 If any reserved bits are set in QuestionFlags, then ASSERT().
2181 If any reserved bits are set in NumericFlags, then ASSERT().
2183 @param[in] OpCodeHandle Handle to the buffer of opcodes.
2184 @param[in] QuestionId Question ID
2185 @param[in] VarStoreId Storage ID
2186 @param[in] VarOffset Offset in Storage
2187 @param[in] Prompt String ID for Prompt
2188 @param[in] Help String ID for Help
2189 @param[in] QuestionFlags Flags in Question Header
2190 @param[in] NumericFlags Flags for numeric opcode
2191 @param[in] Minimum Numeric minimum value
2192 @param[in] Maximum Numeric maximum value
2193 @param[in] Step Numeric step for edit
2194 @param[in] DefaultsOpCodeHandle Handle for a buffer of DEFAULT opcodes. This
2195 is an optional parameter that may be NULL.
2197 @retval NULL There is not enough space left in Buffer to add the opcode.
2198 @retval Other A pointer to the created opcode.
2203 HiiCreateNumericOpCode (
2204 IN VOID
*OpCodeHandle
,
2205 IN EFI_QUESTION_ID QuestionId
,
2206 IN EFI_VARSTORE_ID VarStoreId
,
2207 IN UINT16 VarOffset
,
2208 IN EFI_STRING_ID Prompt
,
2209 IN EFI_STRING_ID Help
,
2210 IN UINT8 QuestionFlags
,
2211 IN UINT8 NumericFlags
,
2215 IN VOID
*DefaultsOpCodeHandle OPTIONAL
2218 EFI_IFR_NUMERIC OpCode
;
2221 ASSERT ((QuestionFlags
& (~(EFI_IFR_FLAG_READ_ONLY
| EFI_IFR_FLAG_CALLBACK
| EFI_IFR_FLAG_RESET_REQUIRED
| EFI_IFR_FLAG_OPTIONS_ONLY
))) == 0);
2223 ZeroMem (&OpCode
, sizeof (OpCode
));
2224 OpCode
.Question
.QuestionId
= QuestionId
;
2225 OpCode
.Question
.VarStoreId
= VarStoreId
;
2226 OpCode
.Question
.VarStoreInfo
.VarOffset
= VarOffset
;
2227 OpCode
.Question
.Header
.Prompt
= Prompt
;
2228 OpCode
.Question
.Header
.Help
= Help
;
2229 OpCode
.Question
.Flags
= QuestionFlags
;
2230 OpCode
.Flags
= NumericFlags
;
2232 switch (NumericFlags
& EFI_IFR_NUMERIC_SIZE
) {
2233 case EFI_IFR_NUMERIC_SIZE_1
:
2234 OpCode
.data
.u8
.MinValue
= (UINT8
)Minimum
;
2235 OpCode
.data
.u8
.MaxValue
= (UINT8
)Maximum
;
2236 OpCode
.data
.u8
.Step
= (UINT8
)Step
;
2239 case EFI_IFR_NUMERIC_SIZE_2
:
2240 OpCode
.data
.u16
.MinValue
= (UINT16
)Minimum
;
2241 OpCode
.data
.u16
.MaxValue
= (UINT16
)Maximum
;
2242 OpCode
.data
.u16
.Step
= (UINT16
)Step
;
2245 case EFI_IFR_NUMERIC_SIZE_4
:
2246 OpCode
.data
.u32
.MinValue
= (UINT32
)Minimum
;
2247 OpCode
.data
.u32
.MaxValue
= (UINT32
)Maximum
;
2248 OpCode
.data
.u32
.Step
= (UINT32
)Step
;
2251 case EFI_IFR_NUMERIC_SIZE_8
:
2252 OpCode
.data
.u64
.MinValue
= Minimum
;
2253 OpCode
.data
.u64
.MaxValue
= Maximum
;
2254 OpCode
.data
.u64
.Step
= Step
;
2258 if (DefaultsOpCodeHandle
== NULL
) {
2259 return InternalHiiCreateOpCode (OpCodeHandle
, &OpCode
, EFI_IFR_NUMERIC_OP
, sizeof (OpCode
));
2262 Position
= InternalHiiOpCodeHandlePosition (OpCodeHandle
);
2263 InternalHiiCreateOpCodeExtended (OpCodeHandle
, &OpCode
, EFI_IFR_NUMERIC_OP
, sizeof (OpCode
), 0, 1);
2264 InternalHiiAppendOpCodes (OpCodeHandle
, DefaultsOpCodeHandle
);
2265 HiiCreateEndOpCode (OpCodeHandle
);
2266 return InternalHiiOpCodeHandleBuffer (OpCodeHandle
) + Position
;
2270 Create EFI_IFR_STRING_OP opcode.
2272 If OpCodeHandle is NULL, then ASSERT().
2273 If any reserved bits are set in QuestionFlags, then ASSERT().
2274 If any reserved bits are set in StringFlags, then ASSERT().
2276 @param[in] OpCodeHandle Handle to the buffer of opcodes.
2277 @param[in] QuestionId Question ID
2278 @param[in] VarStoreId Storage ID
2279 @param[in] VarOffset Offset in Storage
2280 @param[in] Prompt String ID for Prompt
2281 @param[in] Help String ID for Help
2282 @param[in] QuestionFlags Flags in Question Header
2283 @param[in] StringFlags Flags for string opcode
2284 @param[in] MinSize String minimum length
2285 @param[in] MaxSize String maximum length
2286 @param[in] DefaultsOpCodeHandle Handle for a buffer of DEFAULT opcodes. This
2287 is an optional parameter that may be NULL.
2289 @retval NULL There is not enough space left in Buffer to add the opcode.
2290 @retval Other A pointer to the created opcode.
2295 HiiCreateStringOpCode (
2296 IN VOID
*OpCodeHandle
,
2297 IN EFI_QUESTION_ID QuestionId
,
2298 IN EFI_VARSTORE_ID VarStoreId
,
2299 IN UINT16 VarOffset
,
2300 IN EFI_STRING_ID Prompt
,
2301 IN EFI_STRING_ID Help
,
2302 IN UINT8 QuestionFlags
,
2303 IN UINT8 StringFlags
,
2306 IN VOID
*DefaultsOpCodeHandle OPTIONAL
2309 EFI_IFR_STRING OpCode
;
2312 ASSERT ((QuestionFlags
& (~(EFI_IFR_FLAG_READ_ONLY
| EFI_IFR_FLAG_CALLBACK
| EFI_IFR_FLAG_RESET_REQUIRED
| EFI_IFR_FLAG_OPTIONS_ONLY
))) == 0);
2314 ZeroMem (&OpCode
, sizeof (OpCode
));
2315 OpCode
.Question
.Header
.Prompt
= Prompt
;
2316 OpCode
.Question
.Header
.Help
= Help
;
2317 OpCode
.Question
.QuestionId
= QuestionId
;
2318 OpCode
.Question
.VarStoreId
= VarStoreId
;
2319 OpCode
.Question
.VarStoreInfo
.VarOffset
= VarOffset
;
2320 OpCode
.Question
.Flags
= QuestionFlags
;
2321 OpCode
.MinSize
= MinSize
;
2322 OpCode
.MaxSize
= MaxSize
;
2323 OpCode
.Flags
= (UINT8
) (StringFlags
& EFI_IFR_STRING_MULTI_LINE
);
2325 if (DefaultsOpCodeHandle
== NULL
) {
2326 return InternalHiiCreateOpCode (OpCodeHandle
, &OpCode
, EFI_IFR_STRING_OP
, sizeof (OpCode
));
2329 Position
= InternalHiiOpCodeHandlePosition (OpCodeHandle
);
2330 InternalHiiCreateOpCodeExtended (OpCodeHandle
, &OpCode
, EFI_IFR_STRING_OP
, sizeof (OpCode
), 0, 1);
2331 InternalHiiAppendOpCodes (OpCodeHandle
, DefaultsOpCodeHandle
);
2332 HiiCreateEndOpCode (OpCodeHandle
);
2333 return InternalHiiOpCodeHandleBuffer (OpCodeHandle
) + Position
;
2337 Create EFI_IFR_ONE_OF_OP opcode.
2339 If OpCodeHandle is NULL, then ASSERT().
2340 If any reserved bits are set in QuestionFlags, then ASSERT().
2341 If any reserved bits are set in OneOfFlags, then ASSERT().
2343 @param[in] OpCodeHandle Handle to the buffer of opcodes.
2344 @param[in] QuestionId Question ID
2345 @param[in] VarStoreId Storage ID
2346 @param[in] VarOffset Offset in Storage
2347 @param[in] Prompt String ID for Prompt
2348 @param[in] Help String ID for Help
2349 @param[in] QuestionFlags Flags in Question Header
2350 @param[in] OneOfFlags Flags for oneof opcode
2351 @param[in] OptionsOpCodeHandle Handle for a buffer of ONE_OF_OPTION opcodes.
2352 @param[in] DefaultsOpCodeHandle Handle for a buffer of DEFAULT opcodes. This
2353 is an optional parameter that may be NULL.
2355 @retval NULL There is not enough space left in Buffer to add the opcode.
2356 @retval Other A pointer to the created opcode.
2361 HiiCreateOneOfOpCode (
2362 IN VOID
*OpCodeHandle
,
2363 IN EFI_QUESTION_ID QuestionId
,
2364 IN EFI_VARSTORE_ID VarStoreId
,
2365 IN UINT16 VarOffset
,
2366 IN EFI_STRING_ID Prompt
,
2367 IN EFI_STRING_ID Help
,
2368 IN UINT8 QuestionFlags
,
2369 IN UINT8 OneOfFlags
,
2370 IN VOID
*OptionsOpCodeHandle
,
2371 IN VOID
*DefaultsOpCodeHandle OPTIONAL
2374 EFI_IFR_ONE_OF OpCode
;
2377 ASSERT (OptionsOpCodeHandle
!= NULL
);
2378 ASSERT ((QuestionFlags
& (~(EFI_IFR_FLAG_READ_ONLY
| EFI_IFR_FLAG_CALLBACK
| EFI_IFR_FLAG_RESET_REQUIRED
| EFI_IFR_FLAG_OPTIONS_ONLY
))) == 0);
2380 ZeroMem (&OpCode
, sizeof (OpCode
));
2381 OpCode
.Question
.Header
.Prompt
= Prompt
;
2382 OpCode
.Question
.Header
.Help
= Help
;
2383 OpCode
.Question
.QuestionId
= QuestionId
;
2384 OpCode
.Question
.VarStoreId
= VarStoreId
;
2385 OpCode
.Question
.VarStoreInfo
.VarOffset
= VarOffset
;
2386 OpCode
.Question
.Flags
= QuestionFlags
;
2387 OpCode
.Flags
= OneOfFlags
;
2389 Position
= InternalHiiOpCodeHandlePosition (OpCodeHandle
);
2390 InternalHiiCreateOpCodeExtended (OpCodeHandle
, &OpCode
, EFI_IFR_ONE_OF_OP
, sizeof (OpCode
), 0, 1);
2391 InternalHiiAppendOpCodes (OpCodeHandle
, OptionsOpCodeHandle
);
2392 if (DefaultsOpCodeHandle
!= NULL
) {
2393 InternalHiiAppendOpCodes (OpCodeHandle
, DefaultsOpCodeHandle
);
2395 HiiCreateEndOpCode (OpCodeHandle
);
2396 return InternalHiiOpCodeHandleBuffer (OpCodeHandle
) + Position
;
2400 Create EFI_IFR_ORDERED_LIST_OP opcode.
2402 If OpCodeHandle is NULL, then ASSERT().
2403 If any reserved bits are set in QuestionFlags, then ASSERT().
2404 If any reserved bits are set in OrderedListFlags, then ASSERT().
2406 @param[in] OpCodeHandle Handle to the buffer of opcodes.
2407 @param[in] QuestionId Question ID
2408 @param[in] VarStoreId Storage ID
2409 @param[in] VarOffset Offset in Storage
2410 @param[in] Prompt String ID for Prompt
2411 @param[in] Help String ID for Help
2412 @param[in] QuestionFlags Flags in Question Header
2413 @param[in] OrderedListFlags Flags for ordered list opcode
2414 @param[in] DataType Type for option value
2415 @param[in] MaxContainers Maximum count for options in this ordered list
2416 @param[in] OptionsOpCodeHandle Handle for a buffer of ONE_OF_OPTION opcodes.
2417 @param[in] DefaultsOpCodeHandle Handle for a buffer of DEFAULT opcodes. This
2418 is an optional parameter that may be NULL.
2420 @retval NULL There is not enough space left in Buffer to add the opcode.
2421 @retval Other A pointer to the created opcode.
2426 HiiCreateOrderedListOpCode (
2427 IN VOID
*OpCodeHandle
,
2428 IN EFI_QUESTION_ID QuestionId
,
2429 IN EFI_VARSTORE_ID VarStoreId
,
2430 IN UINT16 VarOffset
,
2431 IN EFI_STRING_ID Prompt
,
2432 IN EFI_STRING_ID Help
,
2433 IN UINT8 QuestionFlags
,
2434 IN UINT8 OrderedListFlags
,
2436 IN UINT8 MaxContainers
,
2437 IN VOID
*OptionsOpCodeHandle
,
2438 IN VOID
*DefaultsOpCodeHandle OPTIONAL
2441 EFI_IFR_ORDERED_LIST OpCode
;
2444 ASSERT (OptionsOpCodeHandle
!= NULL
);
2445 ASSERT ((QuestionFlags
& (~(EFI_IFR_FLAG_READ_ONLY
| EFI_IFR_FLAG_CALLBACK
| EFI_IFR_FLAG_RESET_REQUIRED
| EFI_IFR_FLAG_OPTIONS_ONLY
))) == 0);
2447 ZeroMem (&OpCode
, sizeof (OpCode
));
2448 OpCode
.Question
.Header
.Prompt
= Prompt
;
2449 OpCode
.Question
.Header
.Help
= Help
;
2450 OpCode
.Question
.QuestionId
= QuestionId
;
2451 OpCode
.Question
.VarStoreId
= VarStoreId
;
2452 OpCode
.Question
.VarStoreInfo
.VarOffset
= VarOffset
;
2453 OpCode
.Question
.Flags
= QuestionFlags
;
2454 OpCode
.MaxContainers
= MaxContainers
;
2455 OpCode
.Flags
= OrderedListFlags
;
2457 Position
= InternalHiiOpCodeHandlePosition (OpCodeHandle
);
2458 InternalHiiCreateOpCodeExtended (OpCodeHandle
, &OpCode
, EFI_IFR_ORDERED_LIST_OP
, sizeof (OpCode
), 0, 1);
2459 InternalHiiAppendOpCodes (OpCodeHandle
, OptionsOpCodeHandle
);
2460 if (DefaultsOpCodeHandle
!= NULL
) {
2461 InternalHiiAppendOpCodes (OpCodeHandle
, DefaultsOpCodeHandle
);
2463 HiiCreateEndOpCode (OpCodeHandle
);
2464 return InternalHiiOpCodeHandleBuffer (OpCodeHandle
) + Position
;
2468 This is the internal worker function to update the data in
2469 a form specified by FormSetGuid, FormId and Label.
2471 @param FormSetGuid The optional Formset GUID.
2472 @param FormId The Form ID.
2473 @param Package The package header.
2475 @param TempPacakge The resultant package.
2477 @retval EFI_SUCCESS The function completes successfully.
2482 InternalHiiUpdateFormPackageData (
2483 IN EFI_GUID
*FormSetGuid
, OPTIONAL
2484 IN EFI_FORM_ID FormId
,
2485 IN EFI_HII_PACKAGE_HEADER
*Package
,
2486 IN HII_LIB_OPCODE_BUFFER
*OpCodeBufferStart
,
2487 IN HII_LIB_OPCODE_BUFFER
*OpCodeBufferEnd
, OPTIONAL
2488 OUT EFI_HII_PACKAGE_HEADER
*TempPackage
2493 EFI_HII_PACKAGE_HEADER PackageHeader
;
2495 EFI_IFR_OP_HEADER
*IfrOpHdr
;
2496 EFI_IFR_OP_HEADER
*UpdateIfrOpHdr
;
2500 EFI_IFR_OP_HEADER
*AddOpCode
;
2501 UINT32 UpdatePackageLength
;
2503 CopyMem (TempPackage
, Package
, sizeof (EFI_HII_PACKAGE_HEADER
));
2504 UpdatePackageLength
= sizeof (EFI_HII_PACKAGE_HEADER
);
2505 BufferPos
= (UINT8
*) (TempPackage
+ 1);
2507 CopyMem (&PackageHeader
, Package
, sizeof (EFI_HII_PACKAGE_HEADER
));
2508 IfrOpHdr
= (EFI_IFR_OP_HEADER
*)((UINT8
*) Package
+ sizeof (EFI_HII_PACKAGE_HEADER
));
2509 Offset
= sizeof (EFI_HII_PACKAGE_HEADER
);
2510 GetFormSet
= (BOOLEAN
) ((FormSetGuid
== NULL
) ? TRUE
: FALSE
);
2514 while (Offset
< PackageHeader
.Length
) {
2515 CopyMem (BufferPos
, IfrOpHdr
, IfrOpHdr
->Length
);
2516 BufferPos
+= IfrOpHdr
->Length
;
2517 UpdatePackageLength
+= IfrOpHdr
->Length
;
2520 // Find the matched FormSet and Form
2522 if ((IfrOpHdr
->OpCode
== EFI_IFR_FORM_SET_OP
) && (FormSetGuid
!= NULL
)) {
2523 if (CompareGuid((GUID
*)(VOID
*)&((EFI_IFR_FORM_SET
*) IfrOpHdr
)->Guid
, FormSetGuid
)) {
2528 } else if (IfrOpHdr
->OpCode
== EFI_IFR_FORM_OP
) {
2529 if (CompareMem (&((EFI_IFR_FORM
*) IfrOpHdr
)->FormId
, &FormId
, sizeof (EFI_FORM_ID
)) == 0) {
2537 // The matched Form is found, and Update data in this form
2539 if (GetFormSet
&& GetForm
&& !Updated
) {
2540 UpdateIfrOpHdr
= (EFI_IFR_OP_HEADER
*) OpCodeBufferStart
->Buffer
;
2541 if ((UpdateIfrOpHdr
->Length
== IfrOpHdr
->Length
) && \
2542 (CompareMem (IfrOpHdr
, UpdateIfrOpHdr
, UpdateIfrOpHdr
->Length
) == 0)) {
2544 // Remove the original data when End OpCode buffer exist.
2546 if (OpCodeBufferEnd
!= NULL
) {
2547 Offset
+= IfrOpHdr
->Length
;
2548 IfrOpHdr
= (EFI_IFR_OP_HEADER
*) ((UINT8
*) (IfrOpHdr
) + IfrOpHdr
->Length
);
2549 UpdateIfrOpHdr
= (EFI_IFR_OP_HEADER
*) OpCodeBufferEnd
->Buffer
;
2550 while (Offset
< PackageHeader
.Length
) {
2552 // Search the matched end opcode
2554 if ((UpdateIfrOpHdr
->Length
== IfrOpHdr
->Length
) && \
2555 (CompareMem (IfrOpHdr
, UpdateIfrOpHdr
, UpdateIfrOpHdr
->Length
) == 0)) {
2559 // Go to the next Op-Code
2561 Offset
+= IfrOpHdr
->Length
;
2562 IfrOpHdr
= (EFI_IFR_OP_HEADER
*) ((UINT8
*) (IfrOpHdr
) + IfrOpHdr
->Length
);
2565 if (Offset
>= PackageHeader
.Length
) {
2567 // The end opcode is not found.
2569 return EFI_NOT_FOUND
;
2573 // Insert the updated data
2575 UpdateIfrOpHdr
= (EFI_IFR_OP_HEADER
*) OpCodeBufferStart
->Buffer
;
2576 AddOpCode
= (EFI_IFR_OP_HEADER
*) (OpCodeBufferStart
->Buffer
+ UpdateIfrOpHdr
->Length
);
2577 AddSize
= UpdateIfrOpHdr
->Length
;
2578 while (AddSize
< OpCodeBufferStart
->Position
) {
2579 CopyMem (BufferPos
, AddOpCode
, AddOpCode
->Length
);
2580 BufferPos
+= AddOpCode
->Length
;
2581 UpdatePackageLength
+= AddOpCode
->Length
;
2583 AddOpCode
= (EFI_IFR_OP_HEADER
*) ((UINT8
*) (AddOpCode
) + AddOpCode
->Length
);
2584 AddSize
+= AddOpCode
->Length
;
2587 if (OpCodeBufferEnd
!= NULL
) {
2589 // Add the end opcode
2591 CopyMem (BufferPos
, IfrOpHdr
, IfrOpHdr
->Length
);
2592 BufferPos
+= IfrOpHdr
->Length
;
2593 UpdatePackageLength
+= IfrOpHdr
->Length
;
2603 // Go to the next Op-Code
2605 Offset
+= IfrOpHdr
->Length
;
2606 IfrOpHdr
= (EFI_IFR_OP_HEADER
*) ((CHAR8
*) (IfrOpHdr
) + IfrOpHdr
->Length
);
2611 // The updated opcode buffer is not found.
2613 return EFI_NOT_FOUND
;
2616 // Update the package length.
2618 PackageHeader
.Length
= UpdatePackageLength
;
2619 CopyMem (TempPackage
, &PackageHeader
, sizeof (EFI_HII_PACKAGE_HEADER
));
2625 This function updates a form that has previously been registered with the HII
2626 Database. This function will perform at most one update operation.
2628 The form to update is specified by Handle, FormSetGuid, and FormId. Binary
2629 comparisons of IFR opcodes are performed from the beginning of the form being
2630 updated until an IFR opcode is found that exactly matches the first IFR opcode
2631 specifed by StartOpCodeHandle. The following rules are used to determine if
2632 an insert, replace, or delete operation is performed.
2634 1) If no matches are found, then NULL is returned.
2635 2) If a match is found, and EndOpCodeHandle is NULL, then all of the IFR opcodes
2636 from StartOpcodeHandle except the first opcode are inserted immediately after
2637 the matching IFR opcode in the form beng updated.
2638 3) If a match is found, and EndOpCodeHandle is not NULL, then a search is made
2639 from the matching IFR opcode until an IFR opcode exatly matches the first
2640 IFR opcode specified by EndOpCodeHandle. If no match is found for the first
2641 IFR opcode specified by EndOpCodeHandle, then NULL is returned. If a match
2642 is found, then all of the IFR opcodes between the start match and the end
2643 match are deleted from the form being updated and all of the IFR opcodes
2644 from StartOpcodeHandle except the first opcode are inserted immediately after
2645 the matching start IFR opcode. If StartOpCcodeHandle only contains one
2646 IFR instruction, then the result of ths operation will delete all of the IFR
2647 opcodes between the start end matches.
2649 If HiiHandle is NULL, then ASSERT().
2650 If StartOpCodeHandle is NULL, then ASSERT().
2652 @param[in] HiiHandle The HII Handle of the form to update.
2653 @param[in] FormSetGuid The Formset GUID of the form to update. This
2654 is an optional parameter that may be NULL.
2655 If it is NULL, all FormSet will be updated.
2656 @param[in] FormId The ID of the form to update.
2657 @param[in] StartOpCodeHandle An OpCode Handle that contains the set of IFR
2658 opcodes to be inserted or replaced in the form.
2659 The first IFR instruction in StartOpCodeHandle
2660 is used to find matching IFR opcode in the
2662 @param[in] EndOpCodeHandle An OpCcode Handle that contains the IFR opcode
2663 that marks the end of a replace operation in
2664 the form. This is an optional parameter that
2665 may be NULL. If it is NULL, then an the IFR
2666 opcodes specified by StartOpCodeHandle are
2667 inserted into the form.
2669 @retval EFI_OUT_OF_RESOURCES No enough memory resource is allocated.
2670 @retval EFI_NOT_FOUND The following cases will return EFI_NOT_FOUND.
2671 1) The form specified by HiiHandle, FormSetGuid,
2672 and FormId could not be found in the HII Database.
2673 2) No IFR opcodes in the target form match the first
2674 IFR opcode in StartOpCodeHandle.
2675 3) EndOpCOde is not NULL, and no IFR opcodes in the
2676 target form following a matching start opcode match
2677 the first IFR opcode in EndOpCodeHandle.
2678 @retval EFI_SUCCESS The matched form is updated by StartOpcode.
2684 IN EFI_HII_HANDLE HiiHandle
,
2685 IN EFI_GUID
*FormSetGuid
, OPTIONAL
2686 IN EFI_FORM_ID FormId
,
2687 IN VOID
*StartOpcodeHandle
,
2688 IN VOID
*EndOpcodeHandle OPTIONAL
2692 EFI_HII_PACKAGE_LIST_HEADER
*HiiPackageList
;
2693 UINT32 PackageListLength
;
2695 EFI_HII_PACKAGE_LIST_HEADER
*UpdatePackageList
;
2697 UINT8
*UpdateBufferPos
;
2698 EFI_HII_PACKAGE_HEADER
*Package
;
2699 EFI_HII_PACKAGE_HEADER
*TempPacakge
;
2700 EFI_HII_PACKAGE_HEADER PackageHeader
;
2702 HII_LIB_OPCODE_BUFFER
*OpCodeBufferStart
;
2703 HII_LIB_OPCODE_BUFFER
*OpCodeBufferEnd
;
2706 // Input update data can't be NULL.
2708 ASSERT (HiiHandle
!= NULL
);
2709 ASSERT (StartOpcodeHandle
!= NULL
);
2710 UpdatePackageList
= NULL
;
2712 HiiPackageList
= NULL
;
2715 // Restrive buffer data from Opcode Handle
2717 OpCodeBufferStart
= (HII_LIB_OPCODE_BUFFER
*) StartOpcodeHandle
;
2718 OpCodeBufferEnd
= (HII_LIB_OPCODE_BUFFER
*) EndOpcodeHandle
;
2721 // Get the orginal package list
2724 HiiPackageList
= NULL
;
2725 Status
= gHiiDatabase
->ExportPackageLists (gHiiDatabase
, HiiHandle
, &BufferSize
, HiiPackageList
);
2727 // The return status should always be EFI_BUFFER_TOO_SMALL as input buffer's size is 0.
2729 if (Status
!= EFI_BUFFER_TOO_SMALL
) {
2733 HiiPackageList
= AllocatePool (BufferSize
);
2734 if (HiiPackageList
== NULL
) {
2735 Status
= EFI_OUT_OF_RESOURCES
;
2739 Status
= gHiiDatabase
->ExportPackageLists (gHiiDatabase
, HiiHandle
, &BufferSize
, HiiPackageList
);
2740 if (EFI_ERROR (Status
)) {
2745 // Calculate and allocate space for retrieval of IFR data
2747 BufferSize
+= OpCodeBufferStart
->Position
;
2748 UpdatePackageList
= AllocateZeroPool (BufferSize
);
2749 if (UpdatePackageList
== NULL
) {
2750 Status
= EFI_OUT_OF_RESOURCES
;
2755 // Allocate temp buffer to store the temp updated package buffer
2757 TempPacakge
= AllocateZeroPool (BufferSize
);
2758 if (TempPacakge
== NULL
) {
2759 Status
= EFI_OUT_OF_RESOURCES
;
2763 UpdateBufferPos
= (UINT8
*) UpdatePackageList
;
2766 // Copy the package list header
2768 CopyMem (UpdateBufferPos
, HiiPackageList
, sizeof (EFI_HII_PACKAGE_LIST_HEADER
));
2769 UpdateBufferPos
+= sizeof (EFI_HII_PACKAGE_LIST_HEADER
);
2772 // Go through each package to find the matched pacakge and update one by one
2775 Offset
= sizeof (EFI_HII_PACKAGE_LIST_HEADER
);
2776 PackageListLength
= ReadUnaligned32 (&HiiPackageList
->PackageLength
);
2777 while (Offset
< PackageListLength
) {
2778 Package
= (EFI_HII_PACKAGE_HEADER
*) (((UINT8
*) HiiPackageList
) + Offset
);
2779 CopyMem (&PackageHeader
, Package
, sizeof (EFI_HII_PACKAGE_HEADER
));
2780 Offset
+= Package
->Length
;
2782 if (Package
->Type
== EFI_HII_PACKAGE_FORMS
) {
2784 // Check this package is the matched package.
2786 Status
= InternalHiiUpdateFormPackageData (FormSetGuid
, FormId
, Package
, OpCodeBufferStart
, OpCodeBufferEnd
, TempPacakge
);
2788 // The matched package is found. Its pacakge buffer will be updated by the input new data.
2790 if (!EFI_ERROR(Status
)) {
2796 // Add updated package buffer
2798 Package
= TempPacakge
;
2803 // Add pacakge buffer
2805 CopyMem (&PackageHeader
, Package
, sizeof (EFI_HII_PACKAGE_HEADER
));
2806 CopyMem (UpdateBufferPos
, Package
, PackageHeader
.Length
);
2807 UpdateBufferPos
+= PackageHeader
.Length
;
2812 // Update package list length
2814 BufferSize
= UpdateBufferPos
- (UINT8
*) UpdatePackageList
;
2815 WriteUnaligned32 (&UpdatePackageList
->PackageLength
, (UINT32
) BufferSize
);
2818 // Update Pacakge to show form
2820 Status
= gHiiDatabase
->UpdatePackageList (gHiiDatabase
, HiiHandle
, UpdatePackageList
);
2823 // Not matched form is found and updated.
2825 Status
= EFI_NOT_FOUND
;
2829 if (HiiPackageList
!= NULL
) {
2830 FreePool (HiiPackageList
);
2833 if (UpdatePackageList
!= NULL
) {
2834 FreePool (UpdatePackageList
);
2837 if (TempPacakge
!= NULL
) {
2838 FreePool (TempPacakge
);
2845 Configure the buffer accrording to ConfigBody strings in the format of
2846 <Length:4 bytes>, <Offset: 2 bytes>, <Width:2 bytes>, <Data:n bytes>.
2847 This ConfigBody strings is generated by UEFI VfrCompiler for the default
2848 values in a Form Set. The name of the ConfigBody strings is VfrMyIfrNVDataDefault0000
2849 constructed following this rule:
2850 "Vfr" + varstore.name + "Default" + defaultstore.attributes.
2851 Check the generated C file in Output for details.
2853 @param Buffer The start address of buffer.
2854 @param BufferSize The size of buffer.
2855 @param Number The number of the strings.
2856 @param ... Variable argument list for default value in <AltResp> format
2857 generated by the tool.
2859 @retval EFI_BUFFER_TOO_SMALL the BufferSize is too small to operate.
2860 @retval EFI_INVALID_PARAMETER Buffer is NULL or BufferSize is 0.
2861 @retval EFI_SUCCESS Operation successful.
2866 HiiIfrLibExtractDefault(
2868 IN UINTN
*BufferSize
,
2882 if ((Buffer
== NULL
) || (BufferSize
== NULL
)) {
2883 return EFI_INVALID_PARAMETER
;
2890 VA_START (Args
, Number
);
2891 for (Index
= 0; Index
< Number
; Index
++) {
2892 BufCfgArray
= (UINT8
*) VA_ARG (Args
, VOID
*);
2893 TotalLen
= ReadUnaligned32 ((UINT32
*)BufCfgArray
);
2894 BufferPos
= BufCfgArray
+ sizeof (UINT32
);
2896 while ((UINT32
)(BufferPos
- BufCfgArray
) < TotalLen
) {
2897 Offset
= ReadUnaligned16 ((UINT16
*)BufferPos
);
2898 BufferPos
+= sizeof (UINT16
);
2899 Width
= ReadUnaligned16 ((UINT16
*)BufferPos
);
2900 BufferPos
+= sizeof (UINT16
);
2904 if ((UINTN
)(Offset
+ Width
) > *BufferSize
) {
2905 return EFI_BUFFER_TOO_SMALL
;
2908 CopyMem ((UINT8
*)Buffer
+ Offset
, Value
, Width
);
2913 *BufferSize
= (UINTN
)Offset
;