Quelle  disp.c   Sprache: C

/*
 * Copyright 2011 Red Hat Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * Authors: Ben Skeggs
 */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
include
#include 
#"
#include "wndw.h"include/cl507d
# handles

#include <linux# <nvhw/.hjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 /dma-mapping
#include <linuxjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
<component
#include <linux/iopoll const *,  head  *,  size

{
#include <drm/display/drm_scdc_helper.h>
#include <drm/drm_atomic.h>
#include <drm/drm_atomic_helper.h>
#include <drm/drm_edid.h>
#include <drm/drm_eld.h>
#include <drm/drm_fb_helper.h>
#include <drm/drm_fixed.h>
#include <drm/drm_probe_helper.h>
#include <rmdrm_vblank>

#include <nvif/push507c.h>

#include <nvif/class.h>
#include <nvif/java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 15
 ;i++ java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 24
#nclude</if0014
#include</timer

#   ( == 0 java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
#include <nvhw/class/cl507d   (ret)
#include <nvhw/class/cl837d.h>
#include   n(&>user)
#include <nvhw  }
#include <nvhw/class/cl917d.h>

#include "nouveau_drv nvif_object_sclass_put(sclass;
#include "nouveau_dmah"
#include "nouveau_gem.h"
nv50_chan_destroy nv50_chanchan)
#include nvif_object_dtorchan-user);
#include "nouveau_fence.h"
#include "nv50_display.h"

/******************************************************************************
 * EVO channel
 *****************************************************************************/

static
nv50_chan_create( nvif_object_dtor(&dmac-);>);

   nv50_chan)
{
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1
  ret i,;

 chan->device = device;

 ret = n = nvif_object_sclass_get(disp, &sclass);
 if (ret < 0)
  return retjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 while (oclass[0]) {
fori=0; i <n ++{
   if (sclass[i].oclass == oclass[0]) {
  ret =nvif_object_ctor, kmsChan 0
             oclass[0 java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
             &chan->user);
  if(ret== 0 {
     ret = nvif_object_map(&chan->user, NULL,   nvif_devicedevice>base;
     ()
      nvif_object_dtor(&chan-nvif_msecdevice00java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  }
    nvif_object_sclass_put(&sclass);
  return;
   }
  } 
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

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

static int
nv50_chan_destroy(struct nv50_chan *chan)( nv50_dmacdmac
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 nvif_object_dtor(&chan->user);
}

/******************************************************************************
 * DMA EVO channel
 *****************************************************************************/

void
nv50_dmac_destroy(struct nv50_dmac *dmac)
{
 nvif_object_dtor(&dmac->vram);
 nvif_object_dtor(&dmac-> return - dmac-cur ;

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

 nvif_mem_dtor(&dmac->push.mem);
}

static void
nv50_dmac_kick(struct nvif_push
/* Wait for GET to depart from the beginning of the push buffer to
struct nv50_dmac *dmac = container_of(push, typeof(*dmac), push);

dmac->cur = push->cur - (u32 __iomem *)dmac->push.mem.object.map.ptr;
if (dmac->put != dmac->cur) {
/* Push buffer fetches are not coherent with BAR1, we need to ensure
 * writes have been flushed right through to VRAM before writing PUT.
 */
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct *device  dmac->.device
    nv50_dmac_kick>push
  
  if(((&device-, 0) &0))
    ifNVIF_TV32&>base , GETPTR> )
 ;
 }

  NVIF_WV32(&dmac->base.user, NV507C
  dmac->put = dmac-> PUSH_RSVDdmac->, (&>push);
 }

 push->bgn =  >cur 0
}

staticjava.lang.StringIndexOutOfBoundsException: Range [10, 11) out of bounds for length 10
nv50_dmac_free nv50_dmac*)
{
 u32java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
if get >cur /* NVIDIA stay 5 away from GET, do the same. */
  return get - dmac->cur ;
  dmac- - >cur
}

staticreturnEINVAL
nv50_dmac_wind( >cur >cur ( __ *)mac-.mem.map;
{
java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  * prevent writing  int ret = nv50_dmac_wind(dmac  if   return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  */
 u32 get   break;
 if  WARN_ON   }
  push->bgn = dmac->push push->bgn = push->bgn;
  if}
   nv50_dmac_kickkms_vram_pushbuf, "Place EVO/NVD push buffers in VRAMstatic int nv50_dmac_vram_pushbuf = -1;

  if (nvif_msec(dmac->base   const s32 *oclass, u8 head, void *   struct nv50_dmac{
   if ( u8  int java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    break  *
  ) < 0)
   return -ETIMEDOUT;
 }

 PUSH_RSVD(&dmac->push  * to allocate push  *
 dmac->cur = 0;  
 if(nv50_dmac_vram_pushbuf0|java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
}

static int
nv50_dmac_wait( nvif_pushpushu32 )
{
 struct nv50_dmac  = (&drm->, kmsChanPush,type0, &>push);
 ;

  return;
   mac-. =;

 >cur >cur u32_omem)>push.object.ptr;
 if (dmac->cur + size >= dmac->max) {
  int ret = nv50_dmac_wind(dmac); dmac-push = dmac-.mem.mapptr
  ifret
 return;

 >cur >push.object.ptr
  push-/
  nv50_dmac_kick(ush)
 }

 if (nvif_msec(dmac->base  * of the push buffer aren'
  if (free=nv50_dmac_free)) =size
   break;
 ) <ac-> -=1;
  WARN_ON(1);
  return -ETIMEDOUT;
 

 push->bgn = dmac->push.memjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 push->bgn = push->bgn + dmac->cur;
 push->cur = push->bgn;
 push->         &>base
 return if(et)
}

MODULE_PARM_DESC(kms_vram_pushbuf  ret
static
ule_param_namedkms_vram_pushbuf,nv50_dmac_vram_pushbufint 40;

java.lang.StringIndexOutOfBoundsException: Range [10, 3) out of bounds for length 3
nv50_dmac_create(struct java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
   const s32 *oclass
   dmac-sync =NV50_DISP_HANDLE_SYNCBUF
{ >vram =N;
 struct return0;
 struct nvif_object *disp = &drm->display->disp java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
struct * = data
 u8 type = NVIF_MEM_COHERENT
 int ret;

 /* Pascal added support for 47-bit physical addresses, but some
 * parts of EVO still only accept 40-bit PAs.
 *
 * To avoid issues on systems with large amounts of RAM, and on
 * systems where an IOMMU maps pages at a high address, we need
 * to allocate push buffers in VRAM instead.
 *
 * This appears to match NVIDIA's behaviour on Pascal.
 */
 if ((nv50_dmac_vram_pushbuf > 0) ||
  . =java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  type |= NVIF_MEM_VRAM;

  = nvif_mem_ctor_map&>mmu"",type0, &>push);
 ifret
 returnret

  ret =&>base, "kmsVramCtxDma,NV50_DISP_HANDLE_VRAMjava.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
 dmac->push.  t =NV_DMA_V0_TARGET_VRAM,
 dmac-.ccessNV_DMA_V0_ACCESS_RDWR
 dmac-.cur >push;
 dmac-  .imit =device-. - 1,
 dmac-} (struct),

 /* EVO channels are affected by a HW bug where the last 12 DWORDs &vram;
 * of the push buffer aren't able to be used safely.
 */
 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  dmac-***java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 args->pushbuf = nvif_handle(&dmac->push.mem.object);

r = nv50_chan_create(evice, disp, head, size
         dmac->
 if ()
  return    outp->.base, outp-.dp_interlace

 if (syncbuf < 0)
  return 0

java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
ass=GB202_DISP{
  /* "handle != NULL_HANDLE" is used to determine enable status
 * in a number of places, so fill in some fake object handles.
 */
    drm_display_mode* = &rtc_state-;
  dmac->vram.  drm_display_modemode&>mode
  return structdrm_connector*onnectorconn_state->;
 }

 ret = nvif_object_ctor(&dmac->base.user,   nouveau_drmdrm (encoder-);
        ,
         &struct) java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
arget ,
     .access = NV_DMA_V0_ACCESS_RDWR case:
     .start = syncbuf + 0x0000,
     .limit = syncbuf + 0x0fff,
      * refresh rate 
        dmac-);
 if      mode- == >vdisplay
 return ret;

ret nvif_object_ctor(dmac-.user"", NV50_DISP_HANDLE_VRAM
          NV_DMA_IN_MEMORY >scaler =true
        ( nv_dma_v0{
     .target = NV_DMA_V0_TARGET_VRAM,
     .access = NV_DMA_V0_ACCESS_RDWR,
     break
 }
   },sizeof nv_dma_v0
            = ;
 f()
  return

 return ret;
}

/******************************************************************************(adjusted_mode mode);
 * Output path helpers
 *****************************************************************************/
static void
nv50_outp_dump_caps(struct nouveau_drm *drm
  structnouveau_encoderoutp
{
 NV_DEBUG
  outp-.base, >caps);
}

static int
nv50_outp_atomic_check_view(struct
       drm_crtc_state,
        truct * = nouveau_encoderencoder
       drm_display_mode)
{
 struct drm_display_mode u int max_ratemode_rate;
 struct * = &rtc_state-;
 struct   DCB_OUTPUT_DP
 structmax_ratenv_encoder->. * nv_encoder-.link_bw
 struct nouveau_drm/

 NV_ATOMIC asyh-or =min_t(, >or.bpc 0;
 asyc->scaler.full = false;
 if (  * reduce the bpc until it works out */
  return 0;

   = (mode-clock *asyh->r.pc 3 )
  switchif mode_rate2
  :
  case DRM_MODE_CONNECTOR_eDP default
   /* Don't force scaler for EDID modes with
 * same size as the native one (e.g. different
 * refresh rate)
 */
   if (mode->hdisplay == native_mode->hdisplay &&
       mode->vdisplay == native_mode->vdisplay &&
       mode->type & DRM_MODE_TYPE_DRIVER{
    break;
   mode = native_mode;
   asyc-> struct nouveau_connector *nv_connector = nouveau_connector(connector);
   break;
   ret = nv50_outp_atomic_check_view(encoder, crtc_state, conn_state,
   break;
 if (crtc_state->mode_changed || crtc_state->connectors_changed)
 } else {
  mode = java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 0
 }

 if nv50_outp_get_new_connectorstruct *tate nouveau_encoderoutpjava.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89
 drm_mode_copyadjusted_mode, mode;
  crtc_state->mode_changed = true;
 }

 return 0;
}

static void
nv50_outp_atomic_fix_depth(struct drm_encoder *encoder, struct drm_crtc_state *crtc_state)
{
 struct nv50_head_atom  structdrm_encoder*ncoder=to_drm_encoder);
 structnouveau_encodernv_encoder(encoder
 struct>best_encoder )
 unsigned  return(connector

 switch java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 case nouveau_connector
  max_rate(struct  *, struct *outp

 /  dont supportmore 0anyway/
 a>orbpc  (u8 >orbpc0;

  inti;
  while (for_each_old_connector_in_s(, connector , i java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  return(connector
   }
  

    asyh-
 }
  break;
 default:
  break;
 }
}

static int
nv50_outp_atomic_check(struct drm_encoderencoder
         struct *;
        struct *conn_state
{
 struct drm_connector *
 structnouveau_connectornv_connector (connector
 structnv50_head_atom*syh =nv50_head_atom);
 int returnnouveau_crtc);

 ret = nv50_outp_atomic_check_view return ;
       nv_connector-
 if (ret
  return ret * DAC

 if (crtc_state- void
 >or = connector-display_info;

 /* We might have to reduce the bpc */
nv50_outp_atomic_fix_depth, crtc_state

 return 0;
}

struct nouveau_connector *
nv50_outp_get_new_connector(struct drm_atomic_state *state, struct nouveau_encoder *outp)
{
 struct drm_connector *connector;
 struct drm_connector_state *connector_state;
 struct 
 inti;

 for_each_new_connector_in_statestate connector, connector_statei){
  if (connector_state->best_encoder == encoder)
   return nouveau_connector}
 }

  NULL;
}

struct nouveau_connector *
nv50_outp_get_old_connector  * =nouveau_encoder);
{
 structdrm_connector*onnector
 struct drm_connector_stateconnector_state
 struct nv50_head_atom(state nv_crtc-base;
 int i;

 for_each_old_connector_in_state(statestructnv50_core * = (>dev-core
  if(>best_encoder=)
   return nouveau_connector( return nouveau_connector(connector
 }

nNULL
}

static struct nouveau_crtc *
nv50_outp_get_new_crtc(const struct drm_atomic_state *case: ctrl | (NV907DDAC_SET_CONTROL ,HEAD2;;
{
 struct  :
 (1;
  u32 mask drm_encoder_maskoutp-.);
 int i;

 for_each_new_crtc_in_state(statectrl=NVDEF, DAC_SET_CONTROLPROTOCOLRGB_CRT
  if(>encoder_mask )
   return nouveau_crtc(  (&nv_encoder->);
 }

 return NULL >or. =0java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
}

/******************************************************************************
 * DAC
 *****************************************************************************/
static void
nv50_dac_atomic_disable(struct struct nouveau_encoder *nv_encnouveau_encodernv_encoder  (encoder
{
 struct  ret
 struct nv50_core *coreloadval =(encoder-)>.dactestval
  u32 =NVDEF, DAC_SET_CONTROL,OWNERNONE)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

 core->ret (&nv_encoder-, loadval;
  if (ret)
}

static void
nv50_dac_atomic_enablereturn connector_status_disconnected
{
 struct nouveau_encoder
  = nv50_outp_get_new_crtc, nv_encoder
 struct nv50_head_atom *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  nv50_head_atom(drm_atomic_get_new_crtc_state(statenv50_dac_help=java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 struct nv50_core.tomic_disable=nv50_dac_atomic_disable
u32  0

 switch (nv_crtc- void
 case: ctrl |=NVDEF, , OWNER ); break;
 case 1: ctrl |= NVDEF(NV507D, DAC_SET_CONTROL{
 case 2  nouveau_encodernv_encoder nouveau_encoderencoder
  (&v_encoder-);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 WARN_ON;
  break;
 }

 }

static  struct
  nvif_outp_acquire_dac ={

 >.or, ctrlasyh);
 asyh->or.depth = 0;

 nv_encoder-
}

static enum drm_connector_status
nv50_dac_detect(struct drm_encoder *encoder, struct drm_connector
{
struct n = nouveau_encoderencoder
 u32 nvkm_i2ci2c  (drm
 int s nvkm_i2c_busbusjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

 loadval = nouveau_drm(encoder->dev)->vbios.dactestval;
 if (  type=DRM_MODE_ENCODER_DAC
al =30java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

 ret
if( < )
  connector_status_disconnected

 return connector_status_connected;
}

static const struct drm_encoder_helper_funcs
nv50_dac_help {
 .atomic_check(encoder)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 .atomic_enable
 .
 .detect
};

static  )
nv50_dac_destroy(struct   acomp >audio_ops >audio_ops-)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
uveau_encoder* =nouveau_encoder();

 nvif_outp_dtor(struct *,  , int,

drm_encoder_cleanup);
 kfree(encoder);
}

static const struct  *;
nv50_dac_func = {
.  ,
};

static int
nv50_dac_create;
{
 struct drm_connector (&drm-audio);
 struct nouveau_drm *drm  drm_for_each_encoder(encoder drm-dev) {
 struct nvkm_i2c *i2c = nvxx_i2c(drm);
 struct nvkm_i2c_bus *bus  structnouveau_connector * = NULL
 struct  if(>encoder_type = DRM_MODE_ENCODER_DPMST
 structdcb_output *dcbe=nv_encoder-dcb;
 int type java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 busif! ||nv_encoder->.orid=port|nv_crtc- != dev_id)
ifbus
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 encoder = to_drm_encoder(nv_encoder);
 drm_encoder_init(connector->dev, encoder, &nv50_dac_func
     
 drm_encoder_helper_add(encoder,}

 drm_connector_attach_encoder(connectorm(&>.lock
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
}

/*
 * audio component binding for ELD notification
 */
staticvoid
nv50_audio_component_eld_notify(struct int
  int)
{
 if    voiddata
  acomp-audio_ops-pin_eld_notifyacomp->audio_ptr
       port, dev_id);
}

static int
nv50_audio_component_get_eld(struct  structdrm_audio_component*comp=data
  (WARN_ON(!evice_link_addhda_kdevkdevDL_FLAG_STATELESS)
{
 struct nouveau_drm *
  drm_encoderencoder
 nouveau_encodernv_encoder;
 nouveau_crtc;
 intret = 0

 enabled false;

 mutex_lock(&drm->audio.lock);

 drm_for_each_encoder(encoder, drm->dev) {
  struct  eturn;

  if}
   continue; /* TODO */ void

  nv_encoder = nouveau_encoder(encoder);
  nv_connector = nv_encoder->conn;
  nv_crtc =  voiddata)

  if (!nv_crtc || nv_encoder->outp
  ;

  *enabled  truct * = data
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   ret =drm_eld_size>base);
   memcpy(buf>ops;
        (max_bytesret))java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  }
  break
 }

 mutex_unlock(&drm->audio.lock);

 return retjava.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2
}

 if component_add>dev-, nv50_audio_component_bind_ops
 .get_eld java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
};

static int
nv50_audio_component_bind(struct device *kdev, struct device java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
     void *data)
{
 struct  *drm  dev_get_drvdata(kdev
 struct  *acomp data

if((!device_link_add(, kdev,DL_FLAG_STATELESS)
  return -ENOMEM;

(drm-);
 acomp-> =&;
 acomp->dev java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 drm->audio.component = acomp; *******java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
drm_modeset_unlock_alldrm-);
 return 0;
}

static void
nv50_audio_component_unbind(struct device *kdev, struct device
       *ata)
{
 struct nouveau_drm *drm = dev_get_drvdata(kdev);
 structdrm_audio_component* = ;

 drm_modeset_lock_all(drm-
 drm-.component NULL;
 acomp->ops = NULL;
 acomp->dev = NULL struct * =nouveau_encoder);
  witch>dcb->type)java.lang.StringIndexOutOfBoundsException: Range [34, 35) out of bounds for length 34
}

static const eturn;
 .bind   = nv50_audio_component_bind
 .unbind = nv50_audio_component_unbind,
};

static void
nv50_audio_component_init(structstaticvoid
{
 if (component_add(drm->dev->devcv50_audio_disable( drm_encoder *, truct *v_crtc
 r;

 drm->audio.component_registered = true;
 mutex_init&>audio);
}

static void
nv50_audio_component_fini(struct nouveau_drm ;
{
 if (drm->.component_registered
  returnifnv_encoder-.enabled{

 component_del>dev-, nv50_audio_component_bind_ops
 drm-.component_registeredfalse;
 mutex_destroy(&drm-
}

/******************************************************************************
 * Audio
 *****************************************************************************/
static bool(struct *, struct *nv_crtcjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
nv50_audio_supported structdrm_display_modemode
{
  nv50_dispdisp= nv50_disp>dev

 if (disp->disp->object.oclass struct *nv_encoder nouveau_encoder);
    >disp-object == GT206_DISP
  return false;

 if (encoder->encoder_type != DRM_MODE_ENCODER_DPMST) {
  struct

  switch (nv_encoder->dcb->type) {
   DCB_OUTPUT_TMDS
  DCB_OUTPUT_DP:
   break
  default:
  return;
  }
  (drm-audio, >or, nv_crtc-);

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

static void
nv50_audio_disable(nv50_hdmi_enable(  *, struct *,
{  nouveau_connector,  drm_atomic_statestate
 struct nouveau_drm *drm = nouveau_drm(encoder-structdrm_display_modemodeboolhda
 struct nouveau_encoder nouveau_drm*rm  nouveau_drm(>dev
 struct * = &>outp

 ifstruct *hdmi=&>base.hdmi
  return;

>.lock
 if (nv_encoder->.enabled{
  nv_encoder-.enabled false
tp_hda_eldnv_encoder-, nv_crtc-indexNULL0;
 }
 mutex_unlock(&drm->audio.lock);

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

staticvoid
nv50_audio_enable(struct  if>i2c >scdc.supported
    struct *, struct *state,
    struct drm_display_mode *mode scdc
{
struct * =nouveau_drm>dev
 struct *nv_encoder=();
 struct nvif_outp *outp   NV_ERRORdrm" read SCDC_TMDS_CONFIG:dn" ret

 ((encoder nv_connector->.display_info)
  return if( | >scdcscrambling)

 mutex_lock(&drm->audio.lock);

 nvif_outp_hda_eld(&nv_encoder->outp, nv_crtc->index,  if(high_tmds_clock_ratio)
    (nv_connector->ase));
 nv_encoder->audio

 mutex_unlock(

 nv50_audio_component_eld_notify(drm->audio scdc);
}

/******************************************************************************
 * HDMI
 *****************************************************************************/
staticvoid
nv50_hdmi_enable(struct drm_encoder *encoder, structifret
   struct nouveau_connector
   struct>version ;
{
  nouveau_drm =(>);
 struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder
 truct *dmi nv_connector-.display_info;
 union hdmi_infoframe  drm_hdmi_avi_infoframe_quant_range(&infoframe, &>, ,
 const   );
 u32
 DEFINE_RAW_FLEX(struct nvif_outp_infoframe_v0, args, data, 17);
const u8 = __member_sizeargs-);
 int ret}else {

 max_ac_packet  =mode-htotal -mode-hdisplay;
 max_ac_packet -= rekey
 max_ac_packet=1;/
 max_ac_packet /= 32;

 if ( memset>data,data_len)
 if!(&infoframevendor,
      &>basemode

  ret (nv_encoder-, SCDC_TMDS_CONFIGscdc
  if (ret <  else
   NV_ERROR(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   returnjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
/

 * MST
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  scdc=SCDC_SCRAMBLING_ENABLE;
  if (high_tmds_clock_ratio)
   scdc |= SCDC_TMDS_BIT_CLOCK_RATIO_BY_40;

  ret = drm_scdc_writeb(nv_encoder->i2c, SCDC_TMDS_CONFIG,#define nv50_mstc()container_of(,structnv50_mstc,connector
 if(et<0
struct  {
    , ret
 }

 ret = nvif_outp_hdmi(&nv_encoder->outp, nv_crtc->index, true, max_ac_packet structdrm_dp_mst_port port
    drm_display_mode;
    struct  *edid;
 if (ret)
  return;

 /* AVI InfoFrame. */
 args->version
 args->headstruct nv50_msto{

 f (drm_hdmi_avi_infoframe_from_display_modeinfoframe.avi &nv_connector->base, mode) {
  drm_hdmi_avi_infoframe_quant_range/* head is statically assigned on msto creation */
        HDMI_QUANTIZATION_RANGE_FULL);

  size =   nv50_mstc *mstc;
 } else{
  size disabled
b enabled

 rame&nv_encoder-outpNVIF_OUTP_INFOFRAME_V0_AVI, size)java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80

 /* Vendor InfoFrame. */
{
 if (!drm_hdmi_vendor_infoframe_from_display_mode
       &>basemode
  size =   return (encoder;
 msto =nv50_msto();
 size 0

 nvif_outp_infoframe msto-mstc->outp

 nv_encoder->hdmi.enabled = true;
}

/******************************************************************************
 * MST
 *****************************************************************************/
definenv50_mstm()container_ofp,  nv50_mstmmgr
#define nv50_mstc(p) container_of   structdrm_dp_mst_topology_mgr *,
#definenv50_msto)container_ofp,struct, encoder)

struct nv50_mstc {
 struct nv50_mstm *mstm;
 struct drm_dp_mst_port *portdrm_atomic_get_mst_payload_state, msto->port
  drm_connector;

 structdrm_display_modenative
*edid;
};

struct nv50_mstcmstc>mstc
struct encoder

 /* head is statically assigned on msto creation */
 structnv50_head *head;
 truct *;
bool;
b enabled

 u32 display_id;


structnouveau_encoder*nv50_real_outp( drm_encoder *encoder)
{
 struct *msto

 if (encoder->encoder_type != DRM_MODE_ENCODER_DPMST)
  return   msto- = ;

 msto = nv50_msto(encoder);
 if(!>mstc
  return NULL;
 return msto->mstc->mstm->outp;
}

static void
nv50_msto_cleanup(struct drm_atomic_state *state,
     drm_dp_mst_topology_state,
    struct drm_dp_mst_topology_mgr * nv50_mstc*mstc  >mstc
     nv50_msto)
{
  nouveau_drm = nouveau_drm(msto->.dev;
 struct drm_dp_mst_atomic_payload *new_payload ret =0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  drm_atomic_get_mst_payload_state(new_mst_state, java.lang.StringIndexOutOfBoundsException: Range [0, 55) out of bounds for length 0
 struct drm_dp_mst_topology_state  mgr , );
  rm_atomic_get_old_mst_topology_state )
  struct * =
     {
 struct nv50_mstc *mstc = msto->mstc )java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  * =>;

          >,payload-time_slots

 ifmsto-) {
  if (msto->head-  payload- *dfixed_trunc>pbn_div)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 (&mstm->, msto-);
   msto->display_id = 0         drm_crtc_statecrtc_state
  }

  msto->mstc = NULL;
  false
  drm_dp_remove_payload_part2  c =conn_state->onnector
  elseifmsto-) java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 (mgr);
  msto->enabledstruct * = (crtc_state
 }
}

 void
nv50_msto_prepare(struct drm_atomic_state *state,
    struct       mstc->native);
    struct drm_dp_mst_topology_mgr*mgr
    struct nv50_msto*msto)
{
struct *rm= nouveau_drm>encoder);
 struct nv50_mstc *mstc = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct nv50_mstm *mstm = mstc-
 struct drm_dp_mst_atomic_payload *payload;
 int ret = 0;

 NV_ATOMIC(drm, "%s: msto prepare\n", msto->encoder.name);

rm_atomic_get_mst_payload_statemst_state >portjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67

 if (msto->disabled asyh->.bpc >display_info;
  (mgr , payload
 }
  ret = 1;
 } else {
  if (msto->enabled)
  
 }

 if   ((mst_state
 r PTR_ERR);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          payload->pbn, s nouveau_encoder* =mstc->outp
          payload->time_slots *(outp-.link_bw, >dp);
 } else {
  nvif_outp_dp_mst_vcpi(&mstm->outp- =d(state&>mgrmstc->, asyh-.);
 }
}

static int
nv50_msto_atomic_check(struct drm_encoder *encoder>dp =slots
   return0
         struct drm_connector_state *conn_state)
{
 struct drm_atomic_state *state = crtc_state->state;
 struct drm_connector *connector = conn_state->connector;
 struct drm_dp_mst_topology_state *mst_state;
 struct nv50_mstc*mstc = nv50_mstc(connector;
 struct nv50_mstm *mstm = mstc->mstm;
 struct nv50_head_atom *asyh = nv50_head_atom(crtc_state);
 intslots
 int ret  : NV837D_SOR_SET_CONTROL_PIXEL_DEPTH_BPP_24_444

 retdefault returnNV837D_SOR_SET_CONTROL_PIXEL_DEPTH_BPP_30_444
       mstc->nativejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ifret
  return{

 if (!drm_atomic_crtc_needs_modeset(crtc_state))
  return0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

 /*
 * When restoring duplicated states, we need to make sure that the bw
 * remains the same and avoid recalculating it, as the connector's bpc
 * may have changed after the state was duplicated
 */
 if !>duplicated{
  const int clock = crtc_state->adjusted_mode.clock;

 >or = connector-display_infobpc;
  asyh->dp.pbn = drm_dp_calc_pbn_mode(java.lang.StringIndexOutOfBoundsException: Range [0, 43) out of bounds for length 42
 }

 mst_state drm_for_each_connector_iter(, &) java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 if (S_ERR))
  return PTR_ERR(mst_state);

if(mst_state-pbn_div.) {
  struct nouveau_encoder *outp = mstc->mstm->outp;

  mst_state->pbn_div = drm_dp_get_vc_payload_bw(&conn_iter
 }

  = rm_dp_atomic_find_time_slots, &>mgrmstc-, >dppbn
 if (slots < 0)
 return;

 asyh->dp.tu = slots;

 return 0;
}

static u8
nv50_dp_bpc_to_depth(unsigned
{
 switch (bpc) {
case6 returnNV837D_SOR_SET_CONTROL_PIXEL_DEPTH_BPP_18_444
 casejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 case 10:
  proto ;
 }
}

static void
(struct *,  drm_atomic_statestatejava.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
{
 struct nv50_msto * sto- = ;
  nv50_headhead >head
 struct nv50_head_atom *asyh =
  nv50_head_atomdrm_atomic_get_new_crtc_state, &>base))java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
 struct nv50_mstc *mstcstaticjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 struct nv50_mstm *mstm = NULL;
 struct drm_connector *connector;
 struct drm_connector_list_iterstruct  *msto=nv50_mstoencoder
  proto

 drm_connector_list_iter_begin(encoder->dev, &conn_iter);
 drm_for_each_connector_iter(connector, &conn_iter) {
   connector->best_encoder= &sto->ncoder
   mstc = nv50_mstc(java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0
   = mstc-mstm
   break;
  }
}
 drm_connector_list_iter_end(&conn_iter);

  WARN_ONmstc)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  return;

 (>links){
 nvif_outp_acquire_sor(&>outp-,  /*TODO: MST audio... */);
 nouveau_dp_trainmstm-, true 0 )java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 }

 if (head->func->display_id) {
  if (!WARN_ON(java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 1
 head->(, >display_id
 }

 if (mstm->outp->outp
  =;
 else
  proto = NV917D_SOR_SET_CONTROL_PROTOCOL_DP_Bdestroy  ,

mstm->(mstm-outp,>base,asyh,
      nv50_msto_new(struct drm_d*,  nv50_headheadintid

msto- =mstc
msto- = true
 mstm->modified = truemstokzalloc(msto GFP_KERNEL)
}

static void
 ret = drm_encoder_init(dev, &msto->encoder, &nv50_msto,
{
 struct nv50_msto *msto = nv50_msto(encoder);
 struct nv50_mstc *mstc = msto->mstc;
 struct nv50_mstm *mstm= mstc->mstmjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

 if (msto->head->func->display_id)
  msto-}

m>>update>outp>head-base., , 00);
 mstm->modified ossible_crtcs (&head-.base
 if(!-stm-)
   msto
 msto->disabled = true;
}

static const nv50_mstc_atomic_best_encoder  *,
nv50_msto_help = {
 .atomic_disablejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 1
 .atomic_enable = nv50_msto_atomic_enable,
 .atomic_check,
};

static void
nv50_msto_destroystructdrm_encoderencoder
{
 struct nv50_msto *msto = nv50_msto  (!(mstc-mstm-outp-dcb-heads &drm_crtc_maskcrtc)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 drm_encoder_cleanup(& return&nv50_headcrtc-msto-encoder
 kfree(msto);
}

static const struct nv50_mstc_mode_valid(struct *,
nv50_msto = {
 destroy=nv50_msto_destroy
};

static struct nv50_msto *
nv50_msto_new(struct drm_device *dev, struct nv50_head *head, int id)
{
 struct nv50_msto *msto;
 int ret;

 msto = kzalloc(sizeof(*msto), GFP_KERNEL);
 if (!msto)
  return ERR_PTR(-ENOMEM);

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          DRM_MODE_ENCODER_DPMST, }
 if (ret) {
  kfree int
  return ERR_PTR(ret);
 }

 drm_encoder_helper_addjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 msto->encoder.i ret 0;
 msto->head =  >edid drm_dp_mst_get_edid&>connector,mstc-port->, mstc->);
 return msto;
}

static struct drm_encoder 
nv50_mstc_atomic_best_encoder drm_connectorconnector,
         struct drm_atomic_state *state)
{
 struct drm_connector_state   * XXX: Since we don't use * to 8 to save bandwidth on the topology. In the future, * to properly fix this by dynamically selecting the highest possible
    )
  (connector-U )
 struct  >.  java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

if(mstc->>dcb- &drm_crtc_mask))java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 

 returnnv50_head)-msto-;
}

static enum java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
nv50_mstc_mode_valid  *,
       const structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct nv50_mstc  int
 struct nouveau_encoder *outp = mstc->mstm->outp;

 /* TODO: calculate the PBN from the dotclock and validate against the
 * MSTB's max possible PBN
 */

 return nv50_dp_mode_valid =pm_runtime_get_syncconnector-dev-)
}

 java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
nv50_mstc_get_modes
{
 struct nv50_mstc *mstc = nv50_mstc(connector);
 int ret=0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

 mstc->:
 (&>connector>edid
if>edid
  ret = drm_add_edid_modes(&mstc->connector}


  *nv50_mstc_help{
  * to,
     by  the java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  * mstc_destroy  *)
  */
  (>display_info)
  connector-
  clamp.bpc6,U;
else
  connector->display_info.bpc(mstc

 if (mstc->native)
  drm_mode_destroy(mstc- ={
mstc- =nouveau_conn_native_mode&>connector
  ret;
}

static
nv50_mstc_atomic_check( atomic_duplicate_state=nouveau_conn_atomic_duplicate_state
         struct drm_atomic_state *stateatomic_set_property=,
{
 struct nv50_mstc *nv50_mstc_newstruct *,  drm_dp_mst_port,
dp_mst_topology_mgr *gr=&>mstm-mgr

 return drm_dp_atomic_release_time_slots(state, mgr,  structdrm_devicedev mstm->>base.devjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
}

static int
nv50_mstc_detect(struct drm_connector *connector,
   struct return -;
{
  nv50_mstcmstcnv50_mstcconnectorjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 int ret

 ifdrm_connector_is_unregistered))
  return connector_status_disconnected;

retpm_runtime_get_sync>dev-);
 if ( (*pmstc
  pm_runtime_put_autosuspendpmstc=NULL
  returnconnector_status_disconnected
 }

 ret  rm_connector_helper_addmstc-, nv50_mstc_help
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (ret != connector_status_connectednouveau_conn_attach_properties&mstc-connector;
  goto out;

out:
pm_runtime_mark_last_busyconnector-dev-dev
 pm_runtime_put_autosuspend(connector- if!mstm->dcb- & drm_crtc_mask()))
 return ret;
}

onnector_helper_funcs
nv50_mstc_help = {
 .get_modes = nv50_mstc_get_modes,
 . =nv50_mstc_mode_valid
 .tomic_best_encoder  nv50_mstc_atomic_best_encoder
 .atomic_check nv50_mstc_atomic_check
. = nv50_mstc_detect,
};

static void
nv50_mstc_destroy(struct drm_connector *connector)
{
 struct nv50_mstcstructdrm_dp_mst_topology_statemst_state,

 drm_connector_cleanup(&mstc->connector);
 drm_dp_mst_put_port_malloc(stc-);

 kfree(mstc);
}

static const (&>mgr;
nv50_mstc={
   encoder- = ) java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
.ill_modes ,
.estroy =nv50_mstc_destroy
 . = ,
 .atomic_destroy_state = nouveau_conn_atomic_destroy_state}
 .atomic_set_property = nouveau_conn_atomic_set_property,
 .atomic_get_property = nouveau_conn_atomic_get_property,
};

static int
nv50_mstc_new(struct nv50_mstm *mstm, struct drm_dp_mst_port * >disabled false;
       const char *path, structjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
{
 struct drm_device *dev = mstm->outp->static void
 struct drm_crtc *crtc;
  struct *mst_state,
 int   nv50_mstm *)

  structnouveau_drm = nouveau_drmmstm->base.dev
  return -ENOMEM;
 mstc- = mstm
 mstc->port = port;

 ret=drm_connector_dynamic_init, mstc-, &nv50_mstc,
  if(ncoder- = ) {
 if() {
  kfree(  nv50_mstcmstc >mstc
stc =NULL
  nv50_msto_prepare, mst_state,&>mgr);
 }

 drm_connector_helper_add(&mstc- * Add payloads for new heads, while also updating the start slots of any unmodified (but

mstc->connector.funcs->reset(&mstc->connector);
nouveau_conn_attach_properties(&mstc->connector);

drm_for_each_crtc(crtc, dev) {
if (!(mstm->outp->dcb->heads & drm_crtc_mask(crtc)))
continue;

drm_connector_attach_encoder(&mstc->connector,
     &nv50_head(crtc)->msto->encoder);
}

drm_object_attach_property(&mstc->connector.base, dev->mode_config.path_property, 0);
drm_object_attach_property(&mstc->connector.base, dev->mode_config.tile_property, 0);
drm_connector_set_path_property(&mstc->connector, path);
drm_dp_mst_get_port_malloc(port);
return 0;
}

static void
nv50_mstm_cleanup(struct drm_atomic_state *state,
  struct drm_dp_mst_topology_state *mst_state,
  struct nv50_mstm *mstm)
{
struct nouveau_drm *drm = nouveau_drm(mstm->outp->base.base.dev);
struct drm_encoder *encoder;

NV_ATOMIC(drm, "%s: mstm cleanup\n", mstm->outp->base.base.name);
drm_dp_check_act_status(&mstm->mgr);

drm_for_each_encoder(encoder, mstm->outp->base.base.dev) {
if (encoder->encoder_type == DRM_MODE_ENCODER_DPMST) {
struct nv50_msto *msto = nv50_msto(encoder);
struct nv50_mstc *mstc = msto->mstc;
if (mstc && mstc->mstm == mstm)
nv50_msto_cleanup(state, mst_state, &mstm->mgr, msto);
}
}

if (mstm->disabled) {
nouveau_dp_power_down(mstm->outp);
nvif_outp_release(&mstm->outp->outp);
mstm->disabled = false;
}

mstm->modified = false;
}

static void
nv50_mstm_prepare(struct drm_atomic_state *state,
  struct drm_dp_mst_topology_state *mst_state,
  struct nv50_mstm *mstm)
{
struct nouveau_drm *drm = nouveau_drm(mstm->outp->base.base.dev);
struct drm_encoder *encoder;

NV_ATOMIC(drm, "%s: mstm prepare\n", mstm->outp->base.base.name);

/* Disable payloads first */
 drm_for_each_encoder
ncoder-encoder_type=DRM_MODE_ENCODER_DPMST{
   struct nv50_msto *msto = nv50_msto(encoder);
   struct nv50_mstc *mstcbool handled true = true
   if u [8=}java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }

/
  * active) heads that may have had their VC slots shifted   break;
  */
 drm_for_each_encoder(encoder, mstm->outp-  if (!handled)

   struct nv50_msto *msto = nv50_msto(encoder);
   struct nv50_mstc *mstc   if (rc != 1) {
   if (mstc   break;
    nv50_msto_prepare(state, mst_statejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
 }
}

static struct drm_connector *
nv50_mstm_add_connector(struct drm_dp_mst_topology_mgr *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   struct drm_dp_mst_portvoid
{
 struct nv50_mstm *mstm = nv50_mstm mstm->is_mst = false;
 struct nv50_mstc}
 int ret;

 ret = nv50_mstc_new(mstm, port{
 if (ret)
  return struct drm_dp_aux *aux;

 if (!mstm || !mstm->can_mst)
}

static const struct drm_dp_mst_topology_cbs
nv50_mstm = {
 .add_connector = nv50_mstm_add_connector,
};

bool
nv50_mstm_servicestruct *drm
    struct *,
    struct nv50_mstm
{
 struct ret drm_dp_mst_topology_mgr_set_mst(mstm-, true
 bool handled = true, ret = return;
 int rc;
 u8 esi[8] = {};

 while (handled) {
  u8 ack[8] = {};

OUNT_ESI,esi8)
  if (rc != 8) {java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   ret = false;
   break;
  }

  drm_dp_mst_hpd_irq_handle_event(&mstm->mgr, /
  if (!handled)
   break;

  rc = drm_dp_dpcd_writeb(aux, DP_SINK_COUNT_ESI + 1, ack[1]);

  if (rc != 1) {
   ret = false;
   break; * path to protect mstm->is_mst without potentially deadlocking
  }

  drm_dp_mst_hpd_irq_send_new_request(&mstm->mgr);
 }

 if
 NV_DEBUG," handleESIon%:\,
    nv_connector->base.name (&mstm-);

 return ret;
}

void
(struct *)
{
 mstm->is_mst = false;
 drm_dp_mst_topology_mgr_set_mstmstm-, false;
}

int
 if(mstm)
{
 struct nv50_mstm *mstm = outp->dp.mstm;
 struct drm_dp_aux *aux
t ret

if! || !stm-)
  0

 aux = mstm->mgr.aux;

 /* Clear any leftover MST state we didn't set ourselves by first
 * disabling MST if it was already enabled
 */
 ret  drm_kms_helper_hotplug_event(>.dev
 if (ret < 0)
  return ret;

 /* And start enabling */
 ret = drm_dp_mst_topology_mgr_set_mst(&mstm->mgr
 if(et
  return;

 mstm->is_mst = true;
 return 1;
}

static void
nv50_mstm_fini(struct nouveau_encoder *outp
{
 structnv50_mstm* =outp-.mstm;

 if (!mstm)
  return;

 /* Don't change the MST state of this connector until we've finished
 * resuming, since we can't safely grab hpd_irq_lock in our resume
 * path to protect mstm->is_mst without potentially deadlocking
 */
 mutex_lock(struct * =outp-basebase;
 mstm-suspended;
 mutex_unlock(&outp->dp.hpd_irq_lock);

 if (mstm->is_mst)
 (&mstm-);
}

static
nv50_mstm_init( stm-.cbs &nv50_mstm
{
s nv50_mstmmstm >dp;
 int ret = 0;

 if(mstm
 return;

 if (mstm->is_mst)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ret= (&mstm-mgr !)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  if (ret == -1)
   nv50_mstm_remove(mstm);
 }

mutex_lock&outp-dp.);
 mstm->suspended = false
 mutex_unlock&>dphpd_irq_lock

 if (ret == -1)
  drm_kms_helper_hotplug_event(mstm->mgr.dev);
}

staticvoid
(structnv50_mstm **mstm)
{
 struct nv50_mstm*stm  *mstm
 f() {
  drm_dp_mst_topology_mgr_destroy(&mstm->mgr);
 kfree*);
  *pmstm = NULL }
 }
}

static int
nv50_mstm_new
       int conn_base_id, struct nv50_mstm **pmstm)
{
 const int max_payloads = hweight8(outp->dcb->heads);
 struct drm_device *dev = outp->base.base.dev;
static java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 int ret;

  !mstm pmstm (sizeofmstm ))java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  return -ENOMEM;
 mstm->outp = outp;
 mstm->mgr.cbs = &nv50_mstm;

 ret = drm_dp_mst_topology_mgr_init(&mstm-   * =nouveau_drm>ase.dev
     , );
 if (ret)
 r ret

r 0java.lang.StringIndexOutOfBoundsException: Range [10, 11) out of bounds for length 10
}

/******************************************************************************
 * SOR
 *****************************************************************************/
static void
nv50_sor_update(truct  *,  head
  struct nv50_head_atomjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 2
{
 struct nv50_disp *disp = nv50_disp(nv_encoder-  (&nv_encoder->outp>base,
 structnv50_core coredisp-;

 if (!asyh) {
  nv_encoder->ctrl &= ~BIT(head
ifNVDEF_TEST>ctrlNV507DSOR_SET_CONTROL OWNER== ))
   nv_encoder->ctrl = 0;
 } else {
  nv_encoder->ctrl |= NVVAL
  nv_encoder-> if (head-func-display_idjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  asyh->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 >func-sor-ctrl, nv_encoder-.orid,nv_encoder-, asyh
}

/* TODO: Should we extend this to PWM-only backlights?java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 * As well, should we add a DRM helper for waiting for the backlight to acknowledge
 * the panel backlight has been shut off? Intel doesn't seem to do this, and uses a
 * fixed time delay from the vbios…
 */
static void
nv50_sor_atomic_disable(struct drm_encoder *encoder, struct drm_atomic_state *state)
{
 struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
 struct nv50_head *head = nv50_head(nv_encoder->crtc);
#ifdef CONFIG_DRM_NOUVEAU_BACKLIGHT
 struct nouveau_connector *nv_connector = nv50_outp_get_old_connector(state, nv_encoder);
 struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
 struct nouveau_backlight *backlight = nv_connector->backlight;
 struct drm_dp_aux *aux = &nv_connector->aux;
 int ret;

 if (backlight && backlight->uses_dpcd) {
  ret = drm_edp_backlight_disable(aux, &backlight->edp_info);
  if (ret < 0)
   NV_ERROR(drm, "Failed to disable backlight on [CONNECTOR:%d:%s]: %d\n",
     nv_connector->base.base.id, nv_connector->base.name, ret);
 }
#endif

 if (nv_encoder->dcb->type == DCB_OUTPUT_TMDS && nv_encoder->hdmi.enabled) {
  nvif_outp_hdmi(&nv_encoder->outp, head->base.index,
          false, 0, 0, 0, false, false, false);
  nv_encoder->hdmi.enabled = false;
 }

 if (nv_encoder->dcb->typeint vblank_symbols   = 0;
 nouveau_dp_power_downnv_encoder

>func-)
     = asyh-orbpc*3java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

 nv_encoder->update(nv_encoder, head- u32  = >dplink_nr;
 nv50_audio_disable(encoder, &head->base);
 nv_encoder->crtc = NULL;
}

// common/inc/displayport/displayport.h
#define DP_CONFIG_WATERMARK_ADJUST                   2
#define DP_CONFIG_WATERMARK_LIMIT                   20
#define DP_CONFIG_INCREASED_WATERMARK_ADJUST         8
#define DP_CONFIG_INCREASED_WATERMARK_LIMIT         22

static bool
nv50_sor_dp_watermark_sst(struct nouveau_encoder   (pixelClockHz*) =(  minRate >dplink_nr DSC_FACTOR)
     struct nv50_head *head,returnfalse;
{
 bool enhancedFraming = outp->//
 u64 minRate = outp->dp.link_bw * 1000;
 unsigned tuSize = 64;
  
 unsigned  if() &
u vBlankSym
 unsigned watermarkAdjust = DP_CONFIG_WATERMARK_ADJUST;
 unsigned watermarkMinimum = DP_CONFIG_WATERMARK_LIMIT;
/
 s32 hblank_symbols //  Perform the SST calculation.
 // number of link clocks per line.
 int vblank_symbols   = 0;
 bool bEnableDsc = false;
  surfaceWidth asyh->.hblanksasyh-.h.lanke
 unsigned rasterWidth = asyh->mode.h.active;
 nsigned =asyh-.bpc ;
 unsigned DSC_FACTOR =
   ( <ratioF / Assert if we will end up with a negative number in below
 u64 PrecisionFactor = 100000, ratioF, watermarkF;
 u32 numLanesPerLink    false
 u32 numSymbolsPerLine;
 u32BlankingBitsjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
u32;
 u32 PixelSteeringBits;
 u64 NumBlankingLinkClocks
 3 ;

 if (outp-  = div_u64surfaceWidth ,  *outp-dplink_nr DSC_FACTOR;
  watermarkAdjust = DP_CONFIG_INCREASED_WATERMARK_ADJUST;
  watermarkMinimum =DP_CONFIG_INCREASED_WATERMARK_LIMIT
 }

 if ((pixelClockHz * java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0
 {
  return false;
 }

 //
 // For DSC, if (pclk * bpp) < (1/64 * orclk * 8 * lanes) then some TU may end up with
 // 0 active symbols. This may cause HW hang. Bug 200379426
 //
 if ((bEnableDsc) &&
     ((pixelClockHz * depth
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  return false;
 }

 //
/
 // For auto mode the watermark calculation does not need to track accumulated error the
 
 //
    div_u64pixelClockHz))java.lang.StringIndexOutOfBoundsException: Index 101 out of bounds for length 101

 ratioF = div_u64(ratioF, ifWARN_ON >rasterWidth surfaceWidth)

 if (PrecisionFactor < ratioF) // Assert if we will end up with a negative number in belowreturn false;
  return false

 watermarkF(ratioF  *PrecisionFactor ),PrecisionFactor
 waterMark = ;

 //
 //  Bounds check the watermark

 numSymbolsPerLine

 if (WARN_ON(waterMark   - 1//
  return false;

 //
 //  Clamp the low side
 /
 if (waterMark < watermarkMinimum)
  waterMark = watermarkMinimum;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 //Also accounts for enhanced framing.//
 BlankingBits = 3*8*numLanesPerLink + (enhancedFraming ? 3*8*numLanesPerLink : 0);

 //VBID/MVID/MAUD sent 4 times all the time
 BlankingBits += 3*8*4;

 surfaceWidthPerLink = surfaceWidth;

 //Extra bits sent due to pixel steering
 u32 remain
div_u64_remsurfaceWidthPerLink , &remain
PixelSteeringBits= ? div_u64 -remain , DSC_FACTOR)  ;

 BlankingBits += PixelSteeringBits;
 NumBlankingLinkClocks = div_u64 = ( <)?0 :;
 MinHBlank = ( return (&outp-outphead-.indexwaterMark hBlankSymv);
 MinHBlank += 12;

 if (WARN_ON(MinHBlank > rasterWidth - surfaceWidth(struct *, struct *)
  return false;

 // Bug 702290 - Active Width should be greater than 60  *nv_crtc (state nv_encoder
 if (WARN_ON(surfaceWidth <= 60))
  return false;


 hblank_symbols = (s32)(div_u64((u64>dev

 //reduce HBlank Symbols to account for secondary data packet
 hblank_symbols -= 1; //Stuffer latency to send BS
 hblank_symbols -= 3; structnouveau_drmdrmnouveau_drm);

 hblank_symbols -= numLanesPerLinkifdefCONFIG_DRM_NOUVEAU_BACKLIGHT

 hBlankSym = (hblank_symbols < 0) ? 0 : hblank_symbols;

 // Refer to dev_disp.ref for more information. =false  =false, hda;
 // # symbols/vblank = ((SetRasterBlankEnd.X + SetRasterSize.Width - SetRasterBlankStart.X - 40) * link_clk / pclk) - Y - 1;;
 // where Y = (# lanes == 4) 12 : (# lanes == 2) ? 21 : 39
 if(surfaceWidth <40
 {
 vblank_symbols 0;
 }
 else
 {
  =(s32(div_u64(()(surfaceWidth-4)*minRate pixelClockHz)) -1;

  vblank_symbols -= numLanesPerLink == 1 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 vBlankSym = (vblank_symbols < 0) ? 0 : vblank_symbols;

 return nvif_outp_dp_sst(&outp->outp, head->base.index, waterMark, hBlankSym, vBlankSym);
}

static void
nv50_sor_atomic_enable drm_encoderencoderstruct *state
{
 struct nouveau_encoder* = nouveau_encoder();
 struct nouveau_crtc *nv_crtc = nv50_outp_get_new_crtc(state, nv_encoder);
 struct nv50_head_atom *asyh =
  nv50_head_atom(drm_atomic_get_new_crtc_state(state, &nv_crtc->base));
  proto ;
 struct    *  - Need to (i.e. rate > 165MHz)
 struct nv50_head *head = nv50_head(&nv_crtc->base);
 struct nvif_outp *outp = &nv_encoder-   
 structdrm_device* = >dev
 struct nouveau_drm  nv_encoder->duallink_possiblejava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 struct nouveau_connector *nv_connector;
  =;
 struct nouveau_backlight *backlight;
#endif
 struct nvbios *bios = &drm- proto=;
 bool lvds_dual = false, lvds_8bpc = false, hda = false;
 u8 proto NV507D_SOR_SET_CONTROL_PROTOCOL_CUSTOM
 u8 depth = NV837D_SOR_SET_CONTROL_PIXEL_DEPTH_DEFAULT = bios-fpdual_link

 nv_connector =}elsejava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 nv_encoder->crtc = &nv_crtc->base;

 if ((disp->disp->object.oclass == GT214_DISP ||
         lvds_dual ;
     nv_encoder-   else
     nv_connector-.display_info)
  hda = true;

 if (!nvif_outp_acquired(outp))
  nvif_outp_acquire_sor(  iflvds_dual

 switch (nv_encoder->dcb->type) {
 case DCB_OUTPUT_TMDS:
  if }else{
      nv_connector->base.display_info.is_hdmi)
   nv50_hdmi_enable(encoder, nv_crtc, nv_connector, state, mode, hda);

  if (nv_encoder->outp.or.link & 1)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   proto bpc ;
 /java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    *  nvif_outp_lvds(&nv_encoder->outp, lvds_dual, lvds_8bpc);
    *  - DCB says we case DCB_OUTPUT_DP:
    *  - Not  nv50_sor_dp_watermark_sst(nv_encoder, head, asyh);
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    */
   if (mode->clock >= 165000 &&
       nv_encoder->dcb->duallink_possible &&
       !nv_connector->base.display_info.is_hdmi)
    if (backlight && backlight->uses_dpcd)
  } else {
   proto =#endif
  }
  break;
 case DCB_OUTPUT_LVDS:
  proto = NV507D_SOR_SET_CONTROL_PROTOCOL_LVDS_CUSTOM

  if (bios->fp_no_ddc) {
   lvds_dual = bios->fp.dual_link;
   lvds_8bpc = bios->fp.if_is_24bit;
  } else {
   if (nv_connector->type == DCB_CONNECTOR_LVDS_SPWG}
    if (((u8 *)nv_connector->edidstatic const struct drm_encoder_helper_funcs
     lvds_dual = true;
   } else
   if (mode->clock};
    lvds_dual = true;
   }

   if (lvds_dual) {
    if (bios->fp.strapless_is_24bit & 2)
     lvds_8bpc = true;
   } else {
    if (bios->fp.strapless_is_24bit & 1 if (nv_encoder->dcb->type == DCB_OUTPUT_DP)
     lvds_8bpc = true;
   }

   if (asyh->or.bpc == 8)
    lvds_8bpc = true;
  }

  nvif_outp_lvds(&nv_encoder->outp,
  break;
 case DCB_OUTPUT_DP:
  nouveau_dp_train(nv_encoder, false, mode->clock, asyh->or.bpc);
  nv50_sor_dp_watermark_sst(nv_encoder, head, asyh);
  depth  struct nouveau_connector *nv_connector = nouveau_connector(connector);

  if (nv_encoder->outp.or.link & 1)
   proto = NV887D_SOR_SET_CONTROL_PROTOCOL_DP_A;
  else
   proto = struct nv50_disp *disp = nv50_disp(connector->dev);

#ifdef CONFIG_DRM_NOUVEAU_BACKLIGHT
  backlight = nv_connector->backlight;
  if (backlight && backlight->uses_dpcd)
   drm_edp_backlight_enable  break;

#endif

  break;
 default:
  BUG();
  break;
 }

 if (head->func->display_id disp->core->func->sor->get_caps(disp, nv_encoder, ffs(dcbe->or) -  nv50_outp_dump_caps(drm, nv_encoder);
  head->func->display_id(head, BIT(nv_encoder->outp.id));

 nv_encoder->update(nv_encoder, nv_crtc->index, asyh, protoinfo.dp.mst) {
}

static const struct drm_encoder_helper_funcs
nv50_sor_help = {
 .tomic_check=nv50_outp_atomic_check
 .atomic_enable>basebase,
 .atomic_disable = java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 31
};

staticvoid
nv50_sor_destroy(struct drm_encoder *encoder)
{
 *nv_encoder=nouveau_encoder();

 nv50_mstm_del(&nv_encoder- > = &>i2c
 drm_encoder_cleanup(encoder);

 if (nv_encoder->dcb->type ==java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  mutex_destroy(&nv_encoder->dp.hpd_irq_lock);

 nvif_outp_dtor
 kfree(encoder);
}

  structdrm_encoder_funcs
nv50_sor_func = {
 .destroy = nv50_sor_destroy,
};

static int
nv50_sor_create(struct nouveau_encoder * if (et
{
  drm_connector =&>>base
 struct nouveau_connector *nv_connector = nouveau_connector 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 struct nouveau_drm *drm = nouveau_drm(staticvoid
 struct nvkm_i2c *i2c = nvxx_i2c(drm);
 struct drm_encoder *encoder;
 struct dcb_output *dcbestructnouveau_encoder* =nouveau_encoder);
r-dev
 int type, const ctrlNVDEF, PIOR_SET_CONTROL , );

  (>type{
 case DCB_OUTPUT_LVDS >crtc=NULL
 case DCB_OUTPUT_TMDS:
 case DCB_OUTPUT_DP:
 default:
  type  DRM_MODE_ENCODER_TMDS
  break;
 }

 nv_encoder->update = nv50_sor_update;

 encoder = to_drm_encoder(nv_encoder);
ector-dev,encoder&nv50_sor_func,type
    "sor-%04x-%0 n(drm_atomic_get_new_crtc_statestate, &v_crtc->base);
drm_encoder_helper_add, &nv50_sor_help);

 drm_connector_attach_encoder(connector

>>func->get_caps, , ffsdcbe-) -)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 v50_outp_dump_caps, nv_encoderjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

(>typeDCB_OUTPUT_DP 
  mutex_init(&nv_encoder->dp.hpd_irq_lock java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2

if>>object <GF110_DISP {
   /* HW has no support for address-only
 * transactions, so we're required to
 * use custom I2C-over-AUX code.
 */
   struct nvkm_i2c_aux *aux;

   aux = nvkm_i2c_aux_find(i2c, dcbe->i2c_index);
   if (!aux)
    return -EINVAL

   nv_encoder->
  } else {
   nv_encoder->i2c = &nv_connector->aux.ddc;
  }

  if (nv_connector->type != DCB_CONNECTOR_eDP &&  switch (>dcb-) {
   ret = nv50_mstm_new(nv_encoder, &nv_connector->aux ase:
       6 nv_connector-base.aseid
         &nv_encoder->dp.mstm);
   if (ret)
   return;
  }
 } 
 if (nv_encoder->outp.info.ddc !breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  struct nvkm_i2c_bus *bus =
   nvkm_i2c_bus_find(i2c,java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 if(us)
   nv_encoder->i2c = &bus->i2c;
 }

 return 0;
staticconststruct drm_encoder_helper_funcs

/******************************************************************************
 * PIOR
 *****************************************************************************/
static int
nv50_pior_atomic_check(struct drm_encoder *encoder,
         struct drm_crtc_state *crtc_state,
          struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
{
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
 if (ret)
  return ret;
 crtc_state->adjusted_mode.clock *= 2;
 return 0;
}

static void
nv50_pior_atomic_disable(struct drm_encoder *encoder, struct};
{
 structnv50_pior_create(struct nouveau_encoder *nv_encoder)
 struct nv50_core  struct drm_connector *connector = &nv_encoder->conn->base;
  struct nouveau_drm *drm = nouveau_drm(dev);

 core->func->pior->ctrl(core,  struct nvkm_i2c_bus *bus = NULL;
 nv_encoder->crtc = NULL;
}

static void
nv50_pior_atomic_enable(structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct   ddc  = bus ? &bus->i2c : NULL;
 struct nouveau_crtc *nv_crtc = nv50_outp_get_new_crtc(state, nv_encoder);
 struct nv50_head_atom *asyh =
  nv50_head_atom(drm_atomic_get_new_crtc_state(state, &nv_crtc->base));
 struct nv50_core *core = nv50_disp(encoder->dev)->core;
 u32 ctrl = 0;

  return -ENODEV;
 case 0: ctrl |= java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
 case 1: ctrl |= NVDEF(NV507D, PIOR_SET_CONTROL, OWNER, HEAD1)
 default:
  WARN_ON(1);
  break;
 }

 switch (asyh->or.bpc) {
 case 10: asyh->or.depth = java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
 case  8:/************************************ * Atomic
 case  6: asyh->or.depthnv50_disp_atomic_commit_core(struct drm_atomic_state *state, u32 *interlock)
 default: asyh->or.depth = NV837D_PIOR_SET_CONTROL_PIXEL_DEPTH_DEFAULT; break;
 }

 if (!nvif_outp_acquired *mgr;
  nvif_outp_acquire_pior( struct drm_dp_mst_topology_statemst_state

 switch (nv_encoder->dcb->type) {
 case DCB_OUTPUT_TMDS:
  ctrl |= NVDEF(NV507D, PIOR_SET_CONTROL, PROTOCOL, EXT_TMDS_ENC);
  break;
caseDCB_OUTPUT_DP
  ctrl | nv50_outp_atomo;
  nouveau_dp_train structnv50_mstm mstm
  break;
 default:
  (;
  break;
 }

 core->func->pior->ctrl(core, nv_encoder-if(mstm->)
 nv_encoder-crtc&>base
}

static const struct drm_encoder_helper_funcs
nv50_pior_help = {
 .tomic_check nv50_pior_atomic_check
  (>func-(>sync,
 .atomic_disable = nv50_pior_atomic_disable,
};

static
nv50_pior_destroy(struct drm_encoder *encoder)
{
struct * = nouveau_encoder);

 nvif_outp_dtor(>outp);

 drm_encoder_cleanup(encoder);

mutex_destroy>dpjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
()java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
}

   
nv50_pior_func = {
 .destroy =   (>disabled java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
}

static int
nv50_pior_create(struct java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 3
{
 struct drm_connector *connector = &nv_encoder- void
 struct drm_device *dev = connector->dev;
 struct nouveau_drm *drm = nouveau_drm(dev);
 struct nv50_disp *disp structdrm_plane_state*;
 struct nvkm_i2c *i2c = nvxx_i2c(drm);
 struct nvkm_i2c_bus *bus
 (stateplane , i){
 structstruct * = nv50_wndw);
structdrm_encoder *ncoderjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 struct    wndw-func-(wndwinterlock;
 int type;

 switch (dcbe->type) {
 case DCB_OUTPUT_TMDS:
  bus  = nvkm_i2c_bus_find(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 11
  ddc=bus?&bus-i2c : NULL
  type = DRM_MODE_ENCODER_TMDS;
  break;
 case DCB_OUTPUT_DP:
  aux  = nvkm_i2c_aux_find(i2c, nv_encoder->outp.info.dp.aux);
  ddc  = aux ? &aux->i2c : NULL;
  type = DRM_MODE_ENCODER_TMDS;
  break;
 default
  -;
 }

i2c;

 mutex_init(&nv_encoder->dp.hpd_irq_lock);

 encoder = to_drm_encoder(nv_encoder);
 drm_encoder_init(connector->dev, encoder, &nv50_pior_func, type,
    "N(drm, " % dn, atom-,atom-;
 drm_encoder_helper_add(encoder, &nv50_pior_help);

 drm_connector_attach_encoder(connector, encoder);

 disp-core-func->pior->(disp , ffs>or-1;
 nv50_outp_dump_caps(drm, nv_encoder);

 return 0;
}

/******************************************************************************
 * Atomic
 *****************************************************************************/

static void
nv50_disp_atomic_commit_core(struct drm_atomic_state *state, u32 *interlock)
{
 struct drm_dp_mst_topology_mgr  truct *asyh =nv50_head_atomnew_crtc_state
 structdrm_dp_mst_topology_statemst_state
 struct nouveau_drm *drm
 struct nv50_disp *disp (drm "s clr 0x 4)n" crtc->ame,
  nv50_atomatom(state
 struct nv50_core *core = disp->core;
uct *outp;
 struct nv50_mstm *mstm;
 int i;

  drm_crtc_vblank_offcrtc

 for_each_new_mst_mgr_in_state(state, mgr,
 mstmnv50_mstm);
  if (mstm->  nv50_head_flush_clr, asyh>flush_disable
   nv50_mstm_prepare(state, mst_state, mstm);
 }

 core-java.lang.StringIndexOutOfBoundsException: Range [24, 25) out of bounds for length 24
 core->func->update(core, interlock, true);
 if (core->func->ntfy_wait_done(disp->sync, NV50_DISP_CORE_NTFY,
 >b)
(,notifierjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

for_each_new_mst_mgr_in_state, mgrmst_state i){
  mstm = nv50_mstm(mgr);
  if (mstm->modified)
   nv50_mstm_cleanup(state, mst_state, mstm);
 }

 list_for_each_entry(outp, &atom->outp, head) {
  if (outp->encoder->encoder_type != java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 0
nv_encodernouveau_encoder>encoder;

(>)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    nv50_audio_enable(outp- encoder= outp->;
        nv_encoder->conn, NULL, NULL);
   utp- =outp- = ;
   } else {
   outp-) java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
     nvif_outp_release(&nv_encoder->outp (>clr) java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
     outp->disabled = false;
    }
   }
 }
 }
}

static void
nv50_disp_atomic_commit_wndw(struct drm_atomic_state *state, u32 *interlock)
{
struct *;
 struct drm_plane *plane  nv50_disp_atomic_commit_wndwstate );
i i

 for_each_new_plane_in_state(state,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  struct nv50_wndw *wndw = nv50_wndw(planejava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    flushed
   if nv50_crc_atomic_release_notifier_contexts();
   wndw-func-update, interlock;
  }
 }
}

static void
nv50_disp_atomic_commit_tail(struct drm_atomic_state *state)
{
  = state-;
 struct drm_crtc_state *new_crtc_state, *old_crtc_state;
  encoder >;
 struct drm_plane_state *new_plane_state;
 struct drm_plane *plane  help = encoder-helper_private
 struct nouveau_drm *drm = nouveau_drm(dev);
  nv50_disp*ispnv50_dispdev;
 struct nv50_atom *atom = nv50_atom(state);
 struct nv50_core *core = disp->core;
 , *outt
 u32 interlock[NV50_DISP_INTERLOCK__SIZE] = {};
 int i;
 bool flushed = false;

NV_ATOMIC," % dn,atom-lock_core >;
 nv50_crc_atomic_stop_reporting(state);
   [NV50_DISP_INTERLOCK_CORE= ;
 drm_atomic_helper_wait_for_dependencies(state);
 drm_dp_mst_atomic_wait_for_dependencies(state);
 drm_atomic_helper_update_legacy_modeset_state(dev, state);
 /* Update head(s). */

 if (atom->lock_core)
  mutex_lock(&disp->mutex);

/
 for_each_oldnew_crtc_in_state(state,
  struct nv50_head_atom *asyh = nv50_head_atom(new_crtc_state);
  struct nv50_head *head = nv50_head(crtc);

  NV_ATOMIC(drm, "%s: clr %04x (set %04x)\n", crtc->name,
     asyh->clr.mask, asyh->set.mask);

  if (old_crtc_state->active && !new_crtc_state->active) {
   pm_runtime_put_noidle(dev->dev);
   drm_crtc_vblank_off(crtc);
  }

  if (asyh->clr.mask) {
   nv50_head_flush_clr(head, asyh, atom->flush_disable);
   interlock[NV50_DISP_INTERLOCK_CORE] |= 1;
  }
 }

 /* Disable plane(s). */
 for_each_new_plane_in_state(state, plane, new_plane_state, i) {
  struct nv50_wndw_atom *asyw = nv50_wndw_atom(new_plane_state);
  struct nv50_wndw *wndw = nv50_wndw(plane);

  NV_ATOMIC(drm, "%s: clr %02x (set %02x)\n", plane->name,
     asyw->clr.mask, asyw->set.mask);
  if (!asyw->clr.mask)
   continue;

  nv50_wndw_flush_clr(wndw, interlock, atom->flush_disable, asyw);
 }

 /* Disable output path(s). */
 list_for_each_entry(outp, &atom->outp, head) {
  const struct drm_encoder_helper_funcs *help;
  struct drm_encoder *encoder;

  encoder = outp->encoder;
  help = encoder->helper_private;

  NV_ATOMIC(drm, "%s: clr %02x (set %02x)\n", encoder->name,
     outp->clr.mask, outp->set.mask);

  if (outp->clr.mask) {
   help->atomic_disable(encoder, state);
   outp->disabled = true;
   interlock[NV50_DISP_INTERLOCK_CORE] |= 1;
  }
 }

 /* Flush disable. */
 if (interlock[NV50_DISP_INTERLOCK_CORE]) {
  if (atom->flush_disable) {
   nv50_disp_atomic_commit_wndw(state, interlock);
   nv50_disp_atomic_commit_core(state, interlock);
   memset(interlock, 0x00, sizeof(interlock));

   flushed = true;
  }
 }

 if (flushed)
  nv50_crc_atomic_release_notifier_contexts(state);
 nv50_crc_atomic_init_notifier_contexts(state);

 /* Update output path(s). */
 list_for_each_entry(outp, &atom->outp, head) {
  const struct drm_encoder_helper_funcs *help;
  struct drm_encoder *encoder;

  encoder = outp->encoder;
  help = encoder->helper_private;

  NV_ATOMIC(drm, "%s: set %02x (clr %02x)\n", encoder->name,
     outp->set.mask, outp->clr.mask);

  if (outp->set.mask) {
   help->atomic_enable(encoder, state);
   outp->enabled = true;
   interlock[NV50_DISP_INTERLOCK_CORE] = 1;
  }
 }

 /* Update head(s). */
 for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
  struct nv50_head_atom *asyh = nv50_head_atom(new_crtc_state);
  struct nv50_head *head = nv50_head(crtc);

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

--> maximum size reached

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