EmbeddedPkg : Add FdtPlatformDxe driver
[mirror_edk2.git] / EmbeddedPkg / Drivers / FdtPlatformDxe / FdtPlatform.c
1 /** @file
2
3 Copyright (c) 2015, ARM Ltd. All rights reserved.<BR>
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 #include <Uefi.h>
15
16 #include <Library/UefiLib.h>
17 #include <Library/DebugLib.h>
18 #include <Library/UefiBootServicesTableLib.h>
19 #include <Library/UefiRuntimeServicesTableLib.h>
20 #include <Library/PcdLib.h>
21 #include <Library/DevicePathLib.h>
22 #include <Library/MemoryAllocationLib.h>
23
24 #include <Library/BdsLib.h>
25
26 #include <Protocol/DevicePathFromText.h>
27 #include <Protocol/DevicePath.h>
28
29 #include <Guid/EventGroup.h>
30 #include <Guid/Fdt.h>
31
32 #include <libfdt.h>
33
34 //
35 // Internal types
36 //
37 STATIC VOID OnEndOfDxe (
38 IN EFI_EVENT Event,
39 IN VOID *Context
40 );
41 STATIC EFI_STATUS RunFdtInstallation (
42 VOID
43 );
44 STATIC EFI_STATUS InstallFdt (
45 IN CONST CHAR16* TextDevicePath
46 );
47
48 /**
49 Main entry point of the FDT platform driver.
50
51 @param[in] ImageHandle The firmware allocated handle for the present driver
52 UEFI image.
53 @param[in] *SystemTable A pointer to the EFI System table.
54
55 @retval EFI_SUCCESS The driver was initialized.
56 @retval EFI_OUT_OF_RESOURCES The "End of DXE" event could not be allocated.
57
58 **/
59 EFI_STATUS
60 FdtPlatformEntryPoint (
61 IN EFI_HANDLE ImageHandle,
62 IN EFI_SYSTEM_TABLE *SystemTable
63 )
64 {
65 EFI_STATUS Status;
66 EFI_EVENT EndOfDxeEvent;
67
68 //
69 // Create an event belonging to the "gEfiEndOfDxeEventGroupGuid" group.
70 // The "OnEndOfDxe()" function is declared as the call back function.
71 // It will be called at the end of the DXE phase when an event of the
72 // same group is signalled to inform about the end of the DXE phase.
73 //
74 Status = gBS->CreateEventEx (
75 EVT_NOTIFY_SIGNAL,
76 TPL_CALLBACK,
77 OnEndOfDxe,
78 NULL,
79 &gEfiEndOfDxeEventGroupGuid,
80 &EndOfDxeEvent
81 );
82
83 return Status;
84 }
85
86 /**
87 Notification function of the event defined as belonging to the
88 EFI_END_OF_DXE_EVENT_GROUP_GUID event group that was created in
89 the entry point of the driver.
90
91 This function is called when an event belonging to the
92 EFI_END_OF_DXE_EVENT_GROUP_GUID event group is signalled. Such an
93 event is signalled once at the end of the dispatching of all
94 drivers (end of the so called DXE phase).
95
96 @param[in] Event Event declared in the entry point of the driver whose
97 notification function is being invoked.
98 @param[in] Context NULL
99
100 **/
101 STATIC
102 VOID
103 OnEndOfDxe (
104 IN EFI_EVENT Event,
105 IN VOID *Context
106 )
107 {
108 RunFdtInstallation ();
109 gBS->CloseEvent (Event);
110 }
111
112 /**
113 Run the FDT installation process.
114
115 Loop in priority order over the device paths from which the FDT has
116 been asked to be retrieved for. For each device path, try to install
117 the FDT. Stop as soon as an installation succeeds.
118
119 @retval EFI_SUCCESS The FDT was installed.
120 @retval EFI_NOT_FOUND Failed to locate a protocol or a file.
121 @retval EFI_INVALID_PARAMETER Invalid device path.
122 @retval EFI_UNSUPPORTED Device path not supported.
123 @retval EFI_OUT_OF_RESOURCES An allocation failed.
124
125 **/
126 STATIC
127 EFI_STATUS
128 RunFdtInstallation (
129 VOID
130 )
131 {
132 EFI_STATUS Status;
133 UINTN DataSize;
134 VOID *Data;
135 CHAR16 *TextDevicePathStart;
136 CHAR16 *TextDevicePathSeparator;
137 UINTN TextDevicePathLen;
138 CHAR16 *TextDevicePath;
139
140 //
141 // For development purpose, if enabled through the "PcdOverridePlatformFdt"
142 // feature PCD, try first to install the FDT specified by the device path in
143 // text form stored in the "Fdt" UEFI variable.
144 //
145 if (FeaturePcdGet (PcdOverridePlatformFdt)) {
146 Data = NULL;
147 DataSize = 0;
148 Status = gRT->GetVariable (
149 L"Fdt",
150 &gFdtVariableGuid,
151 NULL,
152 &DataSize,
153 Data
154 );
155
156 //
157 // Keep going only if the "Fdt" variable is defined.
158 //
159
160 if (Status == EFI_BUFFER_TOO_SMALL) {
161 Data = AllocatePool (DataSize);
162 if (Data == NULL) {
163 Status = EFI_OUT_OF_RESOURCES;
164 } else {
165 Status = gRT->GetVariable (
166 L"Fdt",
167 &gFdtVariableGuid,
168 NULL,
169 &DataSize,
170 Data
171 );
172 if (!EFI_ERROR (Status)) {
173 Status = InstallFdt ((CHAR16*)Data);
174 if (!EFI_ERROR (Status)) {
175 DEBUG ((
176 EFI_D_WARN,
177 "Installation of the FDT using the device path <%s> completed.\n",
178 (CHAR16*)Data
179 ));
180 }
181 }
182 FreePool (Data);
183 }
184
185 if (EFI_ERROR (Status)) {
186 DEBUG ((
187 EFI_D_ERROR,
188 "Installation of the FDT specified by the \"Fdt\" UEFI variable failed - %r\n",
189 Status
190 ));
191 } else {
192 return Status;
193 }
194 }
195 }
196
197 //
198 // Loop over the device path list provided by "PcdFdtDevicePaths". The device
199 // paths are in text form and separated by a semi-colon.
200 //
201
202 Status = EFI_SUCCESS;
203 for (TextDevicePathStart = (CHAR16*)PcdGetPtr (PcdFdtDevicePaths);
204 *TextDevicePathStart != L'\0' ; ) {
205 TextDevicePathSeparator = StrStr (TextDevicePathStart, L";");
206
207 //
208 // Last device path of the list
209 //
210 if (TextDevicePathSeparator == NULL) {
211 TextDevicePath = TextDevicePathStart;
212 } else {
213 TextDevicePathLen = (UINTN)(TextDevicePathSeparator - TextDevicePathStart);
214 TextDevicePath = AllocateCopyPool (
215 (TextDevicePathLen + 1) * sizeof (CHAR16),
216 TextDevicePathStart
217 );
218 if (TextDevicePath == NULL) {
219 Status = EFI_OUT_OF_RESOURCES;
220 DEBUG ((EFI_D_ERROR, "Memory allocation error during FDT installation process.\n"));
221 break;
222 }
223 TextDevicePath[TextDevicePathLen] = L'\0';
224 }
225
226 Status = InstallFdt (TextDevicePath);
227 if (EFI_ERROR (Status)) {
228 DEBUG ((EFI_D_WARN, "Installation of the FDT using the device path <%s> failed - %r.\n",
229 TextDevicePath, Status
230 ));
231 } else {
232 DEBUG ((EFI_D_WARN, "Installation of the FDT using the device path <%s> completed.\n",
233 TextDevicePath
234 ));
235 }
236
237 if (TextDevicePathSeparator == NULL) {
238 break;
239 } else {
240 FreePool (TextDevicePath);
241 if (!EFI_ERROR (Status)) {
242 break;
243 }
244 TextDevicePathStart = TextDevicePathSeparator + 1;
245 }
246 }
247
248 if (EFI_ERROR (Status)) {
249 DEBUG ((EFI_D_ERROR, "Failed to install the FDT - %r.\n", Status));
250 }
251
252 return Status;
253 }
254
255 /**
256 Install the FDT specified by its device path in text form.
257
258 @param[in] TextDevicePath Device path of the FDT to install in text form
259
260 @retval EFI_SUCCESS The FDT was installed.
261 @retval EFI_NOT_FOUND Failed to locate a protocol or a file.
262 @retval EFI_INVALID_PARAMETER Invalid device path.
263 @retval EFI_UNSUPPORTED Device path not supported.
264 @retval EFI_OUT_OF_RESOURCES An allocation failed.
265 **/
266 STATIC
267 EFI_STATUS
268 InstallFdt (
269 IN CONST CHAR16* TextDevicePath
270 )
271 {
272 EFI_STATUS Status;
273 EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL *EfiDevicePathFromTextProtocol;
274 EFI_DEVICE_PATH *DevicePath;
275 EFI_PHYSICAL_ADDRESS FdtBlobBase;
276 UINTN FdtBlobSize;
277 UINTN NbPages;
278 EFI_PHYSICAL_ADDRESS RsFdtBlobBase;
279
280 Status = gBS->LocateProtocol (
281 &gEfiDevicePathFromTextProtocolGuid,
282 NULL,
283 (VOID **)&EfiDevicePathFromTextProtocol
284 );
285 if (EFI_ERROR (Status)) {
286 DEBUG ((EFI_D_ERROR, "InstallFdt() - Failed to locate EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL protocol\n"));
287 return Status;
288 }
289
290 DevicePath = (EFI_DEVICE_PATH*)EfiDevicePathFromTextProtocol->ConvertTextToDevicePath (TextDevicePath);
291 if (DevicePath == NULL) {
292 return EFI_INVALID_PARAMETER;
293 }
294
295 //
296 // Load the FDT given its device path.
297 // This operation may fail if the device path is not supported.
298 //
299 FdtBlobBase = 0;
300 NbPages = 0;
301 Status = BdsLoadImage (DevicePath, AllocateAnyPages, &FdtBlobBase, &FdtBlobSize);
302 if (EFI_ERROR (Status)) {
303 goto Error;
304 }
305
306 // Check the FDT header is valid. We only make this check in DEBUG mode in
307 // case the FDT header change on production device and this ASSERT() becomes
308 // not valid.
309 ASSERT (fdt_check_header ((VOID*)(UINTN)FdtBlobBase) == 0);
310
311 //
312 // Ensure the Size of the Device Tree is smaller than the size of the read file
313 //
314 ASSERT ((UINTN)fdt_totalsize ((VOID*)(UINTN)FdtBlobBase) <= FdtBlobSize);
315
316 //
317 // Store the FDT as Runtime Service Data to prevent the Kernel from
318 // overwritting its data.
319 //
320 NbPages = EFI_SIZE_TO_PAGES (FdtBlobSize);
321 Status = gBS->AllocatePages (
322 AllocateAnyPages, EfiRuntimeServicesData,
323 NbPages, &RsFdtBlobBase
324 );
325 if (EFI_ERROR (Status)) {
326 goto Error;
327 }
328 CopyMem (
329 (VOID*)((UINTN)RsFdtBlobBase),
330 (VOID*)((UINTN)FdtBlobBase),
331 FdtBlobSize
332 );
333
334 //
335 // Install the FDT into the Configuration Table
336 //
337 Status = gBS->InstallConfigurationTable (
338 &gFdtTableGuid,
339 (VOID*)((UINTN)RsFdtBlobBase)
340 );
341 if (EFI_ERROR (Status)) {
342 gBS->FreePages (RsFdtBlobBase, NbPages);
343 }
344
345 Error :
346
347 if (FdtBlobBase != 0) {
348 gBS->FreePages (FdtBlobBase, NbPages);
349 }
350 FreePool (DevicePath);
351
352 return Status;
353 }
354
355 =======
356
357 /**
358 This is the shell command "setfdt" handler function. This function handles
359 the command when it is invoked in the shell.
360
361 @param[in] This The instance of the
362 EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL.
363 @param[in] SystemTable The pointer to the UEFI system table.
364 @param[in] ShellParameters The parameters associated with the command.
365 @param[in] Shell The instance of the shell protocol used in the
366 context of processing this command.
367
368 @return SHELL_SUCCESS The operation was successful.
369 @return SHELL_ABORTED Operation aborted due to internal error.
370 @return SHELL_INVALID_PARAMETER The parameters of the command are not valid.
371 @return SHELL_INVALID_PARAMETER The EFI Shell file path is not valid.
372 @return SHELL_NOT_FOUND Failed to locate a protocol or a file.
373 @return SHELL_UNSUPPORTED Device path not supported.
374 @return SHELL_OUT_OF_RESOURCES A memory allocation failed.
375 @return SHELL_DEVICE_ERROR The "Fdt" variable could not be saved due to a hardware failure.
376 @return SHELL_ACCESS_DENIED The "Fdt" variable is read-only.
377 @return SHELL_ACCESS_DENIED The "Fdt" variable cannot be deleted.
378 @return SHELL_ACCESS_DENIED The "Fdt" variable could not be written due to security violation.
379
380 **/
381 STATIC
382 SHELL_STATUS
383 EFIAPI
384 ShellDynCmdSetFdtHandler (
385 IN EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL *This,
386 IN EFI_SYSTEM_TABLE *SystemTable,
387 IN EFI_SHELL_PARAMETERS_PROTOCOL *ShellParameters,
388 IN EFI_SHELL_PROTOCOL *Shell
389 )
390 {
391 SHELL_STATUS ShellStatus;
392 EFI_STATUS Status;
393 LIST_ENTRY *ParamPackage;
394 BOOLEAN FilePath;
395 CONST CHAR16 *ValueStr;
396
397 ShellStatus = SHELL_SUCCESS;
398 ParamPackage = NULL;
399 FilePath = FALSE;
400
401 //
402 // Install the Shell and Shell Parameters Protocols on the driver
403 // image. This is necessary for the initialisation of the Shell
404 // Library to succeed in the next step.
405 //
406 Status = gBS->InstallMultipleProtocolInterfaces (
407 &gImageHandle,
408 &gEfiShellProtocolGuid, Shell,
409 &gEfiShellParametersProtocolGuid, ShellParameters,
410 NULL
411 );
412 if (EFI_ERROR (Status)) {
413 return SHELL_ABORTED;
414 }
415
416 //
417 // Initialise the Shell Library as we are going to use it.
418 // Assert that the return code is EFI_SUCCESS as it should.
419 // To anticipate any change is the codes returned by
420 // ShellInitialize(), leave in case of error.
421 //
422 Status = ShellInitialize ();
423 if (EFI_ERROR (Status)) {
424 ASSERT_EFI_ERROR (Status);
425 return SHELL_ABORTED;
426 }
427
428 Status = ShellCommandLineParse (ParamList, &ParamPackage, NULL, TRUE);
429 if (!EFI_ERROR (Status)) {
430 switch (ShellCommandLineGetCount (ParamPackage)) {
431 case 1:
432 //
433 // Case "setfdt -i"
434 //
435 if (!ShellCommandLineGetFlag (ParamPackage, L"-i")) {
436 Status = EFI_INVALID_PARAMETER;
437 }
438 break;
439
440 case 2:
441 //
442 // Case "setfdt file_path" or
443 // "setfdt -i file_path" or
444 // "setfdt file_path -i"
445 //
446 FilePath = TRUE;
447 break;
448
449 default:
450 Status = EFI_INVALID_PARAMETER;
451 }
452 }
453 if (EFI_ERROR (Status)) {
454 ShellStatus = EfiCodeToShellCode (Status);
455 ShellPrintHiiEx (
456 -1, -1, NULL,
457 STRING_TOKEN (STR_SETFDT_ERROR),
458 mFdtPlatformDxeHiiHandle,
459 Status
460 );
461 goto Error;
462 }
463
464 //
465 // Update the preferred device path for the FDT if asked for.
466 //
467 if (FilePath) {
468 ValueStr = ShellCommandLineGetRawValue (ParamPackage, 1);
469 ShellPrintHiiEx (
470 -1, -1, NULL,
471 STRING_TOKEN (STR_SETFDT_UPDATING),
472 mFdtPlatformDxeHiiHandle
473 );
474 ShellStatus = UpdateFdtTextDevicePath (Shell, ValueStr);
475 if (ShellStatus != SHELL_SUCCESS) {
476 goto Error;
477 }
478 }
479
480 //
481 // Run the FDT installation process if asked for.
482 //
483 if (ShellCommandLineGetFlag (ParamPackage, L"-i")) {
484 ShellPrintHiiEx (
485 -1, -1, NULL,
486 STRING_TOKEN (STR_SETFDT_INSTALLING),
487 mFdtPlatformDxeHiiHandle
488 );
489 Status = RunFdtInstallation ();
490 ShellStatus = EfiCodeToShellCode (Status);
491 if (!EFI_ERROR (Status)) {
492 ShellPrintHiiEx (
493 -1, -1, NULL,
494 STRING_TOKEN (STR_SETFDT_INSTALL_SUCCEEDED),
495 mFdtPlatformDxeHiiHandle
496 );
497 } else {
498 if (Status == EFI_INVALID_PARAMETER) {
499 ShellPrintHiiEx (
500 -1, -1, NULL,
501 STRING_TOKEN (STR_SETFDT_INVALID_DEVICE_PATH),
502 mFdtPlatformDxeHiiHandle
503 );
504 } else {
505 ShellPrintHiiEx (
506 -1, -1, NULL,
507 STRING_TOKEN (STR_SETFDT_ERROR),
508 mFdtPlatformDxeHiiHandle,
509 Status
510 );
511 }
512 }
513 }
514
515 Error:
516
517 gBS->UninstallMultipleProtocolInterfaces (
518 gImageHandle,
519 &gEfiShellProtocolGuid, Shell,
520 &gEfiShellParametersProtocolGuid, ShellParameters,
521 NULL
522 );
523 ShellCommandLineFreeVarList (ParamPackage);
524
525 return ShellStatus;
526 }
527
528 /**
529 This is the shell command "setfdt" help handler function. This
530 function returns the formatted help for the "setfdt" command.
531 The format matchs that in Appendix B of the revision 2.1 of the
532 UEFI Shell Specification.
533
534 @param[in] This The instance of the EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL.
535 @param[in] Language The pointer to the language string to use.
536
537 @return CHAR16* Pool allocated help string, must be freed by caller.
538 **/
539 STATIC
540 CHAR16*
541 EFIAPI
542 ShellDynCmdSetFdtGetHelp (
543 IN EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL *This,
544 IN CONST CHAR8 *Language
545 )
546 {
547 //
548 // This allocates memory. The caller has to free the allocated memory.
549 //
550 return HiiGetString (
551 mFdtPlatformDxeHiiHandle,
552 STRING_TOKEN (STR_GET_HELP_SETFDT),
553 Language
554 );
555 }
556
557 /**
558 Update the text device path stored in the "Fdt" UEFI variable given
559 an EFI Shell file path or a text device path.
560
561 This function is a subroutine of the ShellDynCmdSetFdtHandler() function
562 to make its code easier to read.
563
564 @param[in] Shell The instance of the shell protocol used in the
565 context of processing the "setfdt" command.
566 @param[in] FilePath EFI Shell path or the device path to the FDT file.
567
568 @return SHELL_SUCCESS The text device path was succesfully updated.
569 @return SHELL_INVALID_PARAMETER The Shell file path is not valid.
570 @return SHELL_OUT_OF_RESOURCES A memory allocation failed.
571 @return SHELL_DEVICE_ERROR The "Fdt" variable could not be saved due to a hardware failure.
572 @return SHELL_ACCESS_DENIED The "Fdt" variable is read-only.
573 @return SHELL_ACCESS_DENIED The "Fdt" variable cannot be deleted.
574 @return SHELL_ACCESS_DENIED The "Fdt" variable could not be written due to security violation.
575 @return SHELL_NOT_FOUND Device path to text protocol not found.
576 @return SHELL_ABORTED Operation aborted.
577
578 **/
579 STATIC
580 SHELL_STATUS
581 UpdateFdtTextDevicePath (
582 IN EFI_SHELL_PROTOCOL *Shell,
583 IN CONST CHAR16 *FilePath
584 )
585 {
586 EFI_STATUS Status;
587 EFI_DEVICE_PATH *DevicePath;
588 EFI_DEVICE_PATH_TO_TEXT_PROTOCOL *EfiDevicePathToTextProtocol;
589 CHAR16 *TextDevicePath;
590 CHAR16 *FdtVariableValue;
591 EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL *EfiDevicePathFromTextProtocol;
592 SHELL_STATUS ShellStatus;
593
594 ASSERT (FilePath != NULL);
595 TextDevicePath = NULL;
596 FdtVariableValue = NULL;
597
598 DevicePath = Shell->GetDevicePathFromFilePath (FilePath);
599 if (DevicePath != NULL) {
600 Status = gBS->LocateProtocol (
601 &gEfiDevicePathToTextProtocolGuid,
602 NULL,
603 (VOID **)&EfiDevicePathToTextProtocol
604 );
605 if (EFI_ERROR (Status)) {
606 goto Error;
607 }
608
609 TextDevicePath = EfiDevicePathToTextProtocol->ConvertDevicePathToText (
610 DevicePath,
611 FALSE,
612 FALSE
613 );
614 if (TextDevicePath == NULL) {
615 Status = EFI_OUT_OF_RESOURCES;
616 goto Error;
617 }
618 FdtVariableValue = TextDevicePath;
619 } else {
620 //
621 // Try to convert back the EFI Device Path String into a EFI device Path
622 // to ensure the format is valid
623 //
624 Status = gBS->LocateProtocol (
625 &gEfiDevicePathFromTextProtocolGuid,
626 NULL,
627 (VOID **)&EfiDevicePathFromTextProtocol
628 );
629 if (EFI_ERROR (Status)) {
630 goto Error;
631 }
632
633 DevicePath = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath (
634 FilePath
635 );
636 if (DevicePath == NULL) {
637 Status = EFI_INVALID_PARAMETER;
638 goto Error;
639 }
640 FdtVariableValue = (CHAR16*)FilePath;
641 }
642
643 Status = gRT->SetVariable (
644 (CHAR16*)L"Fdt",
645 &gFdtVariableGuid,
646 EFI_VARIABLE_RUNTIME_ACCESS |
647 EFI_VARIABLE_NON_VOLATILE |
648 EFI_VARIABLE_BOOTSERVICE_ACCESS ,
649 StrSize (FdtVariableValue),
650 FdtVariableValue
651 );
652
653 Error:
654 ShellStatus = EfiCodeToShellCode (Status);
655 if (!EFI_ERROR (Status)) {
656 ShellPrintHiiEx (
657 -1, -1, NULL,
658 STRING_TOKEN (STR_SETFDT_UPDATE_SUCCEEDED),
659 mFdtPlatformDxeHiiHandle,
660 FdtVariableValue
661 );
662 } else {
663 if (Status == EFI_INVALID_PARAMETER) {
664 ShellPrintHiiEx (
665 -1, -1, NULL,
666 STRING_TOKEN (STR_SETFDT_INVALID_PATH),
667 mFdtPlatformDxeHiiHandle,
668 FilePath
669 );
670 } else {
671 ShellPrintHiiEx (
672 -1, -1, NULL,
673 STRING_TOKEN (STR_SETFDT_ERROR),
674 mFdtPlatformDxeHiiHandle,
675 Status
676 );
677 }
678 }
679
680 if (DevicePath != NULL) {
681 FreePool (DevicePath);
682 }
683 if (TextDevicePath != NULL) {
684 FreePool (TextDevicePath);
685 }
686
687 return ShellStatus;
688 }
689
690 /**
691 Transcode one of the EFI return code used by the model into an EFI Shell return code.
692
693 @param[in] Status EFI return code.
694
695 @return Transcoded EFI Shell return code.
696
697 **/
698 STATIC
699 SHELL_STATUS
700 EfiCodeToShellCode (
701 IN EFI_STATUS Status
702 )
703 {
704 SHELL_STATUS ShellStatus;
705
706 switch (Status) {
707 case EFI_SUCCESS :
708 ShellStatus = SHELL_SUCCESS;
709 break;
710
711 case EFI_INVALID_PARAMETER :
712 ShellStatus = SHELL_INVALID_PARAMETER;
713 break;
714
715 case EFI_UNSUPPORTED :
716 ShellStatus = SHELL_UNSUPPORTED;
717 break;
718
719 case EFI_DEVICE_ERROR :
720 ShellStatus = SHELL_DEVICE_ERROR;
721 break;
722
723 case EFI_WRITE_PROTECTED :
724 case EFI_SECURITY_VIOLATION :
725 ShellStatus = SHELL_ACCESS_DENIED;
726 break;
727
728 case EFI_OUT_OF_RESOURCES :
729 ShellStatus = SHELL_OUT_OF_RESOURCES;
730 break;
731
732 case EFI_NOT_FOUND :
733 ShellStatus = SHELL_NOT_FOUND;
734 break;
735
736 default :
737 ShellStatus = SHELL_ABORTED;
738 }
739
740 return ShellStatus;
741 }
742 >>>>>>> 4ac4fed... EmbeddedPkg/FdtPlatformDxe: Fix typo issue