ArmMaliDp.c

Go to the documentation of this file.

 
#include <Library/DebugLib.h>
#include <Library/IoLib.h>
#include <Library/LcdHwLib.h>
#include <Library/LcdPlatformLib.h>
#include <Library/MemoryAllocationLib.h>
 
#include "ArmMaliDp.h"
 
// CORE_ID of the MALI DP
STATIC UINT32  mDpDeviceId;
 
STATIC
VOID
LayerGraphicsDisable (
  VOID
  )
{
  MmioAnd32 (DP_BASE + DP_DE_LG_CONTROL, ~DP_DE_LG_ENABLE);
}
 
STATIC
VOID
LayerGraphicsEnable (
  VOID
  )
{
  MmioOr32 (DP_BASE + DP_DE_LG_CONTROL, DP_DE_LG_ENABLE);
}
 
STATIC
VOID
LayerGraphicsSetFrame (
  IN CONST EFI_PHYSICAL_ADDRESS  FrameBaseAddress
  )
{
  // Disable the graphics layer.
  LayerGraphicsDisable ();
 
  // Set up memory address of the data buffer for graphics layer.
  // write lower bits of the address.
  MmioWrite32 (
    DP_BASE + DP_DE_LG_PTR_LOW,
    DP_DE_LG_PTR_LOW_MASK & FrameBaseAddress
    );
 
  // Write higher bits of the address.
  MmioWrite32 (
    DP_BASE + DP_DE_LG_PTR_HIGH,
    (UINT32)(FrameBaseAddress >> DP_DE_LG_PTR_HIGH_SHIFT)
    );
 
  // Enable the graphics layer.
  LayerGraphicsEnable ();
}
 
STATIC
VOID
LayerGraphicsConfig (
  IN CONST EFI_GRAPHICS_PIXEL_FORMAT  UefiGfxPixelFormat,
  IN CONST UINT32                     HRes,
  IN CONST UINT32                     VRes
  )
{
  UINT32  PixelFormat;
 
  // Disable the graphics layer before configuring any settings.
  LayerGraphicsDisable ();
 
  // Setup graphics layer size.
  MmioWrite32 (DP_BASE + DP_DE_LG_IN_SIZE, FRAME_IN_SIZE (HRes, VRes));
 
  // Setup graphics layer composition size.
  MmioWrite32 (DP_BASE + DP_DE_LG_CMP_SIZE, FRAME_CMP_SIZE (HRes, VRes));
 
  // Setup memory stride (total visible pixels on a line * 4).
  MmioWrite32 (DP_BASE + DP_DE_LG_H_STRIDE, (HRes * sizeof (UINT32)));
 
  // Set the format.
 
  // In PixelBlueGreenRedReserved8BitPerColor format, byte 0 represents blue,
  // byte 1 represents green, byte 2 represents red, and byte 3 is reserved
  // which is equivalent to XRGB format of the DP500/DP550/DP650. Whereas
  // PixelRedGreenBlueReserved8BitPerColor is equivalent to XBGR of the
  // DP500/DP550/DP650.
  if (UefiGfxPixelFormat == PixelBlueGreenRedReserved8BitPerColor) {
    PixelFormat = (mDpDeviceId == MALIDP_500) ? DP_PIXEL_FORMAT_DP500_XRGB_8888
                     : DP_PIXEL_FORMAT_XRGB_8888;
  } else {
    PixelFormat = (mDpDeviceId == MALIDP_500) ? DP_PIXEL_FORMAT_DP500_XBGR_8888
                     : DP_PIXEL_FORMAT_XBGR_8888;
  }
 
  MmioWrite32 (DP_BASE + DP_DE_LG_FORMAT, PixelFormat);
 
  // Enable graphics layer.
  LayerGraphicsEnable ();
}
 
STATIC
VOID
SetDisplayEngineTiming (
  IN CONST SCAN_TIMINGS *CONST  Horizontal,
  IN CONST SCAN_TIMINGS *CONST  Vertical
  )
{
  UINTN  RegHIntervals;
  UINTN  RegVIntervals;
  UINTN  RegSyncControl;
  UINTN  RegHVActiveSize;
 
  if (mDpDeviceId == MALIDP_500) {
    // MALI DP500 timing registers.
    RegHIntervals   = DP_BASE + DP_DE_DP500_H_INTERVALS;
    RegVIntervals   = DP_BASE + DP_DE_DP500_V_INTERVALS;
    RegSyncControl  = DP_BASE + DP_DE_DP500_SYNC_CONTROL;
    RegHVActiveSize = DP_BASE + DP_DE_DP500_HV_ACTIVESIZE;
  } else {
    // MALI DP550/DP650 timing registers.
    RegHIntervals   = DP_BASE + DP_DE_H_INTERVALS;
    RegVIntervals   = DP_BASE + DP_DE_V_INTERVALS;
    RegSyncControl  = DP_BASE + DP_DE_SYNC_CONTROL;
    RegHVActiveSize = DP_BASE + DP_DE_HV_ACTIVESIZE;
  }
 
  // Horizontal back porch and front porch.
  MmioWrite32 (
    RegHIntervals,
    H_INTERVALS (Horizontal->FrontPorch, Horizontal->BackPorch)
    );
 
  // Vertical back porch and front porch.
  MmioWrite32 (
    RegVIntervals,
    V_INTERVALS (Vertical->FrontPorch, Vertical->BackPorch)
    );
 
  // Sync control, Horizontal and Vertical sync.
  MmioWrite32 (
    RegSyncControl,
    SYNC_WIDTH (Horizontal->Sync, Vertical->Sync)
    );
 
  // Set up Horizontal and Vertical area size.
  MmioWrite32 (
    RegHVActiveSize,
    HV_ACTIVE (Horizontal->Resolution, Vertical->Resolution)
    );
}
 
STATIC
UINT32
ArmMaliDpGetCoreId (
  )
{
  UINT32  DpCoreId;
 
  // First check for DP500 as register offset for DP550/DP650 CORE_ID
  // is beyond 3K/4K register space of the DP500.
  DpCoreId   = MmioRead32 (DP_BASE + DP_DE_DP500_CORE_ID);
  DpCoreId >>= DP_DE_DP500_CORE_ID_SHIFT;
 
  if (DpCoreId == MALIDP_500) {
    return DpCoreId;
  }
 
  // Check for DP550 or DP650.
  DpCoreId   = MmioRead32 (DP_BASE + DP_DC_CORE_ID);
  DpCoreId >>= DP_DC_CORE_ID_SHIFT;
 
  if ((DpCoreId == MALIDP_550) || (DpCoreId == MALIDP_650)) {
    return DpCoreId;
  }
 
  return MALIDP_NOT_PRESENT;
}
 
EFI_STATUS
LcdIdentify (
  VOID
  )
{
  DEBUG ((
    DEBUG_WARN,
    "Probing ARM Mali DP500/DP550/DP650 at base address 0x%p\n",
    DP_BASE
    ));
 
  if (mDpDeviceId == 0) {
    mDpDeviceId = ArmMaliDpGetCoreId ();
  }
 
  if (mDpDeviceId == MALIDP_NOT_PRESENT) {
    DEBUG ((DEBUG_WARN, "ARM Mali DP not found...\n"));
    return EFI_NOT_FOUND;
  }
 
  DEBUG ((DEBUG_WARN, "Found ARM Mali DP %x\n", mDpDeviceId));
  return EFI_SUCCESS;
}
 
EFI_STATUS
LcdInitialize (
  IN CONST EFI_PHYSICAL_ADDRESS  FrameBaseAddress
  )
{
  DEBUG ((DEBUG_WARN, "Framebuffer base address = %p\n", FrameBaseAddress));
 
  if (mDpDeviceId == 0) {
    mDpDeviceId = ArmMaliDpGetCoreId ();
  }
 
  if (mDpDeviceId == MALIDP_NOT_PRESENT) {
    DEBUG ((
      DEBUG_ERROR,
      "ARM Mali DP initialization failed,"
      "no ARM Mali DP present\n"
      ));
    return EFI_NOT_FOUND;
  }
 
  // We are using graphics layer of the Mali DP as a main framebuffer.
  LayerGraphicsSetFrame (FrameBaseAddress);
 
  return EFI_SUCCESS;
}
 
STATIC
VOID
SetConfigurationMode (
  VOID
  )
{
  // Request configuration Mode.
  if (mDpDeviceId == MALIDP_500) {
    MmioOr32 (DP_BASE + DP_DE_DP500_CONTROL, DP_DE_DP500_CONTROL_CONFIG_REQ);
  } else {
    MmioOr32 (DP_BASE + DP_DC_CONTROL, DP_DC_CONTROL_CM_ACTIVE);
  }
}
 
STATIC
VOID
SetNormalMode (
  VOID
  )
{
  // Disable configuration Mode.
  if (mDpDeviceId == MALIDP_500) {
    MmioAnd32 (DP_BASE + DP_DE_DP500_CONTROL, ~DP_DE_DP500_CONTROL_CONFIG_REQ);
  } else {
    MmioAnd32 (DP_BASE + DP_DC_CONTROL, ~DP_DC_CONTROL_CM_ACTIVE);
  }
}
 
STATIC
VOID
SetConfigValid (
  VOID
  )
{
  if (mDpDeviceId == MALIDP_500) {
    MmioOr32 (DP_BASE + DP_DP500_CONFIG_VALID, DP_DC_CONFIG_VALID);
  } else {
    MmioOr32 (DP_BASE + DP_DC_CONFIG_VALID, DP_DC_CONFIG_VALID);
  }
}
 
EFI_STATUS
LcdSetMode (
  IN CONST UINT32  ModeNumber
  )
{
  EFI_STATUS    Status;
  SCAN_TIMINGS  *Horizontal;
  SCAN_TIMINGS  *Vertical;
 
  EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  ModeInfo;
 
  // Get the display mode timings and other relevant information.
  Status = LcdPlatformGetTimings (
             ModeNumber,
             &Horizontal,
             &Vertical
             );
  if (EFI_ERROR (Status)) {
    ASSERT_EFI_ERROR (Status);
    return Status;
  }
 
  ASSERT (Horizontal != NULL);
  ASSERT (Vertical != NULL);
 
  // Get the pixel format information.
  Status = LcdPlatformQueryMode (ModeNumber, &ModeInfo);
  if (EFI_ERROR (Status)) {
    ASSERT_EFI_ERROR (Status);
    return Status;
  }
 
  // Request configuration mode.
  SetConfigurationMode ();
 
  // Configure the graphics layer.
  LayerGraphicsConfig (
    ModeInfo.PixelFormat,
    Horizontal->Resolution,
    Vertical->Resolution
    );
 
  // Set the display engine timings.
  SetDisplayEngineTiming (Horizontal, Vertical);
 
  // After configuration, set Mali DP in normal mode.
  SetNormalMode ();
 
  // Any parameters written to the display engine are not activated until
  // CONFIG_VALID is set.
  SetConfigValid ();
 
  return EFI_SUCCESS;
}
 
VOID
LcdShutdown (
  VOID
  )
{
  // Disable graphics layer.
  LayerGraphicsDisable ();
}