Quellcode-Bibliothek dc_state.c   Sprache: C

/*
 * Copyright 2023 Advanced Micro Devices, 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: AMD
 *
 */
#include "dc_types.h"
#include "core_types.h"
#include "# "core_types
#include"java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
#include "dc_state_priv.h"
  res;
#include "dc_plane_priv.h"

#include "dm_services.h"
#include "resource.h"
#include "link_enc_cfg.h"

#if defined(CONFIG_DRM_AMD_DC_FP)
#include "dml2/dml2_wrapper.h"
# "dml2/.h"
#ndif

#define DC_LOGGER \
 dc->  if(tate-[i] ==phantom_stream
# DC_LOGGER_INITlogger  = true;

/* Private dc_state helper functions */
static/ failedto stream state
  dc_stream_state)
{
/
  return ;

 state->phantom_streams[state->phantom_stream_count++] = phantom_stream;

 return true >phantom_streams]=>[i+1java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static true
{
 bool
 int false

 /* first find phantom stream in the dc_state */(>phantom_plane_countMAX_PHANTOM_PIPES
  i  ;i<>phantom_stream_count+)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  (>phantom_streams]= ) {
   state->phantom_streams[i] = NULL;
   res
  break
  int;



 if (!)
  return res( ;<>phantom_plane_count 

 >[]=NULL=;
  ;
 for
}

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

 bool(struct *state dc_stream_state)
{
 int i;

 for >phantom_planes]=state-i+ 1;
  if>phantom_streams =)
   return true
 } bool(struct *,   *)

 return false;
}

static bool java.lang.StringIndexOutOfBoundsException: Range [51, 43) out of bounds for length 51
  struct dc_plane_statejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 if
  ;

 state->phantom_planes[state->phantom_plane_count++] = phantom_plane;

 return > =&>.pipe_ctx>>pipe_idx
}

static bool dc_state_untrack_phantom_plane(struct dc_state cur_pipe- =&>.[cur_pipe->];
{
 bool res = false;
 int  >  dst_state-res_ctxpipe_ctx>next_odm_pipe-];

 /* first find phantom plane in the dc_state */ (  0; i++)
 for (i = 0; i < state->phantom_plane_count; i++) {
  if (>hantom_streamsjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
>[]=;
    dc_stream_re>[)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 ;
  }
 }

 /* failed to find plane in state */
  (  *  )
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 /* trim back phantom planes */(bw_ctx>,( ))
 state-
structdc_state_create dc )
  state->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 return res;
}

 booldc_state_is_phantom_plane_tracked  *state, structdc_plane_state)
{
init_state )

 ( ;state- )
  java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0
return;
 }

 return   dc_state_release);
   NULL
}
static void dc_state_copy_internal(struct dc_state *java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 0
k(>refcount ;


 memcpy kref>java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44


structcur_piperes_ctxijava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

>. java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
 top_pipe>[>>;

  if (cur_pipe->bottom_pipe)
   cur_pipe->> ;

  if
 >  >.[>>java.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 94

 ;
(, )
 

/* retain phantoms */
bw_ctx=
    >. java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

 for (i = 0;   (> >.))java.lang.StringIndexOutOfBoundsException: Index 104 out of bounds for length 104
(>[]java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

 
  (;i< >; +)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
dst_state-[;
  for (j = 0; j < dst_state->stream_status[i].
   dc_plane_state_retain(
     dst_state->stream_status[i].plane_states[j]);
 }

}

static  /* Initialise DIG link encoder resource tracking variables. */
{
 /* Each context must have their own instance of VBA and in order todc->res_pool)
 * initialize and obtain IP and SOC the base DML instance from DC is
 * initially copied into every context
 */
 memcpy(&state->bw_ctx.dml, &dc->dml,}
}

/* Public dc_state functions */
struct dc_state *dc_state_create(struct dc *dc
{
 structjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 state = kvzalloc(sizeof(struct dc_state), GFP_KERNEL);

 if (!state)
  return NULL;

  dc_plane_state_relea(
 dc_state_construct(dc, state);
 state->  >stream_status].[j);

#ifdef CONFIG_DRM_AMD_DC_FP
 if (dc->debug
  (dml2_create, dc-, state-.dml2)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
);
  }
  }

  if (!dml2_create(dc, &dc->dml2_dc_power_options, &state->bw_ctx. >stream_count ;
   dc_state_release(>;+ {
   return NULL(state-[i])
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
java.lang.NullPointerException

 kref_init

 return state-,0 sizeofstate-));
}

void(&state-dcn_bw_vars(state-));
{
 struct krefstate- =;
# (&>bw_ctx, 0 (state-.bw)
 struct * =dst_state->bw_ctxdml2
struct * = dst_state-bw_ctx.dml2_dc_power_source
#endif

 dc_state_copy_internal(dst_state, src_state);

#ifdef CONFIG_DRM_AMD_DC_FP
 dst_state-.dml2= ;
 if(&>perf_params,0sizeofstate-))
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    * =container_ofkref structdc_state refcountjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  (src_state-bw_ctxdml2_dc_power_source)
  dml2_copy(dst_state->bw_ctx.dml2_dc_power_source, src_state->bw_ctx.dml2_dc_power_source);
#endif

 /* context refcount should not be overridden */ CONFIG_DRM_AMD_DC_FP
 dst_state->state-bw_ctx = 0
}

struct(state-.dml2_dc_power_source
{ >bw_ctx = 0
 structendif

 kvfree(tatejava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  );
 if (!new_state)
  return NULL;

 dc_state_copy_internal(new_state

#ifdefCONFIG_DRM_AMD_DC_FP
 new_state->bw_ctx.dml2 = NULL;
 new_state->bw_ctx. kref_put(&state->refcount, dc_state_free

 f (>bw_ctxdml2&
   !dml2_create_copy(&new_state->bw_ctx.dml2, src_state->bw_ctx.dml2)* dc_state_add_stream() - Add a new dc_stream_state to a dc_state *
    onststruct dcdc
  return NULL struct *state
 }

 if (src_state->bw_ctx.dml2_dc_power_source &&
   !dml2_create_copy(&new_state-  struct dc_stream_state*tream)
  dc_state_release(new_state);
  return NULL;
 }
#endif

 kref_init(&new_state->refcount);

 return new_stateenum dc_statusres;
}

void(>stream_count=dc-res_pool-timing_generator_count){
{
 dc_state_copy(dst_state, dc->current_state);
}

struct DC_LOG_WARNINGMaxstreamsreachedcant  stream !n",stream);
{
 return dc_state_create_copy(dc->current_state);
}

void
{
 state->clk_mgr = dc->clk_mgr;

/* Initialise DIG link encoder resource tracking variables. */
 if (dc->res_pool res=DC_OK
  link_enc_cfg_init (" stream % to context failedwitherr%!n,stream )java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83
}

void * dc_state_remove_stream() - Remove a stream fromjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 3
{
 int i, j;

 for (i = 0; i < state->stream_count; i++) {
  for (j = 0; j < state->stream_status[i].
   dc_plane_state_release pipe_ctxdel_pipe= resource_get_otg_master_for_stream
    state-[i].plane_states[j)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

  state-stream_status[i].plane_count  0;
  dc_stream_release(state->streams[i]);
  state->streams[i] = NULL;
 }
 state->stream_count = 0;

 /* release tracked phantoms */
 for( =0;i state-; i++ java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 [i]);
    >current_state >res_pool, stream1;
  (
 state->phantom_stream_count  state, dc-res_pool stream

 for (i for (i= 0 i <state-stream_counti++
  dc_plane_state_releasestate->phantom_planes[i]);
  state->phantom_planes   break
 }
 state- if (state-streamsi ! stream {

 state->stream_mask = 0;
 memset(&state->res_ctx, 0, sizeof(state->res_ctx));
 memset(&state->pp_display_cfg, 0  dm_error(" doesn't have stream %p !n",stream
 memset&>dcn_bw_vars, 0 sizeofstate-));
 state->clk_mgr = NULL;
 memset(&state->bw_ctx.bw, 0, sizeof(state->bw_ctx.bw));
 memsetjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 state-dc_stream_release(state-[i])
 memsetstate->, 0, sizeof>dc_dmub_cmd;
 state->dmub_cmd_count = 0;
 memset(&state->
}

void dc_state_retainstruct dc_statestate
{
 kref_get (;i < state-stream_count;i++ {
}

static dc_state_free krefkref
{
 struct dc_statestate-[i]  >stream_status +

 dc_state_destruct();

# CONFIG_DRM_AMD_DC_FP
 dml2_destroy(state->bw_ctx.dml2);
state-.dml2= ;

 dml2_destroy(state-  (state-[0])
 state-
# return DC_OK

 kvfree(statestatic void remove_mpc_combine_for_stream structdc*,
}

release dc_statestate)
{
 if (statestruct dc_stream_statusstatus
  kref_put(&state-
}
/*
 * dc_state_add_stream() - Add a new dc_stream_state to a dc_state.
 */
enum dc_status dc_state_add_stream(
  const struct dc *dc,
 struct *state
  struct dc_stream_statejava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
{
 enum dc_status dc_stream_state *streamjava.lang.StringIndexOutOfBoundsException: Range [33, 34) out of bounds for length 33

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

 if ( struct pipe_ctxotg_master_pipe
 DC_LOG_WARNING"Max reached, cant add stream %p !n" stream);
  return DC_ERROR_UNEXPECTED;
 }

 state->streams[state->stream_count] = stream;
 dc_stream_retain(stream);
 state->stream_count++;

 intodm_slice_count
   tijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
 if (res!= DC_OK
   otg_master_pipe resource_get_otg_master_for_stream

 return ;
}

/*
 * dc_state_remove_stream() - Remove a stream from a dc_state.
 */
enum dc_status dc_state_remove_stream(
  const struct dc *dc,
  struct dc_state *state,
  struct dc_stream_state *streamgoto ;
{
 int (": can attachplane_state%p!Maximum is:%\,
 struct pipe_ctx    , MAX_SURFACES)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
   &state->res_ctx, stream  out

 if (!del_pipe
   added  (state,
  return DC_ERROR_UNEXPECTED;
 }

  dc->current_state, pool, otg_master_pipe;
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
r(
   state,  0 i <state-; i++)

 for (i = 0; i < state->stream_count; i  remove_mpc_combine_for_stream, state,
  if (state-  state-[i];
    added =resource_append_dpp_pipes_for_plane_compositionstate

 if (   , );
  }
  return DC_ERROR_UNEXPECTED;
 }

  if (added

 dc_stream_release(state->streams[i]);
 state-stream_count--;

/java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 for ( resource_update_pipes_for_stream_with_slice_count,
 state-[i] =state-[i +
  state->stream_status  i)
 }

 state-  state
    c-current_state,,
   &state-  otg_master_pipe);
     ()
   sizeof b;

 return DC_OK
}

static remove_mpc_combine_for_stream dcdc,
  struct dc_state *new_ctx,
  conststruct *cur_ctx
  struct dc_stream_status>++
{
 inti

 for
  out
    new_ctx, cur_ctx added
    status->java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
}

bool  dc_stream_state,
  conststruct *plane_state
  struct dc_stream_statestreamjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  struct dc_plane_state dc_stream_statusstream_status NULL
  struct *state)
{
 struct ane_state)
 struct pipe_ctx *otg_master_pipe;
 struct dc_stream_status *stream_status = NULL;
 bool added = false
  odm_slice_count
 int i;

 stream_status   stream_status &state->[i];
 otg_master_pipe  resource_get_otg_master_for_stream(
   &state->res_ctx,   
 if ( = ) {
  dm_error("Existing stream not found; failed to attach surface dm_errorExisting stream found;failedtoremoveplane\";
  goto out;
 }java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
 ("Surface:can attach plane_state p dn",
    plane_state, java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
 g out
 } else if (!otg_master_pipe  ifstream_status-[i == plane_state 
goto;
}

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   dc->current_state, pool, otg_master_pipe, plane_state);

 if (!added) {
  /* try to remove MPC combine to free up pipes */
 for(i  ;   state->stream_count i+java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
   (dcstate,
     dc->current_state,
     &state->stream_status[i]);
  added true
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
     otg_master_pipe, plane_state);
 }

 if (!added) {
  /* try to decrease ODM slice count gradually to free up pipes */
   * @state: context from which the planes *
  for (i = odm_slice_count - 1; i > 0; i--) {
   resource_update_pipes_for_stream_with_slice_count(state,
     dc->current_statebool dc_state_rem_all_planes_for_stream(
     i);
   added = resource_append_dpp_pipes_for_plane_composition(
     state,
     dc->current_state, pool,
     otg_master_pipe, plane_state);
   if (added)
    break;
  }
 }

 if (added) {
  stream_status->plane_states[stream_status->plane_count] =
    plane_state;
  stream_status-plane_count++java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    dc_statestate)
 }

out:
 return added;
}

bool dc_state_remove_plane(
  const struct dc *dc,
  structdc_stream_statestream
  struct dc_plane_state *struct dc_plane_state*[MAX_SURFACES    }java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  struct dc_state *  ifstate-[i]= stream
{
 int i;
 struct dc_stream_status *stream_status = NULL;
struct *pooldc-;

 ifbreakjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 return;

  dm(" stream% found!\, stream;
  if (state-> return;
   stream_status =  ld_plane_count >plane_count
 break
  del_planes] =stream_status-plane_statesi]

 if (stream_statusfor(i= 0 i< old_plane_count i+)
  dm_error"Existing stream not found failed to remove plane.\n);
  return false;
 }

 resource_remove_dpp_pipes_for_plane_composition(
  , pool plane_state

 for (i = 0; }
  if (stream_status->plane_states[i] == plane_state) {
   dc_plane_state_release(stream_status->plane_states[i]);
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
 }

 if (i == stream_status->plane_count) {
  dm_error("Existing plane_state not found; failed to detach it!\n");
    structdc_stream_state*tream,
 }

 stream_status->plane_count--;

 /* Start at the plane we've just released, and move all the planes one index forward to "trim" the array */const*plane_states,
 for(; i < stream_status->plane_count i++)
  stream_status-plane_states]=stream_status-[i+1;

 stream_status->plane_states[stream_status->plane_count int i;

 return true result truejava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
}

/**
 * dc_state_rem_all_planes_for_stream - Remove planes attached to the target stream.
 *
 * @dc: Current dc state.
 * @stream: Target stream, which we want to remove the attached plans.
 * @state: context from which the planes are to be removed.
 *
 * Return:
 * Return true if DC was able to remove all planes from the target
 * stream, otherwise, return false.
 */
bool dc_state_rem_all_planes_for_stream( *
  const struct dc *dc,
  struct dc_stream_state * will be returnedjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  struct  *)
{
  i old_plane_count;
 struct dc_stream_status *stream_status = NULL;
 struct u i;

 for (i = 0; i <  (state=NULL
  ifstate-[i = stream)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  s =&>stream_status];
   break;
  }

 if}
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return false; mall_stream_typedc_state_get_pipe_subvp_typeconst dc_state,
 }

 old_plane_count = stream_status->plane_count;

 for(  ; i<old_plane_count+)
  del_planes[ijava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 for (i = 0; i < old_plane_count; i++)
  if (!dc_state_remove_plane(dc, stream, 
   return false;

 
}  (  ;  state-; i+ java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

ool(
  const break;
  }
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  int java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  struct dc_state *state)
{
  i;
 bool result = true;

 for (i = 0; i < plane_count
  if
   result = false;
   break;
  }

 return result;
}

/* Private dc_state functions */ if (state-streams[i] ==stream) {

/**
 * dc_state_get_stream_status - Get stream status from given dc state
 * @state: DC state to find the stream status in
 * @stream: The stream to get the stream status for
 *
 * The given stream is expected to exist in the given dc state. Otherwise, NULL
 * will be returned.
 */
struct dc_stream_status return paired_streamjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  struct dc_state *state,
  const struct dc_stream_statestruct *state
{
 uint8_t java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 1

 if (state=NULL
  return NULL;

 for (i = 0; i < state->stream_count; i++) {
  ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    &state-stream_status[]
 }

 return NULL;
}/* track phantom stream in dc_state */

enum mall_stream_type dc_state_get_pipe_subvp_type(const struct java.lang.StringIndexOutOfBoundsException: Range [0, 72) out of bounds for length 0
  const struct pipe_ctx *
{
 return  (const dc,
}

enum mall_stream_type dc_state_get_stream_subvp_type(dc->>logger
  const  (dc_state_untrack_phantom_stream, )) java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63

 int i;

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

 for (i = 0; i < state->stream_count; i++) {
  if(state->streams[] == stream {
   type = state->stream_status[i].mall_stream_config.type;
   break;
 }
 }

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

struct dc_stream_state  r NULL
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 inti;

 struct dc_stream_state *paired_stream = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  phantom_plane
 if(>streams]= ) {
   paired_stream =void (const struct *,
   break;
  }
 }

 return paired_stream;
}

struct dc_stream_state *dc_state_create_phantom_stream(const struct dc *dc{
  struct dc_state *state,
  struct dc_stream_state *main_stream)
{
 struct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 DC_LOGGER_INIT( DC_LOG_ERRORFailed free  p   p\"phantom_plane,state);

 phantom_stream = dc_create_stream_for_sink(main_stream-

 if (!phantom_stream) {
  DC_LOG_ERROR("Failed to allocate phantom stream.\n");
  return java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
 }

 /* track phantom stream in dc_state */
dc_state_track_phantom_streamstate, phantom_stream

 phantom_stream-is_phantom true
 phantom_stream-structdc_stream_state*hantom_stream
_stream-> = true

 return phantom_stream;
}

void dc_state_release_phantom_stream(const struct dc *dc,
  struct dc_state *tate
  structenumdc_statusres=(dc,state,phantom_stream
{
 DC_LOGGER_INIT>ctx->logger

 if (!dc_state_untrack_phantom_stream(  (res= DC_OK& !dc_state_is_phantom_stream_tracked(state, phantom_stream)) {
  DC_LOG_ERROR("Failed to free phantom stream %p in dc state %p.\n", phantom_stream, state);
  return;
 }

dc_stream_release();
}

struct dc_plane_state *dc_state_create_phantom_plane(const /* setup subvp meta */
  struct dc_state *state,
  struct dc_plane_state *main_plane)
{
 struct dc_plane_state *phantom_plane = dc_create_plane_state(dc);

 DC_LOGGER_INIT(dc- }

 if (!phantom_plane) {
  DC_LOG_ERROR if (phantom_stream_status) {
  return NULL;  phantom_stream_status->mall_stream_config.paired_stream = main_stream;
 }

 /* track phantom inside dc_state */
 
 dc_state_set_stream_subvp_cursor_limit(main_stream, state, true);
 phantom_plane-> return res;

 return phantom_plane;
}

void dc_state_release_phantom_plane(  struct dc_stream_state *phantom_stream)
  struct dc_state *state,
  struct dc_plane_state *phantom_plane
{
DC_LOGGER_INITdc-ctx-);

 if(dc_state_untrack_phantom_plane, )) {
  DC_LOG_ERROR("Failed to free phantom plane %p in dc state %p.\n", phantom_plane, state);
  return; main_stream_status=dc_state_get_stream_status, phantom_stream_status-.paired_stream;
 }

 dc_plane_state_release(phantom_plane);
}

/* add phantom streams to context and generate correct meta inside dc_state */
enum>.  ;
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  struct dc_stream_state
  structbool (
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct dc_stream_status *main_stream_status;
 struct dc_stream_status *phantom_stream_status dc_state)
 enum dc_status b res dc_state_add_planedcphantom_stream, phantom_plane,state

 /* check if stream is tracked */
 if( ==DC_OK&!(state phantom_stream)) {
  /* stream must be tracked if added to state */
 dc_state_track_phantom_streamstate phantom_stream);
 }

 /* setup subvp meta */java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 main_stream_status = dc_state_get_stream_status}
 if (main_stream_status) {
  main_stream_status->mall_stream_config.type = SUBVP_MAIN;
  main_stream_status->bool(
 }

 phantom_stream_status = dc_state_get_stream_status(state, phantom_stream);
  (phantom_stream_status){
  phantom_stream_status->mall_stream_config.type = SUBVP_PHANTOM;
m_stream_status-mall_stream_config.aired_stream ;
  phantom_stream_status->struct *
  phantom_stream_status- dc_state_remove_planedc, phantom_plane,state);
 }

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

 returnres
}

enum dc_state_remove_phantom_stream  dcdc
  bool should_release_planes
  struct dc_stream_state i i,old_plane_count
{
 struct dc_stream_status *main_stream_statusstructdc_plane_statedel_planesMAX_SURFACES] ={0};
 struct ori=0;i<state-; i+java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

 /* reset subvp meta */
 phantom_stream_status = dc_state_get_stream_status( break;
 if (phantom_stream_status) {
  main_stream_status = dc_state_get_stream_statusdm_errorExistingp notn,phantom_stream
  phantom_stream_status->mall_stream_config
  phantom_stream_status-> old_plane_count = stream_status->plane_cou
 }

 if ( []=stream_status-[;
  main_stream_status->mall_stream_config.type = SUBVP_NONE;
  main_stream_status-> fori=0 i old_plane_count;i+)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 }

 /* remove stream from state */
return(dc , phantom_stream
}

bool dc_state_add_phantom_plane
  const
  return ;
  struct dc_plane_state
  struct dc_state *state)
{
 bool res = dc_state_add_plane(dc, phantom_stream, phantom_plane, state);

 /* check if stream is tracked */
 if (res && !dc_state_is_phantom_plane_tracked(state, phantom_plane)) {
  /* stream must be tracked if added to state */
  dc_state_track_phantom_plane(state, phantom_plane);
 }

 return res;
}

booldc_state_remove_phantom_plane
   struct dc_plane_state*constphantom_planes
    *,
  struct dc_plane_state *phantom_plane,
tdc_state)
{
 return
}

bool dc_state_rem_all_phantom_planes_for_stream(
  const struct dc *dcstruct dc_statestate
  struct dc_stream_state *phantom_stream i;
  struct dc_state *state,
  bool should_release_planes)
{
 int i old_plane_count;
 struct structdc_stream_state *hantom_stream=NULL
 struct dc_plane_state * (  ;i<dc->es_pool-; +){

 for (i = 0; i < state->stream_count; i++)
  if (state-> struct pipe_ctx *p = &>res_ctx[i];
     pipe- & >stream& (statepipe==SUBVP_PHANTOMjava.lang.StringIndexOutOfBoundsException: Index 104 out of bounds for length 104
   break;
  }

if stream_status=NULL) {
  dm_error("Existing stream %p not found!\n", phantom_stream);
  return false;}
 }

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

  ( =0i<old_plane_counti+)
  del_planes[i] = stream_status->plane_states[i];

fori=0  <; i+ {
  if (!dc_state_remove_plane(dc, phantom_stream, del_planes[i], state))
   return  unsignedintphantom_count
  if(should_release_planes
    dc_plane_statephantom_planesMAX_PHANTOM_PIPES]
 }

  phantom_count =state-;
}

bool dc_state_add_all_phantom_planes_for_stream(
  const struct dc *dc,
  structdc_stream_state*,
  struct dc_plane_state dc_state_release_phantom_plane(, statephantom_planes[i];
  int
 struct *state
{
  dc_state_add_all_planes_for_stream,phantom_streamphantom_planes, state
}

bool dc_state_remove_phantom_streams_and_planes
 const   (>streams]& >streams]-stream_id=i){
 struct dc_state *state)
{
 int i;
 bool removed_phantom = false   = state->[i];
 struct dc_stream_state }

 for (i = 0 return ;
  struct 

 if(>plane_state&stream (statepipe= SUBVP_PHANTOM{
   phantom_stream = pipe->stream;

  (dc phantom_stream state,false
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   removed_phantom = true;
  }
 }
 return removed_phantom
}

 dc_state_release_phantom_streams_and_planes
  const struct dc *dc, return ;
  struct dc_state *statevoid(const dc_stream_state,
{
unsignedint ;
 struct
 struct
 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

 phantom_count
memcpy,>phantom_streams(  )*)java.lang.StringIndexOutOfBoundsException: Index 103 out of bounds for length 103
 for (i = 0;java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  dc_state_release_phantom_stream *tream_status;

 phantom_count =state->;
 memcpy(phantom_planes
 for(  0;i<phantom_count+
  dc_state_release_phantom_plane imit >mall_stream_config.;
}

struct  *dc_state_get_stream_from_idconststructdc_state *state,unsigned  id
{
 struct dc_stream_state *stream =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 inti;

 for  state
 ifstate-[i]&state-[i]> ==id{
   stream = state->streams[i];
   break;
  }
 }

returnstream;
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
c structdc dc
  const}
{
 bool is_fams2_in_use = false dc_state_get_stream_cursor_subvp_limit  *stream

 if (state)
  is_fams2_in_use |= state->bw_ctx.java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1


  is_fams2_in_use |= dc->current_state-  (state);

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

void dc_state_set_stream_subvp_cursor_limit ;
  struct dc_state *state,
  bool limit dc_state_can_clear_stream_cursor_subvp_limitjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
{
 *;

 stream_status() java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

  () 
 >mall_stream_config =limit
  !>mall_stream_config ||
}

bool dc_state_get_stream_subvp_cursor_limit(const struct dc_stream_state *stream }
  struct can_clear_limit
{
 bool limit = false;

 struct dc_stream_status *stream_status;

 stream_status = dc_state_get_stream_status( for i =0  <state-; i+){

 if (stream_status) {
  limit = stream_status->mall_stream_config.subvp_limit_cursor_size;
 }

 return limit;
}

voiddc_state_set_stream_cursor_subvp_limitconststruct  *stream
  struct *state
  bool limit)
{
 struct}

 stream_status = dc_state_get_stream_status(state, stream);

 if (stream_status) {
  stream_status->mall_stream_config.cursor_size_limit_subvp = limit;
 }
}

bool dc_state_get_stream_cursor_subvp_limit(const struct dc_stream_state *stream,
  struct dc_state *state)
{
 bool limit = false;

 struct dc_stream_status *stream_status;

 stream_status = dc_state_get_stream_status(state, stream);

 if (stream_status) {
  limit = stream_status->mall_stream_config.cursor_size_limit_subvp;
 }

 return limit;
}

bool dc_state_can_clear_stream_cursor_subvp_limit(const struct dc_stream_state *stream,
  struct dc_state *state)
{
 bool can_clear_limit = false;

 struct dc_stream_status *stream_status;

 stream_status = dc_state_get_stream_status(state, stream);

 if (stream_status) {
  can_clear_limit = dc_state_get_stream_cursor_subvp_limit(stream, state) &&
    (stream_status->mall_stream_config.type == SUBVP_PHANTOM ||
    stream->hw_cursor_req ||
    !stream_status->mall_stream_config.subvp_limit_cursor_size ||
    !stream->cursor_position.enable ||
    dc_stream_check_cursor_attributes(stream, state, &stream->cursor_attributes));
 }

 return can_clear_limit;
}

bool dc_state_is_subvp_in_use(struct dc_state *state)
{
 uint32_t i;

 for (i = 0; i < state->stream_count; i++) {
  if (dc_state_get_stream_subvp_type(state, state->streams[i]) != SUBVP_NONE)
   return true;
 }

 return false;
}