EFI_STATUS ArmFastbootPlatformGetVar ( IN CHAR8 *Name, OUT CHAR8 *Value ) { if (AsciiStrCmp (Name, "product")) { AsciiStrCpy (Value, FixedPcdGetPtr (PcdFirmwareVendor)); } else { *Value = '\0'; } return EFI_SUCCESS; }
/* Initialise: Open the Android NVM device and find the partitions on it. Save them in a list along with the "PartitionName" fields for their GPT entries. We will use these partition names as the key in ArmFastbootPlatformFlashPartition. */ EFI_STATUS ArmFastbootPlatformInit ( VOID ) { EFI_STATUS Status; EFI_DEVICE_PATH_PROTOCOL *FlashDevicePath; EFI_DEVICE_PATH_PROTOCOL *FlashDevicePathDup; EFI_DEVICE_PATH_PROTOCOL *DevicePath; EFI_DEVICE_PATH_PROTOCOL *NextNode; HARDDRIVE_DEVICE_PATH *PartitionNode; UINTN NumHandles; EFI_HANDLE *AllHandles; UINTN LoopIndex; EFI_HANDLE FlashHandle; EFI_BLOCK_IO_PROTOCOL *FlashBlockIo; EFI_PARTITION_ENTRY *PartitionEntries; FASTBOOT_PARTITION_LIST *Entry; InitializeListHead (&mPartitionListHead); // // Get EFI_HANDLES for all the partitions on the block devices pointed to by // PcdFastbootFlashDevicePath, also saving their GPT partition labels. // There's no way to find all of a device's children, so we get every handle // in the system supporting EFI_BLOCK_IO_PROTOCOL and then filter out ones // that don't represent partitions on the flash device. // FlashDevicePath = ConvertTextToDevicePath ((CHAR16*)FixedPcdGetPtr (PcdAndroidFastbootNvmDevicePath)); // // Open the Disk IO protocol on the flash device - this will be used to read // partition names out of the GPT entries // // Create another device path pointer because LocateDevicePath will modify it. FlashDevicePathDup = FlashDevicePath; Status = gBS->LocateDevicePath (&gEfiBlockIoProtocolGuid, &FlashDevicePathDup, &FlashHandle); if (EFI_ERROR (Status)) { DEBUG ((EFI_D_ERROR, "Warning: Couldn't locate Android NVM device (status: %r)\n", Status)); // Failing to locate partitions should not prevent to do other Android FastBoot actions return EFI_SUCCESS; } Status = gBS->OpenProtocol ( FlashHandle, &gEfiBlockIoProtocolGuid, (VOID **) &FlashBlockIo, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL ); if (EFI_ERROR (Status)) { DEBUG ((EFI_D_ERROR, "Fastboot platform: Couldn't open Android NVM device (status: %r)\n", Status)); return EFI_DEVICE_ERROR; } // Read the GPT partition entry array into memory so we can get the partition names Status = ReadPartitionEntries (FlashBlockIo, &PartitionEntries); if (EFI_ERROR (Status)) { DEBUG ((EFI_D_ERROR, "Warning: Failed to read partitions from Android NVM device (status: %r)\n", Status)); // Failing to locate partitions should not prevent to do other Android FastBoot actions return EFI_SUCCESS; } // Get every Block IO protocol instance installed in the system Status = gBS->LocateHandleBuffer ( ByProtocol, &gEfiBlockIoProtocolGuid, NULL, &NumHandles, &AllHandles ); ASSERT_EFI_ERROR (Status); // Filter out handles that aren't children of the flash device for (LoopIndex = 0; LoopIndex < NumHandles; LoopIndex++) { // Get the device path for the handle Status = gBS->OpenProtocol ( AllHandles[LoopIndex], &gEfiDevicePathProtocolGuid, (VOID **) &DevicePath, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL ); ASSERT_EFI_ERROR (Status); // Check if it is a sub-device of the flash device if (!CompareMem (DevicePath, FlashDevicePath, FLASH_DEVICE_PATH_SIZE (FlashDevicePath))) { // Device path starts with path of flash device. Check it isn't the flash // device itself. NextNode = NextDevicePathNode (DevicePath); if (IsDevicePathEndType (NextNode)) { continue; } // Assert that this device path node represents a partition. ASSERT (NextNode->Type == MEDIA_DEVICE_PATH && NextNode->SubType == MEDIA_HARDDRIVE_DP); PartitionNode = (HARDDRIVE_DEVICE_PATH *) NextNode; // Assert that the partition type is GPT. ReadPartitionEntries checks for // presence of a GPT, so we should never find MBR partitions. // ("MBRType" is a misnomer - this field is actually called "Partition // Format") ASSERT (PartitionNode->MBRType == MBR_TYPE_EFI_PARTITION_TABLE_HEADER); // The firmware may install a handle for "partition 0", representing the // whole device. Ignore it. if (PartitionNode->PartitionNumber == 0) { continue; } // // Add the partition handle to the list // // Create entry Entry = AllocatePool (sizeof (FASTBOOT_PARTITION_LIST)); if (Entry == NULL) { Status = EFI_OUT_OF_RESOURCES; FreePartitionList (); goto Exit; } // Copy handle and partition name Entry->PartitionHandle = AllHandles[LoopIndex]; StrnCpy ( Entry->PartitionName, PartitionEntries[PartitionNode->PartitionNumber - 1].PartitionName, // Partition numbers start from 1. PARTITION_NAME_MAX_LENGTH ); InsertTailList (&mPartitionListHead, &Entry->Link); // Print a debug message if the partition label is empty or looks like // garbage. if (!IS_ALPHA (Entry->PartitionName[0])) { DEBUG ((EFI_D_ERROR, "Warning: Partition %d doesn't seem to have a GPT partition label. " "You won't be able to flash it with Fastboot.\n", PartitionNode->PartitionNumber )); } } } Exit: FreePool (PartitionEntries); FreePool (FlashDevicePath); FreePool (AllHandles); return Status; }
/** This function uses policy data from the platform to determine what operating system or system utility should be loaded and invoked. This function call also optionally make the use of user input to determine the operating system or system utility to be loaded and invoked. When the DXE Core has dispatched all the drivers on the dispatch queue, this function is called. This function will attempt to connect the boot devices required to load and invoke the selected operating system or system utility. During this process, additional firmware volumes may be discovered that may contain addition DXE drivers that can be dispatched by the DXE Core. If a boot device cannot be fully connected, this function calls the DXE Service Dispatch() to allow the DXE drivers from any newly discovered firmware volumes to be dispatched. Then the boot device connection can be attempted again. If the same boot device connection operation fails twice in a row, then that boot device has failed, and should be skipped. This function should never return. @param This The EFI_BDS_ARCH_PROTOCOL instance. @return None. **/ VOID EFIAPI BdsEntry ( IN EFI_BDS_ARCH_PROTOCOL *This ) { UINTN Size; EFI_STATUS Status; UINT16 *BootNext; UINTN BootNextSize; CHAR16 BootVariableName[9]; EFI_EVENT EndOfDxeEvent; // // Signal EndOfDxe PI Event // Status = gBS->CreateEventEx ( EVT_NOTIFY_SIGNAL, TPL_NOTIFY, EmptyCallbackFunction, NULL, &gEfiEndOfDxeEventGroupGuid, &EndOfDxeEvent ); if (!EFI_ERROR (Status)) { gBS->SignalEvent (EndOfDxeEvent); } PERF_END (NULL, "DXE", NULL, 0); // // Declare the Firmware Vendor // if (FixedPcdGetPtr(PcdFirmwareVendor) != NULL) { Size = 0x100; gST->FirmwareVendor = AllocateRuntimePool (Size); ASSERT (gST->FirmwareVendor != NULL); UnicodeSPrint (gST->FirmwareVendor, Size, L"%a EFI %a %a", PcdGetPtr(PcdFirmwareVendor), __DATE__, __TIME__); } // // Fixup Table CRC after we updated Firmware Vendor // gST->Hdr.CRC32 = 0; Status = gBS->CalculateCrc32 ((VOID*)gST, gST->Hdr.HeaderSize, &gST->Hdr.CRC32); ASSERT_EFI_ERROR (Status); // If BootNext environment variable is defined then we just load it ! BootNextSize = sizeof(UINT16); Status = GetGlobalEnvironmentVariable (L"BootNext", NULL, &BootNextSize, (VOID**)&BootNext); if (!EFI_ERROR(Status)) { ASSERT(BootNextSize == sizeof(UINT16)); // Generate the requested Boot Entry variable name UnicodeSPrint (BootVariableName, 9 * sizeof(CHAR16), L"Boot%04X", *BootNext); // Set BootCurrent variable gRT->SetVariable (L"BootCurrent", &gEfiGlobalVariableGuid, EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS, BootNextSize, BootNext); FreePool (BootNext); // Start the requested Boot Entry Status = BdsStartBootOption (BootVariableName); if (Status != EFI_NOT_FOUND) { // BootNext has not been succeeded launched if (EFI_ERROR(Status)) { Print(L"Fail to start BootNext.\n"); } // Delete the BootNext environment variable gRT->SetVariable (L"BootNext", &gEfiGlobalVariableGuid, EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS, 0, NULL); } // Clear BootCurrent variable gRT->SetVariable (L"BootCurrent", &gEfiGlobalVariableGuid, EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS, 0, NULL); } // If Boot Order does not exist then create a default entry DefineDefaultBootEntries (); // Now we need to setup the EFI System Table with information about the console devices. InitializeConsole (); // // Update the CRC32 in the EFI System Table header // gST->Hdr.CRC32 = 0; Status = gBS->CalculateCrc32 ((VOID*)gST, gST->Hdr.HeaderSize, &gST->Hdr.CRC32); ASSERT_EFI_ERROR (Status); // Timer before initiating the default boot selection StartDefaultBootOnTimeout (); // Start the Boot Menu Status = BootMenuMain (); ASSERT_EFI_ERROR (Status); }
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. **/ #include "ArmVExpressInternal.h" #include <Library/ArmGicLib.h> // // Description of the AARCH64 model platforms : // Platform ids are defined in ArmVExpressInternal.h for // all "ArmVExpress-like" platforms (AARCH64 or ARM architecture, // model or hardware platforms). // CONST ARM_VEXPRESS_PLATFORM ArmVExpressPlatforms[] = { { ARM_FVP_VEXPRESS_AEMv8x4, FixedPcdGetPtr (PcdFdtFvpVExpressAEMv8x4), L"rtsm_ve-aemv8a.dtb" }, { ARM_FVP_BASE_AEMv8x4_AEMv8x4_GICV2, FixedPcdGetPtr (PcdFdtFvpBaseAEMv8x4GicV2), L"fvp-base-gicv2-psci.dtb" }, { ARM_FVP_BASE_AEMv8x4_AEMv8x4_GICV2_LEGACY, FixedPcdGetPtr (PcdFdtFvpBaseAEMv8x4GicV2Legacy), L"fvp-base-gicv2legacy-psci.dtb" }, { ARM_FVP_BASE_AEMv8x4_AEMv8x4_GICV3, FixedPcdGetPtr (PcdFdtFvpBaseAEMv8x4GicV3), L"fvp-base-gicv3-psci.dtb" }, { ARM_FVP_FOUNDATION_GICV2, FixedPcdGetPtr (PcdFdtFvpFoundationGicV2), L"fvp-foundation-gicv2-psci.dtb" }, { ARM_FVP_FOUNDATION_GICV2_LEGACY, FixedPcdGetPtr (PcdFdtFvpFoundationGicV2Legacy), L"fvp-foundation-gicv2legacy-psci.dtb" }, { ARM_FVP_FOUNDATION_GICV3, FixedPcdGetPtr (PcdFdtFvpFoundationGicV3), L"fvp-foundation-gicv3-psci.dtb" }, { ARM_FVP_VEXPRESS_UNKNOWN } }; /** Get information about the VExpress platform the firmware is running on. @param[out] Platform Address where the pointer to the platform information (type ARM_VEXPRESS_PLATFORM*) should be stored. The returned pointer does not point to an allocated
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. **/ #include "ArmVExpressInternal.h" #include <Library/ArmPlatformLib.h> // To get Core Count // // Description of the four ARM model platforms : // Platform ids are defined in ArmVExpressInternal.h for // all "ArmVExpress-like" platforms (AARCH64 or ARM architecture, // model or hardware platforms). // CONST ARM_VEXPRESS_PLATFORM ArmVExpressPlatforms[] = { { ARM_FVP_VEXPRESS_A9x4, FixedPcdGetPtr (PcdFdtVExpressFvpA9x4), L"rtsm_ve-cortex_a9x4.dtb" }, { ARM_FVP_VEXPRESS_A15x1, FixedPcdGetPtr (PcdFdtVExpressFvpA15x1), L"rtsm_ve-cortex_a15x1.dtb" }, { ARM_FVP_VEXPRESS_A15x2, FixedPcdGetPtr (PcdFdtVExpressFvpA15x2), L"rtsm_ve-cortex_a15x2.dtb" }, { ARM_FVP_VEXPRESS_A15x4, FixedPcdGetPtr (PcdFdtVExpressFvpA15x4), L"rtsm_ve-cortex_a15x4.dtb" }, { ARM_FVP_VEXPRESS_UNKNOWN, } }; /** Get information about the VExpress platform the firmware is running on. @param[out] Platform Address where the pointer to the platform information (type ARM_VEXPRESS_PLATFORM*) should be stored. The returned pointer does not point to an allocated memory area. @retval EFI_SUCCESS The platform information was returned.
/** This function uses policy data from the platform to determine what operating system or system utility should be loaded and invoked. This function call also optionally make the use of user input to determine the operating system or system utility to be loaded and invoked. When the DXE Core has dispatched all the drivers on the dispatch queue, this function is called. This function will attempt to connect the boot devices required to load and invoke the selected operating system or system utility. During this process, additional firmware volumes may be discovered that may contain addition DXE drivers that can be dispatched by the DXE Core. If a boot device cannot be fully connected, this function calls the DXE Service Dispatch() to allow the DXE drivers from any newly discovered firmware volumes to be dispatched. Then the boot device connection can be attempted again. If the same boot device connection operation fails twice in a row, then that boot device has failed, and should be skipped. This function should never return. @param This The EFI_BDS_ARCH_PROTOCOL instance. @return None. **/ VOID EFIAPI BdsEntry ( IN EFI_BDS_ARCH_PROTOCOL *This ) { UINTN Size; EFI_STATUS Status; UINT16 *BootNext; UINTN BootNextSize; CHAR16 BootVariableName[9]; EFI_EVENT EndOfDxeEvent; VOID *NewBase; // // Signal EndOfDxe PI Event // Status = gBS->CreateEventEx ( EVT_NOTIFY_SIGNAL, TPL_NOTIFY, EmptyCallbackFunction, NULL, &gEfiEndOfDxeEventGroupGuid, &EndOfDxeEvent ); if (!EFI_ERROR (Status)) { gBS->SignalEvent (EndOfDxeEvent); } PERF_END (NULL, "DXE", NULL, 0); OemPostEndIndicator(); //?им1??и▓бф?иж?б└бзиви┤и║б└1?б└и╣бд?бу?бъ?ж╠б└ижи║??2G?и▓бф?и║б└бъ??и▓бф?2?1?ио?бъ??ик?ив??HOB?D //memory reserved идидDикимивижy?asystem memory идидDик NewBase = AllocatePages (EFI_SIZE_TO_PAGES(SIZE_2GB)); if (NULL == NewBase) { DEBUG ((EFI_D_ERROR, "There are not enough memory space..........\n")); } else { FreePages(NewBase,EFI_SIZE_TO_PAGES(SIZE_2GB)); } // // Declare the Firmware Vendor // if (FixedPcdGetPtr(PcdFirmwareVendor) != NULL) { Size = 0x100; gST->FirmwareVendor = AllocateRuntimePool (Size); ASSERT (gST->FirmwareVendor != NULL); UnicodeSPrint (gST->FirmwareVendor, Size, L"%a EFI %a %a", PcdGetPtr(PcdFirmwareVendor), __DATE__, __TIME__); } // // Fixup Table CRC after we updated Firmware Vendor // gST->Hdr.CRC32 = 0; Status = gBS->CalculateCrc32 ((VOID*)gST, gST->Hdr.HeaderSize, &gST->Hdr.CRC32); ASSERT_EFI_ERROR (Status); if (EFI_ERROR (Status)) { //for fortify } // If BootNext environment variable is defined then we just load it ! BootNextSize = sizeof(UINT16); Status = GetGlobalEnvironmentVariable (L"BootNext", NULL, &BootNextSize, (VOID**)&BootNext); if (!EFI_ERROR(Status)) { ASSERT(BootNextSize == sizeof(UINT16)); // Generate the requested Boot Entry variable name UnicodeSPrint (BootVariableName, 9 * sizeof(CHAR16), L"Boot%04X", *BootNext); // Set BootCurrent variable gRT->SetVariable (L"BootCurrent", &gEfiGlobalVariableGuid, EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS, BootNextSize, BootNext); FreePool (BootNext); // Start the requested Boot Entry Status = BdsStartBootOption (BootVariableName); if (Status != EFI_NOT_FOUND) { // BootNext has not been succeeded launched if (EFI_ERROR(Status)) { Print(L"Fail to start BootNext.\n"); } // Delete the BootNext environment variable gRT->SetVariable (L"BootNext", &gEfiGlobalVariableGuid, EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS, 0, NULL); } // Clear BootCurrent variable gRT->SetVariable (L"BootCurrent", &gEfiGlobalVariableGuid, EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS, 0, NULL); } // If Boot Order does not exist then create a default entry DefineDefaultBootEntries (); // Now we need to setup the EFI System Table with information about the console devices. InitializeConsole (); // // Update the CRC32 in the EFI System Table header // gST->Hdr.CRC32 = 0; Status = gBS->CalculateCrc32 ((VOID*)gST, gST->Hdr.HeaderSize, &gST->Hdr.CRC32); ASSERT_EFI_ERROR (Status); if (EFI_ERROR (Status)) { //for fortify } // Timer before initiating the default boot selection StartDefaultBootOnTimeout (); Status = VerifyBootLineEntry (); if(EFI_ERROR(Status)) { DEBUG((EFI_D_ERROR,"Input Password Error, Boot failed!\n")); return; } // Start the Boot Menu Status = BootMenuMain (); ASSERT_EFI_ERROR (Status); if (EFI_ERROR (Status)) { //for fortify } }