EmbeddedPkg/AndroidFastbootTransportTcpDxe: fix DestroyChild() call

[mirror_edk2.git] / EmbeddedPkg / Drivers / AndroidFastbootTransportTcpDxe / FastbootTransportTcp.c

/** @file\r
#\r
#  Copyright (c) 2014, ARM Ltd. All rights reserved.<BR>\r
#\r
#  SPDX-License-Identifier: BSD-2-Clause-Patent\r
#\r
#\r
#**/\r
\r
#include <Protocol/AndroidFastbootTransport.h>\r
#include <Protocol/Dhcp4.h>\r
#include <Protocol/Tcp4.h>\r
#include <Protocol/ServiceBinding.h>\r
#include <Protocol/SimpleTextOut.h>\r
\r
#include <Library/BaseLib.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/DebugLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/PrintLib.h>\r
#include <Library/UefiBootServicesTableLib.h>\r
#include <Library/UefiDriverEntryPoint.h>\r
#include <Library/UefiRuntimeServicesTableLib.h>\r
\r
#define IP4_ADDR_TO_STRING(IpAddr, IpAddrString) UnicodeSPrint (       \\r
                                                   IpAddrString,       \\r
                                                   16 * 2,             \\r
                                                   L"%d.%d.%d.%d",     \\r
                                                   IpAddr.Addr[0],     \\r
                                                   IpAddr.Addr[1],     \\r
                                                   IpAddr.Addr[2],     \\r
                                                   IpAddr.Addr[3]      \\r
                                                   );\r
\r
// Fastboot says max packet size is 512, but FASTBOOT_TRANSPORT_PROTOCOL\r
// doesn't place a limit on the size of buffers returned by Receive.\r
// (This isn't actually a packet size - it's just the size of the buffers we\r
//  pass to the TCP driver to fill with received data.)\r
// We can achieve much better performance by doing this in larger chunks.\r
#define RX_FRAGMENT_SIZE 2048\r
\r
STATIC EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *mTextOut;\r
\r
STATIC EFI_TCP4_PROTOCOL *mTcpConnection;\r
STATIC EFI_TCP4_PROTOCOL *mTcpListener;\r
\r
STATIC EFI_EVENT mReceiveEvent;\r
\r
STATIC EFI_SERVICE_BINDING_PROTOCOL *mTcpServiceBinding;\r
STATIC EFI_HANDLE                    mTcpHandle = NULL;\r
\r
// We only ever use one IO token for receive and one for transmit. To save\r
// repeatedly allocating and freeing, just allocate statically and re-use.\r
#define NUM_RX_TOKENS 16\r
#define TOKEN_NEXT(Index) (((Index) + 1) % NUM_RX_TOKENS)\r
\r
STATIC UINTN                     mNextSubmitIndex;\r
STATIC UINTN                     mNextReceiveIndex;\r
STATIC EFI_TCP4_IO_TOKEN         mReceiveToken[NUM_RX_TOKENS];\r
STATIC EFI_TCP4_RECEIVE_DATA     mRxData[NUM_RX_TOKENS];\r
STATIC EFI_TCP4_IO_TOKEN         mTransmitToken;\r
STATIC EFI_TCP4_TRANSMIT_DATA    mTxData;\r
// We also reuse the accept token\r
STATIC EFI_TCP4_LISTEN_TOKEN     mAcceptToken;\r
// .. and the close token\r
STATIC EFI_TCP4_CLOSE_TOKEN      mCloseToken;\r
\r
// List type for queued received packets\r
typedef struct _FASTBOOT_TCP_PACKET_LIST {\r
  LIST_ENTRY  Link;\r
  VOID       *Buffer;\r
  UINTN       BufferSize;\r
} FASTBOOT_TCP_PACKET_LIST;\r
\r
STATIC LIST_ENTRY mPacketListHead;\r
\r
STATIC\r
VOID\r
EFIAPI\r
DataReceived (\r
  IN EFI_EVENT Event,\r
  IN VOID     *Context\r
  );\r
\r
/*\r
  Helper function to set up a receive IO token and call Tcp->Receive\r
*/\r
STATIC\r
EFI_STATUS\r
SubmitRecieveToken (\r
  VOID\r
  )\r
{\r
  EFI_STATUS             Status;\r
  VOID                  *FragmentBuffer;\r
\r
  Status = EFI_SUCCESS;\r
\r
  FragmentBuffer = AllocatePool (RX_FRAGMENT_SIZE);\r
  ASSERT (FragmentBuffer != NULL);\r
  if (FragmentBuffer == NULL) {\r
    DEBUG ((EFI_D_ERROR, "TCP Fastboot out of resources"));\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  mRxData[mNextSubmitIndex].DataLength = RX_FRAGMENT_SIZE;\r
  mRxData[mNextSubmitIndex].FragmentTable[0].FragmentLength = RX_FRAGMENT_SIZE;\r
  mRxData[mNextSubmitIndex].FragmentTable[0].FragmentBuffer = FragmentBuffer;\r
\r
  Status = mTcpConnection->Receive (mTcpConnection, &mReceiveToken[mNextSubmitIndex]);\r
   if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "TCP Receive: %r\n", Status));\r
    FreePool (FragmentBuffer);\r
  }\r
\r
  mNextSubmitIndex = TOKEN_NEXT (mNextSubmitIndex);\r
  return Status;\r
}\r
\r
/*\r
  Event notify function for when we have closed our TCP connection.\r
  We can now start listening for another connection.\r
*/\r
STATIC\r
VOID\r
ConnectionClosed (\r
  IN EFI_EVENT  Event,\r
  IN VOID      *Context\r
  )\r
{\r
  EFI_STATUS Status;\r
\r
  // Possible bug in EDK2 TCP4 driver: closing a connection doesn't remove its\r
  // PCB from the list of live connections. Subsequent attempts to Configure()\r
  // a TCP instance with the same local port will fail with INVALID_PARAMETER.\r
  // Calling Configure with NULL is a workaround for this issue.\r
  Status = mTcpConnection->Configure (mTcpConnection, NULL);\r
\r
  mTcpConnection = NULL;\r
\r
  Status = mTcpListener->Accept (mTcpListener, &mAcceptToken);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "TCP Accept: %r\n", Status));\r
  }\r
}\r
\r
STATIC\r
VOID\r
CloseReceiveEvents (\r
  VOID\r
  )\r
{\r
  UINTN Index;\r
\r
  for (Index = 0; Index < NUM_RX_TOKENS; Index++) {\r
    gBS->CloseEvent (mReceiveToken[Index].CompletionToken.Event);\r
  }\r
}\r
\r
/*\r
  Event notify function to be called when we receive TCP data.\r
*/\r
STATIC\r
VOID\r
EFIAPI\r
DataReceived (\r
  IN EFI_EVENT Event,\r
  IN VOID     *Context\r
  )\r
{\r
  EFI_STATUS                 Status;\r
  FASTBOOT_TCP_PACKET_LIST  *NewEntry;\r
  EFI_TCP4_IO_TOKEN         *ReceiveToken;\r
\r
  ReceiveToken = &mReceiveToken[mNextReceiveIndex];\r
\r
  Status = ReceiveToken->CompletionToken.Status;\r
\r
  if (Status == EFI_CONNECTION_FIN) {\r
    //\r
    // Remote host closed connection. Close our end.\r
    //\r
\r
    CloseReceiveEvents ();\r
\r
    Status = mTcpConnection->Close (mTcpConnection, &mCloseToken);\r
    ASSERT_EFI_ERROR (Status);\r
\r
    return;\r
  }\r
\r
  //\r
  // Add an element to the receive queue\r
  //\r
\r
  NewEntry = AllocatePool (sizeof (FASTBOOT_TCP_PACKET_LIST));\r
  if (NewEntry == NULL) {\r
    DEBUG ((EFI_D_ERROR, "TCP Fastboot: Out of resources\n"));\r
    return;\r
  }\r
\r
  mNextReceiveIndex = TOKEN_NEXT (mNextReceiveIndex);\r
\r
  if (!EFI_ERROR (Status)) {\r
    NewEntry->Buffer\r
      = ReceiveToken->Packet.RxData->FragmentTable[0].FragmentBuffer;\r
    NewEntry->BufferSize\r
      = ReceiveToken->Packet.RxData->FragmentTable[0].FragmentLength;\r
\r
    // Prepare to receive more data\r
    SubmitRecieveToken();\r
  } else {\r
    // Fatal receive error. Put an entry with NULL in the queue, signifying\r
    // to return EFI_DEVICE_ERROR from TcpFastbootTransportReceive.\r
    NewEntry->Buffer = NULL;\r
    NewEntry->BufferSize = 0;\r
\r
    DEBUG ((EFI_D_ERROR, "\nTCP Fastboot Receive error: %r\n", Status));\r
  }\r
\r
  InsertTailList (&mPacketListHead, &NewEntry->Link);\r
\r
  Status = gBS->SignalEvent (mReceiveEvent);\r
  ASSERT_EFI_ERROR (Status);\r
}\r
\r
\r
/*\r
  Event notify function to be called when we accept an incoming TCP connection.\r
*/\r
STATIC\r
VOID\r
EFIAPI\r
ConnectionAccepted (\r
  IN EFI_EVENT Event,\r
  IN VOID     *Context\r
  )\r
{\r
  EFI_TCP4_LISTEN_TOKEN *AcceptToken;\r
  EFI_STATUS             Status;\r
  UINTN                  Index;\r
\r
  AcceptToken = (EFI_TCP4_LISTEN_TOKEN *) Context;\r
  Status = AcceptToken->CompletionToken.Status;\r
\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "TCP Fastboot: Connection Error: %r\n", Status));\r
    return;\r
  }\r
  DEBUG ((EFI_D_ERROR, "TCP Fastboot: Connection Received.\n"));\r
\r
  //\r
  // Accepting a new TCP connection creates a new instance of the TCP protocol.\r
  // Open it and prepare to receive on it.\r
  //\r
\r
  Status = gBS->OpenProtocol (\r
                  AcceptToken->NewChildHandle,\r
                  &gEfiTcp4ProtocolGuid,\r
                  (VOID **) &mTcpConnection,\r
                  gImageHandle,\r
                  NULL,\r
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "Open TCP Connection: %r\n", Status));\r
    return;\r
  }\r
\r
  mNextSubmitIndex = 0;\r
  mNextReceiveIndex = 0;\r
\r
  for (Index = 0; Index < NUM_RX_TOKENS; Index++) {\r
    Status = gBS->CreateEvent (\r
                    EVT_NOTIFY_SIGNAL,\r
                    TPL_CALLBACK,\r
                    DataReceived,\r
                    NULL,\r
                    &(mReceiveToken[Index].CompletionToken.Event)\r
                    );\r
    ASSERT_EFI_ERROR (Status);\r
  }\r
\r
  for (Index = 0; Index < NUM_RX_TOKENS; Index++) {\r
    SubmitRecieveToken();\r
  }\r
}\r
\r
/*\r
  Set up TCP Fastboot transport: Configure the network device via DHCP then\r
  start waiting for a TCP connection on the Fastboot port.\r
*/\r
EFI_STATUS\r
TcpFastbootTransportStart (\r
  EFI_EVENT ReceiveEvent\r
  )\r
{\r
  EFI_STATUS                    Status;\r
  EFI_HANDLE                    NetDeviceHandle;\r
  EFI_HANDLE                   *HandleBuffer;\r
  EFI_IP4_MODE_DATA             Ip4ModeData;\r
  UINTN                         NumHandles;\r
  CHAR16                        IpAddrString[16];\r
  UINTN                         Index;\r
\r
  EFI_TCP4_CONFIG_DATA TcpConfigData = {\r
    0x00,                                           // IPv4 Type of Service\r
    255,                                            // IPv4 Time to Live\r
    {                                               // AccessPoint:\r
      TRUE,                                         // Use default address\r
      { {0, 0, 0, 0} },                             // IP Address  (ignored - use default)\r
      { {0, 0, 0, 0} },                             // Subnet mask (ignored - use default)\r
      FixedPcdGet32 (PcdAndroidFastbootTcpPort),    // Station port\r
      { {0, 0, 0, 0} },                             // Remote address: accept any\r
      0,                                            // Remote Port: accept any\r
      FALSE                                         // ActiveFlag: be a "server"\r
    },\r
    NULL                                            // Default advanced TCP options\r
  };\r
\r
  mReceiveEvent = ReceiveEvent;\r
  InitializeListHead (&mPacketListHead);\r
\r
  mTextOut->OutputString (mTextOut, L"Initialising TCP Fastboot transport...\r\n");\r
\r
  //\r
  // Open a passive TCP instance\r
  //\r
\r
  Status = gBS->LocateHandleBuffer (\r
                  ByProtocol,\r
                  &gEfiTcp4ServiceBindingProtocolGuid,\r
                  NULL,\r
                  &NumHandles,\r
                  &HandleBuffer\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "Find TCP Service Binding: %r\n", Status));\r
    return Status;\r
  }\r
\r
  // We just use the first network device\r
  NetDeviceHandle = HandleBuffer[0];\r
\r
  Status =  gBS->OpenProtocol (\r
                    NetDeviceHandle,\r
                    &gEfiTcp4ServiceBindingProtocolGuid,\r
                    (VOID **) &mTcpServiceBinding,\r
                    gImageHandle,\r
                    NULL,\r
                    EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
                    );\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "Open TCP Service Binding: %r\n", Status));\r
    return Status;\r
  }\r
\r
  Status = mTcpServiceBinding->CreateChild (mTcpServiceBinding, &mTcpHandle);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "TCP ServiceBinding Create: %r\n", Status));\r
    return Status;\r
  }\r
\r
  Status =  gBS->OpenProtocol (\r
                    mTcpHandle,\r
                    &gEfiTcp4ProtocolGuid,\r
                    (VOID **) &mTcpListener,\r
                    gImageHandle,\r
                    NULL,\r
                    EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
                    );\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "Open TCP Protocol: %r\n", Status));\r
  }\r
\r
  //\r
  // Set up re-usable tokens\r
  //\r
\r
  for (Index = 0; Index < NUM_RX_TOKENS; Index++) {\r
    mRxData[Index].UrgentFlag = FALSE;\r
    mRxData[Index].FragmentCount = 1;\r
    mReceiveToken[Index].Packet.RxData = &mRxData[Index];\r
  }\r
\r
  mTxData.Push = TRUE;\r
  mTxData.Urgent = FALSE;\r
  mTxData.FragmentCount = 1;\r
  mTransmitToken.Packet.TxData = &mTxData;\r
\r
  Status = gBS->CreateEvent (\r
                  EVT_NOTIFY_SIGNAL,\r
                  TPL_CALLBACK,\r
                  ConnectionAccepted,\r
                  &mAcceptToken,\r
                  &mAcceptToken.CompletionToken.Event\r
                  );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  Status = gBS->CreateEvent (\r
                  EVT_NOTIFY_SIGNAL,\r
                  TPL_CALLBACK,\r
                  ConnectionClosed,\r
                  &mCloseToken,\r
                  &mCloseToken.CompletionToken.Event\r
                  );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  //\r
  // Configure the TCP instance\r
  //\r
\r
  Status = mTcpListener->Configure (mTcpListener, &TcpConfigData);\r
  if (Status == EFI_NO_MAPPING) {\r
    // Wait until the IP configuration process (probably DHCP) has finished\r
    do {\r
      Status = mTcpListener->GetModeData (mTcpListener,\r
                               NULL, NULL,\r
                               &Ip4ModeData,\r
                               NULL, NULL\r
                               );\r
      ASSERT_EFI_ERROR (Status);\r
    } while (!Ip4ModeData.IsConfigured);\r
    Status = mTcpListener->Configure (mTcpListener, &TcpConfigData);\r
  } else if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "TCP Configure: %r\n", Status));\r
    return Status;\r
  }\r
\r
  //\r
  // Tell the user our address and hostname\r
  //\r
  IP4_ADDR_TO_STRING (Ip4ModeData.ConfigData.StationAddress, IpAddrString);\r
\r
  mTextOut->OutputString (mTextOut, L"TCP Fastboot transport configured.");\r
  mTextOut->OutputString (mTextOut, L"\r\nIP address: ");\r
  mTextOut->OutputString (mTextOut ,IpAddrString);\r
  mTextOut->OutputString (mTextOut, L"\r\n");\r
\r
  //\r
  // Start listening for a connection\r
  //\r
\r
  Status = mTcpListener->Accept (mTcpListener, &mAcceptToken);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "TCP Accept: %r\n", Status));\r
    return Status;\r
  }\r
\r
  mTextOut->OutputString (mTextOut, L"TCP Fastboot transport initialised.\r\n");\r
\r
  FreePool (HandleBuffer);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
TcpFastbootTransportStop (\r
  VOID\r
  )\r
{\r
  EFI_TCP4_CLOSE_TOKEN      CloseToken;\r
  EFI_STATUS                Status;\r
  UINTN                     EventIndex;\r
  FASTBOOT_TCP_PACKET_LIST *Entry;\r
  FASTBOOT_TCP_PACKET_LIST *NextEntry;\r
\r
  // Close any existing TCP connection, blocking until it's done.\r
  if (mTcpConnection != NULL) {\r
    CloseReceiveEvents ();\r
\r
    CloseToken.AbortOnClose = FALSE;\r
\r
    Status = gBS->CreateEvent (0, 0, NULL, NULL, &CloseToken.CompletionToken.Event);\r
    ASSERT_EFI_ERROR (Status);\r
\r
    Status = mTcpConnection->Close (mTcpConnection, &CloseToken);\r
    ASSERT_EFI_ERROR (Status);\r
\r
    Status = gBS->WaitForEvent (\r
                    1,\r
                    &CloseToken.CompletionToken.Event,\r
                    &EventIndex\r
                    );\r
    ASSERT_EFI_ERROR (Status);\r
\r
    ASSERT_EFI_ERROR (CloseToken.CompletionToken.Status);\r
\r
    // Possible bug in EDK2 TCP4 driver: closing a connection doesn't remove its\r
    // PCB from the list of live connections. Subsequent attempts to Configure()\r
    // a TCP instance with the same local port will fail with INVALID_PARAMETER.\r
    // Calling Configure with NULL is a workaround for this issue.\r
    Status = mTcpConnection->Configure (mTcpConnection, NULL);\r
    ASSERT_EFI_ERROR (Status);\r
  }\r
\r
\r
  gBS->CloseEvent (mAcceptToken.CompletionToken.Event);\r
\r
  // Stop listening for connections.\r
  // Ideally we would do this with Cancel, but it isn't implemented by EDK2.\r
  // So we just "reset this TCPv4 instance brutally".\r
  Status = mTcpListener->Configure (mTcpListener, NULL);\r
  ASSERT_EFI_ERROR (Status);\r
\r
  Status = mTcpServiceBinding->DestroyChild (mTcpServiceBinding, mTcpHandle);\r
\r
  // Free any data the user didn't pick up\r
  Entry = (FASTBOOT_TCP_PACKET_LIST *) GetFirstNode (&mPacketListHead);\r
  while (!IsNull (&mPacketListHead, &Entry->Link)) {\r
    NextEntry = (FASTBOOT_TCP_PACKET_LIST *) GetNextNode (&mPacketListHead, &Entry->Link);\r
\r
    RemoveEntryList (&Entry->Link);\r
    if (Entry->Buffer) {\r
      FreePool (Entry->Buffer);\r
    }\r
    FreePool (Entry);\r
\r
    Entry = NextEntry;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/*\r
  Event notify function for when data has been sent. Free resources and report\r
  errors.\r
  Context should point to the transmit IO token passed to\r
  TcpConnection->Transmit.\r
*/\r
STATIC\r
VOID\r
DataSent (\r
  EFI_EVENT Event,\r
  VOID     *Context\r
  )\r
{\r
  EFI_STATUS           Status;\r
\r
  Status = mTransmitToken.CompletionToken.Status;\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "TCP Fastboot transmit result: %r\n", Status));\r
    gBS->SignalEvent (*(EFI_EVENT *) Context);\r
  }\r
\r
  FreePool (mTransmitToken.Packet.TxData->FragmentTable[0].FragmentBuffer);\r
}\r
\r
EFI_STATUS\r
TcpFastbootTransportSend (\r
  IN        UINTN      BufferSize,\r
  IN  CONST VOID      *Buffer,\r
  IN        EFI_EVENT *FatalErrorEvent\r
  )\r
{\r
  EFI_STATUS                Status;\r
\r
  if (BufferSize > 512) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // Build transmit IO token\r
  //\r
\r
  // Create an event so we are notified when a transmission is complete.\r
  // We use this to free resources and report errors.\r
  Status = gBS->CreateEvent (\r
                  EVT_NOTIFY_SIGNAL,\r
                  TPL_CALLBACK,\r
                  DataSent,\r
                  FatalErrorEvent,\r
                  &mTransmitToken.CompletionToken.Event\r
                  );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  mTxData.DataLength = BufferSize;\r
\r
  mTxData.FragmentTable[0].FragmentLength = BufferSize;\r
  mTxData.FragmentTable[0].FragmentBuffer = AllocateCopyPool (\r
                                             BufferSize,\r
                                             Buffer\r
                                             );\r
\r
  Status = mTcpConnection->Transmit (mTcpConnection, &mTransmitToken);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "TCP Transmit: %r\n", Status));\r
    return Status;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
EFI_STATUS\r
TcpFastbootTransportReceive (\r
  OUT UINTN  *BufferSize,\r
  OUT VOID  **Buffer\r
  )\r
{\r
  FASTBOOT_TCP_PACKET_LIST *Entry;\r
\r
  if (IsListEmpty (&mPacketListHead)) {\r
    return EFI_NOT_READY;\r
  }\r
\r
  Entry = (FASTBOOT_TCP_PACKET_LIST *) GetFirstNode (&mPacketListHead);\r
\r
  if (Entry->Buffer == NULL) {\r
    // There was an error receiving this packet.\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  *Buffer = Entry->Buffer;\r
  *BufferSize = Entry->BufferSize;\r
\r
  RemoveEntryList (&Entry->Link);\r
  FreePool (Entry);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
FASTBOOT_TRANSPORT_PROTOCOL mTransportProtocol = {\r
  TcpFastbootTransportStart,\r
  TcpFastbootTransportStop,\r
  TcpFastbootTransportSend,\r
  TcpFastbootTransportReceive\r
};\r
\r
EFI_STATUS\r
TcpFastbootTransportEntryPoint (\r
  IN EFI_HANDLE        ImageHandle,\r
  IN EFI_SYSTEM_TABLE *SystemTable\r
  )\r
{\r
  EFI_STATUS Status;\r
\r
\r
  Status = gBS->LocateProtocol(\r
    &gEfiSimpleTextOutProtocolGuid,\r
    NULL,\r
    (VOID **) &mTextOut\r
    );\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "Fastboot: Open Text Output Protocol: %r\n", Status));\r
    return Status;\r
  }\r
\r
  Status = gBS->InstallProtocolInterface (\r
                  &ImageHandle,\r
                  &gAndroidFastbootTransportProtocolGuid,\r
                  EFI_NATIVE_INTERFACE,\r
                  &mTransportProtocol\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "Fastboot: Install transport Protocol: %r\n", Status));\r
  }\r
\r
  return Status;\r
}\r