/** @file
  This file implements the Graphics Output protocol for Arm platforms

  Copyright (c) 2011 - 2020, Arm Limited. All rights reserved.<BR>
  Copyright (c) 2022 Rockchip Electronics Co. Ltd.

  SPDX-License-Identifier: BSD-2-Clause-Patent

**/

#include <PiDxe.h>
#include <Library/BaseMemoryLib.h>
#include <Library/DevicePathLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiRuntimeServicesTableLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/DrmModes.h>
#include <Library/MediaBusFormat.h>

#include <Guid/GlobalVariable.h>

#include "LcdGraphicsOutputDxe.h"

//to delete
#include <Library/AnalogixDpLib.h>

//
// Global variables
//
STATIC LIST_ENTRY mDisplayStateList;

//STATIC DISPLAY_PROTOCOL mDisplayProtocol;

typedef enum {
  ROCKCHIP_VOP2_CLUSTER0 = 0,
  ROCKCHIP_VOP2_CLUSTER1,
  ROCKCHIP_VOP2_ESMART0,
  ROCKCHIP_VOP2_ESMART1,
  ROCKCHIP_VOP2_SMART0,
  ROCKCHIP_VOP2_SMART1,
  ROCKCHIP_VOP2_CLUSTER2,
  ROCKCHIP_VOP2_CLUSTER3,
  ROCKCHIP_VOP2_ESMART2,
  ROCKCHIP_VOP2_ESMART3,
  ROCKCHIP_VOP2_LAYER_MAX,
} VOP2_LAYER_PHY_ID;

STATIC OVER_SCAN mDefaultOverScanParas = {
  .LeftMargin = 100,
  .RightMargin = 100,
  .TopMargin = 100,
  .BottomMargin = 100
};

typedef struct {
  UINT32                      Resolution;
  UINT32                      Sync;
  UINT32                      BackPorch;
  UINT32                      FrontPorch;
} SCAN_TIMINGS;

typedef struct {
  UINT32                      CrtcId;
  UINT32                      OscFreq;
  SCAN_TIMINGS                Horizontal;
  SCAN_TIMINGS                Vertical;
  UINT32                      HsyncActive;
  UINT32                      VsyncActive;
  UINT32                      DenActive;
  UINT32                      ClkActive;
  UINT32                      VpsConfigModeID;
} DISPLAY_MODE;

STATIC DISPLAY_MODE mDisplayModes[] = {
  {
    // eDP : 1536 x 2048
    2,
    200000000,
    {1536, 16, 12, 48},
    {2048, 4, 8, 8},
    0,
    0,
    0,
    0,
    1
  },
  {
    // eDP : 1920 x 1080
    2,
    148500000,
    {1920, 32, 200, 48},
    {1080, 5, 37, 3},
    0,
    0,
    0,
    0,
    1
  },
};

BOOLEAN mDisplayInitialized = FALSE;

STATIC CONST UINT32 mMaxMode = ARRAY_SIZE (mDisplayModes);

LCD_INSTANCE mLcdTemplate = {
  LCD_INSTANCE_SIGNATURE,
  NULL, // Handle
  { // ModeInfo
    0, // Version
    0, // HorizontalResolution
    0, // VerticalResolution
    PixelBltOnly, // PixelFormat
    { 0 }, // PixelInformation
    0, // PixelsPerScanLine
  },
  {
    0, // MaxMode;
    0, // Mode;
    NULL, // Info;
    0, // SizeOfInfo;
    0, // FrameBufferBase;
    0 // FrameBufferSize;
  },
  { // Gop
    LcdGraphicsQueryMode,  // QueryMode
    LcdGraphicsSetMode,    // SetMode
    LcdGraphicsBlt,        // Blt
    NULL                     // *Mode
  },
  { // DevicePath
    {
      {
        HARDWARE_DEVICE_PATH, HW_VENDOR_DP,
        {
          (UINT8)(sizeof (VENDOR_DEVICE_PATH)),
          (UINT8)((sizeof (VENDOR_DEVICE_PATH)) >> 8)
        },
      },
      // Hardware Device Path for Lcd
      EFI_CALLER_ID_GUID // Use the driver's GUID
    },

    {
      END_DEVICE_PATH_TYPE,
      END_ENTIRE_DEVICE_PATH_SUBTYPE,
      {
        sizeof (EFI_DEVICE_PATH_PROTOCOL),
        0
      }
    }
  },
  (EFI_EVENT)NULL, // ExitBootServicesEvent
};

EFI_STATUS
LcdInstanceContructor (
  OUT LCD_INSTANCE** NewInstance
  )
{
  LCD_INSTANCE* Instance;

  Instance = AllocateCopyPool (sizeof (LCD_INSTANCE), &mLcdTemplate);
  if (Instance == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }

  Instance->Gop.Mode          = &Instance->Mode;
  Instance->Gop.Mode->MaxMode = mMaxMode;
  Instance->Mode.Info         = &Instance->ModeInfo;

  *NewInstance = Instance;
  return EFI_SUCCESS;
}

//
// Function Definitions
//

EFIAPI
EFI_STATUS
DisplayGetTiming (
  OUT DISPLAY_STATE                        *DisplayState
  )
{
  DRM_DISPLAY_MODE *Mode = &DisplayState->ConnectorState.DisplayMode;
  UINT32 ModeNumber = DisplayState->ModeNumber;
  UINT32 HActive, VActive, PixelClock;
  UINT32 HFrontPorch, HBackPorch, HSyncLen;
  UINT32 VFrontPorch, VBackPorch, VSyncLen;
  UINT32 Flags = 0;
  UINT32 Val = 0;

  HActive = mDisplayModes[ModeNumber].Horizontal.Resolution;
  VActive = mDisplayModes[ModeNumber].Vertical.Resolution;
  PixelClock = mDisplayModes[ModeNumber].OscFreq;
  HSyncLen = mDisplayModes[ModeNumber].Horizontal.Sync;
  HFrontPorch = mDisplayModes[ModeNumber].Horizontal.FrontPorch;
  HBackPorch = mDisplayModes[ModeNumber].Horizontal.BackPorch;
  VSyncLen = mDisplayModes[ModeNumber].Vertical.Sync;
  VFrontPorch = mDisplayModes[ModeNumber].Vertical.FrontPorch;
  VBackPorch = mDisplayModes[ModeNumber].Vertical.BackPorch;

  Val = mDisplayModes[ModeNumber].HsyncActive ? DRM_MODE_FLAG_PHSYNC : DRM_MODE_FLAG_NHSYNC;
  Flags |= Val;
  Val = mDisplayModes[ModeNumber].VsyncActive ? DRM_MODE_FLAG_PVSYNC : DRM_MODE_FLAG_NVSYNC;
  Flags |= Val;
  Val = mDisplayModes[ModeNumber].ClkActive ? DRM_MODE_FLAG_PPIXDATA : 0;
  Flags |= Val;

  Mode->HDisplay = HActive;
  Mode->HSyncStart = Mode->HDisplay + HFrontPorch;
  Mode->HSyncEnd = Mode->HSyncStart + HSyncLen;
  Mode->HTotal = Mode->HSyncEnd + HBackPorch;

  Mode->VDisplay = VActive;
  Mode->VSyncStart = Mode->VDisplay + VFrontPorch;
  Mode->VSyncEnd = Mode->VSyncStart + VSyncLen;
  Mode->VTotal = Mode->VSyncEnd + VBackPorch;

  Mode->Clock = PixelClock / 1000;
  Mode->Flags = Flags;

  /* not to set fix --- todo */
  Mode->VScan = 0;

  return EFI_SUCCESS;
}

STATIC
UINT32
DisplayBppConvert (
  IN LCD_BPP             LcdBpp
  )
{
  UINT32                 DisplayBpp;

  switch (LcdBpp) {
  case LcdBitsPerPixel_24:
    DisplayBpp = 32;
    break;
  default:
    DisplayBpp = 32;
    break;
  }

  return DisplayBpp;
}

EFI_STATUS
InitializeDisplay (
  IN LCD_INSTANCE* Instance
  )
{
  EFI_STATUS                  Status;
  EFI_PHYSICAL_ADDRESS        VramBaseAddress;
  UINTN                       VramSize;
  DISPLAY_STATE               *StateInterate;
  CRTC_STATE                  *CrtcState;
  CONNECTOR_STATE             *ConnectorState;
  DRM_DISPLAY_MODE            *Mode;
  ROCKCHIP_CRTC_PROTOCOL      *Crtc;
  LCD_BPP                     LcdBpp;
  ROCKCHIP_CONNECTOR_PROTOCOL *Connector;

  Status = DisplaySetFramebuffer (&VramBaseAddress, &VramSize);
  if (EFI_ERROR (Status)) {
    goto EXIT;
  }

  // Setup all the relevant mode information
  Instance->Gop.Mode->SizeOfInfo      = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);
  Instance->Gop.Mode->FrameBufferBase = VramBaseAddress;

  LIST_FOR_EACH_ENTRY(StateInterate, &mDisplayStateList, ListHead) {
    if (StateInterate->IsEnable) {
      Crtc = (ROCKCHIP_CRTC_PROTOCOL *)StateInterate->CrtcState.Crtc;
      Connector = (ROCKCHIP_CONNECTOR_PROTOCOL *)StateInterate->ConnectorState.Connector;
      CrtcState = &StateInterate->CrtcState;
      ConnectorState = &StateInterate->ConnectorState;
      Mode = &StateInterate->ConnectorState.DisplayMode;

      //to delete
      AnalogixDpConnectorInit (StateInterate);
      if (Connector && Connector->Init)
        Status = Connector->Init(Connector, StateInterate);

      /* move to panel protocol --- todo */
      DisplayGetTiming (StateInterate);

      DEBUG ((DEBUG_INIT, "[INIT]detailed mode clock %u kHz, flags[%x]\n"
                          "          H: %04d %04d %04d %04d\n"
                          "          V: %04d %04d %04d %04d\n"
                          "      bus_format: %x\n",
                          Mode->Clock, Mode->Flags,
                          Mode->HDisplay, Mode->HSyncStart,
                          Mode->HSyncEnd, Mode->HTotal,
                          Mode->VDisplay, Mode->VSyncStart,
                          Mode->VSyncEnd, Mode->VTotal,
                          ConnectorState->BusFormat));

      Status = DisplaySetCrtcInfo(Mode, CRTC_INTERLACE_HALVE_V);
      if (EFI_ERROR (Status)) {
        goto EXIT;
      }

      if (Crtc && Crtc->Init) {
        Status = Crtc->Init (Crtc, StateInterate);
        if (EFI_ERROR (Status)) {
          goto EXIT;
        }
      }

      /* adapt to uefi display architecture */
      CrtcState->Format = ROCKCHIP_FMT_ARGB8888;
      CrtcState->SrcW = ConnectorState->DisplayMode.HDisplay;
      CrtcState->SrcH = ConnectorState->DisplayMode.VDisplay;
      CrtcState->SrcX = 0;
      CrtcState->SrcY = 0;
      CrtcState->CrtcW = ConnectorState->DisplayMode.HDisplay;
      CrtcState->CrtcH = ConnectorState->DisplayMode.VDisplay;
      CrtcState->CrtcX = 0;
      CrtcState->CrtcY = 0;
      CrtcState->YMirror = 0;
      CrtcState->RBSwap = 0;

      LcdGraphicsGetBpp (StateInterate->ModeNumber, &LcdBpp);
      CrtcState->XVirtual = ALIGN(CrtcState->SrcW * DisplayBppConvert (LcdBpp), 32) >> 5;
      CrtcState->DMAAddress = (UINT32)VramBaseAddress;
    }
  }

  // Set the flag before changing the mode, to avoid infinite loops
  mDisplayInitialized = TRUE;

  // All is ok, so don't deal with any errors
  goto EXIT;

EXIT:
  return Status;
}

STATIC
EFI_STATUS
DisplayPreInit (
  IN LCD_INSTANCE* Instance
  )
{
  EFI_STATUS                  Status;
  DISPLAY_STATE               *StateInterate;
  ROCKCHIP_CRTC_PROTOCOL      *Crtc;
  ROCKCHIP_CONNECTOR_PROTOCOL *Connector;

  LIST_FOR_EACH_ENTRY(StateInterate, &mDisplayStateList, ListHead) {
    if (StateInterate->IsEnable) {
      Crtc = (ROCKCHIP_CRTC_PROTOCOL*)StateInterate->CrtcState.Crtc;
      Connector = (ROCKCHIP_CONNECTOR_PROTOCOL *)StateInterate->ConnectorState.Connector;

      //to delete
      AnalogixDpConnectorPreInit(StateInterate);

      if (Connector && Connector->Preinit)
        Status = Connector->Preinit(Connector, StateInterate);

      if (Crtc && Crtc->Preinit) {
        Status = Crtc->Preinit(Crtc, StateInterate);
        if (EFI_ERROR (Status)) {
          goto EXIT;
        }
      }
    }
  }

EXIT:
  return Status;
}

EFI_STATUS
EFIAPI
LcdGraphicsOutputDxeInitialize (
  IN EFI_HANDLE         ImageHandle,
  IN EFI_SYSTEM_TABLE   *SystemTable
  )
{
  EFI_STATUS  Status;
  LCD_INSTANCE* Instance;
  DISPLAY_STATE *DisplayState;
  DISPLAY_MODE *Mode;
  ROCKCHIP_CRTC_PROTOCOL *Crtc;
  INT32 i = 0;
  UINT32 HorizontalResolution  = PcdGet32 (PcdVideoHorizontalResolution);
  UINT32 VerticalResolution    = PcdGet32 (PcdVideoVerticalResolution);

  Status = LcdInstanceContructor (&Instance);
  if (EFI_ERROR (Status)) {
    goto EXIT;
  }

  // Install the Graphics Output Protocol and the Device Path
  Status = gBS->InstallMultipleProtocolInterfaces (
                  &Instance->Handle,
                  &gEfiGraphicsOutputProtocolGuid,
                  &Instance->Gop,
                  &gEfiDevicePathProtocolGuid,
                  &Instance->DevicePath,
                  NULL
                  );

  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "LcdGraphicsOutputDxeInitialize: Can not install the protocol. Exit Status=%r\n", Status));
    goto EXIT;
  }

  InitializeListHead (&mDisplayStateList);

  for (i = 0; i < mMaxMode; i++) {
    Mode = &mDisplayModes[i];

    DisplayState = AllocatePool (sizeof(DISPLAY_STATE));
    InitializeListHead (&DisplayState->ListHead);

    /* adapt to UEFI architecture */
    DisplayState->ModeNumber = i;

    Status = gBS->LocateProtocol (&gRockchipCrtcProtocolGuid, NULL,
                                  (VOID **) &DisplayState->CrtcState.Crtc);
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_ERROR, "Can not locate the RockchipCrtcProtocol. Exit Status=%r\n", Status));
      return EFI_INVALID_PARAMETER;
    }
    Crtc = (ROCKCHIP_CRTC_PROTOCOL*)DisplayState->CrtcState.Crtc;
    Crtc->Vps = Crtc->GetVps (Crtc, Mode->VpsConfigModeID);
    if (!Crtc->Vps) {
      DEBUG ((DEBUG_ERROR, "Can not get vps config. Exit Status=%r\n", EFI_INVALID_PARAMETER));
      return EFI_INVALID_PARAMETER;
    }

    DisplayState->CrtcState.CrtcID = Mode->CrtcId;

    Status = gBS->LocateProtocol (&gRockchipConnectorProtocolGuid, NULL,
                                  (VOID **) &DisplayState->ConnectorState.Connector);
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_ERROR, "Can not locate the RockchipConnectorProtocol. Exit Status=%r\n", Status));
      //to delete
      //return EFI_INVALID_PARAMETER;
    }

    DisplayState->ConnectorState.OverScan.LeftMargin = mDefaultOverScanParas.LeftMargin;
    DisplayState->ConnectorState.OverScan.RightMargin = mDefaultOverScanParas.RightMargin;
    DisplayState->ConnectorState.OverScan.TopMargin = mDefaultOverScanParas.TopMargin;
    DisplayState->ConnectorState.OverScan.BottomMargin = mDefaultOverScanParas.BottomMargin;

    /* set MEDIA_BUS_FMT_RBG888_1X24 by default when using panel */
    /* move to panel driver later -- todo*/
    DisplayState->ConnectorState.BusFormat = MEDIA_BUS_FMT_RBG888_1X24;

    /* add BCSH data if needed --- todo */
    DisplayState->ConnectorState.DispInfo = NULL;

    if (Mode->Horizontal.Resolution == HorizontalResolution && Mode->Vertical.Resolution == VerticalResolution)
      DisplayState->IsEnable = TRUE;
    else
      DisplayState->IsEnable = FALSE;

    InsertTailList (&mDisplayStateList, &DisplayState->ListHead);
  }

  Status = DisplayPreInit (Instance);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "LcdGraphicsOutputDxeInitialize: DisplayPreInit fail. Exit Status=%r\n", Status));
    goto EXIT_ERROR_UNINSTALL_PROTOCOL;
  }

  // Register for an ExitBootServicesEvent
  // When ExitBootServices starts, this function will make sure that the
  // graphics driver shuts down properly, i.e. it will free up all
  // allocated memory and perform any necessary hardware re-configuration.
  Status = gBS->CreateEvent (
                  EVT_SIGNAL_EXIT_BOOT_SERVICES,
                  TPL_NOTIFY,
                  LcdGraphicsExitBootServicesEvent,
                  NULL,
                  &Instance->ExitBootServicesEvent
                  );

  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "LcdGraphicsOutputDxeInitialize: Can not install the ExitBootServicesEvent handler. Exit Status=%r\n", Status));
    goto EXIT_ERROR_UNINSTALL_PROTOCOL;
  }

  // To get here, everything must be fine, so just exit
  goto EXIT;

EXIT_ERROR_UNINSTALL_PROTOCOL:
  // The following function could return an error message,
  // however, to get here something must have gone wrong already,
  // so preserve the original error, i.e. don't change
  // the Status variable, even it fails to uninstall the protocol.
  gBS->UninstallMultipleProtocolInterfaces (
         Instance->Handle,
         &gEfiGraphicsOutputProtocolGuid,
         &Instance->Gop, // Uninstall Graphics Output protocol
         &gEfiDevicePathProtocolGuid,
         &Instance->DevicePath,     // Uninstall device path
         NULL
         );

EXIT:
  return Status;
}

/** This function should be called
  on Event: ExitBootServices
  to free up memory, stop the driver
  and uninstall the protocols
**/
VOID
LcdGraphicsExitBootServicesEvent (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  // By default, this PCD is FALSE. But if a platform starts a predefined OS
  // that does not use a framebuffer then we might want to disable the display
  // controller to avoid to display corrupted information on the screen.
  if (FeaturePcdGet (PcdGopDisableOnExitBootServices)) {
    // Turn-off the Display controller
  }
}

/** GraphicsOutput Protocol function, mapping to
  EFI_GRAPHICS_OUTPUT_PROTOCOL.QueryMode
**/
EFI_STATUS
EFIAPI
LcdGraphicsQueryMode (
  IN EFI_GRAPHICS_OUTPUT_PROTOCOL            *This,
  IN UINT32                                  ModeNumber,
  OUT UINTN                                  *SizeOfInfo,
  OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION   **Info
  )
{
  EFI_STATUS Status;
  LCD_INSTANCE *Instance;

  Instance = LCD_INSTANCE_FROM_GOP_THIS (This);

  // Setup the hardware if not already done
  if (!mDisplayInitialized) {
    Status = InitializeDisplay (Instance);
    if (EFI_ERROR (Status)) {
      goto EXIT;
    }
  }

  // Error checking
  if ((This == NULL) ||
      (Info == NULL) ||
      (SizeOfInfo == NULL) ||
      (ModeNumber >= This->Mode->MaxMode)) {
    DEBUG ((DEBUG_ERROR, "LcdGraphicsQueryMode: ERROR - For mode number %d : Invalid Parameter.\n", ModeNumber));
    Status = EFI_INVALID_PARAMETER;
    goto EXIT;
  }

  *Info = AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION));
  if (*Info == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto EXIT;
  }

  *SizeOfInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);

  (*Info)->Version = 0;
  (*Info)->HorizontalResolution = mDisplayModes[ModeNumber].Horizontal.Resolution;
  (*Info)->VerticalResolution = mDisplayModes[ModeNumber].Vertical.Resolution;
  (*Info)->PixelsPerScanLine = mDisplayModes[ModeNumber].Horizontal.Resolution;
  (*Info)->PixelFormat = FixedPcdGet32 (PcdLcdPixelFormat);

  return EFI_SUCCESS;

EXIT:
  return Status;
}

/** GraphicsOutput Protocol function, mapping to
  EFI_GRAPHICS_OUTPUT_PROTOCOL.SetMode
**/
EFI_STATUS
EFIAPI
LcdGraphicsSetMode (
  IN EFI_GRAPHICS_OUTPUT_PROTOCOL   *This,
  IN UINT32                         ModeNumber
  )
{
  EFI_STATUS                      Status;
  EFI_GRAPHICS_OUTPUT_BLT_PIXEL   FillColour;
  LCD_INSTANCE*                   Instance;
  LCD_BPP                         Bpp;
  DISPLAY_STATE                   *StateInterate;
  ROCKCHIP_CRTC_PROTOCOL          *Crtc;
  ROCKCHIP_CONNECTOR_PROTOCOL     *Connector;
  //to delete
  struct AnalogixDpDevice *Dp;

  Instance = LCD_INSTANCE_FROM_GOP_THIS (This);

  // Setup the hardware if not already done
  if (!mDisplayInitialized) {
    Status = InitializeDisplay (Instance);
    if (EFI_ERROR (Status)) {
      goto EXIT;
    }
  }

  // Check if this mode is supported
  if (ModeNumber >= This->Mode->MaxMode) {
    DEBUG ((DEBUG_ERROR, "LcdGraphicsSetMode: ERROR - Unsupported mode number %d .\n", ModeNumber));
    Status = EFI_UNSUPPORTED;
    goto EXIT;
  }

  // Update the UEFI mode information
  This->Mode->Mode = ModeNumber;

  Instance->ModeInfo.Version = 0;
  Instance->ModeInfo.HorizontalResolution = mDisplayModes[ModeNumber].Horizontal.Resolution;
  Instance->ModeInfo.VerticalResolution = mDisplayModes[ModeNumber].Vertical.Resolution;
  Instance->ModeInfo.PixelsPerScanLine = mDisplayModes[ModeNumber].Horizontal.Resolution;
  Instance->ModeInfo.PixelFormat = FixedPcdGet32 (PcdLcdPixelFormat);

  Status = LcdGraphicsGetBpp (ModeNumber, &Bpp);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "LcdGraphicsSetMode: ERROR - Couldn't get bytes per pixel, status: %r\n", Status));
    goto EXIT;
  }
  This->Mode->FrameBufferSize =  Instance->ModeInfo.VerticalResolution
                                 *Instance->ModeInfo.PixelsPerScanLine
                                 *GetBytesPerPixel (Bpp);

  LIST_FOR_EACH_ENTRY(StateInterate, &mDisplayStateList, ListHead) {
    if (StateInterate->ModeNumber == ModeNumber && StateInterate->IsEnable) {
      Crtc = (ROCKCHIP_CRTC_PROTOCOL*)StateInterate->CrtcState.Crtc;
      Connector = (ROCKCHIP_CONNECTOR_PROTOCOL *)StateInterate->ConnectorState.Connector;

      if (Crtc && Crtc->SetPlane)
        Crtc->SetPlane (Crtc, StateInterate);

      if (Crtc && Crtc->Enable)
        Crtc->Enable (Crtc, StateInterate);

      if (Connector && Connector->Enable)
        Connector->Enable (Connector, StateInterate);

      //to delete
      Dp = AllocatePool(sizeof(*Dp));
      AnalogixDpConnectorEnable(StateInterate, Dp);
    }
  }

  // The UEFI spec requires that we now clear the visible portions of the
  // output display to black.

  // Set the fill colour to black
  SetMem (&FillColour, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0x0);

  // Fill the entire visible area with the same colour.
  Status = This->Blt (
      This,
      &FillColour,
      EfiBltVideoFill,
      0,
      0,
      0,
      0,
      This->Mode->Info->HorizontalResolution,
      This->Mode->Info->VerticalResolution,
      0
      );

EXIT:
  return Status;
}

EFI_STATUS
EFIAPI
LcdGraphicsGetBpp (
  IN  UINT32                                ModeNumber,
  OUT LCD_BPP*                              Bpp
  )
{
  if (ModeNumber >= mMaxMode) {
    return EFI_INVALID_PARAMETER;
  }

  *Bpp = LcdBitsPerPixel_24;

  return EFI_SUCCESS;
}

UINTN
GetBytesPerPixel (
  IN  LCD_BPP       Bpp
  )
{
  switch (Bpp) {
  case LcdBitsPerPixel_24:
    return 4;

  case LcdBitsPerPixel_16_565:
  case LcdBitsPerPixel_16_555:
  case LcdBitsPerPixel_12_444:
    return 2;

  case LcdBitsPerPixel_8:
  case LcdBitsPerPixel_4:
  case LcdBitsPerPixel_2:
  case LcdBitsPerPixel_1:
    return 1;

  default:
    return 0;
  }
}