1 /** @file
2
3 Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
4
5
6 This program and the accompanying materials are licensed and made available under
7
8 the terms and conditions of the BSD License that accompanies this distribution.
9
10 The full text of the license may be found at
11
12 http://opensource.org/licenses/bsd-license.php.
13
14
15
16 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
17
18 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
19
20
21
22
23 **/
24
25 #include "FirmwareUpdate.h"
26
27 EFI_HII_HANDLE HiiHandle;
28
29 //
30 // MinnowMax Flash Layout
31 //
32 //Start (hex) End (hex) Length (hex) Area Name
33 //----------- --------- ------------ ---------
34 //00000000 007FFFFF 00800000 Flash Image
35 //
36 //00000000 00000FFF 00001000 Descriptor Region
37 //00001000 004FFFFF 004FF000 TXE Region
38 //00500000 007FFFFF 00300000 BIOS Region
39 //
40 FV_REGION_INFO mRegionInfo[] = {
41 {FixedPcdGet32 (PcdFlashDescriptorBase), FixedPcdGet32 (PcdFlashDescriptorSize), TRUE},
42 {FixedPcdGet32 (PcdTxeRomBase), FixedPcdGet32 (PcdTxeRomSize), TRUE},
43 {FixedPcdGet32 (PcdBiosRomBase), FixedPcdGet32 (PcdBiosRomSize), TRUE}
GetRegionIndex(IN EFI_PHYSICAL_ADDRESS Address,OUT UINTN * RegionIndex)44 };
45
46 UINTN mRegionInfoCount = sizeof (mRegionInfo) / sizeof (mRegionInfo[0]);
47
48 FV_INPUT_DATA mInputData = {0};
49
50 EFI_SPI_PROTOCOL *mSpiProtocol;
51
52 EFI_STATUS
53 GetRegionIndex (
54 IN EFI_PHYSICAL_ADDRESS Address,
55 OUT UINTN *RegionIndex
56 )
57 {
58 UINTN Index;
59
60 for (Index = 0; Index < mRegionInfoCount; Index++) {
61 if (Address >= mRegionInfo[Index].Base &&
62 Address < (mRegionInfo[Index].Base + mRegionInfo[Index].Size)
63 ) {
64 break;
65 }
66 }
UpdateBlock(IN EFI_PHYSICAL_ADDRESS Address)67
68 *RegionIndex = Index;
69 if (Index >= mRegionInfoCount) {
70 return EFI_NOT_FOUND;
71 }
72 return EFI_SUCCESS;
73 }
74
75 BOOLEAN
76 UpdateBlock (
77 IN EFI_PHYSICAL_ADDRESS Address
78 )
79 {
80 EFI_STATUS Status;
81 UINTN Index;
82
83 if (mInputData.FullFlashUpdate) {
84 return TRUE;
85 }
86
MarkRegionState(IN EFI_PHYSICAL_ADDRESS Address,IN BOOLEAN Update)87 Status = GetRegionIndex (Address, &Index);
88 if ((!EFI_ERROR(Status)) && mRegionInfo[Index].Update) {
89 return TRUE;
90 }
91
92 return FALSE;
93 }
94
95 EFI_STATUS
96 MarkRegionState (
97 IN EFI_PHYSICAL_ADDRESS Address,
98 IN BOOLEAN Update
99 )
100 {
101 EFI_STATUS Status;
102 UINTN Index;
103
InternalPrintToken(IN CONST CHAR16 * Format,IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL * Console,IN VA_LIST Marker)104 Status = GetRegionIndex (Address, &Index);
105 if (!EFI_ERROR(Status)) {
106 mRegionInfo[Index].Update = Update;
107 }
108
109 return Status;
110 }
111
112 UINTN
113 InternalPrintToken (
114 IN CONST CHAR16 *Format,
115 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *Console,
116 IN VA_LIST Marker
117 )
118 {
119 EFI_STATUS Status;
120 UINTN Return;
121 CHAR16 *Buffer;
122 UINTN BufferSize;
123
124 ASSERT (Format != NULL);
125 ASSERT (((UINTN) Format & BIT0) == 0);
126 ASSERT (Console != NULL);
127
128 BufferSize = (PcdGet32 (PcdUefiLibMaxPrintBufferSize) + 1) * sizeof (CHAR16);
129
130 Buffer = (CHAR16 *) AllocatePool(BufferSize);
131 ASSERT (Buffer != NULL);
132
133 Return = UnicodeVSPrint (Buffer, BufferSize, Format, Marker);
134
135 if (Console != NULL && Return > 0) {
136 //
137 // To be extra safe make sure Console has been initialized.
138 //
139 Status = Console->OutputString (Console, Buffer);
140 if (EFI_ERROR (Status)) {
141 Return = 0;
142 }
PrintToken(IN UINT16 Token,IN EFI_HII_HANDLE Handle,...)143 }
144
145 FreePool (Buffer);
146
147 return Return;
148 }
149
150 UINTN
151 EFIAPI
152 PrintToken (
153 IN UINT16 Token,
154 IN EFI_HII_HANDLE Handle,
155 ...
156 )
157 {
158 VA_LIST Marker;
159 UINTN Return;
160 CHAR16 *Format;
161
162 VA_START (Marker, Handle);
163
164 Format = HiiGetString (Handle, Token, NULL);
165 ASSERT (Format != NULL);
166
167 Return = InternalPrintToken (Format, gST->ConOut, Marker);
ParseCommandLine(IN UINTN Argc,IN CHAR16 ** Argv)168
169 FreePool (Format);
170
171 VA_END (Marker);
172
173 return Return;
174 }
175
176 EFI_STATUS
177 ParseCommandLine (
178 IN UINTN Argc,
179 IN CHAR16 **Argv
180 )
181 {
182 EFI_STATUS Status;
183 UINTN Index;
184
185 //
186 // Check to make sure that the command line has enough arguments for minimal
187 // operation. The minimum is just the file name.
188 //
189 if (Argc < 2 || Argc > 4) {
190 return EFI_INVALID_PARAMETER;
191 }
192
193 //
194 // Loop through command line arguments.
195 //
196 for (Index = 1; Index < Argc; Index++) {
197 //
198 // Make sure the string is valid.
199 //
200 if (StrLen (Argv[Index]) == 0) {;
201 PrintToken (STRING_TOKEN (STR_FWUPDATE_ZEROLENGTH_ARG), HiiHandle);
202 return EFI_INVALID_PARAMETER;
203 }
204
205 //
206 // Check to see if this is an option or the file name.
207 //
208 if ((Argv[Index])[0] == L'-' || (Argv[Index])[0] == L'/') {
209 //
210 // Parse the arguments.
211 //
212 if ((StrCmp (Argv[Index], L"-h") == 0) ||
213 (StrCmp (Argv[Index], L"--help") == 0) ||
214 (StrCmp (Argv[Index], L"/?") == 0) ||
215 (StrCmp (Argv[Index], L"/h") == 0)) {
216 //
217 // Print Help Information.
218 //
219 return EFI_INVALID_PARAMETER;
220 } else if (StrCmp (Argv[Index], L"-m") == 0) {
221 //
222 // Parse the MAC address here.
223 //
224 Status = ConvertMac(Argv[Index+1]);
225 if (EFI_ERROR(Status)) {
226 PrintToken (STRING_TOKEN (STR_FWUPDATE_INVAILD_MAC), HiiHandle);
227 return Status;
228 }
229
230 //
231 // Save the MAC address to mInputData.MacValue.
232 //
233 mInputData.UpdateMac= TRUE;
234 Index++;
235 } else {
236 //
237 // Invalid option was provided.
238 //
239 return EFI_INVALID_PARAMETER;
240 }
241 }
242 if ((Index == Argc - 1) && (StrCmp (Argv[Index - 1], L"-m") != 0)) {
243 //
244 // The only parameter that is not an option is the firmware image. Check
245 // to make sure that the file exists.
246 //
247 Status = ShellIsFile (Argv[Index]);
248 if (EFI_ERROR (Status)) {
249 PrintToken (STRING_TOKEN (STR_FWUPDATE_FILE_NOT_FOUND_ERROR), HiiHandle, Argv[Index]);
250 return EFI_INVALID_PARAMETER;
251 }
252 if (StrLen (Argv[Index]) > INPUT_STRING_LEN) {
253 PrintToken (STRING_TOKEN (STR_FWUPDATE_PATH_ERROR), HiiHandle, Argv[Index]);
254 return EFI_INVALID_PARAMETER;
255 }
256 StrCpy (mInputData.FileName, Argv[Index]);
ShellAppMain(IN UINTN Argc,IN CHAR16 ** Argv)257 mInputData.UpdateFromFile = TRUE;
258 }
259 }
260
261 return EFI_SUCCESS;
262 }
263
264 INTN
265 EFIAPI
266 ShellAppMain (
267 IN UINTN Argc,
268 IN CHAR16 **Argv
269 )
270 {
271 EFI_STATUS Status;
272 UINTN Index;
273 UINT32 FileSize;
274 UINT32 BufferSize;
275 UINT8 *FileBuffer;
276 UINT8 *Buffer;
277 EFI_PHYSICAL_ADDRESS Address;
278 UINTN CountOfBlocks;
279 EFI_TPL OldTpl;
280 BOOLEAN ResetRequired;
281 BOOLEAN FlashError;
282
283 Index = 0;
284 FileSize = 0;
285 BufferSize = 0;
286 FileBuffer = NULL;
287 Buffer = NULL;
288 Address = 0;
289 CountOfBlocks = 0;
290 ResetRequired = FALSE;
291 FlashError = FALSE;
292
293 Status = EFI_SUCCESS;
294
295 mInputData.FullFlashUpdate = TRUE;
296
297 //
298 // Publish our HII data.
299 //
300 HiiHandle = HiiAddPackages (
301 &gEfiCallerIdGuid,
302 NULL,
303 FirmwareUpdateStrings,
304 NULL
305 );
306 if (HiiHandle == NULL) {
307 Status = EFI_OUT_OF_RESOURCES;
308 goto Done;
309 }
310
311 //
312 // Locate the SPI protocol.
313 //
314 Status = gBS->LocateProtocol (
315 &gEfiSpiProtocolGuid,
316 NULL,
317 (VOID **)&mSpiProtocol
318 );
319 if (EFI_ERROR (Status)) {
320 PrintToken (STRING_TOKEN (STR_SPI_NOT_FOUND), HiiHandle);
321 return EFI_DEVICE_ERROR;
322 }
323
324 //
325 // Parse the command line.
326 //
327 Status = ParseCommandLine (Argc, Argv);
328 if (EFI_ERROR (Status)) {
329 PrintHelpInfo ();
330 Status = EFI_SUCCESS;
331 goto Done;
332 }
333
334 //
335 // Display sign-on information.
336 //
337 PrintToken (STRING_TOKEN (STR_FWUPDATE_FIRMWARE_VOL_UPDATE), HiiHandle);
338 PrintToken (STRING_TOKEN (STR_FWUPDATE_VERSION), HiiHandle);
339 PrintToken (STRING_TOKEN (STR_FWUPDATE_COPYRIGHT), HiiHandle);
340
341 //
342 // Test to see if the firmware needs to be updated.
343 //
344 if (mInputData.UpdateFromFile) {
345 //
346 // Get the file to use in the update.
347 //
348 PrintToken (STRING_TOKEN (STR_FWUPDATE_READ_FILE), HiiHandle, mInputData.FileName);
349 Status = ReadFileData (mInputData.FileName, &FileBuffer, &FileSize);
350 if (EFI_ERROR (Status)) {
351 PrintToken (STRING_TOKEN (STR_FWUPDATE_READ_FILE_ERROR), HiiHandle, mInputData.FileName);
352 goto Done;
353 }
354
355 //
356 // Check that the file and flash sizes match.
357 //
358 if (FileSize != PcdGet32 (PcdFlashChipSize)) {
359 PrintToken (STRING_TOKEN (STR_FWUPDATE_SIZE), HiiHandle);
360 Status = EFI_UNSUPPORTED;
361 goto Done;
362 }
363
364 //
365 // Display flash update information.
366 //
367 PrintToken (STRING_TOKEN (STR_FWUPDATE_UPDATING_FIRMWARE), HiiHandle);
368
369 //
370 // Update it.
371 //
372 Buffer = FileBuffer;
373 BufferSize = FileSize;
374 Address = PcdGet32 (PcdFlashChipBase);
375 CountOfBlocks = (UINTN) (BufferSize / BLOCK_SIZE);
376
377 //
378 // Raise TPL to TPL_NOTIFY to block any event handler,
379 // while still allowing RaiseTPL(TPL_NOTIFY) within
380 // output driver during Print().
381 //
382 OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
383 for (Index = 0; Index < CountOfBlocks; Index++) {
384 //
385 // Handle block based on address and contents.
386 //
387 if (!UpdateBlock (Address)) {
388 DEBUG((EFI_D_INFO, "Skipping block at 0x%lx\n", Address));
389 } else if (!EFI_ERROR (InternalCompareBlock (Address, Buffer))) {
390 DEBUG((EFI_D_INFO, "Skipping block at 0x%lx (already programmed)\n", Address));
391 } else {
392 //
393 // Display a dot for each block being updated.
394 //
395 Print (L".");
396
397 //
398 // Flag that the flash image will be changed and the system must be rebooted
399 // to use the change.
400 //
401 ResetRequired = TRUE;
402
403 //
404 // Make updating process uninterruptable,
405 // so that the flash memory area is not accessed by other entities
406 // which may interfere with the updating process.
407 //
408 Status = InternalEraseBlock (Address);
409 ASSERT_EFI_ERROR(Status);
410 if (EFI_ERROR (Status)) {
411 gBS->RestoreTPL (OldTpl);
412 FlashError = TRUE;
413 goto Done;
414 }
415 Status = InternalWriteBlock (
416 Address,
417 Buffer,
418 (BufferSize > BLOCK_SIZE ? BLOCK_SIZE : BufferSize)
419 );
420 if (EFI_ERROR (Status)) {
421 gBS->RestoreTPL (OldTpl);
422 FlashError = TRUE;
423 goto Done;
424 }
425 }
426
427 //
428 // Move to next block to update.
429 //
430 Address += BLOCK_SIZE;
431 Buffer += BLOCK_SIZE;
432 if (BufferSize > BLOCK_SIZE) {
433 BufferSize -= BLOCK_SIZE;
434 } else {
435 BufferSize = 0;
436 }
437 }
438 gBS->RestoreTPL (OldTpl);
439
440 //
441 // Print result of update.
442 //
443 if (!FlashError) {
444 if (ResetRequired) {
445 Print (L"\n");
446 PrintToken (STRING_TOKEN (STR_FWUPDATE_UPDATE_SUCCESS), HiiHandle);
447 } else {
448 PrintToken (STRING_TOKEN (STR_FWUPDATE_NO_RESET), HiiHandle);
449 }
450 } else {
451 goto Done;
452 }
453 }
454
455 //
456 // All flash updates are done so see if the system needs to be reset.
457 //
458 if (ResetRequired && !FlashError) {
459 //
460 // Update successful.
461 //
462 for (Index = 5; Index > 0; Index--) {
463 PrintToken (STRING_TOKEN (STR_FWUPDATE_SHUTDOWN), HiiHandle, Index);
464 gBS->Stall (1000000);
465 }
466
467 gRT->ResetSystem (EfiResetShutdown, EFI_SUCCESS, 0, NULL);
468 PrintToken (STRING_TOKEN (STR_FWUPDATE_MANUAL_RESET), HiiHandle);
469 CpuDeadLoop ();
470 }
471
472 Done:
473 //
474 // Print flash update failure message if error detected.
475 //
476 if (FlashError) {
477 PrintToken (STRING_TOKEN (STR_FWUPDATE_UPDATE_FAILED), HiiHandle, Index);
478 }
479
480 //
481 // Do cleanup.
482 //
483 if (HiiHandle != NULL) {
484 HiiRemovePackages (HiiHandle);
485 }
InternalEraseBlock(IN EFI_PHYSICAL_ADDRESS BaseAddress)486 if (FileBuffer) {
487 gBS->FreePool (FileBuffer);
488 }
489
490 return Status;
491 }
492
493 STATIC
494 EFI_STATUS
495 InternalEraseBlock (
496 IN EFI_PHYSICAL_ADDRESS BaseAddress
497 )
498 /*++
499
500 Routine Description:
501
502 Erase the whole block.
503
504 Arguments:
505
506 BaseAddress - Base address of the block to be erased.
507
508 Returns:
509
510 EFI_SUCCESS - The command completed successfully.
511 Other - Device error or wirte-locked, operation failed.
512
513 --*/
514 {
515 EFI_STATUS Status;
516 UINTN NumBytes;
517
518 NumBytes = BLOCK_SIZE;
519
520 Status = SpiFlashBlockErase ((UINTN) BaseAddress, &NumBytes);
521
522 return Status;
523 }
524
525 #if 0
526 STATIC
527 EFI_STATUS
528 InternalReadBlock (
529 IN EFI_PHYSICAL_ADDRESS BaseAddress,
530 OUT VOID *ReadBuffer
531 )
532 {
533 EFI_STATUS Status;
534 UINT32 BlockSize;
535
536 BlockSize = BLOCK_SIZE;
InternalCompareBlock(IN EFI_PHYSICAL_ADDRESS BaseAddress,IN UINT8 * Buffer)537
538 Status = SpiFlashRead ((UINTN) BaseAddress, &BlockSize, ReadBuffer);
539
540 return Status;
541 }
542 #endif
543
544 STATIC
545 EFI_STATUS
546 InternalCompareBlock (
547 IN EFI_PHYSICAL_ADDRESS BaseAddress,
548 IN UINT8 *Buffer
549 )
550 {
551 EFI_STATUS Status;
552 VOID *CompareBuffer;
553 UINT32 NumBytes;
554 INTN CompareResult;
555
556 NumBytes = BLOCK_SIZE;
557 CompareBuffer = AllocatePool (NumBytes);
558 if (CompareBuffer == NULL) {
559 Status = EFI_OUT_OF_RESOURCES;
560 goto Done;
561 }
562
563 Status = SpiFlashRead ((UINTN) BaseAddress, &NumBytes, CompareBuffer);
564 if (EFI_ERROR (Status)) {
565 goto Done;
566 }
567 CompareResult = CompareMem (CompareBuffer, Buffer, BLOCK_SIZE);
568 if (CompareResult != 0) {
569 Status = EFI_VOLUME_CORRUPTED;
570 }
571
572 Done:
InternalWriteBlock(IN EFI_PHYSICAL_ADDRESS BaseAddress,IN UINT8 * Buffer,IN UINT32 BufferSize)573 if (CompareBuffer != NULL) {
574 FreePool (CompareBuffer);
575 }
576
577 return Status;
578 }
579
580 STATIC
581 EFI_STATUS
582 InternalWriteBlock (
583 IN EFI_PHYSICAL_ADDRESS BaseAddress,
584 IN UINT8 *Buffer,
585 IN UINT32 BufferSize
586 )
587 /*++
588
589 Routine Description:
590
591 Write a block of data.
592
593 Arguments:
594
595 BaseAddress - Base address of the block.
596 Buffer - Data buffer.
597 BufferSize - Size of the buffer.
598
599 Returns:
600
601 EFI_SUCCESS - The command completed successfully.
602 EFI_INVALID_PARAMETER - Invalid parameter, can not proceed.
603 Other - Device error or wirte-locked, operation failed.
604
605 --*/
606 {
607 EFI_STATUS Status;
608
609 Status = SpiFlashWrite ((UINTN) BaseAddress, &BufferSize, Buffer);
610 ASSERT_EFI_ERROR(Status);
611 if (EFI_ERROR (Status)) {
612 DEBUG((EFI_D_ERROR, "\nFlash write error."));
613 return Status;
614 }
615
616 WriteBackInvalidateDataCacheRange ((VOID *) (UINTN) BaseAddress, BLOCK_SIZE);
617
618 Status = InternalCompareBlock (BaseAddress, Buffer);
619 if (EFI_ERROR (Status)) {
620 DEBUG((EFI_D_ERROR, "\nError when writing to BaseAddress %lx with different at offset %x.", BaseAddress, Status));
621 } else {
ReadFileData(IN CHAR16 * FileName,OUT UINT8 ** Buffer,OUT UINT32 * BufferSize)622 DEBUG((EFI_D_INFO, "\nVerified data written to Block at %lx is correct.", BaseAddress));
623 }
624
625 return Status;
626
627 }
628
629 STATIC
630 EFI_STATUS
631 ReadFileData (
632 IN CHAR16 *FileName,
633 OUT UINT8 **Buffer,
634 OUT UINT32 *BufferSize
635 )
636 {
637 EFI_STATUS Status;
638 SHELL_FILE_HANDLE FileHandle;
639 UINT64 Size;
640 VOID *NewBuffer;
641 UINTN ReadSize;
642
643 FileHandle = NULL;
644 NewBuffer = NULL;
645 Size = 0;
646
647 Status = ShellOpenFileByName (FileName, &FileHandle, EFI_FILE_MODE_READ, 0);
648 if (EFI_ERROR (Status)) {
649 goto Done;
650 }
651
652 Status = FileHandleIsDirectory (FileHandle);
653 if (!EFI_ERROR (Status)) {
654 Status = EFI_NOT_FOUND;
655 goto Done;
656 }
657
658 Status = FileHandleGetSize (FileHandle, &Size);
659 if (EFI_ERROR (Status)) {
660 goto Done;
661 }
662
663 NewBuffer = AllocatePool ((UINTN) Size);
664
665 ReadSize = (UINTN) Size;
666 Status = FileHandleRead (FileHandle, &ReadSize, NewBuffer);
667 if (EFI_ERROR (Status)) {
668 goto Done;
669 } else if (ReadSize != (UINTN) Size) {
670 Status = EFI_INVALID_PARAMETER;
671 goto Done;
672 }
673
674 Done:
675 if (FileHandle != NULL) {
676 ShellCloseFile (&FileHandle);
677 }
678
679 if (EFI_ERROR (Status)) {
680 if (NewBuffer != NULL) {
681 FreePool (NewBuffer);
682 }
683 } else {
PrintHelpInfo(VOID)684 *Buffer = NewBuffer;
685 *BufferSize = (UINT32) Size;
686 }
687
688 return Status;
689 }
690
691 STATIC
692 VOID
693 PrintHelpInfo (
694 VOID
695 )
696 /*++
697
698 Routine Description:
699
700 Print out help information.
701
702 Arguments:
703
704 None.
705
706 Returns:
707
708 None.
709
710 --*/
711 {
712 PrintToken (STRING_TOKEN (STR_FWUPDATE_FIRMWARE_VOL_UPDATE), HiiHandle);
713 PrintToken (STRING_TOKEN (STR_FWUPDATE_VERSION), HiiHandle);
714 PrintToken (STRING_TOKEN (STR_FWUPDATE_COPYRIGHT), HiiHandle);
715
716 Print (L"\n");
717 PrintToken (STRING_TOKEN (STR_FWUPDATE_USAGE), HiiHandle);
718 PrintToken (STRING_TOKEN (STR_FWUPDATE_USAGE_1), HiiHandle);
719 PrintToken (STRING_TOKEN (STR_FWUPDATE_USAGE_2), HiiHandle);
720 PrintToken (STRING_TOKEN (STR_FWUPDATE_USAGE_3), HiiHandle);
721 PrintToken (STRING_TOKEN (STR_FWUPDATE_USAGE_4), HiiHandle);
722
723 Print (L"\n");
724 }
725
726 /**
727 Read NumBytes bytes of data from the address specified by
728 PAddress into Buffer.
729
730 @param[in] Address The starting physical address of the read.
731 @param[in,out] NumBytes On input, the number of bytes to read. On output, the number
SpiFlashRead(IN UINTN Address,IN OUT UINT32 * NumBytes,OUT UINT8 * Buffer)732 of bytes actually read.
733 @param[out] Buffer The destination data buffer for the read.
734
735 @retval EFI_SUCCESS Opertion is successful.
736 @retval EFI_DEVICE_ERROR If there is any device errors.
737
738 **/
739 EFI_STATUS
740 EFIAPI
741 SpiFlashRead (
742 IN UINTN Address,
743 IN OUT UINT32 *NumBytes,
744 OUT UINT8 *Buffer
745 )
746 {
747 EFI_STATUS Status = EFI_SUCCESS;
748 UINTN Offset = 0;
749
750 ASSERT ((NumBytes != NULL) && (Buffer != NULL));
751
752 Offset = Address - (UINTN)PcdGet32 (PcdFlashChipBase);
753
754 Status = mSpiProtocol->Execute (
755 mSpiProtocol,
756 1, //SPI_READ,
757 0, //SPI_WREN,
758 TRUE,
759 TRUE,
760 FALSE,
761 Offset,
762 BLOCK_SIZE,
763 Buffer,
764 EnumSpiRegionAll
765 );
766 return Status;
767
768 }
769
770 /**
771 Write NumBytes bytes of data from Buffer to the address specified by
772 PAddresss.
773
774 @param[in] Address The starting physical address of the write.
775 @param[in,out] NumBytes On input, the number of bytes to write. On output,
SpiFlashWrite(IN UINTN Address,IN OUT UINT32 * NumBytes,IN UINT8 * Buffer)776 the actual number of bytes written.
777 @param[in] Buffer The source data buffer for the write.
778
779 @retval EFI_SUCCESS Opertion is successful.
780 @retval EFI_DEVICE_ERROR If there is any device errors.
781
782 **/
783 EFI_STATUS
784 EFIAPI
785 SpiFlashWrite (
786 IN UINTN Address,
787 IN OUT UINT32 *NumBytes,
788 IN UINT8 *Buffer
789 )
790 {
791 EFI_STATUS Status;
792 UINTN Offset;
793 UINT32 Length;
794 UINT32 RemainingBytes;
795
796 ASSERT ((NumBytes != NULL) && (Buffer != NULL));
797 ASSERT (Address >= (UINTN)PcdGet32 (PcdFlashChipBase));
798
799 Offset = Address - (UINTN)PcdGet32 (PcdFlashChipBase);
800
801 ASSERT ((*NumBytes + Offset) <= (UINTN)PcdGet32 (PcdFlashChipSize));
802
803 Status = EFI_SUCCESS;
804 RemainingBytes = *NumBytes;
805
806 while (RemainingBytes > 0) {
807 if (RemainingBytes > SIZE_4KB) {
808 Length = SIZE_4KB;
809 } else {
810 Length = RemainingBytes;
811 }
812 Status = mSpiProtocol->Execute (
813 mSpiProtocol,
814 SPI_PROG,
815 SPI_WREN,
816 TRUE,
817 TRUE,
818 TRUE,
819 (UINT32) Offset,
820 Length,
821 Buffer,
822 EnumSpiRegionAll
823 );
824 if (EFI_ERROR (Status)) {
825 break;
826 }
827 RemainingBytes -= Length;
828 Offset += Length;
829 Buffer += Length;
830 }
831
832 //
833 // Actual number of bytes written.
834 //
835 *NumBytes -= RemainingBytes;
836
837 return Status;
838 }
839
840 /**
841 Erase the block starting at Address.
842
843 @param[in] Address The starting physical address of the block to be erased.
844 This library assume that caller garantee that the PAddress
845 is at the starting address of this block.
SpiFlashBlockErase(IN UINTN Address,IN UINTN * NumBytes)846 @param[in] NumBytes On input, the number of bytes of the logical block to be erased.
847 On output, the actual number of bytes erased.
848
849 @retval EFI_SUCCESS. Opertion is successful.
850 @retval EFI_DEVICE_ERROR If there is any device errors.
851
852 **/
853 EFI_STATUS
854 EFIAPI
855 SpiFlashBlockErase (
856 IN UINTN Address,
857 IN UINTN *NumBytes
858 )
859 {
860 EFI_STATUS Status;
861 UINTN Offset;
862 UINTN RemainingBytes;
863
864 ASSERT (NumBytes != NULL);
865 ASSERT (Address >= (UINTN)PcdGet32 (PcdFlashChipBase));
866
867 Offset = Address - (UINTN)PcdGet32 (PcdFlashChipBase);
868
869 ASSERT ((*NumBytes % SIZE_4KB) == 0);
870 ASSERT ((*NumBytes + Offset) <= (UINTN)PcdGet32 (PcdFlashChipSize));
871
872 Status = EFI_SUCCESS;
873 RemainingBytes = *NumBytes;
874
875 while (RemainingBytes > 0) {
876 Status = mSpiProtocol->Execute (
877 mSpiProtocol,
878 SPI_SERASE,
879 SPI_WREN,
880 FALSE,
881 TRUE,
882 FALSE,
883 (UINT32) Offset,
884 0,
885 NULL,
886 EnumSpiRegionAll
887 );
888 if (EFI_ERROR (Status)) {
889 break;
890 }
891 RemainingBytes -= SIZE_4KB;
892 Offset += SIZE_4KB;
893 }
894
895 //
896 // Actual number of bytes erased.
897 //
898 *NumBytes -= RemainingBytes;
899
900 return Status;
901 }
902
903 EFI_STATUS
904 EFIAPI
905 ConvertMac (
906 CHAR16 *Str
907 )
908 {
909 UINTN Index;
910 UINT8 Temp[MAC_ADD_STR_LEN];
911
912 if (Str == NULL)
913 return EFI_INVALID_PARAMETER;
914
915 if (StrLen(Str) != MAC_ADD_STR_LEN)
916 return EFI_INVALID_PARAMETER;
917
918 for (Index = 0; Index < MAC_ADD_STR_LEN; Index++) {
919 if (Str[Index] >= 0x30 && Str[Index] <= 0x39) {
920 Temp[Index] = (UINT8)Str[Index] - 0x30;
921 } else if (Str[Index] >= 0x41 && Str[Index] <= 0x46) {
922 Temp[Index] = (UINT8)Str[Index] - 0x37;
923 } else if (Str[Index] >= 0x61 && Str[Index] <= 0x66) {
924 Temp[Index] = (UINT8)Str[Index] - 0x57;
925 } else {
926 return EFI_INVALID_PARAMETER;
927 }
928 }
929
930 for (Index = 0; Index < MAC_ADD_BYTE_COUNT; Index++) {
931 mInputData.MacValue[Index] = (Temp[2 * Index] << 4) + Temp[2 * Index + 1];
932 }
933
934 return EFI_SUCCESS;
935 }
936
937