VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/HiiDatabaseDxe/Database.c@ 101297

Last change on this file since 101297 was 99404, checked in by vboxsync, 22 months ago

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
  • Property svn:eol-style set to native
File size: 156.2 KB
Line 
1/** @file
2Implementation for EFI_HII_DATABASE_PROTOCOL.
3
4Copyright (c) 2007 - 2020, Intel Corporation. All rights reserved.<BR>
5SPDX-License-Identifier: BSD-2-Clause-Patent
6
7**/
8
9#include "HiiDatabase.h"
10
11#define BASE_NUMBER 10
12
13EFI_HII_PACKAGE_LIST_HEADER *gRTDatabaseInfoBuffer = NULL;
14EFI_STRING gRTConfigRespBuffer = NULL;
15UINTN gDatabaseInfoSize = 0;
16UINTN gConfigRespSize = 0;
17BOOLEAN gExportConfigResp = FALSE;
18UINTN gNvDefaultStoreSize = 0;
19SKU_ID gSkuId = 0xFFFFFFFFFFFFFFFF;
20LIST_ENTRY gVarStorageList = INITIALIZE_LIST_HEAD_VARIABLE (gVarStorageList);
21
22//
23// HII database lock.
24//
25EFI_LOCK mHiiDatabaseLock = EFI_INITIALIZE_LOCK_VARIABLE (TPL_NOTIFY);
26
27/**
28 This function generates a HII_DATABASE_RECORD node and adds into hii database.
29 This is a internal function.
30
31 @param Private hii database private structure
32 @param DatabaseNode HII_DATABASE_RECORD node which is used to store a
33 package list
34
35 @retval EFI_SUCCESS A database record is generated successfully.
36 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
37 database contents.
38 @retval EFI_INVALID_PARAMETER Private is NULL or DatabaseRecord is NULL.
39
40**/
41EFI_STATUS
42GenerateHiiDatabaseRecord (
43 IN HII_DATABASE_PRIVATE_DATA *Private,
44 OUT HII_DATABASE_RECORD **DatabaseNode
45 )
46{
47 HII_DATABASE_RECORD *DatabaseRecord;
48 HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList;
49 HII_HANDLE *HiiHandle;
50
51 if ((Private == NULL) || (DatabaseNode == NULL)) {
52 return EFI_INVALID_PARAMETER;
53 }
54
55 DatabaseRecord = (HII_DATABASE_RECORD *)AllocateZeroPool (sizeof (HII_DATABASE_RECORD));
56 if (DatabaseRecord == NULL) {
57 return EFI_OUT_OF_RESOURCES;
58 }
59
60 DatabaseRecord->Signature = HII_DATABASE_RECORD_SIGNATURE;
61
62 DatabaseRecord->PackageList = AllocateZeroPool (sizeof (HII_DATABASE_PACKAGE_LIST_INSTANCE));
63 if (DatabaseRecord->PackageList == NULL) {
64 FreePool (DatabaseRecord);
65 return EFI_OUT_OF_RESOURCES;
66 }
67
68 PackageList = DatabaseRecord->PackageList;
69
70 InitializeListHead (&PackageList->GuidPkgHdr);
71 InitializeListHead (&PackageList->FormPkgHdr);
72 InitializeListHead (&PackageList->KeyboardLayoutHdr);
73 InitializeListHead (&PackageList->StringPkgHdr);
74 InitializeListHead (&PackageList->FontPkgHdr);
75 InitializeListHead (&PackageList->SimpleFontPkgHdr);
76 PackageList->ImagePkg = NULL;
77 PackageList->DevicePathPkg = NULL;
78
79 //
80 // Create a new hii handle
81 //
82 HiiHandle = (HII_HANDLE *)AllocateZeroPool (sizeof (HII_HANDLE));
83 if (HiiHandle == NULL) {
84 FreePool (DatabaseRecord->PackageList);
85 FreePool (DatabaseRecord);
86 return EFI_OUT_OF_RESOURCES;
87 }
88
89 HiiHandle->Signature = HII_HANDLE_SIGNATURE;
90 //
91 // Backup the number of Hii handles
92 //
93 Private->HiiHandleCount++;
94 HiiHandle->Key = (UINTN)Private->HiiHandleCount;
95 //
96 // Insert the handle to hii handle list of the whole database.
97 //
98 InsertTailList (&Private->HiiHandleList, &HiiHandle->Handle);
99
100 DatabaseRecord->Handle = (EFI_HII_HANDLE)HiiHandle;
101
102 //
103 // Insert the Package List node to Package List link of the whole database.
104 //
105 InsertTailList (&Private->DatabaseList, &DatabaseRecord->DatabaseEntry);
106
107 *DatabaseNode = DatabaseRecord;
108
109 return EFI_SUCCESS;
110}
111
112/**
113 This function checks whether a handle is a valid EFI_HII_HANDLE
114 This is a internal function.
115
116 @param Handle Pointer to a EFI_HII_HANDLE
117
118 @retval TRUE Valid
119 @retval FALSE Invalid
120
121**/
122BOOLEAN
123IsHiiHandleValid (
124 EFI_HII_HANDLE Handle
125 )
126{
127 HII_HANDLE *HiiHandle;
128
129 HiiHandle = (HII_HANDLE *)Handle;
130
131 if (HiiHandle == NULL) {
132 return FALSE;
133 }
134
135 if (HiiHandle->Signature != HII_HANDLE_SIGNATURE) {
136 return FALSE;
137 }
138
139 return TRUE;
140}
141
142/**
143 This function invokes the matching registered function.
144 This is a internal function.
145
146 @param Private HII Database driver private structure.
147 @param NotifyType The type of change concerning the database.
148 @param PackageInstance Points to the package referred to by the
149 notification.
150 @param PackageType Package type
151 @param Handle The handle of the package list which contains the
152 specified package.
153
154 @retval EFI_SUCCESS Already checked all registered function and
155 invoked if matched.
156 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
157
158**/
159EFI_STATUS
160InvokeRegisteredFunction (
161 IN HII_DATABASE_PRIVATE_DATA *Private,
162 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType,
163 IN VOID *PackageInstance,
164 IN UINT8 PackageType,
165 IN EFI_HII_HANDLE Handle
166 )
167{
168 HII_DATABASE_NOTIFY *Notify;
169 LIST_ENTRY *Link;
170 EFI_HII_PACKAGE_HEADER *Package;
171 UINT8 *Buffer;
172 UINT32 BufferSize;
173 UINT32 HeaderSize;
174 UINT32 ImageBlockSize;
175 UINT32 PaletteInfoSize;
176
177 if ((Private == NULL) || ((NotifyType & 0xF) == 0) || (PackageInstance == NULL)) {
178 return EFI_INVALID_PARAMETER;
179 }
180
181 if (Private->Signature != HII_DATABASE_PRIVATE_DATA_SIGNATURE) {
182 return EFI_INVALID_PARAMETER;
183 }
184
185 if (!IsHiiHandleValid (Handle)) {
186 return EFI_INVALID_PARAMETER;
187 }
188
189 Buffer = NULL;
190 Package = NULL;
191
192 //
193 // Convert the incoming package from hii database storage format to UEFI
194 // storage format. e.g. HII_GUID_PACKAGE_INSTANCE to EFI_HII_GUID_PACKAGE_HDR.
195 //
196 switch (PackageType) {
197 case EFI_HII_PACKAGE_TYPE_GUID:
198 Package = (EFI_HII_PACKAGE_HEADER *)(((HII_GUID_PACKAGE_INSTANCE *)PackageInstance)->GuidPkg);
199 break;
200
201 case EFI_HII_PACKAGE_FORMS:
202 BufferSize = ((HII_IFR_PACKAGE_INSTANCE *)PackageInstance)->FormPkgHdr.Length;
203 Buffer = (UINT8 *)AllocateZeroPool (BufferSize);
204 ASSERT (Buffer != NULL);
205 CopyMem (
206 Buffer,
207 &((HII_IFR_PACKAGE_INSTANCE *)PackageInstance)->FormPkgHdr,
208 sizeof (EFI_HII_PACKAGE_HEADER)
209 );
210 CopyMem (
211 Buffer + sizeof (EFI_HII_PACKAGE_HEADER),
212 ((HII_IFR_PACKAGE_INSTANCE *)PackageInstance)->IfrData,
213 BufferSize - sizeof (EFI_HII_PACKAGE_HEADER)
214 );
215 Package = (EFI_HII_PACKAGE_HEADER *)Buffer;
216 break;
217
218 case EFI_HII_PACKAGE_KEYBOARD_LAYOUT:
219 Package = (EFI_HII_PACKAGE_HEADER *)(((HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE *)PackageInstance)->KeyboardPkg);
220 break;
221
222 case EFI_HII_PACKAGE_STRINGS:
223 BufferSize = ((HII_STRING_PACKAGE_INSTANCE *)PackageInstance)->StringPkgHdr->Header.Length;
224 HeaderSize = ((HII_STRING_PACKAGE_INSTANCE *)PackageInstance)->StringPkgHdr->HdrSize;
225 Buffer = (UINT8 *)AllocateZeroPool (BufferSize);
226 ASSERT (Buffer != NULL);
227 CopyMem (
228 Buffer,
229 ((HII_STRING_PACKAGE_INSTANCE *)PackageInstance)->StringPkgHdr,
230 HeaderSize
231 );
232 CopyMem (
233 Buffer + HeaderSize,
234 ((HII_STRING_PACKAGE_INSTANCE *)PackageInstance)->StringBlock,
235 BufferSize - HeaderSize
236 );
237 Package = (EFI_HII_PACKAGE_HEADER *)Buffer;
238 break;
239
240 case EFI_HII_PACKAGE_FONTS:
241 BufferSize = ((HII_FONT_PACKAGE_INSTANCE *)PackageInstance)->FontPkgHdr->Header.Length;
242 HeaderSize = ((HII_FONT_PACKAGE_INSTANCE *)PackageInstance)->FontPkgHdr->HdrSize;
243 Buffer = (UINT8 *)AllocateZeroPool (BufferSize);
244 ASSERT (Buffer != NULL);
245 CopyMem (
246 Buffer,
247 ((HII_FONT_PACKAGE_INSTANCE *)PackageInstance)->FontPkgHdr,
248 HeaderSize
249 );
250 CopyMem (
251 Buffer + HeaderSize,
252 ((HII_FONT_PACKAGE_INSTANCE *)PackageInstance)->GlyphBlock,
253 BufferSize - HeaderSize
254 );
255 Package = (EFI_HII_PACKAGE_HEADER *)Buffer;
256 break;
257
258 case EFI_HII_PACKAGE_IMAGES:
259 BufferSize = ((HII_IMAGE_PACKAGE_INSTANCE *)PackageInstance)->ImagePkgHdr.Header.Length;
260 HeaderSize = sizeof (EFI_HII_IMAGE_PACKAGE_HDR);
261 Buffer = (UINT8 *)AllocateZeroPool (BufferSize);
262 ASSERT (Buffer != NULL);
263
264 CopyMem (
265 Buffer,
266 &((HII_IMAGE_PACKAGE_INSTANCE *)PackageInstance)->ImagePkgHdr,
267 HeaderSize
268 );
269 CopyMem (
270 Buffer + sizeof (EFI_HII_PACKAGE_HEADER),
271 &HeaderSize,
272 sizeof (UINT32)
273 );
274
275 ImageBlockSize = ((HII_IMAGE_PACKAGE_INSTANCE *)PackageInstance)->ImageBlockSize;
276 if (ImageBlockSize != 0) {
277 CopyMem (
278 Buffer + HeaderSize,
279 ((HII_IMAGE_PACKAGE_INSTANCE *)PackageInstance)->ImageBlock,
280 ImageBlockSize
281 );
282 }
283
284 PaletteInfoSize = ((HII_IMAGE_PACKAGE_INSTANCE *)PackageInstance)->PaletteInfoSize;
285 if (PaletteInfoSize != 0) {
286 CopyMem (
287 Buffer + HeaderSize + ImageBlockSize,
288 ((HII_IMAGE_PACKAGE_INSTANCE *)PackageInstance)->PaletteBlock,
289 PaletteInfoSize
290 );
291 HeaderSize += ImageBlockSize;
292 CopyMem (
293 Buffer + sizeof (EFI_HII_PACKAGE_HEADER) + sizeof (UINT32),
294 &HeaderSize,
295 sizeof (UINT32)
296 );
297 }
298
299 Package = (EFI_HII_PACKAGE_HEADER *)Buffer;
300 break;
301
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);
306 CopyMem (
307 Buffer,
308 ((HII_SIMPLE_FONT_PACKAGE_INSTANCE *)PackageInstance)->SimpleFontPkgHdr,
309 BufferSize
310 );
311 Package = (EFI_HII_PACKAGE_HEADER *)Buffer;
312 break;
313
314 case EFI_HII_PACKAGE_DEVICE_PATH:
315 Package = (EFI_HII_PACKAGE_HEADER *)PackageInstance;
316 break;
317
318 default:
319 return EFI_INVALID_PARAMETER;
320 }
321
322 for (Link = Private->DatabaseNotifyList.ForwardLink;
323 Link != &Private->DatabaseNotifyList;
324 Link = Link->ForwardLink
325 )
326 {
327 Notify = CR (Link, HII_DATABASE_NOTIFY, DatabaseNotifyEntry, HII_DATABASE_NOTIFY_SIGNATURE);
328 if ((Notify->NotifyType == NotifyType) && (Notify->PackageType == PackageType)) {
329 //
330 // Check in case PackageGuid is not NULL when Package is GUID package
331 //
332 if (PackageType != EFI_HII_PACKAGE_TYPE_GUID) {
333 Notify->PackageGuid = NULL;
334 }
335
336 //
337 // Status of Registered Function is unknown so did not check it
338 //
339 Notify->PackageNotifyFn (
340 Notify->PackageType,
341 Notify->PackageGuid,
342 Package,
343 Handle,
344 NotifyType
345 );
346 }
347 }
348
349 if (Buffer != NULL) {
350 FreePool (Buffer);
351 }
352
353 return EFI_SUCCESS;
354}
355
356/**
357 This function insert a GUID package to a package list node.
358 This is a internal function.
359
360 @param PackageHdr Pointer to a buffer stored with GUID package
361 information.
362 @param NotifyType The type of change concerning the database.
363 @param PackageList Pointer to a package list which will be inserted
364 to.
365 @param Package Created GUID package
366
367 @retval EFI_SUCCESS Guid Package is inserted successfully.
368 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
369 Guid package.
370 @retval EFI_INVALID_PARAMETER PackageHdr is NULL or PackageList is NULL.
371
372**/
373EFI_STATUS
374InsertGuidPackage (
375 IN VOID *PackageHdr,
376 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType,
377 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
378 OUT HII_GUID_PACKAGE_INSTANCE **Package
379 )
380{
381 HII_GUID_PACKAGE_INSTANCE *GuidPackage;
382 EFI_HII_PACKAGE_HEADER PackageHeader;
383
384 if ((PackageHdr == NULL) || (PackageList == NULL)) {
385 return EFI_INVALID_PARAMETER;
386 }
387
388 CopyMem (&PackageHeader, PackageHdr, sizeof (EFI_HII_PACKAGE_HEADER));
389
390 //
391 // Create a GUID package node
392 //
393 GuidPackage = (HII_GUID_PACKAGE_INSTANCE *)AllocateZeroPool (sizeof (HII_GUID_PACKAGE_INSTANCE));
394 if (GuidPackage == NULL) {
395 return EFI_OUT_OF_RESOURCES;
396 }
397
398 GuidPackage->GuidPkg = (UINT8 *)AllocateZeroPool (PackageHeader.Length);
399 if (GuidPackage->GuidPkg == NULL) {
400 FreePool (GuidPackage);
401 return EFI_OUT_OF_RESOURCES;
402 }
403
404 GuidPackage->Signature = HII_GUID_PACKAGE_SIGNATURE;
405 CopyMem (GuidPackage->GuidPkg, PackageHdr, PackageHeader.Length);
406 InsertTailList (&PackageList->GuidPkgHdr, &GuidPackage->GuidEntry);
407 *Package = GuidPackage;
408
409 if (NotifyType == EFI_HII_DATABASE_NOTIFY_ADD_PACK) {
410 PackageList->PackageListHdr.PackageLength += PackageHeader.Length;
411 }
412
413 return EFI_SUCCESS;
414}
415
416/**
417 This function exports GUID packages to a buffer.
418 This is a internal function.
419
420 @param Private Hii database private structure.
421 @param Handle Identification of a package list.
422 @param PackageList Pointer to a package list which will be exported.
423 @param UsedSize The length of buffer be used.
424 @param BufferSize Length of the Buffer.
425 @param Buffer Allocated space for storing exported data.
426 @param ResultSize The size of the already exported content of this
427 package list.
428
429 @retval EFI_SUCCESS Guid Packages are exported successfully.
430 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
431
432**/
433EFI_STATUS
434ExportGuidPackages (
435 IN HII_DATABASE_PRIVATE_DATA *Private,
436 IN EFI_HII_HANDLE Handle,
437 IN HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
438 IN UINTN UsedSize,
439 IN UINTN BufferSize,
440 IN OUT VOID *Buffer,
441 IN OUT UINTN *ResultSize
442 )
443{
444 HII_GUID_PACKAGE_INSTANCE *GuidPackage;
445 LIST_ENTRY *Link;
446 UINTN PackageLength;
447 EFI_HII_PACKAGE_HEADER PackageHeader;
448 EFI_STATUS Status;
449
450 if ((PackageList == NULL) || (ResultSize == NULL)) {
451 return EFI_INVALID_PARAMETER;
452 }
453
454 if ((BufferSize > 0) && (Buffer == NULL)) {
455 return EFI_INVALID_PARAMETER;
456 }
457
458 PackageLength = 0;
459 Status = EFI_SUCCESS;
460
461 for (Link = PackageList->GuidPkgHdr.ForwardLink; Link != &PackageList->GuidPkgHdr; Link = Link->ForwardLink) {
462 GuidPackage = CR (Link, HII_GUID_PACKAGE_INSTANCE, GuidEntry, HII_GUID_PACKAGE_SIGNATURE);
463 CopyMem (&PackageHeader, GuidPackage->GuidPkg, sizeof (EFI_HII_PACKAGE_HEADER));
464 PackageLength += PackageHeader.Length;
465 if (PackageLength + *ResultSize + UsedSize <= BufferSize) {
466 Status = InvokeRegisteredFunction (
467 Private,
468 EFI_HII_DATABASE_NOTIFY_EXPORT_PACK,
469 (VOID *)GuidPackage,
470 EFI_HII_PACKAGE_TYPE_GUID,
471 Handle
472 );
473 ASSERT_EFI_ERROR (Status);
474 CopyMem (Buffer, GuidPackage->GuidPkg, PackageHeader.Length);
475 Buffer = (UINT8 *)Buffer + PackageHeader.Length;
476 }
477 }
478
479 *ResultSize += PackageLength;
480 return EFI_SUCCESS;
481}
482
483/**
484 This function deletes all GUID packages from a package list node.
485 This is a internal function.
486
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
491 packages.
492
493 @retval EFI_SUCCESS GUID Package(s) is deleted successfully.
494 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
495
496**/
497EFI_STATUS
498RemoveGuidPackages (
499 IN HII_DATABASE_PRIVATE_DATA *Private,
500 IN EFI_HII_HANDLE Handle,
501 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList
502 )
503{
504 LIST_ENTRY *ListHead;
505 HII_GUID_PACKAGE_INSTANCE *Package;
506 EFI_STATUS Status;
507 EFI_HII_PACKAGE_HEADER PackageHeader;
508
509 ListHead = &PackageList->GuidPkgHdr;
510
511 while (!IsListEmpty (ListHead)) {
512 Package = CR (
513 ListHead->ForwardLink,
514 HII_GUID_PACKAGE_INSTANCE,
515 GuidEntry,
516 HII_GUID_PACKAGE_SIGNATURE
517 );
518 Status = InvokeRegisteredFunction (
519 Private,
520 EFI_HII_DATABASE_NOTIFY_REMOVE_PACK,
521 (VOID *)Package,
522 EFI_HII_PACKAGE_TYPE_GUID,
523 Handle
524 );
525 if (EFI_ERROR (Status)) {
526 return Status;
527 }
528
529 RemoveEntryList (&Package->GuidEntry);
530 CopyMem (&PackageHeader, Package->GuidPkg, sizeof (EFI_HII_PACKAGE_HEADER));
531 PackageList->PackageListHdr.PackageLength -= PackageHeader.Length;
532 FreePool (Package->GuidPkg);
533 FreePool (Package);
534 }
535
536 return EFI_SUCCESS;
537}
538
539/**
540 Check the input question related to EFI variable
541
542 @param IfrQuestionHdr Point to Question header
543 @param EfiVarStoreList Point to EFI VarStore List
544 @param EfiVarStoreNumber The number of EFI VarStore
545
546 @retval Index The index of the found EFI varstore in EFI varstore list
547 EfiVarStoreNumber will return if no EFI varstore is found.
548**/
549UINTN
550IsEfiVarStoreQuestion (
551 EFI_IFR_QUESTION_HEADER *IfrQuestionHdr,
552 EFI_IFR_VARSTORE_EFI **EfiVarStoreList,
553 UINTN EfiVarStoreNumber
554 )
555{
556 UINTN Index;
557
558 for (Index = 0; Index < EfiVarStoreNumber; Index++) {
559 if (IfrQuestionHdr->VarStoreId == EfiVarStoreList[Index]->VarStoreId) {
560 return Index;
561 }
562 }
563
564 return EfiVarStoreNumber;
565}
566
567/**
568 Find the matched variable from the input variable storage.
569
570 @param[in] VariableStorage Point to the variable storage header.
571 @param[in] VarGuid A unique identifier for the variable.
572 @param[in] VarAttribute The attributes bitmask for the variable.
573 @param[in] VarName A Null-terminated ascii string that is the name of the variable.
574
575 @return Pointer to the matched variable header or NULL if not found.
576**/
577VARIABLE_HEADER *
578FindVariableData (
579 IN VARIABLE_STORE_HEADER *VariableStorage,
580 IN EFI_GUID *VarGuid,
581 IN UINT32 VarAttribute,
582 IN CHAR16 *VarName
583 )
584{
585 VARIABLE_HEADER *VariableHeader;
586 VARIABLE_HEADER *VariableEnd;
587
588 VariableEnd = (VARIABLE_HEADER *)((UINT8 *)VariableStorage + VariableStorage->Size);
589 VariableHeader = (VARIABLE_HEADER *)(VariableStorage + 1);
590 VariableHeader = (VARIABLE_HEADER *)HEADER_ALIGN (VariableHeader);
591 while (VariableHeader < VariableEnd) {
592 if (CompareGuid (&VariableHeader->VendorGuid, VarGuid) &&
593 (VariableHeader->Attributes == VarAttribute) &&
594 (StrCmp (VarName, (CHAR16 *)(VariableHeader + 1)) == 0))
595 {
596 return VariableHeader;
597 }
598
599 VariableHeader = (VARIABLE_HEADER *)((UINT8 *)VariableHeader + sizeof (VARIABLE_HEADER) + VariableHeader->NameSize + VariableHeader->DataSize);
600 VariableHeader = (VARIABLE_HEADER *)HEADER_ALIGN (VariableHeader);
601 }
602
603 return NULL;
604}
605
606/**
607 Find question default value from PcdNvStoreDefaultValueBuffer
608
609 @param DefaultId Default store ID
610 @param EfiVarStore Point to EFI VarStore header
611 @param IfrQuestionHdr Point to Question header
612 @param ValueBuffer Point to Buffer includes the found default setting
613 @param Width Width of the default value
614 @param BitFieldQuestion Whether the Question is stored in Bit field.
615
616 @retval EFI_SUCCESS Question default value is found.
617 @retval EFI_NOT_FOUND Question default value is not found.
618**/
619EFI_STATUS
620FindQuestionDefaultSetting (
621 IN UINT16 DefaultId,
622 IN EFI_IFR_VARSTORE_EFI *EfiVarStore,
623 IN EFI_IFR_QUESTION_HEADER *IfrQuestionHdr,
624 OUT VOID *ValueBuffer,
625 IN UINTN Width,
626 IN BOOLEAN BitFieldQuestion
627 )
628{
629 VARIABLE_HEADER *VariableHeader;
630 VARIABLE_STORE_HEADER *VariableStorage;
631 LIST_ENTRY *Link;
632 VARSTORAGE_DEFAULT_DATA *Entry;
633 VARIABLE_STORE_HEADER *NvStoreBuffer;
634 UINT8 *DataBuffer;
635 UINT8 *BufferEnd;
636 BOOLEAN IsFound;
637 UINTN Index;
638 UINT32 BufferValue;
639 UINT32 BitFieldVal;
640 UINTN BitOffset;
641 UINTN ByteOffset;
642 UINTN BitWidth;
643 UINTN StartBit;
644 UINTN EndBit;
645 PCD_DEFAULT_DATA *DataHeader;
646 PCD_DEFAULT_INFO *DefaultInfo;
647 PCD_DATA_DELTA *DeltaData;
648
649 if (gSkuId == 0xFFFFFFFFFFFFFFFF) {
650 gSkuId = LibPcdGetSku ();
651 }
652
653 //
654 // Find the DefaultId setting from the full DefaultSetting
655 //
656 VariableStorage = NULL;
657 Link = gVarStorageList.ForwardLink;
658 while (Link != &gVarStorageList) {
659 Entry = BASE_CR (Link, VARSTORAGE_DEFAULT_DATA, Entry);
660 if (Entry->DefaultId == DefaultId) {
661 VariableStorage = Entry->VariableStorage;
662 break;
663 }
664
665 Link = Link->ForwardLink;
666 }
667
668 if (Link == &gVarStorageList) {
669 DataBuffer = (UINT8 *)PcdGetPtr (PcdNvStoreDefaultValueBuffer);
670 gNvDefaultStoreSize = ((PCD_NV_STORE_DEFAULT_BUFFER_HEADER *)DataBuffer)->Length;
671 //
672 // The first section data includes NV storage default setting.
673 //
674 DataHeader = (PCD_DEFAULT_DATA *)(DataBuffer + sizeof (PCD_NV_STORE_DEFAULT_BUFFER_HEADER));
675 NvStoreBuffer = (VARIABLE_STORE_HEADER *)((UINT8 *)DataHeader + sizeof (DataHeader->DataSize) + DataHeader->HeaderSize);
676 VariableStorage = AllocatePool (NvStoreBuffer->Size);
677 ASSERT (VariableStorage != NULL);
678 CopyMem (VariableStorage, NvStoreBuffer, NvStoreBuffer->Size);
679
680 //
681 // Find the matched SkuId and DefaultId in the first section
682 //
683 IsFound = FALSE;
684 DefaultInfo = &(DataHeader->DefaultInfo[0]);
685 BufferEnd = (UINT8 *)DataHeader + sizeof (DataHeader->DataSize) + DataHeader->HeaderSize;
686 while ((UINT8 *)DefaultInfo < BufferEnd) {
687 if ((DefaultInfo->DefaultId == DefaultId) && (DefaultInfo->SkuId == gSkuId)) {
688 IsFound = TRUE;
689 break;
690 }
691
692 DefaultInfo++;
693 }
694
695 //
696 // Find the matched SkuId and DefaultId in the remaining section
697 //
698 Index = sizeof (PCD_NV_STORE_DEFAULT_BUFFER_HEADER) + ((DataHeader->DataSize + 7) & (~7));
699 DataHeader = (PCD_DEFAULT_DATA *)(DataBuffer + Index);
700 while (!IsFound && Index < gNvDefaultStoreSize && DataHeader->DataSize != 0xFFFF) {
701 DefaultInfo = &(DataHeader->DefaultInfo[0]);
702 BufferEnd = (UINT8 *)DataHeader + sizeof (DataHeader->DataSize) + DataHeader->HeaderSize;
703 while ((UINT8 *)DefaultInfo < BufferEnd) {
704 if ((DefaultInfo->DefaultId == DefaultId) && (DefaultInfo->SkuId == gSkuId)) {
705 IsFound = TRUE;
706 break;
707 }
708
709 DefaultInfo++;
710 }
711
712 if (IsFound) {
713 DeltaData = (PCD_DATA_DELTA *)BufferEnd;
714 BufferEnd = (UINT8 *)DataHeader + DataHeader->DataSize;
715 while ((UINT8 *)DeltaData < BufferEnd) {
716 *((UINT8 *)VariableStorage + DeltaData->Offset) = (UINT8)DeltaData->Value;
717 DeltaData++;
718 }
719
720 break;
721 }
722
723 Index = (Index + DataHeader->DataSize + 7) & (~7);
724 DataHeader = (PCD_DEFAULT_DATA *)(DataBuffer + Index);
725 }
726
727 //
728 // Cache the found result in VarStorageList
729 //
730 if (!IsFound) {
731 FreePool (VariableStorage);
732 VariableStorage = NULL;
733 }
734
735 Entry = AllocatePool (sizeof (VARSTORAGE_DEFAULT_DATA));
736 if (Entry != NULL) {
737 Entry->DefaultId = DefaultId;
738 Entry->VariableStorage = VariableStorage;
739 InsertTailList (&gVarStorageList, &Entry->Entry);
740 } else if (VariableStorage != NULL) {
741 FreePool (VariableStorage);
742 VariableStorage = NULL;
743 }
744 }
745
746 //
747 // The matched variable storage is not found.
748 //
749 if (VariableStorage == NULL) {
750 return EFI_NOT_FOUND;
751 }
752
753 //
754 // Find the question default value from the variable storage
755 //
756 VariableHeader = FindVariableData (VariableStorage, &EfiVarStore->Guid, EfiVarStore->Attributes, (CHAR16 *)EfiVarStore->Name);
757 if (VariableHeader == NULL) {
758 return EFI_NOT_FOUND;
759 }
760
761 StartBit = 0;
762 EndBit = 0;
763 ByteOffset = IfrQuestionHdr->VarStoreInfo.VarOffset;
764 if (BitFieldQuestion) {
765 BitOffset = IfrQuestionHdr->VarStoreInfo.VarOffset;
766 ByteOffset = BitOffset / 8;
767 BitWidth = Width;
768 StartBit = BitOffset % 8;
769 EndBit = StartBit + BitWidth - 1;
770 Width = EndBit / 8 + 1;
771 }
772
773 if (VariableHeader->DataSize < ByteOffset + Width) {
774 return EFI_INVALID_PARAMETER;
775 }
776
777 //
778 // Copy the question value
779 //
780 if (ValueBuffer != NULL) {
781 if (BitFieldQuestion) {
782 CopyMem (&BufferValue, (UINT8 *)VariableHeader + sizeof (VARIABLE_HEADER) + VariableHeader->NameSize + ByteOffset, Width);
783 BitFieldVal = BitFieldRead32 (BufferValue, StartBit, EndBit);
784 CopyMem (ValueBuffer, &BitFieldVal, Width);
785 } else {
786 CopyMem (ValueBuffer, (UINT8 *)VariableHeader + sizeof (VARIABLE_HEADER) + VariableHeader->NameSize + IfrQuestionHdr->VarStoreInfo.VarOffset, Width);
787 }
788 }
789
790 return EFI_SUCCESS;
791}
792
793/**
794 Update IFR default setting in Form Package.
795
796 @param FormPackage Form Package to be updated
797
798**/
799VOID
800UpdateDefaultSettingInFormPackage (
801 HII_IFR_PACKAGE_INSTANCE *FormPackage
802 )
803{
804 UINTN IfrOffset;
805 UINTN PackageLength;
806 EFI_IFR_VARSTORE_EFI *IfrEfiVarStore;
807 EFI_IFR_OP_HEADER *IfrOpHdr;
808 EFI_IFR_ONE_OF_OPTION *IfrOneOfOption;
809 UINT8 IfrQuestionType;
810 UINT8 IfrScope;
811 EFI_IFR_QUESTION_HEADER *IfrQuestionHdr;
812 EFI_IFR_VARSTORE_EFI **EfiVarStoreList;
813 UINTN EfiVarStoreMaxNum;
814 UINTN EfiVarStoreNumber;
815 UINT16 *DefaultIdList;
816 UINTN DefaultIdNumber;
817 UINTN DefaultIdMaxNum;
818 UINTN Index;
819 UINTN EfiVarStoreIndex;
820 EFI_IFR_TYPE_VALUE IfrValue;
821 EFI_IFR_TYPE_VALUE IfrManufactValue;
822 BOOLEAN StandardDefaultIsSet;
823 BOOLEAN ManufactDefaultIsSet;
824 EFI_IFR_CHECKBOX *IfrCheckBox;
825 EFI_STATUS Status;
826 EFI_IFR_DEFAULT *IfrDefault;
827 UINTN Width;
828 EFI_IFR_QUESTION_HEADER VarStoreQuestionHeader;
829 BOOLEAN QuestionReferBitField;
830
831 //
832 // If no default setting, do nothing
833 //
834 if (gNvDefaultStoreSize == 0) {
835 gNvDefaultStoreSize = PcdGetSize (PcdNvStoreDefaultValueBuffer);
836 }
837
838 if (gNvDefaultStoreSize < sizeof (PCD_NV_STORE_DEFAULT_BUFFER_HEADER)) {
839 return;
840 }
841
842 ZeroMem (&VarStoreQuestionHeader, sizeof (VarStoreQuestionHeader));
843 PackageLength = FormPackage->FormPkgHdr.Length - sizeof (EFI_HII_PACKAGE_HEADER);
844 Width = 0;
845 IfrOffset = 0;
846 IfrScope = 0;
847 IfrOpHdr = (EFI_IFR_OP_HEADER *)FormPackage->IfrData;
848 IfrQuestionHdr = NULL;
849 IfrQuestionType = 0;
850 EfiVarStoreMaxNum = 0;
851 EfiVarStoreNumber = 0;
852 DefaultIdMaxNum = 0;
853 DefaultIdNumber = 0;
854 EfiVarStoreList = NULL;
855 DefaultIdList = NULL;
856 StandardDefaultIsSet = FALSE;
857 ManufactDefaultIsSet = FALSE;
858 QuestionReferBitField = FALSE;
859
860 while (IfrOffset < PackageLength) {
861 switch (IfrOpHdr->OpCode) {
862 case EFI_IFR_VARSTORE_EFI_OP:
863 if (EfiVarStoreNumber >= EfiVarStoreMaxNum) {
864 //
865 // Reallocate EFI VarStore Buffer
866 //
867 EfiVarStoreList = ReallocatePool (EfiVarStoreMaxNum * sizeof (UINTN), (EfiVarStoreMaxNum + BASE_NUMBER) * sizeof (UINTN), EfiVarStoreList);
868 if (EfiVarStoreList == NULL) {
869 goto Done;
870 }
871
872 EfiVarStoreMaxNum = EfiVarStoreMaxNum + BASE_NUMBER;
873 }
874
875 IfrEfiVarStore = (EFI_IFR_VARSTORE_EFI *)IfrOpHdr;
876 //
877 // Convert VarStore Name from ASCII string to Unicode string.
878 //
879 EfiVarStoreList[EfiVarStoreNumber] = AllocatePool (IfrEfiVarStore->Header.Length + AsciiStrSize ((CHAR8 *)IfrEfiVarStore->Name));
880 if (EfiVarStoreList[EfiVarStoreNumber] == NULL) {
881 break;
882 }
883
884 CopyMem (EfiVarStoreList[EfiVarStoreNumber], IfrEfiVarStore, IfrEfiVarStore->Header.Length);
885 AsciiStrToUnicodeStrS ((CHAR8 *)IfrEfiVarStore->Name, (CHAR16 *)&(EfiVarStoreList[EfiVarStoreNumber]->Name[0]), AsciiStrSize ((CHAR8 *)IfrEfiVarStore->Name) * sizeof (CHAR16));
886 Status = FindQuestionDefaultSetting (EFI_HII_DEFAULT_CLASS_STANDARD, EfiVarStoreList[EfiVarStoreNumber], &VarStoreQuestionHeader, NULL, IfrEfiVarStore->Size, FALSE);
887 if (!EFI_ERROR (Status)) {
888 EfiVarStoreNumber++;
889 } else {
890 FreePool (EfiVarStoreList[EfiVarStoreNumber]);
891 EfiVarStoreList[EfiVarStoreNumber] = NULL;
892 }
893
894 break;
895 case EFI_IFR_DEFAULTSTORE_OP:
896 if (DefaultIdNumber >= DefaultIdMaxNum) {
897 //
898 // Reallocate DefaultIdNumber
899 //
900 DefaultIdList = ReallocatePool (DefaultIdMaxNum * sizeof (UINT16), (DefaultIdMaxNum + BASE_NUMBER) * sizeof (UINT16), DefaultIdList);
901 if (DefaultIdList == NULL) {
902 goto Done;
903 }
904
905 DefaultIdMaxNum = DefaultIdMaxNum + BASE_NUMBER;
906 }
907
908 DefaultIdList[DefaultIdNumber++] = ((EFI_IFR_DEFAULTSTORE *)IfrOpHdr)->DefaultId;
909 break;
910 case EFI_IFR_FORM_OP:
911 case EFI_IFR_FORM_MAP_OP:
912 //
913 // No EFI varstore is found and directly return.
914 //
915 if ((EfiVarStoreNumber == 0) || (DefaultIdNumber == 0)) {
916 goto Done;
917 }
918
919 break;
920 case EFI_IFR_CHECKBOX_OP:
921 IfrScope = IfrOpHdr->Scope;
922 IfrQuestionType = IfrOpHdr->OpCode;
923 IfrQuestionHdr = (EFI_IFR_QUESTION_HEADER *)(IfrOpHdr + 1);
924 IfrCheckBox = (EFI_IFR_CHECKBOX *)IfrOpHdr;
925 EfiVarStoreIndex = IsEfiVarStoreQuestion (IfrQuestionHdr, EfiVarStoreList, EfiVarStoreNumber);
926 Width = sizeof (BOOLEAN);
927 if (EfiVarStoreIndex < EfiVarStoreNumber) {
928 for (Index = 0; Index < DefaultIdNumber; Index++) {
929 if (DefaultIdList[Index] == EFI_HII_DEFAULT_CLASS_STANDARD) {
930 Status = FindQuestionDefaultSetting (DefaultIdList[Index], EfiVarStoreList[EfiVarStoreIndex], IfrQuestionHdr, &IfrValue, sizeof (BOOLEAN), QuestionReferBitField);
931 if (!EFI_ERROR (Status)) {
932 if (IfrValue.b) {
933 IfrCheckBox->Flags = IfrCheckBox->Flags | EFI_IFR_CHECKBOX_DEFAULT;
934 } else {
935 IfrCheckBox->Flags = IfrCheckBox->Flags & (~EFI_IFR_CHECKBOX_DEFAULT);
936 }
937 }
938 } else if (DefaultIdList[Index] == EFI_HII_DEFAULT_CLASS_MANUFACTURING) {
939 Status = FindQuestionDefaultSetting (DefaultIdList[Index], EfiVarStoreList[EfiVarStoreIndex], IfrQuestionHdr, &IfrValue, sizeof (BOOLEAN), QuestionReferBitField);
940 if (!EFI_ERROR (Status)) {
941 if (IfrValue.b) {
942 IfrCheckBox->Flags = IfrCheckBox->Flags | EFI_IFR_CHECKBOX_DEFAULT_MFG;
943 } else {
944 IfrCheckBox->Flags = IfrCheckBox->Flags & (~EFI_IFR_CHECKBOX_DEFAULT_MFG);
945 }
946 }
947 }
948 }
949 }
950
951 break;
952 case EFI_IFR_NUMERIC_OP:
953 IfrScope = IfrOpHdr->Scope;
954 IfrQuestionType = IfrOpHdr->OpCode;
955 IfrQuestionHdr = (EFI_IFR_QUESTION_HEADER *)(IfrOpHdr + 1);
956 if (QuestionReferBitField) {
957 Width = (UINTN)(((EFI_IFR_ONE_OF *)IfrOpHdr)->Flags & EDKII_IFR_NUMERIC_SIZE_BIT);
958 } else {
959 Width = (UINTN)((UINT32)1 << (((EFI_IFR_ONE_OF *)IfrOpHdr)->Flags & EFI_IFR_NUMERIC_SIZE));
960 }
961
962 break;
963 case EFI_IFR_ONE_OF_OP:
964 IfrScope = IfrOpHdr->Scope;
965 IfrQuestionType = IfrOpHdr->OpCode;
966 IfrQuestionHdr = (EFI_IFR_QUESTION_HEADER *)(IfrOpHdr + 1);
967 if (QuestionReferBitField) {
968 Width = (UINTN)(((EFI_IFR_ONE_OF *)IfrOpHdr)->Flags & EDKII_IFR_NUMERIC_SIZE_BIT);
969 } else {
970 Width = (UINTN)((UINT32)1 << (((EFI_IFR_ONE_OF *)IfrOpHdr)->Flags & EFI_IFR_NUMERIC_SIZE));
971 }
972
973 EfiVarStoreIndex = IsEfiVarStoreQuestion (IfrQuestionHdr, EfiVarStoreList, EfiVarStoreNumber);
974 StandardDefaultIsSet = FALSE;
975 ManufactDefaultIsSet = FALSE;
976 //
977 // Find Default and Manufacturing default for OneOf question
978 //
979 if (EfiVarStoreIndex < EfiVarStoreNumber) {
980 for (Index = 0; Index < DefaultIdNumber; Index++) {
981 if (DefaultIdList[Index] == EFI_HII_DEFAULT_CLASS_STANDARD) {
982 Status = FindQuestionDefaultSetting (EFI_HII_DEFAULT_CLASS_STANDARD, EfiVarStoreList[EfiVarStoreIndex], IfrQuestionHdr, &IfrValue, Width, QuestionReferBitField);
983 if (!EFI_ERROR (Status)) {
984 StandardDefaultIsSet = TRUE;
985 }
986 } else if (DefaultIdList[Index] == EFI_HII_DEFAULT_CLASS_MANUFACTURING) {
987 Status = FindQuestionDefaultSetting (EFI_HII_DEFAULT_CLASS_MANUFACTURING, EfiVarStoreList[EfiVarStoreIndex], IfrQuestionHdr, &IfrManufactValue, Width, QuestionReferBitField);
988 if (!EFI_ERROR (Status)) {
989 ManufactDefaultIsSet = TRUE;
990 }
991 }
992 }
993 }
994
995 break;
996 case EFI_IFR_ORDERED_LIST_OP:
997 IfrScope = IfrOpHdr->Scope;
998 IfrQuestionType = IfrOpHdr->OpCode;
999 IfrQuestionHdr = (EFI_IFR_QUESTION_HEADER *)(IfrOpHdr + 1);
1000 break;
1001 case EFI_IFR_ONE_OF_OPTION_OP:
1002 if ((IfrQuestionHdr != NULL) && (IfrScope > 0)) {
1003 IfrOneOfOption = (EFI_IFR_ONE_OF_OPTION *)IfrOpHdr;
1004 if (IfrQuestionType == EFI_IFR_ONE_OF_OP) {
1005 Width = (UINTN)((UINT32)1 << (IfrOneOfOption->Flags & EFI_IFR_NUMERIC_SIZE));
1006 if (StandardDefaultIsSet) {
1007 if (CompareMem (&IfrOneOfOption->Value, &IfrValue, Width) == 0) {
1008 IfrOneOfOption->Flags |= EFI_IFR_OPTION_DEFAULT;
1009 } else {
1010 IfrOneOfOption->Flags &= ~EFI_IFR_OPTION_DEFAULT;
1011 }
1012 }
1013
1014 if (ManufactDefaultIsSet) {
1015 if (CompareMem (&IfrOneOfOption->Value, &IfrManufactValue, Width) == 0) {
1016 IfrOneOfOption->Flags |= EFI_IFR_OPTION_DEFAULT_MFG;
1017 } else {
1018 IfrOneOfOption->Flags &= ~EFI_IFR_OPTION_DEFAULT_MFG;
1019 }
1020 }
1021 }
1022 }
1023
1024 break;
1025 case EFI_IFR_DEFAULT_OP:
1026 if ((IfrQuestionHdr != NULL) && (IfrScope > 0)) {
1027 IfrDefault = (EFI_IFR_DEFAULT *)IfrOpHdr;
1028 //
1029 // Collect default value width
1030 //
1031 if (!QuestionReferBitField) {
1032 Width = 0;
1033 if ((IfrDefault->Type == EFI_IFR_TYPE_NUM_SIZE_8) || (IfrDefault->Type == EFI_IFR_TYPE_BOOLEAN)) {
1034 Width = 1;
1035 } else if (IfrDefault->Type == EFI_IFR_TYPE_NUM_SIZE_16) {
1036 Width = 2;
1037 } else if (IfrDefault->Type == EFI_IFR_TYPE_NUM_SIZE_32) {
1038 Width = 4;
1039 } else if (IfrDefault->Type == EFI_IFR_TYPE_NUM_SIZE_64) {
1040 Width = 8;
1041 } else if (IfrDefault->Type == EFI_IFR_TYPE_BUFFER) {
1042 Width = IfrDefault->Header.Length - OFFSET_OF (EFI_IFR_DEFAULT, Value);
1043 }
1044 }
1045
1046 //
1047 // Update the default value
1048 //
1049 if (Width > 0) {
1050 EfiVarStoreIndex = IsEfiVarStoreQuestion (IfrQuestionHdr, EfiVarStoreList, EfiVarStoreNumber);
1051 if (EfiVarStoreIndex < EfiVarStoreNumber) {
1052 Status = FindQuestionDefaultSetting (IfrDefault->DefaultId, EfiVarStoreList[EfiVarStoreIndex], IfrQuestionHdr, &IfrDefault->Value, Width, QuestionReferBitField);
1053 }
1054 }
1055 }
1056
1057 break;
1058 case EFI_IFR_END_OP:
1059 if (IfrQuestionHdr != NULL) {
1060 if (IfrScope > 0) {
1061 IfrScope--;
1062 }
1063
1064 if (IfrScope == 0) {
1065 IfrQuestionHdr = NULL;
1066 QuestionReferBitField = FALSE;
1067 }
1068 }
1069
1070 break;
1071 case EFI_IFR_GUID_OP:
1072 if (CompareGuid ((EFI_GUID *)((UINT8 *)IfrOpHdr + sizeof (EFI_IFR_OP_HEADER)), &gEdkiiIfrBitVarstoreGuid)) {
1073 QuestionReferBitField = TRUE;
1074 }
1075
1076 break;
1077 default:
1078 break;
1079 }
1080
1081 IfrOffset = IfrOffset + IfrOpHdr->Length;
1082 IfrOpHdr = (EFI_IFR_OP_HEADER *)((UINT8 *)IfrOpHdr + IfrOpHdr->Length);
1083 if (IfrScope > 0) {
1084 IfrScope += IfrOpHdr->Scope;
1085 }
1086 }
1087
1088Done:
1089 if (EfiVarStoreList != NULL) {
1090 for (Index = 0; Index < EfiVarStoreNumber; Index++) {
1091 FreePool (EfiVarStoreList[Index]);
1092 }
1093 }
1094
1095 return;
1096}
1097
1098/**
1099 This function insert a Form package to a package list node.
1100 This is a internal function.
1101
1102 @param PackageHdr Pointer to a buffer stored with Form package
1103 information.
1104 @param NotifyType The type of change concerning the database.
1105 @param PackageList Pointer to a package list which will be inserted
1106 to.
1107 @param Package Created Form package
1108
1109 @retval EFI_SUCCESS Form Package is inserted successfully.
1110 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
1111 Form package.
1112 @retval EFI_INVALID_PARAMETER PackageHdr is NULL or PackageList is NULL.
1113
1114**/
1115EFI_STATUS
1116InsertFormPackage (
1117 IN VOID *PackageHdr,
1118 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType,
1119 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
1120 OUT HII_IFR_PACKAGE_INSTANCE **Package
1121 )
1122{
1123 HII_IFR_PACKAGE_INSTANCE *FormPackage;
1124 EFI_HII_PACKAGE_HEADER PackageHeader;
1125
1126 if ((PackageHdr == NULL) || (PackageList == NULL)) {
1127 return EFI_INVALID_PARAMETER;
1128 }
1129
1130 //
1131 // Get the length of the package, including package header itself
1132 //
1133 CopyMem (&PackageHeader, PackageHdr, sizeof (EFI_HII_PACKAGE_HEADER));
1134
1135 //
1136 // Create a Form package node
1137 //
1138 FormPackage = (HII_IFR_PACKAGE_INSTANCE *)AllocateZeroPool (sizeof (HII_IFR_PACKAGE_INSTANCE));
1139 if (FormPackage == NULL) {
1140 return EFI_OUT_OF_RESOURCES;
1141 }
1142
1143 FormPackage->IfrData = (UINT8 *)AllocateZeroPool (PackageHeader.Length - sizeof (EFI_HII_PACKAGE_HEADER));
1144 if (FormPackage->IfrData == NULL) {
1145 FreePool (FormPackage);
1146 return EFI_OUT_OF_RESOURCES;
1147 }
1148
1149 FormPackage->Signature = HII_IFR_PACKAGE_SIGNATURE;
1150 //
1151 // Copy Package Header
1152 //
1153 CopyMem (&FormPackage->FormPkgHdr, &PackageHeader, sizeof (EFI_HII_PACKAGE_HEADER));
1154
1155 //
1156 // Copy Ifr contents
1157 //
1158 CopyMem (
1159 FormPackage->IfrData,
1160 (UINT8 *)PackageHdr + sizeof (EFI_HII_PACKAGE_HEADER),
1161 PackageHeader.Length - sizeof (EFI_HII_PACKAGE_HEADER)
1162 );
1163
1164 InsertTailList (&PackageList->FormPkgHdr, &FormPackage->IfrEntry);
1165 *Package = FormPackage;
1166
1167 //
1168 // Update FormPackage with the default setting
1169 //
1170 UpdateDefaultSettingInFormPackage (FormPackage);
1171
1172 if (NotifyType == EFI_HII_DATABASE_NOTIFY_ADD_PACK) {
1173 PackageList->PackageListHdr.PackageLength += FormPackage->FormPkgHdr.Length;
1174 }
1175
1176 return EFI_SUCCESS;
1177}
1178
1179/**
1180 This function exports Form packages to a buffer.
1181 This is a internal function.
1182
1183 @param Private Hii database private structure.
1184 @param Handle Identification of a package list.
1185 @param PackageList Pointer to a package list which will be exported.
1186 @param UsedSize The length of buffer be used.
1187 @param BufferSize Length of the Buffer.
1188 @param Buffer Allocated space for storing exported data.
1189 @param ResultSize The size of the already exported content of this
1190 package list.
1191
1192 @retval EFI_SUCCESS Form Packages are exported successfully.
1193 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
1194
1195**/
1196EFI_STATUS
1197ExportFormPackages (
1198 IN HII_DATABASE_PRIVATE_DATA *Private,
1199 IN EFI_HII_HANDLE Handle,
1200 IN HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
1201 IN UINTN UsedSize,
1202 IN UINTN BufferSize,
1203 IN OUT VOID *Buffer,
1204 IN OUT UINTN *ResultSize
1205 )
1206{
1207 HII_IFR_PACKAGE_INSTANCE *FormPackage;
1208 UINTN PackageLength;
1209 LIST_ENTRY *Link;
1210 EFI_STATUS Status;
1211
1212 if ((Private == NULL) || (PackageList == NULL) || (ResultSize == NULL)) {
1213 return EFI_INVALID_PARAMETER;
1214 }
1215
1216 if ((BufferSize > 0) && (Buffer == NULL)) {
1217 return EFI_INVALID_PARAMETER;
1218 }
1219
1220 PackageLength = 0;
1221 Status = EFI_SUCCESS;
1222
1223 //
1224 // Export Form packages.
1225 //
1226 for (Link = PackageList->FormPkgHdr.ForwardLink; Link != &PackageList->FormPkgHdr; Link = Link->ForwardLink) {
1227 FormPackage = CR (Link, HII_IFR_PACKAGE_INSTANCE, IfrEntry, HII_IFR_PACKAGE_SIGNATURE);
1228 PackageLength += FormPackage->FormPkgHdr.Length;
1229 if ((Buffer != NULL) && (PackageLength + *ResultSize + UsedSize <= BufferSize)) {
1230 //
1231 // Invoke registered notification if exists
1232 //
1233 Status = InvokeRegisteredFunction (
1234 Private,
1235 EFI_HII_DATABASE_NOTIFY_EXPORT_PACK,
1236 (VOID *)FormPackage,
1237 EFI_HII_PACKAGE_FORMS,
1238 Handle
1239 );
1240 ASSERT_EFI_ERROR (Status);
1241 //
1242 // Copy the Form package content.
1243 //
1244 CopyMem (Buffer, (VOID *)(&FormPackage->FormPkgHdr), sizeof (EFI_HII_PACKAGE_HEADER));
1245 Buffer = (UINT8 *)Buffer + sizeof (EFI_HII_PACKAGE_HEADER);
1246 CopyMem (
1247 Buffer,
1248 (VOID *)FormPackage->IfrData,
1249 FormPackage->FormPkgHdr.Length - sizeof (EFI_HII_PACKAGE_HEADER)
1250 );
1251 Buffer = (UINT8 *)Buffer + FormPackage->FormPkgHdr.Length - sizeof (EFI_HII_PACKAGE_HEADER);
1252 }
1253 }
1254
1255 *ResultSize += PackageLength;
1256
1257 return EFI_SUCCESS;
1258}
1259
1260/**
1261 This function deletes all Form packages from a package list node.
1262 This is a internal function.
1263
1264 @param Private Hii database private data.
1265 @param Handle Handle of the package list which contains the to
1266 be removed Form packages.
1267 @param PackageList Pointer to a package list that contains removing
1268 packages.
1269
1270 @retval EFI_SUCCESS Form Package(s) is deleted successfully.
1271 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
1272
1273**/
1274EFI_STATUS
1275RemoveFormPackages (
1276 IN HII_DATABASE_PRIVATE_DATA *Private,
1277 IN EFI_HII_HANDLE Handle,
1278 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList
1279 )
1280{
1281 LIST_ENTRY *ListHead;
1282 HII_IFR_PACKAGE_INSTANCE *Package;
1283 EFI_STATUS Status;
1284
1285 ListHead = &PackageList->FormPkgHdr;
1286
1287 while (!IsListEmpty (ListHead)) {
1288 Package = CR (
1289 ListHead->ForwardLink,
1290 HII_IFR_PACKAGE_INSTANCE,
1291 IfrEntry,
1292 HII_IFR_PACKAGE_SIGNATURE
1293 );
1294 Status = InvokeRegisteredFunction (
1295 Private,
1296 EFI_HII_DATABASE_NOTIFY_REMOVE_PACK,
1297 (VOID *)Package,
1298 EFI_HII_PACKAGE_FORMS,
1299 Handle
1300 );
1301 if (EFI_ERROR (Status)) {
1302 return Status;
1303 }
1304
1305 RemoveEntryList (&Package->IfrEntry);
1306 PackageList->PackageListHdr.PackageLength -= Package->FormPkgHdr.Length;
1307 FreePool (Package->IfrData);
1308 FreePool (Package);
1309 //
1310 // If Hii runtime support feature is enabled,
1311 // will export Hii info for runtime use after ReadyToBoot event triggered.
1312 // If some driver add/update/remove packages from HiiDatabase after ReadyToBoot,
1313 // will need to export the content of HiiDatabase.
1314 // But if form packages removed, also need to export the ConfigResp string
1315 //
1316 if (gExportAfterReadyToBoot) {
1317 gExportConfigResp = TRUE;
1318 }
1319 }
1320
1321 return EFI_SUCCESS;
1322}
1323
1324/**
1325 This function insert a String package to a package list node.
1326 This is a internal function.
1327
1328 @param Private Hii database private structure.
1329 @param PackageHdr Pointer to a buffer stored with String package
1330 information.
1331 @param NotifyType The type of change concerning the database.
1332 @param PackageList Pointer to a package list which will be inserted
1333 to.
1334 @param Package Created String package
1335
1336 @retval EFI_SUCCESS String Package is inserted successfully.
1337 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
1338 String package.
1339 @retval EFI_INVALID_PARAMETER PackageHdr is NULL or PackageList is NULL.
1340 @retval EFI_UNSUPPORTED A string package with the same language already
1341 exists in current package list.
1342
1343**/
1344EFI_STATUS
1345InsertStringPackage (
1346 IN HII_DATABASE_PRIVATE_DATA *Private,
1347 IN VOID *PackageHdr,
1348 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType,
1349 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
1350 OUT HII_STRING_PACKAGE_INSTANCE **Package
1351 )
1352{
1353 HII_STRING_PACKAGE_INSTANCE *StringPackage;
1354 UINT32 HeaderSize;
1355 EFI_STATUS Status;
1356 EFI_HII_PACKAGE_HEADER PackageHeader;
1357 CHAR8 *Language;
1358 UINT32 LanguageSize;
1359 LIST_ENTRY *Link;
1360
1361 if ((Private == NULL) || (PackageHdr == NULL) || (PackageList == NULL)) {
1362 return EFI_INVALID_PARAMETER;
1363 }
1364
1365 if (Private->Signature != HII_DATABASE_PRIVATE_DATA_SIGNATURE) {
1366 return EFI_INVALID_PARAMETER;
1367 }
1368
1369 CopyMem (&PackageHeader, PackageHdr, sizeof (EFI_HII_PACKAGE_HEADER));
1370 CopyMem (&HeaderSize, (UINT8 *)PackageHdr + sizeof (EFI_HII_PACKAGE_HEADER), sizeof (UINT32));
1371
1372 //
1373 // It is illegal to have two string packages with same language within one packagelist
1374 // since the stringid will be duplicate if so. Check it to avoid this potential issue.
1375 //
1376 LanguageSize = HeaderSize - sizeof (EFI_HII_STRING_PACKAGE_HDR) + sizeof (CHAR8);
1377 Language = (CHAR8 *)AllocateZeroPool (LanguageSize);
1378 if (Language == NULL) {
1379 return EFI_OUT_OF_RESOURCES;
1380 }
1381
1382 AsciiStrCpyS (Language, LanguageSize / sizeof (CHAR8), (CHAR8 *)PackageHdr + HeaderSize - LanguageSize);
1383 for (Link = PackageList->StringPkgHdr.ForwardLink; Link != &PackageList->StringPkgHdr; Link = Link->ForwardLink) {
1384 StringPackage = CR (Link, HII_STRING_PACKAGE_INSTANCE, StringEntry, HII_STRING_PACKAGE_SIGNATURE);
1385 if (HiiCompareLanguage (Language, StringPackage->StringPkgHdr->Language)) {
1386 FreePool (Language);
1387 return EFI_UNSUPPORTED;
1388 }
1389 }
1390
1391 FreePool (Language);
1392
1393 //
1394 // Create a String package node
1395 //
1396 StringPackage = (HII_STRING_PACKAGE_INSTANCE *)AllocateZeroPool (sizeof (HII_STRING_PACKAGE_INSTANCE));
1397 if (StringPackage == NULL) {
1398 Status = EFI_OUT_OF_RESOURCES;
1399 goto Error;
1400 }
1401
1402 StringPackage->StringPkgHdr = (EFI_HII_STRING_PACKAGE_HDR *)AllocateZeroPool (HeaderSize);
1403 if (StringPackage->StringPkgHdr == NULL) {
1404 Status = EFI_OUT_OF_RESOURCES;
1405 goto Error;
1406 }
1407
1408 StringPackage->StringBlock = (UINT8 *)AllocateZeroPool (PackageHeader.Length - HeaderSize);
1409 if (StringPackage->StringBlock == NULL) {
1410 Status = EFI_OUT_OF_RESOURCES;
1411 goto Error;
1412 }
1413
1414 StringPackage->Signature = HII_STRING_PACKAGE_SIGNATURE;
1415 StringPackage->FontId = 0;
1416 InitializeListHead (&StringPackage->FontInfoList);
1417
1418 //
1419 // Copy the String package header.
1420 //
1421 CopyMem (StringPackage->StringPkgHdr, PackageHdr, HeaderSize);
1422
1423 //
1424 // Copy the String blocks
1425 //
1426 CopyMem (
1427 StringPackage->StringBlock,
1428 (UINT8 *)PackageHdr + HeaderSize,
1429 PackageHeader.Length - HeaderSize
1430 );
1431
1432 //
1433 // Collect all font block info
1434 //
1435 Status = FindStringBlock (Private, StringPackage, (EFI_STRING_ID)(-1), NULL, NULL, NULL, &StringPackage->MaxStringId, NULL);
1436 if (EFI_ERROR (Status)) {
1437 return Status;
1438 }
1439
1440 //
1441 // Insert to String package array
1442 //
1443 InsertTailList (&PackageList->StringPkgHdr, &StringPackage->StringEntry);
1444 *Package = StringPackage;
1445
1446 if (NotifyType == EFI_HII_DATABASE_NOTIFY_ADD_PACK) {
1447 PackageList->PackageListHdr.PackageLength += StringPackage->StringPkgHdr->Header.Length;
1448 }
1449
1450 return EFI_SUCCESS;
1451
1452Error:
1453
1454 if (StringPackage != NULL) {
1455 if (StringPackage->StringBlock != NULL) {
1456 FreePool (StringPackage->StringBlock);
1457 }
1458
1459 if (StringPackage->StringPkgHdr != NULL) {
1460 FreePool (StringPackage->StringPkgHdr);
1461 }
1462
1463 FreePool (StringPackage);
1464 }
1465
1466 return Status;
1467}
1468
1469/**
1470 Adjust all string packages in a single package list to have the same max string ID.
1471
1472 @param PackageList Pointer to a package list which will be adjusted.
1473
1474 @retval EFI_SUCCESS Adjust all string packages successfully.
1475 @retval others Can't adjust string packages.
1476
1477**/
1478EFI_STATUS
1479AdjustStringPackage (
1480 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList
1481 )
1482{
1483 LIST_ENTRY *Link;
1484 HII_STRING_PACKAGE_INSTANCE *StringPackage;
1485 UINT32 Skip2BlockSize;
1486 UINT32 OldBlockSize;
1487 UINT8 *StringBlock;
1488 UINT8 *BlockPtr;
1489 EFI_STRING_ID MaxStringId;
1490 UINT16 SkipCount;
1491
1492 MaxStringId = 0;
1493 for (Link = PackageList->StringPkgHdr.ForwardLink;
1494 Link != &PackageList->StringPkgHdr;
1495 Link = Link->ForwardLink
1496 )
1497 {
1498 StringPackage = CR (Link, HII_STRING_PACKAGE_INSTANCE, StringEntry, HII_STRING_PACKAGE_SIGNATURE);
1499 if (MaxStringId < StringPackage->MaxStringId) {
1500 MaxStringId = StringPackage->MaxStringId;
1501 }
1502 }
1503
1504 for (Link = PackageList->StringPkgHdr.ForwardLink;
1505 Link != &PackageList->StringPkgHdr;
1506 Link = Link->ForwardLink
1507 )
1508 {
1509 StringPackage = CR (Link, HII_STRING_PACKAGE_INSTANCE, StringEntry, HII_STRING_PACKAGE_SIGNATURE);
1510 if (StringPackage->MaxStringId < MaxStringId) {
1511 OldBlockSize = StringPackage->StringPkgHdr->Header.Length - StringPackage->StringPkgHdr->HdrSize;
1512 //
1513 // Create SKIP2 EFI_HII_SIBT_SKIP2_BLOCKs to reserve the missing string IDs.
1514 //
1515 SkipCount = (UINT16)(MaxStringId - StringPackage->MaxStringId);
1516 Skip2BlockSize = (UINT32)sizeof (EFI_HII_SIBT_SKIP2_BLOCK);
1517
1518 StringBlock = (UINT8 *)AllocateZeroPool (OldBlockSize + Skip2BlockSize);
1519 if (StringBlock == NULL) {
1520 return EFI_OUT_OF_RESOURCES;
1521 }
1522
1523 //
1524 // Copy original string blocks, except the EFI_HII_SIBT_END.
1525 //
1526 CopyMem (StringBlock, StringPackage->StringBlock, OldBlockSize - sizeof (EFI_HII_SIBT_END_BLOCK));
1527 //
1528 // Create SKIP2 EFI_HII_SIBT_SKIP2_BLOCK blocks
1529 //
1530 BlockPtr = StringBlock + OldBlockSize - sizeof (EFI_HII_SIBT_END_BLOCK);
1531 *BlockPtr = EFI_HII_SIBT_SKIP2;
1532 CopyMem (BlockPtr + 1, &SkipCount, sizeof (UINT16));
1533 BlockPtr += sizeof (EFI_HII_SIBT_SKIP2_BLOCK);
1534
1535 //
1536 // Append a EFI_HII_SIBT_END block to the end.
1537 //
1538 *BlockPtr = EFI_HII_SIBT_END;
1539 FreePool (StringPackage->StringBlock);
1540 StringPackage->StringBlock = StringBlock;
1541 StringPackage->StringPkgHdr->Header.Length += Skip2BlockSize;
1542 PackageList->PackageListHdr.PackageLength += Skip2BlockSize;
1543 StringPackage->MaxStringId = MaxStringId;
1544 }
1545 }
1546
1547 return EFI_SUCCESS;
1548}
1549
1550/**
1551 This function exports String packages to a buffer.
1552 This is a internal function.
1553
1554 @param Private Hii database private structure.
1555 @param Handle Identification of a package list.
1556 @param PackageList Pointer to a package list which will be exported.
1557 @param UsedSize The length of buffer be used.
1558 @param BufferSize Length of the Buffer.
1559 @param Buffer Allocated space for storing exported data.
1560 @param ResultSize The size of the already exported content of this
1561 package list.
1562
1563 @retval EFI_SUCCESS String Packages are exported successfully.
1564 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
1565
1566**/
1567EFI_STATUS
1568ExportStringPackages (
1569 IN HII_DATABASE_PRIVATE_DATA *Private,
1570 IN EFI_HII_HANDLE Handle,
1571 IN HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
1572 IN UINTN UsedSize,
1573 IN UINTN BufferSize,
1574 IN OUT VOID *Buffer,
1575 IN OUT UINTN *ResultSize
1576 )
1577{
1578 LIST_ENTRY *Link;
1579 UINTN PackageLength;
1580 EFI_STATUS Status;
1581 HII_STRING_PACKAGE_INSTANCE *StringPackage;
1582
1583 if ((Private == NULL) || (PackageList == NULL) || (ResultSize == NULL)) {
1584 return EFI_INVALID_PARAMETER;
1585 }
1586
1587 if ((BufferSize > 0) && (Buffer == NULL)) {
1588 return EFI_INVALID_PARAMETER;
1589 }
1590
1591 PackageLength = 0;
1592 Status = EFI_SUCCESS;
1593
1594 for (Link = PackageList->StringPkgHdr.ForwardLink; Link != &PackageList->StringPkgHdr; Link = Link->ForwardLink) {
1595 StringPackage = CR (Link, HII_STRING_PACKAGE_INSTANCE, StringEntry, HII_STRING_PACKAGE_SIGNATURE);
1596 PackageLength += StringPackage->StringPkgHdr->Header.Length;
1597 if (PackageLength + *ResultSize + UsedSize <= BufferSize) {
1598 //
1599 // Invoke registered notification function with EXPORT_PACK notify type
1600 //
1601 Status = InvokeRegisteredFunction (
1602 Private,
1603 EFI_HII_DATABASE_NOTIFY_EXPORT_PACK,
1604 (VOID *)StringPackage,
1605 EFI_HII_PACKAGE_STRINGS,
1606 Handle
1607 );
1608 ASSERT_EFI_ERROR (Status);
1609 //
1610 // Copy String package header
1611 //
1612 CopyMem (Buffer, StringPackage->StringPkgHdr, StringPackage->StringPkgHdr->HdrSize);
1613 Buffer = (UINT8 *)Buffer + StringPackage->StringPkgHdr->HdrSize;
1614
1615 //
1616 // Copy String blocks information
1617 //
1618 CopyMem (
1619 Buffer,
1620 StringPackage->StringBlock,
1621 StringPackage->StringPkgHdr->Header.Length - StringPackage->StringPkgHdr->HdrSize
1622 );
1623 Buffer = (UINT8 *)Buffer + StringPackage->StringPkgHdr->Header.Length - StringPackage->StringPkgHdr->HdrSize;
1624 }
1625 }
1626
1627 *ResultSize += PackageLength;
1628 return EFI_SUCCESS;
1629}
1630
1631/**
1632 This function deletes all String packages from a package list node.
1633 This is a internal function.
1634
1635 @param Private Hii database private data.
1636 @param Handle Handle of the package list which contains the to
1637 be removed String packages.
1638 @param PackageList Pointer to a package list that contains removing
1639 packages.
1640
1641 @retval EFI_SUCCESS String Package(s) is deleted successfully.
1642 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
1643
1644**/
1645EFI_STATUS
1646RemoveStringPackages (
1647 IN HII_DATABASE_PRIVATE_DATA *Private,
1648 IN EFI_HII_HANDLE Handle,
1649 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList
1650 )
1651{
1652 LIST_ENTRY *ListHead;
1653 HII_STRING_PACKAGE_INSTANCE *Package;
1654 HII_FONT_INFO *FontInfo;
1655 EFI_STATUS Status;
1656
1657 ListHead = &PackageList->StringPkgHdr;
1658
1659 while (!IsListEmpty (ListHead)) {
1660 Package = CR (
1661 ListHead->ForwardLink,
1662 HII_STRING_PACKAGE_INSTANCE,
1663 StringEntry,
1664 HII_STRING_PACKAGE_SIGNATURE
1665 );
1666 Status = InvokeRegisteredFunction (
1667 Private,
1668 EFI_HII_DATABASE_NOTIFY_REMOVE_PACK,
1669 (VOID *)Package,
1670 EFI_HII_PACKAGE_STRINGS,
1671 Handle
1672 );
1673 if (EFI_ERROR (Status)) {
1674 return Status;
1675 }
1676
1677 RemoveEntryList (&Package->StringEntry);
1678 PackageList->PackageListHdr.PackageLength -= Package->StringPkgHdr->Header.Length;
1679 FreePool (Package->StringBlock);
1680 FreePool (Package->StringPkgHdr);
1681 //
1682 // Delete font information
1683 //
1684 while (!IsListEmpty (&Package->FontInfoList)) {
1685 FontInfo = CR (
1686 Package->FontInfoList.ForwardLink,
1687 HII_FONT_INFO,
1688 Entry,
1689 HII_FONT_INFO_SIGNATURE
1690 );
1691 RemoveEntryList (&FontInfo->Entry);
1692 FreePool (FontInfo);
1693 }
1694
1695 FreePool (Package);
1696 }
1697
1698 return EFI_SUCCESS;
1699}
1700
1701/**
1702 This function insert a Font package to a package list node.
1703 This is a internal function.
1704
1705 @param Private Hii database private structure.
1706 @param PackageHdr Pointer to a buffer stored with Font package
1707 information.
1708 @param NotifyType The type of change concerning the database.
1709 @param PackageList Pointer to a package list which will be inserted
1710 to.
1711 @param Package Created Font package
1712
1713 @retval EFI_SUCCESS Font Package is inserted successfully.
1714 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
1715 Font package.
1716 @retval EFI_INVALID_PARAMETER PackageHdr is NULL or PackageList is NULL.
1717 @retval EFI_UNSUPPORTED A font package with same EFI_FONT_INFO already
1718 exists in current hii database.
1719
1720**/
1721EFI_STATUS
1722InsertFontPackage (
1723 IN HII_DATABASE_PRIVATE_DATA *Private,
1724 IN VOID *PackageHdr,
1725 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType,
1726 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
1727 OUT HII_FONT_PACKAGE_INSTANCE **Package
1728 )
1729{
1730 HII_FONT_PACKAGE_INSTANCE *FontPackage;
1731 EFI_HII_FONT_PACKAGE_HDR *FontPkgHdr;
1732 UINT32 HeaderSize;
1733 EFI_STATUS Status;
1734 EFI_HII_PACKAGE_HEADER PackageHeader;
1735 EFI_FONT_INFO *FontInfo;
1736 UINT32 FontInfoSize;
1737 HII_GLOBAL_FONT_INFO *GlobalFont;
1738
1739 if ((Private == NULL) || (PackageHdr == NULL) || (PackageList == NULL)) {
1740 return EFI_INVALID_PARAMETER;
1741 }
1742
1743 CopyMem (&PackageHeader, PackageHdr, sizeof (EFI_HII_PACKAGE_HEADER));
1744 CopyMem (&HeaderSize, (UINT8 *)PackageHdr + sizeof (EFI_HII_PACKAGE_HEADER), sizeof (UINT32));
1745
1746 FontInfo = NULL;
1747 FontPackage = NULL;
1748 GlobalFont = NULL;
1749
1750 //
1751 // It is illegal to have two font packages with same EFI_FONT_INFO within hii
1752 // database. EFI_FONT_INFO (FontName, FontSize, FontStyle) describes font's
1753 // attributes and identify a font uniquely.
1754 //
1755 FontPkgHdr = (EFI_HII_FONT_PACKAGE_HDR *)AllocateZeroPool (HeaderSize);
1756 if (FontPkgHdr == NULL) {
1757 Status = EFI_OUT_OF_RESOURCES;
1758 goto Error;
1759 }
1760
1761 CopyMem (FontPkgHdr, PackageHdr, HeaderSize);
1762
1763 FontInfoSize = sizeof (EFI_FONT_INFO) + HeaderSize - sizeof (EFI_HII_FONT_PACKAGE_HDR);
1764 FontInfo = (EFI_FONT_INFO *)AllocateZeroPool (FontInfoSize);
1765 if (FontInfo == NULL) {
1766 Status = EFI_OUT_OF_RESOURCES;
1767 goto Error;
1768 }
1769
1770 FontInfo->FontStyle = FontPkgHdr->FontStyle;
1771 FontInfo->FontSize = FontPkgHdr->Cell.Height;
1772 StrCpyS (FontInfo->FontName, (FontInfoSize - OFFSET_OF (EFI_FONT_INFO, FontName)) / sizeof (CHAR16), FontPkgHdr->FontFamily);
1773
1774 if (IsFontInfoExisted (Private, FontInfo, NULL, NULL, NULL)) {
1775 Status = EFI_UNSUPPORTED;
1776 goto Error;
1777 }
1778
1779 //
1780 // Create a Font package node
1781 //
1782 FontPackage = (HII_FONT_PACKAGE_INSTANCE *)AllocateZeroPool (sizeof (HII_FONT_PACKAGE_INSTANCE));
1783 if (FontPackage == NULL) {
1784 Status = EFI_OUT_OF_RESOURCES;
1785 goto Error;
1786 }
1787
1788 FontPackage->Signature = HII_FONT_PACKAGE_SIGNATURE;
1789 FontPackage->FontPkgHdr = FontPkgHdr;
1790 InitializeListHead (&FontPackage->GlyphInfoList);
1791
1792 FontPackage->GlyphBlock = (UINT8 *)AllocateZeroPool (PackageHeader.Length - HeaderSize);
1793 if (FontPackage->GlyphBlock == NULL) {
1794 Status = EFI_OUT_OF_RESOURCES;
1795 goto Error;
1796 }
1797
1798 CopyMem (FontPackage->GlyphBlock, (UINT8 *)PackageHdr + HeaderSize, PackageHeader.Length - HeaderSize);
1799
1800 //
1801 // Collect all default character cell information and backup in GlyphInfoList.
1802 //
1803 Status = FindGlyphBlock (FontPackage, (CHAR16)(-1), NULL, NULL, NULL);
1804 if (EFI_ERROR (Status)) {
1805 goto Error;
1806 }
1807
1808 //
1809 // This font package describes an unique EFI_FONT_INFO. Backup it in global
1810 // font info list.
1811 //
1812 GlobalFont = (HII_GLOBAL_FONT_INFO *)AllocateZeroPool (sizeof (HII_GLOBAL_FONT_INFO));
1813 if (GlobalFont == NULL) {
1814 Status = EFI_OUT_OF_RESOURCES;
1815 goto Error;
1816 }
1817
1818 GlobalFont->Signature = HII_GLOBAL_FONT_INFO_SIGNATURE;
1819 GlobalFont->FontPackage = FontPackage;
1820 GlobalFont->FontInfoSize = FontInfoSize;
1821 GlobalFont->FontInfo = FontInfo;
1822 InsertTailList (&Private->FontInfoList, &GlobalFont->Entry);
1823
1824 //
1825 // Insert this font package to Font package array
1826 //
1827 InsertTailList (&PackageList->FontPkgHdr, &FontPackage->FontEntry);
1828 *Package = FontPackage;
1829
1830 if (NotifyType == EFI_HII_DATABASE_NOTIFY_ADD_PACK) {
1831 PackageList->PackageListHdr.PackageLength += FontPackage->FontPkgHdr->Header.Length;
1832 }
1833
1834 return EFI_SUCCESS;
1835
1836Error:
1837
1838 if (FontPkgHdr != NULL) {
1839 FreePool (FontPkgHdr);
1840 }
1841
1842 if (FontInfo != NULL) {
1843 FreePool (FontInfo);
1844 }
1845
1846 if (FontPackage != NULL) {
1847 if (FontPackage->GlyphBlock != NULL) {
1848 FreePool (FontPackage->GlyphBlock);
1849 }
1850
1851 FreePool (FontPackage);
1852 }
1853
1854 if (GlobalFont != NULL) {
1855 FreePool (GlobalFont);
1856 }
1857
1858 return Status;
1859}
1860
1861/**
1862 This function exports Font packages to a buffer.
1863 This is a internal function.
1864
1865 @param Private Hii database private structure.
1866 @param Handle Identification of a package list.
1867 @param PackageList Pointer to a package list which will be exported.
1868 @param UsedSize The length of buffer be used.
1869 @param BufferSize Length of the Buffer.
1870 @param Buffer Allocated space for storing exported data.
1871 @param ResultSize The size of the already exported content of this
1872 package list.
1873
1874 @retval EFI_SUCCESS Font Packages are exported successfully.
1875 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
1876
1877**/
1878EFI_STATUS
1879ExportFontPackages (
1880 IN HII_DATABASE_PRIVATE_DATA *Private,
1881 IN EFI_HII_HANDLE Handle,
1882 IN HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
1883 IN UINTN UsedSize,
1884 IN UINTN BufferSize,
1885 IN OUT VOID *Buffer,
1886 IN OUT UINTN *ResultSize
1887 )
1888{
1889 LIST_ENTRY *Link;
1890 UINTN PackageLength;
1891 EFI_STATUS Status;
1892 HII_FONT_PACKAGE_INSTANCE *Package;
1893
1894 if ((Private == NULL) || (PackageList == NULL) || (ResultSize == NULL)) {
1895 return EFI_INVALID_PARAMETER;
1896 }
1897
1898 if ((BufferSize > 0) && (Buffer == NULL)) {
1899 return EFI_INVALID_PARAMETER;
1900 }
1901
1902 PackageLength = 0;
1903 Status = EFI_SUCCESS;
1904
1905 for (Link = PackageList->FontPkgHdr.ForwardLink; Link != &PackageList->FontPkgHdr; Link = Link->ForwardLink) {
1906 Package = CR (Link, HII_FONT_PACKAGE_INSTANCE, FontEntry, HII_FONT_PACKAGE_SIGNATURE);
1907 PackageLength += Package->FontPkgHdr->Header.Length;
1908 if (PackageLength + *ResultSize + UsedSize <= BufferSize) {
1909 //
1910 // Invoke registered notification function with EXPORT_PACK notify type
1911 //
1912 Status = InvokeRegisteredFunction (
1913 Private,
1914 EFI_HII_DATABASE_NOTIFY_EXPORT_PACK,
1915 (VOID *)Package,
1916 EFI_HII_PACKAGE_FONTS,
1917 Handle
1918 );
1919 ASSERT_EFI_ERROR (Status);
1920 //
1921 // Copy Font package header
1922 //
1923 CopyMem (Buffer, Package->FontPkgHdr, Package->FontPkgHdr->HdrSize);
1924 Buffer = (UINT8 *)Buffer + Package->FontPkgHdr->HdrSize;
1925
1926 //
1927 // Copy Glyph blocks information
1928 //
1929 CopyMem (
1930 Buffer,
1931 Package->GlyphBlock,
1932 Package->FontPkgHdr->Header.Length - Package->FontPkgHdr->HdrSize
1933 );
1934 Buffer = (UINT8 *)Buffer + Package->FontPkgHdr->Header.Length - Package->FontPkgHdr->HdrSize;
1935 }
1936 }
1937
1938 *ResultSize += PackageLength;
1939 return EFI_SUCCESS;
1940}
1941
1942/**
1943 This function deletes all Font packages from a package list node.
1944 This is a internal function.
1945
1946 @param Private Hii database private data.
1947 @param Handle Handle of the package list which contains the to
1948 be removed Font packages.
1949 @param PackageList Pointer to a package list that contains removing
1950 packages.
1951
1952 @retval EFI_SUCCESS Font Package(s) is deleted successfully.
1953 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
1954
1955**/
1956EFI_STATUS
1957RemoveFontPackages (
1958 IN HII_DATABASE_PRIVATE_DATA *Private,
1959 IN EFI_HII_HANDLE Handle,
1960 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList
1961 )
1962{
1963 LIST_ENTRY *ListHead;
1964 HII_FONT_PACKAGE_INSTANCE *Package;
1965 EFI_STATUS Status;
1966 HII_GLYPH_INFO *GlyphInfo;
1967 LIST_ENTRY *Link;
1968 HII_GLOBAL_FONT_INFO *GlobalFont;
1969
1970 ListHead = &PackageList->FontPkgHdr;
1971
1972 while (!IsListEmpty (ListHead)) {
1973 Package = CR (
1974 ListHead->ForwardLink,
1975 HII_FONT_PACKAGE_INSTANCE,
1976 FontEntry,
1977 HII_FONT_PACKAGE_SIGNATURE
1978 );
1979 Status = InvokeRegisteredFunction (
1980 Private,
1981 EFI_HII_DATABASE_NOTIFY_REMOVE_PACK,
1982 (VOID *)Package,
1983 EFI_HII_PACKAGE_FONTS,
1984 Handle
1985 );
1986 if (EFI_ERROR (Status)) {
1987 return Status;
1988 }
1989
1990 RemoveEntryList (&Package->FontEntry);
1991 PackageList->PackageListHdr.PackageLength -= Package->FontPkgHdr->Header.Length;
1992
1993 if (Package->GlyphBlock != NULL) {
1994 FreePool (Package->GlyphBlock);
1995 }
1996
1997 FreePool (Package->FontPkgHdr);
1998 //
1999 // Delete default character cell information
2000 //
2001 while (!IsListEmpty (&Package->GlyphInfoList)) {
2002 GlyphInfo = CR (
2003 Package->GlyphInfoList.ForwardLink,
2004 HII_GLYPH_INFO,
2005 Entry,
2006 HII_GLYPH_INFO_SIGNATURE
2007 );
2008 RemoveEntryList (&GlyphInfo->Entry);
2009 FreePool (GlyphInfo);
2010 }
2011
2012 //
2013 // Remove corresponding global font info
2014 //
2015 for (Link = Private->FontInfoList.ForwardLink; Link != &Private->FontInfoList; Link = Link->ForwardLink) {
2016 GlobalFont = CR (Link, HII_GLOBAL_FONT_INFO, Entry, HII_GLOBAL_FONT_INFO_SIGNATURE);
2017 if (GlobalFont->FontPackage == Package) {
2018 RemoveEntryList (&GlobalFont->Entry);
2019 FreePool (GlobalFont->FontInfo);
2020 FreePool (GlobalFont);
2021 break;
2022 }
2023 }
2024
2025 FreePool (Package);
2026 }
2027
2028 return EFI_SUCCESS;
2029}
2030
2031/**
2032 This function insert a Image package to a package list node.
2033 This is a internal function.
2034
2035 @param PackageHdr Pointer to a buffer stored with Image package
2036 information.
2037 @param NotifyType The type of change concerning the database.
2038 @param PackageList Pointer to a package list which will be inserted
2039 to.
2040 @param Package Created Image package
2041
2042 @retval EFI_SUCCESS Image Package is inserted successfully.
2043 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
2044 Image package.
2045 @retval EFI_INVALID_PARAMETER PackageHdr is NULL or PackageList is NULL.
2046
2047**/
2048EFI_STATUS
2049InsertImagePackage (
2050 IN VOID *PackageHdr,
2051 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType,
2052 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
2053 OUT HII_IMAGE_PACKAGE_INSTANCE **Package
2054 )
2055{
2056 HII_IMAGE_PACKAGE_INSTANCE *ImagePackage;
2057 UINT32 PaletteSize;
2058 UINT32 ImageSize;
2059 UINT16 Index;
2060 EFI_HII_IMAGE_PALETTE_INFO_HEADER *PaletteHdr;
2061 EFI_HII_IMAGE_PALETTE_INFO *PaletteInfo;
2062 UINT32 PaletteInfoOffset;
2063 UINT32 ImageInfoOffset;
2064 UINT16 CurrentSize;
2065
2066 if ((PackageHdr == NULL) || (PackageList == NULL)) {
2067 return EFI_INVALID_PARAMETER;
2068 }
2069
2070 //
2071 // Less than one image package is allowed in one package list.
2072 //
2073 if (PackageList->ImagePkg != NULL) {
2074 return EFI_INVALID_PARAMETER;
2075 }
2076
2077 //
2078 // Create a Image package node
2079 //
2080 ImagePackage = (HII_IMAGE_PACKAGE_INSTANCE *)AllocateZeroPool (sizeof (HII_IMAGE_PACKAGE_INSTANCE));
2081 if (ImagePackage == NULL) {
2082 return EFI_OUT_OF_RESOURCES;
2083 }
2084
2085 //
2086 // Copy the Image package header.
2087 //
2088 CopyMem (&ImagePackage->ImagePkgHdr, PackageHdr, sizeof (EFI_HII_IMAGE_PACKAGE_HDR));
2089
2090 PaletteInfoOffset = ImagePackage->ImagePkgHdr.PaletteInfoOffset;
2091 ImageInfoOffset = ImagePackage->ImagePkgHdr.ImageInfoOffset;
2092
2093 //
2094 // If PaletteInfoOffset is zero, there are no palettes in this image package.
2095 //
2096 PaletteSize = 0;
2097 ImagePackage->PaletteBlock = NULL;
2098 if (PaletteInfoOffset != 0) {
2099 PaletteHdr = (EFI_HII_IMAGE_PALETTE_INFO_HEADER *)((UINT8 *)PackageHdr + PaletteInfoOffset);
2100 PaletteSize = sizeof (EFI_HII_IMAGE_PALETTE_INFO_HEADER);
2101 PaletteInfo = (EFI_HII_IMAGE_PALETTE_INFO *)((UINT8 *)PaletteHdr + PaletteSize);
2102
2103 for (Index = 0; Index < PaletteHdr->PaletteCount; Index++) {
2104 CopyMem (&CurrentSize, PaletteInfo, sizeof (UINT16));
2105 CurrentSize += sizeof (UINT16);
2106 PaletteSize += (UINT32)CurrentSize;
2107 PaletteInfo = (EFI_HII_IMAGE_PALETTE_INFO *)((UINT8 *)PaletteInfo + CurrentSize);
2108 }
2109
2110 ImagePackage->PaletteBlock = (UINT8 *)AllocateZeroPool (PaletteSize);
2111 if (ImagePackage->PaletteBlock == NULL) {
2112 FreePool (ImagePackage);
2113 return EFI_OUT_OF_RESOURCES;
2114 }
2115
2116 CopyMem (
2117 ImagePackage->PaletteBlock,
2118 (UINT8 *)PackageHdr + PaletteInfoOffset,
2119 PaletteSize
2120 );
2121 }
2122
2123 //
2124 // If ImageInfoOffset is zero, there are no images in this package.
2125 //
2126 ImageSize = 0;
2127 ImagePackage->ImageBlock = NULL;
2128 if (ImageInfoOffset != 0) {
2129 ImageSize = ImagePackage->ImagePkgHdr.Header.Length -
2130 sizeof (EFI_HII_IMAGE_PACKAGE_HDR) - PaletteSize;
2131 ImagePackage->ImageBlock = AllocateZeroPool (ImageSize);
2132 if (ImagePackage->ImageBlock == NULL) {
2133 FreePool (ImagePackage->PaletteBlock);
2134 FreePool (ImagePackage);
2135 return EFI_OUT_OF_RESOURCES;
2136 }
2137
2138 CopyMem (
2139 ImagePackage->ImageBlock,
2140 (UINT8 *)PackageHdr + ImageInfoOffset,
2141 ImageSize
2142 );
2143 }
2144
2145 ImagePackage->ImageBlockSize = ImageSize;
2146 ImagePackage->PaletteInfoSize = PaletteSize;
2147 PackageList->ImagePkg = ImagePackage;
2148 *Package = ImagePackage;
2149
2150 if (NotifyType == EFI_HII_DATABASE_NOTIFY_ADD_PACK) {
2151 PackageList->PackageListHdr.PackageLength += ImagePackage->ImagePkgHdr.Header.Length;
2152 }
2153
2154 return EFI_SUCCESS;
2155}
2156
2157/**
2158 This function exports Image packages to a buffer.
2159 This is a internal function.
2160
2161 @param Private Hii database private structure.
2162 @param Handle Identification of a package list.
2163 @param PackageList Pointer to a package list which will be exported.
2164 @param UsedSize The length of buffer be used.
2165 @param BufferSize Length of the Buffer.
2166 @param Buffer Allocated space for storing exported data.
2167 @param ResultSize The size of the already exported content of this
2168 package list.
2169
2170 @retval EFI_SUCCESS Image Packages are exported successfully.
2171 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
2172
2173**/
2174EFI_STATUS
2175ExportImagePackages (
2176 IN HII_DATABASE_PRIVATE_DATA *Private,
2177 IN EFI_HII_HANDLE Handle,
2178 IN HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
2179 IN UINTN UsedSize,
2180 IN UINTN BufferSize,
2181 IN OUT VOID *Buffer,
2182 IN OUT UINTN *ResultSize
2183 )
2184{
2185 UINTN PackageLength;
2186 EFI_STATUS Status;
2187 HII_IMAGE_PACKAGE_INSTANCE *Package;
2188
2189 if ((Private == NULL) || (PackageList == NULL) || (ResultSize == NULL)) {
2190 return EFI_INVALID_PARAMETER;
2191 }
2192
2193 if ((BufferSize > 0) && (Buffer == NULL)) {
2194 return EFI_INVALID_PARAMETER;
2195 }
2196
2197 Package = PackageList->ImagePkg;
2198
2199 if (Package == NULL) {
2200 return EFI_SUCCESS;
2201 }
2202
2203 PackageLength = Package->ImagePkgHdr.Header.Length;
2204
2205 if (PackageLength + *ResultSize + UsedSize <= BufferSize) {
2206 //
2207 // Invoke registered notification function with EXPORT_PACK notify type
2208 //
2209 Status = InvokeRegisteredFunction (
2210 Private,
2211 EFI_HII_DATABASE_NOTIFY_EXPORT_PACK,
2212 (VOID *)Package,
2213 EFI_HII_PACKAGE_IMAGES,
2214 Handle
2215 );
2216 ASSERT_EFI_ERROR (Status);
2217 ASSERT (
2218 Package->ImagePkgHdr.Header.Length ==
2219 sizeof (EFI_HII_IMAGE_PACKAGE_HDR) + Package->ImageBlockSize + Package->PaletteInfoSize
2220 );
2221 //
2222 // Copy Image package header,
2223 // then justify the offset for image info and palette info in the header.
2224 //
2225 CopyMem (Buffer, &Package->ImagePkgHdr, sizeof (EFI_HII_IMAGE_PACKAGE_HDR));
2226 Buffer = (UINT8 *)Buffer + sizeof (EFI_HII_IMAGE_PACKAGE_HDR);
2227
2228 //
2229 // Copy Image blocks information
2230 //
2231 if (Package->ImageBlockSize != 0) {
2232 CopyMem (Buffer, Package->ImageBlock, Package->ImageBlockSize);
2233 Buffer = (UINT8 *)Buffer + Package->ImageBlockSize;
2234 }
2235
2236 //
2237 // Copy Palette information
2238 //
2239 if (Package->PaletteInfoSize != 0) {
2240 CopyMem (Buffer, Package->PaletteBlock, Package->PaletteInfoSize);
2241 Buffer = (UINT8 *)Buffer + Package->PaletteInfoSize;
2242 }
2243 }
2244
2245 *ResultSize += PackageLength;
2246 return EFI_SUCCESS;
2247}
2248
2249/**
2250 This function deletes Image package from a package list node.
2251 This is a internal function.
2252
2253 @param Private Hii database private data.
2254 @param Handle Handle of the package list which contains the to
2255 be removed Image packages.
2256 @param PackageList Package List which contains the to be removed
2257 Image package.
2258
2259 @retval EFI_SUCCESS Image Package(s) is deleted successfully.
2260 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
2261
2262**/
2263EFI_STATUS
2264RemoveImagePackages (
2265 IN HII_DATABASE_PRIVATE_DATA *Private,
2266 IN EFI_HII_HANDLE Handle,
2267 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList
2268 )
2269{
2270 HII_IMAGE_PACKAGE_INSTANCE *Package;
2271 EFI_STATUS Status;
2272
2273 Package = PackageList->ImagePkg;
2274
2275 //
2276 // Image package does not exist, return directly.
2277 //
2278 if (Package == NULL) {
2279 return EFI_SUCCESS;
2280 }
2281
2282 Status = InvokeRegisteredFunction (
2283 Private,
2284 EFI_HII_DATABASE_NOTIFY_REMOVE_PACK,
2285 (VOID *)Package,
2286 EFI_HII_PACKAGE_IMAGES,
2287 Handle
2288 );
2289 if (EFI_ERROR (Status)) {
2290 return Status;
2291 }
2292
2293 PackageList->PackageListHdr.PackageLength -= Package->ImagePkgHdr.Header.Length;
2294
2295 FreePool (Package->ImageBlock);
2296 if (Package->PaletteBlock != NULL) {
2297 FreePool (Package->PaletteBlock);
2298 }
2299
2300 FreePool (Package);
2301
2302 PackageList->ImagePkg = NULL;
2303
2304 return EFI_SUCCESS;
2305}
2306
2307/**
2308 This function insert a Simple Font package to a package list node.
2309 This is a internal function.
2310
2311 @param PackageHdr Pointer to a buffer stored with Simple Font
2312 package information.
2313 @param NotifyType The type of change concerning the database.
2314 @param PackageList Pointer to a package list which will be inserted
2315 to.
2316 @param Package Created Simple Font package
2317
2318 @retval EFI_SUCCESS Simple Font Package is inserted successfully.
2319 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
2320 Simple Font package.
2321 @retval EFI_INVALID_PARAMETER PackageHdr is NULL or PackageList is NULL.
2322
2323**/
2324EFI_STATUS
2325InsertSimpleFontPackage (
2326 IN VOID *PackageHdr,
2327 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType,
2328 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
2329 OUT HII_SIMPLE_FONT_PACKAGE_INSTANCE **Package
2330 )
2331{
2332 HII_SIMPLE_FONT_PACKAGE_INSTANCE *SimpleFontPackage;
2333 EFI_STATUS Status;
2334 EFI_HII_PACKAGE_HEADER Header;
2335
2336 if ((PackageHdr == NULL) || (PackageList == NULL)) {
2337 return EFI_INVALID_PARAMETER;
2338 }
2339
2340 //
2341 // Create a Simple Font package node
2342 //
2343 SimpleFontPackage = AllocateZeroPool (sizeof (HII_SIMPLE_FONT_PACKAGE_INSTANCE));
2344 if (SimpleFontPackage == NULL) {
2345 Status = EFI_OUT_OF_RESOURCES;
2346 goto Error;
2347 }
2348
2349 SimpleFontPackage->Signature = HII_S_FONT_PACKAGE_SIGNATURE;
2350
2351 //
2352 // Copy the Simple Font package.
2353 //
2354 CopyMem (&Header, PackageHdr, sizeof (EFI_HII_PACKAGE_HEADER));
2355
2356 SimpleFontPackage->SimpleFontPkgHdr = AllocateZeroPool (Header.Length);
2357 if (SimpleFontPackage->SimpleFontPkgHdr == NULL) {
2358 Status = EFI_OUT_OF_RESOURCES;
2359 goto Error;
2360 }
2361
2362 CopyMem (SimpleFontPackage->SimpleFontPkgHdr, PackageHdr, Header.Length);
2363
2364 //
2365 // Insert to Simple Font package array
2366 //
2367 InsertTailList (&PackageList->SimpleFontPkgHdr, &SimpleFontPackage->SimpleFontEntry);
2368 *Package = SimpleFontPackage;
2369
2370 if (NotifyType == EFI_HII_DATABASE_NOTIFY_ADD_PACK) {
2371 PackageList->PackageListHdr.PackageLength += Header.Length;
2372 }
2373
2374 return EFI_SUCCESS;
2375
2376Error:
2377
2378 if (SimpleFontPackage != NULL) {
2379 if (SimpleFontPackage->SimpleFontPkgHdr != NULL) {
2380 FreePool (SimpleFontPackage->SimpleFontPkgHdr);
2381 }
2382
2383 FreePool (SimpleFontPackage);
2384 }
2385
2386 return Status;
2387}
2388
2389/**
2390 This function exports SimpleFont packages to a buffer.
2391 This is a internal function.
2392
2393 @param Private Hii database private structure.
2394 @param Handle Identification of a package list.
2395 @param PackageList Pointer to a package list which will be exported.
2396 @param UsedSize The length of buffer be used.
2397 @param BufferSize Length of the Buffer.
2398 @param Buffer Allocated space for storing exported data.
2399 @param ResultSize The size of the already exported content of this
2400 package list.
2401
2402 @retval EFI_SUCCESS SimpleFont Packages are exported successfully.
2403 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
2404
2405**/
2406EFI_STATUS
2407ExportSimpleFontPackages (
2408 IN HII_DATABASE_PRIVATE_DATA *Private,
2409 IN EFI_HII_HANDLE Handle,
2410 IN HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
2411 IN UINTN UsedSize,
2412 IN UINTN BufferSize,
2413 IN OUT VOID *Buffer,
2414 IN OUT UINTN *ResultSize
2415 )
2416{
2417 LIST_ENTRY *Link;
2418 UINTN PackageLength;
2419 EFI_STATUS Status;
2420 HII_SIMPLE_FONT_PACKAGE_INSTANCE *Package;
2421
2422 if ((Private == NULL) || (PackageList == NULL) || (ResultSize == NULL)) {
2423 return EFI_INVALID_PARAMETER;
2424 }
2425
2426 if ((BufferSize > 0) && (Buffer == NULL)) {
2427 return EFI_INVALID_PARAMETER;
2428 }
2429
2430 PackageLength = 0;
2431 Status = EFI_SUCCESS;
2432
2433 for (Link = PackageList->SimpleFontPkgHdr.ForwardLink; Link != &PackageList->SimpleFontPkgHdr; Link = Link->ForwardLink) {
2434 Package = CR (Link, HII_SIMPLE_FONT_PACKAGE_INSTANCE, SimpleFontEntry, HII_S_FONT_PACKAGE_SIGNATURE);
2435 PackageLength += Package->SimpleFontPkgHdr->Header.Length;
2436 if (PackageLength + *ResultSize + UsedSize <= BufferSize) {
2437 //
2438 // Invoke registered notification function with EXPORT_PACK notify type
2439 //
2440 Status = InvokeRegisteredFunction (
2441 Private,
2442 EFI_HII_DATABASE_NOTIFY_EXPORT_PACK,
2443 (VOID *)Package,
2444 EFI_HII_PACKAGE_SIMPLE_FONTS,
2445 Handle
2446 );
2447 ASSERT_EFI_ERROR (Status);
2448
2449 //
2450 // Copy SimpleFont package
2451 //
2452 CopyMem (Buffer, Package->SimpleFontPkgHdr, Package->SimpleFontPkgHdr->Header.Length);
2453 Buffer = (UINT8 *)Buffer + Package->SimpleFontPkgHdr->Header.Length;
2454 }
2455 }
2456
2457 *ResultSize += PackageLength;
2458 return EFI_SUCCESS;
2459}
2460
2461/**
2462 This function deletes all Simple Font packages from a package list node.
2463 This is a internal function.
2464
2465 @param Private Hii database private data.
2466 @param Handle Handle of the package list which contains the to
2467 be removed Simple Font packages.
2468 @param PackageList Pointer to a package list that contains removing
2469 packages.
2470
2471 @retval EFI_SUCCESS Simple Font Package(s) is deleted successfully.
2472 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
2473
2474**/
2475EFI_STATUS
2476RemoveSimpleFontPackages (
2477 IN HII_DATABASE_PRIVATE_DATA *Private,
2478 IN EFI_HII_HANDLE Handle,
2479 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList
2480 )
2481{
2482 LIST_ENTRY *ListHead;
2483 HII_SIMPLE_FONT_PACKAGE_INSTANCE *Package;
2484 EFI_STATUS Status;
2485
2486 ListHead = &PackageList->SimpleFontPkgHdr;
2487
2488 while (!IsListEmpty (ListHead)) {
2489 Package = CR (
2490 ListHead->ForwardLink,
2491 HII_SIMPLE_FONT_PACKAGE_INSTANCE,
2492 SimpleFontEntry,
2493 HII_S_FONT_PACKAGE_SIGNATURE
2494 );
2495 Status = InvokeRegisteredFunction (
2496 Private,
2497 EFI_HII_DATABASE_NOTIFY_REMOVE_PACK,
2498 (VOID *)Package,
2499 EFI_HII_PACKAGE_SIMPLE_FONTS,
2500 Handle
2501 );
2502 if (EFI_ERROR (Status)) {
2503 return Status;
2504 }
2505
2506 RemoveEntryList (&Package->SimpleFontEntry);
2507 PackageList->PackageListHdr.PackageLength -= Package->SimpleFontPkgHdr->Header.Length;
2508 FreePool (Package->SimpleFontPkgHdr);
2509 FreePool (Package);
2510 }
2511
2512 return EFI_SUCCESS;
2513}
2514
2515/**
2516 This function insert a Device path package to a package list node.
2517 This is a internal function.
2518
2519 @param DevicePath Pointer to a EFI_DEVICE_PATH_PROTOCOL protocol
2520 instance
2521 @param NotifyType The type of change concerning the database.
2522 @param PackageList Pointer to a package list which will be inserted
2523 to.
2524
2525 @retval EFI_SUCCESS Device path Package is inserted successfully.
2526 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
2527 Device path package.
2528 @retval EFI_INVALID_PARAMETER DevicePath is NULL or PackageList is NULL.
2529
2530**/
2531EFI_STATUS
2532InsertDevicePathPackage (
2533 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
2534 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType,
2535 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList
2536 )
2537{
2538 UINT32 PackageLength;
2539 EFI_HII_PACKAGE_HEADER Header;
2540
2541 if ((DevicePath == NULL) || (PackageList == NULL)) {
2542 return EFI_INVALID_PARAMETER;
2543 }
2544
2545 //
2546 // Less than one device path package is allowed in one package list.
2547 //
2548 if (PackageList->DevicePathPkg != NULL) {
2549 return EFI_INVALID_PARAMETER;
2550 }
2551
2552 PackageLength = (UINT32)GetDevicePathSize (DevicePath) + sizeof (EFI_HII_PACKAGE_HEADER);
2553 PackageList->DevicePathPkg = (UINT8 *)AllocateZeroPool (PackageLength);
2554 if (PackageList->DevicePathPkg == NULL) {
2555 return EFI_OUT_OF_RESOURCES;
2556 }
2557
2558 Header.Length = PackageLength;
2559 Header.Type = EFI_HII_PACKAGE_DEVICE_PATH;
2560 CopyMem (PackageList->DevicePathPkg, &Header, sizeof (EFI_HII_PACKAGE_HEADER));
2561 CopyMem (
2562 PackageList->DevicePathPkg + sizeof (EFI_HII_PACKAGE_HEADER),
2563 DevicePath,
2564 PackageLength - sizeof (EFI_HII_PACKAGE_HEADER)
2565 );
2566
2567 //
2568 // Since Device Path package is created by NewPackageList, either NEW_PACK
2569 // or ADD_PACK should increase the length of package list.
2570 //
2571 PackageList->PackageListHdr.PackageLength += PackageLength;
2572 return EFI_SUCCESS;
2573}
2574
2575/**
2576 This function exports device path package to a buffer.
2577 This is a internal function.
2578
2579 @param Private Hii database private structure.
2580 @param Handle Identification of a package list.
2581 @param PackageList Pointer to a package list which will be exported.
2582 @param UsedSize The length of buffer be used.
2583 @param BufferSize Length of the Buffer.
2584 @param Buffer Allocated space for storing exported data.
2585 @param ResultSize The size of the already exported content of this
2586 package list.
2587
2588 @retval EFI_SUCCESS Device path Package is exported successfully.
2589 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
2590
2591**/
2592EFI_STATUS
2593ExportDevicePathPackage (
2594 IN HII_DATABASE_PRIVATE_DATA *Private,
2595 IN EFI_HII_HANDLE Handle,
2596 IN HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
2597 IN UINTN UsedSize,
2598 IN UINTN BufferSize,
2599 IN OUT VOID *Buffer,
2600 IN OUT UINTN *ResultSize
2601 )
2602{
2603 EFI_STATUS Status;
2604 UINT8 *Package;
2605 EFI_HII_PACKAGE_HEADER Header;
2606
2607 if ((Private == NULL) || (PackageList == NULL) || (ResultSize == NULL)) {
2608 return EFI_INVALID_PARAMETER;
2609 }
2610
2611 if ((BufferSize > 0) && (Buffer == NULL)) {
2612 return EFI_INVALID_PARAMETER;
2613 }
2614
2615 Package = PackageList->DevicePathPkg;
2616
2617 if (Package == NULL) {
2618 return EFI_SUCCESS;
2619 }
2620
2621 CopyMem (&Header, Package, sizeof (EFI_HII_PACKAGE_HEADER));
2622
2623 if (Header.Length + *ResultSize + UsedSize <= BufferSize) {
2624 //
2625 // Invoke registered notification function with EXPORT_PACK notify type
2626 //
2627 Status = InvokeRegisteredFunction (
2628 Private,
2629 EFI_HII_DATABASE_NOTIFY_EXPORT_PACK,
2630 (VOID *)Package,
2631 EFI_HII_PACKAGE_DEVICE_PATH,
2632 Handle
2633 );
2634 ASSERT_EFI_ERROR (Status);
2635
2636 //
2637 // Copy Device path package
2638 //
2639 CopyMem (Buffer, Package, Header.Length);
2640 }
2641
2642 *ResultSize += Header.Length;
2643 return EFI_SUCCESS;
2644}
2645
2646/**
2647 This function deletes Device Path package from a package list node.
2648 This is a internal function.
2649
2650 @param Private Hii database private data.
2651 @param Handle Handle of the package list.
2652 @param PackageList Package List which contains the to be removed
2653 Device Path package.
2654
2655 @retval EFI_SUCCESS Device Path Package is deleted successfully.
2656 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
2657
2658**/
2659EFI_STATUS
2660RemoveDevicePathPackage (
2661 IN HII_DATABASE_PRIVATE_DATA *Private,
2662 IN EFI_HII_HANDLE Handle,
2663 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList
2664 )
2665{
2666 EFI_STATUS Status;
2667 UINT8 *Package;
2668 EFI_HII_PACKAGE_HEADER Header;
2669
2670 Package = PackageList->DevicePathPkg;
2671
2672 //
2673 // No device path, return directly.
2674 //
2675 if (Package == NULL) {
2676 return EFI_SUCCESS;
2677 }
2678
2679 Status = InvokeRegisteredFunction (
2680 Private,
2681 EFI_HII_DATABASE_NOTIFY_REMOVE_PACK,
2682 (VOID *)Package,
2683 EFI_HII_PACKAGE_DEVICE_PATH,
2684 Handle
2685 );
2686 if (EFI_ERROR (Status)) {
2687 return Status;
2688 }
2689
2690 CopyMem (&Header, Package, sizeof (EFI_HII_PACKAGE_HEADER));
2691 PackageList->PackageListHdr.PackageLength -= Header.Length;
2692
2693 FreePool (Package);
2694
2695 PackageList->DevicePathPkg = NULL;
2696
2697 return EFI_SUCCESS;
2698}
2699
2700/**
2701 This function will insert a device path package to package list firstly then
2702 invoke notification functions if any.
2703 This is a internal function.
2704
2705 @param Private Hii database private structure.
2706 @param NotifyType The type of change concerning the database.
2707 @param DevicePath Pointer to a EFI_DEVICE_PATH_PROTOCOL protocol
2708 instance
2709 @param DatabaseRecord Pointer to a database record contains a package
2710 list which will be inserted to.
2711
2712 @retval EFI_SUCCESS Device path Package is inserted successfully.
2713 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
2714 Device path package.
2715 @retval EFI_INVALID_PARAMETER DevicePath is NULL or PackageList is NULL.
2716
2717**/
2718EFI_STATUS
2719AddDevicePathPackage (
2720 IN HII_DATABASE_PRIVATE_DATA *Private,
2721 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType,
2722 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
2723 IN OUT HII_DATABASE_RECORD *DatabaseRecord
2724 )
2725{
2726 EFI_STATUS Status;
2727
2728 if (DevicePath == NULL) {
2729 return EFI_SUCCESS;
2730 }
2731
2732 ASSERT (Private != NULL);
2733 ASSERT (DatabaseRecord != NULL);
2734
2735 //
2736 // Create a device path package and insert to packagelist
2737 //
2738 Status = InsertDevicePathPackage (
2739 DevicePath,
2740 NotifyType,
2741 DatabaseRecord->PackageList
2742 );
2743 if (EFI_ERROR (Status)) {
2744 return Status;
2745 }
2746
2747 return InvokeRegisteredFunction (
2748 Private,
2749 NotifyType,
2750 (VOID *)DatabaseRecord->PackageList->DevicePathPkg,
2751 EFI_HII_PACKAGE_DEVICE_PATH,
2752 DatabaseRecord->Handle
2753 );
2754}
2755
2756/**
2757 This function insert a Keyboard Layout package to a package list node.
2758 This is a internal function.
2759
2760 @param PackageHdr Pointer to a buffer stored with Keyboard Layout
2761 package information.
2762 @param NotifyType The type of change concerning the database.
2763 @param PackageList Pointer to a package list which will be inserted
2764 to.
2765 @param Package Created Keyboard Layout package
2766
2767 @retval EFI_SUCCESS Keyboard Layout Package is inserted successfully.
2768 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
2769 Keyboard Layout package.
2770 @retval EFI_INVALID_PARAMETER PackageHdr is NULL or PackageList is NULL.
2771
2772**/
2773EFI_STATUS
2774InsertKeyboardLayoutPackage (
2775 IN VOID *PackageHdr,
2776 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType,
2777 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
2778 OUT HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE **Package
2779 )
2780{
2781 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE *KeyboardLayoutPackage;
2782 EFI_HII_PACKAGE_HEADER PackageHeader;
2783 EFI_STATUS Status;
2784
2785 if ((PackageHdr == NULL) || (PackageList == NULL)) {
2786 return EFI_INVALID_PARAMETER;
2787 }
2788
2789 CopyMem (&PackageHeader, PackageHdr, sizeof (EFI_HII_PACKAGE_HEADER));
2790
2791 //
2792 // Create a Keyboard Layout package node
2793 //
2794 KeyboardLayoutPackage = AllocateZeroPool (sizeof (HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE));
2795 if (KeyboardLayoutPackage == NULL) {
2796 Status = EFI_OUT_OF_RESOURCES;
2797 goto Error;
2798 }
2799
2800 KeyboardLayoutPackage->Signature = HII_KB_LAYOUT_PACKAGE_SIGNATURE;
2801
2802 KeyboardLayoutPackage->KeyboardPkg = (UINT8 *)AllocateZeroPool (PackageHeader.Length);
2803 if (KeyboardLayoutPackage->KeyboardPkg == NULL) {
2804 Status = EFI_OUT_OF_RESOURCES;
2805 goto Error;
2806 }
2807
2808 CopyMem (KeyboardLayoutPackage->KeyboardPkg, PackageHdr, PackageHeader.Length);
2809 InsertTailList (&PackageList->KeyboardLayoutHdr, &KeyboardLayoutPackage->KeyboardEntry);
2810
2811 *Package = KeyboardLayoutPackage;
2812
2813 if (NotifyType == EFI_HII_DATABASE_NOTIFY_ADD_PACK) {
2814 PackageList->PackageListHdr.PackageLength += PackageHeader.Length;
2815 }
2816
2817 return EFI_SUCCESS;
2818
2819Error:
2820
2821 if (KeyboardLayoutPackage != NULL) {
2822 if (KeyboardLayoutPackage->KeyboardPkg != NULL) {
2823 FreePool (KeyboardLayoutPackage->KeyboardPkg);
2824 }
2825
2826 FreePool (KeyboardLayoutPackage);
2827 }
2828
2829 return Status;
2830}
2831
2832/**
2833 This function exports Keyboard Layout packages to a buffer.
2834 This is a internal function.
2835
2836 @param Private Hii database private structure.
2837 @param Handle Identification of a package list.
2838 @param PackageList Pointer to a package list which will be exported.
2839 @param UsedSize The length of buffer be used.
2840 @param BufferSize Length of the Buffer.
2841 @param Buffer Allocated space for storing exported data.
2842 @param ResultSize The size of the already exported content of this
2843 package list.
2844
2845 @retval EFI_SUCCESS Keyboard Layout Packages are exported
2846 successfully.
2847 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
2848
2849**/
2850EFI_STATUS
2851ExportKeyboardLayoutPackages (
2852 IN HII_DATABASE_PRIVATE_DATA *Private,
2853 IN EFI_HII_HANDLE Handle,
2854 IN HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
2855 IN UINTN UsedSize,
2856 IN UINTN BufferSize,
2857 IN OUT VOID *Buffer,
2858 IN OUT UINTN *ResultSize
2859 )
2860{
2861 LIST_ENTRY *Link;
2862 UINTN PackageLength;
2863 EFI_STATUS Status;
2864 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE *Package;
2865 EFI_HII_PACKAGE_HEADER PackageHeader;
2866
2867 if ((Private == NULL) || (PackageList == NULL) || (ResultSize == NULL)) {
2868 return EFI_INVALID_PARAMETER;
2869 }
2870
2871 if ((BufferSize > 0) && (Buffer == NULL)) {
2872 return EFI_INVALID_PARAMETER;
2873 }
2874
2875 PackageLength = 0;
2876 Status = EFI_SUCCESS;
2877
2878 for (Link = PackageList->KeyboardLayoutHdr.ForwardLink; Link != &PackageList->KeyboardLayoutHdr; Link = Link->ForwardLink) {
2879 Package = CR (Link, HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE, KeyboardEntry, HII_KB_LAYOUT_PACKAGE_SIGNATURE);
2880 CopyMem (&PackageHeader, Package->KeyboardPkg, sizeof (EFI_HII_PACKAGE_HEADER));
2881 PackageLength += PackageHeader.Length;
2882 if (PackageLength + *ResultSize + UsedSize <= BufferSize) {
2883 //
2884 // Invoke registered notification function with EXPORT_PACK notify type
2885 //
2886 Status = InvokeRegisteredFunction (
2887 Private,
2888 EFI_HII_DATABASE_NOTIFY_EXPORT_PACK,
2889 (EFI_HII_PACKAGE_HEADER *)Package,
2890 EFI_HII_PACKAGE_KEYBOARD_LAYOUT,
2891 Handle
2892 );
2893 ASSERT_EFI_ERROR (Status);
2894
2895 //
2896 // Copy Keyboard Layout package
2897 //
2898 CopyMem (Buffer, Package->KeyboardPkg, PackageHeader.Length);
2899 Buffer = (UINT8 *)Buffer + PackageHeader.Length;
2900 }
2901 }
2902
2903 *ResultSize += PackageLength;
2904 return EFI_SUCCESS;
2905}
2906
2907/**
2908 This function deletes all Keyboard Layout packages from a package list node.
2909 This is a internal function.
2910
2911 @param Private Hii database private data.
2912 @param Handle Handle of the package list which contains the to
2913 be removed Keyboard Layout packages.
2914 @param PackageList Pointer to a package list that contains removing
2915 packages.
2916
2917 @retval EFI_SUCCESS Keyboard Layout Package(s) is deleted
2918 successfully.
2919 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
2920
2921**/
2922EFI_STATUS
2923RemoveKeyboardLayoutPackages (
2924 IN HII_DATABASE_PRIVATE_DATA *Private,
2925 IN EFI_HII_HANDLE Handle,
2926 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList
2927 )
2928{
2929 LIST_ENTRY *ListHead;
2930 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE *Package;
2931 EFI_HII_PACKAGE_HEADER PackageHeader;
2932 EFI_STATUS Status;
2933
2934 ListHead = &PackageList->KeyboardLayoutHdr;
2935
2936 while (!IsListEmpty (ListHead)) {
2937 Package = CR (
2938 ListHead->ForwardLink,
2939 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE,
2940 KeyboardEntry,
2941 HII_KB_LAYOUT_PACKAGE_SIGNATURE
2942 );
2943 Status = InvokeRegisteredFunction (
2944 Private,
2945 EFI_HII_DATABASE_NOTIFY_REMOVE_PACK,
2946 (VOID *)Package,
2947 EFI_HII_PACKAGE_KEYBOARD_LAYOUT,
2948 Handle
2949 );
2950 if (EFI_ERROR (Status)) {
2951 return Status;
2952 }
2953
2954 RemoveEntryList (&Package->KeyboardEntry);
2955 CopyMem (&PackageHeader, Package->KeyboardPkg, sizeof (EFI_HII_PACKAGE_HEADER));
2956 PackageList->PackageListHdr.PackageLength -= PackageHeader.Length;
2957 FreePool (Package->KeyboardPkg);
2958 FreePool (Package);
2959 }
2960
2961 return EFI_SUCCESS;
2962}
2963
2964/**
2965 This function will insert a package list to hii database firstly then
2966 invoke notification functions if any. It is the worker function of
2967 HiiNewPackageList and HiiUpdatePackageList.
2968
2969 This is a internal function.
2970
2971 @param Private Hii database private structure.
2972 @param NotifyType The type of change concerning the database.
2973 @param PackageList Pointer to a package list.
2974 @param DatabaseRecord Pointer to a database record contains a package
2975 list instance which will be inserted to.
2976
2977 @retval EFI_SUCCESS All incoming packages are inserted to current
2978 database.
2979 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
2980 Device path package.
2981 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
2982
2983**/
2984EFI_STATUS
2985AddPackages (
2986 IN HII_DATABASE_PRIVATE_DATA *Private,
2987 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType,
2988 IN CONST EFI_HII_PACKAGE_LIST_HEADER *PackageList,
2989 IN OUT HII_DATABASE_RECORD *DatabaseRecord
2990 )
2991{
2992 EFI_STATUS Status;
2993 HII_GUID_PACKAGE_INSTANCE *GuidPackage;
2994 HII_IFR_PACKAGE_INSTANCE *FormPackage;
2995 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE *KeyboardLayoutPackage;
2996 HII_STRING_PACKAGE_INSTANCE *StringPackage;
2997 HII_FONT_PACKAGE_INSTANCE *FontPackage;
2998 HII_SIMPLE_FONT_PACKAGE_INSTANCE *SimpleFontPackage;
2999 HII_IMAGE_PACKAGE_INSTANCE *ImagePackage;
3000 EFI_HII_PACKAGE_HEADER *PackageHdrPtr;
3001 EFI_HII_PACKAGE_HEADER PackageHeader;
3002 UINT32 OldPackageListLen;
3003 BOOLEAN StringPkgIsAdd;
3004
3005 //
3006 // Initialize Variables
3007 //
3008 StringPkgIsAdd = FALSE;
3009 FontPackage = NULL;
3010 StringPackage = NULL;
3011 GuidPackage = NULL;
3012 FormPackage = NULL;
3013 ImagePackage = NULL;
3014 SimpleFontPackage = NULL;
3015 KeyboardLayoutPackage = NULL;
3016
3017 //
3018 // Process the package list header
3019 //
3020 OldPackageListLen = DatabaseRecord->PackageList->PackageListHdr.PackageLength;
3021 CopyMem (
3022 &DatabaseRecord->PackageList->PackageListHdr,
3023 (VOID *)PackageList,
3024 sizeof (EFI_HII_PACKAGE_LIST_HEADER)
3025 );
3026 if (NotifyType == EFI_HII_DATABASE_NOTIFY_ADD_PACK) {
3027 DatabaseRecord->PackageList->PackageListHdr.PackageLength = OldPackageListLen;
3028 }
3029
3030 PackageHdrPtr = (EFI_HII_PACKAGE_HEADER *)((UINT8 *)PackageList + sizeof (EFI_HII_PACKAGE_LIST_HEADER));
3031 CopyMem (&PackageHeader, PackageHdrPtr, sizeof (EFI_HII_PACKAGE_HEADER));
3032
3033 Status = EFI_SUCCESS;
3034
3035 while (PackageHeader.Type != EFI_HII_PACKAGE_END) {
3036 switch (PackageHeader.Type) {
3037 case EFI_HII_PACKAGE_TYPE_GUID:
3038 Status = InsertGuidPackage (
3039 PackageHdrPtr,
3040 NotifyType,
3041 DatabaseRecord->PackageList,
3042 &GuidPackage
3043 );
3044 if (EFI_ERROR (Status)) {
3045 return Status;
3046 }
3047
3048 Status = InvokeRegisteredFunction (
3049 Private,
3050 NotifyType,
3051 (VOID *)GuidPackage,
3052 (UINT8)(PackageHeader.Type),
3053 DatabaseRecord->Handle
3054 );
3055 break;
3056 case EFI_HII_PACKAGE_FORMS:
3057 Status = InsertFormPackage (
3058 PackageHdrPtr,
3059 NotifyType,
3060 DatabaseRecord->PackageList,
3061 &FormPackage
3062 );
3063 if (EFI_ERROR (Status)) {
3064 return Status;
3065 }
3066
3067 Status = InvokeRegisteredFunction (
3068 Private,
3069 NotifyType,
3070 (VOID *)FormPackage,
3071 (UINT8)(PackageHeader.Type),
3072 DatabaseRecord->Handle
3073 );
3074 //
3075 // If Hii runtime support feature is enabled,
3076 // will export Hii info for runtime use after ReadyToBoot event triggered.
3077 // If some driver add/update/remove packages from HiiDatabase after ReadyToBoot,
3078 // will need to export the content of HiiDatabase.
3079 // But if form packages added/updated, also need to export the ConfigResp string.
3080 //
3081 if (gExportAfterReadyToBoot) {
3082 gExportConfigResp = TRUE;
3083 }
3084
3085 break;
3086 case EFI_HII_PACKAGE_KEYBOARD_LAYOUT:
3087 Status = InsertKeyboardLayoutPackage (
3088 PackageHdrPtr,
3089 NotifyType,
3090 DatabaseRecord->PackageList,
3091 &KeyboardLayoutPackage
3092 );
3093 if (EFI_ERROR (Status)) {
3094 return Status;
3095 }
3096
3097 Status = InvokeRegisteredFunction (
3098 Private,
3099 NotifyType,
3100 (VOID *)KeyboardLayoutPackage,
3101 (UINT8)(PackageHeader.Type),
3102 DatabaseRecord->Handle
3103 );
3104 break;
3105 case EFI_HII_PACKAGE_STRINGS:
3106 Status = InsertStringPackage (
3107 Private,
3108 PackageHdrPtr,
3109 NotifyType,
3110 DatabaseRecord->PackageList,
3111 &StringPackage
3112 );
3113 if (EFI_ERROR (Status)) {
3114 return Status;
3115 }
3116
3117 ASSERT (StringPackage != NULL);
3118 Status = InvokeRegisteredFunction (
3119 Private,
3120 NotifyType,
3121 (VOID *)StringPackage,
3122 (UINT8)(PackageHeader.Type),
3123 DatabaseRecord->Handle
3124 );
3125 StringPkgIsAdd = TRUE;
3126 break;
3127 case EFI_HII_PACKAGE_FONTS:
3128 Status = InsertFontPackage (
3129 Private,
3130 PackageHdrPtr,
3131 NotifyType,
3132 DatabaseRecord->PackageList,
3133 &FontPackage
3134 );
3135 if (EFI_ERROR (Status)) {
3136 return Status;
3137 }
3138
3139 Status = InvokeRegisteredFunction (
3140 Private,
3141 NotifyType,
3142 (VOID *)FontPackage,
3143 (UINT8)(PackageHeader.Type),
3144 DatabaseRecord->Handle
3145 );
3146 break;
3147 case EFI_HII_PACKAGE_IMAGES:
3148 Status = InsertImagePackage (
3149 PackageHdrPtr,
3150 NotifyType,
3151 DatabaseRecord->PackageList,
3152 &ImagePackage
3153 );
3154 if (EFI_ERROR (Status)) {
3155 return Status;
3156 }
3157
3158 Status = InvokeRegisteredFunction (
3159 Private,
3160 NotifyType,
3161 (VOID *)ImagePackage,
3162 (UINT8)(PackageHeader.Type),
3163 DatabaseRecord->Handle
3164 );
3165 break;
3166 case EFI_HII_PACKAGE_SIMPLE_FONTS:
3167 Status = InsertSimpleFontPackage (
3168 PackageHdrPtr,
3169 NotifyType,
3170 DatabaseRecord->PackageList,
3171 &SimpleFontPackage
3172 );
3173 if (EFI_ERROR (Status)) {
3174 return Status;
3175 }
3176
3177 Status = InvokeRegisteredFunction (
3178 Private,
3179 NotifyType,
3180 (VOID *)SimpleFontPackage,
3181 (UINT8)(PackageHeader.Type),
3182 DatabaseRecord->Handle
3183 );
3184 break;
3185 case EFI_HII_PACKAGE_DEVICE_PATH:
3186 Status = AddDevicePathPackage (
3187 Private,
3188 NotifyType,
3189 (EFI_DEVICE_PATH_PROTOCOL *)((UINT8 *)PackageHdrPtr + sizeof (EFI_HII_PACKAGE_HEADER)),
3190 DatabaseRecord
3191 );
3192 break;
3193 default:
3194 break;
3195 }
3196
3197 if (EFI_ERROR (Status)) {
3198 return Status;
3199 }
3200
3201 //
3202 // goto header of next package
3203 //
3204 PackageHdrPtr = (EFI_HII_PACKAGE_HEADER *)((UINT8 *)PackageHdrPtr + PackageHeader.Length);
3205 CopyMem (&PackageHeader, PackageHdrPtr, sizeof (EFI_HII_PACKAGE_HEADER));
3206 }
3207
3208 //
3209 // Adjust String Package to make sure all string packages have the same max string ID.
3210 //
3211 if (!EFI_ERROR (Status) && StringPkgIsAdd) {
3212 Status = AdjustStringPackage (DatabaseRecord->PackageList);
3213 }
3214
3215 return Status;
3216}
3217
3218/**
3219 This function exports a package list to a buffer. It is the worker function
3220 of HiiExportPackageList.
3221
3222 This is a internal function.
3223
3224 @param Private Hii database private structure.
3225 @param Handle Identification of a package list.
3226 @param PackageList Pointer to a package list which will be exported.
3227 @param UsedSize The length of buffer has been used by exporting
3228 package lists when Handle is NULL.
3229 @param BufferSize Length of the Buffer.
3230 @param Buffer Allocated space for storing exported data.
3231
3232 @retval EFI_SUCCESS Keyboard Layout Packages are exported
3233 successfully.
3234 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
3235
3236**/
3237EFI_STATUS
3238ExportPackageList (
3239 IN HII_DATABASE_PRIVATE_DATA *Private,
3240 IN EFI_HII_HANDLE Handle,
3241 IN HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
3242 IN OUT UINTN *UsedSize,
3243 IN UINTN BufferSize,
3244 OUT EFI_HII_PACKAGE_LIST_HEADER *Buffer
3245 )
3246{
3247 EFI_STATUS Status;
3248 UINTN ResultSize;
3249 EFI_HII_PACKAGE_HEADER EndofPackageList;
3250
3251 ASSERT (Private != NULL && PackageList != NULL && UsedSize != NULL);
3252 ASSERT (Private->Signature == HII_DATABASE_PRIVATE_DATA_SIGNATURE);
3253 ASSERT (IsHiiHandleValid (Handle));
3254
3255 if ((BufferSize > 0) && (Buffer == NULL)) {
3256 return EFI_INVALID_PARAMETER;
3257 }
3258
3259 //
3260 // Copy the package list header
3261 // ResultSize indicates the length of the exported bytes of this package list
3262 //
3263 ResultSize = sizeof (EFI_HII_PACKAGE_LIST_HEADER);
3264 if (ResultSize + *UsedSize <= BufferSize) {
3265 CopyMem ((VOID *)Buffer, PackageList, ResultSize);
3266 }
3267
3268 //
3269 // Copy the packages and invoke EXPORT_PACK notify functions if exists.
3270 //
3271 Status = ExportGuidPackages (
3272 Private,
3273 Handle,
3274 PackageList,
3275 *UsedSize,
3276 BufferSize,
3277 (VOID *)((UINT8 *)Buffer + ResultSize),
3278 &ResultSize
3279 );
3280 if (EFI_ERROR (Status)) {
3281 return Status;
3282 }
3283
3284 Status = ExportFormPackages (
3285 Private,
3286 Handle,
3287 PackageList,
3288 *UsedSize,
3289 BufferSize,
3290 (VOID *)((UINT8 *)Buffer + ResultSize),
3291 &ResultSize
3292 );
3293 if (EFI_ERROR (Status)) {
3294 return Status;
3295 }
3296
3297 Status = ExportKeyboardLayoutPackages (
3298 Private,
3299 Handle,
3300 PackageList,
3301 *UsedSize,
3302 BufferSize,
3303 (VOID *)((UINT8 *)Buffer + ResultSize),
3304 &ResultSize
3305 );
3306 if (EFI_ERROR (Status)) {
3307 return Status;
3308 }
3309
3310 Status = ExportStringPackages (
3311 Private,
3312 Handle,
3313 PackageList,
3314 *UsedSize,
3315 BufferSize,
3316 (VOID *)((UINT8 *)Buffer + ResultSize),
3317 &ResultSize
3318 );
3319 if (EFI_ERROR (Status)) {
3320 return Status;
3321 }
3322
3323 Status = ExportFontPackages (
3324 Private,
3325 Handle,
3326 PackageList,
3327 *UsedSize,
3328 BufferSize,
3329 (VOID *)((UINT8 *)Buffer + ResultSize),
3330 &ResultSize
3331 );
3332 if (EFI_ERROR (Status)) {
3333 return Status;
3334 }
3335
3336 Status = ExportImagePackages (
3337 Private,
3338 Handle,
3339 PackageList,
3340 *UsedSize,
3341 BufferSize,
3342 (VOID *)((UINT8 *)Buffer + ResultSize),
3343 &ResultSize
3344 );
3345 if (EFI_ERROR (Status)) {
3346 return Status;
3347 }
3348
3349 Status = ExportSimpleFontPackages (
3350 Private,
3351 Handle,
3352 PackageList,
3353 *UsedSize,
3354 BufferSize,
3355 (VOID *)((UINT8 *)Buffer + ResultSize),
3356 &ResultSize
3357 );
3358 if (EFI_ERROR (Status)) {
3359 return Status;
3360 }
3361
3362 Status = ExportDevicePathPackage (
3363 Private,
3364 Handle,
3365 PackageList,
3366 *UsedSize,
3367 BufferSize,
3368 (VOID *)((UINT8 *)Buffer + ResultSize),
3369 &ResultSize
3370 );
3371 if (EFI_ERROR (Status)) {
3372 return Status;
3373 }
3374
3375 //
3376 // Append the package list end.
3377 //
3378 EndofPackageList.Length = sizeof (EFI_HII_PACKAGE_HEADER);
3379 EndofPackageList.Type = EFI_HII_PACKAGE_END;
3380 if (ResultSize + *UsedSize + sizeof (EFI_HII_PACKAGE_HEADER) <= BufferSize) {
3381 CopyMem (
3382 (VOID *)((UINT8 *)Buffer + ResultSize),
3383 (VOID *)&EndofPackageList,
3384 sizeof (EFI_HII_PACKAGE_HEADER)
3385 );
3386 }
3387
3388 *UsedSize += ResultSize + sizeof (EFI_HII_PACKAGE_HEADER);
3389
3390 return EFI_SUCCESS;
3391}
3392
3393/**
3394This function mainly use to get and update ConfigResp string.
3395
3396@param This A pointer to the EFI_HII_DATABASE_PROTOCOL instance.
3397
3398@retval EFI_SUCCESS Get the information successfully.
3399@retval EFI_OUT_OF_RESOURCES Not enough memory to store the Configuration Setting data.
3400
3401**/
3402EFI_STATUS
3403HiiGetConfigRespInfo (
3404 IN CONST EFI_HII_DATABASE_PROTOCOL *This
3405 )
3406{
3407 EFI_STATUS Status;
3408 HII_DATABASE_PRIVATE_DATA *Private;
3409 EFI_STRING ConfigAltResp;
3410 UINTN ConfigSize;
3411
3412 ConfigAltResp = NULL;
3413 ConfigSize = 0;
3414
3415 Private = HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
3416
3417 //
3418 // Get ConfigResp string
3419 //
3420 Status = HiiConfigRoutingExportConfig (&Private->ConfigRouting, &ConfigAltResp);
3421
3422 if (!EFI_ERROR (Status)) {
3423 ConfigSize = StrSize (ConfigAltResp);
3424 if (ConfigSize > gConfigRespSize) {
3425 //
3426 // Do 25% overallocation to minimize the number of memory allocations after ReadyToBoot.
3427 // Since lots of allocation after ReadyToBoot may change memory map and cause S4 resume issue.
3428 //
3429 gConfigRespSize = ConfigSize + (ConfigSize >> 2);
3430 if (gRTConfigRespBuffer != NULL) {
3431 FreePool (gRTConfigRespBuffer);
3432 DEBUG ((DEBUG_WARN, "[HiiDatabase]: Memory allocation is required after ReadyToBoot, which may change memory map and cause S4 resume issue.\n"));
3433 }
3434
3435 gRTConfigRespBuffer = (EFI_STRING)AllocateRuntimeZeroPool (gConfigRespSize);
3436 if (gRTConfigRespBuffer == NULL) {
3437 FreePool (ConfigAltResp);
3438 DEBUG ((DEBUG_ERROR, "[HiiDatabase]: No enough memory resource to store the ConfigResp string.\n"));
3439 //
3440 // Remove from the System Table when the configuration runtime buffer is freed.
3441 //
3442 gBS->InstallConfigurationTable (&gEfiHiiConfigRoutingProtocolGuid, NULL);
3443 return EFI_OUT_OF_RESOURCES;
3444 }
3445 } else {
3446 ZeroMem (gRTConfigRespBuffer, gConfigRespSize);
3447 }
3448
3449 CopyMem (gRTConfigRespBuffer, ConfigAltResp, ConfigSize);
3450 gBS->InstallConfigurationTable (&gEfiHiiConfigRoutingProtocolGuid, gRTConfigRespBuffer);
3451 FreePool (ConfigAltResp);
3452 }
3453
3454 return EFI_SUCCESS;
3455}
3456
3457/**
3458This is an internal function,mainly use to get HiiDatabase information.
3459
3460@param This A pointer to the EFI_HII_DATABASE_PROTOCOL instance.
3461
3462@retval EFI_SUCCESS Get the information successfully.
3463@retval EFI_OUT_OF_RESOURCES Not enough memory to store the Hiidatabase data.
3464
3465**/
3466EFI_STATUS
3467HiiGetDatabaseInfo (
3468 IN CONST EFI_HII_DATABASE_PROTOCOL *This
3469 )
3470{
3471 EFI_STATUS Status;
3472 EFI_HII_PACKAGE_LIST_HEADER *DatabaseInfo;
3473 UINTN DatabaseInfoSize;
3474
3475 DatabaseInfo = NULL;
3476 DatabaseInfoSize = 0;
3477
3478 //
3479 // Get HiiDatabase information.
3480 //
3481 Status = HiiExportPackageLists (This, NULL, &DatabaseInfoSize, DatabaseInfo);
3482
3483 ASSERT (Status == EFI_BUFFER_TOO_SMALL);
3484
3485 if (DatabaseInfoSize > gDatabaseInfoSize ) {
3486 //
3487 // Do 25% overallocation to minimize the number of memory allocations after ReadyToBoot.
3488 // Since lots of allocation after ReadyToBoot may change memory map and cause S4 resume issue.
3489 //
3490 gDatabaseInfoSize = DatabaseInfoSize + (DatabaseInfoSize >> 2);
3491 if (gRTDatabaseInfoBuffer != NULL) {
3492 FreePool (gRTDatabaseInfoBuffer);
3493 DEBUG ((DEBUG_WARN, "[HiiDatabase]: Memory allocation is required after ReadyToBoot, which may change memory map and cause S4 resume issue.\n"));
3494 }
3495
3496 gRTDatabaseInfoBuffer = AllocateRuntimeZeroPool (gDatabaseInfoSize);
3497 if (gRTDatabaseInfoBuffer == NULL) {
3498 DEBUG ((DEBUG_ERROR, "[HiiDatabase]: No enough memory resource to store the HiiDatabase info.\n"));
3499 //
3500 // Remove from the System Table when the configuration runtime buffer is freed.
3501 //
3502 gBS->InstallConfigurationTable (&gEfiHiiDatabaseProtocolGuid, NULL);
3503 return EFI_OUT_OF_RESOURCES;
3504 }
3505 } else {
3506 ZeroMem (gRTDatabaseInfoBuffer, gDatabaseInfoSize);
3507 }
3508
3509 Status = HiiExportPackageLists (This, NULL, &DatabaseInfoSize, gRTDatabaseInfoBuffer);
3510 ASSERT_EFI_ERROR (Status);
3511 gBS->InstallConfigurationTable (&gEfiHiiDatabaseProtocolGuid, gRTDatabaseInfoBuffer);
3512
3513 return EFI_SUCCESS;
3514}
3515
3516/**
3517 This function adds the packages in the package list to the database and returns a handle. If there is a
3518 EFI_DEVICE_PATH_PROTOCOL associated with the DriverHandle, then this function will
3519 create a package of type EFI_PACKAGE_TYPE_DEVICE_PATH and add it to the package list.
3520
3521 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
3522 instance.
3523 @param PackageList A pointer to an EFI_HII_PACKAGE_LIST_HEADER
3524 structure.
3525 @param DriverHandle Associate the package list with this EFI handle.
3526 If a NULL is specified, this data will not be associate
3527 with any drivers and cannot have a callback induced.
3528 @param Handle A pointer to the EFI_HII_HANDLE instance.
3529
3530 @retval EFI_SUCCESS The package list associated with the Handle was
3531 added to the HII database.
3532 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
3533 database contents.
3534 @retval EFI_INVALID_PARAMETER PackageList is NULL or Handle is NULL.
3535 @retval EFI_INVALID_PARAMETER PackageListGuid already exists in database.
3536
3537**/
3538EFI_STATUS
3539EFIAPI
3540HiiNewPackageList (
3541 IN CONST EFI_HII_DATABASE_PROTOCOL *This,
3542 IN CONST EFI_HII_PACKAGE_LIST_HEADER *PackageList,
3543 IN CONST EFI_HANDLE DriverHandle OPTIONAL,
3544 OUT EFI_HII_HANDLE *Handle
3545 )
3546{
3547 EFI_STATUS Status;
3548 HII_DATABASE_PRIVATE_DATA *Private;
3549 HII_DATABASE_RECORD *DatabaseRecord;
3550 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
3551 LIST_ENTRY *Link;
3552 EFI_GUID PackageListGuid;
3553
3554 if ((This == NULL) || (PackageList == NULL) || (Handle == NULL)) {
3555 return EFI_INVALID_PARAMETER;
3556 }
3557
3558 Private = HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
3559 CopyMem (&PackageListGuid, (VOID *)PackageList, sizeof (EFI_GUID));
3560
3561 //
3562 // Check the Package list GUID to guarantee this GUID is unique in database.
3563 //
3564 for (Link = Private->DatabaseList.ForwardLink; Link != &Private->DatabaseList; Link = Link->ForwardLink) {
3565 DatabaseRecord = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
3566 if (CompareGuid (
3567 &(DatabaseRecord->PackageList->PackageListHdr.PackageListGuid),
3568 &PackageListGuid
3569 ) &&
3570 (DatabaseRecord->DriverHandle == DriverHandle))
3571 {
3572 return EFI_INVALID_PARAMETER;
3573 }
3574 }
3575
3576 EfiAcquireLock (&mHiiDatabaseLock);
3577
3578 //
3579 // Build a PackageList node
3580 //
3581 Status = GenerateHiiDatabaseRecord (Private, &DatabaseRecord);
3582 if (EFI_ERROR (Status)) {
3583 EfiReleaseLock (&mHiiDatabaseLock);
3584 return Status;
3585 }
3586
3587 //
3588 // Fill in information of the created Package List node
3589 // according to incoming package list.
3590 //
3591 Status = AddPackages (Private, EFI_HII_DATABASE_NOTIFY_NEW_PACK, PackageList, DatabaseRecord);
3592 if (EFI_ERROR (Status)) {
3593 EfiReleaseLock (&mHiiDatabaseLock);
3594 return Status;
3595 }
3596
3597 DatabaseRecord->DriverHandle = DriverHandle;
3598
3599 //
3600 // Create a Device path package and add into the package list if exists.
3601 //
3602 Status = gBS->HandleProtocol (
3603 DriverHandle,
3604 &gEfiDevicePathProtocolGuid,
3605 (VOID **)&DevicePath
3606 );
3607 if (!EFI_ERROR (Status)) {
3608 Status = AddDevicePathPackage (Private, EFI_HII_DATABASE_NOTIFY_NEW_PACK, DevicePath, DatabaseRecord);
3609 ASSERT_EFI_ERROR (Status);
3610 }
3611
3612 *Handle = DatabaseRecord->Handle;
3613
3614 //
3615 // Check whether need to get the Database info.
3616 // Only after ReadyToBoot, need to do the export.
3617 //
3618 if (gExportAfterReadyToBoot) {
3619 HiiGetDatabaseInfo (This);
3620 }
3621
3622 EfiReleaseLock (&mHiiDatabaseLock);
3623
3624 //
3625 // Notes:
3626 // HiiGetDatabaseInfo () will get the contents of HII data base,
3627 // belong to the atomic behavior of Hii Database update.
3628 // And since HiiGetConfigRespInfo () will get the configuration setting info from HII drivers
3629 // we can not think it belong to the atomic behavior of Hii Database update.
3630 // That's why EfiReleaseLock (&mHiiDatabaseLock) is callled before HiiGetConfigRespInfo ().
3631 //
3632
3633 // Check whether need to get the configuration setting info from HII drivers.
3634 // When after ReadyToBoot and need to do the export for form package add.
3635 //
3636 if (gExportAfterReadyToBoot && gExportConfigResp) {
3637 HiiGetConfigRespInfo (This);
3638 }
3639
3640 return EFI_SUCCESS;
3641}
3642
3643/**
3644 This function removes the package list that is associated with Handle
3645 from the HII database. Before removing the package, any registered functions
3646 with the notification type REMOVE_PACK and the same package type will be called.
3647
3648 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
3649 instance.
3650 @param Handle The handle that was registered to the data that is
3651 requested for removal.
3652
3653 @retval EFI_SUCCESS The data associated with the Handle was removed
3654 from the HII database.
3655 @retval EFI_NOT_FOUND The specified handle is not in database.
3656 @retval EFI_INVALID_PARAMETER The Handle was not valid.
3657
3658**/
3659EFI_STATUS
3660EFIAPI
3661HiiRemovePackageList (
3662 IN CONST EFI_HII_DATABASE_PROTOCOL *This,
3663 IN EFI_HII_HANDLE Handle
3664 )
3665{
3666 EFI_STATUS Status;
3667 HII_DATABASE_PRIVATE_DATA *Private;
3668 LIST_ENTRY *Link;
3669 HII_DATABASE_RECORD *Node;
3670 HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList;
3671 HII_HANDLE *HiiHandle;
3672
3673 if (This == NULL) {
3674 return EFI_INVALID_PARAMETER;
3675 }
3676
3677 if (!IsHiiHandleValid (Handle)) {
3678 return EFI_NOT_FOUND;
3679 }
3680
3681 EfiAcquireLock (&mHiiDatabaseLock);
3682
3683 Private = HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
3684
3685 //
3686 // Get the packagelist to be removed.
3687 //
3688 for (Link = Private->DatabaseList.ForwardLink; Link != &Private->DatabaseList; Link = Link->ForwardLink) {
3689 Node = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
3690 if (Node->Handle == Handle) {
3691 PackageList = (HII_DATABASE_PACKAGE_LIST_INSTANCE *)(Node->PackageList);
3692 ASSERT (PackageList != NULL);
3693
3694 //
3695 // Call registered functions with REMOVE_PACK before removing packages
3696 // then remove them.
3697 //
3698 Status = RemoveGuidPackages (Private, Handle, PackageList);
3699 if (EFI_ERROR (Status)) {
3700 EfiReleaseLock (&mHiiDatabaseLock);
3701 return Status;
3702 }
3703
3704 Status = RemoveFormPackages (Private, Handle, PackageList);
3705 if (EFI_ERROR (Status)) {
3706 EfiReleaseLock (&mHiiDatabaseLock);
3707 return Status;
3708 }
3709
3710 Status = RemoveKeyboardLayoutPackages (Private, Handle, PackageList);
3711 if (EFI_ERROR (Status)) {
3712 EfiReleaseLock (&mHiiDatabaseLock);
3713 return Status;
3714 }
3715
3716 Status = RemoveStringPackages (Private, Handle, PackageList);
3717 if (EFI_ERROR (Status)) {
3718 EfiReleaseLock (&mHiiDatabaseLock);
3719 return Status;
3720 }
3721
3722 Status = RemoveFontPackages (Private, Handle, PackageList);
3723 if (EFI_ERROR (Status)) {
3724 EfiReleaseLock (&mHiiDatabaseLock);
3725 return Status;
3726 }
3727
3728 Status = RemoveImagePackages (Private, Handle, PackageList);
3729 if (EFI_ERROR (Status)) {
3730 EfiReleaseLock (&mHiiDatabaseLock);
3731 return Status;
3732 }
3733
3734 Status = RemoveSimpleFontPackages (Private, Handle, PackageList);
3735 if (EFI_ERROR (Status)) {
3736 EfiReleaseLock (&mHiiDatabaseLock);
3737 return Status;
3738 }
3739
3740 Status = RemoveDevicePathPackage (Private, Handle, PackageList);
3741 if (EFI_ERROR (Status)) {
3742 EfiReleaseLock (&mHiiDatabaseLock);
3743 return Status;
3744 }
3745
3746 //
3747 // Free resources of the package list
3748 //
3749 RemoveEntryList (&Node->DatabaseEntry);
3750
3751 HiiHandle = (HII_HANDLE *)Handle;
3752 RemoveEntryList (&HiiHandle->Handle);
3753 Private->HiiHandleCount--;
3754 ASSERT (Private->HiiHandleCount >= 0);
3755
3756 HiiHandle->Signature = 0;
3757 FreePool (HiiHandle);
3758 FreePool (Node->PackageList);
3759 FreePool (Node);
3760
3761 //
3762 // Check whether need to get the Database info.
3763 // Only after ReadyToBoot, need to do the export.
3764 //
3765 if (gExportAfterReadyToBoot) {
3766 HiiGetDatabaseInfo (This);
3767 }
3768
3769 EfiReleaseLock (&mHiiDatabaseLock);
3770
3771 //
3772 // Notes:
3773 // HiiGetDatabaseInfo () will get the contents of HII data base,
3774 // belong to the atomic behavior of Hii Database update.
3775 // And since HiiGetConfigRespInfo () will get the configuration setting info from HII drivers
3776 // we can not think it belong to the atomic behavior of Hii Database update.
3777 // That's why EfiReleaseLock (&mHiiDatabaseLock) is callled before HiiGetConfigRespInfo ().
3778 //
3779
3780 //
3781 // Check whether need to get the configuration setting info from HII drivers.
3782 // When after ReadyToBoot and need to do the export for form package remove.
3783 //
3784 if (gExportAfterReadyToBoot && gExportConfigResp) {
3785 HiiGetConfigRespInfo (This);
3786 }
3787
3788 return EFI_SUCCESS;
3789 }
3790 }
3791
3792 EfiReleaseLock (&mHiiDatabaseLock);
3793 return EFI_NOT_FOUND;
3794}
3795
3796/**
3797 This function updates the existing package list (which has the specified Handle)
3798 in the HII databases, using the new package list specified by PackageList.
3799
3800 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
3801 instance.
3802 @param Handle The handle that was registered to the data that is
3803 requested to be updated.
3804 @param PackageList A pointer to an EFI_HII_PACKAGE_LIST_HEADER
3805 package.
3806
3807 @retval EFI_SUCCESS The HII database was successfully updated.
3808 @retval EFI_OUT_OF_RESOURCES Unable to allocate enough memory for the updated
3809 database.
3810 @retval EFI_INVALID_PARAMETER PackageList was NULL.
3811 @retval EFI_NOT_FOUND The specified Handle is not in database.
3812
3813**/
3814EFI_STATUS
3815EFIAPI
3816HiiUpdatePackageList (
3817 IN CONST EFI_HII_DATABASE_PROTOCOL *This,
3818 IN EFI_HII_HANDLE Handle,
3819 IN CONST EFI_HII_PACKAGE_LIST_HEADER *PackageList
3820 )
3821{
3822 EFI_STATUS Status;
3823 HII_DATABASE_PRIVATE_DATA *Private;
3824 LIST_ENTRY *Link;
3825 HII_DATABASE_RECORD *Node;
3826 EFI_HII_PACKAGE_HEADER *PackageHdrPtr;
3827 HII_DATABASE_PACKAGE_LIST_INSTANCE *OldPackageList;
3828 EFI_HII_PACKAGE_HEADER PackageHeader;
3829
3830 if ((This == NULL) || (PackageList == NULL)) {
3831 return EFI_INVALID_PARAMETER;
3832 }
3833
3834 if (!IsHiiHandleValid (Handle)) {
3835 return EFI_NOT_FOUND;
3836 }
3837
3838 Private = HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
3839
3840 PackageHdrPtr = (EFI_HII_PACKAGE_HEADER *)((UINT8 *)PackageList + sizeof (EFI_HII_PACKAGE_LIST_HEADER));
3841
3842 Status = EFI_SUCCESS;
3843
3844 EfiAcquireLock (&mHiiDatabaseLock);
3845 //
3846 // Get original packagelist to be updated
3847 //
3848 for (Link = Private->DatabaseList.ForwardLink; Link != &Private->DatabaseList; Link = Link->ForwardLink) {
3849 Node = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
3850 if (Node->Handle == Handle) {
3851 OldPackageList = Node->PackageList;
3852 //
3853 // Remove the package if its type matches one of the package types which is
3854 // contained in the new package list.
3855 //
3856 CopyMem (&PackageHeader, PackageHdrPtr, sizeof (EFI_HII_PACKAGE_HEADER));
3857 while (PackageHeader.Type != EFI_HII_PACKAGE_END) {
3858 switch (PackageHeader.Type) {
3859 case EFI_HII_PACKAGE_TYPE_GUID:
3860 Status = RemoveGuidPackages (Private, Handle, OldPackageList);
3861 break;
3862 case EFI_HII_PACKAGE_FORMS:
3863 Status = RemoveFormPackages (Private, Handle, OldPackageList);
3864 break;
3865 case EFI_HII_PACKAGE_KEYBOARD_LAYOUT:
3866 Status = RemoveKeyboardLayoutPackages (Private, Handle, OldPackageList);
3867 break;
3868 case EFI_HII_PACKAGE_STRINGS:
3869 Status = RemoveStringPackages (Private, Handle, OldPackageList);
3870 break;
3871 case EFI_HII_PACKAGE_FONTS:
3872 Status = RemoveFontPackages (Private, Handle, OldPackageList);
3873 break;
3874 case EFI_HII_PACKAGE_IMAGES:
3875 Status = RemoveImagePackages (Private, Handle, OldPackageList);
3876 break;
3877 case EFI_HII_PACKAGE_SIMPLE_FONTS:
3878 Status = RemoveSimpleFontPackages (Private, Handle, OldPackageList);
3879 break;
3880 case EFI_HII_PACKAGE_DEVICE_PATH:
3881 Status = RemoveDevicePathPackage (Private, Handle, OldPackageList);
3882 break;
3883 }
3884
3885 if (EFI_ERROR (Status)) {
3886 EfiReleaseLock (&mHiiDatabaseLock);
3887 return Status;
3888 }
3889
3890 PackageHdrPtr = (EFI_HII_PACKAGE_HEADER *)((UINT8 *)PackageHdrPtr + PackageHeader.Length);
3891 CopyMem (&PackageHeader, PackageHdrPtr, sizeof (EFI_HII_PACKAGE_HEADER));
3892 }
3893
3894 //
3895 // Add all of the packages within the new package list
3896 //
3897 Status = AddPackages (Private, EFI_HII_DATABASE_NOTIFY_ADD_PACK, PackageList, Node);
3898
3899 //
3900 // Check whether need to get the Database info.
3901 // Only after ReadyToBoot, need to do the export.
3902 //
3903 if (gExportAfterReadyToBoot && (Status == EFI_SUCCESS)) {
3904 HiiGetDatabaseInfo (This);
3905 }
3906
3907 EfiReleaseLock (&mHiiDatabaseLock);
3908
3909 //
3910 // Notes:
3911 // HiiGetDatabaseInfo () will get the contents of HII data base,
3912 // belong to the atomic behavior of Hii Database update.
3913 // And since HiiGetConfigRespInfo () will get the configuration setting info from HII drivers
3914 // we can not think it belong to the atomic behavior of Hii Database update.
3915 // That's why EfiReleaseLock (&mHiiDatabaseLock) is callled before HiiGetConfigRespInfo ().
3916 //
3917
3918 //
3919 // Check whether need to get the configuration setting info from HII drivers.
3920 // When after ReadyToBoot and need to do the export for form package update.
3921 //
3922 if (gExportAfterReadyToBoot && gExportConfigResp && (Status == EFI_SUCCESS)) {
3923 HiiGetConfigRespInfo (This);
3924 }
3925
3926 return Status;
3927 }
3928 }
3929
3930 EfiReleaseLock (&mHiiDatabaseLock);
3931 return EFI_NOT_FOUND;
3932}
3933
3934/**
3935 This function returns a list of the package handles of the specified type
3936 that are currently active in the database. The pseudo-type
3937 EFI_HII_PACKAGE_TYPE_ALL will cause all package handles to be listed.
3938
3939 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
3940 instance.
3941 @param PackageType Specifies the package type of the packages to list
3942 or EFI_HII_PACKAGE_TYPE_ALL for all packages to be
3943 listed.
3944 @param PackageGuid If PackageType is EFI_HII_PACKAGE_TYPE_GUID, then
3945 this is the pointer to the GUID which must match
3946 the Guid field of EFI_HII_GUID_PACKAGE_GUID_HDR.
3947 Otherwise, it must be NULL.
3948 @param HandleBufferLength On input, a pointer to the length of the handle
3949 buffer. On output, the length of the handle
3950 buffer that is required for the handles found.
3951 @param Handle An array of EFI_HII_HANDLE instances returned.
3952
3953 @retval EFI_SUCCESS The matching handles are outputted successfully.
3954 HandleBufferLength is updated with the actual length.
3955 @retval EFI_BUFFER_TO_SMALL The HandleBufferLength parameter indicates that
3956 Handle is too small to support the number of
3957 handles. HandleBufferLength is updated with a
3958 value that will enable the data to fit.
3959 @retval EFI_NOT_FOUND No matching handle could not be found in database.
3960 @retval EFI_INVALID_PARAMETER HandleBufferLength was NULL.
3961 @retval EFI_INVALID_PARAMETER The value referenced by HandleBufferLength was not
3962 zero and Handle was NULL.
3963 @retval EFI_INVALID_PARAMETER PackageType is not a EFI_HII_PACKAGE_TYPE_GUID but
3964 PackageGuid is not NULL, PackageType is a EFI_HII_
3965 PACKAGE_TYPE_GUID but PackageGuid is NULL.
3966
3967**/
3968EFI_STATUS
3969EFIAPI
3970HiiListPackageLists (
3971 IN CONST EFI_HII_DATABASE_PROTOCOL *This,
3972 IN UINT8 PackageType,
3973 IN CONST EFI_GUID *PackageGuid,
3974 IN OUT UINTN *HandleBufferLength,
3975 OUT EFI_HII_HANDLE *Handle
3976 )
3977{
3978 HII_GUID_PACKAGE_INSTANCE *GuidPackage;
3979 HII_DATABASE_PRIVATE_DATA *Private;
3980 HII_DATABASE_RECORD *Node;
3981 LIST_ENTRY *Link;
3982 BOOLEAN Matched;
3983 HII_HANDLE **Result;
3984 UINTN ResultSize;
3985 HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList;
3986 LIST_ENTRY *Link1;
3987
3988 //
3989 // Check input parameters
3990 //
3991 if ((This == NULL) || (HandleBufferLength == NULL)) {
3992 return EFI_INVALID_PARAMETER;
3993 }
3994
3995 if ((*HandleBufferLength > 0) && (Handle == NULL)) {
3996 return EFI_INVALID_PARAMETER;
3997 }
3998
3999 if (((PackageType == EFI_HII_PACKAGE_TYPE_GUID) && (PackageGuid == NULL)) ||
4000 ((PackageType != EFI_HII_PACKAGE_TYPE_GUID) && (PackageGuid != NULL)))
4001 {
4002 return EFI_INVALID_PARAMETER;
4003 }
4004
4005 Private = HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
4006 Matched = FALSE;
4007 Result = (HII_HANDLE **)Handle;
4008 ResultSize = 0;
4009
4010 for (Link = Private->DatabaseList.ForwardLink; Link != &Private->DatabaseList; Link = Link->ForwardLink) {
4011 Node = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
4012 PackageList = (HII_DATABASE_PACKAGE_LIST_INSTANCE *)(Node->PackageList);
4013 switch (PackageType) {
4014 case EFI_HII_PACKAGE_TYPE_GUID:
4015 for (Link1 = PackageList->GuidPkgHdr.ForwardLink; Link1 != &PackageList->GuidPkgHdr; Link1 = Link1->ForwardLink) {
4016 GuidPackage = CR (Link1, HII_GUID_PACKAGE_INSTANCE, GuidEntry, HII_GUID_PACKAGE_SIGNATURE);
4017 if (CompareGuid (
4018 (EFI_GUID *)PackageGuid,
4019 (EFI_GUID *)(GuidPackage->GuidPkg + sizeof (EFI_HII_PACKAGE_HEADER))
4020 ))
4021 {
4022 Matched = TRUE;
4023 break;
4024 }
4025 }
4026
4027 break;
4028 case EFI_HII_PACKAGE_FORMS:
4029 if (!IsListEmpty (&PackageList->FormPkgHdr)) {
4030 Matched = TRUE;
4031 }
4032
4033 break;
4034 case EFI_HII_PACKAGE_KEYBOARD_LAYOUT:
4035 if (!IsListEmpty (&PackageList->KeyboardLayoutHdr)) {
4036 Matched = TRUE;
4037 }
4038
4039 break;
4040 case EFI_HII_PACKAGE_STRINGS:
4041 if (!IsListEmpty (&PackageList->StringPkgHdr)) {
4042 Matched = TRUE;
4043 }
4044
4045 break;
4046 case EFI_HII_PACKAGE_FONTS:
4047 if (!IsListEmpty (&PackageList->FontPkgHdr)) {
4048 Matched = TRUE;
4049 }
4050
4051 break;
4052 case EFI_HII_PACKAGE_IMAGES:
4053 if (PackageList->ImagePkg != NULL) {
4054 Matched = TRUE;
4055 }
4056
4057 break;
4058 case EFI_HII_PACKAGE_SIMPLE_FONTS:
4059 if (!IsListEmpty (&PackageList->SimpleFontPkgHdr)) {
4060 Matched = TRUE;
4061 }
4062
4063 break;
4064 case EFI_HII_PACKAGE_DEVICE_PATH:
4065 if (PackageList->DevicePathPkg != NULL) {
4066 Matched = TRUE;
4067 }
4068
4069 break;
4070 //
4071 // Pseudo-type EFI_HII_PACKAGE_TYPE_ALL will cause all package handles
4072 // to be listed.
4073 //
4074 case EFI_HII_PACKAGE_TYPE_ALL:
4075 Matched = TRUE;
4076 break;
4077 default:
4078 break;
4079 }
4080
4081 //
4082 // This active package list has the specified package type, list it.
4083 //
4084 if (Matched) {
4085 ResultSize += sizeof (EFI_HII_HANDLE);
4086 if (ResultSize <= *HandleBufferLength) {
4087 *Result++ = Node->Handle;
4088 }
4089 }
4090
4091 Matched = FALSE;
4092 }
4093
4094 if (ResultSize == 0) {
4095 return EFI_NOT_FOUND;
4096 }
4097
4098 if (*HandleBufferLength < ResultSize) {
4099 *HandleBufferLength = ResultSize;
4100 return EFI_BUFFER_TOO_SMALL;
4101 }
4102
4103 *HandleBufferLength = ResultSize;
4104 return EFI_SUCCESS;
4105}
4106
4107/**
4108 This function will export one or all package lists in the database to a buffer.
4109 For each package list exported, this function will call functions registered
4110 with EXPORT_PACK and then copy the package list to the buffer.
4111
4112 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
4113 instance.
4114 @param Handle An EFI_HII_HANDLE that corresponds to the desired
4115 package list in the HII database to export or NULL
4116 to indicate all package lists should be exported.
4117 @param BufferSize On input, a pointer to the length of the buffer.
4118 On output, the length of the buffer that is
4119 required for the exported data.
4120 @param Buffer A pointer to a buffer that will contain the
4121 results of the export function.
4122
4123 @retval EFI_SUCCESS Package exported.
4124 @retval EFI_BUFFER_TO_SMALL The HandleBufferLength parameter indicates that
4125 Handle is too small to support the number of
4126 handles. HandleBufferLength is updated with a
4127 value that will enable the data to fit.
4128 @retval EFI_NOT_FOUND The specified Handle could not be found in the
4129 current database.
4130 @retval EFI_INVALID_PARAMETER BufferSize was NULL.
4131 @retval EFI_INVALID_PARAMETER The value referenced by BufferSize was not zero
4132 and Buffer was NULL.
4133
4134**/
4135EFI_STATUS
4136EFIAPI
4137HiiExportPackageLists (
4138 IN CONST EFI_HII_DATABASE_PROTOCOL *This,
4139 IN EFI_HII_HANDLE Handle,
4140 IN OUT UINTN *BufferSize,
4141 OUT EFI_HII_PACKAGE_LIST_HEADER *Buffer
4142 )
4143{
4144 LIST_ENTRY *Link;
4145 EFI_STATUS Status;
4146 HII_DATABASE_PRIVATE_DATA *Private;
4147 HII_DATABASE_RECORD *Node;
4148 UINTN UsedSize;
4149
4150 if ((This == NULL) || (BufferSize == NULL)) {
4151 return EFI_INVALID_PARAMETER;
4152 }
4153
4154 if ((*BufferSize > 0) && (Buffer == NULL)) {
4155 return EFI_INVALID_PARAMETER;
4156 }
4157
4158 if ((Handle != NULL) && (!IsHiiHandleValid (Handle))) {
4159 return EFI_NOT_FOUND;
4160 }
4161
4162 Private = HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
4163 UsedSize = 0;
4164
4165 for (Link = Private->DatabaseList.ForwardLink; Link != &Private->DatabaseList; Link = Link->ForwardLink) {
4166 Node = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
4167 if (Handle == NULL) {
4168 //
4169 // Export all package lists in current hii database.
4170 //
4171 Status = ExportPackageList (
4172 Private,
4173 Node->Handle,
4174 (HII_DATABASE_PACKAGE_LIST_INSTANCE *)(Node->PackageList),
4175 &UsedSize,
4176 *BufferSize,
4177 (EFI_HII_PACKAGE_LIST_HEADER *)((UINT8 *)Buffer + UsedSize)
4178 );
4179 ASSERT_EFI_ERROR (Status);
4180 } else if ((Handle != NULL) && (Node->Handle == Handle)) {
4181 Status = ExportPackageList (
4182 Private,
4183 Handle,
4184 (HII_DATABASE_PACKAGE_LIST_INSTANCE *)(Node->PackageList),
4185 &UsedSize,
4186 *BufferSize,
4187 Buffer
4188 );
4189 ASSERT_EFI_ERROR (Status);
4190 if (*BufferSize < UsedSize) {
4191 *BufferSize = UsedSize;
4192 return EFI_BUFFER_TOO_SMALL;
4193 }
4194
4195 return EFI_SUCCESS;
4196 }
4197 }
4198
4199 if ((Handle == NULL) && (UsedSize != 0)) {
4200 if (*BufferSize < UsedSize) {
4201 *BufferSize = UsedSize;
4202 return EFI_BUFFER_TOO_SMALL;
4203 }
4204
4205 return EFI_SUCCESS;
4206 }
4207
4208 return EFI_NOT_FOUND;
4209}
4210
4211/**
4212 This function registers a function which will be called when specified actions related to packages of
4213 the specified type occur in the HII database. By registering a function, other HII-related drivers are
4214 notified when specific package types are added, removed or updated in the HII database.
4215 Each driver or application which registers a notification should use
4216 EFI_HII_DATABASE_PROTOCOL.UnregisterPackageNotify() before exiting.
4217
4218 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
4219 instance.
4220 @param PackageType Specifies the package type of the packages to list
4221 or EFI_HII_PACKAGE_TYPE_ALL for all packages to be
4222 listed.
4223 @param PackageGuid If PackageType is EFI_HII_PACKAGE_TYPE_GUID, then
4224 this is the pointer to the GUID which must match
4225 the Guid field of
4226 EFI_HII_GUID_PACKAGE_GUID_HDR. Otherwise, it must
4227 be NULL.
4228 @param PackageNotifyFn Points to the function to be called when the event
4229 specified by
4230 NotificationType occurs.
4231 @param NotifyType Describes the types of notification which this
4232 function will be receiving.
4233 @param NotifyHandle Points to the unique handle assigned to the
4234 registered notification. Can be used in
4235 EFI_HII_DATABASE_PROTOCOL.UnregisterPackageNotify()
4236 to stop notifications.
4237
4238 @retval EFI_SUCCESS Notification registered successfully.
4239 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary data structures
4240 @retval EFI_INVALID_PARAMETER NotifyHandle is NULL.
4241 @retval EFI_INVALID_PARAMETER PackageGuid is not NULL when PackageType is not
4242 EFI_HII_PACKAGE_TYPE_GUID.
4243 @retval EFI_INVALID_PARAMETER PackageGuid is NULL when PackageType is
4244 EFI_HII_PACKAGE_TYPE_GUID.
4245
4246**/
4247EFI_STATUS
4248EFIAPI
4249HiiRegisterPackageNotify (
4250 IN CONST EFI_HII_DATABASE_PROTOCOL *This,
4251 IN UINT8 PackageType,
4252 IN CONST EFI_GUID *PackageGuid,
4253 IN CONST EFI_HII_DATABASE_NOTIFY PackageNotifyFn,
4254 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType,
4255 OUT EFI_HANDLE *NotifyHandle
4256 )
4257{
4258 HII_DATABASE_PRIVATE_DATA *Private;
4259 HII_DATABASE_NOTIFY *Notify;
4260 EFI_STATUS Status;
4261
4262 if ((This == NULL) || (NotifyHandle == NULL)) {
4263 return EFI_INVALID_PARAMETER;
4264 }
4265
4266 if (((PackageType == EFI_HII_PACKAGE_TYPE_GUID) && (PackageGuid == NULL)) ||
4267 ((PackageType != EFI_HII_PACKAGE_TYPE_GUID) && (PackageGuid != NULL)))
4268 {
4269 return EFI_INVALID_PARAMETER;
4270 }
4271
4272 Private = HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
4273
4274 //
4275 // Allocate a notification node
4276 //
4277 Notify = (HII_DATABASE_NOTIFY *)AllocateZeroPool (sizeof (HII_DATABASE_NOTIFY));
4278 if (Notify == NULL) {
4279 return EFI_OUT_OF_RESOURCES;
4280 }
4281
4282 //
4283 // Generate a notify handle
4284 //
4285 Status = gBS->InstallMultipleProtocolInterfaces (
4286 &Notify->NotifyHandle,
4287 &gEfiCallerIdGuid,
4288 NULL,
4289 NULL
4290 );
4291 ASSERT_EFI_ERROR (Status);
4292
4293 //
4294 // Fill in the information to the notification node
4295 //
4296 Notify->Signature = HII_DATABASE_NOTIFY_SIGNATURE;
4297 Notify->PackageType = PackageType;
4298 Notify->PackageGuid = (EFI_GUID *)PackageGuid;
4299 Notify->PackageNotifyFn = (EFI_HII_DATABASE_NOTIFY)PackageNotifyFn;
4300 Notify->NotifyType = NotifyType;
4301
4302 InsertTailList (&Private->DatabaseNotifyList, &Notify->DatabaseNotifyEntry);
4303 *NotifyHandle = Notify->NotifyHandle;
4304
4305 return EFI_SUCCESS;
4306}
4307
4308/**
4309 Removes the specified HII database package-related notification.
4310
4311 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
4312 instance.
4313 @param NotificationHandle The handle of the notification function being
4314 unregistered.
4315
4316 @retval EFI_SUCCESS Notification is unregistered successfully.
4317 @retval EFI_INVALID_PARAMETER The Handle is invalid.
4318 @retval EFI_NOT_FOUND The incoming notification handle does not exist
4319 in current hii database.
4320
4321**/
4322EFI_STATUS
4323EFIAPI
4324HiiUnregisterPackageNotify (
4325 IN CONST EFI_HII_DATABASE_PROTOCOL *This,
4326 IN EFI_HANDLE NotificationHandle
4327 )
4328{
4329 HII_DATABASE_PRIVATE_DATA *Private;
4330 HII_DATABASE_NOTIFY *Notify;
4331 LIST_ENTRY *Link;
4332 EFI_STATUS Status;
4333
4334 if (This == NULL) {
4335 return EFI_INVALID_PARAMETER;
4336 }
4337
4338 if (NotificationHandle == NULL) {
4339 return EFI_NOT_FOUND;
4340 }
4341
4342 Status = gBS->OpenProtocol (
4343 NotificationHandle,
4344 &gEfiCallerIdGuid,
4345 NULL,
4346 NULL,
4347 NULL,
4348 EFI_OPEN_PROTOCOL_TEST_PROTOCOL
4349 );
4350 if (EFI_ERROR (Status)) {
4351 return EFI_NOT_FOUND;
4352 }
4353
4354 Private = HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
4355
4356 for (Link = Private->DatabaseNotifyList.ForwardLink; Link != &Private->DatabaseNotifyList; Link = Link->ForwardLink) {
4357 Notify = CR (Link, HII_DATABASE_NOTIFY, DatabaseNotifyEntry, HII_DATABASE_NOTIFY_SIGNATURE);
4358 if (Notify->NotifyHandle == NotificationHandle) {
4359 //
4360 // Remove the matching notification node
4361 //
4362 RemoveEntryList (&Notify->DatabaseNotifyEntry);
4363 Status = gBS->UninstallMultipleProtocolInterfaces (
4364 Notify->NotifyHandle,
4365 &gEfiCallerIdGuid,
4366 NULL,
4367 NULL
4368 );
4369 ASSERT_EFI_ERROR (Status);
4370 FreePool (Notify);
4371
4372 return EFI_SUCCESS;
4373 }
4374 }
4375
4376 return EFI_NOT_FOUND;
4377}
4378
4379/**
4380 This routine retrieves an array of GUID values for each keyboard layout that
4381 was previously registered in the system.
4382
4383 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
4384 instance.
4385 @param KeyGuidBufferLength On input, a pointer to the length of the keyboard
4386 GUID buffer. On output, the length of the handle
4387 buffer that is required for the handles found.
4388 @param KeyGuidBuffer An array of keyboard layout GUID instances
4389 returned.
4390
4391 @retval EFI_SUCCESS KeyGuidBuffer was updated successfully.
4392 @retval EFI_BUFFER_TOO_SMALL The KeyGuidBufferLength parameter indicates
4393 that KeyGuidBuffer is too small to support the
4394 number of GUIDs. KeyGuidBufferLength is
4395 updated with a value that will enable the data to
4396 fit.
4397 @retval EFI_INVALID_PARAMETER The KeyGuidBufferLength is NULL.
4398 @retval EFI_INVALID_PARAMETER The value referenced by KeyGuidBufferLength is not
4399 zero and KeyGuidBuffer is NULL.
4400 @retval EFI_NOT_FOUND There was no keyboard layout.
4401
4402**/
4403EFI_STATUS
4404EFIAPI
4405HiiFindKeyboardLayouts (
4406 IN CONST EFI_HII_DATABASE_PROTOCOL *This,
4407 IN OUT UINT16 *KeyGuidBufferLength,
4408 OUT EFI_GUID *KeyGuidBuffer
4409 )
4410{
4411 HII_DATABASE_PRIVATE_DATA *Private;
4412 HII_DATABASE_RECORD *Node;
4413 HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList;
4414 LIST_ENTRY *Link;
4415 LIST_ENTRY *Link1;
4416 UINT16 ResultSize;
4417 UINTN Index;
4418 UINT16 LayoutCount;
4419 UINT16 LayoutLength;
4420 UINT8 *Layout;
4421 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE *Package;
4422
4423 if ((This == NULL) || (KeyGuidBufferLength == NULL)) {
4424 return EFI_INVALID_PARAMETER;
4425 }
4426
4427 if ((*KeyGuidBufferLength > 0) && (KeyGuidBuffer == NULL)) {
4428 return EFI_INVALID_PARAMETER;
4429 }
4430
4431 Private = HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
4432 ResultSize = 0;
4433
4434 //
4435 // Search all package lists in whole database to retrieve keyboard layout.
4436 //
4437 for (Link = Private->DatabaseList.ForwardLink; Link != &Private->DatabaseList; Link = Link->ForwardLink) {
4438 Node = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
4439 PackageList = Node->PackageList;
4440 for (Link1 = PackageList->KeyboardLayoutHdr.ForwardLink;
4441 Link1 != &PackageList->KeyboardLayoutHdr;
4442 Link1 = Link1->ForwardLink
4443 )
4444 {
4445 //
4446 // Find out all Keyboard Layout packages in this package list.
4447 //
4448 Package = CR (
4449 Link1,
4450 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE,
4451 KeyboardEntry,
4452 HII_KB_LAYOUT_PACKAGE_SIGNATURE
4453 );
4454 Layout = (UINT8 *)Package->KeyboardPkg + sizeof (EFI_HII_PACKAGE_HEADER) + sizeof (UINT16);
4455 CopyMem (
4456 &LayoutCount,
4457 (UINT8 *)Package->KeyboardPkg + sizeof (EFI_HII_PACKAGE_HEADER),
4458 sizeof (UINT16)
4459 );
4460 for (Index = 0; Index < LayoutCount; Index++) {
4461 ResultSize += sizeof (EFI_GUID);
4462 if (ResultSize <= *KeyGuidBufferLength) {
4463 CopyMem (KeyGuidBuffer + (ResultSize / sizeof (EFI_GUID) - 1), Layout + sizeof (UINT16), sizeof (EFI_GUID));
4464 CopyMem (&LayoutLength, Layout, sizeof (UINT16));
4465 Layout = Layout + LayoutLength;
4466 }
4467 }
4468 }
4469 }
4470
4471 if (ResultSize == 0) {
4472 return EFI_NOT_FOUND;
4473 }
4474
4475 if (*KeyGuidBufferLength < ResultSize) {
4476 *KeyGuidBufferLength = ResultSize;
4477 return EFI_BUFFER_TOO_SMALL;
4478 }
4479
4480 *KeyGuidBufferLength = ResultSize;
4481 return EFI_SUCCESS;
4482}
4483
4484/**
4485 This routine retrieves the requested keyboard layout. The layout is a physical description of the keys
4486 on a keyboard and the character(s) that are associated with a particular set of key strokes.
4487
4488 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
4489 instance.
4490 @param KeyGuid A pointer to the unique ID associated with a given
4491 keyboard layout. If KeyGuid is NULL then the
4492 current layout will be retrieved.
4493 @param KeyboardLayoutLength On input, a pointer to the length of the
4494 KeyboardLayout buffer. On output, the length of
4495 the data placed into KeyboardLayout.
4496 @param KeyboardLayout A pointer to a buffer containing the retrieved
4497 keyboard layout.
4498
4499 @retval EFI_SUCCESS The keyboard layout was retrieved successfully.
4500 @retval EFI_NOT_FOUND The requested keyboard layout was not found.
4501 @retval EFI_INVALID_PARAMETER The KeyboardLayout or KeyboardLayoutLength was
4502 NULL.
4503 @retval EFI_BUFFER_TOO_SMALL The KeyboardLayoutLength parameter indicates
4504 that KeyboardLayout is too small to support the
4505 requested keyboard layout. KeyboardLayoutLength is
4506 updated with a value that will enable the
4507 data to fit.
4508
4509**/
4510EFI_STATUS
4511EFIAPI
4512HiiGetKeyboardLayout (
4513 IN CONST EFI_HII_DATABASE_PROTOCOL *This,
4514 IN CONST EFI_GUID *KeyGuid,
4515 IN OUT UINT16 *KeyboardLayoutLength,
4516 OUT EFI_HII_KEYBOARD_LAYOUT *KeyboardLayout
4517 )
4518{
4519 HII_DATABASE_PRIVATE_DATA *Private;
4520 HII_DATABASE_RECORD *Node;
4521 HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList;
4522 LIST_ENTRY *Link;
4523 LIST_ENTRY *Link1;
4524 UINTN Index;
4525 UINT8 *Layout;
4526 UINT16 LayoutCount;
4527 UINT16 LayoutLength;
4528 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE *Package;
4529
4530 if ((This == NULL) || (KeyboardLayoutLength == NULL)) {
4531 return EFI_INVALID_PARAMETER;
4532 }
4533
4534 if ((*KeyboardLayoutLength > 0) && (KeyboardLayout == NULL)) {
4535 return EFI_INVALID_PARAMETER;
4536 }
4537
4538 Private = HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
4539 //
4540 // Retrieve the current keyboard layout.
4541 //
4542 if (KeyGuid == NULL) {
4543 if (Private->CurrentLayout == NULL) {
4544 return EFI_NOT_FOUND;
4545 }
4546
4547 CopyMem (&LayoutLength, Private->CurrentLayout, sizeof (UINT16));
4548 if (*KeyboardLayoutLength < LayoutLength) {
4549 *KeyboardLayoutLength = LayoutLength;
4550 return EFI_BUFFER_TOO_SMALL;
4551 }
4552
4553 CopyMem (KeyboardLayout, Private->CurrentLayout, LayoutLength);
4554 return EFI_SUCCESS;
4555 }
4556
4557 for (Link = Private->DatabaseList.ForwardLink; Link != &Private->DatabaseList; Link = Link->ForwardLink) {
4558 Node = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
4559 PackageList = (HII_DATABASE_PACKAGE_LIST_INSTANCE *)(Node->PackageList);
4560 for (Link1 = PackageList->KeyboardLayoutHdr.ForwardLink;
4561 Link1 != &PackageList->KeyboardLayoutHdr;
4562 Link1 = Link1->ForwardLink
4563 )
4564 {
4565 Package = CR (
4566 Link1,
4567 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE,
4568 KeyboardEntry,
4569 HII_KB_LAYOUT_PACKAGE_SIGNATURE
4570 );
4571
4572 Layout = (UINT8 *)Package->KeyboardPkg +
4573 sizeof (EFI_HII_PACKAGE_HEADER) + sizeof (UINT16);
4574 CopyMem (&LayoutCount, Layout - sizeof (UINT16), sizeof (UINT16));
4575 for (Index = 0; Index < LayoutCount; Index++) {
4576 CopyMem (&LayoutLength, Layout, sizeof (UINT16));
4577 if (CompareMem (Layout + sizeof (UINT16), KeyGuid, sizeof (EFI_GUID)) == 0) {
4578 if (LayoutLength <= *KeyboardLayoutLength) {
4579 CopyMem (KeyboardLayout, Layout, LayoutLength);
4580 return EFI_SUCCESS;
4581 } else {
4582 *KeyboardLayoutLength = LayoutLength;
4583 return EFI_BUFFER_TOO_SMALL;
4584 }
4585 }
4586
4587 Layout = Layout + LayoutLength;
4588 }
4589 }
4590 }
4591
4592 return EFI_NOT_FOUND;
4593}
4594
4595/**
4596 This routine sets the default keyboard layout to the one referenced by KeyGuid. When this routine
4597 is called, an event will be signaled of the EFI_HII_SET_KEYBOARD_LAYOUT_EVENT_GUID
4598 group type. This is so that agents which are sensitive to the current keyboard layout being changed
4599 can be notified of this change.
4600
4601 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
4602 instance.
4603 @param KeyGuid A pointer to the unique ID associated with a given
4604 keyboard layout.
4605
4606 @retval EFI_SUCCESS The current keyboard layout was successfully set.
4607 @retval EFI_NOT_FOUND The referenced keyboard layout was not found, so
4608 action was taken.
4609 @retval EFI_INVALID_PARAMETER The KeyGuid was NULL.
4610
4611**/
4612EFI_STATUS
4613EFIAPI
4614HiiSetKeyboardLayout (
4615 IN CONST EFI_HII_DATABASE_PROTOCOL *This,
4616 IN CONST EFI_GUID *KeyGuid
4617 )
4618{
4619 HII_DATABASE_PRIVATE_DATA *Private;
4620 EFI_HII_KEYBOARD_LAYOUT *KeyboardLayout;
4621 UINT16 KeyboardLayoutLength;
4622 EFI_STATUS Status;
4623
4624 if ((This == NULL) || (KeyGuid == NULL)) {
4625 return EFI_INVALID_PARAMETER;
4626 }
4627
4628 Private = HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
4629
4630 //
4631 // The specified GUID equals the current keyboard layout GUID,
4632 // return directly.
4633 //
4634 if (CompareGuid (&Private->CurrentLayoutGuid, KeyGuid)) {
4635 return EFI_SUCCESS;
4636 }
4637
4638 //
4639 // Try to find the incoming keyboard layout data in current database.
4640 //
4641 KeyboardLayoutLength = 0;
4642 KeyboardLayout = NULL;
4643 Status = HiiGetKeyboardLayout (This, KeyGuid, &KeyboardLayoutLength, KeyboardLayout);
4644 if (Status != EFI_BUFFER_TOO_SMALL) {
4645 return Status;
4646 }
4647
4648 KeyboardLayout = (EFI_HII_KEYBOARD_LAYOUT *)AllocateZeroPool (KeyboardLayoutLength);
4649 ASSERT (KeyboardLayout != NULL);
4650 Status = HiiGetKeyboardLayout (This, KeyGuid, &KeyboardLayoutLength, KeyboardLayout);
4651 ASSERT_EFI_ERROR (Status);
4652
4653 //
4654 // Backup current keyboard layout.
4655 //
4656 CopyMem (&Private->CurrentLayoutGuid, KeyGuid, sizeof (EFI_GUID));
4657 if (Private->CurrentLayout != NULL) {
4658 FreePool (Private->CurrentLayout);
4659 }
4660
4661 Private->CurrentLayout = KeyboardLayout;
4662
4663 //
4664 // Signal EFI_HII_SET_KEYBOARD_LAYOUT_EVENT_GUID group to notify
4665 // current keyboard layout is changed.
4666 //
4667 Status = gBS->SignalEvent (gHiiKeyboardLayoutChanged);
4668 ASSERT_EFI_ERROR (Status);
4669
4670 return EFI_SUCCESS;
4671}
4672
4673/**
4674 Return the EFI handle associated with a package list.
4675
4676 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
4677 instance.
4678 @param PackageListHandle An EFI_HII_HANDLE that corresponds to the desired
4679 package list in the HIIdatabase.
4680 @param DriverHandle On return, contains the EFI_HANDLE which was
4681 registered with the package list in
4682 NewPackageList().
4683
4684 @retval EFI_SUCCESS The DriverHandle was returned successfully.
4685 @retval EFI_INVALID_PARAMETER The PackageListHandle was not valid or
4686 DriverHandle was NULL.
4687 @retval EFI_NOT_FOUND This PackageList handle can not be found in
4688 current database.
4689
4690**/
4691EFI_STATUS
4692EFIAPI
4693HiiGetPackageListHandle (
4694 IN CONST EFI_HII_DATABASE_PROTOCOL *This,
4695 IN EFI_HII_HANDLE PackageListHandle,
4696 OUT EFI_HANDLE *DriverHandle
4697 )
4698{
4699 HII_DATABASE_PRIVATE_DATA *Private;
4700 HII_DATABASE_RECORD *Node;
4701 LIST_ENTRY *Link;
4702
4703 if ((This == NULL) || (DriverHandle == NULL)) {
4704 return EFI_INVALID_PARAMETER;
4705 }
4706
4707 if (!IsHiiHandleValid (PackageListHandle)) {
4708 return EFI_INVALID_PARAMETER;
4709 }
4710
4711 Private = HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
4712
4713 for (Link = Private->DatabaseList.ForwardLink; Link != &Private->DatabaseList; Link = Link->ForwardLink) {
4714 Node = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
4715 if (Node->Handle == PackageListHandle) {
4716 *DriverHandle = Node->DriverHandle;
4717 return EFI_SUCCESS;
4718 }
4719 }
4720
4721 return EFI_NOT_FOUND;
4722}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette