[mirror_edk2.git] / MdeModulePkg / Universal / DebugPortDxe / DebugPort.c

/** @file\r
  Top level C file for debugport driver.  Contains initialization function.\r
  This driver layers on top of SerialIo.\r
  ALL CODE IN THE SERIALIO STACK MUST BE RE-ENTRANT AND CALLABLE FROM\r
  INTERRUPT CONTEXT\r
\r
Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>\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 "DebugPort.h"\r
\r
//\r
// Globals\r
//\r
EFI_DRIVER_BINDING_PROTOCOL gDebugPortDriverBinding = {\r
  DebugPortSupported,\r
  DebugPortStart,\r
  DebugPortStop,\r
  DEBUGPORT_DRIVER_VERSION,\r
  NULL,\r
  NULL\r
};\r
\r
DEBUGPORT_DEVICE mDebugPortDevice = {\r
  DEBUGPORT_DEVICE_SIGNATURE,\r
  (EFI_HANDLE) 0,\r
  (EFI_HANDLE) 0,\r
  (VOID *) NULL,\r
  (EFI_DEVICE_PATH_PROTOCOL *) NULL,\r
  {\r
    DebugPortReset,\r
    DebugPortRead,\r
    DebugPortWrite,\r
    DebugPortPoll\r
  },\r
  (EFI_HANDLE) 0,\r
  (EFI_SERIAL_IO_PROTOCOL *) NULL,\r
  DEBUGPORT_UART_DEFAULT_BAUDRATE,\r
  DEBUGPORT_UART_DEFAULT_FIFO_DEPTH,\r
  DEBUGPORT_UART_DEFAULT_TIMEOUT,\r
  (EFI_PARITY_TYPE) DEBUGPORT_UART_DEFAULT_PARITY,\r
  DEBUGPORT_UART_DEFAULT_DATA_BITS,\r
  (EFI_STOP_BITS_TYPE) DEBUGPORT_UART_DEFAULT_STOP_BITS\r
};\r
\r
/**\r
  Local worker function to obtain device path information from DebugPort variable.\r
\r
  Records requested settings in DebugPort device structure.\r
\r
**/\r
VOID\r
GetDebugPortVariable (\r
  VOID\r
  )\r
{\r
  UINTN                     DataSize;\r
  EFI_DEVICE_PATH_PROTOCOL  *DevicePath;\r
  EFI_STATUS                Status;\r
\r
  DataSize = 0;\r
\r
  Status = gRT->GetVariable (\r
                  (CHAR16 *) EFI_DEBUGPORT_VARIABLE_NAME,\r
                  &gEfiDebugPortVariableGuid,\r
                  NULL,\r
                  &DataSize,\r
                  mDebugPortDevice.DebugPortVariable\r
                  );\r
\r
  if (Status == EFI_BUFFER_TOO_SMALL) {\r
    if (mDebugPortDevice.DebugPortVariable != NULL) {\r
      FreePool (mDebugPortDevice.DebugPortVariable);\r
    }\r
\r
    mDebugPortDevice.DebugPortVariable = AllocatePool (DataSize);\r
    if (mDebugPortDevice.DebugPortVariable != NULL) {\r
      gRT->GetVariable (\r
            (CHAR16 *) EFI_DEBUGPORT_VARIABLE_NAME,\r
            &gEfiDebugPortVariableGuid,\r
            NULL,\r
            &DataSize,\r
            mDebugPortDevice.DebugPortVariable\r
            );\r
      DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) mDebugPortDevice.DebugPortVariable;\r
      while (!IsDevicePathEnd (DevicePath) && !IS_UART_DEVICEPATH (DevicePath)) {\r
        DevicePath = NextDevicePathNode (DevicePath);\r
      }\r
\r
      if (IsDevicePathEnd (DevicePath)) {\r
        FreePool (mDebugPortDevice.DebugPortVariable);\r
        mDebugPortDevice.DebugPortVariable = NULL;\r
      } else {\r
        CopyMem (\r
          &mDebugPortDevice.BaudRate,\r
          &((UART_DEVICE_PATH *) DevicePath)->BaudRate,\r
          sizeof (((UART_DEVICE_PATH *) DevicePath)->BaudRate)\r
          );\r
        mDebugPortDevice.ReceiveFifoDepth = DEBUGPORT_UART_DEFAULT_FIFO_DEPTH;\r
        mDebugPortDevice.Timeout          = DEBUGPORT_UART_DEFAULT_TIMEOUT;\r
        CopyMem (\r
          &mDebugPortDevice.Parity,\r
          &((UART_DEVICE_PATH *) DevicePath)->Parity,\r
          sizeof (((UART_DEVICE_PATH *) DevicePath)->Parity)\r
          );\r
        CopyMem (\r
          &mDebugPortDevice.DataBits,\r
          &((UART_DEVICE_PATH *) DevicePath)->DataBits,\r
          sizeof (((UART_DEVICE_PATH *) DevicePath)->DataBits)\r
          );\r
        CopyMem (\r
          &mDebugPortDevice.StopBits,\r
          &((UART_DEVICE_PATH *) DevicePath)->StopBits,\r
          sizeof (((UART_DEVICE_PATH *) DevicePath)->StopBits)\r
          );\r
      }\r
    }\r
  }\r
}\r
\r
/**\r
  Debug Port Driver entry point.\r
\r
  Reads DebugPort variable to determine what device and settings to use as the\r
  debug port.  Binds exclusively to SerialIo. Reverts to defaults if no variable\r
  is found.\r
\r
  @param[in] ImageHandle       The firmware allocated handle for the EFI image.\r
  @param[in] SystemTable       A pointer to the EFI System Table.\r
\r
  @retval EFI_SUCCESS          The entry point is executed successfully.\r
  @retval EFI_OUT_OF_RESOURCES Fails to allocate memory for device.\r
  @retval other                Some error occurs when executing this entry point.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
InitializeDebugPortDriver (\r
  IN EFI_HANDLE             ImageHandle,\r
  IN EFI_SYSTEM_TABLE       *SystemTable\r
  )\r
{\r
  EFI_STATUS    Status;\r
\r
  //\r
  // Install driver model protocol(s).\r
  //\r
  Status = EfiLibInstallDriverBindingComponentName2 (\r
             ImageHandle,\r
             SystemTable,\r
             &gDebugPortDriverBinding,\r
             ImageHandle,\r
             &gDebugPortComponentName,\r
             &gDebugPortComponentName2\r
             );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Checks to see if there's not already a DebugPort interface somewhere.\r
\r
  If there's a DEBUGPORT variable, the device path must match exactly.  If there's\r
  no DEBUGPORT variable, then device path is not checked and does not matter.\r
  Checks to see that there's a serial io interface on the controller handle\r
  that can be bound BY_DRIVER | EXCLUSIVE.\r
  If all these tests succeed, then we return EFI_SUCCESS, else, EFI_UNSUPPORTED\r
  or other error returned by OpenProtocol.\r
\r
  @param  This                 Protocol instance pointer.\r
  @param  ControllerHandle     Handle of device to test.\r
  @param  RemainingDevicePath  Optional parameter use to pick a specific child\r
                               device to start.\r
\r
  @retval EFI_SUCCESS          This driver supports this device.\r
  @retval EFI_UNSUPPORTED      Debug Port device is not supported.\r
  @retval EFI_OUT_OF_RESOURCES Fails to allocate memory for device.\r
  @retval others               Some error occurs.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
DebugPortSupported (\r
  IN EFI_DRIVER_BINDING_PROTOCOL    *This,\r
  IN EFI_HANDLE                     ControllerHandle,\r
  IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath\r
  )\r
{\r
  EFI_STATUS                Status;\r
  EFI_DEVICE_PATH_PROTOCOL  *Dp1;\r
  EFI_DEVICE_PATH_PROTOCOL  *Dp2;\r
  EFI_SERIAL_IO_PROTOCOL    *SerialIo;\r
  EFI_DEBUGPORT_PROTOCOL    *DebugPortInterface;\r
  EFI_HANDLE                TempHandle;\r
\r
  //\r
  // Check to see that there's not a debugport protocol already published,\r
  // since only one standard UART serial port could be supported by this driver.\r
  //\r
  if (gBS->LocateProtocol (&gEfiDebugPortProtocolGuid, NULL, (VOID **) &DebugPortInterface) != EFI_NOT_FOUND) {\r
    return EFI_UNSUPPORTED;\r
  }\r
  //\r
  // Read DebugPort variable to determine debug port selection and parameters\r
  //\r
  GetDebugPortVariable ();\r
\r
  if (mDebugPortDevice.DebugPortVariable != NULL) {\r
    //\r
    // There's a DEBUGPORT variable, so do LocateDevicePath and check to see if\r
    // the closest matching handle matches the controller handle, and if it does,\r
    // check to see that the remaining device path has the DebugPort GUIDed messaging\r
    // device path only.  Otherwise, it's a mismatch and EFI_UNSUPPORTED is returned.\r
    //\r
    Dp1 = DuplicateDevicePath ((EFI_DEVICE_PATH_PROTOCOL *) mDebugPortDevice.DebugPortVariable);\r
    if (Dp1 == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    Dp2 = Dp1;\r
\r
    Status = gBS->LocateDevicePath (\r
                    &gEfiSerialIoProtocolGuid,\r
                    &Dp2,\r
                    &TempHandle\r
                    );\r
\r
    if (Status == EFI_SUCCESS && TempHandle != ControllerHandle) {\r
      Status = EFI_UNSUPPORTED;\r
    }\r
\r
    if (Status == EFI_SUCCESS &&\r
        (Dp2->Type != MESSAGING_DEVICE_PATH ||\r
         Dp2->SubType != MSG_VENDOR_DP ||\r
         *((UINT16 *) Dp2->Length) != sizeof (DEBUGPORT_DEVICE_PATH))) {\r
\r
      Status = EFI_UNSUPPORTED;\r
    }\r
\r
    if (Status == EFI_SUCCESS && !CompareGuid (&gEfiDebugPortDevicePathGuid, (GUID *) (Dp2 + 1))) {\r
      Status = EFI_UNSUPPORTED;\r
    }\r
\r
    FreePool (Dp1);\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
  }\r
\r
  Status = gBS->OpenProtocol (\r
                  ControllerHandle,\r
                  &gEfiSerialIoProtocolGuid,\r
                  (VOID **) &SerialIo,\r
                  This->DriverBindingHandle,\r
                  ControllerHandle,\r
                  EFI_OPEN_PROTOCOL_BY_DRIVER | EFI_OPEN_PROTOCOL_EXCLUSIVE\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  gBS->CloseProtocol (\r
        ControllerHandle,\r
        &gEfiSerialIoProtocolGuid,\r
        This->DriverBindingHandle,\r
        ControllerHandle\r
        );\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Binds exclusively to serial io on the controller handle, Produces DebugPort\r
  protocol and DevicePath on new handle.\r
\r
  @param  This                 Protocol instance pointer.\r
  @param  ControllerHandle     Handle of device to bind driver to.\r
  @param  RemainingDevicePath  Optional parameter use to pick a specific child\r
                               device to start.\r
\r
  @retval EFI_SUCCESS          This driver is added to ControllerHandle.\r
  @retval EFI_OUT_OF_RESOURCES Fails to allocate memory for device.\r
  @retval others               Some error occurs.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
DebugPortStart (\r
  IN EFI_DRIVER_BINDING_PROTOCOL    *This,\r
  IN EFI_HANDLE                     ControllerHandle,\r
  IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath\r
  )\r
{\r
  EFI_STATUS                Status;\r
  DEBUGPORT_DEVICE_PATH     DebugPortDP;\r
  EFI_DEVICE_PATH_PROTOCOL  EndDP;\r
  EFI_DEVICE_PATH_PROTOCOL  *Dp1;\r
\r
  Status = gBS->OpenProtocol (\r
                  ControllerHandle,\r
                  &gEfiSerialIoProtocolGuid,\r
                  (VOID **) &mDebugPortDevice.SerialIoBinding,\r
                  This->DriverBindingHandle,\r
                  ControllerHandle,\r
                  EFI_OPEN_PROTOCOL_BY_DRIVER | EFI_OPEN_PROTOCOL_EXCLUSIVE\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  mDebugPortDevice.SerialIoDeviceHandle = ControllerHandle;\r
\r
  //\r
  // Initialize the Serial Io interface...\r
  //\r
  Status = mDebugPortDevice.SerialIoBinding->SetAttributes (\r
                                                mDebugPortDevice.SerialIoBinding,\r
                                                mDebugPortDevice.BaudRate,\r
                                                mDebugPortDevice.ReceiveFifoDepth,\r
                                                mDebugPortDevice.Timeout,\r
                                                mDebugPortDevice.Parity,\r
                                                mDebugPortDevice.DataBits,\r
                                                mDebugPortDevice.StopBits\r
                                                );\r
  if (EFI_ERROR (Status)) {\r
    mDebugPortDevice.BaudRate          = 0;\r
    mDebugPortDevice.Parity            = DefaultParity;\r
    mDebugPortDevice.DataBits          = 0;\r
    mDebugPortDevice.StopBits          = DefaultStopBits;\r
    mDebugPortDevice.ReceiveFifoDepth  = 0;\r
    Status = mDebugPortDevice.SerialIoBinding->SetAttributes (\r
                                                  mDebugPortDevice.SerialIoBinding,\r
                                                  mDebugPortDevice.BaudRate,\r
                                                  mDebugPortDevice.ReceiveFifoDepth,\r
                                                  mDebugPortDevice.Timeout,\r
                                                  mDebugPortDevice.Parity,\r
                                                  mDebugPortDevice.DataBits,\r
                                                  mDebugPortDevice.StopBits\r
                                                  );\r
    if (EFI_ERROR (Status)) {\r
      gBS->CloseProtocol (\r
            ControllerHandle,\r
            &gEfiSerialIoProtocolGuid,\r
            This->DriverBindingHandle,\r
            ControllerHandle\r
            );\r
      return Status;\r
    }\r
  }\r
\r
  mDebugPortDevice.SerialIoBinding->Reset (mDebugPortDevice.SerialIoBinding);\r
\r
  //\r
  // Create device path instance for DebugPort\r
  //\r
  DebugPortDP.Header.Type     = MESSAGING_DEVICE_PATH;\r
  DebugPortDP.Header.SubType  = MSG_VENDOR_DP;\r
  SetDevicePathNodeLength (&(DebugPortDP.Header), sizeof (DebugPortDP));\r
  CopyGuid (&DebugPortDP.Guid, &gEfiDebugPortDevicePathGuid);\r
\r
  Dp1 = DevicePathFromHandle (ControllerHandle);\r
  if (Dp1 == NULL) {\r
    Dp1 = &EndDP;\r
    SetDevicePathEndNode (Dp1);\r
  }\r
\r
  mDebugPortDevice.DebugPortDevicePath = AppendDevicePathNode (Dp1, (EFI_DEVICE_PATH_PROTOCOL *) &DebugPortDP);\r
  if (mDebugPortDevice.DebugPortDevicePath == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
  //\r
  // Publish DebugPort and Device Path protocols\r
  //\r
  Status = gBS->InstallMultipleProtocolInterfaces (\r
                  &mDebugPortDevice.DebugPortDeviceHandle,\r
                  &gEfiDevicePathProtocolGuid,\r
                  mDebugPortDevice.DebugPortDevicePath,\r
                  &gEfiDebugPortProtocolGuid,\r
                  &mDebugPortDevice.DebugPortInterface,\r
                  NULL\r
                  );\r
\r
  if (EFI_ERROR (Status)) {\r
    gBS->CloseProtocol (\r
          ControllerHandle,\r
          &gEfiSerialIoProtocolGuid,\r
          This->DriverBindingHandle,\r
          ControllerHandle\r
          );\r
    return Status;\r
  }\r
  //\r
  // Connect debugport child to serial io\r
  //\r
  Status = gBS->OpenProtocol (\r
                  ControllerHandle,\r
                  &gEfiSerialIoProtocolGuid,\r
                  (VOID **) &mDebugPortDevice.SerialIoBinding,\r
                  This->DriverBindingHandle,\r
                  mDebugPortDevice.DebugPortDeviceHandle,\r
                  EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER\r
                  );\r
\r
  if (EFI_ERROR (Status)) {\r
    gBS->CloseProtocol (\r
          ControllerHandle,\r
          &gEfiSerialIoProtocolGuid,\r
          This->DriverBindingHandle,\r
          ControllerHandle\r
          );\r
    return Status;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Stop this driver on ControllerHandle by removing Serial IO protocol on\r
  the ControllerHandle.\r
\r
  @param  This              Protocol instance pointer.\r
  @param  ControllerHandle  Handle of device to stop driver on\r
  @param  NumberOfChildren  Number of Handles in ChildHandleBuffer. If number of\r
                            children is zero stop the entire bus driver.\r
  @param  ChildHandleBuffer List of Child Handles to Stop.\r
\r
  @retval EFI_SUCCESS       This driver is removed ControllerHandle.\r
  @retval other             This driver was not removed from this device.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
DebugPortStop (\r
  IN  EFI_DRIVER_BINDING_PROTOCOL    *This,\r
  IN  EFI_HANDLE                     ControllerHandle,\r
  IN  UINTN                          NumberOfChildren,\r
  IN  EFI_HANDLE                     *ChildHandleBuffer\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  if (NumberOfChildren == 0) {\r
    //\r
    // Close the bus driver\r
    //\r
    gBS->CloseProtocol (\r
          ControllerHandle,\r
          &gEfiSerialIoProtocolGuid,\r
          This->DriverBindingHandle,\r
          ControllerHandle\r
          );\r
\r
    mDebugPortDevice.SerialIoBinding = NULL;\r
\r
    gBS->CloseProtocol (\r
          ControllerHandle,\r
          &gEfiDevicePathProtocolGuid,\r
          This->DriverBindingHandle,\r
          ControllerHandle\r
          );\r
\r
    FreePool (mDebugPortDevice.DebugPortDevicePath);\r
\r
    return EFI_SUCCESS;\r
  } else {\r
    //\r
    // Disconnect SerialIo child handle\r
    //\r
    Status = gBS->CloseProtocol (\r
                    mDebugPortDevice.SerialIoDeviceHandle,\r
                    &gEfiSerialIoProtocolGuid,\r
                    This->DriverBindingHandle,\r
                    mDebugPortDevice.DebugPortDeviceHandle\r
                    );\r
\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
    //\r
    // Unpublish our protocols (DevicePath, DebugPort)\r
    //\r
    Status = gBS->UninstallMultipleProtocolInterfaces (\r
                    mDebugPortDevice.DebugPortDeviceHandle,\r
                    &gEfiDevicePathProtocolGuid,\r
                    mDebugPortDevice.DebugPortDevicePath,\r
                    &gEfiDebugPortProtocolGuid,\r
                    &mDebugPortDevice.DebugPortInterface,\r
                    NULL\r
                    );\r
\r
    if (EFI_ERROR (Status)) {\r
      gBS->OpenProtocol (\r
            ControllerHandle,\r
            &gEfiSerialIoProtocolGuid,\r
            (VOID **) &mDebugPortDevice.SerialIoBinding,\r
            This->DriverBindingHandle,\r
            mDebugPortDevice.DebugPortDeviceHandle,\r
            EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER\r
            );\r
    } else {\r
      mDebugPortDevice.DebugPortDeviceHandle = NULL;\r
    }\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  DebugPort protocol member function.  Calls SerialIo:GetControl to flush buffer.\r
  We cannot call SerialIo:SetAttributes because it uses pool services, which use\r
  locks, which affect TPL, so it's not interrupt context safe or re-entrant.\r
  SerialIo:Reset() calls SetAttributes, so it can't be used either.\r
\r
  The port itself should be fine since it was set up during initialization.\r
\r
  @param  This              Protocol instance pointer.\r
\r
  @return EFI_SUCCESS       Always.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
DebugPortReset (\r
  IN EFI_DEBUGPORT_PROTOCOL   *This\r
  )\r
{\r
  UINTN             BufferSize;\r
  UINTN             BitBucket;\r
\r
  while (This->Poll (This) == EFI_SUCCESS) {\r
    BufferSize = 1;\r
    This->Read (This, 0, &BufferSize, &BitBucket);\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  DebugPort protocol member function.  Calls SerialIo:Read() after setting\r
  if it's different than the last SerialIo access.\r
\r
  @param  This                Pointer to DebugPort protocol.\r
  @param  Timeout             Timeout value.\r
  @param  BufferSize          On input, the size of Buffer.\r
                              On output, the amount of data actually written.\r
  @param  Buffer              Pointer to buffer to read.\r
\r
  @retval EFI_SUCCESS\r
  @retval others\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
DebugPortRead (\r
  IN EFI_DEBUGPORT_PROTOCOL   *This,\r
  IN UINT32                   Timeout,\r
  IN OUT UINTN                *BufferSize,\r
  IN VOID                     *Buffer\r
  )\r
{\r
  DEBUGPORT_DEVICE  *DebugPortDevice;\r
  UINTN             LocalBufferSize;\r
  EFI_STATUS        Status;\r
  UINT8             *BufferPtr;\r
\r
  DebugPortDevice = DEBUGPORT_DEVICE_FROM_THIS (This);\r
  BufferPtr       = Buffer;\r
  LocalBufferSize = *BufferSize;\r
\r
  do {\r
    Status = DebugPortDevice->SerialIoBinding->Read (\r
                                                DebugPortDevice->SerialIoBinding,\r
                                                &LocalBufferSize,\r
                                                BufferPtr\r
                                                );\r
    if (Status == EFI_TIMEOUT) {\r
      if (Timeout > DEBUGPORT_UART_DEFAULT_TIMEOUT) {\r
        Timeout -= DEBUGPORT_UART_DEFAULT_TIMEOUT;\r
      } else {\r
        Timeout = 0;\r
      }\r
    } else if (EFI_ERROR (Status)) {\r
      break;\r
    }\r
\r
    BufferPtr += LocalBufferSize;\r
    LocalBufferSize = *BufferSize - (BufferPtr - (UINT8 *) Buffer);\r
  } while (LocalBufferSize != 0 && Timeout > 0);\r
\r
  *BufferSize = (UINTN) (BufferPtr - (UINT8 *) Buffer);\r
\r
  return Status;\r
}\r
\r
/**\r
  DebugPort protocol member function.  Calls SerialIo:Write() Writes 8 bytes at\r
  a time and does a GetControl between 8 byte writes to help insure reads are\r
  interspersed This is poor-man's flow control.\r
\r
  @param  This                Pointer to DebugPort protocol.\r
  @param  Timeout             Timeout value.\r
  @param  BufferSize          On input, the size of Buffer.\r
                              On output, the amount of data actually written.\r
  @param  Buffer              Pointer to buffer to read.\r
\r
  @retval EFI_SUCCESS         The data was written.\r
  @retval others              Fails when writting datas to debug port device.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
DebugPortWrite (\r
  IN EFI_DEBUGPORT_PROTOCOL   *This,\r
  IN UINT32                   Timeout,\r
  IN OUT UINTN                *BufferSize,\r
  OUT VOID                    *Buffer\r
  )\r
{\r
  DEBUGPORT_DEVICE  *DebugPortDevice;\r
  UINTN             Position;\r
  UINTN             WriteSize;\r
  EFI_STATUS        Status;\r
  UINT32            SerialControl;\r
\r
  Status          = EFI_SUCCESS;\r
  DebugPortDevice = DEBUGPORT_DEVICE_FROM_THIS (This);\r
\r
  WriteSize       = 8;\r
  for (Position = 0; Position < *BufferSize && !EFI_ERROR (Status); Position += WriteSize) {\r
    DebugPortDevice->SerialIoBinding->GetControl (\r
                                        DebugPortDevice->SerialIoBinding,\r
                                        &SerialControl\r
                                        );\r
    if (*BufferSize - Position < 8) {\r
      WriteSize = *BufferSize - Position;\r
    }\r
\r
    Status = DebugPortDevice->SerialIoBinding->Write (\r
                                                DebugPortDevice->SerialIoBinding,\r
                                                &WriteSize,\r
                                                &((UINT8 *) Buffer)[Position]\r
                                                );\r
  }\r
\r
  *BufferSize = Position;\r
  return Status;\r
}\r
\r
/**\r
  DebugPort protocol member function.  Calls SerialIo:Write() after setting\r
  if it's different than the last SerialIo access.\r
\r
  @param  This                Pointer to DebugPort protocol.\r
\r
  @retval EFI_SUCCESS         At least 1 character is ready to be read from\r
                              the DebugPort interface.\r
  @retval EFI_NOT_READY       There are no characters ready to read from the\r
                              DebugPort interface\r
  @retval EFI_DEVICE_ERROR    A hardware failure occured... (from SerialIo)\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
DebugPortPoll (\r
  IN EFI_DEBUGPORT_PROTOCOL   *This\r
  )\r
{\r
  EFI_STATUS        Status;\r
  UINT32            SerialControl;\r
  DEBUGPORT_DEVICE  *DebugPortDevice;\r
\r
  DebugPortDevice = DEBUGPORT_DEVICE_FROM_THIS (This);\r
\r
  Status = DebugPortDevice->SerialIoBinding->GetControl (\r
                                              DebugPortDevice->SerialIoBinding,\r
                                              &SerialControl\r
                                              );\r
\r
  if (!EFI_ERROR (Status)) {\r
    if ((SerialControl & EFI_SERIAL_INPUT_BUFFER_EMPTY) != 0) {\r
      Status = EFI_NOT_READY;\r
    } else {\r
      Status = EFI_SUCCESS;\r
    }\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Unload function that is registered in the LoadImage protocol.  It un-installs\r
  protocols produced and deallocates pool used by the driver.  Called by the core\r
  when unloading the driver.\r
\r
  @param  ImageHandle\r
\r
  @retval EFI_SUCCESS     Unload Debug Port driver successfully.\r
  @retval EFI_ABORTED     Serial IO is still binding.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
ImageUnloadHandler (\r
  EFI_HANDLE ImageHandle\r
  )\r
{\r
  if (mDebugPortDevice.SerialIoBinding != NULL) {\r
    return EFI_ABORTED;\r
  }\r
\r
  //\r
  // Clean up allocations\r
  //\r
  if (mDebugPortDevice.DebugPortVariable != NULL) {\r
    FreePool (mDebugPortDevice.DebugPortVariable);\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r