514 lines
15 KiB
C
514 lines
15 KiB
C
/* Copyright (c) 2015, The Linux Foundation. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of The Linux Foundation nor
|
|
* the names of its contributors may be used to endorse or promote
|
|
* products derived from this software without specific prior written
|
|
* permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
|
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
|
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
|
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <debug.h>
|
|
#include <mdp5.h>
|
|
#include <reg.h>
|
|
#include <bits.h>
|
|
#include <msm_panel.h>
|
|
#include <panel.h>
|
|
#include <platform/iomap.h>
|
|
#include <mipi_dsi.h>
|
|
|
|
/*
|
|
* rc_buf_thresh = {896, 1792, 2688, 3548, 4480, 5376, 6272, 6720,
|
|
* 7168, 7616, 7744, 7872, 8000, 8064, 8192};
|
|
* (x >> 6) & 0x0ff)
|
|
*/
|
|
static char dsc_rc_buf_thresh[] = {0x0e, 0x1c, 0x2a, 0x38, 0x46, 0x54,
|
|
0x62, 0x69, 0x70, 0x77, 0x79, 0x7b, 0x7d, 0x7e};
|
|
static char dsc_rc_range_min_qp[] = {0, 0, 1, 1, 3, 3, 3, 3, 3, 3, 5,
|
|
5, 5, 7, 13};
|
|
static char dsc_rc_range_max_qp[] = {4, 4, 5, 6, 7, 7, 7, 8, 9, 10, 11,
|
|
12, 13, 13, 15};
|
|
static char dsc_rc_range_bpg_offset[] = {2, 0, 0, -2, -4, -6, -8, -8,
|
|
-8, -10, -10, -12, -12, -12, -12};
|
|
|
|
#define CEIL(x, y) (((x) + ((y)-1)) / (y))
|
|
|
|
int mdss_dsc_to_buf(struct msm_panel_info *pinfo)
|
|
{
|
|
struct dsc_desc *dsc;
|
|
char *bp;
|
|
char data;
|
|
int i, bpp;
|
|
|
|
dsc = &pinfo->dsc;
|
|
bp = dsc->pps_buf;
|
|
|
|
*bp++ = 128; /* pps length */
|
|
*bp++ = 0;
|
|
*bp++ = 0x0a; /* PPS data type */
|
|
*bp++ = 0xc0; /* last + long pkt */
|
|
|
|
/* pps payload */
|
|
*bp++ = ((dsc->major << 4) | dsc->minor); /* pps0 */
|
|
*bp++ = dsc->pps_id; /* pps1 */
|
|
bp++; /* pps2, reserved */
|
|
|
|
data = dsc->line_buf_depth & 0x0f;
|
|
data |= (dsc->bpc << 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 << 5);
|
|
data |= (dsc->convert_rgb << 4);
|
|
data |= (dsc->enable_422 << 3);
|
|
data |= (dsc->vbr_enable << 2);
|
|
*bp++ = data; /* pps4 */
|
|
*bp++ = bpp; /* pps5 */
|
|
|
|
*bp++ = (dsc->pic_height >> 8); /* pps6 */
|
|
*bp++ = (dsc->pic_height & 0x0ff); /* pps7 */
|
|
*bp++ = (dsc->pic_width >> 8); /* pps8 */
|
|
*bp++ = (dsc->pic_width & 0x0ff); /* pps9 */
|
|
|
|
*bp++ = (dsc->slice_height >> 8); /* pps10 */
|
|
*bp++ = (dsc->slice_height & 0x0ff); /* pps11 */
|
|
*bp++ = (dsc->slice_width >> 8); /* pps12 */
|
|
*bp++ = (dsc->slice_width & 0x0ff); /* pps13 */
|
|
|
|
*bp++ = (dsc->chunk_size >> 8); /* pps14 */
|
|
*bp++ = (dsc->chunk_size & 0x0ff); /* pps15 */
|
|
|
|
data = dsc->initial_xmit_delay >> 8;
|
|
data &= 0x03;
|
|
*bp++ = data; /* pps16, bit 0, 1 */
|
|
*bp++ = dsc->initial_xmit_delay; /* pps17 */
|
|
|
|
*bp++ = (dsc->initial_dec_delay >> 8); /* pps18 */
|
|
*bp++ = dsc->initial_dec_delay; /* pps19 */
|
|
|
|
bp++; /* pps20, reserved */
|
|
|
|
*bp++ = (dsc->initial_scale_value & 0x3f); /* pps21 */
|
|
|
|
data = (dsc->scale_increment_interval >> 8);
|
|
data &= 0x0f;
|
|
*bp++ = data; /* pps22 */
|
|
*bp++ = dsc->scale_increment_interval; /* pps23 */
|
|
|
|
data = (dsc->scale_decrement_interval >> 8);
|
|
data &= 0x0f;
|
|
*bp++ = data; /* 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); /* pps28 */
|
|
*bp++ = (dsc->nfl_bpg_offset & 0x0ff); /* pps29 */
|
|
*bp++ = (dsc->slice_bpg_offset >> 8); /* pps30 */
|
|
*bp++ = (dsc->slice_bpg_offset & 0x0ff);/* pps31 */
|
|
|
|
*bp++ = (dsc->initial_offset >> 8); /* pps32 */
|
|
*bp++ = (dsc->initial_offset & 0x0ff); /* pps33 */
|
|
|
|
*bp++ = (dsc->final_offset >> 8); /* 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); /* 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 << 4);
|
|
data |= (dsc->tgt_offset_lo & 0x0f);
|
|
*bp++ = data; /* pps43 */
|
|
|
|
for (i = 0; i < 14; i++)
|
|
*bp++ = dsc->buf_thresh[i]; /* pps44 - pps57 */
|
|
|
|
for (i = 0; i < 15; i++) { /* pps58 - pps87 */
|
|
data = (dsc->range_min_qp[i] & 0x1f); /* 5 bits */
|
|
data <<= 3;
|
|
data |= ((dsc->range_max_qp[i] >> 2) & 0x07); /* 3 bits */
|
|
*bp++ = data;
|
|
data = (dsc->range_max_qp[i] & 0x03); /* 2 bits */
|
|
data <<= 6;
|
|
data |= (dsc->range_bpg_offset[i] & 0x3f); /* 6 bits */
|
|
*bp++ = data;
|
|
}
|
|
|
|
/* pps88 to pps127 are reserved */
|
|
|
|
return 128;
|
|
}
|
|
|
|
static int mdss_dsc_initial_line_calc(int bpc, int xmit_delay,
|
|
int slice_width, int slice_per_line)
|
|
{
|
|
int ssm_delay;
|
|
int total_pixels;
|
|
|
|
ssm_delay = ((bpc < 10) ? 83 : 91);
|
|
total_pixels = ssm_delay * 3 + 30 + xmit_delay + 6;
|
|
total_pixels += ((slice_per_line > 1) ? (ssm_delay * 3) : 0);
|
|
|
|
return CEIL(total_pixels, slice_width);
|
|
}
|
|
|
|
void mdss_dsc_parameters_calc(struct msm_panel_info *pinfo)
|
|
{
|
|
struct dsc_desc *dsc;
|
|
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 target_bpp_x16;
|
|
int data;
|
|
int final_value, final_scale;
|
|
int slice_per_line, bytes_in_slice, total_bytes;
|
|
|
|
dsc = &pinfo->dsc;
|
|
dsc->rc_model_size = 8192; /* rate_buffer_size */
|
|
dsc->first_line_bpg_offset = 12;
|
|
dsc->min_qp_flatness = 3;
|
|
dsc->max_qp_flatness = 12;
|
|
dsc->line_buf_depth = 9;
|
|
|
|
dsc->edge_factor = 6;
|
|
dsc->quant_incr_limit0 = 11;
|
|
dsc->quant_incr_limit1 = 11;
|
|
dsc->tgt_offset_hi = 3;
|
|
dsc->tgt_offset_lo = 3;
|
|
|
|
dsc->buf_thresh = dsc_rc_buf_thresh;
|
|
dsc->range_min_qp = dsc_rc_range_min_qp;
|
|
dsc->range_max_qp = dsc_rc_range_max_qp;
|
|
dsc->range_bpg_offset = dsc_rc_range_bpg_offset;
|
|
|
|
dsc->pic_width = pinfo->xres;
|
|
dsc->pic_height = pinfo->yres;
|
|
|
|
bpp = dsc->bpp;
|
|
bpc = dsc->bpc;
|
|
|
|
if (bpp == 8)
|
|
dsc->initial_offset = 6144;
|
|
else
|
|
dsc->initial_offset = 2048; /* bpp = 12 */
|
|
|
|
if (bpc == 8)
|
|
mux_words_size = 48;
|
|
else
|
|
mux_words_size = 64; /* bpc == 12 */
|
|
|
|
slice_per_line = CEIL(dsc->pic_width, dsc->slice_width);
|
|
|
|
dsc->pkt_per_line = slice_per_line / dsc->slice_per_pkt;
|
|
if (slice_per_line % dsc->slice_per_pkt)
|
|
dsc->pkt_per_line = 1; /* default*/
|
|
|
|
bytes_in_slice = CEIL(dsc->pic_width, slice_per_line);
|
|
|
|
bytes_in_slice *= dsc->bpp; /* bites per compressed pixel */
|
|
bytes_in_slice = CEIL(bytes_in_slice, 8);
|
|
|
|
dsc->bytes_in_slice = bytes_in_slice;
|
|
|
|
dprintf(SPEW, "%s: slice_per_line=%d pkt_per_line=%d bytes_in_slice=%d\n",
|
|
__func__, slice_per_line, dsc->pkt_per_line, bytes_in_slice);
|
|
|
|
total_bytes = bytes_in_slice * slice_per_line;
|
|
dsc->eol_byte_num = total_bytes % 3;
|
|
dsc->pclk_per_line = CEIL(total_bytes, 3);
|
|
|
|
dsc->slice_last_group_size = 3 - dsc->eol_byte_num;
|
|
|
|
dprintf(SPEW, "%s: pclk_per_line=%d total_bytes=%d eol_byte_num=%d\n",
|
|
__func__, dsc->pclk_per_line, total_bytes, dsc->eol_byte_num);
|
|
|
|
dsc->bytes_per_pkt = bytes_in_slice * dsc->slice_per_pkt;
|
|
|
|
dsc->det_thresh_flatness = 7 + (bpc - 8);
|
|
|
|
dsc->initial_xmit_delay = dsc->rc_model_size / (2 * bpp);
|
|
|
|
dsc->initial_lines = mdss_dsc_initial_line_calc(bpc,
|
|
dsc->initial_xmit_delay, dsc->slice_width, slice_per_line);
|
|
|
|
groups_per_line = CEIL(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 = CEIL(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 = CEIL(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 = CEIL(data, groups_total);
|
|
|
|
/* bpp * 16 + 0.5 */
|
|
data = bpp * 16;
|
|
data *= 2;
|
|
data++;
|
|
data /= 2;
|
|
target_bpp_x16 = data;
|
|
|
|
data = (dsc->initial_xmit_delay * target_bpp_x16) / 16;
|
|
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);
|
|
|
|
dprintf(SPEW, "%s: initial_xmit_delay=%d\n", __func__,
|
|
dsc->initial_xmit_delay);
|
|
|
|
dprintf(SPEW, "%s: bpg_offset, nfl=%d slice=%d\n", __func__,
|
|
dsc->nfl_bpg_offset, dsc->slice_bpg_offset);
|
|
|
|
dprintf(SPEW, "%s: groups_per_line=%d chunk_size=%d\n", __func__,
|
|
groups_per_line, dsc->chunk_size);
|
|
dprintf(SPEW, "%s:min_rate_buffer_size=%d hrd_delay=%d\n", __func__,
|
|
min_rate_buffer_size, hrd_delay);
|
|
dprintf(SPEW, "%s:initial_dec_delay=%d initial_scale_value=%d\n", __func__,
|
|
dsc->initial_dec_delay, dsc->initial_scale_value);
|
|
dprintf(SPEW, "%s:slice_bits=%d, groups_total=%d\n", __func__,
|
|
slice_bits, groups_total);
|
|
dprintf(SPEW, "%s: first_line_bgp_offset=%d slice_height=%d\n", __func__,
|
|
dsc->first_line_bpg_offset, dsc->slice_height);
|
|
dprintf(SPEW, "%s:final_value=%d final_scale=%d\n", __func__,
|
|
final_value, final_scale);
|
|
dprintf(SPEW, "%s: sacle_increment_interval=%d scale_decrement_interval=%d\n",
|
|
__func__, dsc->scale_increment_interval,
|
|
dsc->scale_decrement_interval);
|
|
}
|
|
|
|
void mdss_dsc_mdp_config(struct msm_panel_info *pinfo)
|
|
{
|
|
unsigned int data;
|
|
unsigned int offset, off;
|
|
struct dsc_desc *dsc;
|
|
char *lp;
|
|
char *cp;
|
|
int i, bpp, lsb;
|
|
|
|
/* dce0_sel->pp0, dce1_sel->pp1 */
|
|
writel(0x0, MDSS_MDP_REG_DCE_SEL);
|
|
|
|
/* dsc enable */
|
|
writel(1, MDP_PP_0_BASE + MDSS_MDP_PP_DSC_MODE);
|
|
|
|
data = readl(MDP_PP_0_BASE + MDSS_MDP_PP_DCE_DATA_OUT_SWAP);
|
|
data |= BIT(18); /* endian flip */
|
|
writel(data, MDP_PP_0_BASE + MDSS_MDP_PP_DCE_DATA_OUT_SWAP);
|
|
|
|
offset = MDP_DSC_0_BASE;
|
|
|
|
data = 0;
|
|
dsc = &pinfo->dsc;
|
|
if (pinfo->type == MIPI_VIDEO_PANEL)
|
|
data = BIT(2); /* video mode */
|
|
|
|
writel(data, offset + MDSS_MDP_DSC_COMMON_MODE);
|
|
|
|
data = dsc->ich_reset_value | dsc->ich_reset_override;
|
|
data <<= 28;
|
|
data |= (dsc->initial_lines << 20);
|
|
data |= ((dsc->slice_last_group_size - 1) << 18);
|
|
|
|
/* bpp is 6.4 format, 4 LSBs bits are for fractional part */
|
|
lsb = dsc->bpp % 4;
|
|
bpp = dsc->bpp / 4;
|
|
bpp *= 4; /* either 8 or 12 */
|
|
bpp <<= 4;
|
|
bpp |= lsb;
|
|
data |= (bpp << 8);
|
|
data |= (dsc->block_pred_enable << 7);
|
|
data |= (dsc->line_buf_depth << 3);
|
|
data |= (dsc->enable_422 << 2);
|
|
data |= (dsc->convert_rgb << 1);
|
|
data |= dsc->input_10_bits;
|
|
|
|
dprintf(SPEW, "%s: %d %d %d %d %d %d %d %d %d %d, data=%x\n",
|
|
__func__, dsc->ich_reset_value, dsc->ich_reset_override,
|
|
dsc->initial_lines , dsc->slice_last_group_size,
|
|
dsc->bpp, dsc->block_pred_enable, dsc->line_buf_depth,
|
|
dsc->enable_422, dsc->convert_rgb, dsc->input_10_bits, data);
|
|
|
|
writel(data, offset + MDSS_MDP_DSC_ENC);
|
|
|
|
data = dsc->pic_width << 16;
|
|
data |= dsc->pic_height;
|
|
writel(data, offset + MDSS_MDP_DSC_PICTURE);
|
|
|
|
data = dsc->slice_width << 16;
|
|
data |= dsc->slice_height;
|
|
writel(data, offset + MDSS_MDP_DSC_SLICE);
|
|
|
|
data = dsc->chunk_size << 16;
|
|
writel(data, offset + MDSS_MDP_DSC_CHUNK_SIZE);
|
|
|
|
dprintf(SPEW, "%s: pic_w=%d pic_h=%d, slice_h=%d slice_w=%d, chunk=%d\n",
|
|
__func__, dsc->pic_width, dsc->pic_height,
|
|
dsc->slice_width, dsc->slice_height, dsc->chunk_size);
|
|
|
|
data = dsc->initial_dec_delay << 16;
|
|
data |= dsc->initial_xmit_delay;
|
|
writel(data, offset + MDSS_MDP_DSC_DELAY);
|
|
|
|
data = dsc->initial_scale_value;
|
|
writel(data, offset + MDSS_MDP_DSC_SCALE_INITIAL);
|
|
|
|
data = dsc->scale_decrement_interval;
|
|
writel(data, offset + MDSS_MDP_DSC_SCALE_DEC_INTERVAL);
|
|
|
|
data = dsc->scale_increment_interval;
|
|
writel(data, offset + MDSS_MDP_DSC_SCALE_INC_INTERVAL);
|
|
|
|
data = dsc->first_line_bpg_offset;
|
|
writel(data, offset + MDSS_MDP_DSC_FIRST_LINE_BPG_OFFSET);
|
|
|
|
data = dsc->nfl_bpg_offset << 16;
|
|
data |= dsc->slice_bpg_offset;
|
|
writel(data, offset + MDSS_MDP_DSC_BPG_OFFSET);
|
|
|
|
data = dsc->initial_offset << 16;
|
|
data |= dsc->final_offset;
|
|
writel(data, offset + MDSS_MDP_DSC_DSC_OFFSET);
|
|
|
|
data = dsc->det_thresh_flatness << 10;
|
|
data |= dsc->max_qp_flatness << 5;
|
|
data |= dsc->min_qp_flatness;
|
|
writel(data, offset + MDSS_MDP_DSC_FLATNESS);
|
|
|
|
data = dsc->rc_model_size; /* rate_buffer_size */
|
|
writel(data, offset + MDSS_MDP_DSC_RC_MODEL_SIZE);
|
|
|
|
data = dsc->tgt_offset_lo << 18;
|
|
data |= dsc->tgt_offset_hi << 14;
|
|
data |= dsc->quant_incr_limit1 << 9;
|
|
data |= dsc->quant_incr_limit0 << 4;
|
|
data |= dsc->edge_factor;
|
|
writel(data, offset + MDSS_MDP_DSC_RC);
|
|
|
|
lp = dsc->buf_thresh;
|
|
off = offset + MDSS_MDP_DSC_RC_BUF_THRESH;
|
|
for (i = 0; i < 14; i++) {
|
|
writel(*lp++, off);
|
|
off += 4;
|
|
}
|
|
|
|
cp = dsc->range_min_qp;
|
|
off = offset + MDSS_MDP_DSC_RANGE_MIN_QP;
|
|
for (i = 0; i < 15; i++) {
|
|
writel(*cp++, off);
|
|
off += 4;
|
|
}
|
|
|
|
cp = dsc->range_max_qp;
|
|
off = offset + MDSS_MDP_DSC_RANGE_MAX_QP;
|
|
for (i = 0; i < 15; i++) {
|
|
writel(*cp++, off);
|
|
off += 4;
|
|
}
|
|
|
|
cp = dsc->range_bpg_offset;
|
|
off = offset + MDSS_MDP_DSC_RANGE_BPG_OFFSET;
|
|
for (i = 0; i < 15; i++) {
|
|
writel(*cp++, off);
|
|
off += 4;
|
|
}
|
|
}
|
|
|
|
void mdss_dsc_dsi_config(uint32_t ctl_base, int mode,
|
|
struct dsc_desc *dsc)
|
|
{
|
|
unsigned int data;
|
|
|
|
if (mode == DSI_VIDEO_MODE) {
|
|
writel(0, ctl_base + VIDEO_COMPRESSION_MODE_CTRL_2);
|
|
data = dsc->bytes_per_pkt << 16;
|
|
data |= (0x0b << 8); /* dtype of compressed image */
|
|
data |= (dsc->pkt_per_line - 1) << 6;
|
|
data |= dsc->eol_byte_num << 4;
|
|
data |= 1; /* enable */
|
|
|
|
writel(data, ctl_base + VIDEO_COMPRESSION_MODE_CTRL);
|
|
} else {
|
|
/* strem 0 */
|
|
writel(0, ctl_base + CMD_COMPRESSION_MODE_CTRL_3);
|
|
|
|
data = dsc->bytes_in_slice;
|
|
writel(data, ctl_base + CMD_COMPRESSION_MODE_CTRL_2);
|
|
|
|
data = 0x39 << 8;
|
|
data |= (dsc->pkt_per_line - 1) << 6;
|
|
data |= dsc->eol_byte_num << 4;
|
|
data |= 1; /* enable */
|
|
writel(data, ctl_base + CMD_COMPRESSION_MODE_CTRL);
|
|
}
|
|
}
|