From: Ville Syrjälä <ville.syrj...@linux.intel.com>
Rename a bunch of the skl+ watermark struct members to
have sensible names. Avoids me having to think what
plane_res_b/etc. means.
Signed-off-by: Ville Syrjälä <ville.syrj...@linux.intel.com>
---
drivers/gpu/drm/i915/display/intel_display.c | 48 ++---
.../drm/i915/display/intel_display_types.h | 6 +-
drivers/gpu/drm/i915/intel_pm.c | 182 +++++++++---------
3 files changed, 116 insertions(+), 120 deletions(-)
diff --git a/drivers/gpu/drm/i915/display/intel_display.c
b/drivers/gpu/drm/i915/display/intel_display.c
index a6ba155ee8f3..6bb07a6b162b 100644
--- a/drivers/gpu/drm/i915/display/intel_display.c
+++ b/drivers/gpu/drm/i915/display/intel_display.c
@@ -14507,12 +14507,12 @@ static void verify_wm_state(struct intel_crtc *crtc,
drm_err(&dev_priv->drm,
"mismatch in WM pipe %c plane %d level %d
(expected e=%d b=%u l=%u, got e=%d b=%u l=%u)\n",
pipe_name(pipe), plane + 1, level,
- sw_plane_wm->wm[level].plane_en,
- sw_plane_wm->wm[level].plane_res_b,
- sw_plane_wm->wm[level].plane_res_l,
- hw_plane_wm->wm[level].plane_en,
- hw_plane_wm->wm[level].plane_res_b,
- hw_plane_wm->wm[level].plane_res_l);
+ sw_plane_wm->wm[level].enable,
+ sw_plane_wm->wm[level].blocks,
+ sw_plane_wm->wm[level].lines,
+ hw_plane_wm->wm[level].enable,
+ hw_plane_wm->wm[level].blocks,
+ hw_plane_wm->wm[level].lines);
}
if (!skl_wm_level_equals(&hw_plane_wm->trans_wm,
@@ -14520,12 +14520,12 @@ static void verify_wm_state(struct intel_crtc *crtc,
drm_err(&dev_priv->drm,
"mismatch in trans WM pipe %c plane %d
(expected e=%d b=%u l=%u, got e=%d b=%u l=%u)\n",
pipe_name(pipe), plane + 1,
- sw_plane_wm->trans_wm.plane_en,
- sw_plane_wm->trans_wm.plane_res_b,
- sw_plane_wm->trans_wm.plane_res_l,
- hw_plane_wm->trans_wm.plane_en,
- hw_plane_wm->trans_wm.plane_res_b,
- hw_plane_wm->trans_wm.plane_res_l);
+ sw_plane_wm->trans_wm.enable,
+ sw_plane_wm->trans_wm.blocks,
+ sw_plane_wm->trans_wm.lines,
+ hw_plane_wm->trans_wm.enable,
+ hw_plane_wm->trans_wm.blocks,
+ hw_plane_wm->trans_wm.lines);
}
/* DDB */
@@ -14564,12 +14564,12 @@ static void verify_wm_state(struct intel_crtc *crtc,
drm_err(&dev_priv->drm,
"mismatch in WM pipe %c cursor level %d
(expected e=%d b=%u l=%u, got e=%d b=%u l=%u)\n",
pipe_name(pipe), level,
- sw_plane_wm->wm[level].plane_en,
- sw_plane_wm->wm[level].plane_res_b,
- sw_plane_wm->wm[level].plane_res_l,
- hw_plane_wm->wm[level].plane_en,
- hw_plane_wm->wm[level].plane_res_b,
- hw_plane_wm->wm[level].plane_res_l);
+ sw_plane_wm->wm[level].enable,
+ sw_plane_wm->wm[level].blocks,
+ sw_plane_wm->wm[level].lines,
+ hw_plane_wm->wm[level].enable,
+ hw_plane_wm->wm[level].blocks,
+ hw_plane_wm->wm[level].lines);
}
if (!skl_wm_level_equals(&hw_plane_wm->trans_wm,
@@ -14577,12 +14577,12 @@ static void verify_wm_state(struct intel_crtc *crtc,
drm_err(&dev_priv->drm,
"mismatch in trans WM pipe %c cursor (expected
e=%d b=%u l=%u, got e=%d b=%u l=%u)\n",
pipe_name(pipe),
- sw_plane_wm->trans_wm.plane_en,
- sw_plane_wm->trans_wm.plane_res_b,
- sw_plane_wm->trans_wm.plane_res_l,
- hw_plane_wm->trans_wm.plane_en,
- hw_plane_wm->trans_wm.plane_res_b,
- hw_plane_wm->trans_wm.plane_res_l);
+ sw_plane_wm->trans_wm.enable,
+ sw_plane_wm->trans_wm.blocks,
+ sw_plane_wm->trans_wm.lines,
+ hw_plane_wm->trans_wm.enable,
+ hw_plane_wm->trans_wm.blocks,
+ hw_plane_wm->trans_wm.lines);
}
/* DDB */
diff --git a/drivers/gpu/drm/i915/display/intel_display_types.h
b/drivers/gpu/drm/i915/display/intel_display_types.h
index d3ab75b9442f..cf0808c147f5 100644
--- a/drivers/gpu/drm/i915/display/intel_display_types.h
+++ b/drivers/gpu/drm/i915/display/intel_display_types.h
@@ -682,9 +682,9 @@ struct intel_pipe_wm {
struct skl_wm_level {
u16 min_ddb_alloc;
- u16 plane_res_b;
- u8 plane_res_l;
- bool plane_en;
+ u16 blocks;
+ u8 lines;
+ bool enable;
bool ignore_lines;
bool can_sagv;
};
diff --git a/drivers/gpu/drm/i915/intel_pm.c b/drivers/gpu/drm/i915/intel_pm.c
index 30f2de715398..cc330c9a3573 100644
--- a/drivers/gpu/drm/i915/intel_pm.c
+++ b/drivers/gpu/drm/i915/intel_pm.c
@@ -3891,12 +3891,12 @@ static bool skl_crtc_can_enable_sagv(const struct
intel_crtc_state *crtc_state)
int level;
/* Skip this plane if it's not enabled */
- if (!wm->wm[0].plane_en)
+ if (!wm->wm[0].enable)
continue;
/* Find the highest enabled wm level for this plane */
for (level = ilk_wm_max_level(dev_priv);
- !wm->wm[level].plane_en; --level)
+ !wm->wm[level].enable; --level)
{ }
/*
@@ -4835,9 +4835,9 @@ skl_allocate_pipe_ddb(struct intel_atomic_state *state,
* Underruns with WM1+ disabled
*/
if (IS_GEN(dev_priv, 11) &&
- level == 1 && wm->wm[0].plane_en) {
- wm->wm[level].plane_res_b =
wm->wm[0].plane_res_b;
- wm->wm[level].plane_res_l =
wm->wm[0].plane_res_l;
+ level == 1 && wm->wm[0].enable) {
+ wm->wm[level].blocks = wm->wm[0].blocks;
+ wm->wm[level].lines = wm->wm[0].lines;
wm->wm[level].ignore_lines =
wm->wm[0].ignore_lines;
}
}
@@ -4857,13 +4857,13 @@ skl_allocate_pipe_ddb(struct intel_atomic_state *state,
if (INTEL_GEN(dev_priv) < 11 &&
crtc_state->nv12_planes & BIT(plane_id)) {
- if (wm->trans_wm.plane_res_b >=
skl_ddb_entry_size(ddb_y))
+ if (wm->trans_wm.blocks >= skl_ddb_entry_size(ddb_y))
memset(&wm->trans_wm, 0, sizeof(wm->trans_wm));
} else {
WARN_ON(skl_ddb_entry_size(ddb_y));
WARN_ON(wm->uv_wm[level].min_ddb_alloc);
- if (wm->trans_wm.plane_res_b >= skl_ddb_entry_size(ddb))
+ if (wm->trans_wm.blocks >= skl_ddb_entry_size(ddb))
memset(&wm->trans_wm, 0, sizeof(wm->trans_wm));
}
}
@@ -5070,7 +5070,7 @@ static void skl_compute_plane_wm(const struct
intel_crtc_state *crtc_state,
struct drm_i915_private *dev_priv = to_i915(crtc_state->uapi.crtc->dev);
uint_fixed_16_16_t method1, method2;
uint_fixed_16_16_t selected_result;
- u32 res_blocks, res_lines, min_ddb_alloc = 0;
+ u32 blocks, lines, min_ddb_alloc = 0;
if (latency == 0) {
/* reject it */
@@ -5116,24 +5116,22 @@ static void skl_compute_plane_wm(const struct
intel_crtc_state *crtc_state,
}
}
- res_blocks = fixed16_to_u32_round_up(selected_result) + 1;
- res_lines = div_round_up_fixed16(selected_result,
- wp->plane_blocks_per_line);
+ blocks = fixed16_to_u32_round_up(selected_result) + 1;
+ lines = div_round_up_fixed16(selected_result,
+ wp->plane_blocks_per_line);
if (IS_GEN9_BC(dev_priv) || IS_BROXTON(dev_priv)) {
/* Display WA #1125: skl,bxt,kbl */
if (level == 0 && wp->rc_surface)
- res_blocks +=
- fixed16_to_u32_round_up(wp->y_tile_minimum);
+ blocks += fixed16_to_u32_round_up(wp->y_tile_minimum);
/* Display WA #1126: skl,bxt,kbl */
if (level >= 1 && level <= 7) {
if (wp->y_tiled) {
- res_blocks +=
- fixed16_to_u32_round_up(wp->y_tile_minimum);
- res_lines += wp->y_min_scanlines;
+ blocks +=
fixed16_to_u32_round_up(wp->y_tile_minimum);
+ lines += wp->y_min_scanlines;
} else {
- res_blocks++;
+ blocks++;
}
/*
@@ -5142,8 +5140,8 @@ static void skl_compute_plane_wm(const struct
intel_crtc_state *crtc_state,
* Assumption in DDB algorithm optimization for special
* cases. Also covers Display WA #1125 for RC.
*/
- if (result_prev->plane_res_b > res_blocks)
- res_blocks = result_prev->plane_res_b;
+ if (result_prev->blocks > blocks)
+ blocks = result_prev->blocks;
}
}
@@ -5151,40 +5149,39 @@ static void skl_compute_plane_wm(const struct
intel_crtc_state *crtc_state,
if (wp->y_tiled) {
int extra_lines;
- if (res_lines % wp->y_min_scanlines == 0)
+ if (lines % wp->y_min_scanlines == 0)
extra_lines = wp->y_min_scanlines;
else
extra_lines = wp->y_min_scanlines * 2 -
- res_lines % wp->y_min_scanlines;
+ lines % wp->y_min_scanlines;
- min_ddb_alloc = mul_round_up_u32_fixed16(res_lines +
extra_lines,
+ min_ddb_alloc = mul_round_up_u32_fixed16(lines +
extra_lines,
wp->plane_blocks_per_line);
} else {
- min_ddb_alloc = res_blocks +
- DIV_ROUND_UP(res_blocks, 10);
+ min_ddb_alloc = blocks + DIV_ROUND_UP(blocks, 10);
}
}
if (!skl_wm_has_lines(dev_priv, level))
- res_lines = 0;
+ lines = 0;
- if (res_lines > 31) {
+ if (lines > 31) {
/* reject it */
result->min_ddb_alloc = U16_MAX;
return;
}
/*
- * If res_lines is valid, assume we can use this watermark level
+ * If lines is valid, assume we can use this watermark level
* for now. We'll come back and disable it after we calculate the
* DDB allocation if it turns out we don't actually have enough
* blocks to satisfy it.
*/
- result->plane_res_b = res_blocks;
- result->plane_res_l = res_lines;
+ result->blocks = blocks;
+ result->lines = lines;
/* Bspec says: value >= plane ddb allocation -> invalid, hence the +1
here */
- result->min_ddb_alloc = max(min_ddb_alloc, res_blocks) + 1;
- result->plane_en = true;
+ result->min_ddb_alloc = max(min_ddb_alloc, blocks) + 1;
+ result->enable = true;
if (INTEL_GEN(dev_priv) < 12)
result->can_sagv = latency >= dev_priv->sagv_block_time_us;
@@ -5231,7 +5228,7 @@ static void skl_compute_transition_wm(const struct
intel_crtc_state *crtc_state,
struct drm_device *dev = crtc_state->uapi.crtc->dev;
const struct drm_i915_private *dev_priv = to_i915(dev);
u16 trans_min, trans_amount, trans_y_tile_min;
- u16 wm0_sel_res_b, trans_offset_b, res_blocks;
+ u16 wm0_blocks, trans_offset, blocks;
/* Transition WM don't make any sense if ipc is disabled */
if (!dev_priv->ipc_enabled)
@@ -5255,27 +5252,26 @@ static void skl_compute_transition_wm(const struct
intel_crtc_state *crtc_state,
else
trans_amount = 10; /* This is configurable amount */
- trans_offset_b = trans_min + trans_amount;
+ trans_offset = trans_min + trans_amount;
/*
* The spec asks for Selected Result Blocks for wm0 (the real value),
* not Result Blocks (the integer value). Pay attention to the capital
- * letters. The value wm_l0->plane_res_b is actually Result Blocks, but
+ * letters. The value wm_l0->blocks is actually Result Blocks, but
* since Result Blocks is the ceiling of Selected Result Blocks plus 1,
* and since we later will have to get the ceiling of the sum in the
* transition watermarks calculation, we can just pretend Selected
* Result Blocks is Result Blocks minus 1 and it should work for the
* current platforms.
*/
- wm0_sel_res_b = wm->wm[0].plane_res_b - 1;
+ wm0_blocks = wm->wm[0].blocks - 1;
if (wp->y_tiled) {
trans_y_tile_min =
(u16)mul_round_up_u32_fixed16(2, wp->y_tile_minimum);
- res_blocks = max(wm0_sel_res_b, trans_y_tile_min) +
- trans_offset_b;
+ blocks = max(wm0_blocks, trans_y_tile_min) + trans_offset;
} else {
- res_blocks = wm0_sel_res_b + trans_offset_b;
+ blocks = wm0_blocks + trans_offset;
}
/*
@@ -5283,8 +5279,8 @@ static void skl_compute_transition_wm(const struct
intel_crtc_state *crtc_state,
* computing the DDB we'll come back and disable it if that
* assumption turns out to be false.
*/
- wm->trans_wm.plane_res_b = res_blocks + 1;
- wm->trans_wm.plane_en = true;
+ wm->trans_wm.blocks = blocks + 1;
+ wm->trans_wm.enable = true;
}
static int skl_build_plane_wm_single(struct intel_crtc_state *crtc_state,
@@ -5454,12 +5450,12 @@ static void skl_write_wm_level(struct drm_i915_private
*dev_priv,
{
u32 val = 0;
- if (level->plane_en)
+ if (level->enable)
val |= PLANE_WM_EN;
if (level->ignore_lines)
val |= PLANE_WM_IGNORE_LINES;
- val |= level->plane_res_b;
- val |= level->plane_res_l << PLANE_WM_LINES_SHIFT;
+ val |= level->blocks;
+ val |= level->lines << PLANE_WM_LINES_SHIFT;
intel_de_write_fw(dev_priv, reg, val);
}
@@ -5527,10 +5523,10 @@ void skl_write_cursor_wm(struct intel_plane *plane,
bool skl_wm_level_equals(const struct skl_wm_level *l1,
const struct skl_wm_level *l2)
{
- return l1->plane_en == l2->plane_en &&
+ return l1->enable == l2->enable &&
l1->ignore_lines == l2->ignore_lines &&
- l1->plane_res_l == l2->plane_res_l &&
- l1->plane_res_b == l2->plane_res_b;
+ l1->lines == l2->lines &&
+ l1->blocks == l2->blocks;
}
static bool skl_plane_wm_equals(struct drm_i915_private *dev_priv,
@@ -5695,61 +5691,61 @@ skl_print_wm_changes(struct intel_atomic_state *state)
"[PLANE:%d:%s] level
%cwm0,%cwm1,%cwm2,%cwm3,%cwm4,%cwm5,%cwm6,%cwm7,%ctwm,%cswm"
" ->
%cwm0,%cwm1,%cwm2,%cwm3,%cwm4,%cwm5,%cwm6,%cwm7,%ctwm,%cswm\n",
plane->base.base.id, plane->base.name,
- enast(old_wm->wm[0].plane_en),
enast(old_wm->wm[1].plane_en),
- enast(old_wm->wm[2].plane_en),
enast(old_wm->wm[3].plane_en),
- enast(old_wm->wm[4].plane_en),
enast(old_wm->wm[5].plane_en),
- enast(old_wm->wm[6].plane_en),
enast(old_wm->wm[7].plane_en),
- enast(old_wm->trans_wm.plane_en),
- enast(old_wm->sagv_wm0.plane_en),
- enast(new_wm->wm[0].plane_en),
enast(new_wm->wm[1].plane_en),
- enast(new_wm->wm[2].plane_en),
enast(new_wm->wm[3].plane_en),
- enast(new_wm->wm[4].plane_en),
enast(new_wm->wm[5].plane_en),
- enast(new_wm->wm[6].plane_en),
enast(new_wm->wm[7].plane_en),
- enast(new_wm->trans_wm.plane_en),
- enast(new_wm->sagv_wm0.plane_en));
+ enast(old_wm->wm[0].enable),
enast(old_wm->wm[1].enable),
+ enast(old_wm->wm[2].enable),
enast(old_wm->wm[3].enable),
+ enast(old_wm->wm[4].enable),
enast(old_wm->wm[5].enable),
+ enast(old_wm->wm[6].enable),
enast(old_wm->wm[7].enable),
+ enast(old_wm->trans_wm.enable),
+ enast(old_wm->sagv_wm0.enable),
+ enast(new_wm->wm[0].enable),
enast(new_wm->wm[1].enable),
+ enast(new_wm->wm[2].enable),
enast(new_wm->wm[3].enable),
+ enast(new_wm->wm[4].enable),
enast(new_wm->wm[5].enable),
+ enast(new_wm->wm[6].enable),
enast(new_wm->wm[7].enable),
+ enast(new_wm->trans_wm.enable),
+ enast(new_wm->sagv_wm0.enable));
drm_dbg_kms(&dev_priv->drm,
"[PLANE:%d:%s] lines
%c%3d,%c%3d,%c%3d,%c%3d,%c%3d,%c%3d,%c%3d,%c%3d,%c%3d,%c%3d"
" ->
%c%3d,%c%3d,%c%3d,%c%3d,%c%3d,%c%3d,%c%3d,%c%3d,%c%3d,%c%3d\n",
plane->base.base.id, plane->base.name,
- enast(old_wm->wm[0].ignore_lines),
old_wm->wm[0].plane_res_l,
- enast(old_wm->wm[1].ignore_lines),
old_wm->wm[1].plane_res_l,
- enast(old_wm->wm[2].ignore_lines),
old_wm->wm[2].plane_res_l,
- enast(old_wm->wm[3].ignore_lines),
old_wm->wm[3].plane_res_l,
- enast(old_wm->wm[4].ignore_lines),
old_wm->wm[4].plane_res_l,
- enast(old_wm->wm[5].ignore_lines),
old_wm->wm[5].plane_res_l,
- enast(old_wm->wm[6].ignore_lines),
old_wm->wm[6].plane_res_l,
- enast(old_wm->wm[7].ignore_lines),
old_wm->wm[7].plane_res_l,
- enast(old_wm->trans_wm.ignore_lines),
old_wm->trans_wm.plane_res_l,
- enast(old_wm->sagv_wm0.ignore_lines),
old_wm->sagv_wm0.plane_res_l,
+ enast(old_wm->wm[0].ignore_lines),
old_wm->wm[0].lines,
+ enast(old_wm->wm[1].ignore_lines),
old_wm->wm[1].lines,
+ enast(old_wm->wm[2].ignore_lines),
old_wm->wm[2].lines,
+ enast(old_wm->wm[3].ignore_lines),
old_wm->wm[3].lines,
+ enast(old_wm->wm[4].ignore_lines),
old_wm->wm[4].lines,
+ enast(old_wm->wm[5].ignore_lines),
old_wm->wm[5].lines,
+ enast(old_wm->wm[6].ignore_lines),
old_wm->wm[6].lines,
+ enast(old_wm->wm[7].ignore_lines),
old_wm->wm[7].lines,
+ enast(old_wm->trans_wm.ignore_lines),
old_wm->trans_wm.lines,
+ enast(old_wm->sagv_wm0.ignore_lines),
old_wm->sagv_wm0.lines,
- enast(new_wm->wm[0].ignore_lines),
new_wm->wm[0].plane_res_l,
- enast(new_wm->wm[1].ignore_lines),
new_wm->wm[1].plane_res_l,
- enast(new_wm->wm[2].ignore_lines),
new_wm->wm[2].plane_res_l,
- enast(new_wm->wm[3].ignore_lines),
new_wm->wm[3].plane_res_l,
- enast(new_wm->wm[4].ignore_lines),
new_wm->wm[4].plane_res_l,
- enast(new_wm->wm[5].ignore_lines),
new_wm->wm[5].plane_res_l,
- enast(new_wm->wm[6].ignore_lines),
new_wm->wm[6].plane_res_l,
- enast(new_wm->wm[7].ignore_lines),
new_wm->wm[7].plane_res_l,
- enast(new_wm->trans_wm.ignore_lines),
new_wm->trans_wm.plane_res_l,
- enast(new_wm->sagv_wm0.ignore_lines),
new_wm->sagv_wm0.plane_res_l);
+ enast(new_wm->wm[0].ignore_lines),
new_wm->wm[0].lines,
+ enast(new_wm->wm[1].ignore_lines),
new_wm->wm[1].lines,
+ enast(new_wm->wm[2].ignore_lines),
new_wm->wm[2].lines,
+ enast(new_wm->wm[3].ignore_lines),
new_wm->wm[3].lines,
+ enast(new_wm->wm[4].ignore_lines),
new_wm->wm[4].lines,
+ enast(new_wm->wm[5].ignore_lines),
new_wm->wm[5].lines,
+ enast(new_wm->wm[6].ignore_lines),
new_wm->wm[6].lines,
+ enast(new_wm->wm[7].ignore_lines),
new_wm->wm[7].lines,
+ enast(new_wm->trans_wm.ignore_lines),
new_wm->trans_wm.lines,
+ enast(new_wm->sagv_wm0.ignore_lines),
new_wm->sagv_wm0.lines);
drm_dbg_kms(&dev_priv->drm,
"[PLANE:%d:%s] blocks
%4d,%4d,%4d,%4d,%4d,%4d,%4d,%4d,%4d,%4d"
" ->
%4d,%4d,%4d,%4d,%4d,%4d,%4d,%4d,%4d,%4d\n",
plane->base.base.id, plane->base.name,
- old_wm->wm[0].plane_res_b,
old_wm->wm[1].plane_res_b,
- old_wm->wm[2].plane_res_b,
old_wm->wm[3].plane_res_b,
- old_wm->wm[4].plane_res_b,
old_wm->wm[5].plane_res_b,
- old_wm->wm[6].plane_res_b,
old_wm->wm[7].plane_res_b,
- old_wm->trans_wm.plane_res_b,
- old_wm->sagv_wm0.plane_res_b,
- new_wm->wm[0].plane_res_b,
new_wm->wm[1].plane_res_b,
- new_wm->wm[2].plane_res_b,
new_wm->wm[3].plane_res_b,
- new_wm->wm[4].plane_res_b,
new_wm->wm[5].plane_res_b,
- new_wm->wm[6].plane_res_b,
new_wm->wm[7].plane_res_b,
- new_wm->trans_wm.plane_res_b,
- new_wm->sagv_wm0.plane_res_b);
+ old_wm->wm[0].blocks, old_wm->wm[1].blocks,
+ old_wm->wm[2].blocks, old_wm->wm[3].blocks,
+ old_wm->wm[4].blocks, old_wm->wm[5].blocks,
+ old_wm->wm[6].blocks, old_wm->wm[7].blocks,
+ old_wm->trans_wm.blocks,
+ old_wm->sagv_wm0.blocks,
+ new_wm->wm[0].blocks, new_wm->wm[1].blocks,
+ new_wm->wm[2].blocks, new_wm->wm[3].blocks,
+ new_wm->wm[4].blocks, new_wm->wm[5].blocks,
+ new_wm->wm[6].blocks, new_wm->wm[7].blocks,
+ new_wm->trans_wm.blocks,
+ new_wm->sagv_wm0.blocks);
drm_dbg_kms(&dev_priv->drm,
"[PLANE:%d:%s] min_ddb
%4d,%4d,%4d,%4d,%4d,%4d,%4d,%4d,%4d,%4d"
@@ -6035,10 +6031,10 @@ static void ilk_optimize_watermarks(struct
intel_atomic_state *state,
static void skl_wm_level_from_reg_val(u32 val, struct skl_wm_level *level)
{
- level->plane_en = val & PLANE_WM_EN;
+ level->enable = val & PLANE_WM_EN;
level->ignore_lines = val & PLANE_WM_IGNORE_LINES;
- level->plane_res_b = val & PLANE_WM_BLOCKS_MASK;
- level->plane_res_l = (val >> PLANE_WM_LINES_SHIFT) &
+ level->blocks = val & PLANE_WM_BLOCKS_MASK;
+ level->lines = (val >> PLANE_WM_LINES_SHIFT) &
PLANE_WM_LINES_MASK;
}
--
2.26.2
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
