1 /* 2 * Copyright 2019 Advanced Micro Devices, Inc. 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice shall be included in 12 * all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20 * OTHER DEALINGS IN THE SOFTWARE. 21 * 22 * Author: AMD 23 */ 24 25 #include <drm/drm_dsc.h> 26 #include "dc_hw_types.h" 27 #include "dsc.h" 28 #include <drm/drm_dp_helper.h> 29 #include "dc.h" 30 #include "rc_calc.h" 31 32 /* This module's internal functions */ 33 34 /* default DSC policy target bitrate limit is 16bpp */ 35 static uint32_t dsc_policy_max_target_bpp_limit = 16; 36 37 /* default DSC policy enables DSC only when needed */ 38 static bool dsc_policy_enable_dsc_when_not_needed; 39 40 static bool dsc_policy_disable_dsc_stream_overhead; 41 42 static bool dsc_buff_block_size_from_dpcd(int dpcd_buff_block_size, int *buff_block_size) 43 { 44 45 switch (dpcd_buff_block_size) { 46 case DP_DSC_RC_BUF_BLK_SIZE_1: 47 *buff_block_size = 1024; 48 break; 49 case DP_DSC_RC_BUF_BLK_SIZE_4: 50 *buff_block_size = 4 * 1024; 51 break; 52 case DP_DSC_RC_BUF_BLK_SIZE_16: 53 *buff_block_size = 16 * 1024; 54 break; 55 case DP_DSC_RC_BUF_BLK_SIZE_64: 56 *buff_block_size = 64 * 1024; 57 break; 58 default: { 59 dm_error("%s: DPCD DSC buffer size not recognized.\n", __func__); 60 return false; 61 } 62 } 63 64 return true; 65 } 66 67 68 static bool dsc_line_buff_depth_from_dpcd(int dpcd_line_buff_bit_depth, int *line_buff_bit_depth) 69 { 70 if (0 <= dpcd_line_buff_bit_depth && dpcd_line_buff_bit_depth <= 7) 71 *line_buff_bit_depth = dpcd_line_buff_bit_depth + 9; 72 else if (dpcd_line_buff_bit_depth == 8) 73 *line_buff_bit_depth = 8; 74 else { 75 dm_error("%s: DPCD DSC buffer depth not recognized.\n", __func__); 76 return false; 77 } 78 79 return true; 80 } 81 82 83 static bool dsc_throughput_from_dpcd(int dpcd_throughput, int *throughput) 84 { 85 switch (dpcd_throughput) { 86 case DP_DSC_THROUGHPUT_MODE_0_UNSUPPORTED: 87 *throughput = 0; 88 break; 89 case DP_DSC_THROUGHPUT_MODE_0_170: 90 *throughput = 170; 91 break; 92 case DP_DSC_THROUGHPUT_MODE_0_340: 93 *throughput = 340; 94 break; 95 case DP_DSC_THROUGHPUT_MODE_0_400: 96 *throughput = 400; 97 break; 98 case DP_DSC_THROUGHPUT_MODE_0_450: 99 *throughput = 450; 100 break; 101 case DP_DSC_THROUGHPUT_MODE_0_500: 102 *throughput = 500; 103 break; 104 case DP_DSC_THROUGHPUT_MODE_0_550: 105 *throughput = 550; 106 break; 107 case DP_DSC_THROUGHPUT_MODE_0_600: 108 *throughput = 600; 109 break; 110 case DP_DSC_THROUGHPUT_MODE_0_650: 111 *throughput = 650; 112 break; 113 case DP_DSC_THROUGHPUT_MODE_0_700: 114 *throughput = 700; 115 break; 116 case DP_DSC_THROUGHPUT_MODE_0_750: 117 *throughput = 750; 118 break; 119 case DP_DSC_THROUGHPUT_MODE_0_800: 120 *throughput = 800; 121 break; 122 case DP_DSC_THROUGHPUT_MODE_0_850: 123 *throughput = 850; 124 break; 125 case DP_DSC_THROUGHPUT_MODE_0_900: 126 *throughput = 900; 127 break; 128 case DP_DSC_THROUGHPUT_MODE_0_950: 129 *throughput = 950; 130 break; 131 case DP_DSC_THROUGHPUT_MODE_0_1000: 132 *throughput = 1000; 133 break; 134 default: { 135 dm_error("%s: DPCD DSC throughput mode not recognized.\n", __func__); 136 return false; 137 } 138 } 139 140 return true; 141 } 142 143 144 static bool dsc_bpp_increment_div_from_dpcd(uint8_t bpp_increment_dpcd, uint32_t *bpp_increment_div) 145 { 146 // Mask bpp increment dpcd field to avoid reading other fields 147 bpp_increment_dpcd &= 0x7; 148 149 switch (bpp_increment_dpcd) { 150 case 0: 151 *bpp_increment_div = 16; 152 break; 153 case 1: 154 *bpp_increment_div = 8; 155 break; 156 case 2: 157 *bpp_increment_div = 4; 158 break; 159 case 3: 160 *bpp_increment_div = 2; 161 break; 162 case 4: 163 *bpp_increment_div = 1; 164 break; 165 default: { 166 dm_error("%s: DPCD DSC bits-per-pixel increment not recognized.\n", __func__); 167 return false; 168 } 169 } 170 171 return true; 172 } 173 174 static void get_dsc_enc_caps( 175 const struct display_stream_compressor *dsc, 176 struct dsc_enc_caps *dsc_enc_caps, 177 int pixel_clock_100Hz) 178 { 179 // This is a static HW query, so we can use any DSC 180 181 memset(dsc_enc_caps, 0, sizeof(struct dsc_enc_caps)); 182 if (dsc) { 183 if (!dsc->ctx->dc->debug.disable_dsc) 184 dsc->funcs->dsc_get_enc_caps(dsc_enc_caps, pixel_clock_100Hz); 185 if (dsc->ctx->dc->debug.native422_support) 186 dsc_enc_caps->color_formats.bits.YCBCR_NATIVE_422 = 1; 187 } 188 } 189 190 /* Returns 'false' if no intersection was found for at least one capablity. 191 * It also implicitly validates some sink caps against invalid value of zero. 192 */ 193 static bool intersect_dsc_caps( 194 const struct dsc_dec_dpcd_caps *dsc_sink_caps, 195 const struct dsc_enc_caps *dsc_enc_caps, 196 enum dc_pixel_encoding pixel_encoding, 197 struct dsc_enc_caps *dsc_common_caps) 198 { 199 int32_t max_slices; 200 int32_t total_sink_throughput; 201 202 memset(dsc_common_caps, 0, sizeof(struct dsc_enc_caps)); 203 204 dsc_common_caps->dsc_version = min(dsc_sink_caps->dsc_version, dsc_enc_caps->dsc_version); 205 if (!dsc_common_caps->dsc_version) 206 return false; 207 208 dsc_common_caps->slice_caps.bits.NUM_SLICES_1 = dsc_sink_caps->slice_caps1.bits.NUM_SLICES_1 && dsc_enc_caps->slice_caps.bits.NUM_SLICES_1; 209 dsc_common_caps->slice_caps.bits.NUM_SLICES_2 = dsc_sink_caps->slice_caps1.bits.NUM_SLICES_2 && dsc_enc_caps->slice_caps.bits.NUM_SLICES_2; 210 dsc_common_caps->slice_caps.bits.NUM_SLICES_4 = dsc_sink_caps->slice_caps1.bits.NUM_SLICES_4 && dsc_enc_caps->slice_caps.bits.NUM_SLICES_4; 211 dsc_common_caps->slice_caps.bits.NUM_SLICES_8 = dsc_sink_caps->slice_caps1.bits.NUM_SLICES_8 && dsc_enc_caps->slice_caps.bits.NUM_SLICES_8; 212 if (!dsc_common_caps->slice_caps.raw) 213 return false; 214 215 dsc_common_caps->lb_bit_depth = min(dsc_sink_caps->lb_bit_depth, dsc_enc_caps->lb_bit_depth); 216 if (!dsc_common_caps->lb_bit_depth) 217 return false; 218 219 dsc_common_caps->is_block_pred_supported = dsc_sink_caps->is_block_pred_supported && dsc_enc_caps->is_block_pred_supported; 220 221 dsc_common_caps->color_formats.raw = dsc_sink_caps->color_formats.raw & dsc_enc_caps->color_formats.raw; 222 if (!dsc_common_caps->color_formats.raw) 223 return false; 224 225 dsc_common_caps->color_depth.raw = dsc_sink_caps->color_depth.raw & dsc_enc_caps->color_depth.raw; 226 if (!dsc_common_caps->color_depth.raw) 227 return false; 228 229 max_slices = 0; 230 if (dsc_common_caps->slice_caps.bits.NUM_SLICES_1) 231 max_slices = 1; 232 233 if (dsc_common_caps->slice_caps.bits.NUM_SLICES_2) 234 max_slices = 2; 235 236 if (dsc_common_caps->slice_caps.bits.NUM_SLICES_4) 237 max_slices = 4; 238 239 total_sink_throughput = max_slices * dsc_sink_caps->throughput_mode_0_mps; 240 if (pixel_encoding == PIXEL_ENCODING_YCBCR422 || pixel_encoding == PIXEL_ENCODING_YCBCR420) 241 total_sink_throughput = max_slices * dsc_sink_caps->throughput_mode_1_mps; 242 243 dsc_common_caps->max_total_throughput_mps = min(total_sink_throughput, dsc_enc_caps->max_total_throughput_mps); 244 245 dsc_common_caps->max_slice_width = min(dsc_sink_caps->max_slice_width, dsc_enc_caps->max_slice_width); 246 if (!dsc_common_caps->max_slice_width) 247 return false; 248 249 dsc_common_caps->bpp_increment_div = min(dsc_sink_caps->bpp_increment_div, dsc_enc_caps->bpp_increment_div); 250 251 // TODO DSC: Remove this workaround for N422 and 420 once it's fixed, or move it to get_dsc_encoder_caps() 252 if (pixel_encoding == PIXEL_ENCODING_YCBCR422 || pixel_encoding == PIXEL_ENCODING_YCBCR420) 253 dsc_common_caps->bpp_increment_div = min(dsc_common_caps->bpp_increment_div, (uint32_t)8); 254 255 dsc_common_caps->is_dp = dsc_sink_caps->is_dp; 256 return true; 257 } 258 259 static inline uint32_t dsc_div_by_10_round_up(uint32_t value) 260 { 261 return (value + 9) / 10; 262 } 263 264 static struct fixed31_32 compute_dsc_max_bandwidth_overhead( 265 const struct dc_crtc_timing *timing, 266 const int num_slices_h, 267 const bool is_dp) 268 { 269 struct fixed31_32 max_dsc_overhead; 270 struct fixed31_32 refresh_rate; 271 272 if (dsc_policy_disable_dsc_stream_overhead || !is_dp) 273 return dc_fixpt_from_int(0); 274 275 /* use target bpp that can take entire target bandwidth */ 276 refresh_rate = dc_fixpt_from_int(timing->pix_clk_100hz); 277 refresh_rate = dc_fixpt_div_int(refresh_rate, timing->h_total); 278 refresh_rate = dc_fixpt_div_int(refresh_rate, timing->v_total); 279 refresh_rate = dc_fixpt_mul_int(refresh_rate, 100); 280 281 max_dsc_overhead = dc_fixpt_from_int(num_slices_h); 282 max_dsc_overhead = dc_fixpt_mul_int(max_dsc_overhead, timing->v_total); 283 max_dsc_overhead = dc_fixpt_mul_int(max_dsc_overhead, 256); 284 max_dsc_overhead = dc_fixpt_div_int(max_dsc_overhead, 1000); 285 max_dsc_overhead = dc_fixpt_mul(max_dsc_overhead, refresh_rate); 286 287 return max_dsc_overhead; 288 } 289 290 static uint32_t compute_bpp_x16_from_target_bandwidth( 291 const uint32_t bandwidth_in_kbps, 292 const struct dc_crtc_timing *timing, 293 const uint32_t num_slices_h, 294 const uint32_t bpp_increment_div, 295 const bool is_dp) 296 { 297 struct fixed31_32 overhead_in_kbps; 298 struct fixed31_32 effective_bandwidth_in_kbps; 299 struct fixed31_32 bpp_x16; 300 301 overhead_in_kbps = compute_dsc_max_bandwidth_overhead( 302 timing, num_slices_h, is_dp); 303 effective_bandwidth_in_kbps = dc_fixpt_from_int(bandwidth_in_kbps); 304 effective_bandwidth_in_kbps = dc_fixpt_sub(effective_bandwidth_in_kbps, 305 overhead_in_kbps); 306 bpp_x16 = dc_fixpt_mul_int(effective_bandwidth_in_kbps, 10); 307 bpp_x16 = dc_fixpt_div_int(bpp_x16, timing->pix_clk_100hz); 308 bpp_x16 = dc_fixpt_from_int(dc_fixpt_floor(dc_fixpt_mul_int(bpp_x16, bpp_increment_div))); 309 bpp_x16 = dc_fixpt_div_int(bpp_x16, bpp_increment_div); 310 bpp_x16 = dc_fixpt_mul_int(bpp_x16, 16); 311 return dc_fixpt_floor(bpp_x16); 312 } 313 314 /* Get DSC bandwidth range based on [min_bpp, max_bpp] target bitrate range, and timing's pixel clock 315 * and uncompressed bandwidth. 316 */ 317 static void get_dsc_bandwidth_range( 318 const uint32_t min_bpp_x16, 319 const uint32_t max_bpp_x16, 320 const uint32_t num_slices_h, 321 const struct dsc_enc_caps *dsc_caps, 322 const struct dc_crtc_timing *timing, 323 struct dc_dsc_bw_range *range) 324 { 325 /* native stream bandwidth */ 326 range->stream_kbps = dc_bandwidth_in_kbps_from_timing(timing); 327 328 /* max dsc target bpp */ 329 range->max_kbps = dc_dsc_stream_bandwidth_in_kbps(timing, 330 max_bpp_x16, num_slices_h, dsc_caps->is_dp); 331 range->max_target_bpp_x16 = max_bpp_x16; 332 if (range->max_kbps > range->stream_kbps) { 333 /* max dsc target bpp is capped to native bandwidth */ 334 range->max_kbps = range->stream_kbps; 335 range->max_target_bpp_x16 = compute_bpp_x16_from_target_bandwidth( 336 range->max_kbps, timing, num_slices_h, 337 dsc_caps->bpp_increment_div, 338 dsc_caps->is_dp); 339 } 340 341 /* min dsc target bpp */ 342 range->min_kbps = dc_dsc_stream_bandwidth_in_kbps(timing, 343 min_bpp_x16, num_slices_h, dsc_caps->is_dp); 344 range->min_target_bpp_x16 = min_bpp_x16; 345 if (range->min_kbps > range->max_kbps) { 346 /* min dsc target bpp is capped to max dsc bandwidth*/ 347 range->min_kbps = range->max_kbps; 348 range->min_target_bpp_x16 = range->max_target_bpp_x16; 349 } 350 } 351 352 /* Decides if DSC should be used and calculates target bpp if it should, applying DSC policy. 353 * 354 * Returns: 355 * - 'true' if DSC was required by policy and was successfully applied 356 * - 'false' if DSC was not necessary (e.g. if uncompressed stream fits 'target_bandwidth_kbps'), 357 * or if it couldn't be applied based on DSC policy. 358 */ 359 static bool decide_dsc_target_bpp_x16( 360 const struct dc_dsc_policy *policy, 361 const struct dsc_enc_caps *dsc_common_caps, 362 const int target_bandwidth_kbps, 363 const struct dc_crtc_timing *timing, 364 const int num_slices_h, 365 int *target_bpp_x16) 366 { 367 bool should_use_dsc = false; 368 struct dc_dsc_bw_range range; 369 370 memset(&range, 0, sizeof(range)); 371 372 get_dsc_bandwidth_range(policy->min_target_bpp * 16, policy->max_target_bpp * 16, 373 num_slices_h, dsc_common_caps, timing, &range); 374 if (!policy->enable_dsc_when_not_needed && target_bandwidth_kbps >= range.stream_kbps) { 375 /* enough bandwidth without dsc */ 376 *target_bpp_x16 = 0; 377 should_use_dsc = false; 378 } else if (policy->preferred_bpp_x16 > 0 && 379 policy->preferred_bpp_x16 <= range.max_target_bpp_x16 && 380 policy->preferred_bpp_x16 >= range.min_target_bpp_x16) { 381 *target_bpp_x16 = policy->preferred_bpp_x16; 382 should_use_dsc = true; 383 } else if (target_bandwidth_kbps >= range.max_kbps) { 384 /* use max target bpp allowed */ 385 *target_bpp_x16 = range.max_target_bpp_x16; 386 should_use_dsc = true; 387 } else if (target_bandwidth_kbps >= range.min_kbps) { 388 /* use target bpp that can take entire target bandwidth */ 389 *target_bpp_x16 = compute_bpp_x16_from_target_bandwidth( 390 target_bandwidth_kbps, timing, num_slices_h, 391 dsc_common_caps->bpp_increment_div, 392 dsc_common_caps->is_dp); 393 should_use_dsc = true; 394 } else { 395 /* not enough bandwidth to fulfill minimum requirement */ 396 *target_bpp_x16 = 0; 397 should_use_dsc = false; 398 } 399 400 return should_use_dsc; 401 } 402 403 #define MIN_AVAILABLE_SLICES_SIZE 4 404 405 static int get_available_dsc_slices(union dsc_enc_slice_caps slice_caps, int *available_slices) 406 { 407 int idx = 0; 408 409 memset(available_slices, -1, MIN_AVAILABLE_SLICES_SIZE); 410 411 if (slice_caps.bits.NUM_SLICES_1) 412 available_slices[idx++] = 1; 413 414 if (slice_caps.bits.NUM_SLICES_2) 415 available_slices[idx++] = 2; 416 417 if (slice_caps.bits.NUM_SLICES_4) 418 available_slices[idx++] = 4; 419 420 if (slice_caps.bits.NUM_SLICES_8) 421 available_slices[idx++] = 8; 422 423 return idx; 424 } 425 426 427 static int get_max_dsc_slices(union dsc_enc_slice_caps slice_caps) 428 { 429 int max_slices = 0; 430 int available_slices[MIN_AVAILABLE_SLICES_SIZE]; 431 int end_idx = get_available_dsc_slices(slice_caps, &available_slices[0]); 432 433 if (end_idx > 0) 434 max_slices = available_slices[end_idx - 1]; 435 436 return max_slices; 437 } 438 439 440 // Increment sice number in available sice numbers stops if possible, or just increment if not 441 static int inc_num_slices(union dsc_enc_slice_caps slice_caps, int num_slices) 442 { 443 // Get next bigger num slices available in common caps 444 int available_slices[MIN_AVAILABLE_SLICES_SIZE]; 445 int end_idx; 446 int i; 447 int new_num_slices = num_slices; 448 449 end_idx = get_available_dsc_slices(slice_caps, &available_slices[0]); 450 if (end_idx == 0) { 451 // No available slices found 452 new_num_slices++; 453 return new_num_slices; 454 } 455 456 // Numbers of slices found - get the next bigger number 457 for (i = 0; i < end_idx; i++) { 458 if (new_num_slices < available_slices[i]) { 459 new_num_slices = available_slices[i]; 460 break; 461 } 462 } 463 464 if (new_num_slices == num_slices) // No biger number of slices found 465 new_num_slices++; 466 467 return new_num_slices; 468 } 469 470 471 // Decrement sice number in available sice numbers stops if possible, or just decrement if not. Stop at zero. 472 static int dec_num_slices(union dsc_enc_slice_caps slice_caps, int num_slices) 473 { 474 // Get next bigger num slices available in common caps 475 int available_slices[MIN_AVAILABLE_SLICES_SIZE]; 476 int end_idx; 477 int i; 478 int new_num_slices = num_slices; 479 480 end_idx = get_available_dsc_slices(slice_caps, &available_slices[0]); 481 if (end_idx == 0 && new_num_slices > 0) { 482 // No numbers of slices found 483 new_num_slices++; 484 return new_num_slices; 485 } 486 487 // Numbers of slices found - get the next smaller number 488 for (i = end_idx - 1; i >= 0; i--) { 489 if (new_num_slices > available_slices[i]) { 490 new_num_slices = available_slices[i]; 491 break; 492 } 493 } 494 495 if (new_num_slices == num_slices) { 496 // No smaller number of slices found 497 new_num_slices--; 498 if (new_num_slices < 0) 499 new_num_slices = 0; 500 } 501 502 return new_num_slices; 503 } 504 505 506 // Choose next bigger number of slices if the requested number of slices is not available 507 static int fit_num_slices_up(union dsc_enc_slice_caps slice_caps, int num_slices) 508 { 509 // Get next bigger num slices available in common caps 510 int available_slices[MIN_AVAILABLE_SLICES_SIZE]; 511 int end_idx; 512 int i; 513 int new_num_slices = num_slices; 514 515 end_idx = get_available_dsc_slices(slice_caps, &available_slices[0]); 516 if (end_idx == 0) { 517 // No available slices found 518 new_num_slices++; 519 return new_num_slices; 520 } 521 522 // Numbers of slices found - get the equal or next bigger number 523 for (i = 0; i < end_idx; i++) { 524 if (new_num_slices <= available_slices[i]) { 525 new_num_slices = available_slices[i]; 526 break; 527 } 528 } 529 530 return new_num_slices; 531 } 532 533 534 /* Attempts to set DSC configuration for the stream, applying DSC policy. 535 * Returns 'true' if successful or 'false' if not. 536 * 537 * Parameters: 538 * 539 * dsc_sink_caps - DSC sink decoder capabilities (from DPCD) 540 * 541 * dsc_enc_caps - DSC encoder capabilities 542 * 543 * target_bandwidth_kbps - Target bandwidth to fit the stream into. 544 * If 0, do not calculate target bpp. 545 * 546 * timing - The stream timing to fit into 'target_bandwidth_kbps' or apply 547 * maximum compression to, if 'target_badwidth == 0' 548 * 549 * dsc_cfg - DSC configuration to use if it was possible to come up with 550 * one for the given inputs. 551 * The target bitrate after DSC can be calculated by multiplying 552 * dsc_cfg.bits_per_pixel (in U6.4 format) by pixel rate, e.g. 553 * 554 * dsc_stream_bitrate_kbps = (int)ceil(timing->pix_clk_khz * dsc_cfg.bits_per_pixel / 16.0); 555 */ 556 static bool setup_dsc_config( 557 const struct dsc_dec_dpcd_caps *dsc_sink_caps, 558 const struct dsc_enc_caps *dsc_enc_caps, 559 int target_bandwidth_kbps, 560 const struct dc_crtc_timing *timing, 561 int min_slice_height_override, 562 int max_dsc_target_bpp_limit_override_x16, 563 struct dc_dsc_config *dsc_cfg) 564 { 565 struct dsc_enc_caps dsc_common_caps; 566 int max_slices_h; 567 int min_slices_h; 568 int num_slices_h; 569 int pic_width; 570 int slice_width; 571 int target_bpp; 572 int sink_per_slice_throughput_mps; 573 int branch_max_throughput_mps = 0; 574 bool is_dsc_possible = false; 575 int pic_height; 576 int slice_height; 577 struct dc_dsc_policy policy; 578 579 memset(dsc_cfg, 0, sizeof(struct dc_dsc_config)); 580 581 dc_dsc_get_policy_for_timing(timing, max_dsc_target_bpp_limit_override_x16, &policy); 582 pic_width = timing->h_addressable + timing->h_border_left + timing->h_border_right; 583 pic_height = timing->v_addressable + timing->v_border_top + timing->v_border_bottom; 584 585 if (!dsc_sink_caps->is_dsc_supported) 586 goto done; 587 588 if (dsc_sink_caps->branch_max_line_width && dsc_sink_caps->branch_max_line_width < pic_width) 589 goto done; 590 591 // Intersect decoder with encoder DSC caps and validate DSC settings 592 is_dsc_possible = intersect_dsc_caps(dsc_sink_caps, dsc_enc_caps, timing->pixel_encoding, &dsc_common_caps); 593 if (!is_dsc_possible) 594 goto done; 595 596 sink_per_slice_throughput_mps = 0; 597 598 // Validate available DSC settings against the mode timing 599 600 // Validate color format (and pick up the throughput values) 601 dsc_cfg->ycbcr422_simple = false; 602 switch (timing->pixel_encoding) { 603 case PIXEL_ENCODING_RGB: 604 is_dsc_possible = (bool)dsc_common_caps.color_formats.bits.RGB; 605 sink_per_slice_throughput_mps = dsc_sink_caps->throughput_mode_0_mps; 606 branch_max_throughput_mps = dsc_sink_caps->branch_overall_throughput_0_mps; 607 break; 608 case PIXEL_ENCODING_YCBCR444: 609 is_dsc_possible = (bool)dsc_common_caps.color_formats.bits.YCBCR_444; 610 sink_per_slice_throughput_mps = dsc_sink_caps->throughput_mode_0_mps; 611 branch_max_throughput_mps = dsc_sink_caps->branch_overall_throughput_0_mps; 612 break; 613 case PIXEL_ENCODING_YCBCR422: 614 is_dsc_possible = (bool)dsc_common_caps.color_formats.bits.YCBCR_NATIVE_422; 615 sink_per_slice_throughput_mps = dsc_sink_caps->throughput_mode_1_mps; 616 branch_max_throughput_mps = dsc_sink_caps->branch_overall_throughput_1_mps; 617 if (!is_dsc_possible) { 618 is_dsc_possible = (bool)dsc_common_caps.color_formats.bits.YCBCR_SIMPLE_422; 619 dsc_cfg->ycbcr422_simple = is_dsc_possible; 620 sink_per_slice_throughput_mps = dsc_sink_caps->throughput_mode_0_mps; 621 } 622 break; 623 case PIXEL_ENCODING_YCBCR420: 624 is_dsc_possible = (bool)dsc_common_caps.color_formats.bits.YCBCR_NATIVE_420; 625 sink_per_slice_throughput_mps = dsc_sink_caps->throughput_mode_1_mps; 626 branch_max_throughput_mps = dsc_sink_caps->branch_overall_throughput_1_mps; 627 break; 628 default: 629 is_dsc_possible = false; 630 } 631 632 // Validate branch's maximum throughput 633 if (branch_max_throughput_mps && dsc_div_by_10_round_up(timing->pix_clk_100hz) > branch_max_throughput_mps * 1000) 634 is_dsc_possible = false; 635 636 if (!is_dsc_possible) 637 goto done; 638 639 // Color depth 640 switch (timing->display_color_depth) { 641 case COLOR_DEPTH_888: 642 is_dsc_possible = (bool)dsc_common_caps.color_depth.bits.COLOR_DEPTH_8_BPC; 643 break; 644 case COLOR_DEPTH_101010: 645 is_dsc_possible = (bool)dsc_common_caps.color_depth.bits.COLOR_DEPTH_10_BPC; 646 break; 647 case COLOR_DEPTH_121212: 648 is_dsc_possible = (bool)dsc_common_caps.color_depth.bits.COLOR_DEPTH_12_BPC; 649 break; 650 default: 651 is_dsc_possible = false; 652 } 653 654 if (!is_dsc_possible) 655 goto done; 656 657 // Slice width (i.e. number of slices per line) 658 max_slices_h = get_max_dsc_slices(dsc_common_caps.slice_caps); 659 660 while (max_slices_h > 0) { 661 if (pic_width % max_slices_h == 0) 662 break; 663 664 max_slices_h = dec_num_slices(dsc_common_caps.slice_caps, max_slices_h); 665 } 666 667 is_dsc_possible = (dsc_common_caps.max_slice_width > 0); 668 if (!is_dsc_possible) 669 goto done; 670 671 min_slices_h = pic_width / dsc_common_caps.max_slice_width; 672 if (pic_width % dsc_common_caps.max_slice_width) 673 min_slices_h++; 674 675 min_slices_h = fit_num_slices_up(dsc_common_caps.slice_caps, min_slices_h); 676 677 while (min_slices_h <= max_slices_h) { 678 int pix_clk_per_slice_khz = dsc_div_by_10_round_up(timing->pix_clk_100hz) / min_slices_h; 679 if (pix_clk_per_slice_khz <= sink_per_slice_throughput_mps * 1000) 680 break; 681 682 min_slices_h = inc_num_slices(dsc_common_caps.slice_caps, min_slices_h); 683 } 684 685 if (pic_width % min_slices_h != 0) 686 min_slices_h = 0; // DSC TODO: Maybe try increasing the number of slices first? 687 688 is_dsc_possible = (min_slices_h <= max_slices_h); 689 if (!is_dsc_possible) 690 goto done; 691 692 if (policy.use_min_slices_h) { 693 if (min_slices_h > 0) 694 num_slices_h = min_slices_h; 695 else if (max_slices_h > 0) { // Fall back to max slices if min slices is not working out 696 if (policy.max_slices_h) 697 num_slices_h = min(policy.max_slices_h, max_slices_h); 698 else 699 num_slices_h = max_slices_h; 700 } else 701 is_dsc_possible = false; 702 } else { 703 if (max_slices_h > 0) { 704 if (policy.max_slices_h) 705 num_slices_h = min(policy.max_slices_h, max_slices_h); 706 else 707 num_slices_h = max_slices_h; 708 } else if (min_slices_h > 0) // Fall back to min slices if max slices is not possible 709 num_slices_h = min_slices_h; 710 else 711 is_dsc_possible = false; 712 } 713 714 if (!is_dsc_possible) 715 goto done; 716 717 dsc_cfg->num_slices_h = num_slices_h; 718 slice_width = pic_width / num_slices_h; 719 720 is_dsc_possible = slice_width <= dsc_common_caps.max_slice_width; 721 if (!is_dsc_possible) 722 goto done; 723 724 // Slice height (i.e. number of slices per column): start with policy and pick the first one that height is divisible by. 725 // For 4:2:0 make sure the slice height is divisible by 2 as well. 726 if (min_slice_height_override == 0) 727 slice_height = min(policy.min_slice_height, pic_height); 728 else 729 slice_height = min(min_slice_height_override, pic_height); 730 731 while (slice_height < pic_height && (pic_height % slice_height != 0 || 732 (timing->pixel_encoding == PIXEL_ENCODING_YCBCR420 && slice_height % 2 != 0))) 733 slice_height++; 734 735 if (timing->pixel_encoding == PIXEL_ENCODING_YCBCR420) // For the case when pic_height < dsc_policy.min_sice_height 736 is_dsc_possible = (slice_height % 2 == 0); 737 738 if (!is_dsc_possible) 739 goto done; 740 741 dsc_cfg->num_slices_v = pic_height/slice_height; 742 743 if (target_bandwidth_kbps > 0) { 744 is_dsc_possible = decide_dsc_target_bpp_x16( 745 &policy, 746 &dsc_common_caps, 747 target_bandwidth_kbps, 748 timing, 749 num_slices_h, 750 &target_bpp); 751 dsc_cfg->bits_per_pixel = target_bpp; 752 } 753 if (!is_dsc_possible) 754 goto done; 755 756 // Final decission: can we do DSC or not? 757 if (is_dsc_possible) { 758 // Fill out the rest of DSC settings 759 dsc_cfg->block_pred_enable = dsc_common_caps.is_block_pred_supported; 760 dsc_cfg->linebuf_depth = dsc_common_caps.lb_bit_depth; 761 dsc_cfg->version_minor = (dsc_common_caps.dsc_version & 0xf0) >> 4; 762 dsc_cfg->is_dp = dsc_sink_caps->is_dp; 763 } 764 765 done: 766 if (!is_dsc_possible) 767 memset(dsc_cfg, 0, sizeof(struct dc_dsc_config)); 768 769 return is_dsc_possible; 770 } 771 772 bool dc_dsc_parse_dsc_dpcd(const struct dc *dc, const uint8_t *dpcd_dsc_basic_data, const uint8_t *dpcd_dsc_branch_decoder_caps, struct dsc_dec_dpcd_caps *dsc_sink_caps) 773 { 774 if (!dpcd_dsc_basic_data) 775 return false; 776 777 dsc_sink_caps->is_dsc_supported = (dpcd_dsc_basic_data[DP_DSC_SUPPORT - DP_DSC_SUPPORT] & DP_DSC_DECOMPRESSION_IS_SUPPORTED) != 0; 778 if (!dsc_sink_caps->is_dsc_supported) 779 return false; 780 781 dsc_sink_caps->dsc_version = dpcd_dsc_basic_data[DP_DSC_REV - DP_DSC_SUPPORT]; 782 783 { 784 int buff_block_size; 785 int buff_size; 786 787 if (!dsc_buff_block_size_from_dpcd(dpcd_dsc_basic_data[DP_DSC_RC_BUF_BLK_SIZE - DP_DSC_SUPPORT], &buff_block_size)) 788 return false; 789 790 buff_size = dpcd_dsc_basic_data[DP_DSC_RC_BUF_SIZE - DP_DSC_SUPPORT] + 1; 791 dsc_sink_caps->rc_buffer_size = buff_size * buff_block_size; 792 } 793 794 dsc_sink_caps->slice_caps1.raw = dpcd_dsc_basic_data[DP_DSC_SLICE_CAP_1 - DP_DSC_SUPPORT]; 795 if (!dsc_line_buff_depth_from_dpcd(dpcd_dsc_basic_data[DP_DSC_LINE_BUF_BIT_DEPTH - DP_DSC_SUPPORT], &dsc_sink_caps->lb_bit_depth)) 796 return false; 797 798 dsc_sink_caps->is_block_pred_supported = 799 (dpcd_dsc_basic_data[DP_DSC_BLK_PREDICTION_SUPPORT - DP_DSC_SUPPORT] & DP_DSC_BLK_PREDICTION_IS_SUPPORTED) != 0; 800 801 dsc_sink_caps->edp_max_bits_per_pixel = 802 dpcd_dsc_basic_data[DP_DSC_MAX_BITS_PER_PIXEL_LOW - DP_DSC_SUPPORT] | 803 dpcd_dsc_basic_data[DP_DSC_MAX_BITS_PER_PIXEL_HI - DP_DSC_SUPPORT] << 8; 804 805 dsc_sink_caps->color_formats.raw = dpcd_dsc_basic_data[DP_DSC_DEC_COLOR_FORMAT_CAP - DP_DSC_SUPPORT]; 806 dsc_sink_caps->color_depth.raw = dpcd_dsc_basic_data[DP_DSC_DEC_COLOR_DEPTH_CAP - DP_DSC_SUPPORT]; 807 808 { 809 int dpcd_throughput = dpcd_dsc_basic_data[DP_DSC_PEAK_THROUGHPUT - DP_DSC_SUPPORT]; 810 811 if (!dsc_throughput_from_dpcd(dpcd_throughput & DP_DSC_THROUGHPUT_MODE_0_MASK, &dsc_sink_caps->throughput_mode_0_mps)) 812 return false; 813 814 dpcd_throughput = (dpcd_throughput & DP_DSC_THROUGHPUT_MODE_1_MASK) >> DP_DSC_THROUGHPUT_MODE_1_SHIFT; 815 if (!dsc_throughput_from_dpcd(dpcd_throughput, &dsc_sink_caps->throughput_mode_1_mps)) 816 return false; 817 } 818 819 dsc_sink_caps->max_slice_width = dpcd_dsc_basic_data[DP_DSC_MAX_SLICE_WIDTH - DP_DSC_SUPPORT] * 320; 820 dsc_sink_caps->slice_caps2.raw = dpcd_dsc_basic_data[DP_DSC_SLICE_CAP_2 - DP_DSC_SUPPORT]; 821 822 if (!dsc_bpp_increment_div_from_dpcd(dpcd_dsc_basic_data[DP_DSC_BITS_PER_PIXEL_INC - DP_DSC_SUPPORT], &dsc_sink_caps->bpp_increment_div)) 823 return false; 824 825 if (dc->debug.dsc_bpp_increment_div) { 826 /* dsc_bpp_increment_div should onl be 1, 2, 4, 8 or 16, but rather than rejecting invalid values, 827 * we'll accept all and get it into range. This also makes the above check against 0 redundant, 828 * but that one stresses out the override will be only used if it's not 0. 829 */ 830 if (dc->debug.dsc_bpp_increment_div >= 1) 831 dsc_sink_caps->bpp_increment_div = 1; 832 if (dc->debug.dsc_bpp_increment_div >= 2) 833 dsc_sink_caps->bpp_increment_div = 2; 834 if (dc->debug.dsc_bpp_increment_div >= 4) 835 dsc_sink_caps->bpp_increment_div = 4; 836 if (dc->debug.dsc_bpp_increment_div >= 8) 837 dsc_sink_caps->bpp_increment_div = 8; 838 if (dc->debug.dsc_bpp_increment_div >= 16) 839 dsc_sink_caps->bpp_increment_div = 16; 840 } 841 842 /* Extended caps */ 843 if (dpcd_dsc_branch_decoder_caps == NULL) { // branch decoder DPCD DSC data can be null for non branch device 844 dsc_sink_caps->branch_overall_throughput_0_mps = 0; 845 dsc_sink_caps->branch_overall_throughput_1_mps = 0; 846 dsc_sink_caps->branch_max_line_width = 0; 847 return true; 848 } 849 850 dsc_sink_caps->branch_overall_throughput_0_mps = dpcd_dsc_branch_decoder_caps[DP_DSC_BRANCH_OVERALL_THROUGHPUT_0 - DP_DSC_BRANCH_OVERALL_THROUGHPUT_0]; 851 if (dsc_sink_caps->branch_overall_throughput_0_mps == 0) 852 dsc_sink_caps->branch_overall_throughput_0_mps = 0; 853 else if (dsc_sink_caps->branch_overall_throughput_0_mps == 1) 854 dsc_sink_caps->branch_overall_throughput_0_mps = 680; 855 else { 856 dsc_sink_caps->branch_overall_throughput_0_mps *= 50; 857 dsc_sink_caps->branch_overall_throughput_0_mps += 600; 858 } 859 860 dsc_sink_caps->branch_overall_throughput_1_mps = dpcd_dsc_branch_decoder_caps[DP_DSC_BRANCH_OVERALL_THROUGHPUT_1 - DP_DSC_BRANCH_OVERALL_THROUGHPUT_0]; 861 if (dsc_sink_caps->branch_overall_throughput_1_mps == 0) 862 dsc_sink_caps->branch_overall_throughput_1_mps = 0; 863 else if (dsc_sink_caps->branch_overall_throughput_1_mps == 1) 864 dsc_sink_caps->branch_overall_throughput_1_mps = 680; 865 else { 866 dsc_sink_caps->branch_overall_throughput_1_mps *= 50; 867 dsc_sink_caps->branch_overall_throughput_1_mps += 600; 868 } 869 870 dsc_sink_caps->branch_max_line_width = dpcd_dsc_branch_decoder_caps[DP_DSC_BRANCH_MAX_LINE_WIDTH - DP_DSC_BRANCH_OVERALL_THROUGHPUT_0] * 320; 871 ASSERT(dsc_sink_caps->branch_max_line_width == 0 || dsc_sink_caps->branch_max_line_width >= 5120); 872 873 dsc_sink_caps->is_dp = true; 874 return true; 875 } 876 877 878 /* If DSC is possbile, get DSC bandwidth range based on [min_bpp, max_bpp] target bitrate range and 879 * timing's pixel clock and uncompressed bandwidth. 880 * If DSC is not possible, leave '*range' untouched. 881 */ 882 bool dc_dsc_compute_bandwidth_range( 883 const struct display_stream_compressor *dsc, 884 uint32_t dsc_min_slice_height_override, 885 uint32_t min_bpp_x16, 886 uint32_t max_bpp_x16, 887 const struct dsc_dec_dpcd_caps *dsc_sink_caps, 888 const struct dc_crtc_timing *timing, 889 struct dc_dsc_bw_range *range) 890 { 891 bool is_dsc_possible = false; 892 struct dsc_enc_caps dsc_enc_caps; 893 struct dsc_enc_caps dsc_common_caps; 894 struct dc_dsc_config config; 895 896 get_dsc_enc_caps(dsc, &dsc_enc_caps, timing->pix_clk_100hz); 897 898 is_dsc_possible = intersect_dsc_caps(dsc_sink_caps, &dsc_enc_caps, 899 timing->pixel_encoding, &dsc_common_caps); 900 901 if (is_dsc_possible) 902 is_dsc_possible = setup_dsc_config(dsc_sink_caps, &dsc_enc_caps, 0, timing, 903 dsc_min_slice_height_override, max_bpp_x16, &config); 904 905 if (is_dsc_possible) 906 get_dsc_bandwidth_range(min_bpp_x16, max_bpp_x16, 907 config.num_slices_h, &dsc_common_caps, timing, range); 908 909 return is_dsc_possible; 910 } 911 912 bool dc_dsc_compute_config( 913 const struct display_stream_compressor *dsc, 914 const struct dsc_dec_dpcd_caps *dsc_sink_caps, 915 uint32_t dsc_min_slice_height_override, 916 uint32_t max_target_bpp_limit_override, 917 uint32_t target_bandwidth_kbps, 918 const struct dc_crtc_timing *timing, 919 struct dc_dsc_config *dsc_cfg) 920 { 921 bool is_dsc_possible = false; 922 struct dsc_enc_caps dsc_enc_caps; 923 924 get_dsc_enc_caps(dsc, &dsc_enc_caps, timing->pix_clk_100hz); 925 is_dsc_possible = setup_dsc_config(dsc_sink_caps, 926 &dsc_enc_caps, 927 target_bandwidth_kbps, 928 timing, dsc_min_slice_height_override, 929 max_target_bpp_limit_override * 16, dsc_cfg); 930 return is_dsc_possible; 931 } 932 933 uint32_t dc_dsc_stream_bandwidth_in_kbps(const struct dc_crtc_timing *timing, 934 uint32_t bpp_x16, uint32_t num_slices_h, bool is_dp) 935 { 936 struct fixed31_32 overhead_in_kbps; 937 struct fixed31_32 bpp; 938 struct fixed31_32 actual_bandwidth_in_kbps; 939 940 overhead_in_kbps = compute_dsc_max_bandwidth_overhead( 941 timing, num_slices_h, is_dp); 942 bpp = dc_fixpt_from_fraction(bpp_x16, 16); 943 actual_bandwidth_in_kbps = dc_fixpt_from_fraction(timing->pix_clk_100hz, 10); 944 actual_bandwidth_in_kbps = dc_fixpt_mul(actual_bandwidth_in_kbps, bpp); 945 actual_bandwidth_in_kbps = dc_fixpt_add(actual_bandwidth_in_kbps, overhead_in_kbps); 946 return dc_fixpt_ceil(actual_bandwidth_in_kbps); 947 } 948 949 void dc_dsc_get_policy_for_timing(const struct dc_crtc_timing *timing, uint32_t max_target_bpp_limit_override_x16, struct dc_dsc_policy *policy) 950 { 951 uint32_t bpc = 0; 952 953 policy->min_target_bpp = 0; 954 policy->max_target_bpp = 0; 955 956 /* DSC Policy: Use minimum number of slices that fits the pixel clock */ 957 policy->use_min_slices_h = true; 958 959 /* DSC Policy: Use max available slices 960 * (in our case 4 for or 8, depending on the mode) 961 */ 962 policy->max_slices_h = 0; 963 964 /* DSC Policy: Use slice height recommended 965 * by VESA DSC Spreadsheet user guide 966 */ 967 policy->min_slice_height = 108; 968 969 /* DSC Policy: follow DP specs with an internal upper limit to 16 bpp 970 * for better interoperability 971 */ 972 switch (timing->display_color_depth) { 973 case COLOR_DEPTH_888: 974 bpc = 8; 975 break; 976 case COLOR_DEPTH_101010: 977 bpc = 10; 978 break; 979 case COLOR_DEPTH_121212: 980 bpc = 12; 981 break; 982 default: 983 return; 984 } 985 switch (timing->pixel_encoding) { 986 case PIXEL_ENCODING_RGB: 987 case PIXEL_ENCODING_YCBCR444: 988 case PIXEL_ENCODING_YCBCR422: /* assume no YCbCr422 native support */ 989 /* DP specs limits to 8 */ 990 policy->min_target_bpp = 8; 991 /* DP specs limits to 3 x bpc */ 992 policy->max_target_bpp = 3 * bpc; 993 break; 994 case PIXEL_ENCODING_YCBCR420: 995 /* DP specs limits to 6 */ 996 policy->min_target_bpp = 6; 997 /* DP specs limits to 1.5 x bpc assume bpc is an even number */ 998 policy->max_target_bpp = bpc * 3 / 2; 999 break; 1000 default: 1001 return; 1002 } 1003 1004 policy->preferred_bpp_x16 = timing->dsc_fixed_bits_per_pixel_x16; 1005 1006 /* internal upper limit, default 16 bpp */ 1007 if (policy->max_target_bpp > dsc_policy_max_target_bpp_limit) 1008 policy->max_target_bpp = dsc_policy_max_target_bpp_limit; 1009 1010 /* apply override */ 1011 if (max_target_bpp_limit_override_x16 && policy->max_target_bpp > max_target_bpp_limit_override_x16 / 16) 1012 policy->max_target_bpp = max_target_bpp_limit_override_x16 / 16; 1013 1014 /* enable DSC when not needed, default false */ 1015 if (dsc_policy_enable_dsc_when_not_needed) 1016 policy->enable_dsc_when_not_needed = dsc_policy_enable_dsc_when_not_needed; 1017 else 1018 policy->enable_dsc_when_not_needed = false; 1019 } 1020 1021 void dc_dsc_policy_set_max_target_bpp_limit(uint32_t limit) 1022 { 1023 dsc_policy_max_target_bpp_limit = limit; 1024 } 1025 1026 void dc_dsc_policy_set_enable_dsc_when_not_needed(bool enable) 1027 { 1028 dsc_policy_enable_dsc_when_not_needed = enable; 1029 } 1030 1031 void dc_dsc_policy_set_disable_dsc_stream_overhead(bool disable) 1032 { 1033 dsc_policy_disable_dsc_stream_overhead = disable; 1034 } 1035