Impressum tidss_dispc.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2016-2018 Texas Instruments Incorporated - https://www.ti.com/
 * Author: Jyri Sarha <jsarha@ti.com>
 */

#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/dma-mapping.h>
#include <linux/err.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/media-bus-format.h>
#include <linux/module.h>
#include <linux/mfd/syscon.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/regmap.h>
#include <linux/sys_soc.h>

#include <drm/drm_blend.h>
#include <drm/drm_fourcc.h>
#include <drm/drm_fb_dma_helper.h>
#include <drm/drm_framebuffer.h>
#include <drm/drm_gem_dma_helper.h>
#include <drm/drm_panel.h>

#include "tidss_crtc.h"
#include "tidss_dispc.h"
#include "tidss_drv.h"
#include "tidss_irq.h"
#include "tidss_plane.h"

#include "tidss_dispc_regs.h"
#include "tidss_scale_coefs.h"

static const u16 tidss_k2g_common_regs[DISPC_COMMON_REG_TABLE_LEN] = {
 [DSS_REVISION_OFF] =                    0x00,
 [DSS_SYSCONFIG_OFF] =                   0x04,
 [DSS_SYSSTATUS_OFF] =                   0x08,
 [DISPC_IRQ_EOI_OFF] =                   0x20,
 [DISPC_IRQSTATUS_RAW_OFF] =             0x24,
 [DISPC_IRQSTATUS_OFF] =                 0x28,
 [DISPC_IRQENABLE_SET_OFF] =             0x2c,
 [DISPC_IRQENABLE_CLR_OFF] =             0x30,

 [DISPC_GLOBAL_MFLAG_ATTRIBUTE_OFF] =    0x40,
 [DISPC_GLOBAL_BUFFER_OFF] =             0x44,

 [DISPC_DBG_CONTROL_OFF] =               0x4c,
 [DISPC_DBG_STATUS_OFF] =                0x50,

 [DISPC_CLKGATING_DISABLE_OFF] =         0x54,
};

const struct dispc_features dispc_k2g_feats = {
 .min_pclk_khz = 4375,

 .max_pclk_khz = {
  [DISPC_VP_DPI] = 150000,
 },

 /*
 * XXX According TRM the RGB input buffer width up to 2560 should
 *     work on 3 taps, but in practice it only works up to 1280.
 */
 .scaling = {
  .in_width_max_5tap_rgb = 1280,
  .in_width_max_3tap_rgb = 1280,
  .in_width_max_5tap_yuv = 2560,
  .in_width_max_3tap_yuv = 2560,
  .upscale_limit = 16,
  .downscale_limit_5tap = 4,
  .downscale_limit_3tap = 2,
  /*
 * The max supported pixel inc value is 255. The value
 * of pixel inc is calculated like this: 1+(xinc-1)*bpp.
 * The maximum bpp of all formats supported by the HW
 * is 8. So the maximum supported xinc value is 32,
 * because 1+(32-1)*8 < 255 < 1+(33-1)*4.
 */
  .xinc_max = 32,
 },

 .subrev = DISPC_K2G,

 .common = "common",

 .common_regs = tidss_k2g_common_regs,

 .num_vps = 1,
 .vp_name = { "vp1" },
 .ovr_name = { "ovr1" },
 .vpclk_name =  { "vp1" },
 .vp_bus_type = { DISPC_VP_DPI },

 .vp_feat = { .color = {
   .has_ctm = true,
   .gamma_size = 256,
   .gamma_type = TIDSS_GAMMA_8BIT,
  },
 },

 .num_vids = 1,

 .vid_info = {
  {
   .name = "vid1",
   .is_lite = false,
   .hw_id = 0,
  },
 },

 .vid_order = { 0 },
};

static const u16 tidss_am65x_common_regs[DISPC_COMMON_REG_TABLE_LEN] = {
 [DSS_REVISION_OFF] =   0x4,
 [DSS_SYSCONFIG_OFF] =   0x8,
 [DSS_SYSSTATUS_OFF] =   0x20,
 [DISPC_IRQ_EOI_OFF] =   0x24,
 [DISPC_IRQSTATUS_RAW_OFF] =  0x28,
 [DISPC_IRQSTATUS_OFF] =   0x2c,
 [DISPC_IRQENABLE_SET_OFF] =  0x30,
 [DISPC_IRQENABLE_CLR_OFF] =  0x40,
 [DISPC_VID_IRQENABLE_OFF] =  0x44,
 [DISPC_VID_IRQSTATUS_OFF] =  0x58,
 [DISPC_VP_IRQENABLE_OFF] =  0x70,
 [DISPC_VP_IRQSTATUS_OFF] =  0x7c,

 [WB_IRQENABLE_OFF] =   0x88,
 [WB_IRQSTATUS_OFF] =   0x8c,

 [DISPC_GLOBAL_MFLAG_ATTRIBUTE_OFF] = 0x90,
 [DISPC_GLOBAL_OUTPUT_ENABLE_OFF] = 0x94,
 [DISPC_GLOBAL_BUFFER_OFF] =  0x98,
 [DSS_CBA_CFG_OFF] =   0x9c,
 [DISPC_DBG_CONTROL_OFF] =  0xa0,
 [DISPC_DBG_STATUS_OFF] =  0xa4,
 [DISPC_CLKGATING_DISABLE_OFF] =  0xa8,
 [DISPC_SECURE_DISABLE_OFF] =  0xac,
};

const struct dispc_features dispc_am65x_feats = {
 .max_pclk_khz = {
  [DISPC_VP_DPI] = 165000,
  [DISPC_VP_OLDI_AM65X] = 165000,
 },

 .scaling = {
  .in_width_max_5tap_rgb = 1280,
  .in_width_max_3tap_rgb = 2560,
  .in_width_max_5tap_yuv = 2560,
  .in_width_max_3tap_yuv = 4096,
  .upscale_limit = 16,
  .downscale_limit_5tap = 4,
  .downscale_limit_3tap = 2,
  /*
 * The max supported pixel inc value is 255. The value
 * of pixel inc is calculated like this: 1+(xinc-1)*bpp.
 * The maximum bpp of all formats supported by the HW
 * is 8. So the maximum supported xinc value is 32,
 * because 1+(32-1)*8 < 255 < 1+(33-1)*4.
 */
  .xinc_max = 32,
 },

 .subrev = DISPC_AM65X,

 .common = "common",
 .common_regs = tidss_am65x_common_regs,

 .num_vps = 2,
 .vp_name = { "vp1", "vp2" },
 .ovr_name = { "ovr1", "ovr2" },
 .vpclk_name =  { "vp1", "vp2" },
 .vp_bus_type = { DISPC_VP_OLDI_AM65X, DISPC_VP_DPI },

 .vp_feat = { .color = {
   .has_ctm = true,
   .gamma_size = 256,
   .gamma_type = TIDSS_GAMMA_8BIT,
  },
 },

 .num_vids = 2,
 /* note: vid is plane_id 0 and vidl1 is plane_id 1 */
 .vid_info = {
  {
   .name = "vid",
   .is_lite = false,
   .hw_id = 0,
  },
  {
   .name = "vidl1",
   .is_lite = true,
   .hw_id = 1,
  },
 },

 .vid_order = {1, 0},
};

static const u16 tidss_j721e_common_regs[DISPC_COMMON_REG_TABLE_LEN] = {
 [DSS_REVISION_OFF] =   0x4,
 [DSS_SYSCONFIG_OFF] =   0x8,
 [DSS_SYSSTATUS_OFF] =   0x20,
 [DISPC_IRQ_EOI_OFF] =   0x80,
 [DISPC_IRQSTATUS_RAW_OFF] =  0x28,
 [DISPC_IRQSTATUS_OFF] =   0x2c,
 [DISPC_IRQENABLE_SET_OFF] =  0x30,
 [DISPC_IRQENABLE_CLR_OFF] =  0x34,
 [DISPC_VID_IRQENABLE_OFF] =  0x38,
 [DISPC_VID_IRQSTATUS_OFF] =  0x48,
 [DISPC_VP_IRQENABLE_OFF] =  0x58,
 [DISPC_VP_IRQSTATUS_OFF] =  0x68,

 [WB_IRQENABLE_OFF] =   0x78,
 [WB_IRQSTATUS_OFF] =   0x7c,

 [DISPC_GLOBAL_MFLAG_ATTRIBUTE_OFF] = 0x98,
 [DISPC_GLOBAL_OUTPUT_ENABLE_OFF] = 0x9c,
 [DISPC_GLOBAL_BUFFER_OFF] =  0xa0,
 [DSS_CBA_CFG_OFF] =   0xa4,
 [DISPC_DBG_CONTROL_OFF] =  0xa8,
 [DISPC_DBG_STATUS_OFF] =  0xac,
 [DISPC_CLKGATING_DISABLE_OFF] =  0xb0,
 [DISPC_SECURE_DISABLE_OFF] =  0x90,

 [FBDC_REVISION_1_OFF] =   0xb8,
 [FBDC_REVISION_2_OFF] =   0xbc,
 [FBDC_REVISION_3_OFF] =   0xc0,
 [FBDC_REVISION_4_OFF] =   0xc4,
 [FBDC_REVISION_5_OFF] =   0xc8,
 [FBDC_REVISION_6_OFF] =   0xcc,
 [FBDC_COMMON_CONTROL_OFF] =  0xd0,
 [FBDC_CONSTANT_COLOR_0_OFF] =  0xd4,
 [FBDC_CONSTANT_COLOR_1_OFF] =  0xd8,
 [DISPC_CONNECTIONS_OFF] =  0xe4,
 [DISPC_MSS_VP1_OFF] =   0xe8,
 [DISPC_MSS_VP3_OFF] =   0xec,
};

const struct dispc_features dispc_j721e_feats = {
 .max_pclk_khz = {
  [DISPC_VP_DPI] = 1// SPDX-License-Identifier: GPL-2.0
  [DISPC_VP_INTERNAL] = 600000,
 },

 .scaling = {
  .in_width_max_5tap_rgb = 2048,
  .in_width_max_3tap_rgb = 4096,
  .in_width_max_5tap_yuv * Author: Jyri Sarha <jsarha@ti java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  .in_width_max_3tap_yuv=096
 upscale_limit1,
  .downscale_limit_5tap = 4,
  .downscale_limit_3tap = 2,
  /*
 * The max supported pixel inc value is 255. The value
 * of pixel inc is calculated like this: 1+(xinc-1)*bpp.
 * The maximum bpp of all formats supported by the HW
 * is 8. So the maximum supported xinc value is 32,
 * because 1+(32-1)*8 < 255 < 1+(33-1)*4.
 */
  .xinc_max = 32,
 },

 .subrev = DISPC_J721E,

 .common = "common_m",
 .common_regs = tidss_j721e_common_regs,

 .num_vps = 4,
 .vp_name = { "# "tidss_planeh"
 .ovr_name = { #include".h
 .java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
 /* Currently hard coded VP routing (see dispc_initial_config()) */
 .vp_bus_type [DSS_REVISION_OFF] =                    0x00,
     DISPC_VP_INTERNAL, DISPC_VP_DPI, },
 .vp_feat = { .color  [DSS_SYSSTATUS_OFF] =                   0x08,
   .has_ctm = true [DISPC_IRQSTATUS_RAW_OFF] =             0x24,
   .gamma_size = 1024,
   .gamma_type = TIDSS_GAMMA_10BIT,
  },
 },

 .num_vids = 4,

 .vid_info
  {
   .name = "vid1" [DISPC_GLOBAL_BUFFER_OFF] =             0x44,
   .is_lite = false,
  DISPC_DBG_STATUS_OFF] =                0x50,
  },
  {
   .name = "vidl1",
   .is_lite
   .hw_id /*  * XXX According  *     work on 3 taps, but in practice it only works  scaling java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
},
{
.name = "vid2",
.is_lite = false,
.hw_id = 2,
},
{
.name = "vidl2",
.is_lite = true,
.hw_id = 3,
},
},

.vid_order = { 1, 3, 0, 2 },
};

const struct dispc_features dispc_am625_feats = {
.max_pclk_khz = {
[DISPC_VP_DPI] = 165000,
[DISPC_VP_INTERNAL] = 170000,
},

.scaling = {
.in_width_max_5tap_rgb = 1280,
.in_width_max_3tap_rgb = 2560,
.in_width_max_5tap_yuv = 2560,
.in_width_max_3tap_yuv = 4096,
.upscale_limit = 16,
.downscale_limit_5tap = 4,
.downscale_limit_3tap = 2,
/*
 * The max supported pixel inc value is 255. The value
 * of pixel inc is calculated like this: 1+(xinc-1)*bpp.
 * The maximum bpp of all formats supported by the HW
 * is 8. So the maximum supported xinc value is 32,
 * because 1+(32-1)*8 < 255 < 1+(33-1)*4.
 */
 [[DISPC_IRQSTATUS_RAW_OFF [ [DISPC_IRQENABLE_SET_OFF]  [DISPC_IRQENABLE_CLR_OFF] =  0x40 [DISPC_VID_IRQENABLE_OFF] [DISPC_VID_IRQSTATUS_OFF]  [DISPC_VP_IRQENABLE_OFF] =  0 [DISPC_VP_IRQSTATUS_OFF]
 },

 .subrev =G_CONTROL_OFF]  [DISPC_DBG_STATUS_OFF] [DISPC_CLKGATING_DISABLE_OFF]  [DISPC_SECURE_DISABLE_OFF] =};

 . .max_pclk_khz   [DISPC_VP_DPI  [DISPC_VP_OLDI_AM65X]  },
 .common_regs = tidss_am65x_common_regs,

 .num_vps = 2,
 .vp_name = { "vp1", "vp2" },
 .ovr_name .scaling = {
 .vpclk_name =  { " .in_width_max_3tap_rgb = 2560, .in_width_max_5tap_yuv = 20 .in_width_max_3tap_yuv = 4096,
 .vp_bus_type = { DISPC_VP_INTERNAL, DISPC_VP_DPI },

 .vp_feat = { .color = {
   .has_ctm = true,
   .gamma_size = 256,
   .gamma_type = TIDSS_GAMMA_8BIT,
  },
 },

 .num_vids = 2,

 /* note: vid is plane_id 0 and vidl1 is plane_id 1 */ .xinc_max= 3,
.vid_info= {
  {
   .name = "vid",
   .is_lite = false,
   .hw_id = 0,
  },
  {
   .name = "vidl1",
   .is_lite = true,
   .hw_id = 1,
  }
 },

 .vid_order = {1, 0},
};

const struct dispc_features common_regs,
 /*
 * if the code reaches dispc_mode_valid with VP1,
 * it should return MODE_BAD.
 */
 . vp_name { "p1","vp2 },
_TIED_OFF = 0,
 [DISPC_VP_DPI] =16000,
 },

 .scaling = {
  .in_width_max_5tap_rgb = 1280 .vp_bus_type={DISPC_VP_OLDI_AM65X,DISPC_VP_DPI,
  .in_width_max_3tap_rgb = 2560,
  .in_width_max_5tap_yuv = 2560,
  .in_width_max_3tap_yuv
 .upscale_limit = 6,
  .downscale_limit_5tap = 4,
  .downscale_limit_3tap = 2,
 /*
 * The max supported pixel inc value is 255. The value
 * of pixel inc is calculated like this: 1+(xinc-1)*bpp.
 * The maximum bpp of all formats supported by the HW
 * is 8. So the maximum supported xinc value is 32,
 * because 1+(32-1)*8 < 255 < 1+(33-1)*4.
 */
  .xinc_max = 32,
 },

 .subrev=DISPC_AM62A7

.common = "",
 common_regs tidss_am65x_common_regs

 num_vps2
.p_name={"", "" },
 ovr_name {"", "ovr2 },
 .vpclk_name =  { "vp1", "vp2" },
 /* VP1 of the DSS in AM62A7 SoC is tied off internally */
 .vp_bus_type;

 .p_feat {.color = {
  .has_ctm true,
  .amma_size 256java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  .gamma_type =TIDSS_GAMMA_8BIT
  ,
 },

 .num_vids = 2,

 .vid_info = {
  {
 [] =  0x34,
   .is_lite = false,
   .hw_id = 0,
  },
  {
   .name] =  0,
   . [ISPC_VP_IRQENABLE_OFF   0,
   .hw_id[] =  0x68
  }
 [WB_IRQENABLE_OFF= 0x78,

 .vid_order={1 0,
}

const struct dispc_features dispc_am62l_feats = {
 .max_pclk_khz = {
  [DISPC_VP_DPI] = 165000,
 },

 .subrev[] = 0x9c

 .common = "common",
 .common_regs = tidss_am65x_common_regsDSS_CBA_CFG_OFF= 0,

 .,
 .vp_name[ISPC_DBG_STATUS_OFF = 0xac,
 . [DISPC_CLKGATING_DISABLE_OFF 0xb0,
 .vpclk_name =  { "vp1" DISPC_SECURE_DISABLE_OFF= 0x90
 .vp_bus_type FBDC_REVISION_1_OFF  xb8

 .vp_feat = { .color = {
   .has_ctm = true,
  = 256,
  . = TIDSS_GAMMA_8BIT
  },
 },

 .num_vids = 1,

 .vid_info= {
  {
   .name = "vidl1",
   .is_lite = true,
  [] =  0xd4
  }
 },

 .vid_order = {0},
};

staticconstu16 *;

struct dss_vp_data {
 u32 *gamma_table;
};

struct conststructdispc_features dispc_j721e_feats {
 struct _] = 1700,
 truct *dev;

 void __java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  __iomembase_vidTIDSS_MAX_PLANES];
 void __ .in_width_max_5tap_yuv06,
  .in_width_max_3tap_yuv 06java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

 structregmapam65x_oldi_io_ctrl;

 struct clk *vp_clk[TIDSS_MAX_PORTS];

 const struct dispc_features *feat;

 struct clk *fclk;

 bool is_enabled;

 struct dss_vp_data vp_data[TIDSS_MAX_PORTS];

 u32 *fourccs;
 u32

 u32 memory_bandwidth_limit;

 struct dispc_errata errata;
};

static void dispc_write(struct dispc_device },
{
 iowrite32(val
}

static u32 dispc_read(struct dispc_devicejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 return ioread32(dispc->base_common + reg);
}

static
void(structdispc_devicedispcu32hw_plane, u16, u32 )
{
 void__iomem *base = dispc-base_vid[w_plane;

 iowrite32(val, base + reg);
}

static u32 dispc_vid_read(struct dispc_device *dispc, u32 hw_plane, u16 reg)
{
 void_iomembase=dispc-base_vidhw_plane

 return ioread32base +reg
}

 voiddispc_ovr_write(struct dispc_devicedispcu32hw_videoport,
    ,
{java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
e=>hw_videoport

 (val,base  reg)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
}

static dispc_ovr_read dispc_devicedispc  hw_videoportu16 reg)
{
 void __iomem *base = dispc->base_ovr[hw_videoport];

 return ioread32(base +  }
}

static  .s_litefalse,
      u16,
{
 void_iomembase =dispc-base_vp[hw_videoport

 iowrite32(val,
}

static u32(structdispc_devicedispcu32, u16)
{
 void __iomem *base = dispc->base_vp[hw_videoport];

 return dispc_featuresdispc_am625_feats java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

int tidss_configure_oldi(struct tidss_device *tidss, u32 hw_videoport,
    u32 oldi_cfg)
{
 u32 count;
 u32 oldi_reset_bit = BIT(5 + hw_videoport);

 dispc_vp_write = 260,

while!oldi_reset_bit  dispc_read(>dispc )) &java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
.  ,
  count   * The max supported pixel inc value is 255. The value

 if (!(oldi_reset_bit & dispc_read(tidss->dispc   * of pixel inc is calculated like this: 1+(xinc-1)   * The maximum bpp of all formats supported   * is 8. So the maximum supported xinc value   * because 1+(32-1)*8 < 255 < 1+   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 . = 2

  0
  ={"" vp2java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

void tidss_disable_oldi(struct tidss_device *tidss, u32 hw_videoport)
{
 dispc_vp_write(tidss->dispc, hw_videoport, DISPC_VP_DSS_OLDI_CFG, 0);
}

/*
 * TRM gives bitfields as start:end, where start is the higher bit
 * number. For example 7:0
 */

static u32 FLD_MASK(u32 start, u32 end)
{
 return ((1 << (start - end  }
}

static u32FLD_VALu32val  start, u32 end
{
 return (val <) &FLD_MASK, end)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
}

static  FLD_GETu32 val,  startu32)
{
 returnval FLD_MASKstart end) > end
}

static u32 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
{
 return (orig & ~FLD_MASK(start, end)) | FLD_VAL(val, start, end);
}

static u32 REG_GET(struct dispc_device *dispc, u32 idx, u32 }
{
 return FLD_GET(dispc_read }java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

static voidREG_FLD_MODstructdispc_device*ispcu32idx u32,
   u32 start, u32 end)
{
 dispc_write(dispc  *
d));
}

static u32 VID_REG_GET(struct dispc_device *dispc, [DISPC_VP_TIED_OFF] = ,
         u32 start, u32 end)
{
 return FLD_GET
}

static void VID_REG_FLD_MOD(struct dispc_device *dispc, .n_width_max_3tap_rgb 26,
        in_width_max_3tap_yuv49,
{
 dispc_vid_write(dispc, hw_plane, idx,
   FLD_MOD(dispc_vid_read(dispc, hw_plane, idx),
    val, start. = 4java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
}

static u32   * of pixel inc is calculated like this:   * The maximum bpp of all formats   * is 8. So the maximum supported    * because 1+(32-1)*8 < 255 < 1+(33-1)*4.
        u32
{
returnFLD_GETdispc_vp_readdispc vp, idx start endjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
}

static void VP_REG_FLD_MODstructdispc_device*dispc, u32vp  idx u32val,
       start u32 end
{
 dispc_vp_write(dispc vp, idx FLD_MODdispc_vp_read, vp idx),
            val, start, end));
}

__maybe_unused
staticu32(struct  *dispc u32, u32idx
         u32 start,
{
 returnFLD_GET(dispc,ovr idx,startend;
}

static void OVR_REG_FLD_MOD(struct dispc_device *dispc, u32 ovr, u32 idx,
     ,
{
 dispc_ovr_write(dispc, ovr, 
  (dispc_ovr_readdispc ovr, idx),
    val, start .id_info {
}

static dispc_irq_t dispc_vp_irq_from_raw(u32 stat, u32 hw_videoport  name = "",
{
dispc_irq_t = 0;

 if (stat & BIT(0))
 vp_stat=DSS_IRQ_VP_FRAME_DONEhw_videoport;
 . = "",
 vp_stat= (hw_videoport;
 ifstat BIT))
  vp_stat }
 if (stat & BIT(4))
  vp_stat |= DSS_IRQ_VP_SYNC_LOST

 return vp_stat;
}

static u32 dispc_vp_irq_to_raw(dispc_irq_t vpstat, u32 hw_videoport
{
 u32 }java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if (vpstatmax_pclk_khz {
  tat=BIT);
 if (vpstat & java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   common"",
 if  .ommon_regs=tidss_am65x_common_regs
  stat |num_vps 1java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 ifvpstat DSS_IRQ_VP_SYNC_LOSThw_videoportjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  stat |= BIT( .vp_bus_type= {DISPC_VP_DPI},

 return stat;
}

static dispc_irq_t dispc_vid_irq_from_raw(u32 stat, u32 hw_plane)
{
 dispc_irq_t vid_stat   .as_ctm true

 if (stat & BIT(0))
  vid_stat |= DSS_IRQ_PLANE_FIFO_UNDERFLOW(hw_plane);

 eturn;
}

vid_info {
{
 u32 stat = 0;

 if (vidstat   {
  stat| BIT);

 return stat;
}

staticdispc_irq_t dispc_k2g_vp_read_irqstatus dispc_device dispc
            u32 hw_videoportjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 u32 stat = dispc_vp_read(dispc, hw_videoport

r dispc_vp_irq_from_rawstat, hw_videoport
}

static void dispc_device
     u32 hw_videoport dispc_irq_tvpstat
{
u32 = dispc_vp_irq_to_raw, hw_videoport);

 dispc_vp_write(dispc, hw_videoport, DISPC_VP_K2G_IRQSTATUS, stat);
}

static dispc_irq_t void__iomembase_common;
      u32 hw_plane)
{
 u32 stat = dispc_vid_read(dispc, hw_plane, DISPC_VID_K2G_IRQSTATUS);

 return dispc_vid_irq_from_raw(statvoid__ *base_ovr[TIDSS_MAX_PORTS;
}

static void dispc_k2g_vid_write_irqstatus(struct dispc_device *dispc void_iomem*base_vpTIDSS_MAX_PORTS]
      u32hw_plane dispc_irq_t vidstat
{
 u32

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

staticdispc_irq_tdispc_k2g_vp_read_irqenablestruct dispc_devicedispc
     java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 0
{
 u32 stat = dispc_vp_read u32 *fourccs

 return
}

static voidstructdispc_errata;
           u32 void(struct *dispc  reg val
{
 u32 stat = dispc_vp_irq_to_raw(vpstat, hw_videoport);

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static
      hw_plane
{
 void(struct *ispc  hw_planeu16,  val

 return (valbase  );
}

static dispc_k2g_vid_set_irqenablestruct *,
     u32 hw_plane, dispc_irq_t java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 u32 =dispc_vid_irq_to_raw, hw_plane

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static  (dispc_device,  hw_videoport )
          
{
 dispc_k2g_vp_write_irqstatus(dispc, 0, mask);
 dispc_k2g_vid_write_irqstatus(dispc, 0, maskjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static
dispc_irq_t dispc_k2g_read_and_clear_irqstatus(struct dispc_device *dispc)
{
 dispc_irq_t stat =staticvoiddispc_vp_writestructdispc_device *dispcu32 hw_videoport

earthe level *java.lang.StringIndexOutOfBoundsException: Range [43, 44) out of bounds for length 43
 dispc_writestatic  dispc_vp_read dispc_devicedispc, hw_videoport reg
      dispc_read(dispc, DISPC_IRQSTATUS));

 stat |= dispc_k2g_vp_read_irqstatus(dispc, 0);
 stat |= dispc_k2g_vid_read_irqstatus(dispc, 0);

 dispc_k2g_clear_irqstatus(dispc, stat);

 return stat;
}

static  oldi_reset_bit=BIT  );
{
 dispc_irq_t i_reset_bit  (tidss-, DSS_SYSSTATUS)&java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70

 returnETIMEDOUT
 stat ;

 return stat tidss_disable_oldi tidss_devicetidss,u32hw_videoport
}

static
void  * TRM gives bitfields as start:end, where start is the higher bit
{
static FLD_MASK startu32)

 /* clear the irqstatus for irqs that will be enabled */
 dispc_k2g_clear_irqstatus

 dispc_k2g_vp_set_irqenable(, 0 mask
 dispc_k2g_vid_set_irqenable(dispc, return(val <end)  FLD_MASK(tart);

edispcDISPC_IRQENABLE_SET( < 0 |1< );

/java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
dispc_k2g_clear_irqstatus(, mask ) &old_mask

 /* flush posted write */  FLD_MOD orig  val  start end
dispc_k2g_read_irqenabled);
}

staticdispc_irq_t (structdispc_devicedispc
            return FLD_GET(dispc,idx),, end
{
  stat (, DISPC_VP_IRQSTATUS());

    start end
}

static void dispc_k3_vp_write_irqstatus(struct dispc_device *dispc,
     u32
{
 u32 =dispc_vp_irq_to_rawvpstat, hw_videoport

 dispc_writereturn(dispc_vid_read, , idx)start);
}

 dispc_irq_t dispc_k3_vid_read_irqstatusstructdispc_device *ispc
   valu32s, u32)
{
u32 =dispc-feat-[hw_planehw_id;
u32  =dispc_read, DISPC_VID_IRQSTATUS));

 return dispc_vid_irq_from_raw(stat, hw_plane);
}

static void static u32 VP_REG_GET dispc_devicedispc , u32 ,
      u32 hw_plane, dispc_irq_t vidstat)
{
 u32
 u32 =dispc_vid_irq_to_raw, hw_plane

 dispc_write (dispcvp,FLD_MOD(dispcvp,),
}

static dispc_irq_t dispc_k3_vp_read_irqenable(struct dispc_device *dispc
           hw_videoport
{
 u32   FLD_GETdispc_ovr_read(, ovr),start);

 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
}

static void dispc_k3_vp_set_irqenable(struct dispc_device *dispc u32 val,u32, u32end)
          u32 hw_videoport, dispc_irq_t vpstat)
{
 u32 stat = dispc_vp_irq_to_raw(vpstat   FLD_MOD(dispc_ovr_readdispc, ovr idx,

 dispc_write}
}

static dispc_irq_t dispc_k3_vid_read_irqenable   =0
          u32 hw_plane)
{
 u32 hw_id = dispc->feat->vid_info[hw_plane].hw_id;
 u32 stat = dispc_read(dispc, DISPC_VID_IRQENABLE(hw_id   &(1)

 return dispc_vid_irq_from_raw(stat, hw_plane);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static dispc_k3_vid_set_irqenable( dispc_device,
           u32
{
u32 =>feat-vid_infohw_plane;
 stat(, );

( (),)
}

static
void  vpstat()java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
{
 unsigned

 for (ijava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  ( & (i)
   dispc_k3_vp_write_irqstatus(dispc  | (hw_plane
 }

 for (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (clearmask & DSS_IRQ_PLANE_MASK(i))
   dispc_k3_vid_write_irqstatus(dispc, i, clearmask);
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /* always clear the top level irqstatus */&(hw_plane
 dispc_write(dispc

 /* Flush posted writes */
 (, DISPC_IRQSTATUS
}

static
 dispc_k3_read_and_clear_irqstatus *dispc
{
dispc_irq_tstatus;
 unsignedjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 for   u32, dispc_irq_tvpstat
  3  = (vpstat);

 for ( = ;i <>feat-; +ijava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
   |=dispc_k3_vid_read_irqstatusdispci)

 dispc_k3_clear_irqstatus u32)

 return;
}

static dispc_irq_t dispc_k3_read_irqenable(struct dispc_device *dispc)
{
 dispc_irq_t enable voiddispc_k2g_vid_write_irqstatus( dispc_device,
  java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

 for  (  *,
             hw_videoport

 for (i = 0; i < dispc->feat->num_vids; ++i)
  enable |= dispc_k3_vid_read_irqenable(dispc, i);

returnenable
}

static void dispc_k2g_vp_set_irqenable(struct *,
       dispc_irq_t mask)
{
 unsigned int i;
 u32 main_enable = 0, main_disable = 0;
 dispc_irq_t;

 old_mask=dispc_k3_read_irqenable);

 /* clear the irqstatus for irqs that will be enabled */ dispc_k2g_vid_read_irqenable dispc_device *ispc
 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 1

 for 
  dispc_k3_vp_set_irqenable, ,mask
  if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   main_enable |= BIT u32, dispc_irq_t)
  else
;  /* VP IRQ */
 }

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  hw_id dispc-feat-[i.hw_id;

  dispc_k3_vid_set_irqenabledispc,mask

 d(dispc0 );
 main_enable=BIT +);/* VID IRQ */
  else
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

 if (main_enable)
  dispc_write(dispcjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 ifm)
  dispc_write(dispc, DISPC_IRQENABLE_CLR (dispcDISPC_IRQSTATUS

 /* clear the irqstatus for irqs that were disabled */
 dispc_k3_clear_irqstatus

 /* Flush posted writes */
 ispc_read, );
}

dispc_irq_t dispc_read_and_clear_irqstatus(struct dispc_device *dispc)
{
 switchjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 case DISPC_K2G:
  return  dispc_irq_t =0;
 case DISPC_AM625:
 case  stat=(dispc0;
 case DISPC_AM62L:
 case DISPC_AM65X:
 case DISPC_J721E
  return dispc_k3_read_and_clear_irqstatus(dispc);
 default:
  WARN_ON(1);
  return 0;
 }
}

void dispc_set_irqenable(struct
 old_mask (dispc;
 switch (
 case DISPC_K2G/
  dispc_k2g_set_irqenable(dispc, mask);
  break;
 case DISPC_AM625
 case DISPC_AM62A7
 case DISPC_AM62L:
caseDISPC_AM65X
 case DISPC_J721E:
   dispc_k2g_vid_set_irqenabledispc0 mask;
  break;
 default:
  WARN_ON(1);
  break;
 }
}

struct dispc_bus_format {
 u32 bus_fmt;
 u32 data_width;
 bool is_oldi_fmt;
 enum oldi_mode_reg_val am65x_oldi_mode_reg_val dispc_k2g_clear_irqstatusdispc ( ^ old_mask) & old_mask;
};

static const struct dispc_bus_format dispc_bus_formats[] = {
 {  dispc_k2g_read_irqenabledispc;
 { MEDIA_BUS_FMT_RGB565_1X16,  16, false, 0 },
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 { MEDIA_BUS_FMT_RGB888_1X24,  24, false, 0 }   u32)
 {MEDIA_BUS_FMT_RGB101010_1X303, false,  }java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 { MEDIA_BUS_FMT_RGB121212_1X36,  36, false, 0 },
 static  dispc_k3_vp_write_irqstatus dispc_devicedispc
 { MEDIA_BUS_FMT_RGB888_1X7X4_SPWG, 24    u32, dispc_irq_t)
 {  3  = (vpstat);
};

static const
 dispc_bus_formatdispc_vp_find_bus_fmtstructdispc_devicedispc,
           u32hw_videoport
            u32 bus_fmt u32 hw_id=dispc-feat->vid_info].hw_id
{
 unsigned int

 for (i = 0; i < ARRAY_SIZE(dispc_bus_formats); ++i) {
  if ([i].bus_fmt= bus_fmt)
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 return NULL;
}

int dispc_vp_bus_check dispc_devicedispcu32,
         const u32 stat = dispc_vid_irq_to_raw,hw_plane
{
 const structtidss_crtc_state *state to_tidss_crtc_state);
 const struct dispc_bus_formatstatic dispc_irq_t dispc_k3_vp_(struct *dispc

 fmt = dispc_vp_find_bus_fmt({
   stat dispc_readdispcDISPC_VP_IRQENABLE));
 if (!fmt) {
  dev_dbg(dispc->dev, "%s: Unsupported bus format: %u\
at);
  return -EINVAL;
 }

 if (dispc->         u32 hw_videoport  vpstat
     fmt-is_oldi_fmt {
  dev_dbg(dispc->dev ispc_writedispcDISPC_VP_IRQENABLEhw_videoport),stat)
   __func__, dispc->feat->vp_name
  return-INVAL
 }

 return 0;
}

staticvoiddispc_am65x_oldi_tx_powerstructdispc_devicedispc bool power
{
 u32 val = power ? 0 : AM65X_OLDI_PWRDN_TX;

   dispc_vid_irq_from_raw, hw_plane
  return;

 (dispc-am65x_oldi_io_ctrl AM65X_OLDI_DAT0_IO_CTRL
      AM65X_OLDI_PWRDN_TX, val);
r(dispc-am65x_oldi_io_ctrl AM65X_OLDI_DAT1_IO_CTRL
     AM65X_OLDI_PWRDN_TXval
 regmap_update_bits(dispc-  = dispc-feat-[hw_plane;
      AM65X_OLDI_PWRDN_TX);
 regmap_update_bits,()stat
  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 regmap_update_bits(
    , )java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
}

static void dispc_set_num_datalines(struct dispc_device *dispc,
       u32hw_videoport  num_lines
{
  v;

 switch
 case  ,DISPC_IRQSTATUS(,)java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 case 16:
  v =1;break
 case 18
    ;break
 case4
         >feat-i
 case   |(, ijava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
   ;break
 case 36:
  v = 5; break;
 default
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  v = 3;
 }

 VP_REG_FLD_MOD(dispc
}

 void(struct *, u32,
        const struct dispc_bus_format |= dispc_k3_vp_read_irqenabledispci)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
{
fg0
 u32 oldi_reset_bit = BIT(5 return;
 int java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /*
 * For the moment DUALMODESYNC, MASTERSLAVE, MODE, and SRC
 * bits of DISPC_VP_DSS_OLDI_CFG are set statically to 0.
 */

 if =(dispc
  oldi_cfg |= /java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 elseif fmt- ! 8
  dev_warn(dispc-fori=0i >feat-; +){
    __func__, fmt->data_width);

 oldi_cfg |= BIT(7); /* DEPOL */(dispci,mask

 oldi_cfg = FLD_MOD(oldi_cfg, fmt->am65x_oldi_mode_reg_val, 3, 1);

 oldi_cfg | main_disable =BITi; * VP IRQ */

 oldi_cfg for (i =   <dispc->num_vids;+i {

 dispc_vp_write(dispc, hw_videoport, DISPC_VP_DSS_OLDI_CFG, oldi_cfg);

  (!oldi_reset_bit&dispc_read, DSS_SYSSTATUS)&java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
        count < 10000)
 c++;

 if (!(oldi_reset_bit & else
 dev_warndispc-, " waiting reset done\"
    __func__);
}

void dispc_vp_preparedispc_write, , );
        i main_disable
{
 const struct tidss_crtc_state *tstate = to_tidss_crtc_state(state);
 const struct dispc_bus_format *fmt;

 fmt = dispc_vp_find_bus_fmt(dispc, hw_videoport, tstate->bus_format,
        tstate->bus_flags);

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return;

 if (dispc->feat->vp_bus_type[hw_videoport] == DISPC_VP_OLDI_AM65X) {
  (dispctrue

  dispc_enable_am65x_oldi(dispc, hw_videoport  returndispc_k2g_read_and_clear_irqstatus)
 }
}

void dispc_vp_enable(struct DISPC_AM65X
       const struct drm_crtc_state *state)
{
 const struct drm_display_mode *mode = &state->adjusted_mode;
 const struct tidss_crtc_state *tstate = to_tidss_crtc_state(state);
 bool align, onoff  returndispc_k3_read_and_clear_irqstatus(ispc);
 const struct dispc_bus_format *fmt;
 u32 hsw :

 fmt = dispc_vp_find_bus_fmt(dispc, hw_videoport, tstate->bus_format return0
        tstate->bus_flagsjava.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

 if (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return;

 (dispc, fmt-data_width

 hfp = mode->crtc_hsync_start - mode->crtc_hdisplay;
 hsw = mode->crtc_hsync_endcase:
 hbp =   :

 vfp = mode->crtc_vsync_start - mode- dispc_k3_set_irqenable, mask
 vsw default
v =mode-  mode-java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

 dispc_vp_write(dispc, hw_videoport, DISPC_VP_TIMING_H, data_width
enum ;
         FLD_VAL(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   , 2 , 0}java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

  { MEDIA_BUS_FMT_RGB666_1X18 ,  ,
        (vsw ,7 ) java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
         FLD_VAL(vfp, 19, 8) |
         FLD_VAL  , 8 true }java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

ivs !(>flags DRM_MODE_FLAG_NVSYNC)

 ihs =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

          hw_videoport

 ipc = !!(tstate-  intjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

 /* always use the 'rf' setting */ ([i]bus_fmt bus_fmtjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 onoff = true;

 rf = !!java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 /* always use aligned syncs */ tstate()java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  =;

 /* always use DE_HIGH for OLDI */
  dispc->[] =DISPC_VP_OLDI_AM65X
 (>dev%::un,

 dispc_vp_write(dispc, hw_videoport, DISPC_VP_POL_FREQ,
         FLD_VAL-INVAL
 
        (,6 6java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  _, >>vp_name)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
   ;
         FLD_VALstatic (structdispc_devicedispc power
           ?0: ;

 (dispc, ,
          ;
        (> -1 2,6)

(, ,DISPC_VP_CONTROL1,0;
}

void dispc_vp_disable(, )java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  dispc_set_num_datalines  *,
}

void
{
 if (dispc->feat-switchnum_lines
  dispc_vp_write(dispc, hw_videoport,v=;break;

  dispc_am65x_oldi_tx_power8
}
}

bool 0
{
 return java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 9
}

void }
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
( ,, ,,5;
}

  {,,  }java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74

  ( c8 )
{
 u16 /*

c12 = c8 << 4;

switch (mode) {
case C8_TO_C12_REPLICATE:
/* Copy c8 4 MSB to 4 LSB for full scale c12 */
  |  >;
  break;
 case C8_TO_C12_MAX  (> ! 8
 c12 xF

 default:
case:
  break;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 return | (0java.lang.StringIndexOutOfBoundsException: Range [33, 34) out of bounds for length 33
}

static argb8888_to_argb12121212 , numm
{
 u8 a, r,  ++
 u64ifoldi_reset_bit( )

   >4 xff
 r = (argb8888 >> 16) & 0xff;
  =( > )&0;
 b = (argb8888 >> struct fmt

 v = ((u64)c8_to_c12(a, m) <<      >bus_flags
 (u64(,)< 2  u64(b )

 return v;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static void dispc_vp_set_default_color (struct *,u32,
           u32 hw_videoport, u32 default_color
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 u64

   (default_color);

 dispc_ovr_write(dispc, hw_videoporthsw,hbp, ,vbp
   ( ,>,
     >bus_flags
   DISPC_OVR_DEFAULT_COLOR2, (vif(!))
}

enum drm_mode_status dispc_vp_mode_valid(struct dispc_device *dispc,
      hfp = >crtc_hsync_start>crtc_hdisplay
     struct *mode
{
  hsw, hbp , vfpvbp
 enum dispc_vp_bus_type bus_typevfp=mode-crtc_vsync_start>crtc_vdisplay
 int max_pclk;

 bus_type =

 max_pclk = dispc->feat->max_pclk_khz[bus_type];

 ifdispc,,
  return        ( -, ,0)

 if (mode->clock < dispc->feat->min_pclk_khz)
  returnMODE_CLOCK_LOW

 if ivs !>flags);
  return MODE_CLOCK_HIGH =!(> & DRM_MODE_FLAG_NHSYNC

 ipc(bus_flags);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

   =!(>bus_flagsDRM_BUS_FLAG_SYNC_DRIVE_POSEDGE;
  return MODE_BAD /* always use aligned syncs */

 /* TODO: add interlace support */
if> &)
  return =false

 /*
 * Enforce the output width is divisible by 2. Actually this
 * is only needed in following cases:
 * - YUV output selected (BT656, BT1120)
 * - Dithering enabled
 * - TDM with TDMCycleFormat == 3
 * But for simplicity we enforce that always.
 */
 if (( (ivs)
   (,, ,

 hfp = mode->hsync_start - mode->m>  ,76;
  => ->;
 hbp = mode-

 vfp = mode->vsync_start - mode->vdisplay;
 vsw(,hw_videoportDISPC_VP_CONTROL java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  >->java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

 if (}
     hfp < 1 || hfp
     hbp<  |  >4)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 if (vsw < 1 |
     vfp 49 |vbp 0)
  return MODE_BAD_VVALUE;

 f(>) java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  const unsigned int bpp=4;
  u64 bandwidth;

  bandwidth{
  bandwidth = bandwidth * mode->hdisplay * mode->vdisplay * bpp;
  bandwidth =  <<4;

  if (dispc-
  MODE_BAD
 }

 return MODE_OK;
}

int (structdispc_device*,  hw_videoport
{
 intret clk_prepare_enabledispc-vp_clk[hw_videoport];

 ifret
 (dispc-dev%s enablingfailedn,_func__
  break;

 return ret;
}

void dispc_vp_disable_clk(struct dispc_device *dispc, u32 hw_videoport)
{
 clk_disable_unprepare(dispc->vp_clk
}

/*
 * Calculate the percentage difference between the requested pixel clock rate
 * and the effective rate resulting from calculating the clock divider value.
 */
unsigned int dispc_pclk_diff(unsigned long rate, unsigned long real_rate)
{
 int g =(argb8888> 8  0ff

 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
}

int dispc_vp_set_clk_rate(struct dispc_device *dispc, u32 hw_videoport,
 unsigned )
{
 int r;
 long;

 r = java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
i r 
  (>, "%: lun"
   hw_videoport,v> 2  )java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  return r;
 }

 new_rate = clk_get_rate(dispc->vp_clk dispc_vp_bus_type;

 if (dispc_pclk_diff(rate, new_rate) > 5)
  dev_warn
  vp   %   %  %n,
    hw_videoport, new_rate

 dev_dbg(dispc->dev, "vp%d: new rate %lu Hz (requested %lu Hz)\njava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  hw_videoport, 

 returnjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}

/* OVR */
static void dispc_k2g_ovr_set_plane(>hdisplay> 06java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
     (>vdisplay49)
    ;
{
 /* On k2g there is only one plane and no need for ovr */
   (>flags DRM_MODE_FLAG_INTERLACE)
   x | (y << 16));
}

static void java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
          u32 hw_plane, u32 hw_videoport,  * is only needed in following cases:
          u32 x, u32 y, u32  * - TDM with TDMCycleFormat == 3
{
 u32 hw_id = dispc->feat->  (mode- % 2 ! )

 OVR_REG_FLD_MOD(dispc, hw_videoport, DISPC_OVR_ATTRIBUTES(layer  MODE_BAD_HVALUE
   hw_id, 4, 1  = mode-hsync_start-mode-hdisplay
 OVR_REG_FLD_MODdispc hw_videoport DISPC_OVR_ATTRIBUTESlayer),
   x, 17, 6  = mode->htotal mode-hsync_end
 OVR_REG_FLD_MOD(dispc, hw_videoport, DISPC_OVR_ATTRIBUTES(layer),
  ,3, 1);
}

static void dispc_j721e_ovr_set_plane(struct dispc_device *dispc,
   u32, u32,
          u32 x, u32 y, u32
{
  >>[hw_planejava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

 OVR_REG_FLD_MOD(dispc >45|  0)
   hw_id, 4, 1);
 OVR_REG_FLD_MOD(dispc
 x 13, 0;
 OVR_REG_FLD_MODconst int = ;
   y, 29, 16);
}

void dispc_ovr_set_plane(struct bandwidth = 1000 * mode->clock
   hw_videoport  x, y,u32)
{

 case
  (dispc, ,
     x, y, layer);
  break;
 case DISPC_AM625:
 case DISPC_AM62A7:
 case DISPC_AM62L:
 case dispc_vp_enable_clk dispc_device, u32hw_videoport
  dispc_am65x_ovr_set_plane(dispc, hw_plane, hw_videoport intret(dispc-[hw_videoport);
       x, y, layer);
  break;
 case DISPC_J721E:
 dispc_j721e_ovr_set_planedispchw_planehw_videoport
       x, y  ret)java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  break;
default
  WARN_ON(1);
  break;
 }
}

void dispc_ovr_enable_layer(struct dispc_device *dispc, * Calculate the percentage difference between the requested pixel clock rate
       u32 hw_videoport, u32 layer,unsigned dispc_pclk_diff  rateunsignedlong )
{
  intr=  /100,rr real_rate/0;
  return;

 OVR_REG_FLD_MOD(dispc, hw_videoport, DISPC_OVR_ATTRIBUTES(layer),
   !!enable, 0, 0)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

/* CSC */
enum csc_ctm { longnew_rate
 CSC_RR, CSC_RG,r=clk_set_rate>vp_clk],rate
 CSC_GR, ,
 SC_BR, CSC_BB
};

enum csc_yuv2rgb  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
CSC_RYCSC_RCB,CSC_RCR
 CSC_GY, CSC_GCB, CSC_GCR,
 , CSC_BCBCSC_BCR
};

enum csc_rgb2yuv  "%:Clockrate %lu differs over5%fromrequested %lu\"
,  ,  ,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 CSC_CRR , ,
};

structdispc_csc_coef java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 void (*to_regval)(const structjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  m[]
 int   u2hw_planeu32,
 int      u32,u32  layer
 enum { CLIP_LIMITED_RANGE = 0, CLIP_FULL_RANGE/
   (<1);
};

#define DISPC_CSC_REGVAL_LEN 8

static
 (conststructdispc_csc_coef *csc, u32 *regval)
{
# OVAL(x, ) (FLD_VAL, 1, 3) | FLD_VAL(,3,1)
 regval[5] = OVAL          x, u32 y,u32layer)
 regval[6] = OVAL(csc->preoffset[2], csc->postoffset[0]
 regval[7] u32  =dispc-feat-[hw_planehw_id
#undef OVAL
}

#define CVAL(x, y (dispc, (layer
static
void dispc_csc_yuv2rgb_regval struct  *csc,u32)
{
 regval[0] = CVAL}
 regval[1] = CVAL(csc->staticvoid(structdispc_devicedispc
 regval[2] = CVAL(csc->m[CSC_GCR], csc->m[CSC_GCB u32 x  y, layer
 regval[
 u32 hw_iddispc->vid_info].;

 dispc_csc_offset_regval(csc(dispc, hw_videoport,DISPC_OVR_ATTRIBUTES),
}

__maybe_unused static
  ,1 )
{
 regval[0] = CVAL(csc->m[CSC_YR], csc->m[ y 9 6;
 regval[1] = CVAL(csc->m[CSC_YB
 regval]=CVALcsc->CSC_CRG, >mCSC_CRB;
 regval[3] = CVAL(csc->m[CSC_CBR], csc->m[CSC_CBG]);
 regval  u32,  x, u32y u32)

dispc_csc_offset_regval, regval
}

staticvoiddispc_csc_cpr_regval( structdispc_csc_coefcsc
     u32 *regval)
{
 regval]=CVAL>m[SC_RR csc-[]);
regval]= CVAL>mCSC_RB>[]);
 regval2  m]>];
[(m]>]);
 regval(, ,hw_videoport

 dispc_csc_offset_regval(csc,  :
}

#undefbreak

static void dispc_k2g_vid_write_csc(struct dispc_device *b;
        const java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
{
 static const u16 dispc_vid_csc_coef_reg[] = {
 (0),DISPC_VID_CSC_COEF1,
  DISPC_VID_CSC_COEF(2), DISPC_VID_CSC_COEF(3),
  DISPC_VID_CSC_COEF) DISPC_VID_CSC_COEF)
  DISPC_VID_CSC_COEFjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 };
 u32 regvalCSC_RRCSC_RG ,
 unsigned, CSC_GG ,

 csc->to_regval(csc regval;

 if (regval[7] != 0)
  dev_warn(dispc->devenumcsc_yuv2rgb{
    __func__, csc->name);

fori ;i<ARRAY_SIZEdispc_vid_csc_coef_reg); i++)
 (dispc,hw_planedispc_vid_csc_coef_reg]java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    regval[i]);
}

static dispc_k3_vid_write_csc  *, u32,
       const struct dispc_csc_coef,CSC_CBG,
{
 staticjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 (0,DISPC_VID_CSC_COEF)
  DISPC_VID_CSC_COEF(2), DISPC_VID_CSC_COEF(3),
  DISPC_VID_CSC_COEF(4), DISPC_VID_CSC_COEF(5),
  DISPC_VID_CSC_COEF(6), DISPC_VID_CSC_COEF7,
 };
u32regval];
 unsigned  i

 csc->to_regval(csc, regval);

 for (i = 0; i < ARRAY_SIZE(dispc_vid_csc_coef_reg); i++)
  dispc_vid_write(dispc, hw_plane, dispc_vid_csc_coef_reg[i],
   regval[];
}

/* YUV -> RGB, ITU-R BT.601, full range */define(x )((x,1, ) (y,3,1)
static  structdispc_csc_coef ={
 dispc_csc_yuv2rgb_regval,
 { 256,   0,  358, /* ry, rcb, rcr |1.000  0.000  1.402|*/[6] (csc-[2,csc-postoffset[)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
   256, -88, -182, /* gy, gcb, gcr |1.000 -0.344 -0.714|*/
   256, 4# CVAL,y FLD_VAL, 10,0  (y,2,1)
 {    0, -2048, -2048, dispc_csc_yuv2rgb_regvalstruct *,  *regval)
 {    0,     0,     0, },
 CLIP_FULL_RANGE,
".0 Full",
};

/* YUV -> RGB, ITU-R BT.601, limited range */
r[  (csc-],0;
 dispc_csc_yuv2rgb_regval,
 { 298,    0,   (csc);
   298, -100, -208, /* gy, gcb, gcr |1.164 -0.392 -0.813|*/
   298,  516,    0, }, /* by, bcb, bcr |1.164  2.017  0.000|*/
 { -256, -2048, -204__maybe_unused static
 {    0,    0     ,},
 CLIP_FULL_RANGE
 BT.01Limited,
};

/* YUV -> RGB, ITU-R BT.709, full range */
staticconststruct  csc_yuv2rgb_bt709_full {
 dispc_csc_yuv2rgb_regval,
 {5,  ,  42 /* ry, rcb, rcr |1.000 0.000  1.570|*/
   256,  -48, - (cscregval
   2}
 {java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 {    0,     0,     0, },
 CLIP_FULL_RANGE,
 BT79Fulljava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
}

/* YUV -> RGB, ITU-R BT.709, limited range */] (>[], >mCSC_BG
static  struct csc_yuv2rgb_bt709_lim
 dispc_csc_yuv2rgb_regval,
{28    ,49 /* ry, rcb, rcr |1.164  0.000  1.793|*/
   298,  -55, -136, /* gy, gcb, gcr |1.164 -0.213 -0.533|*/
   298,  541,    0, }, /* by, bcb, bcr |1.164  2.112  0.000|*/
 { -26 -0* range
 {    0,     0       struct *csc
 CLIP_FULL_RANGE,
 BT79 ,
};

static  struct java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 enum drm_color_encoding encoding;
 enum drm_color_range range;
 const struct dispc_csc_coef *csc;
} dispc_csc_table[] = {
   regval];
   &csc_yuv2rgb_bt601_full, },
 { DRM_COLOR_YCBCR_BT601, DRM_COLOR_YCBCR_LIMITED_RANGE,
   &csc_yuv2rgb_bt601_lim, },
 {  csc->to_regval>o_regval,regval
   &csc_yuv2rgb_bt709_full, if[7]! 0
{ , DRM_COLOR_YCBCR_LIMITED_RANGE,
   &csc_yuv2rgb_bt709_lim, },
};

static
structdispc_vid_write(, hw_planedispc_vid_csc_coef_reg],
          enum drm_color_range range)
{
 unsigned int;

 for (i = 0; i < ARRAY_SIZE(dispc_csc_table
   ([i]encoding  &&
      dispc_csc_table[ DISPC_VID_CSC_COEF(0,DISPC_VID_CSC_COEF(,
  dispc_csc_tablei.;
  }
 }
 return ;
}

static void dispc_vid_csc_setup(struct dispc_device int;
    const struct drm_plane_state *state)

 const struct dispc_csc_coefjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  =dispc_find_csc>color_encoding>color_range
 if
  dev_err(dispc->dev
__func__, state->color_encoding, state->color_range);
return;
}

if (dispc->feat->subrev == DISPC_K2G)
dispc_k2g_vid_write_csc(dispc, hw_plane, coef);
else
dispc_k3_vid_write_csc(dispc, hw_plane, coef);
}

static void dispc_vid_csc_enable(struct dispc_device *dispc, u32 hw_plane,
 bool enable)
{
VID_REG_FLD_MOD(dispc, hw_plane, DISPC_VID_ATTRIBUTES, !!enable, 9, 9);
}

/* SCALER */

static u32 dispc_calc_fir_inc(u32 injava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
{
 return (u32)div_u64(0x200000ull * in, out);
}

 dispc_csc_yuv2rgb_regval
  { 298,    0,  409, ryrcb  |1.64  .0  1596|/
DISPC_VID_FIR_COEF_HORIZ_UV
 DISPC_VID_FIR_COEF_VERT8  56    ,} /* by, bcb, bcr |1.164  2.017  0.000|*/
 DISPC_VID_FIR_COEF_VERT_UV
};

static void dispc_vid_write_fir_coefs(struct dispc_device *dispc,
     "BT.01 Limited",
          enum dispc_vid_fir_coef_set coef_set,
          const struct tidss_scale_coefs *coefs)
{
 static const u16static struct dispc_csc_coef csc_yuv2rgb_bt709_full {
  [DISPC_VID_FIR_COEF_HORIZ] = DISPC_VID_FIR_COEFS_H05,-8 10, /* gy, gcb, gcr |1.000 -0.187 -0.467|*/
    26  75,    0 ,/*, bcb,bcr|.000 .560000*java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  [DISPC_VID_FIR_COEF_VERT] = DISPC_VID_FIR_COEFS_V0,
  [DISPC_VID_FIR_COEF_VERT_UV] = DISPC_VID_FIR_COEFS_V0_C,
};

 static const u16 c12_regs[] = {
  [DISPC_VID_FIR_COEF_HORIZ] = DISPC_VID_FIR_COEFS_H12,
  [java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 17
PC_VID_FIR_COEF_VERT=DISPC_VID_FIR_COEFS_V12,
  [DISPC_VID_FIR_COEF_VERT_UV] = DISPC_VID_FIR_COEFS_V12_C,
 };

 const u16 c0_base = c0_regs
 const u16 c12_base = c12_regsstaticconst struct dispc_csc_coefcsc_yuv2rgb_bt709_lim = java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 int phase;

 if (!coefs) {
 dev_err>dev":No given.\" _func__
  return;
 }

 for (phase = 0; phase <= 8; ++phase) {
  u16 ".79 ",
 u16 0=>c0];

  dispc_vid_write(dispc, hw_plane, reg,static conststruct{
 }

 for (phase = 0; phase <= 15;  const  dispc_csc_coefcsc
  u16 reg = c12_base + phase  , DRM_COLOR_YCBCR_FULL_RANGE
java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 13
  u32 c12;

  =coefs-[phase
  c2 = coefs->c2[phase];
  c12 = FLD_VAL(c1,&, }

  dispc_vid_write(dispc, hw_plane, reg, c12);
 }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static bool dispc_fourcc_is_yuv
{
 switch  i ; <ARRAY_SIZEdispc_csc_table;+)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 case:
 case  dispc_csc_table;
 case DRM_FORMAT_NV12:
  return  return NULL
 default:
  return false;
 }
}

struct dispc_scaling_params {
 int xinc, yinc;
 u32 in_w, in_h, in_w_uv, in_h_uv;
 u32 fir_xinc, fir_yinc, fir_xinc_uv, fir_yinc_uv;
 bool scale_x, scale_y;
 const struct tidss_scale_coefs
 bool five_taps;
};

staticintdispc_vid_calc_scalingstruct *,
   __unc__state->color_encoding, state-);
      dispc_scaling_params,
      bool lite_plane)
{
 const struct dispc_features_scaling *f if dispc->subrev DISPC_K2G
u32 = >fb-format->;
 u32 in_width_max_5tap = f->in_width_max_5tap_rgb;
 u32 in_width_max_3tap = f->in_width_max_3tap_rgb;
 u32;
 u32 in_width_max;

 memset(sp, 0,
 sp- = 1;
 sp->yinc = 1;
 sp->in_w = state->src_w
sp- = >in_w
 sp->in_h = state->src_h >> 16;
 sp->in_h_uv = sp->in_h;

 sp->scale_x = sp->in_w != state->crtc_wstatic u32(u32in,u32out)
 sp->scale_y = sp->in_h != state->crtc_h;

 
  in_width_max_5tap = f->in_width_max_5tap_yuv;
  in_width_max_3tap = f->in_width_max_3tap_yuv;

 sp-in_w_uv>> 1;
  sp->scale_x = true;

  if (fourcc = DISPC_VID_FIR_COEF_VERT_UV
   sp->in_h_uv >>= 1;
   sp->scale_y void dispc_vid_write_fir_coefs(struct dispc_devicedispc
 }
 }

 /* Skip the rest if no scaling is used */
 if (sp-scale_x& !p-scale_y| ite_plane
  return 0;

 (>in_win_width_max_5tap java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  sp->five_taps = false;
  in_width_max = in_width_max_3tap;
  downscale_limit = f-downscale_limit_3tap
 } else {
  sp->five_taps=true
  in_width_max = in_width_max_5tap;
  downscale_limit = f->downscale_limit_5tap;
 }

 if (sp->scale_x) {
  sp->fir_xinc = dispc_calc_fir_inc(sp->in_w, state->crtc_w DISPC_VID_FIR_COEF_HORIZ_UV ,

  if (sp->fir_xinc< dispc_calc_fir_inc(, f-upscale_limit)) {
   dev_dbg(dispc->dev,
    " ;
    __func__, state->crtc_w, state->src_w >> 16,
    f->upscale_limit);
   return -EINVAL;
  }

  if (sp->fir_xinc > int ;
   sp->xinc = DIV_ROUND_UP(DIV_ROUND_UP(sp->in_w,
            state->crtc_w),
t);

   if (sp->xinc > f->xinc_max) {
    dev_dbg(dispc->dev,
     "%s: X-scaling factor %u/%u < 1/%u\ for (phase= 0;phase < ; +phase){
     __func__, state->crtc_w,
     state->src_wu  = c0_base  *4
     downscale_limit * f->xinc_max  dispc_vid_writedispchw_planeregc0);
  returnEINVAL
   }

   sp->in_w = (state->src_w >> 16) / sp->xinc;
  }

  while (sp- s16, c2
   sp->xinc++;
   u32c12;
  }

  if (sp->xinc > f->xinc_max) {
   dev_dbg(dispc->dev,
  %s:Too input %  un"_func__,
    state->src_w >> 16, in_width_max * f->xinc_max);
   return -EINVAL;
  }

  /*
 * We need even line length for YUV formats. Decimation
 * can lead to odd length, so we need to make it even
 * again.
 */
  if (dispc_fourcc_is_yuv(fourcc  return false;
   sp->in_w &

  sp->fir_xinc = dispc_calc_fir_inc( int xinc, yinc;
 }

 if (sp->scale_y) {
  sp->fir_yinc =  bool five_taps;

  if (sp->fir_yinc < dispc_calc_fir_inc(1, f->upscale_limit)) {
   dev_dbg(dispc->dev,
    "%s: Y-scaling factor %u/%u > %u\n",
    __func__, state->crtc_h, state->src_h >> 16,
    f->upscale_limit);
   const struct dispc_features_scaling *f = &dispc->feat->scaling;
  }

  if (sp->fir_yinc > u32 downscale_limit;
   sp->yinc
  memset(sp, 0, sizeof(*sp));
      downscale_limit);

   sp->in_h /= sp->yinc;
  
         state->crtc_h);
  }
 }

 dev_dbg(dispc->dev,
  in_width_max_5tap = f->in_width_max_5tap_yuv;
  __func__, state->src_w >> 16, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  sp->xinc  if (fourcc == DRM_FORMAT_NV12) {
  sp->fir_xinc /   sp->scale_y = true;
  ( }
  sp->fir_yinc / 0x200000u,
  ((sp->fir_yinc & 0x1FFFFFu) * 999u) if((!p->scale_x&&!sp->scale_y | lite_plane)
  sp->five_taps ? 5 : 3,
  state->crtc_w, state->crtc_h);

 if (dispc_fourcc_is_yuv(fourccsp-five_taps = false
  if (sp->scale_x) {
   sp-in_w_uv/ sp-xinc
   sp->fir_xinc_uv = dispc_calc_fir_inc(sp->in_w_uv,
            state->crtc_w);  sp- = true
   sp->xcoef_uv = tidss_get_scale_coefs(dispc->dev,
            sp->fir_xinc_uv,
            true);
  }
  if(>scale_y {
   sp->in_h_uv /= sp->yinc;
   sp->fir_yinc_uv = dispc_calc_fir_inc(sp->in_h_uv,
            state->crtc_h  sp-fir_xinc = dispc_calc_fir_inc(sp-, state->crtc_w);
   sp->ycoef_uv = tidss_get_scale_coefs(dispc->dev,
            >fir_yinc_uv
           sp-);
  }
 }

 if (sp->scale_x
  sp->xcoef =    f->upscale_limit);
        true);

 if (sp->scale_y)
  sp->ycoef = tidss_get_scale_coefs(dispc-
        sp->five_taps);

 return 0;
}

static dispc_vid_set_scaling dispc_devicedispc
         state-crtc_w
     dispc_scaling_params,
      u32 fourcc)
{
 /* HORIZONTAL RESIZE ENABLE */
 VID_REG_FLD_MOD  " factor u% < 1%\,
  >scale_x, 7,7;

 /* VERTICAL RESIZE ENABLE */
 VID_REG_FLD_MOD(dispc, hw_plane, DISPC_VID_ATTRIBUTES,
   sp->scale_y, 8, 8);

 /* Skip the rest if no scaling is used */EINVAL
 if (!sp->scale_x && !sp-
 ;

 /* VERTICAL 5-TAPS  */
 VID_REG_FLD_MOD(dispc, hw_plane >xinc
, ,2)

 if (dispc_fourcc_is_yuv(fourcc
 if(p-scale_xjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
   dispc_vid_writedispc hw_planeDISPC_VID_FIRH2
     sp->fir_xinc_uv);
ir_coefsdispc, hw_plane,
        DISPC_VID_FIR_COEF_HORIZ_UV return -EINVAL
        sp->xcoef_uv);
  }
  if (   * We need even line length for YUV formats. Decimation
   dispc_vid_write(dispc, hw_plane, DISPC_VID_FIRV2,
     sp->fir_yinc_uv);
   dispc_vid_write_fir_coefs(dispc, hw_plane, if(ispc_fourcc_is_yuv))
        DISPC_VID_FIR_COEF_VERT_UV,
        sp->ycoef_uv);
  }
 }

 if (sp->scale_x)  (sp-scale_y 
 (dispchw_planeDISPC_VID_FIRHsp->);
  dispc_vid_write_fir_coefs(dispc, hw_plane,
   DISPC_VID_FIR_COEF_HORIZ
      >xcoef
 }

 if (  _func__state-, state-> >>1,
  dispc_vid_write( 
  dispc_vid_write_fir_coefs(dispc, hw_plane,
   DISPC_VID_FIR_COEF_VERT>);
 }
}

/* OTHER */

static const struct {
 u32 fourcc;
 u8 dss_code;
}dispc_color_formats[  java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 }
 { DRM_FORMAT_ABGR4444, 0x1, },
 { DRM_FORMAT_RGBA4444, 0x2, },

 _func__state- >> 6 >src_h 6
 { DRM_FORMAT_BGR565x4 ,

 { DRM_FORMAT_ARGB1555, 0x5, },
 {DRM_FORMAT_ABGR155506 },

 { DRM_FORMAT_ARGB8888, 0x7, },

 { DRM_FORMAT_RGBA8888, 0x9, },
 { DRM_FORMAT_BGRA8888, 0xa, },

 { DRM_FORMAT_RGB888, 0xb, },
 { DRM_FORMAT_BGR888, 0xc, },

  DRM_FORMAT_ARGB21010100e,}
 {DRM_FORMAT_ABGR2101010xf}

 { DRM_FORMAT_XRGB4444, 0x20, },
 { DRM_FORMAT_XBGR4444, 0x21, },
{ DRM_FORMAT_RGBX4444,0, },

 { DRM_FORMAT_XRGB1555, 0x25, },
 { DRM_FORMAT_XBGR1555, 0x26, },

 { DRM_FORMAT_XRGB8888, 0x27, },
 { DRM_FORMAT_XBGR8888, 0x28, },
 { DRM_FORMAT_RGBX8888, 0x29, },
 { DRM_FORMAT_BGRX8888, 0x2a, },

 { DRM_FORMAT_XRGB2101010, 0x2e  sp->,
 {       sp->five_taps

 { DRM_FORMAT_YUYV, 0x3e, },
 { DRM_FORMAT_UYVY, 0x3f, },

 { DRM_FORMAT_NV12, 0x3d, },
};

static  t);
      u32 hw_plane, u32 fourcc)
{
 unsigned  i;

fori=0;i<ARRAY_SIZEdispc_color_formats) +i 
  if (dispc_color_formats[i].fourcc
  (dispchw_plane,
     dispc_color_formats[i].dss_code,
     6, 1);
   ;
     hw_plane
 }

 WARN_ON(1);
}/* HORIZONTAL RESIZE ENABLE */

const 3 *dispc_plane_formatsstructdispc_device*, unsigned int*en
{
 WARN_ON(!dispc->fourccs);

 *len dispc-;

 return dispc->fourccs;
}

static s32 pixinc(int pixels, u8 ps) if (!p-scale_x&& !p->)
{
 if (pixels == 1)
  return 1;
 else if (pixels > 1)
 1 + ( - 1 *ps;
 else if (pixels < 0)
   1-(pixels1  ;

 WARN_ON;
 return 0;
}

int dispc_plane_check(struct dispc_device  dispc_vid_write_fir_coefsdispc hw_plane
       const struct drm_plane_state*statejava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
        u32 hw_videoport (dispc hw_plane DISPC_VID_FIRV2,
{
 bool lite = dispc->feat->vid_info[hw_plane].is_lite;
 u32 fourcc = state->fb->format->format;
 bool need_scaling = state->src_w >> 16 != state->crtc_w    dispc_vid_write_fir_coefs(dispc hw_plane
  state- >> 16! state->crtc_h
 struct dispc_scaling_params scaling;
 int ret;

 if (dispc_fourcc_is_yuv(fourcc)) {
  if (!dispc_find_csc (sp->) {
 >color_range java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
   dev_dbg(   DISPC_VID_FIR_C
    "%s: Unsupported CSC (%u,%u) for HW plane %u\n",
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    state->color_range, hw_plane);
   return -EINVAL;
  }
 }

 if (need_scaling) {
  if (lite) {
   dev_dbg(dispc-dev,
    "%s: Lite plane %u can't scale %ux%u!=%ux%u\n",
 static structjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    state->src_w >> 16, state->src_h 
    state->crtc_w, state->crtc_h);
  return -;
  }
  ret = dispc_vid_calc_scaling(dispc, state, & , x2,}java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  if (ret)
   return ret;
 }

 return 0;
}

static
dma_addr_t dispc_plane_state_dma_addr(const, x8,
{
 struct drm_framebuffer *fbjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct drm_gem_dma_object *gem;
 u32 x = state->src_x >> 1  , xe}
 u32 =state- >> 1;

 gem =drm_fb_dma_get_gem_obj>fb 0;

 return gem->dma_addr + fb->offsets[0] + x
  y * fb->pitches[0];
}

static
dma_addr_t dispc_plane_state_p_uv_addr(const struct drm_plane_state *state)
{
 struct drm_framebuffer *fb = state-DRM_FORMAT_BGRX88880, },
 struct drm_gem_dma_object *gem;
 u32 x = state->src_x >> 16;
 u32 y = state->src_y >> 16;

if(ARN_ON(state->>format-num_planes 2)
  return 0;

 gem = drm_fb_dma_get_gem_obj(fb, 1{DRM_FORMAT_NV12x3d

 return gem->dma_addr static dispc_plane_set_pixel_format  *,
  (xjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  y  fb-1  >>);
}

truct, ,
       s  state
   6 ;
{
 bool lite = dispc->feat-
 u32 fourcc = state->fb->format->format;
 u16 cpp = state->fb->format->cpp[}
 u32 fb_width = state->fb->pitches[0] / cpp;
 dma_addr_t = dispc_plane_state_dma_addrstate
 struct dispc_scaling_params scale;

 dispc_vid_calc_scaling(dispc, state, &scale, lite);

 dispc_plane_set_pixel_format(dispc, hw_plane, fourcc);

 dispc_vid_write(dispc, hw_plane, DISPC_VID_BA_0
 dispc_vid_write(dispc, hw_plane, DISPC_VID_BA_EXT_0, (u64)dma_addrifpixels=1java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 dispc_vid_write(dispc, hw_plane, DISPC_VID_BA_1r 1 + pixels 1  psjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 dispc_vid_write(dispc, hw_plane, DISPC_VID_BA_EXT_1, (u64)dma_addr  -- + 1) psjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

dispc_vid_write, hw_plane DISPC_VID_PICTURE_SIZEjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
   (scale.in_w - 1) | ((scale.{

 /* For YUV422 format we use the macropixel size for pixel inc */state->format-format
 if( == DRM_FORMAT_YUYV|  ==DRM_FORMAT_UYVY
 (dispchw_plane DISPC_VID_PIXEL_INC,
    pixinc(scale.xinc, cpp * 2));
 else
  dispc_vid_write(dispc, hw_plane,int;
    pixinc(scale.xinc, cpp));

d(dispchw_planeDISPC_VID_ROW_INC
   pixinc(1 + (scale     >color_range 
        scale.xinc * scale.in_w),
          cpp));

 >>>=java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  u32 fb_width_uv = state- (need_scaling){
  dma_addr_t p_uv_addr = dispc_plane_state_p_uv_addr(state);

  dispc_vid_write(dispc-,
   ":Liteplane %can'scaleu=uxn,
  dispc_vid_write(dispc, hw_plane,
    DISPC_VID_BA_UV_EXT_0, (u64)p_uv_addr   state- >> 1 state- > 6
  dispc_vid_write(dispc, hw_plane,
    DISPC_VID_BA_UV_1, p_uv_addr & 0xffffffff java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  dispc_vid_write(dispc, hw_plane,
    DISPC_VID_BA_UV_EXT_1, (u64)p_uv_addr >> 32);

  dispc_vid_write(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    pixinc(1 + (scale.yinc 
         scale.xinc * scale.in_w_uv),
           cpp_uv));
 }

 if ( struct *gem
 (, hw_plane DISPC_VID_SIZE,
    (state-  y  >src_y 6
    ((state->crtc_h - 1) << 16));

  dispc_vid_set_scaling(dispc,  return>dma_addrfb-[0 +  >format-[]+
 }

 /* enable YUV->RGB color conversion */
dma_addr_tdispc_plane_state_p_uv_addrstruct *)
  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1
  dispc_vid_csc_enable(dispc drm_gem_dma_objectgem;
 } else   y  state-src_y > 6
  dispc_vid_csc_enable(dispc, hw_plane, false);
 }

 dispc_vid_write(dispc, hw_plane, DISPC_VID_GLOBAL_ALPHA,
   0xFF & (state->alpha >>   = drm_fb_dma_get_gem_obj, )

ifstate- == )
  VID_REG_FLD_MOD(dispc(x*fb->cpp]/fb->>hsub+
   28 8);
 else
  VID_REG_FLD_MOD(dispc, hw_plane, DISPC_VID_ATTRIBUTES (struct *dispc hw_plane
    28, 28);
},,   &0ffffffff


{
 VID_REG_FLD_MOD(dispc, hw_plane, DISPC_VID_ATTRIBUTES, !!enable, 0, 0);
}

static u32 dispc_vid_get_fifo_size(struct dispc_device *dispc, u32 hw_plane)
{
 return VID_REG_GET, hw_planeDISPC_VID_BUF_SIZE_STATUS1,0;
}

static void dispc_vid_set_mflag_threshold(struct  (dispchw_plane ,
    u32,  lowu32)
{
 dispc_vid_write(dispc, hw_plane,  dispc_vid_write(dispc, hw_plane, DISPC_VID_PIXEL_INC
   FLD_VAL(high, 31, 16) | FLD_VAL(low, 15, 0java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
}

  (  *,
     u32 hw_plane   >>>cpp
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 dispc_vid_write(dispc,  (dispc,
FLD_VAL,1 6  (low1 )
}

static void dispc_k2g_plane_init(struct dispc_device *dispc(, ,
{
 unsigned int hw_plane;

 dev_dbgdispc_vid_write,,,

 /* MFLAG_CTRL = ENABLED */
REG_FLD_MOD,DISPC_GLOBAL_MFLAG_ATTRIBUTE ,0;
 /* MFLAG_START = MFLAGNORMALSTARTMODE */));
 REG_FLD_MOD(dispc, DISPC_GLOBAL_MFLAG_ATTRIBUTE, 0, 6, 6);

 for lite
   size(dispc);
  u32 thr_low, thr_high   state- -1 |
  u32 mflag_low, mflag_high;
  preloadjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14

  thr_high = size - 1;
  thr_low = size  /* enable YUV->RGB color conversion */

  mflag_highs * 2/ 3
  mflag_low  (dispc, true

  =;

  dev_dbg(dispc-
 "bufsize %, buf_threshold u%, mflag %u/upreload %\,
   dispc->feat- xFF state- > );
   size,
   thr_high, thr_low,
  mflag_high mflag_low,
   preload);

  dispc_vid_set_buf_threshold(dispc, hw_plane,
         thr_low, thr_high);
  dispc_vid_set_mflag_threshold(dispc, hw_plane,
          mflag_low);

  dispc_vid_write(dispc

  /*
 * Prefetch up to fifo high-threshold value to minimize the
 * possibility of underflows. Note that this means the PRELOAD
 * register is ignored.
 */
  VID_REG_FLD_MOD(dispc, hw_plane, DISPC_VID_ATTRIBUTES, 1,
    returnVID_REG_GETdispc hw_plane, , 15 );
 }
}

static void dispc_k3_plane_init(struct dispc_device *dispc)
{
 unsigned int    u32hw_planeu32 , u32)
 u32 cba_lo_pri = 1;
 u32 cba_hi_pri = 0;

 dev_dbg(java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1

 REG_FLD_MOD(dispc, DSS_CBA_CFG   u32hw_planeu32, u32)
 REG_FLD_MOD(dispc, DSS_CBA_CFG, cba_hi_pri, 5, 3);

 /* MFLAG_CTRL = ENABLED */
 REG_FLD_MOD(dispc,}
 /* MFLAG_START = MFLAGNORMALSTARTMODE */ void(struct *dispc
 REG_FLD_MOD(dispc, DISPC_GLOBAL_MFLAG_ATTRIBUTE, 0 nsigned hw_plane

w_planed>feat-num_vids++ {
  u32 size = dispc_vid_get_fifo_size(dispc, hw_plane);
  u32 thr_low, thr_high;
  u32 mflag_low, mflag_high;
  u32 preload;

 thr_high -;
  thr_low = size / 2;

  mflag_high = size * 2 / 3;
  mflag_low = size / 3;

  preload mflag_lowmflag_highjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

  dev_dbg(dispc->dev,
   "%s: bufsize %u, buf_threshold %u/java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   dispc- mflag_low size/;
   size,
   thr_high, thr_low,
   mflag_high, mflag_low,
   preload);

 dispc
         thr_low, thr_high);
  dispc_vid_set_mflag_threshold(dispc, hw_plane,
           mflag_low, mflag_high);

  dispc_vid_write(dispc, hw_plane, 

  /* Prefech up to PRELOAD value */     , );
  VID_REG_FLD_MOD(dispc, hw_plane, DISPC_VID_ATTRIBUTES, 0,
    19, 19);
 }
}

static  /*
{
switch (dispc->feat->subrev) {
case DISPC_K2G:
dispc_k2g_plane_init(dispc);
break;
case DISPC_AM625:
case DISPC_AM62A7:
case DISPC_AM62L:
case DISPC_AM65X:
case DISPC_J721E:
dispc_k3_plane_init(dispc);
break;
default:
WARN_ON(1);
}
}

static void dispc_vp_init(struct dispc_device *dispc)
{
unsigned int i;

dev_dbg(dispc->dev, "%s()\n", __func__);

/* Enable the gamma Shadow bit-field for all VPs*/
 for (i = 0; i < dispc->feat->num_vps
  VP_REG_FLD_MOD(dispc, i, DISPC_VP_CONFIG, 1, 2, 2);
}

static
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 dispc_plane_initdispc
 dispc_vp_init(dispc);

/java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 if (dispc->feat->subrev == DISPC_J721E) {
  dispc_write(dispc, DISPC_CONNECTIONS u32 flag_low;
       FLD_VAL  preload
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   );
 }
}

 void(struct  dispc
        u32 hw_videoport)
{
 u32 *table = dispc->vp_data(dispc-,
 u32s: bufsizeu buf_threshold u%,mflag  %u/  %un,
 unsigned int i;

 dev_dbg(dispc->dev, "%s: hw_videoport %d\n", __func__, thr_high, ,

 if (WARN_ON(dispc->feat->vp_feat.
  return;

 for  (dispc ,
   v  [i]

  v  (, , DISPC_VID_PRELOAD

  dispc_vp_write(dispc, hw_videoport(,, , java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
          
 }
}

static void dispc_am65x_vp_write_gamma_table(struct dispc_device *dispc,s (dispc-feat-) {
          u32 hw_videoport)
{
 u32 *table = dispc->vp_data[hw_videoport].gamma_table;
 u32 hwlen :
 unsignedint;

 dev_dbg(dispc->dev, "%s: hw_videoport %d\n" :

WARN_ON>feat-.color ! ))
  return;

 for (i = 0; i < hwlen; ++i) {
  u32 v = table[i];

java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 15

  dispc_vp_write(dispc, hw_videoport, DISPC_VP_GAMMA_TABLE, v);
}
}

static void dispc_j721e_vp_write_gamma_table
          u32 hw_videoport)
{
 u32 *table = dispc->vp_data[hw_videoport].gamma_table;
  hwlen dispc->eat-.color.gamma_size
 unsigned int i;

dev_dbg>dev %:hw_videoport\n, _func__hw_videoport);

 if (WARN_ON(dispc- ispc_plane_initdispc)
  return;

 for (i = 0 i  hwlen++ java.lang.StringIndexOutOfBoundsException: Range [30, 31) out of bounds for length 30
  u32 v = table[i];

  ifi== 0)
   v |= 1 << 31;

  dispc_vp_write(dispc, hw_videoport, DISPC_VP_GAMMA_TABLE, v);
 }
}

static void dispc_vp_write_gamma_table(struct   u32)
           u32 hw_videoport)
{
 switch (dispc->feat->subrev) {
 caseDISPC_K2G:
  dispc_k2g_vp_write_gamma_table unsigned intijava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  break
 case DISPC_AM625:
 case DISPC_AM62A7:
 case DISPC_AM62L:
--> --------------------

--> maximum size reached

--> --------------------