Quelle  lsdc_crtc.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (C) 2023 Loongson Technology Corporation Limited
 */

#include <linux/debugfs.h>
#include <linux/delay.h>

#include <drm/drm_atomic.h>
#include <drm/drm_atomic_helper.h>
#include <drm/drm_debugfs.h>
#include <drm/drm_vblank.h>

#include "lsdc_drv.h"

/*
 * After the CRTC soft reset, the vblank counter would be reset to zero.
 * But the address and other settings in the CRTC register remain the same
 * as before.
 */

static void lsdc_crtc0_soft_reset(struct lsdc_crtc *lcrtc)
{
 struct lsdc_device *ldev = lcrtc->ldev;
 u32 val;

 val = lsdc_rreg32(ldev, LSDC_CRTC0_CFG_REG);

 val &= CFG_VALID_BITS_MASK;

 /* Soft reset bit, active low */
 val &= ~CFG_RESET_N;

 val &= ~CFG_PIX_FMT_MASK;

 lsdc_wreg32(ldev, LSDC_CRTC0_CFG_REG, val);

 udelay(1);

 val |= CFG_RESET_N | LSDC_PF_XRGB8888 | CFG_OUTPUT_ENABLE;

 lsdc_wreg32(ldev, LSDC_CRTC0_CFG_REG, val);

 /* Wait about a vblank time */
 mdelay(20);
}

static void lsdc_crtc1_soft_reset(struct lsdc_crtc *lcrtc)
{
 struct lsdc_device *ldev = lcrtc->ldev;
 u32 val;

 val = lsdc_rreg32(ldev, LSDC_CRTC1_CFG_REG);

 val &= CFG_VALID_BITS_MASK;

 /* Soft reset bit, active low */
 val &= ~CFG_RESET_N;

 val &= ~CFG_PIX_FMT_MASK;

 lsdc_wreg32(ldev, LSDC_CRTC1_CFG_REG, val);

 udelay(1);

 val |= CFG_RESET_N | LSDC_PF_XRGB8888 | CFG_OUTPUT_ENABLE;

 lsdc_wreg32(ldev, LSDC_CRTC1_CFG_REG, val);

 /* Wait about a vblank time */
 msleep(20);
}

static void lsdc_crtc0_enable(struct lsdc_crtc *lcrtc)
{
 struct lsdc_device *ldev = lcrtc->ldev;
 u32 val;

 val = lsdc_rreg32(ldev, LSDC_CRTC0_CFG_REG);

 /*
 * This may happen in extremely rare cases, but a soft reset can
 * bring it back to normal. We add a warning here, hoping to catch
 * something if it happens.
 */
 if (val & CRTC_ANCHORED) {
  drm_warn(&ldev->base, "%s stall\n", lcrtc->base.name);
  return lsdc_crtc0_soft_reset(lcrtc);
 }

 lsdc_wreg32(ldev, LSDC_CRTC0_CFG_REG, val | CFG_OUTPUT_ENABLE);
}

static void lsdc_crtc0_disable(struct lsdc_crtc *lcrtc)
{
 struct lsdc_device *ldev = lcrtc->ldev;

 lsdc_ureg32_clr(ldev, LSDC_CRTC0_CFG_REG, CFG_OUTPUT_ENABLE);

 udelay(9);
}

static void lsdc_crtc1_enable(struct lsdc_crtc *lcrtc)
{
 struct lsdc_device *ldev = lcrtc->ldev;
 u32 val;

 /*
 * This may happen in extremely rare cases, but a soft reset can
 * bring it back to normal. We add a warning here, hoping to catch
 * something if it happens.
 */
 val = lsdc_rreg32(ldev, LSDC_CRTC1_CFG_REG);
 if (val & CRTC_ANCHORED) {
  drm_warn(&ldev->base, "%s stall\n", lcrtc->base.name);
  return lsdc_crtc1_soft_reset(lcrtc);
 }

 lsdc_wreg32(ldev, LSDC_CRTC1_CFG_REG, val | CFG_OUTPUT_ENABLE);
}

static void lsdc_crtc1_disable(struct lsdc_crtc *lcrtc)
{
 struct lsdc_device *ldev = lcrtc->ldev;

 lsdc_ureg32_clr(ldev, LSDC_CRTC1_CFG_REG, CFG_OUTPUT_ENABLE);

 udelay(9);
}

/* All Loongson display controllers have hardware scanout position recoders */

static void lsdc_crtc0_scan_pos(struct lsdc_crtc *lcrtc, int *hpos, int *vpos)
{
 struct lsdc_device *ldev = lcrtc->ldev;
 u32 val;

 val = lsdc_rreg32(ldev, LSDC_CRTC0_SCAN_POS_REG);

 *hpos = val >> 16;
 *vpos = val & 0xffff;
}

static void lsdc_crtc1_scan_pos(struct lsdc_crtc *lcrtc, int *hpos, int *vpos)
{
 struct lsdc_device *ldev = lcrtc->ldev;
 u32 val;

 val = lsdc_rreg32(ldev, LSDC_CRTC1_SCAN_POS_REG);

 *hpos = val >> 16;
 *vpos = val & 0xffff;
}

static void lsdc_crtc0_enable_vblank(struct lsdc_crtc *lcrtc)
{
 struct lsdc_device *ldev = lcrtc->ldev;

 lsdc_ureg32_set(ldev, LSDC_INT_REG, INT_CRTC0_VSYNC_EN);
}

static void lsdc_crtc0_disable_vblank(struct lsdc_crtc *lcrtc)
{
 struct lsdc_device *ldev = lcrtc->ldev;

 lsdc_ureg32_clr(ldev, LSDC_INT_REG, INT_CRTC0_VSYNC_EN);
}

static void lsdc_crtc1_enable_vblank(struct lsdc_crtc *lcrtc)
{
 struct lsdc_device *ldev = lcrtc->ldev;

 lsdc_ureg32_set(ldev, LSDC_INT_REG, INT_CRTC1_VSYNC_EN);
}

static void lsdc_crtc1_disable_vblank(struct lsdc_crtc *lcrtc)
{
 struct lsdc_device *ldev = lcrtc->ldev;

 lsdc_ureg32_clr(ldev, LSDC_INT_REG, INT_CRTC1_VSYNC_EN);
}

static void lsdc_crtc0_flip(struct lsdc_crtc *lcrtc)
{
 struct lsdc_device *ldev = lcrtc->ldev;

 lsdc_ureg32_set(ldev, LSDC_CRTC0_CFG_REG, CFG_PAGE_FLIP);
}

static void lsdc_crtc1_flip(struct lsdc_crtc *lcrtc)
{
 struct lsdc_device *ldev = lcrtc->ldev;

 lsdc_ureg32_set(ldev, LSDC_CRTC1_CFG_REG, CFG_PAGE_FLIP);
}

/*
 * CRTC0 clone from CRTC1 or CRTC1 clone from CRTC0 using hardware logic
 * This may be useful for custom cloning (TWIN) applications. Saving the
 * bandwidth compared with the clone (mirroring) display mode provided by
 * drm core.
 */

static void lsdc_crtc0_clone(struct lsdc_crtc *lcrtc)
{
 struct lsdc_device *ldev = lcrtc->ldev;

 lsdc_ureg32_set(ldev, LSDC_CRTC0_CFG_REG, CFG_HW_CLONE);
}

static void lsdc_crtc1_clone(struct lsdc_crtc *lcrtc)
{
 struct lsdc_device *ldev = lcrtc->ldev;

 lsdc_ureg32_set(ldev, LSDC_CRTC1_CFG_REG, CFG_HW_CLONE);
}

static void lsdc_crtc0_set_mode(struct lsdc_crtc *lcrtc,
    const struct drm_display_mode *mode)
{
 struct lsdc_device *ldev = lcrtc->ldev;

 lsdc_wreg32(ldev, LSDC_CRTC0_HDISPLAY_REG,
      (mode->crtc_htotal << 16) | mode->crtc_hdisplay);

 lsdc_wreg32(ldev, LSDC_CRTC0_VDISPLAY_REG,
      (mode->crtc_vtotal << 16) | mode->crtc_vdisplay);

 lsdc_wreg32(ldev, LSDC_CRTC0_HSYNC_REG,
      (mode->crtc_hsync_end << 16) | mode->crtc_hsync_start | HSYNC_EN);

 lsdc_wreg32(ldev, LSDC_CRTC0_VSYNC_REG,
      (mode->crtc_vsync_end << 16) | mode->crtc_vsync_start | VSYNC_EN);
}

static void lsdc_crtc1_set_mode(struct lsdc_crtc *lcrtc,
    const struct drm_display_mode *mode)
{
 struct lsdc_device *ldev = lcrtc->ldev;

 lsdc_wreg32(ldev, LSDC_CRTC1_HDISPLAY_REG,
      (mode->crtc_htotal << 16) | mode->crtc_hdisplay);

 lsdc_wreg32(ldev, LSDC_CRTC1_VDISPLAY_REG,
      (mode->crtc_vtotal << 16) | mode->crtc_vdisplay);

 lsdc_wreg32(ldev, LSDC_CRTC1_HSYNC_REG,
      (mode->crtc_hsync_end << 16) | mode->crtc_hsync_start | HSYNC_EN);

 lsdc_wreg32(ldev, LSDC_CRTC1_VSYNC_REG,
      (mode->crtc_vsync_end << 16) | mode->crtc_vsync_start | VSYNC_EN);
}

/*
 * This is required for S3 support.
 * After resuming from suspend, LSDC_CRTCx_CFG_REG (x = 0 or 1) is filled
 * with garbage value, which causes the CRTC hang there.
 *
 * This function provides minimal settings for the affected registers.
 * This overrides the firmware's settings on startup, making the CRTC work
 * on our own, similar to the functional of GPU POST (Power On Self Test).
 * Only touch CRTC hardware-related parts.
 */

static void lsdc_crtc0_reset(struct lsdc_crtc *lcrtc)
{
 struct lsdc_device *ldev = lcrtc->ldev;

 lsdc_wreg32(ldev, LSDC_CRTC0_CFG_REG, CFG_RESET_N | LSDC_PF_XRGB8888);
}

static void lsdc_crtc1_reset(struct lsdc_crtc *lcrtc)
{
 struct lsdc_device *ldev = lcrtc->ldev;

 lsdc_wreg32(ldev, LSDC_CRTC1_CFG_REG, CFG_RESET_N | LSDC_PF_XRGB8888);
}

static const struct lsdc_crtc_hw_ops ls7a1000_crtc_hw_ops[2] = {
 {
  .enable = lsdc_crtc0_enable,
  .disable = lsdc_crtc0_disable,
  .enable_vblank = lsdc_crtc0_enable_vblank,
  .disable_vblank = lsdc_crtc0_disable_vblank,
  .flip = lsdc_crtc0_flip,
  .clone = lsdc_crtc0_clone,
  .set_mode = lsdc_crtc0_set_mode,
  .get_scan_pos = lsdc_crtc0_scan_pos,
  .soft_reset = lsdc_crtc0_soft_reset,
  .reset = lsdc_crtc0_reset,
 },
 {
  .enable = lsdc_crtc1_enable,
  .disable = lsdc_crtc1_disable,
  .enable_vblank = lsdc_crtc1_enable_vblank,
  .disable_vblank = lsdc_crtc1_disable_vblank,
  .flip = lsdc_crtc1_flip,
  .clone = lsdc_crtc1_clone,
  .set_mode = lsdc_crtc1_set_mode,
  .get_scan_pos = lsdc_crtc1_scan_pos,
  .soft_reset = lsdc_crtc1_soft_reset,
  .reset = lsdc_crtc1_reset,
 },
};

/*
 * The 32-bit hardware vblank counter has been available since LS7A2000
 * and LS2K2000. The counter increases even though the CRTC is disabled,
 * it will be reset only if the CRTC is being soft reset.
 * Those registers are also readable for ls7a1000, but its value does not
 * change.
 */

static u32 lsdc_crtc0_get_vblank_count(struct lsdc_crtc *lcrtc)
{
 struct lsdc_device *ldev = lcrtc->ldev;

 return lsdc_rreg32(ldev, LSDC_CRTC0_VSYNC_COUNTER_REG);
}

static u32 lsdc_crtc1_get_vblank_count(struct lsdc_crtc *lcrtc)
{
 struct lsdc_device *ldev = lcrtc->ldev;

 return lsdc_rreg32(ldev, LSDC_CRTC1_VSYNC_COUNTER_REG);
}

/*
 * The DMA step bit fields are available since LS7A2000/LS2K2000, for
 * supporting odd resolutions. But a large DMA step save the bandwidth.
 * The larger, the better. Behavior of writing those bits on LS7A1000
 * or LS2K1000 is underfined.
 */

static void lsdc_crtc0_set_dma_step(struct lsdc_crtc *lcrtc,
        enum lsdc_dma_steps dma_step)
{
 struct lsdc_device *ldev = lcrtc->ldev;
 u32 val = lsdc_rreg32(ldev, LSDC_CRTC0_CFG_REG);

 val &= ~CFG_DMA_STEP_MASK;
 val |= dma_step << CFG_DMA_STEP_SHIFT;

 lsdc_wreg32(ldev, LSDC_CRTC0_CFG_REG, val);
}

static void lsdc_crtc1_set_dma_step(struct lsdc_crtc *lcrtc,
        enum lsdc_dma_steps dma_step)
{
 struct lsdc_device *ldev = lcrtc->ldev;
 u32 val = lsdc_rreg32(ldev, LSDC_CRTC1_CFG_REG);

 val &= ~CFG_DMA_STEP_MASK;
 val |= dma_step << CFG_DMA_STEP_SHIFT;

 lsdc_wreg32(ldev, LSDC_CRTC1_CFG_REG, val);
}

static const struct lsdc_crtc_hw_ops ls7a2000_crtc_hw_ops[2] = {
 {
  .enable = lsdc_crtc0_enable,
  .disable = lsdc_crtc0_disable,
  .enable_vblank = lsdc_crtc0_enable_vblank,
  .disable_vblank = lsdc_crtc0_disable_vblank,
  .flip = lsdc_crtc0_flip,
  .clone = lsdc_crtc0_clone,
  .set_mode = lsdc_crtc0_set_mode,
  .soft_reset = lsdc_crtc0_soft_reset,
  .get_scan_pos = lsdc_crtc0_scan_pos,
  .set_dma_step = lsdc_crtc0_set_dma_step,
  .get_vblank_counter = lsdc_crtc0_get_vblank_count,
  .reset = lsdc_crtc0_reset,
 },
 {
  .enable = lsdc_crtc1_enable,
  .disable = lsdc_crtc1_disable,
  .enable_vblank = lsdc_crtc1_enable_vblank,
  .disable_vblank = lsdc_crtc1_disable_vblank,
  .flip = lsdc_crtc1_flip,
  .clone = lsdc_crtc1_clone,
  .set_mode = lsdc_crtc1_set_mode,
  .get_scan_pos = lsdc_crtc1_scan_pos,
  .soft_reset = lsdc_crtc1_soft_reset,
  .set_dma_step = lsdc_crtc1_set_dma_step,
  .get_vblank_counter = lsdc_crtc1_get_vblank_count,
  .reset = lsdc_crtc1_reset,
 },
};

static void lsdc_crtc_reset(struct drm_crtc *crtc)
{
 struct lsdc_crtc *lcrtc = to_lsdc_crtc(crtc);
 const struct lsdc_crtc_hw_ops *ops = lcrtc->hw_ops;
 struct lsdc_crtc_state *priv_crtc_state;

 if (crtc->state)
  crtc->funcs->atomic_destroy_state(crtc, crtc->state);

 priv_crtc_state = kzalloc(sizeof(*priv_crtc_state), GFP_KERNEL);

 if (!priv_crtc_state)
  __drm_atomic_helper_crtc_reset(crtc, NULL);
 else
  __drm_atomic_helper_crtc_reset(crtc, &priv_crtc_state->base);

 /* Reset the CRTC hardware, this is required for S3 support */
 ops->reset(lcrtc);
}

static void lsdc_crtc_atomic_destroy_state(struct drm_crtc *crtc,
        struct drm_crtc_state *state)
{
 struct lsdc_crtc_state *priv_state = to_lsdc_crtc_state(state);

 __drm_atomic_helper_crtc_destroy_state(&priv_state->base);

 kfree(priv_state);
}

static struct drm_crtc_state *
lsdc_crtc_atomic_duplicate_state(struct drm_crtc *crtc)
{
 struct lsdc_crtc_state *new_priv_state;
 struct lsdc_crtc_state *old_priv_state;

 new_priv_state = kzalloc(sizeof(*new_priv_state), GFP_KERNEL);
 if (!new_priv_state)
  return NULL;

 __drm_atomic_helper_crtc_duplicate_state(crtc, &new_priv_state->base);

 old_priv_state = to_lsdc_crtc_state(crtc->state);

 memcpy(&new_priv_state->pparms, &old_priv_state->pparms,
        sizeof(new_priv_state->pparms));

 return &new_priv_state->base;
}

static u32 lsdc_crtc_get_vblank_counter(struct drm_crtc *crtc)
{
 struct lsdc_crtc *lcrtc = to_lsdc_crtc(crtc);

 /* 32-bit hardware vblank counter */
 return lcrtc->hw_ops->get_vblank_counter(lcrtc);
}

static int lsdc_crtc_enable_vblank(struct drm_crtc *crtc)
{
 struct lsdc_crtc *lcrtc = to_lsdc_crtc(crtc);

 if (!lcrtc->has_vblank)
  return -EINVAL;

 lcrtc->hw_ops->enable_vblank(lcrtc);

 return 0;
}

static void lsdc_crtc_disable_vblank(struct drm_crtc *crtc)
{
 struct lsdc_crtc *lcrtc = to_lsdc_crtc(crtc);

 if (!lcrtc->has_vblank)
  return;

 lcrtc->hw_ops->disable_vblank(lcrtc);
}

/*
 * CRTC related debugfs
 * Primary planes and cursor planes belong to the CRTC as well.
 * For the sake of convenience, plane-related registers are also add here.
 */

#define REG_DEF(reg) { \
 .name = __stringify_1(LSDC_##reg##_REG), \
 .offset = LSDC_##reg##_REG, \
}

static const struct lsdc_reg32 lsdc_crtc_regs_array[2][21] = {
 [0] = {
  REG_DEF(CRTC0_CFG),
  REG_DEF(CRTC0_FB_ORIGIN),
  REG_DEF(CRTC0_DVO_CONF),
  REG_DEF(CRTC0_HDISPLAY),
  REG_DEF(CRTC0_HSYNC),
  REG_DEF(CRTC0_VDISPLAY),
  REG_DEF(CRTC0_VSYNC),
  REG_DEF(CRTC0_GAMMA_INDEX),
  REG_DEF(CRTC0_GAMMA_DATA),
  REG_DEF(CRTC0_SYNC_DEVIATION),
  REG_DEF(CRTC0_VSYNC_COUNTER),
  REG_DEF(CRTC0_SCAN_POS),
  REG_DEF(CRTC0_STRIDE),
  REG_DEF(CRTC0_FB1_ADDR_HI),
  REG_DEF(CRTC0_FB1_ADDR_LO),
  REG_DEF(CRTC0_FB0_ADDR_HI),
  REG_DEF(CRTC0_FB0_ADDR_LO),
  REG_DEF(CURSOR0_CFG),
  REG_DEF(CURSOR0_POSITION),
  REG_DEF(CURSOR0_BG_COLOR),
  REG_DEF(CURSOR0_FG_COLOR),
 },
 [1] = {
  REG_DEF(CRTC1_CFG),
  REG_DEF(CRTC1_FB_ORIGIN),
  REG_DEF(CRTC1_DVO_CONF),
  REG_DEF(CRTC1_HDISPLAY),
  REG_DEF(CRTC1_HSYNC),
  REG_DEF(CRTC1_VDISPLAY),
  REG_DEF(CRTC1_VSYNC),
  REG_DEF(CRTC1_GAMMA_INDEX),
  REG_DEF(CRTC1_GAMMA_DATA),
  REG_DEF(CRTC1_SYNC_DEVIATION),
  REG_DEF(CRTC1_VSYNC_COUNTER),
  REG_DEF(CRTC1_SCAN_POS),
  REG_DEF(CRTC1_STRIDE),
  REG_DEF(CRTC1_FB1_ADDR_HI),
  REG_DEF(CRTC1_FB1_ADDR_LO),
  REG_DEF(CRTC1_FB0_ADDR_HI),
  REG_DEF(CRTC1_FB0_ADDR_LO),
  REG_DEF(CURSOR1_CFG),
  REG_DEF(CURSOR1_POSITION),
  REG_DEF(CURSOR1_BG_COLOR),
  REG_DEF(CURSOR1_FG_COLOR),
 },
};

static int lsdc_crtc_show_regs(struct seq_file *m, void *arg)
{
 struct drm_info_node *node = (struct drm_info_node *)m->private;
 struct lsdc_crtc *lcrtc = (struct lsdc_crtc *)node->info_ent->data;
 struct lsdc_device *ldev = lcrtc->ldev;
 unsigned int i;

 for (i = 0; i < lcrtc->nreg; i++) {
  const struct lsdc_reg32 *preg = &lcrtc->preg[i];
  u32 offset = preg->offset;

  seq_printf(m, "%s (0x%04x): 0x%08x\n",
      preg->name, offset, lsdc_rreg32(ldev, offset));
 }

 return 0;
}

static int lsdc_crtc_show_scan_position(struct seq_file *m, void *arg)
{
 struct drm_info_node *node = (struct drm_info_node *)m->private;
 struct lsdc_crtc *lcrtc = (struct lsdc_crtc *)node->info_ent->data;
 int x, y;

 lcrtc->hw_ops->get_scan_pos(lcrtc, &x, &y);
 seq_printf(m, "Scanout position: x: %08u, y: %08u\n", x, y);

 return 0;
}

static int lsdc_crtc_show_vblank_counter(struct seq_file *m, void *arg)
{
 struct drm_info_node *node = (struct drm_info_node *)m->private;
 struct lsdc_crtc *lcrtc = (struct lsdc_crtc *)node->info_ent->data;

 if (lcrtc->hw_ops->get_vblank_counter)
  seq_printf(m, "%s vblank counter: %08u\n\n", lcrtc->base.name,
      lcrtc->hw_ops->get_vblank_counter(lcrtc));

 return 0;
}

static int lsdc_pixpll_show_clock(struct seq_file *m, void *arg)
{
 struct drm_info_node *node = (struct drm_info_node *)m->private;
 struct lsdc_crtc *lcrtc = (struct lsdc_crtc *)node->info_ent->data;
 struct lsdc_pixpll *pixpll = &lcrtc->pixpll;
 const struct lsdc_pixpll_funcs *funcs = pixpll->funcs;
 struct drm_crtc *crtc = &lcrtc->base;
 struct drm_display_mode *mode = &crtc->state->mode;
 struct drm_printer printer = drm_seq_file_printer(m);
 unsigned int out_khz;

 out_khz = funcs->get_rate(pixpll);

 seq_printf(m, "%s: %dx%d@%d\n", crtc->name,
     mode->hdisplay, mode->vdisplay, drm_mode_vrefresh(mode));

 seq_printf(m, "Pixel clock required: %d kHz\n", mode->clock);
 seq_printf(m, "Actual frequency output: %u kHz\n", out_khz);
 seq_printf(m, "Diff: %d kHz\n", out_khz - mode->clock);

 funcs->print(pixpll, &printer);

 return 0;
}

static struct drm_info_list lsdc_crtc_debugfs_list[2][4] = {
 [0] = {
  { "regs", lsdc_crtc_show_regs, 0, NULL },
  { "pixclk", lsdc_pixpll_show_clock, 0, NULL },
  { "scanpos", lsdc_crtc_show_scan_position, 0, NULL },
  { "vblanks", lsdc_crtc_show_vblank_counter, 0, NULL },
 },
 [1] = {
  { "regs", lsdc_crtc_show_regs, 0, NULL },
  { "pixclk", lsdc_pixpll_show_clock, 0, NULL },
  { "scanpos", lsdc_crtc_show_scan_position, 0, NULL },
  { "vblanks", lsdc_crtc_show_vblank_counter, 0, NULL },
 },
};

/* operate manually */

static int lsdc_crtc_man_op_show(struct seq_file *m, void *data)
{
 seq_puts(m, "soft_reset: soft reset this CRTC\n");
 seq_puts(m, "enable: enable this CRTC\n");
 seq_puts(m, "disable: disable this CRTC\n");
 seq_puts(m, "flip: trigger the page flip\n");
 seq_puts(m, "clone: clone the another crtc with hardware logic\n");

 return 0;
}

static int lsdc_crtc_man_op_open(struct inode *inode, struct file *file)
{
 struct drm_crtc *crtc = inode->i_private;

 return single_open(file, lsdc_crtc_man_op_show, crtc);
}

static ssize_t lsdc_crtc_man_op_write(struct file *file,
          const char __user *ubuf,
          size_t len,
          loff_t *offp)
{
 struct seq_file *m = file->private_data;
 struct lsdc_crtc *lcrtc = m->private;
 const struct lsdc_crtc_hw_ops *ops = lcrtc->hw_ops;
 char buf[16];

 if (len > sizeof(buf) - 1)
  return -EINVAL;

 if (copy_from_user(buf, ubuf, len))
  return -EFAULT;

 buf[len] = '\0';

 if (sysfs_streq(buf, "soft_reset"))
  ops->soft_reset(lcrtc);
 else if (sysfs_streq(buf, "enable"))
  ops->enable(lcrtc);
 else if (sysfs_streq(buf, "disable"))
  ops->disable(lcrtc);
 else if (sysfs_streq(buf, "flip"))
  ops->flip(lcrtc);
 else if (sysfs_streq(buf, "clone"))
  ops->clone(lcrtc);

 return len;
}

static const struct file_operations lsdc_crtc_man_op_fops = {
 .owner = THIS_MODULE,
 .open = lsdc_crtc_man_op_open,
 .read = seq_read,
 .llseek = seq_lseek,
 .release = single_release,
 .write = lsdc_crtc_man_op_write,
};

static int lsdc_crtc_late_register(struct drm_crtc *crtc)
{
 struct lsdc_display_pipe *dispipe = crtc_to_display_pipe(crtc);
 struct lsdc_crtc *lcrtc = to_lsdc_crtc(crtc);
 struct drm_minor *minor = crtc->dev->primary;
 unsigned int index = dispipe->index;
 unsigned int i;

 lcrtc->preg = lsdc_crtc_regs_array[index];
 lcrtc->nreg = ARRAY_SIZE(lsdc_crtc_regs_array[index]);
 lcrtc->p_info_list = lsdc_crtc_debugfs_list[index];
 lcrtc->n_info_list = ARRAY_SIZE(lsdc_crtc_debugfs_list[index]);

 for (i = 0; i < lcrtc->n_info_list; ++i)
  lcrtc->p_info_list[i].data = lcrtc;

 drm_debugfs_create_files(lcrtc->p_info_list, lcrtc->n_info_list,
     crtc->debugfs_entry, minor);

 /* Manual operations supported */
 debugfs_create_file("ops", 0644, crtc->debugfs_entry, lcrtc,
       &lsdc_crtc_man_op_fops);

 return 0;
}

static void lsdc_crtc_atomic_print_state(struct drm_printer *p,
      const struct drm_crtc_state *state)
{
 const struct lsdc_crtc_state *priv_state;
 const struct lsdc_pixpll_parms *pparms;

 priv_state = container_of_const(state, struct lsdc_crtc_state, base);
 pparms = &priv_state->pparms;

 drm_printf(p, "\tInput clock divider = %u\n", pparms->div_ref);
 drm_printf(p, "\tMedium clock multiplier = %u\n", pparms->loopc);
 drm_printf(p, "\tOutput clock divider = %u\n", pparms->div_out);
}

static const struct drm_crtc_funcs ls7a1000_crtc_funcs = {
 .reset = lsdc_crtc_reset,
 .destroy = drm_crtc_cleanup,
 .set_config = drm_atomic_helper_set_config,
 .page_flip = drm_atomic_helper_page_flip,
 .atomic_duplicate_state = lsdc_crtc_atomic_duplicate_state,
 .atomic_destroy_state = lsdc_crtc_atomic_destroy_state,
 .late_register = lsdc_crtc_late_register,
 .enable_vblank = lsdc_crtc_enable_vblank,
 .disable_vblank = lsdc_crtc_disable_vblank,
 .get_vblank_timestamp = drm_crtc_vblank_helper_get_vblank_timestamp,
 .atomic_print_state = lsdc_crtc_atomic_print_state,
};

static const struct drm_crtc_funcs ls7a2000_crtc_funcs = {
 .reset = lsdc_crtc_reset,
 .destroy = drm_crtc_cleanup,
 .set_config = drm_atomic_helper_set_config,
 .page_flip = drm_atomic_helper_page_flip,
 .atomic_duplicate_state = lsdc_crtc_atomic_duplicate_state,
 .atomic_destroy_state = lsdc_crtc_atomic_destroy_state,
 .late_register = lsdc_crtc_late_register,
 .get_vblank_counter = lsdc_crtc_get_vblank_counter,
 .enable_vblank = lsdc_crtc_enable_vblank,
 .disable_vblank = lsdc_crtc_disable_vblank,
 .get_vblank_timestamp = drm_crtc_vblank_helper_get_vblank_timestamp,
 .atomic_print_state = lsdc_crtc_atomic_print_state,
};

static enum drm_mode_status
lsdc_crtc_mode_valid(struct drm_crtc *crtc, const struct drm_display_mode *mode)
{
 struct drm_device *ddev = crtc->dev;
 struct lsdc_device *ldev = to_lsdc(ddev);
 const struct lsdc_desc *descp = ldev->descp;
 unsigned int pitch;

 if (mode->hdisplay > descp->max_width)
  return MODE_BAD_HVALUE;

 if (mode->vdisplay > descp->max_height)
  return MODE_BAD_VVALUE;

 if (mode->clock > descp->max_pixel_clk) {
  drm_dbg_kms(ddev, "mode %dx%d, pixel clock=%d is too high\n",
       mode->hdisplay, mode->vdisplay, mode->clock);
  return MODE_CLOCK_HIGH;
 }

 /* 4 for DRM_FORMAT_XRGB8888 */
 pitch = mode->hdisplay * 4;

 if (pitch % descp->pitch_align) {
  drm_dbg_kms(ddev, "align to %u bytes is required: %u\n",
       descp->pitch_align, pitch);
  return MODE_BAD_WIDTH;
 }

 return MODE_OK;
}

static int lsdc_pixpll_atomic_check(struct drm_crtc *crtc,
        struct drm_crtc_state *state)
{
 struct lsdc_crtc *lcrtc = to_lsdc_crtc(crtc);
 struct lsdc_pixpll *pixpll = &lcrtc->pixpll;
 const struct lsdc_pixpll_funcs *pfuncs = pixpll->funcs;
 struct lsdc_crtc_state *priv_state = to_lsdc_crtc_state(state);
 unsigned int clock = state->mode.clock;
 int ret;

 ret = pfuncs->compute(pixpll, clock, &priv_state->pparms);
 if (ret) {
  drm_warn(crtc->dev, "Failed to find PLL params for %ukHz\n",
    clock);
  return -EINVAL;
 }

 return 0;
}

static int lsdc_crtc_helper_atomic_check(struct drm_crtc *crtc,
      struct drm_atomic_state *state)
{
 struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc);

 if (!crtc_state->enable)
  return 0;

 return lsdc_pixpll_atomic_check(crtc, crtc_state);
}

static void lsdc_crtc_mode_set_nofb(struct drm_crtc *crtc)
{
 struct lsdc_crtc *lcrtc = to_lsdc_crtc(crtc);
 const struct lsdc_crtc_hw_ops *crtc_hw_ops = lcrtc->hw_ops;
 struct lsdc_pixpll *pixpll = &lcrtc->pixpll;
 const struct lsdc_pixpll_funcs *pixpll_funcs = pixpll->funcs;
 struct drm_crtc_state *state = crtc->state;
 struct drm_display_mode *mode = &state->mode;
 struct lsdc_crtc_state *priv_state = to_lsdc_crtc_state(state);

 pixpll_funcs->update(pixpll, &priv_state->pparms);

 if (crtc_hw_ops->set_dma_step) {
  unsigned int width_in_bytes = mode->hdisplay * 4;
  enum lsdc_dma_steps dma_step;

  /*
 * Using DMA step as large as possible, for improving
 * hardware DMA efficiency.
 */
  if (width_in_bytes % 256 == 0)
   dma_step = LSDC_DMA_STEP_256_BYTES;
  else if (width_in_bytes % 128 == 0)
   dma_step = LSDC_DMA_STEP_128_BYTES;
  else if (width_in_bytes % 64 == 0)
   dma_step = LSDC_DMA_STEP_64_BYTES;
  else  /* width_in_bytes % 32 == 0 */
   dma_step = LSDC_DMA_STEP_32_BYTES;

  crtc_hw_ops->set_dma_step(lcrtc, dma_step);
 }

 crtc_hw_ops->set_mode(lcrtc, mode);
}

static void lsdc_crtc_send_vblank(struct drm_crtc *crtc)
{
 struct drm_device *ddev = crtc->dev;
 unsigned long flags;

 if (!crtc->state || !crtc->state->event)
  return;

 drm_dbg(ddev, "Send vblank manually\n");

 spin_lock_irqsave(&ddev->event_lock, flags);
 drm_crtc_send_vblank_event(crtc, crtc->state->event);
 crtc->state->event = NULL;
 spin_unlock_irqrestore(&ddev->event_lock, flags);
}

static void lsdc_crtc_atomic_enable(struct drm_crtc *crtc,
        struct drm_atomic_state *state)
{
 struct lsdc_crtc *lcrtc = to_lsdc_crtc(crtc);

 if (lcrtc->has_vblank)
  drm_crtc_vblank_on(crtc);

 lcrtc->hw_ops->enable(lcrtc);
}

static void lsdc_crtc_atomic_disable(struct drm_crtc *crtc,
         struct drm_atomic_state *state)
{
 struct lsdc_crtc *lcrtc = to_lsdc_crtc(crtc);

 if (lcrtc->has_vblank)
  drm_crtc_vblank_off(crtc);

 lcrtc->hw_ops->disable(lcrtc);

 /*
 * Make sure we issue a vblank event after disabling the CRTC if
 * someone was waiting it.
 */
 lsdc_crtc_send_vblank(crtc);
}

static void lsdc_crtc_atomic_flush(struct drm_crtc *crtc,
       struct drm_atomic_state *state)
{
 spin_lock_irq(&crtc->dev->event_lock);
 if (crtc->state->event) {
  if (drm_crtc_vblank_get(crtc) == 0)
   drm_crtc_arm_vblank_event(crtc, crtc->state->event);
  else
   drm_crtc_send_vblank_event(crtc, crtc->state->event);
  crtc->state->event = NULL;
 }
 spin_unlock_irq(&crtc->dev->event_lock);
}

static bool lsdc_crtc_get_scanout_position(struct drm_crtc *crtc,
        bool in_vblank_irq,
        int *vpos,
        int *hpos,
        ktime_t *stime,
        ktime_t *etime,
        const struct drm_display_mode *mode)
{
 struct lsdc_crtc *lcrtc = to_lsdc_crtc(crtc);
 const struct lsdc_crtc_hw_ops *ops = lcrtc->hw_ops;
 int vsw, vbp, vactive_start, vactive_end, vfp_end;
 int x, y;

 vsw = mode->crtc_vsync_end - mode->crtc_vsync_start;
 vbp = mode->crtc_vtotal - mode->crtc_vsync_end;

 vactive_start = vsw + vbp + 1;
 vactive_end = vactive_start + mode->crtc_vdisplay;

 /* last scan line before VSYNC */
 vfp_end = mode->crtc_vtotal;

 if (stime)
  *stime = ktime_get();

 ops->get_scan_pos(lcrtc, &x, &y);

 if (y > vactive_end)
  y = y - vfp_end - vactive_start;
 else
  y -= vactive_start;

 *vpos = y;
 *hpos = 0;

 if (etime)
  *etime = ktime_get();

 return true;
}

static const struct drm_crtc_helper_funcs lsdc_crtc_helper_funcs = {
 .mode_valid = lsdc_crtc_mode_valid,
 .mode_set_nofb = lsdc_crtc_mode_set_nofb,
 .atomic_enable = lsdc_crtc_atomic_enable,
 .atomic_disable = lsdc_crtc_atomic_disable,
 .atomic_check = lsdc_crtc_helper_atomic_check,
 .atomic_flush = lsdc_crtc_atomic_flush,
 .get_scanout_position = lsdc_crtc_get_scanout_position,
};

int ls7a1000_crtc_init(struct drm_device *ddev,
         struct drm_crtc *crtc,
         struct drm_plane *primary,
         struct drm_plane *cursor,
         unsigned int index,
         bool has_vblank)
{
 struct lsdc_crtc *lcrtc = to_lsdc_crtc(crtc);
 int ret;

 ret = lsdc_pixpll_init(&lcrtc->pixpll, ddev, index);
 if (ret) {
  drm_err(ddev, "pixel pll init failed: %d\n", ret);
  return ret;
 }

 lcrtc->ldev = to_lsdc(ddev);
 lcrtc->has_vblank = has_vblank;
 lcrtc->hw_ops = &ls7a1000_crtc_hw_ops[index];

 ret = drm_crtc_init_with_planes(ddev, crtc, primary, cursor,
     &ls7a1000_crtc_funcs,
     "LS-CRTC-%d", index);
 if (ret) {
  drm_err(ddev, "crtc init with planes failed: %d\n", ret);
  return ret;
 }

 drm_crtc_helper_add(crtc, &lsdc_crtc_helper_funcs);

 ret = drm_mode_crtc_set_gamma_size(crtc, 256);
 if (ret)
  return ret;

 drm_crtc_enable_color_mgmt(crtc, 0, false, 256);

 return 0;
}

int ls7a2000_crtc_init(struct drm_device *ddev,
         struct drm_crtc *crtc,
         struct drm_plane *primary,
         struct drm_plane *cursor,
         unsigned int index,
         bool has_vblank)
{
 struct lsdc_crtc *lcrtc = to_lsdc_crtc(crtc);
 int ret;

 ret = lsdc_pixpll_init(&lcrtc->pixpll, ddev, index);
 if (ret) {
  drm_err(ddev, "crtc init with pll failed: %d\n", ret);
  return ret;
 }

 lcrtc->ldev = to_lsdc(ddev);
 lcrtc->has_vblank = has_vblank;
 lcrtc->hw_ops = &ls7a2000_crtc_hw_ops[index];

 ret = drm_crtc_init_with_planes(ddev, crtc, primary, cursor,
     &ls7a2000_crtc_funcs,
     "LS-CRTC-%u", index);
 if (ret) {
  drm_err(ddev, "crtc init with planes failed: %d\n", ret);
  return ret;
 }

 drm_crtc_helper_add(crtc, &lsdc_crtc_helper_funcs);

 ret = drm_mode_crtc_set_gamma_size(crtc, 256);
 if (ret)
  return ret;

 drm_crtc_enable_color_mgmt(crtc, 0, false, 256);

 return 0;
}