]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Universal/HiiDatabaseDxe/Database.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update code to support VS2013 tool chain.
[mirror_edk2.git] / MdeModulePkg / Universal / HiiDatabaseDxe / Database.c
1 /** @file
2 Implementation for EFI_HII_DATABASE_PROTOCOL.
3
4 Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 **/
14
15
16 #include "HiiDatabase.h"
17
18 /**
19 This function generates a HII_DATABASE_RECORD node and adds into hii database.
20 This is a internal function.
21
22 @param Private hii database private structure
23 @param DatabaseNode HII_DATABASE_RECORD node which is used to store a
24 package list
25
26 @retval EFI_SUCCESS A database record is generated successfully.
27 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
28 database contents.
29 @retval EFI_INVALID_PARAMETER Private is NULL or DatabaseRecord is NULL.
30
31 **/
32 EFI_STATUS
33 GenerateHiiDatabaseRecord (
34 IN HII_DATABASE_PRIVATE_DATA *Private,
35 OUT HII_DATABASE_RECORD **DatabaseNode
36 )
37 {
38 HII_DATABASE_RECORD *DatabaseRecord;
39 HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList;
40 HII_HANDLE *HiiHandle;
41
42 if (Private == NULL || DatabaseNode == NULL) {
43 return EFI_INVALID_PARAMETER;
44 }
45
46 DatabaseRecord = (HII_DATABASE_RECORD *) AllocateZeroPool (sizeof (HII_DATABASE_RECORD));
47 if (DatabaseRecord == NULL) {
48 return EFI_OUT_OF_RESOURCES;
49 }
50 DatabaseRecord->Signature = HII_DATABASE_RECORD_SIGNATURE;
51
52 DatabaseRecord->PackageList = AllocateZeroPool (sizeof (HII_DATABASE_PACKAGE_LIST_INSTANCE));
53 if (DatabaseRecord->PackageList == NULL) {
54 FreePool (DatabaseRecord);
55 return EFI_OUT_OF_RESOURCES;
56 }
57
58 PackageList = DatabaseRecord->PackageList;
59
60 InitializeListHead (&PackageList->GuidPkgHdr);
61 InitializeListHead (&PackageList->FormPkgHdr);
62 InitializeListHead (&PackageList->KeyboardLayoutHdr);
63 InitializeListHead (&PackageList->StringPkgHdr);
64 InitializeListHead (&PackageList->FontPkgHdr);
65 InitializeListHead (&PackageList->SimpleFontPkgHdr);
66 PackageList->ImagePkg = NULL;
67 PackageList->DevicePathPkg = NULL;
68
69 //
70 // Create a new hii handle
71 //
72 HiiHandle = (HII_HANDLE *) AllocateZeroPool (sizeof (HII_HANDLE));
73 if (HiiHandle == NULL) {
74 FreePool (DatabaseRecord->PackageList);
75 FreePool (DatabaseRecord);
76 return EFI_OUT_OF_RESOURCES;
77 }
78 HiiHandle->Signature = HII_HANDLE_SIGNATURE;
79 //
80 // Backup the number of Hii handles
81 //
82 Private->HiiHandleCount++;
83 HiiHandle->Key = (UINTN) Private->HiiHandleCount;
84 //
85 // Insert the handle to hii handle list of the whole database.
86 //
87 InsertTailList (&Private->HiiHandleList, &HiiHandle->Handle);
88
89 DatabaseRecord->Handle = (EFI_HII_HANDLE) HiiHandle;
90
91 //
92 // Insert the Package List node to Package List link of the whole database.
93 //
94 InsertTailList (&Private->DatabaseList, &DatabaseRecord->DatabaseEntry);
95
96 *DatabaseNode = DatabaseRecord;
97
98 return EFI_SUCCESS;
99
100 }
101
102
103 /**
104 This function checks whether a handle is a valid EFI_HII_HANDLE
105 This is a internal function.
106
107 @param Handle Pointer to a EFI_HII_HANDLE
108
109 @retval TRUE Valid
110 @retval FALSE Invalid
111
112 **/
113 BOOLEAN
114 IsHiiHandleValid (
115 EFI_HII_HANDLE Handle
116 )
117 {
118 HII_HANDLE *HiiHandle;
119
120 HiiHandle = (HII_HANDLE *) Handle;
121
122 if (HiiHandle == NULL) {
123 return FALSE;
124 }
125
126 if (HiiHandle->Signature != HII_HANDLE_SIGNATURE) {
127 return FALSE;
128 }
129
130 return TRUE;
131 }
132
133
134 /**
135 This function invokes the matching registered function.
136 This is a internal function.
137
138 @param Private HII Database driver private structure.
139 @param NotifyType The type of change concerning the database.
140 @param PackageInstance Points to the package referred to by the
141 notification.
142 @param PackageType Package type
143 @param Handle The handle of the package list which contains the
144 specified package.
145
146 @retval EFI_SUCCESS Already checked all registered function and
147 invoked if matched.
148 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
149
150 **/
151 EFI_STATUS
152 InvokeRegisteredFunction (
153 IN HII_DATABASE_PRIVATE_DATA *Private,
154 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType,
155 IN VOID *PackageInstance,
156 IN UINT8 PackageType,
157 IN EFI_HII_HANDLE Handle
158 )
159 {
160 HII_DATABASE_NOTIFY *Notify;
161 LIST_ENTRY *Link;
162 EFI_HII_PACKAGE_HEADER *Package;
163 UINT8 *Buffer;
164 UINT32 BufferSize;
165 UINT32 HeaderSize;
166 UINT32 ImageBlockSize;
167 UINT32 PaletteInfoSize;
168
169 if (Private == NULL || (NotifyType & 0xF) == 0 || PackageInstance == NULL) {
170 return EFI_INVALID_PARAMETER;
171 }
172 if (Private->Signature != HII_DATABASE_PRIVATE_DATA_SIGNATURE) {
173 return EFI_INVALID_PARAMETER;
174 }
175 if (!IsHiiHandleValid (Handle)) {
176 return EFI_INVALID_PARAMETER;
177 }
178
179 Buffer = NULL;
180 Package = NULL;
181
182 //
183 // Convert the incoming package from hii database storage format to UEFI
184 // storage format. e.g. HII_GUID_PACKAGE_INSTANCE to EFI_HII_GUID_PACKAGE_HDR.
185 //
186 switch (PackageType) {
187 case EFI_HII_PACKAGE_TYPE_GUID:
188 Package = (EFI_HII_PACKAGE_HEADER *) (((HII_GUID_PACKAGE_INSTANCE *) PackageInstance)->GuidPkg);
189 break;
190
191 case EFI_HII_PACKAGE_FORMS:
192 BufferSize = ((HII_IFR_PACKAGE_INSTANCE *) PackageInstance)->FormPkgHdr.Length;
193 Buffer = (UINT8 *) AllocateZeroPool (BufferSize);
194 ASSERT (Buffer != NULL);
195 CopyMem (
196 Buffer,
197 &((HII_IFR_PACKAGE_INSTANCE *) PackageInstance)->FormPkgHdr,
198 sizeof (EFI_HII_PACKAGE_HEADER)
199 );
200 CopyMem (
201 Buffer + sizeof (EFI_HII_PACKAGE_HEADER),
202 ((HII_IFR_PACKAGE_INSTANCE *) PackageInstance)->IfrData,
203 BufferSize - sizeof (EFI_HII_PACKAGE_HEADER)
204 );
205 Package = (EFI_HII_PACKAGE_HEADER *) Buffer;
206 break;
207
208 case EFI_HII_PACKAGE_KEYBOARD_LAYOUT:
209 Package = (EFI_HII_PACKAGE_HEADER *) (((HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE *) PackageInstance)->KeyboardPkg);
210 break;
211
212 case EFI_HII_PACKAGE_STRINGS:
213 BufferSize = ((HII_STRING_PACKAGE_INSTANCE *) PackageInstance)->StringPkgHdr->Header.Length;
214 HeaderSize = ((HII_STRING_PACKAGE_INSTANCE *) PackageInstance)->StringPkgHdr->HdrSize;
215 Buffer = (UINT8 *) AllocateZeroPool (BufferSize);
216 ASSERT (Buffer != NULL);
217 CopyMem (
218 Buffer,
219 ((HII_STRING_PACKAGE_INSTANCE *) PackageInstance)->StringPkgHdr,
220 HeaderSize
221 );
222 CopyMem (
223 Buffer + HeaderSize,
224 ((HII_STRING_PACKAGE_INSTANCE *) PackageInstance)->StringBlock,
225 BufferSize - HeaderSize
226 );
227 Package = (EFI_HII_PACKAGE_HEADER *) Buffer;
228 break;
229
230 case EFI_HII_PACKAGE_FONTS:
231 BufferSize = ((HII_FONT_PACKAGE_INSTANCE *) PackageInstance)->FontPkgHdr->Header.Length;
232 HeaderSize = ((HII_FONT_PACKAGE_INSTANCE *) PackageInstance)->FontPkgHdr->HdrSize;
233 Buffer = (UINT8 *) AllocateZeroPool (BufferSize);
234 ASSERT (Buffer != NULL);
235 CopyMem (
236 Buffer,
237 ((HII_FONT_PACKAGE_INSTANCE *) PackageInstance)->FontPkgHdr,
238 HeaderSize
239 );
240 CopyMem (
241 Buffer + HeaderSize,
242 ((HII_FONT_PACKAGE_INSTANCE *) PackageInstance)->GlyphBlock,
243 BufferSize - HeaderSize
244 );
245 Package = (EFI_HII_PACKAGE_HEADER *) Buffer;
246 break;
247
248 case EFI_HII_PACKAGE_IMAGES:
249 BufferSize = ((HII_IMAGE_PACKAGE_INSTANCE *) PackageInstance)->ImagePkgHdr.Header.Length;
250 HeaderSize = sizeof (EFI_HII_IMAGE_PACKAGE_HDR);
251 Buffer = (UINT8 *) AllocateZeroPool (BufferSize);
252 ASSERT (Buffer != NULL);
253
254 CopyMem (
255 Buffer,
256 &((HII_IMAGE_PACKAGE_INSTANCE *) PackageInstance)->ImagePkgHdr,
257 HeaderSize
258 );
259 CopyMem (
260 Buffer + sizeof (EFI_HII_PACKAGE_HEADER),
261 &HeaderSize,
262 sizeof (UINT32)
263 );
264
265 ImageBlockSize = ((HII_IMAGE_PACKAGE_INSTANCE *) PackageInstance)->ImageBlockSize;
266 if (ImageBlockSize != 0) {
267 CopyMem (
268 Buffer + HeaderSize,
269 ((HII_IMAGE_PACKAGE_INSTANCE *) PackageInstance)->ImageBlock,
270 ImageBlockSize
271 );
272 }
273
274 PaletteInfoSize = ((HII_IMAGE_PACKAGE_INSTANCE *) PackageInstance)->PaletteInfoSize;
275 if (PaletteInfoSize != 0) {
276 CopyMem (
277 Buffer + HeaderSize + ImageBlockSize,
278 ((HII_IMAGE_PACKAGE_INSTANCE *) PackageInstance)->PaletteBlock,
279 PaletteInfoSize
280 );
281 HeaderSize += ImageBlockSize;
282 CopyMem (
283 Buffer + sizeof (EFI_HII_PACKAGE_HEADER) + sizeof (UINT32),
284 &HeaderSize,
285 sizeof (UINT32)
286 );
287 }
288 Package = (EFI_HII_PACKAGE_HEADER *) Buffer;
289 break;
290
291 case EFI_HII_PACKAGE_SIMPLE_FONTS:
292 BufferSize = ((HII_SIMPLE_FONT_PACKAGE_INSTANCE *) PackageInstance)->SimpleFontPkgHdr->Header.Length;
293 Buffer = (UINT8 *) AllocateZeroPool (BufferSize);
294 ASSERT (Buffer != NULL);
295 CopyMem (
296 Buffer,
297 ((HII_SIMPLE_FONT_PACKAGE_INSTANCE *) PackageInstance)->SimpleFontPkgHdr,
298 BufferSize
299 );
300 Package = (EFI_HII_PACKAGE_HEADER *) Buffer;
301 break;
302
303 case EFI_HII_PACKAGE_DEVICE_PATH:
304 Package = (EFI_HII_PACKAGE_HEADER *) PackageInstance;
305 break;
306
307 default:
308 return EFI_INVALID_PARAMETER;
309 }
310
311 for (Link = Private->DatabaseNotifyList.ForwardLink;
312 Link != &Private->DatabaseNotifyList;
313 Link = Link->ForwardLink
314 ) {
315 Notify = CR (Link, HII_DATABASE_NOTIFY, DatabaseNotifyEntry, HII_DATABASE_NOTIFY_SIGNATURE);
316 if (Notify->NotifyType == NotifyType && Notify->PackageType == PackageType) {
317 //
318 // Check in case PackageGuid is not NULL when Package is GUID package
319 //
320 if (PackageType != EFI_HII_PACKAGE_TYPE_GUID) {
321 Notify->PackageGuid = NULL;
322 }
323 //
324 // Status of Registered Function is unknown so did not check it
325 //
326 Notify->PackageNotifyFn (
327 Notify->PackageType,
328 Notify->PackageGuid,
329 Package,
330 Handle,
331 NotifyType
332 );
333 }
334 }
335
336 if (Buffer != NULL) {
337 FreePool (Buffer);
338 }
339
340 return EFI_SUCCESS;
341 }
342
343
344 /**
345 This function insert a GUID package to a package list node.
346 This is a internal function.
347
348 @param PackageHdr Pointer to a buffer stored with GUID package
349 information.
350 @param NotifyType The type of change concerning the database.
351 @param PackageList Pointer to a package list which will be inserted
352 to.
353 @param Package Created GUID pacakge
354
355 @retval EFI_SUCCESS Guid Package is inserted successfully.
356 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
357 Guid package.
358 @retval EFI_INVALID_PARAMETER PackageHdr is NULL or PackageList is NULL.
359
360 **/
361 EFI_STATUS
362 InsertGuidPackage (
363 IN VOID *PackageHdr,
364 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType,
365 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
366 OUT HII_GUID_PACKAGE_INSTANCE **Package
367 )
368 {
369 HII_GUID_PACKAGE_INSTANCE *GuidPackage;
370 EFI_HII_PACKAGE_HEADER PackageHeader;
371
372 if (PackageHdr == NULL || PackageList == NULL) {
373 return EFI_INVALID_PARAMETER;
374 }
375
376 CopyMem (&PackageHeader, PackageHdr, sizeof (EFI_HII_PACKAGE_HEADER));
377
378 //
379 // Create a GUID package node
380 //
381 GuidPackage = (HII_GUID_PACKAGE_INSTANCE *) AllocateZeroPool (sizeof (HII_GUID_PACKAGE_INSTANCE));
382 if (GuidPackage == NULL) {
383 return EFI_OUT_OF_RESOURCES;
384 }
385 GuidPackage->GuidPkg = (UINT8 *) AllocateZeroPool (PackageHeader.Length);
386 if (GuidPackage->GuidPkg == NULL) {
387 FreePool (GuidPackage);
388 return EFI_OUT_OF_RESOURCES;
389 }
390
391 GuidPackage->Signature = HII_GUID_PACKAGE_SIGNATURE;
392 CopyMem (GuidPackage->GuidPkg, PackageHdr, PackageHeader.Length);
393 InsertTailList (&PackageList->GuidPkgHdr, &GuidPackage->GuidEntry);
394 *Package = GuidPackage;
395
396 if (NotifyType == EFI_HII_DATABASE_NOTIFY_ADD_PACK) {
397 PackageList->PackageListHdr.PackageLength += PackageHeader.Length;
398 }
399
400 return EFI_SUCCESS;
401 }
402
403
404 /**
405 This function exports GUID packages to a buffer.
406 This is a internal function.
407
408 @param Private Hii database private structure.
409 @param Handle Identification of a package list.
410 @param PackageList Pointer to a package list which will be exported.
411 @param UsedSize The length of buffer be used.
412 @param BufferSize Length of the Buffer.
413 @param Buffer Allocated space for storing exported data.
414 @param ResultSize The size of the already exported content of this
415 package list.
416
417 @retval EFI_SUCCESS Guid Packages are exported successfully.
418 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
419
420 **/
421 EFI_STATUS
422 ExportGuidPackages (
423 IN HII_DATABASE_PRIVATE_DATA *Private,
424 IN EFI_HII_HANDLE Handle,
425 IN HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
426 IN UINTN UsedSize,
427 IN UINTN BufferSize,
428 IN OUT VOID *Buffer,
429 IN OUT UINTN *ResultSize
430 )
431 {
432 HII_GUID_PACKAGE_INSTANCE *GuidPackage;
433 LIST_ENTRY *Link;
434 UINTN PackageLength;
435 EFI_HII_PACKAGE_HEADER PackageHeader;
436 EFI_STATUS Status;
437
438 if (PackageList == NULL || ResultSize == NULL) {
439 return EFI_INVALID_PARAMETER;
440 }
441
442 if (BufferSize > 0 && Buffer == NULL ) {
443 return EFI_INVALID_PARAMETER;
444 }
445
446 PackageLength = 0;
447 Status = EFI_SUCCESS;
448
449 for (Link = PackageList->GuidPkgHdr.ForwardLink; Link != &PackageList->GuidPkgHdr; Link = Link->ForwardLink) {
450 GuidPackage = CR (Link, HII_GUID_PACKAGE_INSTANCE, GuidEntry, HII_GUID_PACKAGE_SIGNATURE);
451 CopyMem (&PackageHeader, GuidPackage->GuidPkg, sizeof (EFI_HII_PACKAGE_HEADER));
452 PackageLength += PackageHeader.Length;
453 if (PackageLength + *ResultSize + UsedSize <= BufferSize) {
454 Status = InvokeRegisteredFunction (
455 Private,
456 EFI_HII_DATABASE_NOTIFY_EXPORT_PACK,
457 (VOID *) GuidPackage,
458 EFI_HII_PACKAGE_TYPE_GUID,
459 Handle
460 );
461 ASSERT_EFI_ERROR (Status);
462 CopyMem (Buffer, GuidPackage->GuidPkg, PackageHeader.Length);
463 Buffer = (UINT8 *) Buffer + PackageHeader.Length;
464 }
465 }
466
467 *ResultSize += PackageLength;
468 return EFI_SUCCESS;
469 }
470
471
472 /**
473 This function deletes all GUID packages from a package list node.
474 This is a internal function.
475
476 @param Private Hii database private data.
477 @param Handle Handle of the package list which contains the to
478 be removed GUID packages.
479 @param PackageList Pointer to a package list that contains removing
480 packages.
481
482 @retval EFI_SUCCESS GUID Package(s) is deleted successfully.
483 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
484
485 **/
486 EFI_STATUS
487 RemoveGuidPackages (
488 IN HII_DATABASE_PRIVATE_DATA *Private,
489 IN EFI_HII_HANDLE Handle,
490 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList
491 )
492 {
493 LIST_ENTRY *ListHead;
494 HII_GUID_PACKAGE_INSTANCE *Package;
495 EFI_STATUS Status;
496 EFI_HII_PACKAGE_HEADER PackageHeader;
497
498 ListHead = &PackageList->GuidPkgHdr;
499
500 while (!IsListEmpty (ListHead)) {
501 Package = CR (
502 ListHead->ForwardLink,
503 HII_GUID_PACKAGE_INSTANCE,
504 GuidEntry,
505 HII_GUID_PACKAGE_SIGNATURE
506 );
507 Status = InvokeRegisteredFunction (
508 Private,
509 EFI_HII_DATABASE_NOTIFY_REMOVE_PACK,
510 (VOID *) Package,
511 EFI_HII_PACKAGE_TYPE_GUID,
512 Handle
513 );
514 if (EFI_ERROR (Status)) {
515 return Status;
516 }
517
518 RemoveEntryList (&Package->GuidEntry);
519 CopyMem (&PackageHeader, Package->GuidPkg, sizeof (EFI_HII_PACKAGE_HEADER));
520 PackageList->PackageListHdr.PackageLength -= PackageHeader.Length;
521 FreePool (Package->GuidPkg);
522 FreePool (Package);
523 }
524
525 return EFI_SUCCESS;
526 }
527
528
529 /**
530 This function insert a Form package to a package list node.
531 This is a internal function.
532
533 @param PackageHdr Pointer to a buffer stored with Form package
534 information.
535 @param NotifyType The type of change concerning the database.
536 @param PackageList Pointer to a package list which will be inserted
537 to.
538 @param Package Created Form package
539
540 @retval EFI_SUCCESS Form Package is inserted successfully.
541 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
542 Form package.
543 @retval EFI_INVALID_PARAMETER PackageHdr is NULL or PackageList is NULL.
544
545 **/
546 EFI_STATUS
547 InsertFormPackage (
548 IN VOID *PackageHdr,
549 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType,
550 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
551 OUT HII_IFR_PACKAGE_INSTANCE **Package
552 )
553 {
554 HII_IFR_PACKAGE_INSTANCE *FormPackage;
555 EFI_HII_PACKAGE_HEADER PackageHeader;
556
557 if (PackageHdr == NULL || PackageList == NULL) {
558 return EFI_INVALID_PARAMETER;
559 }
560
561 //
562 // Get the length of the package, including package header itself
563 //
564 CopyMem (&PackageHeader, PackageHdr, sizeof (EFI_HII_PACKAGE_HEADER));
565
566 //
567 // Create a Form package node
568 //
569 FormPackage = (HII_IFR_PACKAGE_INSTANCE *) AllocateZeroPool (sizeof (HII_IFR_PACKAGE_INSTANCE));
570 if (FormPackage == NULL) {
571 return EFI_OUT_OF_RESOURCES;
572 }
573
574 FormPackage->IfrData = (UINT8 *) AllocateZeroPool (PackageHeader.Length - sizeof (EFI_HII_PACKAGE_HEADER));
575 if (FormPackage->IfrData == NULL) {
576 FreePool (FormPackage);
577 return EFI_OUT_OF_RESOURCES;
578 }
579
580 FormPackage->Signature = HII_IFR_PACKAGE_SIGNATURE;
581 //
582 // Copy Package Header
583 //
584 CopyMem (&FormPackage->FormPkgHdr, &PackageHeader, sizeof (EFI_HII_PACKAGE_HEADER));
585
586 //
587 // Copy Ifr contents
588 //
589 CopyMem (
590 FormPackage->IfrData,
591 (UINT8 *) PackageHdr + sizeof (EFI_HII_PACKAGE_HEADER),
592 PackageHeader.Length - sizeof (EFI_HII_PACKAGE_HEADER)
593 );
594
595 InsertTailList (&PackageList->FormPkgHdr, &FormPackage->IfrEntry);
596 *Package = FormPackage;
597
598 if (NotifyType == EFI_HII_DATABASE_NOTIFY_ADD_PACK) {
599 PackageList->PackageListHdr.PackageLength += FormPackage->FormPkgHdr.Length;
600 }
601 return EFI_SUCCESS;
602 }
603
604
605 /**
606 This function exports Form packages to a buffer.
607 This is a internal function.
608
609 @param Private Hii database private structure.
610 @param Handle Identification of a package list.
611 @param PackageList Pointer to a package list which will be exported.
612 @param UsedSize The length of buffer be used.
613 @param BufferSize Length of the Buffer.
614 @param Buffer Allocated space for storing exported data.
615 @param ResultSize The size of the already exported content of this
616 package list.
617
618 @retval EFI_SUCCESS Form Packages are exported successfully.
619 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
620
621 **/
622 EFI_STATUS
623 ExportFormPackages (
624 IN HII_DATABASE_PRIVATE_DATA *Private,
625 IN EFI_HII_HANDLE Handle,
626 IN HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
627 IN UINTN UsedSize,
628 IN UINTN BufferSize,
629 IN OUT VOID *Buffer,
630 IN OUT UINTN *ResultSize
631 )
632 {
633 HII_IFR_PACKAGE_INSTANCE *FormPackage;
634 UINTN PackageLength;
635 LIST_ENTRY *Link;
636 EFI_STATUS Status;
637
638 if (Private == NULL || PackageList == NULL || ResultSize == NULL) {
639 return EFI_INVALID_PARAMETER;
640 }
641
642 if (BufferSize > 0 && Buffer == NULL ) {
643 return EFI_INVALID_PARAMETER;
644 }
645
646 PackageLength = 0;
647 Status = EFI_SUCCESS;
648
649 //
650 // Export Form packages.
651 //
652 for (Link = PackageList->FormPkgHdr.ForwardLink; Link != &PackageList->FormPkgHdr; Link = Link->ForwardLink) {
653 FormPackage = CR (Link, HII_IFR_PACKAGE_INSTANCE, IfrEntry, HII_IFR_PACKAGE_SIGNATURE);
654 PackageLength += FormPackage->FormPkgHdr.Length;
655 if ((Buffer != NULL) && (PackageLength + *ResultSize + UsedSize <= BufferSize)) {
656 //
657 // Invoke registered notification if exists
658 //
659 Status = InvokeRegisteredFunction (
660 Private,
661 EFI_HII_DATABASE_NOTIFY_EXPORT_PACK,
662 (VOID *) FormPackage,
663 EFI_HII_PACKAGE_FORMS,
664 Handle
665 );
666 ASSERT_EFI_ERROR (Status);
667 //
668 // Copy the Form package content.
669 //
670 CopyMem (Buffer, (VOID *) (&FormPackage->FormPkgHdr), sizeof (EFI_HII_PACKAGE_HEADER));
671 Buffer = (UINT8 *) Buffer + sizeof (EFI_HII_PACKAGE_HEADER);
672 CopyMem (
673 Buffer,
674 (VOID *) FormPackage->IfrData,
675 FormPackage->FormPkgHdr.Length - sizeof (EFI_HII_PACKAGE_HEADER)
676 );
677 Buffer = (UINT8 *) Buffer + FormPackage->FormPkgHdr.Length - sizeof (EFI_HII_PACKAGE_HEADER);
678 }
679 }
680
681 *ResultSize += PackageLength;
682
683 return EFI_SUCCESS;
684
685 }
686
687
688 /**
689 This function deletes all Form packages from a package list node.
690 This is a internal function.
691
692 @param Private Hii database private data.
693 @param Handle Handle of the package list which contains the to
694 be removed Form packages.
695 @param PackageList Pointer to a package list that contains removing
696 packages.
697
698 @retval EFI_SUCCESS Form Package(s) is deleted successfully.
699 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
700
701 **/
702 EFI_STATUS
703 RemoveFormPackages (
704 IN HII_DATABASE_PRIVATE_DATA *Private,
705 IN EFI_HII_HANDLE Handle,
706 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList
707 )
708 {
709 LIST_ENTRY *ListHead;
710 HII_IFR_PACKAGE_INSTANCE *Package;
711 EFI_STATUS Status;
712
713 ListHead = &PackageList->FormPkgHdr;
714
715 while (!IsListEmpty (ListHead)) {
716 Package = CR (
717 ListHead->ForwardLink,
718 HII_IFR_PACKAGE_INSTANCE,
719 IfrEntry,
720 HII_IFR_PACKAGE_SIGNATURE
721 );
722 Status = InvokeRegisteredFunction (
723 Private,
724 EFI_HII_DATABASE_NOTIFY_REMOVE_PACK,
725 (VOID *) Package,
726 EFI_HII_PACKAGE_FORMS,
727 Handle
728 );
729 if (EFI_ERROR (Status)) {
730 return Status;
731 }
732
733 RemoveEntryList (&Package->IfrEntry);
734 PackageList->PackageListHdr.PackageLength -= Package->FormPkgHdr.Length;
735 FreePool (Package->IfrData);
736 FreePool (Package);
737
738 }
739
740 return EFI_SUCCESS;
741 }
742
743
744
745 /**
746 This function insert a String package to a package list node.
747 This is a internal function.
748
749 @param Private Hii database private structure.
750 @param PackageHdr Pointer to a buffer stored with String package
751 information.
752 @param NotifyType The type of change concerning the database.
753 @param PackageList Pointer to a package list which will be inserted
754 to.
755 @param Package Created String package
756
757 @retval EFI_SUCCESS String Package is inserted successfully.
758 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
759 String package.
760 @retval EFI_INVALID_PARAMETER PackageHdr is NULL or PackageList is NULL.
761 @retval EFI_UNSUPPORTED A string package with the same language already
762 exists in current package list.
763
764 **/
765 EFI_STATUS
766 InsertStringPackage (
767 IN HII_DATABASE_PRIVATE_DATA *Private,
768 IN VOID *PackageHdr,
769 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType,
770 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
771 OUT HII_STRING_PACKAGE_INSTANCE **Package
772 )
773 {
774 HII_STRING_PACKAGE_INSTANCE *StringPackage;
775 UINT32 HeaderSize;
776 EFI_STATUS Status;
777 EFI_HII_PACKAGE_HEADER PackageHeader;
778 CHAR8 *Language;
779 UINT32 LanguageSize;
780 LIST_ENTRY *Link;
781
782 if (Private == NULL || PackageHdr == NULL || PackageList == NULL) {
783 return EFI_INVALID_PARAMETER;
784 }
785 if (Private->Signature != HII_DATABASE_PRIVATE_DATA_SIGNATURE) {
786 return EFI_INVALID_PARAMETER;
787 }
788
789 CopyMem (&PackageHeader, PackageHdr, sizeof (EFI_HII_PACKAGE_HEADER));
790 CopyMem (&HeaderSize, (UINT8 *) PackageHdr + sizeof (EFI_HII_PACKAGE_HEADER), sizeof (UINT32));
791
792 //
793 // It is illegal to have two string packages with same language within one packagelist
794 // since the stringid will be duplicate if so. Check it to avoid this potential issue.
795 //
796 LanguageSize = HeaderSize - sizeof (EFI_HII_STRING_PACKAGE_HDR) + sizeof (CHAR8);
797 Language = (CHAR8 *) AllocateZeroPool (LanguageSize);
798 if (Language == NULL) {
799 return EFI_OUT_OF_RESOURCES;
800 }
801 AsciiStrCpy (Language, (CHAR8 *) PackageHdr + HeaderSize - LanguageSize);
802 for (Link = PackageList->StringPkgHdr.ForwardLink; Link != &PackageList->StringPkgHdr; Link = Link->ForwardLink) {
803 StringPackage = CR (Link, HII_STRING_PACKAGE_INSTANCE, StringEntry, HII_STRING_PACKAGE_SIGNATURE);
804 if (HiiCompareLanguage (Language, StringPackage->StringPkgHdr->Language)) {
805 FreePool (Language);
806 return EFI_UNSUPPORTED;
807 }
808 }
809 FreePool (Language);
810
811 //
812 // Create a String package node
813 //
814 StringPackage = (HII_STRING_PACKAGE_INSTANCE *) AllocateZeroPool (sizeof (HII_STRING_PACKAGE_INSTANCE));
815 if (StringPackage == NULL) {
816 Status = EFI_OUT_OF_RESOURCES;
817 goto Error;
818 }
819
820 StringPackage->StringPkgHdr = (EFI_HII_STRING_PACKAGE_HDR *) AllocateZeroPool (HeaderSize);
821 if (StringPackage->StringPkgHdr == NULL) {
822 Status = EFI_OUT_OF_RESOURCES;
823 goto Error;
824 }
825
826 StringPackage->StringBlock = (UINT8 *) AllocateZeroPool (PackageHeader.Length - HeaderSize);
827 if (StringPackage->StringBlock == NULL) {
828 Status = EFI_OUT_OF_RESOURCES;
829 goto Error;
830 }
831
832 StringPackage->Signature = HII_STRING_PACKAGE_SIGNATURE;
833 StringPackage->FontId = 0;
834 InitializeListHead (&StringPackage->FontInfoList);
835
836 //
837 // Copy the String package header.
838 //
839 CopyMem (StringPackage->StringPkgHdr, PackageHdr, HeaderSize);
840
841 //
842 // Copy the String blocks
843 //
844 CopyMem (
845 StringPackage->StringBlock,
846 (UINT8 *) PackageHdr + HeaderSize,
847 PackageHeader.Length - HeaderSize
848 );
849
850 //
851 // Collect all font block info
852 //
853 Status = FindStringBlock (Private, StringPackage, (EFI_STRING_ID) (-1), NULL, NULL, NULL, &StringPackage->MaxStringId, NULL);
854 if (EFI_ERROR (Status)) {
855 return Status;
856 }
857
858 //
859 // Insert to String package array
860 //
861 InsertTailList (&PackageList->StringPkgHdr, &StringPackage->StringEntry);
862 *Package = StringPackage;
863
864 if (NotifyType == EFI_HII_DATABASE_NOTIFY_ADD_PACK) {
865 PackageList->PackageListHdr.PackageLength += StringPackage->StringPkgHdr->Header.Length;
866 }
867
868 return EFI_SUCCESS;
869
870 Error:
871
872 if (StringPackage != NULL) {
873 if (StringPackage->StringBlock != NULL) {
874 FreePool (StringPackage->StringBlock);
875 }
876 if (StringPackage->StringPkgHdr != NULL) {
877 FreePool (StringPackage->StringPkgHdr);
878 }
879 FreePool (StringPackage);
880 }
881 return Status;
882
883 }
884
885 /**
886 Adjust all string packages in a single package list to have the same max string ID.
887
888 @param PackageList Pointer to a package list which will be adjusted.
889
890 @retval EFI_SUCCESS Adjust all string packages successfully.
891 @retval others Can't adjust string packges.
892
893 **/
894 EFI_STATUS
895 AdjustStringPackage (
896 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList
897 )
898 {
899 LIST_ENTRY *Link;
900 HII_STRING_PACKAGE_INSTANCE *StringPackage;
901 UINT32 Skip2BlockSize;
902 UINT32 OldBlockSize;
903 UINT8 *StringBlock;
904 UINT8 *BlockPtr;
905 EFI_STRING_ID MaxStringId;
906 UINT16 SkipCount;
907
908 MaxStringId = 0;
909 for (Link = PackageList->StringPkgHdr.ForwardLink;
910 Link != &PackageList->StringPkgHdr;
911 Link = Link->ForwardLink
912 ) {
913 StringPackage = CR (Link, HII_STRING_PACKAGE_INSTANCE, StringEntry, HII_STRING_PACKAGE_SIGNATURE);
914 if (MaxStringId < StringPackage->MaxStringId) {
915 MaxStringId = StringPackage->MaxStringId;
916 }
917 }
918
919 for (Link = PackageList->StringPkgHdr.ForwardLink;
920 Link != &PackageList->StringPkgHdr;
921 Link = Link->ForwardLink
922 ) {
923 StringPackage = CR (Link, HII_STRING_PACKAGE_INSTANCE, StringEntry, HII_STRING_PACKAGE_SIGNATURE);
924 if (StringPackage->MaxStringId < MaxStringId) {
925 OldBlockSize = StringPackage->StringPkgHdr->Header.Length - StringPackage->StringPkgHdr->HdrSize;
926 //
927 // Create SKIP2 EFI_HII_SIBT_SKIP2_BLOCKs to reserve the missing string IDs.
928 //
929 SkipCount = (UINT16) (MaxStringId - StringPackage->MaxStringId);
930 Skip2BlockSize = (UINT32) sizeof (EFI_HII_SIBT_SKIP2_BLOCK);
931
932 StringBlock = (UINT8 *) AllocateZeroPool (OldBlockSize + Skip2BlockSize);
933 if (StringBlock == NULL) {
934 return EFI_OUT_OF_RESOURCES;
935 }
936 //
937 // Copy original string blocks, except the EFI_HII_SIBT_END.
938 //
939 CopyMem (StringBlock, StringPackage->StringBlock, OldBlockSize - sizeof (EFI_HII_SIBT_END_BLOCK));
940 //
941 // Create SKIP2 EFI_HII_SIBT_SKIP2_BLOCK blocks
942 //
943 BlockPtr = StringBlock + OldBlockSize - sizeof (EFI_HII_SIBT_END_BLOCK);
944 *BlockPtr = EFI_HII_SIBT_SKIP2;
945 CopyMem (BlockPtr + 1, &SkipCount, sizeof (UINT16));
946 BlockPtr += sizeof (EFI_HII_SIBT_SKIP2_BLOCK);
947
948 //
949 // Append a EFI_HII_SIBT_END block to the end.
950 //
951 *BlockPtr = EFI_HII_SIBT_END;
952 FreePool (StringPackage->StringBlock);
953 StringPackage->StringBlock = StringBlock;
954 StringPackage->StringPkgHdr->Header.Length += Skip2BlockSize;
955 PackageList->PackageListHdr.PackageLength += Skip2BlockSize;
956 StringPackage->MaxStringId = MaxStringId;
957 }
958 }
959
960 return EFI_SUCCESS;
961 }
962
963 /**
964 This function exports String packages to a buffer.
965 This is a internal function.
966
967 @param Private Hii database private structure.
968 @param Handle Identification of a package list.
969 @param PackageList Pointer to a package list which will be exported.
970 @param UsedSize The length of buffer be used.
971 @param BufferSize Length of the Buffer.
972 @param Buffer Allocated space for storing exported data.
973 @param ResultSize The size of the already exported content of this
974 package list.
975
976 @retval EFI_SUCCESS String Packages are exported successfully.
977 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
978
979 **/
980 EFI_STATUS
981 ExportStringPackages (
982 IN HII_DATABASE_PRIVATE_DATA *Private,
983 IN EFI_HII_HANDLE Handle,
984 IN HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
985 IN UINTN UsedSize,
986 IN UINTN BufferSize,
987 IN OUT VOID *Buffer,
988 IN OUT UINTN *ResultSize
989 )
990 {
991 LIST_ENTRY *Link;
992 UINTN PackageLength;
993 EFI_STATUS Status;
994 HII_STRING_PACKAGE_INSTANCE *StringPackage;
995
996 if (Private == NULL || PackageList == NULL || ResultSize == NULL) {
997 return EFI_INVALID_PARAMETER;
998 }
999
1000 if (BufferSize > 0 && Buffer == NULL ) {
1001 return EFI_INVALID_PARAMETER;
1002 }
1003
1004 PackageLength = 0;
1005 Status = EFI_SUCCESS;
1006
1007 for (Link = PackageList->StringPkgHdr.ForwardLink; Link != &PackageList->StringPkgHdr; Link = Link->ForwardLink) {
1008 StringPackage = CR (Link, HII_STRING_PACKAGE_INSTANCE, StringEntry, HII_STRING_PACKAGE_SIGNATURE);
1009 PackageLength += StringPackage->StringPkgHdr->Header.Length;
1010 if (PackageLength + *ResultSize + UsedSize <= BufferSize) {
1011 //
1012 // Invoke registered notification function with EXPORT_PACK notify type
1013 //
1014 Status = InvokeRegisteredFunction (
1015 Private,
1016 EFI_HII_DATABASE_NOTIFY_EXPORT_PACK,
1017 (VOID *) StringPackage,
1018 EFI_HII_PACKAGE_STRINGS,
1019 Handle
1020 );
1021 ASSERT_EFI_ERROR (Status);
1022 //
1023 // Copy String package header
1024 //
1025 CopyMem (Buffer, StringPackage->StringPkgHdr, StringPackage->StringPkgHdr->HdrSize);
1026 Buffer = (UINT8 *) Buffer + StringPackage->StringPkgHdr->HdrSize;
1027
1028 //
1029 // Copy String blocks information
1030 //
1031 CopyMem (
1032 Buffer,
1033 StringPackage->StringBlock,
1034 StringPackage->StringPkgHdr->Header.Length - StringPackage->StringPkgHdr->HdrSize
1035 );
1036 Buffer = (UINT8 *) Buffer + StringPackage->StringPkgHdr->Header.Length - StringPackage->StringPkgHdr->HdrSize;
1037 }
1038 }
1039
1040 *ResultSize += PackageLength;
1041 return EFI_SUCCESS;
1042 }
1043
1044
1045 /**
1046 This function deletes all String packages from a package list node.
1047 This is a internal function.
1048
1049 @param Private Hii database private data.
1050 @param Handle Handle of the package list which contains the to
1051 be removed String packages.
1052 @param PackageList Pointer to a package list that contains removing
1053 packages.
1054
1055 @retval EFI_SUCCESS String Package(s) is deleted successfully.
1056 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
1057
1058 **/
1059 EFI_STATUS
1060 RemoveStringPackages (
1061 IN HII_DATABASE_PRIVATE_DATA *Private,
1062 IN EFI_HII_HANDLE Handle,
1063 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList
1064 )
1065 {
1066 LIST_ENTRY *ListHead;
1067 HII_STRING_PACKAGE_INSTANCE *Package;
1068 HII_FONT_INFO *FontInfo;
1069 EFI_STATUS Status;
1070
1071 ListHead = &PackageList->StringPkgHdr;
1072
1073 while (!IsListEmpty (ListHead)) {
1074 Package = CR (
1075 ListHead->ForwardLink,
1076 HII_STRING_PACKAGE_INSTANCE,
1077 StringEntry,
1078 HII_STRING_PACKAGE_SIGNATURE
1079 );
1080 Status = InvokeRegisteredFunction (
1081 Private,
1082 EFI_HII_DATABASE_NOTIFY_REMOVE_PACK,
1083 (VOID *) Package,
1084 EFI_HII_PACKAGE_STRINGS,
1085 Handle
1086 );
1087 if (EFI_ERROR (Status)) {
1088 return Status;
1089 }
1090
1091 RemoveEntryList (&Package->StringEntry);
1092 PackageList->PackageListHdr.PackageLength -= Package->StringPkgHdr->Header.Length;
1093 FreePool (Package->StringBlock);
1094 FreePool (Package->StringPkgHdr);
1095 //
1096 // Delete font information
1097 //
1098 while (!IsListEmpty (&Package->FontInfoList)) {
1099 FontInfo = CR (
1100 Package->FontInfoList.ForwardLink,
1101 HII_FONT_INFO,
1102 Entry,
1103 HII_FONT_INFO_SIGNATURE
1104 );
1105 RemoveEntryList (&FontInfo->Entry);
1106 FreePool (FontInfo);
1107 }
1108
1109 FreePool (Package);
1110 }
1111
1112 return EFI_SUCCESS;
1113 }
1114
1115
1116 /**
1117 This function insert a Font package to a package list node.
1118 This is a internal function.
1119
1120 @param Private Hii database private structure.
1121 @param PackageHdr Pointer to a buffer stored with Font package
1122 information.
1123 @param NotifyType The type of change concerning the database.
1124 @param PackageList Pointer to a package list which will be inserted
1125 to.
1126 @param Package Created Font package
1127
1128 @retval EFI_SUCCESS Font Package is inserted successfully.
1129 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
1130 Font package.
1131 @retval EFI_INVALID_PARAMETER PackageHdr is NULL or PackageList is NULL.
1132 @retval EFI_UNSUPPORTED A font package with same EFI_FONT_INFO already
1133 exists in current hii database.
1134
1135 **/
1136 EFI_STATUS
1137 InsertFontPackage (
1138 IN HII_DATABASE_PRIVATE_DATA *Private,
1139 IN VOID *PackageHdr,
1140 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType,
1141 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
1142 OUT HII_FONT_PACKAGE_INSTANCE **Package
1143 )
1144 {
1145 HII_FONT_PACKAGE_INSTANCE *FontPackage;
1146 EFI_HII_FONT_PACKAGE_HDR *FontPkgHdr;
1147 UINT32 HeaderSize;
1148 EFI_STATUS Status;
1149 EFI_HII_PACKAGE_HEADER PackageHeader;
1150 EFI_FONT_INFO *FontInfo;
1151 UINT32 FontInfoSize;
1152 HII_GLOBAL_FONT_INFO *GlobalFont;
1153
1154 if (Private == NULL || PackageHdr == NULL || PackageList == NULL) {
1155 return EFI_INVALID_PARAMETER;
1156 }
1157
1158 CopyMem (&PackageHeader, PackageHdr, sizeof (EFI_HII_PACKAGE_HEADER));
1159 CopyMem (&HeaderSize, (UINT8 *) PackageHdr + sizeof (EFI_HII_PACKAGE_HEADER), sizeof (UINT32));
1160
1161 FontInfo = NULL;
1162 FontPackage = NULL;
1163 GlobalFont = NULL;
1164
1165 //
1166 // It is illegal to have two font packages with same EFI_FONT_INFO within hii
1167 // database. EFI_FONT_INFO (FontName, FontSize, FontStyle) describes font's
1168 // attributes and identify a font uniquely.
1169 //
1170 FontPkgHdr = (EFI_HII_FONT_PACKAGE_HDR *) AllocateZeroPool (HeaderSize);
1171 if (FontPkgHdr == NULL) {
1172 Status = EFI_OUT_OF_RESOURCES;
1173 goto Error;
1174 }
1175 CopyMem (FontPkgHdr, PackageHdr, HeaderSize);
1176
1177 FontInfoSize = sizeof (EFI_FONT_INFO) + HeaderSize - sizeof (EFI_HII_FONT_PACKAGE_HDR);
1178 FontInfo = (EFI_FONT_INFO *) AllocateZeroPool (FontInfoSize);
1179 if (FontInfo == NULL) {
1180 Status = EFI_OUT_OF_RESOURCES;
1181 goto Error;
1182 }
1183 FontInfo->FontStyle = FontPkgHdr->FontStyle;
1184 FontInfo->FontSize = FontPkgHdr->Cell.Height;
1185 StrCpy (FontInfo->FontName, FontPkgHdr->FontFamily);
1186
1187 if (IsFontInfoExisted (Private, FontInfo, NULL, NULL, NULL)) {
1188 Status = EFI_UNSUPPORTED;
1189 goto Error;
1190 }
1191
1192 //
1193 // Create a Font package node
1194 //
1195 FontPackage = (HII_FONT_PACKAGE_INSTANCE *) AllocateZeroPool (sizeof (HII_FONT_PACKAGE_INSTANCE));
1196 if (FontPackage == NULL) {
1197 Status = EFI_OUT_OF_RESOURCES;
1198 goto Error;
1199 }
1200 FontPackage->Signature = HII_FONT_PACKAGE_SIGNATURE;
1201 FontPackage->FontPkgHdr = FontPkgHdr;
1202 InitializeListHead (&FontPackage->GlyphInfoList);
1203
1204 FontPackage->GlyphBlock = (UINT8 *) AllocateZeroPool (PackageHeader.Length - HeaderSize);
1205 if (FontPackage->GlyphBlock == NULL) {
1206 Status = EFI_OUT_OF_RESOURCES;
1207 goto Error;
1208 }
1209 CopyMem (FontPackage->GlyphBlock, (UINT8 *) PackageHdr + HeaderSize, PackageHeader.Length - HeaderSize);
1210
1211 //
1212 // Collect all default character cell information and backup in GlyphInfoList.
1213 //
1214 Status = FindGlyphBlock (FontPackage, (CHAR16) (-1), NULL, NULL, NULL);
1215 if (EFI_ERROR (Status)) {
1216 goto Error;
1217 }
1218
1219 //
1220 // This font package describes an unique EFI_FONT_INFO. Backup it in global
1221 // font info list.
1222 //
1223 GlobalFont = (HII_GLOBAL_FONT_INFO *) AllocateZeroPool (sizeof (HII_GLOBAL_FONT_INFO));
1224 if (GlobalFont == NULL) {
1225 Status = EFI_OUT_OF_RESOURCES;
1226 goto Error;
1227 }
1228 GlobalFont->Signature = HII_GLOBAL_FONT_INFO_SIGNATURE;
1229 GlobalFont->FontPackage = FontPackage;
1230 GlobalFont->FontInfoSize = FontInfoSize;
1231 GlobalFont->FontInfo = FontInfo;
1232 InsertTailList (&Private->FontInfoList, &GlobalFont->Entry);
1233
1234 //
1235 // Insert this font package to Font package array
1236 //
1237 InsertTailList (&PackageList->FontPkgHdr, &FontPackage->FontEntry);
1238 *Package = FontPackage;
1239
1240 if (NotifyType == EFI_HII_DATABASE_NOTIFY_ADD_PACK) {
1241 PackageList->PackageListHdr.PackageLength += FontPackage->FontPkgHdr->Header.Length;
1242 }
1243
1244 return EFI_SUCCESS;
1245
1246 Error:
1247
1248 if (FontPkgHdr != NULL) {
1249 FreePool (FontPkgHdr);
1250 }
1251 if (FontInfo != NULL) {
1252 FreePool (FontInfo);
1253 }
1254 if (FontPackage != NULL) {
1255 if (FontPackage->GlyphBlock != NULL) {
1256 FreePool (FontPackage->GlyphBlock);
1257 }
1258 FreePool (FontPackage);
1259 }
1260 if (GlobalFont != NULL) {
1261 FreePool (GlobalFont);
1262 }
1263
1264 return Status;
1265
1266 }
1267
1268
1269 /**
1270 This function exports Font packages to a buffer.
1271 This is a internal function.
1272
1273 @param Private Hii database private structure.
1274 @param Handle Identification of a package list.
1275 @param PackageList Pointer to a package list which will be exported.
1276 @param UsedSize The length of buffer be used.
1277 @param BufferSize Length of the Buffer.
1278 @param Buffer Allocated space for storing exported data.
1279 @param ResultSize The size of the already exported content of this
1280 package list.
1281
1282 @retval EFI_SUCCESS Font Packages are exported successfully.
1283 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
1284
1285 **/
1286 EFI_STATUS
1287 ExportFontPackages (
1288 IN HII_DATABASE_PRIVATE_DATA *Private,
1289 IN EFI_HII_HANDLE Handle,
1290 IN HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
1291 IN UINTN UsedSize,
1292 IN UINTN BufferSize,
1293 IN OUT VOID *Buffer,
1294 IN OUT UINTN *ResultSize
1295 )
1296 {
1297 LIST_ENTRY *Link;
1298 UINTN PackageLength;
1299 EFI_STATUS Status;
1300 HII_FONT_PACKAGE_INSTANCE *Package;
1301
1302
1303 if (Private == NULL || PackageList == NULL || ResultSize == NULL) {
1304 return EFI_INVALID_PARAMETER;
1305 }
1306
1307 if (BufferSize > 0 && Buffer == NULL ) {
1308 return EFI_INVALID_PARAMETER;
1309 }
1310
1311 PackageLength = 0;
1312 Status = EFI_SUCCESS;
1313
1314 for (Link = PackageList->FontPkgHdr.ForwardLink; Link != &PackageList->FontPkgHdr; Link = Link->ForwardLink) {
1315 Package = CR (Link, HII_FONT_PACKAGE_INSTANCE, FontEntry, HII_FONT_PACKAGE_SIGNATURE);
1316 PackageLength += Package->FontPkgHdr->Header.Length;
1317 if (PackageLength + *ResultSize + UsedSize <= BufferSize) {
1318 //
1319 // Invoke registered notification function with EXPORT_PACK notify type
1320 //
1321 Status = InvokeRegisteredFunction (
1322 Private,
1323 EFI_HII_DATABASE_NOTIFY_EXPORT_PACK,
1324 (VOID *) Package,
1325 EFI_HII_PACKAGE_FONTS,
1326 Handle
1327 );
1328 ASSERT_EFI_ERROR (Status);
1329 //
1330 // Copy Font package header
1331 //
1332 CopyMem (Buffer, Package->FontPkgHdr, Package->FontPkgHdr->HdrSize);
1333 Buffer = (UINT8 *) Buffer + Package->FontPkgHdr->HdrSize;
1334
1335 //
1336 // Copy Glyph blocks information
1337 //
1338 CopyMem (
1339 Buffer,
1340 Package->GlyphBlock,
1341 Package->FontPkgHdr->Header.Length - Package->FontPkgHdr->HdrSize
1342 );
1343 Buffer = (UINT8 *) Buffer + Package->FontPkgHdr->Header.Length - Package->FontPkgHdr->HdrSize;
1344 }
1345 }
1346
1347 *ResultSize += PackageLength;
1348 return EFI_SUCCESS;
1349 }
1350
1351
1352 /**
1353 This function deletes all Font packages from a package list node.
1354 This is a internal function.
1355
1356 @param Private Hii database private data.
1357 @param Handle Handle of the package list which contains the to
1358 be removed Font packages.
1359 @param PackageList Pointer to a package list that contains removing
1360 packages.
1361
1362 @retval EFI_SUCCESS Font Package(s) is deleted successfully.
1363 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
1364
1365 **/
1366 EFI_STATUS
1367 RemoveFontPackages (
1368 IN HII_DATABASE_PRIVATE_DATA *Private,
1369 IN EFI_HII_HANDLE Handle,
1370 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList
1371 )
1372 {
1373 LIST_ENTRY *ListHead;
1374 HII_FONT_PACKAGE_INSTANCE *Package;
1375 EFI_STATUS Status;
1376 HII_GLYPH_INFO *GlyphInfo;
1377 LIST_ENTRY *Link;
1378 HII_GLOBAL_FONT_INFO *GlobalFont;
1379
1380 ListHead = &PackageList->FontPkgHdr;
1381
1382 while (!IsListEmpty (ListHead)) {
1383 Package = CR (
1384 ListHead->ForwardLink,
1385 HII_FONT_PACKAGE_INSTANCE,
1386 FontEntry,
1387 HII_FONT_PACKAGE_SIGNATURE
1388 );
1389 Status = InvokeRegisteredFunction (
1390 Private,
1391 EFI_HII_DATABASE_NOTIFY_REMOVE_PACK,
1392 (VOID *) Package,
1393 EFI_HII_PACKAGE_FONTS,
1394 Handle
1395 );
1396 if (EFI_ERROR (Status)) {
1397 return Status;
1398 }
1399
1400 RemoveEntryList (&Package->FontEntry);
1401 PackageList->PackageListHdr.PackageLength -= Package->FontPkgHdr->Header.Length;
1402
1403 if (Package->GlyphBlock != NULL) {
1404 FreePool (Package->GlyphBlock);
1405 }
1406 FreePool (Package->FontPkgHdr);
1407 //
1408 // Delete default character cell information
1409 //
1410 while (!IsListEmpty (&Package->GlyphInfoList)) {
1411 GlyphInfo = CR (
1412 Package->GlyphInfoList.ForwardLink,
1413 HII_GLYPH_INFO,
1414 Entry,
1415 HII_GLYPH_INFO_SIGNATURE
1416 );
1417 RemoveEntryList (&GlyphInfo->Entry);
1418 FreePool (GlyphInfo);
1419 }
1420
1421 //
1422 // Remove corresponding global font info
1423 //
1424 for (Link = Private->FontInfoList.ForwardLink; Link != &Private->FontInfoList; Link = Link->ForwardLink) {
1425 GlobalFont = CR (Link, HII_GLOBAL_FONT_INFO, Entry, HII_GLOBAL_FONT_INFO_SIGNATURE);
1426 if (GlobalFont->FontPackage == Package) {
1427 RemoveEntryList (&GlobalFont->Entry);
1428 FreePool (GlobalFont->FontInfo);
1429 FreePool (GlobalFont);
1430 break;
1431 }
1432 }
1433
1434 FreePool (Package);
1435 }
1436
1437 return EFI_SUCCESS;
1438 }
1439
1440
1441 /**
1442 This function insert a Image package to a package list node.
1443 This is a internal function.
1444
1445 @param PackageHdr Pointer to a buffer stored with Image package
1446 information.
1447 @param NotifyType The type of change concerning the database.
1448 @param PackageList Pointer to a package list which will be inserted
1449 to.
1450 @param Package Created Image package
1451
1452 @retval EFI_SUCCESS Image Package is inserted successfully.
1453 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
1454 Image package.
1455 @retval EFI_INVALID_PARAMETER PackageHdr is NULL or PackageList is NULL.
1456
1457 **/
1458 EFI_STATUS
1459 InsertImagePackage (
1460 IN VOID *PackageHdr,
1461 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType,
1462 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
1463 OUT HII_IMAGE_PACKAGE_INSTANCE **Package
1464 )
1465 {
1466 HII_IMAGE_PACKAGE_INSTANCE *ImagePackage;
1467 UINT32 PaletteSize;
1468 UINT32 ImageSize;
1469 UINT16 Index;
1470 EFI_HII_IMAGE_PALETTE_INFO_HEADER *PaletteHdr;
1471 EFI_HII_IMAGE_PALETTE_INFO *PaletteInfo;
1472 UINT32 PaletteInfoOffset;
1473 UINT32 ImageInfoOffset;
1474 UINT16 CurrentSize;
1475
1476 if (PackageHdr == NULL || PackageList == NULL) {
1477 return EFI_INVALID_PARAMETER;
1478 }
1479
1480 //
1481 // Less than one image package is allowed in one package list.
1482 //
1483 if (PackageList->ImagePkg != NULL) {
1484 return EFI_INVALID_PARAMETER;
1485 }
1486
1487 //
1488 // Create a Image package node
1489 //
1490 ImagePackage = (HII_IMAGE_PACKAGE_INSTANCE *) AllocateZeroPool (sizeof (HII_IMAGE_PACKAGE_INSTANCE));
1491 if (ImagePackage == NULL) {
1492 return EFI_OUT_OF_RESOURCES;
1493 }
1494
1495 //
1496 // Copy the Image package header.
1497 //
1498 CopyMem (&ImagePackage->ImagePkgHdr, PackageHdr, sizeof (EFI_HII_IMAGE_PACKAGE_HDR));
1499
1500 PaletteInfoOffset = ImagePackage->ImagePkgHdr.PaletteInfoOffset;
1501 ImageInfoOffset = ImagePackage->ImagePkgHdr.ImageInfoOffset;
1502
1503 //
1504 // If PaletteInfoOffset is zero, there are no palettes in this image package.
1505 //
1506 PaletteSize = 0;
1507 ImagePackage->PaletteBlock = NULL;
1508 if (PaletteInfoOffset != 0) {
1509 PaletteHdr = (EFI_HII_IMAGE_PALETTE_INFO_HEADER *) ((UINT8 *) PackageHdr + PaletteInfoOffset);
1510 PaletteSize = sizeof (EFI_HII_IMAGE_PALETTE_INFO_HEADER);
1511 PaletteInfo = (EFI_HII_IMAGE_PALETTE_INFO *) ((UINT8 *) PaletteHdr + PaletteSize);
1512
1513 for (Index = 0; Index < PaletteHdr->PaletteCount; Index++) {
1514 CopyMem (&CurrentSize, PaletteInfo, sizeof (UINT16));
1515 CurrentSize += sizeof (UINT16);
1516 PaletteSize += (UINT32) CurrentSize;
1517 PaletteInfo = (EFI_HII_IMAGE_PALETTE_INFO *) ((UINT8 *) PaletteInfo + CurrentSize);
1518 }
1519
1520 ImagePackage->PaletteBlock = (UINT8 *) AllocateZeroPool (PaletteSize);
1521 if (ImagePackage->PaletteBlock == NULL) {
1522 FreePool (ImagePackage);
1523 return EFI_OUT_OF_RESOURCES;
1524 }
1525 CopyMem (
1526 ImagePackage->PaletteBlock,
1527 (UINT8 *) PackageHdr + PaletteInfoOffset,
1528 PaletteSize
1529 );
1530 }
1531
1532 //
1533 // If ImageInfoOffset is zero, there are no images in this package.
1534 //
1535 ImageSize = 0;
1536 ImagePackage->ImageBlock = NULL;
1537 if (ImageInfoOffset != 0) {
1538 ImageSize = ImagePackage->ImagePkgHdr.Header.Length -
1539 sizeof (EFI_HII_IMAGE_PACKAGE_HDR) - PaletteSize;
1540 ImagePackage->ImageBlock = (UINT8 *) AllocateZeroPool (ImageSize);
1541 if (ImagePackage->ImageBlock == NULL) {
1542 FreePool (ImagePackage->PaletteBlock);
1543 FreePool (ImagePackage);
1544 return EFI_OUT_OF_RESOURCES;
1545 }
1546 CopyMem (
1547 ImagePackage->ImageBlock,
1548 (UINT8 *) PackageHdr + ImageInfoOffset,
1549 ImageSize
1550 );
1551 }
1552
1553 ImagePackage->ImageBlockSize = ImageSize;
1554 ImagePackage->PaletteInfoSize = PaletteSize;
1555 PackageList->ImagePkg = ImagePackage;
1556 *Package = ImagePackage;
1557
1558 if (NotifyType == EFI_HII_DATABASE_NOTIFY_ADD_PACK) {
1559 PackageList->PackageListHdr.PackageLength += ImagePackage->ImagePkgHdr.Header.Length;
1560 }
1561
1562 return EFI_SUCCESS;
1563 }
1564
1565
1566 /**
1567 This function exports Image packages to a buffer.
1568 This is a internal function.
1569
1570 @param Private Hii database private structure.
1571 @param Handle Identification of a package list.
1572 @param PackageList Pointer to a package list which will be exported.
1573 @param UsedSize The length of buffer be used.
1574 @param BufferSize Length of the Buffer.
1575 @param Buffer Allocated space for storing exported data.
1576 @param ResultSize The size of the already exported content of this
1577 package list.
1578
1579 @retval EFI_SUCCESS Image Packages are exported successfully.
1580 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
1581
1582 **/
1583 EFI_STATUS
1584 ExportImagePackages (
1585 IN HII_DATABASE_PRIVATE_DATA *Private,
1586 IN EFI_HII_HANDLE Handle,
1587 IN HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
1588 IN UINTN UsedSize,
1589 IN UINTN BufferSize,
1590 IN OUT VOID *Buffer,
1591 IN OUT UINTN *ResultSize
1592 )
1593 {
1594 UINTN PackageLength;
1595 EFI_STATUS Status;
1596 HII_IMAGE_PACKAGE_INSTANCE *Package;
1597
1598
1599 if (Private == NULL || PackageList == NULL || ResultSize == NULL) {
1600 return EFI_INVALID_PARAMETER;
1601 }
1602
1603 if (BufferSize > 0 && Buffer == NULL ) {
1604 return EFI_INVALID_PARAMETER;
1605 }
1606
1607 Package = PackageList->ImagePkg;
1608
1609 if (Package == NULL) {
1610 return EFI_SUCCESS;
1611 }
1612
1613 PackageLength = Package->ImagePkgHdr.Header.Length;
1614
1615 if (PackageLength + *ResultSize + UsedSize <= BufferSize) {
1616 //
1617 // Invoke registered notification function with EXPORT_PACK notify type
1618 //
1619 Status = InvokeRegisteredFunction (
1620 Private,
1621 EFI_HII_DATABASE_NOTIFY_EXPORT_PACK,
1622 (VOID *) Package,
1623 EFI_HII_PACKAGE_IMAGES,
1624 Handle
1625 );
1626 ASSERT_EFI_ERROR (Status);
1627 ASSERT (Package->ImagePkgHdr.Header.Length ==
1628 sizeof (EFI_HII_IMAGE_PACKAGE_HDR) + Package->ImageBlockSize + Package->PaletteInfoSize);
1629 //
1630 // Copy Image package header,
1631 // then justify the offset for image info and palette info in the header.
1632 //
1633 CopyMem (Buffer, &Package->ImagePkgHdr, sizeof (EFI_HII_IMAGE_PACKAGE_HDR));
1634 Buffer = (UINT8 *) Buffer + sizeof (EFI_HII_IMAGE_PACKAGE_HDR);
1635
1636 //
1637 // Copy Image blocks information
1638 //
1639 if (Package->ImageBlockSize != 0) {
1640 CopyMem (Buffer, Package->ImageBlock, Package->ImageBlockSize);
1641 Buffer = (UINT8 *) Buffer + Package->ImageBlockSize;
1642 }
1643 //
1644 // Copy Palette information
1645 //
1646 if (Package->PaletteInfoSize != 0) {
1647 CopyMem (Buffer, Package->PaletteBlock, Package->PaletteInfoSize);
1648 Buffer = (UINT8 *) Buffer + Package->PaletteInfoSize;
1649 }
1650 }
1651
1652 *ResultSize += PackageLength;
1653 return EFI_SUCCESS;
1654 }
1655
1656
1657 /**
1658 This function deletes Image package from a package list node.
1659 This is a internal function.
1660
1661 @param Private Hii database private data.
1662 @param Handle Handle of the package list which contains the to
1663 be removed Image packages.
1664 @param PackageList Package List which contains the to be removed
1665 Image package.
1666
1667 @retval EFI_SUCCESS Image Package(s) is deleted successfully.
1668 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
1669
1670 **/
1671 EFI_STATUS
1672 RemoveImagePackages (
1673 IN HII_DATABASE_PRIVATE_DATA *Private,
1674 IN EFI_HII_HANDLE Handle,
1675 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList
1676 )
1677 {
1678 HII_IMAGE_PACKAGE_INSTANCE *Package;
1679 EFI_STATUS Status;
1680
1681 Package = PackageList->ImagePkg;
1682
1683 //
1684 // Image package does not exist, return directly.
1685 //
1686 if (Package == NULL) {
1687 return EFI_SUCCESS;
1688 }
1689
1690 Status = InvokeRegisteredFunction (
1691 Private,
1692 EFI_HII_DATABASE_NOTIFY_REMOVE_PACK,
1693 (VOID *) Package,
1694 EFI_HII_PACKAGE_IMAGES,
1695 Handle
1696 );
1697 if (EFI_ERROR (Status)) {
1698 return Status;
1699 }
1700
1701 PackageList->PackageListHdr.PackageLength -= Package->ImagePkgHdr.Header.Length;
1702
1703 FreePool (Package->ImageBlock);
1704 if (Package->PaletteBlock != NULL) {
1705 FreePool (Package->PaletteBlock);
1706 }
1707 FreePool (Package);
1708
1709 PackageList->ImagePkg = NULL;
1710
1711 return EFI_SUCCESS;
1712 }
1713
1714
1715 /**
1716 This function insert a Simple Font package to a package list node.
1717 This is a internal function.
1718
1719 @param PackageHdr Pointer to a buffer stored with Simple Font
1720 package information.
1721 @param NotifyType The type of change concerning the database.
1722 @param PackageList Pointer to a package list which will be inserted
1723 to.
1724 @param Package Created Simple Font package
1725
1726 @retval EFI_SUCCESS Simple Font Package is inserted successfully.
1727 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
1728 Simple Font package.
1729 @retval EFI_INVALID_PARAMETER PackageHdr is NULL or PackageList is NULL.
1730
1731 **/
1732 EFI_STATUS
1733 InsertSimpleFontPackage (
1734 IN VOID *PackageHdr,
1735 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType,
1736 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
1737 OUT HII_SIMPLE_FONT_PACKAGE_INSTANCE **Package
1738 )
1739 {
1740 HII_SIMPLE_FONT_PACKAGE_INSTANCE *SimpleFontPackage;
1741 EFI_STATUS Status;
1742 EFI_HII_PACKAGE_HEADER Header;
1743
1744 if (PackageHdr == NULL || PackageList == NULL) {
1745 return EFI_INVALID_PARAMETER;
1746 }
1747
1748 //
1749 // Create a Simple Font package node
1750 //
1751 SimpleFontPackage = AllocateZeroPool (sizeof (HII_SIMPLE_FONT_PACKAGE_INSTANCE));
1752 if (SimpleFontPackage == NULL) {
1753 Status = EFI_OUT_OF_RESOURCES;
1754 goto Error;
1755 }
1756 SimpleFontPackage->Signature = HII_S_FONT_PACKAGE_SIGNATURE;
1757
1758 //
1759 // Copy the Simple Font package.
1760 //
1761 CopyMem (&Header, PackageHdr, sizeof (EFI_HII_PACKAGE_HEADER));
1762
1763 SimpleFontPackage->SimpleFontPkgHdr = AllocateZeroPool (Header.Length);
1764 if (SimpleFontPackage->SimpleFontPkgHdr == NULL) {
1765 Status = EFI_OUT_OF_RESOURCES;
1766 goto Error;
1767 }
1768
1769 CopyMem (SimpleFontPackage->SimpleFontPkgHdr, PackageHdr, Header.Length);
1770
1771 //
1772 // Insert to Simple Font package array
1773 //
1774 InsertTailList (&PackageList->SimpleFontPkgHdr, &SimpleFontPackage->SimpleFontEntry);
1775 *Package = SimpleFontPackage;
1776
1777 if (NotifyType == EFI_HII_DATABASE_NOTIFY_ADD_PACK) {
1778 PackageList->PackageListHdr.PackageLength += Header.Length;
1779 }
1780
1781 return EFI_SUCCESS;
1782
1783 Error:
1784
1785 if (SimpleFontPackage != NULL) {
1786 if (SimpleFontPackage->SimpleFontPkgHdr != NULL) {
1787 FreePool (SimpleFontPackage->SimpleFontPkgHdr);
1788 }
1789 FreePool (SimpleFontPackage);
1790 }
1791 return Status;
1792 }
1793
1794
1795 /**
1796 This function exports SimpleFont packages to a buffer.
1797 This is a internal function.
1798
1799 @param Private Hii database private structure.
1800 @param Handle Identification of a package list.
1801 @param PackageList Pointer to a package list which will be exported.
1802 @param UsedSize The length of buffer be used.
1803 @param BufferSize Length of the Buffer.
1804 @param Buffer Allocated space for storing exported data.
1805 @param ResultSize The size of the already exported content of this
1806 package list.
1807
1808 @retval EFI_SUCCESS SimpleFont Packages are exported successfully.
1809 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
1810
1811 **/
1812 EFI_STATUS
1813 ExportSimpleFontPackages (
1814 IN HII_DATABASE_PRIVATE_DATA *Private,
1815 IN EFI_HII_HANDLE Handle,
1816 IN HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
1817 IN UINTN UsedSize,
1818 IN UINTN BufferSize,
1819 IN OUT VOID *Buffer,
1820 IN OUT UINTN *ResultSize
1821 )
1822 {
1823 LIST_ENTRY *Link;
1824 UINTN PackageLength;
1825 EFI_STATUS Status;
1826 HII_SIMPLE_FONT_PACKAGE_INSTANCE *Package;
1827
1828 if (Private == NULL || PackageList == NULL || ResultSize == NULL) {
1829 return EFI_INVALID_PARAMETER;
1830 }
1831
1832 if (BufferSize > 0 && Buffer == NULL ) {
1833 return EFI_INVALID_PARAMETER;
1834 }
1835
1836 PackageLength = 0;
1837 Status = EFI_SUCCESS;
1838
1839 for (Link = PackageList->SimpleFontPkgHdr.ForwardLink; Link != &PackageList->SimpleFontPkgHdr; Link = Link->ForwardLink) {
1840 Package = CR (Link, HII_SIMPLE_FONT_PACKAGE_INSTANCE, SimpleFontEntry, HII_S_FONT_PACKAGE_SIGNATURE);
1841 PackageLength += Package->SimpleFontPkgHdr->Header.Length;
1842 if (PackageLength + *ResultSize + UsedSize <= BufferSize) {
1843 //
1844 // Invoke registered notification function with EXPORT_PACK notify type
1845 //
1846 Status = InvokeRegisteredFunction (
1847 Private,
1848 EFI_HII_DATABASE_NOTIFY_EXPORT_PACK,
1849 (VOID *) Package,
1850 EFI_HII_PACKAGE_SIMPLE_FONTS,
1851 Handle
1852 );
1853 ASSERT_EFI_ERROR (Status);
1854
1855 //
1856 // Copy SimpleFont package
1857 //
1858 CopyMem (Buffer, Package->SimpleFontPkgHdr, Package->SimpleFontPkgHdr->Header.Length);
1859 Buffer = (UINT8 *) Buffer + Package->SimpleFontPkgHdr->Header.Length;
1860 }
1861 }
1862
1863 *ResultSize += PackageLength;
1864 return EFI_SUCCESS;
1865 }
1866
1867
1868 /**
1869 This function deletes all Simple Font packages from a package list node.
1870 This is a internal function.
1871
1872 @param Private Hii database private data.
1873 @param Handle Handle of the package list which contains the to
1874 be removed Simple Font packages.
1875 @param PackageList Pointer to a package list that contains removing
1876 packages.
1877
1878 @retval EFI_SUCCESS Simple Font Package(s) is deleted successfully.
1879 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
1880
1881 **/
1882 EFI_STATUS
1883 RemoveSimpleFontPackages (
1884 IN HII_DATABASE_PRIVATE_DATA *Private,
1885 IN EFI_HII_HANDLE Handle,
1886 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList
1887 )
1888 {
1889 LIST_ENTRY *ListHead;
1890 HII_SIMPLE_FONT_PACKAGE_INSTANCE *Package;
1891 EFI_STATUS Status;
1892
1893 ListHead = &PackageList->SimpleFontPkgHdr;
1894
1895 while (!IsListEmpty (ListHead)) {
1896 Package = CR (
1897 ListHead->ForwardLink,
1898 HII_SIMPLE_FONT_PACKAGE_INSTANCE,
1899 SimpleFontEntry,
1900 HII_S_FONT_PACKAGE_SIGNATURE
1901 );
1902 Status = InvokeRegisteredFunction (
1903 Private,
1904 EFI_HII_DATABASE_NOTIFY_REMOVE_PACK,
1905 (VOID *) Package,
1906 EFI_HII_PACKAGE_SIMPLE_FONTS,
1907 Handle
1908 );
1909 if (EFI_ERROR (Status)) {
1910 return Status;
1911 }
1912
1913 RemoveEntryList (&Package->SimpleFontEntry);
1914 PackageList->PackageListHdr.PackageLength -= Package->SimpleFontPkgHdr->Header.Length;
1915 FreePool (Package->SimpleFontPkgHdr);
1916 FreePool (Package);
1917 }
1918
1919 return EFI_SUCCESS;
1920 }
1921
1922
1923 /**
1924 This function insert a Device path package to a package list node.
1925 This is a internal function.
1926
1927 @param DevicePath Pointer to a EFI_DEVICE_PATH_PROTOCOL protocol
1928 instance
1929 @param NotifyType The type of change concerning the database.
1930 @param PackageList Pointer to a package list which will be inserted
1931 to.
1932
1933 @retval EFI_SUCCESS Device path Package is inserted successfully.
1934 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
1935 Device path package.
1936 @retval EFI_INVALID_PARAMETER DevicePath is NULL or PackageList is NULL.
1937
1938 **/
1939 EFI_STATUS
1940 InsertDevicePathPackage (
1941 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
1942 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType,
1943 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList
1944 )
1945 {
1946 UINT32 PackageLength;
1947 EFI_HII_PACKAGE_HEADER Header;
1948
1949 if (DevicePath == NULL || PackageList == NULL) {
1950 return EFI_INVALID_PARAMETER;
1951 }
1952 //
1953 // Less than one device path package is allowed in one package list.
1954 //
1955 if (PackageList->DevicePathPkg != NULL) {
1956 return EFI_INVALID_PARAMETER;
1957 }
1958
1959 PackageLength = (UINT32) GetDevicePathSize (DevicePath) + sizeof (EFI_HII_PACKAGE_HEADER);
1960 PackageList->DevicePathPkg = (UINT8 *) AllocateZeroPool (PackageLength);
1961 if (PackageList->DevicePathPkg == NULL) {
1962 return EFI_OUT_OF_RESOURCES;
1963 }
1964
1965 Header.Length = PackageLength;
1966 Header.Type = EFI_HII_PACKAGE_DEVICE_PATH;
1967 CopyMem (PackageList->DevicePathPkg, &Header, sizeof (EFI_HII_PACKAGE_HEADER));
1968 CopyMem (
1969 PackageList->DevicePathPkg + sizeof (EFI_HII_PACKAGE_HEADER),
1970 DevicePath,
1971 PackageLength - sizeof (EFI_HII_PACKAGE_HEADER)
1972 );
1973
1974 //
1975 // Since Device Path package is created by NewPackageList, either NEW_PACK
1976 // or ADD_PACK should increase the length of package list.
1977 //
1978 PackageList->PackageListHdr.PackageLength += PackageLength;
1979 return EFI_SUCCESS;
1980 }
1981
1982
1983 /**
1984 This function exports device path package to a buffer.
1985 This is a internal function.
1986
1987 @param Private Hii database private structure.
1988 @param Handle Identification of a package list.
1989 @param PackageList Pointer to a package list which will be exported.
1990 @param UsedSize The length of buffer be used.
1991 @param BufferSize Length of the Buffer.
1992 @param Buffer Allocated space for storing exported data.
1993 @param ResultSize The size of the already exported content of this
1994 package list.
1995
1996 @retval EFI_SUCCESS Device path Package is exported successfully.
1997 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
1998
1999 **/
2000 EFI_STATUS
2001 ExportDevicePathPackage (
2002 IN HII_DATABASE_PRIVATE_DATA *Private,
2003 IN EFI_HII_HANDLE Handle,
2004 IN HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
2005 IN UINTN UsedSize,
2006 IN UINTN BufferSize,
2007 IN OUT VOID *Buffer,
2008 IN OUT UINTN *ResultSize
2009 )
2010 {
2011 EFI_STATUS Status;
2012 UINT8 *Package;
2013 EFI_HII_PACKAGE_HEADER Header;
2014
2015 if (Private == NULL || PackageList == NULL || ResultSize == NULL) {
2016 return EFI_INVALID_PARAMETER;
2017 }
2018 if (BufferSize > 0 && Buffer == NULL ) {
2019 return EFI_INVALID_PARAMETER;
2020 }
2021
2022 Package = PackageList->DevicePathPkg;
2023
2024 if (Package == NULL) {
2025 return EFI_SUCCESS;
2026 }
2027
2028 CopyMem (&Header, Package, sizeof (EFI_HII_PACKAGE_HEADER));
2029
2030 if (Header.Length + *ResultSize + UsedSize <= BufferSize) {
2031 //
2032 // Invoke registered notification function with EXPORT_PACK notify type
2033 //
2034 Status = InvokeRegisteredFunction (
2035 Private,
2036 EFI_HII_DATABASE_NOTIFY_EXPORT_PACK,
2037 (VOID *) Package,
2038 EFI_HII_PACKAGE_DEVICE_PATH,
2039 Handle
2040 );
2041 ASSERT_EFI_ERROR (Status);
2042
2043 //
2044 // Copy Device path package
2045 //
2046 CopyMem (Buffer, Package, Header.Length);
2047 }
2048
2049 *ResultSize += Header.Length;
2050 return EFI_SUCCESS;
2051 }
2052
2053
2054 /**
2055 This function deletes Device Path package from a package list node.
2056 This is a internal function.
2057
2058 @param Private Hii database private data.
2059 @param Handle Handle of the package list.
2060 @param PackageList Package List which contains the to be removed
2061 Device Path package.
2062
2063 @retval EFI_SUCCESS Device Path Package is deleted successfully.
2064 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
2065
2066 **/
2067 EFI_STATUS
2068 RemoveDevicePathPackage (
2069 IN HII_DATABASE_PRIVATE_DATA *Private,
2070 IN EFI_HII_HANDLE Handle,
2071 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList
2072 )
2073 {
2074 EFI_STATUS Status;
2075 UINT8 *Package;
2076 EFI_HII_PACKAGE_HEADER Header;
2077
2078 Package = PackageList->DevicePathPkg;
2079
2080 //
2081 // No device path, return directly.
2082 //
2083 if (Package == NULL) {
2084 return EFI_SUCCESS;
2085 }
2086
2087 Status = InvokeRegisteredFunction (
2088 Private,
2089 EFI_HII_DATABASE_NOTIFY_REMOVE_PACK,
2090 (VOID *) Package,
2091 EFI_HII_PACKAGE_DEVICE_PATH,
2092 Handle
2093 );
2094 if (EFI_ERROR (Status)) {
2095 return Status;
2096 }
2097
2098 CopyMem (&Header, Package, sizeof (EFI_HII_PACKAGE_HEADER));
2099 PackageList->PackageListHdr.PackageLength -= Header.Length;
2100
2101 FreePool (Package);
2102
2103 PackageList->DevicePathPkg = NULL;
2104
2105 return EFI_SUCCESS;
2106 }
2107
2108
2109 /**
2110 This function will insert a device path package to package list firstly then
2111 invoke notification functions if any.
2112 This is a internal function.
2113
2114 @param Private Hii database private structure.
2115 @param NotifyType The type of change concerning the database.
2116 @param DevicePath Pointer to a EFI_DEVICE_PATH_PROTOCOL protocol
2117 instance
2118 @param DatabaseRecord Pointer to a database record contains a package
2119 list which will be inserted to.
2120
2121 @retval EFI_SUCCESS Device path Package is inserted successfully.
2122 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
2123 Device path package.
2124 @retval EFI_INVALID_PARAMETER DevicePath is NULL or PackageList is NULL.
2125
2126 **/
2127 EFI_STATUS
2128 AddDevicePathPackage (
2129 IN HII_DATABASE_PRIVATE_DATA *Private,
2130 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType,
2131 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
2132 IN OUT HII_DATABASE_RECORD *DatabaseRecord
2133 )
2134 {
2135 EFI_STATUS Status;
2136
2137 if (DevicePath == NULL) {
2138 return EFI_SUCCESS;
2139 }
2140
2141 ASSERT (Private != NULL);
2142 ASSERT (DatabaseRecord != NULL);
2143
2144 //
2145 // Create a device path package and insert to packagelist
2146 //
2147 Status = InsertDevicePathPackage (
2148 DevicePath,
2149 NotifyType,
2150 DatabaseRecord->PackageList
2151 );
2152 if (EFI_ERROR (Status)) {
2153 return Status;
2154 }
2155
2156 return InvokeRegisteredFunction (
2157 Private,
2158 NotifyType,
2159 (VOID *) DatabaseRecord->PackageList->DevicePathPkg,
2160 EFI_HII_PACKAGE_DEVICE_PATH,
2161 DatabaseRecord->Handle
2162 );
2163 }
2164
2165
2166 /**
2167 This function insert a Keyboard Layout package to a package list node.
2168 This is a internal function.
2169
2170 @param PackageHdr Pointer to a buffer stored with Keyboard Layout
2171 package information.
2172 @param NotifyType The type of change concerning the database.
2173 @param PackageList Pointer to a package list which will be inserted
2174 to.
2175 @param Package Created Keyboard Layout package
2176
2177 @retval EFI_SUCCESS Keyboard Layout Package is inserted successfully.
2178 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
2179 Keyboard Layout package.
2180 @retval EFI_INVALID_PARAMETER PackageHdr is NULL or PackageList is NULL.
2181
2182 **/
2183 EFI_STATUS
2184 InsertKeyboardLayoutPackage (
2185 IN VOID *PackageHdr,
2186 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType,
2187 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
2188 OUT HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE **Package
2189 )
2190 {
2191 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE *KeyboardLayoutPackage;
2192 EFI_HII_PACKAGE_HEADER PackageHeader;
2193 EFI_STATUS Status;
2194
2195 if (PackageHdr == NULL || PackageList == NULL) {
2196 return EFI_INVALID_PARAMETER;
2197 }
2198
2199 CopyMem (&PackageHeader, PackageHdr, sizeof (EFI_HII_PACKAGE_HEADER));
2200
2201 //
2202 // Create a Keyboard Layout package node
2203 //
2204 KeyboardLayoutPackage = AllocateZeroPool (sizeof (HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE));
2205 if (KeyboardLayoutPackage == NULL) {
2206 Status = EFI_OUT_OF_RESOURCES;
2207 goto Error;
2208 }
2209 KeyboardLayoutPackage->Signature = HII_KB_LAYOUT_PACKAGE_SIGNATURE;
2210
2211 KeyboardLayoutPackage->KeyboardPkg = (UINT8 *) AllocateZeroPool (PackageHeader.Length);
2212 if (KeyboardLayoutPackage->KeyboardPkg == NULL) {
2213 Status = EFI_OUT_OF_RESOURCES;
2214 goto Error;
2215 }
2216
2217 CopyMem (KeyboardLayoutPackage->KeyboardPkg, PackageHdr, PackageHeader.Length);
2218 InsertTailList (&PackageList->KeyboardLayoutHdr, &KeyboardLayoutPackage->KeyboardEntry);
2219
2220 *Package = KeyboardLayoutPackage;
2221
2222 if (NotifyType == EFI_HII_DATABASE_NOTIFY_ADD_PACK) {
2223 PackageList->PackageListHdr.PackageLength += PackageHeader.Length;
2224 }
2225
2226 return EFI_SUCCESS;
2227
2228 Error:
2229
2230
2231 if (KeyboardLayoutPackage != NULL) {
2232 if (KeyboardLayoutPackage->KeyboardPkg != NULL) {
2233 FreePool (KeyboardLayoutPackage->KeyboardPkg);
2234 }
2235 FreePool (KeyboardLayoutPackage);
2236 }
2237
2238 return Status;
2239 }
2240
2241
2242 /**
2243 This function exports Keyboard Layout packages to a buffer.
2244 This is a internal function.
2245
2246 @param Private Hii database private structure.
2247 @param Handle Identification of a package list.
2248 @param PackageList Pointer to a package list which will be exported.
2249 @param UsedSize The length of buffer be used.
2250 @param BufferSize Length of the Buffer.
2251 @param Buffer Allocated space for storing exported data.
2252 @param ResultSize The size of the already exported content of this
2253 package list.
2254
2255 @retval EFI_SUCCESS Keyboard Layout Packages are exported
2256 successfully.
2257 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
2258
2259 **/
2260 EFI_STATUS
2261 ExportKeyboardLayoutPackages (
2262 IN HII_DATABASE_PRIVATE_DATA *Private,
2263 IN EFI_HII_HANDLE Handle,
2264 IN HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
2265 IN UINTN UsedSize,
2266 IN UINTN BufferSize,
2267 IN OUT VOID *Buffer,
2268 IN OUT UINTN *ResultSize
2269 )
2270 {
2271 LIST_ENTRY *Link;
2272 UINTN PackageLength;
2273 EFI_STATUS Status;
2274 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE *Package;
2275 EFI_HII_PACKAGE_HEADER PackageHeader;
2276
2277 if (Private == NULL || PackageList == NULL || ResultSize == NULL) {
2278 return EFI_INVALID_PARAMETER;
2279 }
2280
2281 if (BufferSize > 0 && Buffer == NULL ) {
2282 return EFI_INVALID_PARAMETER;
2283 }
2284
2285 PackageLength = 0;
2286 Status = EFI_SUCCESS;
2287
2288 for (Link = PackageList->KeyboardLayoutHdr.ForwardLink; Link != &PackageList->KeyboardLayoutHdr; Link = Link->ForwardLink) {
2289 Package = CR (Link, HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE, KeyboardEntry, HII_KB_LAYOUT_PACKAGE_SIGNATURE);
2290 CopyMem (&PackageHeader, Package->KeyboardPkg, sizeof (EFI_HII_PACKAGE_HEADER));
2291 PackageLength += PackageHeader.Length;
2292 if (PackageLength + *ResultSize + UsedSize <= BufferSize) {
2293 //
2294 // Invoke registered notification function with EXPORT_PACK notify type
2295 //
2296 Status = InvokeRegisteredFunction (
2297 Private,
2298 EFI_HII_DATABASE_NOTIFY_EXPORT_PACK,
2299 (EFI_HII_PACKAGE_HEADER *) Package,
2300 EFI_HII_PACKAGE_KEYBOARD_LAYOUT,
2301 Handle
2302 );
2303 ASSERT_EFI_ERROR (Status);
2304
2305 //
2306 // Copy Keyboard Layout package
2307 //
2308 CopyMem (Buffer, Package->KeyboardPkg, PackageHeader.Length);
2309 Buffer = (UINT8 *) Buffer + PackageHeader.Length;
2310 }
2311 }
2312
2313 *ResultSize += PackageLength;
2314 return EFI_SUCCESS;
2315 }
2316
2317
2318 /**
2319 This function deletes all Keyboard Layout packages from a package list node.
2320 This is a internal function.
2321
2322 @param Private Hii database private data.
2323 @param Handle Handle of the package list which contains the to
2324 be removed Keyboard Layout packages.
2325 @param PackageList Pointer to a package list that contains removing
2326 packages.
2327
2328 @retval EFI_SUCCESS Keyboard Layout Package(s) is deleted
2329 successfully.
2330 @retval EFI_INVALID_PARAMETER Any input parameter is not valid.
2331
2332 **/
2333 EFI_STATUS
2334 RemoveKeyboardLayoutPackages (
2335 IN HII_DATABASE_PRIVATE_DATA *Private,
2336 IN EFI_HII_HANDLE Handle,
2337 IN OUT HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList
2338 )
2339 {
2340 LIST_ENTRY *ListHead;
2341 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE *Package;
2342 EFI_HII_PACKAGE_HEADER PackageHeader;
2343 EFI_STATUS Status;
2344
2345 ListHead = &PackageList->KeyboardLayoutHdr;
2346
2347 while (!IsListEmpty (ListHead)) {
2348 Package = CR (
2349 ListHead->ForwardLink,
2350 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE,
2351 KeyboardEntry,
2352 HII_KB_LAYOUT_PACKAGE_SIGNATURE
2353 );
2354 Status = InvokeRegisteredFunction (
2355 Private,
2356 EFI_HII_DATABASE_NOTIFY_REMOVE_PACK,
2357 (VOID *) Package,
2358 EFI_HII_PACKAGE_KEYBOARD_LAYOUT,
2359 Handle
2360 );
2361 if (EFI_ERROR (Status)) {
2362 return Status;
2363 }
2364
2365 RemoveEntryList (&Package->KeyboardEntry);
2366 CopyMem (&PackageHeader, Package->KeyboardPkg, sizeof (EFI_HII_PACKAGE_HEADER));
2367 PackageList->PackageListHdr.PackageLength -= PackageHeader.Length;
2368 FreePool (Package->KeyboardPkg);
2369 FreePool (Package);
2370 }
2371
2372 return EFI_SUCCESS;
2373 }
2374
2375
2376 /**
2377 This function will insert a package list to hii database firstly then
2378 invoke notification functions if any. It is the worker function of
2379 HiiNewPackageList and HiiUpdatePackageList.
2380
2381 This is a internal function.
2382
2383 @param Private Hii database private structure.
2384 @param NotifyType The type of change concerning the database.
2385 @param PackageList Pointer to a package list.
2386 @param DatabaseRecord Pointer to a database record contains a package
2387 list instance which will be inserted to.
2388
2389 @retval EFI_SUCCESS All incoming packages are inserted to current
2390 database.
2391 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
2392 Device path package.
2393 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
2394
2395 **/
2396 EFI_STATUS
2397 AddPackages (
2398 IN HII_DATABASE_PRIVATE_DATA *Private,
2399 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType,
2400 IN CONST EFI_HII_PACKAGE_LIST_HEADER *PackageList,
2401 IN OUT HII_DATABASE_RECORD *DatabaseRecord
2402 )
2403 {
2404 EFI_STATUS Status;
2405 HII_GUID_PACKAGE_INSTANCE *GuidPackage;
2406 HII_IFR_PACKAGE_INSTANCE *FormPackage;
2407 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE *KeyboardLayoutPackage;
2408 HII_STRING_PACKAGE_INSTANCE *StringPackage;
2409 HII_FONT_PACKAGE_INSTANCE *FontPackage;
2410 HII_SIMPLE_FONT_PACKAGE_INSTANCE *SimpleFontPackage;
2411 HII_IMAGE_PACKAGE_INSTANCE *ImagePackage;
2412 EFI_HII_PACKAGE_HEADER *PackageHdrPtr;
2413 EFI_HII_PACKAGE_HEADER PackageHeader;
2414 UINT32 OldPackageListLen;
2415 BOOLEAN StringPkgIsAdd;
2416
2417 //
2418 // Initialize Variables
2419 //
2420 StringPkgIsAdd = FALSE;
2421 FontPackage = NULL;
2422 StringPackage = NULL;
2423 GuidPackage = NULL;
2424 FormPackage = NULL;
2425 ImagePackage = NULL;
2426 SimpleFontPackage = NULL;
2427 KeyboardLayoutPackage = NULL;
2428
2429 //
2430 // Process the package list header
2431 //
2432 OldPackageListLen = DatabaseRecord->PackageList->PackageListHdr.PackageLength;
2433 CopyMem (
2434 &DatabaseRecord->PackageList->PackageListHdr,
2435 (VOID *) PackageList,
2436 sizeof (EFI_HII_PACKAGE_LIST_HEADER)
2437 );
2438 if (NotifyType == EFI_HII_DATABASE_NOTIFY_ADD_PACK) {
2439 DatabaseRecord->PackageList->PackageListHdr.PackageLength = OldPackageListLen;
2440 }
2441
2442 PackageHdrPtr = (EFI_HII_PACKAGE_HEADER *) ((UINT8 *) PackageList + sizeof (EFI_HII_PACKAGE_LIST_HEADER));
2443 CopyMem (&PackageHeader, PackageHdrPtr, sizeof (EFI_HII_PACKAGE_HEADER));
2444
2445 Status = EFI_SUCCESS;
2446
2447 while (PackageHeader.Type != EFI_HII_PACKAGE_END) {
2448 switch (PackageHeader.Type) {
2449 case EFI_HII_PACKAGE_TYPE_GUID:
2450 Status = InsertGuidPackage (
2451 PackageHdrPtr,
2452 NotifyType,
2453 DatabaseRecord->PackageList,
2454 &GuidPackage
2455 );
2456 if (EFI_ERROR (Status)) {
2457 return Status;
2458 }
2459 Status = InvokeRegisteredFunction (
2460 Private,
2461 NotifyType,
2462 (VOID *) GuidPackage,
2463 (UINT8) (PackageHeader.Type),
2464 DatabaseRecord->Handle
2465 );
2466 break;
2467 case EFI_HII_PACKAGE_FORMS:
2468 Status = InsertFormPackage (
2469 PackageHdrPtr,
2470 NotifyType,
2471 DatabaseRecord->PackageList,
2472 &FormPackage
2473 );
2474 if (EFI_ERROR (Status)) {
2475 return Status;
2476 }
2477 Status = InvokeRegisteredFunction (
2478 Private,
2479 NotifyType,
2480 (VOID *) FormPackage,
2481 (UINT8) (PackageHeader.Type),
2482 DatabaseRecord->Handle
2483 );
2484 break;
2485 case EFI_HII_PACKAGE_KEYBOARD_LAYOUT:
2486 Status = InsertKeyboardLayoutPackage (
2487 PackageHdrPtr,
2488 NotifyType,
2489 DatabaseRecord->PackageList,
2490 &KeyboardLayoutPackage
2491 );
2492 if (EFI_ERROR (Status)) {
2493 return Status;
2494 }
2495 Status = InvokeRegisteredFunction (
2496 Private,
2497 NotifyType,
2498 (VOID *) KeyboardLayoutPackage,
2499 (UINT8) (PackageHeader.Type),
2500 DatabaseRecord->Handle
2501 );
2502 break;
2503 case EFI_HII_PACKAGE_STRINGS:
2504 Status = InsertStringPackage (
2505 Private,
2506 PackageHdrPtr,
2507 NotifyType,
2508 DatabaseRecord->PackageList,
2509 &StringPackage
2510 );
2511 if (EFI_ERROR (Status)) {
2512 return Status;
2513 }
2514 ASSERT (StringPackage != NULL);
2515 Status = InvokeRegisteredFunction (
2516 Private,
2517 NotifyType,
2518 (VOID *) StringPackage,
2519 (UINT8) (PackageHeader.Type),
2520 DatabaseRecord->Handle
2521 );
2522 StringPkgIsAdd = TRUE;
2523 break;
2524 case EFI_HII_PACKAGE_FONTS:
2525 Status = InsertFontPackage (
2526 Private,
2527 PackageHdrPtr,
2528 NotifyType,
2529 DatabaseRecord->PackageList,
2530 &FontPackage
2531 );
2532 if (EFI_ERROR (Status)) {
2533 return Status;
2534 }
2535 Status = InvokeRegisteredFunction (
2536 Private,
2537 NotifyType,
2538 (VOID *) FontPackage,
2539 (UINT8) (PackageHeader.Type),
2540 DatabaseRecord->Handle
2541 );
2542 break;
2543 case EFI_HII_PACKAGE_IMAGES:
2544 Status = InsertImagePackage (
2545 PackageHdrPtr,
2546 NotifyType,
2547 DatabaseRecord->PackageList,
2548 &ImagePackage
2549 );
2550 if (EFI_ERROR (Status)) {
2551 return Status;
2552 }
2553 Status = InvokeRegisteredFunction (
2554 Private,
2555 NotifyType,
2556 (VOID *) ImagePackage,
2557 (UINT8) (PackageHeader.Type),
2558 DatabaseRecord->Handle
2559 );
2560 break;
2561 case EFI_HII_PACKAGE_SIMPLE_FONTS:
2562 Status = InsertSimpleFontPackage (
2563 PackageHdrPtr,
2564 NotifyType,
2565 DatabaseRecord->PackageList,
2566 &SimpleFontPackage
2567 );
2568 if (EFI_ERROR (Status)) {
2569 return Status;
2570 }
2571 Status = InvokeRegisteredFunction (
2572 Private,
2573 NotifyType,
2574 (VOID *) SimpleFontPackage,
2575 (UINT8) (PackageHeader.Type),
2576 DatabaseRecord->Handle
2577 );
2578 break;
2579 case EFI_HII_PACKAGE_DEVICE_PATH:
2580 Status = AddDevicePathPackage (
2581 Private,
2582 NotifyType,
2583 (EFI_DEVICE_PATH_PROTOCOL *) ((UINT8 *) PackageHdrPtr + sizeof (EFI_HII_PACKAGE_HEADER)),
2584 DatabaseRecord
2585 );
2586 break;
2587 default:
2588 break;
2589 }
2590
2591 if (EFI_ERROR (Status)) {
2592 return Status;
2593 }
2594 //
2595 // goto header of next package
2596 //
2597 PackageHdrPtr = (EFI_HII_PACKAGE_HEADER *) ((UINT8 *) PackageHdrPtr + PackageHeader.Length);
2598 CopyMem (&PackageHeader, PackageHdrPtr, sizeof (EFI_HII_PACKAGE_HEADER));
2599 }
2600
2601 //
2602 // Adjust String Package to make sure all string packages have the same max string ID.
2603 //
2604 if (!EFI_ERROR (Status) && StringPkgIsAdd) {
2605 Status = AdjustStringPackage (DatabaseRecord->PackageList);
2606 }
2607
2608 return Status;
2609 }
2610
2611
2612 /**
2613 This function exports a package list to a buffer. It is the worker function
2614 of HiiExportPackageList.
2615
2616 This is a internal function.
2617
2618 @param Private Hii database private structure.
2619 @param Handle Identification of a package list.
2620 @param PackageList Pointer to a package list which will be exported.
2621 @param UsedSize The length of buffer has been used by exporting
2622 package lists when Handle is NULL.
2623 @param BufferSize Length of the Buffer.
2624 @param Buffer Allocated space for storing exported data.
2625
2626 @retval EFI_SUCCESS Keyboard Layout Packages are exported
2627 successfully.
2628 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
2629
2630 **/
2631 EFI_STATUS
2632 ExportPackageList (
2633 IN HII_DATABASE_PRIVATE_DATA *Private,
2634 IN EFI_HII_HANDLE Handle,
2635 IN HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList,
2636 IN OUT UINTN *UsedSize,
2637 IN UINTN BufferSize,
2638 OUT EFI_HII_PACKAGE_LIST_HEADER *Buffer
2639 )
2640 {
2641 EFI_STATUS Status;
2642 UINTN ResultSize;
2643 EFI_HII_PACKAGE_HEADER EndofPackageList;
2644
2645 ASSERT (Private != NULL && PackageList != NULL && UsedSize != NULL);
2646 ASSERT (Private->Signature == HII_DATABASE_PRIVATE_DATA_SIGNATURE);
2647 ASSERT (IsHiiHandleValid (Handle));
2648
2649 if (BufferSize > 0 && Buffer == NULL ) {
2650 return EFI_INVALID_PARAMETER;
2651 }
2652
2653 //
2654 // Copy the package list header
2655 // ResultSize indicates the length of the exported bytes of this package list
2656 //
2657 ResultSize = sizeof (EFI_HII_PACKAGE_LIST_HEADER);
2658 if (ResultSize + *UsedSize <= BufferSize) {
2659 CopyMem ((VOID *) Buffer, PackageList, ResultSize);
2660 }
2661 //
2662 // Copy the packages and invoke EXPORT_PACK notify functions if exists.
2663 //
2664 Status = ExportGuidPackages (
2665 Private,
2666 Handle,
2667 PackageList,
2668 *UsedSize,
2669 BufferSize,
2670 (VOID *) ((UINT8 *) Buffer + ResultSize),
2671 &ResultSize
2672 );
2673 if (EFI_ERROR (Status)) {
2674 return Status;
2675 }
2676 Status = ExportFormPackages (
2677 Private,
2678 Handle,
2679 PackageList,
2680 *UsedSize,
2681 BufferSize,
2682 (VOID *) ((UINT8 *) Buffer + ResultSize),
2683 &ResultSize
2684 );
2685 if (EFI_ERROR (Status)) {
2686 return Status;
2687 }
2688 Status = ExportKeyboardLayoutPackages (
2689 Private,
2690 Handle,
2691 PackageList,
2692 *UsedSize,
2693 BufferSize,
2694 (VOID *) ((UINT8 *) Buffer + ResultSize),
2695 &ResultSize
2696 );
2697 if (EFI_ERROR (Status)) {
2698 return Status;
2699 }
2700 Status = ExportStringPackages (
2701 Private,
2702 Handle,
2703 PackageList,
2704 *UsedSize,
2705 BufferSize,
2706 (VOID *) ((UINT8 *) Buffer + ResultSize),
2707 &ResultSize
2708 );
2709 if (EFI_ERROR (Status)) {
2710 return Status;
2711 }
2712 Status = ExportFontPackages (
2713 Private,
2714 Handle,
2715 PackageList,
2716 *UsedSize,
2717 BufferSize,
2718 (VOID *) ((UINT8 *) Buffer + ResultSize),
2719 &ResultSize
2720 );
2721 if (EFI_ERROR (Status)) {
2722 return Status;
2723 }
2724 Status = ExportImagePackages (
2725 Private,
2726 Handle,
2727 PackageList,
2728 *UsedSize,
2729 BufferSize,
2730 (VOID *) ((UINT8 *) Buffer + ResultSize),
2731 &ResultSize
2732 );
2733 if (EFI_ERROR (Status)) {
2734 return Status;
2735 }
2736 Status = ExportSimpleFontPackages (
2737 Private,
2738 Handle,
2739 PackageList,
2740 *UsedSize,
2741 BufferSize,
2742 (VOID *) ((UINT8 *) Buffer + ResultSize),
2743 &ResultSize
2744 );
2745 if (EFI_ERROR (Status)) {
2746 return Status;
2747 }
2748 Status = ExportDevicePathPackage (
2749 Private,
2750 Handle,
2751 PackageList,
2752 *UsedSize,
2753 BufferSize,
2754 (VOID *) ((UINT8 *) Buffer + ResultSize),
2755 &ResultSize
2756 );
2757 if (EFI_ERROR (Status)) {
2758 return Status;
2759 }
2760 //
2761 // Append the package list end.
2762 //
2763 EndofPackageList.Length = sizeof (EFI_HII_PACKAGE_HEADER);
2764 EndofPackageList.Type = EFI_HII_PACKAGE_END;
2765 if (ResultSize + *UsedSize + sizeof (EFI_HII_PACKAGE_HEADER) <= BufferSize) {
2766 CopyMem (
2767 (VOID *) ((UINT8 *) Buffer + ResultSize),
2768 (VOID *) &EndofPackageList,
2769 sizeof (EFI_HII_PACKAGE_HEADER)
2770 );
2771 }
2772
2773 *UsedSize += ResultSize + sizeof (EFI_HII_PACKAGE_HEADER);
2774
2775 return EFI_SUCCESS;
2776 }
2777
2778
2779 /**
2780 This function adds the packages in the package list to the database and returns a handle. If there is a
2781 EFI_DEVICE_PATH_PROTOCOL associated with the DriverHandle, then this function will
2782 create a package of type EFI_PACKAGE_TYPE_DEVICE_PATH and add it to the package list.
2783
2784 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
2785 instance.
2786 @param PackageList A pointer to an EFI_HII_PACKAGE_LIST_HEADER
2787 structure.
2788 @param DriverHandle Associate the package list with this EFI handle.
2789 If a NULL is specified, this data will not be associate
2790 with any drivers and cannot have a callback induced.
2791 @param Handle A pointer to the EFI_HII_HANDLE instance.
2792
2793 @retval EFI_SUCCESS The package list associated with the Handle was
2794 added to the HII database.
2795 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary resources for the new
2796 database contents.
2797 @retval EFI_INVALID_PARAMETER PackageList is NULL or Handle is NULL.
2798 @retval EFI_INVALID_PARAMETER PackageListGuid already exists in database.
2799
2800 **/
2801 EFI_STATUS
2802 EFIAPI
2803 HiiNewPackageList (
2804 IN CONST EFI_HII_DATABASE_PROTOCOL *This,
2805 IN CONST EFI_HII_PACKAGE_LIST_HEADER *PackageList,
2806 IN CONST EFI_HANDLE DriverHandle, OPTIONAL
2807 OUT EFI_HII_HANDLE *Handle
2808 )
2809 {
2810 EFI_STATUS Status;
2811 HII_DATABASE_PRIVATE_DATA *Private;
2812 HII_DATABASE_RECORD *DatabaseRecord;
2813 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
2814 LIST_ENTRY *Link;
2815 EFI_GUID PackageListGuid;
2816
2817 if (This == NULL || PackageList == NULL || Handle == NULL) {
2818 return EFI_INVALID_PARAMETER;
2819 }
2820
2821 Private = HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
2822 CopyMem (&PackageListGuid, (VOID *) PackageList, sizeof (EFI_GUID));
2823
2824 //
2825 // Check the Package list GUID to guarantee this GUID is unique in database.
2826 //
2827 for (Link = Private->DatabaseList.ForwardLink; Link != &Private->DatabaseList; Link = Link->ForwardLink) {
2828 DatabaseRecord = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
2829 if (CompareGuid (
2830 &(DatabaseRecord->PackageList->PackageListHdr.PackageListGuid),
2831 &PackageListGuid) &&
2832 DatabaseRecord->DriverHandle == DriverHandle) {
2833 return EFI_INVALID_PARAMETER;
2834 }
2835 }
2836
2837 //
2838 // Build a PackageList node
2839 //
2840 Status = GenerateHiiDatabaseRecord (Private, &DatabaseRecord);
2841 if (EFI_ERROR (Status)) {
2842 return Status;
2843 }
2844
2845 //
2846 // Fill in information of the created Package List node
2847 // according to incoming package list.
2848 //
2849 Status = AddPackages (Private, EFI_HII_DATABASE_NOTIFY_NEW_PACK, PackageList, DatabaseRecord);
2850 if (EFI_ERROR (Status)) {
2851 return Status;
2852 }
2853
2854 DatabaseRecord->DriverHandle = DriverHandle;
2855
2856 //
2857 // Create a Device path package and add into the package list if exists.
2858 //
2859 Status = gBS->HandleProtocol (
2860 DriverHandle,
2861 &gEfiDevicePathProtocolGuid,
2862 (VOID **) &DevicePath
2863 );
2864 if (!EFI_ERROR (Status)) {
2865 Status = AddDevicePathPackage (Private, EFI_HII_DATABASE_NOTIFY_NEW_PACK, DevicePath, DatabaseRecord);
2866 ASSERT_EFI_ERROR (Status);
2867 }
2868
2869 *Handle = DatabaseRecord->Handle;
2870 return EFI_SUCCESS;
2871 }
2872
2873
2874 /**
2875 This function removes the package list that is associated with a handle Handle
2876 from the HII database. Before removing the package, any registered functions
2877 with the notification type REMOVE_PACK and the same package type will be called.
2878
2879 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
2880 instance.
2881 @param Handle The handle that was registered to the data that is
2882 requested for removal.
2883
2884 @retval EFI_SUCCESS The data associated with the Handle was removed
2885 from the HII database.
2886 @retval EFI_NOT_FOUND The specified andle is not in database.
2887 @retval EFI_INVALID_PARAMETER The Handle was not valid.
2888
2889 **/
2890 EFI_STATUS
2891 EFIAPI
2892 HiiRemovePackageList (
2893 IN CONST EFI_HII_DATABASE_PROTOCOL *This,
2894 IN EFI_HII_HANDLE Handle
2895 )
2896 {
2897 EFI_STATUS Status;
2898 HII_DATABASE_PRIVATE_DATA *Private;
2899 LIST_ENTRY *Link;
2900 HII_DATABASE_RECORD *Node;
2901 HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList;
2902 HII_HANDLE *HiiHandle;
2903
2904 if (This == NULL) {
2905 return EFI_INVALID_PARAMETER;
2906 }
2907
2908 if (!IsHiiHandleValid (Handle)) {
2909 return EFI_NOT_FOUND;
2910 }
2911
2912 Private = HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
2913
2914 //
2915 // Get the packagelist to be removed.
2916 //
2917 for (Link = Private->DatabaseList.ForwardLink; Link != &Private->DatabaseList; Link = Link->ForwardLink) {
2918 Node = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
2919 if (Node->Handle == Handle) {
2920 PackageList = (HII_DATABASE_PACKAGE_LIST_INSTANCE *) (Node->PackageList);
2921 ASSERT (PackageList != NULL);
2922
2923 //
2924 // Call registered functions with REMOVE_PACK before removing packages
2925 // then remove them.
2926 //
2927 Status = RemoveGuidPackages (Private, Handle, PackageList);
2928 if (EFI_ERROR (Status)) {
2929 return Status;
2930 }
2931 Status = RemoveFormPackages (Private, Handle, PackageList);
2932 if (EFI_ERROR (Status)) {
2933 return Status;
2934 }
2935 Status = RemoveKeyboardLayoutPackages (Private, Handle, PackageList);
2936 if (EFI_ERROR (Status)) {
2937 return Status;
2938 }
2939 Status = RemoveStringPackages (Private, Handle, PackageList);
2940 if (EFI_ERROR (Status)) {
2941 return Status;
2942 }
2943 Status = RemoveFontPackages (Private, Handle, PackageList);
2944 if (EFI_ERROR (Status)) {
2945 return Status;
2946 }
2947 Status = RemoveImagePackages (Private, Handle, PackageList);
2948 if (EFI_ERROR (Status)) {
2949 return Status;
2950 }
2951 Status = RemoveSimpleFontPackages (Private, Handle, PackageList);
2952 if (EFI_ERROR (Status)) {
2953 return Status;
2954 }
2955 Status = RemoveDevicePathPackage (Private, Handle, PackageList);
2956 if (EFI_ERROR (Status)) {
2957 return Status;
2958 }
2959
2960 //
2961 // Free resources of the package list
2962 //
2963 RemoveEntryList (&Node->DatabaseEntry);
2964
2965 HiiHandle = (HII_HANDLE *) Handle;
2966 RemoveEntryList (&HiiHandle->Handle);
2967 Private->HiiHandleCount--;
2968 ASSERT (Private->HiiHandleCount >= 0);
2969
2970 HiiHandle->Signature = 0;
2971 FreePool (HiiHandle);
2972 FreePool (Node->PackageList);
2973 FreePool (Node);
2974
2975 return EFI_SUCCESS;
2976 }
2977 }
2978
2979 return EFI_NOT_FOUND;
2980 }
2981
2982
2983 /**
2984 This function updates the existing package list (which has the specified Handle)
2985 in the HII databases, using the new package list specified by PackageList.
2986
2987 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
2988 instance.
2989 @param Handle The handle that was registered to the data that is
2990 requested to be updated.
2991 @param PackageList A pointer to an EFI_HII_PACKAGE_LIST_HEADER
2992 package.
2993
2994 @retval EFI_SUCCESS The HII database was successfully updated.
2995 @retval EFI_OUT_OF_RESOURCES Unable to allocate enough memory for the updated
2996 database.
2997 @retval EFI_INVALID_PARAMETER PackageList was NULL.
2998 @retval EFI_NOT_FOUND The specified Handle is not in database.
2999
3000 **/
3001 EFI_STATUS
3002 EFIAPI
3003 HiiUpdatePackageList (
3004 IN CONST EFI_HII_DATABASE_PROTOCOL *This,
3005 IN EFI_HII_HANDLE Handle,
3006 IN CONST EFI_HII_PACKAGE_LIST_HEADER *PackageList
3007 )
3008 {
3009 EFI_STATUS Status;
3010 HII_DATABASE_PRIVATE_DATA *Private;
3011 LIST_ENTRY *Link;
3012 HII_DATABASE_RECORD *Node;
3013 EFI_HII_PACKAGE_HEADER *PackageHdrPtr;
3014 HII_DATABASE_PACKAGE_LIST_INSTANCE *OldPackageList;
3015 EFI_HII_PACKAGE_HEADER PackageHeader;
3016
3017 if (This == NULL || PackageList == NULL) {
3018 return EFI_INVALID_PARAMETER;
3019 }
3020
3021 if (!IsHiiHandleValid (Handle)) {
3022 return EFI_NOT_FOUND;
3023 }
3024
3025 Private = HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
3026
3027 PackageHdrPtr = (EFI_HII_PACKAGE_HEADER *) ((UINT8 *) PackageList + sizeof (EFI_HII_PACKAGE_LIST_HEADER));
3028
3029 Status = EFI_SUCCESS;
3030
3031 //
3032 // Get original packagelist to be updated
3033 //
3034 for (Link = Private->DatabaseList.ForwardLink; Link != &Private->DatabaseList; Link = Link->ForwardLink) {
3035 Node = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
3036 if (Node->Handle == Handle) {
3037 OldPackageList = Node->PackageList;
3038 //
3039 // Remove the package if its type matches one of the package types which is
3040 // contained in the new package list.
3041 //
3042 CopyMem (&PackageHeader, PackageHdrPtr, sizeof (EFI_HII_PACKAGE_HEADER));
3043 while (PackageHeader.Type != EFI_HII_PACKAGE_END) {
3044 switch (PackageHeader.Type) {
3045 case EFI_HII_PACKAGE_TYPE_GUID:
3046 Status = RemoveGuidPackages (Private, Handle, OldPackageList);
3047 break;
3048 case EFI_HII_PACKAGE_FORMS:
3049 Status = RemoveFormPackages (Private, Handle, OldPackageList);
3050 break;
3051 case EFI_HII_PACKAGE_KEYBOARD_LAYOUT:
3052 Status = RemoveKeyboardLayoutPackages (Private, Handle, OldPackageList);
3053 break;
3054 case EFI_HII_PACKAGE_STRINGS:
3055 Status = RemoveStringPackages (Private, Handle, OldPackageList);
3056 break;
3057 case EFI_HII_PACKAGE_FONTS:
3058 Status = RemoveFontPackages (Private, Handle, OldPackageList);
3059 break;
3060 case EFI_HII_PACKAGE_IMAGES:
3061 Status = RemoveImagePackages (Private, Handle, OldPackageList);
3062 break;
3063 case EFI_HII_PACKAGE_SIMPLE_FONTS:
3064 Status = RemoveSimpleFontPackages (Private, Handle, OldPackageList);
3065 break;
3066 case EFI_HII_PACKAGE_DEVICE_PATH:
3067 Status = RemoveDevicePathPackage (Private, Handle, OldPackageList);
3068 break;
3069 }
3070
3071 if (EFI_ERROR (Status)) {
3072 return Status;
3073 }
3074
3075 PackageHdrPtr = (EFI_HII_PACKAGE_HEADER *) ((UINT8 *) PackageHdrPtr + PackageHeader.Length);
3076 CopyMem (&PackageHeader, PackageHdrPtr, sizeof (EFI_HII_PACKAGE_HEADER));
3077 }
3078
3079 //
3080 // Add all of the packages within the new package list
3081 //
3082 return AddPackages (Private, EFI_HII_DATABASE_NOTIFY_ADD_PACK, PackageList, Node);
3083 }
3084 }
3085
3086 return EFI_NOT_FOUND;
3087 }
3088
3089
3090 /**
3091 This function returns a list of the package handles of the specified type
3092 that are currently active in the database. The pseudo-type
3093 EFI_HII_PACKAGE_TYPE_ALL will cause all package handles to be listed.
3094
3095 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
3096 instance.
3097 @param PackageType Specifies the package type of the packages to list
3098 or EFI_HII_PACKAGE_TYPE_ALL for all packages to be
3099 listed.
3100 @param PackageGuid If PackageType is EFI_HII_PACKAGE_TYPE_GUID, then
3101 this is the pointer to the GUID which must match
3102 the Guid field of EFI_HII_GUID_PACKAGE_GUID_HDR.
3103 Otherwise, it must be NULL.
3104 @param HandleBufferLength On input, a pointer to the length of the handle
3105 buffer. On output, the length of the handle
3106 buffer that is required for the handles found.
3107 @param Handle An array of EFI_HII_HANDLE instances returned.
3108
3109 @retval EFI_SUCCESS The matching handles are outputed successfully.
3110 HandleBufferLength is updated with the actual length.
3111 @retval EFI_BUFFER_TO_SMALL The HandleBufferLength parameter indicates that
3112 Handle is too small to support the number of
3113 handles. HandleBufferLength is updated with a
3114 value that will enable the data to fit.
3115 @retval EFI_NOT_FOUND No matching handle could not be found in database.
3116 @retval EFI_INVALID_PARAMETER HandleBufferLength was NULL.
3117 @retval EFI_INVALID_PARAMETER The value referenced by HandleBufferLength was not
3118 zero and Handle was NULL.
3119 @retval EFI_INVALID_PARAMETER PackageType is not a EFI_HII_PACKAGE_TYPE_GUID but
3120 PackageGuid is not NULL, PackageType is a EFI_HII_
3121 PACKAGE_TYPE_GUID but PackageGuid is NULL.
3122
3123 **/
3124 EFI_STATUS
3125 EFIAPI
3126 HiiListPackageLists (
3127 IN CONST EFI_HII_DATABASE_PROTOCOL *This,
3128 IN UINT8 PackageType,
3129 IN CONST EFI_GUID *PackageGuid,
3130 IN OUT UINTN *HandleBufferLength,
3131 OUT EFI_HII_HANDLE *Handle
3132 )
3133 {
3134 HII_GUID_PACKAGE_INSTANCE *GuidPackage;
3135 HII_DATABASE_PRIVATE_DATA *Private;
3136 HII_DATABASE_RECORD *Node;
3137 LIST_ENTRY *Link;
3138 BOOLEAN Matched;
3139 HII_HANDLE **Result;
3140 UINTN ResultSize;
3141 HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList;
3142 LIST_ENTRY *Link1;
3143
3144 //
3145 // Check input parameters
3146 //
3147 if (This == NULL || HandleBufferLength == NULL) {
3148 return EFI_INVALID_PARAMETER;
3149 }
3150 if (*HandleBufferLength > 0 && Handle == NULL) {
3151 return EFI_INVALID_PARAMETER;
3152 }
3153 if ((PackageType == EFI_HII_PACKAGE_TYPE_GUID && PackageGuid == NULL) ||
3154 (PackageType != EFI_HII_PACKAGE_TYPE_GUID && PackageGuid != NULL)) {
3155 return EFI_INVALID_PARAMETER;
3156 }
3157
3158 Private = HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
3159 Matched = FALSE;
3160 Result = (HII_HANDLE **) Handle;
3161 ResultSize = 0;
3162
3163 for (Link = Private->DatabaseList.ForwardLink; Link != &Private->DatabaseList; Link = Link->ForwardLink) {
3164 Node = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
3165 PackageList = (HII_DATABASE_PACKAGE_LIST_INSTANCE *) (Node->PackageList);
3166 switch (PackageType) {
3167 case EFI_HII_PACKAGE_TYPE_GUID:
3168 for (Link1 = PackageList->GuidPkgHdr.ForwardLink; Link1 != &PackageList->GuidPkgHdr; Link1 = Link1->ForwardLink) {
3169 GuidPackage = CR (Link1, HII_GUID_PACKAGE_INSTANCE, GuidEntry, HII_GUID_PACKAGE_SIGNATURE);
3170 if (CompareGuid (
3171 (EFI_GUID *) PackageGuid,
3172 (EFI_GUID *) (GuidPackage->GuidPkg + sizeof (EFI_HII_PACKAGE_HEADER))
3173 )) {
3174 Matched = TRUE;
3175 break;
3176 }
3177 }
3178 break;
3179 case EFI_HII_PACKAGE_FORMS:
3180 if (!IsListEmpty (&PackageList->FormPkgHdr)) {
3181 Matched = TRUE;
3182 }
3183 break;
3184 case EFI_HII_PACKAGE_KEYBOARD_LAYOUT:
3185 if (!IsListEmpty (&PackageList->KeyboardLayoutHdr)) {
3186 Matched = TRUE;
3187 }
3188 break;
3189 case EFI_HII_PACKAGE_STRINGS:
3190 if (!IsListEmpty (&PackageList->StringPkgHdr)) {
3191 Matched = TRUE;
3192 }
3193 break;
3194 case EFI_HII_PACKAGE_FONTS:
3195 if (!IsListEmpty (&PackageList->FontPkgHdr)) {
3196 Matched = TRUE;
3197 }
3198 break;
3199 case EFI_HII_PACKAGE_IMAGES:
3200 if (PackageList->ImagePkg != NULL) {
3201 Matched = TRUE;
3202 }
3203 break;
3204 case EFI_HII_PACKAGE_SIMPLE_FONTS:
3205 if (!IsListEmpty (&PackageList->SimpleFontPkgHdr)) {
3206 Matched = TRUE;
3207 }
3208 break;
3209 case EFI_HII_PACKAGE_DEVICE_PATH:
3210 if (PackageList->DevicePathPkg != NULL) {
3211 Matched = TRUE;
3212 }
3213 break;
3214 //
3215 // Pesudo-type EFI_HII_PACKAGE_TYPE_ALL will cause all package handles
3216 // to be listed.
3217 //
3218 case EFI_HII_PACKAGE_TYPE_ALL:
3219 Matched = TRUE;
3220 break;
3221 default:
3222 break;
3223 }
3224
3225 //
3226 // This active package list has the specified package type, list it.
3227 //
3228 if (Matched) {
3229 ResultSize += sizeof (EFI_HII_HANDLE);
3230 if (ResultSize <= *HandleBufferLength) {
3231 *Result++ = Node->Handle;
3232 }
3233 }
3234 Matched = FALSE;
3235 }
3236
3237 if (ResultSize == 0) {
3238 return EFI_NOT_FOUND;
3239 }
3240
3241 if (*HandleBufferLength < ResultSize) {
3242 *HandleBufferLength = ResultSize;
3243 return EFI_BUFFER_TOO_SMALL;
3244 }
3245
3246 *HandleBufferLength = ResultSize;
3247 return EFI_SUCCESS;
3248 }
3249
3250
3251 /**
3252 This function will export one or all package lists in the database to a buffer.
3253 For each package list exported, this function will call functions registered
3254 with EXPORT_PACK and then copy the package list to the buffer.
3255
3256 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
3257 instance.
3258 @param Handle An EFI_HII_HANDLE that corresponds to the desired
3259 package list in the HII database to export or NULL
3260 to indicate all package lists should be exported.
3261 @param BufferSize On input, a pointer to the length of the buffer.
3262 On output, the length of the buffer that is
3263 required for the exported data.
3264 @param Buffer A pointer to a buffer that will contain the
3265 results of the export function.
3266
3267 @retval EFI_SUCCESS Package exported.
3268 @retval EFI_BUFFER_TO_SMALL The HandleBufferLength parameter indicates that
3269 Handle is too small to support the number of
3270 handles. HandleBufferLength is updated with a
3271 value that will enable the data to fit.
3272 @retval EFI_NOT_FOUND The specifiecd Handle could not be found in the
3273 current database.
3274 @retval EFI_INVALID_PARAMETER BufferSize was NULL.
3275 @retval EFI_INVALID_PARAMETER The value referenced by BufferSize was not zero
3276 and Buffer was NULL.
3277
3278 **/
3279 EFI_STATUS
3280 EFIAPI
3281 HiiExportPackageLists (
3282 IN CONST EFI_HII_DATABASE_PROTOCOL *This,
3283 IN EFI_HII_HANDLE Handle,
3284 IN OUT UINTN *BufferSize,
3285 OUT EFI_HII_PACKAGE_LIST_HEADER *Buffer
3286 )
3287 {
3288 LIST_ENTRY *Link;
3289 EFI_STATUS Status;
3290 HII_DATABASE_PRIVATE_DATA *Private;
3291 HII_DATABASE_RECORD *Node;
3292 UINTN UsedSize;
3293
3294 if (This == NULL || BufferSize == NULL) {
3295 return EFI_INVALID_PARAMETER;
3296 }
3297 if (*BufferSize > 0 && Buffer == NULL) {
3298 return EFI_INVALID_PARAMETER;
3299 }
3300 if ((Handle != NULL) && (!IsHiiHandleValid (Handle))) {
3301 return EFI_NOT_FOUND;
3302 }
3303
3304 Private = HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
3305 UsedSize = 0;
3306
3307 for (Link = Private->DatabaseList.ForwardLink; Link != &Private->DatabaseList; Link = Link->ForwardLink) {
3308 Node = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
3309 if (Handle == NULL) {
3310 //
3311 // Export all package lists in current hii database.
3312 //
3313 Status = ExportPackageList (
3314 Private,
3315 Node->Handle,
3316 (HII_DATABASE_PACKAGE_LIST_INSTANCE *) (Node->PackageList),
3317 &UsedSize,
3318 *BufferSize,
3319 (EFI_HII_PACKAGE_LIST_HEADER *)((UINT8 *) Buffer + UsedSize)
3320 );
3321 ASSERT_EFI_ERROR (Status);
3322 } else if (Handle != NULL && Node->Handle == Handle) {
3323 Status = ExportPackageList (
3324 Private,
3325 Handle,
3326 (HII_DATABASE_PACKAGE_LIST_INSTANCE *) (Node->PackageList),
3327 &UsedSize,
3328 *BufferSize,
3329 Buffer
3330 );
3331 ASSERT_EFI_ERROR (Status);
3332 if (*BufferSize < UsedSize) {
3333 *BufferSize = UsedSize;
3334 return EFI_BUFFER_TOO_SMALL;
3335 }
3336 return EFI_SUCCESS;
3337 }
3338 }
3339
3340 if (Handle == NULL && UsedSize != 0) {
3341 if (*BufferSize < UsedSize) {
3342 *BufferSize = UsedSize;
3343 return EFI_BUFFER_TOO_SMALL;
3344 }
3345 return EFI_SUCCESS;
3346 }
3347
3348 return EFI_NOT_FOUND;
3349 }
3350
3351
3352 /**
3353 This function registers a function which will be called when specified actions related to packages of
3354 the specified type occur in the HII database. By registering a function, other HII-related drivers are
3355 notified when specific package types are added, removed or updated in the HII database.
3356 Each driver or application which registers a notification should use
3357 EFI_HII_DATABASE_PROTOCOL.UnregisterPackageNotify() before exiting.
3358
3359 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
3360 instance.
3361 @param PackageType Specifies the package type of the packages to list
3362 or EFI_HII_PACKAGE_TYPE_ALL for all packages to be
3363 listed.
3364 @param PackageGuid If PackageType is EFI_HII_PACKAGE_TYPE_GUID, then
3365 this is the pointer to the GUID which must match
3366 the Guid field of
3367 EFI_HII_GUID_PACKAGE_GUID_HDR. Otherwise, it must
3368 be NULL.
3369 @param PackageNotifyFn Points to the function to be called when the event
3370 specified by
3371 NotificationType occurs.
3372 @param NotifyType Describes the types of notification which this
3373 function will be receiving.
3374 @param NotifyHandle Points to the unique handle assigned to the
3375 registered notification. Can be used in
3376 EFI_HII_DATABASE_PROTOCOL.UnregisterPackageNotify()
3377 to stop notifications.
3378
3379 @retval EFI_SUCCESS Notification registered successfully.
3380 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary data structures
3381 @retval EFI_INVALID_PARAMETER NotifyHandle is NULL.
3382 @retval EFI_INVALID_PARAMETER PackageGuid is not NULL when PackageType is not
3383 EFI_HII_PACKAGE_TYPE_GUID.
3384 @retval EFI_INVALID_PARAMETER PackageGuid is NULL when PackageType is
3385 EFI_HII_PACKAGE_TYPE_GUID.
3386
3387 **/
3388 EFI_STATUS
3389 EFIAPI
3390 HiiRegisterPackageNotify (
3391 IN CONST EFI_HII_DATABASE_PROTOCOL *This,
3392 IN UINT8 PackageType,
3393 IN CONST EFI_GUID *PackageGuid,
3394 IN CONST EFI_HII_DATABASE_NOTIFY PackageNotifyFn,
3395 IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType,
3396 OUT EFI_HANDLE *NotifyHandle
3397 )
3398 {
3399 HII_DATABASE_PRIVATE_DATA *Private;
3400 HII_DATABASE_NOTIFY *Notify;
3401 EFI_STATUS Status;
3402
3403 if (This == NULL || NotifyHandle == NULL) {
3404 return EFI_INVALID_PARAMETER;
3405 }
3406 if ((PackageType == EFI_HII_PACKAGE_TYPE_GUID && PackageGuid == NULL) ||
3407 (PackageType != EFI_HII_PACKAGE_TYPE_GUID && PackageGuid != NULL)) {
3408 return EFI_INVALID_PARAMETER;
3409 }
3410
3411 Private = HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
3412
3413 //
3414 // Allocate a notification node
3415 //
3416 Notify = (HII_DATABASE_NOTIFY *) AllocateZeroPool (sizeof (HII_DATABASE_NOTIFY));
3417 if (Notify == NULL) {
3418 return EFI_OUT_OF_RESOURCES;
3419 }
3420
3421 //
3422 // Generate a notify handle
3423 //
3424 Status = gBS->InstallMultipleProtocolInterfaces (
3425 &Notify->NotifyHandle,
3426 &gEfiCallerIdGuid,
3427 NULL,
3428 NULL
3429 );
3430 ASSERT_EFI_ERROR (Status);
3431
3432 //
3433 // Fill in the information to the notification node
3434 //
3435 Notify->Signature = HII_DATABASE_NOTIFY_SIGNATURE;
3436 Notify->PackageType = PackageType;
3437 Notify->PackageGuid = (EFI_GUID *) PackageGuid;
3438 Notify->PackageNotifyFn = (EFI_HII_DATABASE_NOTIFY) PackageNotifyFn;
3439 Notify->NotifyType = NotifyType;
3440
3441 InsertTailList (&Private->DatabaseNotifyList, &Notify->DatabaseNotifyEntry);
3442 *NotifyHandle = Notify->NotifyHandle;
3443
3444 return EFI_SUCCESS;
3445 }
3446
3447
3448 /**
3449 Removes the specified HII database package-related notification.
3450
3451 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
3452 instance.
3453 @param NotificationHandle The handle of the notification function being
3454 unregistered.
3455
3456 @retval EFI_SUCCESS Notification is unregistered successfully.
3457 @retval EFI_INVALID_PARAMETER The Handle is invalid.
3458 @retval EFI_NOT_FOUND The incoming notification handle does not exist
3459 in current hii database.
3460
3461 **/
3462 EFI_STATUS
3463 EFIAPI
3464 HiiUnregisterPackageNotify (
3465 IN CONST EFI_HII_DATABASE_PROTOCOL *This,
3466 IN EFI_HANDLE NotificationHandle
3467 )
3468 {
3469 HII_DATABASE_PRIVATE_DATA *Private;
3470 HII_DATABASE_NOTIFY *Notify;
3471 LIST_ENTRY *Link;
3472 EFI_STATUS Status;
3473
3474 if (This == NULL) {
3475 return EFI_INVALID_PARAMETER;
3476 }
3477
3478 if (NotificationHandle == NULL) {
3479 return EFI_NOT_FOUND;
3480 }
3481
3482 Status = gBS->OpenProtocol (
3483 NotificationHandle,
3484 &gEfiCallerIdGuid,
3485 NULL,
3486 NULL,
3487 NULL,
3488 EFI_OPEN_PROTOCOL_TEST_PROTOCOL
3489 );
3490 if (EFI_ERROR (Status)) {
3491 return EFI_NOT_FOUND;
3492 }
3493
3494 Private = HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
3495
3496 for (Link = Private->DatabaseNotifyList.ForwardLink; Link != &Private->DatabaseNotifyList; Link = Link->ForwardLink) {
3497 Notify = CR (Link, HII_DATABASE_NOTIFY, DatabaseNotifyEntry, HII_DATABASE_NOTIFY_SIGNATURE);
3498 if (Notify->NotifyHandle == NotificationHandle) {
3499 //
3500 // Remove the matching notification node
3501 //
3502 RemoveEntryList (&Notify->DatabaseNotifyEntry);
3503 Status = gBS->UninstallMultipleProtocolInterfaces (
3504 Notify->NotifyHandle,
3505 &gEfiCallerIdGuid,
3506 NULL,
3507 NULL
3508 );
3509 ASSERT_EFI_ERROR (Status);
3510 FreePool (Notify);
3511
3512 return EFI_SUCCESS;
3513 }
3514 }
3515
3516 return EFI_NOT_FOUND;
3517 }
3518
3519
3520 /**
3521 This routine retrieves an array of GUID values for each keyboard layout that
3522 was previously registered in the system.
3523
3524 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
3525 instance.
3526 @param KeyGuidBufferLength On input, a pointer to the length of the keyboard
3527 GUID buffer. On output, the length of the handle
3528 buffer that is required for the handles found.
3529 @param KeyGuidBuffer An array of keyboard layout GUID instances
3530 returned.
3531
3532 @retval EFI_SUCCESS KeyGuidBuffer was updated successfully.
3533 @retval EFI_BUFFER_TOO_SMALL The KeyGuidBufferLength parameter indicates
3534 that KeyGuidBuffer is too small to support the
3535 number of GUIDs. KeyGuidBufferLength is
3536 updated with a value that will enable the data to
3537 fit.
3538 @retval EFI_INVALID_PARAMETER The KeyGuidBufferLength is NULL.
3539 @retval EFI_INVALID_PARAMETER The value referenced by KeyGuidBufferLength is not
3540 zero and KeyGuidBuffer is NULL.
3541 @retval EFI_NOT_FOUND There was no keyboard layout.
3542
3543 **/
3544 EFI_STATUS
3545 EFIAPI
3546 HiiFindKeyboardLayouts (
3547 IN CONST EFI_HII_DATABASE_PROTOCOL *This,
3548 IN OUT UINT16 *KeyGuidBufferLength,
3549 OUT EFI_GUID *KeyGuidBuffer
3550 )
3551 {
3552 HII_DATABASE_PRIVATE_DATA *Private;
3553 HII_DATABASE_RECORD *Node;
3554 HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList;
3555 LIST_ENTRY *Link;
3556 LIST_ENTRY *Link1;
3557 UINT16 ResultSize;
3558 UINTN Index;
3559 UINT16 LayoutCount;
3560 UINT16 LayoutLength;
3561 UINT8 *Layout;
3562 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE *Package;
3563
3564 if (This == NULL || KeyGuidBufferLength == NULL) {
3565 return EFI_INVALID_PARAMETER;
3566 }
3567
3568 if (*KeyGuidBufferLength > 0 && KeyGuidBuffer == NULL) {
3569 return EFI_INVALID_PARAMETER;
3570 }
3571
3572 Private = HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
3573 ResultSize = 0;
3574
3575 //
3576 // Search all package lists in whole database to retrieve keyboard layout.
3577 //
3578 for (Link = Private->DatabaseList.ForwardLink; Link != &Private->DatabaseList; Link = Link->ForwardLink) {
3579 Node = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
3580 PackageList = Node->PackageList;
3581 for (Link1 = PackageList->KeyboardLayoutHdr.ForwardLink;
3582 Link1 != &PackageList->KeyboardLayoutHdr;
3583 Link1 = Link1->ForwardLink
3584 ) {
3585 //
3586 // Find out all Keyboard Layout packages in this package list.
3587 //
3588 Package = CR (
3589 Link1,
3590 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE,
3591 KeyboardEntry,
3592 HII_KB_LAYOUT_PACKAGE_SIGNATURE
3593 );
3594 Layout = (UINT8 *) Package->KeyboardPkg + sizeof (EFI_HII_PACKAGE_HEADER) + sizeof (UINT16);
3595 CopyMem (
3596 &LayoutCount,
3597 (UINT8 *) Package->KeyboardPkg + sizeof (EFI_HII_PACKAGE_HEADER),
3598 sizeof (UINT16)
3599 );
3600 for (Index = 0; Index < LayoutCount; Index++) {
3601 ResultSize += sizeof (EFI_GUID);
3602 if (ResultSize <= *KeyGuidBufferLength) {
3603 CopyMem (KeyGuidBuffer + (ResultSize / sizeof (EFI_GUID) - 1), Layout + sizeof (UINT16), sizeof (EFI_GUID));
3604 CopyMem (&LayoutLength, Layout, sizeof (UINT16));
3605 Layout = Layout + LayoutLength;
3606 }
3607 }
3608 }
3609 }
3610
3611 if (ResultSize == 0) {
3612 return EFI_NOT_FOUND;
3613 }
3614
3615 if (*KeyGuidBufferLength < ResultSize) {
3616 *KeyGuidBufferLength = ResultSize;
3617 return EFI_BUFFER_TOO_SMALL;
3618 }
3619
3620 *KeyGuidBufferLength = ResultSize;
3621 return EFI_SUCCESS;
3622 }
3623
3624
3625 /**
3626 This routine retrieves the requested keyboard layout. The layout is a physical description of the keys
3627 on a keyboard and the character(s) that are associated with a particular set of key strokes.
3628
3629 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
3630 instance.
3631 @param KeyGuid A pointer to the unique ID associated with a given
3632 keyboard layout. If KeyGuid is NULL then the
3633 current layout will be retrieved.
3634 @param KeyboardLayoutLength On input, a pointer to the length of the
3635 KeyboardLayout buffer. On output, the length of
3636 the data placed into KeyboardLayout.
3637 @param KeyboardLayout A pointer to a buffer containing the retrieved
3638 keyboard layout.
3639
3640 @retval EFI_SUCCESS The keyboard layout was retrieved successfully.
3641 @retval EFI_NOT_FOUND The requested keyboard layout was not found.
3642 @retval EFI_INVALID_PARAMETER The KeyboardLayout or KeyboardLayoutLength was
3643 NULL.
3644 @retval EFI_BUFFER_TOO_SMALL The KeyboardLayoutLength parameter indicates
3645 that KeyboardLayout is too small to support the
3646 requested keyboard layout. KeyboardLayoutLength is
3647 updated with a value that will enable the
3648 data to fit.
3649
3650 **/
3651 EFI_STATUS
3652 EFIAPI
3653 HiiGetKeyboardLayout (
3654 IN CONST EFI_HII_DATABASE_PROTOCOL *This,
3655 IN CONST EFI_GUID *KeyGuid,
3656 IN OUT UINT16 *KeyboardLayoutLength,
3657 OUT EFI_HII_KEYBOARD_LAYOUT *KeyboardLayout
3658 )
3659 {
3660 HII_DATABASE_PRIVATE_DATA *Private;
3661 HII_DATABASE_RECORD *Node;
3662 HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageList;
3663 LIST_ENTRY *Link;
3664 LIST_ENTRY *Link1;
3665 UINTN Index;
3666 UINT8 *Layout;
3667 UINT16 LayoutCount;
3668 UINT16 LayoutLength;
3669 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE *Package;
3670
3671 if (This == NULL || KeyboardLayoutLength == NULL) {
3672 return EFI_INVALID_PARAMETER;
3673 }
3674 if (*KeyboardLayoutLength > 0 && KeyboardLayout == NULL) {
3675 return EFI_INVALID_PARAMETER;
3676 }
3677
3678 Private = HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
3679 //
3680 // Retrieve the current keyboard layout.
3681 //
3682 if (KeyGuid == NULL) {
3683 if (Private->CurrentLayout == NULL) {
3684 return EFI_NOT_FOUND;
3685 }
3686 CopyMem (&LayoutLength, Private->CurrentLayout, sizeof (UINT16));
3687 if (*KeyboardLayoutLength < LayoutLength) {
3688 *KeyboardLayoutLength = LayoutLength;
3689 return EFI_BUFFER_TOO_SMALL;
3690 }
3691 CopyMem (KeyboardLayout, Private->CurrentLayout, LayoutLength);
3692 return EFI_SUCCESS;
3693 }
3694
3695 for (Link = Private->DatabaseList.ForwardLink; Link != &Private->DatabaseList; Link = Link->ForwardLink) {
3696 Node = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
3697 PackageList = (HII_DATABASE_PACKAGE_LIST_INSTANCE *) (Node->PackageList);
3698 for (Link1 = PackageList->KeyboardLayoutHdr.ForwardLink;
3699 Link1 != &PackageList->KeyboardLayoutHdr;
3700 Link1 = Link1->ForwardLink
3701 ) {
3702 Package = CR (
3703 Link1,
3704 HII_KEYBOARD_LAYOUT_PACKAGE_INSTANCE,
3705 KeyboardEntry,
3706 HII_KB_LAYOUT_PACKAGE_SIGNATURE
3707 );
3708
3709 Layout = (UINT8 *) Package->KeyboardPkg +
3710 sizeof (EFI_HII_PACKAGE_HEADER) + sizeof (UINT16);
3711 CopyMem (&LayoutCount, Layout - sizeof (UINT16), sizeof (UINT16));
3712 for (Index = 0; Index < LayoutCount; Index++) {
3713 CopyMem (&LayoutLength, Layout, sizeof (UINT16));
3714 if (CompareMem (Layout + sizeof (UINT16), KeyGuid, sizeof (EFI_GUID)) == 0) {
3715 if (LayoutLength <= *KeyboardLayoutLength) {
3716 CopyMem (KeyboardLayout, Layout, LayoutLength);
3717 return EFI_SUCCESS;
3718 } else {
3719 *KeyboardLayoutLength = LayoutLength;
3720 return EFI_BUFFER_TOO_SMALL;
3721 }
3722 }
3723 Layout = Layout + LayoutLength;
3724 }
3725 }
3726 }
3727
3728 return EFI_NOT_FOUND;
3729 }
3730
3731
3732 /**
3733 This routine sets the default keyboard layout to the one referenced by KeyGuid. When this routine
3734 is called, an event will be signaled of the EFI_HII_SET_KEYBOARD_LAYOUT_EVENT_GUID
3735 group type. This is so that agents which are sensitive to the current keyboard layout being changed
3736 can be notified of this change.
3737
3738 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
3739 instance.
3740 @param KeyGuid A pointer to the unique ID associated with a given
3741 keyboard layout.
3742
3743 @retval EFI_SUCCESS The current keyboard layout was successfully set.
3744 @retval EFI_NOT_FOUND The referenced keyboard layout was not found, so
3745 action was taken.
3746 @retval EFI_INVALID_PARAMETER The KeyGuid was NULL.
3747
3748 **/
3749 EFI_STATUS
3750 EFIAPI
3751 HiiSetKeyboardLayout (
3752 IN CONST EFI_HII_DATABASE_PROTOCOL *This,
3753 IN CONST EFI_GUID *KeyGuid
3754 )
3755 {
3756 HII_DATABASE_PRIVATE_DATA *Private;
3757 EFI_HII_KEYBOARD_LAYOUT *KeyboardLayout;
3758 UINT16 KeyboardLayoutLength;
3759 EFI_STATUS Status;
3760
3761 if (This == NULL || KeyGuid == NULL) {
3762 return EFI_INVALID_PARAMETER;
3763 }
3764
3765 Private = HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
3766
3767 //
3768 // The specified GUID equals the current keyboard layout GUID,
3769 // return directly.
3770 //
3771 if (CompareGuid (&Private->CurrentLayoutGuid, KeyGuid)) {
3772 return EFI_SUCCESS;
3773 }
3774
3775 //
3776 // Try to find the incoming keyboard layout data in current database.
3777 //
3778 KeyboardLayoutLength = 0;
3779 KeyboardLayout = NULL;
3780 Status = HiiGetKeyboardLayout (This, KeyGuid, &KeyboardLayoutLength, KeyboardLayout);
3781 if (Status != EFI_BUFFER_TOO_SMALL) {
3782 return Status;
3783 }
3784
3785 KeyboardLayout = (EFI_HII_KEYBOARD_LAYOUT *) AllocateZeroPool (KeyboardLayoutLength);
3786 ASSERT (KeyboardLayout != NULL);
3787 Status = HiiGetKeyboardLayout (This, KeyGuid, &KeyboardLayoutLength, KeyboardLayout);
3788 ASSERT_EFI_ERROR (Status);
3789
3790 //
3791 // Backup current keyboard layout.
3792 //
3793 CopyMem (&Private->CurrentLayoutGuid, KeyGuid, sizeof (EFI_GUID));
3794 if (Private->CurrentLayout != NULL) {
3795 FreePool(Private->CurrentLayout);
3796 }
3797 Private->CurrentLayout = KeyboardLayout;
3798
3799 //
3800 // Signal EFI_HII_SET_KEYBOARD_LAYOUT_EVENT_GUID group to notify
3801 // current keyboard layout is changed.
3802 //
3803 Status = gBS->SignalEvent (gHiiKeyboardLayoutChanged);
3804 ASSERT_EFI_ERROR (Status);
3805
3806 return EFI_SUCCESS;
3807 }
3808
3809
3810 /**
3811 Return the EFI handle associated with a package list.
3812
3813 @param This A pointer to the EFI_HII_DATABASE_PROTOCOL
3814 instance.
3815 @param PackageListHandle An EFI_HII_HANDLE that corresponds to the desired
3816 package list in the HIIdatabase.
3817 @param DriverHandle On return, contains the EFI_HANDLE which was
3818 registered with the package list in
3819 NewPackageList().
3820
3821 @retval EFI_SUCCESS The DriverHandle was returned successfully.
3822 @retval EFI_INVALID_PARAMETER The PackageListHandle was not valid or
3823 DriverHandle was NULL.
3824 @retval EFI_NOT_FOUND This PackageList handle can not be found in
3825 current database.
3826
3827 **/
3828 EFI_STATUS
3829 EFIAPI
3830 HiiGetPackageListHandle (
3831 IN CONST EFI_HII_DATABASE_PROTOCOL *This,
3832 IN EFI_HII_HANDLE PackageListHandle,
3833 OUT EFI_HANDLE *DriverHandle
3834 )
3835 {
3836 HII_DATABASE_PRIVATE_DATA *Private;
3837 HII_DATABASE_RECORD *Node;
3838 LIST_ENTRY *Link;
3839
3840 if (This == NULL || DriverHandle == NULL) {
3841 return EFI_INVALID_PARAMETER;
3842 }
3843
3844 if (!IsHiiHandleValid (PackageListHandle)) {
3845 return EFI_INVALID_PARAMETER;
3846 }
3847
3848 Private = HII_DATABASE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
3849
3850 for (Link = Private->DatabaseList.ForwardLink; Link != &Private->DatabaseList; Link = Link->ForwardLink) {
3851 Node = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
3852 if (Node->Handle == PackageListHandle) {
3853 *DriverHandle = Node->DriverHandle;
3854 return EFI_SUCCESS;
3855 }
3856 }
3857
3858 return EFI_NOT_FOUND;
3859 }
3860
EFI Development Kit II mirror for PVE