From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga04.intel.com ([192.55.52.120]:48010 "EHLO mga04.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751077AbcI0HGa (ORCPT ); Tue, 27 Sep 2016 03:06:30 -0400 Subject: Re: [Intel-gfx] [PATCH 5/9] drm/i915/gen9: minimum scanlines for Y tile is not always 4 To: Paulo Zanoni , intel-gfx@lists.freedesktop.org References: <1474578035-424-1-git-send-email-paulo.r.zanoni@intel.com> <1474578035-424-6-git-send-email-paulo.r.zanoni@intel.com> Cc: stable@vger.kernel.org From: Tvrtko Ursulin Message-ID: <18aa9128-a5ec-ee7a-0602-27676742b86b@linux.intel.com> Date: Tue, 27 Sep 2016 08:06:23 +0100 MIME-Version: 1.0 In-Reply-To: <1474578035-424-6-git-send-email-paulo.r.zanoni@intel.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit Sender: stable-owner@vger.kernel.org List-ID: Hi, On 22/09/2016 22:00, Paulo Zanoni wrote: > During watermarks calculations, this value is used in 3 different > places. Only one of them was not using a hardcoded 4. Move the code up > so everybody can benefit from the actual value. > > This should only help on situations with Y tiling + 90/270 rotation + > 1 or 2 bpp or NV12. I don't think bothering stable with this was required since 90/270 on NV12 was never fully enabled AFAIR. Unless Ville accidentaly enabled it in his recent rewrite? But it was not put in due instability issues so I hope not. Regards, Tvrtko > Cc: stable@vger.kernel.org > Reviewed-by: Maarten Lankhorst > Signed-off-by: Paulo Zanoni > --- > drivers/gpu/drm/i915/intel_pm.c | 56 +++++++++++++++++++++++------------------ > 1 file changed, 32 insertions(+), 24 deletions(-) > > diff --git a/drivers/gpu/drm/i915/intel_pm.c b/drivers/gpu/drm/i915/intel_pm.c > index ee561c2..a7f5f7f 100644 > --- a/drivers/gpu/drm/i915/intel_pm.c > +++ b/drivers/gpu/drm/i915/intel_pm.c > @@ -3495,7 +3495,8 @@ static uint32_t skl_wm_method1(uint32_t pixel_rate, uint8_t cpp, uint32_t latenc > > static uint32_t skl_wm_method2(uint32_t pixel_rate, uint32_t pipe_htotal, > uint32_t horiz_pixels, uint8_t cpp, > - uint64_t tiling, uint32_t latency) > + uint64_t tiling, uint32_t latency, > + uint32_t y_min_scanlines) > { > uint32_t ret; > uint32_t plane_bytes_per_line, plane_blocks_per_line; > @@ -3508,9 +3509,9 @@ static uint32_t skl_wm_method2(uint32_t pixel_rate, uint32_t pipe_htotal, > > if (tiling == I915_FORMAT_MOD_Y_TILED || > tiling == I915_FORMAT_MOD_Yf_TILED) { > - plane_bytes_per_line *= 4; > + plane_bytes_per_line *= y_min_scanlines; > plane_blocks_per_line = DIV_ROUND_UP(plane_bytes_per_line, 512); > - plane_blocks_per_line /= 4; > + plane_blocks_per_line /= y_min_scanlines; > } else if (tiling == DRM_FORMAT_MOD_NONE) { > plane_blocks_per_line = DIV_ROUND_UP(plane_bytes_per_line, 512) + 1; > } else { > @@ -3567,6 +3568,7 @@ static int skl_compute_plane_wm(const struct drm_i915_private *dev_priv, > uint8_t cpp; > uint32_t width = 0, height = 0; > uint32_t plane_pixel_rate; > + uint32_t y_min_scanlines; > > if (latency == 0 || !cstate->base.active || !intel_pstate->base.visible) { > *enabled = false; > @@ -3582,38 +3584,44 @@ static int skl_compute_plane_wm(const struct drm_i915_private *dev_priv, > cpp = drm_format_plane_cpp(fb->pixel_format, 0); > plane_pixel_rate = skl_adjusted_plane_pixel_rate(cstate, intel_pstate); > > + if (intel_rotation_90_or_270(pstate->rotation)) { > + int cpp = (fb->pixel_format == DRM_FORMAT_NV12) ? > + drm_format_plane_cpp(fb->pixel_format, 1) : > + drm_format_plane_cpp(fb->pixel_format, 0); > + > + switch (cpp) { > + case 1: > + y_min_scanlines = 16; > + break; > + case 2: > + y_min_scanlines = 8; > + break; > + default: > + WARN(1, "Unsupported pixel depth for rotation"); > + case 4: > + y_min_scanlines = 4; > + break; > + } > + } else { > + y_min_scanlines = 4; > + } > + > method1 = skl_wm_method1(plane_pixel_rate, cpp, latency); > method2 = skl_wm_method2(plane_pixel_rate, > cstate->base.adjusted_mode.crtc_htotal, > width, > cpp, > fb->modifier[0], > - latency); > + latency, > + y_min_scanlines); > > plane_bytes_per_line = width * cpp; > plane_blocks_per_line = DIV_ROUND_UP(plane_bytes_per_line, 512); > > if (fb->modifier[0] == I915_FORMAT_MOD_Y_TILED || > fb->modifier[0] == I915_FORMAT_MOD_Yf_TILED) { > - uint32_t min_scanlines = 4; > - uint32_t y_tile_minimum; > - if (intel_rotation_90_or_270(pstate->rotation)) { > - int cpp = (fb->pixel_format == DRM_FORMAT_NV12) ? > - drm_format_plane_cpp(fb->pixel_format, 1) : > - drm_format_plane_cpp(fb->pixel_format, 0); > - > - switch (cpp) { > - case 1: > - min_scanlines = 16; > - break; > - case 2: > - min_scanlines = 8; > - break; > - case 8: > - WARN(1, "Unsupported pixel depth for rotation"); > - } > - } > - y_tile_minimum = plane_blocks_per_line * min_scanlines; > + uint32_t y_tile_minimum = plane_blocks_per_line * > + y_min_scanlines; > selected_result = max(method2, y_tile_minimum); > } else { > if ((ddb_allocation / plane_blocks_per_line) >= 1) > @@ -3628,7 +3636,7 @@ static int skl_compute_plane_wm(const struct drm_i915_private *dev_priv, > if (level >= 1 && level <= 7) { > if (fb->modifier[0] == I915_FORMAT_MOD_Y_TILED || > fb->modifier[0] == I915_FORMAT_MOD_Yf_TILED) > - res_lines += 4; > + res_lines += y_min_scanlines; > else > res_blocks++; > } From mboxrd@z Thu Jan 1 00:00:00 1970 From: Tvrtko Ursulin Subject: Re: [PATCH 5/9] drm/i915/gen9: minimum scanlines for Y tile is not always 4 Date: Tue, 27 Sep 2016 08:06:23 +0100 Message-ID: <18aa9128-a5ec-ee7a-0602-27676742b86b@linux.intel.com> References: <1474578035-424-1-git-send-email-paulo.r.zanoni@intel.com> <1474578035-424-6-git-send-email-paulo.r.zanoni@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by gabe.freedesktop.org (Postfix) with ESMTPS id 934286E607 for ; Tue, 27 Sep 2016 07:06:28 +0000 (UTC) In-Reply-To: <1474578035-424-6-git-send-email-paulo.r.zanoni@intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: Paulo Zanoni , intel-gfx@lists.freedesktop.org Cc: stable@vger.kernel.org List-Id: intel-gfx@lists.freedesktop.org CkhpLAoKT24gMjIvMDkvMjAxNiAyMjowMCwgUGF1bG8gWmFub25pIHdyb3RlOgo+IER1cmluZyB3 YXRlcm1hcmtzIGNhbGN1bGF0aW9ucywgdGhpcyB2YWx1ZSBpcyB1c2VkIGluIDMgZGlmZmVyZW50 Cj4gcGxhY2VzLiBPbmx5IG9uZSBvZiB0aGVtIHdhcyBub3QgdXNpbmcgYSBoYXJkY29kZWQgNC4g TW92ZSB0aGUgY29kZSB1cAo+IHNvIGV2ZXJ5Ym9keSBjYW4gYmVuZWZpdCBmcm9tIHRoZSBhY3R1 YWwgdmFsdWUuCj4KPiBUaGlzIHNob3VsZCBvbmx5IGhlbHAgb24gc2l0dWF0aW9ucyB3aXRoIFkg dGlsaW5nICsgOTAvMjcwIHJvdGF0aW9uICsKPiAxIG9yIDIgYnBwIG9yIE5WMTIuCgpJIGRvbid0 IHRoaW5rIGJvdGhlcmluZyBzdGFibGUgd2l0aCB0aGlzIHdhcyByZXF1aXJlZCBzaW5jZSA5MC8y NzAgb24gCk5WMTIgd2FzIG5ldmVyIGZ1bGx5IGVuYWJsZWQgQUZBSVIuIFVubGVzcyBWaWxsZSBh Y2NpZGVudGFseSBlbmFibGVkIGl0IAppbiBoaXMgcmVjZW50IHJld3JpdGU/IEJ1dCBpdCB3YXMg bm90IHB1dCBpbiBkdWUgaW5zdGFiaWxpdHkgaXNzdWVzIHNvIEkgCmhvcGUgbm90LgoKUmVnYXJk cywKClR2cnRrbwoKPiBDYzogc3RhYmxlQHZnZXIua2VybmVsLm9yZwo+IFJldmlld2VkLWJ5OiBN YWFydGVuIExhbmtob3JzdCA8bWFhcnRlbi5sYW5raG9yc3RAbGludXguaW50ZWwuY29tPgo+IFNp Z25lZC1vZmYtYnk6IFBhdWxvIFphbm9uaSA8cGF1bG8uci56YW5vbmlAaW50ZWwuY29tPgo+IC0t LQo+ICAgZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcG0uYyB8IDU2ICsrKysrKysrKysrKysr KysrKysrKysrLS0tLS0tLS0tLS0tLS0tLS0tCj4gICAxIGZpbGUgY2hhbmdlZCwgMzIgaW5zZXJ0 aW9ucygrKSwgMjQgZGVsZXRpb25zKC0pCj4KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvaW50ZWxfcG0uYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3BtLmMKPiBpbmRl eCBlZTU2MWMyLi5hN2Y1ZjdmIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2lu dGVsX3BtLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9wbS5jCj4gQEAgLTM0 OTUsNyArMzQ5NSw4IEBAIHN0YXRpYyB1aW50MzJfdCBza2xfd21fbWV0aG9kMSh1aW50MzJfdCBw aXhlbF9yYXRlLCB1aW50OF90IGNwcCwgdWludDMyX3QgbGF0ZW5jCj4gICAKPiAgIHN0YXRpYyB1 aW50MzJfdCBza2xfd21fbWV0aG9kMih1aW50MzJfdCBwaXhlbF9yYXRlLCB1aW50MzJfdCBwaXBl X2h0b3RhbCwKPiAgIAkJCSAgICAgICB1aW50MzJfdCBob3Jpel9waXhlbHMsIHVpbnQ4X3QgY3Bw LAo+IC0JCQkgICAgICAgdWludDY0X3QgdGlsaW5nLCB1aW50MzJfdCBsYXRlbmN5KQo+ICsJCQkg ICAgICAgdWludDY0X3QgdGlsaW5nLCB1aW50MzJfdCBsYXRlbmN5LAo+ICsJCQkgICAgICAgdWlu dDMyX3QgeV9taW5fc2NhbmxpbmVzKQo+ICAgewo+ICAgCXVpbnQzMl90IHJldDsKPiAgIAl1aW50 MzJfdCBwbGFuZV9ieXRlc19wZXJfbGluZSwgcGxhbmVfYmxvY2tzX3Blcl9saW5lOwo+IEBAIC0z NTA4LDkgKzM1MDksOSBAQCBzdGF0aWMgdWludDMyX3Qgc2tsX3dtX21ldGhvZDIodWludDMyX3Qg cGl4ZWxfcmF0ZSwgdWludDMyX3QgcGlwZV9odG90YWwsCj4gICAKPiAgIAlpZiAodGlsaW5nID09 IEk5MTVfRk9STUFUX01PRF9ZX1RJTEVEIHx8Cj4gICAJICAgIHRpbGluZyA9PSBJOTE1X0ZPUk1B VF9NT0RfWWZfVElMRUQpIHsKPiAtCQlwbGFuZV9ieXRlc19wZXJfbGluZSAqPSA0Owo+ICsJCXBs YW5lX2J5dGVzX3Blcl9saW5lICo9IHlfbWluX3NjYW5saW5lczsKPiAgIAkJcGxhbmVfYmxvY2tz X3Blcl9saW5lID0gRElWX1JPVU5EX1VQKHBsYW5lX2J5dGVzX3Blcl9saW5lLCA1MTIpOwo+IC0J CXBsYW5lX2Jsb2Nrc19wZXJfbGluZSAvPSA0Owo+ICsJCXBsYW5lX2Jsb2Nrc19wZXJfbGluZSAv PSB5X21pbl9zY2FubGluZXM7Cj4gICAJfSBlbHNlIGlmICh0aWxpbmcgPT0gRFJNX0ZPUk1BVF9N T0RfTk9ORSkgewo+ICAgCQlwbGFuZV9ibG9ja3NfcGVyX2xpbmUgPSBESVZfUk9VTkRfVVAocGxh bmVfYnl0ZXNfcGVyX2xpbmUsIDUxMikgKyAxOwo+ICAgCX0gZWxzZSB7Cj4gQEAgLTM1NjcsNiAr MzU2OCw3IEBAIHN0YXRpYyBpbnQgc2tsX2NvbXB1dGVfcGxhbmVfd20oY29uc3Qgc3RydWN0IGRy bV9pOTE1X3ByaXZhdGUgKmRldl9wcml2LAo+ICAgCXVpbnQ4X3QgY3BwOwo+ICAgCXVpbnQzMl90 IHdpZHRoID0gMCwgaGVpZ2h0ID0gMDsKPiAgIAl1aW50MzJfdCBwbGFuZV9waXhlbF9yYXRlOwo+ ICsJdWludDMyX3QgeV9taW5fc2NhbmxpbmVzOwo+ICAgCj4gICAJaWYgKGxhdGVuY3kgPT0gMCB8 fCAhY3N0YXRlLT5iYXNlLmFjdGl2ZSB8fCAhaW50ZWxfcHN0YXRlLT5iYXNlLnZpc2libGUpIHsK PiAgIAkJKmVuYWJsZWQgPSBmYWxzZTsKPiBAQCAtMzU4MiwzOCArMzU4NCw0NCBAQCBzdGF0aWMg aW50IHNrbF9jb21wdXRlX3BsYW5lX3dtKGNvbnN0IHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpk ZXZfcHJpdiwKPiAgIAljcHAgPSBkcm1fZm9ybWF0X3BsYW5lX2NwcChmYi0+cGl4ZWxfZm9ybWF0 LCAwKTsKPiAgIAlwbGFuZV9waXhlbF9yYXRlID0gc2tsX2FkanVzdGVkX3BsYW5lX3BpeGVsX3Jh dGUoY3N0YXRlLCBpbnRlbF9wc3RhdGUpOwo+ICAgCj4gKwlpZiAoaW50ZWxfcm90YXRpb25fOTBf b3JfMjcwKHBzdGF0ZS0+cm90YXRpb24pKSB7Cj4gKwkJaW50IGNwcCA9IChmYi0+cGl4ZWxfZm9y bWF0ID09IERSTV9GT1JNQVRfTlYxMikgPwo+ICsJCQlkcm1fZm9ybWF0X3BsYW5lX2NwcChmYi0+ cGl4ZWxfZm9ybWF0LCAxKSA6Cj4gKwkJCWRybV9mb3JtYXRfcGxhbmVfY3BwKGZiLT5waXhlbF9m b3JtYXQsIDApOwo+ICsKPiArCQlzd2l0Y2ggKGNwcCkgewo+ICsJCWNhc2UgMToKPiArCQkJeV9t aW5fc2NhbmxpbmVzID0gMTY7Cj4gKwkJCWJyZWFrOwo+ICsJCWNhc2UgMjoKPiArCQkJeV9taW5f c2NhbmxpbmVzID0gODsKPiArCQkJYnJlYWs7Cj4gKwkJZGVmYXVsdDoKPiArCQkJV0FSTigxLCAi VW5zdXBwb3J0ZWQgcGl4ZWwgZGVwdGggZm9yIHJvdGF0aW9uIik7Cj4gKwkJY2FzZSA0Ogo+ICsJ CQl5X21pbl9zY2FubGluZXMgPSA0Owo+ICsJCQlicmVhazsKPiArCQl9Cj4gKwl9IGVsc2Ugewo+ ICsJCXlfbWluX3NjYW5saW5lcyA9IDQ7Cj4gKwl9Cj4gKwo+ICAgCW1ldGhvZDEgPSBza2xfd21f bWV0aG9kMShwbGFuZV9waXhlbF9yYXRlLCBjcHAsIGxhdGVuY3kpOwo+ICAgCW1ldGhvZDIgPSBz a2xfd21fbWV0aG9kMihwbGFuZV9waXhlbF9yYXRlLAo+ICAgCQkJCSBjc3RhdGUtPmJhc2UuYWRq dXN0ZWRfbW9kZS5jcnRjX2h0b3RhbCwKPiAgIAkJCQkgd2lkdGgsCj4gICAJCQkJIGNwcCwKPiAg IAkJCQkgZmItPm1vZGlmaWVyWzBdLAo+IC0JCQkJIGxhdGVuY3kpOwo+ICsJCQkJIGxhdGVuY3ks Cj4gKwkJCQkgeV9taW5fc2NhbmxpbmVzKTsKPiAgIAo+ICAgCXBsYW5lX2J5dGVzX3Blcl9saW5l ID0gd2lkdGggKiBjcHA7Cj4gICAJcGxhbmVfYmxvY2tzX3Blcl9saW5lID0gRElWX1JPVU5EX1VQ KHBsYW5lX2J5dGVzX3Blcl9saW5lLCA1MTIpOwo+ICAgCj4gICAJaWYgKGZiLT5tb2RpZmllclsw XSA9PSBJOTE1X0ZPUk1BVF9NT0RfWV9USUxFRCB8fAo+ICAgCSAgICBmYi0+bW9kaWZpZXJbMF0g PT0gSTkxNV9GT1JNQVRfTU9EX1lmX1RJTEVEKSB7Cj4gLQkJdWludDMyX3QgbWluX3NjYW5saW5l cyA9IDQ7Cj4gLQkJdWludDMyX3QgeV90aWxlX21pbmltdW07Cj4gLQkJaWYgKGludGVsX3JvdGF0 aW9uXzkwX29yXzI3MChwc3RhdGUtPnJvdGF0aW9uKSkgewo+IC0JCQlpbnQgY3BwID0gKGZiLT5w aXhlbF9mb3JtYXQgPT0gRFJNX0ZPUk1BVF9OVjEyKSA/Cj4gLQkJCQlkcm1fZm9ybWF0X3BsYW5l X2NwcChmYi0+cGl4ZWxfZm9ybWF0LCAxKSA6Cj4gLQkJCQlkcm1fZm9ybWF0X3BsYW5lX2NwcChm Yi0+cGl4ZWxfZm9ybWF0LCAwKTsKPiAtCj4gLQkJCXN3aXRjaCAoY3BwKSB7Cj4gLQkJCWNhc2Ug MToKPiAtCQkJCW1pbl9zY2FubGluZXMgPSAxNjsKPiAtCQkJCWJyZWFrOwo+IC0JCQljYXNlIDI6 Cj4gLQkJCQltaW5fc2NhbmxpbmVzID0gODsKPiAtCQkJCWJyZWFrOwo+IC0JCQljYXNlIDg6Cj4g LQkJCQlXQVJOKDEsICJVbnN1cHBvcnRlZCBwaXhlbCBkZXB0aCBmb3Igcm90YXRpb24iKTsKPiAt CQkJfQo+IC0JCX0KPiAtCQl5X3RpbGVfbWluaW11bSA9IHBsYW5lX2Jsb2Nrc19wZXJfbGluZSAq IG1pbl9zY2FubGluZXM7Cj4gKwkJdWludDMyX3QgeV90aWxlX21pbmltdW0gPSBwbGFuZV9ibG9j a3NfcGVyX2xpbmUgKgo+ICsJCQkJCSAgeV9taW5fc2NhbmxpbmVzOwo+ICAgCQlzZWxlY3RlZF9y ZXN1bHQgPSBtYXgobWV0aG9kMiwgeV90aWxlX21pbmltdW0pOwo+ICAgCX0gZWxzZSB7Cj4gICAJ CWlmICgoZGRiX2FsbG9jYXRpb24gLyBwbGFuZV9ibG9ja3NfcGVyX2xpbmUpID49IDEpCj4gQEAg LTM2MjgsNyArMzYzNiw3IEBAIHN0YXRpYyBpbnQgc2tsX2NvbXB1dGVfcGxhbmVfd20oY29uc3Qg c3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2LAo+ICAgCWlmIChsZXZlbCA+PSAxICYm IGxldmVsIDw9IDcpIHsKPiAgIAkJaWYgKGZiLT5tb2RpZmllclswXSA9PSBJOTE1X0ZPUk1BVF9N T0RfWV9USUxFRCB8fAo+ICAgCQkgICAgZmItPm1vZGlmaWVyWzBdID09IEk5MTVfRk9STUFUX01P RF9ZZl9USUxFRCkKPiAtCQkJcmVzX2xpbmVzICs9IDQ7Cj4gKwkJCXJlc19saW5lcyArPSB5X21p bl9zY2FubGluZXM7Cj4gICAJCWVsc2UKPiAgIAkJCXJlc19ibG9ja3MrKzsKPiAgIAl9CgpfX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZnggbWFp bGluZyBsaXN0CkludGVsLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5m cmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZngK