/** @file
  Graphics Output Protocol functions for the QEMU video controller.

  Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>

  SPDX-License-Identifier: BSD-2-Clause-Patent

**/

#include "Qemu.h"

///
/// Generic Attribute Controller Register Settings
///
UINT8  AttributeController[21] = {
  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
  0x41, 0x00, 0x0F, 0x00, 0x00
};

///
/// Generic Graphics Controller Register Settings
///
UINT8  GraphicsController[9] = {
  0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF
};

//
// 640 x 480 x 256 color @ 60 Hertz
//
UINT8  Crtc_640_480_256_60[28] = {
  0x5d, 0x4f, 0x50, 0x82, 0x53, 0x9f, 0x00, 0x3e,
  0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0xe1, 0x83, 0xdf, 0x50, 0x00, 0xe7, 0x04, 0xe3,
  0xff, 0x00, 0x00, 0x22
};

UINT8  Crtc_640_480_32bpp_60[28] = {
  0x5d, 0x4f, 0x50, 0x82, 0x53, 0x9f, 0x00, 0x3e,
  0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0xe1, 0x83, 0xdf, 0x40, 0x00, 0xe7, 0x04, 0xe3,
  0xff, 0x00, 0x00, 0x32
};

UINT16  Seq_640_480_256_60[15] = {
  0x0100, 0x0101, 0x0f02, 0x0003, 0x0e04, 0x1107, 0x0008, 0x4a0b,
  0x5b0c, 0x450d, 0x7e0e, 0x2b1b, 0x2f1c, 0x301d, 0x331e
};

UINT16  Seq_640_480_32bpp_60[15] = {
  0x0100, 0x0101, 0x0f02, 0x0003, 0x0e04, 0x1907, 0x0008, 0x4a0b,
  0x5b0c, 0x450d, 0x7e0e, 0x2b1b, 0x2f1c, 0x301d, 0x331e
};

//
// 800 x 600 x 256 color @ 60 Hertz
//
UINT8  Crtc_800_600_256_60[28] = {
  0x7F, 0x63, 0x64, 0x80, 0x6B, 0x1B, 0x72, 0xF0,
  0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x58, 0x8C, 0x57, 0x64, 0x00, 0x5F, 0x91, 0xE3,
  0xFF, 0x00, 0x00, 0x22
};

UINT8  Crtc_800_600_32bpp_60[28] = {
  0x7F, 0x63, 0x64, 0x80, 0x6B, 0x1B, 0x72, 0xF0,
  0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x58, 0x8C, 0x57, 0x90, 0x00, 0x5F, 0x91, 0xE3,
  0xFF, 0x00, 0x00, 0x32
};

UINT16  Seq_800_600_256_60[15] = {
  0x0100, 0x0101, 0x0f02, 0x0003, 0x0e04, 0x1107, 0x0008, 0x4a0b,
  0x5b0c, 0x450d, 0x510e, 0x2b1b, 0x2f1c, 0x301d, 0x3a1e
};

UINT16  Seq_800_600_32bpp_60[15] = {
  0x0100, 0x0101, 0x0f02, 0x0003, 0x0e04, 0x1907, 0x0008, 0x4a0b,
  0x5b0c, 0x450d, 0x510e, 0x2b1b, 0x2f1c, 0x301d, 0x3a1e
};

UINT8  Crtc_960_720_32bpp_60[28] = {
  0xA3, 0x77, 0x80, 0x86, 0x85, 0x96, 0x24, 0xFD,
  0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x02, 0x88, 0xCF, 0xe0, 0x00, 0x00, 0x64, 0xE3,
  0xFF, 0x4A, 0x00, 0x32
};

UINT16  Seq_960_720_32bpp_60[15] = {
  0x0100, 0x0101, 0x0f02, 0x0003, 0x0e04, 0x1907, 0x0008, 0x4a0b,
  0x5b0c, 0x450d, 0x760e, 0x2b1b, 0x2f1c, 0x301d, 0x341e
};

//
// 1024 x 768 x 256 color @ 60 Hertz
//
UINT8  Crtc_1024_768_256_60[28] = {
  0xA3, 0x7F, 0x80, 0x86, 0x85, 0x96, 0x24, 0xFD,
  0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x02, 0x88, 0xFF, 0x80, 0x00, 0x00, 0x24, 0xE3,
  0xFF, 0x4A, 0x00, 0x22
};

UINT16  Seq_1024_768_256_60[15] = {
  0x0100, 0x0101, 0x0f02, 0x0003, 0x0e04, 0x1107, 0x0008, 0x4a0b,
  0x5b0c, 0x450d, 0x760e, 0x2b1b, 0x2f1c, 0x301d, 0x341e
};

//
// 1024 x 768 x 24-bit color @ 60 Hertz
//
UINT8  Crtc_1024_768_24bpp_60[28] = {
  0xA3, 0x7F, 0x80, 0x86, 0x85, 0x96, 0x24, 0xFD,
  0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x02, 0x88, 0xFF, 0x80, 0x00, 0x00, 0x24, 0xE3,
  0xFF, 0x4A, 0x00, 0x32
};

UINT16  Seq_1024_768_24bpp_60[15] = {
  0x0100, 0x0101, 0x0f02, 0x0003, 0x0e04, 0x1507, 0x0008, 0x4a0b,
  0x5b0c, 0x450d, 0x760e, 0x2b1b, 0x2f1c, 0x301d, 0x341e
};

UINT8  Crtc_1024_768_32bpp_60[28] = {
  0xA3, 0x7F, 0x80, 0x86, 0x85, 0x96, 0x24, 0xFD,
  0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x02, 0x88, 0xFF, 0xe0, 0x00, 0x00, 0x64, 0xE3,
  0xFF, 0x4A, 0x00, 0x32
};

UINT16  Seq_1024_768_32bpp_60[15] = {
  0x0100, 0x0101, 0x0f02, 0x0003, 0x0e04, 0x1907, 0x0008, 0x4a0b,
  0x5b0c, 0x450d, 0x760e, 0x2b1b, 0x2f1c, 0x301d, 0x341e
};

///
/// Table of supported video modes
///
QEMU_VIDEO_CIRRUS_MODES  QemuVideoCirrusModes[] = {
  //  {  640, 480, 8, Crtc_640_480_256_60,  Seq_640_480_256_60,  0xe3 },
  //  {  800, 600, 8, Crtc_800_600_256_60,  Seq_800_600_256_60,  0xef },
  { 640,  480, 32, Crtc_640_480_32bpp_60,  Seq_640_480_32bpp_60,  0xef },
  { 800,  600, 32, Crtc_800_600_32bpp_60,  Seq_800_600_32bpp_60,  0xef },
  //  { 1024, 768, 8, Crtc_1024_768_256_60, Seq_1024_768_256_60, 0xef }
  { 1024, 768, 24, Crtc_1024_768_24bpp_60, Seq_1024_768_24bpp_60, 0xef }
  //  { 1024, 768, 32, Crtc_1024_768_32bpp_60, Seq_1024_768_32bpp_60, 0xef }
  //  { 960, 720, 32, Crtc_960_720_32bpp_60, Seq_1024_768_32bpp_60, 0xef }
};

#define QEMU_VIDEO_CIRRUS_MODE_COUNT \
  (ARRAY_SIZE (QemuVideoCirrusModes))

/**
  Construct the valid video modes for QemuVideo.

**/
EFI_STATUS
QemuVideoCirrusModeSetup (
  QEMU_VIDEO_PRIVATE_DATA  *Private
  )
{
  UINT32                   Index;
  QEMU_VIDEO_MODE_DATA     *ModeData;
  QEMU_VIDEO_CIRRUS_MODES  *VideoMode;

  //
  // Setup Video Modes
  //
  Private->ModeData = AllocatePool (
                        sizeof (Private->ModeData[0]) * QEMU_VIDEO_CIRRUS_MODE_COUNT
                        );
  if (Private->ModeData == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }

  ModeData  = Private->ModeData;
  VideoMode = &QemuVideoCirrusModes[0];
  for (Index = 0; Index < QEMU_VIDEO_CIRRUS_MODE_COUNT; Index++) {
    ModeData->InternalModeIndex    = Index;
    ModeData->HorizontalResolution = VideoMode->Width;
    ModeData->VerticalResolution   = VideoMode->Height;
    ModeData->ColorDepth           = VideoMode->ColorDepth;
    DEBUG ((
      DEBUG_INFO,
      "Adding Mode %d as Cirrus Internal Mode %d: %dx%d, %d-bit\n",
      (INT32)(ModeData - Private->ModeData),
      ModeData->InternalModeIndex,
      ModeData->HorizontalResolution,
      ModeData->VerticalResolution,
      ModeData->ColorDepth
      ));

    ModeData++;
    VideoMode++;
  }

  Private->MaxMode = ModeData - Private->ModeData;

  return EFI_SUCCESS;
}

///
/// Table of supported video modes
///
STATIC QEMU_VIDEO_BOCHS_MODES  QemuVideoBochsModes[] = {
  { 640,  480  },
  { 800,  480  },
  { 800,  600  },
  { 832,  624  },
  { 960,  640  },
  { 1024, 600  },
  { 1024, 768  },
  { 1152, 864  },
  { 1152, 870  },
  { 1280, 720  },
  { 1280, 760  },
  { 1280, 768  },
  { 1280, 800  },
  { 1280, 960  },
  { 1280, 1024 },
  { 1360, 768  },
  { 1366, 768  },
  { 1400, 1050 },
  { 1440, 900  },
  { 1600, 900  },
  { 1600, 1200 },
  { 1680, 1050 },
  { 1920, 1080 },
  { 1920, 1200 },
  { 1920, 1440 },
  { 2000, 2000 },
  { 2048, 1536 },
  { 2048, 2048 },
  { 2560, 1440 },
  { 2560, 1600 },
  { 2560, 2048 },
  { 2800, 2100 },
  { 3200, 2400 },
  { 3840, 2160 },
  { 4096, 2160 },
  { 7680, 4320 },
  { 8192, 4320 }
};

#define QEMU_VIDEO_BOCHS_MODE_COUNT \
  (ARRAY_SIZE (QemuVideoBochsModes))

STATIC
VOID
QemuVideoBochsAddMode (
  QEMU_VIDEO_PRIVATE_DATA  *Private,
  UINT32                   AvailableFbSize,
  UINT32                   Width,
  UINT32                   Height
  )
{
  QEMU_VIDEO_MODE_DATA  *ModeData = Private->ModeData + Private->MaxMode;
  UINTN                 RequiredFbSize;

  RequiredFbSize = (UINTN)Width * Height * 4;
  if (RequiredFbSize > AvailableFbSize) {
    DEBUG ((
      DEBUG_INFO,
      "Skipping Bochs Mode %dx%d, 32-bit (not enough vram)\n",
      Width,
      Height
      ));
    return;
  }

  ModeData->InternalModeIndex    = (UINT32)Private->MaxMode;
  ModeData->HorizontalResolution = Width;
  ModeData->VerticalResolution   = Height;
  ModeData->ColorDepth           = 32;
  DEBUG ((
    DEBUG_INFO,
    "Adding Bochs Internal Mode %d: %dx%d, %d-bit\n",
    ModeData->InternalModeIndex,
    ModeData->HorizontalResolution,
    ModeData->VerticalResolution,
    ModeData->ColorDepth
    ));

  Private->MaxMode++;
}

STATIC
VOID
QemuVideoBochsEdid (
  QEMU_VIDEO_PRIVATE_DATA  *Private,
  UINT32                   *XRes,
  UINT32                   *YRes
  )
{
  EFI_STATUS  Status;

  if (Private->Variant != QEMU_VIDEO_BOCHS_MMIO) {
    return;
  }

  Status = Private->PciIo->Mem.Read (
                                 Private->PciIo,
                                 EfiPciIoWidthUint8,
                                 PCI_BAR_IDX2,
                                 0,
                                 sizeof (Private->Edid),
                                 Private->Edid
                                 );
  if (Status != EFI_SUCCESS) {
    DEBUG ((
      DEBUG_INFO,
      "%a: mmio read failed\n",
      __func__
      ));
    return;
  }

  if ((Private->Edid[0] != 0x00) ||
      (Private->Edid[1] != 0xff))
  {
    DEBUG ((
      DEBUG_INFO,
      "%a: magic check failed\n",
      __func__
      ));
    return;
  }

  DEBUG ((
    DEBUG_INFO,
    "%a: blob found (extensions: %d)\n",
    __func__,
    Private->Edid[126]
    ));

  if ((Private->Edid[54] == 0x00) &&
      (Private->Edid[55] == 0x00))
  {
    DEBUG ((
      DEBUG_INFO,
      "%a: no detailed timing descriptor\n",
      __func__
      ));
    return;
  }

  *XRes = Private->Edid[56] | ((Private->Edid[58] & 0xf0) << 4);
  *YRes = Private->Edid[59] | ((Private->Edid[61] & 0xf0) << 4);
  DEBUG ((
    DEBUG_INFO,
    "%a: default resolution: %dx%d\n",
    __func__,
    *XRes,
    *YRes
    ));

  if (PcdGet8 (PcdVideoResolutionSource) == 0) {
    Status = PcdSet32S (PcdVideoHorizontalResolution, *XRes);
    ASSERT_RETURN_ERROR (Status);
    Status = PcdSet32S (PcdVideoVerticalResolution, *YRes);
    ASSERT_RETURN_ERROR (Status);
    Status = PcdSet8S (PcdVideoResolutionSource, 2);
    ASSERT_RETURN_ERROR (Status);
  }

  // TODO: register edid as gEfiEdidDiscoveredProtocolGuid ?
}

EFI_STATUS
QemuVideoBochsModeSetup (
  QEMU_VIDEO_PRIVATE_DATA  *Private,
  BOOLEAN                  IsQxl
  )
{
  UINT32  AvailableFbSize;
  UINT32  Index, XRes = 0, YRes = 0;

  //
  // Fetch the available framebuffer size.
  //
  // VBE_DISPI_INDEX_VIDEO_MEMORY_64K is expected to return the size of the
  // drawable framebuffer. Up to and including qemu-2.1 however it used to
  // return the size of PCI BAR 0 (ie. the full video RAM size).
  //
  // On stdvga the two concepts coincide with each other; the full memory size
  // is usable for drawing.
  //
  // On QXL however, only a leading segment, "surface 0", can be used for
  // drawing; the rest of the video memory is used for the QXL guest-host
  // protocol. VBE_DISPI_INDEX_VIDEO_MEMORY_64K should report the size of
  // "surface 0", but since it doesn't (up to and including qemu-2.1), we
  // retrieve the size of the drawable portion from a field in the QXL ROM BAR,
  // where it is also available.
  //
  if (IsQxl) {
    UINT32  Signature;
    UINT32  DrawStart;

    Signature       = 0;
    DrawStart       = 0xFFFFFFFF;
    AvailableFbSize = 0;
    if (EFI_ERROR (
          Private->PciIo->Mem.Read (
                                Private->PciIo,
                                EfiPciIoWidthUint32,
                                PCI_BAR_IDX2,
                                0,
                                1,
                                &Signature
                                )
          ) ||
        (Signature != SIGNATURE_32 ('Q', 'X', 'R', 'O')) ||
        EFI_ERROR (
          Private->PciIo->Mem.Read (
                                Private->PciIo,
                                EfiPciIoWidthUint32,
                                PCI_BAR_IDX2,
                                36,
                                1,
                                &DrawStart
                                )
          ) ||
        (DrawStart != 0) ||
        EFI_ERROR (
          Private->PciIo->Mem.Read (
                                Private->PciIo,
                                EfiPciIoWidthUint32,
                                PCI_BAR_IDX2,
                                40,
                                1,
                                &AvailableFbSize
                                )
          ))
    {
      DEBUG ((
        DEBUG_ERROR,
        "%a: can't read size of drawable buffer from QXL "
        "ROM\n",
        __func__
        ));
      return EFI_NOT_FOUND;
    }
  } else {
    AvailableFbSize  = BochsRead (Private, VBE_DISPI_INDEX_VIDEO_MEMORY_64K);
    AvailableFbSize *= SIZE_64KB;
  }

  DEBUG ((
    DEBUG_INFO,
    "%a: AvailableFbSize=0x%x\n",
    __func__,
    AvailableFbSize
    ));

  //
  // Setup Video Modes
  //
  Private->ModeData = AllocatePool (
                        sizeof (Private->ModeData[0]) * (QEMU_VIDEO_BOCHS_MODE_COUNT+1)
                        );
  if (Private->ModeData == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }

  QemuVideoBochsEdid (Private, &XRes, &YRes);
  if (XRes && YRes) {
    QemuVideoBochsAddMode (
      Private,
      AvailableFbSize,
      XRes,
      YRes
      );
  }

  for (Index = 0; Index < QEMU_VIDEO_BOCHS_MODE_COUNT; Index++) {
    if ((QemuVideoBochsModes[Index].Width == XRes) &&
        (QemuVideoBochsModes[Index].Height == YRes))
    {
      continue; // duplicate with edid resolution
    }

    QemuVideoBochsAddMode (
      Private,
      AvailableFbSize,
      QemuVideoBochsModes[Index].Width,
      QemuVideoBochsModes[Index].Height
      );
  }

  return EFI_SUCCESS;
}