]> git.proxmox.com Git - mirror_edk2.git/blob - IntelFrameworkModulePkg/Universal/FirmwareVolume/UpdateDriverDxe/FlashUpdate.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
FatPkg: Clean up source files
[mirror_edk2.git] / IntelFrameworkModulePkg / Universal / FirmwareVolume / UpdateDriverDxe / FlashUpdate.c
1 /** @file
2 Functions in this file will program the image into flash area.
3
4 Copyright (c) 2002 - 2010, Intel Corporation. All rights reserved.<BR>
5
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions
8 of the BSD License which accompanies this distribution. The
9 full text of the license may be found at
10 http://opensource.org/licenses/bsd-license.php
11
12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
14
15 **/
16
17 #include "UpdateDriver.h"
18
19 /**
20 Write a block size data into flash.
21
22 @param FvbProtocol Pointer to FVB protocol.
23 @param Lba Logic block index to be updated.
24 @param BlockSize Block size
25 @param Buffer Buffer data to be written.
26
27 @retval EFI_SUCCESS Write data successfully.
28 @retval other errors Write data failed.
29
30 **/
31 EFI_STATUS
32 UpdateOneBlock (
33 IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvbProtocol,
34 IN EFI_LBA Lba,
35 IN UINTN BlockSize,
36 IN UINT8 *Buffer
37 )
38 {
39 EFI_STATUS Status;
40 UINTN Size;
41
42 //
43 // First erase the block
44 //
45 Status = FvbProtocol->EraseBlocks (
46 FvbProtocol,
47 Lba, // Lba
48 1, // NumOfBlocks
49 EFI_LBA_LIST_TERMINATOR
50 );
51 if (EFI_ERROR (Status)) {
52 return Status;
53 }
54
55 //
56 // Write the block
57 //
58 Size = BlockSize;
59 Status = FvbProtocol->Write (
60 FvbProtocol,
61 Lba, // Lba
62 0, // Offset
63 &Size, // Size
64 Buffer // Buffer
65 );
66 if ((EFI_ERROR (Status)) || (Size != BlockSize)) {
67 return Status;
68 }
69
70 return EFI_SUCCESS;
71 }
72
73 /**
74 Write buffer data in a flash block.
75
76 @param FvbProtocol Pointer to FVB protocol.
77 @param Lba Logic block index to be updated.
78 @param Offset The offset within the block.
79 @param Length Size of buffer to be updated.
80 @param BlockSize Block size.
81 @param Buffer Buffer data to be updated.
82
83 @retval EFI_SUCCESS Write data successfully.
84 @retval other errors Write data failed.
85
86 **/
87 EFI_STATUS
88 UpdateBufferInOneBlock (
89 IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvbProtocol,
90 IN EFI_LBA Lba,
91 IN UINTN Offset,
92 IN UINTN Length,
93 IN UINTN BlockSize,
94 IN UINT8 *Buffer
95 )
96 {
97 EFI_STATUS Status;
98 UINTN Size;
99 UINT8 *ReservedBuffer;
100
101 //
102 // If we are going to update a whole block
103 //
104 if ((Offset == 0) && (Length == BlockSize)) {
105 Status = UpdateOneBlock (
106 FvbProtocol,
107 Lba,
108 BlockSize,
109 Buffer
110 );
111 return Status;
112 }
113
114 //
115 // If it is not a full block update, we need to coalesce data in
116 // the block that is not going to be updated and new data together.
117 //
118
119 //
120 // Allocate a reserved buffer to make up the final buffer for update
121 //
122 ReservedBuffer = NULL;
123 ReservedBuffer = AllocatePool (BlockSize);
124 if (ReservedBuffer == NULL) {
125 return EFI_OUT_OF_RESOURCES;
126 }
127 //
128 // First get the original content of the block
129 //
130 Size = BlockSize;
131 Status = FvbProtocol->Read (
132 FvbProtocol,
133 Lba,
134 0,
135 &Size,
136 ReservedBuffer
137 );
138 if ((EFI_ERROR (Status)) || (Size != BlockSize)) {
139 FreePool (ReservedBuffer);
140 return Status;
141 }
142
143 //
144 // Overwrite the reserved buffer with new content
145 //
146 CopyMem (ReservedBuffer + Offset, Buffer, Length);
147
148 Status = UpdateOneBlock (
149 FvbProtocol,
150 Lba,
151 BlockSize,
152 ReservedBuffer
153 );
154
155 FreePool (ReservedBuffer);
156
157 return Status;
158 }
159
160 /**
161 Get the last write log, and check the status of last write.
162 If not complete, restart will be taken.
163
164 @param FvbHandle Handle of FVB protocol.
165 @param FtwProtocol FTW protocol instance.
166 @param ConfigData Config data on updating driver.
167 @param PrivateDataSize bytes from the private data
168 stored for this write.
169 @param PrivateData A pointer to a buffer. The function will copy.
170 @param Lba The logical block address of the last write.
171 @param Offset The offset within the block of the last write.
172 @param Length The length of the last write.
173 @param Pending A Boolean value with TRUE indicating
174 that the write was completed.
175
176 @retval EFI_OUT_OF_RESOURCES No enough memory is allocated.
177 @retval EFI_ABORTED The FTW work space is damaged.
178 @retval EFI_NOT_FOUND The last write is not done by this driver.
179 @retval EFI_SUCCESS Last write log is got.
180
181 **/
182 EFI_STATUS
183 RetrieveLastWrite (
184 IN EFI_HANDLE FvbHandle,
185 IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL *FtwProtocol,
186 IN UPDATE_CONFIG_DATA *ConfigData,
187 IN UINTN PrivateDataSize,
188 IN OUT UPDATE_PRIVATE_DATA *PrivateData,
189 IN OUT EFI_LBA *Lba,
190 IN OUT UINTN *Offset,
191 IN OUT UINTN *Length,
192 IN OUT BOOLEAN *Pending
193 )
194 {
195 EFI_STATUS Status;
196 EFI_GUID CallerId;
197 UINTN PrivateBufferSize;
198 BOOLEAN Complete;
199 VOID *PrivateDataBuffer;
200
201 //
202 // Get the last write
203 //
204 *Pending = FALSE;
205 PrivateBufferSize = PrivateDataSize;
206 PrivateDataBuffer = NULL;
207 Status = FtwProtocol->GetLastWrite (
208 FtwProtocol,
209 &CallerId,
210 Lba,
211 Offset,
212 Length,
213 &PrivateBufferSize,
214 PrivateData,
215 &Complete
216 );
217 if (EFI_ERROR (Status)) {
218 //
219 // If there is no incompleted record, return success.
220 //
221 if ((Status == EFI_NOT_FOUND) && Complete) {
222 return EFI_SUCCESS;
223 } else if (Status == EFI_BUFFER_TOO_SMALL) {
224 //
225 // If buffer too small, reallocate buffer and call getlastwrite again
226 //
227 PrivateDataBuffer = AllocatePool (PrivateBufferSize);
228
229 if (PrivateDataBuffer == NULL) {
230 return EFI_OUT_OF_RESOURCES;
231 }
232
233 Status = FtwProtocol->GetLastWrite (
234 FtwProtocol,
235 &CallerId,
236 Lba,
237 Offset,
238 Length,
239 &PrivateBufferSize,
240 PrivateDataBuffer,
241 &Complete
242 );
243 if (EFI_ERROR (Status)) {
244 FreePool ( PrivateDataBuffer);
245 return EFI_ABORTED;
246 } else {
247 CopyMem (PrivateData, PrivateDataBuffer, PrivateDataSize);
248 FreePool (PrivateDataBuffer);
249 PrivateDataBuffer = NULL;
250 }
251 } else {
252 return EFI_ABORTED;
253 }
254 }
255
256 *Pending = TRUE;
257
258 //
259 // If the caller is not the update driver, then return.
260 // The update driver cannot continue to perform the update
261 //
262 if (CompareMem (&CallerId, &gEfiCallerIdGuid, sizeof (EFI_GUID)) != 0) {
263 return EFI_NOT_FOUND;
264 }
265
266 //
267 // Check the private data and see if it is the one I need.
268 //
269 if (CompareMem (&(PrivateData->FileGuid), &(ConfigData->FileGuid), sizeof(EFI_GUID)) != 0) {
270 return EFI_NOT_FOUND;
271 }
272
273 //
274 // If the caller is the update driver and complete is not true, then restart().
275 //
276 if (!Complete) {
277 //
278 // Re-start the update
279 //
280 Status = FtwProtocol->Restart (
281 FtwProtocol,
282 FvbHandle
283 );
284 //
285 // If restart() error, then abort().
286 //
287 if (EFI_ERROR (Status)) {
288 FtwProtocol->Abort (FtwProtocol);
289 //
290 // Now set Pending as FALSE as this record has been cleared
291 //
292 *Pending = FALSE;
293 return EFI_SUCCESS;
294 }
295
296 }
297
298 return Status;
299 }
300
301 /**
302 Update the whole FV image in fault tolerant write method.
303
304 @param FvbHandle Handle of FVB protocol for the updated flash range.
305 @param FvbProtocol FVB protocol.
306 @param BlockMap Block array to specify flash area.
307 @param ConfigData Config data on updating driver.
308 @param ImageBuffer Image buffer to be updated.
309 @param ImageSize Image size.
310
311 @retval EFI_SUCCESS FV image is writed into flash.
312 @retval EFI_INVALID_PARAMETER Config data is not valid.
313 @retval EFI_NOT_FOUND FTW protocol doesn't exist.
314 @retval EFI_OUT_OF_RESOURCES No enough backup space.
315 @retval EFI_ABORTED Error happen when update FV.
316
317 **/
318 EFI_STATUS
319 FaultTolerantUpdateOnWholeFv (
320 IN EFI_HANDLE FvbHandle,
321 IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvbProtocol,
322 IN EFI_FV_BLOCK_MAP_ENTRY *BlockMap,
323 IN UPDATE_CONFIG_DATA *ConfigData,
324 IN UINT8 *ImageBuffer,
325 IN UINTN ImageSize
326 )
327 {
328 EFI_STATUS Status;
329 EFI_FAULT_TOLERANT_WRITE_PROTOCOL *FtwProtocol;
330 UINTN MaxBlockSize;
331 UINTN FtwMaxBlockSize;
332 BOOLEAN Pending;
333 UPDATE_PRIVATE_DATA PrivateData;
334 EFI_LBA PendingLba;
335 EFI_LBA Lba;
336 UINTN PendingOffset;
337 UINTN Offset;
338 UINTN PendingLength;
339 UINTN Length;
340 EFI_FV_BLOCK_MAP_ENTRY *PtrMap;
341 UINTN NumOfBlocks;
342 UINTN Index;
343 UINT8 *UpdateBuffer;
344
345 if ((ConfigData->UpdateType != UpdateWholeFV)
346 || (!ConfigData->FaultTolerant)) {
347 return EFI_INVALID_PARAMETER;
348 }
349
350 //
351 // Get the FTW protocol
352 //
353 Status = gBS->LocateProtocol (
354 &gEfiFaultTolerantWriteProtocolGuid,
355 NULL,
356 (VOID **) &FtwProtocol
357 );
358 if (EFI_ERROR (Status)) {
359 return EFI_NOT_FOUND;
360 }
361
362 //
363 // Get the maximum block size of the FV, and number of blocks
364 // NumOfBlocks will be the NumOfUdpates.
365 //
366 MaxBlockSize = 0;
367 NumOfBlocks = 0;
368 PtrMap = BlockMap;
369 while (TRUE) {
370 if ((PtrMap->NumBlocks == 0) || (PtrMap->Length == 0)) {
371 break;
372 }
373 if (MaxBlockSize < PtrMap->Length) {
374 MaxBlockSize = PtrMap->Length;
375 }
376 NumOfBlocks = NumOfBlocks + PtrMap->NumBlocks;
377 PtrMap++;
378 }
379
380 FtwProtocol->GetMaxBlockSize (FtwProtocol, &FtwMaxBlockSize);
381 //
382 // Not enough backup space. return directly
383 //
384 if (FtwMaxBlockSize < MaxBlockSize) {
385 return EFI_OUT_OF_RESOURCES;
386 }
387
388 PendingLba = 0;
389 PendingOffset = 0;
390 PendingLength = 0;
391 Pending = FALSE;
392
393 //
394 // Fault Tolerant Write can only support actual fault tolerance if the write
395 // is a reclaim operation, which means the data buffer (new and old) are
396 // acutally both stored in flash. But for component update write, the data
397 // are now in memory. So we cannot actually recover the data after power
398 // failure.
399 //
400 Status = RetrieveLastWrite (
401 FvbHandle,
402 FtwProtocol,
403 ConfigData,
404 sizeof (UPDATE_PRIVATE_DATA),
405 &PrivateData,
406 &PendingLba,
407 &PendingOffset,
408 &PendingLength,
409 &Pending
410 );
411
412 if (Pending && (Status == EFI_NOT_FOUND)) {
413 //
414 // Cannot continue with the write operation
415 //
416 return EFI_ABORTED;
417 }
418
419 if (EFI_ERROR(Status)) {
420 return EFI_ABORTED;
421 }
422
423 //
424 // Currently we start from the pending write if there is any. But as we
425 // are going to update a whole FV, we can just abort last write and start
426 // from the very begining.
427 //
428 if (!Pending) {
429 //
430 // Now allocte the update private data in FTW. If there is pending
431 // write, it has already been allocated and no need to allocate here.
432 //
433 Status = FtwProtocol->Allocate (
434 FtwProtocol,
435 &gEfiCallerIdGuid,
436 sizeof (UPDATE_PRIVATE_DATA),
437 NumOfBlocks
438 );
439 if (EFI_ERROR (Status)) {
440 return Status;
441 }
442 }
443
444 //
445 // Perform the update now. If there are pending writes, we need to
446 // start from the pending write instead of the very beginning.
447 //
448 PtrMap = BlockMap;
449 Lba = 0;
450 Offset = 0;
451 UpdateBuffer = ImageBuffer;
452 CopyMem (
453 (VOID *) &PrivateData.FileGuid,
454 (VOID *) &ConfigData->FileGuid,
455 sizeof (EFI_GUID)
456 );
457
458 while (TRUE) {
459 if ((PtrMap->NumBlocks == 0) || (PtrMap->Length == 0)) {
460 break;
461 }
462 Length = (UINTN)PtrMap->Length;
463 for (Index = 0; Index < PtrMap->NumBlocks; Index++) {
464
465 //
466 // Add an extra check here to see if the pending record is correct
467 //
468 if (Pending && (Lba == PendingLba)) {
469 if ((PendingOffset != Offset) || (PendingLength != Length)) {
470 //
471 // Error.
472 //
473 Status = EFI_ABORTED;
474 break;
475 }
476 }
477
478 if ((!Pending) || (Lba >= PendingLba)) {
479 Status = FtwProtocol->Write (
480 FtwProtocol,
481 Lba, // Lba
482 Offset, // Offset
483 Length, // Size
484 &PrivateData, // Private Data
485 FvbHandle, // FVB handle
486 UpdateBuffer // Buffer
487 );
488 }
489
490 if (EFI_ERROR (Status)) {
491 break;
492 }
493 Lba++;
494 UpdateBuffer = (UINT8 *) ((UINTN)UpdateBuffer + Length);
495 }
496
497 if (EFI_ERROR (Status)) {
498 break;
499 }
500 PtrMap++;
501 }
502
503 return Status;
504
505 }
506
507 /**
508 Directly update the whole FV image without fault tolerant write method.
509
510 @param FvbHandle Handle of FVB protocol for the updated flash range.
511 @param FvbProtocol FVB protocol.
512 @param BlockMap Block array to specify flash area.
513 @param ConfigData Config data on updating driver.
514 @param ImageBuffer Image buffer to be updated.
515 @param ImageSize Image size.
516
517 @retval EFI_SUCCESS FV image is writed into flash.
518 @retval EFI_INVALID_PARAMETER Config data is not valid.
519 @retval EFI_ABORTED Error happen when update FV.
520
521 **/
522 EFI_STATUS
523 NonFaultTolerantUpdateOnWholeFv (
524 IN EFI_HANDLE FvbHandle,
525 IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvbProtocol,
526 IN EFI_FV_BLOCK_MAP_ENTRY *BlockMap,
527 IN UPDATE_CONFIG_DATA *ConfigData,
528 IN UINT8 *ImageBuffer,
529 IN UINTN ImageSize
530 )
531 {
532 EFI_STATUS Status;
533 EFI_FV_BLOCK_MAP_ENTRY *PtrMap;
534 UINTN Index;
535 EFI_LBA UpdateLba;
536 UINT8 *UpdateBuffer;
537 UINTN UpdateSize;
538
539 if ((ConfigData->UpdateType != UpdateWholeFV )
540 || (ConfigData->FaultTolerant)) {
541 return EFI_INVALID_PARAMETER;
542 }
543
544 Status = EFI_SUCCESS;
545 PtrMap = BlockMap;
546 UpdateLba = 0;
547 UpdateBuffer = ImageBuffer;
548
549 //
550 // Perform the update now
551 //
552 while (TRUE) {
553 if ((PtrMap->NumBlocks == 0) || (PtrMap->Length == 0)) {
554 break;
555 }
556 UpdateSize = (UINTN)PtrMap->Length;
557 for (Index = 0; Index < PtrMap->NumBlocks; Index++) {
558 Status = UpdateOneBlock (
559 FvbProtocol,
560 UpdateLba,
561 UpdateSize,
562 UpdateBuffer
563 );
564 if (EFI_ERROR (Status)) {
565 break;
566 }
567
568 UpdateLba++;
569 UpdateBuffer = (UINT8 *) ((UINTN)UpdateBuffer + UpdateSize);
570 }
571
572 if (EFI_ERROR (Status)) {
573 break;
574 }
575 PtrMap++;
576 }
577
578 return Status;
579 }
580
581 /**
582 Update the whole FV image, and reinsall FVB protocol for the updated FV image.
583
584 @param FvbHandle Handle of FVB protocol for the updated flash range.
585 @param FvbProtocol FVB protocol.
586 @param ConfigData Config data on updating driver.
587 @param ImageBuffer Image buffer to be updated.
588 @param ImageSize Image size.
589
590 @retval EFI_INVALID_PARAMETER Update type is not UpdateWholeFV.
591 Or Image size is not same to the size of whole FV.
592 @retval EFI_OUT_OF_RESOURCES No enoug memory is allocated.
593 @retval EFI_SUCCESS FV image is updated, and its FVB protocol is reinstalled.
594
595 **/
596 EFI_STATUS
597 PerformUpdateOnWholeFv (
598 IN EFI_HANDLE FvbHandle,
599 IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvbProtocol,
600 IN UPDATE_CONFIG_DATA *ConfigData,
601 IN UINT8 *ImageBuffer,
602 IN UINTN ImageSize
603 )
604 {
605 EFI_STATUS Status;
606 EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;
607 EFI_FV_BLOCK_MAP_ENTRY *BlockMap;
608 CHAR16 *TmpStr;
609
610 if (ConfigData->UpdateType != UpdateWholeFV) {
611 return EFI_INVALID_PARAMETER;
612 }
613
614 //
615 // Get the header of the firmware volume
616 //
617 FwVolHeader = NULL;
618 FwVolHeader = AllocatePool (((EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) (ConfigData->BaseAddress)))->HeaderLength);
619 if (FwVolHeader == NULL) {
620 return EFI_OUT_OF_RESOURCES;
621 }
622 CopyMem (
623 FwVolHeader,
624 (VOID *) ((UINTN) (ConfigData->BaseAddress)),
625 ((EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) (ConfigData->BaseAddress)))->HeaderLength
626 );
627
628 //
629 // Check if ImageSize is the same as the size of the whole FV
630 //
631 if ((UINT64)ImageSize != FwVolHeader->FvLength) {
632 FreePool (FwVolHeader);
633 return EFI_INVALID_PARAMETER;
634 }
635
636 //
637 // Print on screen
638 //
639 TmpStr = HiiGetString (gHiiHandle, STRING_TOKEN(UPDATE_FIRMWARE_VOLUME), NULL);
640 if (TmpStr != NULL) {
641 Print (TmpStr, ConfigData->BaseAddress, (FwVolHeader->FvLength + ConfigData->BaseAddress));
642 FreePool (TmpStr);
643 }
644
645 DEBUG ((EFI_D_UPDATE, "UpdateDriver: updating whole FV from %08LX to %08LX\n",
646 ConfigData->BaseAddress, (FwVolHeader->FvLength + ConfigData->BaseAddress)));
647
648 //
649 // Get the block map of the firmware volume
650 //
651 BlockMap = &(FwVolHeader->BlockMap[0]);
652
653 //
654 // It is about the same if we are going to fault tolerantly update
655 // a certain FV in our current design. But we divide non-fault tolerant
656 // and fault tolerant udpate here for better maintenance as fault
657 // tolerance may change and may be done more wisely if we have space.
658 //
659 if (ConfigData->FaultTolerant) {
660 Status = FaultTolerantUpdateOnWholeFv (
661 FvbHandle,
662 FvbProtocol,
663 BlockMap,
664 ConfigData,
665 ImageBuffer,
666 ImageSize
667 );
668 } else {
669 Status = NonFaultTolerantUpdateOnWholeFv (
670 FvbHandle,
671 FvbProtocol,
672 BlockMap,
673 ConfigData,
674 ImageBuffer,
675 ImageSize
676 );
677 }
678
679 FreePool (FwVolHeader);
680
681 if (EFI_ERROR (Status)) {
682 return Status;
683 }
684
685 //
686 // As the whole FV has been replaced, the FV driver shall re-parse the
687 // firmware volume. So re-install FVB protocol here
688 //
689 Status = gBS->ReinstallProtocolInterface (
690 FvbHandle,
691 &gEfiFirmwareVolumeBlockProtocolGuid,
692 FvbProtocol,
693 FvbProtocol
694 );
695
696 return Status;
697 }
698
699 /**
700 Update certain file in the FV.
701
702 @param FvbHandle Handle of FVB protocol for the updated flash range.
703 @param FvbProtocol FVB protocol.
704 @param ConfigData Config data on updating driver.
705 @param ImageBuffer Image buffer to be updated.
706 @param ImageSize Image size.
707 @param FileType FFS file type.
708 @param FileAttributes FFS file attribute
709
710 @retval EFI_INVALID_PARAMETER Update type is not UpdateFvFile.
711 Or Image size is not same to the size of whole FV.
712 @retval EFI_UNSUPPORTED PEIM FFS is unsupported to be updated.
713 @retval EFI_SUCCESS The FFS file is added into FV.
714
715 **/
716 EFI_STATUS
717 PerformUpdateOnFvFile (
718 IN EFI_HANDLE FvbHandle,
719 IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvbProtocol,
720 IN UPDATE_CONFIG_DATA *ConfigData,
721 IN UINT8 *ImageBuffer,
722 IN UINTN ImageSize,
723 IN EFI_FV_FILETYPE FileType,
724 IN EFI_FV_FILE_ATTRIBUTES FileAttributes
725 )
726 {
727 EFI_STATUS Status;
728 EFI_FIRMWARE_VOLUME2_PROTOCOL *FwVolProtocol;
729 EFI_FV_WRITE_FILE_DATA FileData;
730 CHAR16 *TmpStr;
731
732 if (ConfigData->UpdateType != UpdateFvFile) {
733 return EFI_INVALID_PARAMETER;
734 }
735
736 //
737 // Print on screen
738 //
739 TmpStr = HiiGetString (gHiiHandle, STRING_TOKEN(UPDATE_FIRMWARE_VOLUME_FILE), NULL);
740 if (TmpStr != NULL) {
741 Print (TmpStr, &(ConfigData->FileGuid));
742 FreePool (TmpStr);
743 }
744
745 DEBUG ((EFI_D_UPDATE, "UpdateDriver: updating file: %g\n",
746 &(ConfigData->FileGuid)));
747
748 //
749 // Get Firmware volume protocol on this FVB protocol
750 //
751 Status = gBS->HandleProtocol (
752 FvbHandle,
753 &gEfiFirmwareVolume2ProtocolGuid,
754 (VOID **) &FwVolProtocol
755 );
756 if (EFI_ERROR (Status)) {
757 return Status;
758 }
759
760 //
761 // If it is a PEIM, we need first to rebase it before committing
762 // the write to target
763 //
764 if ((FileType == EFI_FV_FILETYPE_PEI_CORE) || (FileType == EFI_FV_FILETYPE_PEIM )
765 || (FileType == EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER)) {
766 return EFI_UNSUPPORTED;
767 }
768
769 FileData.NameGuid = &(ConfigData->FileGuid);
770 FileData.Type = FileType;
771 FileData.FileAttributes = FileAttributes;
772 FileData.Buffer = ImageBuffer;
773 FileData.BufferSize = (UINT32) ImageSize;
774
775 Status = FwVolProtocol->WriteFile (
776 FwVolProtocol,
777 1, // NumberOfFiles
778 (EFI_FV_WRITE_POLICY)ConfigData->FaultTolerant,
779 &FileData
780 );
781 return Status;
782 }
783
784 /**
785 Update the buffer into flash area in fault tolerant write method.
786
787 @param ImageBuffer Image buffer to be updated.
788 @param SizeLeft Size of the image buffer.
789 @param UpdatedSize Size of the updated buffer.
790 @param ConfigData Config data on updating driver.
791 @param FlashAddress Flash address to be updated as start address.
792 @param FvbProtocol FVB protocol.
793 @param FvbHandle Handle of FVB protocol for the updated flash range.
794
795 @retval EFI_SUCCESS Buffer data is updated into flash.
796 @retval EFI_INVALID_PARAMETER Base flash address is not in FVB flash area.
797 @retval EFI_NOT_FOUND FTW protocol doesn't exist.
798 @retval EFI_OUT_OF_RESOURCES No enough backup space.
799 @retval EFI_ABORTED Error happen when update flash area.
800
801 **/
802 EFI_STATUS
803 FaultTolerantUpdateOnPartFv (
804 IN UINT8 *ImageBuffer,
805 IN UINTN SizeLeft,
806 IN OUT UINTN *UpdatedSize,
807 IN UPDATE_CONFIG_DATA *ConfigData,
808 IN EFI_PHYSICAL_ADDRESS FlashAddress,
809 IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvbProtocol,
810 IN EFI_HANDLE FvbHandle
811 )
812 {
813 EFI_STATUS Status;
814 EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;
815 EFI_FIRMWARE_VOLUME_HEADER *FwVolHeaderTmp;
816 EFI_PHYSICAL_ADDRESS BaseAddress;
817 EFI_PHYSICAL_ADDRESS FvBase;
818 EFI_PHYSICAL_ADDRESS NextBlock;
819 EFI_FV_BLOCK_MAP_ENTRY *BlockMap;
820 EFI_FV_BLOCK_MAP_ENTRY *PtrMap;
821 UINTN NumOfUpdates;
822 UINTN TotalSize;
823 EFI_PHYSICAL_ADDRESS StartAddress;
824 EFI_FAULT_TOLERANT_WRITE_PROTOCOL *FtwProtocol;
825 UINTN MaxBlockSize;
826 UINTN FtwMaxBlockSize;
827 BOOLEAN Pending;
828 UPDATE_PRIVATE_DATA PrivateData;
829 EFI_LBA PendingLba;
830 EFI_LBA Lba;
831 UINTN BlockSize;
832 UINTN PendingOffset;
833 UINTN Offset;
834 UINTN PendingLength;
835 UINTN Length;
836 UINTN Index;
837 UINT8 *Image;
838
839 //
840 // Get the block map to update the block one by one
841 //
842 Status = FvbProtocol->GetPhysicalAddress (
843 FvbProtocol,
844 &FvBase
845 );
846 if (EFI_ERROR (Status)) {
847 return Status;
848 }
849
850 FwVolHeaderTmp = (EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)FvBase;
851 if ((FlashAddress < FvBase) || (FlashAddress > (FvBase + FwVolHeaderTmp->FvLength))) {
852 return EFI_INVALID_PARAMETER;
853 }
854
855 FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *)AllocateCopyPool (
856 FwVolHeaderTmp->HeaderLength,
857 FwVolHeaderTmp
858 );
859 if (FwVolHeader == NULL) {
860 return EFI_OUT_OF_RESOURCES;
861 }
862
863 //
864 // For fault tolerant write, we have to know how many blocks we need to
865 // update. So we will calculate number of updates and max block size first
866 //
867 NumOfUpdates = 0;
868 MaxBlockSize = 0;
869 TotalSize = SizeLeft;
870 StartAddress = FlashAddress;
871 BaseAddress = FvBase;
872 BlockMap = &(FwVolHeader->BlockMap[0]);
873 PtrMap = BlockMap;
874
875 while (TotalSize > 0) {
876 if ((PtrMap->NumBlocks == 0) || (PtrMap->Length == 0)) {
877 break;
878 }
879
880 BlockSize = PtrMap->Length;
881 for (Index = 0; Index < PtrMap->NumBlocks; Index++) {
882 NextBlock = BaseAddress + BlockSize;
883 //
884 // Check if this block need to be updated
885 //
886 if ((StartAddress >= BaseAddress) && (StartAddress < NextBlock)) {
887 //
888 // Get the maximum block size
889 //
890 if (MaxBlockSize < BlockSize) {
891 MaxBlockSize = BlockSize;
892 }
893
894 //
895 // This block shall be udpated. So increment number of updates
896 //
897 NumOfUpdates++;
898 Offset = (UINTN) (StartAddress - BaseAddress);
899 Length = TotalSize;
900 if ((Length + Offset ) > BlockSize) {
901 Length = BlockSize - Offset;
902 }
903
904 StartAddress = StartAddress + Length;
905 TotalSize = TotalSize - Length;
906 if (TotalSize <= 0) {
907 break;
908 }
909 }
910 BaseAddress = NextBlock;
911 }
912 PtrMap++;
913 }
914
915 //
916 // Get the FTW protocol
917 //
918 Status = gBS->LocateProtocol (
919 &gEfiFaultTolerantWriteProtocolGuid,
920 NULL,
921 (VOID **) &FtwProtocol
922 );
923 if (EFI_ERROR (Status)) {
924 FreePool (FwVolHeader);
925 return EFI_NOT_FOUND;
926 }
927
928 FtwProtocol->GetMaxBlockSize (FtwProtocol, &FtwMaxBlockSize);
929
930 //
931 // Not enough backup space. return directly
932 //
933 if (FtwMaxBlockSize < MaxBlockSize) {
934 FreePool (FwVolHeader);
935 return EFI_OUT_OF_RESOURCES;
936 }
937
938 PendingLba = 0;
939 PendingOffset = 0;
940 PendingLength = 0;
941 Pending = FALSE;
942
943 //
944 // Fault Tolerant Write can only support actual fault tolerance if the write
945 // is a reclaim operation, which means the data buffer (new and old) are
946 // acutally both stored in flash. But for component update write, the data
947 // are now in memory. So we cannot actually recover the data after power
948 // failure.
949 //
950 Status = RetrieveLastWrite (
951 FvbHandle,
952 FtwProtocol,
953 ConfigData,
954 sizeof (UPDATE_PRIVATE_DATA),
955 &PrivateData,
956 &PendingLba,
957 &PendingOffset,
958 &PendingLength,
959 &Pending
960 );
961 if (Pending && (Status == EFI_NOT_FOUND)) {
962 //
963 // I'm not the owner of the pending fault tolerant write record
964 // Cannot continue with the write operation
965 //
966 FreePool (FwVolHeader);
967 return EFI_ABORTED;
968 }
969
970 if (EFI_ERROR(Status)) {
971 FreePool (FwVolHeader);
972 return EFI_ABORTED;
973 }
974
975 //
976 // Currently we start from the pending write if there is any. But if the
977 // caller is exactly the same, and the new data is already a in memory, (it
978 // cannot be stored in flash in last write,) we can just abort last write
979 // and start from the very begining.
980 //
981 if (!Pending) {
982 //
983 // Now allocte the update private data in FTW. If there is pending
984 // write, it has already been allocated and no need to allocate here.
985 //
986 Status = FtwProtocol->Allocate (
987 FtwProtocol,
988 &gEfiCallerIdGuid,
989 sizeof (UPDATE_PRIVATE_DATA),
990 NumOfUpdates
991 );
992 if (EFI_ERROR (Status)) {
993 FreePool (FwVolHeader);
994 return Status;
995 }
996 }
997
998 //
999 // Perform the update now. If there are pending writes, we need to
1000 // start from the pending write instead of the very beginning.
1001 //
1002 TotalSize = SizeLeft;
1003 Lba = 0;
1004 StartAddress = FlashAddress;
1005 BaseAddress = FvBase;
1006 PtrMap = BlockMap;
1007 Image = ImageBuffer;
1008 CopyMem (
1009 (VOID *) &PrivateData.FileGuid,
1010 (VOID *) &ConfigData->FileGuid,
1011 sizeof (EFI_GUID)
1012 );
1013
1014 while (TotalSize > 0) {
1015 if ((PtrMap->NumBlocks == 0) || (PtrMap->Length == 0)) {
1016 break;
1017 }
1018
1019 BlockSize = (UINTN)PtrMap->Length;
1020 for (Index = 0; Index < PtrMap->NumBlocks; Index++) {
1021 NextBlock = BaseAddress + BlockSize;
1022 if ((StartAddress >= BaseAddress) && (StartAddress < NextBlock)) {
1023 //
1024 // So we need to update this block
1025 //
1026 Offset = (UINTN) (StartAddress - BaseAddress);
1027 Length = TotalSize;
1028 if ((Length + Offset ) > BlockSize) {
1029 Length = BlockSize - Offset;
1030 }
1031
1032 //
1033 // Add an extra check here to see if the pending record is correct
1034 //
1035 if (Pending && (Lba == PendingLba)) {
1036 if ((PendingOffset != Offset) || (PendingLength != Length)) {
1037 //
1038 // Error.
1039 //
1040 Status = EFI_ABORTED;
1041 break;
1042 }
1043 }
1044
1045 if ((!Pending) || (Lba >= PendingLba)) {
1046 DEBUG ((EFI_D_UPDATE, "Update Flash area from %08LX to %08LX\n", StartAddress, (UINT64)StartAddress + Length));
1047 Status = FtwProtocol->Write (
1048 FtwProtocol,
1049 Lba, // Lba
1050 Offset, // Offset
1051 Length, // Size
1052 &PrivateData, // Private Data
1053 FvbHandle, // FVB handle
1054 Image // Buffer
1055 );
1056 if (EFI_ERROR (Status)) {
1057 break;
1058 }
1059 }
1060
1061 //
1062 // Now increment StartAddress, ImageBuffer and decrease the
1063 // left size to prepare for the next block update.
1064 //
1065 StartAddress = StartAddress + Length;
1066 Image = Image + Length;
1067 TotalSize = TotalSize - Length;
1068 if (TotalSize <= 0) {
1069 break;
1070 }
1071 }
1072 BaseAddress = NextBlock;
1073 Lba++;
1074 }
1075
1076 if (EFI_ERROR (Status)) {
1077 break;
1078 }
1079 PtrMap++;
1080 }
1081
1082 FreePool (FwVolHeader);
1083
1084 *UpdatedSize = SizeLeft - TotalSize;
1085
1086 return EFI_SUCCESS;
1087 }
1088
1089 /**
1090 Directly update the buffer into flash area without fault tolerant write method.
1091
1092 @param ImageBuffer Image buffer to be updated.
1093 @param SizeLeft Size of the image buffer.
1094 @param UpdatedSize Size of the updated buffer.
1095 @param FlashAddress Flash address to be updated as start address.
1096 @param FvbProtocol FVB protocol.
1097 @param FvbHandle Handle of FVB protocol for the updated flash range.
1098
1099 @retval EFI_SUCCESS Buffer data is updated into flash.
1100 @retval EFI_INVALID_PARAMETER Base flash address is not in FVB flash area.
1101 @retval EFI_OUT_OF_RESOURCES No enough backup space.
1102
1103 **/
1104 EFI_STATUS
1105 NonFaultTolerantUpdateOnPartFv (
1106 IN UINT8 *ImageBuffer,
1107 IN UINTN SizeLeft,
1108 IN OUT UINTN *UpdatedSize,
1109 IN EFI_PHYSICAL_ADDRESS FlashAddress,
1110 IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvbProtocol,
1111 IN EFI_HANDLE FvbHandle
1112 )
1113 {
1114 EFI_STATUS Status;
1115 EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;
1116 EFI_FIRMWARE_VOLUME_HEADER *FwVolHeaderTmp;
1117 EFI_PHYSICAL_ADDRESS BaseAddress;
1118 EFI_PHYSICAL_ADDRESS NextBlock;
1119 EFI_FV_BLOCK_MAP_ENTRY *BlockMap;
1120 UINTN Index;
1121 UINTN TotalSize;
1122 UINTN BlockSize;
1123 EFI_LBA Lba;
1124 UINTN Offset;
1125 UINTN Length;
1126 UINT8 *Image;
1127
1128 //
1129 // Get the block map to update the block one by one
1130 //
1131 Status = FvbProtocol->GetPhysicalAddress (
1132 FvbProtocol,
1133 &BaseAddress
1134 );
1135 if (EFI_ERROR (Status)) {
1136 return Status;
1137 }
1138
1139 FwVolHeaderTmp = (EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)BaseAddress;
1140 if ((FlashAddress < BaseAddress) || (FlashAddress > ( BaseAddress + FwVolHeaderTmp->FvLength ))) {
1141 return EFI_INVALID_PARAMETER;
1142 }
1143
1144 FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *)AllocateCopyPool (
1145 FwVolHeaderTmp->HeaderLength,
1146 FwVolHeaderTmp
1147 );
1148 if (FwVolHeader == NULL) {
1149 return EFI_OUT_OF_RESOURCES;
1150 }
1151
1152 Image = ImageBuffer;
1153 TotalSize = SizeLeft;
1154 BlockMap = &(FwVolHeader->BlockMap[0]);
1155 Lba = 0;
1156
1157 while (TotalSize > 0) {
1158 if ((BlockMap->NumBlocks == 0) || (BlockMap->Length == 0)) {
1159 break;
1160 }
1161
1162 BlockSize = BlockMap->Length;
1163 for (Index = 0 ; Index < BlockMap->NumBlocks ; Index++) {
1164 NextBlock = BaseAddress + BlockSize;
1165 if ((FlashAddress >= BaseAddress) && (FlashAddress < NextBlock)) {
1166 //
1167 // So we need to update this block
1168 //
1169 Offset = (UINTN) FlashAddress - (UINTN) BaseAddress;
1170 Length = TotalSize;
1171 if ((Length + Offset ) > BlockSize) {
1172 Length = BlockSize - Offset;
1173 }
1174
1175 DEBUG ((EFI_D_UPDATE, "Update Flash area from %08LX to %08LX\n", FlashAddress, (UINT64)FlashAddress + Length));
1176 //
1177 // Update the block
1178 //
1179 Status = UpdateBufferInOneBlock (
1180 FvbProtocol,
1181 Lba,
1182 Offset,
1183 Length,
1184 BlockSize,
1185 Image
1186 );
1187 if (EFI_ERROR (Status)) {
1188 FreePool (FwVolHeader);
1189 return Status;
1190 }
1191
1192 //
1193 // Now increment FlashAddress, ImageBuffer and decrease the
1194 // left size to prepare for the next block update.
1195 //
1196 FlashAddress = FlashAddress + Length;
1197 Image = Image + Length;
1198 TotalSize = TotalSize - Length;
1199 if (TotalSize <= 0) {
1200 break;
1201 }
1202 }
1203 BaseAddress = NextBlock;
1204 Lba++;
1205 }
1206
1207 if (EFI_ERROR (Status)) {
1208 break;
1209 }
1210 BlockMap++;
1211 }
1212
1213 FreePool (FwVolHeader);
1214
1215 *UpdatedSize = SizeLeft - TotalSize;
1216
1217 return EFI_SUCCESS;
1218 }
EFI Development Kit II mirror for PVE