drivers/gpu/drm/amd/display/dc/core/dc_resource.c

   1 /*
   2  * Copyright 2012-15 Advanced Micro Devices, Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20  * OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * Authors: AMD
  23  *
  24  */
  25
  26 #include <linux/slab.h>
  27
  28 #include "dm_services.h"
  29
  30 #include "resource.h"
  31 #include "include/irq_service_interface.h"
  32 #include "link_encoder.h"
  33 #include "stream_encoder.h"
  34 #include "opp.h"
  35 #include "timing_generator.h"
  36 #include "transform.h"
  37 #include "dccg.h"
  38 #include "dchubbub.h"
  39 #include "dpp.h"
  40 #include "core_types.h"
  41 #include "set_mode_types.h"
  42 #include "virtual/virtual_stream_encoder.h"
  43 #include "dpcd_defs.h"
  44 #include "link_enc_cfg.h"
  45 #include "dc_link_dp.h"
  46
  47 #if defined(CONFIG_DRM_AMD_DC_SI)
  48 #include "dce60/dce60_resource.h"
  49 #endif
  50 #include "dce80/dce80_resource.h"
  51 #include "dce100/dce100_resource.h"
  52 #include "dce110/dce110_resource.h"
  53 #include "dce112/dce112_resource.h"
  54 #include "dce120/dce120_resource.h"
  55 #if defined(CONFIG_DRM_AMD_DC_DCN)
  56 #include "dcn10/dcn10_resource.h"
  57 #include "dcn20/dcn20_resource.h"
  58 #include "dcn21/dcn21_resource.h"
  59 #include "dcn201/dcn201_resource.h"
  60 #include "dcn30/dcn30_resource.h"
  61 #include "dcn301/dcn301_resource.h"
  62 #include "dcn302/dcn302_resource.h"
  63 #include "dcn303/dcn303_resource.h"
  64 #include "dcn31/dcn31_resource.h"
  65 #endif
  66
  67 #define DC_LOGGER_INIT(logger)
  68
  69 enum dce_version resource_parse_asic_id(struct hw_asic_id asic_id)
  70 {
  71         enum dce_version dc_version = DCE_VERSION_UNKNOWN;
  72         switch (asic_id.chip_family) {
  73
  74 #if defined(CONFIG_DRM_AMD_DC_SI)
  75         case FAMILY_SI:
  76                 if (ASIC_REV_IS_TAHITI_P(asic_id.hw_internal_rev) ||
  77                     ASIC_REV_IS_PITCAIRN_PM(asic_id.hw_internal_rev) ||
  78                     ASIC_REV_IS_CAPEVERDE_M(asic_id.hw_internal_rev))
  79                         dc_version = DCE_VERSION_6_0;
  80                 else if (ASIC_REV_IS_OLAND_M(asic_id.hw_internal_rev))
  81                         dc_version = DCE_VERSION_6_4;
  82                 else
  83                         dc_version = DCE_VERSION_6_1;
  84                 break;
  85 #endif
  86         case FAMILY_CI:
  87                 dc_version = DCE_VERSION_8_0;
  88                 break;
  89         case FAMILY_KV:
  90                 if (ASIC_REV_IS_KALINDI(asic_id.hw_internal_rev) ||
  91                     ASIC_REV_IS_BHAVANI(asic_id.hw_internal_rev) ||
  92                     ASIC_REV_IS_GODAVARI(asic_id.hw_internal_rev))
  93                         dc_version = DCE_VERSION_8_3;
  94                 else
  95                         dc_version = DCE_VERSION_8_1;
  96                 break;
  97         case FAMILY_CZ:
  98                 dc_version = DCE_VERSION_11_0;
  99                 break;
 100
 101         case FAMILY_VI:
 102                 if (ASIC_REV_IS_TONGA_P(asic_id.hw_internal_rev) ||
 103                                 ASIC_REV_IS_FIJI_P(asic_id.hw_internal_rev)) {
 104                         dc_version = DCE_VERSION_10_0;
 105                         break;
 106                 }
 107                 if (ASIC_REV_IS_POLARIS10_P(asic_id.hw_internal_rev) ||
 108                                 ASIC_REV_IS_POLARIS11_M(asic_id.hw_internal_rev) ||
 109                                 ASIC_REV_IS_POLARIS12_V(asic_id.hw_internal_rev)) {
 110                         dc_version = DCE_VERSION_11_2;
 111                 }
 112                 if (ASIC_REV_IS_VEGAM(asic_id.hw_internal_rev))
 113                         dc_version = DCE_VERSION_11_22;
 114                 break;
 115         case FAMILY_AI:
 116                 if (ASICREV_IS_VEGA20_P(asic_id.hw_internal_rev))
 117                         dc_version = DCE_VERSION_12_1;
 118                 else
 119                         dc_version = DCE_VERSION_12_0;
 120                 break;
 121 #if defined(CONFIG_DRM_AMD_DC_DCN)
 122         case FAMILY_RV:
 123                 dc_version = DCN_VERSION_1_0;
 124                 if (ASICREV_IS_RAVEN2(asic_id.hw_internal_rev))
 125                         dc_version = DCN_VERSION_1_01;
 126                 if (ASICREV_IS_RENOIR(asic_id.hw_internal_rev))
 127                         dc_version = DCN_VERSION_2_1;
 128                 if (ASICREV_IS_GREEN_SARDINE(asic_id.hw_internal_rev))
 129                         dc_version = DCN_VERSION_2_1;
 130                 break;
 131
 132         case FAMILY_NV:
 133                 dc_version = DCN_VERSION_2_0;
 134                 if (asic_id.chip_id == DEVICE_ID_NV_13FE) {
 135                         dc_version = DCN_VERSION_2_01;
 136                         break;
 137                 }
 138                 if (ASICREV_IS_SIENNA_CICHLID_P(asic_id.hw_internal_rev))
 139                         dc_version = DCN_VERSION_3_0;
 140                 if (ASICREV_IS_DIMGREY_CAVEFISH_P(asic_id.hw_internal_rev))
 141                         dc_version = DCN_VERSION_3_02;
 142                 if (ASICREV_IS_BEIGE_GOBY_P(asic_id.hw_internal_rev))
 143                         dc_version = DCN_VERSION_3_03;
 144                 break;
 145
 146         case FAMILY_VGH:
 147                 dc_version = DCN_VERSION_3_01;
 148                 break;
 149
 150         case FAMILY_YELLOW_CARP:
 151                 if (ASICREV_IS_YELLOW_CARP(asic_id.hw_internal_rev))
 152                         dc_version = DCN_VERSION_3_1;
 153                 break;
 154 #endif
 155
 156         default:
 157                 dc_version = DCE_VERSION_UNKNOWN;
 158                 break;
 159         }
 160         return dc_version;
 161 }
 162
 163 struct resource_pool *dc_create_resource_pool(struct dc  *dc,
 164                                               const struct dc_init_data *init_data,
 165                                               enum dce_version dc_version)
 166 {
 167         struct resource_pool *res_pool = NULL;
 168
 169         switch (dc_version) {
 170 #if defined(CONFIG_DRM_AMD_DC_SI)
 171         case DCE_VERSION_6_0:
 172                 res_pool = dce60_create_resource_pool(
 173                         init_data->num_virtual_links, dc);
 174                 break;
 175         case DCE_VERSION_6_1:
 176                 res_pool = dce61_create_resource_pool(
 177                         init_data->num_virtual_links, dc);
 178                 break;
 179         case DCE_VERSION_6_4:
 180                 res_pool = dce64_create_resource_pool(
 181                         init_data->num_virtual_links, dc);
 182                 break;
 183 #endif
 184         case DCE_VERSION_8_0:
 185                 res_pool = dce80_create_resource_pool(
 186                                 init_data->num_virtual_links, dc);
 187                 break;
 188         case DCE_VERSION_8_1:
 189                 res_pool = dce81_create_resource_pool(
 190                                 init_data->num_virtual_links, dc);
 191                 break;
 192         case DCE_VERSION_8_3:
 193                 res_pool = dce83_create_resource_pool(
 194                                 init_data->num_virtual_links, dc);
 195                 break;
 196         case DCE_VERSION_10_0:
 197                 res_pool = dce100_create_resource_pool(
 198                                 init_data->num_virtual_links, dc);
 199                 break;
 200         case DCE_VERSION_11_0:
 201                 res_pool = dce110_create_resource_pool(
 202                                 init_data->num_virtual_links, dc,
 203                                 init_data->asic_id);
 204                 break;
 205         case DCE_VERSION_11_2:
 206         case DCE_VERSION_11_22:
 207                 res_pool = dce112_create_resource_pool(
 208                                 init_data->num_virtual_links, dc);
 209                 break;
 210         case DCE_VERSION_12_0:
 211         case DCE_VERSION_12_1:
 212                 res_pool = dce120_create_resource_pool(
 213                                 init_data->num_virtual_links, dc);
 214                 break;
 215
 216 #if defined(CONFIG_DRM_AMD_DC_DCN)
 217         case DCN_VERSION_1_0:
 218         case DCN_VERSION_1_01:
 219                 res_pool = dcn10_create_resource_pool(init_data, dc);
 220                 break;
 221         case DCN_VERSION_2_0:
 222                 res_pool = dcn20_create_resource_pool(init_data, dc);
 223                 break;
 224         case DCN_VERSION_2_1:
 225                 res_pool = dcn21_create_resource_pool(init_data, dc);
 226                 break;
 227         case DCN_VERSION_2_01:
 228                 res_pool = dcn201_create_resource_pool(init_data, dc);
 229                 break;
 230         case DCN_VERSION_3_0:
 231                 res_pool = dcn30_create_resource_pool(init_data, dc);
 232                 break;
 233         case DCN_VERSION_3_01:
 234                 res_pool = dcn301_create_resource_pool(init_data, dc);
 235                 break;
 236         case DCN_VERSION_3_02:
 237                 res_pool = dcn302_create_resource_pool(init_data, dc);
 238                 break;
 239         case DCN_VERSION_3_03:
 240                 res_pool = dcn303_create_resource_pool(init_data, dc);
 241                 break;
 242         case DCN_VERSION_3_1:
 243                 res_pool = dcn31_create_resource_pool(init_data, dc);
 244                 break;
 245 #endif
 246         default:
 247                 break;
 248         }
 249
 250         if (res_pool != NULL) {
 251                 if (dc->ctx->dc_bios->fw_info_valid) {
 252                         res_pool->ref_clocks.xtalin_clock_inKhz =
 253                                 dc->ctx->dc_bios->fw_info.pll_info.crystal_frequency;
 254                         /* initialize with firmware data first, no all
 255                          * ASIC have DCCG SW component. FPGA or
 256                          * simulation need initialization of
 257                          * dccg_ref_clock_inKhz, dchub_ref_clock_inKhz
 258                          * with xtalin_clock_inKhz
 259                          */
 260                         res_pool->ref_clocks.dccg_ref_clock_inKhz =
 261                                 res_pool->ref_clocks.xtalin_clock_inKhz;
 262                         res_pool->ref_clocks.dchub_ref_clock_inKhz =
 263                                 res_pool->ref_clocks.xtalin_clock_inKhz;
 264                 } else
 265                         ASSERT_CRITICAL(false);
 266         }
 267
 268         return res_pool;
 269 }
 270
 271 void dc_destroy_resource_pool(struct dc  *dc)
 272 {
 273         if (dc) {
 274                 if (dc->res_pool)
 275                         dc->res_pool->funcs->destroy(&dc->res_pool);
 276
 277                 kfree(dc->hwseq);
 278         }
 279 }
 280
 281 static void update_num_audio(
 282         const struct resource_straps *straps,
 283         unsigned int *num_audio,
 284         struct audio_support *aud_support)
 285 {
 286         aud_support->dp_audio = true;
 287         aud_support->hdmi_audio_native = false;
 288         aud_support->hdmi_audio_on_dongle = false;
 289
 290         if (straps->hdmi_disable == 0) {
 291                 if (straps->dc_pinstraps_audio & 0x2) {
 292                         aud_support->hdmi_audio_on_dongle = true;
 293                         aud_support->hdmi_audio_native = true;
 294                 }
 295         }
 296
 297         switch (straps->audio_stream_number) {
 298         case 0: /* multi streams supported */
 299                 break;
 300         case 1: /* multi streams not supported */
 301                 *num_audio = 1;
 302                 break;
 303         default:
 304                 DC_ERR("DC: unexpected audio fuse!\n");
 305         }
 306 }
 307
 308 bool resource_construct(
 309         unsigned int num_virtual_links,
 310         struct dc  *dc,
 311         struct resource_pool *pool,
 312         const struct resource_create_funcs *create_funcs)
 313 {
 314         struct dc_context *ctx = dc->ctx;
 315         const struct resource_caps *caps = pool->res_cap;
 316         int i;
 317         unsigned int num_audio = caps->num_audio;
 318         struct resource_straps straps = {0};
 319
 320         if (create_funcs->read_dce_straps)
 321                 create_funcs->read_dce_straps(dc->ctx, &straps);
 322
 323         pool->audio_count = 0;
 324         if (create_funcs->create_audio) {
 325                 /* find the total number of streams available via the
 326                  * AZALIA_F0_CODEC_PIN_CONTROL_RESPONSE_CONFIGURATION_DEFAULT
 327                  * registers (one for each pin) starting from pin 1
 328                  * up to the max number of audio pins.
 329                  * We stop on the first pin where
 330                  * PORT_CONNECTIVITY == 1 (as instructed by HW team).
 331                  */
 332                 update_num_audio(&straps, &num_audio, &pool->audio_support);
 333                 for (i = 0; i < caps->num_audio; i++) {
 334                         struct audio *aud = create_funcs->create_audio(ctx, i);
 335
 336                         if (aud == NULL) {
 337                                 DC_ERR("DC: failed to create audio!\n");
 338                                 return false;
 339                         }
 340                         if (!aud->funcs->endpoint_valid(aud)) {
 341                                 aud->funcs->destroy(&aud);
 342                                 break;
 343                         }
 344                         pool->audios[i] = aud;
 345                         pool->audio_count++;
 346                 }
 347         }
 348
 349         pool->stream_enc_count = 0;
 350         if (create_funcs->create_stream_encoder) {
 351                 for (i = 0; i < caps->num_stream_encoder; i++) {
 352                         pool->stream_enc[i] = create_funcs->create_stream_encoder(i, ctx);
 353                         if (pool->stream_enc[i] == NULL)
 354                                 DC_ERR("DC: failed to create stream_encoder!\n");
 355                         pool->stream_enc_count++;
 356                 }
 357         }
 358
 359 #if defined(CONFIG_DRM_AMD_DC_DCN)
 360         pool->hpo_dp_stream_enc_count = 0;
 361         if (create_funcs->create_hpo_dp_stream_encoder) {
 362                 for (i = 0; i < caps->num_hpo_dp_stream_encoder; i++) {
 363                         pool->hpo_dp_stream_enc[i] = create_funcs->create_hpo_dp_stream_encoder(i+ENGINE_ID_HPO_DP_0, ctx);
 364                         if (pool->hpo_dp_stream_enc[i] == NULL)
 365                                 DC_ERR("DC: failed to create HPO DP stream encoder!\n");
 366                         pool->hpo_dp_stream_enc_count++;
 367
 368                 }
 369         }
 370
 371         pool->hpo_dp_link_enc_count = 0;
 372         if (create_funcs->create_hpo_dp_link_encoder) {
 373                 for (i = 0; i < caps->num_hpo_dp_link_encoder; i++) {
 374                         pool->hpo_dp_link_enc[i] = create_funcs->create_hpo_dp_link_encoder(i, ctx);
 375                         if (pool->hpo_dp_link_enc[i] == NULL)
 376                                 DC_ERR("DC: failed to create HPO DP link encoder!\n");
 377                         pool->hpo_dp_link_enc_count++;
 378                 }
 379         }
 380 #endif
 381
 382 #if defined(CONFIG_DRM_AMD_DC_DCN)
 383         for (i = 0; i < caps->num_mpc_3dlut; i++) {
 384                 pool->mpc_lut[i] = dc_create_3dlut_func();
 385                 if (pool->mpc_lut[i] == NULL)
 386                         DC_ERR("DC: failed to create MPC 3dlut!\n");
 387                 pool->mpc_shaper[i] = dc_create_transfer_func();
 388                 if (pool->mpc_shaper[i] == NULL)
 389                         DC_ERR("DC: failed to create MPC shaper!\n");
 390         }
 391 #endif
 392         dc->caps.dynamic_audio = false;
 393         if (pool->audio_count < pool->stream_enc_count) {
 394                 dc->caps.dynamic_audio = true;
 395         }
 396         for (i = 0; i < num_virtual_links; i++) {
 397                 pool->stream_enc[pool->stream_enc_count] =
 398                         virtual_stream_encoder_create(
 399                                         ctx, ctx->dc_bios);
 400                 if (pool->stream_enc[pool->stream_enc_count] == NULL) {
 401                         DC_ERR("DC: failed to create stream_encoder!\n");
 402                         return false;
 403                 }
 404                 pool->stream_enc_count++;
 405         }
 406
 407         dc->hwseq = create_funcs->create_hwseq(ctx);
 408
 409         return true;
 410 }
 411 static int find_matching_clock_source(
 412                 const struct resource_pool *pool,
 413                 struct clock_source *clock_source)
 414 {
 415
 416         int i;
 417
 418         for (i = 0; i < pool->clk_src_count; i++) {
 419                 if (pool->clock_sources[i] == clock_source)
 420                         return i;
 421         }
 422         return -1;
 423 }
 424
 425 void resource_unreference_clock_source(
 426                 struct resource_context *res_ctx,
 427                 const struct resource_pool *pool,
 428                 struct clock_source *clock_source)
 429 {
 430         int i = find_matching_clock_source(pool, clock_source);
 431
 432         if (i > -1)
 433                 res_ctx->clock_source_ref_count[i]--;
 434
 435         if (pool->dp_clock_source == clock_source)
 436                 res_ctx->dp_clock_source_ref_count--;
 437 }
 438
 439 void resource_reference_clock_source(
 440                 struct resource_context *res_ctx,
 441                 const struct resource_pool *pool,
 442                 struct clock_source *clock_source)
 443 {
 444         int i = find_matching_clock_source(pool, clock_source);
 445
 446         if (i > -1)
 447                 res_ctx->clock_source_ref_count[i]++;
 448
 449         if (pool->dp_clock_source == clock_source)
 450                 res_ctx->dp_clock_source_ref_count++;
 451 }
 452
 453 int resource_get_clock_source_reference(
 454                 struct resource_context *res_ctx,
 455                 const struct resource_pool *pool,
 456                 struct clock_source *clock_source)
 457 {
 458         int i = find_matching_clock_source(pool, clock_source);
 459
 460         if (i > -1)
 461                 return res_ctx->clock_source_ref_count[i];
 462
 463         if (pool->dp_clock_source == clock_source)
 464                 return res_ctx->dp_clock_source_ref_count;
 465
 466         return -1;
 467 }
 468
 469 bool resource_are_vblanks_synchronizable(
 470         struct dc_stream_state *stream1,
 471         struct dc_stream_state *stream2)
 472 {
 473         uint32_t base60_refresh_rates[] = {10, 20, 5};
 474         uint8_t i;
 475         uint8_t rr_count = ARRAY_SIZE(base60_refresh_rates);
 476         uint64_t frame_time_diff;
 477
 478         if (stream1->ctx->dc->config.vblank_alignment_dto_params &&
 479                 stream1->ctx->dc->config.vblank_alignment_max_frame_time_diff > 0 &&
 480                 dc_is_dp_signal(stream1->signal) &&
 481                 dc_is_dp_signal(stream2->signal) &&
 482                 false == stream1->has_non_synchronizable_pclk &&
 483                 false == stream2->has_non_synchronizable_pclk &&
 484                 stream1->timing.flags.VBLANK_SYNCHRONIZABLE &&
 485                 stream2->timing.flags.VBLANK_SYNCHRONIZABLE) {
 486                 /* disable refresh rates higher than 60Hz for now */
 487                 if (stream1->timing.pix_clk_100hz*100/stream1->timing.h_total/
 488                                 stream1->timing.v_total > 60)
 489                         return false;
 490                 if (stream2->timing.pix_clk_100hz*100/stream2->timing.h_total/
 491                                 stream2->timing.v_total > 60)
 492                         return false;
 493                 frame_time_diff = (uint64_t)10000 *
 494                         stream1->timing.h_total *
 495                         stream1->timing.v_total *
 496                         stream2->timing.pix_clk_100hz;
 497                 frame_time_diff = div_u64(frame_time_diff, stream1->timing.pix_clk_100hz);
 498                 frame_time_diff = div_u64(frame_time_diff, stream2->timing.h_total);
 499                 frame_time_diff = div_u64(frame_time_diff, stream2->timing.v_total);
 500                 for (i = 0; i < rr_count; i++) {
 501                         int64_t diff = (int64_t)div_u64(frame_time_diff * base60_refresh_rates[i], 10) - 10000;
 502
 503                         if (diff < 0)
 504                                 diff = -diff;
 505                         if (diff < stream1->ctx->dc->config.vblank_alignment_max_frame_time_diff)
 506                                 return true;
 507                 }
 508         }
 509         return false;
 510 }
 511
 512 bool resource_are_streams_timing_synchronizable(
 513         struct dc_stream_state *stream1,
 514         struct dc_stream_state *stream2)
 515 {
 516         if (stream1->timing.h_total != stream2->timing.h_total)
 517                 return false;
 518
 519         if (stream1->timing.v_total != stream2->timing.v_total)
 520                 return false;
 521
 522         if (stream1->timing.h_addressable
 523                                 != stream2->timing.h_addressable)
 524                 return false;
 525
 526         if (stream1->timing.v_addressable
 527                                 != stream2->timing.v_addressable)
 528                 return false;
 529
 530         if (stream1->timing.v_front_porch
 531                                 != stream2->timing.v_front_porch)
 532                 return false;
 533
 534         if (stream1->timing.pix_clk_100hz
 535                                 != stream2->timing.pix_clk_100hz)
 536                 return false;
 537
 538         if (stream1->clamping.c_depth != stream2->clamping.c_depth)
 539                 return false;
 540
 541         if (stream1->phy_pix_clk != stream2->phy_pix_clk
 542                         && (!dc_is_dp_signal(stream1->signal)
 543                         || !dc_is_dp_signal(stream2->signal)))
 544                 return false;
 545
 546         if (stream1->view_format != stream2->view_format)
 547                 return false;
 548
 549         if (stream1->ignore_msa_timing_param || stream2->ignore_msa_timing_param)
 550                 return false;
 551
 552         return true;
 553 }
 554 static bool is_dp_and_hdmi_sharable(
 555                 struct dc_stream_state *stream1,
 556                 struct dc_stream_state *stream2)
 557 {
 558         if (stream1->ctx->dc->caps.disable_dp_clk_share)
 559                 return false;
 560
 561         if (stream1->clamping.c_depth != COLOR_DEPTH_888 ||
 562                 stream2->clamping.c_depth != COLOR_DEPTH_888)
 563                 return false;
 564
 565         return true;
 566
 567 }
 568
 569 static bool is_sharable_clk_src(
 570         const struct pipe_ctx *pipe_with_clk_src,
 571         const struct pipe_ctx *pipe)
 572 {
 573         if (pipe_with_clk_src->clock_source == NULL)
 574                 return false;
 575
 576         if (pipe_with_clk_src->stream->signal == SIGNAL_TYPE_VIRTUAL)
 577                 return false;
 578
 579         if (dc_is_dp_signal(pipe_with_clk_src->stream->signal) ||
 580                 (dc_is_dp_signal(pipe->stream->signal) &&
 581                 !is_dp_and_hdmi_sharable(pipe_with_clk_src->stream,
 582                                      pipe->stream)))
 583                 return false;
 584
 585         if (dc_is_hdmi_signal(pipe_with_clk_src->stream->signal)
 586                         && dc_is_dual_link_signal(pipe->stream->signal))
 587                 return false;
 588
 589         if (dc_is_hdmi_signal(pipe->stream->signal)
 590                         && dc_is_dual_link_signal(pipe_with_clk_src->stream->signal))
 591                 return false;
 592
 593         if (!resource_are_streams_timing_synchronizable(
 594                         pipe_with_clk_src->stream, pipe->stream))
 595                 return false;
 596
 597         return true;
 598 }
 599
 600 struct clock_source *resource_find_used_clk_src_for_sharing(
 601                                         struct resource_context *res_ctx,
 602                                         struct pipe_ctx *pipe_ctx)
 603 {
 604         int i;
 605
 606         for (i = 0; i < MAX_PIPES; i++) {
 607                 if (is_sharable_clk_src(&res_ctx->pipe_ctx[i], pipe_ctx))
 608                         return res_ctx->pipe_ctx[i].clock_source;
 609         }
 610
 611         return NULL;
 612 }
 613
 614 static enum pixel_format convert_pixel_format_to_dalsurface(
 615                 enum surface_pixel_format surface_pixel_format)
 616 {
 617         enum pixel_format dal_pixel_format = PIXEL_FORMAT_UNKNOWN;
 618
 619         switch (surface_pixel_format) {
 620         case SURFACE_PIXEL_FORMAT_GRPH_PALETA_256_COLORS:
 621                 dal_pixel_format = PIXEL_FORMAT_INDEX8;
 622                 break;
 623         case SURFACE_PIXEL_FORMAT_GRPH_ARGB1555:
 624                 dal_pixel_format = PIXEL_FORMAT_RGB565;
 625                 break;
 626         case SURFACE_PIXEL_FORMAT_GRPH_RGB565:
 627                 dal_pixel_format = PIXEL_FORMAT_RGB565;
 628                 break;
 629         case SURFACE_PIXEL_FORMAT_GRPH_ARGB8888:
 630                 dal_pixel_format = PIXEL_FORMAT_ARGB8888;
 631                 break;
 632         case SURFACE_PIXEL_FORMAT_GRPH_ABGR8888:
 633                 dal_pixel_format = PIXEL_FORMAT_ARGB8888;
 634                 break;
 635         case SURFACE_PIXEL_FORMAT_GRPH_ARGB2101010:
 636                 dal_pixel_format = PIXEL_FORMAT_ARGB2101010;
 637                 break;
 638         case SURFACE_PIXEL_FORMAT_GRPH_ABGR2101010:
 639                 dal_pixel_format = PIXEL_FORMAT_ARGB2101010;
 640                 break;
 641         case SURFACE_PIXEL_FORMAT_GRPH_ABGR2101010_XR_BIAS:
 642                 dal_pixel_format = PIXEL_FORMAT_ARGB2101010_XRBIAS;
 643                 break;
 644         case SURFACE_PIXEL_FORMAT_GRPH_ABGR16161616F:
 645         case SURFACE_PIXEL_FORMAT_GRPH_ARGB16161616F:
 646                 dal_pixel_format = PIXEL_FORMAT_FP16;
 647                 break;
 648         case SURFACE_PIXEL_FORMAT_VIDEO_420_YCbCr:
 649         case SURFACE_PIXEL_FORMAT_VIDEO_420_YCrCb:
 650                 dal_pixel_format = PIXEL_FORMAT_420BPP8;
 651                 break;
 652         case SURFACE_PIXEL_FORMAT_VIDEO_420_10bpc_YCbCr:
 653         case SURFACE_PIXEL_FORMAT_VIDEO_420_10bpc_YCrCb:
 654                 dal_pixel_format = PIXEL_FORMAT_420BPP10;
 655                 break;
 656         case SURFACE_PIXEL_FORMAT_GRPH_ARGB16161616:
 657         case SURFACE_PIXEL_FORMAT_GRPH_ABGR16161616:
 658         default:
 659                 dal_pixel_format = PIXEL_FORMAT_UNKNOWN;
 660                 break;
 661         }
 662         return dal_pixel_format;
 663 }
 664
 665 static inline void get_vp_scan_direction(
 666         enum dc_rotation_angle rotation,
 667         bool horizontal_mirror,
 668         bool *orthogonal_rotation,
 669         bool *flip_vert_scan_dir,
 670         bool *flip_horz_scan_dir)
 671 {
 672         *orthogonal_rotation = false;
 673         *flip_vert_scan_dir = false;
 674         *flip_horz_scan_dir = false;
 675         if (rotation == ROTATION_ANGLE_180) {
 676                 *flip_vert_scan_dir = true;
 677                 *flip_horz_scan_dir = true;
 678         } else if (rotation == ROTATION_ANGLE_90) {
 679                 *orthogonal_rotation = true;
 680                 *flip_horz_scan_dir = true;
 681         } else if (rotation == ROTATION_ANGLE_270) {
 682                 *orthogonal_rotation = true;
 683                 *flip_vert_scan_dir = true;
 684         }
 685
 686         if (horizontal_mirror)
 687                 *flip_horz_scan_dir = !*flip_horz_scan_dir;
 688 }
 689
 690 int get_num_mpc_splits(struct pipe_ctx *pipe)
 691 {
 692         int mpc_split_count = 0;
 693         struct pipe_ctx *other_pipe = pipe->bottom_pipe;
 694
 695         while (other_pipe && other_pipe->plane_state == pipe->plane_state) {
 696                 mpc_split_count++;
 697                 other_pipe = other_pipe->bottom_pipe;
 698         }
 699         other_pipe = pipe->top_pipe;
 700         while (other_pipe && other_pipe->plane_state == pipe->plane_state) {
 701                 mpc_split_count++;
 702                 other_pipe = other_pipe->top_pipe;
 703         }
 704
 705         return mpc_split_count;
 706 }
 707
 708 int get_num_odm_splits(struct pipe_ctx *pipe)
 709 {
 710         int odm_split_count = 0;
 711         struct pipe_ctx *next_pipe = pipe->next_odm_pipe;
 712         while (next_pipe) {
 713                 odm_split_count++;
 714                 next_pipe = next_pipe->next_odm_pipe;
 715         }
 716         pipe = pipe->prev_odm_pipe;
 717         while (pipe) {
 718                 odm_split_count++;
 719                 pipe = pipe->prev_odm_pipe;
 720         }
 721         return odm_split_count;
 722 }
 723
 724 static void calculate_split_count_and_index(struct pipe_ctx *pipe_ctx, int *split_count, int *split_idx)
 725 {
 726         *split_count = get_num_odm_splits(pipe_ctx);
 727         *split_idx = 0;
 728         if (*split_count == 0) {
 729                 /*Check for mpc split*/
 730                 struct pipe_ctx *split_pipe = pipe_ctx->top_pipe;
 731
 732                 *split_count = get_num_mpc_splits(pipe_ctx);
 733                 while (split_pipe && split_pipe->plane_state == pipe_ctx->plane_state) {
 734                         (*split_idx)++;
 735                         split_pipe = split_pipe->top_pipe;
 736                 }
 737         } else {
 738                 /*Get odm split index*/
 739                 struct pipe_ctx *split_pipe = pipe_ctx->prev_odm_pipe;
 740
 741                 while (split_pipe) {
 742                         (*split_idx)++;
 743                         split_pipe = split_pipe->prev_odm_pipe;
 744                 }
 745         }
 746 }
 747
 748 /*
 749  * This is a preliminary vp size calculation to allow us to check taps support.
 750  * The result is completely overridden afterwards.
 751  */
 752 static void calculate_viewport_size(struct pipe_ctx *pipe_ctx)
 753 {
 754         struct scaler_data *data = &pipe_ctx->plane_res.scl_data;
 755
 756         data->viewport.width = dc_fixpt_ceil(dc_fixpt_mul_int(data->ratios.horz, data->recout.width));
 757         data->viewport.height = dc_fixpt_ceil(dc_fixpt_mul_int(data->ratios.vert, data->recout.height));
 758         data->viewport_c.width = dc_fixpt_ceil(dc_fixpt_mul_int(data->ratios.horz_c, data->recout.width));
 759         data->viewport_c.height = dc_fixpt_ceil(dc_fixpt_mul_int(data->ratios.vert_c, data->recout.height));
 760         if (pipe_ctx->plane_state->rotation == ROTATION_ANGLE_90 ||
 761                         pipe_ctx->plane_state->rotation == ROTATION_ANGLE_270) {
 762                 swap(data->viewport.width, data->viewport.height);
 763                 swap(data->viewport_c.width, data->viewport_c.height);
 764         }
 765 }
 766
 767 static void calculate_recout(struct pipe_ctx *pipe_ctx)
 768 {
 769         const struct dc_plane_state *plane_state = pipe_ctx->plane_state;
 770         const struct dc_stream_state *stream = pipe_ctx->stream;
 771         struct scaler_data *data = &pipe_ctx->plane_res.scl_data;
 772         struct rect surf_clip = plane_state->clip_rect;
 773         bool split_tb = stream->view_format == VIEW_3D_FORMAT_TOP_AND_BOTTOM;
 774         int split_count, split_idx;
 775
 776         calculate_split_count_and_index(pipe_ctx, &split_count, &split_idx);
 777         if (stream->view_format == VIEW_3D_FORMAT_SIDE_BY_SIDE)
 778                 split_idx = 0;
 779
 780         /*
 781          * Only the leftmost ODM pipe should be offset by a nonzero distance
 782          */
 783         if (!pipe_ctx->prev_odm_pipe || split_idx == split_count) {
 784                 data->recout.x = stream->dst.x;
 785                 if (stream->src.x < surf_clip.x)
 786                         data->recout.x += (surf_clip.x - stream->src.x) * stream->dst.width
 787                                                 / stream->src.width;
 788         } else
 789                 data->recout.x = 0;
 790
 791         if (stream->src.x > surf_clip.x)
 792                 surf_clip.width -= stream->src.x - surf_clip.x;
 793         data->recout.width = surf_clip.width * stream->dst.width / stream->src.width;
 794         if (data->recout.width + data->recout.x > stream->dst.x + stream->dst.width)
 795                 data->recout.width = stream->dst.x + stream->dst.width - data->recout.x;
 796
 797         data->recout.y = stream->dst.y;
 798         if (stream->src.y < surf_clip.y)
 799                 data->recout.y += (surf_clip.y - stream->src.y) * stream->dst.height
 800                                                 / stream->src.height;
 801         else if (stream->src.y > surf_clip.y)
 802                 surf_clip.height -= stream->src.y - surf_clip.y;
 803
 804         data->recout.height = surf_clip.height * stream->dst.height / stream->src.height;
 805         if (data->recout.height + data->recout.y > stream->dst.y + stream->dst.height)
 806                 data->recout.height = stream->dst.y + stream->dst.height - data->recout.y;
 807
 808         /* Handle h & v split */
 809         if (split_tb) {
 810                 ASSERT(data->recout.height % 2 == 0);
 811                 data->recout.height /= 2;
 812         } else if (split_count) {
 813                 if (!pipe_ctx->next_odm_pipe && !pipe_ctx->prev_odm_pipe) {
 814                         /* extra pixels in the division remainder need to go to pipes after
 815                          * the extra pixel index minus one(epimo) defined here as:
 816                          */
 817                         int epimo = split_count - data->recout.width % (split_count + 1);
 818
 819                         data->recout.x += (data->recout.width / (split_count + 1)) * split_idx;
 820                         if (split_idx > epimo)
 821                                 data->recout.x += split_idx - epimo - 1;
 822                         ASSERT(stream->view_format != VIEW_3D_FORMAT_SIDE_BY_SIDE || data->recout.width % 2 == 0);
 823                         data->recout.width = data->recout.width / (split_count + 1) + (split_idx > epimo ? 1 : 0);
 824                 } else {
 825                         /* odm */
 826                         if (split_idx == split_count) {
 827                                 /* rightmost pipe is the remainder recout */
 828                                 data->recout.width -= data->h_active * split_count - data->recout.x;
 829
 830                                 /* ODM combine cases with MPO we can get negative widths */
 831                                 if (data->recout.width < 0)
 832                                         data->recout.width = 0;
 833
 834                                 data->recout.x = 0;
 835                         } else
 836                                 data->recout.width = data->h_active - data->recout.x;
 837                 }
 838         }
 839 }
 840
 841 static void calculate_scaling_ratios(struct pipe_ctx *pipe_ctx)
 842 {
 843         const struct dc_plane_state *plane_state = pipe_ctx->plane_state;
 844         const struct dc_stream_state *stream = pipe_ctx->stream;
 845         struct rect surf_src = plane_state->src_rect;
 846         const int in_w = stream->src.width;
 847         const int in_h = stream->src.height;
 848         const int out_w = stream->dst.width;
 849         const int out_h = stream->dst.height;
 850
 851         /*Swap surf_src height and width since scaling ratios are in recout rotation*/
 852         if (pipe_ctx->plane_state->rotation == ROTATION_ANGLE_90 ||
 853                         pipe_ctx->plane_state->rotation == ROTATION_ANGLE_270)
 854                 swap(surf_src.height, surf_src.width);
 855
 856         pipe_ctx->plane_res.scl_data.ratios.horz = dc_fixpt_from_fraction(
 857                                         surf_src.width,
 858                                         plane_state->dst_rect.width);
 859         pipe_ctx->plane_res.scl_data.ratios.vert = dc_fixpt_from_fraction(
 860                                         surf_src.height,
 861                                         plane_state->dst_rect.height);
 862
 863         if (stream->view_format == VIEW_3D_FORMAT_SIDE_BY_SIDE)
 864                 pipe_ctx->plane_res.scl_data.ratios.horz.value *= 2;
 865         else if (stream->view_format == VIEW_3D_FORMAT_TOP_AND_BOTTOM)
 866                 pipe_ctx->plane_res.scl_data.ratios.vert.value *= 2;
 867
 868         pipe_ctx->plane_res.scl_data.ratios.vert.value = div64_s64(
 869                 pipe_ctx->plane_res.scl_data.ratios.vert.value * in_h, out_h);
 870         pipe_ctx->plane_res.scl_data.ratios.horz.value = div64_s64(
 871                 pipe_ctx->plane_res.scl_data.ratios.horz.value * in_w, out_w);
 872
 873         pipe_ctx->plane_res.scl_data.ratios.horz_c = pipe_ctx->plane_res.scl_data.ratios.horz;
 874         pipe_ctx->plane_res.scl_data.ratios.vert_c = pipe_ctx->plane_res.scl_data.ratios.vert;
 875
 876         if (pipe_ctx->plane_res.scl_data.format == PIXEL_FORMAT_420BPP8
 877                         || pipe_ctx->plane_res.scl_data.format == PIXEL_FORMAT_420BPP10) {
 878                 pipe_ctx->plane_res.scl_data.ratios.horz_c.value /= 2;
 879                 pipe_ctx->plane_res.scl_data.ratios.vert_c.value /= 2;
 880         }
 881         pipe_ctx->plane_res.scl_data.ratios.horz = dc_fixpt_truncate(
 882                         pipe_ctx->plane_res.scl_data.ratios.horz, 19);
 883         pipe_ctx->plane_res.scl_data.ratios.vert = dc_fixpt_truncate(
 884                         pipe_ctx->plane_res.scl_data.ratios.vert, 19);
 885         pipe_ctx->plane_res.scl_data.ratios.horz_c = dc_fixpt_truncate(
 886                         pipe_ctx->plane_res.scl_data.ratios.horz_c, 19);
 887         pipe_ctx->plane_res.scl_data.ratios.vert_c = dc_fixpt_truncate(
 888                         pipe_ctx->plane_res.scl_data.ratios.vert_c, 19);
 889 }
 890
 891
 892 /*
 893  * We completely calculate vp offset, size and inits here based entirely on scaling
 894  * ratios and recout for pixel perfect pipe combine.
 895  */
 896 static void calculate_init_and_vp(
 897                 bool flip_scan_dir,
 898                 int recout_offset_within_recout_full,
 899                 int recout_size,
 900                 int src_size,
 901                 int taps,
 902                 struct fixed31_32 ratio,
 903                 struct fixed31_32 *init,
 904                 int *vp_offset,
 905                 int *vp_size)
 906 {
 907         struct fixed31_32 temp;
 908         int int_part;
 909
 910         /*
 911          * First of the taps starts sampling pixel number <init_int_part> corresponding to recout
 912          * pixel 1. Next recout pixel samples int part of <init + scaling ratio> and so on.
 913          * All following calculations are based on this logic.
 914          *
 915          * Init calculated according to formula:
 916          *      init = (scaling_ratio + number_of_taps + 1) / 2
 917          *      init_bot = init + scaling_ratio
 918          *      to get pixel perfect combine add the fraction from calculating vp offset
 919          */
 920         temp = dc_fixpt_mul_int(ratio, recout_offset_within_recout_full);
 921         *vp_offset = dc_fixpt_floor(temp);
 922         temp.value &= 0xffffffff;
 923         *init = dc_fixpt_truncate(dc_fixpt_add(dc_fixpt_div_int(
 924                         dc_fixpt_add_int(ratio, taps + 1), 2), temp), 19);
 925         /*
 926          * If viewport has non 0 offset and there are more taps than covered by init then
 927          * we should decrease the offset and increase init so we are never sampling
 928          * outside of viewport.
 929          */
 930         int_part = dc_fixpt_floor(*init);
 931         if (int_part < taps) {
 932                 int_part = taps - int_part;
 933                 if (int_part > *vp_offset)
 934                         int_part = *vp_offset;
 935                 *vp_offset -= int_part;
 936                 *init = dc_fixpt_add_int(*init, int_part);
 937         }
 938         /*
 939          * If taps are sampling outside of viewport at end of recout and there are more pixels
 940          * available in the surface we should increase the viewport size, regardless set vp to
 941          * only what is used.
 942          */
 943         temp = dc_fixpt_add(*init, dc_fixpt_mul_int(ratio, recout_size - 1));
 944         *vp_size = dc_fixpt_floor(temp);
 945         if (*vp_size + *vp_offset > src_size)
 946                 *vp_size = src_size - *vp_offset;
 947
 948         /* We did all the math assuming we are scanning same direction as display does,
 949          * however mirror/rotation changes how vp scans vs how it is offset. If scan direction
 950          * is flipped we simply need to calculate offset from the other side of plane.
 951          * Note that outside of viewport all scaling hardware works in recout space.
 952          */
 953         if (flip_scan_dir)
 954                 *vp_offset = src_size - *vp_offset - *vp_size;
 955 }
 956
 957 static void calculate_inits_and_viewports(struct pipe_ctx *pipe_ctx)
 958 {
 959         const struct dc_plane_state *plane_state = pipe_ctx->plane_state;
 960         const struct dc_stream_state *stream = pipe_ctx->stream;
 961         struct scaler_data *data = &pipe_ctx->plane_res.scl_data;
 962         struct rect src = plane_state->src_rect;
 963         int vpc_div = (data->format == PIXEL_FORMAT_420BPP8
 964                                 || data->format == PIXEL_FORMAT_420BPP10) ? 2 : 1;
 965         int split_count, split_idx, ro_lb, ro_tb, recout_full_x, recout_full_y;
 966         bool orthogonal_rotation, flip_vert_scan_dir, flip_horz_scan_dir;
 967
 968         calculate_split_count_and_index(pipe_ctx, &split_count, &split_idx);
 969         /*
 970          * recout full is what the recout would have been if we didnt clip
 971          * the source plane at all. We only care about left(ro_lb) and top(ro_tb)
 972          * offsets of recout within recout full because those are the directions
 973          * we scan from and therefore the only ones that affect inits.
 974          */
 975         recout_full_x = stream->dst.x + (plane_state->dst_rect.x - stream->src.x)
 976                         * stream->dst.width / stream->src.width;
 977         recout_full_y = stream->dst.y + (plane_state->dst_rect.y - stream->src.y)
 978                         * stream->dst.height / stream->src.height;
 979         if (pipe_ctx->prev_odm_pipe && split_idx)
 980                 ro_lb = data->h_active * split_idx - recout_full_x;
 981         else
 982                 ro_lb = data->recout.x - recout_full_x;
 983         ro_tb = data->recout.y - recout_full_y;
 984         ASSERT(ro_lb >= 0 && ro_tb >= 0);
 985
 986         /*
 987          * Work in recout rotation since that requires less transformations
 988          */
 989         get_vp_scan_direction(
 990                         plane_state->rotation,
 991                         plane_state->horizontal_mirror,
 992                         &orthogonal_rotation,
 993                         &flip_vert_scan_dir,
 994                         &flip_horz_scan_dir);
 995
 996         if (orthogonal_rotation) {
 997                 swap(src.width, src.height);
 998                 swap(flip_vert_scan_dir, flip_horz_scan_dir);
 999         }
1000
1001         calculate_init_and_vp(
1002                         flip_horz_scan_dir,
1003                         ro_lb,
1004                         data->recout.width,
1005                         src.width,
1006                         data->taps.h_taps,
1007                         data->ratios.horz,
1008                         &data->inits.h,
1009                         &data->viewport.x,
1010                         &data->viewport.width);
1011         calculate_init_and_vp(
1012                         flip_horz_scan_dir,
1013                         ro_lb,
1014                         data->recout.width,
1015                         src.width / vpc_div,
1016                         data->taps.h_taps_c,
1017                         data->ratios.horz_c,
1018                         &data->inits.h_c,
1019                         &data->viewport_c.x,
1020                         &data->viewport_c.width);
1021         calculate_init_and_vp(
1022                         flip_vert_scan_dir,
1023                         ro_tb,
1024                         data->recout.height,
1025                         src.height,
1026                         data->taps.v_taps,
1027                         data->ratios.vert,
1028                         &data->inits.v,
1029                         &data->viewport.y,
1030                         &data->viewport.height);
1031         calculate_init_and_vp(
1032                         flip_vert_scan_dir,
1033                         ro_tb,
1034                         data->recout.height,
1035                         src.height / vpc_div,
1036                         data->taps.v_taps_c,
1037                         data->ratios.vert_c,
1038                         &data->inits.v_c,
1039                         &data->viewport_c.y,
1040                         &data->viewport_c.height);
1041         if (orthogonal_rotation) {
1042                 swap(data->viewport.x, data->viewport.y);
1043                 swap(data->viewport.width, data->viewport.height);
1044                 swap(data->viewport_c.x, data->viewport_c.y);
1045                 swap(data->viewport_c.width, data->viewport_c.height);
1046         }
1047         data->viewport.x += src.x;
1048         data->viewport.y += src.y;
1049         ASSERT(src.x % vpc_div == 0 && src.y % vpc_div == 0);
1050         data->viewport_c.x += src.x / vpc_div;
1051         data->viewport_c.y += src.y / vpc_div;
1052 }
1053
1054 bool resource_build_scaling_params(struct pipe_ctx *pipe_ctx)
1055 {
1056         const struct dc_plane_state *plane_state = pipe_ctx->plane_state;
1057         struct dc_crtc_timing *timing = &pipe_ctx->stream->timing;
1058         bool res = false;
1059         DC_LOGGER_INIT(pipe_ctx->stream->ctx->logger);
1060
1061         pipe_ctx->plane_res.scl_data.format = convert_pixel_format_to_dalsurface(
1062                         pipe_ctx->plane_state->format);
1063
1064         /* Timing borders are part of vactive that we are also supposed to skip in addition
1065          * to any stream dst offset. Since dm logic assumes dst is in addressable
1066          * space we need to add the left and top borders to dst offsets temporarily.
1067          * TODO: fix in DM, stream dst is supposed to be in vactive
1068          */
1069         pipe_ctx->stream->dst.x += timing->h_border_left;
1070         pipe_ctx->stream->dst.y += timing->v_border_top;
1071
1072         /* Calculate H and V active size */
1073         pipe_ctx->plane_res.scl_data.h_active = timing->h_addressable +
1074                         timing->h_border_left + timing->h_border_right;
1075         pipe_ctx->plane_res.scl_data.v_active = timing->v_addressable +
1076                 timing->v_border_top + timing->v_border_bottom;
1077         if (pipe_ctx->next_odm_pipe || pipe_ctx->prev_odm_pipe)
1078                 pipe_ctx->plane_res.scl_data.h_active /= get_num_odm_splits(pipe_ctx) + 1;
1079
1080         /* depends on h_active */
1081         calculate_recout(pipe_ctx);
1082         /* depends on pixel format */
1083         calculate_scaling_ratios(pipe_ctx);
1084         /* depends on scaling ratios and recout, does not calculate offset yet */
1085         calculate_viewport_size(pipe_ctx);
1086
1087         /* Stopgap for validation of ODM + MPO on one side of screen case */
1088         if (pipe_ctx->plane_res.scl_data.viewport.height < 1 ||
1089                         pipe_ctx->plane_res.scl_data.viewport.width < 1)
1090                 return false;
1091
1092         /*
1093          * LB calculations depend on vp size, h/v_active and scaling ratios
1094          * Setting line buffer pixel depth to 24bpp yields banding
1095          * on certain displays, such as the Sharp 4k. 36bpp is needed
1096          * to support SURFACE_PIXEL_FORMAT_GRPH_ARGB16161616 and
1097          * SURFACE_PIXEL_FORMAT_GRPH_ABGR16161616 with actual > 10 bpc
1098          * precision on at least DCN display engines. However, at least
1099          * Carrizo with DCE_VERSION_11_0 does not like 36 bpp lb depth,
1100          * so use only 30 bpp on DCE_VERSION_11_0. Testing with DCE 11.2 and 8.3
1101          * did not show such problems, so this seems to be the exception.
1102          */
1103         if (plane_state->ctx->dce_version > DCE_VERSION_11_0)
1104                 pipe_ctx->plane_res.scl_data.lb_params.depth = LB_PIXEL_DEPTH_36BPP;
1105         else
1106                 pipe_ctx->plane_res.scl_data.lb_params.depth = LB_PIXEL_DEPTH_30BPP;
1107
1108         pipe_ctx->plane_res.scl_data.lb_params.alpha_en = plane_state->per_pixel_alpha;
1109
1110         if (pipe_ctx->plane_res.xfm != NULL)
1111                 res = pipe_ctx->plane_res.xfm->funcs->transform_get_optimal_number_of_taps(
1112                                 pipe_ctx->plane_res.xfm, &pipe_ctx->plane_res.scl_data, &plane_state->scaling_quality);
1113
1114         if (pipe_ctx->plane_res.dpp != NULL)
1115                 res = pipe_ctx->plane_res.dpp->funcs->dpp_get_optimal_number_of_taps(
1116                                 pipe_ctx->plane_res.dpp, &pipe_ctx->plane_res.scl_data, &plane_state->scaling_quality);
1117
1118
1119         if (!res) {
1120                 /* Try 24 bpp linebuffer */
1121                 pipe_ctx->plane_res.scl_data.lb_params.depth = LB_PIXEL_DEPTH_24BPP;
1122
1123                 if (pipe_ctx->plane_res.xfm != NULL)
1124                         res = pipe_ctx->plane_res.xfm->funcs->transform_get_optimal_number_of_taps(
1125                                         pipe_ctx->plane_res.xfm,
1126                                         &pipe_ctx->plane_res.scl_data,
1127                                         &plane_state->scaling_quality);
1128
1129                 if (pipe_ctx->plane_res.dpp != NULL)
1130                         res = pipe_ctx->plane_res.dpp->funcs->dpp_get_optimal_number_of_taps(
1131                                         pipe_ctx->plane_res.dpp,
1132                                         &pipe_ctx->plane_res.scl_data,
1133                                         &plane_state->scaling_quality);
1134         }
1135
1136         /*
1137          * Depends on recout, scaling ratios, h_active and taps
1138          * May need to re-check lb size after this in some obscure scenario
1139          */
1140         if (res)
1141                 calculate_inits_and_viewports(pipe_ctx);
1142
1143         /*
1144          * Handle side by side and top bottom 3d recout offsets after vp calculation
1145          * since 3d is special and needs to calculate vp as if there is no recout offset
1146          * This may break with rotation, good thing we aren't mixing hw rotation and 3d
1147          */
1148         if (pipe_ctx->top_pipe && pipe_ctx->top_pipe->plane_state == plane_state) {
1149                 ASSERT(plane_state->rotation == ROTATION_ANGLE_0 ||
1150                         (pipe_ctx->stream->view_format != VIEW_3D_FORMAT_TOP_AND_BOTTOM &&
1151                                 pipe_ctx->stream->view_format != VIEW_3D_FORMAT_SIDE_BY_SIDE));
1152                 if (pipe_ctx->stream->view_format == VIEW_3D_FORMAT_TOP_AND_BOTTOM)
1153                         pipe_ctx->plane_res.scl_data.recout.y += pipe_ctx->plane_res.scl_data.recout.height;
1154                 else if (pipe_ctx->stream->view_format == VIEW_3D_FORMAT_SIDE_BY_SIDE)
1155                         pipe_ctx->plane_res.scl_data.recout.x += pipe_ctx->plane_res.scl_data.recout.width;
1156         }
1157
1158         if (!pipe_ctx->stream->ctx->dc->config.enable_windowed_mpo_odm) {
1159                 if (pipe_ctx->plane_res.scl_data.viewport.height < MIN_VIEWPORT_SIZE ||
1160                                 pipe_ctx->plane_res.scl_data.viewport.width < MIN_VIEWPORT_SIZE)
1161                         res = false;
1162         } else {
1163                 /* Clamp minimum viewport size */
1164                 if (pipe_ctx->plane_res.scl_data.viewport.height < MIN_VIEWPORT_SIZE)
1165                         pipe_ctx->plane_res.scl_data.viewport.height = MIN_VIEWPORT_SIZE;
1166                 if (pipe_ctx->plane_res.scl_data.viewport.width < MIN_VIEWPORT_SIZE)
1167                         pipe_ctx->plane_res.scl_data.viewport.width = MIN_VIEWPORT_SIZE;
1168         }
1169
1170         DC_LOG_SCALER("%s pipe %d:\nViewport: height:%d width:%d x:%d y:%d  Recout: height:%d width:%d x:%d y:%d  HACTIVE:%d VACTIVE:%d\n"
1171                         "src_rect: height:%d width:%d x:%d y:%d  dst_rect: height:%d width:%d x:%d y:%d  clip_rect: height:%d width:%d x:%d y:%d\n",
1172                         __func__,
1173                         pipe_ctx->pipe_idx,
1174                         pipe_ctx->plane_res.scl_data.viewport.height,
1175                         pipe_ctx->plane_res.scl_data.viewport.width,
1176                         pipe_ctx->plane_res.scl_data.viewport.x,
1177                         pipe_ctx->plane_res.scl_data.viewport.y,
1178                         pipe_ctx->plane_res.scl_data.recout.height,
1179                         pipe_ctx->plane_res.scl_data.recout.width,
1180                         pipe_ctx->plane_res.scl_data.recout.x,
1181                         pipe_ctx->plane_res.scl_data.recout.y,
1182                         pipe_ctx->plane_res.scl_data.h_active,
1183                         pipe_ctx->plane_res.scl_data.v_active,
1184                         plane_state->src_rect.height,
1185                         plane_state->src_rect.width,
1186                         plane_state->src_rect.x,
1187                         plane_state->src_rect.y,
1188                         plane_state->dst_rect.height,
1189                         plane_state->dst_rect.width,
1190                         plane_state->dst_rect.x,
1191                         plane_state->dst_rect.y,
1192                         plane_state->clip_rect.height,
1193                         plane_state->clip_rect.width,
1194                         plane_state->clip_rect.x,
1195                         plane_state->clip_rect.y);
1196
1197         pipe_ctx->stream->dst.x -= timing->h_border_left;
1198         pipe_ctx->stream->dst.y -= timing->v_border_top;
1199
1200         return res;
1201 }
1202
1203
1204 enum dc_status resource_build_scaling_params_for_context(
1205         const struct dc  *dc,
1206         struct dc_state *context)
1207 {
1208         int i;
1209
1210         for (i = 0; i < MAX_PIPES; i++) {
1211                 if (context->res_ctx.pipe_ctx[i].plane_state != NULL &&
1212                                 context->res_ctx.pipe_ctx[i].stream != NULL)
1213                         if (!resource_build_scaling_params(&context->res_ctx.pipe_ctx[i]))
1214                                 return DC_FAIL_SCALING;
1215         }
1216
1217         return DC_OK;
1218 }
1219
1220 struct pipe_ctx *find_idle_secondary_pipe(
1221                 struct resource_context *res_ctx,
1222                 const struct resource_pool *pool,
1223                 const struct pipe_ctx *primary_pipe)
1224 {
1225         int i;
1226         struct pipe_ctx *secondary_pipe = NULL;
1227
1228         /*
1229          * We add a preferred pipe mapping to avoid the chance that
1230          * MPCCs already in use will need to be reassigned to other trees.
1231          * For example, if we went with the strict, assign backwards logic:
1232          *
1233          * (State 1)
1234          * Display A on, no surface, top pipe = 0
1235          * Display B on, no surface, top pipe = 1
1236          *
1237          * (State 2)
1238          * Display A on, no surface, top pipe = 0
1239          * Display B on, surface enable, top pipe = 1, bottom pipe = 5
1240          *
1241          * (State 3)
1242          * Display A on, surface enable, top pipe = 0, bottom pipe = 5
1243          * Display B on, surface enable, top pipe = 1, bottom pipe = 4
1244          *
1245          * The state 2->3 transition requires remapping MPCC 5 from display B
1246          * to display A.
1247          *
1248          * However, with the preferred pipe logic, state 2 would look like:
1249          *
1250          * (State 2)
1251          * Display A on, no surface, top pipe = 0
1252          * Display B on, surface enable, top pipe = 1, bottom pipe = 4
1253          *
1254          * This would then cause 2->3 to not require remapping any MPCCs.
1255          */
1256         if (primary_pipe) {
1257                 int preferred_pipe_idx = (pool->pipe_count - 1) - primary_pipe->pipe_idx;
1258                 if (res_ctx->pipe_ctx[preferred_pipe_idx].stream == NULL) {
1259                         secondary_pipe = &res_ctx->pipe_ctx[preferred_pipe_idx];
1260                         secondary_pipe->pipe_idx = preferred_pipe_idx;
1261                 }
1262         }
1263
1264         /*
1265          * search backwards for the second pipe to keep pipe
1266          * assignment more consistent
1267          */
1268         if (!secondary_pipe)
1269                 for (i = pool->pipe_count - 1; i >= 0; i--) {
1270                         if (res_ctx->pipe_ctx[i].stream == NULL) {
1271                                 secondary_pipe = &res_ctx->pipe_ctx[i];
1272                                 secondary_pipe->pipe_idx = i;
1273                                 break;
1274                         }
1275                 }
1276
1277         return secondary_pipe;
1278 }
1279
1280 struct pipe_ctx *resource_get_head_pipe_for_stream(
1281                 struct resource_context *res_ctx,
1282                 struct dc_stream_state *stream)
1283 {
1284         int i;
1285
1286         for (i = 0; i < MAX_PIPES; i++) {
1287                 if (res_ctx->pipe_ctx[i].stream == stream
1288                                 && !res_ctx->pipe_ctx[i].top_pipe
1289                                 && !res_ctx->pipe_ctx[i].prev_odm_pipe)
1290                         return &res_ctx->pipe_ctx[i];
1291         }
1292         return NULL;
1293 }
1294
1295 static struct pipe_ctx *resource_get_tail_pipe(
1296                 struct resource_context *res_ctx,
1297                 struct pipe_ctx *head_pipe)
1298 {
1299         struct pipe_ctx *tail_pipe;
1300
1301         tail_pipe = head_pipe->bottom_pipe;
1302
1303         while (tail_pipe) {
1304                 head_pipe = tail_pipe;
1305                 tail_pipe = tail_pipe->bottom_pipe;
1306         }
1307
1308         return head_pipe;
1309 }
1310
1311 /*
1312  * A free_pipe for a stream is defined here as a pipe
1313  * that has no surface attached yet
1314  */
1315 static struct pipe_ctx *acquire_free_pipe_for_head(
1316                 struct dc_state *context,
1317                 const struct resource_pool *pool,
1318                 struct pipe_ctx *head_pipe)
1319 {
1320         int i;
1321         struct resource_context *res_ctx = &context->res_ctx;
1322
1323         if (!head_pipe->plane_state)
1324                 return head_pipe;
1325
1326         /* Re-use pipe already acquired for this stream if available*/
1327         for (i = pool->pipe_count - 1; i >= 0; i--) {
1328                 if (res_ctx->pipe_ctx[i].stream == head_pipe->stream &&
1329                                 !res_ctx->pipe_ctx[i].plane_state) {
1330                         return &res_ctx->pipe_ctx[i];
1331                 }
1332         }
1333
1334         /*
1335          * At this point we have no re-useable pipe for this stream and we need
1336          * to acquire an idle one to satisfy the request
1337          */
1338
1339         if (!pool->funcs->acquire_idle_pipe_for_layer)
1340                 return NULL;
1341
1342         return pool->funcs->acquire_idle_pipe_for_layer(context, pool, head_pipe->stream);
1343 }
1344
1345 #if defined(CONFIG_DRM_AMD_DC_DCN)
1346 static int acquire_first_split_pipe(
1347                 struct resource_context *res_ctx,
1348                 const struct resource_pool *pool,
1349                 struct dc_stream_state *stream)
1350 {
1351         int i;
1352
1353         for (i = 0; i < pool->pipe_count; i++) {
1354                 struct pipe_ctx *split_pipe = &res_ctx->pipe_ctx[i];
1355
1356                 if (split_pipe->top_pipe &&
1357                                 split_pipe->top_pipe->plane_state == split_pipe->plane_state) {
1358                         split_pipe->top_pipe->bottom_pipe = split_pipe->bottom_pipe;
1359                         if (split_pipe->bottom_pipe)
1360                                 split_pipe->bottom_pipe->top_pipe = split_pipe->top_pipe;
1361
1362                         if (split_pipe->top_pipe->plane_state)
1363                                 resource_build_scaling_params(split_pipe->top_pipe);
1364
1365                         memset(split_pipe, 0, sizeof(*split_pipe));
1366                         split_pipe->stream_res.tg = pool->timing_generators[i];
1367                         split_pipe->plane_res.hubp = pool->hubps[i];
1368                         split_pipe->plane_res.ipp = pool->ipps[i];
1369                         split_pipe->plane_res.dpp = pool->dpps[i];
1370                         split_pipe->stream_res.opp = pool->opps[i];
1371                         split_pipe->plane_res.mpcc_inst = pool->dpps[i]->inst;
1372                         split_pipe->pipe_idx = i;
1373
1374                         split_pipe->stream = stream;
1375                         return i;
1376                 }
1377         }
1378         return -1;
1379 }
1380 #endif
1381
1382 bool dc_add_plane_to_context(
1383                 const struct dc *dc,
1384                 struct dc_stream_state *stream,
1385                 struct dc_plane_state *plane_state,
1386                 struct dc_state *context)
1387 {
1388         int i;
1389         struct resource_pool *pool = dc->res_pool;
1390         struct pipe_ctx *head_pipe, *tail_pipe, *free_pipe;
1391         struct dc_stream_status *stream_status = NULL;
1392
1393         for (i = 0; i < context->stream_count; i++)
1394                 if (context->streams[i] == stream) {
1395                         stream_status = &context->stream_status[i];
1396                         break;
1397                 }
1398         if (stream_status == NULL) {
1399                 dm_error("Existing stream not found; failed to attach surface!\n");
1400                 return false;
1401         }
1402
1403
1404         if (stream_status->plane_count == MAX_SURFACE_NUM) {
1405                 dm_error("Surface: can not attach plane_state %p! Maximum is: %d\n",
1406                                 plane_state, MAX_SURFACE_NUM);
1407                 return false;
1408         }
1409
1410         head_pipe = resource_get_head_pipe_for_stream(&context->res_ctx, stream);
1411
1412         if (!head_pipe) {
1413                 dm_error("Head pipe not found for stream_state %p !\n", stream);
1414                 return false;
1415         }
1416
1417         /* retain new surface, but only once per stream */
1418         dc_plane_state_retain(plane_state);
1419
1420         while (head_pipe) {
1421                 free_pipe = acquire_free_pipe_for_head(context, pool, head_pipe);
1422
1423         #if defined(CONFIG_DRM_AMD_DC_DCN)
1424                 if (!free_pipe) {
1425                         int pipe_idx = acquire_first_split_pipe(&context->res_ctx, pool, stream);
1426                         if (pipe_idx >= 0)
1427                                 free_pipe = &context->res_ctx.pipe_ctx[pipe_idx];
1428                 }
1429         #endif
1430                 if (!free_pipe) {
1431                         dc_plane_state_release(plane_state);
1432                         return false;
1433                 }
1434
1435                 free_pipe->plane_state = plane_state;
1436
1437                 if (head_pipe != free_pipe) {
1438                         tail_pipe = resource_get_tail_pipe(&context->res_ctx, head_pipe);
1439                         ASSERT(tail_pipe);
1440                         free_pipe->stream_res.tg = tail_pipe->stream_res.tg;
1441                         free_pipe->stream_res.abm = tail_pipe->stream_res.abm;
1442                         free_pipe->stream_res.opp = tail_pipe->stream_res.opp;
1443                         free_pipe->stream_res.stream_enc = tail_pipe->stream_res.stream_enc;
1444                         free_pipe->stream_res.audio = tail_pipe->stream_res.audio;
1445                         free_pipe->clock_source = tail_pipe->clock_source;
1446                         free_pipe->top_pipe = tail_pipe;
1447                         tail_pipe->bottom_pipe = free_pipe;
1448                         if (!free_pipe->next_odm_pipe && tail_pipe->next_odm_pipe && tail_pipe->next_odm_pipe->bottom_pipe) {
1449                                 free_pipe->next_odm_pipe = tail_pipe->next_odm_pipe->bottom_pipe;
1450                                 tail_pipe->next_odm_pipe->bottom_pipe->prev_odm_pipe = free_pipe;
1451                         }
1452                         if (!free_pipe->prev_odm_pipe && tail_pipe->prev_odm_pipe && tail_pipe->prev_odm_pipe->bottom_pipe) {
1453                                 free_pipe->prev_odm_pipe = tail_pipe->prev_odm_pipe->bottom_pipe;
1454                                 tail_pipe->prev_odm_pipe->bottom_pipe->next_odm_pipe = free_pipe;
1455                         }
1456                 }
1457                 head_pipe = head_pipe->next_odm_pipe;
1458         }
1459         /* assign new surfaces*/
1460         stream_status->plane_states[stream_status->plane_count] = plane_state;
1461
1462         stream_status->plane_count++;
1463
1464         return true;
1465 }
1466
1467 bool dc_remove_plane_from_context(
1468                 const struct dc *dc,
1469                 struct dc_stream_state *stream,
1470                 struct dc_plane_state *plane_state,
1471                 struct dc_state *context)
1472 {
1473         int i;
1474         struct dc_stream_status *stream_status = NULL;
1475         struct resource_pool *pool = dc->res_pool;
1476
1477         for (i = 0; i < context->stream_count; i++)
1478                 if (context->streams[i] == stream) {
1479                         stream_status = &context->stream_status[i];
1480                         break;
1481                 }
1482
1483         if (stream_status == NULL) {
1484                 dm_error("Existing stream not found; failed to remove plane.\n");
1485                 return false;
1486         }
1487
1488         /* release pipe for plane*/
1489         for (i = pool->pipe_count - 1; i >= 0; i--) {
1490                 struct pipe_ctx *pipe_ctx = &context->res_ctx.pipe_ctx[i];
1491
1492                 if (pipe_ctx->plane_state == plane_state) {
1493                         if (pipe_ctx->top_pipe)
1494                                 pipe_ctx->top_pipe->bottom_pipe = pipe_ctx->bottom_pipe;
1495
1496                         /* Second condition is to avoid setting NULL to top pipe
1497                          * of tail pipe making it look like head pipe in subsequent
1498                          * deletes
1499                          */
1500                         if (pipe_ctx->bottom_pipe && pipe_ctx->top_pipe)
1501                                 pipe_ctx->bottom_pipe->top_pipe = pipe_ctx->top_pipe;
1502
1503                         /*
1504                          * For head pipe detach surfaces from pipe for tail
1505                          * pipe just zero it out
1506                          */
1507                         if (!pipe_ctx->top_pipe)
1508                                 pipe_ctx->plane_state = NULL;
1509                         else
1510                                 memset(pipe_ctx, 0, sizeof(*pipe_ctx));
1511                 }
1512         }
1513
1514
1515         for (i = 0; i < stream_status->plane_count; i++) {
1516                 if (stream_status->plane_states[i] == plane_state) {
1517
1518                         dc_plane_state_release(stream_status->plane_states[i]);
1519                         break;
1520                 }
1521         }
1522
1523         if (i == stream_status->plane_count) {
1524                 dm_error("Existing plane_state not found; failed to detach it!\n");
1525                 return false;
1526         }
1527
1528         stream_status->plane_count--;
1529
1530         /* Start at the plane we've just released, and move all the planes one index forward to "trim" the array */
1531         for (; i < stream_status->plane_count; i++)
1532                 stream_status->plane_states[i] = stream_status->plane_states[i + 1];
1533
1534         stream_status->plane_states[stream_status->plane_count] = NULL;
1535
1536         return true;
1537 }
1538
1539 bool dc_rem_all_planes_for_stream(
1540                 const struct dc *dc,
1541                 struct dc_stream_state *stream,
1542                 struct dc_state *context)
1543 {
1544         int i, old_plane_count;
1545         struct dc_stream_status *stream_status = NULL;
1546         struct dc_plane_state *del_planes[MAX_SURFACE_NUM] = { 0 };
1547
1548         for (i = 0; i < context->stream_count; i++)
1549                         if (context->streams[i] == stream) {
1550                                 stream_status = &context->stream_status[i];
1551                                 break;
1552                         }
1553
1554         if (stream_status == NULL) {
1555                 dm_error("Existing stream %p not found!\n", stream);
1556                 return false;
1557         }
1558
1559         old_plane_count = stream_status->plane_count;
1560
1561         for (i = 0; i < old_plane_count; i++)
1562                 del_planes[i] = stream_status->plane_states[i];
1563
1564         for (i = 0; i < old_plane_count; i++)
1565                 if (!dc_remove_plane_from_context(dc, stream, del_planes[i], context))
1566                         return false;
1567
1568         return true;
1569 }
1570
1571 static bool add_all_planes_for_stream(
1572                 const struct dc *dc,
1573                 struct dc_stream_state *stream,
1574                 const struct dc_validation_set set[],
1575                 int set_count,
1576                 struct dc_state *context)
1577 {
1578         int i, j;
1579
1580         for (i = 0; i < set_count; i++)
1581                 if (set[i].stream == stream)
1582                         break;
1583
1584         if (i == set_count) {
1585                 dm_error("Stream %p not found in set!\n", stream);
1586                 return false;
1587         }
1588
1589         for (j = 0; j < set[i].plane_count; j++)
1590                 if (!dc_add_plane_to_context(dc, stream, set[i].plane_states[j], context))
1591                         return false;
1592
1593         return true;
1594 }
1595
1596 bool dc_add_all_planes_for_stream(
1597                 const struct dc *dc,
1598                 struct dc_stream_state *stream,
1599                 struct dc_plane_state * const *plane_states,
1600                 int plane_count,
1601                 struct dc_state *context)
1602 {
1603         struct dc_validation_set set;
1604         int i;
1605
1606         set.stream = stream;
1607         set.plane_count = plane_count;
1608
1609         for (i = 0; i < plane_count; i++)
1610                 set.plane_states[i] = plane_states[i];
1611
1612         return add_all_planes_for_stream(dc, stream, &set, 1, context);
1613 }
1614
1615 static bool is_timing_changed(struct dc_stream_state *cur_stream,
1616                 struct dc_stream_state *new_stream)
1617 {
1618         if (cur_stream == NULL)
1619                 return true;
1620
1621         /* If output color space is changed, need to reprogram info frames */
1622         if (cur_stream->output_color_space != new_stream->output_color_space)
1623                 return true;
1624
1625         return memcmp(
1626                 &cur_stream->timing,
1627                 &new_stream->timing,
1628                 sizeof(struct dc_crtc_timing)) != 0;
1629 }
1630
1631 static bool are_stream_backends_same(
1632         struct dc_stream_state *stream_a, struct dc_stream_state *stream_b)
1633 {
1634         if (stream_a == stream_b)
1635                 return true;
1636
1637         if (stream_a == NULL || stream_b == NULL)
1638                 return false;
1639
1640         if (is_timing_changed(stream_a, stream_b))
1641                 return false;
1642
1643         if (stream_a->dpms_off != stream_b->dpms_off)
1644                 return false;
1645
1646         return true;
1647 }
1648
1649 /*
1650  * dc_is_stream_unchanged() - Compare two stream states for equivalence.
1651  *
1652  * Checks if there a difference between the two states
1653  * that would require a mode change.
1654  *
1655  * Does not compare cursor position or attributes.
1656  */
1657 bool dc_is_stream_unchanged(
1658         struct dc_stream_state *old_stream, struct dc_stream_state *stream)
1659 {
1660
1661         if (!are_stream_backends_same(old_stream, stream))
1662                 return false;
1663
1664         if (old_stream->ignore_msa_timing_param != stream->ignore_msa_timing_param)
1665                 return false;
1666
1667         // Only Have Audio left to check whether it is same or not. This is a corner case for Tiled sinks
1668         if (old_stream->audio_info.mode_count != stream->audio_info.mode_count)
1669                 return false;
1670
1671         return true;
1672 }
1673
1674 /*
1675  * dc_is_stream_scaling_unchanged() - Compare scaling rectangles of two streams.
1676  */
1677 bool dc_is_stream_scaling_unchanged(
1678         struct dc_stream_state *old_stream, struct dc_stream_state *stream)
1679 {
1680         if (old_stream == stream)
1681                 return true;
1682
1683         if (old_stream == NULL || stream == NULL)
1684                 return false;
1685
1686         if (memcmp(&old_stream->src,
1687                         &stream->src,
1688                         sizeof(struct rect)) != 0)
1689                 return false;
1690
1691         if (memcmp(&old_stream->dst,
1692                         &stream->dst,
1693                         sizeof(struct rect)) != 0)
1694                 return false;
1695
1696         return true;
1697 }
1698
1699 static void update_stream_engine_usage(
1700                 struct resource_context *res_ctx,
1701                 const struct resource_pool *pool,
1702                 struct stream_encoder *stream_enc,
1703                 bool acquired)
1704 {
1705         int i;
1706
1707         for (i = 0; i < pool->stream_enc_count; i++) {
1708                 if (pool->stream_enc[i] == stream_enc)
1709                         res_ctx->is_stream_enc_acquired[i] = acquired;
1710         }
1711 }
1712
1713 #if defined(CONFIG_DRM_AMD_DC_DCN)
1714 static void update_hpo_dp_stream_engine_usage(
1715                 struct resource_context *res_ctx,
1716                 const struct resource_pool *pool,
1717                 struct hpo_dp_stream_encoder *hpo_dp_stream_enc,
1718                 bool acquired)
1719 {
1720         int i;
1721
1722         for (i = 0; i < pool->hpo_dp_stream_enc_count; i++) {
1723                 if (pool->hpo_dp_stream_enc[i] == hpo_dp_stream_enc)
1724                         res_ctx->is_hpo_dp_stream_enc_acquired[i] = acquired;
1725         }
1726 }
1727
1728 static inline int find_acquired_hpo_dp_link_enc_for_link(
1729                 const struct resource_context *res_ctx,
1730                 const struct dc_link *link)
1731 {
1732         int i;
1733
1734         for (i = 0; i < ARRAY_SIZE(res_ctx->hpo_dp_link_enc_to_link_idx); i++)
1735                 if (res_ctx->hpo_dp_link_enc_ref_cnts[i] > 0 &&
1736                                 res_ctx->hpo_dp_link_enc_to_link_idx[i] == link->link_index)
1737                         return i;
1738
1739         return -1;
1740 }
1741
1742 static inline int find_free_hpo_dp_link_enc(const struct resource_context *res_ctx,
1743                 const struct resource_pool *pool)
1744 {
1745         int i;
1746
1747         for (i = 0; i < ARRAY_SIZE(res_ctx->hpo_dp_link_enc_ref_cnts); i++)
1748                 if (res_ctx->hpo_dp_link_enc_ref_cnts[i] == 0)
1749                         break;
1750
1751         return (i < ARRAY_SIZE(res_ctx->hpo_dp_link_enc_ref_cnts) &&
1752                         i < pool->hpo_dp_link_enc_count) ? i : -1;
1753 }
1754
1755 static inline void acquire_hpo_dp_link_enc(
1756                 struct resource_context *res_ctx,
1757                 unsigned int link_index,
1758                 int enc_index)
1759 {
1760         res_ctx->hpo_dp_link_enc_to_link_idx[enc_index] = link_index;
1761         res_ctx->hpo_dp_link_enc_ref_cnts[enc_index] = 1;
1762 }
1763
1764 static inline void retain_hpo_dp_link_enc(
1765                 struct resource_context *res_ctx,
1766                 int enc_index)
1767 {
1768         res_ctx->hpo_dp_link_enc_ref_cnts[enc_index]++;
1769 }
1770
1771 static inline void release_hpo_dp_link_enc(
1772                 struct resource_context *res_ctx,
1773                 int enc_index)
1774 {
1775         ASSERT(res_ctx->hpo_dp_link_enc_ref_cnts[enc_index] > 0);
1776         res_ctx->hpo_dp_link_enc_ref_cnts[enc_index]--;
1777 }
1778
1779 static bool add_hpo_dp_link_enc_to_ctx(struct resource_context *res_ctx,
1780                 const struct resource_pool *pool,
1781                 struct pipe_ctx *pipe_ctx,
1782                 struct dc_stream_state *stream)
1783 {
1784         int enc_index;
1785
1786         enc_index = find_acquired_hpo_dp_link_enc_for_link(res_ctx, stream->link);
1787
1788         if (enc_index >= 0) {
1789                 retain_hpo_dp_link_enc(res_ctx, enc_index);
1790         } else {
1791                 enc_index = find_free_hpo_dp_link_enc(res_ctx, pool);
1792                 if (enc_index >= 0)
1793                         acquire_hpo_dp_link_enc(res_ctx, stream->link->link_index, enc_index);
1794         }
1795
1796         if (enc_index >= 0)
1797                 pipe_ctx->link_res.hpo_dp_link_enc = pool->hpo_dp_link_enc[enc_index];
1798
1799         return pipe_ctx->link_res.hpo_dp_link_enc != NULL;
1800 }
1801
1802 static void remove_hpo_dp_link_enc_from_ctx(struct resource_context *res_ctx,
1803                 struct pipe_ctx *pipe_ctx,
1804                 struct dc_stream_state *stream)
1805 {
1806         int enc_index;
1807
1808         enc_index = find_acquired_hpo_dp_link_enc_for_link(res_ctx, stream->link);
1809
1810         if (enc_index >= 0) {
1811                 release_hpo_dp_link_enc(res_ctx, enc_index);
1812                 pipe_ctx->link_res.hpo_dp_link_enc = NULL;
1813         }
1814 }
1815 #endif
1816
1817 /* TODO: release audio object */
1818 void update_audio_usage(
1819                 struct resource_context *res_ctx,
1820                 const struct resource_pool *pool,
1821                 struct audio *audio,
1822                 bool acquired)
1823 {
1824         int i;
1825         for (i = 0; i < pool->audio_count; i++) {
1826                 if (pool->audios[i] == audio)
1827                         res_ctx->is_audio_acquired[i] = acquired;
1828         }
1829 }
1830
1831 static int acquire_first_free_pipe(
1832                 struct resource_context *res_ctx,
1833                 const struct resource_pool *pool,
1834                 struct dc_stream_state *stream)
1835 {
1836         int i;
1837
1838         for (i = 0; i < pool->pipe_count; i++) {
1839                 if (!res_ctx->pipe_ctx[i].stream) {
1840                         struct pipe_ctx *pipe_ctx = &res_ctx->pipe_ctx[i];
1841
1842                         pipe_ctx->stream_res.tg = pool->timing_generators[i];
1843                         pipe_ctx->plane_res.mi = pool->mis[i];
1844                         pipe_ctx->plane_res.hubp = pool->hubps[i];
1845                         pipe_ctx->plane_res.ipp = pool->ipps[i];
1846                         pipe_ctx->plane_res.xfm = pool->transforms[i];
1847                         pipe_ctx->plane_res.dpp = pool->dpps[i];
1848                         pipe_ctx->stream_res.opp = pool->opps[i];
1849                         if (pool->dpps[i])
1850                                 pipe_ctx->plane_res.mpcc_inst = pool->dpps[i]->inst;
1851                         pipe_ctx->pipe_idx = i;
1852
1853
1854                         pipe_ctx->stream = stream;
1855                         return i;
1856                 }
1857         }
1858         return -1;
1859 }
1860
1861 #if defined(CONFIG_DRM_AMD_DC_DCN)
1862 static struct hpo_dp_stream_encoder *find_first_free_match_hpo_dp_stream_enc_for_link(
1863                 struct resource_context *res_ctx,
1864                 const struct resource_pool *pool,
1865                 struct dc_stream_state *stream)
1866 {
1867         int i;
1868
1869         for (i = 0; i < pool->hpo_dp_stream_enc_count; i++) {
1870                 if (!res_ctx->is_hpo_dp_stream_enc_acquired[i] &&
1871                                 pool->hpo_dp_stream_enc[i]) {
1872
1873                         return pool->hpo_dp_stream_enc[i];
1874                 }
1875         }
1876
1877         return NULL;
1878 }
1879 #endif
1880
1881 static struct audio *find_first_free_audio(
1882                 struct resource_context *res_ctx,
1883                 const struct resource_pool *pool,
1884                 enum engine_id id,
1885                 enum dce_version dc_version)
1886 {
1887         int i, available_audio_count;
1888
1889         available_audio_count = pool->audio_count;
1890
1891         for (i = 0; i < available_audio_count; i++) {
1892                 if ((res_ctx->is_audio_acquired[i] == false) && (res_ctx->is_stream_enc_acquired[i] == true)) {
1893                         /*we have enough audio endpoint, find the matching inst*/
1894                         if (id != i)
1895                                 continue;
1896                         return pool->audios[i];
1897                 }
1898         }
1899
1900         /* use engine id to find free audio */
1901         if ((id < available_audio_count) && (res_ctx->is_audio_acquired[id] == false)) {
1902                 return pool->audios[id];
1903         }
1904         /*not found the matching one, first come first serve*/
1905         for (i = 0; i < available_audio_count; i++) {
1906                 if (res_ctx->is_audio_acquired[i] == false) {
1907                         return pool->audios[i];
1908                 }
1909         }
1910         return 0;
1911 }
1912
1913 /*
1914  * dc_add_stream_to_ctx() - Add a new dc_stream_state to a dc_state.
1915  */
1916 enum dc_status dc_add_stream_to_ctx(
1917                 struct dc *dc,
1918                 struct dc_state *new_ctx,
1919                 struct dc_stream_state *stream)
1920 {
1921         enum dc_status res;
1922         DC_LOGGER_INIT(dc->ctx->logger);
1923
1924         if (new_ctx->stream_count >= dc->res_pool->timing_generator_count) {
1925                 DC_LOG_WARNING("Max streams reached, can't add stream %p !\n", stream);
1926                 return DC_ERROR_UNEXPECTED;
1927         }
1928
1929         new_ctx->streams[new_ctx->stream_count] = stream;
1930         dc_stream_retain(stream);
1931         new_ctx->stream_count++;
1932
1933         res = dc->res_pool->funcs->add_stream_to_ctx(dc, new_ctx, stream);
1934         if (res != DC_OK)
1935                 DC_LOG_WARNING("Adding stream %p to context failed with err %d!\n", stream, res);
1936
1937         return res;
1938 }
1939
1940 /*
1941  * dc_remove_stream_from_ctx() - Remove a stream from a dc_state.
1942  */
1943 enum dc_status dc_remove_stream_from_ctx(
1944                         struct dc *dc,
1945                         struct dc_state *new_ctx,
1946                         struct dc_stream_state *stream)
1947 {
1948         int i;
1949         struct dc_context *dc_ctx = dc->ctx;
1950         struct pipe_ctx *del_pipe = resource_get_head_pipe_for_stream(&new_ctx->res_ctx, stream);
1951         struct pipe_ctx *odm_pipe;
1952
1953         if (!del_pipe) {
1954                 DC_ERROR("Pipe not found for stream %p !\n", stream);
1955                 return DC_ERROR_UNEXPECTED;
1956         }
1957
1958         odm_pipe = del_pipe->next_odm_pipe;
1959
1960         /* Release primary pipe */
1961         ASSERT(del_pipe->stream_res.stream_enc);
1962         update_stream_engine_usage(
1963                         &new_ctx->res_ctx,
1964                                 dc->res_pool,
1965                         del_pipe->stream_res.stream_enc,
1966                         false);
1967 #if defined(CONFIG_DRM_AMD_DC_DCN)
1968         if (is_dp_128b_132b_signal(del_pipe)) {
1969                 update_hpo_dp_stream_engine_usage(
1970                         &new_ctx->res_ctx, dc->res_pool,
1971                         del_pipe->stream_res.hpo_dp_stream_enc,
1972                         false);
1973                 remove_hpo_dp_link_enc_from_ctx(&new_ctx->res_ctx, del_pipe, del_pipe->stream);
1974         }
1975 #endif
1976
1977         if (del_pipe->stream_res.audio)
1978                 update_audio_usage(
1979                         &new_ctx->res_ctx,
1980                         dc->res_pool,
1981                         del_pipe->stream_res.audio,
1982                         false);
1983
1984         resource_unreference_clock_source(&new_ctx->res_ctx,
1985                                           dc->res_pool,
1986                                           del_pipe->clock_source);
1987
1988         if (dc->res_pool->funcs->remove_stream_from_ctx)
1989                 dc->res_pool->funcs->remove_stream_from_ctx(dc, new_ctx, stream);
1990
1991         while (odm_pipe) {
1992                 struct pipe_ctx *next_odm_pipe = odm_pipe->next_odm_pipe;
1993
1994                 memset(odm_pipe, 0, sizeof(*odm_pipe));
1995                 odm_pipe = next_odm_pipe;
1996         }
1997         memset(del_pipe, 0, sizeof(*del_pipe));
1998
1999         for (i = 0; i < new_ctx->stream_count; i++)
2000                 if (new_ctx->streams[i] == stream)
2001                         break;
2002
2003         if (new_ctx->streams[i] != stream) {
2004                 DC_ERROR("Context doesn't have stream %p !\n", stream);
2005                 return DC_ERROR_UNEXPECTED;
2006         }
2007
2008         dc_stream_release(new_ctx->streams[i]);
2009         new_ctx->stream_count--;
2010
2011         /* Trim back arrays */
2012         for (; i < new_ctx->stream_count; i++) {
2013                 new_ctx->streams[i] = new_ctx->streams[i + 1];
2014                 new_ctx->stream_status[i] = new_ctx->stream_status[i + 1];
2015         }
2016
2017         new_ctx->streams[new_ctx->stream_count] = NULL;
2018         memset(
2019                         &new_ctx->stream_status[new_ctx->stream_count],
2020                         0,
2021                         sizeof(new_ctx->stream_status[0]));
2022
2023         return DC_OK;
2024 }
2025
2026 static struct dc_stream_state *find_pll_sharable_stream(
2027                 struct dc_stream_state *stream_needs_pll,
2028                 struct dc_state *context)
2029 {
2030         int i;
2031
2032         for (i = 0; i < context->stream_count; i++) {
2033                 struct dc_stream_state *stream_has_pll = context->streams[i];
2034
2035                 /* We are looking for non dp, non virtual stream */
2036                 if (resource_are_streams_timing_synchronizable(
2037                         stream_needs_pll, stream_has_pll)
2038                         && !dc_is_dp_signal(stream_has_pll->signal)
2039                         && stream_has_pll->link->connector_signal
2040                         != SIGNAL_TYPE_VIRTUAL)
2041                         return stream_has_pll;
2042
2043         }
2044
2045         return NULL;
2046 }
2047
2048 static int get_norm_pix_clk(const struct dc_crtc_timing *timing)
2049 {
2050         uint32_t pix_clk = timing->pix_clk_100hz;
2051         uint32_t normalized_pix_clk = pix_clk;
2052
2053         if (timing->pixel_encoding == PIXEL_ENCODING_YCBCR420)
2054                 pix_clk /= 2;
2055         if (timing->pixel_encoding != PIXEL_ENCODING_YCBCR422) {
2056                 switch (timing->display_color_depth) {
2057                 case COLOR_DEPTH_666:
2058                 case COLOR_DEPTH_888:
2059                         normalized_pix_clk = pix_clk;
2060                         break;
2061                 case COLOR_DEPTH_101010:
2062                         normalized_pix_clk = (pix_clk * 30) / 24;
2063                         break;
2064                 case COLOR_DEPTH_121212:
2065                         normalized_pix_clk = (pix_clk * 36) / 24;
2066                 break;
2067                 case COLOR_DEPTH_161616:
2068                         normalized_pix_clk = (pix_clk * 48) / 24;
2069                 break;
2070                 default:
2071                         ASSERT(0);
2072                 break;
2073                 }
2074         }
2075         return normalized_pix_clk;
2076 }
2077
2078 static void calculate_phy_pix_clks(struct dc_stream_state *stream)
2079 {
2080         /* update actual pixel clock on all streams */
2081         if (dc_is_hdmi_signal(stream->signal))
2082                 stream->phy_pix_clk = get_norm_pix_clk(
2083                         &stream->timing) / 10;
2084         else
2085                 stream->phy_pix_clk =
2086                         stream->timing.pix_clk_100hz / 10;
2087
2088         if (stream->timing.timing_3d_format == TIMING_3D_FORMAT_HW_FRAME_PACKING)
2089                 stream->phy_pix_clk *= 2;
2090 }
2091
2092 static int acquire_resource_from_hw_enabled_state(
2093                 struct resource_context *res_ctx,
2094                 const struct resource_pool *pool,
2095                 struct dc_stream_state *stream)
2096 {
2097         struct dc_link *link = stream->link;
2098         unsigned int i, inst, tg_inst = 0;
2099
2100         /* Check for enabled DIG to identify enabled display */
2101         if (!link->link_enc->funcs->is_dig_enabled(link->link_enc))
2102                 return -1;
2103
2104         inst = link->link_enc->funcs->get_dig_frontend(link->link_enc);
2105
2106         if (inst == ENGINE_ID_UNKNOWN)
2107                 return -1;
2108
2109         for (i = 0; i < pool->stream_enc_count; i++) {
2110                 if (pool->stream_enc[i]->id == inst) {
2111                         tg_inst = pool->stream_enc[i]->funcs->dig_source_otg(
2112                                 pool->stream_enc[i]);
2113                         break;
2114                 }
2115         }
2116
2117         // tg_inst not found
2118         if (i == pool->stream_enc_count)
2119                 return -1;
2120
2121         if (tg_inst >= pool->timing_generator_count)
2122                 return -1;
2123
2124         if (!res_ctx->pipe_ctx[tg_inst].stream) {
2125                 struct pipe_ctx *pipe_ctx = &res_ctx->pipe_ctx[tg_inst];
2126
2127                 pipe_ctx->stream_res.tg = pool->timing_generators[tg_inst];
2128                 pipe_ctx->plane_res.mi = pool->mis[tg_inst];
2129                 pipe_ctx->plane_res.hubp = pool->hubps[tg_inst];
2130                 pipe_ctx->plane_res.ipp = pool->ipps[tg_inst];
2131                 pipe_ctx->plane_res.xfm = pool->transforms[tg_inst];
2132                 pipe_ctx->plane_res.dpp = pool->dpps[tg_inst];
2133                 pipe_ctx->stream_res.opp = pool->opps[tg_inst];
2134
2135                 if (pool->dpps[tg_inst]) {
2136                         pipe_ctx->plane_res.mpcc_inst = pool->dpps[tg_inst]->inst;
2137
2138                         // Read DPP->MPCC->OPP Pipe from HW State
2139                         if (pool->mpc->funcs->read_mpcc_state) {
2140                                 struct mpcc_state s = {0};
2141
2142                                 pool->mpc->funcs->read_mpcc_state(pool->mpc, pipe_ctx->plane_res.mpcc_inst, &s);
2143
2144                                 if (s.dpp_id < MAX_MPCC)
2145                                         pool->mpc->mpcc_array[pipe_ctx->plane_res.mpcc_inst].dpp_id = s.dpp_id;
2146
2147                                 if (s.bot_mpcc_id < MAX_MPCC)
2148                                         pool->mpc->mpcc_array[pipe_ctx->plane_res.mpcc_inst].mpcc_bot =
2149                                                         &pool->mpc->mpcc_array[s.bot_mpcc_id];
2150
2151                                 if (s.opp_id < MAX_OPP)
2152                                         pipe_ctx->stream_res.opp->mpc_tree_params.opp_id = s.opp_id;
2153                         }
2154                 }
2155                 pipe_ctx->pipe_idx = tg_inst;
2156
2157                 pipe_ctx->stream = stream;
2158                 return tg_inst;
2159         }
2160
2161         return -1;
2162 }
2163
2164 static void mark_seamless_boot_stream(
2165                 const struct dc  *dc,
2166                 struct dc_stream_state *stream)
2167 {
2168         struct dc_bios *dcb = dc->ctx->dc_bios;
2169
2170         if (dc->config.allow_seamless_boot_optimization &&
2171                         !dcb->funcs->is_accelerated_mode(dcb)) {
2172                 if (dc_validate_seamless_boot_timing(dc, stream->sink, &stream->timing))
2173                         stream->apply_seamless_boot_optimization = true;
2174         }
2175 }
2176
2177 enum dc_status resource_map_pool_resources(
2178                 const struct dc  *dc,
2179                 struct dc_state *context,
2180                 struct dc_stream_state *stream)
2181 {
2182         const struct resource_pool *pool = dc->res_pool;
2183         int i;
2184         struct dc_context *dc_ctx = dc->ctx;
2185         struct pipe_ctx *pipe_ctx = NULL;
2186         int pipe_idx = -1;
2187
2188         calculate_phy_pix_clks(stream);
2189
2190         mark_seamless_boot_stream(dc, stream);
2191
2192         if (stream->apply_seamless_boot_optimization) {
2193                 pipe_idx = acquire_resource_from_hw_enabled_state(
2194                                 &context->res_ctx,
2195                                 pool,
2196                                 stream);
2197                 if (pipe_idx < 0)
2198                         /* hw resource was assigned to other stream */
2199                         stream->apply_seamless_boot_optimization = false;
2200         }
2201
2202         if (pipe_idx < 0)
2203                 /* acquire new resources */
2204                 pipe_idx = acquire_first_free_pipe(&context->res_ctx, pool, stream);
2205
2206 #ifdef CONFIG_DRM_AMD_DC_DCN
2207         if (pipe_idx < 0)
2208                 pipe_idx = acquire_first_split_pipe(&context->res_ctx, pool, stream);
2209 #endif
2210
2211         if (pipe_idx < 0 || context->res_ctx.pipe_ctx[pipe_idx].stream_res.tg == NULL)
2212                 return DC_NO_CONTROLLER_RESOURCE;
2213
2214         pipe_ctx = &context->res_ctx.pipe_ctx[pipe_idx];
2215
2216         pipe_ctx->stream_res.stream_enc =
2217                 dc->res_pool->funcs->find_first_free_match_stream_enc_for_link(
2218                         &context->res_ctx, pool, stream);
2219
2220         if (!pipe_ctx->stream_res.stream_enc)
2221                 return DC_NO_STREAM_ENC_RESOURCE;
2222
2223         update_stream_engine_usage(
2224                 &context->res_ctx, pool,
2225                 pipe_ctx->stream_res.stream_enc,
2226                 true);
2227
2228 #if defined(CONFIG_DRM_AMD_DC_DCN)
2229         /* Allocate DP HPO Stream Encoder based on signal, hw capabilities
2230          * and link settings
2231          */
2232         if (dc_is_dp_signal(stream->signal) &&
2233                         dc->caps.dp_hpo) {
2234                 struct dc_link_settings link_settings = {0};
2235
2236                 decide_link_settings(stream, &link_settings);
2237                 if (dp_get_link_encoding_format(&link_settings) == DP_128b_132b_ENCODING) {
2238                         pipe_ctx->stream_res.hpo_dp_stream_enc =
2239                                         find_first_free_match_hpo_dp_stream_enc_for_link(
2240                                                         &context->res_ctx, pool, stream);
2241
2242                         if (!pipe_ctx->stream_res.hpo_dp_stream_enc)
2243                                 return DC_NO_STREAM_ENC_RESOURCE;
2244
2245                         update_hpo_dp_stream_engine_usage(
2246                                         &context->res_ctx, pool,
2247                                         pipe_ctx->stream_res.hpo_dp_stream_enc,
2248                                         true);
2249                         if (!add_hpo_dp_link_enc_to_ctx(&context->res_ctx, pool, pipe_ctx, stream))
2250                                 return DC_NO_LINK_ENC_RESOURCE;
2251                 }
2252         }
2253 #endif
2254
2255         /* TODO: Add check if ASIC support and EDID audio */
2256         if (!stream->converter_disable_audio &&
2257             dc_is_audio_capable_signal(pipe_ctx->stream->signal) &&
2258             stream->audio_info.mode_count && stream->audio_info.flags.all) {
2259                 pipe_ctx->stream_res.audio = find_first_free_audio(
2260                 &context->res_ctx, pool, pipe_ctx->stream_res.stream_enc->id, dc_ctx->dce_version);
2261
2262                 /*
2263                  * Audio assigned in order first come first get.
2264                  * There are asics which has number of audio
2265                  * resources less then number of pipes
2266                  */
2267                 if (pipe_ctx->stream_res.audio)
2268                         update_audio_usage(&context->res_ctx, pool,
2269                                            pipe_ctx->stream_res.audio, true);
2270         }
2271
2272         /* Add ABM to the resource if on EDP */
2273         if (pipe_ctx->stream && dc_is_embedded_signal(pipe_ctx->stream->signal)) {
2274 #if defined(CONFIG_DRM_AMD_DC_DCN)
2275                 if (pool->abm)
2276                         pipe_ctx->stream_res.abm = pool->abm;
2277                 else
2278                         pipe_ctx->stream_res.abm = pool->multiple_abms[pipe_ctx->stream_res.tg->inst];
2279 #else
2280                 pipe_ctx->stream_res.abm = pool->abm;
2281 #endif
2282         }
2283
2284         for (i = 0; i < context->stream_count; i++)
2285                 if (context->streams[i] == stream) {
2286                         context->stream_status[i].primary_otg_inst = pipe_ctx->stream_res.tg->inst;
2287                         context->stream_status[i].stream_enc_inst = pipe_ctx->stream_res.stream_enc->stream_enc_inst;
2288                         context->stream_status[i].audio_inst =
2289                                 pipe_ctx->stream_res.audio ? pipe_ctx->stream_res.audio->inst : -1;
2290
2291                         return DC_OK;
2292                 }
2293
2294         DC_ERROR("Stream %p not found in new ctx!\n", stream);
2295         return DC_ERROR_UNEXPECTED;
2296 }
2297
2298 /**
2299  * dc_resource_state_copy_construct_current() - Creates a new dc_state from existing state
2300  * Is a shallow copy.  Increments refcounts on existing streams and planes.
2301  * @dc: copy out of dc->current_state
2302  * @dst_ctx: copy into this
2303  */
2304 void dc_resource_state_copy_construct_current(
2305                 const struct dc *dc,
2306                 struct dc_state *dst_ctx)
2307 {
2308         dc_resource_state_copy_construct(dc->current_state, dst_ctx);
2309 }
2310
2311
2312 void dc_resource_state_construct(
2313                 const struct dc *dc,
2314                 struct dc_state *dst_ctx)
2315 {
2316         dst_ctx->clk_mgr = dc->clk_mgr;
2317
2318         /* Initialise DIG link encoder resource tracking variables. */
2319         link_enc_cfg_init(dc, dst_ctx);
2320 }
2321
2322
2323 bool dc_resource_is_dsc_encoding_supported(const struct dc *dc)
2324 {
2325         return dc->res_pool->res_cap->num_dsc > 0;
2326 }
2327
2328
2329 /**
2330  * dc_validate_global_state() - Determine if HW can support a given state
2331  * Checks HW resource availability and bandwidth requirement.
2332  * @dc: dc struct for this driver
2333  * @new_ctx: state to be validated
2334  * @fast_validate: set to true if only yes/no to support matters
2335  *
2336  * Return: DC_OK if the result can be programmed.  Otherwise, an error code.
2337  */
2338 enum dc_status dc_validate_global_state(
2339                 struct dc *dc,
2340                 struct dc_state *new_ctx,
2341                 bool fast_validate)
2342 {
2343         enum dc_status result = DC_ERROR_UNEXPECTED;
2344         int i, j;
2345
2346         if (!new_ctx)
2347                 return DC_ERROR_UNEXPECTED;
2348
2349         if (dc->res_pool->funcs->validate_global) {
2350                 result = dc->res_pool->funcs->validate_global(dc, new_ctx);
2351                 if (result != DC_OK)
2352                         return result;
2353         }
2354
2355         for (i = 0; i < new_ctx->stream_count; i++) {
2356                 struct dc_stream_state *stream = new_ctx->streams[i];
2357
2358                 for (j = 0; j < dc->res_pool->pipe_count; j++) {
2359                         struct pipe_ctx *pipe_ctx = &new_ctx->res_ctx.pipe_ctx[j];
2360
2361                         if (pipe_ctx->stream != stream)
2362                                 continue;
2363
2364                         if (dc->res_pool->funcs->patch_unknown_plane_state &&
2365                                         pipe_ctx->plane_state &&
2366                                         pipe_ctx->plane_state->tiling_info.gfx9.swizzle == DC_SW_UNKNOWN) {
2367                                 result = dc->res_pool->funcs->patch_unknown_plane_state(pipe_ctx->plane_state);
2368                                 if (result != DC_OK)
2369                                         return result;
2370                         }
2371
2372                         /* Switch to dp clock source only if there is
2373                          * no non dp stream that shares the same timing
2374                          * with the dp stream.
2375                          */
2376                         if (dc_is_dp_signal(pipe_ctx->stream->signal) &&
2377                                 !find_pll_sharable_stream(stream, new_ctx)) {
2378
2379                                 resource_unreference_clock_source(
2380                                                 &new_ctx->res_ctx,
2381                                                 dc->res_pool,
2382                                                 pipe_ctx->clock_source);
2383
2384                                 pipe_ctx->clock_source = dc->res_pool->dp_clock_source;
2385                                 resource_reference_clock_source(
2386                                                 &new_ctx->res_ctx,
2387                                                 dc->res_pool,
2388                                                  pipe_ctx->clock_source);
2389                         }
2390                 }
2391         }
2392
2393         result = resource_build_scaling_params_for_context(dc, new_ctx);
2394
2395         if (result == DC_OK)
2396                 if (!dc->res_pool->funcs->validate_bandwidth(dc, new_ctx, fast_validate))
2397                         result = DC_FAIL_BANDWIDTH_VALIDATE;
2398
2399 #if defined(CONFIG_DRM_AMD_DC_DCN)
2400         /*
2401          * Only update link encoder to stream assignment after bandwidth validation passed.
2402          * TODO: Split out assignment and validation.
2403          */
2404         if (result == DC_OK && dc->res_pool->funcs->link_encs_assign && fast_validate == false)
2405                 dc->res_pool->funcs->link_encs_assign(
2406                         dc, new_ctx, new_ctx->streams, new_ctx->stream_count);
2407 #endif
2408
2409         return result;
2410 }
2411
2412 static void patch_gamut_packet_checksum(
2413                 struct dc_info_packet *gamut_packet)
2414 {
2415         /* For gamut we recalc checksum */
2416         if (gamut_packet->valid) {
2417                 uint8_t chk_sum = 0;
2418                 uint8_t *ptr;
2419                 uint8_t i;
2420
2421                 /*start of the Gamut data. */
2422                 ptr = &gamut_packet->sb[3];
2423
2424                 for (i = 0; i <= gamut_packet->sb[1]; i++)
2425                         chk_sum += ptr[i];
2426
2427                 gamut_packet->sb[2] = (uint8_t) (0x100 - chk_sum);
2428         }
2429 }
2430
2431 static void set_avi_info_frame(
2432                 struct dc_info_packet *info_packet,
2433                 struct pipe_ctx *pipe_ctx)
2434 {
2435         struct dc_stream_state *stream = pipe_ctx->stream;
2436         enum dc_color_space color_space = COLOR_SPACE_UNKNOWN;
2437         uint32_t pixel_encoding = 0;
2438         enum scanning_type scan_type = SCANNING_TYPE_NODATA;
2439         enum dc_aspect_ratio aspect = ASPECT_RATIO_NO_DATA;
2440         bool itc = false;
2441         uint8_t itc_value = 0;
2442         uint8_t cn0_cn1 = 0;
2443         unsigned int cn0_cn1_value = 0;
2444         uint8_t *check_sum = NULL;
2445         uint8_t byte_index = 0;
2446         union hdmi_info_packet hdmi_info;
2447         union display_content_support support = {0};
2448         unsigned int vic = pipe_ctx->stream->timing.vic;
2449         enum dc_timing_3d_format format;
2450
2451         memset(&hdmi_info, 0, sizeof(union hdmi_info_packet));
2452
2453         color_space = pipe_ctx->stream->output_color_space;
2454         if (color_space == COLOR_SPACE_UNKNOWN)
2455                 color_space = (stream->timing.pixel_encoding == PIXEL_ENCODING_RGB) ?
2456                         COLOR_SPACE_SRGB:COLOR_SPACE_YCBCR709;
2457
2458         /* Initialize header */
2459         hdmi_info.bits.header.info_frame_type = HDMI_INFOFRAME_TYPE_AVI;
2460         /* InfoFrameVersion_3 is defined by CEA861F (Section 6.4), but shall
2461         * not be used in HDMI 2.0 (Section 10.1) */
2462         hdmi_info.bits.header.version = 2;
2463         hdmi_info.bits.header.length = HDMI_AVI_INFOFRAME_SIZE;
2464
2465         /*
2466          * IDO-defined (Y2,Y1,Y0 = 1,1,1) shall not be used by devices built
2467          * according to HDMI 2.0 spec (Section 10.1)
2468          */
2469
2470         switch (stream->timing.pixel_encoding) {
2471         case PIXEL_ENCODING_YCBCR422:
2472                 pixel_encoding = 1;
2473                 break;
2474
2475         case PIXEL_ENCODING_YCBCR444:
2476                 pixel_encoding = 2;
2477                 break;
2478         case PIXEL_ENCODING_YCBCR420:
2479                 pixel_encoding = 3;
2480                 break;
2481
2482         case PIXEL_ENCODING_RGB:
2483         default:
2484                 pixel_encoding = 0;
2485         }
2486
2487         /* Y0_Y1_Y2 : The pixel encoding */
2488         /* H14b AVI InfoFrame has extension on Y-field from 2 bits to 3 bits */
2489         hdmi_info.bits.Y0_Y1_Y2 = pixel_encoding;
2490
2491         /* A0 = 1 Active Format Information valid */
2492         hdmi_info.bits.A0 = ACTIVE_FORMAT_VALID;
2493
2494         /* B0, B1 = 3; Bar info data is valid */
2495         hdmi_info.bits.B0_B1 = BAR_INFO_BOTH_VALID;
2496
2497         hdmi_info.bits.SC0_SC1 = PICTURE_SCALING_UNIFORM;
2498
2499         /* S0, S1 : Underscan / Overscan */
2500         /* TODO: un-hardcode scan type */
2501         scan_type = SCANNING_TYPE_UNDERSCAN;
2502         hdmi_info.bits.S0_S1 = scan_type;
2503
2504         /* C0, C1 : Colorimetry */
2505         if (color_space == COLOR_SPACE_YCBCR709 ||
2506                         color_space == COLOR_SPACE_YCBCR709_LIMITED)
2507                 hdmi_info.bits.C0_C1 = COLORIMETRY_ITU709;
2508         else if (color_space == COLOR_SPACE_YCBCR601 ||
2509                         color_space == COLOR_SPACE_YCBCR601_LIMITED)
2510                 hdmi_info.bits.C0_C1 = COLORIMETRY_ITU601;
2511         else {
2512                 hdmi_info.bits.C0_C1 = COLORIMETRY_NO_DATA;
2513         }
2514         if (color_space == COLOR_SPACE_2020_RGB_FULLRANGE ||
2515                         color_space == COLOR_SPACE_2020_RGB_LIMITEDRANGE ||
2516                         color_space == COLOR_SPACE_2020_YCBCR) {
2517                 hdmi_info.bits.EC0_EC2 = COLORIMETRYEX_BT2020RGBYCBCR;
2518                 hdmi_info.bits.C0_C1   = COLORIMETRY_EXTENDED;
2519         } else if (color_space == COLOR_SPACE_ADOBERGB) {
2520                 hdmi_info.bits.EC0_EC2 = COLORIMETRYEX_ADOBERGB;
2521                 hdmi_info.bits.C0_C1   = COLORIMETRY_EXTENDED;
2522         }
2523
2524         /* TODO: un-hardcode aspect ratio */
2525         aspect = stream->timing.aspect_ratio;
2526
2527         switch (aspect) {
2528         case ASPECT_RATIO_4_3:
2529         case ASPECT_RATIO_16_9:
2530                 hdmi_info.bits.M0_M1 = aspect;
2531                 break;
2532
2533         case ASPECT_RATIO_NO_DATA:
2534         case ASPECT_RATIO_64_27:
2535         case ASPECT_RATIO_256_135:
2536         default:
2537                 hdmi_info.bits.M0_M1 = 0;
2538         }
2539
2540         /* Active Format Aspect ratio - same as Picture Aspect Ratio. */
2541         hdmi_info.bits.R0_R3 = ACTIVE_FORMAT_ASPECT_RATIO_SAME_AS_PICTURE;
2542
2543         /* TODO: un-hardcode cn0_cn1 and itc */
2544
2545         cn0_cn1 = 0;
2546         cn0_cn1_value = 0;
2547
2548         itc = true;
2549         itc_value = 1;
2550
2551         support = stream->content_support;
2552
2553         if (itc) {
2554                 if (!support.bits.valid_content_type) {
2555                         cn0_cn1_value = 0;
2556                 } else {
2557                         if (cn0_cn1 == DISPLAY_CONTENT_TYPE_GRAPHICS) {
2558                                 if (support.bits.graphics_content == 1) {
2559                                         cn0_cn1_value = 0;
2560                                 }
2561                         } else if (cn0_cn1 == DISPLAY_CONTENT_TYPE_PHOTO) {
2562                                 if (support.bits.photo_content == 1) {
2563                                         cn0_cn1_value = 1;
2564                                 } else {
2565                                         cn0_cn1_value = 0;
2566                                         itc_value = 0;
2567                                 }
2568                         } else if (cn0_cn1 == DISPLAY_CONTENT_TYPE_CINEMA) {
2569                                 if (support.bits.cinema_content == 1) {
2570                                         cn0_cn1_value = 2;
2571                                 } else {
2572                                         cn0_cn1_value = 0;
2573                                         itc_value = 0;
2574                                 }
2575                         } else if (cn0_cn1 == DISPLAY_CONTENT_TYPE_GAME) {
2576                                 if (support.bits.game_content == 1) {
2577                                         cn0_cn1_value = 3;
2578                                 } else {
2579                                         cn0_cn1_value = 0;
2580                                         itc_value = 0;
2581                                 }
2582                         }
2583                 }
2584                 hdmi_info.bits.CN0_CN1 = cn0_cn1_value;
2585                 hdmi_info.bits.ITC = itc_value;
2586         }
2587
2588         if (stream->qs_bit == 1) {
2589                 if (color_space == COLOR_SPACE_SRGB ||
2590                         color_space == COLOR_SPACE_2020_RGB_FULLRANGE)
2591                         hdmi_info.bits.Q0_Q1   = RGB_QUANTIZATION_FULL_RANGE;
2592                 else if (color_space == COLOR_SPACE_SRGB_LIMITED ||
2593                                         color_space == COLOR_SPACE_2020_RGB_LIMITEDRANGE)
2594                         hdmi_info.bits.Q0_Q1   = RGB_QUANTIZATION_LIMITED_RANGE;
2595                 else
2596                         hdmi_info.bits.Q0_Q1   = RGB_QUANTIZATION_DEFAULT_RANGE;
2597         } else
2598                 hdmi_info.bits.Q0_Q1   = RGB_QUANTIZATION_DEFAULT_RANGE;
2599
2600         /* TODO : We should handle YCC quantization */
2601         /* but we do not have matrix calculation */
2602         hdmi_info.bits.YQ0_YQ1 = YYC_QUANTIZATION_LIMITED_RANGE;
2603
2604         ///VIC
2605         format = stream->timing.timing_3d_format;
2606         /*todo, add 3DStereo support*/
2607         if (format != TIMING_3D_FORMAT_NONE) {
2608                 // Based on HDMI specs hdmi vic needs to be converted to cea vic when 3D is enabled
2609                 switch (pipe_ctx->stream->timing.hdmi_vic) {
2610                 case 1:
2611                         vic = 95;
2612                         break;
2613                 case 2:
2614                         vic = 94;
2615                         break;
2616                 case 3:
2617                         vic = 93;
2618                         break;
2619                 case 4:
2620                         vic = 98;
2621                         break;
2622                 default:
2623                         break;
2624                 }
2625         }
2626         /* If VIC >= 128, the Source shall use AVI InfoFrame Version 3*/
2627         hdmi_info.bits.VIC0_VIC7 = vic;
2628         if (vic >= 128)
2629                 hdmi_info.bits.header.version = 3;
2630         /* If (C1, C0)=(1, 1) and (EC2, EC1, EC0)=(1, 1, 1),
2631          * the Source shall use 20 AVI InfoFrame Version 4
2632          */
2633         if (hdmi_info.bits.C0_C1 == COLORIMETRY_EXTENDED &&
2634                         hdmi_info.bits.EC0_EC2 == COLORIMETRYEX_RESERVED) {
2635                 hdmi_info.bits.header.version = 4;
2636                 hdmi_info.bits.header.length = 14;
2637         }
2638
2639         /* pixel repetition
2640          * PR0 - PR3 start from 0 whereas pHwPathMode->mode.timing.flags.pixel
2641          * repetition start from 1 */
2642         hdmi_info.bits.PR0_PR3 = 0;
2643
2644         /* Bar Info
2645          * barTop:    Line Number of End of Top Bar.
2646          * barBottom: Line Number of Start of Bottom Bar.
2647          * barLeft:   Pixel Number of End of Left Bar.
2648          * barRight:  Pixel Number of Start of Right Bar. */
2649         hdmi_info.bits.bar_top = stream->timing.v_border_top;
2650         hdmi_info.bits.bar_bottom = (stream->timing.v_total
2651                         - stream->timing.v_border_bottom + 1);
2652         hdmi_info.bits.bar_left  = stream->timing.h_border_left;
2653         hdmi_info.bits.bar_right = (stream->timing.h_total
2654                         - stream->timing.h_border_right + 1);
2655
2656     /* Additional Colorimetry Extension
2657      * Used in conduction with C0-C1 and EC0-EC2
2658      * 0 = DCI-P3 RGB (D65)
2659      * 1 = DCI-P3 RGB (theater)
2660      */
2661         hdmi_info.bits.ACE0_ACE3 = 0;
2662
2663         /* check_sum - Calculate AFMT_AVI_INFO0 ~ AFMT_AVI_INFO3 */
2664         check_sum = &hdmi_info.packet_raw_data.sb[0];
2665
2666         *check_sum = HDMI_INFOFRAME_TYPE_AVI + hdmi_info.bits.header.length + hdmi_info.bits.header.version;
2667
2668         for (byte_index = 1; byte_index <= hdmi_info.bits.header.length; byte_index++)
2669                 *check_sum += hdmi_info.packet_raw_data.sb[byte_index];
2670
2671         /* one byte complement */
2672         *check_sum = (uint8_t) (0x100 - *check_sum);
2673
2674         /* Store in hw_path_mode */
2675         info_packet->hb0 = hdmi_info.packet_raw_data.hb0;
2676         info_packet->hb1 = hdmi_info.packet_raw_data.hb1;
2677         info_packet->hb2 = hdmi_info.packet_raw_data.hb2;
2678
2679         for (byte_index = 0; byte_index < sizeof(hdmi_info.packet_raw_data.sb); byte_index++)
2680                 info_packet->sb[byte_index] = hdmi_info.packet_raw_data.sb[byte_index];
2681
2682         info_packet->valid = true;
2683 }
2684
2685 static void set_vendor_info_packet(
2686                 struct dc_info_packet *info_packet,
2687                 struct dc_stream_state *stream)
2688 {
2689         /* SPD info packet for FreeSync */
2690
2691         /* Check if Freesync is supported. Return if false. If true,
2692          * set the corresponding bit in the info packet
2693          */
2694         if (!stream->vsp_infopacket.valid)
2695                 return;
2696
2697         *info_packet = stream->vsp_infopacket;
2698 }
2699
2700 static void set_spd_info_packet(
2701                 struct dc_info_packet *info_packet,
2702                 struct dc_stream_state *stream)
2703 {
2704         /* SPD info packet for FreeSync */
2705
2706         /* Check if Freesync is supported. Return if false. If true,
2707          * set the corresponding bit in the info packet
2708          */
2709         if (!stream->vrr_infopacket.valid)
2710                 return;
2711
2712         *info_packet = stream->vrr_infopacket;
2713 }
2714
2715 static void set_hdr_static_info_packet(
2716                 struct dc_info_packet *info_packet,
2717                 struct dc_stream_state *stream)
2718 {
2719         /* HDR Static Metadata info packet for HDR10 */
2720
2721         if (!stream->hdr_static_metadata.valid ||
2722                         stream->use_dynamic_meta)
2723                 return;
2724
2725         *info_packet = stream->hdr_static_metadata;
2726 }
2727
2728 static void set_vsc_info_packet(
2729                 struct dc_info_packet *info_packet,
2730                 struct dc_stream_state *stream)
2731 {
2732         if (!stream->vsc_infopacket.valid)
2733                 return;
2734
2735         *info_packet = stream->vsc_infopacket;
2736 }
2737
2738 void dc_resource_state_destruct(struct dc_state *context)
2739 {
2740         int i, j;
2741
2742         for (i = 0; i < context->stream_count; i++) {
2743                 for (j = 0; j < context->stream_status[i].plane_count; j++)
2744                         dc_plane_state_release(
2745                                 context->stream_status[i].plane_states[j]);
2746
2747                 context->stream_status[i].plane_count = 0;
2748                 dc_stream_release(context->streams[i]);
2749                 context->streams[i] = NULL;
2750         }
2751         context->stream_count = 0;
2752 }
2753
2754 void dc_resource_state_copy_construct(
2755                 const struct dc_state *src_ctx,
2756                 struct dc_state *dst_ctx)
2757 {
2758         int i, j;
2759         struct kref refcount = dst_ctx->refcount;
2760
2761         *dst_ctx = *src_ctx;
2762
2763         for (i = 0; i < MAX_PIPES; i++) {
2764                 struct pipe_ctx *cur_pipe = &dst_ctx->res_ctx.pipe_ctx[i];
2765
2766                 if (cur_pipe->top_pipe)
2767                         cur_pipe->top_pipe =  &dst_ctx->res_ctx.pipe_ctx[cur_pipe->top_pipe->pipe_idx];
2768
2769                 if (cur_pipe->bottom_pipe)
2770                         cur_pipe->bottom_pipe = &dst_ctx->res_ctx.pipe_ctx[cur_pipe->bottom_pipe->pipe_idx];
2771
2772                 if (cur_pipe->next_odm_pipe)
2773                         cur_pipe->next_odm_pipe =  &dst_ctx->res_ctx.pipe_ctx[cur_pipe->next_odm_pipe->pipe_idx];
2774
2775                 if (cur_pipe->prev_odm_pipe)
2776                         cur_pipe->prev_odm_pipe = &dst_ctx->res_ctx.pipe_ctx[cur_pipe->prev_odm_pipe->pipe_idx];
2777         }
2778
2779         for (i = 0; i < dst_ctx->stream_count; i++) {
2780                 dc_stream_retain(dst_ctx->streams[i]);
2781                 for (j = 0; j < dst_ctx->stream_status[i].plane_count; j++)
2782                         dc_plane_state_retain(
2783                                 dst_ctx->stream_status[i].plane_states[j]);
2784         }
2785
2786         /* context refcount should not be overridden */
2787         dst_ctx->refcount = refcount;
2788
2789 }
2790
2791 struct clock_source *dc_resource_find_first_free_pll(
2792                 struct resource_context *res_ctx,
2793                 const struct resource_pool *pool)
2794 {
2795         int i;
2796
2797         for (i = 0; i < pool->clk_src_count; ++i) {
2798                 if (res_ctx->clock_source_ref_count[i] == 0)
2799                         return pool->clock_sources[i];
2800         }
2801
2802         return NULL;
2803 }
2804
2805 void resource_build_info_frame(struct pipe_ctx *pipe_ctx)
2806 {
2807         enum signal_type signal = SIGNAL_TYPE_NONE;
2808         struct encoder_info_frame *info = &pipe_ctx->stream_res.encoder_info_frame;
2809
2810         /* default all packets to invalid */
2811         info->avi.valid = false;
2812         info->gamut.valid = false;
2813         info->vendor.valid = false;
2814         info->spd.valid = false;
2815         info->hdrsmd.valid = false;
2816         info->vsc.valid = false;
2817
2818         signal = pipe_ctx->stream->signal;
2819
2820         /* HDMi and DP have different info packets*/
2821         if (dc_is_hdmi_signal(signal)) {
2822                 set_avi_info_frame(&info->avi, pipe_ctx);
2823
2824                 set_vendor_info_packet(&info->vendor, pipe_ctx->stream);
2825
2826                 set_spd_info_packet(&info->spd, pipe_ctx->stream);
2827
2828                 set_hdr_static_info_packet(&info->hdrsmd, pipe_ctx->stream);
2829
2830         } else if (dc_is_dp_signal(signal)) {
2831                 set_vsc_info_packet(&info->vsc, pipe_ctx->stream);
2832
2833                 set_spd_info_packet(&info->spd, pipe_ctx->stream);
2834
2835                 set_hdr_static_info_packet(&info->hdrsmd, pipe_ctx->stream);
2836         }
2837
2838         patch_gamut_packet_checksum(&info->gamut);
2839 }
2840
2841 enum dc_status resource_map_clock_resources(
2842                 const struct dc  *dc,
2843                 struct dc_state *context,
2844                 struct dc_stream_state *stream)
2845 {
2846         /* acquire new resources */
2847         const struct resource_pool *pool = dc->res_pool;
2848         struct pipe_ctx *pipe_ctx = resource_get_head_pipe_for_stream(
2849                                 &context->res_ctx, stream);
2850
2851         if (!pipe_ctx)
2852                 return DC_ERROR_UNEXPECTED;
2853
2854         if (dc_is_dp_signal(pipe_ctx->stream->signal)
2855                 || pipe_ctx->stream->signal == SIGNAL_TYPE_VIRTUAL)
2856                 pipe_ctx->clock_source = pool->dp_clock_source;
2857         else {
2858                 pipe_ctx->clock_source = NULL;
2859
2860                 if (!dc->config.disable_disp_pll_sharing)
2861                         pipe_ctx->clock_source = resource_find_used_clk_src_for_sharing(
2862                                 &context->res_ctx,
2863                                 pipe_ctx);
2864
2865                 if (pipe_ctx->clock_source == NULL)
2866                         pipe_ctx->clock_source =
2867                                 dc_resource_find_first_free_pll(
2868                                         &context->res_ctx,
2869                                         pool);
2870         }
2871
2872         if (pipe_ctx->clock_source == NULL)
2873                 return DC_NO_CLOCK_SOURCE_RESOURCE;
2874
2875         resource_reference_clock_source(
2876                 &context->res_ctx, pool,
2877                 pipe_ctx->clock_source);
2878
2879         return DC_OK;
2880 }
2881
2882 /*
2883  * Note: We need to disable output if clock sources change,
2884  * since bios does optimization and doesn't apply if changing
2885  * PHY when not already disabled.
2886  */
2887 bool pipe_need_reprogram(
2888                 struct pipe_ctx *pipe_ctx_old,
2889                 struct pipe_ctx *pipe_ctx)
2890 {
2891         if (!pipe_ctx_old->stream)
2892                 return false;
2893
2894         if (pipe_ctx_old->stream->sink != pipe_ctx->stream->sink)
2895                 return true;
2896
2897         if (pipe_ctx_old->stream->signal != pipe_ctx->stream->signal)
2898                 return true;
2899
2900         if (pipe_ctx_old->stream_res.audio != pipe_ctx->stream_res.audio)
2901                 return true;
2902
2903         if (pipe_ctx_old->clock_source != pipe_ctx->clock_source
2904                         && pipe_ctx_old->stream != pipe_ctx->stream)
2905                 return true;
2906
2907         if (pipe_ctx_old->stream_res.stream_enc != pipe_ctx->stream_res.stream_enc)
2908                 return true;
2909
2910         if (is_timing_changed(pipe_ctx_old->stream, pipe_ctx->stream))
2911                 return true;
2912
2913         if (pipe_ctx_old->stream->dpms_off != pipe_ctx->stream->dpms_off)
2914                 return true;
2915
2916         if (false == pipe_ctx_old->stream->link->link_state_valid &&
2917                 false == pipe_ctx_old->stream->dpms_off)
2918                 return true;
2919
2920         if (pipe_ctx_old->stream_res.dsc != pipe_ctx->stream_res.dsc)
2921                 return true;
2922
2923 #if defined(CONFIG_DRM_AMD_DC_DCN)
2924         if (pipe_ctx_old->stream_res.hpo_dp_stream_enc != pipe_ctx->stream_res.hpo_dp_stream_enc)
2925                 return true;
2926         if (pipe_ctx_old->link_res.hpo_dp_link_enc != pipe_ctx->link_res.hpo_dp_link_enc)
2927                 return true;
2928 #endif
2929
2930         /* DIG link encoder resource assignment for stream changed. */
2931         if (pipe_ctx_old->stream->ctx->dc->res_pool->funcs->link_encs_assign) {
2932                 bool need_reprogram = false;
2933                 struct dc *dc = pipe_ctx_old->stream->ctx->dc;
2934                 enum link_enc_cfg_mode mode = dc->current_state->res_ctx.link_enc_cfg_ctx.mode;
2935
2936                 dc->current_state->res_ctx.link_enc_cfg_ctx.mode = LINK_ENC_CFG_STEADY;
2937                 if (link_enc_cfg_get_link_enc_used_by_stream(dc, pipe_ctx_old->stream) != pipe_ctx->stream->link_enc)
2938                         need_reprogram = true;
2939                 dc->current_state->res_ctx.link_enc_cfg_ctx.mode = mode;
2940
2941                 return need_reprogram;
2942         }
2943
2944         return false;
2945 }
2946
2947 void resource_build_bit_depth_reduction_params(struct dc_stream_state *stream,
2948                 struct bit_depth_reduction_params *fmt_bit_depth)
2949 {
2950         enum dc_dither_option option = stream->dither_option;
2951         enum dc_pixel_encoding pixel_encoding =
2952                         stream->timing.pixel_encoding;
2953
2954         memset(fmt_bit_depth, 0, sizeof(*fmt_bit_depth));
2955
2956         if (option == DITHER_OPTION_DEFAULT) {
2957                 switch (stream->timing.display_color_depth) {
2958                 case COLOR_DEPTH_666:
2959                         option = DITHER_OPTION_SPATIAL6;
2960                         break;
2961                 case COLOR_DEPTH_888:
2962                         option = DITHER_OPTION_SPATIAL8;
2963                         break;
2964                 case COLOR_DEPTH_101010:
2965                         option = DITHER_OPTION_SPATIAL10;
2966                         break;
2967                 default:
2968                         option = DITHER_OPTION_DISABLE;
2969                 }
2970         }
2971
2972         if (option == DITHER_OPTION_DISABLE)
2973                 return;
2974
2975         if (option == DITHER_OPTION_TRUN6) {
2976                 fmt_bit_depth->flags.TRUNCATE_ENABLED = 1;
2977                 fmt_bit_depth->flags.TRUNCATE_DEPTH = 0;
2978         } else if (option == DITHER_OPTION_TRUN8 ||
2979                         option == DITHER_OPTION_TRUN8_SPATIAL6 ||
2980                         option == DITHER_OPTION_TRUN8_FM6) {
2981                 fmt_bit_depth->flags.TRUNCATE_ENABLED = 1;
2982                 fmt_bit_depth->flags.TRUNCATE_DEPTH = 1;
2983         } else if (option == DITHER_OPTION_TRUN10        ||
2984                         option == DITHER_OPTION_TRUN10_SPATIAL6   ||
2985                         option == DITHER_OPTION_TRUN10_SPATIAL8   ||
2986                         option == DITHER_OPTION_TRUN10_FM8     ||
2987                         option == DITHER_OPTION_TRUN10_FM6     ||
2988                         option == DITHER_OPTION_TRUN10_SPATIAL8_FM6) {
2989                 fmt_bit_depth->flags.TRUNCATE_ENABLED = 1;
2990                 fmt_bit_depth->flags.TRUNCATE_DEPTH = 2;
2991         }
2992
2993         /* special case - Formatter can only reduce by 4 bits at most.
2994          * When reducing from 12 to 6 bits,
2995          * HW recommends we use trunc with round mode
2996          * (if we did nothing, trunc to 10 bits would be used)
2997          * note that any 12->10 bit reduction is ignored prior to DCE8,
2998          * as the input was 10 bits.
2999          */
3000         if (option == DITHER_OPTION_SPATIAL6_FRAME_RANDOM ||
3001                         option == DITHER_OPTION_SPATIAL6 ||
3002                         option == DITHER_OPTION_FM6) {
3003                 fmt_bit_depth->flags.TRUNCATE_ENABLED = 1;
3004                 fmt_bit_depth->flags.TRUNCATE_DEPTH = 2;
3005                 fmt_bit_depth->flags.TRUNCATE_MODE = 1;
3006         }
3007
3008         /* spatial dither
3009          * note that spatial modes 1-3 are never used
3010          */
3011         if (option == DITHER_OPTION_SPATIAL6_FRAME_RANDOM            ||
3012                         option == DITHER_OPTION_SPATIAL6 ||
3013                         option == DITHER_OPTION_TRUN10_SPATIAL6      ||
3014                         option == DITHER_OPTION_TRUN8_SPATIAL6) {
3015                 fmt_bit_depth->flags.SPATIAL_DITHER_ENABLED = 1;
3016                 fmt_bit_depth->flags.SPATIAL_DITHER_DEPTH = 0;
3017                 fmt_bit_depth->flags.HIGHPASS_RANDOM = 1;
3018                 fmt_bit_depth->flags.RGB_RANDOM =
3019                                 (pixel_encoding == PIXEL_ENCODING_RGB) ? 1 : 0;
3020         } else if (option == DITHER_OPTION_SPATIAL8_FRAME_RANDOM            ||
3021                         option == DITHER_OPTION_SPATIAL8 ||
3022                         option == DITHER_OPTION_SPATIAL8_FM6        ||
3023                         option == DITHER_OPTION_TRUN10_SPATIAL8      ||
3024                         option == DITHER_OPTION_TRUN10_SPATIAL8_FM6) {
3025                 fmt_bit_depth->flags.SPATIAL_DITHER_ENABLED = 1;
3026                 fmt_bit_depth->flags.SPATIAL_DITHER_DEPTH = 1;
3027                 fmt_bit_depth->flags.HIGHPASS_RANDOM = 1;
3028                 fmt_bit_depth->flags.RGB_RANDOM =
3029                                 (pixel_encoding == PIXEL_ENCODING_RGB) ? 1 : 0;
3030         } else if (option == DITHER_OPTION_SPATIAL10_FRAME_RANDOM ||
3031                         option == DITHER_OPTION_SPATIAL10 ||
3032                         option == DITHER_OPTION_SPATIAL10_FM8 ||
3033                         option == DITHER_OPTION_SPATIAL10_FM6) {
3034                 fmt_bit_depth->flags.SPATIAL_DITHER_ENABLED = 1;
3035                 fmt_bit_depth->flags.SPATIAL_DITHER_DEPTH = 2;
3036                 fmt_bit_depth->flags.HIGHPASS_RANDOM = 1;
3037                 fmt_bit_depth->flags.RGB_RANDOM =
3038                                 (pixel_encoding == PIXEL_ENCODING_RGB) ? 1 : 0;
3039         }
3040
3041         if (option == DITHER_OPTION_SPATIAL6 ||
3042                         option == DITHER_OPTION_SPATIAL8 ||
3043                         option == DITHER_OPTION_SPATIAL10) {
3044                 fmt_bit_depth->flags.FRAME_RANDOM = 0;
3045         } else {
3046                 fmt_bit_depth->flags.FRAME_RANDOM = 1;
3047         }
3048
3049         //////////////////////
3050         //// temporal dither
3051         //////////////////////
3052         if (option == DITHER_OPTION_FM6           ||
3053                         option == DITHER_OPTION_SPATIAL8_FM6     ||
3054                         option == DITHER_OPTION_SPATIAL10_FM6     ||
3055                         option == DITHER_OPTION_TRUN10_FM6     ||
3056                         option == DITHER_OPTION_TRUN8_FM6      ||
3057                         option == DITHER_OPTION_TRUN10_SPATIAL8_FM6) {
3058                 fmt_bit_depth->flags.FRAME_MODULATION_ENABLED = 1;
3059                 fmt_bit_depth->flags.FRAME_MODULATION_DEPTH = 0;
3060         } else if (option == DITHER_OPTION_FM8        ||
3061                         option == DITHER_OPTION_SPATIAL10_FM8  ||
3062                         option == DITHER_OPTION_TRUN10_FM8) {
3063                 fmt_bit_depth->flags.FRAME_MODULATION_ENABLED = 1;
3064                 fmt_bit_depth->flags.FRAME_MODULATION_DEPTH = 1;
3065         } else if (option == DITHER_OPTION_FM10) {
3066                 fmt_bit_depth->flags.FRAME_MODULATION_ENABLED = 1;
3067                 fmt_bit_depth->flags.FRAME_MODULATION_DEPTH = 2;
3068         }
3069
3070         fmt_bit_depth->pixel_encoding = pixel_encoding;
3071 }
3072
3073 enum dc_status dc_validate_stream(struct dc *dc, struct dc_stream_state *stream)
3074 {
3075         struct dc_link *link = stream->link;
3076         struct timing_generator *tg = dc->res_pool->timing_generators[0];
3077         enum dc_status res = DC_OK;
3078
3079         calculate_phy_pix_clks(stream);
3080
3081         if (!tg->funcs->validate_timing(tg, &stream->timing))
3082                 res = DC_FAIL_CONTROLLER_VALIDATE;
3083
3084         if (res == DC_OK) {
3085                 if (link->ep_type == DISPLAY_ENDPOINT_PHY &&
3086                                 !link->link_enc->funcs->validate_output_with_stream(
3087                                                 link->link_enc, stream))
3088                         res = DC_FAIL_ENC_VALIDATE;
3089         }
3090
3091         /* TODO: validate audio ASIC caps, encoder */
3092
3093         if (res == DC_OK)
3094                 res = dc_link_validate_mode_timing(stream,
3095                       link,
3096                       &stream->timing);
3097
3098         return res;
3099 }
3100
3101 enum dc_status dc_validate_plane(struct dc *dc, const struct dc_plane_state *plane_state)
3102 {
3103         enum dc_status res = DC_OK;
3104
3105         /* check if surface has invalid dimensions */
3106         if (plane_state->src_rect.width == 0 || plane_state->src_rect.height == 0 ||
3107                 plane_state->dst_rect.width == 0 || plane_state->dst_rect.height == 0)
3108                 return DC_FAIL_SURFACE_VALIDATE;
3109
3110         /* TODO For now validates pixel format only */
3111         if (dc->res_pool->funcs->validate_plane)
3112                 return dc->res_pool->funcs->validate_plane(plane_state, &dc->caps);
3113
3114         return res;
3115 }
3116
3117 unsigned int resource_pixel_format_to_bpp(enum surface_pixel_format format)
3118 {
3119         switch (format) {
3120         case SURFACE_PIXEL_FORMAT_GRPH_PALETA_256_COLORS:
3121                 return 8;
3122         case SURFACE_PIXEL_FORMAT_VIDEO_420_YCbCr:
3123         case SURFACE_PIXEL_FORMAT_VIDEO_420_YCrCb:
3124                 return 12;
3125         case SURFACE_PIXEL_FORMAT_GRPH_ARGB1555:
3126         case SURFACE_PIXEL_FORMAT_GRPH_RGB565:
3127         case SURFACE_PIXEL_FORMAT_VIDEO_420_10bpc_YCbCr:
3128         case SURFACE_PIXEL_FORMAT_VIDEO_420_10bpc_YCrCb:
3129                 return 16;
3130         case SURFACE_PIXEL_FORMAT_GRPH_ARGB8888:
3131         case SURFACE_PIXEL_FORMAT_GRPH_ABGR8888:
3132         case SURFACE_PIXEL_FORMAT_GRPH_ARGB2101010:
3133         case SURFACE_PIXEL_FORMAT_GRPH_ABGR2101010:
3134         case SURFACE_PIXEL_FORMAT_GRPH_ABGR2101010_XR_BIAS:
3135 #if defined(CONFIG_DRM_AMD_DC_DCN)
3136         case SURFACE_PIXEL_FORMAT_GRPH_RGBE:
3137         case SURFACE_PIXEL_FORMAT_GRPH_RGBE_ALPHA:
3138 #endif
3139                 return 32;
3140         case SURFACE_PIXEL_FORMAT_GRPH_ARGB16161616:
3141         case SURFACE_PIXEL_FORMAT_GRPH_ABGR16161616:
3142         case SURFACE_PIXEL_FORMAT_GRPH_ARGB16161616F:
3143         case SURFACE_PIXEL_FORMAT_GRPH_ABGR16161616F:
3144                 return 64;
3145         default:
3146                 ASSERT_CRITICAL(false);
3147                 return -1;
3148         }
3149 }
3150 static unsigned int get_max_audio_sample_rate(struct audio_mode *modes)
3151 {
3152         if (modes) {
3153                 if (modes->sample_rates.rate.RATE_192)
3154                         return 192000;
3155                 if (modes->sample_rates.rate.RATE_176_4)
3156                         return 176400;
3157                 if (modes->sample_rates.rate.RATE_96)
3158                         return 96000;
3159                 if (modes->sample_rates.rate.RATE_88_2)
3160                         return 88200;
3161                 if (modes->sample_rates.rate.RATE_48)
3162                         return 48000;
3163                 if (modes->sample_rates.rate.RATE_44_1)
3164                         return 44100;
3165                 if (modes->sample_rates.rate.RATE_32)
3166                         return 32000;
3167         }
3168         /*original logic when no audio info*/
3169         return 441000;
3170 }
3171
3172 void get_audio_check(struct audio_info *aud_modes,
3173         struct audio_check *audio_chk)
3174 {
3175         unsigned int i;
3176         unsigned int max_sample_rate = 0;
3177
3178         if (aud_modes) {
3179                 audio_chk->audio_packet_type = 0x2;/*audio sample packet AP = .25 for layout0, 1 for layout1*/
3180
3181                 audio_chk->max_audiosample_rate = 0;
3182                 for (i = 0; i < aud_modes->mode_count; i++) {
3183                         max_sample_rate = get_max_audio_sample_rate(&aud_modes->modes[i]);
3184                         if (audio_chk->max_audiosample_rate < max_sample_rate)
3185                                 audio_chk->max_audiosample_rate = max_sample_rate;
3186                         /*dts takes the same as type 2: AP = 0.25*/
3187                 }
3188                 /*check which one take more bandwidth*/
3189                 if (audio_chk->max_audiosample_rate > 192000)
3190                         audio_chk->audio_packet_type = 0x9;/*AP =1*/
3191                 audio_chk->acat = 0;/*not support*/
3192         }
3193 }
3194
3195 #if defined(CONFIG_DRM_AMD_DC_DCN)
3196 struct hpo_dp_link_encoder *resource_get_hpo_dp_link_enc_for_det_lt(
3197                 const struct resource_context *res_ctx,
3198                 const struct resource_pool *pool,
3199                 const struct dc_link *link)
3200 {
3201         struct hpo_dp_link_encoder *hpo_dp_link_enc = NULL;
3202         int enc_index;
3203
3204         enc_index = find_acquired_hpo_dp_link_enc_for_link(res_ctx, link);
3205
3206         if (enc_index < 0)
3207                 enc_index = find_free_hpo_dp_link_enc(res_ctx, pool);
3208
3209         if (enc_index >= 0)
3210                 hpo_dp_link_enc = pool->hpo_dp_link_enc[enc_index];
3211
3212         return hpo_dp_link_enc;
3213 }
3214 #endif
3215
3216 void reset_syncd_pipes_from_disabled_pipes(struct dc *dc,
3217                 struct dc_state *context)
3218 {
3219         int i, j;
3220         struct pipe_ctx *pipe_ctx_old, *pipe_ctx, *pipe_ctx_syncd;
3221
3222         /* If pipe backend is reset, need to reset pipe syncd status */
3223         for (i = 0; i < dc->res_pool->pipe_count; i++) {
3224                 pipe_ctx_old =  &dc->current_state->res_ctx.pipe_ctx[i];
3225                 pipe_ctx = &context->res_ctx.pipe_ctx[i];
3226
3227                 if (!pipe_ctx_old->stream)
3228                         continue;
3229
3230                 if (pipe_ctx_old->top_pipe || pipe_ctx_old->prev_odm_pipe)
3231                         continue;
3232
3233                 if (!pipe_ctx->stream ||
3234                                 pipe_need_reprogram(pipe_ctx_old, pipe_ctx)) {
3235
3236                         /* Reset all the syncd pipes from the disabled pipe */
3237                         for (j = 0; j < dc->res_pool->pipe_count; j++) {
3238                                 pipe_ctx_syncd = &context->res_ctx.pipe_ctx[j];
3239                                 if ((GET_PIPE_SYNCD_FROM_PIPE(pipe_ctx_syncd) == pipe_ctx_old->pipe_idx) ||
3240                                         !IS_PIPE_SYNCD_VALID(pipe_ctx_syncd))
3241                                         SET_PIPE_SYNCD_TO_PIPE(pipe_ctx_syncd, j);
3242                         }
3243                 }
3244         }
3245 }
3246
3247 void check_syncd_pipes_for_disabled_master_pipe(struct dc *dc,
3248         struct dc_state *context,
3249         uint8_t disabled_master_pipe_idx)
3250 {
3251         int i;
3252         struct pipe_ctx *pipe_ctx, *pipe_ctx_check;
3253
3254         pipe_ctx = &context->res_ctx.pipe_ctx[disabled_master_pipe_idx];
3255         if ((GET_PIPE_SYNCD_FROM_PIPE(pipe_ctx) != disabled_master_pipe_idx) ||
3256                 !IS_PIPE_SYNCD_VALID(pipe_ctx))
3257                 SET_PIPE_SYNCD_TO_PIPE(pipe_ctx, disabled_master_pipe_idx);
3258
3259         /* for the pipe disabled, check if any slave pipe exists and assert */
3260         for (i = 0; i < dc->res_pool->pipe_count; i++) {
3261                 pipe_ctx_check = &context->res_ctx.pipe_ctx[i];
3262
3263                 if ((GET_PIPE_SYNCD_FROM_PIPE(pipe_ctx_check) == disabled_master_pipe_idx) &&
3264                         IS_PIPE_SYNCD_VALID(pipe_ctx_check) && (i != disabled_master_pipe_idx))
3265                         DC_ERR("DC: Failure: pipe_idx[%d] syncd with disabled master pipe_idx[%d]\n",
3266                                 i, disabled_master_pipe_idx);
3267         }
3268 }
3269
3270 uint8_t resource_transmitter_to_phy_idx(const struct dc *dc, enum transmitter transmitter)
3271 {
3272         /* TODO - get transmitter to phy idx mapping from DMUB */
3273         uint8_t phy_idx = transmitter - TRANSMITTER_UNIPHY_A;
3274
3275 #if defined(CONFIG_DRM_AMD_DC_DCN)
3276         if (dc->ctx->dce_version == DCN_VERSION_3_1 &&
3277                         dc->ctx->asic_id.hw_internal_rev == YELLOW_CARP_B0) {
3278                 switch (transmitter) {
3279                 case TRANSMITTER_UNIPHY_A:
3280                         phy_idx = 0;
3281                         break;
3282                 case TRANSMITTER_UNIPHY_B:
3283                         phy_idx = 1;
3284                         break;
3285                 case TRANSMITTER_UNIPHY_C:
3286                         phy_idx = 5;
3287                         break;
3288                 case TRANSMITTER_UNIPHY_D:
3289                         phy_idx = 6;
3290                         break;
3291                 case TRANSMITTER_UNIPHY_E:
3292                         phy_idx = 4;
3293                         break;
3294                 default:
3295                         phy_idx = 0;
3296                         break;
3297                 }
3298         }
3299 #endif
3300         return phy_idx;
3301 }