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"
#   46
#include " .upscale_limit = 6java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
include.

#include "tidss_dispc_regs.h"
#include tidss_scale_coefs"

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.
 */
 . = {
  .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 =  [DISPC_VP_DPI]  [DISPC_VP_INTERNAL }
 },

 .subrev = DISPC_K2G,

 . .in_width_max_3tap_yuv  .  .downscale_limit_5tap  .downscale_limit_3tap  /*

.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.
 */
 .  2
 },

 .  java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14

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

 .num_vps =   * it should
. =  " ",
 .ovr_name [DISPC_VP] 0
  DISPC_VP_DPI=50java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
.     }java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

  upscale_limit1java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
   ./*
.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   * The maximum bpp   * is 8. So   * because 1+( 
  {
  =,
  
   commoncommon
 . =,
  {
   .. = 2
   . .p_name   vp1vp2
   .hw_id. =  ovr1",
  },
 }/

 .vid_order = {1, 0},
};

static . =  color
 [ . =true
 . =26
 [DSS_SYSSTATUS_OFF] =   0x20,
 [DISPC_IRQ_EOI_OFF] =   0x80,
 [DISPC_IRQSTATUS_RAW_OFF] =  0x28,
 [DISPC_IRQSTATUS_OFF gamma_type ,
 [}java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
DISPC_IRQENABLE_CLR_OFF x34java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 [DISPC_VID_IRQENABLE_OFF
 [DISPC_VID_IRQSTATUS_OFF x48
[]= x58
 DISPC_VP_IRQSTATUS_OFF,

[]   x78
 [WB_IRQSTATUS_OFF =1,}

 java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
 DISPC_GLOBAL_OUTPUT_ENABLE_OFF,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 []   xa4
 [.num_vps = 1
 [] = xac
 [] = xb0
[]  0,

[] = 0,
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 [ .gamma_size6
   gamma_type,
 [FBDC_REVISION_5_OFFjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 [FBDC_REVISION_6_OFF ={
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
FBDC_CONSTANT_COLOR_0_OFF,
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 [DISPC_CONNECTIONS_OFF
 [DISPC_MSS_VP1_OFF  u16dispc_common_regmap
 [java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
};

  dispc_features ={
 .max_pclk_khz = {
VP_DPI00
s device
 },

 .scaling = {
  .in_width_max_5tap_rgb = 2048,
  .in_width_max_3tap_rgb =void *[TIDSS_MAX_PLANES
  = 49,
  =49,
  .upscale_limit = 16,
  .downscale_limit_5tap = 4,
  .downscale_limit_3tap =   *am65x_oldi_io_ctrl
  /*
 * 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.
 */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

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

 .common = "common_m",
 .common_regs = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 .num_vps
 .vp_name dispc_vid_write  *,  hw_plane regval
  iomem>[];
 .vpclk_name
 /* Currently hard coded VP routing (see dispc_initial_config()) */
 .vp_bus_type
 _ * =>[];
 .vp_featreturn(base );
   .has_ctm
   static dispc_ovr_writestruct *,  hw_videoport
  .gamma_type=TIDSS_GAMMA_10BIT
  },
 },

 .num_vids = 4,

 .vid_info = {
  {
   .name = " void __iomem *bas =dispc-base_ovr[hw_videoport];
   iowrite32val base+reg;
   .hw_id = 0,
  },
  {
   .name

  static u32(struct *, u32, u16regjava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
 ,
  {
   .name
  . = false
   .hw_id = 2,
  },
  {
   .name _ *base=>base_vp];
   .is_lite = true,
   .hw_id = 3,
  },
 },

 .vid_order static dispc_vp_read  *,  hw_videoport regjava.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
};

truct  ={
 .max_pclk_khz = {
  [DISPC_VP_DPI] = 165000,
  [DISPC_VP_INTERNAL] = 170}
 },

 java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
  .in_width_max_5tap_rgb = 0java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  .in_width_max_3tap_rgb = 25
  .in_width_max_5tap_yuv560,
  .in_width_max_3tap_yuv =  (!oldi_reset_bit&dispc_readtidss-,DSS_SYSSTATUS&
  .upscale_limit = 16,
  .downscale_limit_5tap = 4,
  .ownscale_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_AM625,

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

 num_vps2
 .vp_name = { "vp1", "vp2" },
 .ovr_name return;
.vpclk_name   "p1, "" },
 .vp_bus_type = { DISPC_VP_INTERNAL, DISPC_VP_DPI },

 .java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
   .has_ctm = true,
   .java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   .gamma_type = TIDSS_GAMMA_8BIT * number java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ,
 },

 .num_vids ( ,u32u32)

 /* note: vid is plane_id 0 and vidl1 is plane_id 1 */< end (start;
 .vid_info = {
  {
   .u32(u32val u32,  end
   .is_lite ( &(, )) >;
   .hw_id
  },
  {
   .name = "vidl1",
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   .hw_id =java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 1
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 ,

 .vid_order = {1, 0},
};

const (  *,  ,  val
 /*
 * if the code reaches dispc_mode_valid with VP1,
 * it should return MODE_BAD.
 */
 .max_pclk_khzjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 DISPC_VP_TIED_OFF=0java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  [DISPC_VP_DPI] = 165000,
 },

 .scaling
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 . = 50
  .in_width_max_5tap_yuv = 2560,
  . = 06
  java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
  downscale_limit_5tap,
  .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
  ((, vp),, );

 .num_vps = 2,
 .vp_name
 .ovr_namevoid(  *dispc ,u32, val
 .vpclk_nameu32,u32)
 /* VP1 of the DSS in AM62A7 SoC is tied off internally */,vp ,((dispc,idx
 .vp_bus_type = { 

 .vp_feat = { .  OVR_REG_GETdispc_device, ovr ,

   .gamma_size (dispc_ovr_read,, ),, );
   .gamma_type =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }
 },

  FLD_MOD(, ovridx

. ={
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 .amevid
   .is_lite = false,
   .hw_id  vp_stat;
  }java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  {  | ();
  namevidl1
   | DSS_IRQ_VP_VSYNC_EVEN)
   . ( &(2)
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Range [33, 3) out of bounds for length 3

 .vid_order
;

const struct dispc_features dispc_am62l_feats = {
 . ={
  [s |=(0;
 },

 .subrev = DISPC_AM62L,

. = common
.  ,

. = ,
 .vp_name = { "vp1" },
  ( &())
 .vpclk_name =  { "vp1" },
 { java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

 .vp_feat
 h =,
   .gamma_size java.lang.StringIndexOutOfBoundsException: Range [15, 16) out of bounds for length 0
 r vid_stat
  },
 },

 .num_vids = 1,

. = java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
{
  |(0;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   .hw_id  (struct*,
  }
 },

 .vid_order = {0},
};

static const

struct
  eturn(stat);
};

struct {
 struct tidss_device *  u32, )
   stat(vpstatjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

  *java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 void
  iomem]java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  _ *[;

 struct regmap      ,dispc_irq_t)

 struct clk

 const struct dispc_features *feat;

 struct clk  (struct *,

 bool is_enabled;

 struct dss_vp_data

u32;
 u32

 u32

   errata
};

static dispc_write dispc_devicedispc,u16, u32)
{
 iowrite32java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

static u32 dispc_read(struct dispc_device *dispc, u16 reg)
{
    u32)
}

static
 dispc_vid_write dispc_device*ispc,u32,  regu32)
{
 void __iomem *base

iowrite32, base +reg
}

static u32 dispc_vid_read(struct dispc_device *dispc voiddispc_k2g_vid_set_irqenable( dispc_devicedispc
{
 void __iomem *base = dispc->base_vid[hw_plane];

 return ioread32 stat (vidstat);
}

static void dispc_ovr_write(struct dispc_device *dispc, u32 hw_videoport,
       u16 reg, u32 val)
{
 }

 iowrite32(val, base + reg);
}

staticu32dispc_ovr_readstruct dispc_device *dispcu32, u16reg
{
 void _java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 return ioread32(base + reg);
}

  ( dispc_device, u32 ,
      u16 reg, u32 val)
{
 void __iomem  top irqstatus/

 iowrite32(val, base + reg);
}

staticu32(struct *dispc,u32, u16)
{
 void __iomem *base = dispc->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return ioread32(base + reg);
}

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

 dispc_vp_write(tidss->dispc

i_reset_bit&dispc_read>dispcDSS_SYSSTATUS) &
        count < 10000)
  count++;

 if (!(oldi_reset_bit
   -;

 return0
}

void(struct *tidss,u32 )
{
 dispc_vp_write
}

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

 u32(u32,  end
{
java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 46
}

static u32dispc_k2g_vp_set_irqenabledispc,);
{
  (val< end)&FLD_MASK(, end
}

static u32 dispc_writ(, , ( < )|( <7)
/* clear the irqstatus for irqs that were disabled */
 return (val ispc_k2g_clear_irqstatus(ispc( ^old_mask );
}

staticu32(u32orig,u32, u32, u32)
{
 return (orig & ispc_k2g_read_irqenable(ispc
}

static dispc_irq_tdispc_k3_vp_read_irqstatus  *,
{
(dispc_readdispc,idx,start);
}

static void REG_FLD_MODu32 = dispc_readdispcDISPC_VP_IRQSTATUShw_videoport
 u32, u32)
{
 dispc_write(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     start, end));
}

static u32 
         u32 stat (vpstat,);
{
  FLD_GET(dispchw_planeidx) , end
}

static void VID_REG_FLD_MOD(staticdispc_irq_t dispc_k3_vid_read_irqstatus( dispc_device *,
     u32, u32 tart end
{
 dispc_vid_write(  hw_id dispc->>vid_info].hw_id;
    u32 stat (dispc(hw_idjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    val, start
}

(struct *, u32vpu32 idx
        u32 start, u32 end)
{
 return FLD_GET(dispc_vp_read
}

static stat (vidstat);
      u32 start
{
dispc_vp_write, , idx (dispc_vp_read, vp,idx
            java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

__maybe_unused
static    u32)
         
{
return(dispc_ovr_read(dispc, idx , end
}

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

static dispc_irq_t
{
dispc_irq_tvp_stat ;

 if (  u32hw_planejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 vp_stat |= DSS_IRQ_VP_FRAME_DONE(hw_videoport);
 if(stat BIT1)
  vp_stat |= DSS_IRQ_VP_VSYNC_EVEN(hw_videoport);
 if (stat & java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  vp_stat}
 if (stat & BIT(4))
  vp_stat |= DSS_IRQ_VP_SYNC_LOST(hw_videoport);

 return vp_stat
} voiddispc_k3_vid_set_irqenablestruct *dispc

static
 hw_id dispc->[hw_plane].hw_id
 u32 stat u32 = dispc_vid_irq_to_rawvidstathw_plane;

 if (vpstat & DSS_IRQ_VP_FRAME_DONE dispc_writedispc, DISPC_VID_IRQENABLEhw_id stat)
  stat |= BIT(0);
 if (vpstat & DSS_IRQ_VP_VSYNC_EVEN(hw_videoport))
  stat |= BIT(1);
 if( & DSS_IRQ_VP_VSYNC_ODD(w_videoport)
  stat |= BIT(2);
 if (vpstat & DSS_IRQ_VP_SYNC_LOST(hw_videoport))
  stat |= BIT(4);

 return stat;
}

static dispc_irq_t dispc_vid_irq_from_raw
{
 dispc_irq_t vid_stat = 0;

 if (stat &  ifclearmask DSS_IRQ_VP_MASKi)
 vid_stat=DSS_IRQ_PLANE_FIFO_UNDERFLOW);

 return vid_stat;
}

static u32 dispc_vid_irq_to_raw(}
{
 u32 stat = 0;

 if (vidstat &DSS_IRQ_PLANE_FIFO_UNDERFLOW))
  stat |= BIT(0);

 return 
}

static dispc_irq_t dispc_k2g_vp_read_irqstatus(struct dispc_device  dispc_readdispc);
            u32
{
 u32 dispc_irq_t(struct dispc_device)

 return dispc_irq_t  = 0;
}

static void dispc_k2g_vp_write_irqstatus(struct dispc_device *dispc,
     hw_videoportdispc_irq_t )
{
u2statdispc_vp_irq_to_raw, hw_videoport

 dispc_vp_write (i =0  <dispc->num_vids+)
}

static dispc_irq_t dispc_k2g_vid_read_irqstatus(struct dispc_devicestatus dispc_k3_vid_read_irqstatus(, i;
      hw_plane
{
 u32 status

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

staticvoid dispc_k2g_vid_write_irqstatusstruct *dispc
       u32 hw_plane, dispc_irq_t vidstat)
{
 u32 stat = dispc_vid_irq_to_raw(vidstat, hw_plane) unsignedinti;

 dispc_vid_write(dispc, hw_plane, DISPC_VID_K2G_IRQSTATUS, stat);
}

staticdispc_irq_tdispc_k2g_vp_read_irqenablestructdispc_device*ispc
          u32)
{
 u32 stat = dispc_vp_readjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  ;
}

staticdispc_k2g_vp_set_irqenable dispc_devicedispc
           u32 java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 24
{
 u32 stat = dispc_vp_irq_to_raw(vpstat old_mask

 old_mask  (dispc
}

static dispc_irq_t(structdispc_device*,
      u32 hw_plane)
{
 u32 stat = dispc_vid_read(dispc, hw_plane, DISPC_VID_K2G_IRQENABLE);

 return  (dispci );
}

static void dispc_k2g_vid_set_irqenable(struct dispc_device *dispc,
    u32 hw_planedispc_irq_t vidstat
{
 u32 stat =  main_disable |= BIT(i)

 dispc_vid_write(dispc, hw_plane
}

static void dispc_k2g_clear_irqstatus(struct u32 = dispc->>vid_info]hw_id;
          dispc_irq_tdispc_k3_vid_set_irqenable(, i );
{
 ispc_k2g_vp_write_irqstatus, 0 mask
 dispc_k2g_vid_write_irqstatus   | (hw_id 4;/* VID IRQ */
}

static
dispc_irq_t dispc_k2g_read_and_clear_irqstatus(struct dispc_device java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
{
 dispc_irq_t stat = 0;

 /* always clear the top level irqstatus */ (ain_disable
dispc_write, ,
      dispc_readjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 stat |= dispc_k2g_vp_read_irqstatus
 stat |= d(dispcDISPC_IRQENABLE_SET

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

 return stat;
}

static dispc_irq_t dispc_k2g_read_irqenable(struct dispc_device *dispc)
{
 stat 0java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

 | dispc_k2g_vp_read_irqenable, 0)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 stat case:

 return stat;
}

static
void dispc_k2g_set_irqenablejava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
{
dispc_irq_t =dispc_k2g_read_irqenable)

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

 dispc_k2g_vp_set_irqenable(dispc, 0,  :
(, 0)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

 dispc_write

 /* clear the irqstatus for irqs that were disabled */
(,mask& )java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64

 /* flush posted write */
()java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
}

static dispc_irq_t dispc_k3_vp_read_irqstatus(struct dispc_device *dispc,
         hw_videoport
{
 u32 ,  0 false0}

 return dispc_vp_irq_from_raw(stat, hw_videoport);
}

staticvoid(struct *,
    hw_videoport vpstat
{
u2stat dispc_vp_irq_to_raw, hw_videoport

 dispc_write(dispc, DISPC_VP_IRQSTATUS
}

staticstruct *(struct  *dispc,
     ,
{
u32  >feat-[hw_plane;
 u32

 return dispc_vid_irq_from_rawjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
ifdispc_bus_formats. = bus_fmt

static void dispc_k3_vid_write_irqstatus(struct dispc_device *dispc,
      u32 hw_plane, dispc_irq_t 
{
 u32 hw_id =int(struct *,  hw_videoport
 (vidstat,);

 dispc_write
}const tidss_crtc_state* =(state

read_irqenable dispc_device,
           u32 hw_videoport)
{
 u32 =dispc_read(, (hw_videoportjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64

 return  __func__, tstate->bus_form
}

static void dispc_k3_vp_set_irqenable(struct
         u32,dispc_irq_t)
{
 u32 stat>){

d(, (hw_videoport, stat;
}

static dispc_irq_t -;
     java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 2

  (  *, )
 u32 statjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

return(stat);
}

static void dispc_k3_vid_set_irqenable(structregmap_update_bits>,,
           u32 egmap_update_bits>, ,
{ AM65X_OLDI_PWRDN_TX, val);
 u32hw_id dispc->feat->vid_info].hw_id
 u32 stat   , val

 dispc_write(dispc DISPC_VID_IRQENABLEhw_id, stat);
}

static
void dispc_k3_clear_irqstatus(struct dispc_device *dispc, dispc_irq_t clearmask)
{
 unsigned int i;

 for     AM65X_OLDI_PWRDN_TXval;
  if (clearmask & DSS_IRQ_VP_MASK(i))
   dispc_k3_vp_write_irqstatus(dispc, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 for (i = 0; i < dispc- u32 , int)
  if intvjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
   dispc_k3_vid_write_irqstatus(dispc, i, clearmask);
 }

 /* always clear the top level irqstatus */
dispc_write(dispc DISPC_IRQSTATUS, dispc_readdispc DISPC_IRQSTATUS);

 /* Flush posted writes */
 dispc_read(dispc, DISPC_IRQSTATUS);
}

static
dispc_irq_t dispc_k3_read_and_clear_irqstatus ;;
{case:
 dispc_irq_t status = 0;v=2 ;
 unsigned  2:

 for(i= 0;i <dispc-feat->num_vps; ++)
 status= dispc_k3_vp_read_irqstatusdispci);

 for (i = 0; i < dispc->feat->num_vids; ++i)
  status |= dispc_k3_vid_read_irqstatus v =4 ;

 dispc_k3_clear_irqstatus:

 return status;
}

static dispc_irq_t dispc_k3_read_irqenable(struct dispc_device *
{
 dispc_irq_t enable = 0;
 unsigned}

 for (i = 0; i < dispc->feat-static dispc_enable_am65x_oldi dispc_devicedispc hw_videoport
  enable=dispc_k3_vp_read_irqenable(, i);

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

 return enable
}

static void dispc_k3_set_irqenable(struct dispc_device *dispc,
       dispc_irq_t mask)
{
 unsigned int i;
 u32 main_enable = 0, main_disable = 0;
 dispc_irq_t old_mask;

 old_mask dispc_k3_read_irqenable);

 /* clear the irqstatus for irqs that will be enabled */
 dispc_k3_clear_irqstatus else  (>data_width=1)

  (i  0  <dispc->num_vps+i java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  dispc_k3_vp_set_irqenable,  );
  if (mask &java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   main_enable |= BIT(i);  /* VP IRQ */
  else
  main_disable | BIT() /
 }

0;i < >feat-num_vids +){
  u32 hw_id = dispc->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  dispc_k3_vid_set_irqenable(dispc, i, while!oldi_reset_bit  (dispc) &

  if (mask & DSS_IRQ_PLANE_MASK(i))
   main_enable |=  ountjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 
   main_disable |= BIT(hw_id dev_warn(>dev %s:timeoutOLDI\n,
 }

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

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

 /* clear the irqstatus for irqs that were disabled */
 dispc_k3_clear_irqstatus(dispc, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* Flush posted writes */
 dispc_read(dispc, DISPC_IRQENABLE_SET
}

dispc_irq_t dispc_read_and_clear_irqstatus(structreturnjava.lang.StringIndexOutOfBoundsException: Range [9, 10) out of bounds for length 9
{
 switch (dispc->feat->subrevdispc_am65x_oldi_tx_power, );
 case DISPC_K2G:
return (dispc;
 case DISPC_AM625:
 case DISPC_AM62A7
 case DISPC_AM62L:
 case:
 case DISPC_J721Econststate
  d)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
default
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  0
 }
}

void dispc_set_irqenable(struct dispc_device *dispc, dispc_irq_t mask)
{
 switch (dispc->feat->subrev) {
 case DISPC_K2G:
  dispc_set_num_datalines, hw_videoport>);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 case DISPC_AM625:
  DISPC_AM62A7
 case DISPC_AM62L:
 caseDISPC_AM65X
 case DISPC_J721E:
  (dispc);
  break;
 :
  WARN_ON bp >crtc_vtotal-mode->crtc_vsync_end;
  break;
 }
}

struct dispc_bus_format {
 u32 bus_fmtjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 u32data_width;
 bool is_oldi_fmt;
  oldi_mode_reg_valam65x_oldi_mode_reg_val
};

static const struct dispc_bus_format dispc_bus_formats[] = {
{MEDIA_BUS_FMT_RGB444_1X12 1, false ,
 { MEDIA_BUS_FMT_RGB565_1X16,  16, false, 0 },
 ,  18, false0},
 { MEDIA_BUS_FMT_RGB888_1X24,   FLD_VAL -1 ,0 |
 { MEDIA_BUS_FMT_RGB101010_1X30,  30, false, 0 },
 { MEDIA_BUS_FMT_RGB121212_1X36,  36, false, 0 },
{MEDIA_BUS_FMT_RGB666_1X7X3_SPWG1, , SPWG_18,
 { MEDIA_BUS_FMT_RGB888_1X7X4_SPWG, 24, true, SPWG_24 },
 { MEDIA_BUS_FMT_RGB888_1X7X4_JEIDA, 24,   =!(ode- &DRM_MODE_FLAG_NVSYNC);
};

static const
struct dispc_bus_format
   u32,
            
{
 unsigned i;

 for (i = 0; i < ARRAY_SIZE
  if(ispc_bus_formats. ==bus_fmt)
   return &dispc_bus_formats[i];
 }

 return NULL;
}

int dispc_vp_bus_check(struct dispc_device *dispc, u32 hw_videoport,
         
{
 const struct tidss_crtc_state* = to_tidss_crtc_statestate;
 const struct dispc_bus_format *fmt;

 fmt = dispc_vp_find_bus_fmt(dispcalign true
        tstate-
 if (if(>feat-vp_bus_typehw_videoport= )
 dev_dbgdispc-, "s:Unsupported bus format: %\"java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
   __func__, tstate->bus_format);
  return EINVAL;
 }

  FLD_VALrf 1,1) |
     fmt->is_oldi_fmt) {
  dev_dbg(dispc->dev, "%s: %s is not OLDI-port\n",
  _func__dispc-feat-[hw_videoport]);
  return -EINVAL;
 }

 return 0;
}

static voiddispc_am65x_oldi_tx_power dispc_device *dispc, bool)
{
= power  : AM65X_OLDI_PWRDN_TX

 if (WARN_ON(!dispc- dispc_vp_writedispc, hw_videoportDISPC_VP_SIZE_SCREEN
 return

 regmap_update_bits(dispc- FLD_VALmode-crtc_vdisplay 1,7, 1));
  
 regmap_update_bits(dispc->am65x_oldi_io_ctrl, VP_REG_FLD_MODdispc hw_videoport DISPC_VP_CONTROL, 1 0 0);
      AM65X_OLDI_PWRDN_TX, val);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      AM65X_OLDI_PWRDN_TX val;
 regmap_update_bits(dispc->am65x_oldi_io_ctrl, AM65X_OLDI_DAT3_IO_CTRL,
      AM65X_OLDI_PWRDN_TX, val);
 regmap_update_bits(dispc->am65x_oldi_io_ctrl, AM65X_OLDI_CLK_IO_CTRL,
      AM65X_OLDI_PWRDN_TX, val{
}

staticvoid (structdispc_devicedispc
        u32 hw_videoport,
{
 int

 switch () {
 case 12:
   =0 break;
 case 16:
  v = 1; break;
 case 1:
  v = 2; break }
 
  v = 3; break;
 case3:
  v = 4; break;
 case 36:
  v = 5; break;
 default:
  WARN_ON(1);
  v = 3;
 }

 VP_REG_FLD_MOD(dispc
}

static void dispc_enable_am65x_oldi(struct dispc_device *dispc, u32 hw_videoport,
     VP_REG_FLD_MOD(dispc,hw_videoport DISPC_VP_CONTROL1 5 5)java.lang.StringIndexOutOfBoundsException: Range [64, 65) out of bounds for length 64
{enumc8_to_c12_mode C8_TO_C12_REPLICATE,C8_TO_C12_MAXC8_TO_C12_MIN;
 u32 oldi_cfg = 0;
 u32 oldi_reset_bit = BIT(5 + hw_videoport);
 int count staticu16c8_to_c12u8, enum c8_to_c12_modemode

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

 if  /* Copy c8 4 MSB to 4 LSB for full scale c12 */
  c12= c8> 4java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 elseif(fmt-data_width= 1)
  dev_warn  c12 |=0;
    __func__, fmt->data_width

 oldi_cfg |= BIT  C8_TO_C12_MIN

 oldi_cfg = FLD_MOD(oldi_cfg}

 oldi_cfg |= BIT(12); /* SOFTRST */

 oldi_cfg| BIT0; /* ENABLE */

 dispc_vp_write(dispc, hw_videoport, DISPC_VP_DSS_OLDI_CFG, oldi_cfg);

 while (!(oldi_reset_bit & dispc_read(dispcstatic u64argb8888_to_argb12121212(u32argb8888e c8_to_c12_mode )
        count < 10000)
  count;

  (!( & dispc_readdispc,DSS_SYSSTATUS))
  dev_warn(dispc->dev, "%s: timeout waiting
     a=(argb8888> 24 &0xff;
}

void dispc_vp_prepare(struct dispc_device *dispc, u32 hw_videoport,
        const struct drm_crtc_state *state)
{
 const struct tidss_crtc_state *tstate = to_tidss_crtc_stateg = argb8888>8  xff
 const struct dispc_bus_format*;

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       tstate-);

 if  (()c8_to_c12g m <1)|(u64)c8_to_c12b,m;
  return;

 if (dispc->}
  dispc_am65x_oldi_tx_power(dispc, true);

  dispc_enable_am65x_oldi(dispc, hw_videoport, fmt);
 }
}

voiddispc_vp_enable dispc_device*ispc  hw_videoport,
       const struct drm_crtc_state *state)
{
 const struct drm_display_mode *mode = &state-{
 const struct tidss_crtc_state *tstate = to_tidss_crtc_state v;
 bool align v=argb8888_to_argb12121212, C8_TO_C12_REPLICATE;
 const struct dispc_bus_format *fmt;
 u32 hsw, hfp hbp, vsw vfp ;

 fmt = dispc_vp_find_bus_fmtdispc,hw_videoport tstate-bus_format
       tstate-bus_flags);

 if (WARN_ON!mt
  return;

 dispc_set_num_datalines(dispc, hw_videoport,java.lang.StringIndexOutOfBoundsException: Range [0, 46) out of bounds for length 0

mode- - mode-;
 hsw = mode->crtc_hsync_end - mode-  const drm_display_mode)
 hbp = mode->crtc_htotal - u32, hfphbp,vsw, ;

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

 dispc_vp_write(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         FLD_VAL(hsw - 1, 7, 0) |
         FLD_VAL(hfp - 1, 19, 8) |
         FLD_VAL(hbp - 1, 31, 20));

 dispc_vp_write(, hw_videoport DISPC_VP_TIMING_V
  FLD_VALvsw-1, 7 0) |
         FLD_VAL(vfp, 19, 8) |
           ;

 =!!mode- & DRM_MODE_FLAG_NVSYNC

 ihs !mode-flagsDRM_MODE_FLAG_NHSYNC);

 ieo = !!(tstate-

 ipc = !!tstate-> & DRM_BUS_FLAG_PIXDATA_DRIVE_NEGEDGE

 /* always use the 'rf' setting */
 onoff = true;

rf !!tstate- & DRM_BUS_FLAG_SYNC_DRIVE_POSEDGE);

/
 align = true;

 /* always use DE_HIGH for OLDI */
 if (dispc->feat->vp_bus_type[hw_videoport] ==  (mode-flags DRM_MODE_FLAG_INTERLACE
  ieo false;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         FLD_VAL(align, 18, 18) |
           * is only needed in following cases:
           * - YUV output selected (BT656, BT1120)
         FLD_VAL(ieo, 15, 15)   * - TDM with TDMCycleFormat == 3
         FLD_VAL(ipc, 14, 14) |
         FLD_VAL(ihs, 13, 13) |
        FLD_VAL, 12, 12);

dispc_vp_writedispc, hw_videoportDISPC_VP_SIZE_SCREEN
         java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         FLD_VAL(ode-crtc_vdisplay-1,27, 1));

 VP_REG_FLD_MODhsw mode-hsync_end-mode-hsync_start
}

void dispc_vp_disable(struct dispc_device *dispc, java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 0
{
 VP_REG_FLD_MODdispc hw_videoport, DISPC_VP_CONTROL, 0, 0, 0);
}

void dispc_vp_unprepare(struct dispc_device *dispc, u32 hw_videoport)
{
  vbp=mode-vtotal -mode-vsync_end;
  dispc_vp_write(dispc, hw_videoport, DISPC_VP_DSS_OLDI_CFG, 0);

  dispc_am65x_oldi_tx_power(dispc, false);
 }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

bool  hbp < 1||hbp 096
{
 return VP_REG_GET(dispc, hw_videoport, DISPC_VP_CONTROL, 5, 5);
}

void dispc_vp_go(struct dispc_device *      > 05| vbp >495
{
 
 i (ispc-memory_bandwidth_limit{
}

enum  const unsignedint  

static u16 c8_to_c12
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 u16 c12;

 c12= c8<4java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

 switch (mode)   return;
 case java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  /* Copy c8 4 MSB to 4 LSB for full scale c12 */dispc_vp_enable_clk dispc_device dispcu32)
  c12 |=    =(>vp_clk)
  break;
 ()
  c12 dev_errdispc->, ":enabling clk failed: %d\" _,
 breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 default:
 case C8_TO_C12_MINjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  break;
 }

 return c12;
}

staticjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 u8 a, r, g, b;
 u64 v;

 a = (argb8888 >> 24) & 0xff;
 r = (argb8888{
g  >)&0;
 b = (argb8888

 v = ((u64)c8_to_c12(a, m) << 36) | ((u64)c8_to_c12(r, m) << 24) |
  ((u64)c8_to_c12(gjava.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0

 return     unsigned long rate
}

static void dispc_vp_set_default_color(struct dispc_device *dispc,
  unsigned new_rate
{
 u64 v;

 v = argb8888_to_argb12121212(default_color, C8_TO_C12_REPLICATE);

 dispc_ovr_write(dispc, hw_videoport,
   DISPC_OVR_DEFAULT_COLOR, v  f (){
 dispc_ovr_write dev_errdispc-dev "pd: failedtosetclkrateto %lu\,
   DISPC_OVR_DEFAULT_COLOR2 ( >>32)&0xffff;
}

enum drm_mode_status dispc_vp_mode_valid(struct dispc_device *dispc,
      u32 hw_videoport,
      const struct drm_display_mode *mode)
{
 u32 hsw, hfp, hbp, vsw, vfp,java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
 enumdispc_vp_bus_type bus_type
 int max_pclk;

 bus_type =   "%d:Clockrate %udiffersover5%fromrequested %lu\"

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

 if (WARN_ON(max_pclk == 0))
  return MODE_BAD;

 if (mode- 0;
  return MODE_CLOCK_LOW;

 if (mode->clock > 
MODE_CLOCK_HIGH;

 if (mode-hdisplay >49)
  return MODE_BAD;

ifmode- > 06
 returnMODE_BAD

 /* TODO: add interlace support */
ifmode- &DRM_MODE_FLAG_INTERLACEjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  return MODE_NO_INTERLACE;

 /*
 * 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(>hdisplay)!0java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 return;

hfp> ->;
 hsw(,,(layer
hbpmode- ->;

 vfp = mode->vsync_start -  y 09;
 vsw = mode->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 vbp          hw_plane hw_videoport

 if (hsw < 1 || hsw > 256 ||
     hfp < 1 || hfp > 4096 u32hw_id= dispc-feat-vid_infohw_plane].hw_id;
     hbp < 1 || hbp > 4096)
  return MODE_BAD_HVALUE;

 if (vsw < 1 || vsw > 256 ||
     vfp 495 ||vbp>405java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  return MODE_BAD_VVALUE;

 if (dispc->memory_bandwidth_limit)   ,13, 0
   unsigned bpp4java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
}

;
  bandwidth = bandwidth * mode->  u32,u32,u32  layer
  bandwidth = div_u64(bandwidth, mode->

  if (dispc-dispc_k2g_ovr_set_plane, hw_planehw_videoport
D
 }

 return MODE_OK;
}

int(struct *dispc )
{
 int  = clk_prepare_enable>vp_clk])java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

 if (ret)
  dev_err(dispc->dev, "%s: enabling (dispc, , ,
  ret;

 return ret;
}

void dispc_vp_disable_clk(struct dispc_device *:
{
 clk_disable_unprepare(dispc->vp_clk[hw_videoport]);
}

/*
 * Calculate the percentage difference between the requested pixel clock rate
 * and the effective rate resulting from calculating the clock divider value.
 */
 int(unsignedlong, unsigned longreal_rate
{
  =rate 100  = real_rate  10

 return (unsigned int)(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

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

   (dispc-[hw_videoport );
 if (r) {, CSC_GGCSC_GB
  dev_err(dispc-C, CSC_BG,
   hw_videoport, rate);
  return r;
}

 new_rate = clk_get_rate(dispc- , CSC_RCB ,

 if (dispc_pclk_diff(rate, new_rate)CSC_BY, ,
  dev_warn(dispc->dev
  vpd  rateludiffers %  requested%lun"
 CSC_YRCSC_YGCSC_YB

 dev_dbg(dispc->dev, "vp%d: new CSC_CRR,CSC_CRG,CSC_CRBjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  hw_videoport, clk_get_rate(dispc->vp_clkstruct dispc_csc_coef{

 return 0;
}

/* OVR */
int[;
       3 ,  hw_videoport
       x  y,u32)
{
 /* On k2g there is only one plane and no need for ovr */
 dispc_vid_write(dispc, hw_plane, DISPC_VID_K2G_POSITION,
  x | ( << 6))java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
}

static void dispc_am65x_ovr_set_plane(struct dispc_device
          u32 hw_planevoiddispc_csc_offset_regvalconst  definey((x 5y 1 9)
  u32u32  u32 layerjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
u32hw_id >>vid_info].;

 OVR_REG_FLD_MOD(dispc, hw_videoport,}
   hw_id, 4, 1);
OVR_REG_FLD_MOD, hw_videoportDISPC_OVR_ATTRIBUTES),
   x, 17, 6);
 OVR_REG_FLD_MOD(dispcvoid(conststructdispc_csc_coefcsc  *regval
   y, 30, 19);
}

  dispc_j721e_ovr_set_plane  *,
          u32 hw_plane, u32 hw_videoport,
         u32 ,u32, u32)
{
u32  = >feat-[hw_plane.w_id

 OVR_REG_FLD_MODdispc, hw_videoport,(layer
   hw_id
 OVR_REG_FLD_MOD(dispc, hw_videoport, DISPC_OVR_ATTRIBUTES2(layer),
  x 1,0;
 java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 1
  ,2,1);
}

void [2  (csc-m[],csc-[])java.lang.StringIndexOutOfBoundsException: Range [52, 53) out of bounds for length 52
   hw_videoportu32,u32 ,u32 layer
{
 switch (dispc-> (csc);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  dispc_csc_cpr_regval(onst  *,
     x, y, layer);
  break;
  [0]  (csc-[], >mCSC_RG
 case DISPC_AM62A7 [1  CVAL(csc-[], csc-m[SC_GR
 case regval[] =CVAL(csc->m[CSC_GG, csc-m[CSC_GB);
 case DISPC_AM65X regval3] = CVALcsc->m[CSC_BR, csc-m[CSC_BG
  dispc_am65x_ovr_set_planedispchw_plane ,
    
  break;
caseDISPC_J721E
  dispc_j721e_ovr_set_plane(dispc,}
     
  ;
 default:
  WARN_ON(1);
  break;
 }
}

void dispc_ovr_enable_layer(struct dispc_device *dispc,
       u32 hw_videoport, u32 layer, bool     u32 hw_videoport, u32 layer, bool 
{
 if (dispc->feat- DISPC_VID_CSC_COEF0) DISPC_VID_CSC_COEF()java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  return;

 OVR_REG_FLD_MOD(dispc, hw_videoport, DISPC_OVR_ATTRIBUTES(layer),
   !!enable(4,(5,
}

/* CSC */
enum csc_ctm {
 , ,CSC_RB
 CSC_GR,CSC_GB
 CSC_BR,)
};

  java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 CSC_RY,   ( =0   (dispc_vid_csc_coef_reg;i+)
 CSC_GY, CSC_GCB dispc_vid_writedispc , [i,
 CSC_BY, CSC_BCB, CSC_BCR,
};

enum csc_rgb2yuv {
 CSC_YR voiddispc_k3_vid_write_csc(structdispc_device*ispc  hw_plane
 CSC_CBR , CSC_CBB,
 CSC_CRR, CSC_CRG, CSC_CRB,
};

struct dispc_csc_coef {
 void (* DISPC_VID_CSC_COEF) (1,
 int m[9];
 int preoffset[3];
 int postoffset[3];
 enum  3 [DISPC_CSC_REGVAL_LEN
 const char  unsignedint;
};

#define java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0

static
void dispc_csc_offset_regval(const struct dispc_csc_coef *csc, u32   regvali)
{
#define OVAL,y FLD_VAL 5 3 |FLD_VAL 1 9)
 regval[5] =staticconststruct  csc_yuv2rgb_bt601_full java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 regval6]=OVAL>preoffset] >postoffset[];
 regval[7] = OVAL(csc->postoffset[1], csc->postoffset[2]);
#undef OVAL
}

define(x )((x 10 )|FLD_VAL,6 6)
static
void(const  dispc_csc_coefcscu32regval)
{
 regval[0] = CVAL(csc->m[CSC_RY], csc->
 regval[1] =  BT61Fulljava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 regval[2] = CVAL(csc->m[CSC_GCR], csc->m[CSC_GCB]);
 regval[3] = CVAL(csc->m[CSC_BY], csc->m[java.lang.StringIndexOutOfBoundsException: Range [0, 48) out of bounds for length 45
 egval[4]=CVALcsc->m[CSC_BCB 0)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

 dispc_csc_offset_regval, regval
}

maybe_unused
void dispc_csc_rgb2yuv_regval    ,,0 ,
{
". ",
 regval[1] = CVAL(csc-
 regval
 regval[3] = CVAL(csc->m[CSC_CBR  structdispc_csc_coef ={
 regval[4] = CVAL(csc->{26 0  0,/

 dispc_csc_offset_regval, );
}

static void dispc_csc_cpr_regval(const struct dispc_csc_coef *csc,
     u32 *regval)
{
 regval[0] = CVAL".0 ",
 regval[1] = CVAL(csc->m[CSC_RB], csc->m[;
 regval[2] = CVAL(csc-
 regval[3 =CVALcsc-mCSC_BRcsc-[]);
 regval[4] = CVAL(csc-staticconst dispc_csc_coef = {

 {9,0  5,/
}

#undef CVAL

  26 -048, -2048, },/* limited */
  const dispc_csc_coef)
{
 static const u16 dispc_vid_csc_coef_reg[] = ".0 Limited"
  DISPC_VID_CSC_COEFconststruct{
  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), /* K2G has no post offset support */
 };
u32regval[DISPC_CSC_REGVAL_LENjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 unsigned int i;

 csc->(csc );

  (regval ! )
  dev_warn(dispc->dev DRM_COLOR_YCBCR_BT709DRM_COLOR_YCBCR_LIMITED_RANGE
    __func__, csc->name);

 const
  dispc_vid_writedispc, [i]
    regval[i]);
}

static void dispc_k3_vid_write_csc(structunsigned i
       const struct dispc_csc_coef *csc)
{
 static const u16 dispc_vid_csc_coef_reg[DISPC_CSC_REGVAL_LENifdispc_csc_table]. ==encoding
 DISPC_VID_CSC_COEF() DISPC_VID_CSC_COEF()
  DISPC_VID_CSC_COEF(2), DISPC_VID_CSC_COEF(3)  returndispc_csc_table[]csc
  DISPC_VID_CSC_COEF(4), DISPC_VID_CSC_COEF(5),
  DISPC_VID_CSC_COEF(6), DISPC_VID_CSC_COEF7returnNULL
 };
 u32 regval[DISPC_CSC_REGVAL_LEN];
 unsigned ijava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

 csc->to_regval(csc, regval

 for (i = 0; i < ARRAY_SIZE(dispc_vid_csc_coef_reg); i++)

    coef (state-, state-);
}

/* YUV -> RGB, ITU-R BT.601, full range */
static const struct dispc_csc_coef csc_yuv2rgb_bt601_full = {
 dispc_csc_yuv2rgb_regval,
 { 256,   0,  358, /* ry, rcb, rcr |1.000  0.000  1.402|*/
   dispc_k2g_vid_write_csc(dispc, hw_plane, coef);
   25  dispc_k3_vid_write_csc(dispc, hw_plane, coef);
 {    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 {    0,     0,     0, },
 CLIP_FULL_RANGE,
 "BT.601 Full",
};

/* YUV -> RGB, ITU-R BT.601, limited range */
static const struct dispc_csc_coef csc_yuv2rgb_bt601_limjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
,
/* , ,rcr.4000 19|/
   2 ,
   29,  1,0 ,/
 { -256, -2048, -2048, },
 {    0,     0,     0, },
 CLIP_FULL_RANGE,
 .,
};

/* YUV -> RGB, ITU-R BT.709, full range */
 const  ={
 dispc_csc_yuv2rgb_regval,
 { 256,   0,  402, /* ry, rcb, rcr |1.000 0.000  1.570|*/
   26  -,-2, /* gy, gcb, gcr |1.000 -0.187 -0.467|*/
 5,45,,} *bybcb,  100186 .00/
 {    0, -2048, -2048, }, /* full range */
 {    0,     0,     0, }java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 CLIP_FULL_RANGE,
 "BT.7] java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
};

/* YUV -> RGB, ITU-R BT.709, limited range */
 struct  ={
 dispc_csc_yuv2rgb_regval,
 { 298,    0,  459, /* ry, rcb, rcr |1.164  0.000  1.793|*/
   298,  -55, -136, /* gy, gcb, gcr |1.164 -0.213 -0.533|*/
   298,  541,    0,  (dispc-, %s coefficientsgivenn,_);
 { -256, -2048, -}
 {    0,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 CLIP_FULL_RANGE,
 BT0 Limited
u16c  coefs-[phase

static  {
 enum drm_color_encoding encoding;
 enum drm_color_range range;
  struct *;
} dispc_csc_table[] = {
{DRM_COLOR_YCBCR_BT601,
   &csc_yuv2rgb_bt601_full, },
 { DRM_COLOR_YCBCR_BT601, DRM_COLOR_YCBCR_LIMITED_RANGE,
   &csc_yuv2rgb_bt601_lim, },
 { DRM_COLOR_YCBCR_BT709, c1 >c1];
   &csc_yuv2rgb_bt709_full, },
 { DRM_COLOR_YCBCR_BT709, DRM_COLOR_YCBCR_LIMITED_RANGE,
   csc_yuv2rgb_bt709_lim }
};

static const
struct dispc_csc_coef *
          enum drm_color_range
{
 unsigned int i;

for( =0 i< ARRAY_SIZE(dispc_csc_table);i+){
  if (dispc_csc_table[i].encoding == encoding &&
      dispc_csc_table[i].range == rangecase DRM_FORMAT_YUYV
urn[i].csc
  }
 }
;
}

static void
    java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 0
{
 const struct dispc_csc_coef *coef;

 coef =boolfive_taps
 if (!coef) {
   ( dispc_devicedispc
 _, state-color_encoding >color_range
  return  struct *sp
 }

if(>feat- ==)
  dispc_k2g_vid_write_csc(dispc, hw_plane,  fourccstate->format-format
 else
  dispc_k3_vid_write_csc(dispc, hw_plane, coef downscale_limit
}

static void >xinc;
     bool enable)
{
  >in_w_uvsp-;
}

/* SCALER */

static dispc_calc_fir_inc in  outjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
{
 return (u32)div_u64


enum dispc_vid_fir_coef_set {
 DISPC_VID_FIR_COEF_HORIZ
  > >=1java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 DISPC_VID_FIR_COEF_VERT,
 ,
};

staticdispc_vid_write_fir_coefsstruct *,
  
          enum
          const struct tidss_scale_coefs *coefs(!> &!>) |l)
{
 static const u16
  [ if(p-in_w > ) {
  [DISPC_VID_FIR_COEF_HORIZ_UV] = DISPC_VID_FIR_COEFS_H0_C,
  [DISPC_VID_FIR_COEF_VERT>;
  [DISPC_VID_FIR_COEF_VERT_UV] = DISPC_VID_FIR_COEFS_V0_C>  ;
 };

 static const u16
  [DISPC_VID_FIR_COEF_HORIZ] = DISPC_VID_FIR_COEFS_H12,
 [] =DISPC_VID_FIR_COEFS_H12_C
  [DISPC_VID_FIR_COEF_VERT
  [DISPC_VID_FIR_COEF_VERT_UV 1>java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
}

 const u16 c0_base = c0_regs[coef_set];
 const u16 c12_base =
intphase

 if (!coefs) {
  dev_err(dispc->dev
  return;
 }

for  ;<8 +)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  16regc0_base +phase 4
  u16 c0 = coefs->c0[phase];

 (, , , c0
    -;

 for (phase = 0; java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  u16 reg =  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   c1;
  c12

  c1 = coefs->c1[phase];
  c2 = coefs->c2[phase];
  c12 = FLD_VAL(c1,   " wide buffer %u>%\, _

  dispc_vid_write(dispc, hw_plane, reg, c12);
 }
}

static /*
{
switch (fourcc) {
case DRM_FORMAT_YUYV:
case DRM_FORMAT_UYVY:
case DRM_FORMAT_NV12:
return true;
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 *xcoef, *ycoef, *xcoef_uv, *ycoef_uv;
bool five_taps;
};

static int dispc_vid_calc_scaling(struct dispc_device *dispc,
  const struct drm_plane_state *state,
  struct dispc_scaling_params *sp,
  bool lite_plane)
{
const struct dispc_features_scaling *f = &dispc->feat->scaling;
u32 fourcc = state->fb->format->format;
u32 in_width_max_5tap = f->in_width_max_5tap_rgb;
u32 in_width_max_3tap = f->in_width_max_3tap_rgb;
u32 downscale_limit;
u32 in_width_max;

memset(sp, 0, sizeof(*sp));
sp->xinc = 1;
sp->yinc = 1;
sp->in_w = state->src_w >> 16;
sp->in_w_uv = 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_w;
sp->scale_y = sp->in_h != state->crtc_h;

if (dispc_fourcc_is_yuv(fourcc)) {
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 == DRM_FORMAT_NV12) {
sp->in_h_uv >>= 1;
sp->scale_y = true;
}
}

/* Skip the rest if no scaling is used */
 !>  sp-) |lite_plane
  return 0;

 if (sp->in_w > in_width_max_5tap) {
  >five_taps ;
  in_width_max = in_width_max_3tap;
  downscale_limit = f->downscale_limit_3tap > =>;
 } else {
 >five_taps;
  in_width_max = in_width_max_5tap;
  downscale_limit = f->downscale_limit_5tap;
 }

 if (sp->scale_x sp-)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
> >in_w

  if (sp->fir_xinc sp-,
        >five_taps
    "%s: X-scaling factor %u/%u > %u\n"}
    __func__, state->)
upscale_limit
   return -EINVAL;
  }

  if (sp->fir_xinc >= dispc_calc_fir_inc(downscale_limit,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   sp- void(struct *,
           >),
    struct *sp

   if (sp->xinc
 /* HORIZONTAL RESIZE ENABLE */
   %s:X-scaling%/u< /un"
     __func__, state-  sp-scale_x, 7 )
     state->src_w >> 16,
     downscale_limit
    return -;
   }

 return
  }

  while (sp->in_w > in_width_max) {
  sp-++;
   sp->in_w taps21 1)
  }

  if  (>) {
   dev_dbg(dispc->dev,
    "% (,, ,
    state->src_w >> (dispc,
   return;
  }

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

  sp->fir_xinc = dispc_calc_fir_inc(sp->in_w, state->crtc_w}
 }

if>scale_y){
  sp->fir_yinc = dispc_calc_fir_inc(sp->in_h, dispc_vid_write, , , sp-fir_xinc

      ,
     sp-);
    "%s: Y-scaling factor %u/%u > %u\n",
   _, >crtc_hstate->rc_h 6
    f->upscale_limit);
   return -EINVAL;
  }

  if (sp->fir_yinc >= dispc_calc_fir_inc(downscale_limit, 1))      , sp-ycoef
   sp-
            state->crtc_h
      downscale_limit);

   sp->in_h /= sp->yinc;
   sp->fir_yinc = dispc_calc_fir_inc(sp- dispc_color_formats]={
         state->crtc_h);
  }
 }

 dev_dbg(dispc->dev,
  "%s: %ux%u decim %ux%u -
 _, >src_w1,state- >>1,
  sp->xinc, sp->yinc , 0, }
  sp->fir_xinc / 0x200000u,
  ((sp->fir_xinc & 0x1FFFFFu , 0, ,
  sp->fir_yinc / 0x200000u,
  ((sp->fir_yinc & 0x1FFFFFu) * 999u) / 0x1FFFFFu
  sp->five_taps ? 5 : 3,
  state->crtc_w, state->crtc_h);

 if (dispc_fourcc_is_yuv(fourcc)) {
  if (sp->scale_x) {
   sp->in_w_uv /= sp-{, 0 ,
  , 0, ,
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   sp->xcoef_uv = tidss_get_scale_coefs(dispc->  DRM_FORMAT_RGBX4444 x22,
            sp->fir_xinc_uv,
            true);
  }
  if (sp->scale_y) {
   sp->in_h_uv /= sp->yinc;
   sp->fir_yinc_uv = dispc_calc_fir_inc(sp->in_h_uv,
            state->crtc_h);
   sp->ycoef_uv = tidss_get_scale_coefs(dispc->dev,
          sp-fir_yinc_uv
  );
  }
 }

 if (sp->scale_x)
  sp->xcoef = tidss_get_scale_coefs(dispc->java.lang.StringIndexOutOfBoundsException: Range [0, 46) out of bounds for length 28
      rue

 if (sp->scale_y)
  sp->ycoef = tidss_get_scale_coefs(dispc-unsigned int;
        sp->five_taps  (  0   (dispc_color_formats; +){

 return VID_REG_FLD_MOD, , DISPC_VID_ATTRIBUTES
}

staticreturn
  u32,
      struct
      u32 fourcc)
{
java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 VID_REG_FLD_MOD(constu2*(  dispc  *)
   sp->scale_x, 7, 7);

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

 /* Skip the rest if no scaling is used */
if!> !p-scale_y
  return;

 /* VERTICAL 5-TAPS  */
 VID_REG_FLD_MOD(dispc, hw_plane, DISPC_VID_ATTRIBUTES,
   sp->five_taps, 21, 21);

 if ( return pixels)*psjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  if (sp-return -- + )*ps
   dispc_vid_write(dispc, hw_plane, (1)java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
     sp->java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
 (,,
     const ,
        sp->xcoef_uv);
  }
  if (sp->scale_y) {
  dispc_vid_write,,,
     sp->java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 1
dispc_vid_write_fir_coefs,,
        DISPC_VID_FIR_COEF_VERT_UV>src_h =state-;
        sp->ycoef_uv);
  }
 }

 ifsp-scale_x{
       state-)){
  dispc_vid_write_fir_coefs(dispc, hw_plane,
OEF_HORIZ,
       sp->xcoef);
 }

 if (sp->scale_y) {
  dispc_vid_write(dispc, hw_plane, DISPC_VID_FIRV, sp->fir_yinc);
  dispc_vid_write_fir_coefs(dispc, hw_plane,
       DISPC_VID_FIR_COEF_VERT, sp->ycoef}
 }
}

/* OTHER */>devjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

 const {
 u32 fourcc;

} dispc_color_formats[] = {
 { DRM_FORMAT_ARGB4444, 0x0, } returnEINVAL
 { DRM_FORMAT_ABGR4444, 0x1, },
 { DRM_FORMAT_RGBA44440x2, ,

 { DRM_FORMAT_RGB565, 0x3, },
 { DRM_FORMAT_BGR565, 0x4, },

 { DRM_FORMAT_ARGB1555, 0x5, },
 { DRM_FORMAT_ABGR15550java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

 { DRM_FORMAT_ARGB8888, 0x7, },
 { DRM_FORMAT_ABGR88880, }
 { DRM_FORMAT_RGBA8888, 0x9, },
 { DRM_FORMAT_BGRA8888, 0xa, },

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

{DRM_FORMAT_ARGB21010100, ,
 { DRM_FORMAT_ABGR2101010,  y >src_y 6

 {gem  (state-, 0
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0


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

 { DRM_FORMAT_XRGB8888, 0x27, },
 { DRM_FORMAT_XBGR8888, 0x28, },
 { DRM_FORMAT_RGBX8888, 0x29, },
 { , 0x2a}java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

 { DRM_FORMAT_XRGB2101010, 0x2e, },
 { DRM_FORMAT_XBGR2101010, 0x2f, },

 { DRM_FORMAT_YUYV, 0x3e  (ARN_ONstate-fb->num_planes !=)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 { DRM_FORMAT_UYVY, 0x3f, },

  DRM_FORMAT_NV12, 0x3d, },
};

 voiddispc_plane_set_pixel_format(struct dispc_device*ispc
      u32 hw_plane, u32 fourcc)
{
 unsigned int i;

 for (i = ( *>pitches[] /fb-format-vsub
  if (dispc_color_formats[i].fourcc == fourcc) {
   VID_REG_FLD_MOD(dispctruct dispc_device *dispc u32hw_plane
     dispc_color_formats[i]  const structdrm_plane_state *state,
 6 1)
   return;
  }
 }

 WARN_ON(1);
}

const u32 *dispc_plane_formats(struct dispc_device *dispc, unsigned int *len)
{
 WARN_ON(!dispc->fourccs dma_addr dispc_plane_state_dma_addr();

 *len = dispc->num_fourccs;

 return dispc->fourccs;
}


{
  ( = )
  return 1;
 else if (pixels > 1)
  eturn+( - 1)*ps;
 else if (pixels < 0)
  return1-(pixels1) *ps;

 WARN_ON(1);
 return 0;
}

int dispc_plane_check(struct dispc_device *dispc, u32 hw_plane,
        const struct (dispc,DISPC_VID_PICTURE_SIZE,
        u32 hw_videoport)

 bool
 u32 fourcc = >fb-format->;
 bool need_scaling = state->src_w >> 16 != state- fourcc=  ||fourcc )
 dispc_vid_write, , DISPC_VID_PIXEL_INCjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 struct dispc_scaling_params scaling;
  ret

 if (dispc_fourcc_is_yuv(fourcc)) {
  if (!dispc_find_csc(state-> ispc_vid_write, , ,
   state-)) {
   dev_dbg(dispc->dev,
    "%s: Unsupported CSC (%u,%u) for HW plane %u\n",
    __func__, state->color_encoding,
    state->color_range if(state-fb-format-num_planes ==2) {
   return -EINVAL;
  }
 }

 if(need_scaling java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  if (lite
   dev_dbg>dev
  %s  planeu ' %ux%!=%%u\",
    __func__, hw_plane,
   >src_w 1,>src_h>1,
    state->crtc_w, state->crtc_h);
   return -EINVAL;
 }
  ret = dispc_vid_calc_scaling(dispc, state, &scaling, false);
  if (ret)
   return ret;
 }

 return 0;
}

static
dma_addr_t dispc_plane_state_dma_addr(const struct drm_plane_state *state)
{
 struct drm_framebuffer *fb = state-
  drm_gem_dma_object;
 u32 x = state->src_x >> 1 dispc_vid_writedispchw_plane,,
 u32 =state- >>1;

 gem = drm_fb_dma_get_gem_obj(state->fb, 0);

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

static
dma_addr_t (const  drm_plane_statestate
{
 struct drm_framebuffer *fb = state->fb;
 struct *gem;
 u32 x = state->src_x >> 16;
u32 = state->src_y >1;

 if (WARN_ON(state->fb->format->num_planes != 2))
  return 0;

gem(fb1;

 return gem->dma_addr + fb->offsets[  (>pixel_blend_mode=DRM_MODE_BLEND_PREMULTI
  ( *>format-[1  fb-format-) +
  (y * fb->pitches[1]   282);
}

voiddispc_plane_setup dispc_device, u32,
         const struct drm_plane_state *state,
         u32 hw_videoport)
{
 bool lite = dispc->feat->vid_info[hw_plane].is_lite;
 u32 fourcc = state->fb->format->format;
 u16 cpp = state->fb->format->cpp[0];
 u32 fb_width = state->fb->pitches[0] / cpp;
 dma_addr_t dma_addr = dispc_plane_state_dma_addr(state);
 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, dma_addr & 0xffffffff);
 dispc_vid_write(dispc, hw_plane, DISPC_VID_BA_EXT_0, (u64)dma_addr >> 32);
 dispc_vid_write(dispc hw_planeDISPC_VID_BA_1,dma_addr 0ffffffff);
 dispc_vid_write(dispc, hw_plane, DISPC_VID_BA_EXT_1, (u64)dma_addr >> 32)

 dispc_vid_write(dispc, hw_plane, DISPC_VID_PICTURE_SIZE,
   (scale.in_w - 1) | ((scale.in_h - 1) << 1 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

 /* For YUV422 format we use the macropixel size for pixel inc */ (dispc, , 15 )
 if (fourcc == DRM_FORMAT_YUYV || fourcc
 dispc_vid_write, hw_plane,DISPC_VID_PIXEL_INC
    pixinc(scale.xinc, cpp     hw_planeu32,  high
 else
,
    pixinc(scale.xinc, cpp));

 dispc_vid_write(dispc, hw_plane, DISPC_VID_ROW_INC,
   pixinc(1 + (scale.yinc * fb_width -
        scale.xinc * scale.in_w),
          cpp));

 if (state->fb->format->num_planes ==staticvoiddispc_vid_set_buf_thresholdstructdispc_device*ispc
  u16cpp_uv= state->fb-format-[1];
  u32 fb_width_uv = state->fb->pitches[1{
  dma_addr_t p_uv_addr = dispc_plane_state_p_uv_addr(state);

 dispc_vid_write, hw_plane
    DISPC_VID_BA_UV_0,   FLD_VAL(high 31,1) |FLD_VALlow, 5, 0);
  dispc_vid_write(dispc, hw_plane,
    DISPC_VID_BA_UV_EXT_0, (u64)p_uv_addr >> 32);
  dispc_vid_writedispchw_plane
    DISPC_VID_BA_UV_1, p_uv_addr & 0xffffffff);
  dispc_vid_write(dispc, hw_plane,
    DISPC_VID_BA_UV_EXT_1, (u64)p_uv_addr >> 32);

  (dispc hw_plane DISPC_VID_ROW_INC_UV
    pixinc(1 + (scale.yinc * fb_width_uv -
         scale.xinc * scale (dispc , 2,1 );
           cpp_uvjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 }

!) {
  dispc_vid_writeu32 = dispc_vid_get_fifo_size, hw_plane
  (>crtc_w )java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    ((state->crtc_h - 1) << 16));u32preload;

  dispc_vid_set_scaling(dispc, hw_plane, &scale, fourcc);
 }

 /* enable YUV->RGB color conversion */
 if (dispc_fourcc_is_yuv(fourcc
  dispc_vid_csc_setup = ize   3;
  dispc_vid_csc_enable, hw_plane);
 } else {
  dispc_vid_csc_enable(dispc,  preload thr_low
 }

 dispc_vid_write(  %s: bufsizeu %/u threshold%  un"
  0 &(>alpha>8)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

 if (state->pixel_blend_mode ==  , mflag_lowjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  VID_REG_FLD_MOD(dispc, hw_plane, DISPC_VID_ATTRIBUTES, 1,
    28, 28);
 else
  VID_REG_FLD_MOD(dispc, hw_plane,         , mflag_high
    28, 28);
}

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

static u32 dispc_vid_get_fifo_size(struct   * register is ignored.
{
 (,,DISPC_VID_BUF_SIZE_STATUS,0java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
}

static void dispc_vid_set_mflag_threshold(struct dispc_device *dispc,
     u32 , u32 low high
{
 dispc_vid_write(dispc, hw_plane, DISPC_VID_MFLAG_THRESHOLD,
   FLD_VAL(high
}

static void dispc_vid_set_buf_threshold(struct dispc_device *dispc
  u32 ,  low high
{
 dispc_vid_write(dispc, hw_plane, DISPC_VID_BUF_THRESHOLD,
   FLD_VAL(high/* MFLAG_CTRL = ENABLED */
}

static  dispc_k2g_plane_init dispc_device*)
{
u int;

 dev_dbg(dispc->dev,  < ispc-feat->; hw_plane)java.lang.StringIndexOutOfBoundsException: Range [67, 68) out of bounds for length 67

 /* MFLAG_CTRL = ENABLED */
 REG_FLD_MOD(dispc, DISPC_GLOBAL_MFLAG_ATTRIBUTE, 2, 1, 0);
 /* MFLAG_START = MFLAGNORMALSTARTMODE */
 REG_FLD_MOD(dispc, DISPC_GLOBAL_MFLAG_ATTRIBUTE,   = size 1

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

  thr_high = size - 1;
  thr_low = size / 2;

  mflag_high = size * 2 / 3;
  = size / 3java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

  preload = thr_low;

  dev_dbg(dispc->dev,
   "%s: bufsize %u, buf_threshold %u/%u, dispc_vid_set_buf_threshold(, hw_plane,
   dispc->feat->vid_info[hw_plane].name,
   size,
   thr_high, thr_low,
   mflag_high, mflag_low,
   preload);

  dispc_vid_set_buf_threshold(dispc, hw_plane
     thr_lowthr_high
  dispc_vid_set_mflag_threshold(dispc, hw_plane,
           mflag_low, mflag_high);

  dispc_vid_write(dispc, hw_plane, DISPC_VID_PRELOAD, preload);

 /*
{
   * possibility of underflows. Note that this  case DISPC_K2G:
   * register is ignored.
 case DISPC_AM625:
  VID_REG_FLD_MOD(dispc, hw_plane, DISPC_VID_ATTRIBUTES, 1,
    19, 19);
 }
}

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

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

 REG_FLD_MOD(dispc, DSS_CBA_CFG
 REG_FLD_MODjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* MFLAG_CTRL = ENABLED */
 REG_FLD_MOD(dispc, DISPC_GLOBAL_MFLAG_ATTRIBUTE, 2, 1, 0java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
 /* MFLAG_START = MFLAGNORMALSTARTMODE */
 REG_FLD_MOD(dispc, DISPC_GLOBAL_MFLAG_ATTRIBUTE, 0, 6{

 for (hw_plane = 0; hw_planedispc_plane_init();
  u32  * Note: Hardcoded DPI routing on J721E for now */
  u32 thr_low, thr_high;
 u32m, mflag_high
 u32;

  thr_high = size - 1;
  thr_low = size / 2;

  mflag_high = size * 2 / 3;
  mflag_low = size / 3;tatic dispc_k2g_vp_write_gamma_table dispc_device*,

  preload = thr_low;

  dev_dbg>dev
%s: %,buf_threshold %/% mflagthreshold%u/upreload\"
   dispc->feat->vid_info[hw_plane].name,
   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,hw_plane
           mflag_low, mflag_highu32v=table]

 dispc_vid_writedispchw_plane , preload);

  /* Prefech up to PRELOAD value */
  VID_REG_FLD_MODdispc hw_plane DISPC_VID_ATTRIBUTES0,
    19, 19);
 }
}

static void dispc_plane_init(struct dispc_device *dispc)
{
 witchdispc->>subrev
 case DISPC_K2G:
  dispc_k2g_plane_init(dispc);
  break;
 case DISPC_AM625:
_AM62A7
 caseunsigned  i
 case DISPC_AM65X:
 case DISPC_J721E
  dispc_k3_plane_init(dispc);
  break;if ((dispc->vp_feat.gamma_type=TIDSS_GAMMA_8BIT)
 default:
  WARN_ON(1);
 }
}

static void dispc_vp_init(struct dispc_device 
{
 unsigned int i;

 dev_dbg(dispc-> java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

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

static  (dispc-,"s %dn" _, hw_videoport;
{
d(dispc;
 dispc_vp_init(dispc);

 /* Note: Hardcoded DPI routing on J721E for now */;i<; ++){
 if (dispc->feat->subrev == DISPC_J721E) {
  dispc_write(dispc, DISPC_CONNECTIONS,
       FLD_VAL(2, 3, 0) |  ( == 0java.lang.StringIndexOutOfBoundsException: Range [13, 14) out of bounds for length 13
       FLD_VAL(8, 7, 4)  /* VP3 to DPI1 */
   );
 }
}

static void dispc_k2g_vp_write_gamma_table(struct dispc_device *dispc
       hw_videoport
{
 u32 *table = dispc->vp_data[
 u32  :
unsigned ;

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

 if (WARN_ONjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  return;

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

  v |= i << 24;

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

static void dispc_am65x_vp_write_gamma_table(struct dispc_device *dispc,
          u32 hw_videoport)
{
 u32 *table = dispc->vp_data[hw_videoport].gamma_table;
 u32 hwlen = dispc->feat->vp_feat.color.gamma_size;
 unsigned int i;

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

 if (WARN_ON(dispc->feat->vp_feat.color.gamma_type != TIDSS_GAMMA_8BIT))
  return;

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

  v |= i << 24;

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

static void dispc_j721e_vp_write_gamma_table(struct dispc_device *dispc,
          u32 hw_videoport)
{
 u32 *table = dispc->vp_data[hw_videoport].gamma_table;
 u32 hwlen = dispc->feat->vp_feat.color.gamma_size;
 unsigned int i;

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

 if (WARN_ON(dispc->feat->vp_feat.color.gamma_type != TIDSS_GAMMA_10BIT))
  return;

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

  if (i == 0)
   v |= 1 << 31;

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

static void dispc_vp_write_gamma_table(struct dispc_device *dispc,
           u32 hw_videoport)
{
 switch (dispc->feat->subrev) {
 case DISPC_K2G:
  dispc_k2g_vp_write_gamma_table(dispc, hw_videoport);
  break;
 case DISPC_AM625:
 case DISPC_AM62A7:
 case DISPC_AM62L:
--> --------------------

--> maximum size reached

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