// Copyright 2023 The Pigweed Authors
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.

#include "pw_mipi_dsi_mcuxpresso/device.h"

#include <cstring>

#include "board.h"
#include "common.h"
#include "fsl_gpio.h"
#include "fsl_inputmux.h"
#include "fsl_mipi_dsi.h"
#include "fsl_mipi_dsi_smartdma.h"
#include "fsl_power.h"
#include "pin_mux.h"
#include "pw_assert/assert.h"

using pw::framebuffer::Framebuffer;
using pw::framebuffer_pool::FramebufferPool;

namespace pw::mipi::dsi {

namespace {

constexpr uint8_t kMipiDsiLaneNum = 1;
constexpr IRQn_Type kMipiDsiIrqn = MIPI_IRQn;
constexpr int kVideoLayer = 0;

// This class is currently a singleton because the some callbacks and IRQ
// handlers do not have a user-data param.
MCUXpressoDevice* s_device;

pw::mipi::dsi::Device::WriteCallback s_write_callback;
Framebuffer s_write_framebuffer;

extern "C" {
void GPIO_INTA_DriverIRQHandler(void) {
  uint32_t intStat = GPIO_PortGetInterruptStatus(GPIO, BOARD_MIPI_TE_PORT, 0);

  GPIO_PortClearInterruptFlags(GPIO, BOARD_MIPI_TE_PORT, 0, intStat);

  if (s_device && intStat & (1U << BOARD_MIPI_TE_PIN)) {
    s_device->DisplayTEPinHandler();
  }
}

void SDMA_DriverIRQHandler(void) { SMARTDMA_HandleIRQ(); }
}  // extern "C"

}  // namespace

MCUXpressoDevice::MCUXpressoDevice(
    const FramebufferPool& framebuffer_pool,
    const pw::geometry::Size<uint16_t>& panel_size,
    video_pixel_format_t pixel_format)
    : framebuffer_pool_(framebuffer_pool),
      fbdev_(kVideoLayer),
      dsi_device_({
          .virtualChannel = 0,
          .xferFunc = MCUXpressoDevice::DSI_Transfer,
          .memWriteFunc = MCUXpressoDevice::DSI_MemWrite,
          .callback = nullptr,
          .userData = nullptr,
      }),
      rm67162_resource_({
          .dsiDevice = &dsi_device_,
          .pullResetPin = MCUXpressoDevice::PullPanelResetPin,
          .pullPowerPin = MCUXpressoDevice::PullPanelPowerPin,
      }),
      display_handle_({
          .resource = &rm67162_resource_,
          .ops = &rm67162_ops,
          .width = panel_size.width,
          .height = panel_size.height,
          .pixelFormat = pixel_format,
      }),
      dc_fb_dsi_cmd_handle_({
          .dsiDevice = &dsi_device_,
          .panelHandle = &display_handle_,
          .initTimes = 0,
          .enabledLayerCount = 0,
          .layers = {},
          .useTEPin = true,
      }),
      panel_config_({
          .commonConfig =
              {
                  .resolution =
                      FSL_VIDEO_RESOLUTION(panel_size.width, panel_size.height),
                  .hsw = 0,  // Unused.
                  .hfp = 0,  // Unused.
                  .hbp = 0,  // Unused.
                  .vsw = 0,  // Unused.
                  .vfp = 0,  // Unused.
                  .vbp = 0,  // Unused.
                  .controlFlags = 0,
                  .dsiLanes = kMipiDsiLaneNum,
                  .pixelClock_Hz = 0,  // Unsure of correct value.
                  .pixelFormat = pixel_format,
              },
          .useTEPin = true,
      }),
      dc_({
          .ops = &g_dcFbOpsDsiCmd,
          .prvData = &dc_fb_dsi_cmd_handle_,
          .config = &panel_config_,
      }) {
  PW_ASSERT(s_device == nullptr);
  s_device = this;
}

MCUXpressoDevice::~MCUXpressoDevice() = default;

Status MCUXpressoDevice::Init() {
  const FramebufferPool::BufferArray& buffers =
      framebuffer_pool_.GetBuffersForInit();
  if (buffers.empty())
    return Status::InvalidArgument();

  Status s = PrepareDisplayController();
  if (!s.ok())
    return s;

  s = fbdev_.Init(&dc_, framebuffer_pool_);
  if (!s.ok())
    return s;

  // Clear buffer to black - it is shown once screen is enabled.
  void* buffer = fbdev_.GetFramebuffer();
  if (!buffer) {
    return Status::Internal();
  }
  std::memset(
      buffer,
      0,
      framebuffer_pool_.row_bytes() * framebuffer_pool_.dimensions().height);
  fbdev_.WriteFramebuffer(buffer, [](void*, Status) {});

  return fbdev_.Enable();
}

Framebuffer MCUXpressoDevice::GetFramebuffer() {
  return Framebuffer(fbdev_.GetFramebuffer(),
                     framebuffer_pool_.pixel_format(),
                     framebuffer_pool_.dimensions(),
                     framebuffer_pool_.row_bytes());
}

void MCUXpressoDevice::WriteFramebuffer(Framebuffer framebuffer,
                                        WriteCallback write_callback) {
  PW_ASSERT(framebuffer.is_valid());
  PW_ASSERT(!s_write_callback);
  s_write_callback = std::move(write_callback);
  s_write_framebuffer = std::move(framebuffer);
  fbdev_.WriteFramebuffer(s_write_framebuffer.data(),
                          [](void* buffer, Status s) {
                            PW_ASSERT(s_write_callback);
                            s_write_callback(std::move(s_write_framebuffer), s);
                          });
}

Status MCUXpressoDevice::PrepareDisplayController(void) {
  Status status = InitDisplayInterface();
  if (!status.ok())
    return status;

#if USE_DSI_SMARTDMA
  InitSmartDMA();
  status_t s = DSI_TransferCreateHandleSMARTDMA(
      MIPI_DSI_HOST,
      &dsi_smartdma_driver_handle_,
      MCUXpressoDevice::DsiSmartDMAMemWriteCallback,
      this);

  return MCUXpressoToPigweedStatus(s);

#else

  NVIC_SetPriority(kMipiDsiIrqn, 6);

  memset(&dsi_mem_write_ctx_, 0, sizeof(DSIMemWriteContext));

  return MCUXpressoToPigweedStatus(
      DSI_TransferCreateHandle(MIPI_DSI_HOST,
                               &dsi_driver_handle_,
                               MCUXpressoDevice::DsiMemWriteCallback,
                               this));
#endif
}

// static
Status MCUXpressoDevice::InitDisplayInterface() {
  RESET_SetPeripheralReset(kMIPI_DSI_PHY_RST_SHIFT_RSTn);
  InitMipiDsiClock();
  RESET_ClearPeripheralReset(kMIPI_DSI_CTRL_RST_SHIFT_RSTn);
  SetMipiDsiConfig();
  RESET_ClearPeripheralReset(kMIPI_DSI_PHY_RST_SHIFT_RSTn);
  return InitLcdPanel();
}

Status MCUXpressoDevice::InitLcdPanel() {
  const gpio_pin_config_t pinConfig = {
      .pinDirection = kGPIO_DigitalOutput,
      .outputLogic = 0,
  };

  GPIO_PinInit(GPIO, BOARD_MIPI_POWER_PORT, BOARD_MIPI_POWER_PIN, &pinConfig);
  GPIO_PinInit(GPIO, BOARD_MIPI_RST_PORT, BOARD_MIPI_RST_PIN, &pinConfig);

  InitMipiPanelTEPin();

  return OkStatus();
}

// static
void MCUXpressoDevice::InitMipiDsiClock(void) {
  POWER_DisablePD(kPDRUNCFG_APD_MIPIDSI_SRAM);
  POWER_DisablePD(kPDRUNCFG_PPD_MIPIDSI_SRAM);
  POWER_DisablePD(kPDRUNCFG_PD_MIPIDSI);
  POWER_ApplyPD();

  CLOCK_AttachClk(kFRO_DIV1_to_MIPI_DPHYESC_CLK);
  CLOCK_SetClkDiv(kCLOCK_DivDphyEscRxClk, 4);
  CLOCK_SetClkDiv(kCLOCK_DivDphyEscTxClk, 3);
  mipi_dsi_tx_esc_clk_freq_hz_ = CLOCK_GetMipiDphyEscTxClkFreq();

  CLOCK_AttachClk(kAUX1_PLL_to_MIPI_DPHY_CLK);
#if (DEMO_RM67162_BUFFER_FORMAT == PIXEL_FORMAT_RGB565)
  CLOCK_InitSysPfd(kCLOCK_Pfd3, 30);
#else
  CLOCK_InitSysPfd(kCLOCK_Pfd3, 19);
#endif
  CLOCK_SetClkDiv(kCLOCK_DivDphyClk, 1);
  mipi_dsi_dphy_bit_clk_freq_hz_ = CLOCK_GetMipiDphyClkFreq();
}

// static
void MCUXpressoDevice::InitMipiPanelTEPin(void) {
  const gpio_pin_config_t tePinConfig = {
      .pinDirection = kGPIO_DigitalInput,
      .outputLogic = 0,
  };

  gpio_interrupt_config_t te_pin_int_config = {kGPIO_PinIntEnableEdge,
                                               kGPIO_PinIntEnableHighOrRise};

  GPIO_PinInit(GPIO, BOARD_MIPI_TE_PORT, BOARD_MIPI_TE_PIN, &tePinConfig);

  GPIO_SetPinInterruptConfig(
      GPIO, BOARD_MIPI_TE_PORT, BOARD_MIPI_TE_PIN, &te_pin_int_config);

  GPIO_PinEnableInterrupt(GPIO, BOARD_MIPI_TE_PORT, BOARD_MIPI_TE_PIN, 0);

  NVIC_SetPriority(GPIO_INTA_IRQn, 3);

  NVIC_EnableIRQ(GPIO_INTA_IRQn);
}

// static
void MCUXpressoDevice::SetMipiDsiConfig() {
  dsi_config_t dsiConfig;
  dsi_dphy_config_t dphyConfig;

  DSI_GetDefaultConfig(&dsiConfig);
  dsiConfig.numLanes = kMipiDsiLaneNum;
  dsiConfig.autoInsertEoTp = true;

  DSI_GetDphyDefaultConfig(&dphyConfig,
                           mipi_dsi_dphy_bit_clk_freq_hz_,
                           mipi_dsi_tx_esc_clk_freq_hz_);

  DSI_Init(MIPI_DSI_HOST, &dsiConfig);

  DSI_InitDphy(MIPI_DSI_HOST, &dphyConfig, 0);
}

#if USE_DSI_SMARTDMA
// static
void MCUXpressoDevice::InitSmartDMA() {
  RESET_ClearPeripheralReset(kINPUTMUX_RST_SHIFT_RSTn);

  INPUTMUX_Init(INPUTMUX);
  INPUTMUX_AttachSignal(INPUTMUX, 0, kINPUTMUX_MipiIrqToSmartDmaInput);

  INPUTMUX_Deinit(INPUTMUX);

  POWER_DisablePD(kPDRUNCFG_APD_SMARTDMA_SRAM);
  POWER_DisablePD(kPDRUNCFG_PPD_SMARTDMA_SRAM);
  POWER_ApplyPD();

  RESET_ClearPeripheralReset(kSMART_DMA_RST_SHIFT_RSTn);
  CLOCK_EnableClock(kCLOCK_Smartdma);

  SMARTDMA_InitWithoutFirmware();
  NVIC_EnableIRQ(SDMA_IRQn);

  NVIC_SetPriority(SDMA_IRQn, 3);
}
#endif

// static
status_t MCUXpressoDevice::DSI_Transfer(dsi_transfer_t* xfer) {
  return DSI_TransferBlocking(MIPI_DSI_HOST, xfer);
}

// static
status_t MCUXpressoDevice::DSI_MemWrite(uint8_t virtualChannel,
                                        const uint8_t* data,
                                        uint32_t length) {
#if USE_DSI_SMARTDMA
  dsi_smartdma_write_mem_transfer_t xfer = {
#if (DEMO_RM67162_BUFFER_FORMAT == PIXEL_FORMAT_RGB565)
      .inputFormat = kDSI_SMARTDMA_InputPixelFormatRGB565,
      .outputFormat = kDSI_SMARTDMA_OutputPixelFormatRGB565,
#elif (DEMO_RM67162_BUFFER_FORMAT == PIXEL_FORMAT_RGB888)
      .inputFormat = kDSI_SMARTDMA_InputPixelFormatRGB888,
      .outputFormat = kDSI_SMARTDMA_OutputPixelFormatRGB888,
#else
      .inputFormat = kDSI_SMARTDMA_InputPixelFormatXRGB8888,
      .outputFormat = kDSI_SMARTDMA_OutputPixelFormatRGB888,
#endif /* DEMO_RM67162_BUFFER_FORMAT */
      .data = data,
      .dataSize = length,

      .virtualChannel = virtualChannel,
      .disablePixelByteSwap = false,
  };

  return DSI_TransferWriteMemorySMARTDMA(
      MIPI_DSI_HOST, &s_device->dsi_smartdma_driver_handle_, &xfer);

#else /* USE_DSI_SMARTDMA */

  status_t status;

  if (s_device->dsi_mem_write_ctx_.ongoing) {
    return kStatus_Fail;
  }

  s_device->dsi_mem_write_xfer_.virtualChannel = virtualChannel;
  s_device->dsi_mem_write_xfer_.flags = kDSI_TransferUseHighSpeed;
  s_device->dsi_mem_write_xfer_.sendDscCmd = true;

  s_device->dsi_mem_write_ctx_.ongoing = true;
  s_device->dsi_mem_write_ctx_.tx_data = data;
  s_device->dsi_mem_write_ctx_.num_bytes_remaining = length;
  s_device->dsi_mem_write_ctx_.dsc_cmd = kMIPI_DCS_WriteMemoryStart;

  status = s_device->DsiMemWriteSendChunck();

  if (status != kStatus_Success) {
    /* Memory write does not start actually. */
    s_device->dsi_mem_write_ctx_.ongoing = false;
  }

  return status;
#endif
}

// static
void MCUXpressoDevice::PullPanelResetPin(bool pullUp) {
  if (pullUp) {
    GPIO_PinWrite(GPIO, BOARD_MIPI_RST_PORT, BOARD_MIPI_RST_PIN, 1);
  } else {
    GPIO_PinWrite(GPIO, BOARD_MIPI_RST_PORT, BOARD_MIPI_RST_PIN, 0);
  }
}

// static
void MCUXpressoDevice::PullPanelPowerPin(bool pullUp) {
  if (pullUp) {
    GPIO_PinWrite(GPIO, BOARD_MIPI_POWER_PORT, BOARD_MIPI_POWER_PIN, 1);
  } else {
    GPIO_PinWrite(GPIO, BOARD_MIPI_POWER_PORT, BOARD_MIPI_POWER_PIN, 0);
  }
}

void MCUXpressoDevice::DisplayTEPinHandler() {
  DC_FB_DSI_CMD_TE_IRQHandler(&dc_);
}

// static
status_t MCUXpressoDevice::DsiMemWriteSendChunck(void) {
  uint32_t curSendLen;
  uint32_t i;

  curSendLen = kMaxDSITxArraySize > dsi_mem_write_ctx_.num_bytes_remaining
                   ? dsi_mem_write_ctx_.num_bytes_remaining
                   : kMaxDSITxArraySize;

  dsi_mem_write_xfer_.txDataType = kDSI_TxDataDcsLongWr;
  dsi_mem_write_xfer_.dscCmd = dsi_mem_write_ctx_.dsc_cmd;
  dsi_mem_write_xfer_.txData = dsi_mem_write_tmp_array_;
  dsi_mem_write_xfer_.txDataSize = curSendLen;

#if (DEMO_RM67162_BUFFER_FORMAT == PIXEL_FORMAT_RGB565)
  for (i = 0; i < curSendLen; i += 2) {
    dsi_mem_write_tmp_array_[i] = *(dsi_mem_write_ctx_.tx_data + 1);
    dsi_mem_write_tmp_array_[i + 1] = *(dsi_mem_write_ctx_.tx_data);

    dsi_mem_write_ctx_.tx_data += 2;
  }
#else
  for (i = 0; i < curSendLen; i += 3) {
    dsi_mem_write_tmp_array_[i] = *(dsi_mem_write_ctx_.tx_data + 2);
    dsi_mem_write_tmp_array_[i + 1] = *(dsi_mem_write_ctx_.tx_data + 1);
    dsi_mem_write_tmp_array_[i + 2] = *(dsi_mem_write_ctx_.tx_data);

    dsi_mem_write_ctx_.tx_data += 3;
  }
#endif

  dsi_mem_write_ctx_.num_bytes_remaining -= curSendLen;
  dsi_mem_write_ctx_.dsc_cmd = kMIPI_DCS_WriteMemoryContinue;

  return DSI_TransferNonBlocking(
      MIPI_DSI_HOST, &dsi_driver_handle_, &dsi_mem_write_xfer_);
}

// static
void MCUXpressoDevice::DsiMemWriteCallback(MIPI_DSI_HOST_Type* base,
                                           dsi_handle_t* handle,
                                           status_t status,
                                           void* userData) {
  MCUXpressoDevice* device = static_cast<MCUXpressoDevice*>(userData);
  if ((kStatus_Success == status) &&
      (device->dsi_mem_write_ctx_.num_bytes_remaining > 0)) {
    status = device->DsiMemWriteSendChunck();
    if (kStatus_Success == status) {
      return;
    }
  }

  device->dsi_mem_write_ctx_.ongoing = false;
  MIPI_DSI_MemoryDoneDriverCallback(status, &device->dsi_device_);
}

// static
void MCUXpressoDevice::DsiSmartDMAMemWriteCallback(
    MIPI_DSI_HOST_Type* base,
    dsi_smartdma_handle_t* handle,
    status_t status,
    void* userData) {
  MCUXpressoDevice* device = static_cast<MCUXpressoDevice*>(userData);
  MIPI_DSI_MemoryDoneDriverCallback(status, &device->dsi_device_);
}

}  // namespace pw::mipi::dsi