samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
程式碼 問題 合併請求 Actions 套件 專案 版本發布 Wiki 動態

disp: msm: use upstream dsc config data

瀏覽代碼 
This change enforces dp, dsi and the sde drivers to use the
drm framework defined dsc_config data structure. As a part of this,
it introduces the sde_dsc_helper API to configure the dsc params
and creating a PPS command. Earlier each driver implemented it's
private versions leading to duplication of code. Additionaly the
helper api supports DSC spec 1.2 422 and 420 mode.

Change-Id: I25933fab08cdabbc6787079926885d1a78945e97
Signed-off-by: Abhijit Kulkarni <kabhijit@codeaurora.org>
此提交包含在：
Abhijit Kulkarni
2019-05-14 10:21:07 -07:00
父節點 673ebb896c
當前提交 acb8d98e66
共有 14 個檔案被更改，包括 705 行新增 和 930 行删除
下載 Patch 檔 下載差異檔 展開所有檔案 折疊所有檔案

421
msm/dp/dp_panel.c
查看文件

@@ -1,12 +1,14 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2012-2019, The Linux Foundation. All rights reserved.
* Copyright (c) 2012-2020, The Linux Foundation. All rights reserved.
*/
#include "dp_panel.h"
#include <linux/unistd.h>
#include <drm/drm_fixed.h>
#include "dp_debug.h"
#include <drm/drm_dsc.h>
#include "sde_dsc_helper.h"
#define DP_KHZ_TO_HZ 1000
#define DP_PANEL_DEFAULT_BPP 24
@@ -1062,68 +1064,6 @@ static void dp_panel_config_tr_unit(struct dp_panel *dp_panel)
catalog->update_transfer_unit(catalog);
}
enum dp_dsc_ratio_type {
DSC_8BPC_8BPP,
DSC_10BPC_8BPP,
DSC_12BPC_8BPP,
DSC_10BPC_10BPP,
DSC_RATIO_TYPE_MAX
};
static u32 dp_dsc_rc_buf_thresh[] = {0x0e, 0x1c, 0x2a, 0x38, 0x46, 0x54,
0x62, 0x69, 0x70, 0x77, 0x79, 0x7b, 0x7d, 0x7e};
/*
* DSC 1.1
* Rate control - Min QP values for each ratio type in dp_dsc_ratio_type
*/
static char dp_dsc_rc_range_min_qp_1_1[][15] = {
{0, 0, 1, 1, 3, 3, 3, 3, 3, 3, 5, 5, 5, 7, 13},
{0, 4, 5, 5, 7, 7, 7, 7, 7, 7, 9, 9, 9, 11, 17},
{0, 4, 9, 9, 11, 11, 11, 11, 11, 11, 13, 13, 13, 15, 21},
{0, 4, 5, 6, 7, 7, 7, 7, 7, 7, 9, 9, 9, 11, 15},
};
/*
* DSC 1.1 SCR
* Rate control - Min QP values for each ratio type in dp_dsc_ratio_type
*/
static char dp_dsc_rc_range_min_qp_1_1_scr1[][15] = {
{0, 0, 1, 1, 3, 3, 3, 3, 3, 3, 5, 5, 5, 9, 12},
{0, 4, 5, 5, 7, 7, 7, 7, 7, 7, 9, 9, 9, 13, 16},
{0, 4, 9, 9, 11, 11, 11, 11, 11, 11, 13, 13, 13, 17, 20},
{0, 4, 5, 6, 7, 7, 7, 7, 7, 7, 9, 9, 9, 11, 15},
};
/*
* DSC 1.1
* Rate control - Max QP values for each ratio type in dp_dsc_ratio_type
*/
static char dp_dsc_rc_range_max_qp_1_1[][15] = {
{4, 4, 5, 6, 7, 7, 7, 8, 9, 10, 11, 12, 13, 13, 15},
{8, 8, 9, 10, 11, 11, 11, 12, 13, 14, 15, 16, 17, 17, 19},
{12, 12, 13, 14, 15, 15, 15, 16, 17, 18, 19, 20, 21, 21, 23},
{7, 8, 9, 10, 11, 11, 11, 12, 13, 13, 14, 14, 15, 15, 16},
};
/*
* DSC 1.1 SCR
* Rate control - Max QP values for each ratio type in dp_dsc_ratio_type
*/
static char dp_dsc_rc_range_max_qp_1_1_scr1[][15] = {
{4, 4, 5, 6, 7, 7, 7, 8, 9, 10, 10, 11, 11, 12, 13},
{8, 8, 9, 10, 11, 11, 11, 12, 13, 14, 14, 15, 15, 16, 17},
{12, 12, 13, 14, 15, 15, 15, 16, 17, 18, 18, 19, 19, 20, 21},
{7, 8, 9, 10, 11, 11, 11, 12, 13, 13, 14, 14, 15, 15, 16},
};
/*
* DSC 1.1 and DSC 1.1 SCR
* Rate control - bpg offset values
*/
static char dp_dsc_rc_range_bpg_offset[] = {2, 0, 0, -2, -4, -6, -8, -8,
-8, -10, -10, -12, -12, -12, -12};
struct dp_dsc_dto_data {
enum msm_display_compression_ratio comp_ratio;
u32 org_bpp; /* bits */
@@ -1153,108 +1093,6 @@ static void _dp_panel_get_dto_m_n(enum msm_display_compression_ratio ratio,
}
}
static int dp_panel_dsc_create_pps_buf_cmd(struct msm_display_dsc_info *dsc,
char *buf, int pps_id)
{
char *bp = buf;
char data;
int i, bpp;
*bp++ = (dsc->version & 0xff); /* pps0 */
*bp++ = (pps_id & 0xff); /* pps1 */
bp++; /* pps2, reserved */
data = dsc->line_buf_depth & 0x0f;
data |= ((dsc->bpc & 0xf) << 4);
*bp++ = data; /* pps3 */
bpp = dsc->bpp;
bpp <<= 4; /* 4 fraction bits */
data = (bpp >> 8);
data &= 0x03; /* upper two bits */
data |= ((dsc->block_pred_enable & 0x1) << 5);
data |= ((dsc->convert_rgb & 0x1) << 4);
data |= ((dsc->enable_422 & 0x1) << 3);
data |= ((dsc->vbr_enable & 0x1) << 2);
*bp++ = data; /* pps4 */
*bp++ = (bpp & 0xff); /* pps5 */
*bp++ = ((dsc->pic_height >> 8) & 0xff); /* pps6 */
*bp++ = (dsc->pic_height & 0x0ff); /* pps7 */
*bp++ = ((dsc->pic_width >> 8) & 0xff); /* pps8 */
*bp++ = (dsc->pic_width & 0x0ff); /* pps9 */
*bp++ = ((dsc->slice_height >> 8) & 0xff);/* pps10 */
*bp++ = (dsc->slice_height & 0x0ff); /* pps11 */
*bp++ = ((dsc->slice_width >> 8) & 0xff); /* pps12 */
*bp++ = (dsc->slice_width & 0x0ff); /* pps13 */
*bp++ = ((dsc->chunk_size >> 8) & 0xff);/* pps14 */
*bp++ = (dsc->chunk_size & 0x0ff); /* pps15 */
*bp++ = (dsc->initial_xmit_delay >> 8) & 0x3; /* pps16*/
*bp++ = (dsc->initial_xmit_delay & 0xff);/* pps17 */
*bp++ = ((dsc->initial_dec_delay >> 8) & 0xff); /* pps18 */
*bp++ = (dsc->initial_dec_delay & 0xff);/* pps19 */
bp++; /* pps20, reserved */
*bp++ = (dsc->initial_scale_value & 0x3f); /* pps21 */
*bp++ = ((dsc->scale_increment_interval >> 8) & 0xff); /* pps22 */
*bp++ = (dsc->scale_increment_interval & 0xff); /* pps23 */
*bp++ = ((dsc->scale_decrement_interval >> 8) & 0xf); /* pps24 */
*bp++ = (dsc->scale_decrement_interval & 0x0ff);/* pps25 */
bp++; /* pps26, reserved */
*bp++ = (dsc->first_line_bpg_offset & 0x1f);/* pps27 */
*bp++ = ((dsc->nfl_bpg_offset >> 8) & 0xff);/* pps28 */
*bp++ = (dsc->nfl_bpg_offset & 0x0ff); /* pps29 */
*bp++ = ((dsc->slice_bpg_offset >> 8) & 0xff);/* pps30 */
*bp++ = (dsc->slice_bpg_offset & 0x0ff);/* pps31 */
*bp++ = ((dsc->initial_offset >> 8) & 0xff);/* pps32 */
*bp++ = (dsc->initial_offset & 0x0ff); /* pps33 */
*bp++ = ((dsc->final_offset >> 8) & 0xff);/* pps34 */
*bp++ = (dsc->final_offset & 0x0ff); /* pps35 */
*bp++ = (dsc->min_qp_flatness & 0x1f); /* pps36 */
*bp++ = (dsc->max_qp_flatness & 0x1f); /* pps37 */
*bp++ = ((dsc->rc_model_size >> 8) & 0xff);/* pps38 */
*bp++ = (dsc->rc_model_size & 0x0ff); /* pps39 */
*bp++ = (dsc->edge_factor & 0x0f); /* pps40 */
*bp++ = (dsc->quant_incr_limit0 & 0x1f); /* pps41 */
*bp++ = (dsc->quant_incr_limit1 & 0x1f); /* pps42 */
data = ((dsc->tgt_offset_hi & 0xf) << 4);
data |= (dsc->tgt_offset_lo & 0x0f);
*bp++ = data; /* pps43 */
for (i = 0; i < ARRAY_SIZE(dp_dsc_rc_buf_thresh); i++)
*bp++ = (dsc->buf_thresh[i] & 0xff); /* pps44 - pps57 */
for (i = 0; i < 15; i++) { /* pps58 - pps87 */
data = (dsc->range_min_qp[i] & 0x1f);
data <<= 3;
data |= ((dsc->range_max_qp[i] >> 2) & 0x07);
*bp++ = data;
data = (dsc->range_max_qp[i] & 0x03);
data <<= 6;
data |= (dsc->range_bpg_offset[i] & 0x3f);
*bp++ = data;
}
return 88;
}
static void dp_panel_dsc_prepare_pps_packet(struct dp_panel *dp_panel)
{
struct dp_panel_private *panel;
@@ -1301,10 +1139,11 @@ static void _dp_panel_dsc_get_num_extra_pclk(struct msm_display_dsc_info *dsc,
unsigned int dto_n = 0, dto_d = 0, remainder;
int ack_required, last_few_ack_required, accum_ack;
int last_few_pclk, last_few_pclk_required;
int start, temp, line_width = dsc->pic_width/2;
int start, temp, line_width = dsc->config.pic_width/2;
s64 temp1_fp, temp2_fp;
_dp_panel_get_dto_m_n(ratio, dsc->bpc * 3, &dto_n, &dto_d);
_dp_panel_get_dto_m_n(ratio, dsc->config.bits_per_component * 3,
&dto_n, &dto_d);
ack_required = dsc->pclk_per_line;
@@ -1383,9 +1222,8 @@ static void dp_panel_dsc_pclk_param_calc(struct dp_panel *dp_panel,
enum msm_display_compression_ratio ratio,
struct dp_display_mode *dp_mode)
{
int slice_per_pkt, slice_per_intf, intf_width;
int bytes_in_slice, total_bytes_per_intf;
int comp_ratio;
int comp_ratio, intf_width;
int slice_per_pkt, slice_per_intf;
s64 temp1_fp, temp2_fp;
s64 numerator_fp, denominator_fp;
s64 dsc_byte_count_fp;
@@ -1393,21 +1231,12 @@ static void dp_panel_dsc_pclk_param_calc(struct dp_panel *dp_panel,
intf_width = dp_mode->timing.h_active;
if (!dsc || !dsc->slice_width || !dsc->slice_per_pkt ||
(intf_width < dsc->slice_width))
(intf_width < dsc->slice_width))
return;
slice_per_pkt = dsc->slice_per_pkt;
slice_per_intf = DIV_ROUND_UP(intf_width, dsc->slice_width);
if (slice_per_pkt > slice_per_intf)
slice_per_pkt = 1;
bytes_in_slice = DIV_ROUND_UP(dsc->slice_width * dsc->bpp, 8);
total_bytes_per_intf = bytes_in_slice * slice_per_intf;
dsc->bytes_in_slice = bytes_in_slice;
dsc->bytes_per_pkt = bytes_in_slice * slice_per_pkt;
dsc->pkt_per_line = slice_per_intf / slice_per_pkt;
slice_per_intf = DIV_ROUND_UP(intf_width,
dsc->config.slice_width);
switch (ratio) {
case MSM_DISPLAY_COMPRESSION_RATIO_2_TO_1:
@@ -1424,7 +1253,8 @@ static void dp_panel_dsc_pclk_param_calc(struct dp_panel *dp_panel,
temp1_fp = drm_fixp_from_fraction(comp_ratio, 100);
temp2_fp = drm_fixp_from_fraction(slice_per_pkt * 8, 1);
denominator_fp = drm_fixp_mul(temp1_fp, temp2_fp);
numerator_fp = drm_fixp_from_fraction(intf_width * dsc->bpc * 3, 1);
numerator_fp = drm_fixp_from_fraction(
intf_width * dsc->config.bits_per_component * 3, 1);
dsc_byte_count_fp = drm_fixp_div(numerator_fp, denominator_fp);
dsc_byte_count = drm_fixp2int_ceil(dsc_byte_count_fp);
@@ -1445,169 +1275,6 @@ static void dp_panel_dsc_pclk_param_calc(struct dp_panel *dp_panel,
_dp_panel_dsc_bw_overhead_calc(dp_panel, dsc, dp_mode, dsc_byte_count);
}
static void dp_panel_dsc_populate_static_params(
struct msm_display_dsc_info *dsc, struct dp_panel *panel)
{
int bpp, bpc;
int mux_words_size;
int groups_per_line, groups_total;
int min_rate_buffer_size;
int hrd_delay;
int pre_num_extra_mux_bits, num_extra_mux_bits;
int slice_bits;
int data;
int final_value, final_scale;
int ratio_index, mod_offset;
int line_buf_depth_raw, line_buf_depth;
dsc->version = 0x11;
dsc->scr_rev = 0;
dsc->rc_model_size = 8192;
if (dsc->version == 0x11 && dsc->scr_rev == 0x1)
dsc->first_line_bpg_offset = 15;
else
dsc->first_line_bpg_offset = 12;
dsc->edge_factor = 6;
dsc->tgt_offset_hi = 3;
dsc->tgt_offset_lo = 3;
dsc->enable_422 = 0;
dsc->convert_rgb = 1;
dsc->vbr_enable = 0;
dsc->buf_thresh = dp_dsc_rc_buf_thresh;
bpp = dsc->bpp;
bpc = dsc->bpc;
if (bpc == 12 && bpp == 8)
ratio_index = DSC_12BPC_8BPP;
else if (bpc == 10 && bpp == 8)
ratio_index = DSC_10BPC_8BPP;
else if (bpc == 10 && bpp == 10)
ratio_index = DSC_10BPC_10BPP;
else
ratio_index = DSC_8BPC_8BPP;
if (dsc->version == 0x11 && dsc->scr_rev == 0x1) {
dsc->range_min_qp =
dp_dsc_rc_range_min_qp_1_1_scr1[ratio_index];
dsc->range_max_qp =
dp_dsc_rc_range_max_qp_1_1_scr1[ratio_index];
} else {
dsc->range_min_qp = dp_dsc_rc_range_min_qp_1_1[ratio_index];
dsc->range_max_qp = dp_dsc_rc_range_max_qp_1_1[ratio_index];
}
dsc->range_bpg_offset = dp_dsc_rc_range_bpg_offset;
if (bpp == 8) {
dsc->initial_offset = 6144;
dsc->initial_xmit_delay = 512;
} else if (bpp == 10) {
dsc->initial_offset = 5632;
dsc->initial_xmit_delay = 410;
} else {
dsc->initial_offset = 2048;
dsc->initial_xmit_delay = 341;
}
line_buf_depth_raw = panel->dsc_dpcd[5] & 0x0f;
line_buf_depth = (line_buf_depth_raw == 8) ? 8 :
(line_buf_depth_raw + 9);
dsc->line_buf_depth = min(line_buf_depth, dsc->bpc + 1);
if (bpc == 8) {
dsc->input_10_bits = 0;
dsc->min_qp_flatness = 3;
dsc->max_qp_flatness = 12;
dsc->quant_incr_limit0 = 11;
dsc->quant_incr_limit1 = 11;
mux_words_size = 48;
} else if (bpc == 10) { /* 10bpc */
dsc->input_10_bits = 1;
dsc->min_qp_flatness = 7;
dsc->max_qp_flatness = 16;
dsc->quant_incr_limit0 = 15;
dsc->quant_incr_limit1 = 15;
mux_words_size = 48;
} else { /* 12 bpc */
dsc->input_10_bits = 0;
dsc->min_qp_flatness = 11;
dsc->max_qp_flatness = 20;
dsc->quant_incr_limit0 = 19;
dsc->quant_incr_limit1 = 19;
mux_words_size = 64;
}
mod_offset = dsc->slice_width % 3;
switch (mod_offset) {
case 0:
dsc->slice_last_group_size = 2;
break;
case 1:
dsc->slice_last_group_size = 0;
break;
case 2:
dsc->slice_last_group_size = 1;
break;
default:
break;
}
dsc->det_thresh_flatness = 2 << (bpc - 8);
groups_per_line = DIV_ROUND_UP(dsc->slice_width, 3);
dsc->chunk_size = dsc->slice_width * bpp / 8;
if ((dsc->slice_width * bpp) % 8)
dsc->chunk_size++;
/* rbs-min */
min_rate_buffer_size = dsc->rc_model_size - dsc->initial_offset +
dsc->initial_xmit_delay * bpp +
groups_per_line * dsc->first_line_bpg_offset;
hrd_delay = DIV_ROUND_UP(min_rate_buffer_size, bpp);
dsc->initial_dec_delay = hrd_delay - dsc->initial_xmit_delay;
dsc->initial_scale_value = 8 * dsc->rc_model_size /
(dsc->rc_model_size - dsc->initial_offset);
slice_bits = 8 * dsc->chunk_size * dsc->slice_height;
groups_total = groups_per_line * dsc->slice_height;
data = dsc->first_line_bpg_offset * 2048;
dsc->nfl_bpg_offset = DIV_ROUND_UP(data, (dsc->slice_height - 1));
pre_num_extra_mux_bits = 3 * (mux_words_size + (4 * bpc + 4) - 2);
num_extra_mux_bits = pre_num_extra_mux_bits - (mux_words_size -
((slice_bits - pre_num_extra_mux_bits) % mux_words_size));
data = 2048 * (dsc->rc_model_size - dsc->initial_offset
+ num_extra_mux_bits);
dsc->slice_bpg_offset = DIV_ROUND_UP(data, groups_total);
data = dsc->initial_xmit_delay * bpp;
final_value = dsc->rc_model_size - data + num_extra_mux_bits;
final_scale = 8 * dsc->rc_model_size /
(dsc->rc_model_size - final_value);
dsc->final_offset = final_value;
data = (final_scale - 9) * (dsc->nfl_bpg_offset +
dsc->slice_bpg_offset);
dsc->scale_increment_interval = (2048 * dsc->final_offset) / data;
dsc->scale_decrement_interval = groups_per_line /
(dsc->initial_scale_value - 8);
}
struct dp_dsc_slices_per_line {
u32 min_ppr;
u32 max_ppr;
@@ -1711,6 +1378,10 @@ static int dp_panel_dsc_prepare_basic_params(
u32 slice_caps_1;
u32 slice_caps_2;
comp_info->dsc_info.config.dsc_version_major = 0x1;
comp_info->dsc_info.config.dsc_version_minor = 0x1;
comp_info->dsc_info.scr_rev = 0x0;
comp_info->dsc_info.slice_per_pkt = 0;
for (i = 0; i < ARRAY_SIZE(slice_per_line_tbl); i++) {
rec = &slice_per_line_tbl[i];
@@ -1764,27 +1435,25 @@ static int dp_panel_dsc_prepare_basic_params(
i++;
}
comp_info->dsc_info.block_pred_enable =
comp_info->dsc_info.config.block_pred_enable =
dp_panel->sink_dsc_caps.block_pred_en;
comp_info->dsc_info.vbr_enable = 0;
comp_info->dsc_info.enable_422 = 0;
comp_info->dsc_info.convert_rgb = 1;
comp_info->dsc_info.input_10_bits = 0;
comp_info->dsc_info.pic_width = dp_mode->timing.h_active;
comp_info->dsc_info.pic_height = dp_mode->timing.v_active;
comp_info->dsc_info.slice_width = slice_width;
comp_info->dsc_info.config.pic_width = dp_mode->timing.h_active;
comp_info->dsc_info.config.pic_height = dp_mode->timing.v_active;
comp_info->dsc_info.config.slice_width = slice_width;
if (comp_info->dsc_info.pic_height % 16 == 0)
comp_info->dsc_info.slice_height = 16;
else if (comp_info->dsc_info.pic_height % 12 == 0)
comp_info->dsc_info.slice_height = 12;
if (comp_info->dsc_info.config.pic_height % 16 == 0)
comp_info->dsc_info.config.slice_height = 16;
else if (comp_info->dsc_info.config.pic_height % 12 == 0)
comp_info->dsc_info.config.slice_height = 12;
else
comp_info->dsc_info.slice_height = 15;
comp_info->dsc_info.config.slice_height = 15;
comp_info->dsc_info.bpc = dp_mode->timing.bpp / 3;
comp_info->dsc_info.bpp = comp_info->dsc_info.bpc;
comp_info->dsc_info.full_frame_slices =
comp_info->dsc_info.config.bits_per_component =
(dp_mode->timing.bpp / 3);
comp_info->dsc_info.config.bits_per_pixel =
comp_info->dsc_info.config.bits_per_component << 4;
comp_info->dsc_info.config.slice_count =
DIV_ROUND_UP(dp_mode->timing.h_active, slice_width);
comp_info->comp_type = MSM_DISPLAY_COMPRESSION_DSC;
@@ -2508,7 +2177,7 @@ static void dp_panel_config_dsc(struct dp_panel *dp_panel, bool enable)
struct dp_panel_info *pinfo;
struct msm_compression_info *comp_info;
struct dp_dsc_cfg_data *dsc;
int pps_len;
int rc;
panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
@@ -2518,9 +2187,13 @@ static void dp_panel_config_dsc(struct dp_panel *dp_panel, bool enable)
comp_info = &pinfo->comp_info;
if (comp_info->comp_type == MSM_DISPLAY_COMPRESSION_DSC && enable) {
pps_len = dp_panel_dsc_create_pps_buf_cmd(&comp_info->dsc_info,
dsc->pps, 0);
dsc->pps_len = pps_len;
rc = sde_dsc_create_pps_buf_cmd(&comp_info->dsc_info,
dsc->pps, 0, sizeof(dsc->pps));
if (rc) {
DP_ERR("failed to create pps cmd %d\n", rc);
return;
}
dsc->pps_len = DSC_1_1_PPS_PARAMETER_SET_ELEMENTS;
dp_panel_dsc_prepare_pps_packet(dp_panel);
dsc->slice_per_pkt = comp_info->dsc_info.slice_per_pkt - 1;
@@ -3245,6 +2918,7 @@ static void dp_panel_convert_to_dp_mode(struct dp_panel *dp_panel,
struct msm_compression_info *comp_info;
bool dsc_cap = (dp_mode->capabilities & DP_PANEL_CAPS_DSC) ?
true : false;
int rc;
dp_mode->timing.h_active = drm_mode->hdisplay;
dp_mode->timing.h_back_porch = drm_mode->htotal - drm_mode->hsync_end;
@@ -3292,8 +2966,19 @@ static void dp_panel_convert_to_dp_mode(struct dp_panel *dp_panel,
return;
}
dp_panel_dsc_populate_static_params(&comp_info->dsc_info,
dp_panel);
rc = sde_dsc_populate_dsc_config(&comp_info->dsc_info.config, 0);
if (rc) {
DP_DEBUG("failed populating dsc params \n");
return;
}
rc = sde_dsc_populate_dsc_private_params(&comp_info->dsc_info,
dp_mode->timing.h_active);
if (rc) {
DP_DEBUG("failed populating other dsc params\n");
return;
}
dp_panel_dsc_pclk_param_calc(dp_panel,
&comp_info->dsc_info,
comp_info->comp_ratio,