drivers/gpu/drm/amd/display/dc/dcn20/dcn20_resource.c

   1 /*
   2 * Copyright 2016 Advanced Micro Devices, Inc.
   3  * Copyright 2019 Raptor Engineering, LLC
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  19  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  20  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  21  * OTHER DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors: AMD
  24  *
  25  */
  26
  27 #include <linux/slab.h>
  28
  29 #include "dm_services.h"
  30 #include "dc.h"
  31
  32 #include "dcn20_init.h"
  33
  34 #include "resource.h"
  35 #include "include/irq_service_interface.h"
  36 #include "dcn20/dcn20_resource.h"
  37
  38 #include "dcn10/dcn10_hubp.h"
  39 #include "dcn10/dcn10_ipp.h"
  40 #include "dcn20_hubbub.h"
  41 #include "dcn20_mpc.h"
  42 #include "dcn20_hubp.h"
  43 #include "irq/dcn20/irq_service_dcn20.h"
  44 #include "dcn20_dpp.h"
  45 #include "dcn20_optc.h"
  46 #include "dcn20_hwseq.h"
  47 #include "dce110/dce110_hw_sequencer.h"
  48 #include "dcn10/dcn10_resource.h"
  49 #include "dcn20_opp.h"
  50
  51 #include "dcn20_dsc.h"
  52
  53 #include "dcn20_link_encoder.h"
  54 #include "dcn20_stream_encoder.h"
  55 #include "dce/dce_clock_source.h"
  56 #include "dce/dce_audio.h"
  57 #include "dce/dce_hwseq.h"
  58 #include "virtual/virtual_stream_encoder.h"
  59 #include "dce110/dce110_resource.h"
  60 #include "dml/display_mode_vba.h"
  61 #include "dcn20_dccg.h"
  62 #include "dcn20_vmid.h"
  63 #include "dc_link_ddc.h"
  64 #include "dce/dce_panel_cntl.h"
  65
  66 #include "navi10_ip_offset.h"
  67
  68 #include "dcn/dcn_2_0_0_offset.h"
  69 #include "dcn/dcn_2_0_0_sh_mask.h"
  70 #include "dpcs/dpcs_2_0_0_offset.h"
  71 #include "dpcs/dpcs_2_0_0_sh_mask.h"
  72
  73 #include "nbio/nbio_2_3_offset.h"
  74
  75 #include "dcn20/dcn20_dwb.h"
  76 #include "dcn20/dcn20_mmhubbub.h"
  77
  78 #include "mmhub/mmhub_2_0_0_offset.h"
  79 #include "mmhub/mmhub_2_0_0_sh_mask.h"
  80
  81 #include "reg_helper.h"
  82 #include "dce/dce_abm.h"
  83 #include "dce/dce_dmcu.h"
  84 #include "dce/dce_aux.h"
  85 #include "dce/dce_i2c.h"
  86 #include "vm_helper.h"
  87
  88 #include "amdgpu_socbb.h"
  89
  90 #define DC_LOGGER_INIT(logger)
  91
  92 struct _vcs_dpi_ip_params_st dcn2_0_ip = {
  93         .odm_capable = 1,
  94         .gpuvm_enable = 0,
  95         .hostvm_enable = 0,
  96         .gpuvm_max_page_table_levels = 4,
  97         .hostvm_max_page_table_levels = 4,
  98         .hostvm_cached_page_table_levels = 0,
  99         .pte_group_size_bytes = 2048,
 100         .num_dsc = 6,
 101         .rob_buffer_size_kbytes = 168,
 102         .det_buffer_size_kbytes = 164,
 103         .dpte_buffer_size_in_pte_reqs_luma = 84,
 104         .pde_proc_buffer_size_64k_reqs = 48,
 105         .dpp_output_buffer_pixels = 2560,
 106         .opp_output_buffer_lines = 1,
 107         .pixel_chunk_size_kbytes = 8,
 108         .pte_chunk_size_kbytes = 2,
 109         .meta_chunk_size_kbytes = 2,
 110         .writeback_chunk_size_kbytes = 2,
 111         .line_buffer_size_bits = 789504,
 112         .is_line_buffer_bpp_fixed = 0,
 113         .line_buffer_fixed_bpp = 0,
 114         .dcc_supported = true,
 115         .max_line_buffer_lines = 12,
 116         .writeback_luma_buffer_size_kbytes = 12,
 117         .writeback_chroma_buffer_size_kbytes = 8,
 118         .writeback_chroma_line_buffer_width_pixels = 4,
 119         .writeback_max_hscl_ratio = 1,
 120         .writeback_max_vscl_ratio = 1,
 121         .writeback_min_hscl_ratio = 1,
 122         .writeback_min_vscl_ratio = 1,
 123         .writeback_max_hscl_taps = 12,
 124         .writeback_max_vscl_taps = 12,
 125         .writeback_line_buffer_luma_buffer_size = 0,
 126         .writeback_line_buffer_chroma_buffer_size = 14643,
 127         .cursor_buffer_size = 8,
 128         .cursor_chunk_size = 2,
 129         .max_num_otg = 6,
 130         .max_num_dpp = 6,
 131         .max_num_wb = 1,
 132         .max_dchub_pscl_bw_pix_per_clk = 4,
 133         .max_pscl_lb_bw_pix_per_clk = 2,
 134         .max_lb_vscl_bw_pix_per_clk = 4,
 135         .max_vscl_hscl_bw_pix_per_clk = 4,
 136         .max_hscl_ratio = 8,
 137         .max_vscl_ratio = 8,
 138         .hscl_mults = 4,
 139         .vscl_mults = 4,
 140         .max_hscl_taps = 8,
 141         .max_vscl_taps = 8,
 142         .dispclk_ramp_margin_percent = 1,
 143         .underscan_factor = 1.10,
 144         .min_vblank_lines = 32, //
 145         .dppclk_delay_subtotal = 77, //
 146         .dppclk_delay_scl_lb_only = 16,
 147         .dppclk_delay_scl = 50,
 148         .dppclk_delay_cnvc_formatter = 8,
 149         .dppclk_delay_cnvc_cursor = 6,
 150         .dispclk_delay_subtotal = 87, //
 151         .dcfclk_cstate_latency = 10, // SRExitTime
 152         .max_inter_dcn_tile_repeaters = 8,
 153         .xfc_supported = true,
 154         .xfc_fill_bw_overhead_percent = 10.0,
 155         .xfc_fill_constant_bytes = 0,
 156         .number_of_cursors = 1,
 157 };
 158
 159 static struct _vcs_dpi_ip_params_st dcn2_0_nv14_ip = {
 160         .odm_capable = 1,
 161         .gpuvm_enable = 0,
 162         .hostvm_enable = 0,
 163         .gpuvm_max_page_table_levels = 4,
 164         .hostvm_max_page_table_levels = 4,
 165         .hostvm_cached_page_table_levels = 0,
 166         .num_dsc = 5,
 167         .rob_buffer_size_kbytes = 168,
 168         .det_buffer_size_kbytes = 164,
 169         .dpte_buffer_size_in_pte_reqs_luma = 84,
 170         .dpte_buffer_size_in_pte_reqs_chroma = 42,//todo
 171         .dpp_output_buffer_pixels = 2560,
 172         .opp_output_buffer_lines = 1,
 173         .pixel_chunk_size_kbytes = 8,
 174         .pte_enable = 1,
 175         .max_page_table_levels = 4,
 176         .pte_chunk_size_kbytes = 2,
 177         .meta_chunk_size_kbytes = 2,
 178         .writeback_chunk_size_kbytes = 2,
 179         .line_buffer_size_bits = 789504,
 180         .is_line_buffer_bpp_fixed = 0,
 181         .line_buffer_fixed_bpp = 0,
 182         .dcc_supported = true,
 183         .max_line_buffer_lines = 12,
 184         .writeback_luma_buffer_size_kbytes = 12,
 185         .writeback_chroma_buffer_size_kbytes = 8,
 186         .writeback_chroma_line_buffer_width_pixels = 4,
 187         .writeback_max_hscl_ratio = 1,
 188         .writeback_max_vscl_ratio = 1,
 189         .writeback_min_hscl_ratio = 1,
 190         .writeback_min_vscl_ratio = 1,
 191         .writeback_max_hscl_taps = 12,
 192         .writeback_max_vscl_taps = 12,
 193         .writeback_line_buffer_luma_buffer_size = 0,
 194         .writeback_line_buffer_chroma_buffer_size = 14643,
 195         .cursor_buffer_size = 8,
 196         .cursor_chunk_size = 2,
 197         .max_num_otg = 5,
 198         .max_num_dpp = 5,
 199         .max_num_wb = 1,
 200         .max_dchub_pscl_bw_pix_per_clk = 4,
 201         .max_pscl_lb_bw_pix_per_clk = 2,
 202         .max_lb_vscl_bw_pix_per_clk = 4,
 203         .max_vscl_hscl_bw_pix_per_clk = 4,
 204         .max_hscl_ratio = 8,
 205         .max_vscl_ratio = 8,
 206         .hscl_mults = 4,
 207         .vscl_mults = 4,
 208         .max_hscl_taps = 8,
 209         .max_vscl_taps = 8,
 210         .dispclk_ramp_margin_percent = 1,
 211         .underscan_factor = 1.10,
 212         .min_vblank_lines = 32, //
 213         .dppclk_delay_subtotal = 77, //
 214         .dppclk_delay_scl_lb_only = 16,
 215         .dppclk_delay_scl = 50,
 216         .dppclk_delay_cnvc_formatter = 8,
 217         .dppclk_delay_cnvc_cursor = 6,
 218         .dispclk_delay_subtotal = 87, //
 219         .dcfclk_cstate_latency = 10, // SRExitTime
 220         .max_inter_dcn_tile_repeaters = 8,
 221         .xfc_supported = true,
 222         .xfc_fill_bw_overhead_percent = 10.0,
 223         .xfc_fill_constant_bytes = 0,
 224         .ptoi_supported = 0,
 225         .number_of_cursors = 1,
 226 };
 227
 228 static struct _vcs_dpi_soc_bounding_box_st dcn2_0_soc = {
 229         /* Defaults that get patched on driver load from firmware. */
 230         .clock_limits = {
 231                         {
 232                                 .state = 0,
 233                                 .dcfclk_mhz = 560.0,
 234                                 .fabricclk_mhz = 560.0,
 235                                 .dispclk_mhz = 513.0,
 236                                 .dppclk_mhz = 513.0,
 237                                 .phyclk_mhz = 540.0,
 238                                 .socclk_mhz = 560.0,
 239                                 .dscclk_mhz = 171.0,
 240                                 .dram_speed_mts = 8960.0,
 241                         },
 242                         {
 243                                 .state = 1,
 244                                 .dcfclk_mhz = 694.0,
 245                                 .fabricclk_mhz = 694.0,
 246                                 .dispclk_mhz = 642.0,
 247                                 .dppclk_mhz = 642.0,
 248                                 .phyclk_mhz = 600.0,
 249                                 .socclk_mhz = 694.0,
 250                                 .dscclk_mhz = 214.0,
 251                                 .dram_speed_mts = 11104.0,
 252                         },
 253                         {
 254                                 .state = 2,
 255                                 .dcfclk_mhz = 875.0,
 256                                 .fabricclk_mhz = 875.0,
 257                                 .dispclk_mhz = 734.0,
 258                                 .dppclk_mhz = 734.0,
 259                                 .phyclk_mhz = 810.0,
 260                                 .socclk_mhz = 875.0,
 261                                 .dscclk_mhz = 245.0,
 262                                 .dram_speed_mts = 14000.0,
 263                         },
 264                         {
 265                                 .state = 3,
 266                                 .dcfclk_mhz = 1000.0,
 267                                 .fabricclk_mhz = 1000.0,
 268                                 .dispclk_mhz = 1100.0,
 269                                 .dppclk_mhz = 1100.0,
 270                                 .phyclk_mhz = 810.0,
 271                                 .socclk_mhz = 1000.0,
 272                                 .dscclk_mhz = 367.0,
 273                                 .dram_speed_mts = 16000.0,
 274                         },
 275                         {
 276                                 .state = 4,
 277                                 .dcfclk_mhz = 1200.0,
 278                                 .fabricclk_mhz = 1200.0,
 279                                 .dispclk_mhz = 1284.0,
 280                                 .dppclk_mhz = 1284.0,
 281                                 .phyclk_mhz = 810.0,
 282                                 .socclk_mhz = 1200.0,
 283                                 .dscclk_mhz = 428.0,
 284                                 .dram_speed_mts = 16000.0,
 285                         },
 286                         /*Extra state, no dispclk ramping*/
 287                         {
 288                                 .state = 5,
 289                                 .dcfclk_mhz = 1200.0,
 290                                 .fabricclk_mhz = 1200.0,
 291                                 .dispclk_mhz = 1284.0,
 292                                 .dppclk_mhz = 1284.0,
 293                                 .phyclk_mhz = 810.0,
 294                                 .socclk_mhz = 1200.0,
 295                                 .dscclk_mhz = 428.0,
 296                                 .dram_speed_mts = 16000.0,
 297                         },
 298                 },
 299         .num_states = 5,
 300         .sr_exit_time_us = 8.6,
 301         .sr_enter_plus_exit_time_us = 10.9,
 302         .urgent_latency_us = 4.0,
 303         .urgent_latency_pixel_data_only_us = 4.0,
 304         .urgent_latency_pixel_mixed_with_vm_data_us = 4.0,
 305         .urgent_latency_vm_data_only_us = 4.0,
 306         .urgent_out_of_order_return_per_channel_pixel_only_bytes = 4096,
 307         .urgent_out_of_order_return_per_channel_pixel_and_vm_bytes = 4096,
 308         .urgent_out_of_order_return_per_channel_vm_only_bytes = 4096,
 309         .pct_ideal_dram_sdp_bw_after_urgent_pixel_only = 40.0,
 310         .pct_ideal_dram_sdp_bw_after_urgent_pixel_and_vm = 40.0,
 311         .pct_ideal_dram_sdp_bw_after_urgent_vm_only = 40.0,
 312         .max_avg_sdp_bw_use_normal_percent = 40.0,
 313         .max_avg_dram_bw_use_normal_percent = 40.0,
 314         .writeback_latency_us = 12.0,
 315         .ideal_dram_bw_after_urgent_percent = 40.0,
 316         .max_request_size_bytes = 256,
 317         .dram_channel_width_bytes = 2,
 318         .fabric_datapath_to_dcn_data_return_bytes = 64,
 319         .dcn_downspread_percent = 0.5,
 320         .downspread_percent = 0.38,
 321         .dram_page_open_time_ns = 50.0,
 322         .dram_rw_turnaround_time_ns = 17.5,
 323         .dram_return_buffer_per_channel_bytes = 8192,
 324         .round_trip_ping_latency_dcfclk_cycles = 131,
 325         .urgent_out_of_order_return_per_channel_bytes = 256,
 326         .channel_interleave_bytes = 256,
 327         .num_banks = 8,
 328         .num_chans = 16,
 329         .vmm_page_size_bytes = 4096,
 330         .dram_clock_change_latency_us = 404.0,
 331         .dummy_pstate_latency_us = 5.0,
 332         .writeback_dram_clock_change_latency_us = 23.0,
 333         .return_bus_width_bytes = 64,
 334         .dispclk_dppclk_vco_speed_mhz = 3850,
 335         .xfc_bus_transport_time_us = 20,
 336         .xfc_xbuf_latency_tolerance_us = 4,
 337         .use_urgent_burst_bw = 0
 338 };
 339
 340 static struct _vcs_dpi_soc_bounding_box_st dcn2_0_nv14_soc = {
 341         .clock_limits = {
 342                         {
 343                                 .state = 0,
 344                                 .dcfclk_mhz = 560.0,
 345                                 .fabricclk_mhz = 560.0,
 346                                 .dispclk_mhz = 513.0,
 347                                 .dppclk_mhz = 513.0,
 348                                 .phyclk_mhz = 540.0,
 349                                 .socclk_mhz = 560.0,
 350                                 .dscclk_mhz = 171.0,
 351                                 .dram_speed_mts = 8960.0,
 352                         },
 353                         {
 354                                 .state = 1,
 355                                 .dcfclk_mhz = 694.0,
 356                                 .fabricclk_mhz = 694.0,
 357                                 .dispclk_mhz = 642.0,
 358                                 .dppclk_mhz = 642.0,
 359                                 .phyclk_mhz = 600.0,
 360                                 .socclk_mhz = 694.0,
 361                                 .dscclk_mhz = 214.0,
 362                                 .dram_speed_mts = 11104.0,
 363                         },
 364                         {
 365                                 .state = 2,
 366                                 .dcfclk_mhz = 875.0,
 367                                 .fabricclk_mhz = 875.0,
 368                                 .dispclk_mhz = 734.0,
 369                                 .dppclk_mhz = 734.0,
 370                                 .phyclk_mhz = 810.0,
 371                                 .socclk_mhz = 875.0,
 372                                 .dscclk_mhz = 245.0,
 373                                 .dram_speed_mts = 14000.0,
 374                         },
 375                         {
 376                                 .state = 3,
 377                                 .dcfclk_mhz = 1000.0,
 378                                 .fabricclk_mhz = 1000.0,
 379                                 .dispclk_mhz = 1100.0,
 380                                 .dppclk_mhz = 1100.0,
 381                                 .phyclk_mhz = 810.0,
 382                                 .socclk_mhz = 1000.0,
 383                                 .dscclk_mhz = 367.0,
 384                                 .dram_speed_mts = 16000.0,
 385                         },
 386                         {
 387                                 .state = 4,
 388                                 .dcfclk_mhz = 1200.0,
 389                                 .fabricclk_mhz = 1200.0,
 390                                 .dispclk_mhz = 1284.0,
 391                                 .dppclk_mhz = 1284.0,
 392                                 .phyclk_mhz = 810.0,
 393                                 .socclk_mhz = 1200.0,
 394                                 .dscclk_mhz = 428.0,
 395                                 .dram_speed_mts = 16000.0,
 396                         },
 397                         /*Extra state, no dispclk ramping*/
 398                         {
 399                                 .state = 5,
 400                                 .dcfclk_mhz = 1200.0,
 401                                 .fabricclk_mhz = 1200.0,
 402                                 .dispclk_mhz = 1284.0,
 403                                 .dppclk_mhz = 1284.0,
 404                                 .phyclk_mhz = 810.0,
 405                                 .socclk_mhz = 1200.0,
 406                                 .dscclk_mhz = 428.0,
 407                                 .dram_speed_mts = 16000.0,
 408                         },
 409                 },
 410         .num_states = 5,
 411         .sr_exit_time_us = 11.6,
 412         .sr_enter_plus_exit_time_us = 13.9,
 413         .urgent_latency_us = 4.0,
 414         .urgent_latency_pixel_data_only_us = 4.0,
 415         .urgent_latency_pixel_mixed_with_vm_data_us = 4.0,
 416         .urgent_latency_vm_data_only_us = 4.0,
 417         .urgent_out_of_order_return_per_channel_pixel_only_bytes = 4096,
 418         .urgent_out_of_order_return_per_channel_pixel_and_vm_bytes = 4096,
 419         .urgent_out_of_order_return_per_channel_vm_only_bytes = 4096,
 420         .pct_ideal_dram_sdp_bw_after_urgent_pixel_only = 40.0,
 421         .pct_ideal_dram_sdp_bw_after_urgent_pixel_and_vm = 40.0,
 422         .pct_ideal_dram_sdp_bw_after_urgent_vm_only = 40.0,
 423         .max_avg_sdp_bw_use_normal_percent = 40.0,
 424         .max_avg_dram_bw_use_normal_percent = 40.0,
 425         .writeback_latency_us = 12.0,
 426         .ideal_dram_bw_after_urgent_percent = 40.0,
 427         .max_request_size_bytes = 256,
 428         .dram_channel_width_bytes = 2,
 429         .fabric_datapath_to_dcn_data_return_bytes = 64,
 430         .dcn_downspread_percent = 0.5,
 431         .downspread_percent = 0.38,
 432         .dram_page_open_time_ns = 50.0,
 433         .dram_rw_turnaround_time_ns = 17.5,
 434         .dram_return_buffer_per_channel_bytes = 8192,
 435         .round_trip_ping_latency_dcfclk_cycles = 131,
 436         .urgent_out_of_order_return_per_channel_bytes = 256,
 437         .channel_interleave_bytes = 256,
 438         .num_banks = 8,
 439         .num_chans = 8,
 440         .vmm_page_size_bytes = 4096,
 441         .dram_clock_change_latency_us = 404.0,
 442         .dummy_pstate_latency_us = 5.0,
 443         .writeback_dram_clock_change_latency_us = 23.0,
 444         .return_bus_width_bytes = 64,
 445         .dispclk_dppclk_vco_speed_mhz = 3850,
 446         .xfc_bus_transport_time_us = 20,
 447         .xfc_xbuf_latency_tolerance_us = 4,
 448         .use_urgent_burst_bw = 0
 449 };
 450
 451 static struct _vcs_dpi_soc_bounding_box_st dcn2_0_nv12_soc = { 0 };
 452
 453 #ifndef mmDP0_DP_DPHY_INTERNAL_CTRL
 454         #define mmDP0_DP_DPHY_INTERNAL_CTRL             0x210f
 455         #define mmDP0_DP_DPHY_INTERNAL_CTRL_BASE_IDX    2
 456         #define mmDP1_DP_DPHY_INTERNAL_CTRL             0x220f
 457         #define mmDP1_DP_DPHY_INTERNAL_CTRL_BASE_IDX    2
 458         #define mmDP2_DP_DPHY_INTERNAL_CTRL             0x230f
 459         #define mmDP2_DP_DPHY_INTERNAL_CTRL_BASE_IDX    2
 460         #define mmDP3_DP_DPHY_INTERNAL_CTRL             0x240f
 461         #define mmDP3_DP_DPHY_INTERNAL_CTRL_BASE_IDX    2
 462         #define mmDP4_DP_DPHY_INTERNAL_CTRL             0x250f
 463         #define mmDP4_DP_DPHY_INTERNAL_CTRL_BASE_IDX    2
 464         #define mmDP5_DP_DPHY_INTERNAL_CTRL             0x260f
 465         #define mmDP5_DP_DPHY_INTERNAL_CTRL_BASE_IDX    2
 466         #define mmDP6_DP_DPHY_INTERNAL_CTRL             0x270f
 467         #define mmDP6_DP_DPHY_INTERNAL_CTRL_BASE_IDX    2
 468 #endif
 469
 470
 471 enum dcn20_clk_src_array_id {
 472         DCN20_CLK_SRC_PLL0,
 473         DCN20_CLK_SRC_PLL1,
 474         DCN20_CLK_SRC_PLL2,
 475         DCN20_CLK_SRC_PLL3,
 476         DCN20_CLK_SRC_PLL4,
 477         DCN20_CLK_SRC_PLL5,
 478         DCN20_CLK_SRC_TOTAL
 479 };
 480
 481 /* begin *********************
 482  * macros to expend register list macro defined in HW object header file */
 483
 484 /* DCN */
 485 /* TODO awful hack. fixup dcn20_dwb.h */
 486 #undef BASE_INNER
 487 #define BASE_INNER(seg) DCN_BASE__INST0_SEG ## seg
 488
 489 #define BASE(seg) BASE_INNER(seg)
 490
 491 #define SR(reg_name)\
 492                 .reg_name = BASE(mm ## reg_name ## _BASE_IDX) +  \
 493                                         mm ## reg_name
 494
 495 #define SRI(reg_name, block, id)\
 496         .reg_name = BASE(mm ## block ## id ## _ ## reg_name ## _BASE_IDX) + \
 497                                         mm ## block ## id ## _ ## reg_name
 498
 499 #define SRIR(var_name, reg_name, block, id)\
 500         .var_name = BASE(mm ## block ## id ## _ ## reg_name ## _BASE_IDX) + \
 501                                         mm ## block ## id ## _ ## reg_name
 502
 503 #define SRII(reg_name, block, id)\
 504         .reg_name[id] = BASE(mm ## block ## id ## _ ## reg_name ## _BASE_IDX) + \
 505                                         mm ## block ## id ## _ ## reg_name
 506
 507 #define DCCG_SRII(reg_name, block, id)\
 508         .block ## _ ## reg_name[id] = BASE(mm ## block ## id ## _ ## reg_name ## _BASE_IDX) + \
 509                                         mm ## block ## id ## _ ## reg_name
 510
 511 #define VUPDATE_SRII(reg_name, block, id)\
 512         .reg_name[id] = BASE(mm ## reg_name ## _ ## block ## id ## _BASE_IDX) + \
 513                                         mm ## reg_name ## _ ## block ## id
 514
 515 /* NBIO */
 516 #define NBIO_BASE_INNER(seg) \
 517         NBIO_BASE__INST0_SEG ## seg
 518
 519 #define NBIO_BASE(seg) \
 520         NBIO_BASE_INNER(seg)
 521
 522 #define NBIO_SR(reg_name)\
 523                 .reg_name = NBIO_BASE(mm ## reg_name ## _BASE_IDX) + \
 524                                         mm ## reg_name
 525
 526 /* MMHUB */
 527 #define MMHUB_BASE_INNER(seg) \
 528         MMHUB_BASE__INST0_SEG ## seg
 529
 530 #define MMHUB_BASE(seg) \
 531         MMHUB_BASE_INNER(seg)
 532
 533 #define MMHUB_SR(reg_name)\
 534                 .reg_name = MMHUB_BASE(mmMM ## reg_name ## _BASE_IDX) + \
 535                                         mmMM ## reg_name
 536
 537 static const struct bios_registers bios_regs = {
 538                 NBIO_SR(BIOS_SCRATCH_3),
 539                 NBIO_SR(BIOS_SCRATCH_6)
 540 };
 541
 542 #define clk_src_regs(index, pllid)\
 543 [index] = {\
 544         CS_COMMON_REG_LIST_DCN2_0(index, pllid),\
 545 }
 546
 547 static const struct dce110_clk_src_regs clk_src_regs[] = {
 548         clk_src_regs(0, A),
 549         clk_src_regs(1, B),
 550         clk_src_regs(2, C),
 551         clk_src_regs(3, D),
 552         clk_src_regs(4, E),
 553         clk_src_regs(5, F)
 554 };
 555
 556 static const struct dce110_clk_src_shift cs_shift = {
 557                 CS_COMMON_MASK_SH_LIST_DCN2_0(__SHIFT)
 558 };
 559
 560 static const struct dce110_clk_src_mask cs_mask = {
 561                 CS_COMMON_MASK_SH_LIST_DCN2_0(_MASK)
 562 };
 563
 564 static const struct dce_dmcu_registers dmcu_regs = {
 565                 DMCU_DCN10_REG_LIST()
 566 };
 567
 568 static const struct dce_dmcu_shift dmcu_shift = {
 569                 DMCU_MASK_SH_LIST_DCN10(__SHIFT)
 570 };
 571
 572 static const struct dce_dmcu_mask dmcu_mask = {
 573                 DMCU_MASK_SH_LIST_DCN10(_MASK)
 574 };
 575
 576 static const struct dce_abm_registers abm_regs = {
 577                 ABM_DCN20_REG_LIST()
 578 };
 579
 580 static const struct dce_abm_shift abm_shift = {
 581                 ABM_MASK_SH_LIST_DCN20(__SHIFT)
 582 };
 583
 584 static const struct dce_abm_mask abm_mask = {
 585                 ABM_MASK_SH_LIST_DCN20(_MASK)
 586 };
 587
 588 #define audio_regs(id)\
 589 [id] = {\
 590                 AUD_COMMON_REG_LIST(id)\
 591 }
 592
 593 static const struct dce_audio_registers audio_regs[] = {
 594         audio_regs(0),
 595         audio_regs(1),
 596         audio_regs(2),
 597         audio_regs(3),
 598         audio_regs(4),
 599         audio_regs(5),
 600         audio_regs(6),
 601 };
 602
 603 #define DCE120_AUD_COMMON_MASK_SH_LIST(mask_sh)\
 604                 SF(AZF0ENDPOINT0_AZALIA_F0_CODEC_ENDPOINT_INDEX, AZALIA_ENDPOINT_REG_INDEX, mask_sh),\
 605                 SF(AZF0ENDPOINT0_AZALIA_F0_CODEC_ENDPOINT_DATA, AZALIA_ENDPOINT_REG_DATA, mask_sh),\
 606                 AUD_COMMON_MASK_SH_LIST_BASE(mask_sh)
 607
 608 static const struct dce_audio_shift audio_shift = {
 609                 DCE120_AUD_COMMON_MASK_SH_LIST(__SHIFT)
 610 };
 611
 612 static const struct dce_audio_mask audio_mask = {
 613                 DCE120_AUD_COMMON_MASK_SH_LIST(_MASK)
 614 };
 615
 616 #define stream_enc_regs(id)\
 617 [id] = {\
 618         SE_DCN2_REG_LIST(id)\
 619 }
 620
 621 static const struct dcn10_stream_enc_registers stream_enc_regs[] = {
 622         stream_enc_regs(0),
 623         stream_enc_regs(1),
 624         stream_enc_regs(2),
 625         stream_enc_regs(3),
 626         stream_enc_regs(4),
 627         stream_enc_regs(5),
 628 };
 629
 630 static const struct dcn10_stream_encoder_shift se_shift = {
 631                 SE_COMMON_MASK_SH_LIST_DCN20(__SHIFT)
 632 };
 633
 634 static const struct dcn10_stream_encoder_mask se_mask = {
 635                 SE_COMMON_MASK_SH_LIST_DCN20(_MASK)
 636 };
 637
 638
 639 #define aux_regs(id)\
 640 [id] = {\
 641         DCN2_AUX_REG_LIST(id)\
 642 }
 643
 644 static const struct dcn10_link_enc_aux_registers link_enc_aux_regs[] = {
 645                 aux_regs(0),
 646                 aux_regs(1),
 647                 aux_regs(2),
 648                 aux_regs(3),
 649                 aux_regs(4),
 650                 aux_regs(5)
 651 };
 652
 653 #define hpd_regs(id)\
 654 [id] = {\
 655         HPD_REG_LIST(id)\
 656 }
 657
 658 static const struct dcn10_link_enc_hpd_registers link_enc_hpd_regs[] = {
 659                 hpd_regs(0),
 660                 hpd_regs(1),
 661                 hpd_regs(2),
 662                 hpd_regs(3),
 663                 hpd_regs(4),
 664                 hpd_regs(5)
 665 };
 666
 667 #define link_regs(id, phyid)\
 668 [id] = {\
 669         LE_DCN10_REG_LIST(id), \
 670         UNIPHY_DCN2_REG_LIST(phyid), \
 671         DPCS_DCN2_REG_LIST(id), \
 672         SRI(DP_DPHY_INTERNAL_CTRL, DP, id) \
 673 }
 674
 675 static const struct dcn10_link_enc_registers link_enc_regs[] = {
 676         link_regs(0, A),
 677         link_regs(1, B),
 678         link_regs(2, C),
 679         link_regs(3, D),
 680         link_regs(4, E),
 681         link_regs(5, F)
 682 };
 683
 684 static const struct dcn10_link_enc_shift le_shift = {
 685         LINK_ENCODER_MASK_SH_LIST_DCN20(__SHIFT),\
 686         DPCS_DCN2_MASK_SH_LIST(__SHIFT)
 687 };
 688
 689 static const struct dcn10_link_enc_mask le_mask = {
 690         LINK_ENCODER_MASK_SH_LIST_DCN20(_MASK),\
 691         DPCS_DCN2_MASK_SH_LIST(_MASK)
 692 };
 693
 694 static const struct dce_panel_cntl_registers panel_cntl_regs[] = {
 695         { DCN_PANEL_CNTL_REG_LIST() }
 696 };
 697
 698 static const struct dce_panel_cntl_shift panel_cntl_shift = {
 699         DCE_PANEL_CNTL_MASK_SH_LIST(__SHIFT)
 700 };
 701
 702 static const struct dce_panel_cntl_mask panel_cntl_mask = {
 703         DCE_PANEL_CNTL_MASK_SH_LIST(_MASK)
 704 };
 705
 706 #define ipp_regs(id)\
 707 [id] = {\
 708         IPP_REG_LIST_DCN20(id),\
 709 }
 710
 711 static const struct dcn10_ipp_registers ipp_regs[] = {
 712         ipp_regs(0),
 713         ipp_regs(1),
 714         ipp_regs(2),
 715         ipp_regs(3),
 716         ipp_regs(4),
 717         ipp_regs(5),
 718 };
 719
 720 static const struct dcn10_ipp_shift ipp_shift = {
 721                 IPP_MASK_SH_LIST_DCN20(__SHIFT)
 722 };
 723
 724 static const struct dcn10_ipp_mask ipp_mask = {
 725                 IPP_MASK_SH_LIST_DCN20(_MASK),
 726 };
 727
 728 #define opp_regs(id)\
 729 [id] = {\
 730         OPP_REG_LIST_DCN20(id),\
 731 }
 732
 733 static const struct dcn20_opp_registers opp_regs[] = {
 734         opp_regs(0),
 735         opp_regs(1),
 736         opp_regs(2),
 737         opp_regs(3),
 738         opp_regs(4),
 739         opp_regs(5),
 740 };
 741
 742 static const struct dcn20_opp_shift opp_shift = {
 743                 OPP_MASK_SH_LIST_DCN20(__SHIFT)
 744 };
 745
 746 static const struct dcn20_opp_mask opp_mask = {
 747                 OPP_MASK_SH_LIST_DCN20(_MASK)
 748 };
 749
 750 #define aux_engine_regs(id)\
 751 [id] = {\
 752         AUX_COMMON_REG_LIST0(id), \
 753         .AUXN_IMPCAL = 0, \
 754         .AUXP_IMPCAL = 0, \
 755         .AUX_RESET_MASK = DP_AUX0_AUX_CONTROL__AUX_RESET_MASK, \
 756 }
 757
 758 static const struct dce110_aux_registers aux_engine_regs[] = {
 759                 aux_engine_regs(0),
 760                 aux_engine_regs(1),
 761                 aux_engine_regs(2),
 762                 aux_engine_regs(3),
 763                 aux_engine_regs(4),
 764                 aux_engine_regs(5)
 765 };
 766
 767 #define tf_regs(id)\
 768 [id] = {\
 769         TF_REG_LIST_DCN20(id),\
 770         TF_REG_LIST_DCN20_COMMON_APPEND(id),\
 771 }
 772
 773 static const struct dcn2_dpp_registers tf_regs[] = {
 774         tf_regs(0),
 775         tf_regs(1),
 776         tf_regs(2),
 777         tf_regs(3),
 778         tf_regs(4),
 779         tf_regs(5),
 780 };
 781
 782 static const struct dcn2_dpp_shift tf_shift = {
 783                 TF_REG_LIST_SH_MASK_DCN20(__SHIFT),
 784                 TF_DEBUG_REG_LIST_SH_DCN20
 785 };
 786
 787 static const struct dcn2_dpp_mask tf_mask = {
 788                 TF_REG_LIST_SH_MASK_DCN20(_MASK),
 789                 TF_DEBUG_REG_LIST_MASK_DCN20
 790 };
 791
 792 #define dwbc_regs_dcn2(id)\
 793 [id] = {\
 794         DWBC_COMMON_REG_LIST_DCN2_0(id),\
 795                 }
 796
 797 static const struct dcn20_dwbc_registers dwbc20_regs[] = {
 798         dwbc_regs_dcn2(0),
 799 };
 800
 801 static const struct dcn20_dwbc_shift dwbc20_shift = {
 802         DWBC_COMMON_MASK_SH_LIST_DCN2_0(__SHIFT)
 803 };
 804
 805 static const struct dcn20_dwbc_mask dwbc20_mask = {
 806         DWBC_COMMON_MASK_SH_LIST_DCN2_0(_MASK)
 807 };
 808
 809 #define mcif_wb_regs_dcn2(id)\
 810 [id] = {\
 811         MCIF_WB_COMMON_REG_LIST_DCN2_0(id),\
 812                 }
 813
 814 static const struct dcn20_mmhubbub_registers mcif_wb20_regs[] = {
 815         mcif_wb_regs_dcn2(0),
 816 };
 817
 818 static const struct dcn20_mmhubbub_shift mcif_wb20_shift = {
 819         MCIF_WB_COMMON_MASK_SH_LIST_DCN2_0(__SHIFT)
 820 };
 821
 822 static const struct dcn20_mmhubbub_mask mcif_wb20_mask = {
 823         MCIF_WB_COMMON_MASK_SH_LIST_DCN2_0(_MASK)
 824 };
 825
 826 static const struct dcn20_mpc_registers mpc_regs = {
 827                 MPC_REG_LIST_DCN2_0(0),
 828                 MPC_REG_LIST_DCN2_0(1),
 829                 MPC_REG_LIST_DCN2_0(2),
 830                 MPC_REG_LIST_DCN2_0(3),
 831                 MPC_REG_LIST_DCN2_0(4),
 832                 MPC_REG_LIST_DCN2_0(5),
 833                 MPC_OUT_MUX_REG_LIST_DCN2_0(0),
 834                 MPC_OUT_MUX_REG_LIST_DCN2_0(1),
 835                 MPC_OUT_MUX_REG_LIST_DCN2_0(2),
 836                 MPC_OUT_MUX_REG_LIST_DCN2_0(3),
 837                 MPC_OUT_MUX_REG_LIST_DCN2_0(4),
 838                 MPC_OUT_MUX_REG_LIST_DCN2_0(5),
 839                 MPC_DBG_REG_LIST_DCN2_0()
 840 };
 841
 842 static const struct dcn20_mpc_shift mpc_shift = {
 843         MPC_COMMON_MASK_SH_LIST_DCN2_0(__SHIFT),
 844         MPC_DEBUG_REG_LIST_SH_DCN20
 845 };
 846
 847 static const struct dcn20_mpc_mask mpc_mask = {
 848         MPC_COMMON_MASK_SH_LIST_DCN2_0(_MASK),
 849         MPC_DEBUG_REG_LIST_MASK_DCN20
 850 };
 851
 852 #define tg_regs(id)\
 853 [id] = {TG_COMMON_REG_LIST_DCN2_0(id)}
 854
 855
 856 static const struct dcn_optc_registers tg_regs[] = {
 857         tg_regs(0),
 858         tg_regs(1),
 859         tg_regs(2),
 860         tg_regs(3),
 861         tg_regs(4),
 862         tg_regs(5)
 863 };
 864
 865 static const struct dcn_optc_shift tg_shift = {
 866         TG_COMMON_MASK_SH_LIST_DCN2_0(__SHIFT)
 867 };
 868
 869 static const struct dcn_optc_mask tg_mask = {
 870         TG_COMMON_MASK_SH_LIST_DCN2_0(_MASK)
 871 };
 872
 873 #define hubp_regs(id)\
 874 [id] = {\
 875         HUBP_REG_LIST_DCN20(id)\
 876 }
 877
 878 static const struct dcn_hubp2_registers hubp_regs[] = {
 879                 hubp_regs(0),
 880                 hubp_regs(1),
 881                 hubp_regs(2),
 882                 hubp_regs(3),
 883                 hubp_regs(4),
 884                 hubp_regs(5)
 885 };
 886
 887 static const struct dcn_hubp2_shift hubp_shift = {
 888                 HUBP_MASK_SH_LIST_DCN20(__SHIFT)
 889 };
 890
 891 static const struct dcn_hubp2_mask hubp_mask = {
 892                 HUBP_MASK_SH_LIST_DCN20(_MASK)
 893 };
 894
 895 static const struct dcn_hubbub_registers hubbub_reg = {
 896                 HUBBUB_REG_LIST_DCN20(0)
 897 };
 898
 899 static const struct dcn_hubbub_shift hubbub_shift = {
 900                 HUBBUB_MASK_SH_LIST_DCN20(__SHIFT)
 901 };
 902
 903 static const struct dcn_hubbub_mask hubbub_mask = {
 904                 HUBBUB_MASK_SH_LIST_DCN20(_MASK)
 905 };
 906
 907 #define vmid_regs(id)\
 908 [id] = {\
 909                 DCN20_VMID_REG_LIST(id)\
 910 }
 911
 912 static const struct dcn_vmid_registers vmid_regs[] = {
 913         vmid_regs(0),
 914         vmid_regs(1),
 915         vmid_regs(2),
 916         vmid_regs(3),
 917         vmid_regs(4),
 918         vmid_regs(5),
 919         vmid_regs(6),
 920         vmid_regs(7),
 921         vmid_regs(8),
 922         vmid_regs(9),
 923         vmid_regs(10),
 924         vmid_regs(11),
 925         vmid_regs(12),
 926         vmid_regs(13),
 927         vmid_regs(14),
 928         vmid_regs(15)
 929 };
 930
 931 static const struct dcn20_vmid_shift vmid_shifts = {
 932                 DCN20_VMID_MASK_SH_LIST(__SHIFT)
 933 };
 934
 935 static const struct dcn20_vmid_mask vmid_masks = {
 936                 DCN20_VMID_MASK_SH_LIST(_MASK)
 937 };
 938
 939 static const struct dce110_aux_registers_shift aux_shift = {
 940                 DCN_AUX_MASK_SH_LIST(__SHIFT)
 941 };
 942
 943 static const struct dce110_aux_registers_mask aux_mask = {
 944                 DCN_AUX_MASK_SH_LIST(_MASK)
 945 };
 946
 947 static int map_transmitter_id_to_phy_instance(
 948         enum transmitter transmitter)
 949 {
 950         switch (transmitter) {
 951         case TRANSMITTER_UNIPHY_A:
 952                 return 0;
 953         break;
 954         case TRANSMITTER_UNIPHY_B:
 955                 return 1;
 956         break;
 957         case TRANSMITTER_UNIPHY_C:
 958                 return 2;
 959         break;
 960         case TRANSMITTER_UNIPHY_D:
 961                 return 3;
 962         break;
 963         case TRANSMITTER_UNIPHY_E:
 964                 return 4;
 965         break;
 966         case TRANSMITTER_UNIPHY_F:
 967                 return 5;
 968         break;
 969         default:
 970                 ASSERT(0);
 971                 return 0;
 972         }
 973 }
 974
 975 #define dsc_regsDCN20(id)\
 976 [id] = {\
 977         DSC_REG_LIST_DCN20(id)\
 978 }
 979
 980 static const struct dcn20_dsc_registers dsc_regs[] = {
 981         dsc_regsDCN20(0),
 982         dsc_regsDCN20(1),
 983         dsc_regsDCN20(2),
 984         dsc_regsDCN20(3),
 985         dsc_regsDCN20(4),
 986         dsc_regsDCN20(5)
 987 };
 988
 989 static const struct dcn20_dsc_shift dsc_shift = {
 990         DSC_REG_LIST_SH_MASK_DCN20(__SHIFT)
 991 };
 992
 993 static const struct dcn20_dsc_mask dsc_mask = {
 994         DSC_REG_LIST_SH_MASK_DCN20(_MASK)
 995 };
 996
 997 static const struct dccg_registers dccg_regs = {
 998                 DCCG_REG_LIST_DCN2()
 999 };
1000
1001 static const struct dccg_shift dccg_shift = {
1002                 DCCG_MASK_SH_LIST_DCN2(__SHIFT)
1003 };
1004
1005 static const struct dccg_mask dccg_mask = {
1006                 DCCG_MASK_SH_LIST_DCN2(_MASK)
1007 };
1008
1009 static const struct resource_caps res_cap_nv10 = {
1010                 .num_timing_generator = 6,
1011                 .num_opp = 6,
1012                 .num_video_plane = 6,
1013                 .num_audio = 7,
1014                 .num_stream_encoder = 6,
1015                 .num_pll = 6,
1016                 .num_dwb = 1,
1017                 .num_ddc = 6,
1018                 .num_vmid = 16,
1019                 .num_dsc = 6,
1020 };
1021
1022 static const struct dc_plane_cap plane_cap = {
1023         .type = DC_PLANE_TYPE_DCN_UNIVERSAL,
1024         .blends_with_above = true,
1025         .blends_with_below = true,
1026         .per_pixel_alpha = true,
1027
1028         .pixel_format_support = {
1029                         .argb8888 = true,
1030                         .nv12 = true,
1031                         .fp16 = true,
1032                         .p010 = true
1033         },
1034
1035         .max_upscale_factor = {
1036                         .argb8888 = 16000,
1037                         .nv12 = 16000,
1038                         .fp16 = 1
1039         },
1040
1041         .max_downscale_factor = {
1042                         .argb8888 = 250,
1043                         .nv12 = 250,
1044                         .fp16 = 1
1045         },
1046         16,
1047         16
1048 };
1049 static const struct resource_caps res_cap_nv14 = {
1050                 .num_timing_generator = 5,
1051                 .num_opp = 5,
1052                 .num_video_plane = 5,
1053                 .num_audio = 6,
1054                 .num_stream_encoder = 5,
1055                 .num_pll = 5,
1056                 .num_dwb = 1,
1057                 .num_ddc = 5,
1058                 .num_vmid = 16,
1059                 .num_dsc = 5,
1060 };
1061
1062 static const struct dc_debug_options debug_defaults_drv = {
1063                 .disable_dmcu = false,
1064                 .force_abm_enable = false,
1065                 .timing_trace = false,
1066                 .clock_trace = true,
1067                 .disable_pplib_clock_request = true,
1068                 .pipe_split_policy = MPC_SPLIT_DYNAMIC,
1069                 .force_single_disp_pipe_split = false,
1070                 .disable_dcc = DCC_ENABLE,
1071                 .vsr_support = true,
1072                 .performance_trace = false,
1073                 .max_downscale_src_width = 5120,/*upto 5K*/
1074                 .disable_pplib_wm_range = false,
1075                 .scl_reset_length10 = true,
1076                 .sanity_checks = false,
1077                 .underflow_assert_delay_us = 0xFFFFFFFF,
1078 };
1079
1080 static const struct dc_debug_options debug_defaults_diags = {
1081                 .disable_dmcu = false,
1082                 .force_abm_enable = false,
1083                 .timing_trace = true,
1084                 .clock_trace = true,
1085                 .disable_dpp_power_gate = true,
1086                 .disable_hubp_power_gate = true,
1087                 .disable_clock_gate = true,
1088                 .disable_pplib_clock_request = true,
1089                 .disable_pplib_wm_range = true,
1090                 .disable_stutter = true,
1091                 .scl_reset_length10 = true,
1092                 .underflow_assert_delay_us = 0xFFFFFFFF,
1093                 .enable_tri_buf = true,
1094 };
1095
1096 void dcn20_dpp_destroy(struct dpp **dpp)
1097 {
1098         kfree(TO_DCN20_DPP(*dpp));
1099         *dpp = NULL;
1100 }
1101
1102 struct dpp *dcn20_dpp_create(
1103         struct dc_context *ctx,
1104         uint32_t inst)
1105 {
1106         struct dcn20_dpp *dpp =
1107                 kzalloc(sizeof(struct dcn20_dpp), GFP_ATOMIC);
1108
1109         if (!dpp)
1110                 return NULL;
1111
1112         if (dpp2_construct(dpp, ctx, inst,
1113                         &tf_regs[inst], &tf_shift, &tf_mask))
1114                 return &dpp->base;
1115
1116         BREAK_TO_DEBUGGER();
1117         kfree(dpp);
1118         return NULL;
1119 }
1120
1121 struct input_pixel_processor *dcn20_ipp_create(
1122         struct dc_context *ctx, uint32_t inst)
1123 {
1124         struct dcn10_ipp *ipp =
1125                 kzalloc(sizeof(struct dcn10_ipp), GFP_ATOMIC);
1126
1127         if (!ipp) {
1128                 BREAK_TO_DEBUGGER();
1129                 return NULL;
1130         }
1131
1132         dcn20_ipp_construct(ipp, ctx, inst,
1133                         &ipp_regs[inst], &ipp_shift, &ipp_mask);
1134         return &ipp->base;
1135 }
1136
1137
1138 struct output_pixel_processor *dcn20_opp_create(
1139         struct dc_context *ctx, uint32_t inst)
1140 {
1141         struct dcn20_opp *opp =
1142                 kzalloc(sizeof(struct dcn20_opp), GFP_ATOMIC);
1143
1144         if (!opp) {
1145                 BREAK_TO_DEBUGGER();
1146                 return NULL;
1147         }
1148
1149         dcn20_opp_construct(opp, ctx, inst,
1150                         &opp_regs[inst], &opp_shift, &opp_mask);
1151         return &opp->base;
1152 }
1153
1154 struct dce_aux *dcn20_aux_engine_create(
1155         struct dc_context *ctx,
1156         uint32_t inst)
1157 {
1158         struct aux_engine_dce110 *aux_engine =
1159                 kzalloc(sizeof(struct aux_engine_dce110), GFP_ATOMIC);
1160
1161         if (!aux_engine)
1162                 return NULL;
1163
1164         dce110_aux_engine_construct(aux_engine, ctx, inst,
1165                                     SW_AUX_TIMEOUT_PERIOD_MULTIPLIER * AUX_TIMEOUT_PERIOD,
1166                                     &aux_engine_regs[inst],
1167                                         &aux_mask,
1168                                         &aux_shift,
1169                                         ctx->dc->caps.extended_aux_timeout_support);
1170
1171         return &aux_engine->base;
1172 }
1173 #define i2c_inst_regs(id) { I2C_HW_ENGINE_COMMON_REG_LIST(id) }
1174
1175 static const struct dce_i2c_registers i2c_hw_regs[] = {
1176                 i2c_inst_regs(1),
1177                 i2c_inst_regs(2),
1178                 i2c_inst_regs(3),
1179                 i2c_inst_regs(4),
1180                 i2c_inst_regs(5),
1181                 i2c_inst_regs(6),
1182 };
1183
1184 static const struct dce_i2c_shift i2c_shifts = {
1185                 I2C_COMMON_MASK_SH_LIST_DCN2(__SHIFT)
1186 };
1187
1188 static const struct dce_i2c_mask i2c_masks = {
1189                 I2C_COMMON_MASK_SH_LIST_DCN2(_MASK)
1190 };
1191
1192 struct dce_i2c_hw *dcn20_i2c_hw_create(
1193         struct dc_context *ctx,
1194         uint32_t inst)
1195 {
1196         struct dce_i2c_hw *dce_i2c_hw =
1197                 kzalloc(sizeof(struct dce_i2c_hw), GFP_ATOMIC);
1198
1199         if (!dce_i2c_hw)
1200                 return NULL;
1201
1202         dcn2_i2c_hw_construct(dce_i2c_hw, ctx, inst,
1203                                     &i2c_hw_regs[inst], &i2c_shifts, &i2c_masks);
1204
1205         return dce_i2c_hw;
1206 }
1207 struct mpc *dcn20_mpc_create(struct dc_context *ctx)
1208 {
1209         struct dcn20_mpc *mpc20 = kzalloc(sizeof(struct dcn20_mpc),
1210                                           GFP_ATOMIC);
1211
1212         if (!mpc20)
1213                 return NULL;
1214
1215         dcn20_mpc_construct(mpc20, ctx,
1216                         &mpc_regs,
1217                         &mpc_shift,
1218                         &mpc_mask,
1219                         6);
1220
1221         return &mpc20->base;
1222 }
1223
1224 struct hubbub *dcn20_hubbub_create(struct dc_context *ctx)
1225 {
1226         int i;
1227         struct dcn20_hubbub *hubbub = kzalloc(sizeof(struct dcn20_hubbub),
1228                                           GFP_ATOMIC);
1229
1230         if (!hubbub)
1231                 return NULL;
1232
1233         hubbub2_construct(hubbub, ctx,
1234                         &hubbub_reg,
1235                         &hubbub_shift,
1236                         &hubbub_mask);
1237
1238         for (i = 0; i < res_cap_nv10.num_vmid; i++) {
1239                 struct dcn20_vmid *vmid = &hubbub->vmid[i];
1240
1241                 vmid->ctx = ctx;
1242
1243                 vmid->regs = &vmid_regs[i];
1244                 vmid->shifts = &vmid_shifts;
1245                 vmid->masks = &vmid_masks;
1246         }
1247
1248         return &hubbub->base;
1249 }
1250
1251 struct timing_generator *dcn20_timing_generator_create(
1252                 struct dc_context *ctx,
1253                 uint32_t instance)
1254 {
1255         struct optc *tgn10 =
1256                 kzalloc(sizeof(struct optc), GFP_ATOMIC);
1257
1258         if (!tgn10)
1259                 return NULL;
1260
1261         tgn10->base.inst = instance;
1262         tgn10->base.ctx = ctx;
1263
1264         tgn10->tg_regs = &tg_regs[instance];
1265         tgn10->tg_shift = &tg_shift;
1266         tgn10->tg_mask = &tg_mask;
1267
1268         dcn20_timing_generator_init(tgn10);
1269
1270         return &tgn10->base;
1271 }
1272
1273 static const struct encoder_feature_support link_enc_feature = {
1274                 .max_hdmi_deep_color = COLOR_DEPTH_121212,
1275                 .max_hdmi_pixel_clock = 600000,
1276                 .hdmi_ycbcr420_supported = true,
1277                 .dp_ycbcr420_supported = true,
1278                 .fec_supported = true,
1279                 .flags.bits.IS_HBR2_CAPABLE = true,
1280                 .flags.bits.IS_HBR3_CAPABLE = true,
1281                 .flags.bits.IS_TPS3_CAPABLE = true,
1282                 .flags.bits.IS_TPS4_CAPABLE = true
1283 };
1284
1285 struct link_encoder *dcn20_link_encoder_create(
1286         const struct encoder_init_data *enc_init_data)
1287 {
1288         struct dcn20_link_encoder *enc20 =
1289                 kzalloc(sizeof(struct dcn20_link_encoder), GFP_KERNEL);
1290         int link_regs_id;
1291
1292         if (!enc20)
1293                 return NULL;
1294
1295         link_regs_id =
1296                 map_transmitter_id_to_phy_instance(enc_init_data->transmitter);
1297
1298         dcn20_link_encoder_construct(enc20,
1299                                       enc_init_data,
1300                                       &link_enc_feature,
1301                                       &link_enc_regs[link_regs_id],
1302                                       &link_enc_aux_regs[enc_init_data->channel - 1],
1303                                       &link_enc_hpd_regs[enc_init_data->hpd_source],
1304                                       &le_shift,
1305                                       &le_mask);
1306
1307         return &enc20->enc10.base;
1308 }
1309
1310 static struct panel_cntl *dcn20_panel_cntl_create(const struct panel_cntl_init_data *init_data)
1311 {
1312         struct dce_panel_cntl *panel_cntl =
1313                 kzalloc(sizeof(struct dce_panel_cntl), GFP_KERNEL);
1314
1315         if (!panel_cntl)
1316                 return NULL;
1317
1318         dce_panel_cntl_construct(panel_cntl,
1319                         init_data,
1320                         &panel_cntl_regs[init_data->inst],
1321                         &panel_cntl_shift,
1322                         &panel_cntl_mask);
1323
1324         return &panel_cntl->base;
1325 }
1326
1327 static struct clock_source *dcn20_clock_source_create(
1328         struct dc_context *ctx,
1329         struct dc_bios *bios,
1330         enum clock_source_id id,
1331         const struct dce110_clk_src_regs *regs,
1332         bool dp_clk_src)
1333 {
1334         struct dce110_clk_src *clk_src =
1335                 kzalloc(sizeof(struct dce110_clk_src), GFP_ATOMIC);
1336
1337         if (!clk_src)
1338                 return NULL;
1339
1340         if (dcn20_clk_src_construct(clk_src, ctx, bios, id,
1341                         regs, &cs_shift, &cs_mask)) {
1342                 clk_src->base.dp_clk_src = dp_clk_src;
1343                 return &clk_src->base;
1344         }
1345
1346         kfree(clk_src);
1347         BREAK_TO_DEBUGGER();
1348         return NULL;
1349 }
1350
1351 static void read_dce_straps(
1352         struct dc_context *ctx,
1353         struct resource_straps *straps)
1354 {
1355         generic_reg_get(ctx, mmDC_PINSTRAPS + BASE(mmDC_PINSTRAPS_BASE_IDX),
1356                 FN(DC_PINSTRAPS, DC_PINSTRAPS_AUDIO), &straps->dc_pinstraps_audio);
1357 }
1358
1359 static struct audio *dcn20_create_audio(
1360                 struct dc_context *ctx, unsigned int inst)
1361 {
1362         return dce_audio_create(ctx, inst,
1363                         &audio_regs[inst], &audio_shift, &audio_mask);
1364 }
1365
1366 struct stream_encoder *dcn20_stream_encoder_create(
1367         enum engine_id eng_id,
1368         struct dc_context *ctx)
1369 {
1370         struct dcn10_stream_encoder *enc1 =
1371                 kzalloc(sizeof(struct dcn10_stream_encoder), GFP_KERNEL);
1372
1373         if (!enc1)
1374                 return NULL;
1375
1376         if (ASICREV_IS_NAVI14_M(ctx->asic_id.hw_internal_rev)) {
1377                 if (eng_id >= ENGINE_ID_DIGD)
1378                         eng_id++;
1379         }
1380
1381         dcn20_stream_encoder_construct(enc1, ctx, ctx->dc_bios, eng_id,
1382                                         &stream_enc_regs[eng_id],
1383                                         &se_shift, &se_mask);
1384
1385         return &enc1->base;
1386 }
1387
1388 static const struct dce_hwseq_registers hwseq_reg = {
1389                 HWSEQ_DCN2_REG_LIST()
1390 };
1391
1392 static const struct dce_hwseq_shift hwseq_shift = {
1393                 HWSEQ_DCN2_MASK_SH_LIST(__SHIFT)
1394 };
1395
1396 static const struct dce_hwseq_mask hwseq_mask = {
1397                 HWSEQ_DCN2_MASK_SH_LIST(_MASK)
1398 };
1399
1400 struct dce_hwseq *dcn20_hwseq_create(
1401         struct dc_context *ctx)
1402 {
1403         struct dce_hwseq *hws = kzalloc(sizeof(struct dce_hwseq), GFP_KERNEL);
1404
1405         if (hws) {
1406                 hws->ctx = ctx;
1407                 hws->regs = &hwseq_reg;
1408                 hws->shifts = &hwseq_shift;
1409                 hws->masks = &hwseq_mask;
1410         }
1411         return hws;
1412 }
1413
1414 static const struct resource_create_funcs res_create_funcs = {
1415         .read_dce_straps = read_dce_straps,
1416         .create_audio = dcn20_create_audio,
1417         .create_stream_encoder = dcn20_stream_encoder_create,
1418         .create_hwseq = dcn20_hwseq_create,
1419 };
1420
1421 static const struct resource_create_funcs res_create_maximus_funcs = {
1422         .read_dce_straps = NULL,
1423         .create_audio = NULL,
1424         .create_stream_encoder = NULL,
1425         .create_hwseq = dcn20_hwseq_create,
1426 };
1427
1428 static void dcn20_pp_smu_destroy(struct pp_smu_funcs **pp_smu);
1429
1430 void dcn20_clock_source_destroy(struct clock_source **clk_src)
1431 {
1432         kfree(TO_DCE110_CLK_SRC(*clk_src));
1433         *clk_src = NULL;
1434 }
1435
1436
1437 struct display_stream_compressor *dcn20_dsc_create(
1438         struct dc_context *ctx, uint32_t inst)
1439 {
1440         struct dcn20_dsc *dsc =
1441                 kzalloc(sizeof(struct dcn20_dsc), GFP_ATOMIC);
1442
1443         if (!dsc) {
1444                 BREAK_TO_DEBUGGER();
1445                 return NULL;
1446         }
1447
1448         dsc2_construct(dsc, ctx, inst, &dsc_regs[inst], &dsc_shift, &dsc_mask);
1449         return &dsc->base;
1450 }
1451
1452 void dcn20_dsc_destroy(struct display_stream_compressor **dsc)
1453 {
1454         kfree(container_of(*dsc, struct dcn20_dsc, base));
1455         *dsc = NULL;
1456 }
1457
1458
1459 static void dcn20_resource_destruct(struct dcn20_resource_pool *pool)
1460 {
1461         unsigned int i;
1462
1463         for (i = 0; i < pool->base.stream_enc_count; i++) {
1464                 if (pool->base.stream_enc[i] != NULL) {
1465                         kfree(DCN10STRENC_FROM_STRENC(pool->base.stream_enc[i]));
1466                         pool->base.stream_enc[i] = NULL;
1467                 }
1468         }
1469
1470         for (i = 0; i < pool->base.res_cap->num_dsc; i++) {
1471                 if (pool->base.dscs[i] != NULL)
1472                         dcn20_dsc_destroy(&pool->base.dscs[i]);
1473         }
1474
1475         if (pool->base.mpc != NULL) {
1476                 kfree(TO_DCN20_MPC(pool->base.mpc));
1477                 pool->base.mpc = NULL;
1478         }
1479         if (pool->base.hubbub != NULL) {
1480                 kfree(pool->base.hubbub);
1481                 pool->base.hubbub = NULL;
1482         }
1483         for (i = 0; i < pool->base.pipe_count; i++) {
1484                 if (pool->base.dpps[i] != NULL)
1485                         dcn20_dpp_destroy(&pool->base.dpps[i]);
1486
1487                 if (pool->base.ipps[i] != NULL)
1488                         pool->base.ipps[i]->funcs->ipp_destroy(&pool->base.ipps[i]);
1489
1490                 if (pool->base.hubps[i] != NULL) {
1491                         kfree(TO_DCN20_HUBP(pool->base.hubps[i]));
1492                         pool->base.hubps[i] = NULL;
1493                 }
1494
1495                 if (pool->base.irqs != NULL) {
1496                         dal_irq_service_destroy(&pool->base.irqs);
1497                 }
1498         }
1499
1500         for (i = 0; i < pool->base.res_cap->num_ddc; i++) {
1501                 if (pool->base.engines[i] != NULL)
1502                         dce110_engine_destroy(&pool->base.engines[i]);
1503                 if (pool->base.hw_i2cs[i] != NULL) {
1504                         kfree(pool->base.hw_i2cs[i]);
1505                         pool->base.hw_i2cs[i] = NULL;
1506                 }
1507                 if (pool->base.sw_i2cs[i] != NULL) {
1508                         kfree(pool->base.sw_i2cs[i]);
1509                         pool->base.sw_i2cs[i] = NULL;
1510                 }
1511         }
1512
1513         for (i = 0; i < pool->base.res_cap->num_opp; i++) {
1514                 if (pool->base.opps[i] != NULL)
1515                         pool->base.opps[i]->funcs->opp_destroy(&pool->base.opps[i]);
1516         }
1517
1518         for (i = 0; i < pool->base.res_cap->num_timing_generator; i++) {
1519                 if (pool->base.timing_generators[i] != NULL)    {
1520                         kfree(DCN10TG_FROM_TG(pool->base.timing_generators[i]));
1521                         pool->base.timing_generators[i] = NULL;
1522                 }
1523         }
1524
1525         for (i = 0; i < pool->base.res_cap->num_dwb; i++) {
1526                 if (pool->base.dwbc[i] != NULL) {
1527                         kfree(TO_DCN20_DWBC(pool->base.dwbc[i]));
1528                         pool->base.dwbc[i] = NULL;
1529                 }
1530                 if (pool->base.mcif_wb[i] != NULL) {
1531                         kfree(TO_DCN20_MMHUBBUB(pool->base.mcif_wb[i]));
1532                         pool->base.mcif_wb[i] = NULL;
1533                 }
1534         }
1535
1536         for (i = 0; i < pool->base.audio_count; i++) {
1537                 if (pool->base.audios[i])
1538                         dce_aud_destroy(&pool->base.audios[i]);
1539         }
1540
1541         for (i = 0; i < pool->base.clk_src_count; i++) {
1542                 if (pool->base.clock_sources[i] != NULL) {
1543                         dcn20_clock_source_destroy(&pool->base.clock_sources[i]);
1544                         pool->base.clock_sources[i] = NULL;
1545                 }
1546         }
1547
1548         if (pool->base.dp_clock_source != NULL) {
1549                 dcn20_clock_source_destroy(&pool->base.dp_clock_source);
1550                 pool->base.dp_clock_source = NULL;
1551         }
1552
1553
1554         if (pool->base.abm != NULL)
1555                 dce_abm_destroy(&pool->base.abm);
1556
1557         if (pool->base.dmcu != NULL)
1558                 dce_dmcu_destroy(&pool->base.dmcu);
1559
1560         if (pool->base.dccg != NULL)
1561                 dcn_dccg_destroy(&pool->base.dccg);
1562
1563         if (pool->base.pp_smu != NULL)
1564                 dcn20_pp_smu_destroy(&pool->base.pp_smu);
1565
1566         if (pool->base.oem_device != NULL)
1567                 dal_ddc_service_destroy(&pool->base.oem_device);
1568 }
1569
1570 struct hubp *dcn20_hubp_create(
1571         struct dc_context *ctx,
1572         uint32_t inst)
1573 {
1574         struct dcn20_hubp *hubp2 =
1575                 kzalloc(sizeof(struct dcn20_hubp), GFP_ATOMIC);
1576
1577         if (!hubp2)
1578                 return NULL;
1579
1580         if (hubp2_construct(hubp2, ctx, inst,
1581                         &hubp_regs[inst], &hubp_shift, &hubp_mask))
1582                 return &hubp2->base;
1583
1584         BREAK_TO_DEBUGGER();
1585         kfree(hubp2);
1586         return NULL;
1587 }
1588
1589 static void get_pixel_clock_parameters(
1590         struct pipe_ctx *pipe_ctx,
1591         struct pixel_clk_params *pixel_clk_params)
1592 {
1593         const struct dc_stream_state *stream = pipe_ctx->stream;
1594         struct pipe_ctx *odm_pipe;
1595         int opp_cnt = 1;
1596
1597         for (odm_pipe = pipe_ctx->next_odm_pipe; odm_pipe; odm_pipe = odm_pipe->next_odm_pipe)
1598                 opp_cnt++;
1599
1600         pixel_clk_params->requested_pix_clk_100hz = stream->timing.pix_clk_100hz;
1601         pixel_clk_params->encoder_object_id = stream->link->link_enc->id;
1602         pixel_clk_params->signal_type = pipe_ctx->stream->signal;
1603         pixel_clk_params->controller_id = pipe_ctx->stream_res.tg->inst + 1;
1604         /* TODO: un-hardcode*/
1605         pixel_clk_params->requested_sym_clk = LINK_RATE_LOW *
1606                 LINK_RATE_REF_FREQ_IN_KHZ;
1607         pixel_clk_params->flags.ENABLE_SS = 0;
1608         pixel_clk_params->color_depth =
1609                 stream->timing.display_color_depth;
1610         pixel_clk_params->flags.DISPLAY_BLANKED = 1;
1611         pixel_clk_params->pixel_encoding = stream->timing.pixel_encoding;
1612
1613         if (stream->timing.pixel_encoding == PIXEL_ENCODING_YCBCR422)
1614                 pixel_clk_params->color_depth = COLOR_DEPTH_888;
1615
1616         if (opp_cnt == 4)
1617                 pixel_clk_params->requested_pix_clk_100hz /= 4;
1618         else if (optc2_is_two_pixels_per_containter(&stream->timing) || opp_cnt == 2)
1619                 pixel_clk_params->requested_pix_clk_100hz /= 2;
1620
1621         if (stream->timing.timing_3d_format == TIMING_3D_FORMAT_HW_FRAME_PACKING)
1622                 pixel_clk_params->requested_pix_clk_100hz *= 2;
1623
1624 }
1625
1626 static void build_clamping_params(struct dc_stream_state *stream)
1627 {
1628         stream->clamping.clamping_level = CLAMPING_FULL_RANGE;
1629         stream->clamping.c_depth = stream->timing.display_color_depth;
1630         stream->clamping.pixel_encoding = stream->timing.pixel_encoding;
1631 }
1632
1633 static enum dc_status build_pipe_hw_param(struct pipe_ctx *pipe_ctx)
1634 {
1635
1636         get_pixel_clock_parameters(pipe_ctx, &pipe_ctx->stream_res.pix_clk_params);
1637
1638         pipe_ctx->clock_source->funcs->get_pix_clk_dividers(
1639                 pipe_ctx->clock_source,
1640                 &pipe_ctx->stream_res.pix_clk_params,
1641                 &pipe_ctx->pll_settings);
1642
1643         pipe_ctx->stream->clamping.pixel_encoding = pipe_ctx->stream->timing.pixel_encoding;
1644
1645         resource_build_bit_depth_reduction_params(pipe_ctx->stream,
1646                                         &pipe_ctx->stream->bit_depth_params);
1647         build_clamping_params(pipe_ctx->stream);
1648
1649         return DC_OK;
1650 }
1651
1652 enum dc_status dcn20_build_mapped_resource(const struct dc *dc, struct dc_state *context, struct dc_stream_state *stream)
1653 {
1654         enum dc_status status = DC_OK;
1655         struct pipe_ctx *pipe_ctx = resource_get_head_pipe_for_stream(&context->res_ctx, stream);
1656
1657         if (!pipe_ctx)
1658                 return DC_ERROR_UNEXPECTED;
1659
1660
1661         status = build_pipe_hw_param(pipe_ctx);
1662
1663         return status;
1664 }
1665
1666
1667 void dcn20_acquire_dsc(const struct dc *dc,
1668                         struct resource_context *res_ctx,
1669                         struct display_stream_compressor **dsc,
1670                         int pipe_idx)
1671 {
1672         int i;
1673         const struct resource_pool *pool = dc->res_pool;
1674         struct display_stream_compressor *dsc_old = dc->current_state->res_ctx.pipe_ctx[pipe_idx].stream_res.dsc;
1675
1676         ASSERT(*dsc == NULL); /* If this ASSERT fails, dsc was not released properly */
1677         *dsc = NULL;
1678
1679         /* Always do 1-to-1 mapping when number of DSCs is same as number of pipes */
1680         if (pool->res_cap->num_dsc == pool->res_cap->num_opp) {
1681                 *dsc = pool->dscs[pipe_idx];
1682                 res_ctx->is_dsc_acquired[pipe_idx] = true;
1683                 return;
1684         }
1685
1686         /* Return old DSC to avoid the need for re-programming */
1687         if (dsc_old && !res_ctx->is_dsc_acquired[dsc_old->inst]) {
1688                 *dsc = dsc_old;
1689                 res_ctx->is_dsc_acquired[dsc_old->inst] = true;
1690                 return ;
1691         }
1692
1693         /* Find first free DSC */
1694         for (i = 0; i < pool->res_cap->num_dsc; i++)
1695                 if (!res_ctx->is_dsc_acquired[i]) {
1696                         *dsc = pool->dscs[i];
1697                         res_ctx->is_dsc_acquired[i] = true;
1698                         break;
1699                 }
1700 }
1701
1702 void dcn20_release_dsc(struct resource_context *res_ctx,
1703                         const struct resource_pool *pool,
1704                         struct display_stream_compressor **dsc)
1705 {
1706         int i;
1707
1708         for (i = 0; i < pool->res_cap->num_dsc; i++)
1709                 if (pool->dscs[i] == *dsc) {
1710                         res_ctx->is_dsc_acquired[i] = false;
1711                         *dsc = NULL;
1712                         break;
1713                 }
1714 }
1715
1716
1717
1718 enum dc_status dcn20_add_dsc_to_stream_resource(struct dc *dc,
1719                 struct dc_state *dc_ctx,
1720                 struct dc_stream_state *dc_stream)
1721 {
1722         enum dc_status result = DC_OK;
1723         int i;
1724
1725         /* Get a DSC if required and available */
1726         for (i = 0; i < dc->res_pool->pipe_count; i++) {
1727                 struct pipe_ctx *pipe_ctx = &dc_ctx->res_ctx.pipe_ctx[i];
1728
1729                 if (pipe_ctx->stream != dc_stream)
1730                         continue;
1731
1732                 if (pipe_ctx->stream_res.dsc)
1733                         continue;
1734
1735                 dcn20_acquire_dsc(dc, &dc_ctx->res_ctx, &pipe_ctx->stream_res.dsc, i);
1736
1737                 /* The number of DSCs can be less than the number of pipes */
1738                 if (!pipe_ctx->stream_res.dsc) {
1739                         result = DC_NO_DSC_RESOURCE;
1740                 }
1741
1742                 break;
1743         }
1744
1745         return result;
1746 }
1747
1748
1749 static enum dc_status remove_dsc_from_stream_resource(struct dc *dc,
1750                 struct dc_state *new_ctx,
1751                 struct dc_stream_state *dc_stream)
1752 {
1753         struct pipe_ctx *pipe_ctx = NULL;
1754         int i;
1755
1756         for (i = 0; i < MAX_PIPES; i++) {
1757                 if (new_ctx->res_ctx.pipe_ctx[i].stream == dc_stream && !new_ctx->res_ctx.pipe_ctx[i].top_pipe) {
1758                         pipe_ctx = &new_ctx->res_ctx.pipe_ctx[i];
1759
1760                         if (pipe_ctx->stream_res.dsc)
1761                                 dcn20_release_dsc(&new_ctx->res_ctx, dc->res_pool, &pipe_ctx->stream_res.dsc);
1762                 }
1763         }
1764
1765         if (!pipe_ctx)
1766                 return DC_ERROR_UNEXPECTED;
1767         else
1768                 return DC_OK;
1769 }
1770
1771
1772 enum dc_status dcn20_add_stream_to_ctx(struct dc *dc, struct dc_state *new_ctx, struct dc_stream_state *dc_stream)
1773 {
1774         enum dc_status result = DC_ERROR_UNEXPECTED;
1775
1776         result = resource_map_pool_resources(dc, new_ctx, dc_stream);
1777
1778         if (result == DC_OK)
1779                 result = resource_map_phy_clock_resources(dc, new_ctx, dc_stream);
1780
1781         /* Get a DSC if required and available */
1782         if (result == DC_OK && dc_stream->timing.flags.DSC)
1783                 result = dcn20_add_dsc_to_stream_resource(dc, new_ctx, dc_stream);
1784
1785         if (result == DC_OK)
1786                 result = dcn20_build_mapped_resource(dc, new_ctx, dc_stream);
1787
1788         return result;
1789 }
1790
1791
1792 enum dc_status dcn20_remove_stream_from_ctx(struct dc *dc, struct dc_state *new_ctx, struct dc_stream_state *dc_stream)
1793 {
1794         enum dc_status result = DC_OK;
1795
1796         result = remove_dsc_from_stream_resource(dc, new_ctx, dc_stream);
1797
1798         return result;
1799 }
1800
1801
1802 static void swizzle_to_dml_params(
1803                 enum swizzle_mode_values swizzle,
1804                 unsigned int *sw_mode)
1805 {
1806         switch (swizzle) {
1807         case DC_SW_LINEAR:
1808                 *sw_mode = dm_sw_linear;
1809                 break;
1810         case DC_SW_4KB_S:
1811                 *sw_mode = dm_sw_4kb_s;
1812                 break;
1813         case DC_SW_4KB_S_X:
1814                 *sw_mode = dm_sw_4kb_s_x;
1815                 break;
1816         case DC_SW_4KB_D:
1817                 *sw_mode = dm_sw_4kb_d;
1818                 break;
1819         case DC_SW_4KB_D_X:
1820                 *sw_mode = dm_sw_4kb_d_x;
1821                 break;
1822         case DC_SW_64KB_S:
1823                 *sw_mode = dm_sw_64kb_s;
1824                 break;
1825         case DC_SW_64KB_S_X:
1826                 *sw_mode = dm_sw_64kb_s_x;
1827                 break;
1828         case DC_SW_64KB_S_T:
1829                 *sw_mode = dm_sw_64kb_s_t;
1830                 break;
1831         case DC_SW_64KB_D:
1832                 *sw_mode = dm_sw_64kb_d;
1833                 break;
1834         case DC_SW_64KB_D_X:
1835                 *sw_mode = dm_sw_64kb_d_x;
1836                 break;
1837         case DC_SW_64KB_D_T:
1838                 *sw_mode = dm_sw_64kb_d_t;
1839                 break;
1840         case DC_SW_64KB_R_X:
1841                 *sw_mode = dm_sw_64kb_r_x;
1842                 break;
1843         case DC_SW_VAR_S:
1844                 *sw_mode = dm_sw_var_s;
1845                 break;
1846         case DC_SW_VAR_S_X:
1847                 *sw_mode = dm_sw_var_s_x;
1848                 break;
1849         case DC_SW_VAR_D:
1850                 *sw_mode = dm_sw_var_d;
1851                 break;
1852         case DC_SW_VAR_D_X:
1853                 *sw_mode = dm_sw_var_d_x;
1854                 break;
1855
1856         default:
1857                 ASSERT(0); /* Not supported */
1858                 break;
1859         }
1860 }
1861
1862 bool dcn20_split_stream_for_odm(
1863                 const struct dc *dc,
1864                 struct resource_context *res_ctx,
1865                 struct pipe_ctx *prev_odm_pipe,
1866                 struct pipe_ctx *next_odm_pipe)
1867 {
1868         int pipe_idx = next_odm_pipe->pipe_idx;
1869         const struct resource_pool *pool = dc->res_pool;
1870
1871         *next_odm_pipe = *prev_odm_pipe;
1872
1873         next_odm_pipe->pipe_idx = pipe_idx;
1874         next_odm_pipe->plane_res.mi = pool->mis[next_odm_pipe->pipe_idx];
1875         next_odm_pipe->plane_res.hubp = pool->hubps[next_odm_pipe->pipe_idx];
1876         next_odm_pipe->plane_res.ipp = pool->ipps[next_odm_pipe->pipe_idx];
1877         next_odm_pipe->plane_res.xfm = pool->transforms[next_odm_pipe->pipe_idx];
1878         next_odm_pipe->plane_res.dpp = pool->dpps[next_odm_pipe->pipe_idx];
1879         next_odm_pipe->plane_res.mpcc_inst = pool->dpps[next_odm_pipe->pipe_idx]->inst;
1880         next_odm_pipe->stream_res.dsc = NULL;
1881         if (prev_odm_pipe->next_odm_pipe && prev_odm_pipe->next_odm_pipe != next_odm_pipe) {
1882                 next_odm_pipe->next_odm_pipe = prev_odm_pipe->next_odm_pipe;
1883                 next_odm_pipe->next_odm_pipe->prev_odm_pipe = next_odm_pipe;
1884         }
1885         if (prev_odm_pipe->top_pipe && prev_odm_pipe->top_pipe->next_odm_pipe) {
1886                 prev_odm_pipe->top_pipe->next_odm_pipe->bottom_pipe = next_odm_pipe;
1887                 next_odm_pipe->top_pipe = prev_odm_pipe->top_pipe->next_odm_pipe;
1888         }
1889         if (prev_odm_pipe->bottom_pipe && prev_odm_pipe->bottom_pipe->next_odm_pipe) {
1890                 prev_odm_pipe->bottom_pipe->next_odm_pipe->top_pipe = next_odm_pipe;
1891                 next_odm_pipe->bottom_pipe = prev_odm_pipe->bottom_pipe->next_odm_pipe;
1892         }
1893         prev_odm_pipe->next_odm_pipe = next_odm_pipe;
1894         next_odm_pipe->prev_odm_pipe = prev_odm_pipe;
1895
1896         if (prev_odm_pipe->plane_state) {
1897                 struct scaler_data *sd = &prev_odm_pipe->plane_res.scl_data;
1898                 int new_width;
1899
1900                 /* HACTIVE halved for odm combine */
1901                 sd->h_active /= 2;
1902                 /* Calculate new vp and recout for left pipe */
1903                 /* Need at least 16 pixels width per side */
1904                 if (sd->recout.x + 16 >= sd->h_active)
1905                         return false;
1906                 new_width = sd->h_active - sd->recout.x;
1907                 sd->viewport.width -= dc_fixpt_floor(dc_fixpt_mul_int(
1908                                 sd->ratios.horz, sd->recout.width - new_width));
1909                 sd->viewport_c.width -= dc_fixpt_floor(dc_fixpt_mul_int(
1910                                 sd->ratios.horz_c, sd->recout.width - new_width));
1911                 sd->recout.width = new_width;
1912
1913                 /* Calculate new vp and recout for right pipe */
1914                 sd = &next_odm_pipe->plane_res.scl_data;
1915                 /* HACTIVE halved for odm combine */
1916                 sd->h_active /= 2;
1917                 /* Need at least 16 pixels width per side */
1918                 if (new_width <= 16)
1919                         return false;
1920                 new_width = sd->recout.width + sd->recout.x - sd->h_active;
1921                 sd->viewport.width -= dc_fixpt_floor(dc_fixpt_mul_int(
1922                                 sd->ratios.horz, sd->recout.width - new_width));
1923                 sd->viewport_c.width -= dc_fixpt_floor(dc_fixpt_mul_int(
1924                                 sd->ratios.horz_c, sd->recout.width - new_width));
1925                 sd->recout.width = new_width;
1926                 sd->viewport.x += dc_fixpt_floor(dc_fixpt_mul_int(
1927                                 sd->ratios.horz, sd->h_active - sd->recout.x));
1928                 sd->viewport_c.x += dc_fixpt_floor(dc_fixpt_mul_int(
1929                                 sd->ratios.horz_c, sd->h_active - sd->recout.x));
1930                 sd->recout.x = 0;
1931         }
1932         if (!next_odm_pipe->top_pipe)
1933                 next_odm_pipe->stream_res.opp = pool->opps[next_odm_pipe->pipe_idx];
1934         else
1935                 next_odm_pipe->stream_res.opp = next_odm_pipe->top_pipe->stream_res.opp;
1936         if (next_odm_pipe->stream->timing.flags.DSC == 1 && !next_odm_pipe->top_pipe) {
1937                 dcn20_acquire_dsc(dc, res_ctx, &next_odm_pipe->stream_res.dsc, next_odm_pipe->pipe_idx);
1938                 ASSERT(next_odm_pipe->stream_res.dsc);
1939                 if (next_odm_pipe->stream_res.dsc == NULL)
1940                         return false;
1941         }
1942
1943         return true;
1944 }
1945
1946 void dcn20_split_stream_for_mpc(
1947                 struct resource_context *res_ctx,
1948                 const struct resource_pool *pool,
1949                 struct pipe_ctx *primary_pipe,
1950                 struct pipe_ctx *secondary_pipe)
1951 {
1952         int pipe_idx = secondary_pipe->pipe_idx;
1953         struct pipe_ctx *sec_bot_pipe = secondary_pipe->bottom_pipe;
1954
1955         *secondary_pipe = *primary_pipe;
1956         secondary_pipe->bottom_pipe = sec_bot_pipe;
1957
1958         secondary_pipe->pipe_idx = pipe_idx;
1959         secondary_pipe->plane_res.mi = pool->mis[secondary_pipe->pipe_idx];
1960         secondary_pipe->plane_res.hubp = pool->hubps[secondary_pipe->pipe_idx];
1961         secondary_pipe->plane_res.ipp = pool->ipps[secondary_pipe->pipe_idx];
1962         secondary_pipe->plane_res.xfm = pool->transforms[secondary_pipe->pipe_idx];
1963         secondary_pipe->plane_res.dpp = pool->dpps[secondary_pipe->pipe_idx];
1964         secondary_pipe->plane_res.mpcc_inst = pool->dpps[secondary_pipe->pipe_idx]->inst;
1965         secondary_pipe->stream_res.dsc = NULL;
1966         if (primary_pipe->bottom_pipe && primary_pipe->bottom_pipe != secondary_pipe) {
1967                 ASSERT(!secondary_pipe->bottom_pipe);
1968                 secondary_pipe->bottom_pipe = primary_pipe->bottom_pipe;
1969                 secondary_pipe->bottom_pipe->top_pipe = secondary_pipe;
1970         }
1971         primary_pipe->bottom_pipe = secondary_pipe;
1972         secondary_pipe->top_pipe = primary_pipe;
1973
1974         ASSERT(primary_pipe->plane_state);
1975 }
1976
1977 void dcn20_populate_dml_writeback_from_context(
1978                 struct dc *dc, struct resource_context *res_ctx, display_e2e_pipe_params_st *pipes)
1979 {
1980         int pipe_cnt, i;
1981
1982         for (i = 0, pipe_cnt = 0; i < dc->res_pool->pipe_count; i++) {
1983                 struct dc_writeback_info *wb_info = &res_ctx->pipe_ctx[i].stream->writeback_info[0];
1984
1985                 if (!res_ctx->pipe_ctx[i].stream)
1986                         continue;
1987
1988                 /* Set writeback information */
1989                 pipes[pipe_cnt].dout.wb_enable = (wb_info->wb_enabled == true) ? 1 : 0;
1990                 pipes[pipe_cnt].dout.num_active_wb++;
1991                 pipes[pipe_cnt].dout.wb.wb_src_height = wb_info->dwb_params.cnv_params.crop_height;
1992                 pipes[pipe_cnt].dout.wb.wb_src_width = wb_info->dwb_params.cnv_params.crop_width;
1993                 pipes[pipe_cnt].dout.wb.wb_dst_width = wb_info->dwb_params.dest_width;
1994                 pipes[pipe_cnt].dout.wb.wb_dst_height = wb_info->dwb_params.dest_height;
1995                 pipes[pipe_cnt].dout.wb.wb_htaps_luma = 1;
1996                 pipes[pipe_cnt].dout.wb.wb_vtaps_luma = 1;
1997                 pipes[pipe_cnt].dout.wb.wb_htaps_chroma = wb_info->dwb_params.scaler_taps.h_taps_c;
1998                 pipes[pipe_cnt].dout.wb.wb_vtaps_chroma = wb_info->dwb_params.scaler_taps.v_taps_c;
1999                 pipes[pipe_cnt].dout.wb.wb_hratio = 1.0;
2000                 pipes[pipe_cnt].dout.wb.wb_vratio = 1.0;
2001                 if (wb_info->dwb_params.out_format == dwb_scaler_mode_yuv420) {
2002                         if (wb_info->dwb_params.output_depth == DWB_OUTPUT_PIXEL_DEPTH_8BPC)
2003                                 pipes[pipe_cnt].dout.wb.wb_pixel_format = dm_420_8;
2004                         else
2005                                 pipes[pipe_cnt].dout.wb.wb_pixel_format = dm_420_10;
2006                 } else
2007                         pipes[pipe_cnt].dout.wb.wb_pixel_format = dm_444_32;
2008
2009                 pipe_cnt++;
2010         }
2011
2012 }
2013
2014 int dcn20_populate_dml_pipes_from_context(
2015                 struct dc *dc,
2016                 struct dc_state *context,
2017                 display_e2e_pipe_params_st *pipes,
2018                 bool fast_validate)
2019 {
2020         int pipe_cnt, i;
2021         bool synchronized_vblank = true;
2022         struct resource_context *res_ctx = &context->res_ctx;
2023
2024         for (i = 0, pipe_cnt = -1; i < dc->res_pool->pipe_count; i++) {
2025                 if (!res_ctx->pipe_ctx[i].stream)
2026                         continue;
2027
2028                 if (pipe_cnt < 0) {
2029                         pipe_cnt = i;
2030                         continue;
2031                 }
2032
2033                 if (res_ctx->pipe_ctx[pipe_cnt].stream == res_ctx->pipe_ctx[i].stream)
2034                         continue;
2035
2036                 if (dc->debug.disable_timing_sync ||
2037                         (!resource_are_streams_timing_synchronizable(
2038                                 res_ctx->pipe_ctx[pipe_cnt].stream,
2039                                 res_ctx->pipe_ctx[i].stream) &&
2040                         !resource_are_vblanks_synchronizable(
2041                                 res_ctx->pipe_ctx[pipe_cnt].stream,
2042                                 res_ctx->pipe_ctx[i].stream))) {
2043                         synchronized_vblank = false;
2044                         break;
2045                 }
2046         }
2047
2048         for (i = 0, pipe_cnt = 0; i < dc->res_pool->pipe_count; i++) {
2049                 struct dc_crtc_timing *timing = &res_ctx->pipe_ctx[i].stream->timing;
2050                 unsigned int v_total;
2051                 unsigned int front_porch;
2052                 int output_bpc;
2053                 struct audio_check aud_check = {0};
2054
2055                 if (!res_ctx->pipe_ctx[i].stream)
2056                         continue;
2057
2058                 v_total = timing->v_total;
2059                 front_porch = timing->v_front_porch;
2060
2061                 /* todo:
2062                 pipes[pipe_cnt].pipe.src.dynamic_metadata_enable = 0;
2063                 pipes[pipe_cnt].pipe.src.dcc = 0;
2064                 pipes[pipe_cnt].pipe.src.vm = 0;*/
2065
2066                 pipes[pipe_cnt].clks_cfg.refclk_mhz = dc->res_pool->ref_clocks.dchub_ref_clock_inKhz / 1000.0;
2067
2068                 pipes[pipe_cnt].dout.dsc_enable = res_ctx->pipe_ctx[i].stream->timing.flags.DSC;
2069                 /* todo: rotation?*/
2070                 pipes[pipe_cnt].dout.dsc_slices = res_ctx->pipe_ctx[i].stream->timing.dsc_cfg.num_slices_h;
2071                 if (res_ctx->pipe_ctx[i].stream->use_dynamic_meta) {
2072                         pipes[pipe_cnt].pipe.src.dynamic_metadata_enable = true;
2073                         /* 1/2 vblank */
2074                         pipes[pipe_cnt].pipe.src.dynamic_metadata_lines_before_active =
2075                                 (v_total - timing->v_addressable
2076                                         - timing->v_border_top - timing->v_border_bottom) / 2;
2077                         /* 36 bytes dp, 32 hdmi */
2078                         pipes[pipe_cnt].pipe.src.dynamic_metadata_xmit_bytes =
2079                                 dc_is_dp_signal(res_ctx->pipe_ctx[i].stream->signal) ? 36 : 32;
2080                 }
2081                 pipes[pipe_cnt].pipe.src.dcc = false;
2082                 pipes[pipe_cnt].pipe.src.dcc_rate = 1;
2083                 pipes[pipe_cnt].pipe.dest.synchronized_vblank_all_planes = synchronized_vblank;
2084                 pipes[pipe_cnt].pipe.dest.hblank_start = timing->h_total - timing->h_front_porch;
2085                 pipes[pipe_cnt].pipe.dest.hblank_end = pipes[pipe_cnt].pipe.dest.hblank_start
2086                                 - timing->h_addressable
2087                                 - timing->h_border_left
2088                                 - timing->h_border_right;
2089                 pipes[pipe_cnt].pipe.dest.vblank_start = v_total - front_porch;
2090                 pipes[pipe_cnt].pipe.dest.vblank_end = pipes[pipe_cnt].pipe.dest.vblank_start
2091                                 - timing->v_addressable
2092                                 - timing->v_border_top
2093                                 - timing->v_border_bottom;
2094                 pipes[pipe_cnt].pipe.dest.htotal = timing->h_total;
2095                 pipes[pipe_cnt].pipe.dest.vtotal = v_total;
2096                 pipes[pipe_cnt].pipe.dest.hactive = timing->h_addressable;
2097                 pipes[pipe_cnt].pipe.dest.vactive = timing->v_addressable;
2098                 pipes[pipe_cnt].pipe.dest.interlaced = timing->flags.INTERLACE;
2099                 pipes[pipe_cnt].pipe.dest.pixel_rate_mhz = timing->pix_clk_100hz/10000.0;
2100                 if (timing->timing_3d_format == TIMING_3D_FORMAT_HW_FRAME_PACKING)
2101                         pipes[pipe_cnt].pipe.dest.pixel_rate_mhz *= 2;
2102                 pipes[pipe_cnt].pipe.dest.otg_inst = res_ctx->pipe_ctx[i].stream_res.tg->inst;
2103                 pipes[pipe_cnt].dout.dp_lanes = 4;
2104                 pipes[pipe_cnt].dout.is_virtual = 0;
2105                 pipes[pipe_cnt].pipe.dest.vtotal_min = res_ctx->pipe_ctx[i].stream->adjust.v_total_min;
2106                 pipes[pipe_cnt].pipe.dest.vtotal_max = res_ctx->pipe_ctx[i].stream->adjust.v_total_max;
2107                 switch (get_num_odm_splits(&res_ctx->pipe_ctx[i])) {
2108                 case 1:
2109                         pipes[pipe_cnt].pipe.dest.odm_combine = dm_odm_combine_mode_2to1;
2110                         break;
2111                 case 3:
2112                         pipes[pipe_cnt].pipe.dest.odm_combine = dm_odm_combine_mode_4to1;
2113                         break;
2114                 default:
2115                         pipes[pipe_cnt].pipe.dest.odm_combine = dm_odm_combine_mode_disabled;
2116                 }
2117                 pipes[pipe_cnt].pipe.src.hsplit_grp = res_ctx->pipe_ctx[i].pipe_idx;
2118                 if (res_ctx->pipe_ctx[i].top_pipe && res_ctx->pipe_ctx[i].top_pipe->plane_state
2119                                 == res_ctx->pipe_ctx[i].plane_state) {
2120                         struct pipe_ctx *first_pipe = res_ctx->pipe_ctx[i].top_pipe;
2121                         int split_idx = 0;
2122
2123                         while (first_pipe->top_pipe && first_pipe->top_pipe->plane_state
2124                                         == res_ctx->pipe_ctx[i].plane_state) {
2125                                 first_pipe = first_pipe->top_pipe;
2126                                 split_idx++;
2127                         }
2128                         /* Treat 4to1 mpc combine as an mpo of 2 2-to-1 combines */
2129                         if (split_idx == 0)
2130                                 pipes[pipe_cnt].pipe.src.hsplit_grp = first_pipe->pipe_idx;
2131                         else if (split_idx == 1)
2132                                 pipes[pipe_cnt].pipe.src.hsplit_grp = res_ctx->pipe_ctx[i].pipe_idx;
2133                         else if (split_idx == 2)
2134                                 pipes[pipe_cnt].pipe.src.hsplit_grp = res_ctx->pipe_ctx[i].top_pipe->pipe_idx;
2135                 } else if (res_ctx->pipe_ctx[i].prev_odm_pipe) {
2136                         struct pipe_ctx *first_pipe = res_ctx->pipe_ctx[i].prev_odm_pipe;
2137
2138                         while (first_pipe->prev_odm_pipe)
2139                                 first_pipe = first_pipe->prev_odm_pipe;
2140                         pipes[pipe_cnt].pipe.src.hsplit_grp = first_pipe->pipe_idx;
2141                 }
2142
2143                 switch (res_ctx->pipe_ctx[i].stream->signal) {
2144                 case SIGNAL_TYPE_DISPLAY_PORT_MST:
2145                 case SIGNAL_TYPE_DISPLAY_PORT:
2146                         pipes[pipe_cnt].dout.output_type = dm_dp;
2147                         break;
2148                 case SIGNAL_TYPE_EDP:
2149                         pipes[pipe_cnt].dout.output_type = dm_edp;
2150                         break;
2151                 case SIGNAL_TYPE_HDMI_TYPE_A:
2152                 case SIGNAL_TYPE_DVI_SINGLE_LINK:
2153                 case SIGNAL_TYPE_DVI_DUAL_LINK:
2154                         pipes[pipe_cnt].dout.output_type = dm_hdmi;
2155                         break;
2156                 default:
2157                         /* In case there is no signal, set dp with 4 lanes to allow max config */
2158                         pipes[pipe_cnt].dout.is_virtual = 1;
2159                         pipes[pipe_cnt].dout.output_type = dm_dp;
2160                         pipes[pipe_cnt].dout.dp_lanes = 4;
2161                 }
2162
2163                 switch (res_ctx->pipe_ctx[i].stream->timing.display_color_depth) {
2164                 case COLOR_DEPTH_666:
2165                         output_bpc = 6;
2166                         break;
2167                 case COLOR_DEPTH_888:
2168                         output_bpc = 8;
2169                         break;
2170                 case COLOR_DEPTH_101010:
2171                         output_bpc = 10;
2172                         break;
2173                 case COLOR_DEPTH_121212:
2174                         output_bpc = 12;
2175                         break;
2176                 case COLOR_DEPTH_141414:
2177                         output_bpc = 14;
2178                         break;
2179                 case COLOR_DEPTH_161616:
2180                         output_bpc = 16;
2181                         break;
2182                 case COLOR_DEPTH_999:
2183                         output_bpc = 9;
2184                         break;
2185                 case COLOR_DEPTH_111111:
2186                         output_bpc = 11;
2187                         break;
2188                 default:
2189                         output_bpc = 8;
2190                         break;
2191                 }
2192
2193                 switch (res_ctx->pipe_ctx[i].stream->timing.pixel_encoding) {
2194                 case PIXEL_ENCODING_RGB:
2195                 case PIXEL_ENCODING_YCBCR444:
2196                         pipes[pipe_cnt].dout.output_format = dm_444;
2197                         pipes[pipe_cnt].dout.output_bpp = output_bpc * 3;
2198                         break;
2199                 case PIXEL_ENCODING_YCBCR420:
2200                         pipes[pipe_cnt].dout.output_format = dm_420;
2201                         pipes[pipe_cnt].dout.output_bpp = (output_bpc * 3.0) / 2;
2202                         break;
2203                 case PIXEL_ENCODING_YCBCR422:
2204                         if (true) /* todo */
2205                                 pipes[pipe_cnt].dout.output_format = dm_s422;
2206                         else
2207                                 pipes[pipe_cnt].dout.output_format = dm_n422;
2208                         pipes[pipe_cnt].dout.output_bpp = output_bpc * 2;
2209                         break;
2210                 default:
2211                         pipes[pipe_cnt].dout.output_format = dm_444;
2212                         pipes[pipe_cnt].dout.output_bpp = output_bpc * 3;
2213                 }
2214
2215                 if (res_ctx->pipe_ctx[i].stream->timing.flags.DSC)
2216                         pipes[pipe_cnt].dout.output_bpp = res_ctx->pipe_ctx[i].stream->timing.dsc_cfg.bits_per_pixel / 16.0;
2217
2218                 /* todo: default max for now, until there is logic reflecting this in dc*/
2219                 pipes[pipe_cnt].dout.dsc_input_bpc = 12;
2220                 /*fill up the audio sample rate (unit in kHz)*/
2221                 get_audio_check(&res_ctx->pipe_ctx[i].stream->audio_info, &aud_check);
2222                 pipes[pipe_cnt].dout.max_audio_sample_rate = aud_check.max_audiosample_rate / 1000;
2223                 /*
2224                  * For graphic plane, cursor number is 1, nv12 is 0
2225                  * bw calculations due to cursor on/off
2226                  */
2227                 if (res_ctx->pipe_ctx[i].plane_state &&
2228                                 res_ctx->pipe_ctx[i].plane_state->address.type == PLN_ADDR_TYPE_VIDEO_PROGRESSIVE)
2229                         pipes[pipe_cnt].pipe.src.num_cursors = 0;
2230                 else
2231                         pipes[pipe_cnt].pipe.src.num_cursors = dc->dml.ip.number_of_cursors;
2232
2233                 pipes[pipe_cnt].pipe.src.cur0_src_width = 256;
2234                 pipes[pipe_cnt].pipe.src.cur0_bpp = dm_cur_32bit;
2235
2236                 if (!res_ctx->pipe_ctx[i].plane_state) {
2237                         pipes[pipe_cnt].pipe.src.is_hsplit = pipes[pipe_cnt].pipe.dest.odm_combine != dm_odm_combine_mode_disabled;
2238                         pipes[pipe_cnt].pipe.src.source_scan = dm_horz;
2239                         pipes[pipe_cnt].pipe.src.sw_mode = dm_sw_4kb_s;
2240                         pipes[pipe_cnt].pipe.src.macro_tile_size = dm_64k_tile;
2241                         pipes[pipe_cnt].pipe.src.viewport_width = timing->h_addressable;
2242                         if (pipes[pipe_cnt].pipe.src.viewport_width > 1920)
2243                                 pipes[pipe_cnt].pipe.src.viewport_width = 1920;
2244                         pipes[pipe_cnt].pipe.src.viewport_height = timing->v_addressable;
2245                         if (pipes[pipe_cnt].pipe.src.viewport_height > 1080)
2246                                 pipes[pipe_cnt].pipe.src.viewport_height = 1080;
2247                         pipes[pipe_cnt].pipe.src.surface_height_y = pipes[pipe_cnt].pipe.src.viewport_height;
2248                         pipes[pipe_cnt].pipe.src.surface_width_y = pipes[pipe_cnt].pipe.src.viewport_width;
2249                         pipes[pipe_cnt].pipe.src.surface_height_c = pipes[pipe_cnt].pipe.src.viewport_height;
2250                         pipes[pipe_cnt].pipe.src.surface_width_c = pipes[pipe_cnt].pipe.src.viewport_width;
2251                         pipes[pipe_cnt].pipe.src.data_pitch = ((pipes[pipe_cnt].pipe.src.viewport_width + 255) / 256) * 256;
2252                         pipes[pipe_cnt].pipe.src.source_format = dm_444_32;
2253                         pipes[pipe_cnt].pipe.dest.recout_width = pipes[pipe_cnt].pipe.src.viewport_width; /*vp_width/hratio*/
2254                         pipes[pipe_cnt].pipe.dest.recout_height = pipes[pipe_cnt].pipe.src.viewport_height; /*vp_height/vratio*/
2255                         pipes[pipe_cnt].pipe.dest.full_recout_width = pipes[pipe_cnt].pipe.dest.recout_width;  /*when is_hsplit != 1*/
2256                         pipes[pipe_cnt].pipe.dest.full_recout_height = pipes[pipe_cnt].pipe.dest.recout_height; /*when is_hsplit != 1*/
2257                         pipes[pipe_cnt].pipe.scale_ratio_depth.lb_depth = dm_lb_16;
2258                         pipes[pipe_cnt].pipe.scale_ratio_depth.hscl_ratio = 1.0;
2259                         pipes[pipe_cnt].pipe.scale_ratio_depth.vscl_ratio = 1.0;
2260                         pipes[pipe_cnt].pipe.scale_ratio_depth.scl_enable = 0; /*Lb only or Full scl*/
2261                         pipes[pipe_cnt].pipe.scale_taps.htaps = 1;
2262                         pipes[pipe_cnt].pipe.scale_taps.vtaps = 1;
2263                         pipes[pipe_cnt].pipe.dest.vtotal_min = v_total;
2264                         pipes[pipe_cnt].pipe.dest.vtotal_max = v_total;
2265
2266                         if (pipes[pipe_cnt].pipe.dest.odm_combine == dm_odm_combine_mode_2to1) {
2267                                 pipes[pipe_cnt].pipe.src.viewport_width /= 2;
2268                                 pipes[pipe_cnt].pipe.dest.recout_width /= 2;
2269                         } else if (pipes[pipe_cnt].pipe.dest.odm_combine == dm_odm_combine_mode_4to1) {
2270                                 pipes[pipe_cnt].pipe.src.viewport_width /= 4;
2271                                 pipes[pipe_cnt].pipe.dest.recout_width /= 4;
2272                         }
2273                 } else {
2274                         struct dc_plane_state *pln = res_ctx->pipe_ctx[i].plane_state;
2275                         struct scaler_data *scl = &res_ctx->pipe_ctx[i].plane_res.scl_data;
2276
2277                         pipes[pipe_cnt].pipe.src.immediate_flip = pln->flip_immediate;
2278                         pipes[pipe_cnt].pipe.src.is_hsplit = (res_ctx->pipe_ctx[i].bottom_pipe && res_ctx->pipe_ctx[i].bottom_pipe->plane_state == pln)
2279                                         || (res_ctx->pipe_ctx[i].top_pipe && res_ctx->pipe_ctx[i].top_pipe->plane_state == pln)
2280                                         || pipes[pipe_cnt].pipe.dest.odm_combine != dm_odm_combine_mode_disabled;
2281
2282                         /* stereo is not split */
2283                         if (pln->stereo_format == PLANE_STEREO_FORMAT_SIDE_BY_SIDE ||
2284                             pln->stereo_format == PLANE_STEREO_FORMAT_TOP_AND_BOTTOM) {
2285                                 pipes[pipe_cnt].pipe.src.is_hsplit = false;
2286                                 pipes[pipe_cnt].pipe.src.hsplit_grp = res_ctx->pipe_ctx[i].pipe_idx;
2287                         }
2288
2289                         pipes[pipe_cnt].pipe.src.source_scan = pln->rotation == ROTATION_ANGLE_90
2290                                         || pln->rotation == ROTATION_ANGLE_270 ? dm_vert : dm_horz;
2291                         pipes[pipe_cnt].pipe.src.viewport_y_y = scl->viewport_unadjusted.y;
2292                         pipes[pipe_cnt].pipe.src.viewport_y_c = scl->viewport_c_unadjusted.y;
2293                         pipes[pipe_cnt].pipe.src.viewport_width = scl->viewport_unadjusted.width;
2294                         pipes[pipe_cnt].pipe.src.viewport_width_c = scl->viewport_c_unadjusted.width;
2295                         pipes[pipe_cnt].pipe.src.viewport_height = scl->viewport_unadjusted.height;
2296                         pipes[pipe_cnt].pipe.src.viewport_height_c = scl->viewport_c_unadjusted.height;
2297                         pipes[pipe_cnt].pipe.src.surface_width_y = pln->plane_size.surface_size.width;
2298                         pipes[pipe_cnt].pipe.src.surface_height_y = pln->plane_size.surface_size.height;
2299                         pipes[pipe_cnt].pipe.src.surface_width_c = pln->plane_size.chroma_size.width;
2300                         pipes[pipe_cnt].pipe.src.surface_height_c = pln->plane_size.chroma_size.height;
2301                         if (pln->format == SURFACE_PIXEL_FORMAT_GRPH_RGBE_ALPHA
2302                                         || pln->format >= SURFACE_PIXEL_FORMAT_VIDEO_BEGIN) {
2303                                 pipes[pipe_cnt].pipe.src.data_pitch = pln->plane_size.surface_pitch;
2304                                 pipes[pipe_cnt].pipe.src.data_pitch_c = pln->plane_size.chroma_pitch;
2305                                 pipes[pipe_cnt].pipe.src.meta_pitch = pln->dcc.meta_pitch;
2306                                 pipes[pipe_cnt].pipe.src.meta_pitch_c = pln->dcc.meta_pitch_c;
2307                         } else {
2308                                 pipes[pipe_cnt].pipe.src.data_pitch = pln->plane_size.surface_pitch;
2309                                 pipes[pipe_cnt].pipe.src.meta_pitch = pln->dcc.meta_pitch;
2310                         }
2311                         pipes[pipe_cnt].pipe.src.dcc = pln->dcc.enable;
2312                         pipes[pipe_cnt].pipe.dest.recout_width = scl->recout.width;
2313                         pipes[pipe_cnt].pipe.dest.recout_height = scl->recout.height;
2314                         pipes[pipe_cnt].pipe.dest.full_recout_height = scl->recout.height;
2315                         pipes[pipe_cnt].pipe.dest.full_recout_width = scl->recout.width;
2316                         if (pipes[pipe_cnt].pipe.dest.odm_combine == dm_odm_combine_mode_2to1)
2317                                 pipes[pipe_cnt].pipe.dest.full_recout_width *= 2;
2318                         else if (pipes[pipe_cnt].pipe.dest.odm_combine == dm_odm_combine_mode_4to1)
2319                                 pipes[pipe_cnt].pipe.dest.full_recout_width *= 4;
2320                         else {
2321                                 struct pipe_ctx *split_pipe = res_ctx->pipe_ctx[i].bottom_pipe;
2322
2323                                 while (split_pipe && split_pipe->plane_state == pln) {
2324                                         pipes[pipe_cnt].pipe.dest.full_recout_width += split_pipe->plane_res.scl_data.recout.width;
2325                                         split_pipe = split_pipe->bottom_pipe;
2326                                 }
2327                                 split_pipe = res_ctx->pipe_ctx[i].top_pipe;
2328                                 while (split_pipe && split_pipe->plane_state == pln) {
2329                                         pipes[pipe_cnt].pipe.dest.full_recout_width += split_pipe->plane_res.scl_data.recout.width;
2330                                         split_pipe = split_pipe->top_pipe;
2331                                 }
2332                         }
2333
2334                         pipes[pipe_cnt].pipe.scale_ratio_depth.lb_depth = dm_lb_16;
2335                         pipes[pipe_cnt].pipe.scale_ratio_depth.hscl_ratio = (double) scl->ratios.horz.value / (1ULL<<32);
2336                         pipes[pipe_cnt].pipe.scale_ratio_depth.hscl_ratio_c = (double) scl->ratios.horz_c.value / (1ULL<<32);
2337                         pipes[pipe_cnt].pipe.scale_ratio_depth.vscl_ratio = (double) scl->ratios.vert.value / (1ULL<<32);
2338                         pipes[pipe_cnt].pipe.scale_ratio_depth.vscl_ratio_c = (double) scl->ratios.vert_c.value / (1ULL<<32);
2339                         pipes[pipe_cnt].pipe.scale_ratio_depth.scl_enable =
2340                                         scl->ratios.vert.value != dc_fixpt_one.value
2341                                         || scl->ratios.horz.value != dc_fixpt_one.value
2342                                         || scl->ratios.vert_c.value != dc_fixpt_one.value
2343                                         || scl->ratios.horz_c.value != dc_fixpt_one.value /*Lb only or Full scl*/
2344                                         || dc->debug.always_scale; /*support always scale*/
2345                         pipes[pipe_cnt].pipe.scale_taps.htaps = scl->taps.h_taps;
2346                         pipes[pipe_cnt].pipe.scale_taps.htaps_c = scl->taps.h_taps_c;
2347                         pipes[pipe_cnt].pipe.scale_taps.vtaps = scl->taps.v_taps;
2348                         pipes[pipe_cnt].pipe.scale_taps.vtaps_c = scl->taps.v_taps_c;
2349
2350                         pipes[pipe_cnt].pipe.src.macro_tile_size =
2351                                         swizzle_mode_to_macro_tile_size(pln->tiling_info.gfx9.swizzle);
2352                         swizzle_to_dml_params(pln->tiling_info.gfx9.swizzle,
2353                                         &pipes[pipe_cnt].pipe.src.sw_mode);
2354
2355                         switch (pln->format) {
2356                         case SURFACE_PIXEL_FORMAT_VIDEO_420_YCbCr:
2357                         case SURFACE_PIXEL_FORMAT_VIDEO_420_YCrCb:
2358                                 pipes[pipe_cnt].pipe.src.source_format = dm_420_8;
2359                                 break;
2360                         case SURFACE_PIXEL_FORMAT_VIDEO_420_10bpc_YCbCr:
2361                         case SURFACE_PIXEL_FORMAT_VIDEO_420_10bpc_YCrCb:
2362                                 pipes[pipe_cnt].pipe.src.source_format = dm_420_10;
2363                                 break;
2364                         case SURFACE_PIXEL_FORMAT_GRPH_ARGB16161616:
2365                         case SURFACE_PIXEL_FORMAT_GRPH_ARGB16161616F:
2366                         case SURFACE_PIXEL_FORMAT_GRPH_ABGR16161616F:
2367                                 pipes[pipe_cnt].pipe.src.source_format = dm_444_64;
2368                                 break;
2369                         case SURFACE_PIXEL_FORMAT_GRPH_ARGB1555:
2370                         case SURFACE_PIXEL_FORMAT_GRPH_RGB565:
2371                                 pipes[pipe_cnt].pipe.src.source_format = dm_444_16;
2372                                 break;
2373                         case SURFACE_PIXEL_FORMAT_GRPH_PALETA_256_COLORS:
2374                                 pipes[pipe_cnt].pipe.src.source_format = dm_444_8;
2375                                 break;
2376                         case SURFACE_PIXEL_FORMAT_GRPH_RGBE_ALPHA:
2377                                 pipes[pipe_cnt].pipe.src.source_format = dm_rgbe_alpha;
2378                                 break;
2379                         default:
2380                                 pipes[pipe_cnt].pipe.src.source_format = dm_444_32;
2381                                 break;
2382                         }
2383                 }
2384
2385                 pipe_cnt++;
2386         }
2387
2388         /* populate writeback information */
2389         dc->res_pool->funcs->populate_dml_writeback_from_context(dc, res_ctx, pipes);
2390
2391         return pipe_cnt;
2392 }
2393
2394 unsigned int dcn20_calc_max_scaled_time(
2395                 unsigned int time_per_pixel,
2396                 enum mmhubbub_wbif_mode mode,
2397                 unsigned int urgent_watermark)
2398 {
2399         unsigned int time_per_byte = 0;
2400         unsigned int total_y_free_entry = 0x200; /* two memory piece for luma */
2401         unsigned int total_c_free_entry = 0x140; /* two memory piece for chroma */
2402         unsigned int small_free_entry, max_free_entry;
2403         unsigned int buf_lh_capability;
2404         unsigned int max_scaled_time;
2405
2406         if (mode == PACKED_444) /* packed mode */
2407                 time_per_byte = time_per_pixel/4;
2408         else if (mode == PLANAR_420_8BPC)
2409                 time_per_byte  = time_per_pixel;
2410         else if (mode == PLANAR_420_10BPC) /* p010 */
2411                 time_per_byte  = time_per_pixel * 819/1024;
2412
2413         if (time_per_byte == 0)
2414                 time_per_byte = 1;
2415
2416         small_free_entry  = (total_y_free_entry > total_c_free_entry) ? total_c_free_entry : total_y_free_entry;
2417         max_free_entry    = (mode == PACKED_444) ? total_y_free_entry + total_c_free_entry : small_free_entry;
2418         buf_lh_capability = max_free_entry*time_per_byte*32/16; /* there is 4bit fraction */
2419         max_scaled_time   = buf_lh_capability - urgent_watermark;
2420         return max_scaled_time;
2421 }
2422
2423 void dcn20_set_mcif_arb_params(
2424                 struct dc *dc,
2425                 struct dc_state *context,
2426                 display_e2e_pipe_params_st *pipes,
2427                 int pipe_cnt)
2428 {
2429         enum mmhubbub_wbif_mode wbif_mode;
2430         struct mcif_arb_params *wb_arb_params;
2431         int i, j, k, dwb_pipe;
2432
2433         /* Writeback MCIF_WB arbitration parameters */
2434         dwb_pipe = 0;
2435         for (i = 0; i < dc->res_pool->pipe_count; i++) {
2436
2437                 if (!context->res_ctx.pipe_ctx[i].stream)
2438                         continue;
2439
2440                 for (j = 0; j < MAX_DWB_PIPES; j++) {
2441                         if (context->res_ctx.pipe_ctx[i].stream->writeback_info[j].wb_enabled == false)
2442                                 continue;
2443
2444                         //wb_arb_params = &context->res_ctx.pipe_ctx[i].stream->writeback_info[j].mcif_arb_params;
2445                         wb_arb_params = &context->bw_ctx.bw.dcn.bw_writeback.mcif_wb_arb[dwb_pipe];
2446
2447                         if (context->res_ctx.pipe_ctx[i].stream->writeback_info[j].dwb_params.out_format == dwb_scaler_mode_yuv420) {
2448                                 if (context->res_ctx.pipe_ctx[i].stream->writeback_info[j].dwb_params.output_depth == DWB_OUTPUT_PIXEL_DEPTH_8BPC)
2449                                         wbif_mode = PLANAR_420_8BPC;
2450                                 else
2451                                         wbif_mode = PLANAR_420_10BPC;
2452                         } else
2453                                 wbif_mode = PACKED_444;
2454
2455                         for (k = 0; k < sizeof(wb_arb_params->cli_watermark)/sizeof(wb_arb_params->cli_watermark[0]); k++) {
2456                                 wb_arb_params->cli_watermark[k] = get_wm_writeback_urgent(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
2457                                 wb_arb_params->pstate_watermark[k] = get_wm_writeback_dram_clock_change(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
2458                         }
2459                         wb_arb_params->time_per_pixel = 16.0 / context->res_ctx.pipe_ctx[i].stream->phy_pix_clk; /* 4 bit fraction, ms */
2460                         wb_arb_params->slice_lines = 32;
2461                         wb_arb_params->arbitration_slice = 2;
2462                         wb_arb_params->max_scaled_time = dcn20_calc_max_scaled_time(wb_arb_params->time_per_pixel,
2463                                 wbif_mode,
2464                                 wb_arb_params->cli_watermark[0]); /* assume 4 watermark sets have the same value */
2465
2466                         dwb_pipe++;
2467
2468                         if (dwb_pipe >= MAX_DWB_PIPES)
2469                                 return;
2470                 }
2471                 if (dwb_pipe >= MAX_DWB_PIPES)
2472                         return;
2473         }
2474 }
2475
2476 bool dcn20_validate_dsc(struct dc *dc, struct dc_state *new_ctx)
2477 {
2478         int i;
2479
2480         /* Validate DSC config, dsc count validation is already done */
2481         for (i = 0; i < dc->res_pool->pipe_count; i++) {
2482                 struct pipe_ctx *pipe_ctx = &new_ctx->res_ctx.pipe_ctx[i];
2483                 struct dc_stream_state *stream = pipe_ctx->stream;
2484                 struct dsc_config dsc_cfg;
2485                 struct pipe_ctx *odm_pipe;
2486                 int opp_cnt = 1;
2487
2488                 for (odm_pipe = pipe_ctx->next_odm_pipe; odm_pipe; odm_pipe = odm_pipe->next_odm_pipe)
2489                         opp_cnt++;
2490
2491                 /* Only need to validate top pipe */
2492                 if (pipe_ctx->top_pipe || pipe_ctx->prev_odm_pipe || !stream || !stream->timing.flags.DSC)
2493                         continue;
2494
2495                 dsc_cfg.pic_width = (stream->timing.h_addressable + stream->timing.h_border_left
2496                                 + stream->timing.h_border_right) / opp_cnt;
2497                 dsc_cfg.pic_height = stream->timing.v_addressable + stream->timing.v_border_top
2498                                 + stream->timing.v_border_bottom;
2499                 dsc_cfg.pixel_encoding = stream->timing.pixel_encoding;
2500                 dsc_cfg.color_depth = stream->timing.display_color_depth;
2501                 dsc_cfg.is_odm = pipe_ctx->next_odm_pipe ? true : false;
2502                 dsc_cfg.dc_dsc_cfg = stream->timing.dsc_cfg;
2503                 dsc_cfg.dc_dsc_cfg.num_slices_h /= opp_cnt;
2504
2505                 if (!pipe_ctx->stream_res.dsc->funcs->dsc_validate_stream(pipe_ctx->stream_res.dsc, &dsc_cfg))
2506                         return false;
2507         }
2508         return true;
2509 }
2510
2511 struct pipe_ctx *dcn20_find_secondary_pipe(struct dc *dc,
2512                 struct resource_context *res_ctx,
2513                 const struct resource_pool *pool,
2514                 const struct pipe_ctx *primary_pipe)
2515 {
2516         struct pipe_ctx *secondary_pipe = NULL;
2517
2518         if (dc && primary_pipe) {
2519                 int j;
2520                 int preferred_pipe_idx = 0;
2521
2522                 /* first check the prev dc state:
2523                  * if this primary pipe has a bottom pipe in prev. state
2524                  * and if the bottom pipe is still available (which it should be),
2525                  * pick that pipe as secondary
2526                  * Same logic applies for ODM pipes
2527                  */
2528                 if (dc->current_state->res_ctx.pipe_ctx[primary_pipe->pipe_idx].bottom_pipe) {
2529                         preferred_pipe_idx = dc->current_state->res_ctx.pipe_ctx[primary_pipe->pipe_idx].bottom_pipe->pipe_idx;
2530                         if (res_ctx->pipe_ctx[preferred_pipe_idx].stream == NULL) {
2531                                 secondary_pipe = &res_ctx->pipe_ctx[preferred_pipe_idx];
2532                                 secondary_pipe->pipe_idx = preferred_pipe_idx;
2533                         }
2534                 }
2535                 if (secondary_pipe == NULL &&
2536                                 dc->current_state->res_ctx.pipe_ctx[primary_pipe->pipe_idx].next_odm_pipe) {
2537                         preferred_pipe_idx = dc->current_state->res_ctx.pipe_ctx[primary_pipe->pipe_idx].next_odm_pipe->pipe_idx;
2538                         if (res_ctx->pipe_ctx[preferred_pipe_idx].stream == NULL) {
2539                                 secondary_pipe = &res_ctx->pipe_ctx[preferred_pipe_idx];
2540                                 secondary_pipe->pipe_idx = preferred_pipe_idx;
2541                         }
2542                 }
2543
2544                 /*
2545                  * if this primary pipe does not have a bottom pipe in prev. state
2546                  * start backward and find a pipe that did not used to be a bottom pipe in
2547                  * prev. dc state. This way we make sure we keep the same assignment as
2548                  * last state and will not have to reprogram every pipe
2549                  */
2550                 if (secondary_pipe == NULL) {
2551                         for (j = dc->res_pool->pipe_count - 1; j >= 0; j--) {
2552                                 if (dc->current_state->res_ctx.pipe_ctx[j].top_pipe == NULL
2553                                                 && dc->current_state->res_ctx.pipe_ctx[j].prev_odm_pipe == NULL) {
2554                                         preferred_pipe_idx = j;
2555
2556                                         if (res_ctx->pipe_ctx[preferred_pipe_idx].stream == NULL) {
2557                                                 secondary_pipe = &res_ctx->pipe_ctx[preferred_pipe_idx];
2558                                                 secondary_pipe->pipe_idx = preferred_pipe_idx;
2559                                                 break;
2560                                         }
2561                                 }
2562                         }
2563                 }
2564                 /*
2565                  * We should never hit this assert unless assignments are shuffled around
2566                  * if this happens we will prob. hit a vsync tdr
2567                  */
2568                 ASSERT(secondary_pipe);
2569                 /*
2570                  * search backwards for the second pipe to keep pipe
2571                  * assignment more consistent
2572                  */
2573                 if (secondary_pipe == NULL) {
2574                         for (j = dc->res_pool->pipe_count - 1; j >= 0; j--) {
2575                                 preferred_pipe_idx = j;
2576
2577                                 if (res_ctx->pipe_ctx[preferred_pipe_idx].stream == NULL) {
2578                                         secondary_pipe = &res_ctx->pipe_ctx[preferred_pipe_idx];
2579                                         secondary_pipe->pipe_idx = preferred_pipe_idx;
2580                                         break;
2581                                 }
2582                         }
2583                 }
2584         }
2585
2586         return secondary_pipe;
2587 }
2588
2589 void dcn20_merge_pipes_for_validate(
2590                 struct dc *dc,
2591                 struct dc_state *context)
2592 {
2593         int i;
2594
2595         /* merge previously split odm pipes since mode support needs to make the decision */
2596         for (i = 0; i < dc->res_pool->pipe_count; i++) {
2597                 struct pipe_ctx *pipe = &context->res_ctx.pipe_ctx[i];
2598                 struct pipe_ctx *odm_pipe = pipe->next_odm_pipe;
2599
2600                 if (pipe->prev_odm_pipe)
2601                         continue;
2602
2603                 pipe->next_odm_pipe = NULL;
2604                 while (odm_pipe) {
2605                         struct pipe_ctx *next_odm_pipe = odm_pipe->next_odm_pipe;
2606
2607                         odm_pipe->plane_state = NULL;
2608                         odm_pipe->stream = NULL;
2609                         odm_pipe->top_pipe = NULL;
2610                         odm_pipe->bottom_pipe = NULL;
2611                         odm_pipe->prev_odm_pipe = NULL;
2612                         odm_pipe->next_odm_pipe = NULL;
2613                         if (odm_pipe->stream_res.dsc)
2614                                 dcn20_release_dsc(&context->res_ctx, dc->res_pool, &odm_pipe->stream_res.dsc);
2615                         /* Clear plane_res and stream_res */
2616                         memset(&odm_pipe->plane_res, 0, sizeof(odm_pipe->plane_res));
2617                         memset(&odm_pipe->stream_res, 0, sizeof(odm_pipe->stream_res));
2618                         odm_pipe = next_odm_pipe;
2619                 }
2620                 if (pipe->plane_state)
2621                         resource_build_scaling_params(pipe);
2622         }
2623
2624         /* merge previously mpc split pipes since mode support needs to make the decision */
2625         for (i = 0; i < dc->res_pool->pipe_count; i++) {
2626                 struct pipe_ctx *pipe = &context->res_ctx.pipe_ctx[i];
2627                 struct pipe_ctx *hsplit_pipe = pipe->bottom_pipe;
2628
2629                 if (!hsplit_pipe || hsplit_pipe->plane_state != pipe->plane_state)
2630                         continue;
2631
2632                 pipe->bottom_pipe = hsplit_pipe->bottom_pipe;
2633                 if (hsplit_pipe->bottom_pipe)
2634                         hsplit_pipe->bottom_pipe->top_pipe = pipe;
2635                 hsplit_pipe->plane_state = NULL;
2636                 hsplit_pipe->stream = NULL;
2637                 hsplit_pipe->top_pipe = NULL;
2638                 hsplit_pipe->bottom_pipe = NULL;
2639
2640                 /* Clear plane_res and stream_res */
2641                 memset(&hsplit_pipe->plane_res, 0, sizeof(hsplit_pipe->plane_res));
2642                 memset(&hsplit_pipe->stream_res, 0, sizeof(hsplit_pipe->stream_res));
2643                 if (pipe->plane_state)
2644                         resource_build_scaling_params(pipe);
2645         }
2646 }
2647
2648 int dcn20_validate_apply_pipe_split_flags(
2649                 struct dc *dc,
2650                 struct dc_state *context,
2651                 int vlevel,
2652                 int *split,
2653                 bool *merge)
2654 {
2655         int i, pipe_idx, vlevel_split;
2656         int plane_count = 0;
2657         bool force_split = false;
2658         bool avoid_split = dc->debug.pipe_split_policy == MPC_SPLIT_AVOID;
2659         struct vba_vars_st *v = &context->bw_ctx.dml.vba;
2660         int max_mpc_comb = v->maxMpcComb;
2661
2662         if (context->stream_count > 1) {
2663                 if (dc->debug.pipe_split_policy == MPC_SPLIT_AVOID_MULT_DISP)
2664                         avoid_split = true;
2665         } else if (dc->debug.force_single_disp_pipe_split)
2666                         force_split = true;
2667
2668         for (i = 0; i < dc->res_pool->pipe_count; i++) {
2669                 struct pipe_ctx *pipe = &context->res_ctx.pipe_ctx[i];
2670
2671                 /**
2672                  * Workaround for avoiding pipe-split in cases where we'd split
2673                  * planes that are too small, resulting in splits that aren't
2674                  * valid for the scaler.
2675                  */
2676                 if (pipe->plane_state &&
2677                     (pipe->plane_state->dst_rect.width <= 16 ||
2678                      pipe->plane_state->dst_rect.height <= 16 ||
2679                      pipe->plane_state->src_rect.width <= 16 ||
2680                      pipe->plane_state->src_rect.height <= 16))
2681                         avoid_split = true;
2682
2683                 /* TODO: fix dc bugs and remove this split threshold thing */
2684                 if (pipe->stream && !pipe->prev_odm_pipe &&
2685                                 (!pipe->top_pipe || pipe->top_pipe->plane_state != pipe->plane_state))
2686                         ++plane_count;
2687         }
2688         if (plane_count > dc->res_pool->pipe_count / 2)
2689                 avoid_split = true;
2690
2691         /* W/A: Mode timing with borders may not work well with pipe split, avoid for this corner case */
2692         for (i = 0; i < dc->res_pool->pipe_count; i++) {
2693                 struct pipe_ctx *pipe = &context->res_ctx.pipe_ctx[i];
2694                 struct dc_crtc_timing timing;
2695
2696                 if (!pipe->stream)
2697                         continue;
2698                 else {
2699                         timing = pipe->stream->timing;
2700                         if (timing.h_border_left + timing.h_border_right
2701                                         + timing.v_border_top + timing.v_border_bottom > 0) {
2702                                 avoid_split = true;
2703                                 break;
2704                         }
2705                 }
2706         }
2707
2708         /* Avoid split loop looks for lowest voltage level that allows most unsplit pipes possible */
2709         if (avoid_split) {
2710                 for (i = 0, pipe_idx = 0; i < dc->res_pool->pipe_count; i++) {
2711                         if (!context->res_ctx.pipe_ctx[i].stream)
2712                                 continue;
2713
2714                         for (vlevel_split = vlevel; vlevel <= context->bw_ctx.dml.soc.num_states; vlevel++)
2715                                 if (v->NoOfDPP[vlevel][0][pipe_idx] == 1 &&
2716                                                 v->ModeSupport[vlevel][0])
2717                                         break;
2718                         /* Impossible to not split this pipe */
2719                         if (vlevel > context->bw_ctx.dml.soc.num_states)
2720                                 vlevel = vlevel_split;
2721                         else
2722                                 max_mpc_comb = 0;
2723                         pipe_idx++;
2724                 }
2725                 v->maxMpcComb = max_mpc_comb;
2726         }
2727
2728         /* Split loop sets which pipe should be split based on dml outputs and dc flags */
2729         for (i = 0, pipe_idx = 0; i < dc->res_pool->pipe_count; i++) {
2730                 struct pipe_ctx *pipe = &context->res_ctx.pipe_ctx[i];
2731                 int pipe_plane = v->pipe_plane[pipe_idx];
2732                 bool split4mpc = context->stream_count == 1 && plane_count == 1
2733                                 && dc->config.enable_4to1MPC && dc->res_pool->pipe_count >= 4;
2734
2735                 if (!context->res_ctx.pipe_ctx[i].stream)
2736                         continue;
2737
2738                 if (split4mpc || v->NoOfDPP[vlevel][max_mpc_comb][pipe_plane] == 4)
2739                         split[i] = 4;
2740                 else if (force_split || v->NoOfDPP[vlevel][max_mpc_comb][pipe_plane] == 2)
2741                                 split[i] = 2;
2742
2743                 if ((pipe->stream->view_format ==
2744                                 VIEW_3D_FORMAT_SIDE_BY_SIDE ||
2745                                 pipe->stream->view_format ==
2746                                 VIEW_3D_FORMAT_TOP_AND_BOTTOM) &&
2747                                 (pipe->stream->timing.timing_3d_format ==
2748                                 TIMING_3D_FORMAT_TOP_AND_BOTTOM ||
2749                                  pipe->stream->timing.timing_3d_format ==
2750                                 TIMING_3D_FORMAT_SIDE_BY_SIDE))
2751                         split[i] = 2;
2752                 if (dc->debug.force_odm_combine & (1 << pipe->stream_res.tg->inst)) {
2753                         split[i] = 2;
2754                         v->ODMCombineEnablePerState[vlevel][pipe_plane] = dm_odm_combine_mode_2to1;
2755                 }
2756                 if (dc->debug.force_odm_combine_4to1 & (1 << pipe->stream_res.tg->inst)) {
2757                         split[i] = 4;
2758                         v->ODMCombineEnablePerState[vlevel][pipe_plane] = dm_odm_combine_mode_4to1;
2759                 }
2760                 /*420 format workaround*/
2761                 if (pipe->stream->timing.h_addressable > 7680 &&
2762                                 pipe->stream->timing.pixel_encoding == PIXEL_ENCODING_YCBCR420) {
2763                         split[i] = 4;
2764                 }
2765                 v->ODMCombineEnabled[pipe_plane] =
2766                         v->ODMCombineEnablePerState[vlevel][pipe_plane];
2767
2768                 if (v->ODMCombineEnabled[pipe_plane] == dm_odm_combine_mode_disabled) {
2769                         if (get_num_mpc_splits(pipe) == 1) {
2770                                 /*If need split for mpc but 2 way split already*/
2771                                 if (split[i] == 4)
2772                                         split[i] = 2; /* 2 -> 4 MPC */
2773                                 else if (split[i] == 2)
2774                                         split[i] = 0; /* 2 -> 2 MPC */
2775                                 else if (pipe->top_pipe && pipe->top_pipe->plane_state == pipe->plane_state)
2776                                         merge[i] = true; /* 2 -> 1 MPC */
2777                         } else if (get_num_mpc_splits(pipe) == 3) {
2778                                 /*If need split for mpc but 4 way split already*/
2779                                 if (split[i] == 2 && ((pipe->top_pipe && !pipe->top_pipe->top_pipe)
2780                                                 || !pipe->bottom_pipe)) {
2781                                         merge[i] = true; /* 4 -> 2 MPC */
2782                                 } else if (split[i] == 0 && pipe->top_pipe &&
2783                                                 pipe->top_pipe->plane_state == pipe->plane_state)
2784                                         merge[i] = true; /* 4 -> 1 MPC */
2785                                 split[i] = 0;
2786                         } else if (get_num_odm_splits(pipe)) {
2787                                 /* ODM -> MPC transition */
2788                                 ASSERT(0); /* NOT expected yet */
2789                                 if (pipe->prev_odm_pipe) {
2790                                         split[i] = 0;
2791                                         merge[i] = true;
2792                                 }
2793                         }
2794                 } else {
2795                         if (get_num_odm_splits(pipe) == 1) {
2796                                 /*If need split for odm but 2 way split already*/
2797                                 if (split[i] == 4)
2798                                         split[i] = 2; /* 2 -> 4 ODM */
2799                                 else if (split[i] == 2)
2800                                         split[i] = 0; /* 2 -> 2 ODM */
2801                                 else if (pipe->prev_odm_pipe) {
2802                                         ASSERT(0); /* NOT expected yet */
2803                                         merge[i] = true; /* exit ODM */
2804                                 }
2805                         } else if (get_num_odm_splits(pipe) == 3) {
2806                                 /*If need split for odm but 4 way split already*/
2807                                 if (split[i] == 2 && ((pipe->prev_odm_pipe && !pipe->prev_odm_pipe->prev_odm_pipe)
2808                                                 || !pipe->next_odm_pipe)) {
2809                                         ASSERT(0); /* NOT expected yet */
2810                                         merge[i] = true; /* 4 -> 2 ODM */
2811                                 } else if (split[i] == 0 && pipe->prev_odm_pipe) {
2812                                         ASSERT(0); /* NOT expected yet */
2813                                         merge[i] = true; /* exit ODM */
2814                                 }
2815                                 split[i] = 0;
2816                         } else if (get_num_mpc_splits(pipe)) {
2817                                 /* MPC -> ODM transition */
2818                                 ASSERT(0); /* NOT expected yet */
2819                                 if (pipe->top_pipe && pipe->top_pipe->plane_state == pipe->plane_state) {
2820                                         split[i] = 0;
2821                                         merge[i] = true;
2822                                 }
2823                         }
2824                 }
2825
2826                 /* Adjust dppclk when split is forced, do not bother with dispclk */
2827                 if (split[i] != 0 && v->NoOfDPP[vlevel][max_mpc_comb][pipe_idx] == 1)
2828                         v->RequiredDPPCLK[vlevel][max_mpc_comb][pipe_idx] /= 2;
2829                 pipe_idx++;
2830         }
2831
2832         return vlevel;
2833 }
2834
2835 bool dcn20_fast_validate_bw(
2836                 struct dc *dc,
2837                 struct dc_state *context,
2838                 display_e2e_pipe_params_st *pipes,
2839                 int *pipe_cnt_out,
2840                 int *pipe_split_from,
2841                 int *vlevel_out,
2842                 bool fast_validate)
2843 {
2844         bool out = false;
2845         int split[MAX_PIPES] = { 0 };
2846         int pipe_cnt, i, pipe_idx, vlevel;
2847
2848         ASSERT(pipes);
2849         if (!pipes)
2850                 return false;
2851
2852         dcn20_merge_pipes_for_validate(dc, context);
2853
2854         pipe_cnt = dc->res_pool->funcs->populate_dml_pipes(dc, context, pipes, fast_validate);
2855
2856         *pipe_cnt_out = pipe_cnt;
2857
2858         if (!pipe_cnt) {
2859                 out = true;
2860                 goto validate_out;
2861         }
2862
2863         vlevel = dml_get_voltage_level(&context->bw_ctx.dml, pipes, pipe_cnt);
2864
2865         if (vlevel > context->bw_ctx.dml.soc.num_states)
2866                 goto validate_fail;
2867
2868         vlevel = dcn20_validate_apply_pipe_split_flags(dc, context, vlevel, split, NULL);
2869
2870         /*initialize pipe_just_split_from to invalid idx*/
2871         for (i = 0; i < MAX_PIPES; i++)
2872                 pipe_split_from[i] = -1;
2873
2874         for (i = 0, pipe_idx = -1; i < dc->res_pool->pipe_count; i++) {
2875                 struct pipe_ctx *pipe = &context->res_ctx.pipe_ctx[i];
2876                 struct pipe_ctx *hsplit_pipe = pipe->bottom_pipe;
2877
2878                 if (!pipe->stream || pipe_split_from[i] >= 0)
2879                         continue;
2880
2881                 pipe_idx++;
2882
2883                 if (!pipe->top_pipe && !pipe->plane_state && context->bw_ctx.dml.vba.ODMCombineEnabled[pipe_idx]) {
2884                         hsplit_pipe = dcn20_find_secondary_pipe(dc, &context->res_ctx, dc->res_pool, pipe);
2885                         ASSERT(hsplit_pipe);
2886                         if (!dcn20_split_stream_for_odm(
2887                                         dc, &context->res_ctx,
2888                                         pipe, hsplit_pipe))
2889                                 goto validate_fail;
2890                         pipe_split_from[hsplit_pipe->pipe_idx] = pipe_idx;
2891                         dcn20_build_mapped_resource(dc, context, pipe->stream);
2892                 }
2893
2894                 if (!pipe->plane_state)
2895                         continue;
2896                 /* Skip 2nd half of already split pipe */
2897                 if (pipe->top_pipe && pipe->plane_state == pipe->top_pipe->plane_state)
2898                         continue;
2899
2900                 /* We do not support mpo + odm at the moment */
2901                 if (hsplit_pipe && hsplit_pipe->plane_state != pipe->plane_state
2902                                 && context->bw_ctx.dml.vba.ODMCombineEnabled[pipe_idx])
2903                         goto validate_fail;
2904
2905                 if (split[i] == 2) {
2906                         if (!hsplit_pipe || hsplit_pipe->plane_state != pipe->plane_state) {
2907                                 /* pipe not split previously needs split */
2908                                 hsplit_pipe = dcn20_find_secondary_pipe(dc, &context->res_ctx, dc->res_pool, pipe);
2909                                 ASSERT(hsplit_pipe);
2910                                 if (!hsplit_pipe) {
2911                                         context->bw_ctx.dml.vba.RequiredDPPCLK[vlevel][context->bw_ctx.dml.vba.maxMpcComb][pipe_idx] *= 2;
2912                                         continue;
2913                                 }
2914                                 if (context->bw_ctx.dml.vba.ODMCombineEnabled[pipe_idx]) {
2915                                         if (!dcn20_split_stream_for_odm(
2916                                                         dc, &context->res_ctx,
2917                                                         pipe, hsplit_pipe))
2918                                                 goto validate_fail;
2919                                         dcn20_build_mapped_resource(dc, context, pipe->stream);
2920                                 } else {
2921                                         dcn20_split_stream_for_mpc(
2922                                                         &context->res_ctx, dc->res_pool,
2923                                                         pipe, hsplit_pipe);
2924                                         resource_build_scaling_params(pipe);
2925                                         resource_build_scaling_params(hsplit_pipe);
2926                                 }
2927                                 pipe_split_from[hsplit_pipe->pipe_idx] = pipe_idx;
2928                         }
2929                 } else if (hsplit_pipe && hsplit_pipe->plane_state == pipe->plane_state) {
2930                         /* merge should already have been done */
2931                         ASSERT(0);
2932                 }
2933         }
2934         /* Actual dsc count per stream dsc validation*/
2935         if (!dcn20_validate_dsc(dc, context)) {
2936                 context->bw_ctx.dml.vba.ValidationStatus[context->bw_ctx.dml.vba.soc.num_states] =
2937                                 DML_FAIL_DSC_VALIDATION_FAILURE;
2938                 goto validate_fail;
2939         }
2940
2941         *vlevel_out = vlevel;
2942
2943         out = true;
2944         goto validate_out;
2945
2946 validate_fail:
2947         out = false;
2948
2949 validate_out:
2950         return out;
2951 }
2952
2953 static void dcn20_calculate_wm(
2954                 struct dc *dc, struct dc_state *context,
2955                 display_e2e_pipe_params_st *pipes,
2956                 int *out_pipe_cnt,
2957                 int *pipe_split_from,
2958                 int vlevel,
2959                 bool fast_validate)
2960 {
2961         int pipe_cnt, i, pipe_idx;
2962
2963         for (i = 0, pipe_idx = 0, pipe_cnt = 0; i < dc->res_pool->pipe_count; i++) {
2964                 if (!context->res_ctx.pipe_ctx[i].stream)
2965                         continue;
2966
2967                 pipes[pipe_cnt].clks_cfg.refclk_mhz = dc->res_pool->ref_clocks.dchub_ref_clock_inKhz / 1000.0;
2968                 pipes[pipe_cnt].clks_cfg.dispclk_mhz = context->bw_ctx.dml.vba.RequiredDISPCLK[vlevel][context->bw_ctx.dml.vba.maxMpcComb];
2969
2970                 if (pipe_split_from[i] < 0) {
2971                         pipes[pipe_cnt].clks_cfg.dppclk_mhz =
2972                                         context->bw_ctx.dml.vba.RequiredDPPCLK[vlevel][context->bw_ctx.dml.vba.maxMpcComb][pipe_idx];
2973                         if (context->bw_ctx.dml.vba.BlendingAndTiming[pipe_idx] == pipe_idx)
2974                                 pipes[pipe_cnt].pipe.dest.odm_combine =
2975                                                 context->bw_ctx.dml.vba.ODMCombineEnabled[pipe_idx];
2976                         else
2977                                 pipes[pipe_cnt].pipe.dest.odm_combine = 0;
2978                         pipe_idx++;
2979                 } else {
2980                         pipes[pipe_cnt].clks_cfg.dppclk_mhz =
2981                                         context->bw_ctx.dml.vba.RequiredDPPCLK[vlevel][context->bw_ctx.dml.vba.maxMpcComb][pipe_split_from[i]];
2982                         if (context->bw_ctx.dml.vba.BlendingAndTiming[pipe_split_from[i]] == pipe_split_from[i])
2983                                 pipes[pipe_cnt].pipe.dest.odm_combine =
2984                                                 context->bw_ctx.dml.vba.ODMCombineEnabled[pipe_split_from[i]];
2985                         else
2986                                 pipes[pipe_cnt].pipe.dest.odm_combine = 0;
2987                 }
2988
2989                 if (dc->config.forced_clocks) {
2990                         pipes[pipe_cnt].clks_cfg.dispclk_mhz = context->bw_ctx.dml.soc.clock_limits[0].dispclk_mhz;
2991                         pipes[pipe_cnt].clks_cfg.dppclk_mhz = context->bw_ctx.dml.soc.clock_limits[0].dppclk_mhz;
2992                 }
2993                 if (dc->debug.min_disp_clk_khz > pipes[pipe_cnt].clks_cfg.dispclk_mhz * 1000)
2994                         pipes[pipe_cnt].clks_cfg.dispclk_mhz = dc->debug.min_disp_clk_khz / 1000.0;
2995                 if (dc->debug.min_dpp_clk_khz > pipes[pipe_cnt].clks_cfg.dppclk_mhz * 1000)
2996                         pipes[pipe_cnt].clks_cfg.dppclk_mhz = dc->debug.min_dpp_clk_khz / 1000.0;
2997
2998                 pipe_cnt++;
2999         }
3000
3001         if (pipe_cnt != pipe_idx) {
3002                 if (dc->res_pool->funcs->populate_dml_pipes)
3003                         pipe_cnt = dc->res_pool->funcs->populate_dml_pipes(dc,
3004                                 context, pipes, fast_validate);
3005                 else
3006                         pipe_cnt = dcn20_populate_dml_pipes_from_context(dc,
3007                                 context, pipes, fast_validate);
3008         }
3009
3010         *out_pipe_cnt = pipe_cnt;
3011
3012         pipes[0].clks_cfg.voltage = vlevel;
3013         pipes[0].clks_cfg.dcfclk_mhz = context->bw_ctx.dml.soc.clock_limits[vlevel].dcfclk_mhz;
3014         pipes[0].clks_cfg.socclk_mhz = context->bw_ctx.dml.soc.clock_limits[vlevel].socclk_mhz;
3015
3016         /* only pipe 0 is read for voltage and dcf/soc clocks */
3017         if (vlevel < 1) {
3018                 pipes[0].clks_cfg.voltage = 1;
3019                 pipes[0].clks_cfg.dcfclk_mhz = context->bw_ctx.dml.soc.clock_limits[1].dcfclk_mhz;
3020                 pipes[0].clks_cfg.socclk_mhz = context->bw_ctx.dml.soc.clock_limits[1].socclk_mhz;
3021         }
3022         context->bw_ctx.bw.dcn.watermarks.b.urgent_ns = get_wm_urgent(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3023         context->bw_ctx.bw.dcn.watermarks.b.cstate_pstate.cstate_enter_plus_exit_ns = get_wm_stutter_enter_exit(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3024         context->bw_ctx.bw.dcn.watermarks.b.cstate_pstate.cstate_exit_ns = get_wm_stutter_exit(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3025         context->bw_ctx.bw.dcn.watermarks.b.cstate_pstate.pstate_change_ns = get_wm_dram_clock_change(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3026         context->bw_ctx.bw.dcn.watermarks.b.pte_meta_urgent_ns = get_wm_memory_trip(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3027         context->bw_ctx.bw.dcn.watermarks.b.frac_urg_bw_nom = get_fraction_of_urgent_bandwidth(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3028         context->bw_ctx.bw.dcn.watermarks.b.frac_urg_bw_flip = get_fraction_of_urgent_bandwidth_imm_flip(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3029         context->bw_ctx.bw.dcn.watermarks.b.urgent_latency_ns = get_urgent_latency(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3030
3031         if (vlevel < 2) {
3032                 pipes[0].clks_cfg.voltage = 2;
3033                 pipes[0].clks_cfg.dcfclk_mhz = context->bw_ctx.dml.soc.clock_limits[2].dcfclk_mhz;
3034                 pipes[0].clks_cfg.socclk_mhz = context->bw_ctx.dml.soc.clock_limits[2].socclk_mhz;
3035         }
3036         context->bw_ctx.bw.dcn.watermarks.c.urgent_ns = get_wm_urgent(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3037         context->bw_ctx.bw.dcn.watermarks.c.cstate_pstate.cstate_enter_plus_exit_ns = get_wm_stutter_enter_exit(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3038         context->bw_ctx.bw.dcn.watermarks.c.cstate_pstate.cstate_exit_ns = get_wm_stutter_exit(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3039         context->bw_ctx.bw.dcn.watermarks.c.cstate_pstate.pstate_change_ns = get_wm_dram_clock_change(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3040         context->bw_ctx.bw.dcn.watermarks.c.pte_meta_urgent_ns = get_wm_memory_trip(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3041         context->bw_ctx.bw.dcn.watermarks.c.frac_urg_bw_nom = get_fraction_of_urgent_bandwidth(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3042         context->bw_ctx.bw.dcn.watermarks.c.frac_urg_bw_flip = get_fraction_of_urgent_bandwidth_imm_flip(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3043
3044         if (vlevel < 3) {
3045                 pipes[0].clks_cfg.voltage = 3;
3046                 pipes[0].clks_cfg.dcfclk_mhz = context->bw_ctx.dml.soc.clock_limits[2].dcfclk_mhz;
3047                 pipes[0].clks_cfg.socclk_mhz = context->bw_ctx.dml.soc.clock_limits[2].socclk_mhz;
3048         }
3049         context->bw_ctx.bw.dcn.watermarks.d.urgent_ns = get_wm_urgent(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3050         context->bw_ctx.bw.dcn.watermarks.d.cstate_pstate.cstate_enter_plus_exit_ns = get_wm_stutter_enter_exit(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3051         context->bw_ctx.bw.dcn.watermarks.d.cstate_pstate.cstate_exit_ns = get_wm_stutter_exit(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3052         context->bw_ctx.bw.dcn.watermarks.d.cstate_pstate.pstate_change_ns = get_wm_dram_clock_change(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3053         context->bw_ctx.bw.dcn.watermarks.d.pte_meta_urgent_ns = get_wm_memory_trip(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3054         context->bw_ctx.bw.dcn.watermarks.d.frac_urg_bw_nom = get_fraction_of_urgent_bandwidth(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3055         context->bw_ctx.bw.dcn.watermarks.d.frac_urg_bw_flip = get_fraction_of_urgent_bandwidth_imm_flip(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3056
3057         pipes[0].clks_cfg.voltage = vlevel;
3058         pipes[0].clks_cfg.dcfclk_mhz = context->bw_ctx.dml.soc.clock_limits[vlevel].dcfclk_mhz;
3059         pipes[0].clks_cfg.socclk_mhz = context->bw_ctx.dml.soc.clock_limits[vlevel].socclk_mhz;
3060         context->bw_ctx.bw.dcn.watermarks.a.urgent_ns = get_wm_urgent(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3061         context->bw_ctx.bw.dcn.watermarks.a.cstate_pstate.cstate_enter_plus_exit_ns = get_wm_stutter_enter_exit(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3062         context->bw_ctx.bw.dcn.watermarks.a.cstate_pstate.cstate_exit_ns = get_wm_stutter_exit(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3063         context->bw_ctx.bw.dcn.watermarks.a.cstate_pstate.pstate_change_ns = get_wm_dram_clock_change(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3064         context->bw_ctx.bw.dcn.watermarks.a.pte_meta_urgent_ns = get_wm_memory_trip(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3065         context->bw_ctx.bw.dcn.watermarks.a.frac_urg_bw_nom = get_fraction_of_urgent_bandwidth(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3066         context->bw_ctx.bw.dcn.watermarks.a.frac_urg_bw_flip = get_fraction_of_urgent_bandwidth_imm_flip(&context->bw_ctx.dml, pipes, pipe_cnt) * 1000;
3067 }
3068
3069 void dcn20_calculate_dlg_params(
3070                 struct dc *dc, struct dc_state *context,
3071                 display_e2e_pipe_params_st *pipes,
3072                 int pipe_cnt,
3073                 int vlevel)
3074 {
3075         int i, pipe_idx;
3076
3077         /* Writeback MCIF_WB arbitration parameters */
3078         dc->res_pool->funcs->set_mcif_arb_params(dc, context, pipes, pipe_cnt);
3079
3080         context->bw_ctx.bw.dcn.clk.dispclk_khz = context->bw_ctx.dml.vba.DISPCLK * 1000;
3081         context->bw_ctx.bw.dcn.clk.dcfclk_khz = context->bw_ctx.dml.vba.DCFCLK * 1000;
3082         context->bw_ctx.bw.dcn.clk.socclk_khz = context->bw_ctx.dml.vba.SOCCLK * 1000;
3083         context->bw_ctx.bw.dcn.clk.dramclk_khz = context->bw_ctx.dml.vba.DRAMSpeed * 1000 / 16;
3084         context->bw_ctx.bw.dcn.clk.dcfclk_deep_sleep_khz = context->bw_ctx.dml.vba.DCFCLKDeepSleep * 1000;
3085         context->bw_ctx.bw.dcn.clk.fclk_khz = context->bw_ctx.dml.vba.FabricClock * 1000;
3086         context->bw_ctx.bw.dcn.clk.p_state_change_support =
3087                 context->bw_ctx.dml.vba.DRAMClockChangeSupport[vlevel][context->bw_ctx.dml.vba.maxMpcComb]
3088                                                         != dm_dram_clock_change_unsupported;
3089         context->bw_ctx.bw.dcn.clk.dppclk_khz = 0;
3090
3091         if (context->bw_ctx.bw.dcn.clk.dispclk_khz < dc->debug.min_disp_clk_khz)
3092                 context->bw_ctx.bw.dcn.clk.dispclk_khz = dc->debug.min_disp_clk_khz;
3093
3094         for (i = 0, pipe_idx = 0; i < dc->res_pool->pipe_count; i++) {
3095                 if (!context->res_ctx.pipe_ctx[i].stream)
3096                         continue;
3097                 pipes[pipe_idx].pipe.dest.vstartup_start = get_vstartup(&context->bw_ctx.dml, pipes, pipe_cnt, pipe_idx);
3098                 pipes[pipe_idx].pipe.dest.vupdate_offset = get_vupdate_offset(&context->bw_ctx.dml, pipes, pipe_cnt, pipe_idx);
3099                 pipes[pipe_idx].pipe.dest.vupdate_width = get_vupdate_width(&context->bw_ctx.dml, pipes, pipe_cnt, pipe_idx);
3100                 pipes[pipe_idx].pipe.dest.vready_offset = get_vready_offset(&context->bw_ctx.dml, pipes, pipe_cnt, pipe_idx);
3101                 if (context->bw_ctx.bw.dcn.clk.dppclk_khz < pipes[pipe_idx].clks_cfg.dppclk_mhz * 1000)
3102                         context->bw_ctx.bw.dcn.clk.dppclk_khz = pipes[pipe_idx].clks_cfg.dppclk_mhz * 1000;
3103                 context->res_ctx.pipe_ctx[i].plane_res.bw.dppclk_khz =
3104                                                 pipes[pipe_idx].clks_cfg.dppclk_mhz * 1000;
3105                 context->res_ctx.pipe_ctx[i].pipe_dlg_param = pipes[pipe_idx].pipe.dest;
3106                 pipe_idx++;
3107         }
3108         /*save a original dppclock copy*/
3109         context->bw_ctx.bw.dcn.clk.bw_dppclk_khz = context->bw_ctx.bw.dcn.clk.dppclk_khz;
3110         context->bw_ctx.bw.dcn.clk.bw_dispclk_khz = context->bw_ctx.bw.dcn.clk.dispclk_khz;
3111         context->bw_ctx.bw.dcn.clk.max_supported_dppclk_khz = context->bw_ctx.dml.soc.clock_limits[vlevel].dppclk_mhz * 1000;
3112         context->bw_ctx.bw.dcn.clk.max_supported_dispclk_khz = context->bw_ctx.dml.soc.clock_limits[vlevel].dispclk_mhz * 1000;
3113
3114         for (i = 0, pipe_idx = 0; i < dc->res_pool->pipe_count; i++) {
3115                 bool cstate_en = context->bw_ctx.dml.vba.PrefetchMode[vlevel][context->bw_ctx.dml.vba.maxMpcComb] != 2;
3116
3117                 if (!context->res_ctx.pipe_ctx[i].stream)
3118                         continue;
3119
3120                 context->bw_ctx.dml.funcs.rq_dlg_get_dlg_reg(&context->bw_ctx.dml,
3121                                 &context->res_ctx.pipe_ctx[i].dlg_regs,
3122                                 &context->res_ctx.pipe_ctx[i].ttu_regs,
3123                                 pipes,
3124                                 pipe_cnt,
3125                                 pipe_idx,
3126                                 cstate_en,
3127                                 context->bw_ctx.bw.dcn.clk.p_state_change_support,
3128                                 false, false, true);
3129
3130                 context->bw_ctx.dml.funcs.rq_dlg_get_rq_reg(&context->bw_ctx.dml,
3131                                 &context->res_ctx.pipe_ctx[i].rq_regs,
3132                                 pipes[pipe_idx].pipe);
3133                 pipe_idx++;
3134         }
3135 }
3136
3137 static bool dcn20_validate_bandwidth_internal(struct dc *dc, struct dc_state *context,
3138                 bool fast_validate)
3139 {
3140         bool out = false;
3141
3142         BW_VAL_TRACE_SETUP();
3143
3144         int vlevel = 0;
3145         int pipe_split_from[MAX_PIPES];
3146         int pipe_cnt = 0;
3147         display_e2e_pipe_params_st *pipes = kzalloc(dc->res_pool->pipe_count * sizeof(display_e2e_pipe_params_st), GFP_ATOMIC);
3148         DC_LOGGER_INIT(dc->ctx->logger);
3149
3150         BW_VAL_TRACE_COUNT();
3151
3152         out = dcn20_fast_validate_bw(dc, context, pipes, &pipe_cnt, pipe_split_from, &vlevel, fast_validate);
3153
3154         if (pipe_cnt == 0)
3155                 goto validate_out;
3156
3157         if (!out)
3158                 goto validate_fail;
3159
3160         BW_VAL_TRACE_END_VOLTAGE_LEVEL();
3161
3162         if (fast_validate) {
3163                 BW_VAL_TRACE_SKIP(fast);
3164                 goto validate_out;
3165         }
3166
3167         dcn20_calculate_wm(dc, context, pipes, &pipe_cnt, pipe_split_from, vlevel, fast_validate);
3168         dcn20_calculate_dlg_params(dc, context, pipes, pipe_cnt, vlevel);
3169
3170         BW_VAL_TRACE_END_WATERMARKS();
3171
3172         goto validate_out;
3173
3174 validate_fail:
3175         DC_LOG_WARNING("Mode Validation Warning: %s failed validation.\n",
3176                 dml_get_status_message(context->bw_ctx.dml.vba.ValidationStatus[context->bw_ctx.dml.vba.soc.num_states]));
3177
3178         BW_VAL_TRACE_SKIP(fail);
3179         out = false;
3180
3181 validate_out:
3182         kfree(pipes);
3183
3184         BW_VAL_TRACE_FINISH();
3185
3186         return out;
3187 }
3188
3189 /*
3190  * This must be noinline to ensure anything that deals with FP registers
3191  * is contained within this call; previously our compiling with hard-float
3192  * would result in fp instructions being emitted outside of the boundaries
3193  * of the DC_FP_START/END macros, which makes sense as the compiler has no
3194  * idea about what is wrapped and what is not
3195  *
3196  * This is largely just a workaround to avoid breakage introduced with 5.6,
3197  * ideally all fp-using code should be moved into its own file, only that
3198  * should be compiled with hard-float, and all code exported from there
3199  * should be strictly wrapped with DC_FP_START/END
3200  */
3201 static noinline bool dcn20_validate_bandwidth_fp(struct dc *dc,
3202                 struct dc_state *context, bool fast_validate)
3203 {
3204         bool voltage_supported = false;
3205         bool full_pstate_supported = false;
3206         bool dummy_pstate_supported = false;
3207         double p_state_latency_us;
3208
3209         p_state_latency_us = context->bw_ctx.dml.soc.dram_clock_change_latency_us;
3210         context->bw_ctx.dml.soc.disable_dram_clock_change_vactive_support =
3211                 dc->debug.disable_dram_clock_change_vactive_support;
3212         context->bw_ctx.dml.soc.allow_dram_clock_one_display_vactive =
3213                 dc->debug.enable_dram_clock_change_one_display_vactive;
3214
3215         /*Unsafe due to current pipe merge and split logic*/
3216         ASSERT(context != dc->current_state);
3217
3218         if (fast_validate) {
3219                 return dcn20_validate_bandwidth_internal(dc, context, true);
3220         }
3221
3222         // Best case, we support full UCLK switch latency
3223         voltage_supported = dcn20_validate_bandwidth_internal(dc, context, false);
3224         full_pstate_supported = context->bw_ctx.bw.dcn.clk.p_state_change_support;
3225
3226         if (context->bw_ctx.dml.soc.dummy_pstate_latency_us == 0 ||
3227                 (voltage_supported && full_pstate_supported)) {
3228                 context->bw_ctx.bw.dcn.clk.p_state_change_support = full_pstate_supported;
3229                 goto restore_dml_state;
3230         }
3231
3232         // Fallback: Try to only support G6 temperature read latency
3233         context->bw_ctx.dml.soc.dram_clock_change_latency_us = context->bw_ctx.dml.soc.dummy_pstate_latency_us;
3234
3235         voltage_supported = dcn20_validate_bandwidth_internal(dc, context, false);
3236         dummy_pstate_supported = context->bw_ctx.bw.dcn.clk.p_state_change_support;
3237
3238         if (voltage_supported && dummy_pstate_supported) {
3239                 context->bw_ctx.bw.dcn.clk.p_state_change_support = false;
3240                 goto restore_dml_state;
3241         }
3242
3243         // ERROR: fallback is supposed to always work.
3244         ASSERT(false);
3245
3246 restore_dml_state:
3247         context->bw_ctx.dml.soc.dram_clock_change_latency_us = p_state_latency_us;
3248         return voltage_supported;
3249 }
3250
3251 bool dcn20_validate_bandwidth(struct dc *dc, struct dc_state *context,
3252                 bool fast_validate)
3253 {
3254         bool voltage_supported;
3255         DC_FP_START();
3256         voltage_supported = dcn20_validate_bandwidth_fp(dc, context, fast_validate);
3257         DC_FP_END();
3258         return voltage_supported;
3259 }
3260
3261 struct pipe_ctx *dcn20_acquire_idle_pipe_for_layer(
3262                 struct dc_state *state,
3263                 const struct resource_pool *pool,
3264                 struct dc_stream_state *stream)
3265 {
3266         struct resource_context *res_ctx = &state->res_ctx;
3267         struct pipe_ctx *head_pipe = resource_get_head_pipe_for_stream(res_ctx, stream);
3268         struct pipe_ctx *idle_pipe = find_idle_secondary_pipe(res_ctx, pool, head_pipe);
3269
3270         if (!head_pipe)
3271                 ASSERT(0);
3272
3273         if (!idle_pipe)
3274                 return NULL;
3275
3276         idle_pipe->stream = head_pipe->stream;
3277         idle_pipe->stream_res.tg = head_pipe->stream_res.tg;
3278         idle_pipe->stream_res.opp = head_pipe->stream_res.opp;
3279
3280         idle_pipe->plane_res.hubp = pool->hubps[idle_pipe->pipe_idx];
3281         idle_pipe->plane_res.ipp = pool->ipps[idle_pipe->pipe_idx];
3282         idle_pipe->plane_res.dpp = pool->dpps[idle_pipe->pipe_idx];
3283         idle_pipe->plane_res.mpcc_inst = pool->dpps[idle_pipe->pipe_idx]->inst;
3284
3285         return idle_pipe;
3286 }
3287
3288 bool dcn20_get_dcc_compression_cap(const struct dc *dc,
3289                 const struct dc_dcc_surface_param *input,
3290                 struct dc_surface_dcc_cap *output)
3291 {
3292         return dc->res_pool->hubbub->funcs->get_dcc_compression_cap(
3293                         dc->res_pool->hubbub,
3294                         input,
3295                         output);
3296 }
3297
3298 static void dcn20_destroy_resource_pool(struct resource_pool **pool)
3299 {
3300         struct dcn20_resource_pool *dcn20_pool = TO_DCN20_RES_POOL(*pool);
3301
3302         dcn20_resource_destruct(dcn20_pool);
3303         kfree(dcn20_pool);
3304         *pool = NULL;
3305 }
3306
3307
3308 static struct dc_cap_funcs cap_funcs = {
3309         .get_dcc_compression_cap = dcn20_get_dcc_compression_cap
3310 };
3311
3312
3313 enum dc_status dcn20_patch_unknown_plane_state(struct dc_plane_state *plane_state)
3314 {
3315         enum surface_pixel_format surf_pix_format = plane_state->format;
3316         unsigned int bpp = resource_pixel_format_to_bpp(surf_pix_format);
3317
3318         enum swizzle_mode_values swizzle = DC_SW_LINEAR;
3319
3320         if (bpp == 64)
3321                 swizzle = DC_SW_64KB_D;
3322         else
3323                 swizzle = DC_SW_64KB_S;
3324
3325         plane_state->tiling_info.gfx9.swizzle = swizzle;
3326         return DC_OK;
3327 }
3328
3329 static const struct resource_funcs dcn20_res_pool_funcs = {
3330         .destroy = dcn20_destroy_resource_pool,
3331         .link_enc_create = dcn20_link_encoder_create,
3332         .panel_cntl_create = dcn20_panel_cntl_create,
3333         .validate_bandwidth = dcn20_validate_bandwidth,
3334         .acquire_idle_pipe_for_layer = dcn20_acquire_idle_pipe_for_layer,
3335         .add_stream_to_ctx = dcn20_add_stream_to_ctx,
3336         .add_dsc_to_stream_resource = dcn20_add_dsc_to_stream_resource,
3337         .remove_stream_from_ctx = dcn20_remove_stream_from_ctx,
3338         .populate_dml_writeback_from_context = dcn20_populate_dml_writeback_from_context,
3339         .patch_unknown_plane_state = dcn20_patch_unknown_plane_state,
3340         .set_mcif_arb_params = dcn20_set_mcif_arb_params,
3341         .populate_dml_pipes = dcn20_populate_dml_pipes_from_context,
3342         .find_first_free_match_stream_enc_for_link = dcn10_find_first_free_match_stream_enc_for_link
3343 };
3344
3345 bool dcn20_dwbc_create(struct dc_context *ctx, struct resource_pool *pool)
3346 {
3347         int i;
3348         uint32_t pipe_count = pool->res_cap->num_dwb;
3349
3350         for (i = 0; i < pipe_count; i++) {
3351                 struct dcn20_dwbc *dwbc20 = kzalloc(sizeof(struct dcn20_dwbc),
3352                                                     GFP_KERNEL);
3353
3354                 if (!dwbc20) {
3355                         dm_error("DC: failed to create dwbc20!\n");
3356                         return false;
3357                 }
3358                 dcn20_dwbc_construct(dwbc20, ctx,
3359                                 &dwbc20_regs[i],
3360                                 &dwbc20_shift,
3361                                 &dwbc20_mask,
3362                                 i);
3363                 pool->dwbc[i] = &dwbc20->base;
3364         }
3365         return true;
3366 }
3367
3368 bool dcn20_mmhubbub_create(struct dc_context *ctx, struct resource_pool *pool)
3369 {
3370         int i;
3371         uint32_t pipe_count = pool->res_cap->num_dwb;
3372
3373         ASSERT(pipe_count > 0);
3374
3375         for (i = 0; i < pipe_count; i++) {
3376                 struct dcn20_mmhubbub *mcif_wb20 = kzalloc(sizeof(struct dcn20_mmhubbub),
3377                                                     GFP_KERNEL);
3378
3379                 if (!mcif_wb20) {
3380                         dm_error("DC: failed to create mcif_wb20!\n");
3381                         return false;
3382                 }
3383
3384                 dcn20_mmhubbub_construct(mcif_wb20, ctx,
3385                                 &mcif_wb20_regs[i],
3386                                 &mcif_wb20_shift,
3387                                 &mcif_wb20_mask,
3388                                 i);
3389
3390                 pool->mcif_wb[i] = &mcif_wb20->base;
3391         }
3392         return true;
3393 }
3394
3395 static struct pp_smu_funcs *dcn20_pp_smu_create(struct dc_context *ctx)
3396 {
3397         struct pp_smu_funcs *pp_smu = kzalloc(sizeof(*pp_smu), GFP_ATOMIC);
3398
3399         if (!pp_smu)
3400                 return pp_smu;
3401
3402         dm_pp_get_funcs(ctx, pp_smu);
3403
3404         if (pp_smu->ctx.ver != PP_SMU_VER_NV)
3405                 pp_smu = memset(pp_smu, 0, sizeof(struct pp_smu_funcs));
3406
3407         return pp_smu;
3408 }
3409
3410 static void dcn20_pp_smu_destroy(struct pp_smu_funcs **pp_smu)
3411 {
3412         if (pp_smu && *pp_smu) {
3413                 kfree(*pp_smu);
3414                 *pp_smu = NULL;
3415         }
3416 }
3417
3418 void dcn20_cap_soc_clocks(
3419                 struct _vcs_dpi_soc_bounding_box_st *bb,
3420                 struct pp_smu_nv_clock_table max_clocks)
3421 {
3422         int i;
3423
3424         // First pass - cap all clocks higher than the reported max
3425         for (i = 0; i < bb->num_states; i++) {
3426                 if ((bb->clock_limits[i].dcfclk_mhz > (max_clocks.dcfClockInKhz / 1000))
3427                                 && max_clocks.dcfClockInKhz != 0)
3428                         bb->clock_limits[i].dcfclk_mhz = (max_clocks.dcfClockInKhz / 1000);
3429
3430                 if ((bb->clock_limits[i].dram_speed_mts > (max_clocks.uClockInKhz / 1000) * 16)
3431                                                 && max_clocks.uClockInKhz != 0)
3432                         bb->clock_limits[i].dram_speed_mts = (max_clocks.uClockInKhz / 1000) * 16;
3433
3434                 if ((bb->clock_limits[i].fabricclk_mhz > (max_clocks.fabricClockInKhz / 1000))
3435                                                 && max_clocks.fabricClockInKhz != 0)
3436                         bb->clock_limits[i].fabricclk_mhz = (max_clocks.fabricClockInKhz / 1000);
3437
3438                 if ((bb->clock_limits[i].dispclk_mhz > (max_clocks.displayClockInKhz / 1000))
3439                                                 && max_clocks.displayClockInKhz != 0)
3440                         bb->clock_limits[i].dispclk_mhz = (max_clocks.displayClockInKhz / 1000);
3441
3442                 if ((bb->clock_limits[i].dppclk_mhz > (max_clocks.dppClockInKhz / 1000))
3443                                                 && max_clocks.dppClockInKhz != 0)
3444                         bb->clock_limits[i].dppclk_mhz = (max_clocks.dppClockInKhz / 1000);
3445
3446                 if ((bb->clock_limits[i].phyclk_mhz > (max_clocks.phyClockInKhz / 1000))
3447                                                 && max_clocks.phyClockInKhz != 0)
3448                         bb->clock_limits[i].phyclk_mhz = (max_clocks.phyClockInKhz / 1000);
3449
3450                 if ((bb->clock_limits[i].socclk_mhz > (max_clocks.socClockInKhz / 1000))
3451                                                 && max_clocks.socClockInKhz != 0)
3452                         bb->clock_limits[i].socclk_mhz = (max_clocks.socClockInKhz / 1000);
3453
3454                 if ((bb->clock_limits[i].dscclk_mhz > (max_clocks.dscClockInKhz / 1000))
3455                                                 && max_clocks.dscClockInKhz != 0)
3456                         bb->clock_limits[i].dscclk_mhz = (max_clocks.dscClockInKhz / 1000);
3457         }
3458
3459         // Second pass - remove all duplicate clock states
3460         for (i = bb->num_states - 1; i > 1; i--) {
3461                 bool duplicate = true;
3462
3463                 if (bb->clock_limits[i-1].dcfclk_mhz != bb->clock_limits[i].dcfclk_mhz)
3464                         duplicate = false;
3465                 if (bb->clock_limits[i-1].dispclk_mhz != bb->clock_limits[i].dispclk_mhz)
3466                         duplicate = false;
3467                 if (bb->clock_limits[i-1].dppclk_mhz != bb->clock_limits[i].dppclk_mhz)
3468                         duplicate = false;
3469                 if (bb->clock_limits[i-1].dram_speed_mts != bb->clock_limits[i].dram_speed_mts)
3470                         duplicate = false;
3471                 if (bb->clock_limits[i-1].dscclk_mhz != bb->clock_limits[i].dscclk_mhz)
3472                         duplicate = false;
3473                 if (bb->clock_limits[i-1].fabricclk_mhz != bb->clock_limits[i].fabricclk_mhz)
3474                         duplicate = false;
3475                 if (bb->clock_limits[i-1].phyclk_mhz != bb->clock_limits[i].phyclk_mhz)
3476                         duplicate = false;
3477                 if (bb->clock_limits[i-1].socclk_mhz != bb->clock_limits[i].socclk_mhz)
3478                         duplicate = false;
3479
3480                 if (duplicate)
3481                         bb->num_states--;
3482         }
3483 }
3484
3485 void dcn20_update_bounding_box(struct dc *dc, struct _vcs_dpi_soc_bounding_box_st *bb,
3486                 struct pp_smu_nv_clock_table *max_clocks, unsigned int *uclk_states, unsigned int num_states)
3487 {
3488         struct _vcs_dpi_voltage_scaling_st calculated_states[DC__VOLTAGE_STATES];
3489         int i;
3490         int num_calculated_states = 0;
3491         int min_dcfclk = 0;
3492
3493         if (num_states == 0)
3494                 return;
3495
3496         memset(calculated_states, 0, sizeof(calculated_states));
3497
3498         if (dc->bb_overrides.min_dcfclk_mhz > 0)
3499                 min_dcfclk = dc->bb_overrides.min_dcfclk_mhz;
3500         else {
3501                 if (ASICREV_IS_NAVI12_P(dc->ctx->asic_id.hw_internal_rev))
3502                         min_dcfclk = 310;
3503                 else
3504                         // Accounting for SOC/DCF relationship, we can go as high as
3505                         // 506Mhz in Vmin.
3506                         min_dcfclk = 506;
3507         }
3508
3509         for (i = 0; i < num_states; i++) {
3510                 int min_fclk_required_by_uclk;
3511                 calculated_states[i].state = i;
3512                 calculated_states[i].dram_speed_mts = uclk_states[i] * 16 / 1000;
3513
3514                 // FCLK:UCLK ratio is 1.08
3515                 min_fclk_required_by_uclk = div_u64(((unsigned long long)uclk_states[i]) * 1080,
3516                         1000000);
3517
3518                 calculated_states[i].fabricclk_mhz = (min_fclk_required_by_uclk < min_dcfclk) ?
3519                                 min_dcfclk : min_fclk_required_by_uclk;
3520
3521                 calculated_states[i].socclk_mhz = (calculated_states[i].fabricclk_mhz > max_clocks->socClockInKhz / 1000) ?
3522                                 max_clocks->socClockInKhz / 1000 : calculated_states[i].fabricclk_mhz;
3523
3524                 calculated_states[i].dcfclk_mhz = (calculated_states[i].fabricclk_mhz > max_clocks->dcfClockInKhz / 1000) ?
3525                                 max_clocks->dcfClockInKhz / 1000 : calculated_states[i].fabricclk_mhz;
3526
3527                 calculated_states[i].dispclk_mhz = max_clocks->displayClockInKhz / 1000;
3528                 calculated_states[i].dppclk_mhz = max_clocks->displayClockInKhz / 1000;
3529                 calculated_states[i].dscclk_mhz = max_clocks->displayClockInKhz / (1000 * 3);
3530
3531                 calculated_states[i].phyclk_mhz = max_clocks->phyClockInKhz / 1000;
3532
3533                 num_calculated_states++;
3534         }
3535
3536         calculated_states[num_calculated_states - 1].socclk_mhz = max_clocks->socClockInKhz / 1000;
3537         calculated_states[num_calculated_states - 1].fabricclk_mhz = max_clocks->socClockInKhz / 1000;
3538         calculated_states[num_calculated_states - 1].dcfclk_mhz = max_clocks->dcfClockInKhz / 1000;
3539
3540         memcpy(bb->clock_limits, calculated_states, sizeof(bb->clock_limits));
3541         bb->num_states = num_calculated_states;
3542
3543         // Duplicate the last state, DML always an extra state identical to max state to work
3544         memcpy(&bb->clock_limits[num_calculated_states], &bb->clock_limits[num_calculated_states - 1], sizeof(struct _vcs_dpi_voltage_scaling_st));
3545         bb->clock_limits[num_calculated_states].state = bb->num_states;
3546 }
3547
3548 void dcn20_patch_bounding_box(struct dc *dc, struct _vcs_dpi_soc_bounding_box_st *bb)
3549 {
3550         if ((int)(bb->sr_exit_time_us * 1000) != dc->bb_overrides.sr_exit_time_ns
3551                         && dc->bb_overrides.sr_exit_time_ns) {
3552                 bb->sr_exit_time_us = dc->bb_overrides.sr_exit_time_ns / 1000.0;
3553         }
3554
3555         if ((int)(bb->sr_enter_plus_exit_time_us * 1000)
3556                                 != dc->bb_overrides.sr_enter_plus_exit_time_ns
3557                         && dc->bb_overrides.sr_enter_plus_exit_time_ns) {
3558                 bb->sr_enter_plus_exit_time_us =
3559                                 dc->bb_overrides.sr_enter_plus_exit_time_ns / 1000.0;
3560         }
3561
3562         if ((int)(bb->urgent_latency_us * 1000) != dc->bb_overrides.urgent_latency_ns
3563                         && dc->bb_overrides.urgent_latency_ns) {
3564                 bb->urgent_latency_us = dc->bb_overrides.urgent_latency_ns / 1000.0;
3565         }
3566
3567         if ((int)(bb->dram_clock_change_latency_us * 1000)
3568                                 != dc->bb_overrides.dram_clock_change_latency_ns
3569                         && dc->bb_overrides.dram_clock_change_latency_ns) {
3570                 bb->dram_clock_change_latency_us =
3571                                 dc->bb_overrides.dram_clock_change_latency_ns / 1000.0;
3572         }
3573
3574         if ((int)(bb->dummy_pstate_latency_us * 1000)
3575                                 != dc->bb_overrides.dummy_clock_change_latency_ns
3576                         && dc->bb_overrides.dummy_clock_change_latency_ns) {
3577                 bb->dummy_pstate_latency_us =
3578                                 dc->bb_overrides.dummy_clock_change_latency_ns / 1000.0;
3579         }
3580 }
3581
3582 static struct _vcs_dpi_soc_bounding_box_st *get_asic_rev_soc_bb(
3583         uint32_t hw_internal_rev)
3584 {
3585         if (ASICREV_IS_NAVI14_M(hw_internal_rev))
3586                 return &dcn2_0_nv14_soc;
3587
3588         if (ASICREV_IS_NAVI12_P(hw_internal_rev))
3589                 return &dcn2_0_nv12_soc;
3590
3591         return &dcn2_0_soc;
3592 }
3593
3594 static struct _vcs_dpi_ip_params_st *get_asic_rev_ip_params(
3595         uint32_t hw_internal_rev)
3596 {
3597         /* NV14 */
3598         if (ASICREV_IS_NAVI14_M(hw_internal_rev))
3599                 return &dcn2_0_nv14_ip;
3600
3601         /* NV12 and NV10 */
3602         return &dcn2_0_ip;
3603 }
3604
3605 static enum dml_project get_dml_project_version(uint32_t hw_internal_rev)
3606 {
3607         return DML_PROJECT_NAVI10v2;
3608 }
3609
3610 #define fixed16_to_double(x) (((double) x) / ((double) (1 << 16)))
3611 #define fixed16_to_double_to_cpu(x) fixed16_to_double(le32_to_cpu(x))
3612
3613 static bool init_soc_bounding_box(struct dc *dc,
3614                                   struct dcn20_resource_pool *pool)
3615 {
3616         struct _vcs_dpi_soc_bounding_box_st *loaded_bb =
3617                         get_asic_rev_soc_bb(dc->ctx->asic_id.hw_internal_rev);
3618         struct _vcs_dpi_ip_params_st *loaded_ip =
3619                         get_asic_rev_ip_params(dc->ctx->asic_id.hw_internal_rev);
3620
3621         DC_LOGGER_INIT(dc->ctx->logger);
3622
3623         if (pool->base.pp_smu) {
3624                 struct pp_smu_nv_clock_table max_clocks = {0};
3625                 unsigned int uclk_states[8] = {0};
3626                 unsigned int num_states = 0;
3627                 enum pp_smu_status status;
3628                 bool clock_limits_available = false;
3629                 bool uclk_states_available = false;
3630
3631                 if (pool->base.pp_smu->nv_funcs.get_uclk_dpm_states) {
3632                         status = (pool->base.pp_smu->nv_funcs.get_uclk_dpm_states)
3633                                 (&pool->base.pp_smu->nv_funcs.pp_smu, uclk_states, &num_states);
3634
3635                         uclk_states_available = (status == PP_SMU_RESULT_OK);
3636                 }
3637
3638                 if (pool->base.pp_smu->nv_funcs.get_maximum_sustainable_clocks) {
3639                         status = (*pool->base.pp_smu->nv_funcs.get_maximum_sustainable_clocks)
3640                                         (&pool->base.pp_smu->nv_funcs.pp_smu, &max_clocks);
3641                         /* SMU cannot set DCF clock to anything equal to or higher than SOC clock
3642                          */
3643                         if (max_clocks.dcfClockInKhz >= max_clocks.socClockInKhz)
3644                                 max_clocks.dcfClockInKhz = max_clocks.socClockInKhz - 1000;
3645                         clock_limits_available = (status == PP_SMU_RESULT_OK);
3646                 }
3647
3648                 if (clock_limits_available && uclk_states_available && num_states)
3649                         dcn20_update_bounding_box(dc, loaded_bb, &max_clocks, uclk_states, num_states);
3650                 else if (clock_limits_available)
3651                         dcn20_cap_soc_clocks(loaded_bb, max_clocks);
3652         }
3653
3654         loaded_ip->max_num_otg = pool->base.res_cap->num_timing_generator;
3655         loaded_ip->max_num_dpp = pool->base.pipe_count;
3656         dcn20_patch_bounding_box(dc, loaded_bb);
3657
3658         return true;
3659 }
3660
3661 static bool dcn20_resource_construct(
3662         uint8_t num_virtual_links,
3663         struct dc *dc,
3664         struct dcn20_resource_pool *pool)
3665 {
3666         int i;
3667         struct dc_context *ctx = dc->ctx;
3668         struct irq_service_init_data init_data;
3669         struct ddc_service_init_data ddc_init_data;
3670         struct _vcs_dpi_soc_bounding_box_st *loaded_bb =
3671                         get_asic_rev_soc_bb(ctx->asic_id.hw_internal_rev);
3672         struct _vcs_dpi_ip_params_st *loaded_ip =
3673                         get_asic_rev_ip_params(ctx->asic_id.hw_internal_rev);
3674         enum dml_project dml_project_version =
3675                         get_dml_project_version(ctx->asic_id.hw_internal_rev);
3676
3677         DC_FP_START();
3678
3679         ctx->dc_bios->regs = &bios_regs;
3680         pool->base.funcs = &dcn20_res_pool_funcs;
3681
3682         if (ASICREV_IS_NAVI14_M(ctx->asic_id.hw_internal_rev)) {
3683                 pool->base.res_cap = &res_cap_nv14;
3684                 pool->base.pipe_count = 5;
3685                 pool->base.mpcc_count = 5;
3686         } else {
3687                 pool->base.res_cap = &res_cap_nv10;
3688                 pool->base.pipe_count = 6;
3689                 pool->base.mpcc_count = 6;
3690         }
3691         /*************************************************
3692          *  Resource + asic cap harcoding                *
3693          *************************************************/
3694         pool->base.underlay_pipe_index = NO_UNDERLAY_PIPE;
3695
3696         dc->caps.max_downscale_ratio = 200;
3697         dc->caps.i2c_speed_in_khz = 100;
3698         dc->caps.i2c_speed_in_khz_hdcp = 100; /*1.4 w/a not applied by default*/
3699         dc->caps.max_cursor_size = 256;
3700         dc->caps.min_horizontal_blanking_period = 80;
3701         dc->caps.dmdata_alloc_size = 2048;
3702
3703         dc->caps.max_slave_planes = 1;
3704         dc->caps.max_slave_yuv_planes = 1;
3705         dc->caps.max_slave_rgb_planes = 1;
3706         dc->caps.post_blend_color_processing = true;
3707         dc->caps.force_dp_tps4_for_cp2520 = true;
3708         dc->caps.extended_aux_timeout_support = true;
3709
3710         /* Color pipeline capabilities */
3711         dc->caps.color.dpp.dcn_arch = 1;
3712         dc->caps.color.dpp.input_lut_shared = 0;
3713         dc->caps.color.dpp.icsc = 1;
3714         dc->caps.color.dpp.dgam_ram = 1;
3715         dc->caps.color.dpp.dgam_rom_caps.srgb = 1;
3716         dc->caps.color.dpp.dgam_rom_caps.bt2020 = 1;
3717         dc->caps.color.dpp.dgam_rom_caps.gamma2_2 = 0;
3718         dc->caps.color.dpp.dgam_rom_caps.pq = 0;
3719         dc->caps.color.dpp.dgam_rom_caps.hlg = 0;
3720         dc->caps.color.dpp.post_csc = 0;
3721         dc->caps.color.dpp.gamma_corr = 0;
3722         dc->caps.color.dpp.dgam_rom_for_yuv = 1;
3723
3724         dc->caps.color.dpp.hw_3d_lut = 1;
3725         dc->caps.color.dpp.ogam_ram = 1;
3726         // no OGAM ROM on DCN2, only MPC ROM
3727         dc->caps.color.dpp.ogam_rom_caps.srgb = 0;
3728         dc->caps.color.dpp.ogam_rom_caps.bt2020 = 0;
3729         dc->caps.color.dpp.ogam_rom_caps.gamma2_2 = 0;
3730         dc->caps.color.dpp.ogam_rom_caps.pq = 0;
3731         dc->caps.color.dpp.ogam_rom_caps.hlg = 0;
3732         dc->caps.color.dpp.ocsc = 0;
3733
3734         dc->caps.color.mpc.gamut_remap = 0;
3735         dc->caps.color.mpc.num_3dluts = 0;
3736         dc->caps.color.mpc.shared_3d_lut = 0;
3737         dc->caps.color.mpc.ogam_ram = 1;
3738         dc->caps.color.mpc.ogam_rom_caps.srgb = 0;
3739         dc->caps.color.mpc.ogam_rom_caps.bt2020 = 0;
3740         dc->caps.color.mpc.ogam_rom_caps.gamma2_2 = 0;
3741         dc->caps.color.mpc.ogam_rom_caps.pq = 0;
3742         dc->caps.color.mpc.ogam_rom_caps.hlg = 0;
3743         dc->caps.color.mpc.ocsc = 1;
3744
3745         if (dc->ctx->dce_environment == DCE_ENV_PRODUCTION_DRV) {
3746                 dc->debug = debug_defaults_drv;
3747         } else if (dc->ctx->dce_environment == DCE_ENV_FPGA_MAXIMUS) {
3748                 pool->base.pipe_count = 4;
3749                 pool->base.mpcc_count = pool->base.pipe_count;
3750                 dc->debug = debug_defaults_diags;
3751         } else {
3752                 dc->debug = debug_defaults_diags;
3753         }
3754         //dcn2.0x
3755         dc->work_arounds.dedcn20_305_wa = true;
3756
3757         // Init the vm_helper
3758         if (dc->vm_helper)
3759                 vm_helper_init(dc->vm_helper, 16);
3760
3761         /*************************************************
3762          *  Create resources                             *
3763          *************************************************/
3764
3765         pool->base.clock_sources[DCN20_CLK_SRC_PLL0] =
3766                         dcn20_clock_source_create(ctx, ctx->dc_bios,
3767                                 CLOCK_SOURCE_COMBO_PHY_PLL0,
3768                                 &clk_src_regs[0], false);
3769         pool->base.clock_sources[DCN20_CLK_SRC_PLL1] =
3770                         dcn20_clock_source_create(ctx, ctx->dc_bios,
3771                                 CLOCK_SOURCE_COMBO_PHY_PLL1,
3772                                 &clk_src_regs[1], false);
3773         pool->base.clock_sources[DCN20_CLK_SRC_PLL2] =
3774                         dcn20_clock_source_create(ctx, ctx->dc_bios,
3775                                 CLOCK_SOURCE_COMBO_PHY_PLL2,
3776                                 &clk_src_regs[2], false);
3777         pool->base.clock_sources[DCN20_CLK_SRC_PLL3] =
3778                         dcn20_clock_source_create(ctx, ctx->dc_bios,
3779                                 CLOCK_SOURCE_COMBO_PHY_PLL3,
3780                                 &clk_src_regs[3], false);
3781         pool->base.clock_sources[DCN20_CLK_SRC_PLL4] =
3782                         dcn20_clock_source_create(ctx, ctx->dc_bios,
3783                                 CLOCK_SOURCE_COMBO_PHY_PLL4,
3784                                 &clk_src_regs[4], false);
3785         pool->base.clock_sources[DCN20_CLK_SRC_PLL5] =
3786                         dcn20_clock_source_create(ctx, ctx->dc_bios,
3787                                 CLOCK_SOURCE_COMBO_PHY_PLL5,
3788                                 &clk_src_regs[5], false);
3789         pool->base.clk_src_count = DCN20_CLK_SRC_TOTAL;
3790         /* todo: not reuse phy_pll registers */
3791         pool->base.dp_clock_source =
3792                         dcn20_clock_source_create(ctx, ctx->dc_bios,
3793                                 CLOCK_SOURCE_ID_DP_DTO,
3794                                 &clk_src_regs[0], true);
3795
3796         for (i = 0; i < pool->base.clk_src_count; i++) {
3797                 if (pool->base.clock_sources[i] == NULL) {
3798                         dm_error("DC: failed to create clock sources!\n");
3799                         BREAK_TO_DEBUGGER();
3800                         goto create_fail;
3801                 }
3802         }
3803
3804         pool->base.dccg = dccg2_create(ctx, &dccg_regs, &dccg_shift, &dccg_mask);
3805         if (pool->base.dccg == NULL) {
3806                 dm_error("DC: failed to create dccg!\n");
3807                 BREAK_TO_DEBUGGER();
3808                 goto create_fail;
3809         }
3810
3811         pool->base.dmcu = dcn20_dmcu_create(ctx,
3812                         &dmcu_regs,
3813                         &dmcu_shift,
3814                         &dmcu_mask);
3815         if (pool->base.dmcu == NULL) {
3816                 dm_error("DC: failed to create dmcu!\n");
3817                 BREAK_TO_DEBUGGER();
3818                 goto create_fail;
3819         }
3820
3821         pool->base.abm = dce_abm_create(ctx,
3822                         &abm_regs,
3823                         &abm_shift,
3824                         &abm_mask);
3825         if (pool->base.abm == NULL) {
3826                 dm_error("DC: failed to create abm!\n");
3827                 BREAK_TO_DEBUGGER();
3828                 goto create_fail;
3829         }
3830
3831         pool->base.pp_smu = dcn20_pp_smu_create(ctx);
3832
3833
3834         if (!init_soc_bounding_box(dc, pool)) {
3835                 dm_error("DC: failed to initialize soc bounding box!\n");
3836                 BREAK_TO_DEBUGGER();
3837                 goto create_fail;
3838         }
3839
3840         dml_init_instance(&dc->dml, loaded_bb, loaded_ip, dml_project_version);
3841
3842         if (!dc->debug.disable_pplib_wm_range) {
3843                 struct pp_smu_wm_range_sets ranges = {0};
3844                 int i = 0;
3845
3846                 ranges.num_reader_wm_sets = 0;
3847
3848                 if (loaded_bb->num_states == 1) {
3849                         ranges.reader_wm_sets[0].wm_inst = i;
3850                         ranges.reader_wm_sets[0].min_drain_clk_mhz = PP_SMU_WM_SET_RANGE_CLK_UNCONSTRAINED_MIN;
3851                         ranges.reader_wm_sets[0].max_drain_clk_mhz = PP_SMU_WM_SET_RANGE_CLK_UNCONSTRAINED_MAX;
3852                         ranges.reader_wm_sets[0].min_fill_clk_mhz = PP_SMU_WM_SET_RANGE_CLK_UNCONSTRAINED_MIN;
3853                         ranges.reader_wm_sets[0].max_fill_clk_mhz = PP_SMU_WM_SET_RANGE_CLK_UNCONSTRAINED_MAX;
3854
3855                         ranges.num_reader_wm_sets = 1;
3856                 } else if (loaded_bb->num_states > 1) {
3857                         for (i = 0; i < 4 && i < loaded_bb->num_states; i++) {
3858                                 ranges.reader_wm_sets[i].wm_inst = i;
3859                                 ranges.reader_wm_sets[i].min_drain_clk_mhz = PP_SMU_WM_SET_RANGE_CLK_UNCONSTRAINED_MIN;
3860                                 ranges.reader_wm_sets[i].max_drain_clk_mhz = PP_SMU_WM_SET_RANGE_CLK_UNCONSTRAINED_MAX;
3861                                 ranges.reader_wm_sets[i].min_fill_clk_mhz = (i > 0) ? (loaded_bb->clock_limits[i - 1].dram_speed_mts / 16) + 1 : 0;
3862                                 ranges.reader_wm_sets[i].max_fill_clk_mhz = loaded_bb->clock_limits[i].dram_speed_mts / 16;
3863
3864                                 ranges.num_reader_wm_sets = i + 1;
3865                         }
3866
3867                         ranges.reader_wm_sets[0].min_fill_clk_mhz = PP_SMU_WM_SET_RANGE_CLK_UNCONSTRAINED_MIN;
3868                         ranges.reader_wm_sets[ranges.num_reader_wm_sets - 1].max_fill_clk_mhz = PP_SMU_WM_SET_RANGE_CLK_UNCONSTRAINED_MAX;
3869                 }
3870
3871                 ranges.num_writer_wm_sets = 1;
3872
3873                 ranges.writer_wm_sets[0].wm_inst = 0;
3874                 ranges.writer_wm_sets[0].min_fill_clk_mhz = PP_SMU_WM_SET_RANGE_CLK_UNCONSTRAINED_MIN;
3875                 ranges.writer_wm_sets[0].max_fill_clk_mhz = PP_SMU_WM_SET_RANGE_CLK_UNCONSTRAINED_MAX;
3876                 ranges.writer_wm_sets[0].min_drain_clk_mhz = PP_SMU_WM_SET_RANGE_CLK_UNCONSTRAINED_MIN;
3877                 ranges.writer_wm_sets[0].max_drain_clk_mhz = PP_SMU_WM_SET_RANGE_CLK_UNCONSTRAINED_MAX;
3878
3879                 /* Notify PP Lib/SMU which Watermarks to use for which clock ranges */
3880                 if (pool->base.pp_smu->nv_funcs.set_wm_ranges)
3881                         pool->base.pp_smu->nv_funcs.set_wm_ranges(&pool->base.pp_smu->nv_funcs.pp_smu, &ranges);
3882         }
3883
3884         init_data.ctx = dc->ctx;
3885         pool->base.irqs = dal_irq_service_dcn20_create(&init_data);
3886         if (!pool->base.irqs)
3887                 goto create_fail;
3888
3889         /* mem input -> ipp -> dpp -> opp -> TG */
3890         for (i = 0; i < pool->base.pipe_count; i++) {
3891                 pool->base.hubps[i] = dcn20_hubp_create(ctx, i);
3892                 if (pool->base.hubps[i] == NULL) {
3893                         BREAK_TO_DEBUGGER();
3894                         dm_error(
3895                                 "DC: failed to create memory input!\n");
3896                         goto create_fail;
3897                 }
3898
3899                 pool->base.ipps[i] = dcn20_ipp_create(ctx, i);
3900                 if (pool->base.ipps[i] == NULL) {
3901                         BREAK_TO_DEBUGGER();
3902                         dm_error(
3903                                 "DC: failed to create input pixel processor!\n");
3904                         goto create_fail;
3905                 }
3906
3907                 pool->base.dpps[i] = dcn20_dpp_create(ctx, i);
3908                 if (pool->base.dpps[i] == NULL) {
3909                         BREAK_TO_DEBUGGER();
3910                         dm_error(
3911                                 "DC: failed to create dpps!\n");
3912                         goto create_fail;
3913                 }
3914         }
3915         for (i = 0; i < pool->base.res_cap->num_ddc; i++) {
3916                 pool->base.engines[i] = dcn20_aux_engine_create(ctx, i);
3917                 if (pool->base.engines[i] == NULL) {
3918                         BREAK_TO_DEBUGGER();
3919                         dm_error(
3920                                 "DC:failed to create aux engine!!\n");
3921                         goto create_fail;
3922                 }
3923                 pool->base.hw_i2cs[i] = dcn20_i2c_hw_create(ctx, i);
3924                 if (pool->base.hw_i2cs[i] == NULL) {
3925                         BREAK_TO_DEBUGGER();
3926                         dm_error(
3927                                 "DC:failed to create hw i2c!!\n");
3928                         goto create_fail;
3929                 }
3930                 pool->base.sw_i2cs[i] = NULL;
3931         }
3932
3933         for (i = 0; i < pool->base.res_cap->num_opp; i++) {
3934                 pool->base.opps[i] = dcn20_opp_create(ctx, i);
3935                 if (pool->base.opps[i] == NULL) {
3936                         BREAK_TO_DEBUGGER();
3937                         dm_error(
3938                                 "DC: failed to create output pixel processor!\n");
3939                         goto create_fail;
3940                 }
3941         }
3942
3943         for (i = 0; i < pool->base.res_cap->num_timing_generator; i++) {
3944                 pool->base.timing_generators[i] = dcn20_timing_generator_create(
3945                                 ctx, i);
3946                 if (pool->base.timing_generators[i] == NULL) {
3947                         BREAK_TO_DEBUGGER();
3948                         dm_error("DC: failed to create tg!\n");
3949                         goto create_fail;
3950                 }
3951         }
3952
3953         pool->base.timing_generator_count = i;
3954
3955         pool->base.mpc = dcn20_mpc_create(ctx);
3956         if (pool->base.mpc == NULL) {
3957                 BREAK_TO_DEBUGGER();
3958                 dm_error("DC: failed to create mpc!\n");
3959                 goto create_fail;
3960         }
3961
3962         pool->base.hubbub = dcn20_hubbub_create(ctx);
3963         if (pool->base.hubbub == NULL) {
3964                 BREAK_TO_DEBUGGER();
3965                 dm_error("DC: failed to create hubbub!\n");
3966                 goto create_fail;
3967         }
3968
3969         for (i = 0; i < pool->base.res_cap->num_dsc; i++) {
3970                 pool->base.dscs[i] = dcn20_dsc_create(ctx, i);
3971                 if (pool->base.dscs[i] == NULL) {
3972                         BREAK_TO_DEBUGGER();
3973                         dm_error("DC: failed to create display stream compressor %d!\n", i);
3974                         goto create_fail;
3975                 }
3976         }
3977
3978         if (!dcn20_dwbc_create(ctx, &pool->base)) {
3979                 BREAK_TO_DEBUGGER();
3980                 dm_error("DC: failed to create dwbc!\n");
3981                 goto create_fail;
3982         }
3983         if (!dcn20_mmhubbub_create(ctx, &pool->base)) {
3984                 BREAK_TO_DEBUGGER();
3985                 dm_error("DC: failed to create mcif_wb!\n");
3986                 goto create_fail;
3987         }
3988
3989         if (!resource_construct(num_virtual_links, dc, &pool->base,
3990                         (!IS_FPGA_MAXIMUS_DC(dc->ctx->dce_environment) ?
3991                         &res_create_funcs : &res_create_maximus_funcs)))
3992                         goto create_fail;
3993
3994         dcn20_hw_sequencer_construct(dc);
3995
3996         // IF NV12, set PG function pointer to NULL. It's not that
3997         // PG isn't supported for NV12, it's that we don't want to
3998         // program the registers because that will cause more power
3999         // to be consumed. We could have created dcn20_init_hw to get
4000         // the same effect by checking ASIC rev, but there was a
4001         // request at some point to not check ASIC rev on hw sequencer.
4002         if (ASICREV_IS_NAVI12_P(dc->ctx->asic_id.hw_internal_rev)) {
4003                 dc->hwseq->funcs.enable_power_gating_plane = NULL;
4004                 dc->debug.disable_dpp_power_gate = true;
4005                 dc->debug.disable_hubp_power_gate = true;
4006         }
4007
4008
4009         dc->caps.max_planes =  pool->base.pipe_count;
4010
4011         for (i = 0; i < dc->caps.max_planes; ++i)
4012                 dc->caps.planes[i] = plane_cap;
4013
4014         dc->cap_funcs = cap_funcs;
4015
4016         if (dc->ctx->dc_bios->fw_info.oem_i2c_present) {
4017                 ddc_init_data.ctx = dc->ctx;
4018                 ddc_init_data.link = NULL;
4019                 ddc_init_data.id.id = dc->ctx->dc_bios->fw_info.oem_i2c_obj_id;
4020                 ddc_init_data.id.enum_id = 0;
4021                 ddc_init_data.id.type = OBJECT_TYPE_GENERIC;
4022                 pool->base.oem_device = dal_ddc_service_create(&ddc_init_data);
4023         } else {
4024                 pool->base.oem_device = NULL;
4025         }
4026
4027         DC_FP_END();
4028         return true;
4029
4030 create_fail:
4031
4032         DC_FP_END();
4033         dcn20_resource_destruct(pool);
4034
4035         return false;
4036 }
4037
4038 struct resource_pool *dcn20_create_resource_pool(
4039                 const struct dc_init_data *init_data,
4040                 struct dc *dc)
4041 {
4042         struct dcn20_resource_pool *pool =
4043                 kzalloc(sizeof(struct dcn20_resource_pool), GFP_ATOMIC);
4044
4045         if (!pool)
4046                 return NULL;
4047
4048         if (dcn20_resource_construct(init_data->num_virtual_links, dc, pool))
4049                 return &pool->base;
4050
4051         BREAK_TO_DEBUGGER();
4052         kfree(pool);
4053         return NULL;
4054 }