]> git.proxmox.com Git - mirror_edk2.git/blob - QuarkPlatformPkg/Platform/SpiFvbServices/FwBlockService.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
MdeModulePkg/Ps2MouseDxe: Use a different FILE_GUID
[mirror_edk2.git] / QuarkPlatformPkg / Platform / SpiFvbServices / FwBlockService.c
1 /** @file
2
3 Copyright (c) 2013-2015 Intel Corporation.
4
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 "FwBlockService.h"
17
18 ESAL_FWB_GLOBAL *mFvbModuleGlobal;
19
20 EFI_FW_VOL_BLOCK_DEVICE mFvbDeviceTemplate = {
21 FVB_DEVICE_SIGNATURE, // Signature
22 //
23 // FV_DEVICE_PATH FvDevicePath
24 //
25 {
26 {
27 {
28 HARDWARE_DEVICE_PATH,
29 HW_MEMMAP_DP,
30 {
31 (UINT8)(sizeof (MEMMAP_DEVICE_PATH)),
32 (UINT8)(sizeof (MEMMAP_DEVICE_PATH) >> 8)
33 }
34 },
35 EfiMemoryMappedIO,
36 (EFI_PHYSICAL_ADDRESS) 0,
37 (EFI_PHYSICAL_ADDRESS) 0
38 },
39 {
40 END_DEVICE_PATH_TYPE,
41 END_ENTIRE_DEVICE_PATH_SUBTYPE,
42 {
43 END_DEVICE_PATH_LENGTH,
44 0
45 }
46 }
47 },
48 //
49 // UEFI_FV_DEVICE_PATH UefiFvDevicePath
50 //
51 {
52 {
53 {
54 MEDIA_DEVICE_PATH,
55 MEDIA_PIWG_FW_VOL_DP,
56 {
57 (UINT8)(sizeof (MEDIA_FW_VOL_DEVICE_PATH)),
58 (UINT8)(sizeof (MEDIA_FW_VOL_DEVICE_PATH) >> 8)
59 }
60 },
61 { 0 }
62 },
63 {
64 END_DEVICE_PATH_TYPE,
65 END_ENTIRE_DEVICE_PATH_SUBTYPE,
66 {
67 END_DEVICE_PATH_LENGTH,
68 0
69 }
70 }
71 },
72 0, // Instance
73 //
74 // EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL FwVolBlockInstance
75 //
76 {
77 FvbProtocolGetAttributes,
78 FvbProtocolSetAttributes,
79 FvbProtocolGetPhysicalAddress,
80 FvbProtocolGetBlockSize,
81 FvbProtocolRead,
82 FvbProtocolWrite,
83 FvbProtocolEraseBlocks,
84 NULL
85 }
86 };
87
88 UINT32 mInSmmMode = 0;
89 EFI_SMM_SYSTEM_TABLE2* mSmst = NULL;
90
91 VOID
92 PublishFlashDeviceInfo (
93 IN SPI_INIT_TABLE *Found
94 )
95 /*++
96
97 Routine Description:
98
99 Publish info on found flash device to other drivers via PcdSpiFlashDeviceSize.
100
101 Arguments:
102 Found - Pointer to entry in mSpiInitTable for found flash part.
103
104 Returns:
105 None
106
107 --*/
108 {
109 EFI_STATUS Status;
110
111 //
112 // Publish Byte Size of found flash device.
113 //
114 Status = PcdSet32S (PcdSpiFlashDeviceSize, (UINT32)(Found->BiosStartOffset + Found->BiosSize));
115 ASSERT_EFI_ERROR (Status);
116 }
117
118 VOID
119 FvbVirtualddressChangeEvent (
120 IN EFI_EVENT Event,
121 IN VOID *Context
122 )
123 /*++
124
125 Routine Description:
126
127 Fixup internal data so that EFI and SAL can be call in virtual mode.
128 Call the passed in Child Notify event and convert the mFvbModuleGlobal
129 date items to there virtual address.
130
131 mFvbModuleGlobal->FvInstance[FVB_PHYSICAL] - Physical copy of instance data
132 mFvbModuleGlobal->FvInstance[FVB_VIRTUAL] - Virtual pointer to common
133 instance data.
134
135 Arguments:
136
137 (Standard EFI notify event - EFI_EVENT_NOTIFY)
138
139 Returns:
140
141 None
142
143 --*/
144 {
145 EFI_FW_VOL_INSTANCE *FwhInstance;
146 UINTN Index;
147
148 gRT->ConvertPointer (EFI_INTERNAL_POINTER, (VOID **) &mFvbModuleGlobal->FvInstance[FVB_VIRTUAL]);
149
150 //
151 // Convert the base address of all the instances
152 //
153 Index = 0;
154 FwhInstance = mFvbModuleGlobal->FvInstance[FVB_PHYSICAL];
155 while (Index < mFvbModuleGlobal->NumFv) {
156
157 gRT->ConvertPointer (EFI_INTERNAL_POINTER, (VOID **) &FwhInstance->FvBase[FVB_VIRTUAL]);
158 //
159 // SpiWrite and SpiErase always use Physical Address instead of
160 // Virtual Address, even in Runtime. So we need not convert pointer
161 // for FvWriteBase[FVB_VIRTUAL]
162 //
163 // EfiConvertPointer (0, (VOID **) &FwhInstance->FvWriteBase[FVB_VIRTUAL]);
164 //
165 FwhInstance = (EFI_FW_VOL_INSTANCE *)
166 (
167 (UINTN) ((UINT8 *) FwhInstance) + FwhInstance->VolumeHeader.HeaderLength +
168 (sizeof (EFI_FW_VOL_INSTANCE) - sizeof (EFI_FIRMWARE_VOLUME_HEADER))
169 );
170 Index++;
171 }
172
173 gRT->ConvertPointer (EFI_INTERNAL_POINTER, (VOID **) &mFvbModuleGlobal->FvbScratchSpace[FVB_VIRTUAL]);
174 //
175 // Convert SPI_PROTOCOL instance for runtime
176 //
177 gRT->ConvertPointer (EFI_INTERNAL_POINTER, (VOID **) &mFvbModuleGlobal->SpiProtocol);
178 gRT->ConvertPointer (EFI_INTERNAL_POINTER, (VOID **) &mFvbModuleGlobal);
179 }
180
181 VOID
182 FvbMemWrite8 (
183 IN UINT64 Dest,
184 IN UINT8 Byte
185 )
186 {
187 MmioWrite8 ((UINTN)Dest, Byte);
188
189 return ;
190 }
191
192 EFI_STATUS
193 GetFvbInstance (
194 IN UINTN Instance,
195 IN ESAL_FWB_GLOBAL *Global,
196 OUT EFI_FW_VOL_INSTANCE **FwhInstance,
197 IN BOOLEAN Virtual
198 )
199 /*++
200
201 Routine Description:
202 Retrieves the physical address of a memory mapped FV
203
204 Arguments:
205 Instance - The FV instance whose base address is going to be
206 returned
207 Global - Pointer to ESAL_FWB_GLOBAL that contains all
208 instance data
209 FwhInstance - The EFI_FW_VOL_INSTANCE fimrware instance structure
210 Virtual - Whether CPU is in virtual or physical mode
211
212 Returns:
213 EFI_SUCCESS - Successfully returns
214 EFI_INVALID_PARAMETER - Instance not found
215
216 --*/
217 {
218 EFI_FW_VOL_INSTANCE *FwhRecord;
219
220 if (Instance >= Global->NumFv) {
221 return EFI_INVALID_PARAMETER;
222 }
223 //
224 // Find the right instance of the FVB private data
225 //
226 FwhRecord = Global->FvInstance[Virtual];
227 while (Instance > 0) {
228 FwhRecord = (EFI_FW_VOL_INSTANCE *)
229 (
230 (UINTN) ((UINT8 *) FwhRecord) + FwhRecord->VolumeHeader.HeaderLength +
231 (sizeof (EFI_FW_VOL_INSTANCE) - sizeof (EFI_FIRMWARE_VOLUME_HEADER))
232 );
233 Instance--;
234 }
235
236 *FwhInstance = FwhRecord;
237
238 return EFI_SUCCESS;
239 }
240
241 EFI_STATUS
242 FvbGetPhysicalAddress (
243 IN UINTN Instance,
244 OUT EFI_PHYSICAL_ADDRESS *Address,
245 IN ESAL_FWB_GLOBAL *Global,
246 IN BOOLEAN Virtual
247 )
248 /*++
249
250 Routine Description:
251 Retrieves the physical address of a memory mapped FV
252
253 Arguments:
254 Instance - The FV instance whose base address is going to be
255 returned
256 Address - Pointer to a caller allocated EFI_PHYSICAL_ADDRESS
257 that on successful return, contains the base address
258 of the firmware volume.
259 Global - Pointer to ESAL_FWB_GLOBAL that contains all
260 instance data
261 Virtual - Whether CPU is in virtual or physical mode
262
263 Returns:
264 EFI_SUCCESS - Successfully returns
265 EFI_INVALID_PARAMETER - Instance not found
266
267 --*/
268 {
269 EFI_FW_VOL_INSTANCE *FwhInstance;
270 EFI_STATUS Status;
271
272 FwhInstance = NULL;
273
274 //
275 // Find the right instance of the FVB private data
276 //
277 Status = GetFvbInstance (Instance, Global, &FwhInstance, Virtual);
278 ASSERT_EFI_ERROR (Status);
279 *Address = FwhInstance->FvBase[Virtual];
280
281 return EFI_SUCCESS;
282 }
283
284 EFI_STATUS
285 FvbGetVolumeAttributes (
286 IN UINTN Instance,
287 OUT EFI_FVB_ATTRIBUTES_2 *Attributes,
288 IN ESAL_FWB_GLOBAL *Global,
289 IN BOOLEAN Virtual
290 )
291 /*++
292
293 Routine Description:
294 Retrieves attributes, insures positive polarity of attribute bits, returns
295 resulting attributes in output parameter
296
297 Arguments:
298 Instance - The FV instance whose attributes is going to be
299 returned
300 Attributes - Output buffer which contains attributes
301 Global - Pointer to ESAL_FWB_GLOBAL that contains all
302 instance data
303 Virtual - Whether CPU is in virtual or physical mode
304
305 Returns:
306 EFI_SUCCESS - Successfully returns
307 EFI_INVALID_PARAMETER - Instance not found
308
309 --*/
310 {
311 EFI_FW_VOL_INSTANCE *FwhInstance;
312 EFI_STATUS Status;
313
314 FwhInstance = NULL;
315
316 //
317 // Find the right instance of the FVB private data
318 //
319 Status = GetFvbInstance (Instance, Global, &FwhInstance, Virtual);
320 ASSERT_EFI_ERROR (Status);
321 *Attributes = FwhInstance->VolumeHeader.Attributes;
322
323 return EFI_SUCCESS;
324 }
325
326 EFI_STATUS
327 FvbGetLbaAddress (
328 IN UINTN Instance,
329 IN EFI_LBA Lba,
330 OUT UINTN *LbaAddress,
331 OUT UINTN *LbaWriteAddress,
332 OUT UINTN *LbaLength,
333 OUT UINTN *NumOfBlocks,
334 IN ESAL_FWB_GLOBAL *Global,
335 IN BOOLEAN Virtual
336 )
337 /*++
338
339 Routine Description:
340 Retrieves the starting address of an LBA in an FV
341
342 Arguments:
343 Instance - The FV instance which the Lba belongs to
344 Lba - The logical block address
345 LbaAddress - On output, contains the physical starting address
346 of the Lba
347 LbaWriteAddress - On output, contains the physical starting address
348 of the Lba for writing
349 LbaLength - On output, contains the length of the block
350 NumOfBlocks - A pointer to a caller allocated UINTN in which the
351 number of consecutive blocks starting with Lba is
352 returned. All blocks in this range have a size of
353 BlockSize
354 Global - Pointer to ESAL_FWB_GLOBAL that contains all
355 instance data
356 Virtual - Whether CPU is in virtual or physical mode
357
358 Returns:
359 EFI_SUCCESS - Successfully returns
360 EFI_INVALID_PARAMETER - Instance not found
361
362 --*/
363 {
364 UINT32 NumBlocks;
365 UINT32 BlockLength;
366 UINTN Offset;
367 EFI_LBA StartLba;
368 EFI_LBA NextLba;
369 EFI_FW_VOL_INSTANCE *FwhInstance;
370 EFI_FV_BLOCK_MAP_ENTRY *BlockMap;
371 EFI_STATUS Status;
372
373 FwhInstance = NULL;
374
375 //
376 // Find the right instance of the FVB private data
377 //
378 Status = GetFvbInstance (Instance, Global, &FwhInstance, Virtual);
379 ASSERT_EFI_ERROR (Status);
380
381 StartLba = 0;
382 Offset = 0;
383 BlockMap = &(FwhInstance->VolumeHeader.BlockMap[0]);
384
385 //
386 // Parse the blockmap of the FV to find which map entry the Lba belongs to
387 //
388 while (TRUE) {
389 NumBlocks = BlockMap->NumBlocks;
390 BlockLength = BlockMap->Length;
391
392 if ((NumBlocks == 0) || (BlockLength == 0)) {
393 return EFI_INVALID_PARAMETER;
394 }
395
396 NextLba = StartLba + NumBlocks;
397
398 //
399 // The map entry found
400 //
401 if (Lba >= StartLba && Lba < NextLba) {
402 Offset = Offset + (UINTN) MultU64x32 ((Lba - StartLba), BlockLength);
403 if (LbaAddress) {
404 *LbaAddress = FwhInstance->FvBase[Virtual] + Offset;
405 }
406
407 if (LbaWriteAddress) {
408 *LbaWriteAddress = FwhInstance->FvWriteBase[Virtual] + Offset;
409 }
410
411 if (LbaLength) {
412 *LbaLength = BlockLength;
413 }
414
415 if (NumOfBlocks) {
416 *NumOfBlocks = (UINTN) (NextLba - Lba);
417 }
418
419 return EFI_SUCCESS;
420 }
421
422 StartLba = NextLba;
423 Offset = Offset + NumBlocks * BlockLength;
424 BlockMap++;
425 }
426 }
427
428 EFI_STATUS
429 FvbReadBlock (
430 IN UINTN Instance,
431 IN EFI_LBA Lba,
432 IN UINTN BlockOffset,
433 IN OUT UINTN *NumBytes,
434 IN UINT8 *Buffer,
435 IN ESAL_FWB_GLOBAL *Global,
436 IN BOOLEAN Virtual
437 )
438 /*++
439
440 Routine Description:
441 Reads specified number of bytes into a buffer from the specified block
442
443 Arguments:
444 Instance - The FV instance to be read from
445 Lba - The logical block address to be read from
446 BlockOffset - Offset into the block at which to begin reading
447 NumBytes - Pointer that on input contains the total size of
448 the buffer. On output, it contains the total number
449 of bytes read
450 Buffer - Pointer to a caller allocated buffer that will be
451 used to hold the data read
452 Global - Pointer to ESAL_FWB_GLOBAL that contains all
453 instance data
454 Virtual - Whether CPU is in virtual or physical mode
455
456 Returns:
457 EFI_SUCCESS - The firmware volume was read successfully and
458 contents are in Buffer
459 EFI_BAD_BUFFER_SIZE - Read attempted across a LBA boundary. On output,
460 NumBytes contains the total number of bytes returned
461 in Buffer
462 EFI_ACCESS_DENIED - The firmware volume is in the ReadDisabled state
463 EFI_DEVICE_ERROR - The block device is not functioning correctly and
464 could not be read
465 EFI_INVALID_PARAMETER - Instance not found, or NumBytes, Buffer are NULL
466
467 --*/
468 {
469 EFI_FVB_ATTRIBUTES_2 Attributes;
470 UINTN LbaAddress;
471 UINTN LbaLength;
472 EFI_STATUS Status;
473
474 //
475 // Check for invalid conditions
476 //
477 if ((NumBytes == NULL) || (Buffer == NULL)) {
478 return EFI_INVALID_PARAMETER;
479 }
480
481 if (*NumBytes == 0) {
482 return EFI_INVALID_PARAMETER;
483 }
484
485 Status = FvbGetLbaAddress (Instance, Lba, &LbaAddress, NULL, &LbaLength, NULL, Global, Virtual);
486 if (EFI_ERROR (Status)) {
487 return Status;
488 }
489 //
490 // Check if the FV is read enabled
491 //
492 FvbGetVolumeAttributes (Instance, &Attributes, Global, Virtual);
493
494 if ((Attributes & EFI_FVB2_READ_STATUS) == 0) {
495 return EFI_ACCESS_DENIED;
496 }
497 //
498 // Perform boundary checks and adjust NumBytes
499 //
500 if (BlockOffset > LbaLength) {
501 return EFI_INVALID_PARAMETER;
502 }
503
504 if (LbaLength < (*NumBytes + BlockOffset)) {
505 *NumBytes = (UINT32) (LbaLength - BlockOffset);
506 Status = EFI_BAD_BUFFER_SIZE;
507 }
508
509 MmioReadBuffer8 (LbaAddress + BlockOffset, (UINTN) *NumBytes, Buffer);
510
511 return Status;
512 }
513
514 EFI_STATUS
515 FlashFdWrite (
516 IN UINTN WriteAddress,
517 IN UINTN Address,
518 IN OUT UINTN *NumBytes,
519 IN UINT8 *Buffer,
520 IN UINTN LbaLength
521 )
522 /*++
523
524 Routine Description:
525 Writes specified number of bytes from the input buffer to the address
526
527 Arguments:
528
529 Returns:
530
531 --*/
532 {
533 EFI_STATUS Status;
534
535 Status = EFI_SUCCESS;
536
537 //
538 // TODO: Suggested that this code be "critical section"
539 //
540 WriteAddress -= ( PcdGet32 (PcdFlashAreaBaseAddress) );
541 if (mInSmmMode == 0) { // !(EfiInManagementInterrupt ())) {
542 Status = mFvbModuleGlobal->SpiProtocol->Execute (
543 mFvbModuleGlobal->SpiProtocol,
544 SPI_OPCODE_WRITE_INDEX, // OpcodeIndex
545 0, // PrefixOpcodeIndex
546 TRUE, // DataCycle
547 TRUE, // Atomic
548 TRUE, // ShiftOut
549 WriteAddress, // Address
550 (UINT32) (*NumBytes), // Data Number
551 Buffer,
552 EnumSpiRegionBios
553 );
554
555 } else {
556 Status = mFvbModuleGlobal->SmmSpiProtocol->Execute (
557 mFvbModuleGlobal->SmmSpiProtocol,
558 SPI_OPCODE_WRITE_INDEX, // OpcodeIndex
559 0, // PrefixOpcodeIndex
560 TRUE, // DataCycle
561 TRUE, // Atomic
562 TRUE, // ShiftOut
563 WriteAddress, // Address
564 (UINT32) (*NumBytes), // Data Number
565 Buffer,
566 EnumSpiRegionBios
567 );
568 }
569
570 AsmWbinvd ();
571
572 return Status;
573 }
574
575 EFI_STATUS
576 FlashFdErase (
577 IN UINTN WriteAddress,
578 IN UINTN Address,
579 IN UINTN LbaLength
580 )
581 /*++
582
583 Routine Description:
584 Erase a certain block from address LbaWriteAddress
585
586 Arguments:
587
588 Returns:
589
590 --*/
591 {
592 EFI_STATUS Status;
593 UINTN NumBytes;
594
595 NumBytes = LbaLength;
596
597 WriteAddress -= (PcdGet32 (PcdFlashAreaBaseAddress));
598 if (mInSmmMode == 0 ) { // !(EfiInManagementInterrupt ())) {
599 Status = mFvbModuleGlobal->SpiProtocol->Execute (
600 mFvbModuleGlobal->SpiProtocol,
601 SPI_OPCODE_ERASE_INDEX, // OpcodeIndex
602 0, // PrefixOpcodeIndex
603 FALSE, // DataCycle
604 TRUE, // Atomic
605 FALSE, // ShiftOut
606 WriteAddress, // Address
607 0, // Data Number
608 NULL,
609 EnumSpiRegionBios // SPI_REGION_TYPE
610 );
611 } else {
612 Status = mFvbModuleGlobal->SmmSpiProtocol->Execute (
613 mFvbModuleGlobal->SmmSpiProtocol,
614 SPI_OPCODE_ERASE_INDEX, // OpcodeIndex
615 0, // PrefixOpcodeIndex
616 FALSE, // DataCycle
617 TRUE, // Atomic
618 FALSE, // ShiftOut
619 WriteAddress, // Address
620 0, // Data Number
621 NULL,
622 EnumSpiRegionBios // SPI_REGION_TYPE
623 );
624 }
625
626 AsmWbinvd ();
627
628 return Status;
629 }
630
631 EFI_STATUS
632 FvbWriteBlock (
633 IN UINTN Instance,
634 IN EFI_LBA Lba,
635 IN UINTN BlockOffset,
636 IN OUT UINTN *NumBytes,
637 IN UINT8 *Buffer,
638 IN ESAL_FWB_GLOBAL *Global,
639 IN BOOLEAN Virtual
640 )
641 /*++
642
643 Routine Description:
644 Writes specified number of bytes from the input buffer to the block
645
646 Arguments:
647 Instance - The FV instance to be written to
648 Lba - The starting logical block index to write to
649 BlockOffset - Offset into the block at which to begin writing
650 NumBytes - Pointer that on input contains the total size of
651 the buffer. On output, it contains the total number
652 of bytes actually written
653 Buffer - Pointer to a caller allocated buffer that contains
654 the source for the write
655 Global - Pointer to ESAL_FWB_GLOBAL that contains all
656 instance data
657 Virtual - Whether CPU is in virtual or physical mode
658
659 Returns:
660 EFI_SUCCESS - The firmware volume was written successfully
661 EFI_BAD_BUFFER_SIZE - Write attempted across a LBA boundary. On output,
662 NumBytes contains the total number of bytes
663 actually written
664 EFI_ACCESS_DENIED - The firmware volume is in the WriteDisabled state
665 EFI_DEVICE_ERROR - The block device is not functioning correctly and
666 could not be written
667 EFI_INVALID_PARAMETER - Instance not found, or NumBytes, Buffer are NULL
668
669 --*/
670 {
671 EFI_FVB_ATTRIBUTES_2 Attributes;
672 UINTN LbaAddress;
673 UINTN LbaWriteAddress;
674 UINTN LbaLength;
675 EFI_FW_VOL_INSTANCE *FwhInstance;
676 EFI_STATUS Status;
677 EFI_STATUS ReturnStatus;
678
679 FwhInstance = NULL;
680
681 //
682 // Find the right instance of the FVB private data
683 //
684 Status = GetFvbInstance (Instance, Global, &FwhInstance, Virtual);
685 ASSERT_EFI_ERROR (Status);
686
687 //
688 // Writes are enabled in the init routine itself
689 //
690 if (!FwhInstance->WriteEnabled) {
691 return EFI_ACCESS_DENIED;
692 }
693 //
694 // Check for invalid conditions
695 //
696 if ((NumBytes == NULL) || (Buffer == NULL)) {
697 return EFI_INVALID_PARAMETER;
698 }
699
700 if (*NumBytes == 0) {
701 return EFI_INVALID_PARAMETER;
702 }
703
704 Status = FvbGetLbaAddress (Instance, Lba, &LbaAddress, &LbaWriteAddress, &LbaLength, NULL, Global, Virtual);
705 if (EFI_ERROR (Status)) {
706 return Status;
707 }
708 //
709 // Check if the FV is write enabled
710 //
711 FvbGetVolumeAttributes (Instance, &Attributes, Global, Virtual);
712
713 if ((Attributes & EFI_FVB2_WRITE_STATUS) == 0) {
714 return EFI_ACCESS_DENIED;
715 }
716 //
717 // Perform boundary checks and adjust NumBytes
718 //
719 if (BlockOffset > LbaLength) {
720 return EFI_INVALID_PARAMETER;
721 }
722
723 if (LbaLength < (*NumBytes + BlockOffset)) {
724 *NumBytes = (UINT32) (LbaLength - BlockOffset);
725 Status = EFI_BAD_BUFFER_SIZE;
726 }
727
728 ReturnStatus = FlashFdWrite (
729 LbaWriteAddress + BlockOffset,
730 LbaAddress,
731 NumBytes,
732 Buffer,
733 LbaLength
734 );
735 if (EFI_ERROR (ReturnStatus)) {
736 return ReturnStatus;
737 }
738
739 return Status;
740 }
741
742 EFI_STATUS
743 FvbEraseBlock (
744 IN UINTN Instance,
745 IN EFI_LBA Lba,
746 IN ESAL_FWB_GLOBAL *Global,
747 IN BOOLEAN Virtual
748 )
749 /*++
750
751 Routine Description:
752 Erases and initializes a firmware volume block
753
754 Arguments:
755 Instance - The FV instance to be erased
756 Lba - The logical block index to be erased
757 Global - Pointer to ESAL_FWB_GLOBAL that contains all
758 instance data
759 Virtual - Whether CPU is in virtual or physical mode
760
761 Returns:
762 EFI_SUCCESS - The erase request was successfully completed
763 EFI_ACCESS_DENIED - The firmware volume is in the WriteDisabled state
764 EFI_DEVICE_ERROR - The block device is not functioning correctly and
765 could not be written. Firmware device may have been
766 partially erased
767 EFI_INVALID_PARAMETER - Instance not found
768
769 --*/
770 {
771
772 EFI_FVB_ATTRIBUTES_2 Attributes;
773 UINTN LbaAddress;
774 UINTN LbaWriteAddress;
775 EFI_FW_VOL_INSTANCE *FwhInstance;
776 UINTN LbaLength;
777 EFI_STATUS Status;
778 UINTN SectorNum;
779 UINTN Index;
780
781 FwhInstance = NULL;
782
783 //
784 // Find the right instance of the FVB private data
785 //
786 Status = GetFvbInstance (Instance, Global, &FwhInstance, Virtual);
787 ASSERT_EFI_ERROR (Status);
788
789 //
790 // Writes are enabled in the init routine itself
791 //
792 if (!FwhInstance->WriteEnabled) {
793 return EFI_ACCESS_DENIED;
794 }
795 //
796 // Check if the FV is write enabled
797 //
798 FvbGetVolumeAttributes (Instance, &Attributes, Global, Virtual);
799
800 if ((Attributes & EFI_FVB2_WRITE_STATUS) == 0) {
801 return EFI_ACCESS_DENIED;
802 }
803 //
804 // Get the starting address of the block for erase. For debug reasons,
805 // LbaWriteAddress may not be the same as LbaAddress.
806 //
807 Status = FvbGetLbaAddress (Instance, Lba, &LbaAddress, &LbaWriteAddress, &LbaLength, NULL, Global, Virtual);
808 if (EFI_ERROR (Status)) {
809 return Status;
810 }
811
812 SectorNum = LbaLength / SPI_ERASE_SECTOR_SIZE;
813 for (Index = 0; Index < SectorNum; Index++){
814 Status = FlashFdErase (
815 LbaWriteAddress + Index * SPI_ERASE_SECTOR_SIZE,
816 LbaAddress,
817 SPI_ERASE_SECTOR_SIZE
818 );
819 if (Status != EFI_SUCCESS){
820 break;
821 }
822 }
823
824 return Status;
825 }
826
827 EFI_STATUS
828 FvbEraseCustomBlockRange (
829 IN UINTN Instance,
830 IN EFI_LBA StartLba,
831 IN UINTN OffsetStartLba,
832 IN EFI_LBA LastLba,
833 IN UINTN OffsetLastLba,
834 IN ESAL_FWB_GLOBAL *Global,
835 IN BOOLEAN Virtual
836 )
837 /*++
838
839 Routine Description:
840 Erases and initializes a specified range of a firmware volume
841
842 Arguments:
843 Instance - The FV instance to be erased
844 StartLba - The starting logical block index to be erased
845 OffsetStartLba - Offset into the starting block at which to
846 begin erasing
847 LastLba - The last logical block index to be erased
848 OffsetStartLba - Offset into the last block at which to end erasing
849 Global - Pointer to ESAL_FWB_GLOBAL that contains all
850 instance data
851 Virtual - Whether CPU is in virtual or physical mode
852
853 Returns:
854 EFI_SUCCESS - The firmware volume was erased successfully
855 EFI_ACCESS_DENIED - The firmware volume is in the WriteDisabled state
856 EFI_DEVICE_ERROR - The block device is not functioning correctly and
857 could not be written. Firmware device may have been
858 partially erased
859 EFI_INVALID_PARAMETER - Instance not found
860
861 --*/
862 {
863 EFI_LBA Index;
864 UINTN LbaSize;
865 UINTN ScratchLbaSizeData;
866
867 //
868 // First LBA.
869 //
870 FvbGetLbaAddress (Instance, StartLba, NULL, NULL, &LbaSize, NULL, Global, Virtual);
871
872 //
873 // Use the scratch space as the intermediate buffer to transfer data
874 // Back up the first LBA in scratch space.
875 //
876 FvbReadBlock (Instance, StartLba, 0, &LbaSize, Global->FvbScratchSpace[Virtual], Global, Virtual);
877
878 //
879 // erase now
880 //
881 FvbEraseBlock (Instance, StartLba, Global, Virtual);
882 ScratchLbaSizeData = OffsetStartLba;
883
884 //
885 // write the data back to the first block
886 //
887 if (ScratchLbaSizeData > 0) {
888 FvbWriteBlock (Instance, StartLba, 0, &ScratchLbaSizeData, Global->FvbScratchSpace[Virtual], Global, Virtual);
889 }
890 //
891 // Middle LBAs
892 //
893 if (LastLba > (StartLba + 1)) {
894 for (Index = (StartLba + 1); Index <= (LastLba - 1); Index++) {
895 FvbEraseBlock (Instance, Index, Global, Virtual);
896 }
897 }
898 //
899 // Last LBAs, the same as first LBAs
900 //
901 if (LastLba > StartLba) {
902 FvbGetLbaAddress (Instance, LastLba, NULL, NULL, &LbaSize, NULL, Global, Virtual);
903 FvbReadBlock (Instance, LastLba, 0, &LbaSize, Global->FvbScratchSpace[Virtual], Global, Virtual);
904 FvbEraseBlock (Instance, LastLba, Global, Virtual);
905 }
906
907 ScratchLbaSizeData = LbaSize - (OffsetStartLba + 1);
908
909 return FvbWriteBlock (
910 Instance,
911 LastLba,
912 (OffsetLastLba + 1),
913 &ScratchLbaSizeData,
914 Global->FvbScratchSpace[Virtual],
915 Global,
916 Virtual
917 );
918 }
919
920 EFI_STATUS
921 FvbSetVolumeAttributes (
922 IN UINTN Instance,
923 IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes,
924 IN ESAL_FWB_GLOBAL *Global,
925 IN BOOLEAN Virtual
926 )
927 /*++
928
929 Routine Description:
930 Modifies the current settings of the firmware volume according to the
931 input parameter, and returns the new setting of the volume
932
933 Arguments:
934 Instance - The FV instance whose attributes is going to be
935 modified
936 Attributes - On input, it is a pointer to EFI_FVB_ATTRIBUTES_2
937 containing the desired firmware volume settings.
938 On successful return, it contains the new settings
939 of the firmware volume
940 Global - Pointer to ESAL_FWB_GLOBAL that contains all
941 instance data
942 Virtual - Whether CPU is in virtual or physical mode
943
944 Returns:
945 EFI_SUCCESS - Successfully returns
946 EFI_ACCESS_DENIED - The volume setting is locked and cannot be modified
947 EFI_INVALID_PARAMETER - Instance not found, or The attributes requested are
948 in conflict with the capabilities as declared in the
949 firmware volume header
950
951 --*/
952 {
953 EFI_FW_VOL_INSTANCE *FwhInstance;
954 EFI_FVB_ATTRIBUTES_2 OldAttributes;
955 EFI_FVB_ATTRIBUTES_2 *AttribPtr;
956 UINT32 Capabilities;
957 UINT32 OldStatus;
958 UINT32 NewStatus;
959 EFI_STATUS Status;
960
961 FwhInstance = NULL;
962
963 //
964 // Find the right instance of the FVB private data
965 //
966 Status = GetFvbInstance (Instance, Global, &FwhInstance, Virtual);
967 ASSERT_EFI_ERROR (Status);
968
969 AttribPtr = (EFI_FVB_ATTRIBUTES_2 *) &(FwhInstance->VolumeHeader.Attributes);
970 OldAttributes = *AttribPtr;
971 Capabilities = OldAttributes & EFI_FVB2_CAPABILITIES;
972 OldStatus = OldAttributes & EFI_FVB2_STATUS;
973 NewStatus = *Attributes & EFI_FVB2_STATUS;
974
975 //
976 // If firmware volume is locked, no status bit can be updated
977 //
978 if (OldAttributes & EFI_FVB2_LOCK_STATUS) {
979 if (OldStatus ^ NewStatus) {
980 return EFI_ACCESS_DENIED;
981 }
982 }
983 //
984 // Test read disable
985 //
986 if ((Capabilities & EFI_FVB2_READ_DISABLED_CAP) == 0) {
987 if ((NewStatus & EFI_FVB2_READ_STATUS) == 0) {
988 return EFI_INVALID_PARAMETER;
989 }
990 }
991 //
992 // Test read enable
993 //
994 if ((Capabilities & EFI_FVB2_READ_ENABLED_CAP) == 0) {
995 if (NewStatus & EFI_FVB2_READ_STATUS) {
996 return EFI_INVALID_PARAMETER;
997 }
998 }
999 //
1000 // Test write disable
1001 //
1002 if ((Capabilities & EFI_FVB2_WRITE_DISABLED_CAP) == 0) {
1003 if ((NewStatus & EFI_FVB2_WRITE_STATUS) == 0) {
1004 return EFI_INVALID_PARAMETER;
1005 }
1006 }
1007 //
1008 // Test write enable
1009 //
1010 if ((Capabilities & EFI_FVB2_WRITE_ENABLED_CAP) == 0) {
1011 if (NewStatus & EFI_FVB2_WRITE_STATUS) {
1012 return EFI_INVALID_PARAMETER;
1013 }
1014 }
1015 //
1016 // Test lock
1017 //
1018 if ((Capabilities & EFI_FVB2_LOCK_CAP) == 0) {
1019 if (NewStatus & EFI_FVB2_LOCK_STATUS) {
1020 return EFI_INVALID_PARAMETER;
1021 }
1022 }
1023
1024 *AttribPtr = (*AttribPtr) & (0xFFFFFFFF & (~EFI_FVB2_STATUS));
1025 *AttribPtr = (*AttribPtr) | NewStatus;
1026 *Attributes = *AttribPtr;
1027
1028 return EFI_SUCCESS;
1029 }
1030 //
1031 // FVB protocol APIs
1032 //
1033 EFI_STATUS
1034 EFIAPI
1035 FvbProtocolGetPhysicalAddress (
1036 IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
1037 OUT EFI_PHYSICAL_ADDRESS *Address
1038 )
1039 /*++
1040
1041 Routine Description:
1042
1043 Retrieves the physical address of the device.
1044
1045 Arguments:
1046
1047 This - Calling context
1048 Address - Output buffer containing the address.
1049
1050 Returns:
1051
1052 Returns:
1053 EFI_SUCCESS - Successfully returns
1054
1055 --*/
1056 {
1057 EFI_FW_VOL_BLOCK_DEVICE *FvbDevice;
1058
1059 FvbDevice = FVB_DEVICE_FROM_THIS (This);
1060
1061 return FvbGetPhysicalAddress (FvbDevice->Instance, Address, mFvbModuleGlobal, EfiGoneVirtual ());
1062 }
1063
1064 EFI_STATUS
1065 FvbProtocolGetBlockSize (
1066 IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
1067 IN EFI_LBA Lba,
1068 OUT UINTN *BlockSize,
1069 OUT UINTN *NumOfBlocks
1070 )
1071 /*++
1072
1073 Routine Description:
1074 Retrieve the size of a logical block
1075
1076 Arguments:
1077 This - Calling context
1078 Lba - Indicates which block to return the size for.
1079 BlockSize - A pointer to a caller allocated UINTN in which
1080 the size of the block is returned
1081 NumOfBlocks - a pointer to a caller allocated UINTN in which the
1082 number of consecutive blocks starting with Lba is
1083 returned. All blocks in this range have a size of
1084 BlockSize
1085
1086 Returns:
1087 EFI_SUCCESS - The firmware volume was read successfully and
1088 contents are in Buffer
1089
1090 --*/
1091 {
1092 EFI_FW_VOL_BLOCK_DEVICE *FvbDevice;
1093
1094 FvbDevice = FVB_DEVICE_FROM_THIS (This);
1095
1096 return FvbGetLbaAddress (
1097 FvbDevice->Instance,
1098 Lba,
1099 NULL,
1100 NULL,
1101 BlockSize,
1102 NumOfBlocks,
1103 mFvbModuleGlobal,
1104 EfiGoneVirtual ()
1105 );
1106 }
1107
1108 EFI_STATUS
1109 EFIAPI
1110 FvbProtocolGetAttributes (
1111 IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
1112 OUT EFI_FVB_ATTRIBUTES_2 *Attributes
1113 )
1114 /*++
1115
1116 Routine Description:
1117 Retrieves Volume attributes. No polarity translations are done.
1118
1119 Arguments:
1120 This - Calling context
1121 Attributes - output buffer which contains attributes
1122
1123 Returns:
1124 EFI_SUCCESS - Successfully returns
1125
1126 --*/
1127 {
1128 EFI_FW_VOL_BLOCK_DEVICE *FvbDevice;
1129
1130 FvbDevice = FVB_DEVICE_FROM_THIS (This);
1131
1132 return FvbGetVolumeAttributes (FvbDevice->Instance, Attributes, mFvbModuleGlobal, EfiGoneVirtual ());
1133 }
1134
1135 EFI_STATUS
1136 EFIAPI
1137 FvbProtocolSetAttributes (
1138 IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
1139 IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes
1140 )
1141 /*++
1142
1143 Routine Description:
1144 Sets Volume attributes. No polarity translations are done.
1145
1146 Arguments:
1147 This - Calling context
1148 Attributes - output buffer which contains attributes
1149
1150 Returns:
1151 EFI_SUCCESS - Successfully returns
1152
1153 --*/
1154 {
1155 EFI_FW_VOL_BLOCK_DEVICE *FvbDevice;
1156
1157 FvbDevice = FVB_DEVICE_FROM_THIS (This);
1158
1159 return FvbSetVolumeAttributes (FvbDevice->Instance, Attributes, mFvbModuleGlobal, EfiGoneVirtual ());
1160 }
1161
1162 EFI_STATUS
1163 EFIAPI
1164 FvbProtocolEraseBlocks (
1165 IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
1166 ...
1167 )
1168 /*++
1169
1170 Routine Description:
1171
1172 The EraseBlock() function erases one or more blocks as denoted by the
1173 variable argument list. The entire parameter list of blocks must be verified
1174 prior to erasing any blocks. If a block is requested that does not exist
1175 within the associated firmware volume (it has a larger index than the last
1176 block of the firmware volume), the EraseBlock() function must return
1177 EFI_INVALID_PARAMETER without modifying the contents of the firmware volume.
1178
1179 Arguments:
1180 This - Calling context
1181 ... - Starting LBA followed by Number of Lba to erase.
1182 a -1 to terminate the list.
1183
1184 Returns:
1185 EFI_SUCCESS - The erase request was successfully completed
1186 EFI_ACCESS_DENIED - The firmware volume is in the WriteDisabled state
1187 EFI_DEVICE_ERROR - The block device is not functioning correctly and
1188 could not be written. Firmware device may have been
1189 partially erased
1190
1191 --*/
1192 {
1193 EFI_FW_VOL_BLOCK_DEVICE *FvbDevice;
1194 EFI_FW_VOL_INSTANCE *FwhInstance;
1195 UINTN NumOfBlocks;
1196 VA_LIST args;
1197 EFI_LBA StartingLba;
1198 UINTN NumOfLba;
1199 EFI_STATUS Status;
1200
1201 FwhInstance = NULL;
1202 FvbDevice = FVB_DEVICE_FROM_THIS (This);
1203
1204 Status = GetFvbInstance (FvbDevice->Instance, mFvbModuleGlobal, &FwhInstance, EfiGoneVirtual ());
1205 ASSERT_EFI_ERROR (Status);
1206
1207 NumOfBlocks = FwhInstance->NumOfBlocks;
1208
1209 VA_START (args, This);
1210
1211 do {
1212 StartingLba = VA_ARG (args, EFI_LBA);
1213 if (StartingLba == EFI_LBA_LIST_TERMINATOR) {
1214 break;
1215 }
1216
1217 NumOfLba = VA_ARG (args, UINT32);
1218
1219 //
1220 // Check input parameters
1221 //
1222 if (NumOfLba == 0) {
1223 VA_END (args);
1224 return EFI_INVALID_PARAMETER;
1225 }
1226
1227 if ((StartingLba + NumOfLba) > NumOfBlocks) {
1228 return EFI_INVALID_PARAMETER;
1229 }
1230 } while (TRUE);
1231
1232 VA_END (args);
1233
1234 VA_START (args, This);
1235 do {
1236 StartingLba = VA_ARG (args, EFI_LBA);
1237 if (StartingLba == EFI_LBA_LIST_TERMINATOR) {
1238 break;
1239 }
1240
1241 NumOfLba = VA_ARG (args, UINT32);
1242
1243 while (NumOfLba > 0) {
1244 Status = FvbEraseBlock (FvbDevice->Instance, StartingLba, mFvbModuleGlobal, EfiGoneVirtual ());
1245 if (EFI_ERROR (Status)) {
1246 VA_END (args);
1247 return Status;
1248 }
1249
1250 StartingLba++;
1251 NumOfLba--;
1252 }
1253
1254 } while (TRUE);
1255
1256 VA_END (args);
1257
1258 return EFI_SUCCESS;
1259 }
1260
1261 EFI_STATUS
1262 EFIAPI
1263 FvbProtocolWrite (
1264 IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
1265 IN EFI_LBA Lba,
1266 IN UINTN Offset,
1267 IN OUT UINTN *NumBytes,
1268 IN UINT8 *Buffer
1269 )
1270 /*++
1271
1272 Routine Description:
1273
1274 Writes data beginning at Lba:Offset from FV. The write terminates either
1275 when *NumBytes of data have been written, or when a block boundary is
1276 reached. *NumBytes is updated to reflect the actual number of bytes
1277 written. The write opertion does not include erase. This routine will
1278 attempt to write only the specified bytes. If the writes do not stick,
1279 it will return an error.
1280
1281 Arguments:
1282 This - Calling context
1283 Lba - Block in which to begin write
1284 Offset - Offset in the block at which to begin write
1285 NumBytes - On input, indicates the requested write size. On
1286 output, indicates the actual number of bytes written
1287 Buffer - Buffer containing source data for the write.
1288
1289 Returns:
1290 EFI_SUCCESS - The firmware volume was written successfully
1291 EFI_BAD_BUFFER_SIZE - Write attempted across a LBA boundary. On output,
1292 NumBytes contains the total number of bytes
1293 actually written
1294 EFI_ACCESS_DENIED - The firmware volume is in the WriteDisabled state
1295 EFI_DEVICE_ERROR - The block device is not functioning correctly and
1296 could not be written
1297 EFI_INVALID_PARAMETER - NumBytes or Buffer are NULL
1298
1299 --*/
1300 {
1301
1302 EFI_FW_VOL_BLOCK_DEVICE *FvbDevice;
1303
1304 FvbDevice = FVB_DEVICE_FROM_THIS (This);
1305
1306 return FvbWriteBlock (FvbDevice->Instance, Lba, Offset, NumBytes, Buffer, mFvbModuleGlobal, EfiGoneVirtual ());
1307 }
1308
1309 EFI_STATUS
1310 EFIAPI
1311 FvbProtocolRead (
1312 IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
1313 IN EFI_LBA Lba,
1314 IN UINTN Offset,
1315 IN OUT UINTN *NumBytes,
1316 IN UINT8 *Buffer
1317 )
1318 /*++
1319
1320 Routine Description:
1321
1322 Reads data beginning at Lba:Offset from FV. The Read terminates either
1323 when *NumBytes of data have been read, or when a block boundary is
1324 reached. *NumBytes is updated to reflect the actual number of bytes
1325 written. The write opertion does not include erase. This routine will
1326 attempt to write only the specified bytes. If the writes do not stick,
1327 it will return an error.
1328
1329 Arguments:
1330 This - Calling context
1331 Lba - Block in which to begin Read
1332 Offset - Offset in the block at which to begin Read
1333 NumBytes - On input, indicates the requested write size. On
1334 output, indicates the actual number of bytes Read
1335 Buffer - Buffer containing source data for the Read.
1336
1337 Returns:
1338 EFI_SUCCESS - The firmware volume was read successfully and
1339 contents are in Buffer
1340 EFI_BAD_BUFFER_SIZE - Read attempted across a LBA boundary. On output,
1341 NumBytes contains the total number of bytes returned
1342 in Buffer
1343 EFI_ACCESS_DENIED - The firmware volume is in the ReadDisabled state
1344 EFI_DEVICE_ERROR - The block device is not functioning correctly and
1345 could not be read
1346 EFI_INVALID_PARAMETER - NumBytes or Buffer are NULL
1347
1348 --*/
1349 {
1350
1351 EFI_FW_VOL_BLOCK_DEVICE *FvbDevice;
1352 EFI_STATUS Status;
1353
1354 FvbDevice = FVB_DEVICE_FROM_THIS (This);
1355 Status = FvbReadBlock (FvbDevice->Instance, Lba, Offset, NumBytes, Buffer, mFvbModuleGlobal, EfiGoneVirtual ());
1356
1357 return Status;
1358 }
1359
1360 EFI_STATUS
1361 ValidateFvHeader (
1362 EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader
1363 )
1364 /*++
1365
1366 Routine Description:
1367 Check the integrity of firmware volume header
1368
1369 Arguments:
1370 FwVolHeader - A pointer to a firmware volume header
1371
1372 Returns:
1373 EFI_SUCCESS - The firmware volume is consistent
1374 EFI_NOT_FOUND - The firmware volume has corrupted. So it is not an FV
1375
1376 --*/
1377 {
1378 UINT16 *Ptr;
1379 UINT16 HeaderLength;
1380 UINT16 Checksum;
1381
1382 //
1383 // Verify the header revision, header signature, length
1384 // Length of FvBlock cannot be 2**64-1
1385 // HeaderLength cannot be an odd number
1386 //
1387 #ifndef R864_BUILD
1388 if (((FwVolHeader->Revision != EFI_FVH_REVISION) && (FwVolHeader->Revision != EFI_FVH_REVISION)) ||
1389 #else
1390 if ((FwVolHeader->Revision != EFI_FVH_REVISION) ||
1391 #endif
1392 (FwVolHeader->Signature != EFI_FVH_SIGNATURE) ||
1393 (FwVolHeader->FvLength == ((UINTN) -1)) ||
1394 ((FwVolHeader->HeaderLength & 0x01) != 0)
1395 ) {
1396 return EFI_NOT_FOUND;
1397 }
1398 //
1399 // Verify the header checksum
1400 //
1401 HeaderLength = (UINT16) (FwVolHeader->HeaderLength / 2);
1402 Ptr = (UINT16 *) FwVolHeader;
1403 Checksum = 0;
1404 while (HeaderLength > 0) {
1405 Checksum = Checksum + (*Ptr);
1406 Ptr++;
1407 HeaderLength--;
1408 }
1409
1410 if (Checksum != 0) {
1411 return EFI_NOT_FOUND;
1412 }
1413
1414 return EFI_SUCCESS;
1415 }
1416
1417 EFI_STATUS
1418 GetFvbHeader (
1419 VOID **HobList,
1420 OUT EFI_FIRMWARE_VOLUME_HEADER **FwVolHeader,
1421 OUT EFI_PHYSICAL_ADDRESS *BaseAddress,
1422 OUT BOOLEAN *WriteBack
1423 )
1424 {
1425 EFI_STATUS Status;
1426
1427 Status = EFI_SUCCESS;
1428 *WriteBack = FALSE;
1429
1430 if (*FwVolHeader == NULL) {
1431 *BaseAddress = PcdGet32 (PcdFlashFvRecoveryBase);
1432 } else if (*FwVolHeader == (VOID *)(UINTN)PcdGet32 (PcdFlashFvRecoveryBase)) {
1433 *BaseAddress = PcdGet32 (PcdFlashFvMainBase);
1434 } else if (*FwVolHeader == (VOID *)(UINTN)PcdGet32 (PcdFlashFvMainBase)) {
1435 *BaseAddress = PcdGet32 (PcdFlashNvStorageVariableBase);
1436 } else {
1437 return EFI_NOT_FOUND;
1438 }
1439
1440 DEBUG((EFI_D_INFO, "Fvb base : %08x\n",*BaseAddress));
1441
1442 *FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) (*BaseAddress);
1443 Status = ValidateFvHeader (*FwVolHeader);
1444 if (EFI_ERROR (Status)) {
1445 //
1446 // Get FvbInfo
1447 //
1448 *WriteBack = TRUE;
1449
1450 Status = GetFvbInfo (*BaseAddress, FwVolHeader);
1451 DEBUG(( DEBUG_ERROR, "Through GetFvbInfo: %08x!\n",*BaseAddress));
1452
1453 ASSERT_EFI_ERROR (Status);
1454 }
1455
1456 return EFI_SUCCESS;
1457 }
1458
1459
1460 EFI_STATUS
1461 SmmSpiInit (
1462 VOID
1463 )
1464 {
1465 UINT8 SpiStatus;
1466 UINT8 FlashIndex;
1467 UINT8 FlashID[3];
1468 EFI_STATUS Status;
1469
1470 //
1471 // Obtain a handle for ICH SPI Protocol
1472 //
1473 ASSERT(mSmst != NULL);
1474 if (mFvbModuleGlobal->SmmSpiProtocol == NULL){
1475 Status = mSmst->SmmLocateProtocol (&gEfiSmmSpiProtocolGuid, NULL, (VOID **) &mFvbModuleGlobal->SmmSpiProtocol);
1476 ASSERT_EFI_ERROR(Status);
1477 }
1478 //
1479 // attempt to identify flash part and initialize spi table
1480 //
1481 for (FlashIndex = 0; FlashIndex < EnumSpiFlashMax; FlashIndex++) {
1482 Status = mFvbModuleGlobal->SmmSpiProtocol->Init (
1483 mFvbModuleGlobal->SmmSpiProtocol,
1484 &(mSpiInitTable[FlashIndex])
1485 );
1486 if (!EFI_ERROR (Status)) {
1487 //
1488 // read vendor/device IDs to check if flash device is supported
1489 //
1490 Status = mFvbModuleGlobal->SmmSpiProtocol->Execute (
1491 mFvbModuleGlobal->SmmSpiProtocol,
1492 SPI_OPCODE_JEDEC_ID_INDEX,
1493 SPI_WREN_INDEX,
1494 TRUE,
1495 FALSE,
1496 FALSE,
1497 0,
1498 3,
1499 FlashID,
1500 EnumSpiRegionAll
1501 );
1502 if (!EFI_ERROR (Status)) {
1503 if (((FlashID[0] == mSpiInitTable[FlashIndex].VendorId) &&
1504 (FlashID[2] == mSpiInitTable[FlashIndex].DeviceId1)) ||
1505 ((FlashID[0] == SPI_AT26DF321_ID1) &&
1506 (FlashID[0] == mSpiInitTable[FlashIndex].VendorId) &&
1507 (FlashID[1] == mSpiInitTable[FlashIndex].DeviceId0))) {
1508 //
1509 // Supported SPI device found
1510 //
1511 DEBUG (
1512 ((EFI_D_INFO),
1513 "Smm Mode: Supported SPI Flash device found, Vendor Id: 0x%02x, Device ID: 0x%02x%02x!\n",
1514 FlashID[0],
1515 FlashID[1],
1516 FlashID[2])
1517 );
1518 break;
1519 }
1520 }
1521 }
1522 }
1523
1524 if (FlashIndex >= EnumSpiFlashMax) {
1525 Status = EFI_UNSUPPORTED;
1526 DEBUG (
1527 (EFI_D_ERROR,
1528 "ERROR - Unknown SPI Flash Device, Vendor Id: 0x%02x, Device ID: 0x%02x%02x!\n",
1529 FlashID[0],
1530 FlashID[1],
1531 FlashID[2])
1532 );
1533 ASSERT_EFI_ERROR (Status);
1534 }
1535
1536 SpiStatus = 0;
1537 Status = mFvbModuleGlobal->SmmSpiProtocol->Execute (
1538 mFvbModuleGlobal->SmmSpiProtocol,
1539 SPI_OPCODE_WRITE_S_INDEX, // OpcodeIndex
1540 1, // PrefixOpcodeIndex
1541 TRUE, // DataCycle
1542 TRUE, // Atomic
1543 TRUE, // ShiftOut
1544 0, // Address
1545 1, // Data Number
1546 &SpiStatus,
1547 EnumSpiRegionAll // SPI_REGION_TYPE
1548 );
1549 return Status;
1550 }
1551
1552 EFI_STATUS
1553 SmmSpiNotificationFunction (
1554 IN CONST EFI_GUID *Protocol,
1555 IN VOID *Interface,
1556 IN EFI_HANDLE Handle
1557 )
1558 {
1559 return SmmSpiInit();
1560 }
1561
1562
1563 VOID
1564 EFIAPI
1565 GetFullDriverPath (
1566 IN EFI_HANDLE ImageHandle,
1567 IN EFI_SYSTEM_TABLE *SystemTable,
1568 OUT EFI_DEVICE_PATH_PROTOCOL **CompleteFilePath
1569 )
1570 /*++
1571
1572 Routine Description:
1573
1574 Function is used to get the full device path for this driver.
1575
1576 Arguments:
1577
1578 ImageHandle - The loaded image handle of this driver.
1579 SystemTable - The pointer of system table.
1580 CompleteFilePath - The pointer of returned full file path
1581
1582 Returns:
1583
1584 none
1585
1586 --*/
1587 {
1588 EFI_STATUS Status;
1589 EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
1590 EFI_DEVICE_PATH_PROTOCOL *ImageDevicePath;
1591
1592
1593 Status = gBS->HandleProtocol (
1594 ImageHandle,
1595 &gEfiLoadedImageProtocolGuid,
1596 (VOID **) &LoadedImage
1597 );
1598 ASSERT_EFI_ERROR (Status);
1599
1600 Status = gBS->HandleProtocol (
1601 LoadedImage->DeviceHandle,
1602 &gEfiDevicePathProtocolGuid,
1603 (VOID *) &ImageDevicePath
1604 );
1605 ASSERT_EFI_ERROR (Status);
1606
1607 *CompleteFilePath = AppendDevicePath (
1608 ImageDevicePath,
1609 LoadedImage->FilePath
1610 );
1611
1612 return ;
1613 }
1614
1615
1616
1617 EFI_STATUS
1618 FvbInitialize (
1619 IN EFI_HANDLE ImageHandle,
1620 IN EFI_SYSTEM_TABLE *SystemTable
1621 )
1622 /*++
1623
1624 Routine Description:
1625 This function does common initialization for FVB services
1626
1627 Arguments:
1628
1629 Returns:
1630
1631 --*/
1632 {
1633 EFI_STATUS Status;
1634 EFI_FW_VOL_INSTANCE *FwhInstance;
1635 EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;
1636 EFI_FIRMWARE_VOLUME_HEADER *TempFwVolHeader;
1637 VOID *HobList;
1638 VOID *FirmwareVolumeHobList;
1639 UINT32 BufferSize;
1640 EFI_FV_BLOCK_MAP_ENTRY *PtrBlockMapEntry;
1641 UINTN LbaAddress;
1642 BOOLEAN WriteEnabled;
1643 BOOLEAN WriteLocked;
1644 EFI_HANDLE FwbHandle;
1645 EFI_FW_VOL_BLOCK_DEVICE *FvbDevice;
1646 EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *OldFwbInterface;
1647 EFI_DEVICE_PATH_PROTOCOL *FwbDevicePath;
1648 EFI_DEVICE_PATH_PROTOCOL *TempFwbDevicePath;
1649 UINT32 MaxLbaSize;
1650 EFI_PHYSICAL_ADDRESS BaseAddress;
1651 BOOLEAN WriteBack;
1652 UINTN NumOfBlocks;
1653 UINTN HeaderLength;
1654 UINT8 SpiStatus;
1655 UINT8 FlashIndex;
1656 UINT8 FlashID[3];
1657 EFI_DEVICE_PATH_PROTOCOL *CompleteFilePath;
1658 UINT8 PrefixOpcodeIndex;
1659 BOOLEAN InSmm;
1660 EFI_SMM_BASE2_PROTOCOL *mSmmBase2;
1661 EFI_HANDLE Handle;
1662
1663 VOID *Registration;
1664 EFI_EVENT Event;
1665
1666 CompleteFilePath = NULL;
1667 GetFullDriverPath (ImageHandle, SystemTable, &CompleteFilePath);
1668
1669 Status = EfiGetSystemConfigurationTable (&gEfiHobListGuid, &HobList);
1670
1671 //
1672 // No FV HOBs found
1673 //
1674 ASSERT_EFI_ERROR (Status);
1675
1676
1677 //
1678 // Allocate runtime services data for global variable, which contains
1679 // the private data of all firmware volume block instances
1680 //
1681 mFvbModuleGlobal = (ESAL_FWB_GLOBAL *)AllocateRuntimeZeroPool(sizeof (ESAL_FWB_GLOBAL ));
1682 ASSERT(mFvbModuleGlobal);
1683 mSmmBase2 = NULL;
1684 Status = gBS->LocateProtocol (
1685 &gEfiSmmBase2ProtocolGuid,
1686 NULL,
1687 (VOID **) &mSmmBase2
1688 );
1689
1690 if (mSmmBase2 == NULL) {
1691 InSmm = FALSE;
1692 } else {
1693 mSmmBase2->InSmm (mSmmBase2, &InSmm);
1694 mSmmBase2->GetSmstLocation (mSmmBase2, &mSmst);
1695
1696 }
1697
1698 if (!InSmm) {
1699 mInSmmMode = 0;
1700 //
1701 // Obtain a handle for ICH SPI Protocol
1702 //
1703 Status = gBS->LocateProtocol (&gEfiSpiProtocolGuid, NULL, (VOID **) &mFvbModuleGlobal->SpiProtocol);
1704 ASSERT_EFI_ERROR (Status);
1705
1706 //
1707 // attempt to identify flash part and initialize spi table
1708 //
1709 for (FlashIndex = 0; FlashIndex < EnumSpiFlashMax; FlashIndex++) {
1710 Status = mFvbModuleGlobal->SpiProtocol->Init (
1711 mFvbModuleGlobal->SpiProtocol,
1712 &(mSpiInitTable[FlashIndex])
1713 );
1714 if (!EFI_ERROR (Status)) {
1715 //
1716 // read vendor/device IDs to check if flash device is supported
1717 //
1718 Status = mFvbModuleGlobal->SpiProtocol->Execute (
1719 mFvbModuleGlobal->SpiProtocol,
1720 SPI_OPCODE_JEDEC_ID_INDEX,
1721 SPI_WREN_INDEX,
1722 TRUE,
1723 FALSE,
1724 FALSE,
1725 0,
1726 3,
1727 FlashID,
1728 EnumSpiRegionAll
1729 );
1730 if (!EFI_ERROR (Status)) {
1731 if (((FlashID[0] == mSpiInitTable[FlashIndex].VendorId) &&
1732 (FlashID[2] == mSpiInitTable[FlashIndex].DeviceId1)) ||
1733 ((FlashID[0] == SPI_AT26DF321_ID1) &&
1734 (FlashID[0] == mSpiInitTable[FlashIndex].VendorId) &&
1735 (FlashID[1] == mSpiInitTable[FlashIndex].DeviceId0))) {
1736 //
1737 // Supported SPI device found
1738 //
1739 DEBUG (
1740 ((EFI_D_INFO),
1741 "Supported SPI Flash device found, Vendor Id: 0x%02x, Device ID: 0x%02x%02x!\n",
1742 FlashID[0],
1743 FlashID[1],
1744 FlashID[2])
1745 );
1746
1747 PublishFlashDeviceInfo (&mSpiInitTable[FlashIndex]);
1748 break;
1749 }
1750 }
1751 }
1752 }
1753
1754 if (FlashIndex >= EnumSpiFlashMax) {
1755 Status = EFI_UNSUPPORTED;
1756 DEBUG (
1757 (DEBUG_ERROR,
1758 "ERROR - Unknown SPI Flash Device, Vendor Id: 0x%02x, Device ID: 0x%02x%02x!\n",
1759 FlashID[0],
1760 FlashID[1],
1761 FlashID[2])
1762 );
1763 ASSERT_EFI_ERROR (Status);
1764 }
1765
1766 //
1767 // Unlock all regions by writing to status register
1768 // This could be SPI device specific, need to follow the datasheet
1769 // To write to Write Status Register the Spi PrefixOpcode needs to be:
1770 // 0 for Atmel parts
1771 // 0 for Intel parts
1772 // 0 for Macronix parts
1773 // 0 for Winbond parts
1774 // 1 for SST parts
1775 SpiStatus = 0;
1776 if (FlashID[0] == SPI_SST25VF016B_ID1) {
1777 PrefixOpcodeIndex = 1;
1778 } else {
1779 PrefixOpcodeIndex = 0;
1780 }
1781 Status = mFvbModuleGlobal->SpiProtocol->Execute (
1782 mFvbModuleGlobal->SpiProtocol,
1783 SPI_OPCODE_WRITE_S_INDEX, // OpcodeIndex
1784 PrefixOpcodeIndex, // PrefixOpcodeIndex
1785 TRUE, // DataCycle
1786 TRUE, // Atomic
1787 TRUE, // ShiftOut
1788 0, // Address
1789 1, // Data Number
1790 &SpiStatus,
1791 EnumSpiRegionAll // SPI_REGION_TYPE
1792 );
1793
1794
1795 } else {
1796 mInSmmMode = 1;
1797
1798 Status = mSmst->SmmLocateProtocol (&gEfiSmmSpiProtocolGuid, NULL, (VOID **) &mFvbModuleGlobal->SmmSpiProtocol);
1799 if (EFI_ERROR(Status)) {
1800 Registration = NULL;
1801 Status = mSmst->SmmRegisterProtocolNotify (
1802 &gEfiSmmSpiProtocolGuid,
1803 SmmSpiNotificationFunction,
1804 &Registration
1805 );
1806 } else {
1807 Status = SmmSpiInit();
1808 }
1809
1810 }
1811
1812 //
1813 // Calculate the total size for all firmware volume block instances
1814 //
1815 BufferSize = 0;
1816 FirmwareVolumeHobList = HobList;
1817 FwVolHeader = NULL;
1818 do {
1819 Status = GetFvbHeader (&FirmwareVolumeHobList, &FwVolHeader, &BaseAddress, &WriteBack);
1820 if (EFI_ERROR (Status)) {
1821 break;
1822 }
1823
1824 if (FwVolHeader) {
1825 BufferSize += (FwVolHeader->HeaderLength + sizeof (EFI_FW_VOL_INSTANCE) - sizeof (EFI_FIRMWARE_VOLUME_HEADER));
1826 }
1827 } while (TRUE);
1828
1829 //
1830 // Only need to allocate once. There is only one copy of physical memory for
1831 // the private data of each FV instance. But in virtual mode or in physical
1832 // mode, the address of the the physical memory may be different.
1833 //
1834 mFvbModuleGlobal->FvInstance[FVB_PHYSICAL] = (EFI_FW_VOL_INSTANCE *) AllocateRuntimeZeroPool (BufferSize);
1835 ASSERT(mFvbModuleGlobal->FvInstance[FVB_PHYSICAL]);
1836 //
1837 // Make a virtual copy of the FvInstance pointer.
1838 //
1839 FwhInstance = mFvbModuleGlobal->FvInstance[FVB_PHYSICAL];
1840 mFvbModuleGlobal->FvInstance[FVB_VIRTUAL] = FwhInstance;
1841
1842 mFvbModuleGlobal->NumFv = 0;
1843 FirmwareVolumeHobList = HobList;
1844 TempFwVolHeader = NULL;
1845
1846 MaxLbaSize = 0;
1847
1848 //
1849 // Fill in the private data of each firmware volume block instance
1850 //
1851 // Foreach Fv HOB in the FirmwareVolumeHobList, loop
1852 //
1853 do {
1854 Status = GetFvbHeader (&FirmwareVolumeHobList, &TempFwVolHeader, &BaseAddress, &WriteBack);
1855 if (EFI_ERROR (Status)) {
1856 break;
1857 }
1858 FwVolHeader = TempFwVolHeader;
1859
1860 if (!FwVolHeader) {
1861 continue;
1862 }
1863
1864
1865 CopyMem ((UINTN *) &(FwhInstance->VolumeHeader), (UINTN *) FwVolHeader, FwVolHeader->HeaderLength);
1866 FwVolHeader = &(FwhInstance->VolumeHeader);
1867
1868 FwhInstance->FvBase[FVB_PHYSICAL] = (UINTN) BaseAddress;
1869 FwhInstance->FvBase[FVB_VIRTUAL] = (UINTN) BaseAddress;
1870
1871 //
1872 // FwhInstance->FvWriteBase may not be the same as FwhInstance->FvBase
1873 //
1874 FwhInstance->FvWriteBase[FVB_PHYSICAL] = (UINTN) BaseAddress;
1875 WriteEnabled = TRUE;
1876
1877 //
1878 // Every pointer should have a virtual copy.
1879 //
1880 FwhInstance->FvWriteBase[FVB_VIRTUAL] = FwhInstance->FvWriteBase[FVB_PHYSICAL];
1881
1882 FwhInstance->WriteEnabled = WriteEnabled;
1883 EfiInitializeLock (&(FwhInstance->FvbDevLock), TPL_HIGH_LEVEL);
1884
1885 LbaAddress = (UINTN) FwhInstance->FvWriteBase[0];
1886 NumOfBlocks = 0;
1887 WriteLocked = FALSE;
1888
1889 if (WriteEnabled) {
1890 for (PtrBlockMapEntry = FwVolHeader->BlockMap; PtrBlockMapEntry->NumBlocks != 0; PtrBlockMapEntry++) {
1891 //
1892 // Get the maximum size of a block. The size will be used to allocate
1893 // buffer for Scratch space, the intermediate buffer for FVB extension
1894 // protocol
1895 //
1896 if (MaxLbaSize < PtrBlockMapEntry->Length) {
1897 MaxLbaSize = PtrBlockMapEntry->Length;
1898 }
1899
1900 NumOfBlocks = NumOfBlocks + PtrBlockMapEntry->NumBlocks;
1901 }
1902 //
1903 // Write back a healthy FV header
1904 //
1905 if (WriteBack && (!WriteLocked)) {
1906
1907 Status = FlashFdErase (
1908 (UINTN) FwhInstance->FvWriteBase[0],
1909 (UINTN) BaseAddress,
1910 FwVolHeader->BlockMap->Length
1911 );
1912
1913 HeaderLength = (UINTN) FwVolHeader->HeaderLength;
1914 Status = FlashFdWrite (
1915 (UINTN) FwhInstance->FvWriteBase[0],
1916 (UINTN) BaseAddress,
1917 &HeaderLength,
1918 (UINT8 *) FwVolHeader,
1919 FwVolHeader->BlockMap->Length
1920 );
1921
1922 }
1923 }
1924 //
1925 // The total number of blocks in the FV.
1926 //
1927 FwhInstance->NumOfBlocks = NumOfBlocks;
1928
1929 //
1930 // If the FV is write locked, set the appropriate attributes
1931 //
1932 if (WriteLocked) {
1933 //
1934 // write disabled
1935 //
1936 FwhInstance->VolumeHeader.Attributes &= ~EFI_FVB2_WRITE_STATUS;
1937 //
1938 // lock enabled
1939 //
1940 FwhInstance->VolumeHeader.Attributes |= EFI_FVB2_LOCK_STATUS;
1941 }
1942
1943 //
1944 // Allocate and initialize FVB Device in a runtime data buffer
1945 //
1946 FvbDevice = AllocateRuntimeCopyPool (sizeof (EFI_FW_VOL_BLOCK_DEVICE), &mFvbDeviceTemplate);
1947 ASSERT (FvbDevice);
1948
1949 FvbDevice->Instance = mFvbModuleGlobal->NumFv;
1950 mFvbModuleGlobal->NumFv++;
1951
1952 //
1953 // FV does not contains extension header, then produce MEMMAP_DEVICE_PATH
1954 //
1955 if (FwVolHeader->ExtHeaderOffset == 0) {
1956 FvbDevice->FvDevicePath.MemMapDevPath.StartingAddress = BaseAddress;
1957 FvbDevice->FvDevicePath.MemMapDevPath.EndingAddress = BaseAddress + (FwVolHeader->FvLength - 1);
1958 FwbDevicePath = (EFI_DEVICE_PATH_PROTOCOL *)&FvbDevice->FvDevicePath;
1959 } else {
1960 CopyGuid (
1961 &FvbDevice->UefiFvDevicePath.FvDevPath.FvName,
1962 (EFI_GUID *)(UINTN)(BaseAddress + FwVolHeader->ExtHeaderOffset)
1963 );
1964 FwbDevicePath = (EFI_DEVICE_PATH_PROTOCOL *)&FvbDevice->UefiFvDevicePath;
1965 }
1966
1967 if (!InSmm) {
1968 //
1969 // Find a handle with a matching device path that has supports FW Block protocol
1970 //
1971 TempFwbDevicePath = FwbDevicePath;
1972 Status = gBS->LocateDevicePath (&gEfiFirmwareVolumeBlockProtocolGuid, &TempFwbDevicePath, &FwbHandle);
1973 if (EFI_ERROR (Status)) {
1974 //
1975 // LocateDevicePath fails so install a new interface and device path
1976 //
1977 FwbHandle = NULL;
1978 Status = gBS->InstallMultipleProtocolInterfaces (
1979 &FwbHandle,
1980 &gEfiFirmwareVolumeBlockProtocolGuid,
1981 &FvbDevice->FwVolBlockInstance,
1982 &gEfiDevicePathProtocolGuid,
1983 FwbDevicePath,
1984 NULL
1985 );
1986 ASSERT_EFI_ERROR (Status);
1987 } else if (EfiIsDevicePathEnd (TempFwbDevicePath)) {
1988 //
1989 // Device already exists, so reinstall the FVB protocol
1990 //
1991 Status = gBS->HandleProtocol (
1992 FwbHandle,
1993 &gEfiFirmwareVolumeBlockProtocolGuid,
1994 (VOID **) &OldFwbInterface
1995 );
1996 ASSERT_EFI_ERROR (Status);
1997
1998 Status = gBS->ReinstallProtocolInterface (
1999 FwbHandle,
2000 &gEfiFirmwareVolumeBlockProtocolGuid,
2001 OldFwbInterface,
2002 &FvbDevice->FwVolBlockInstance
2003 );
2004 ASSERT_EFI_ERROR (Status);
2005
2006 } else {
2007 //
2008 // There was a FVB protocol on an End Device Path node
2009 //
2010 ASSERT (FALSE);
2011 }
2012 } else {
2013 FwbHandle = NULL;
2014 Status = mSmst->SmmInstallProtocolInterface (
2015 &FwbHandle,
2016 &gEfiSmmFirmwareVolumeBlockProtocolGuid,
2017 EFI_NATIVE_INTERFACE,
2018 &FvbDevice->FwVolBlockInstance
2019 );
2020 ASSERT_EFI_ERROR (Status);
2021 }
2022
2023 FwhInstance = (EFI_FW_VOL_INSTANCE *)
2024 (
2025 (UINTN) ((UINT8 *) FwhInstance) + FwVolHeader->HeaderLength +
2026 (sizeof (EFI_FW_VOL_INSTANCE) - sizeof (EFI_FIRMWARE_VOLUME_HEADER))
2027 );
2028 } while (TRUE);
2029
2030 //
2031 // Allocate for scratch space, an intermediate buffer for FVB extention
2032 //
2033
2034 mFvbModuleGlobal->FvbScratchSpace[FVB_PHYSICAL] = AllocateRuntimeZeroPool (MaxLbaSize);
2035
2036 ASSERT (mFvbModuleGlobal->FvbScratchSpace[FVB_PHYSICAL]);
2037
2038 mFvbModuleGlobal->FvbScratchSpace[FVB_VIRTUAL] = mFvbModuleGlobal->FvbScratchSpace[FVB_PHYSICAL];
2039
2040 if (!InSmm) {
2041 Status = gBS->CreateEventEx (
2042 EVT_NOTIFY_SIGNAL,
2043 TPL_NOTIFY,
2044 FvbVirtualddressChangeEvent,
2045 NULL,
2046 &gEfiEventVirtualAddressChangeGuid,
2047 &Event
2048 );
2049 ASSERT_EFI_ERROR (Status);
2050 } else {
2051 //
2052 // Inform other platform drivers that SPI device discovered and
2053 // SPI interface ready for use.
2054 //
2055 Handle = NULL;
2056 Status = gBS->InstallProtocolInterface (
2057 &Handle,
2058 &gEfiSmmSpiReadyProtocolGuid,
2059 EFI_NATIVE_INTERFACE,
2060 NULL
2061 );
2062 }
2063 return EFI_SUCCESS;
2064 }
EFI Development Kit II mirror for PVE