ArmPlatformPkg: remove ArmPlatformSysConfigLib library class

[mirror_edk2.git] / ArmPlatformPkg / Library / ArmShellCmdRunAxf / RunAxf.c

/** @file\r
*\r
*  Shell command for launching AXF files.\r
*\r
*  Copyright (c) 2014, ARM Limited. All rights reserved.\r
*\r
*  This program and the accompanying materials\r
*  are licensed and made available under the terms and conditions of the BSD License\r
*  which accompanies this distribution.  The full text of the license may be found at\r
*  http://opensource.org/licenses/bsd-license.php\r
*\r
*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
*\r
**/\r
\r
#include <Guid/GlobalVariable.h>\r
\r
#include <Library/PrintLib.h>\r
#include <Library/HandleParsingLib.h>\r
#include <Library/DevicePathLib.h>\r
#include <Library/BaseLib.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/DebugLib.h>\r
\r
#include <Library/ArmLib.h>\r
\r
#include "ArmShellCmdRunAxf.h"\r
#include "ElfLoader.h"\r
#include "BootMonFsLoader.h"\r
\r
// Provide arguments to AXF?\r
typedef VOID (*ELF_ENTRYPOINT)(UINTN arg0, UINTN arg1,\r
                               UINTN arg2, UINTN arg3);\r
\r
STATIC\r
EFI_STATUS\r
ShutdownUefiBootServices (\r
  VOID\r
  )\r
{\r
  EFI_STATUS              Status;\r
  UINTN                   MemoryMapSize;\r
  EFI_MEMORY_DESCRIPTOR   *MemoryMap;\r
  UINTN                   MapKey;\r
  UINTN                   DescriptorSize;\r
  UINT32                  DescriptorVersion;\r
  UINTN                   Pages;\r
\r
  MemoryMap = NULL;\r
  MemoryMapSize = 0;\r
  Pages = 0;\r
\r
  do {\r
    Status = gBS->GetMemoryMap (\r
                    &MemoryMapSize,\r
                    MemoryMap,\r
                    &MapKey,\r
                    &DescriptorSize,\r
                    &DescriptorVersion\r
                    );\r
    if (Status == EFI_BUFFER_TOO_SMALL) {\r
\r
      Pages = EFI_SIZE_TO_PAGES (MemoryMapSize) + 1;\r
      MemoryMap = AllocatePages (Pages);\r
\r
      //\r
      // Get System MemoryMap\r
      //\r
      Status = gBS->GetMemoryMap (\r
                      &MemoryMapSize,\r
                      MemoryMap,\r
                      &MapKey,\r
                      &DescriptorSize,\r
                      &DescriptorVersion\r
                      );\r
    }\r
\r
    // Don't do anything between the GetMemoryMap() and ExitBootServices()\r
    if (!EFI_ERROR(Status)) {\r
      Status = gBS->ExitBootServices (gImageHandle, MapKey);\r
      if (EFI_ERROR(Status)) {\r
        FreePages (MemoryMap, Pages);\r
        MemoryMap = NULL;\r
        MemoryMapSize = 0;\r
      }\r
    }\r
  } while (EFI_ERROR(Status));\r
\r
  return Status;\r
}\r
\r
\r
STATIC\r
EFI_STATUS\r
PreparePlatformHardware (\r
  VOID\r
  )\r
{\r
  //Note: Interrupts will be disabled by the GIC driver when ExitBootServices() will be called.\r
\r
  // Clean before Disable else the Stack gets corrupted with old data.\r
  ArmCleanDataCache ();\r
  ArmDisableDataCache ();\r
  // Invalidate all the entries that might have snuck in.\r
  ArmInvalidateDataCache ();\r
\r
  // Disable and invalidate the instruction cache\r
  ArmDisableInstructionCache ();\r
  ArmInvalidateInstructionCache ();\r
\r
  // Turn off MMU\r
  ArmDisableMmu();\r
\r
  return EFI_SUCCESS;\r
}\r
\r
// Process arguments to pass to AXF?\r
STATIC CONST SHELL_PARAM_ITEM ParamList[] = {\r
  {NULL, TypeMax}\r
};\r
\r
\r
/**\r
  This is the shell command handler function pointer callback type. This\r
  function handles the command when it is invoked in the shell.\r
\r
  @param[in] This             The instance of the\r
                              EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL.\r
  @param[in] SystemTable      The pointer to the system table.\r
  @param[in] ShellParameters  The parameters associated with the command.\r
  @param[in] Shell            The instance of the shell protocol used in the\r
                              context of processing this command.\r
\r
  @return EFI_SUCCESS         The operation was successful.\r
  @return other               The operation failed.\r
**/\r
SHELL_STATUS\r
EFIAPI\r
ShellDynCmdRunAxfHandler (\r
  IN EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL    *This,\r
  IN EFI_SYSTEM_TABLE                      *SystemTable,\r
  IN EFI_SHELL_PARAMETERS_PROTOCOL         *ShellParameters,\r
  IN EFI_SHELL_PROTOCOL                    *Shell\r
  )\r
{\r
  LIST_ENTRY        *ParamPackage;\r
  EFI_STATUS         Status;\r
  SHELL_STATUS       ShellStatus;\r
  SHELL_FILE_HANDLE  FileHandle;\r
  ELF_ENTRYPOINT     StartElf;\r
  CONST CHAR16      *FileName;\r
  EFI_FILE_INFO     *Info;\r
  UINTN              FileSize;\r
  VOID              *FileData;\r
  VOID              *Entrypoint;\r
  LIST_ENTRY         LoadList;\r
  LIST_ENTRY        *Node;\r
  LIST_ENTRY        *NextNode;\r
  RUNAXF_LOAD_LIST  *LoadNode;\r
  CHAR16            *TmpFileName;\r
  CHAR16            *TmpChar16;\r
\r
\r
  ShellStatus = SHELL_SUCCESS;\r
  FileHandle = NULL;\r
  FileData = NULL;\r
  InitializeListHead (&LoadList);\r
\r
  // Only install if they are not there yet? First time or every time?\r
  // These can change if the shell exits and start again.\r
  Status = gBS->InstallMultipleProtocolInterfaces (&gImageHandle,\r
                &gEfiShellProtocolGuid, Shell,\r
                &gEfiShellParametersProtocolGuid, ShellParameters,\r
                NULL);\r
\r
  if (EFI_ERROR (Status)) {\r
    return SHELL_DEVICE_ERROR;\r
  }\r
\r
  // Update the protocols for the application library\r
  Status = ShellInitialize ();\r
  ASSERT_EFI_ERROR (Status);\r
  // Add support to load AXF with optipnal args?\r
\r
  //\r
  // Process Command Line arguments\r
  //\r
  Status = ShellCommandLineParse (ParamList, &ParamPackage, NULL, TRUE);\r
  if (EFI_ERROR (Status)) {\r
    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_INVALID_ARG), gRunAxfHiiHandle);\r
    ShellStatus = SHELL_INVALID_PARAMETER;\r
  } else {\r
    //\r
    // Check for "-?"\r
    //\r
    if ((ShellCommandLineGetFlag (ParamPackage, L"-?")) ||\r
        (ShellCommandLineGetRawValue (ParamPackage, 1) == NULL)) {\r
      //\r
      // We didn't get a file to load\r
      //\r
      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_INVALID_ARG), gRunAxfHiiHandle);\r
      ShellStatus = SHELL_INVALID_PARAMETER;\r
    } else {\r
      // For the moment we assume we only ever get one file to load with no arguments.\r
      FileName = ShellCommandLineGetRawValue (ParamPackage, 1);\r
      Status = ShellOpenFileByName (FileName, &FileHandle, EFI_FILE_MODE_READ, 0);\r
      if (EFI_ERROR (Status)) {\r
        // BootMonFS supports file extensions, but they are stripped by default\r
        // when the NOR is programmed.\r
        // Remove the file extension and try to open again.\r
        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_FILE_NOT_FOUND),\r
                         gRunAxfHiiHandle, FileName);\r
        // Go through the filename and remove file extension. Preserve the\r
        // original name.\r
        TmpFileName = AllocateCopyPool (StrSize (FileName), (VOID *)FileName);\r
        if (TmpFileName != NULL) {\r
          TmpChar16 = StrStr (TmpFileName, L".");\r
          if (TmpChar16 != NULL) {\r
            *TmpChar16 = '\0';\r
            DEBUG((EFI_D_ERROR, "Trying to open file: %s\n", TmpFileName));\r
            Status = ShellOpenFileByName (TmpFileName, &FileHandle,\r
                                          EFI_FILE_MODE_READ, 0);\r
          }\r
          FreePool (TmpFileName);\r
        }\r
        // Do we now have an open file after trying again?\r
        if (EFI_ERROR (Status)) {\r
          ShellStatus = SHELL_INVALID_PARAMETER;\r
          FileHandle = NULL;\r
        }\r
      }\r
\r
      if (FileHandle != NULL) {\r
        Info = ShellGetFileInfo (FileHandle);\r
        FileSize = (UINTN) Info->FileSize;\r
        FreePool (Info);\r
\r
        //\r
        // Allocate buffer to read file. 'Runtime' so we can access it after\r
        // ExitBootServices().\r
        //\r
        FileData = AllocateRuntimeZeroPool (FileSize);\r
        if (FileData == NULL) {\r
          ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_NO_MEM), gRunAxfHiiHandle);\r
          ShellStatus = SHELL_OUT_OF_RESOURCES;\r
        } else {\r
          //\r
          // Read file into Buffer\r
          //\r
          Status = ShellReadFile (FileHandle, &FileSize, FileData);\r
          if (EFI_ERROR (Status)) {\r
            ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_READ_FAIL), gRunAxfHiiHandle);\r
            SHELL_FREE_NON_NULL (FileData);\r
            FileData = NULL;\r
            ShellStatus = SHELL_DEVICE_ERROR;\r
          }\r
        }\r
      }\r
    }\r
\r
    //\r
    // Free the command line package\r
    //\r
    ShellCommandLineFreeVarList (ParamPackage);\r
  }\r
\r
  // We have a file in memory. Try to work out if we can use it.\r
  // It can either be in ELF format or BootMonFS format.\r
  if (FileData != NULL) {\r
    // Do some validation on the file before we try to load it. The file can\r
    // either be an proper ELF file or one processed by the FlashLoader.\r
    // Since the data might need to go to various locations in memory we cannot\r
    // load the data directly while UEFI is running. We use the file loaders to\r
    // populate a linked list of data and load addresses. This is processed and\r
    // data copied to where it needs to go after calling ExitBootServices. At\r
    // that stage we've reached the point of no return, so overwriting UEFI code\r
    // does not make a difference.\r
    Status = ElfCheckFile (FileData);\r
    if (!EFI_ERROR (Status)) {\r
      // Load program into memory\r
      Status = ElfLoadFile ((VOID*)FileData, &Entrypoint, &LoadList);\r
    } else {\r
      // Try to see if it is a BootMonFs executable\r
      Status = BootMonFsCheckFile ((EFI_FILE_HANDLE)FileHandle);\r
      if (!EFI_ERROR (Status)) {\r
        // Load program into memory\r
        Status = BootMonFsLoadFile ((EFI_FILE_HANDLE)FileHandle,\r
                                    (VOID*)FileData, &Entrypoint, &LoadList);\r
      } else {\r
        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_BAD_FILE),\r
                         gRunAxfHiiHandle);\r
        SHELL_FREE_NON_NULL (FileData);\r
        ShellStatus = SHELL_UNSUPPORTED;\r
      }\r
    }\r
  }\r
\r
  // Program load list created.\r
  // Shutdown UEFI, copy and jump to code.\r
  if (!IsListEmpty (&LoadList) && !EFI_ERROR (Status)) {\r
    // Exit boot services here. This means we cannot return and cannot assume to\r
    // have access to UEFI functions.\r
    Status = ShutdownUefiBootServices ();\r
    if (EFI_ERROR (Status)) {\r
      DEBUG ((EFI_D_ERROR,"Can not shutdown UEFI boot services. Status=0x%X\n",\r
              Status));\r
    } else {\r
      // Process linked list. Copy data to Memory.\r
      Node = GetFirstNode (&LoadList);\r
      while (!IsNull (&LoadList, Node)) {\r
        LoadNode = (RUNAXF_LOAD_LIST *)Node;\r
        // Do we have data to copy or do we need to set Zeroes (.bss)?\r
        if (LoadNode->Zeroes) {\r
          ZeroMem ((VOID*)LoadNode->MemOffset, LoadNode->Length);\r
        } else {\r
          CopyMem ((VOID *)LoadNode->MemOffset, (VOID *)LoadNode->FileOffset,\r
                   LoadNode->Length);\r
        }\r
        Node = GetNextNode (&LoadList, Node);\r
      }\r
\r
      //\r
      // Switch off interrupts, caches, mmu, etc\r
      //\r
      Status = PreparePlatformHardware ();\r
      ASSERT_EFI_ERROR (Status);\r
\r
      StartElf = (ELF_ENTRYPOINT)Entrypoint;\r
      StartElf (0,0,0,0);\r
\r
      // We should never get here.. But if we do, spin..\r
      ASSERT (FALSE);\r
      while (1);\r
    }\r
  }\r
\r
  // Free file related information as we are returning to UEFI.\r
  Node = GetFirstNode (&LoadList);\r
  while (!IsNull (&LoadList, Node)) {\r
    NextNode = RemoveEntryList (Node);\r
    FreePool (Node);\r
    Node = NextNode;\r
  }\r
  SHELL_FREE_NON_NULL (FileData);\r
  if (FileHandle != NULL) {\r
    ShellCloseFile (&FileHandle);\r
  }\r
\r
  // Uninstall protocols as we don't know if they will change.\r
  // If the shell exits and come in again these mappings may be different\r
  // and cause a crash.\r
  Status = gBS->UninstallMultipleProtocolInterfaces (gImageHandle,\r
                &gEfiShellProtocolGuid, Shell,\r
                &gEfiShellParametersProtocolGuid, ShellParameters,\r
                NULL);\r
\r
  if (EFI_ERROR (Status) && ShellStatus == SHELL_SUCCESS) {\r
    ShellStatus = SHELL_DEVICE_ERROR;\r
  }\r
\r
  return ShellStatus;\r
}\r
\r
\r
/**\r
  This is the command help handler function pointer callback type. This\r
  function is responsible for displaying help information for the associated\r
  command.\r
\r
  @param[in] This             The instance of the\r
                              EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL.\r
  @param[in] Language         The pointer to the language string to use.\r
\r
  @return string              Pool allocated help string, must be freed by\r
                              caller.\r
**/\r
CHAR16*\r
EFIAPI\r
ShellDynCmdRunAxfGetHelp (\r
  IN EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL    *This,\r
  IN CONST CHAR8                           *Language\r
  )\r
{\r
  CHAR16 *HelpText;\r
\r
  ASSERT (gRunAxfHiiHandle != NULL);\r
\r
  // This allocates memory. The caller is responsoible to free.\r
  HelpText = HiiGetString (gRunAxfHiiHandle, STRING_TOKEN (STR_GET_HELP_RUNAXF),\r
                           Language);\r
\r
  return HelpText;\r
}\r