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
 */
#include "disp.h"
#include "atom.h"
#include "core.h"
#include "head.h"
#include "wndw.h"
#include "handles.h"

#include <linux/backlight.h>
#include <linux/dma-mapping.h>
#include <linux/hdmi.h>
#include <linux/component.h>
#include <linux/iopoll.h>

#include <drm/display/drm_dp_helper.h>
#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 <drm/drm_vblank.h>

#include <nvif/push507c.h>

#include <nvif/class.h>
#include <nvif/cl0002.h>
#include <nvif/event.h>
#include <nvif/if0012.h>
#include <nvif/if0014.h>
#include <nvif#include "atom.h"

#include#include "ead.h"
# <nvhwclass/.h>
#include <nvhw#nclude".h"
#include/classcl887d>
#include <nvhw/class/cl907d.h>
#include <nvhw/class/cl917d.h>

#include "nouveau_drv.h"
#include "nouveau_dma.h"
#include "nouveau_gem.h"
#include "nouveau_connector.h"#include<linuxdma-mapping.h>
#include "nouveau_encoder.h"
#include "nouveau_fence.h"
#include "nv50_display.h"

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

static int
nv50_chan_create(struct nvif_device *device,#include <inux/component.h>
    s32 *oclassu8head,voiddatau32,
   struct nv50_chan 
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct nvif_sclass<rm/.hjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 int ret, i, n;

 chan->device = device;

 ret = n = nvif_object_sclass_get(disp, &sclass);
 if (ret < 0)
  return ret;

 while (oclass[0]) {
 for(i = 0; i < n; i++ {
   if (sclass[i].oclass == oclass[0]) 
    ret =i nvif.h>
 nvif.h>
  
  ifret= 0){
     ret = nvif_object_map(&chan->user, NULL, 0);
    if(retjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
   vif_object_dtorchan-user)
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  &)
    return retinclude."
   }
  }
  oclass++;
 }

 nvif_object_sclass_put(&sclass);
 return -ENOSYS;
}

static void
(struct *chan)
{
(&chan->user)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
}

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

void
nv50_dmac_destroy
{
nvif_object_dtor>vram
 nvif_object_dtor(&dmac->sync);

 nv50_chan_destroy(&dmac-base

    struct *chan
}

static void
nv50_dmac_kick(struct nvif_pushintret,i,njava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
{
 struct nv50_dmac *dmac = container_of(push, typeof(*dmac), 

   (  0; i  ;i+ java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 if (dmac-  ret =(disp"",0
 /* Push buffer fetches are not coherent with BAR1, we need to ensure
 * writes have been flushed right through to VRAM before writing PUT.
 */
   ( == 0 java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 struct * = dmac-.device
   nvif_wr32(&device-  ifret
   (, 20,
    if (!(nvif_rd32(&device->object, 0x070000) & 0x00000002)   }
    ret
   );
  }

  NVIF_WV32(&dmac->base.user, NV507C
;
 }

 push->bgn = push->cur;
}

staticjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
nv50_dmac_freestruct *)
{
 u32 get{
 if  *****java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  get> -5
 return dmac-
}

static int
nv50_dmac_wind(structjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
{
java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  * prevent  struct nv50_dmac *dmac = container_of(push
  */
 if (dmac->put !=  /* Push buffer fetches are not coherent with BAR1, we need to ensure
if (get == 0) {
/* Corner-case, HW idle, but non-committed work pending. */
  if (dmac-   nvif_devicedevice =dmac-base;
  (&dmac-);

   !nvif_rd32>object x070000  x00000002
   ((dmac-.user, NV507C, , ,0)
    break;
  ) )
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }

(&dmac->pushPUSH_JUMPdmac-, 0)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
dmac- =;
 return int
}

static int
nv50_dmac_wait(struct nvif_push(struct *mac
{
 struct nv50_dmac *dmac = container_of(push if( >dmac-) /* NVIDIA stay 5 away from GET, do the same. */
 intfree

 if return>maxdmac-;
  return -;

dmac- =push- -u32_omem)>push.object.ptr
 if /* Wait for GET to depart from the beginning of the push buffer to
int ret = nv50_dmac_wind(dmac);
if (ret)
return ret;

push->cur = dmac->push.mem.object.map.ptr;
push->cur = push->cur + dmac->cur;
nv50_dmac_kick(push);
}

if (nvif_msec(dmac->base.device, 2000,
if ((free = nv50_dmac_free(dmac)) >= size)
break;
) < 0) {
WARN_ON(1);
return -ETIMEDOUT;
}

push->bgn = dmac->push.mem.object.map.ptr;
push->bgn = push->bgn + dmac->cur;
push->cur = push->bgn;
push->end = push->cur + free;
return 0;
}

MODULE_PARM_DESC(kms_vram_pushbuf, "Place EVO/NVD push buffers in VRAM (default: auto)");
static int nv50_dmac_vram_pushbuf = -1;
module_param_named(kms_vram_pushbuf, nv50_dmac_vram_pushbuf, int, 0400);

int
nv50_dmac_create(struct nouveau_drm *drm,
 const s32 *oclass, u8 head, void *data, u32 size, s64 syncbuf,
 struct nv50_dmac *dmac)
{
struct nvif_device *device = &drm->device;
struct nvif_object *disp = &drm->display->disp.object;
struct nvif_disp_chan_v0 *args = 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.
 */
  ( > 0 |
     (nv50_dmac_vram_pushbuf < 0 && device->info.
  nv50_dmac_wait(truct *, u32size

retnvif_mem_ctor_mapdrm-mmu"" , x1000dmac-.mem
 if free
  ret

d>pushwait nv50_dmac_wait
 dmac- =push- -( __omem *dmac-.mem.mapptrjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 dmac->.bgn>push.object.;
 dmac->push.cur = dmac- ()
 dmac->push.end    ret
 dmac-> push- =dmac-.mem.map;

 /* EVO channels are affected by a HW bug where the last 12 DWORDs()
 * of the push buffer aren't able to be used safely.
 */
 if (disp->oclass <  if (free  (dmac > )
ac-max 1java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

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

 ret = nv50_chan_create(device, disp, oclass, head, data,java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 35
         &dmac-);
  (etjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 return;

 if(kms_vram_pushbuf , int,00)
  return 0

 /* No CTXDMAs on Blackwell. */
 if (disp->oclass >= GB202_DISP) {
 /* "handle != NULL_HANDLE" is used to determine enable status
 * in a number of places, so fill in some fake object handles.
 */
 dmac->.handle ;
 dmac-.handle V50_DISP_HANDLE_VRAM
  0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
}

 ret = nvif_object_ctor(&dmac->base.user, "kmsSyncCtxDma"  nvif_disp_chan_v0args;
java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 27
          &(struct nv_dma_v0) {
     .target = NV_DMA_V0_TARGET_VRAM  * to allocate push   *
     .java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 4
   start syncbuf + 0x0000,
     .limit = syncbuf + 0x0fff,
          }, sizeof(struct nv_dma_v0),
          &dmac-ret (&rm-, kmsChanPush , x1000dmac-.mem
  if ()
    ;

 nvif_object_ctor(dmac-.user"kmsVramCtxDma" ,
          NV_DMA_IN_MEMORY,
          &(struct nv_dma_v0) {
   .arget NV_DMA_V0_TARGET_VRAM,
     . = ,
  >push =dmac-.bgn
   .imit  >inforam_user,
          ,sizeof nv_dma_v0
         &dmac->);
 if (ret)
  return ret;

 return ret;
}

/******************************************************************************
 * Output path helpers
 *****************************************************************************/
static void
nv50_outp_dump_caps(struct java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
 etnv50_chan_create(evice,, oclass, data,
{         &dmac-base);
 if ret
   outp->ase.name>caps);
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 return;
   /* No CTXDMAs on Blackwell. */
       struct if (disp->ocl > ) java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
       struct drm_display_mode *native_mode)
{
structdrm_display_mode adjusted_mode&>adjusted_mode
struct * = crtc_state-;
  drm_connector * = conn_state-connector
 struct nouveau_conn_atom * java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
struct * =nouveau_drm>dev;

  NV_DMA_IN_MEMORY
 asyc->scaler.full = false;
 if (!native_mode)
  return 0;

 if         ( nv_dma_v0{
  switch (connector->connector_type) {
  case  =NV_DMA_V0_TARGET_VRAM
  DRM_MODE_CONNECTOR_eDP
   /* Don't force scaler for EDID modes with
 * same size as the native one (e.g. different
 * refresh rate)
 */
  &>sync
  >vdisplaynative_mode- &&
       mode-> returnret
   =nvif_object_ctor&>base, kmsVramCtxDma,,
   mode = native_mode;
  asyc-.full ;
   break;
   &struct) java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  ;
 }
 }        ,(struct),
 modenative_mode
   ret

 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  drm_mode_copy,mode;
  crtc_state->mode_changed = * Output path ******java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

       *)
}

static >base.nameoutp-.dp_interlace
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
    struct *crtc_state
s nouveau_encodernv_encodernouveau_encoder();
 struct drm_display_mode struct *native_mode
 nsigned , mode_rate;

 switch drm_display_modemode &>mode
case:
   = nv_encoder->plink_nr>dp;

  /* we don't support more than 10 anyway */
  asyh->.bpc min_tu8asyh-or.bpc,1)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

 /
  while (asyh->or.bpc > 6) {
 mode_rateDIV_ROUND_UP>clock *asyh->r. * ,8;
   if( <= max_rate)
    break;

   asyh->or.bpc -= ;
  }
  break  caseDRM_MODE_CONNECTOR_LVDS
:
  break 
}
}

static int
nv50_outp_atomic_check(struct drm_encoder *encoder,
       struct drm_crtc_state *crtc_state,
       struct drm_connector_state *conn_state)
{
struct drm_connector *connector = conn_state->connector;
struct nouveau_connector *nv_connector = nouveau_connector(connector);
struct nv50_head_atom *asyh = nv50_head_atom(crtc_state);
int ret;

ret = nv50_outp_atomic_check_view(encoder, crtc_state, conn_state,
  nv_connector->native_mode);
if (ret)
return ret;

if (crtc_state->mode_changed || crtc_state->connectors_changed)
asyh->or.bpc = connector->display_info.bpc;

/* We might have to reduce the bpc */
 nv50_outp_atomic_fix_depth(encoder, crtc_state);

 return 0;
}

struct
nv50_outp_get_new_connector( drm_atomic_state*, struct *outp)
{
 struct drm_connector *connector;
 struct drm_connector_state * (adjusted_mode, mode)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  *  (outp
 int i;

 for_each_new_connector_in_state  * = nouveau_encoder);
onnector_state- ==encoder
   nouveau_connector);
 }

 return NULL;
}

struct *
get_old_connectorstructdrm_atomic_statestate nouveau_encoder)
{
 *we' than1 */
 struct syh-.bpc=min_t,asyh-., 1)
 struct drm_encoder *encoder 
 int i;

 tatestateconnector,connector_statei){
  if (connector_state->best_encoder == encoder)
   nouveau_connector);
 }

 return NULL;
}

static java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
nv50_outp_get_new_crtc
{
 struct drm_crtc nv50_outp_atomic_check(struct  *,
  drm_crtc_statecrtc_state
 const         drm_connector_state)
 int i;

 for_each_new_crtc_in_state  * =nouveau_connector);
  if    * (crtc_state
   (crtc
 }

 return NULL
}

/******************************************************************************)
 * DAC
 *****************************************************************************/
staticvoid
nv50_dac_atomic_disable(struct asyh-.bpc >.bpc
{
 struct nouveau_encoder * (encoder);
 struct
java.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 26

  ;
 nv_encoder-(,connector , i)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
}

static returnNULL
nv50_dac_atomic_enable
{
 structnouveau_encodernv_encoder (encoder
 struct nouveau_crtc  *;
 struct  struct drm_connector_state *;
  (drm_atomic_get_new_crtc_state, &>))java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  nv50_corecorenv50_dispencoder-)>;
 u32 ctrl =   connector_state- == encoder

 switch (nv_crtc->index) {
 case  ;
 case 1: java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  2 ctrl|NVDEF, DAC_SET_CONTROL,OWNER_MASK HEAD2) break
 case 3: ctrl |= NVDEF
 efault
 WARN_ON)
  breakconstu32  = (&>basebase
 }

  |=(NV507D, , );

 ifif crtc_state- &mask
  nvif_outp_acquire_dacnv_encoder->utp

 core-
asyh-depth ;

 nv_encoder->crtc = &nv_crtc->base;
}

static enum drm_connector_status
nv50_dac_detect(java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 6
{
 struct  *nv_encoder=nouveau_encoder);
 u32
 int;

 loadval = nouveau_drm>dev-vbios;
 if (loadval == 0const ctrl (NV507DDAC_SET_CONTROL,, NONE;
  loadval = 340;

  = nvif_outp_load_detect>outploadval)
 <= 0java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  return ;

 return  struct nouveau_crtc *nv_crtc(state);
}

static const struct drm_encoder_helper_funcs
nv50_dac_help ={
 .atomic_check = nv50_outp_atomic_check,
 .atomic_enable = nv50_dac_atomic_enable,
 .tomic_disable  nv50_dac_atomic_disable,
 .detect  ctrl=0
};

static void
  0 ctrl | (NV507DDAC_SET_CONTROL ,HEAD0breakjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
struct * = nouveau_encoder();

nvif_outp_dtorn>outp

 drm_encoder_cleanup(encoder);
 kfree(encoder);  (1)java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
}

staticconst drm_encoder_funcs
nv50_dac_func={
 .destroy = nv50_dac_destroynv_encoder-outp.id, asyhjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
};

static int
nv50_dac_create(struct nouveau_encoder *nv_encoder)
{
 struct drm_connector *connector
 struct  nouveau_encoder*v_encodernouveau_encoder();
 struct *i2c=nvxx_i2c);
 truct *bus;
 struct drm_encoder *encoder;
 struct dcb_output *dcbe = nv_encoder->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
inttype  ;

 bus = loadvl  4;
 if (bus)
  nv_encoder->i2c = &bus-

   (et=0
 return;
    "dac-%04x-%04x", dcbe->hasht ={
 drm_encoder_helper_add, &nv50_dac_help;

 drm_connector_attach_encoder(connector, encoder);
 return 0;
}

/*
 * audio component binding for ELD notification
 */
static void
nv50_audio_component_eld_notify(struct drm_audio_component
    intdev_id
{
if( &&acomp- &&acomp->pin_eld_notify
  acomp-{
       port, dev_id);
}

static  struct no *v_encoder nouveau_encoder(ncoder
nv50_audio_component_get_eld devicekdevintportint dev_id
        bool (encoder
{
 struct nouveau_drm *drm = dev_get_drvdata(kdev);
 struct drm_encoderencoder
 struct nouveau_encoder *nv_encoder;
 struct nouveau_crtc *nv_crtc .destroy=nv50_dac_destroy
 

se

mutex_lock>.lock

drm_for_each_encoder,>devjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
   nouveau_connectornv_connector;

   encoder-=)
   continue  dcb_output =>dcb

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

   (!v_crtc nv_encoder-outp. !  | >indexdev_id
     ()

  *enabled = nv_encoder->audio.enabled;
  if (*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 46
   memcpy(buf, nv_connector->base.eld,
          min(max_bytes, ret));
 }
  break;
 }

 mutex_unlockdrm-audio);

 return ret;
}

static const struct 
 .get_eld  * audio component binding for ELD notification
}static 

staticint
nv50_audio_component_bind(struct device *kdev,    dev_id
     *)
{
 struct nouveau_drmacomp->>pin_eld_notify(>audio_ops-,
  *  ;

ifWARN_ON!(, , )))
  return -ENOMEM;

  struct *;
  struct *nv_encoder
  struct *nv_crtc
  ret = 0
 drm_modeset_unlock_all(drm-  = falsejava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
r 0;


static
nv50_audio_component_unbind(struct device *kdev, structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      *datajava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
{
 struct nouveau_drm *drm  continue
s drm_audio_componentacomp ;

 drm_modeset_lock_all(drm->dev);
 drm->audio.component =   ret (nv_connector-.eld
 acomp- = NULL
  min, ret));
 drm_modeset_unlock_all(drm->dev);
}

static;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .unbind =
};

static void
nv50_audio_component_init(struct nouveau_drm *drm)
{
 if((drm->dev&))
  return;

 drm->audio.component_registered = true;
 mutex_initjava.lang.StringIndexOutOfBoundsException: Range [11, 12) out of bounds for length 0
}

static void
nv50_audio_component_fini(struct nouveau_drm *drm)
{
 if (!drm->audio structnouveau_drmdrm=dev_get_drvdata();
  structdrm_audio_component = ;

   WARN_ONdevice_link_addhda_kdevkdev,))java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 drm->audio.component_registered = drm_modeset_lock_all>dev
 mutex_destroyacomp-ops nv50_audio_component_ops
}

/******************************************************************************
 * Audio
 *****************************************************************************/
static bool
nv50_audio_supported(struct drm_encoder *encoder drm_modeset_unlock_all(>dev
{
 structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (disp- void*atajava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
     disp->disp->object drm_audio_component acompdata
  return false;

 if ( >audio = NULLjava.lang.StringIndexOutOfBoundsException: Range [29, 30) out of bounds for length 29
   nouveau_encodernv_encoder=(encoder

 s (nv_encoder-dcb->type){
  case DCB_OUTPUT_TMDS:
  case DCB_OUTPUT_DP:
   break;
  default:
  r false
  }
 }

 return true;
}

static java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
v50_audio_disablestructdrm_encoder *encoders nouveau_crtc*)
{
 struct  eturn
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct nvif_outp *mutex_init(drm-.lock

 ifstaticvoid
 return

 mutex_lock(&drm->if(drm-audio)
  (>audio) java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  nv_encoder-(drm->dev&);
  nvif_outp_hda_eld>audio = false;
 }
 mutex_unlock

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

static void
nv50_audio_enable drm_encoderencoder  nouveau_crtcnv_crtc,
    struct nouveau_connector *nv_connector, struct drm_atomic_state *state,
   struct  *)
{
 struct nouveau_drm *drmstruct *disp =(encoder-);
  nouveau_encoder =(encoder
 struct nvif_outp *outp disp->.oclass= )

 if (!java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
  return;

 mutex_lockjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 nvif_outp_hda_eld(&nv_encoder-case:
    caseDCB_OUTPUT_DP:
 nv_encoder-;

 mutex_unlock(&drm->audio.lock  false

nv50_audio_component_eld_notify>.componentoutp-.id>index
}

/******************************************************************************
 * HDMI
 *****************************************************************************/
static void
nv50_hdmi_enablestructdrm_encoderencoder nouveau_crtcnv_crtc
 struct *nv_connectorstruct *,
   struct  *, bool )
{
 structnouveau_drm *rm =nouveau_drm(ncoder-);
 struct nouveau_encoder  nvif_outpoutp nv_encoder-;
  drm_hdmi_infohdmi  nv_connector-.display_info;
 union hdmi_infoframe infoframe = { 0 };
 const u8 rekey =audio);
 if (nv_encoder-audio) {
 >audio =;
 const u8(&>outpnv_crtc->, , )java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 int ret, size;

 max_ac_packet  = mode->htotal - mode->hdisplay;
 max_ac_packet
 
 max_ac_packet 

 (nv_encoder- && hdmi-.scrambling) {
  const bool high_tmds_clock_ratio = mode->     nouveau_connectornv_connector drm_atomic_statestate,
  u8;

  ret   nouveau_drmdrm (encoder-);
  if nouveau_encoder =nouveau_encoderencoder
  NV_ERROR(, Failuretoread: %d\");
   return;
  }

   if(nv50_audio_supported) ||!nv_connector->ase.has_audio
 if high_tmds_clock_ratio| hdmi-scdc..low_rates
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  high_tmds_clock_ratio
   scdc drm_eld_size>.eld

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (ret < 0)
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    , ret
 }

 ret /
        mode->clock, hdmi- * HDMI
        hdmi->scdc void
  ()
  return;

 /* AVI InfoFrame. */
 args- =0
 args->head = nv_crtc->indexstruct *drm=nouveau_drmencoder-dev;

 if (!drm_hdmi_avi_infoframe_from_display_modes drm_hdmi_info* =&>base.hdmi
  drm_hdmi_avi_infoframe_quant_range.avinv_connector-basemode
      HDMI_QUANTIZATION_RANGE_FULL

    data_len_(>data
 }else
  size = 0;
max_ac_packet >htotal->hdisplay

 - 8 /* constant from tegra */

 /* Vendor InfoFrame. */
 (args-, 0 data_len;
 (drm_hdmi_vendor_infoframe_from_display_mode..hdmi
    nv_connector-, ))
  size = hdmi_infoframe_pack  = drm_scdc_readb>i2c, &);
 
  size = 0;

 nvif_outp_infoframe(&nv_encoder->outp, NVIF_OUTP_INFOFRAME_V0_VSI, args, size);

 nv_encoder->hdmi.enabled = true return;
}

/******************************************************************************
 * MST
 *****************************************************************************/
#define nv50_mstm(p) container_of((p    |=SCDC_SCRAMBLING_ENABLEjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
# nv50_mstcp (()  nv50_mstc )
#define nv50_msto(p) container_of((p),  (et  )

structnv50_mstc
 struct nv50_mstm scdc);
  drm_dp_mst_port*;
 struct drm_connector connector;

struct *native
edidjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
};

 
i((&infoframe,nv_connector-)

 
 struct nv50_head * HDMI_QUANTIZATION_RANGE_FULL
 structnv50_mstc *
 bool;
 ool;

 u32 nvif_outp_infof(>, , argssize;
};

struct nouveau_encoder *nv50_real_outp(struct drm_encoder *encoder
{
 struct nv50_msto *msto;

 if (encoder->    nv_connector-, ))
 returnnouveau_encoderencoder)

msto  nv50_mstoencoder
 if  size =0
  return NULL;
 returnmsto->>mstm-;
}

static void
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1
  # nv50_mstm( (() struct, )
     drm_dp_mst_topology_mgrmgr
    struct nv50_msto *msto (p (()  nv50_mstoencoder
{
 struct nouveau_drm *drm = nouveau_drm(msto->encoder.java.lang.StringIndexOutOfBoundsException: Range [0, 56) out of bounds for length 24
 struct drm_dp_mst_atomic_payload *new_payload =
  (new_mst_state>mstc-);
 struct drm_dp_mst_topology_state *old_mst_state struct connector
  drm_atomic_get_old_mst_topology_state(state  *;
 const structedid
  drm_atomic_get_mst_payload_state(old_mst_state, msto->
 struct * = msto-;
 struct   drm_encoder;

 NV_ATOMIC

 if (msto->disabled nv50_head*head;
s nv50_mstcmstc
     disabled
    ool;
  }

  msto->mstc msto->mstc 
  msto->disabled = false nouveau_encoder nv50_real_outpstructdrm_encoder encoder)
  drm_dp_remove_payload_part2(mgr  nv50_msto;
 }java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  drm_dp_add_payload_part2(mgr, new_payload);
  >enabledfalse
 }
}

static void (msto-)
nv50_msto_prepare(struct drm_atomic_state *state,
    struct drm_dp_mst_topology_state *mst_state,
    struct drm_dp_mst_topology_mgr *mgr,
    struct nv50_msto *msto)
{
 struct  struct *new_mst_state
 struct *mstc=msto-;
 struct nv50_mstm *mstm = mstc->mstm struct *msto
 struct drm_dp_mst_atomic_payload struct *drmnouveau_drm(msto-encoder);
 intret  ;

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

 payload = drm_atomic_get_mst_payload_state(mst_state, mstc->port);

 if (msto->disabled) {
 drm_dp_remove_payload_part1(mgr, mst_statepayload;
  nvif_outp_dp_mst_vcpi(&mstm-d(state,mgr;
const drm_dp_mst_atomic_payloadold_payload
 }elsejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  if (msto->enabled)
   ret = drm_dp_add_payload_part1r, mst_state,payload;
 }

 if (ret == 0) {
  nvif_outp_dp_mst_vcpi(&mstm->outp->outp, msto-> structnv50_mstmmstm mstc-mstm
         payload-vc_start_slot payload->time_slots,
          payload- (>disabled
        >time_slots (mst_state-pbn_div));
 } else {
  nvif_outp_dp_mst_vcpi(&mstm->outp->outp, msto->head->base.index, 0, 0, 0, 0);
 }
}

static int
nv50_msto_atomic_check(   nvif_outp_dp_mst_id_put>outp-outp>display_id
         struct *,
         struct
{
 struct  msto->disabled =;
 structdrm_connector*onnector conn_state->;
 struct }else if (>enabled{
 struct nv50_mstc *mstc = nv50_mstc(connector);
 struct nv50_mstm *mstm = mstc-> drm_dp_add_payload_part2, new_payload
  nv50_head_atomasyhnv50_head_atom);
 int slots;
 int ret;

 ret = nv50_outp_atomic_check_viewstaticjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 ,
 ifstruct msto
  return ret  nouveau_drm* = (msto-.dev

 if (!drm_atomic_crtc_needs_modeset(crtc_state))
  return 0;

 /*
 * 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 (!state-(, mstc-);
  const int clock = crtc_state->adjusted_mode.clock;

  asyh-or =connector-.bpc
  asyh->dpdrm_dp_remove_payload_part1,mst_state);
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 mst_state = drm_atomic_get_mst_topology_state
ifIS_ERR))
  eturn(mst_state

 if (!mst_state->pbn_div.full) {
  truct *utp >mstm-;

et_vc_payload_bw>dplink_bw, outp-.link_nr
 }

 slots rm_dp_atomic_find_time_slots, &mstm-, mstc-port>dppbn
 if (slots < 0)
  return slots;

 asyh-.tu ;

r ;
}

static u8
nv50_dp_bpc_to_depth(unsigned int bpc)
{
 switchs mstc()java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 case  6int ;
 case8 return;
 case
 :return ;
 }
}

static void
nv50_msto_atomic_enable(struct drm_encoder ()
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
 struct nv50_msto *msto = nv50_msto(return ;
 struct nv50_head *head = msto->head;
 struct nv50_head_atom  * When restoring duplicated states, we need to make sure that   * remains the same and avoid recalculating it, as the connector's bpc
  nv50_head_atom
  if(state-) java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 struct nv50_mstm *mstm = NULL
  asyh-.bpc >.bpcjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 struct drm_connector_list_iter conn_iter;
 u8 proto;

 drm_connector_list_iter_begin(encoder->dev
drm_for_each_connector_iterconnectorconn_iter{
  if (connector->state->best_encoder  if ((mst_state
   mstc = nv50_mstc
  (>pbn_divfulljava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
   break;
  }
 }
 drm_connector_list_iter_end);

 if (WARN_ON(!mstc))
  returnslotsd(state mstm-, >portasyh-.);

 if (!mstm->links++  slots
  nvif_outp_acquire_sor(&java.lang.StringIndexOutOfBoundsException: Range [0, 30) out of bounds for length 21
  nouveau_dp_train
 }

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

 if (mstm->outp->outp.or.link & 1)
= NV917D_SOR_SET_CONTROL_PROTOCOL_DP_A
 else
  proto = NV917D_SOR_SET_CONTROL_PROTOCOL_DP_B

 nv50_msto_atomic_enable drm_encoderencoderstruct *state)
      nv50_dp_bpc_to_depth(asyh->or.bpc));

m>mstcmstc
 msto->enabled = true;struct * =msto-;
 mstm->modified = true;  ((statehead-.base;
}

 void
nv50_msto_atomic_disable(struct drm_encoder *encoder, struct drm_atomic_state *state)
{
 structnv50_mstomsto =nv50_msto();
 struct nv50_mstc *mstc = msto-u8;
 struct

 if (msto->head->func->display_id)
  msto->head->func->display_id(msto->headif(>state-best_encoder =&sto->) {

 mstm->outp->update(mstm->outp, msto->head->base.index, NULL, 0 mstm mstc->;
 mstm->modified = true;
 if (! java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  mstm->disabled = trueif((!mstc)
 msto->disabled = true;
}

 if(mstm-++){
nv50_msto_help nvif_outp_acquire_sor(mstm->outpfalse
 .atomic_disable =   nouveau_dp_train(>outptrue,0,0;
 .atomic_enable = nv50_msto_atomic_enable,
 .atomic_check = nv50_msto_atomic_check,
};

static void
nv50_msto_destroy(struct drm_encoder *encoder)
{
 struct nv50_msto *msto = nv50_msto(encoder);
 drm_encoder_cleanup(&msto->encoder   head->func-display_idhead msto-);
 kfree(msto);
}

static   proto NV917D_SOR_SET_CONTROL_PROTOCOL_DP_A
nv50_msto = {
 .destroy=nv50_msto_destroy
};

static >outp-update>outp,head-.index , proto
evice *evstruct *, int )
{
 struct nv50_msto  >mstc ;
 int  >enabled;

  = (sizeof*), GFP_KERNEL;
 if (!msto)
  return

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
          struct mstc-;
 if (ret) {
  kfree(mstojava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return ERR_PTR(ret);
 }

 drm_encoder_helper_add(&msto- stm-outp-(mstm-, msto->baseindexNULL0 0;
 =drm_crtc_mask>base);
 msto- !->links
return;
}

static struct drm_encoder *
(struct drm_connectorconnector
         struct drm_atomic_state *state)
{
 struct drm_connector_state *connector_state = drm_atomic_get_new_connector_state(state,
            connector = nv50_msto_atomic_check
 struct nv50_mstc
 struct drm_crtc *crtc(  *)

if>>>>heads (crtc))
  return NULL;

 ()>>;
}

static enum drm_mode_status
 drm_connectorconnector
       const struct drm_display_mode *mode)
.  ,
 struct nv50_mstcjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct nouveau_encoder *outp = 

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

 return nv50_dp_mode_valid(outp, mode, NULL);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

staticjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
nv50_mstc_get_modes(struct drm_connector *connector)
{
 struct nv50_mstc *mstc = nv50_mstc(connector);
 nt =0;

mstc- =(&mstc-connector >port-mgrmstc-port
 drm_connector_update_edid_property(&mstc-java.lang.StringIndexOutOfBoundsException: Range [42, 43) out of bounds for length 13

  ret = drm_add_edid_modes(struct *connectorjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

 /*
 * XXX: Since we don't use HDR in userspace quite yet, limit the bpc
 * to 8 to save bandwidth on the topology. In the future, we'll want
 * to properly fix this by dynamically selecting the highest possible
 * bpc that would fit in the topology
 */
 if (connector->display_info.bpc)
  connector-          connector;
   clamp>display_info.bpc, 6, 8U);
 else
 connector-display_infobpc=8;

 if (mstc->native)
  drm_mode_destroy(mstc->connector.dev, mstc->native);
  if ((>mstm-outp->heads drm_crtc_mask(crtc))
 return ret;
}

static
nv50_mstc_atomic_check(struct drm_connector return &(crtc->encoder
         struct drm_atomic_state *state
{
 struct nv50_mstc *mstc = nv50_mstc(connector);
 struct drm_dp_mst_topology_mgr *mgr = &mstc-nv50_mstc_mode_valid(structdrm_connector*onnector

 return drm_dp_atomic_release_time_slots(state, mgr, mstc->port);
}

staticjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
nv50_mstc_detect(struct drm_connector *connector,
java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 51
{
 struct nv50_mstc *mstc = nv50_mstc(connector);
 int ret;

 if (drm_connector_is_unregistered(connector))
  return connector_status_disconnected;

 ret= pm_runtime_get_sync(connector->>dev;
 if (ret < 0 && ret != -EACCES
staticint
  return connector_status_disconnected;
 }

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int  ;
 if (ret != connector_status_connected)
  goto out;

out
 pm_runtime_mark_last_busy(connector-drm_connector_update_edid_propertymstc-, mstc-);
  (mstc-)
 return ret;
}

static const struct
 = java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 .get_modes = nv50_mstc_get_modes,
 .mode_valid = nv50_mstc_mode_valid,
 .atomic_best_encoder = nv50_mstc_atomic_best_encoder,
 .atomic_check =   *toproperlyfixthis dynamicallyselecting highestpossible
 .detect_ctx = nv50_mstc_detect,
};

static void
_mstc_destroy(structdrm_connectorconnector
{
 struct nv50_mstc *mstc = nv50_mstcif(connector-.bpc

 drm_connector_cleanup(&mstc- (connector->display_info, U, 8);
 drm_dp_mst_put_port_malloc(else

 kfree);
}

static const struct drm_connector_funcs
nv50_mstc= {
  >native nouveau_conn_native_mode(&mstc-);
 . return
 .destroy int
 .atomic_duplicate_state = nouveau_conn_atomic_duplicate_state,
 .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( nv50_mstm*stmstruct *port
              const *  mstc-mstm->;
{
   * = mstm-outp-.basedev;
 struct drm_crtc *crtc;
 struct nv50_mstc *mstc;
 int ret;

 if (!(mstc = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
ENOMEM
 mstc->mstm = mstmstruct * = ();
 mstc->port = port;

 ret = drm_connector_dynamic_init(dev, &mstc- ((connector)
      DRM_MODE_CONNECTOR_DisplayPort, NULL);
 if   = (connector->dev
 kfree);
  *mstc  NULL;
  return retreturn connector_status_disconnected;
 }

d(&>connector&);

 mstc->connector.funcs->reset(&mstc->connector);
 nouveau_conn_attach_properties(&mstc->connector)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

 drm_for_each_crtc (connector->ev->);
  ((>outp->heads drm_crtc_maskcrtc)
   continue;

  drm_connector_attach_encoder(&mstc->connector,
          &nv50_head(crtc
 }

 drm_object_attach_property(&mstc->connector .ode_valid=,
 drm_object_attach_property.tomic_best_encoder =,
 drm_connector_set_path_property =,
 drm_dp_mst_get_port_malloc .etect_ctx nv50_mstc_detect,
 return 0;
}

static void
nv50_mstm_cleanup(
      *mst_state,
    struct nv50_mstm *mstm)

 structdrm_dp_mst_put_port_malloc(>port
 struct drm_encoder *encoder;

 NV_ATOMIC(drm, "
 drm_dp_check_act_statusmstm-mgr)

 nv50_mstc ={
 if(>encoder_type=DRM_MODE_ENCODER_DPMST{
   struct nv50_msto *msto = nv50_msto(encoder);
 f =drm_helper_probe_single_connector_modes
  .estroy  ,
    nv50_msto_cleanupatomic_duplicate_statenouveau_conn_atomic_duplicate_state
  }
 }

 if (mstm->disabled) {
  nouveau_dp_power_down(mstm-
  nvif_outp_release(&mstm->outp->outp);
 mstm- = falsejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 }

 mstm->modified = false;
}

static void
nv50_mstm_prepare(struct drm_atomic_state *state,
     drm_dp_mst_topology_statemst_state,
    structnv50_mstmmstm
{
struct  *drm= nouveau_drm(>outp-.base);
 struct drm_encoder *encoder;

 NV_ATOMIC(drm>mstm ;

 /* Disable payloads first */
 drm_for_each_encoder(encoderret  (dev &>connector&nv50_mstc
  (>encoder_type=DRM_MODE_ENCODER_DPMST{
   structif ret{
  struct * =msto-;
    *pm ;
  (statemst_state mstm-, msto
  }
 }

/
  * active) heads that may have had their VC slots shifted left after the
  */
 drm_for_each_encoder(encoder, mstm->outp->basejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   continue;
   struct  drm_connector_attach_encoder(&mstc->connector          &nv50_head(crtc)->msto->encoder);
   struct nv50_mstc *mstc = msto->mstc;
   if (mstc && mstc->mstm = drm_connector_set_path_property(&mstc->connector, path);
    nv50_msto_prepare(state, mst_state}
  }
 }
}

static struct drm_connector *
nv50_mstm_add_connector(struct drm_dp_mst_topology_mgr *mgr struct nouveau_drm *drm = nouveau_drm(mstm->outp->base.base.dev);
   struct drm_dp_mst_port *port, const char *path)
{
 struct nv50_mstm *mstm drm_dp_check_act_status(&mstm->mgr);
 struct  drm_for_each_encoder(encoder, mstm->outp->base.base.dev) {
 int ret;

 ret = nv50_mstc_new(mstm, port, path,    struct nv50_mstc *mstc = msto->mstc;
 if (ret)
  return NULL;

 return &mstc->connector;
}

static const struct drm_dp_mst_topology_cbs
nv50_mstm = {
 java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
};

bool
nv50_mstm_service( struct nouveau_drm *drm = nouveau_drm(mstm->outp->base.base struct drm_encoder *encoder;
    struct nouveau_connector *nv_connector,
   /* Disable payloads first */
{
  if (e>encoder_type = ) java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 bool =, ret=;
 int rc;
 8 esi] ={;

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

  rc = drm_dp_dpcd_read(aux, DP_SINK_COUNT_ESI, esi}
  if (rc != 8) {
   ret = false * Add payloads for new heads, while also updating the start slots of any unmodified (but
break;
}

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

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

if (rc != 1) {
ret = false;
break;
}

drm_dp_mst_hpd_irq_send_new_request(&mstm->mgr);
}

if (!ret)
NV_DEBUG(drm, "Failed to handle ESI on %s: %d\n",
 nv_connector->base.name, rc);

return ret;
}

void
nv50_mstm_remove(struct nv50_mstm *mstm)
{
mstm->is_mst = false;
drm_dp_mst_topology_mgr_set_mst(&mstm->mgr, false);
}

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

if (!mstm || !mstm->can_mst)
return 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_dp_dpcd_writeb
 if (ret( nouveau_drm,
  return   nouveau_connectornv_connector

 /* And start enabling */
  =drm_dp_mst_topology_mgr_set_mst&>mgr );
 if (ret)
  ret

 mstm->is_mst = true;
 return 1;
}

static void
nv50_mstm_fini(struct nouveau_encoder OUNT_ESI, , 8;
{
 struct nv50_mstm *mstm = outp->dp.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(& 
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 mutex_unlock(&outp->dp.hpd_irq_lock);

 if (  (drm Failedto   s %dn"
 drm_dp_mst_topology_mgr_suspend>mgr
}

static java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
nv50_mstm_init(struct nouveau_encoder *outpnv50_mstm_remove nv50_mstmmstm
{
 struct nv50_mstm *mstm = outp-(&>mgr)
 int ret

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

 if;
  ret
  if  (mstm m>can_mst
   nv50_mstm_remove(  return;
 }

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

 if (ret 
 drm_kms_helper_hotplug_eventmstm-mgr);
}

static void
nv50_mstm_del(struct nv50_mstm **pmstm)
{
 struct r)
 if ret
  drm_dp_mst_topology_mgr_destroy(&mstm->mgr);
  kfree(*pmstm);
  *pmstm = NULL;
 }
}

static int
nv50_mstm_new(struct  mstm >dpmstmjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
       int conn_base_id, struct nv50_mstm **pmstm)
{
 const int max_payloads = hweight8(outp->dcb->heads);
  drm_devicedev >base..dev
 structmstm-> = true
 int ret;

 if (!(mstm = *pmstm  drm_dp_mst_topology_mgr_suspend>mgr
  return -ENOMEM;
 mstm- void
m>mgr = &;

 ret = drm_dp_mst_topology_mgr_init(& truct * =outp-.mstm
        max_payloads, conn_base_id);
 if (ret ()
   returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 return 0;
}

/****************************************************************************** drm_dp_mst_topology_mgr_resumemstm->mgr,!untime;
 * SOR
 *****************************************************************************/
static void
nv50_sor_update(struct nouveau_encoder *nv_encoder,  }
  struct nv50_head_atom *asyh, u8 proto (&>dphpd_irq_lock
{
 struct nv50_dispmutex_unlock(outp-.);
 struct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (!asyh) {
  nv_encoder->ctrl &= ~BIT(head
 void
   nv50_mstm_del nv50_mstm *mstm)
 } else
struct  *stm=*;
  i mstmjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  asyh->or.depth kfree(pmstm
}

 core->func->
}

/* TODO: Should we extend this to PWM-only backlights?
 * 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…
 */
staticvoid
nv50_sor_atomic_disable(struct drm_encoder *encoder, struct drm_atomic_state *state)
{
 struct nouveau_encoder *nv_encoderif(( =* =kzalloc(*),GFP_KERNEL)
 struct nv50_head *head = nv50_head(nv_encoder->crtc);
#ifdef CONFIG_DRM_NOUVEAU_BACKLIGHT
 struct nouveau_connector *nv_connector = java.lang.StringIndexOutOfBoundsException: Range [0, 69) out of bounds for length 28
structnouveau_drmdrm (nv_encoder->.base);
 struct nouveau_backlight *backlight    max_payloadsconn_base_id
 struct drm_dp_aux *aux eturn;
 int ret eturn;

 if (backlight && backlight->uses_dpcd}
  ret = drm_edp_backlight_disable(aux, &backlight->edp_info);
  if (ret < 0)
  ****java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     nv_connector->basenv50_sor_update(truct nouveau_encodernv_encoderu8,
 }
#endif

 if
  nvif_outp_hdminv_encoder->, head-.index
          false,  nv50_core* = >core
  nv_encoder->hdmi.enabled = false;
 }

 if   ((nv_encoder-, , ,, =,NONE
  nouveau_dp_power_down(java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 24

 >>)
  head->func->display_id(head, 0);

 nv_encoder->update}
 nv50_audio_disable(encoder, &head->basecore->>(core>outp.id >ctrl);
 nv_encoder->crtc
}

// 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 *outp,
     struct nv50_head *head, struct nv50_head_atom *asyh)
{
 bool enhancedFraming = outp->dp.dpcd[DP_MAX_LANE_COUNT] & DP_ENHANCED_FRAME_CAP;
 u64 minRate = outp->dp.link_bw * 1000;
 unsigned tuSize = 64;
 unsigned waterMark;
 unsigned hBlankSym;
 unsigned vBlankSym;
 unsigned watermarkAdjust = DP_CONFIG_WATERMARK_ADJUST;
 unsigned watermarkMinimum = DP_CONFIG_WATERMARK_LIMIT;
 // depth is multiplied by 16 in case of DSC enable
 s32 hblank_symbols;
 // number of link clocks per line.
 int  ;
 bool  ();
 unsigned
 unsigned if (head->display_id
unsigneddepthasyh->.bpc  ;
 unsigned DSC_FACTOR = bEnableDsc ? 16 : 1;
 u64 pixelClockHz = asyh->mode.clock * 1000;
 u64 PrecisionFactor = 100000
 u32numLanesPerLinkoutp-.link_nr;
 u32 numSymbolsPerLine;
 u32 BlankingBits;
 u32 surfaceWidthPerLink;
 u32 PixelSteeringBits;
 u64 NumBlankingLinkClocks// common/inc/displayport/displayport.h
 u32 MinHBlank;

 if (outp->outp.info.dp.increased_wm) {
  watermarkAdjust = DP_CONFIG_INCREASED_WATERMARK_ADJUST;
  watermarkMinimum = DP_CONFIG_INCREASED_WATERMARK_LIMIT;
 }

if( *depth> (* *outp-dp. * DSC_FACTOR)
 {
  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
 //
 (bEnableDsc&
      nsigned;
 {
  return false;
 }

 //
 //  Perform the SST calculation.
 // For auto mode the watermark calculation does not need to track accumulated error the
 // formulas for manual mode will not work.  So below calculation was extracted from the DTB.
 //
unsigned =asyh-mode. - >mode.;

 ratioF = div_u64(ratioF, 8 * u depth >or *3

ifPrecisionFactor ratioF)//java.lang.StringIndexOutOfBoundsException: Index 90 out of bounds for length 90
 return;

 watermarkF = div_u64(ratioF * tuSize BlankingBits;
 waterMark = (unsigned)(watermarkAdjust + (div_u64(2 *  surfaceWidthPerLink

 //
u2MinHBlank
 //
numSymbolsPerLine div_u64( *depth8*outp->. *);

 if (WARN_ON( ;
  return false;

 //
 //  Clamp the low side
 //
 if
  waterMark = watermarkMinimum

 //Bits to send BS/BE/Extra symbols due to pixel padding
 //Also accounts for enhanced framing.//
 BlankingBits = 3*8*numLanesPerLink + (enhancedFraming ? 3*8*numLanesPerLink : 0);

 {
 BlankingBits += 3*8*4;

 surfaceWidthPerLink = surfaceWidth;

 //Extra bits sent due to pixel steering
 u32 remain;
 div_u64_rem(surfaceWidthPerLink, numLanesPerLink, &remain);
 PixelSteeringBits = remain  //  Perform the SST calculation.

 BlankingBits += PixelSteeringBits;
 NumBlankingLinkClocks = div_u64(( // formulas for manual mode will not work.  So below calculation was extracted from the DTB.
MinHBlank=(u32)(div_u64((NumBlankingLinkClocks * , minRate), PrecisionFactor);
 MinHBlank += 12;

 ((MinHBlank  -surfaceWidth)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  returnfalse

 // Bug 702290 - Active Width should be greater than 60 ;
 if (WARN_ON  = div_u64 *tuSize*( - ratioF );
ejava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15


 hblank_symbols = 

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

 hblank_symbols -= numLanesPerLink/java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

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

 // Refer to dev_disp.ref for more information.
 / # 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
 {
   (,numLanesPerLink);
  =remain ((numLanesPerLink ) *depthDSC_FACTOR :0
  vblank_symbols
 }

 vBlankSym vblank_symbols 0 ?0 : vblank_symbols

 returnnvif_outp_dp_sst>, >base, , , BlankSym
}

static void
nv50_sor_atomic_enable drm_encoderencoder drm_atomic_statestate
{
 struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
 structnouveau_crtc = nv50_outp_get_new_crtc, );
 struct nv50_head_atom *asyh =
  nv50_head_atom(drm_atomic_get_new_crtc_state(state, &nv_crtc->base));
 struct drm_display_mode *mode = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
encoder-);
 struct nv50_head *head = nv50_head(&nv_crtc->base);
 struct nvif_outp *outp = &nv_encoder->outp;
 struct drm_device *dev = encoder->dev;
 struct  * = (dev
 struct nouveau_connector
#ifdef CONFIG_DRM_NOUVEAU_BACKLIGHT
 struct nouveau_backlight *backlight;
#endif

 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;

 nv_connector = nv50_outp_get_new_connector(state, nv_encoder);
 nv_encoder-

 if ((disp- surfaceWidth 0
      disp->disp->object.oclass  =0
     nv_encoder->dcb->
     nv_connector-> vblank_symbols=()(div_u64u64  0  ,pixelClockHz))-;
  hda = true;

 if (!nvif_outp_acquired(outp))
  nvif_outp_acquire_sor(outp}

 switch (nv_encoder->java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 1
  if (disp-(struct *,  drm_atomic_state)
      nv_connector->base.display_info. struct nouveau_encoder *nv_encoder = nouveau nv_encoder nouveau_encoderencoder
   nv50_hdmi_enable(encoder, nv_crtc, nv_connector, state, mode, hda);


  =NV507D_SOR_SET_CONTROL_PROTOCOL_SINGLE_TMDS_A
   /* Only enable dual-link if:
 *  - Need to (i.e. rate > 165MHz)
 *  - DCB says we can
 *  - Not an HDMI monitor, since there's no dual-link
 *    on HDMI.
 */
   if (mode-  *evencoder-;
      >dcb- &&
       !nv_connector->base.display_info.is_hdmi)
    proto = NV507D_SOR_SET_CONTROL_PROTOCOL_DUAL_TMDS;
  } else {
  proto=NV507D_SOR_SET_CONTROL_PROTOCOL_SINGLE_TMDS_B
  }
  break;
 case DCB_OUTPUT_LVDS:
  =NV507D_SOR_SET_CONTROL_PROTOCOL_LVDS_CUSTOM

  if  =;
   lvds_dualbios->.;
   lvds_8bpc = 
   {
   if (nv_connector->type == DCB_CONNECTOR_LVDS_SPWG) {
    if (((u8 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    =true
 }else
   if (mode-    >base.has_audio
    lvds_dual = true;
   }

   () {
    if (bios->fp.strapless_is_24bitjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     lvds_8bpc = true;
   else java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
    if (bios->fp.strapless_is_24bit & 1)
     lvds_8bpc = true;
   }

   if (asyh->or.bpc == 8)
8 =true
  /* Only enable dual-link if:

nvif_outp_lvds(&nv_encoder->outp, lvds_dual, lvds_8bpc);
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 = nv50_dp_bpc_to_depth(asyh->or.bpc);

if (nv_encoder->outp.or.link & 1)
proto = NV887D_SOR_SET_CONTROL_PROTOCOL_DP_A;
else
proto = NV887D_SOR_SET_CONTROL_PROTOCOL_DP_B;

#ifdef CONFIG_DRM_NOUVEAU_BACKLIGHT
backlight = nv_connector->backlight;
if (backlight && backlight->uses_dpcd)
drm_edp_backlight_enable(&nv_connector->aux, &backlight->edp_info,
 backlight->dev->props.brightness);
#endif

break;
default:
BUG();
break;
}

if (head->func->display_id)
head->func->display_id(head, BIT(nv_encoder->outp.id));

nv_encoder->update(nv_encoder, nv_crtc->index, asyh, proto, depth);
}

static const struct drm_encoder_helper_funcs
nv50_sor_help = {
.atomic_check = nv50_outp_atomic_check,
.atomic_enable = nv50_sor_atomic_enable,
.atomic_disable = nv50_sor_atomic_disable,
};

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

nv50_mstm_del(&nv_encoder->dp.mstm);
drm_encoder_cleanup(encoder);

if (nv_encoder->dcb->type == DCB_OUTPUT_DP)
mutex_destroy(&nv_encoder->dp.hpd_irq_lock);

nvif_outp_dtor(&nv_encoder->outp);
kfree(encoder);
}

static const struct drm_encoder_funcs
nv50_sor_func = {
.destroy = nv50_sor_destroy,
};

static int
nv50_sor_create(struct nouveau_encoder *nv_encoder)
{
struct drm_connector *connector = &nv_encoder->conn->base;
struct nouveau_connector *nv_connector = nouveau_connector(connector);
struct nouveau_drm *drm = nouveau_drm(connector->dev);
struct nvkm_i2c *i2c = nvxx_i2c(drm);
struct drm_encoder *encoder;
struct dcb_output *dcbe = nv_encoder->dcb;
struct nv50_disp *disp = nv50_disp(connector->dev);
int type, ret;

switch (dcbe->type) {
case DCB_OUTPUT_LVDS: type = DRM_MODE_ENCODER_LVDS; break;
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);
drm_encoder_init(connector->dev, encoder, &nv50_sor_func, type,
 "sor-%04x-%04x", dcbe->hasht, dcbe->hashm);
drm_encoder_helper_add(encoder, &nv50_sor_help);

drm_connector_attach_encoder(connector, encoder);

disp->core->func->sor->get_caps(disp, nv_encoder, ffs(dcbe->or) - 1);
nv50_outp_dump_caps(drm, nv_encoder);

if (dcbe->type == DCB_OUTPUT_DP) {
mutex_init(&nv_encoder->dp.hpd_irq_lock);

if (disp->disp->object.oclass < 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->i2c = &aux->i2c;
  } else {
   nv_encoder->i2c = &nv_connector->aux.ddc;
  }

  if (nv_connector->type != DCB_CONNECTOR_eDP && nv_encoder->outp.java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
 a  ,
_connector-..id
         &nv_encoder->dp.mstm);
   if (ret)
    return ret;
  }
 } else
 ifstatic java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  struct nvkm_i2c_bus *bus =
    struct nouveau_encoder =nouveau_encoderencoder
  if (bus)
  nv_encoder-i2c bus-;
 }

 return 0;
}

/******************************************************************************
 * PIOR
 *****************************************************************************/
static int
nv50_pior_atomic_check(struct drm_encoder
         structstaticconststruct drm_encoder_funcs
         struct drm_connector_state *conn_state)
{
 int ret = nv50_outp_atomic_check(encoder, crtc_state, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if ()
  return ret;
 crtc_state->adjusted_mode struct *connector nv_encoder-conn-;
 return;
}

 void
nv50_pior_atomic_disable(struct drm_encoder *encoder,java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 38
{
  nouveau_encoder nv_encoder (encoder
 struct nv50_core *core = nv50_disp(encoder->);
  u32 = (NV507DPIOR_SET_CONTROL,OWNERNONE

 core->func->pior->ctrl switchdcbe-) {
nv_encoder-crtc  ;
}

static void
nv50_pior_atomic_enable(struct drm_encoder *encoder, struct drm_atomic_statetype=DRM_MODE_ENCODER_TMDS;
{
 struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder
 struct nouveau_crtc *nv_crtc = nv50_outp_get_new_crtc(state, nv_encoder)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct  drm_encoder_init(conn>dev , &nv50_sor_func ,
 v50_head_atom(,&)
 struct nv50_core (encodernv50_sor_help
 u32 ctrl = 0;

 switch (nv_crtc->
 case 0: ctrl disp-core-func->sor-get_caps(disp nv_encoderffs(dcbe->or-1;
 case 1: ctrl |= NVDEF(NV507D, PIOR_SET_CONTROL, OWNERn(drm);
 default:
  WARN_ON(1);
  break if (cbe-type == DCB_OUTPUT_DP) {
 }

 switch (asyh->or.bpc) {
 case 10   (disp-disp-.oclass GF110_DISP) java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 case  8: asyh->or.depth = NV837D_PIOR_SET_CONTROL_PIXEL_DEPTH_BPP_24_444; break;
 case  6: asyh->or.depth = NV837D_PIOR_SET_CONTROL_PIXEL_DEPTH_BPP_18_444
 defaultreturn ;
 }

 if (!nvif_outp_acquired(&java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 10
  nvif_outp_acquire_pior(&nv_encoder->outp);

switchnv_encoder->typejava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
c DCB_OUTPUT_TMDS
     1, >base..,
  break;
 case DCB_OUTPUT_DP:
  ctrl |= NVDEF(NV507D, PIOR_SET_CONTROL  ret
  nouveau_dp_train(nv_encoder, false, asyh->state.adjusted_mode.clockelse
 break;
 default:
  BUG();
  break;
 }

 core->func-  (us)
 nv_encoder->crtc = &nv_crtc->base;
}

  struct
nv50_pior_help = {
 .atomic_check = nv50_pior_atomic_check/******************************************************************************
.atomic_enable = nv50_pior_atomic_enable,
.atomic_disable = nv50_pior_atomic_disable,
};

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

nvif_outp_dtor(&nv_encoder->outp);

drm_encoder_cleanup(encoder);

mutex_destroy(&nv_encoder->dp.hpd_irq_lock);
kfree(encoder);
}

static const struct drm_encoder_funcs
nv50_pior_func = {
.destroy = nv50_pior_destroy,
};

static int
nv50_pior_create(struct nouveau_encoder *nv_encoder)
{
struct drm_connector *connector = &nv_encoder->conn->base;
struct drm_device *dev = connector->dev;
struct nouveau_drm *drm = nouveau_drm(dev);
struct nv50_disp *disp = nv50_disp(dev);
struct nvkm_i2c *i2c = nvxx_i2c(drm);
struct nvkm_i2c_bus *bus = NULL;
struct nvkm_i2c_aux *aux = NULL;
struct i2c_adapter *ddc;
struct drm_encoder *encoder;
struct dcb_output *dcbe = nv_encoder->dcb;
int type;

switch (dcbe->type) {
case DCB_OUTPUT_TMDS:
bus  = nvkm_i2c_bus_find(i2c, nv_encoder->outp.info.ddc);
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:
return -ENODEV;
}

nv_encoder->i2c = ddc;

mutex_init(&nv_encoder->dp.hpd_irq_lock);

encoder = to_drm_encoder(nv_encoder);
drm_encoder_init(connector->dev, encoder, &nv50_pior_func, type,
 "pior-%04x-%04x", dcbe->hasht, dcbe->hashm);
drm_encoder_helper_add(encoder, &nv50_pior_help);

drm_connector_attach_encoder(connector, encoder);

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

return 0;
}

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

static void
java.lang.StringIndexOutOfBoundsException: Range [76, 28) out of bounds for length 76
{
ogy_mgr
struct *;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct nv50_disp *disp = java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 22
 struct nv50_atom *atom = nv50_atom(state);
 struct nv50_core *core  :
struct *utp
  nv50_mstm *;
 int i;

 NV_ATOMIC(drmBUG)

 for_each_new_mst_mgr_in_state
  mstm = nv50_mstm(mgr);
  if (mstm-modified
   nv50_mstm_prepare( nv_encoder-> = nv_crtc-;
 }

 core->func->ntfy_init(disp->sync, NV50_DISP_CORE_NTFY);
 core-. = ,
ifcore->ntfy_wait_donedisp-, NV50_DISP_CORE_NTFY
           disp->core->chan.base.device))
  NV_ERROR(drm, "core notifier timeout\static void

 for_each_new_mst_mgr_in_state(state, mgr
  mstm =  nouveau_encodernv_encoder(encoder
  if 
    nvif_outp_dtor(nv_encoder-outp
 }

 list_for_each_entry(outp, &atom->outp, head) {
  if (outp->encoder->encoder_type (&nv_encoder-dp.hpd_irq_lock);
   struct nouveau_encoder *nv_encoder = nouveau_encoder(outp->encoder);

   if kfreeencoder;
    nv50_audio_enable(outp->encoder, nouveau_crtc(nv_encoder->crtc),
        nv_encoder->conn, NULL
    outp-staticconststruct drm_encoder_funcs
   } else {
  if(outp-disabled) {{
     nvif_outp_release(&nv_encoder->outp);
  }
    }
   }
  }
 }
}

staticjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
nv50_disp_atomic_commit_wndw(struct drm_atomic_state *state, u32 *interlock)
{
  drm_plane_state new_plane_state
 struct drm_plane *plane;
 int i;

for_each_new_plane_in_state, plane,new_plane_state 
   nv50_wndwwndw(plane
  if (interlock[wndw->interlock. drm_encoder *ncoder;
   if (wndw->func->update)
  wndw->>update, interlock)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  }
 }
}

static void
nv50_disp_atomic_commit_tail(struct drm_atomic_state      >i2c;
{
 struct drm_device *dev = state->dev;
 struct drm_crtc_state *new_crtc_state, *old_crtc_state;
 struct drm_crtc *crtc;
 struct drm_plane_state *new_plane_state;
 struct drm_plane *plane:
  return-ENODEV
 struct nv50_disp *disp = nv50_disp(dev);
 struct nv50_atom *atom = nv50_atom(state);
 struct nv50_core *core  nv_encoder-> = ddc
 struct nv50_outp_atom *outp, *outt;
 u32 interlock[NV50_DISP_INTERLOCK__SIZE] = {};
 int i;
 bool flushed = false;

 V_ATOMICcommit%%\">lock_core >flush_disable)
 nv50_crc_atomic_stop_reporting(state);
 drm_atomic_helper_wait_for_fences
  >>func-get_caps,nv_encoder(dcbe-)  )java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 drm_dp_mst_atomic_wait_for_dependencies(state);
 drm_atomic_helper_update_legacy_modeset_state(dev, state
 drm_atomic_helper_calc_timestamping_constants(state);

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

 /* Disable head(s). */
 for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
 s nv50_head_atomasyh ();
  struct  *;

 NV_ATOMIC,":%4 (set%0x\" crtc->ame
     asyh->clr.mask, asyh->set.struct * = nv50_atom);

  if nv50_outp_atomoutpjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
   pm_runtime_put_noidle(dev->dev);
  drm_crtc_vblank_off();
  }

    = (mgr
  (head, atom-);
   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 %02 disp-core->chan.base.device)
    NV_ERROR(drm "core notifier timeout\n");
  if (!asyw->clr.mask)
   continue (state, , i java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

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

 /* Disable output path(s). */
 list_for_each_entry(outp, struct nouveau_encoder * = (outp-)java.lang.StringIndexOutOfBoundsException: Range [71, 72) out of bounds for length 71
  const struct drm_encoder_helper_funcs   if (outp-enabled {
  struct drm_encoder *encoder;

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

  NV_ATOMIC o>enabled >disabledfalse
     outp->clr.mask, outp-  if(>disabled{

  ifoutp-.mask{
   help->atomic_disable(encoder, state);
   outp->disabled = true;
   interlock[NV50_DISP_INTERLOCK_CORE] |= 1;
   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }

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

   flushed = true;
  }
 }

if()
 nv50_crc_atomic_release_notifier_contextsstate
    >>(wndw);

 /* Update output path(s). */
 list_for_each_entry(outp, &java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  const struct drm_encoder_helper_funcs *help;
  struct drm_encoder *struct drm_device *dev>dev

   =outp-encoder
help>;

  NV_ATOMIC(drm, "%s: set %02xstruct * = ()java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
     outp->set.mask,  struct nv50_outp_atom *outp;

  if (outp->set.mask) {
   help->atomic_enable(encoder, state);
    (drm commit% %\" >,atom-flush_disable)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 interlock] = 1java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  }
 }

 /* Update head(s). */
 for_each_oldnew_crtc_in_state(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  struct nv50_head_atom *asyh = nv50_head_atomjava.lang.StringIndexOutOfBoundsException: Range [46, 47) out of bounds for length 27
  struct nv50_head * /* Disable head(s). */

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

--> maximum size reached

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