]> git.proxmox.com Git - mirror_edk2.git/blob - EdkCompatibilityPkg/Foundation/Library/Dxe/UefiEfiIfrSupportLib/UefiIfrForm.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add Missing invocations to VA_END() for VA_START().
[mirror_edk2.git] / EdkCompatibilityPkg / Foundation / Library / Dxe / UefiEfiIfrSupportLib / UefiIfrForm.c
1 /*++
2
3 Copyright (c) 2007 - 2012, Intel Corporation. All rights reserved.<BR>
4 This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
8
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
11
12 Module Name:
13
14 UefiIfrForm.c
15
16 Abstract:
17
18 Common Library Routines to assist handle HII elements.
19
20 --*/
21
22 #include "UefiIfrLibrary.h"
23
24 //
25 // Fake <ConfigHdr>
26 //
27 UINT16 mFakeConfigHdr[] = L"GUID=00000000000000000000000000000000&NAME=0000&PATH=0";
28
29 EFI_STATUS
30 GetPackageDataFromPackageList (
31 IN EFI_HII_PACKAGE_LIST_HEADER *HiiPackageList,
32 IN UINT32 PackageIndex,
33 OUT UINT32 *BufferLen,
34 OUT EFI_HII_PACKAGE_HEADER **Buffer
35 )
36 {
37 UINT32 Index;
38 EFI_HII_PACKAGE_HEADER *Package;
39 UINT32 Offset;
40 UINT32 PackageListLength;
41 EFI_HII_PACKAGE_HEADER PackageHeader = {0, 0};
42
43 ASSERT(HiiPackageList != NULL);
44
45 if ((BufferLen == NULL) || (Buffer == NULL)) {
46 return EFI_INVALID_PARAMETER;
47 }
48
49 Package = NULL;
50 Index = 0;
51 Offset = sizeof (EFI_HII_PACKAGE_LIST_HEADER);
52 EfiCopyMem (&PackageListLength, &HiiPackageList->PackageLength, sizeof (UINT32));
53 while (Offset < PackageListLength) {
54 Package = (EFI_HII_PACKAGE_HEADER *) (((UINT8 *) HiiPackageList) + Offset);
55 EfiCopyMem (&PackageHeader, Package, sizeof (EFI_HII_PACKAGE_HEADER));
56 if (Index == PackageIndex) {
57 break;
58 }
59 Offset += PackageHeader.Length;
60 Index++;
61 }
62 if (Offset >= PackageListLength) {
63 //
64 // no package found in this Package List
65 //
66 return EFI_NOT_FOUND;
67 }
68
69 *BufferLen = PackageHeader.Length;
70 *Buffer = Package;
71 return EFI_SUCCESS;
72 }
73
74 EFI_STATUS
75 UpdateFormPackageData (
76 IN EFI_GUID *FormSetGuid,
77 IN EFI_FORM_ID FormId,
78 IN EFI_HII_PACKAGE_HEADER *Package,
79 IN UINT32 PackageLength,
80 IN UINT16 Label,
81 IN BOOLEAN Insert,
82 IN EFI_HII_UPDATE_DATA *Data,
83 OUT UINT8 **TempBuffer,
84 OUT UINT32 *TempBufferSize
85 )
86 {
87 UINT8 *BufferPos;
88 EFI_HII_PACKAGE_HEADER PackageHeader;
89 UINT32 Offset;
90 EFI_IFR_OP_HEADER *IfrOpHdr;
91 BOOLEAN GetFormSet;
92 BOOLEAN GetForm;
93 UINT8 ExtendOpCode;
94 UINT16 LabelNumber;
95 BOOLEAN Updated;
96
97 if ((TempBuffer == NULL) || (TempBufferSize == NULL)) {
98 return EFI_INVALID_PARAMETER;
99 }
100
101 *TempBufferSize = PackageLength;
102 if (Data != NULL) {
103 *TempBufferSize += Data->Offset;
104 }
105 *TempBuffer = EfiLibAllocateZeroPool (*TempBufferSize);
106 if (*TempBuffer == NULL) {
107 return EFI_OUT_OF_RESOURCES;
108 }
109
110 EfiCopyMem (*TempBuffer, Package, sizeof (EFI_HII_PACKAGE_HEADER));
111 *TempBufferSize = sizeof (EFI_HII_PACKAGE_HEADER);
112 BufferPos = *TempBuffer + sizeof (EFI_HII_PACKAGE_HEADER);
113
114 EfiCopyMem (&PackageHeader, Package, sizeof (EFI_HII_PACKAGE_HEADER));
115 IfrOpHdr = (EFI_IFR_OP_HEADER *)((UINT8 *) Package + sizeof (EFI_HII_PACKAGE_HEADER));
116 Offset = sizeof (EFI_HII_PACKAGE_HEADER);
117 GetFormSet = (BOOLEAN)((FormSetGuid == NULL) ? TRUE : FALSE);
118 GetForm = FALSE;
119 Updated = FALSE;
120
121 while (!Updated && Offset < PackageHeader.Length) {
122 EfiCopyMem (BufferPos, IfrOpHdr, IfrOpHdr->Length);
123 BufferPos += IfrOpHdr->Length;
124 *TempBufferSize += IfrOpHdr->Length;
125
126 switch (IfrOpHdr->OpCode) {
127 case EFI_IFR_FORM_SET_OP :
128 if (FormSetGuid != NULL) {
129 if (EfiCompareMem (&((EFI_IFR_FORM_SET *) IfrOpHdr)->Guid, FormSetGuid, sizeof (EFI_GUID)) == 0) {
130 GetFormSet = TRUE;
131 } else {
132 GetFormSet = FALSE;
133 }
134 }
135 break;
136
137 case EFI_IFR_FORM_OP:
138 if (EfiCompareMem (&((EFI_IFR_FORM *) IfrOpHdr)->FormId, &FormId, sizeof (EFI_FORM_ID)) == 0) {
139 GetForm = TRUE;
140 } else {
141 GetForm = FALSE;
142 }
143 break;
144
145 case EFI_IFR_GUID_OP :
146 if (!GetFormSet || !GetForm) {
147 //
148 // Go to the next Op-Code
149 //
150 break;
151 }
152
153 if (!EfiCompareGuid (&((EFI_IFR_GUID *) IfrOpHdr)->Guid, &mIfrVendorGuid)) {
154 //
155 // GUID mismatch, skip this op-code
156 //
157 break;
158 }
159
160 ExtendOpCode = ((EFI_IFR_GUID_LABEL *) IfrOpHdr)->ExtendOpCode;
161 EfiCopyMem (&LabelNumber, &((EFI_IFR_GUID_LABEL *)IfrOpHdr)->Number, sizeof (UINT16));
162 if ((ExtendOpCode != EFI_IFR_EXTEND_OP_LABEL) || (LabelNumber != Label)) {
163 //
164 // Go to the next Op-Code
165 //
166 break;
167 }
168
169 if (Insert) {
170 //
171 // Insert data after current Label, skip myself
172 //
173 Offset += IfrOpHdr->Length;
174 IfrOpHdr = (EFI_IFR_OP_HEADER *) ((CHAR8 *) (IfrOpHdr) + IfrOpHdr->Length);
175 } else {
176 //
177 // Replace data between two paired Label, try to find the next Label.
178 //
179 while (TRUE) {
180 Offset += IfrOpHdr->Length;
181 //
182 // Search the next label and Fail if not label found.
183 //
184 if (Offset >= PackageHeader.Length) {
185 goto Fail;
186 }
187 IfrOpHdr = (EFI_IFR_OP_HEADER *) ((CHAR8 *) (IfrOpHdr) + IfrOpHdr->Length);
188 if (IfrOpHdr->OpCode == EFI_IFR_GUID_OP) {
189 ExtendOpCode = ((EFI_IFR_GUID_LABEL *) IfrOpHdr)->ExtendOpCode;
190 if (EfiCompareGuid (&((EFI_IFR_GUID *) IfrOpHdr)->Guid, &mIfrVendorGuid) && ExtendOpCode == EFI_IFR_EXTEND_OP_LABEL) {
191 break;
192 }
193 }
194 }
195 }
196
197 //
198 // Fill in the update data
199 //
200 if (Data != NULL) {
201 EfiCopyMem (BufferPos, Data->Data, Data->Offset);
202 BufferPos += Data->Offset;
203 *TempBufferSize += Data->Offset;
204 }
205
206 //
207 // Copy the reset data
208 //
209 EfiCopyMem (BufferPos, IfrOpHdr, PackageHeader.Length - Offset);
210 *TempBufferSize += PackageHeader.Length - Offset;
211
212 Updated = TRUE;
213 break;
214 default :
215 break;
216 }
217
218 //
219 // Go to the next Op-Code
220 //
221 Offset += IfrOpHdr->Length;
222 IfrOpHdr = (EFI_IFR_OP_HEADER *) ((CHAR8 *) (IfrOpHdr) + IfrOpHdr->Length);
223 }
224
225 //
226 // Update the package length.
227 //
228 PackageHeader.Length = *TempBufferSize;
229 EfiCopyMem (*TempBuffer, &PackageHeader, sizeof (EFI_HII_PACKAGE_HEADER));
230
231 Fail:
232 if (!Updated) {
233 gBS->FreePool (*TempBuffer);
234 *TempBufferSize = 0;
235 return EFI_NOT_FOUND;
236 }
237
238 return EFI_SUCCESS;
239 }
240
241 EFI_STATUS
242 IfrLibInitUpdateData (
243 IN OUT EFI_HII_UPDATE_DATA *UpdateData,
244 IN UINT32 BufferSize
245 )
246 /*++
247
248 Routine Description:
249 This function initialize the data structure for dynamic opcode.
250
251 Arguments:
252 UpdateData - The adding data;
253 BufferSize - Length of the buffer to fill dynamic opcodes.
254
255 Returns:
256 EFI_SUCCESS - Update data is initialized.
257 EFI_INVALID_PARAMETER - UpdateData is NULL.
258 EFI_OUT_OF_RESOURCES - No enough memory to allocate.
259
260 --*/
261 {
262 if (UpdateData == NULL) {
263 return EFI_INVALID_PARAMETER;
264 }
265
266 UpdateData->BufferSize = BufferSize;
267 UpdateData->Offset = 0;
268 UpdateData->Data = EfiLibAllocatePool (BufferSize);
269
270 return (UpdateData->Data != NULL) ? EFI_SUCCESS : EFI_OUT_OF_RESOURCES;
271 }
272
273 EFI_STATUS
274 IfrLibFreeUpdateData (
275 IN EFI_HII_UPDATE_DATA *UpdateData
276 )
277 /*++
278
279 Routine Description:
280 This function free the resource of update data.
281
282 Arguments:
283 UpdateData - The adding data;
284
285 Returns:
286 EFI_SUCCESS - Resource in UpdateData is released.
287 EFI_INVALID_PARAMETER - UpdateData is NULL.
288
289 --*/
290 {
291 EFI_STATUS Status;
292
293 if (UpdateData == NULL) {
294 return EFI_INVALID_PARAMETER;
295 }
296
297 Status = gBS->FreePool (UpdateData->Data);
298 UpdateData->Data = NULL;
299
300 return Status;
301 }
302
303 EFI_STATUS
304 IfrLibUpdateForm (
305 IN EFI_HII_HANDLE Handle,
306 IN EFI_GUID *FormSetGuid, OPTIONAL
307 IN EFI_FORM_ID FormId,
308 IN UINT16 Label,
309 IN BOOLEAN Insert,
310 IN EFI_HII_UPDATE_DATA *Data
311 )
312 /*++
313
314 Routine Description:
315 This function allows the caller to update a form that has
316 previously been registered with the EFI HII database.
317
318 Arguments:
319 Handle - Hii Handle
320 FormSetGuid - The formset should be updated.
321 FormId - The form should be updated.
322 Label - Update information starting immediately after this label in the IFR
323 Insert - If TRUE and Data is not NULL, insert data after Label.
324 If FALSE, replace opcodes between two labels with Data
325 Data - The adding data; If NULL, remove opcodes between two Label.
326
327 Returns:
328 EFI_SUCCESS - Update success.
329 Other - Update fail.
330
331 --*/
332 {
333 EFI_STATUS Status;
334 EFI_HII_DATABASE_PROTOCOL *HiiDatabase;
335 EFI_HII_PACKAGE_LIST_HEADER *HiiPackageList;
336 UINT32 Index;
337 EFI_HII_PACKAGE_LIST_HEADER *UpdateBuffer;
338 UINTN BufferSize;
339 UINT8 *UpdateBufferPos;
340 EFI_HII_PACKAGE_HEADER PackageHeader;
341 EFI_HII_PACKAGE_HEADER *Package;
342 UINT32 PackageLength;
343 EFI_HII_PACKAGE_HEADER *TempBuffer;
344 UINT32 TempBufferSize;
345 BOOLEAN Updated;
346
347 if (Data == NULL) {
348 return EFI_INVALID_PARAMETER;
349 }
350
351 LocateHiiProtocols ();
352 HiiDatabase = gIfrLibHiiDatabase;
353
354 //
355 // Get the orginal package list
356 //
357 BufferSize = 0;
358 HiiPackageList = NULL;
359 Status = HiiDatabase->ExportPackageLists (HiiDatabase, Handle, &BufferSize, HiiPackageList);
360 if (Status == EFI_BUFFER_TOO_SMALL) {
361 HiiPackageList = EfiLibAllocatePool (BufferSize);
362 ASSERT (HiiPackageList != NULL);
363
364 Status = HiiDatabase->ExportPackageLists (HiiDatabase, Handle, &BufferSize, HiiPackageList);
365 if (EFI_ERROR (Status)) {
366 gBS->FreePool (HiiPackageList);
367 return Status;
368 }
369 }
370
371 //
372 // Calculate and allocate space for retrieval of IFR data
373 //
374 BufferSize += Data->Offset;
375 UpdateBuffer = EfiLibAllocateZeroPool (BufferSize);
376 if (UpdateBuffer == NULL) {
377 return EFI_OUT_OF_RESOURCES;
378 }
379
380 UpdateBufferPos = (UINT8 *) UpdateBuffer;
381
382 //
383 // copy the package list header
384 //
385 EfiCopyMem (UpdateBufferPos, HiiPackageList, sizeof (EFI_HII_PACKAGE_LIST_HEADER));
386 UpdateBufferPos += sizeof (EFI_HII_PACKAGE_LIST_HEADER);
387
388 Updated = FALSE;
389 for (Index = 0; ; Index++) {
390 Status = GetPackageDataFromPackageList (HiiPackageList, Index, &PackageLength, &Package);
391 if (Status == EFI_SUCCESS) {
392 EfiCopyMem (&PackageHeader, Package, sizeof (EFI_HII_PACKAGE_HEADER));
393 if ((PackageHeader.Type == EFI_HII_PACKAGE_FORMS) && !Updated) {
394 Status = UpdateFormPackageData (FormSetGuid, FormId, Package, PackageLength, Label, Insert, Data, (UINT8 **)&TempBuffer, &TempBufferSize);
395 if (!EFI_ERROR(Status)) {
396 if (FormSetGuid == NULL) {
397 Updated = TRUE;
398 }
399 EfiCopyMem (UpdateBufferPos, TempBuffer, TempBufferSize);
400 UpdateBufferPos += TempBufferSize;
401 gBS->FreePool (TempBuffer);
402 continue;
403 }
404 }
405
406 EfiCopyMem (UpdateBufferPos, Package, PackageLength);
407 UpdateBufferPos += PackageLength;
408 } else if (Status == EFI_NOT_FOUND) {
409 break;
410 } else {
411 gBS->FreePool (HiiPackageList);
412 return Status;
413 }
414 }
415
416 //
417 // Update package list length
418 //
419 BufferSize = UpdateBufferPos - (UINT8 *) UpdateBuffer;
420 EfiCopyMem (&UpdateBuffer->PackageLength, &BufferSize, sizeof (UINT32));
421
422 gBS->FreePool (HiiPackageList);
423
424 return HiiDatabase->UpdatePackageList (HiiDatabase, Handle, UpdateBuffer);
425 }
426
427 EFI_STATUS
428 IfrLibCreatePopUp (
429 IN UINTN NumberOfLines,
430 OUT EFI_INPUT_KEY *KeyValue,
431 IN CHAR16 *String,
432 ...
433 )
434 /*++
435
436 Routine Description:
437 Draw a dialog and return the selected key.
438
439 Arguments:
440 NumberOfLines - The number of lines for the dialog box
441 KeyValue - The EFI_KEY value returned if HotKey is TRUE..
442 String - Pointer to the first string in the list
443 ... - A series of (quantity == NumberOfLines) text strings which
444 will be used to construct the dialog box
445
446 Returns:
447 EFI_SUCCESS - Displayed dialog and received user interaction
448 EFI_INVALID_PARAMETER - One of the parameters was invalid.
449
450 --*/
451 {
452 UINTN Index;
453 UINTN Count;
454 UINTN Start;
455 UINTN End;
456 UINTN Top;
457 UINTN Bottom;
458 CHAR16 *StringPtr;
459 UINTN LeftColumn;
460 UINTN RightColumn;
461 UINTN TopRow;
462 UINTN BottomRow;
463 UINTN DimensionsWidth;
464 UINTN DimensionsHeight;
465 VA_LIST Marker;
466 EFI_INPUT_KEY Key;
467 UINTN LargestString;
468 CHAR16 *StackString;
469 EFI_STATUS Status;
470 UINTN StringLen;
471 CHAR16 *LineBuffer;
472 CHAR16 **StringArray;
473 EFI_EVENT TimerEvent;
474 EFI_EVENT WaitList[2];
475 UINTN CurrentAttribute;
476 EFI_SIMPLE_TEXT_OUT_PROTOCOL *ConOut;
477
478 if ((KeyValue == NULL) || (String == NULL)) {
479 return EFI_INVALID_PARAMETER;
480 }
481
482 TopRow = 0;
483 BottomRow = 0;
484 LeftColumn = 0;
485 RightColumn = 0;
486
487 ConOut = gST->ConOut;
488 ConOut->QueryMode (ConOut, ConOut->Mode->Mode, &RightColumn, &BottomRow);
489
490 DimensionsWidth = RightColumn - LeftColumn;
491 DimensionsHeight = BottomRow - TopRow;
492
493 CurrentAttribute = ConOut->Mode->Attribute;
494
495 LineBuffer = EfiLibAllocateZeroPool (DimensionsWidth * sizeof (CHAR16));
496 ASSERT (LineBuffer != NULL);
497
498 //
499 // Determine the largest string in the dialog box
500 // Notice we are starting with 1 since String is the first string
501 //
502 StringArray = EfiLibAllocateZeroPool (NumberOfLines * sizeof (CHAR16 *));
503 LargestString = EfiStrLen (String);
504 StringArray[0] = String;
505
506 VA_START (Marker, String);
507 for (Index = 1; Index < NumberOfLines; Index++) {
508 StackString = VA_ARG (Marker, CHAR16 *);
509
510 if (StackString == NULL) {
511 VA_END (Marker);
512 return EFI_INVALID_PARAMETER;
513 }
514
515 StringArray[Index] = StackString;
516 StringLen = EfiStrLen (StackString);
517 if (StringLen > LargestString) {
518 LargestString = StringLen;
519 }
520 }
521 VA_END (Marker);
522
523 if ((LargestString + 2) > DimensionsWidth) {
524 LargestString = DimensionsWidth - 2;
525 }
526
527 //
528 // Subtract the PopUp width from total Columns, allow for one space extra on
529 // each end plus a border.
530 //
531 Start = (DimensionsWidth - LargestString - 2) / 2 + LeftColumn + 1;
532 End = Start + LargestString + 1;
533
534 Top = ((DimensionsHeight - NumberOfLines - 2) / 2) + TopRow - 1;
535 Bottom = Top + NumberOfLines + 2;
536
537 //
538 // Disable cursor
539 //
540 ConOut->EnableCursor (ConOut, FALSE);
541 ConOut->SetAttribute (ConOut, EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE);
542
543 StringPtr = &LineBuffer[0];
544 *StringPtr++ = BOXDRAW_DOWN_RIGHT;
545 for (Index = 0; Index < LargestString; Index++) {
546 *StringPtr++ = BOXDRAW_HORIZONTAL;
547 }
548 *StringPtr++ = BOXDRAW_DOWN_LEFT;
549 *StringPtr = L'\0';
550
551 ConOut->SetCursorPosition (ConOut, Start, Top);
552 ConOut->OutputString (ConOut, LineBuffer);
553
554 for (Index = 0; Index < NumberOfLines; Index++) {
555 StringPtr = &LineBuffer[0];
556 *StringPtr++ = BOXDRAW_VERTICAL;
557
558 for (Count = 0; Count < LargestString; Count++) {
559 StringPtr[Count] = L' ';
560 }
561
562 StringLen = EfiStrLen (StringArray[Index]);
563 if (StringLen > LargestString) {
564 StringLen = LargestString;
565 }
566 EfiCopyMem (
567 StringPtr + ((LargestString - StringLen) / 2),
568 StringArray[Index],
569 StringLen * sizeof (CHAR16)
570 );
571 StringPtr += LargestString;
572
573 *StringPtr++ = BOXDRAW_VERTICAL;
574 *StringPtr = L'\0';
575
576 ConOut->SetCursorPosition (ConOut, Start, Top + 1 + Index);
577 ConOut->OutputString (ConOut, LineBuffer);
578 }
579
580 StringPtr = &LineBuffer[0];
581 *StringPtr++ = BOXDRAW_UP_RIGHT;
582 for (Index = 0; Index < LargestString; Index++) {
583 *StringPtr++ = BOXDRAW_HORIZONTAL;
584 }
585 *StringPtr++ = BOXDRAW_UP_LEFT;
586 *StringPtr = L'\0';
587
588 ConOut->SetCursorPosition (ConOut, Start, Top + NumberOfLines + 1);
589 ConOut->OutputString (ConOut, LineBuffer);
590
591 do {
592 Status = gBS->CreateEvent (EFI_EVENT_TIMER, 0, NULL, NULL, &TimerEvent);
593
594 //
595 // Set a timer event of 1 second expiration
596 //
597 gBS->SetTimer (
598 TimerEvent,
599 TimerRelative,
600 10000000
601 );
602
603 //
604 // Wait for the keystroke event or the timer
605 //
606 WaitList[0] = gST->ConIn->WaitForKey;
607 WaitList[1] = TimerEvent;
608 Status = gBS->WaitForEvent (2, WaitList, &Index);
609
610 //
611 // Check for the timer expiration
612 //
613 if (!EFI_ERROR (Status) && Index == 1) {
614 Status = EFI_TIMEOUT;
615 }
616
617 gBS->CloseEvent (TimerEvent);
618 } while (Status == EFI_TIMEOUT);
619
620 Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
621 EfiCopyMem (KeyValue, &Key, sizeof (EFI_INPUT_KEY));
622
623 ConOut->SetAttribute (ConOut, CurrentAttribute);
624 ConOut->EnableCursor (ConOut, TRUE);
625
626 return Status;
627 }
628
629 EFI_STATUS
630 ExtractDefault(
631 IN VOID *Buffer,
632 IN UINTN *BufferSize,
633 UINTN Number,
634 ...
635 )
636 /*++
637
638 Routine Description:
639
640 Configure the buffer accrording to ConfigBody strings.
641
642 Arguments:
643 DefaultId - the ID of default.
644 Buffer - the start address of buffer.
645 BufferSize - the size of buffer.
646 Number - the number of the strings.
647
648 Returns:
649 EFI_BUFFER_TOO_SMALL - the BufferSize is too small to operate.
650 EFI_INVALID_PARAMETER - Buffer is NULL or BufferSize is 0.
651 EFI_SUCCESS - Operation successful.
652
653 --*/
654 {
655 VA_LIST Args;
656 UINTN Index;
657 UINT32 TotalLen;
658 UINT8 *BufCfgArray;
659 UINT8 *BufferPos;
660 UINT16 Offset;
661 UINT16 Width;
662 UINT8 *Value;
663
664 if ((Buffer == NULL) || (BufferSize == NULL)) {
665 return EFI_INVALID_PARAMETER;
666 }
667
668 Offset = 0;
669 Width = 0;
670 Value = NULL;
671
672 VA_START (Args, Number);
673 for (Index = 0; Index < Number; Index++) {
674 BufCfgArray = (UINT8 *) VA_ARG (Args, VOID *);
675 EfiCopyMem (&TotalLen, BufCfgArray, sizeof (UINT32));
676 BufferPos = BufCfgArray + sizeof (UINT32);
677
678 while ((UINT32)(BufferPos - BufCfgArray) < TotalLen) {
679 EfiCopyMem (&Offset, BufferPos, sizeof (UINT16));
680 BufferPos += sizeof (UINT16);
681 EfiCopyMem (&Width, BufferPos, sizeof (UINT16));
682 BufferPos += sizeof (UINT16);
683 Value = BufferPos;
684 BufferPos += Width;
685
686 if ((UINTN)(Offset + Width) > *BufferSize) {
687 VA_END (Args);
688 return EFI_BUFFER_TOO_SMALL;
689 }
690
691 EfiCopyMem ((UINT8 *)Buffer + Offset, Value, Width);
692 }
693 }
694 VA_END (Args);
695
696 *BufferSize = (UINTN)Offset;
697
698 return EFI_SUCCESS;
699 }
700
701 EFI_STATUS
702 ExtractBlockName (
703 IN UINT8 *Buffer,
704 OUT CHAR16 **BlockName
705 )
706 /*++
707
708 Routine Description:
709
710 Extract block name from the array generated by VFR compiler. The name of
711 this array is "Vfr + <StorageName> + BlockName", e.g. "VfrMyIfrNVDataBlockName".
712 Format of this array is:
713 Array length | 4-bytes
714 Offset | 2-bytes
715 Width | 2-bytes
716 Offset | 2-bytes
717 Width | 2-bytes
718 ... ...
719
720 Arguments:
721 Buffer - Array generated by VFR compiler.
722 BlockName - The returned <BlockName>
723
724 Returns:
725 EFI_OUT_OF_RESOURCES - Run out of memory resource.
726 EFI_INVALID_PARAMETER - Buffer is NULL or BlockName is NULL.
727 EFI_SUCCESS - Operation successful.
728
729 --*/
730 {
731 UINTN Index;
732 UINT32 Length;
733 UINT32 BlockNameNumber;
734 UINTN HexStringBufferLen;
735 CHAR16 *StringPtr;
736
737 if ((Buffer == NULL) || (BlockName == NULL)) {
738 return EFI_INVALID_PARAMETER;
739 }
740
741 //
742 // Calculate number of Offset/Width pair
743 //
744 EfiCopyMem (&Length, Buffer, sizeof (UINT32));
745 BlockNameNumber = (Length - sizeof (UINT32)) / (sizeof (UINT16) * 2);
746
747 //
748 // <BlockName> ::= &OFFSET=1234&WIDTH=1234
749 // | 8 | 4 | 7 | 4 |
750 //
751 StringPtr = EfiLibAllocateZeroPool ((BlockNameNumber * (8 + 4 + 7 + 4) + 1) * sizeof (CHAR16));
752 *BlockName = StringPtr;
753 if (StringPtr == NULL) {
754 return EFI_OUT_OF_RESOURCES;
755 }
756
757 Buffer += sizeof (UINT32);
758 for (Index = 0; Index < BlockNameNumber; Index++) {
759 EfiStrCpy (StringPtr, L"&OFFSET=");
760 StringPtr += 8;
761
762 HexStringBufferLen = 5;
763 BufToHexString (StringPtr, &HexStringBufferLen, Buffer, sizeof (UINT16));
764 Buffer += sizeof (UINT16);
765 StringPtr += 4;
766
767 EfiStrCpy (StringPtr, L"&WIDTH=");
768 StringPtr += 7;
769
770 HexStringBufferLen = 5;
771 BufToHexString (StringPtr, &HexStringBufferLen, Buffer, sizeof (UINT16));
772 Buffer += sizeof (UINT16);
773 StringPtr += 4;
774 }
775
776 return EFI_SUCCESS;
777 }
778
779 EFI_STATUS
780 ExtractBlockConfig (
781 IN UINT8 *Buffer,
782 OUT CHAR16 **BlockConfig
783 )
784 /*++
785
786 Routine Description:
787
788 Extract block config from the array generated by VFR compiler. The name of
789 this array is "Vfr + <StorageName> + Default<HexCh>4", e.g. "VfrMyIfrNVDataDefault0000".
790
791 Arguments:
792 Buffer - Array generated by VFR compiler.
793 BlockConfig - The returned <BlockConfig>
794
795 Returns:
796 EFI_OUT_OF_RESOURCES - Run out of memory resource.
797 EFI_INVALID_PARAMETER - Buffer is NULL or BlockConfig is NULL.
798 EFI_SUCCESS - Operation successful.
799
800 --*/
801 {
802 UINT32 Length;
803 UINT16 Width;
804 UINTN HexStringBufferLen;
805 CHAR16 *StringPtr;
806 UINT8 *BufferEnd;
807 CHAR16 *StringEnd;
808 EFI_STATUS Status;
809
810 if ((Buffer == NULL) || (BlockConfig == NULL)) {
811 return EFI_INVALID_PARAMETER;
812 }
813
814 //
815 // Calculate length of AltResp string
816 // Format of Default value array is:
817 // Array length | 4-bytes
818 // Offset | 2-bytes
819 // Width | 2-bytes
820 // Value | Variable length
821 // Offset | 2-bytes
822 // Width | 2-bytes
823 // Value | Variable length
824 // ... ...
825 // When value is 1 byte in length, overhead of AltResp string will be maximum,
826 // BlockConfig ::= <&OFFSET=1234&WIDTH=1234&VALUE=12>+
827 // | 8 | 4 | 7 | 4 | 7 |2|
828 // so the maximum length of BlockConfig could be calculated as:
829 // (ArrayLength / 5) * (8 + 4 + 7 + 4 + 7 + 2) = ArrayLength * 6.4 < ArrayLength * 7
830 //
831 EfiCopyMem (&Length, Buffer, sizeof (UINT32));
832 BufferEnd = Buffer + Length;
833 StringPtr = EfiLibAllocatePool (Length * 7 * sizeof (CHAR16));
834 *BlockConfig = StringPtr;
835 if (StringPtr == NULL) {
836 return EFI_OUT_OF_RESOURCES;
837 }
838 StringEnd = StringPtr + (Length * 7);
839
840 Buffer += sizeof (UINT32);
841 while (Buffer < BufferEnd) {
842 EfiStrCpy (StringPtr, L"&OFFSET=");
843 StringPtr += 8;
844
845 HexStringBufferLen = 5;
846 BufToHexString (StringPtr, &HexStringBufferLen, Buffer, sizeof (UINT16));
847 Buffer += sizeof (UINT16);
848 StringPtr += 4;
849
850 EfiStrCpy (StringPtr, L"&WIDTH=");
851 StringPtr += 7;
852
853 HexStringBufferLen = 5;
854 BufToHexString (StringPtr, &HexStringBufferLen, Buffer, sizeof (UINT16));
855 EfiCopyMem (&Width, Buffer, sizeof (UINT16));
856 Buffer += sizeof (UINT16);
857 StringPtr += 4;
858
859 EfiStrCpy (StringPtr, L"&VALUE=");
860 StringPtr += 7;
861
862 HexStringBufferLen = StringEnd - StringPtr;
863 Status = BufToHexString (StringPtr, &HexStringBufferLen, Buffer, Width);
864 if (EFI_ERROR (Status)) {
865 return Status;
866 }
867 Buffer += Width;
868 StringPtr += (Width * 2);
869 }
870
871 return EFI_SUCCESS;
872 }
873
874 EFI_STATUS
875 ConstructConfigAltResp (
876 IN EFI_STRING ConfigRequest, OPTIONAL
877 OUT EFI_STRING *Progress,
878 OUT EFI_STRING *ConfigAltResp,
879 IN EFI_GUID *Guid,
880 IN CHAR16 *Name,
881 IN EFI_HANDLE *DriverHandle,
882 IN VOID *BufferStorage,
883 IN UINTN BufferStorageSize,
884 IN VOID *BlockNameArray, OPTIONAL
885 IN UINTN NumberAltCfg,
886 ...
887 //IN UINT16 AltCfgId,
888 //IN VOID *DefaultValueArray,
889 )
890 /*++
891
892 Routine Description:
893
894 Construct <ConfigAltResp> for a buffer storage.
895
896 Arguments:
897 ConfigRequest - The Config request string. If set to NULL, all the
898 configurable elements will be extracted from BlockNameArray.
899 ConfigAltResp - The returned <ConfigAltResp>.
900 Progress - On return, points to a character in the Request.
901 Guid - GUID of the buffer storage.
902 Name - Name of the buffer storage.
903 DriverHandle - The DriverHandle which is used to invoke HiiDatabase
904 protocol interface NewPackageList().
905 BufferStorage - Content of the buffer storage.
906 BufferStorageSize - Length in bytes of the buffer storage.
907 BlockNameArray - Array generated by VFR compiler.
908 NumberAltCfg - Number of Default value array generated by VFR compiler.
909 The sequential input parameters will be number of
910 AltCfgId and DefaultValueArray pairs. When set to 0,
911 there will be no <AltResp>.
912
913 Returns:
914 EFI_OUT_OF_RESOURCES - Run out of memory resource.
915 EFI_INVALID_PARAMETER - ConfigAltResp is NULL.
916 EFI_SUCCESS - Operation successful.
917
918 --*/
919 {
920 EFI_STATUS Status;
921 CHAR16 *ConfigHdr;
922 CHAR16 *BlockName;
923 CHAR16 *DescHdr;
924 CHAR16 *StringPtr;
925 CHAR16 **AltCfg;
926 UINT16 AltCfgId;
927 VOID *DefaultValueArray;
928 UINTN StrBufferLen;
929 EFI_STRING ConfigResp;
930 EFI_STRING TempStr;
931 VA_LIST Args;
932 UINTN AltRespLen;
933 UINTN Index;
934 BOOLEAN NeedFreeConfigRequest;
935 EFI_HII_CONFIG_ROUTING_PROTOCOL *HiiConfigRouting;
936
937 if (ConfigAltResp == NULL) {
938 return EFI_INVALID_PARAMETER;
939 }
940
941 //
942 // Construct <ConfigHdr> : "GUID=...&NAME=...&PATH=..."
943 //
944 ConfigHdr = NULL;
945 StrBufferLen = 0;
946 Status = ConstructConfigHdr (
947 ConfigHdr,
948 &StrBufferLen,
949 Guid,
950 Name,
951 DriverHandle
952 );
953 if (Status == EFI_BUFFER_TOO_SMALL) {
954 ConfigHdr = EfiLibAllocateZeroPool (StrBufferLen);
955 Status = ConstructConfigHdr (
956 ConfigHdr,
957 &StrBufferLen,
958 Guid,
959 Name,
960 DriverHandle
961 );
962 }
963
964 if (EFI_ERROR (Status) || (ConfigHdr == NULL)) {
965 return Status;
966 }
967
968 //
969 // Construct <ConfigResp>
970 //
971 NeedFreeConfigRequest = FALSE;
972 if (ConfigRequest == NULL) {
973 //
974 // If ConfigRequest is set to NULL, export all configurable elements in BlockNameArray
975 //
976 Status = ExtractBlockName (BlockNameArray, &BlockName);
977 if (EFI_ERROR (Status)) {
978 return Status;
979 }
980
981 StrBufferLen = EfiStrSize (ConfigHdr);
982 StrBufferLen = StrBufferLen + EfiStrSize (BlockName) - sizeof (CHAR16);
983 ConfigRequest = EfiLibAllocateZeroPool (StrBufferLen);
984 EfiStrCpy (ConfigRequest, ConfigHdr);
985 EfiStrCat (ConfigRequest, BlockName);
986 NeedFreeConfigRequest = TRUE;
987 }
988
989 Status = gBS->LocateProtocol (&gEfiHiiConfigRoutingProtocolGuid, NULL, (VOID **) &HiiConfigRouting);
990 if (EFI_ERROR (Status)) {
991 return Status;
992 }
993
994 Status = HiiConfigRouting->BlockToConfig (
995 HiiConfigRouting,
996 ConfigRequest,
997 BufferStorage,
998 BufferStorageSize,
999 &ConfigResp,
1000 (Progress == NULL) ? &TempStr : Progress
1001 );
1002 if (EFI_ERROR (Status)) {
1003 return Status;
1004 }
1005
1006 //
1007 // Construct <AltResp>
1008 //
1009 DescHdr = EfiLibAllocateZeroPool (NumberAltCfg * 16 * sizeof (CHAR16));
1010 StringPtr = DescHdr;
1011 AltCfg = EfiLibAllocateZeroPool (NumberAltCfg * sizeof (CHAR16 *));
1012 AltRespLen = 0;
1013 VA_START (Args, NumberAltCfg);
1014 for (Index = 0; Index < NumberAltCfg; Index++) {
1015 AltCfgId = (UINT16) VA_ARG (Args, UINT16);
1016 DefaultValueArray = (UINT8 *) VA_ARG (Args, VOID *);
1017
1018 //
1019 // '&' <ConfigHdr>
1020 //
1021 AltRespLen += (EfiStrLen (ConfigHdr) + 1);
1022
1023 StringPtr = DescHdr + Index * 16;
1024 EfiStrCpy (StringPtr, L"&ALTCFG=");
1025 AltRespLen += (8 + sizeof (UINT16) * 2);
1026
1027 StrBufferLen = 5;
1028 BufToHexString (StringPtr + 8, &StrBufferLen, (UINT8 *) &AltCfgId, sizeof (UINT16));
1029 Status = ExtractBlockConfig (DefaultValueArray, &AltCfg[Index]);
1030 if (EFI_ERROR (Status)) {
1031 VA_END (Args);
1032 return Status;
1033 }
1034 AltRespLen += EfiStrLen (AltCfg[Index]);
1035 }
1036 VA_END (Args);
1037
1038 //
1039 // Generate the final <ConfigAltResp>
1040 //
1041 StrBufferLen = (EfiStrLen ((CHAR16 *) ConfigResp) + AltRespLen + 1) * sizeof (CHAR16);
1042 TempStr = EfiLibAllocateZeroPool (StrBufferLen);
1043 *ConfigAltResp = TempStr;
1044 if (TempStr == NULL) {
1045 return EFI_OUT_OF_RESOURCES;
1046 }
1047
1048 //
1049 // <ConfigAltResp> ::= <ConfigResp> ['&' <AltResp>]*
1050 //
1051 EfiStrCpy (TempStr, ConfigResp);
1052 for (Index = 0; Index < NumberAltCfg; Index++) {
1053 EfiStrCat (TempStr, L"&");
1054 EfiStrCat (TempStr, ConfigHdr);
1055 EfiStrCat (TempStr, DescHdr + Index * 16);
1056 EfiStrCat (TempStr, AltCfg[Index]);
1057
1058 gBS->FreePool (AltCfg[Index]);
1059 }
1060
1061 if (NeedFreeConfigRequest) {
1062 gBS->FreePool (ConfigRequest);
1063 }
1064 gBS->FreePool (ConfigHdr);
1065 gBS->FreePool (ConfigResp);
1066 gBS->FreePool (DescHdr);
1067 gBS->FreePool (AltCfg);
1068
1069 return EFI_SUCCESS;
1070 }
1071
1072 VOID
1073 SwapBuffer (
1074 IN OUT UINT8 *Buffer,
1075 IN UINTN BufferSize
1076 )
1077 /*++
1078
1079 Routine Description:
1080 Swap bytes in the buffer.
1081
1082 Arguments:
1083 Buffer - Binary buffer.
1084 BufferSize - Size of the buffer in bytes.
1085
1086 Returns:
1087 None.
1088
1089 --*/
1090 {
1091 UINTN Index;
1092 UINT8 Temp;
1093 UINTN SwapCount;
1094
1095 SwapCount = BufferSize / 2;
1096 for (Index = 0; Index < SwapCount; Index++) {
1097 Temp = Buffer[Index];
1098 Buffer[Index] = Buffer[BufferSize - 1 - Index];
1099 Buffer[BufferSize - 1 - Index] = Temp;
1100 }
1101 }
1102
1103 VOID
1104 ToLower (
1105 IN OUT CHAR16 *Str
1106 )
1107 /*++
1108
1109 Routine Description:
1110 Converts the unicode character of the string from uppercase to lowercase.
1111
1112 Arguments:
1113 Str - String to be converted
1114
1115 Returns:
1116
1117 --*/
1118 {
1119 CHAR16 *Ptr;
1120
1121 for (Ptr = Str; *Ptr != L'\0'; Ptr++) {
1122 if (*Ptr >= L'A' && *Ptr <= L'Z') {
1123 *Ptr = (CHAR16) (*Ptr - L'A' + L'a');
1124 }
1125 }
1126 }
1127
1128 EFI_STATUS
1129 BufferToHexString (
1130 IN OUT CHAR16 *Str,
1131 IN UINT8 *Buffer,
1132 IN UINTN BufferSize
1133 )
1134 /*++
1135
1136 Routine Description:
1137 Converts binary buffer to Unicode string in reversed byte order from BufToHexString().
1138
1139 Arguments:
1140 Str - String for output
1141 Buffer - Binary buffer.
1142 BufferSize - Size of the buffer in bytes.
1143
1144 Returns:
1145 EFI_SUCCESS - The function completed successfully.
1146
1147 --*/
1148 {
1149 EFI_STATUS Status;
1150 UINT8 *NewBuffer;
1151 UINTN StrBufferLen;
1152
1153 NewBuffer = EfiLibAllocateCopyPool (BufferSize, Buffer);
1154 SwapBuffer (NewBuffer, BufferSize);
1155
1156 StrBufferLen = BufferSize * 2 + 1;
1157 Status = BufToHexString (Str, &StrBufferLen, NewBuffer, BufferSize);
1158
1159 gBS->FreePool (NewBuffer);
1160 //
1161 // Convert the uppercase to lowercase since <HexAf> is defined in lowercase format.
1162 //
1163 ToLower (Str);
1164
1165 return Status;
1166 }
1167
1168 EFI_STATUS
1169 HexStringToBuffer (
1170 IN OUT UINT8 *Buffer,
1171 IN OUT UINTN *BufferSize,
1172 IN CHAR16 *Str
1173 )
1174 /*++
1175
1176 Routine Description:
1177 Converts Hex String to binary buffer in reversed byte order from HexStringToBuf().
1178
1179 Arguments:
1180 Buffer - Pointer to buffer that receives the data.
1181 BufferSize - Length in bytes of the buffer to hold converted data.
1182 If routine return with EFI_SUCCESS, containing length of converted data.
1183 If routine return with EFI_BUFFER_TOO_SMALL, containg length of buffer desired.
1184 Str - String to be converted from.
1185
1186 Returns:
1187 EFI_SUCCESS - The function completed successfully.
1188
1189 --*/
1190 {
1191 EFI_STATUS Status;
1192 UINTN ConvertedStrLen;
1193
1194 ConvertedStrLen = 0;
1195 Status = HexStringToBuf (Buffer, BufferSize, Str, &ConvertedStrLen);
1196 if (!EFI_ERROR (Status)) {
1197 SwapBuffer (Buffer, (ConvertedStrLen + 1) / 2);
1198 }
1199
1200 return Status;
1201 }
1202
1203 EFI_STATUS
1204 ConfigStringToUnicode (
1205 IN OUT CHAR16 *UnicodeString,
1206 IN OUT UINTN *StrBufferLen,
1207 IN CHAR16 *ConfigString
1208 )
1209 /*++
1210
1211 Routine Description:
1212 Convert binary representation Config string (e.g. "0041004200430044") to the
1213 original string (e.g. "ABCD"). Config string appears in <ConfigHdr> (i.e.
1214 "&NAME=<string>"), or Name/Value pair in <ConfigBody> (i.e. "label=<string>").
1215
1216 Arguments:
1217 UnicodeString - Original Unicode string.
1218 StrBufferLen - On input: Length in bytes of buffer to hold the Unicode string.
1219 Includes tailing '\0' character.
1220 On output:
1221 If return EFI_SUCCESS, containing length of Unicode string buffer.
1222 If return EFI_BUFFER_TOO_SMALL, containg length of string buffer desired.
1223 ConfigString - Binary representation of Unicode String, <string> := (<HexCh>4)+
1224
1225 Returns:
1226 EFI_SUCCESS - Routine success.
1227 EFI_BUFFER_TOO_SMALL - The string buffer is too small.
1228
1229 --*/
1230 {
1231 UINTN Index;
1232 UINTN Len;
1233 UINTN BufferSize;
1234 CHAR16 BackupChar;
1235
1236 Len = EfiStrLen (ConfigString) / 4;
1237 BufferSize = (Len + 1) * sizeof (CHAR16);
1238
1239 if (*StrBufferLen < BufferSize) {
1240 *StrBufferLen = BufferSize;
1241 return EFI_BUFFER_TOO_SMALL;
1242 }
1243
1244 *StrBufferLen = BufferSize;
1245
1246 for (Index = 0; Index < Len; Index++) {
1247 BackupChar = ConfigString[4];
1248 ConfigString[4] = L'\0';
1249
1250 HexStringToBuf ((UINT8 *) UnicodeString, &BufferSize, ConfigString, NULL);
1251
1252 ConfigString[4] = BackupChar;
1253
1254 ConfigString += 4;
1255 UnicodeString += 1;
1256 }
1257
1258 //
1259 // Add tailing '\0' character
1260 //
1261 *UnicodeString = L'\0';
1262
1263 return EFI_SUCCESS;
1264 }
1265
1266 EFI_STATUS
1267 UnicodeToConfigString (
1268 IN OUT CHAR16 *ConfigString,
1269 IN OUT UINTN *StrBufferLen,
1270 IN CHAR16 *UnicodeString
1271 )
1272 /*++
1273
1274 Routine Description:
1275 Convert Unicode string to binary representation Config string, e.g.
1276 "ABCD" => "0041004200430044". Config string appears in <ConfigHdr> (i.e.
1277 "&NAME=<string>"), or Name/Value pair in <ConfigBody> (i.e. "label=<string>").
1278
1279 Arguments:
1280 ConfigString - Binary representation of Unicode String, <string> := (<HexCh>4)+
1281 StrBufferLen - On input: Length in bytes of buffer to hold the Unicode string.
1282 Includes tailing '\0' character.
1283 On output:
1284 If return EFI_SUCCESS, containing length of Unicode string buffer.
1285 If return EFI_BUFFER_TOO_SMALL, containg length of string buffer desired.
1286 UnicodeString - Original Unicode string.
1287
1288 Returns:
1289 EFI_SUCCESS - Routine success.
1290 EFI_BUFFER_TOO_SMALL - The string buffer is too small.
1291
1292 --*/
1293 {
1294 UINTN Index;
1295 UINTN Len;
1296 UINTN BufferSize;
1297 CHAR16 *String;
1298
1299 Len = EfiStrLen (UnicodeString);
1300 BufferSize = (Len * 4 + 1) * sizeof (CHAR16);
1301
1302 if (*StrBufferLen < BufferSize) {
1303 *StrBufferLen = BufferSize;
1304 return EFI_BUFFER_TOO_SMALL;
1305 }
1306
1307 *StrBufferLen = BufferSize;
1308 String = ConfigString;
1309
1310 for (Index = 0; Index < Len; Index++) {
1311 BufToHexString (ConfigString, &BufferSize, (UINT8 *) UnicodeString, 2);
1312
1313 ConfigString += 4;
1314 UnicodeString += 1;
1315 }
1316
1317 //
1318 // Add tailing '\0' character
1319 //
1320 *ConfigString = L'\0';
1321
1322 //
1323 // Convert the uppercase to lowercase since <HexAf> is defined in lowercase format.
1324 //
1325 ToLower (String);
1326 return EFI_SUCCESS;
1327 }
1328
1329 EFI_STATUS
1330 ConstructConfigHdr (
1331 IN OUT CHAR16 *ConfigHdr,
1332 IN OUT UINTN *StrBufferLen,
1333 IN EFI_GUID *Guid,
1334 IN CHAR16 *Name, OPTIONAL
1335 IN EFI_HANDLE *DriverHandle
1336 )
1337 /*++
1338
1339 Routine Description:
1340 Construct <ConfigHdr> using routing information GUID/NAME/PATH.
1341
1342 Arguments:
1343 ConfigHdr - Pointer to the ConfigHdr string.
1344 StrBufferLen - On input: Length in bytes of buffer to hold the ConfigHdr string.
1345 Includes tailing '\0' character.
1346 On output:
1347 If return EFI_SUCCESS, containing length of ConfigHdr string buffer.
1348 If return EFI_BUFFER_TOO_SMALL, containg length of string buffer desired.
1349 Guid - Routing information: GUID.
1350 Name - Routing information: NAME.
1351 DriverHandle - Driver handle which contains the routing information: PATH.
1352
1353 Returns:
1354 EFI_SUCCESS - Routine success.
1355 EFI_BUFFER_TOO_SMALL - The ConfigHdr string buffer is too small.
1356
1357 --*/
1358 {
1359 EFI_STATUS Status;
1360 UINTN NameStrLen;
1361 UINTN DevicePathSize;
1362 UINTN BufferSize;
1363 CHAR16 *StrPtr;
1364 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
1365
1366 if (Name == NULL) {
1367 //
1368 // There will be no "NAME" in <ConfigHdr> for Name/Value storage
1369 //
1370 NameStrLen = 0;
1371 } else {
1372 //
1373 // For buffer storage
1374 //
1375 NameStrLen = EfiStrLen (Name);
1376 }
1377
1378 //
1379 // Retrieve DevicePath Protocol associated with this HiiPackageList
1380 //
1381 Status = gBS->HandleProtocol (
1382 DriverHandle,
1383 &gEfiDevicePathProtocolGuid,
1384 (VOID **) &DevicePath
1385 );
1386 if (EFI_ERROR (Status)) {
1387 return Status;
1388 }
1389
1390 DevicePathSize = EfiDevicePathSize (DevicePath);
1391
1392 //
1393 // GUID=<HexCh>32&NAME=<Char>NameStrLen&PATH=<HexChar>DevicePathStrLen <NULL>
1394 // | 5 | 32 | 6 | NameStrLen*4 | 6 | DevicePathStrLen | 1 |
1395 //
1396 BufferSize = (5 + 32 + 6 + NameStrLen * 4 + 6 + DevicePathSize * 2 + 1) * sizeof (CHAR16);
1397 if (*StrBufferLen < BufferSize) {
1398 *StrBufferLen = BufferSize;
1399 return EFI_BUFFER_TOO_SMALL;
1400 }
1401
1402 if (ConfigHdr == NULL) {
1403 return EFI_INVALID_PARAMETER;
1404 }
1405
1406 *StrBufferLen = BufferSize;
1407
1408 StrPtr = ConfigHdr;
1409
1410 EfiStrCpy (StrPtr, L"GUID=");
1411 StrPtr += 5;
1412 BufferToHexString (StrPtr, (UINT8 *) Guid, sizeof (EFI_GUID));
1413 StrPtr += 32;
1414
1415 //
1416 // Convert name string, e.g. name "ABCD" => "&NAME=0041004200430044"
1417 //
1418 EfiStrCpy (StrPtr, L"&NAME=");
1419 StrPtr += 6;
1420 if (Name != NULL) {
1421 BufferSize = (NameStrLen * 4 + 1) * sizeof (CHAR16);
1422 UnicodeToConfigString (StrPtr, &BufferSize, Name);
1423 StrPtr += (NameStrLen * 4);
1424 }
1425
1426 EfiStrCpy (StrPtr, L"&PATH=");
1427 StrPtr += 6;
1428 BufferToHexString (StrPtr, (UINT8 *) DevicePath, DevicePathSize);
1429
1430 return EFI_SUCCESS;
1431 }
1432
1433 BOOLEAN
1434 IsConfigHdrMatch (
1435 IN EFI_STRING ConfigString,
1436 IN EFI_GUID *StorageGuid, OPTIONAL
1437 IN CHAR16 *StorageName OPTIONAL
1438 )
1439 /*++
1440
1441 Routine Description:
1442 Determines if the Routing data (Guid and Name) is correct in <ConfigHdr>.
1443
1444 Arguments:
1445 ConfigString - Either <ConfigRequest> or <ConfigResp>.
1446 StorageGuid - GUID of the storage.
1447 StorageName - Name of the stoarge.
1448
1449 Returns:
1450 TRUE - Routing information is correct in ConfigString.
1451 FALSE - Routing information is incorrect in ConfigString.
1452
1453 --*/
1454 {
1455 EFI_STATUS Status;
1456 BOOLEAN Match;
1457 EFI_GUID Guid;
1458 CHAR16 *Name;
1459 CHAR16 *StrPtr;
1460 UINTN BufferSize;
1461
1462 //
1463 // <ConfigHdr> ::=
1464 // GUID=<HexCh>32&NAME=<Char>NameStrLen&PATH=<HexChar>DevicePathStrLen <NULL>
1465 // | 5 | 32 | 6 | NameStrLen*4 | 6 | DevicePathStrLen | 1 |
1466 //
1467 if (EfiStrLen (ConfigString) <= (5 + 32 + 6)) {
1468 return FALSE;
1469 }
1470
1471 //
1472 // Compare GUID
1473 //
1474 if (StorageGuid != NULL) {
1475
1476 StrPtr = ConfigString + 5 + 32;
1477 if (*StrPtr != L'&') {
1478 return FALSE;
1479 }
1480 *StrPtr = L'\0';
1481
1482 BufferSize = sizeof (EFI_GUID);
1483 Status = HexStringToBuffer (
1484 (UINT8 *) &Guid,
1485 &BufferSize,
1486 ConfigString + 5
1487 );
1488 *StrPtr = L'&';
1489
1490 if (EFI_ERROR (Status)) {
1491 return FALSE;
1492 }
1493
1494 if (!EfiCompareGuid (&Guid, StorageGuid)) {
1495 return FALSE;
1496 }
1497 }
1498
1499 //
1500 // Compare Name
1501 //
1502 Match = TRUE;
1503 if (StorageName != NULL) {
1504 StrPtr = ConfigString + 5 + 32 + 6;
1505 while (*StrPtr != L'\0' && *StrPtr != L'&') {
1506 StrPtr++;
1507 }
1508 if (*StrPtr != L'&') {
1509 return FALSE;
1510 }
1511
1512 *StrPtr = L'\0';
1513 BufferSize = (EfiStrLen (ConfigString + 5 + 32 + 6) + 1) * sizeof (CHAR16);
1514 Name = EfiLibAllocatePool (BufferSize);
1515 ASSERT (Name != NULL);
1516 Status = ConfigStringToUnicode (
1517 Name,
1518 &BufferSize,
1519 ConfigString + 5 + 32 + 6
1520 );
1521 *StrPtr = L'&';
1522
1523 if (EFI_ERROR (Status) || (EfiStrCmp (Name, StorageName) != 0)) {
1524 Match = FALSE;
1525 }
1526 gBS->FreePool (Name);
1527 }
1528
1529 return Match;
1530 }
1531
1532 BOOLEAN
1533 FindBlockName (
1534 IN OUT CHAR16 *String,
1535 UINTN Offset,
1536 UINTN Width
1537 )
1538 /*++
1539
1540 Routine Description:
1541 Search BlockName "&OFFSET=Offset&WIDTH=Width" in a string.
1542
1543 Arguments:
1544 String - The string to be searched in.
1545 Offset - Offset in BlockName.
1546 Width - Width in BlockName.
1547
1548 Returns:
1549 TRUE - Block name found.
1550 FALSE - Block name not found.
1551
1552 --*/
1553 {
1554 EFI_STATUS Status;
1555 UINTN Data;
1556 UINTN BufferSize;
1557 UINTN ConvertedStrLen;
1558
1559 while ((String = EfiStrStr (String, L"&OFFSET=")) != NULL) {
1560 //
1561 // Skip '&OFFSET='
1562 //
1563 String = String + 8;
1564
1565 Data = 0;
1566 BufferSize = sizeof (UINTN);
1567 Status = HexStringToBuf ((UINT8 *) &Data, &BufferSize, String, &ConvertedStrLen);
1568 if (EFI_ERROR (Status)) {
1569 return FALSE;
1570 }
1571 String = String + ConvertedStrLen;
1572
1573 if (Data != Offset) {
1574 continue;
1575 }
1576
1577 if (EfiStrnCmp (String, L"&WIDTH=", 7) != 0) {
1578 return FALSE;
1579 }
1580 String = String + 7;
1581
1582 Data = 0;
1583 BufferSize = sizeof (UINTN);
1584 Status = HexStringToBuf ((UINT8 *) &Data, &BufferSize, String, &ConvertedStrLen);
1585 if (EFI_ERROR (Status)) {
1586 return FALSE;
1587 }
1588 if (Data == Width) {
1589 return TRUE;
1590 }
1591
1592 String = String + ConvertedStrLen;
1593 }
1594
1595 return FALSE;
1596 }
1597
1598 EFI_STATUS
1599 GetBrowserData (
1600 EFI_GUID *VariableGuid, OPTIONAL
1601 CHAR16 *VariableName, OPTIONAL
1602 UINTN *BufferSize,
1603 UINT8 *Buffer
1604 )
1605 /*++
1606
1607 Routine Description:
1608 This routine is invoked by ConfigAccess.Callback() to retrived uncommitted data from Form Browser.
1609
1610 Arguments:
1611 VariableGuid - An optional field to indicate the target variable GUID name to use.
1612 VariableName - An optional field to indicate the target human-readable variable name.
1613 BufferSize - On input: Length in bytes of buffer to hold retrived data.
1614 On output:
1615 If return EFI_BUFFER_TOO_SMALL, containg length of buffer desired.
1616 Buffer - Buffer to hold retrived data.
1617
1618 Returns:
1619 EFI_SUCCESS - Routine success.
1620 EFI_BUFFER_TOO_SMALL - The intput buffer is too small.
1621
1622 --*/
1623 {
1624 EFI_STATUS Status;
1625 CHAR16 *ConfigHdr;
1626 CHAR16 *ConfigResp;
1627 CHAR16 *StringPtr;
1628 UINTN HeaderLen;
1629 UINTN BufferLen;
1630 CHAR16 *Progress;
1631 EFI_FORM_BROWSER2_PROTOCOL *FormBrowser2;
1632 EFI_HII_CONFIG_ROUTING_PROTOCOL *HiiConfigRouting;
1633
1634 //
1635 // Locate protocols for use
1636 //
1637 Status = gBS->LocateProtocol (&gEfiFormBrowser2ProtocolGuid, NULL, (VOID **) &FormBrowser2);
1638 if (EFI_ERROR (Status)) {
1639 return Status;
1640 }
1641
1642 Status = gBS->LocateProtocol (&gEfiHiiConfigRoutingProtocolGuid, NULL, (VOID **) &HiiConfigRouting);
1643 if (EFI_ERROR (Status)) {
1644 return Status;
1645 }
1646
1647 //
1648 // Retrive formset storage data from Form Browser
1649 //
1650 ConfigHdr = mFakeConfigHdr;
1651 HeaderLen = EfiStrLen (ConfigHdr);
1652
1653 BufferLen = 0x4000;
1654 ConfigResp = EfiLibAllocateZeroPool (BufferLen + (HeaderLen + 1) * sizeof (CHAR16));
1655
1656 StringPtr = ConfigResp + HeaderLen;
1657 *StringPtr = L'&';
1658 StringPtr++;
1659
1660 Status = FormBrowser2->BrowserCallback (
1661 FormBrowser2,
1662 &BufferLen,
1663 StringPtr,
1664 TRUE,
1665 VariableGuid,
1666 VariableName
1667 );
1668 if (Status == EFI_BUFFER_TOO_SMALL) {
1669 gBS->FreePool (ConfigResp);
1670 ConfigResp = EfiLibAllocateZeroPool (BufferLen + (HeaderLen + 1) * sizeof (CHAR16));
1671
1672 StringPtr = ConfigResp + HeaderLen;
1673 *StringPtr = L'&';
1674 StringPtr++;
1675
1676 Status = FormBrowser2->BrowserCallback (
1677 FormBrowser2,
1678 &BufferLen,
1679 StringPtr,
1680 TRUE,
1681 VariableGuid,
1682 VariableName
1683 );
1684 }
1685 if (EFI_ERROR (Status)) {
1686 gBS->FreePool (ConfigResp);
1687 return Status;
1688 }
1689 EfiCopyMem (ConfigResp, ConfigHdr, HeaderLen * sizeof (UINT16));
1690
1691 //
1692 // Convert <ConfigResp> to buffer data
1693 //
1694 Status = HiiConfigRouting->ConfigToBlock (
1695 HiiConfigRouting,
1696 ConfigResp,
1697 Buffer,
1698 BufferSize,
1699 &Progress
1700 );
1701 gBS->FreePool (ConfigResp);
1702
1703 return Status;
1704 }
1705
1706 EFI_STATUS
1707 SetBrowserData (
1708 EFI_GUID *VariableGuid, OPTIONAL
1709 CHAR16 *VariableName, OPTIONAL
1710 UINTN BufferSize,
1711 UINT8 *Buffer,
1712 CHAR16 *RequestElement OPTIONAL
1713 )
1714 /*++
1715
1716 Routine Description:
1717 This routine is invoked by ConfigAccess.Callback() to update uncommitted data of Form Browser.
1718
1719 Arguments:
1720 VariableGuid - An optional field to indicate the target variable GUID name to use.
1721 VariableName - An optional field to indicate the target human-readable variable name.
1722 BufferSize - Length in bytes of buffer to hold retrived data.
1723 Buffer - Buffer to hold retrived data.
1724 RequestElement - An optional field to specify which part of the buffer data
1725 will be send back to Browser. If NULL, the whole buffer of
1726 data will be committed to Browser.
1727 <RequestElement> ::= &OFFSET=<Number>&WIDTH=<Number>*
1728
1729 Returns:
1730 EFI_SUCCESS - Routine success.
1731 Other - Updating Browser uncommitted data failed.
1732
1733 --*/
1734 {
1735 EFI_STATUS Status;
1736 CHAR16 *ConfigHdr;
1737 CHAR16 *ConfigResp;
1738 CHAR16 *StringPtr;
1739 UINTN HeaderLen;
1740 UINTN BufferLen;
1741 CHAR16 *Progress;
1742 EFI_FORM_BROWSER2_PROTOCOL *FormBrowser2;
1743 EFI_HII_CONFIG_ROUTING_PROTOCOL *HiiConfigRouting;
1744 CHAR16 BlockName[33];
1745 CHAR16 *ConfigRequest;
1746 CHAR16 *Request;
1747
1748 //
1749 // Locate protocols for use
1750 //
1751 Status = gBS->LocateProtocol (&gEfiFormBrowser2ProtocolGuid, NULL, (VOID **) &FormBrowser2);
1752 if (EFI_ERROR (Status)) {
1753 return Status;
1754 }
1755
1756 Status = gBS->LocateProtocol (&gEfiHiiConfigRoutingProtocolGuid, NULL, (VOID **) &HiiConfigRouting);
1757 if (EFI_ERROR (Status)) {
1758 return Status;
1759 }
1760
1761 //
1762 // Prepare <ConfigRequest>
1763 //
1764 ConfigHdr = mFakeConfigHdr;
1765 HeaderLen = EfiStrLen (ConfigHdr);
1766
1767 if (RequestElement == NULL) {
1768 //
1769 // RequestElement not specified, use "&OFFSET=0&WIDTH=<BufferSize>" as <BlockName>
1770 //
1771 BlockName[0] = L'\0';
1772 EfiStrCpy (BlockName, L"&OFFSET=0&WIDTH=");
1773
1774 //
1775 // String lenghth of L"&OFFSET=0&WIDTH=" is 16
1776 //
1777 StringPtr = BlockName + 16;
1778 BufferLen = sizeof (BlockName) - (16 * sizeof (CHAR16));
1779 BufToHexString (StringPtr, &BufferLen, (UINT8 *) &BufferSize, sizeof (UINTN));
1780
1781 Request = BlockName;
1782 } else {
1783 Request = RequestElement;
1784 }
1785
1786 BufferLen = HeaderLen * sizeof (CHAR16) + EfiStrSize (Request);
1787 ConfigRequest = EfiLibAllocateZeroPool (BufferLen);
1788
1789 EfiCopyMem (ConfigRequest, ConfigHdr, HeaderLen * sizeof (CHAR16));
1790 StringPtr = ConfigRequest + HeaderLen;
1791 EfiStrCpy (StringPtr, Request);
1792
1793 //
1794 // Convert buffer to <ConfigResp>
1795 //
1796 Status = HiiConfigRouting->BlockToConfig (
1797 HiiConfigRouting,
1798 ConfigRequest,
1799 Buffer,
1800 BufferSize,
1801 &ConfigResp,
1802 &Progress
1803 );
1804 if (EFI_ERROR (Status)) {
1805 gBS->FreePool (ConfigRequest);
1806 return Status;
1807 }
1808
1809 //
1810 // Skip <ConfigHdr> and '&'
1811 //
1812 StringPtr = ConfigResp + HeaderLen + 1;
1813
1814 //
1815 // Change uncommitted data in Browser
1816 //
1817 Status = FormBrowser2->BrowserCallback (
1818 FormBrowser2,
1819 &BufferSize,
1820 StringPtr,
1821 FALSE,
1822 VariableGuid,
1823 VariableName
1824 );
1825 gBS->FreePool (ConfigResp);
1826 gBS->FreePool (ConfigRequest);
1827 return Status;
1828 }
EFI Development Kit II mirror for PVE