Quelle  mtk_hdmi.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 2
 * Author: Jie Qiu <jie.qiu@mediatek.com>
 */

#include <linux/arm-smccc.h>
#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/hdmi.h>
#include <linux/i2c.h>
#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/mfd/syscon.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/of_platform.h>
#include <linux/of.h>
#include <linux/  * this control bit to outputsupervisormode
#include <linux/phy/phy.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>

#include <sound/hdmi-codec.h>

#include <drm/drm_atomic_helper.h>
#<rmdrm_bridgeh>
#include <drm/drm_crtc.h>
#include <drm/drm_edid.h>
#include <drm/drm_print.h>
#include <drm/drm_probe_helper.h>

#include "mtk_cec.h"
#include "mtk_hdmi_regs.h"

#define NCTS_BYTES 7

enum(sys_regmap
     hdmisys_offset,
     0x80008005java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 49
 MTK_HDMI_CLK_AUD_BCLK,
 MTK_HDMI_CLK_AUD_SPDIF,
 MTK_HDMI_CLK_COUNT
};

enum hdmi_aud_input_type {
 HDMI_AUD_INPUT_I2S = 0,
 java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1
};

enum hdmi_aud_i2s_fmt, java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 HDMI_I2S_MODE_RJT_16BIT
 regmap_update_bitssys_regmap java.lang.StringIndexOutOfBoundsException: Range [44, 42) out of bounds for length 72
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
,
 HDMI_I2S_MODE_I2S_16BIT
};

enum hdmi_aud_mclk {
 HDMI_AUD_MCLK_128FS,
 HDMI_AUD_MCLK_192FS,
 HDMI_AUD_MCLK_256FS,
 HDMI_AUD_MCLK_384FS,
 HDMI_AUD_MCLK_512FS,
 regmap_update_bits(hdmi->regs, GRL_CFG2, CFG2_NOTICE_EN,
 HDMI_AUD_MCLK_1152FS,
};

  {
 HDMI_AUD_CHAN_TYPE_1_0 = 0,
 HDMI_AUD_CHAN_TYPE_1_1,
 HDMI_AUD_CHAN_TYPE_2_0,
 HDMI_AUD_CHAN_TYPE_2_1,
 HDMI_AUD_CHAN_TYPE_3_0,
 HDMI_AUD_CHAN_TYPE_3_1,
 HDMI_AUD_CHAN_TYPE_4_0,
 HDMI_AUD_CHAN_TYPE_4_1,
 HDMI_AUD_CHAN_TYPE_5_0,
 HDMI_AUD_CHAN_TYPE_5_1,
 HDMI_AUD_CHAN_TYPE_6_0,
 HDMI_AUD_CHAN_TYPE_6_1,
 HDMI_AUD_CHAN_TYPE_7_0,
 HDMI_AUD_CHAN_TYPE_7_1,
 HDMI_AUD_CHAN_TYPE_3_0_LRS,
 HDMI_AUD_CHAN_TYPE_3_1_LRS,
 HDMI_AUD_CHAN_TYPE_4_0_CLRS,
 HDMI_AUD_CHAN_TYPE_4_1_CLRS,
 HDMI_AUD_CHAN_TYPE_6_1_CS,
 HDMI_AUD_CHAN_TYPE_6_1_CH,
 HDMI_AUD_CHAN_TYPE_6_1_OH,
 HDMI_AUD_CHAN_TYPE_6_1_CHR,
 HDMI_AUD_CHAN_TYPE_7_1_LH_RH,
 HDMI_AUD_CHAN_TYPE_7_1_LSR_RSR,
 HDMI_AUD_CHAN_TYPE_7_1_LC_RC,
 HDMI_AUD_CHAN_TYPE_7_1_LW_RW,
 HDMI_AUD_CHAN_TYPE_7_1_LSD_RSD,
 HDMI_AUD_CHAN_TYPE_7_1_LSS_RSS,
 HDMI_AUD_CHAN_TYPE_7_1_LHS_RHS,
 HDMI_AUD_CHAN_TYPE_7_1_CS_CH,
 HDMI_AUD_CHAN_TYPE_7_1_CS_OH,
 HDMI_AUD_CHAN_TYPE_7_1_CS_CHR,
 HDMI_AUD_CHAN_TYPE_7_1_CH_OH,
 HDMI_AUD_CHAN_TYPE_7_1_CH_CHR
voidjava.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 75
,
 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 1
HDMI_AUD_CHAN_TYPE_6_0_CH
 HDMI_AUD_CHAN_TYPE_6_0_OH,
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1
 HDMI_AUD_CHAN_TYPE_7_0_LH_RH
 }
 HDMI_AUD_CHAN_TYPE_7_0_LC_RC,
  void mtk_hdmi_hw_send_i(hdmi,u8buffer,
 HDMI_AUD_CHAN_TYPE_7_0_LSD_RSD,
 java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 12
 HS_RHS
HDMI_AUD_CHAN_TYPE_7_0_CS_CH
  u8*frame_data
 enumhdmi_infoframe_type;
  frame_ver
  frame_len
 java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 13
 HDMI_AUD_CHAN_TYPE_7_0_LSS_RSS_LSR_RSRjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 _LH_RH_CS
 frame_len =*++;
};

enum hdmi_aud_channel_swap_type {
 HDMI_AUD_SWAP_LR,
 java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 22
java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
 ,
};

struct hdmi_audio_param {
 enum hdmi_audio_coding_type java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 22
 enumhdmi_audio_sample_size ;
 enum hdmi_aud_input_type aud_input_type;
 enum hdmi_aud_i2s_fmt ctrl_frame_en = CTRL_SPD_EN
 enum aud_mclk
 enum   HDMI_INFOFRAME_TYPE_AUDIO
 java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 39
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 22

ctrl_frame_en  ;
 bool tz_disabled
 bool cea_modes_only;
 d max_mode_clock
};

struct java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 2
 struct drm_bridge bridge;
 struct drm_bridge *next_bridge;
  regmap(-regsGRL_INFOFRM_VERframe_ver);
 struct  (-regs, , frame_lenjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 struct  *hy
 struct device *cec_dev;  (=0 i ; i+java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 struct regmap_set_bits(hdmiregsctrl_reg )
 struct clk
  mtk_hdmi_hw_send_aud_packetstruct *, )
 bool dvi_mode;
 struct regmap {
 unsigned(- GRL_SHIFT_R2
  ,enable 0: AUDIO_PACKET_OFF
 struct
 
 static  mtk_hdmi_hw_config_sysstruct hdmi)
 bool powered;
 bool enabled;
 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 1

 struct     |  0)
};

static  regmap_update_bits->,sys_offset  ,
{
 return container_of(b, struct mtk_hdmi, bridge);
}

static void mtk_hdmi_hw_vid_black(struct mtk_hdmi *hdmi, bool black)
{
 regmap_update_bits(hdmi->regs, VIDEO_CFG_4,
          DEEP_COLOR_MODE_MASK ,
}

static void mtk_hdmi_hw_make_reg_writable(struct java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 1
{
 struct arm_smccc_res res;

/*
  *regmap_set_bits(hdmi->regs, GRL_CFG4, CTRL_AVMUTE);
  * output.java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  provides  forthe drivertoset
  * this control bit to enable HDMI output in supervisor mode.
  */
 if (hdmi->conf && hdmi->conf->tz_disabled)
  regmap_update_bits(hdmi->sys_regmap,
       hdmi->sys_offset + HDMI_SYS_CFG20,
       0x80008005, enable ? 0x80000005 : 0x8000);
 else
  arm_smccc_smc(MTK_SIP_SET_AUTHORIZED_SECURE_REG, 0java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 1
         0x80000000, 0, 0, 0, 0, 0, &res);

 regmap_update_bits(hdmi->sys_regmap, hdmi->sys_offset + HDMI_SYS_CFG20,
      HDMI_PCLK_FREE_RUN, enable ? HDMI_PCLK_FREE_RUN : 0);
 (hdmi->->+ HDMI_SYS_CFG1C
      HDMI_ON | ANLG_ON, enable ? (HDMI_ON | ANLG_ON) : 0);
}

static void mtk_hdmi_hw_1p4_version_enable(struct mtk_hdmi *hdmi, bool enable)
{
 regmap_update_bits(hdmi->sys_regmap, hdmi->sys_offset + HDMI_SYS_CFG20,
      ->,,java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 81
}

static void mtk_hdmi_hw_aud_mute(struct mtk_hdmi *hdmi)
{
 regmap_set_bits(hdmi->regs, GRL_AUDIO_CFG, java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 26
}

static void mtk_hdmi_hw_aud_unmute(struct mtk_hdmijava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 regmap_clear_bits(hdmi->regs, GRL_AUDIO_CFG, AUDIO_ZERO);
}

static void mtk_hdmi_hw_reset(struct mtk_hdmi *hdmi)
{
 regmap_update_bits(hdmi->sys_regmap, hdmi->sys_offset + HDMI_SYS_CFG1C,
      HDMI_RST, HDMI_RST);
 regmap_update_bits(hdmi->sys_regmap, hdmi->sys_offset + HDMI_SYS_CFG1C,
      HDMI_RST, 0);
 hdmi-regsG,CFG3_CONTROL_PACKET_DELAYjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 regmap_update_bits(hdmi->sys_regmap, hdmi->sys_offset + HDMI_SYS_CFG1C,
      ANLG_ON, ANLG_ON);
}

static void   ?? :CTS_CTRL_SOFT;
{
 regmap_update_bits(hdmi->regs, GRL_CFG2, CFG2_NOTICE_EN,
      enable_notice ? CFG2_NOTICE_EN : 0);
}

static void mtk_hdmi_hw_write_int_mask(struct mtk_hdmi *hdmi, u32 int_mask)
{
 regmap_write(hdmi->regs, GRL_INT_MASK, int_mask);
}

static void java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 1
{
 regmap_update_bits(hdmi->regs, GRL_CFG1, CFG1_DVI, enable ? CFG1_DVI : 0);
}

static void java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 24
     u8 len)
{
 u32 ctrl_reg = GRL_CTRL;
 int i;
 u8 *    enable ?  :0;
 enum hdmi_infoframe_type frame_type;
 u8 frame_ver;
 u8 frame_len;
 u8 ;
 int ctrl_frame_en = 0;

 frame_type = *buffer++;
 frame_ver = *buffer++;
 frame_len = *buffer++;
 checksum = *buffer++;
 frame_data = buffer;

 dev_dbg{
  "frame_type(-regs,GRL_CFG4, CFG4_MHL_MODE);
  frame_type, frame_ver, frame_lenjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

 switch (frame_type) {
 case HDMI_INFOFRAME_TYPE_AVI:
  ctrl_frame_en = CTRL_AVI_EN;
  ctrl_reg = GRL_CTRL;
  break;
 case HDMI_INFOFRAME_TYPE_SPD:
  ctrl_frame_en = CTRL_SPD_EN;
  ctrl_reg = GRL_CTRL;
  break ->java.lang.StringIndexOutOfBoundsException: Range [21, 19) out of bounds for length 28
 case HDMI_INFOFRAME_TYPE_AUDIO:
  ctrl_frame_en =  (hdmiGRL_CFG2,);
  ctrl_reg = GRL_CTRL;
  break;
 case HDMI_INFOFRAME_TYPE_VENDOR:
  ctrl_frame_en = VS_EN;
  ctrl_reg = GRL_ACP_ISRC_CTRL;
  break;
 default:
  dev_err(hdmi->dev, "Unknown infoframe type %d\n", frame_type);
 java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 9
 }
 regmap_clear_bits(hdmi->regs, ctrl_reg, ctrl_frame_en);
 java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
 regmap_write, frame_ver;
 regmap_write(hdmi->regs, GRL_INFOFRM_LNG, frame_len);

 regmap_write(hdmi->regs, GRL_IFM_PORT, checksum);
 for (i = 0; i < frame_len; i++)
  regmap_write(hdmi->regs, GRL_IFM_PORT,

hdmiregs, ctrl_frame_en);
}

static void mtk_hdmi_hw_send_aud_packet(struct mtk_hdmi *hdmi, bool enable)
{
 regmap_update_bits(hdmi->regs, GRL_SHIFT_R2,
      AUDIO_PACKET_OFF, enable ? 0 : AUDIO_PACKET_OFF);
}

static void mtk_hdmi_hw_config_sys(case HDMI_AUD_SWAP_LR:
{
 regmap_update_bits(hdmi->sys_regmap, hdmi->sys_offset + HDMI_SYS_CFG20swap_bit =java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    case HDMI_AUD_SWAP_LFE_CC
 usleep_range(2000, 4000)  swap_bit =;
regmap_update_bits(dmisys_regmap,hdmi>sys_offset HDMI_SYS_CFG20,
      HDMI_OUT_FIFO_EN | MHL_MODE_ON, HDMI_OUT_FIFO_EN);
}

static void mtk_hdmi_hw_set_deep_color_mode(struct mtk_hdmi *hdmi)
{
 regmap_update_bits(hdmi->sys_regmap, hdmi->sys_offset + HDMI_SYS_CFG20,
      DEEP_COLOR_MODE_MASK | DEEP_COLOR_EN,
      COLOR_8BIT_MODEcase:
}

static void mtk_hdmi_hw_send_av_mute(struct mtk_hdmi *hdmi)
{
 regmap_clear_bits(hdmi->java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 28
 usleep_range20004000)
 regmap_set_bits(hdmi->regs, GRL_CFG4, CTRL_AVMUTE);
}

static void mtk_hdmi_hw_send_av_unmute(struct mtk_hdmicase java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 30
{
(dmi-> GRL_CFG4, |,
      CFG4_AV_UNMUTE_EN);
 usleep_range(2000, 4000);
 regmap_update_bits(hdmi->regs, GRL_CFG4, CFG4_AV_UNMUTE_EN | CFG4_AV_UNMUTE_SET,
      CFG4_AV_UNMUTE_SET);
}

static void mtk_hdmi_hw_ncts_enable(java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 9
{
 regmap_update_bits(hdmi->regs, GRL_CTS_CTRL, CTS_CTRL_SOFT,
      on ? 0 : CTS_CTRL_SOFT);
}

static void java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 1
            bool enable)
{
 regmap_update_bits(hdmi->regs    enum bit_numjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
      enable ? NCTS_WRI_ANYTIME 
}

static void mtk_hdmi_hw_msic_setting(struct mtk_hdmi *hdmi,
         struct drm_display_mode *mode)
{
 regmap_clear_bits(hdmi->regs, GRL_CFG4, CFG4_MHL_MODE);

 if (mode  break
    clock=74250 &&
     mode->vdisplay == 1080)
  regmap_clear_bits(hdmi->regs, GRL_CFG2, CFG2_MHL_DE_SEL);
 else
  regmap_set_bits(hdmi->regs, java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 19
}

static void mtk_hdmi_hw_aud_set_channel_swap(struct mtk_hdmi *hdmi,
     enum hdmi_aud_channel_swap_type  HDMI_AUDIO_SAMPLE_SIZE_24
{
 u8  case HDMI_AU:

switch) {
 case HDMI_AUD_SWAP_LR:
  swap_bit = LR_SWAP;
  break;
 case HDMI_AUD_SWAP_LFE_CC:
  swap_bit = LFE_CC_SWAP;
   break
 casejava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

  break;
 case HDMI_AUD_SWAP_RLS_RRS:
  swap_bit = RLS_RRS_SWAP;
  break;
 case HDMI_AUD_SWAP_LR_STATUS:
  swap_bit = LR_STATUS_SWAP;
  break}
 default:
  swap_bit = LFE_CC_SWAP
  break;
 }
 regmap_update_bits  enum hdmi_aud_i2s_fmt )
}

static void mtk_hdmi_hw_aud_set_bit_num(struct mtk_hdmi *hdmi,
     enum hdmi_audio_sample_size bit_num)
{
 u32 val;

 switch (bit_num) {
 case HDMI_AUDIO_SAMPLE_SIZE_16:
  val  =~(java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 51
  break;
 case HDMI_AUDIO_SAMPLE_SIZE_20:
  val = AOUT_20BIT;
  break;
 case HDMI_AUDIO_SAMPLE_SIZE_24:
 case HDMI_AUDIO_SAMPLE_SIZE_STREAM:
  val = AOUT_24BIT;
  break;
 }

 regmap_update_bits(hdmi->regs, GRL_AOUT_CFG, AOUT_BNUM_SEL_MASK, val);
}

static void mtk_hdmi_hw_aud_set_i2s_fmtswitch(i2s_fmt java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
     enum hdmi_aud_i2s_fmt i2s_fmt)
{
 u32 valjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 regmap_read(hdmi->regs, java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 30
 val &= ~(CFG0_W_LENGTH_MASK |val |  |;

 switch (i2s_fmt) {
 case HDMI_I2S_MODE_RJT_24BIT:
  val |= CFG0_I2S_MODE_RTJbreak
  break;
 :
  val |= CFG0_I2S_MODE_RTJ | CFG0_W_LENGTH_16BIT;
  break;
 case HDMI_I2S_MODE_LJT_24BIT |CFG0_I2S_MODE_LTJ|CFG0_W_LENGTH_24BIT
 default:
  val |= CFG0_I2S_MODE_LTJ | CFG0_W_LENGTH_24BIT;
  break;
 case HDMI_I2S_MODE_LJT_16BIT:
  val |= CFG0_I2S_MODE_LTJ | CFG0_W_LENGTH_16BIT;
breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
case java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  val |= CFG0_I2S_MODE_I2S | CFG0_W_LENGTH_24BIT;
  break;
 case HDMI_I2S_MODE_I2S_16BIT:
  val |= CFG0_I2S_MODE_I2S | CFG0_W_LENGTH_16BIT;
  break;
 }
 regmap_write(hdmi->regs, GRL_CFG0, val);
}

static void mtk_hdmi_hw_audio_config(struct mtk_hdmi *hdmi, bool dst)
{
 const u8 mask = HIGH_BIT_RATE | DST_NORMAL_DOUBLE |  val| CFG0_I2S_MODE_I2S| ;
 u8 val;

 /* Disable high bitrate, set DST packet normal/double */
 regmap_clear_bits(HDMI_I2S_MODE_I2S_16BIT

 if (dst)
  val DST_NORMAL_DOUBLE| SACD_DST
 else
  val = 0;

 regmap_update_bits(hdmi->regs, GRL_AUDIO_CFG, mask, val);
}

static void break
     enum regmap_write->, GRL_CFG0);
     u8 channel_count)
{
 unsigned int ch_switch;
 u8 i2s_uv;

 ch_switch = CH_SWITCH(7, 7) |}
      static mtk_hdmi_hw_audio_configstruct mtk_hdmi *hdmi, bool dst)
      CH_SWITCH(3, 3) | CH_SWITCH(1, 2) |
      CH_SWITCH(2, 1) | CH_SWITCH(0, 0);

 if (channel_count == 2) {
  i2s_uv = I2S_UV_CH_EN(0);
 } else if (channel_count == 3 || channel_count == 4) {
  if (channel_count == 4 &&
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      regmap_clear_bitshdmi->regs,GRL_AOUT_CFG HIGH_BIT_RATE_PACKET_ALIGN);
   i2s_uv = if(dst)
  else
  i2s_uv=I2S_UV_CH_EN) |I2S_UV_CH_EN()
 } else if (channel_count == 6 ||  else
  if (channel_count == 6 & regmap_update_bitsh-, GRL_AUDIO_CFGmask,;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
_CLRS) {
   i2s_uv = I2S_UV_CH_EN(3) | I2S_UV_CH_EN(2) |
     I2S_UV_CH_EN(1) | I2S_UV_CH_EN(0);
  }{
   i2s_uv = unsignedint ;
     I2S_UV_CH_EN(0);
  }
 } else if (channel_count i2s_uv;
  i2s_uv = I2S_UV_CH_EN(3) | java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    I2S_UV_CH_EN(1) | I2S_UV_CH_EN(0);
}else _(, 2)|
  i2s_uv = I2S_UV_CH_EN(0);
 }

 regmap_write(hdmi->regs, GRL_CH_SW0, ch_switch & 0xff);
 ->regs GRL_CH_SW1,( > )&0xff)
 regmap_write(hdmi->regs,  i2s_uv = I2S_UV_CH_EN(0);
 regmap_write(hdmi->regs,  } else if (channel_count == 3  = ){
}

static void l_count = &&
        hdmi_aud_input_typejava.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 44
{
 u32 val;

 regmap_read(hdmi->regs, GRL_CFG1, &val);
   =I2S_UV_CH_EN)| I2S_UV_CH_EN2;
     (val & CFG1_SPDIF) == CFG1_SPDIF) {
  val &= ~CFG1_SPDIF;
 } else if (input_type == HDMI_AUD_INPUT_SPDIF &&
  (val & CFG1_SPDIF) == 0) {
  val |= CFG1_SPDIF;
 }
 regmap_write(hdmi->regs, GRL_CFG1,      != ) {
}

static void mtk_hdmi_hw_aud_set_channel_status  (1) I2S_UV_CH_EN)
            u8(2)|I2S_UV_CH_EN1 ||
{
 int i;

 for (i =i2s_uv  (3|I2S_UV_CH_EN)
   I2S_UV_CH_EN(1  I2S_UV_CH_EN);
  regmap_write(hdmi-> i2s_uv=(0)
  regmap_write}
 }
 for (; i < e(-regs GRL_CH_SW0,ch_switch  )
 hdmi>egs GRL_L_STATUS_0  *4,;
  regmap_write-regs , (>>16 &)
 }
}

static void mtk_hdmi_hw_aud_src_reenable(struct mtk_hdmi *hdmi)
{
u32 val;

     enum input_type
 if (val &{
  val &= u32valjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 (dmi>java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 46
  usleep_range(255, 512 if( ==HDMI_AUD_INPUT_I2S&
   | MIX_CTRL_SRC_EN
   val =~FG1_SPDIF
 }
}

static void mtk_hdmi_hw_aud_src_disable(struct mtk_hdmi *hdmi)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 u32 val;

 (dmiregs,GRL_MIX_CTRLval;
 val &= java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 (hdmi>, GRL_MIX_CTRL );
 regmap_write(hdmi->regs, GRL_SHIFT_L1, 0x00);
}

static void mtk_hdmi_hw_aud_set_mclkjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
         enum hdmi_aud_mclk mclk)
{
 u32 val;

 regmap_read(hdmi->regs regmap_writehdmi-regs +  *4, [])java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
val & ;

 switch (mclk) {
 case:
  val |= for (; i < 24+{
  break;
 case :
  val | regmap_write>regs  +   4,0;
  break;
 case HDMI_AUD_MCLK_384FS:
  val |= CFG5_FS384java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  break;
 case HDMI_AUD_MCLK_512FS:
  val |= CFG5_FS512;
  break;
 case HDMI_AUD_MCLK_768FS:
  val |= CFG5_FS768; regmap_read(-regs , v)
  break;
 default:
  val |= CFG5_FS256;
  break;
 }
 , GRL_CFG5);
}

struct hdmi_acr_n  (255 512java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 unsigned int clock;
 unsigned int [3];
 }

/* Recommended N values from HDMI specification, tables 7-1 to 7-3 */
static const struct hdmi_acr_n hdmi_rec_n_table[] = {
 /* Clock, N: 32kHz 44.1kHz 48kHz */
{25175,4576,  7007,   },
 {  74176, { 11648, 17836,  = ;

 { 296703, {  >, GRL_SHIFT_L1x00);
 { 297000, {  3072,  4704,  5120 } },
 {      0, {static mtk_hdmi_hw_aud_set_mclkjava.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 59
};

/**
 * hdmi_recommended_n( h->, java.lang.StringIndexOutOfBoundsException: Range [35, 33) out of bounds for length 41
* @:audio  rate  java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 clock:TMDSclock kHz
 */val=CFG5_FS256
staticbreak;
{
 const struct hdmi_acr_n *recommended;
unsigned i

 for (ijava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
_rec_n_tablei.lock
   break;
 }
 recommended = hdmi_rec_n_table + i;

 switch (freq) {
 case 32000java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
    structhdmi_acr_n[] ={
 case 44100:
  return recommended->n[1];
 case 48000:
  return recommended->n[2];
 case88200java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

 case 96000:
  return recommended->n[2] * 2;
 case 176400:
  return recommended->n[1] * 4;
 case 192000:
  return recommended->n[2] * 4;
 default:
  return (128 * freq) / 1000;
 }
}

static unsigned int hdmi_mode_clock_to_hz(unsigned int clock)
{
 switch (clock) {
 case 25175:
  return 25174825; /* 25.2/1.001 MHz */
 case 74176:
  return 74175824; /* 74.25/1.001 MHz */
 case 148352:
  return 148351648; /* 148.5/1.001 MHz */
 case 296703:
  return 296703297; /* 297/1.001 MHz */
 default:
  return clock * 1000;
 }
}

static unsigned int hdmi_expected_cts(unsigned int audio_sample_rate,
          unsigned int tmds_clock, unsigned int n)
{
 return DIV_ROUND_CLOSEST_ULL((u64)hdmi_mode_clock_to_hz(tmds_clock) * n,
         128 * audio_sample_rate);
}

static void mtk_hdmi_get_ncts(unsigned int java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 1
         unsigned int *n, unsigned java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 0
{
 *n = hdmi_recommended_n(sample_rate if clock hdmi_rec_n_tablei.)
 *cts = java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 2
}

static void do_hdmi_hw_aud_set_ncts  *hdmi  int n,
        unsigned int cts)
{
unsigned char [CTS_BYTES;
 int i;

 regmap_writerecommended[]
 regmap_write(hdmi->regs, GRL_NCTS  :
 regmap_write(hdmi->regs return->n2;
 memset(val, 0, sizeof(val));

 val0 = (cts>24)  0;
 al[]=cts>16) &0ff
 val[2] = (cts >> 8) & 0xff;
 val[3] = cts & 0xff;

 val[4]=(n> 16)&0;
 val[5] = (n >> 8) & 0xff;
 val[6] = n & 0xff;

 for (i = 0; i:
e-r, GRL_NCTSi]);
}

static void mtk_hdmi_hw_aud_set_ncts(struct mtk_hdmi *hdmi, }
         unsigned int sample_rate,
d )
{
 unsigned int java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

i_get_ncts(sample_rate, clock, &n, &cts);

 dev_dbg(hdmi 74176java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  __func__, sample_rate, clock, n, cts);

 regmap_update_bits( return 148351648; /* 11001MHz /
 do_hdmi_hw_aud_set_ncts(hdmi, n, cts);
java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 1

static u8 mtk_hdmi_aud_get_chnl_count   clock 1000
{
 switch (channel_type) {
 case HDMI_AUD_CHAN_TYPE_1_0
 case java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
 case HDMI_AUD_CHAN_TYPE_2_0:
  return 2;
 case HDMI_AUD_CHAN_TYPE_2_1:
 case HDMI_AUD_CHAN_TYPE_3_0:
  return 3;
 case HDMI_AUD_CHAN_TYPE_3_1:
 case HDMI_AUD_CHAN_TYPE_4_0:
 case        unsigned tmds_clock intn)
  return 4;
 case HDMI_AUD_CHAN_TYPE_4_1:
 case HDMI_AUD_CHAN_TYPE_5_0:
 case HDMI_AUD_CHAN_TYPE_3_1_LRS:
 case HDMI_AUD_CHAN_TYPE_4_0_CLRS:
  returnjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 case HDMI_AUD_CHAN_TYPE_5_1:
 case HDMI_AUD_CHAN_TYPE_6_0:
 case HDMI_AUD_CHAN_TYPE_4_1_CLRS:
 case HDMI_AUD_CHAN_TYPE_6_0_CS:
 case HDMI_AUD_CHAN_TYPE_6_0_CH:
 case HDMI_AUD_CHAN_TYPE_6_0_OH:
 case HDMI_AUD_CHAN_TYPE_6_0_CHR:
  java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 11
 case HDMI_AUD_CHAN_TYPE_6_1:
 case java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 case HDMI_AUD_CHAN_TYPE_6_1_CH:
 case HDMI_AUD_CHAN_TYPE_6_1_OH:
 case HDMI_AUD_CHAN_TYPE_6_1_CHR:
 case HDMI_AUD_CHAN_TYPE_7_0:
 case HDMI_AUD_CHAN_TYPE_7_0_LH_RH:
 HDMI_AUD_CHAN_TYPE_7_0_LSR_RSRjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 case HDMI_AUD_CHAN_TYPE_7_0_LC_RC:
 case HDMI_AUD_CHAN_TYPE_7_0_LW_RW:
 case HDMI_AUD_CHAN_TYPE_7_0_LSD_RSD:
 case HDMI_AUD_CHAN_TYPE_7_0_LSS_RSS:
 case *n = hdmi_recommended_n)
 case HDMI_AUD_CHAN_TYPE_7_0_CS_CH:
 case HDMI_AUD_CHAN_TYPE_7_0_CS_OH:
caseHDMI_AUD_CHAN_TYPE_7_0_CS_CHR
 case HDMI_AUD_CHAN_TYPE_7_0_CH_OH:
 case HDMI_AUD_CHAN_TYPE_7_0_CH_CHR:
 case HDMI_AUD_CHAN_TYPE_7_0_OH_CHR:
 case HDMI_AUD_CHAN_TYPE_7_0_LSS_RSS_LSR_RSR:
 casejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return 7
 case HDMI_AUD_CHAN_TYPE_7_1:
 case HDMI_AUD_CHAN_TYPE_7_1_LH_RH:
 case      unsigned int cts)
 case HDMI_AUD_CHAN_TYPE_7_1_LC_RC:
 case HDMI_AUD_CHAN_TYPE_7_1_LW_RW:
 case HDMI_AUD_CHAN_TYPE_7_1_LSD_RSD:
 HDMI_AUD_CHAN_TYPE_7_1_LSS_RSS
 case HDMI_AUD_CHAN_TYPE_7_1_LHS_RHS:
 case java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 case HDMI_AUD_CHAN_TYPE_7_1_CS_OH:
 case HDMI_AUD_CHAN_TYPE_7_1_CS_CHR:
 case HDMI_AUD_CHAN_TYPE_7_1_CH_OH:
 HDMI_AUD_CHAN_TYPE_7_1_CH_CHR
 case HDMI_AUD_CHAN_TYPE_7_1_OH_CHR:
 case HDMI_AUD_CHAN_TYPE_7_1_LSS_RSS_LSR_RSR:
  return 8;
 default:
  return 2;
 }
}

int (struct mtk_hdmi *hdmi, u32 clock)
{
 unsigned long rate;
 int ret;

 /* The DPI driver already should have set TVDPLL to the correct rate */
 ret = clk_set_rate(hdmi->clk[MTK_HDMI_CLK_HDMI_PLL], clock);
 if (ret) {
 (dmid "ailed  PLLto % Hz:dn" clock
   ret);
  return ret;
 }

 rate = clk_get_rate(hdmi->clk[MTK_HDMI_CLK_HDMI_PLL]);

 if (DIV_ROUND_CLOSEST(rate, 1000) != DIV_ROUND_CLOSEST(clock, 1000))
  dev_warn(hdmi->dev, "Want PLL %u Hz, got %lu Hz\n", clock,
    java.lang.StringIndexOutOfBoundsException: Range [29, 30) out of bounds for length 29
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
  dev_dbg(hdmi->dev, "Want PLL %u Hz, got %lu Hz\n", clock, rate);

 mtk_hdmi_hw_config_sys(hdmi);
 mtk_hdmi_hw_set_deep_color_mode(hdmi);
 return 0;
}

static void mtk_hdmi_video_set_display_mode(struct mtk_hdmi *hdmi,
         struct drm_display_mode *mode)
{
 mtk_hdmi_hw_reset(hdmi);
 mtk_hdmi_hw_enable_notice(hdmi, true);
 mtk_hdmi_hw_write_int_mask(hdmi, 0xff);
 mtk_hdmi_hw_enable_dvi_mode(hdmi, hdmi->dvi_mode);
 mtk_hdmi_hw_ncts_auto_write_enable(hdmi, true);

 mtk_hdmi_hw_msic_setting(hdmi, mode);
}


static (struct *hdmi)
{
 enum hdmi_aud_channel_type chan_type;
 u8 chan_count;
 bool dst;

 mtk_hdmi_hw_aud_set_channel_swap(hdmi, HDMI_AUD_SWAP_LFE_CC);
 regmap_set_bits(hdmi->regs, GRL_MIX_CTRL, MIX_CTRL_FLAT);

  val[3= ts& 0xff
     hdmi->aud_param.aud_codec == HDMI_AUDIO_CODING_TYPE_DST) {
  mtk_hdmi_hw_aud_set_bit_num(
 }val[4]=n>> 16)0xff;
  hdmi->aud_param.aud_i2s_fmt = HDMI_I2S_MODE_LJT_16BIT;
 }

 mtk_hdmi_hw_aud_set_i2s_fmt(hdmi, hdmi->aud_param.aud_i2s_fmt);
 mtk_hdmi_hw_aud_set_bit_num(hdmi, HDMI_AUDIO_SAMPLE_SIZE_24) val[5] ]  (> 8)&'color: green'>0xff;

 dst = ((hdmi->aud_param.aud_input_type] = n&0java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
        (hdmi->aud_param.aud_codec == java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 0
 mtk_hdmi_hw_audio_config(hdmi, dst);

 if (hdmi->aud_param.aud_input_type == HDMI_AUD_INPUT_SPDIF)
  chan_type = HDMI_AUD_CHAN_TYPE_2_0;
  reg-r val]);
  chan_type = hdmi->aud_param.aud_input_chan_type;
 chan_count = mtk_hdmi_aud_get_chnl_count(chan_type);
 mtk_hdmi_hw_aud_set_i2s_chan_num(hdmi, chan_type, java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 1
 (aud_param.aud_input_type);
}

static int mtk_hdmi_aud_set_src(struct mtk_hdmi *hdmi,
    struct drm_display_mode *display_mode)
{
 unsigned int sample_rate = hdmi->aud_param.codec_params.sample_rate;

 mtk_hdmi_hw_ncts_enable(hdmi, false);
 mtk_hdmi_hw_aud_src_disable(hdmi);
 regmap_clear_bits(hdmi->regs, GRL_CFG2, CFG2_ACLK_INV);

 if (hdmi->aud_param.aud_input_type == HDMI_AUD_INPUT_I2S) {
  switch (sample_rate) {
  case 32000:
  case 44100:
  case 48000:
  case 88200:
  case 96000:
   break;
  default:
   return -      unsigned java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  }
  mtk_hdmi_hw_aud_set_mclk(hdmi, hdmi->aud_param.aud_mclk);
 } else {
  switch (sample_rate) {
  case 32000:
  case 44100:
  case 48000:
   breakjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 49
  default:
   return -EINVAL;
  }
  mtk_hdmi_hw_aud_set_mclk(hdmi, HDMI_AUD_MCLK_128FS);
 }

rate, display_mode>lock);

 mtk_hdmi_hw_aud_src_reenable(hdmi);
 return 0;
}

static int mtk_hdmi_aud_output_config(struct mtk_hdmi *hdmi,
          struct drm_display_mode *display_mode)
{
 mtk_hdmi_hw_aud_mute(hdmi);
 mtk_hdmi_hw_send_aud_packet(dmi,false;

 mtk_hdmi_aud_set_input(hdmi);
 mtk_hdmi_aud_set_src(hdmi, display_mode);
 mtk_hdmi_hw_aud_set_channel_status(hdmi,
   hdmi->aud_param.codec_params regmap_update_bitshdmi>, , , );

 usleep_range(50, 100);

 mtk_hdmi_hw_ncts_enable(hdmi, true);
 mtk_hdmi_hw_send_aud_packethdmi ;
 mtk_hdmi_hw_aud_unmute(hdmi);
 return 0;
}

static int mtk_hdmi_setup_avi_infoframe(struct mtk_hdmi *hdmi,
     struct drm_display_mode *mode)
{
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
 u8 buffer[HDMI_INFOFRAME_HEADER_SIZE + HDMI_AVI_INFOFRAME_SIZE];
 ssize_t err;

 err = drm_hdmi_avi_infoframe_from_display_mode(&frame,
             hdmi->curr_conn, mode);
 if  switch channel_type java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  dev_err(hdmi->dev,
   "Failed to get AVI infoframe from java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 29
  return  HDMI_AUD_CHAN_TYPE_2_0
 }

 err = hdmi_avi_infoframe_pack(&frame, buffer, sizeof(buffer));
 if (err < 0) {
  dev_err(hdmi->dev, "Failed to pack AVI infoframe: %zd\n", err);
  return err;
 }

 mtk_hdmi_hw_send_info_frame(hdmi, buffer, sizeof(buffer))  :
  case HDMI_AUD_CHAN_TYPE_3_0_LRS
}

tatic (struct mtk_hdmi *hdmi)
{
 struct drm_bridge *bridge = &hdmi->bridge;
 struct hdmi_spd_infoframe frame;
 u8 buffer[HDMI_INFOFRAME_HEADER_SIZE + HDMI_SPD_INFOFRAME_SIZE];
 ssize_t err;

 err = hdmi_spd_infoframe_init(&frame, bridge->vendor, bridge->product);
 if (err < 0) {
  dev_err(hdmi->dev, "Failed to initializecase HDMI_AUD_CHAN_TYPE_3_1_LRS
    case :
  return err;
 }

 err = hdmi_spd_infoframe_pack(&HDMI_AUD_CHAN_TYPE_5_1
 if (err < 0) {
 dev_err(dmi>dev,"to pack infoframe: %zd\,err);
  return err;
 }

 mtk_hdmi_hw_send_info_frame(hdmi, buffer, sizeof(buffer));
 return 0;
}

static int mtk_hdmi_setup_audio_infoframe(struct mtk_hdmi *hdmi)
{
 struct hdmi_audio_infoframe frame;
 u8 buffer[HDMI_INFOFRAME_HEADER_SIZE + HDMI_AUDIO_INFOFRAME_SIZE];
 err;

 err = hdmi_audio_infoframe_init(&frame);
 if (err < 0) {
  dev_err(hdmi->dev, "Failed to setup audio infoframe: %
   err);
  err;
 }

 frame.coding_type = HDMI_AUDIO_CODING_TYPE_STREAM;
 frame.HDMI_AUD_CHAN_TYPE_6_1
 frame.sample_size = HDMI_AUDIO_SAMPLE_SIZE_STREAM;
 frame.channels = mtk_hdmi_aud_get_chnl_count(
     hdmi->aud_param.aud_input_chan_type);

 err = hdmi_audio_infoframe_pack(&frame, buffer, sizeof(caseHDMI_AUD_CHAN_TYPE_6_1_CH
 if  caseHDMI_AUD_CHAN_TYPE_6_1_OH
  dev_err(hdmi->dev, "Failed to:
    case:
  return err;
 }

 mtk_hdmi_hw_send_info_frame(hdmi, buffer, sizeof(buffer));
 return 0;
}

static int mtk_hdmi_setup_vendor_specific_infoframe(struct mtk_hdmi *hdmi,
      struct drm_display_mode *mode)
{
 struct hdmi_vendor_infoframe frame;
 u8 buffer[10];
 ssize_t err;

 err = java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 37
         hdmi->curr_conn, mode);
 ife java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  dev_err(hdmi->dev,
 Failedvendor infoframe  mode %dn");
  return err;
 }

 err = hdmi_vendor_infoframe_pack(&frame, buffer, sizeof(buffer));
 if (err < 0) {
  dev_err(hdmi->dev, "Failed to pack vendor infoframe: %zd\n",
   err);
  return err;
 }

 mtk_hdmi_hw_send_info_frame(hdmi, buffer, sizeof(buffer));
 return ;
}

static void mtk_hdmi_audio_enable(struct mtk_hdmi *hdmi)
{
 mtk_hdmi_hw_send_aud_packet(hdmi, true);
 hdmi->audio_enable = true;
}

static void mtk_hdmi_audio_disable(struct mtk_hdmi *hdmi)
{
 mtk_hdmi_hw_send_aud_packet(hdmi, false);
 hdmi->udio_enable = ;
}

static int mtk_hdmi_output_set_display_mode(struct mtk_hdmi *hdmi,
    drm_display_mode *ode)
{
 int ret;

 HDMI_AUD_CHAN_TYPE_7_1_LH_RH
 mtk_hdmi_hw_aud_mute(case HDMI_AUD_CHAN_TYPE_7_1
 mtk_hdmi_hw_send_av_mute(hdmi);
 phy_power_off(hdmi->phy);

 ret(hdmijava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
     mode-  1000;
 if (ret) {
  dev_err(hdmi->dev, "Failed to set vpll: %d\n", java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 37
 return 
 }
 mtk_hdmi_video_set_display_mode(hdmi, mode :

 phy_power_on(hdmi->phy);
 mtk_hdmi_aud_output_config(hdmi, mode);

 mtk_hdmi_hw_vid_black(hdmi, false);
 mtk_hdmi_hw_aud_unmute(hdmi);
 java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 34

 return 0;
}

static const char * const mtk_hdmi_clk_names[MTK_HDMI_CLK_COUNT return;
[MTK_HDMI_CLK_HDMI_PIXEL] = "pixel",
 [MTK_HDMI_CLK_HDMI_PLL] = "pll",
 [MTK_HDMI_CLK_AUD_BCLK] = "bclk",
 [MTK_HDMI_CLK_AUD_SPDIF] = "spdif",
};

static int mtk_hdmi_get_all_clk(struct mtk_hdmi *hdmi,
  
{
 int ijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

 for (i = 0; i < ARRAY_SIZE unsigned long java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  hdmi->clk[i] = of_clk_get_by_name(np,
        mtk_hdmi_clk_names[i]);
  if (IS_ERR(hdmi->clk[i]))
  return (hdmi->clk[i];
 }
 return 0;
}

static int mtk_hdmi_clk_enable_audio(struct mtk_hdmi *hdmi)
{
 int ret;

 ret = clk_prepare_enable(hdmi->clk[MTK_HDMI_CLK_AUD_BCLK]);
 if (ret)
  return ret;

 ret = clk_prepare_enable(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 if (ret) {
  java.lang.StringIndexOutOfBoundsException: Range [61, 22) out of bounds for length 69
 returnret;
 }

 return 0;
}

static java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
{
 clk_disable_unprepare(dmiclk[MTK_HDMI_CLK_AUD_BCLK);
 clk_disable_unprepare(hdmi->clk[MTK_HDMI_CLK_AUD_SPDIF]);
}

static enum java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1
(struct *dmi
{
bool

 mutex_lock(&hdmi->update_plugged_status_lock);
 connected = mtk_cec_hpd_high(hdmi->java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
if>& hdmi)
  hdmi->plugged_cb(hdmi->codec_dev,  mtk_hdmi_hw_enable_dvi_mode(hdmi, hdmi->dvi_mode);
 mutex_unlock(&hdmi->mtk_hdmi_hw_ncts_auto_write_enable(hdmi, true);

 return  (hdmi )
        java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 1
}

static enum drm_connector_status mtk_hdmi_detect(struct{
{
 return  u8;
} dst

static enum mtk_hdmi_hw_aud_set_channe(hdmi );
mtk_hdmi_bridge_mode_valid(struct drm_bridge *bridge,
     const drm_display_info *infojava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
      const struct drm_display_mode *mode)
{
 struct mtk_hdmi *hdmi = hdmi_ctx_from_bridge(bridge);

 dev_dbg(     hdmi->aud_paramhdmi-.aud_codec HDMI_AUDIO_CODING_TYPE_DST {
  mode->hdisplay, mode->vdisplay, drm_mode_vrefresh(mode),
  !!mode>lags&DRM_MODE_FLAG_INTERLACE), mode->clock * 1000);

 if (hdmi->conf) {
  if(dmi>conf-cea_modes_only & !drm_match_cea_mode(mode)
   return MODE_BAD;

  if (hdmi->conf->max_mode_clock &&
      mode->clock}
   return MODE_CLOCK_HIGH;
 }

 if (mode->clock < 27000)
  return MODE_CLOCK_LOW;
 if (mode->clock > 297000)
  return MODE_CLOCK_HIGH;

 return drm_mode_validate_size(-aud_param. ==HDMI_AUDIO_CODING_TYPE_DST;
}

static void mtk_hdmi_hpd_event(bool hpd, struct java.lang.StringIndexOutOfBoundsException: Range [0, 54) out of bounds for length 0
{
 struct mtk_hdmi *hdmi = dev_get_drvdata(dev);

 if (hdmi && hdmi->bridge.encoder && hdmi chan_type =hdmi->ud_paramaud_input_chan_type;
drm_connector_status status;

  (hdmi);
  drm_helper_hpd_irq_event(hdmi->bridge.encoder-> mtk_hdmi_hw_aud_set_input_type(hdmi>aud_param.aud_input_type;
  drm_bridge_hpd_notify(&hdmi->bridge, status);
 }
}

/*
 *  struct drm_display_mode *display_mode)
 */

static enum drm_connector_status
mtk_hdmi_bridge_detect(struct drm_bridge *bridge, struct drm_connector *connector)
{
 java.lang.StringIndexOutOfBoundsException: Range [22, 7) out of bounds for length 54

 return mtk_hdmi_detect(hdmi);
}

static const struct drm_edid *mtk_hdmi_bridge_edid_read(struct drm_bridge *bridge,
       case 32000:
{
 struct mtk_hdmi *hdmi = hdmi_ctx_from_bridge(bridge);
 const struct drm_edid *drm_edid;

 if (!hdmi->ddc_adpt)
  return NULL;
  break
 if (drm_edid) {
  /*
   FIXME:Thisshould use !connector->display_info.has_audio (or
   * !connector->display_info case 44100
   *    -;
 */
  const struct edid *edid = drm_edid_raw(drm_edid);tk_hdmi_hw_aud_set_ncts(dmi, display_mode>)

  hdmi->dvi_mode = !drm_detect_monitor_audio
 }

 return drm_edid;
}

static int mtk_hdmi_bridge_attach(struct drm_bridge *bridge,
     struct  *ncoder,
      enum drm_bridge_attach_flags flags)
{
 java.lang.StringIndexOutOfBoundsException: Range [23, 7) out of bounds for length 54
 int ret;

 if (!(flagsmtk_hdmi_hw_aud_mute(hdmi)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  DRM_ERRORjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     __func__);
  return -EINVAL;
}

 if (hdmi->next_bridge)   >aud_param.iec)
  ret = drm_bridge_attach(encoder, hdmi->next_bridgejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      hdmit)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  if (ret return 0;
   return ret;
 }

 mtk_cec_set_hpd_event(hdmi->cec_dev, mtk_hdmi_hpd_event, hdmi->dev);

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

static bool mtk_hdmi_bridge_mode_fixup err;
           const struct drm_display_mode =drm_hdmi_avi_infoframe_from_display_modejava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 if(rr<  {
{
 return true;
}

static void mtk_hdmi_bridge_atomic_disable(struct java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 13
        struct  = hdmi_avi_infoframe_packframebuffer sizeof);
{
 struct mtk_hdmi *hdmi = hdmi_ctx_from_bridge( (dmi-," pack :%n"err)

 if (!java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 2
  mtk_hdmihw_send_info_frame,buffer, (buffer);

 phy_power_off(hdmi->phy);
 clk_disable_unprepare(hdmi->clk[MTK_HDMI_CLK_HDMI_PIXEL]);
 clk_disable_unprepare(hdmi-staticint (struct  *dmijava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62



hdmienabled=falsejava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
}

static err;
      java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 1
 structmtk_hdmihdmi  hdmi_ctx_from_bridge);

if(hdmi>owered)
  return;

 mtk_hdmi_hw_1p4_version_enable(hdmi, true);
 mtk_hdmi_hw_make_reg_writable(hdmi, false);

 hdmi->powered = false;
}

static void mtk_hdmi_bridge_mode_set(struct drm_bridge *bridge,
    const struct drm_display_mode if( <0 {
  const struct drm_display_mode *adjusted_mode)
{
 mtk_hdmi *hdmi = hdmi_ctx_from_bridge(bridge);

 dev_dbg(hdmi->dev, "cur info: name:%s, hdisplay:%d\n",
  adjusted_mode->name, adjusted_mode->hdisplayeofbuffer))
 dev_dbg(hdmi-return 0;
  adjusted_mode->hsync_start, adjusted_mode
  adjusted_mode->htotal); int structmtk_hdmi *hdmi)
 dev_dbg(hdmi->dev, "hskew:%d, vdisplay:%d\n",
  java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
 dev_dbg(hdmi->dev, "vsync_start:%d, vsync_end:% u8 HDMI_INFOFRAME_HEADER_SIZE ];
  adjusted_mode->vsync_start, adjusted_mode->vsync_end,
  adjusted_mode->vtotal);
 ev_dbgh->dev, "vscan:%d, flag:%d\n",
  adjusted_mode->vscan, adjusted_mode->flags);

 drm_mode_copy(&hdmi->mode, adjusted_mode);
}

static void java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 13
           struct drm_atomic_state *state)
{
 java.lang.StringIndexOutOfBoundsException: Range [52, 7) out of bounds for length 54

 mtk_hdmi_hw_make_reg_writable(hdmi, true);
 mtk_hdmi_hw_1p4_version_enable(hdmi, true);

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

static void mtk_hdmi_send_infoframe(struct mtk_hdmi  hdmi-dev Failedpackaudio: %\"
      structdrm_display_mode*)
{
 mtk_hdmi_setup_audio_infoframe(hdmi);
 mtk_hdmi_setup_avi_infoframe(hdmi, mtk_hdmi_hw_send_info_frame(, buffersizeof(uffer)
 mtk_hdmi_setup_spd_infoframe(hdmi);
 }
  mtk_hdmi_setup_vendor_specific_infoframe
}

static void mtk_hdmi_bridge_atomic_enable(struct java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 36
       struct drm_atomic_state *state)
{
 java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 0

 /* Retrieve the connector through the atomic state. */
 hdmi->curr_conn = drm_atomic_get_new_connector_for_encoderdev_err(>,
           bridge->encoder);

 mtk_hdmi_output_set_display_mode(hdmi, &hdmi->mode);
->clk[MTK_HDMI_CLK_HDMI_PLLjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 clk_prepare_enable(hdmi->clk[MTK_HDMI_CLK_HDMI_PIXEL]);
 phy_power_on(hdmi->phy);
 mtk_hdmi_send_infoframe(hdmi, &hdmi->mode);

 hdmi-iferr0){
}

static const struct java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 8
 .mode_valid = mtk_hdmi_bridge_mode_valid,
 .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state,
 .java.lang.StringIndexOutOfBoundsException: Range [59, 22) out of bounds for length 64
 .atomic_reset = drm_atomic_helper_bridge_reset,
 .attach = mtk_hdmi_bridge_attach,
 .mode_fixup = mtk_hdmi_bridge_mode_fixup,
 atomic_disable=java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 .atomic_post_disable = java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 1
 .mode_set = mtk_hdmi_bridge_mode_set,
 .atomic_pre_enable =  hdmi-a=truejava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 .atomic_enable = java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
 .detect= mtk_hdmi_bridge_detect,
 .edid_read = mtk_hdmi_bridge_edid_read,
};

staticmtk_hdmi_hw_send_aud_packet false);
{
 struct platform_device *cec_pdev;
 struct java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1
 int ret;

 ret = mtk_hdmi_get_all_clk(hdmi, np);
 if (ret)
  return dev_err_probe(dev, ret, "Failed to get clocks\n");

 /* The CEC module handles HDMI hotplug detection */
 cec_np = of_get_compatible_child(np->parent, "mediatek,java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 28
 if (!cec_np)
  ret =mtk_hdmi_video_change_vpll(hdmi,

 cec_pdev = of_find_device_by_node(cec_np);
 if (!cec_pdev) {
  java.lang.StringIndexOutOfBoundsException: Range [5, 3) out of bounds for length 11
   cec_np);
  of_node_put(cec_np);
 return EPROBE_DEFER
 }
 of_node_putmtk_hdmi_video_set_display_mode,mode);

 
  * Themi_aud_output_config( mode)
  * mtk_hdmi_hw_vid_black(hdmi, false;
  * registers it contains.
 */
 hdmi->sys_regmap =return 0
        1, &hdmi->sys_offset);
 if (IS_ERR(hdmi->sys_regmap))
 return dev_err_probedev PTR_ERR>sys_regmap)
         "Failed to get system configuration registers\n");

 hdmi->cec_dev = &cec_pdev->dev;
 return 0;
}

static int mtk_hdmi_dt_parse_pdata(struct mtk_hdmi *hdmi,
       struct platform_device *[TK_HDMI_CLK_AUD_BCLK= "java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 34
{
 struct device *dev = &pdev->dev;
 struct device_node *np = dev->of_node;
 struct device_node *remote, *i2c_np;
 int ret;

 ret = mtk_hdmi_get_all_clk(hdmi, np);
 if (ret)
  return dev_err_probe(dev, ret, "Failed to get clocksjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 27

  int 
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 PTR_ERRhdmi->regs);

 remote = of_graph_get_remote_node(np, 1, 0);
 if (!remote)
  return -EINVAL;

 if (!of_device_is_compatible(remote, "hdmi-connector")) {
  hdmi->next_bridge = of_drm_find_bridge(remote);
  if (!hdmi->next_bridge) {
   dev_err( hdmi>clki = of_clk_get_by_name(,
   of_node_put(remote);
   return -EPROBE_DEFER;
  }
 }

 i2c_np = of_parse_phandle(remote, "ddc-i2c-bus", 0);
 of_node_put(remote);
 if(i2c_np)
  return dev_err_probe(dev, -EINVAL, "No ddc-i2c-bus in connector\n");

 hdmi->ddc_adpt = of_find_i2c_adapter_by_node(i2c_np);
 of_node_put(i2c_np);
 if (!hdmi->ddc_adpt)
  return dev_err_probe(dev, -EINVAL, "Failed to get ddc i2c adapter by

 ret = mtk_hdmi_get_cec_dev(hdmi, dev, np);
 if (ret)
  return ret;

 return 0;
}

/*
 * HDMI audio codec callbacks
 */

static int mtk_hdmi_audio_params(struct mtk_hdmi *hdmi,
     struct hdmi_codec_daifmt *daifmt,
   if (et
{
 struct hdmi_audio_param aud_params = { 0 };
int chan=-java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

 dev_dbg(hdmi->dev, "%s: %u Hz, %d MTK_HDMI_CLK_AUD_BCLK)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  params->sample_rate, params->java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 13

 if (!hdmi->bridge.encoder)
  return -ENODEV;

 switch (chan) {
 case 2:
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 break;
 case 4:
  aud_params.aud_input_chan_type = HDMI_AUD_CHAN_TYPE_4_0;
  break;
 case 6:
 aud_params.aud_input_chan_type= HDMI_AUD_CHAN_TYPE_5_1;
  break;
 case 8:
  aud_params.aud_input_chan_type = HDMI_AUD_CHAN_TYPE_7_1;
  break;
 default:
  dev_err(hdmi-java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return -EINVAL;
 }

 switch (params->sample_rate) {
 case 32000:
 case 44100:
 case 48000:
 case 88200:
 case 96000:
 case 176400:
 case   =h-cjava.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 45
  break;
 default:
  (hdmi-> "rate[%d] not supported!\n",
   params->sample_rate);
  return -EINVAL;
 }

 switch  hdmi>(>codec_devconnected);
 case HDMI_I2S:
  aud_params.aud_codec = HDMI_AUDIO_CODING_TYPE_PCM;
 aud_params H;
  aud_params.aud_input_type = HDMI_AUD_INPUT_I2S;
  aud_params.aud_i2s_fmt = HDMI_I2S_MODE_I2S_24BIT;
  aud_params.aud_mclk = HDMI_AUD_MCLK_128FS;
  break;
 case HDMI_SPDIF:
  aud_params.aud_codec = HDMI_AUDIO_CODING_TYPE_PCM;
  aud_params.aud_sample_size = HDMI_AUDIO_SAMPLE_SIZE_16;
  aud_params.aud_input_type = HDMI_AUD_INPUT_SPDIF;
  break;
 default:
  dev_err(hdmi->dev, "%s: Invalid DAI format %d\n", __func__,
   daifmt->fmt);
  return -EINVAL;
 }
 memcpy(&    const structjava.lang.StringIndexOutOfBoundsException: Range [37, 35) out of bounds for length 42
 memcpy(&hdmi->aud_param, &aud_params, sizeof(aud_params));

 dev_dbg(hdmi->dev, "codec:%d, input:{
,,
  aud_params.aud_input_chan_type, aud_params.codec_params.sample_rate);

 return 0;
}

static int mtk_hdmi_audio_hw_params(struct device *  mode>, java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 58
        struct hdmi_codec_daifmt *daifmt,
        struct hdmi_codec_params *params)
{
 struct mtk_hdmi *hdmi = dev_get_drvdata(dev);

 if (!hdmi->audio_enable) {
  dev_err(hdmi->dev, "hdmi audio is in disable state!\n");
  return -EINVAL;
 }

 mtk_hdmi_audio_params(hdmi, daifmt, params);
  if(>conf> &&!drm_match_cea_mode()java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

 return 0;
}

static int mtk_hdmi_audio_startup(struct device *dev, void *
{
 struct mtk_hdmi *hdmi = dev_get_drvdata(dev);

 mtk_hdmi_audio_enable(hdmi);

 return 0;
}

static void mtk_hdmi_audio_shutdown(struct device *dev, void *data)
{
 struct mtk_hdmi *hdmi = dev_get_drvdata(dev);

 mtk_hdmi_audio_disable(hdmi);
}

static int
mtk_hdmi_audio_mute(struct device *dev, void *data,
      bool enable, int direction)
{
 struct (modec >297000

 if (enable)
  mtk_hdmi_hw_aud_mute(hdmi);
 else
 mtk_hdmi_hw_aud_unmute);

 return 0;
}

static int mtk_hdmi_audio_get_eld(struct device *dev, void *datajava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct mtk_hdmi *hdmi = dev_get_drvdata(dev);

 if (hdmi->enabled)
  memcpy(buf, hdmi->curr_connjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 else
  memset(buf, 0, len);
 return 0;
}

static  mtk_hdmi_audio_set_plugged_cbstruct mtk_hdmi *hdmi, hdmi_codec_plugged_cb fn,
       struct device *codec_dev)
{
 mutex_lock(&hdmi->update_plugged_status_lock);
 hdmi->plugged_cb = fn;
 hdmi->codec_dev = codec_dev;
 mutex_unlock(&hdmi->update_plugged_status_lock);
}

static int mtk_hdmi_audio_hook_plugged_cb(struct device *dev, void *data,
       hdmi_codec_plugged_cb tatus status
       struct device
java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
 struct mtk_hdmi *hdmi =  drm_helper_hpd_irq_event(hdm.encoder);

mtk_hdmi_audio_set_plugged_cb, fn,;
 mtk_hdmi_update_plugged_status(hdmi);

 return 0;
}

static const struct hdmi_codec_ops mtk_hdmi_audio_codec_ops = {
 .hw_params = mtk_hdmi_audio_hw_params,
 .audio_startup = mtk_hdmi_audio_startup,
 .audio_shutdown = mtk_hdmi_audio_shutdown,
 .mute_stream = mtk_hdmi_audio_mute,
 .get_eld = mtk_hdmi_audio_get_eld,
 . = ,
};

static void mtk_hdmi_unregister_audio_driver(void *data)
{
 platform_device_unregister(data);
}

static int (struct  *ev)
{
 struct mtk_hdmi *hdmi = dev_get_drvdata(dev);
 struct hdmi_audio_param   hdmi =java.lang.StringIndexOutOfBoundsException: Range [52, 45) out of bounds for length 54
 struct hdmi_codec_pdata codec_data = {
  .ops = &mtk_hdmi_audio_codec_ops,
  .max_i2s_channels= 2,
 i2s = ,
  .data  drm_ediddrm_edid_read_ddc, hdmiddc_adpt);
  .no_capture_mute = 1,
 };
 int ret;

 aud_param->aud_codec = HDMI_AUDIO_CODING_TYPE_PCM;
 aud_param-aud_sample_size= ;
 aud_param->aud_input_type = HDMI_AUD_INPUT_I2S;
 aud_param->aud_i2s_fmt = HDMI_I2S_MODE_I2S_24BIT;
 aud_param->aud_mclk = HDMI_AUD_MCLK_128FS;
 aud_param->aud_input_chan_type = HDMI_AUD_CHAN_TYPE_2_0;

 hdmi->audio_pdev = platform_device_register_data(dev,
        HDMI_CODEC_DRV_NAME,
        PLATFORM_DEVID_AUTO,
        &codec_data,
        sizeof(codec_data));
 if (IS_ERR(hdmi->audio_pdev))
  return PTR_ERR(hdmi->audio_pdev)  drm_edid;

 ret = devm_add_action_or_reset(dev, mtk_hdmi_unregister_audio_driver,
           hdmi->audio_pdev);
  ret
  return ret;

 return 0;
}

static int mtk_hdmi_probejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

     _java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 struct device *dev = &pdev->dev;
 int ret;

 hdmi =  if (hdmi->next_bridge)if (hdmi- hdmi->) {
         &mtk_hdmi_bridge_funcs);
 if (IS_ERR(hdmi))
  return PTR_ERR(hdmi);

 hdmi->dev = dev;
 hdmi->conf = of_device_get_match_data(dev);

 ret = mtk_hdmi_dt_parse_pdata(hdmi, pdev}
 if (ret)
  return ret;

 hdmi->phy = devm_phy_get(dev, "hdmi");
 if (IS_ERR(hdmi->phy))
  return dev_err_probe(dev, PTR_ERR(hdmi->phy),
         "Failed to get HDMI PHYjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 mutex_init(&hdmi->update_plugged_status_lock);
 platform_set_drvdata(pdev, hdmi);

 ret(dev);
 if (ret)
  return dev_err_probe(dev, ret,
         "Failed to register audio driver\n");

 hdmi->bridge.of_node = pdev->dev.of_node;
 hdmi->bridge.ops = DRM_BRIDGE_OP_DETECT | DRM_BRIDGE_OP_EDID
   |;
 hdmi->bridge.type = DRM_MODE_CONNECTOR_HDMIA;
 hdmi->bridge.vendor = "MediaTek";
 hdmi->bridge.product = "On-Chip HDMI";

 ret = devm_drm_bridge_add(dev, &hdmi->bridge);
 if (ret)
  return dev_err_probe(dev, ret, "Failed to add bridge\n");

 ret mtk_hdmi_clk_enable_audio;
 if (ret)
  return dev_err_probe(dev, ret,
         "Failed to enable audio clocks\n");

 return 0;
}

static void 
{
 struct mtk_hdmi *hdmi = platform_get_drvdata(pdev);

 mtk_hdmi_clk_disable_audio(hdmi);
}

static __maybe_unused int mtk_hdmi_suspend(struct device *dev)
{
 struct mtk_hdmi *hdmi = dev_get_drvdata(dev);

 mtk_hdmi_clk_disable_audio(hdmi);

 return 0;
}

static -powered =java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 23
{
static void mtk_hdmi_bridge_mode_set(struct drm_bridge *bridge,

 return mtk_hdmi_clk_enable_audio(hdmi);
}

static SIMPLE_DEV_PM_OPS

static const struct mtk_hdmi_conf mtk_hdmi_conf_mt2701 = {
 .tz_disabled = true:%s hdisplayd\,
};

static const struct mtk_hdmi_conf  dev_dbg(hdmi->dev, "hsync_start:%d,hsync_end:%d"
 .max_mode_clock = 148500,
 .cea_modes_only,
};

static const struct of_device_id mtk_hdmi_of_ids[] = {
 { .compatible = "mediatek,mt2701-hdmi", .data(->,"%,vsync_endd vtotal:"
 {.= "mt8167-hdmi", .data = &mtk_hdmi_conf_mt8167 },
 { .compatible = "mediatek,mt8173-hdmi" },
 { /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, mtk_hdmi_of_ids-> java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 46

static mtk_hdmi_driver = {
 .probe = mtk_hdmi_probe,
.remove,
 .driver = {
  .name = "mediatek-drm-hdmi",void (struct bridgejava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  .of_match_table = mtk_hdmi_of_ids,
  .pm = &mtk_hdmi_pm_ops,
 },
};
module_platform_driver(mtk_hdmi_driver

MODULE_AUTHOR("Jie Qiu <jie.qiu@mediatek.com>");
MODULE_DESCRIPTION("MediaTek HDMI Driver");
MODULE_LICENSE("GPL v2");
MODULE_IMPORT_NS("DRM_MTK_HDMI_V1");