VirtualBox

Ignore:
Timestamp:
Apr 14, 2023 3:17:44 PM (2 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
156854
Message:

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643

Location:
trunk/src/VBox/Devices/EFI/FirmwareNew
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/EFI/FirmwareNew

  • trunk/src/VBox/Devices/EFI/FirmwareNew/EmbeddedPkg/Application/AndroidBoot/AndroidBootApp.c

    r85718 r99404  
    2121EFI_STATUS
    2222ValidateAndroidMediaDevicePath (
    23   IN EFI_DEVICE_PATH                  *DevicePath
     23  IN EFI_DEVICE_PATH  *DevicePath
    2424  )
    2525{
    26   EFI_DEVICE_PATH_PROTOCOL            *Node, *NextNode;
     26  EFI_DEVICE_PATH_PROTOCOL  *Node, *NextNode;
    2727
    2828  NextNode = DevicePath;
    2929  while (NextNode != NULL) {
    3030    Node = NextNode;
    31     if (Node->Type == MEDIA_DEVICE_PATH &&
    32         Node->SubType == MEDIA_HARDDRIVE_DP) {
     31    if ((Node->Type == MEDIA_DEVICE_PATH) &&
     32        (Node->SubType == MEDIA_HARDDRIVE_DP))
     33    {
    3334      return EFI_SUCCESS;
    3435    }
     36
    3537    NextNode = NextDevicePathNode (Node);
    3638  }
     39
    3740  return EFI_INVALID_PARAMETER;
    3841}
    … …  
    4144EFIAPI
    4245AndroidBootAppEntryPoint (
    43   IN EFI_HANDLE                            ImageHandle,
    44   IN EFI_SYSTEM_TABLE                      *SystemTable
     46  IN EFI_HANDLE        ImageHandle,
     47  IN EFI_SYSTEM_TABLE  *SystemTable
    4548  )
    4649{
    … …  
    5760  BootPathStr = (CHAR16 *)PcdGetPtr (PcdAndroidBootDevicePath);
    5861  ASSERT (BootPathStr != NULL);
    59   Status = gBS->LocateProtocol (&gEfiDevicePathFromTextProtocolGuid, NULL,
    60                                 (VOID **)&EfiDevicePathFromTextProtocol);
    61   ASSERT_EFI_ERROR(Status);
     62  Status = gBS->LocateProtocol (
     63                  &gEfiDevicePathFromTextProtocolGuid,
     64                  NULL,
     65                  (VOID **)&EfiDevicePathFromTextProtocol
     66                  );
     67  ASSERT_EFI_ERROR (Status);
    6268  DevicePath = (EFI_DEVICE_PATH *)EfiDevicePathFromTextProtocol->ConvertTextToDevicePath (BootPathStr);
    6369  ASSERT (DevicePath != NULL);
    … …  
    6874  }
    6975
    70   Status = gBS->LocateDevicePath (&gEfiDevicePathProtocolGuid,
    71                                   &DevicePath, &Handle);
     76  Status = gBS->LocateDevicePath (
     77                  &gEfiDevicePathProtocolGuid,
     78                  &DevicePath,
     79                  &Handle
     80                  );
    7281  if (EFI_ERROR (Status)) {
    7382    return Status;
    … …  
    7786                  Handle,
    7887                  &gEfiBlockIoProtocolGuid,
    79                   (VOID **) &BlockIo,
     88                  (VOID **)&BlockIo,
    8089                  gImageHandle,
    8190                  NULL,
    … …  
    8796  }
    8897
    89   MediaId = BlockIo->Media->MediaId;
     98  MediaId   = BlockIo->Media->MediaId;
    9099  BlockSize = BlockIo->Media->BlockSize;
    91   Buffer = AllocatePages (EFI_SIZE_TO_PAGES (sizeof(ANDROID_BOOTIMG_HEADER)));
     100  Buffer    = AllocatePages (EFI_SIZE_TO_PAGES (sizeof (ANDROID_BOOTIMG_HEADER)));
    92101  if (Buffer == NULL) {
    93102    return EFI_BUFFER_TOO_SMALL;
    94103  }
     104
    95105  /* Load header of boot.img */
    96106  Status = BlockIo->ReadBlocks (
    … …  
    106116    return Status;
    107117  }
     118
    108119  BootImgSize = ALIGN_VALUE (BootImgSize, BlockSize);
    109   FreePages (Buffer, EFI_SIZE_TO_PAGES (sizeof(ANDROID_BOOTIMG_HEADER)));
     120  FreePages (Buffer, EFI_SIZE_TO_PAGES (sizeof (ANDROID_BOOTIMG_HEADER)));
    110121
    111122  /* Both PartitionStart and PartitionSize are counted as block size. */

  • trunk/src/VBox/Devices/EFI/FirmwareNew/EmbeddedPkg/Application/AndroidFastboot/AndroidBootImg.c

    r85718 r99404  
    1717EFI_STATUS
    1818ParseAndroidBootImg (
    19   IN  VOID    *BootImg,
     19  IN  VOID   *BootImg,
    2020  OUT VOID   **Kernel,
    21   OUT UINTN   *KernelSize,
     21  OUT UINTN  *KernelSize,
    2222  OUT VOID   **Ramdisk,
    23   OUT UINTN   *RamdiskSize,
    24   OUT CHAR8   *KernelArgs
     23  OUT UINTN  *RamdiskSize,
     24  OUT CHAR8  *KernelArgs
    2525  )
    2626{
    27   ANDROID_BOOTIMG_HEADER   *Header;
    28   UINT8                    *BootImgBytePtr;
     27  ANDROID_BOOTIMG_HEADER  *Header;
     28  UINT8                   *BootImgBytePtr;
    2929
    3030  // Cast to UINT8 so we can do pointer arithmetic
    31   BootImgBytePtr = (UINT8 *) BootImg;
     31  BootImgBytePtr = (UINT8 *)BootImg;
    3232
    33   Header = (ANDROID_BOOTIMG_HEADER *) BootImg;
     33  Header = (ANDROID_BOOTIMG_HEADER *)BootImg;
    3434
    35   if (AsciiStrnCmp ((CONST CHAR8 *)Header->BootMagic, ANDROID_BOOT_MAGIC,
    36                     ANDROID_BOOT_MAGIC_LENGTH) != 0) {
     35  if (AsciiStrnCmp (
     36        (CONST CHAR8 *)Header->BootMagic,
     37        ANDROID_BOOT_MAGIC,
     38        ANDROID_BOOT_MAGIC_LENGTH
     39        ) != 0)
     40  {
    3741    return EFI_INVALID_PARAMETER;
    3842  }
    … …  
    4448  ASSERT (IS_VALID_ANDROID_PAGE_SIZE (Header->PageSize));
    4549
    46   *KernelSize = Header->KernelSize;
    47   *Kernel = BootImgBytePtr + Header->PageSize;
     50  *KernelSize  = Header->KernelSize;
     51  *Kernel      = BootImgBytePtr + Header->PageSize;
    4852  *RamdiskSize = Header->RamdiskSize;
    4953
    5054  if (Header->RamdiskSize != 0) {
    51     *Ramdisk = (VOID *) (BootImgBytePtr
    52                  + Header->PageSize
    53                  + ALIGN_VALUE (Header->KernelSize, Header->PageSize));
     55    *Ramdisk = (VOID *)(BootImgBytePtr
     56                        + Header->PageSize
     57                        + ALIGN_VALUE (Header->KernelSize, Header->PageSize));
    5458  }
    5559
    56   AsciiStrnCpyS (KernelArgs, ANDROID_BOOTIMG_KERNEL_ARGS_SIZE, Header->KernelArgs,
    57     ANDROID_BOOTIMG_KERNEL_ARGS_SIZE);
     60  AsciiStrnCpyS (
     61    KernelArgs,
     62    ANDROID_BOOTIMG_KERNEL_ARGS_SIZE,
     63    Header->KernelArgs,
     64    ANDROID_BOOTIMG_KERNEL_ARGS_SIZE
     65    );
    5866
    5967  return EFI_SUCCESS;

  • trunk/src/VBox/Devices/EFI/FirmwareNew/EmbeddedPkg/Application/AndroidFastboot/AndroidFastbootApp.c

    r85718 r99404  
    2626 */
    2727
    28 STATIC FASTBOOT_TRANSPORT_PROTOCOL *mTransport;
    29 STATIC FASTBOOT_PLATFORM_PROTOCOL  *mPlatform;
    30 
    31 STATIC EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *mTextOut;
     28STATIC FASTBOOT_TRANSPORT_PROTOCOL  *mTransport;
     29STATIC FASTBOOT_PLATFORM_PROTOCOL   *mPlatform;
     30
     31STATIC EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *mTextOut;
    3232
    3333typedef enum {
    … …  
    3737} ANDROID_FASTBOOT_STATE;
    3838
    39 STATIC ANDROID_FASTBOOT_STATE mState = ExpectCmdState;
     39STATIC ANDROID_FASTBOOT_STATE  mState = ExpectCmdState;
    4040
    4141// When in ExpectDataState, the number of bytes of data to expect:
    42 STATIC UINT64 mNumDataBytes;
     42STATIC UINT64  mNumDataBytes;
    4343// .. and the number of bytes so far received this data phase
    44 STATIC UINT64 mBytesReceivedSoFar;
     44STATIC UINT64  mBytesReceivedSoFar;
    4545// .. and the buffer to save data into
    46 STATIC UINT8 *mDataBuffer = NULL;
     46STATIC UINT8  *mDataBuffer = NULL;
    4747
    4848// Event notify functions, from which gBS->Exit shouldn't be called, can signal
    4949// this event when the application should exit
    50 STATIC EFI_EVENT mFinishedEvent;
    51 
    52 STATIC EFI_EVENT mFatalSendErrorEvent;
     50STATIC EFI_EVENT  mFinishedEvent;
     51
     52STATIC EFI_EVENT  mFatalSendErrorEvent;
    5353
    5454// This macro uses sizeof - only use it on arrays (i.e. string literals)
    55 #define SEND_LITERAL(Str) mTransport->Send (                  \
     55#define SEND_LITERAL(Str)            mTransport->Send (       \
    5656                                        sizeof (Str) - 1,     \
    5757                                        Str,                  \
    5858                                        &mFatalSendErrorEvent \
    5959                                        )
    60 #define MATCH_CMD_LITERAL(Cmd, Buf) !AsciiStrnCmp (Cmd, Buf, sizeof (Cmd) - 1)
    61 
    62 #define IS_LOWERCASE_ASCII(Char) (Char >= 'a' && Char <= 'z')
    63 
    64 #define FASTBOOT_STRING_MAX_LENGTH  256
    65 #define FASTBOOT_COMMAND_MAX_LENGTH 64
     60#define MATCH_CMD_LITERAL(Cmd, Buf)  !AsciiStrnCmp (Cmd, Buf, sizeof (Cmd) - 1)
     61
     62#define IS_LOWERCASE_ASCII(Char)  (Char >= 'a' && Char <= 'z')
     63
     64#define FASTBOOT_STRING_MAX_LENGTH   256
     65#define FASTBOOT_COMMAND_MAX_LENGTH  64
    6666
    6767STATIC
    6868VOID
    6969HandleGetVar (
    70   IN CHAR8 *CmdArg
    71   )
    72 {
    73   CHAR8      Response[FASTBOOT_COMMAND_MAX_LENGTH + 1] = "OKAY";
    74   EFI_STATUS Status;
     70  IN CHAR8  *CmdArg
     71  )
     72{
     73  CHAR8       Response[FASTBOOT_COMMAND_MAX_LENGTH + 1] = "OKAY";
     74  EFI_STATUS  Status;
    7575
    7676  // Respond to getvar:version with 0.4 (version of Fastboot protocol)
    77   if (!AsciiStrnCmp ("version", CmdArg, sizeof ("version") - 1 )) {
     77  if (!AsciiStrnCmp ("version", CmdArg, sizeof ("version") - 1)) {
    7878    SEND_LITERAL ("OKAY" ANDROID_FASTBOOT_VERSION);
    7979  } else {
    … …  
    9191VOID
    9292HandleDownload (
    93   IN CHAR8 *NumBytesString
    94   )
    95 {
    96   CHAR8       Response[13];
    97   CHAR16      OutputString[FASTBOOT_STRING_MAX_LENGTH];
     93  IN CHAR8  *NumBytesString
     94  )
     95{
     96  CHAR8   Response[13];
     97  CHAR16  OutputString[FASTBOOT_STRING_MAX_LENGTH];
    9898
    9999  // Argument is 8-character ASCII string hex representation of number of bytes
    … …  
    123123  } else {
    124124    ZeroMem (Response, sizeof Response);
    125     AsciiSPrint (Response, sizeof Response, "DATA%x",
    126       (UINT32)mNumDataBytes);
     125    AsciiSPrint (
     126      Response,
     127      sizeof Response,
     128      "DATA%x",
     129      (UINT32)mNumDataBytes
     130      );
    127131    mTransport->Send (sizeof Response - 1, Response, &mFatalSendErrorEvent);
    128132
    129     mState = ExpectDataState;
     133    mState              = ExpectDataState;
    130134    mBytesReceivedSoFar = 0;
    131135  }
    … …  
    135139VOID
    136140HandleFlash (
    137   IN CHAR8 *PartitionName
     141  IN CHAR8  *PartitionName
    138142  )
    139143{
    … …  
    162166    SEND_LITERAL ("FAILError flashing partition.");
    163167    mTextOut->OutputString (mTextOut, L"Error flashing partition.\r\n");
    164     DEBUG ((EFI_D_ERROR, "Couldn't flash image:  %r\n", Status));
     168    DEBUG ((DEBUG_ERROR, "Couldn't flash image:  %r\n", Status));
    165169  } else {
    166170    mTextOut->OutputString (mTextOut, L"Done.\r\n");
    … …  
    172176VOID
    173177HandleErase (
    174   IN CHAR8 *PartitionName
     178  IN CHAR8  *PartitionName
    175179  )
    176180{
    … …  
    185189  if (EFI_ERROR (Status)) {
    186190    SEND_LITERAL ("FAILCheck device console.");
    187     DEBUG ((EFI_D_ERROR, "Couldn't erase image:  %r\n", Status));
     191    DEBUG ((DEBUG_ERROR, "Couldn't erase image:  %r\n", Status));
    188192  } else {
    189193    SEND_LITERAL ("OKAY");
    … …  
    197201  )
    198202{
    199   EFI_STATUS Status;
     203  EFI_STATUS  Status;
    200204
    201205  mTextOut->OutputString (mTextOut, L"Booting downloaded image\r\n");
    … …  
    213217  Status = BootAndroidBootImg (mNumDataBytes, mDataBuffer);
    214218  if (EFI_ERROR (Status)) {
    215     DEBUG ((EFI_D_ERROR, "Failed to boot downloaded image: %r\n", Status));
    216   }
     219    DEBUG ((DEBUG_ERROR, "Failed to boot downloaded image: %r\n", Status));
     220  }
     221
    217222  // We shouldn't get here
    218223}
    … …  
    221226VOID
    222227HandleOemCommand (
    223   IN CHAR8 *Command
     228  IN CHAR8  *Command
    224229  )
    225230{
    … …  
    242247AcceptCmd (
    243248  IN        UINTN  Size,
    244   IN  CONST CHAR8 *Data
    245   )
    246 {
    247   CHAR8       Command[FASTBOOT_COMMAND_MAX_LENGTH + 1];
     249  IN  CONST CHAR8  *Data
     250  )
     251{
     252  CHAR8  Command[FASTBOOT_COMMAND_MAX_LENGTH + 1];
    248253
    249254  // Max command size is 64 bytes
    … …  
    283288      SEND_LITERAL ("INFOreboot-bootloader not supported, rebooting normally.");
    284289    }
     290
    285291    SEND_LITERAL ("OKAY");
    286292    gRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
    287293
    288294    // Shouldn't get here
    289     DEBUG ((EFI_D_ERROR, "Fastboot: gRT->ResetSystem didn't work\n"));
     295    DEBUG ((DEBUG_ERROR, "Fastboot: gRT->ResetSystem didn't work\n"));
    290296  } else if (MATCH_CMD_LITERAL ("powerdown", Command)) {
    291297    SEND_LITERAL ("OKAY");
    … …  
    293299
    294300    // Shouldn't get here
    295     DEBUG ((EFI_D_ERROR, "Fastboot: gRT->ResetSystem didn't work\n"));
     301    DEBUG ((DEBUG_ERROR, "Fastboot: gRT->ResetSystem didn't work\n"));
    296302  } else if (MATCH_CMD_LITERAL ("oem", Command)) {
    297303    // The "oem" command isn't in the specification, but it was observed in the
    … …  
    314320AcceptData (
    315321  IN  UINTN  Size,
    316   IN  VOID  *Data
    317   )
    318 {
    319   UINT32 RemainingBytes = mNumDataBytes - mBytesReceivedSoFar;
    320   CHAR16 OutputString[FASTBOOT_STRING_MAX_LENGTH];
    321   STATIC UINTN Count = 0;
     322  IN  VOID   *Data
     323  )
     324{
     325  UINT32        RemainingBytes = mNumDataBytes - mBytesReceivedSoFar;
     326  CHAR16        OutputString[FASTBOOT_STRING_MAX_LENGTH];
     327  STATIC UINTN  Count = 0;
    322328
    323329  // Protocol doesn't say anything about sending extra data so just ignore it.
    … …  
    332338  // Show download progress. Don't do it for every packet  as outputting text
    333339  // might be time consuming - do it on the last packet and on every 32nd packet
    334   if ((Count++ % 32) == 0 || Size == RemainingBytes) {
     340  if (((Count++ % 32) == 0) || (Size == RemainingBytes)) {
    335341    // (Note no newline in format string - it will overwrite the line each time)
    336342    UnicodeSPrint (
    … …  
    364370DataReady (
    365371  IN EFI_EVENT  Event,
    366   IN VOID      *Context
     372  IN VOID       *Context
    367373  )
    368374{
    369375  UINTN       Size;
    370   VOID       *Data;
     376  VOID        *Data;
    371377  EFI_STATUS  Status;
    372378
    … …  
    375381    if (!EFI_ERROR (Status)) {
    376382      if (mState == ExpectCmdState) {
    377         AcceptCmd (Size, (CHAR8 *) Data);
     383        AcceptCmd (Size, (CHAR8 *)Data);
    378384      } else if (mState == ExpectDataState) {
    379385        AcceptData (Size, Data);
    … …  
    381387        ASSERT (FALSE);
    382388      }
     389
    383390      FreePool (Data);
    384391    }
    … …  
    402409FatalErrorNotify (
    403410  IN EFI_EVENT  Event,
    404   IN VOID      *Context
     411  IN VOID       *Context
    405412  )
    406413{
    … …  
    412419EFIAPI
    413420FastbootAppEntryPoint (
    414   IN EFI_HANDLE                            ImageHandle,
    415   IN EFI_SYSTEM_TABLE                      *SystemTable
     421  IN EFI_HANDLE        ImageHandle,
     422  IN EFI_SYSTEM_TABLE  *SystemTable
    416423  )
    417424{
    … …  
    420427  EFI_EVENT                       WaitEventArray[2];
    421428  UINTN                           EventIndex;
    422   EFI_SIMPLE_TEXT_INPUT_PROTOCOL *TextIn;
     429  EFI_SIMPLE_TEXT_INPUT_PROTOCOL  *TextIn;
    423430  EFI_INPUT_KEY                   Key;
    424431
    … …  
    426433
    427434  Status = gBS->LocateProtocol (
    428     &gAndroidFastbootTransportProtocolGuid,
    429     NULL,
    430     (VOID **) &mTransport
    431     );
    432   if (EFI_ERROR (Status)) {
    433     DEBUG ((EFI_D_ERROR, "Fastboot: Couldn't open Fastboot Transport Protocol: %r\n", Status));
     435                  &gAndroidFastbootTransportProtocolGuid,
     436                  NULL,
     437                  (VOID **)&mTransport
     438                  );
     439  if (EFI_ERROR (Status)) {
     440    DEBUG ((DEBUG_ERROR, "Fastboot: Couldn't open Fastboot Transport Protocol: %r\n", Status));
    434441    return Status;
    435442  }
    436443
    437   Status = gBS->LocateProtocol (&gAndroidFastbootPlatformProtocolGuid, NULL, (VOID **) &mPlatform);
    438   if (EFI_ERROR (Status)) {
    439     DEBUG ((EFI_D_ERROR, "Fastboot: Couldn't open Fastboot Platform Protocol: %r\n", Status));
     444  Status = gBS->LocateProtocol (&gAndroidFastbootPlatformProtocolGuid, NULL, (VOID **)&mPlatform);
     445  if (EFI_ERROR (Status)) {
     446    DEBUG ((DEBUG_ERROR, "Fastboot: Couldn't open Fastboot Platform Protocol: %r\n", Status));
    440447    return Status;
    441448  }
    … …  
    443450  Status = mPlatform->Init ();
    444451  if (EFI_ERROR (Status)) {
    445     DEBUG ((EFI_D_ERROR, "Fastboot: Couldn't initialise Fastboot Platform Protocol: %r\n", Status));
     452    DEBUG ((DEBUG_ERROR, "Fastboot: Couldn't initialise Fastboot Platform Protocol: %r\n", Status));
    446453    return Status;
    447454  }
    448455
    449   Status = gBS->LocateProtocol (&gEfiSimpleTextOutProtocolGuid, NULL, (VOID **) &mTextOut);
    450   if (EFI_ERROR (Status)) {
    451     DEBUG ((EFI_D_ERROR,
    452       "Fastboot: Couldn't open Text Output Protocol: %r\n", Status
     456  Status = gBS->LocateProtocol (&gEfiSimpleTextOutProtocolGuid, NULL, (VOID **)&mTextOut);
     457  if (EFI_ERROR (Status)) {
     458    DEBUG ((
     459      DEBUG_ERROR,
     460      "Fastboot: Couldn't open Text Output Protocol: %r\n",
     461      Status
    453462      ));
    454463    return Status;
    455464  }
    456465
    457   Status = gBS->LocateProtocol (&gEfiSimpleTextInProtocolGuid, NULL, (VOID **) &TextIn);
    458   if (EFI_ERROR (Status)) {
    459     DEBUG ((EFI_D_ERROR, "Fastboot: Couldn't open Text Input Protocol: %r\n", Status));
     466  Status = gBS->LocateProtocol (&gEfiSimpleTextInProtocolGuid, NULL, (VOID **)&TextIn);
     467  if (EFI_ERROR (Status)) {
     468    DEBUG ((DEBUG_ERROR, "Fastboot: Couldn't open Text Input Protocol: %r\n", Status));
    460469    return Status;
    461470  }
    … …  
    464473  Status = gBS->SetWatchdogTimer (0, 0x10000, 0, NULL);
    465474  if (EFI_ERROR (Status)) {
    466     DEBUG ((EFI_D_ERROR, "Fastboot: Couldn't disable watchdog timer: %r\n", Status));
     475    DEBUG ((DEBUG_ERROR, "Fastboot: Couldn't disable watchdog timer: %r\n", Status));
    467476  }
    468477
    … …  
    484493  // fatal error
    485494  Status = gBS->CreateEvent (
    486                  EVT_NOTIFY_SIGNAL,
    487                  TPL_CALLBACK,
    488                  FatalErrorNotify,
    489                  NULL,
    490                  &mFatalSendErrorEvent
    491                  );
     495                  EVT_NOTIFY_SIGNAL,
     496                  TPL_CALLBACK,
     497                  FatalErrorNotify,
     498                  NULL,
     499                  &mFatalSendErrorEvent
     500                  );
    492501  ASSERT_EFI_ERROR (Status);
    493 
    494502
    495503  // Start listening for data
    496504  Status = mTransport->Start (
    497     ReceiveEvent
    498     );
    499   if (EFI_ERROR (Status)) {
    500     DEBUG ((EFI_D_ERROR, "Fastboot: Couldn't start transport: %r\n", Status));
     505                         ReceiveEvent
     506                         );
     507  if (EFI_ERROR (Status)) {
     508    DEBUG ((DEBUG_ERROR, "Fastboot: Couldn't start transport: %r\n", Status));
    501509    return Status;
    502510  }
    503511
    504512  // Talk to the user
    505   mTextOut->OutputString (mTextOut,
    506       L"Android Fastboot mode - version " ANDROID_FASTBOOT_VERSION ". Press RETURN or SPACE key to quit.\r\n");
     513  mTextOut->OutputString (
     514              mTextOut,
     515              L"Android Fastboot mode - version " ANDROID_FASTBOOT_VERSION ". Press RETURN or SPACE key to quit.\r\n"
     516              );
    507517
    508518  // Quit when the user presses any key, or mFinishedEvent is signalled
    … …  
    514524    if (Key.ScanCode == SCAN_NULL) {
    515525      if ((Key.UnicodeChar == CHAR_CARRIAGE_RETURN) ||
    516           (Key.UnicodeChar == L' ')) {
     526          (Key.UnicodeChar == L' '))
     527      {
    517528        break;
    518529      }
    … …  
    522533  mTransport->Stop ();
    523534  if (EFI_ERROR (Status)) {
    524     DEBUG ((EFI_D_ERROR, "Warning: Fastboot Transport Stop: %r\n", Status));
    525   }
     535    DEBUG ((DEBUG_ERROR, "Warning: Fastboot Transport Stop: %r\n", Status));
     536  }
     537
    526538  mPlatform->UnInit ();
    527539

  • trunk/src/VBox/Devices/EFI/FirmwareNew/EmbeddedPkg/Application/AndroidFastboot/AndroidFastbootApp.h

    r85718 r99404  
    1515#include <Library/MemoryAllocationLib.h>
    1616
    17 #define BOOTIMG_KERNEL_ARGS_SIZE 512
     17#define BOOTIMG_KERNEL_ARGS_SIZE  512
    1818
    19 #define ANDROID_FASTBOOT_VERSION "0.4"
     19#define ANDROID_FASTBOOT_VERSION  "0.4"
    2020
    2121EFI_STATUS
    2222BootAndroidBootImg (
    23   IN  UINTN    BufferSize,
    24   IN  VOID    *Buffer
     23  IN  UINTN  BufferSize,
     24  IN  VOID   *Buffer
    2525  );
    2626
    2727EFI_STATUS
    2828ParseAndroidBootImg (
    29   IN  VOID    *BootImg,
     29  IN  VOID   *BootImg,
    3030  OUT VOID   **Kernel,
    31   OUT UINTN   *KernelSize,
     31  OUT UINTN  *KernelSize,
    3232  OUT VOID   **Ramdisk,
    33   OUT UINTN   *RamdiskSize,
    34   OUT CHAR8   *KernelArgs
     33  OUT UINTN  *RamdiskSize,
     34  OUT CHAR8  *KernelArgs
    3535  );
    3636

  • trunk/src/VBox/Devices/EFI/FirmwareNew/EmbeddedPkg/Application/AndroidFastboot/Arm/BootAndroidBootImg.c

    r85718 r99404  
    1919#pragma pack(1)
    2020typedef struct {
    21   MEMMAP_DEVICE_PATH                      Node1;
    22   EFI_DEVICE_PATH_PROTOCOL                End;
     21  MEMMAP_DEVICE_PATH          Node1;
     22  EFI_DEVICE_PATH_PROTOCOL    End;
    2323} MEMORY_DEVICE_PATH;
    2424#pragma pack()
    2525
    26 STATIC CONST MEMORY_DEVICE_PATH MemoryDevicePathTemplate =
     26STATIC CONST MEMORY_DEVICE_PATH  MemoryDevicePathTemplate =
    2727{
    2828  {
    … …  
    4545};
    4646
    47 
    4847/**
    4948  Start an EFI Application from a Device Path
    … …  
    6059EFI_STATUS
    6160StartEfiApplication (
    62   IN EFI_HANDLE                  ParentImageHandle,
    63   IN EFI_DEVICE_PATH_PROTOCOL    *DevicePath,
    64   IN UINTN                       LoadOptionsSize,
    65   IN VOID*                       LoadOptions
     61  IN EFI_HANDLE                ParentImageHandle,
     62  IN EFI_DEVICE_PATH_PROTOCOL  *DevicePath,
     63  IN UINTN                     LoadOptionsSize,
     64  IN VOID                      *LoadOptions
    6665  )
    6766{
    68   EFI_STATUS                   Status;
    69   EFI_HANDLE                   ImageHandle;
    70   EFI_LOADED_IMAGE_PROTOCOL*   LoadedImage;
     67  EFI_STATUS                 Status;
     68  EFI_HANDLE                 ImageHandle;
     69  EFI_LOADED_IMAGE_PROTOCOL  *LoadedImage;
    7170
    7271  // Load the image from the device path with Boot Services function
    73   Status = gBS->LoadImage (TRUE, ParentImageHandle, DevicePath, NULL, 0,
    74                   &ImageHandle);
     72  Status = gBS->LoadImage (
     73                  TRUE,
     74                  ParentImageHandle,
     75                  DevicePath,
     76                  NULL,
     77                  0,
     78                  &ImageHandle
     79                  );
    7580  if (EFI_ERROR (Status)) {
    7681    //
    … …  
    8388      gBS->UnloadImage (ImageHandle);
    8489    }
     90
    8591    return Status;
    8692  }
    … …  
    8894  // Passed LoadOptions to the EFI Application
    8995  if (LoadOptionsSize != 0) {
    90     Status = gBS->HandleProtocol (ImageHandle, &gEfiLoadedImageProtocolGuid,
    91                     (VOID **) &LoadedImage);
     96    Status = gBS->HandleProtocol (
     97                    ImageHandle,
     98                    &gEfiLoadedImageProtocolGuid,
     99                    (VOID **)&LoadedImage
     100                    );
    92101    if (EFI_ERROR (Status)) {
    93102      return Status;
    94103    }
    95104
    96     LoadedImage->LoadOptionsSize  = LoadOptionsSize;
    97     LoadedImage->LoadOptions      = LoadOptions;
     105    LoadedImage->LoadOptionsSize = LoadOptionsSize;
     106    LoadedImage->LoadOptions     = LoadOptions;
    98107  }
    99108
    … …  
    110119EFI_STATUS
    111120BootAndroidBootImg (
    112   IN UINTN    BufferSize,
    113   IN VOID    *Buffer
     121  IN UINTN  BufferSize,
     122  IN VOID   *Buffer
    114123  )
    115124{
    116   EFI_STATUS                          Status;
    117   CHAR8                               KernelArgs[ANDROID_BOOTIMG_KERNEL_ARGS_SIZE];
    118   VOID                               *Kernel;
    119   UINTN                               KernelSize;
    120   VOID                               *Ramdisk;
    121   UINTN                               RamdiskSize;
    122   MEMORY_DEVICE_PATH                  KernelDevicePath;
    123   CHAR16                              *LoadOptions, *NewLoadOptions;
     125  EFI_STATUS          Status;
     126  CHAR8               KernelArgs[ANDROID_BOOTIMG_KERNEL_ARGS_SIZE];
     127  VOID                *Kernel;
     128  UINTN               KernelSize;
     129  VOID                *Ramdisk;
     130  UINTN               RamdiskSize;
     131  MEMORY_DEVICE_PATH  KernelDevicePath;
     132  CHAR16              *LoadOptions, *NewLoadOptions;
    124133
    125134  Status = ParseAndroidBootImg (
    126             Buffer,
    127             &Kernel,
    128             &KernelSize,
    129             &Ramdisk,
    130             &RamdiskSize,
    131             KernelArgs
    132             );
     135             Buffer,
     136             &Kernel,
     137             &KernelSize,
     138             &Ramdisk,
     139             &RamdiskSize,
     140             KernelArgs
     141             );
    133142  if (EFI_ERROR (Status)) {
    134143    return Status;
    … …  
    139148  // Have to cast to UINTN before casting to EFI_PHYSICAL_ADDRESS in order to
    140149  // appease GCC.
    141   KernelDevicePath.Node1.StartingAddress = (EFI_PHYSICAL_ADDRESS)(UINTN) Kernel;
    142   KernelDevicePath.Node1.EndingAddress   = (EFI_PHYSICAL_ADDRESS)(UINTN) Kernel + KernelSize;
     150  KernelDevicePath.Node1.StartingAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)Kernel;
     151  KernelDevicePath.Node1.EndingAddress   = (EFI_PHYSICAL_ADDRESS)(UINTN)Kernel + KernelSize;
    143152
    144153  // Initialize Linux command line
    … …  
    149158
    150159  if (RamdiskSize != 0) {
    151     NewLoadOptions = CatSPrint (LoadOptions, L" initrd=0x%x,0x%x",
    152                        (UINTN)Ramdisk, RamdiskSize);
     160    NewLoadOptions = CatSPrint (
     161                       LoadOptions,
     162                       L" initrd=0x%x,0x%x",
     163                       (UINTN)Ramdisk,
     164                       RamdiskSize
     165                       );
    153166    FreePool (LoadOptions);
    154167    if (NewLoadOptions == NULL) {
    155168      return EFI_OUT_OF_RESOURCES;
    156169    }
     170
    157171    LoadOptions = NewLoadOptions;
    158172  }
    159173
    160   Status = StartEfiApplication (gImageHandle,
    161              (EFI_DEVICE_PATH_PROTOCOL *) &KernelDevicePath,
     174  Status = StartEfiApplication (
     175             gImageHandle,
     176             (EFI_DEVICE_PATH_PROTOCOL *)&KernelDevicePath,
    162177             StrSize (LoadOptions),
    163              LoadOptions);
     178             LoadOptions
     179             );
    164180  if (EFI_ERROR (Status)) {
    165     DEBUG ((EFI_D_ERROR, "Couldn't Boot Linux: %d\n", Status));
     181    DEBUG ((DEBUG_ERROR, "Couldn't Boot Linux: %d\n", Status));
    166182    Status = EFI_DEVICE_ERROR;
    167183    goto FreeLoadOptions;
    … …  
    170186  // If we got here we do a confused face because BootLinuxFdt returned,
    171187  // reporting success.
    172   DEBUG ((EFI_D_ERROR, "WARNING: BdsBootLinuxFdt returned EFI_SUCCESS.\n"));
     188  DEBUG ((DEBUG_ERROR, "WARNING: BdsBootLinuxFdt returned EFI_SUCCESS.\n"));
    173189  return EFI_SUCCESS;
    174190
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette