From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753878AbcHQT50 (ORCPT ); Wed, 17 Aug 2016 15:57:26 -0400 Received: from mx1.redhat.com ([209.132.183.28]:42066 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753066AbcHQT4M (ORCPT ); Wed, 17 Aug 2016 15:56:12 -0400 From: Lyude To: intel-gfx@lists.freedesktop.org, =?UTF-8?q?Ville=20Syrj=C3=A4l=C3=A4?= , Maarten Lankhorst , Matt Roper Cc: Lyude , stable@vger.kernel.org, Daniel Vetter , Radhakrishna Sripada , Hans de Goede , Jani Nikula , David Airlie , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Subject: [PATCH v12 3/7] drm/i915/gen9: Only copy WM results for changed pipes to skl_hw Date: Wed, 17 Aug 2016 15:55:55 -0400 Message-Id: <1471463761-26796-4-git-send-email-cpaul@redhat.com> In-Reply-To: <1471463761-26796-1-git-send-email-cpaul@redhat.com> References: <1471463761-26796-1-git-send-email-cpaul@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.29]); Wed, 17 Aug 2016 19:56:12 +0000 (UTC) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Matt Roper When we write watermark values to the hardware, those values are stored in dev_priv->wm.skl_hw. However with recent watermark changes, the results structure we're copying from only contains valid watermark and DDB values for the pipes that are actually changing; the values for other pipes remain 0. Thus a blind copy of the entire skl_wm_values structure will clobber the values for unchanged pipes...we need to be more selective and only copy over the values for the changing pipes. This mistake was hidden until recently due to another bug that caused us to erroneously re-calculate watermarks for all active pipes rather than changing pipes. Only when that bug was fixed was the impact of this bug discovered (e.g., modesets failing with "Requested display configuration exceeds system watermark limitations" messages and leaving watermarks non-functional, even ones initiated by intel_fbdev_restore_mode). Changes since v1: - Add a function for copying a pipe's wm values (skl_copy_wm_for_pipe()) so we can reuse this later Fixes: 734fa01f3a17 ("drm/i915/gen9: Calculate watermarks during atomic 'check' (v2)") Fixes: 9b6130227495 ("drm/i915/gen9: Re-allocate DDB only for changed pipes") Signed-off-by: Matt Roper Signed-off-by: Lyude Reviewed-by: Matt Roper Cc: stable@vger.kernel.org Cc: Maarten Lankhorst Cc: Ville Syrjälä Cc: Daniel Vetter Cc: Radhakrishna Sripada Cc: Hans de Goede --- drivers/gpu/drm/i915/intel_pm.c | 28 ++++++++++++++++++++++++++-- 1 file changed, 26 insertions(+), 2 deletions(-) diff --git a/drivers/gpu/drm/i915/intel_pm.c b/drivers/gpu/drm/i915/intel_pm.c index fed2bae8..5c9cf68 100644 --- a/drivers/gpu/drm/i915/intel_pm.c +++ b/drivers/gpu/drm/i915/intel_pm.c @@ -4104,6 +4104,24 @@ skl_compute_ddb(struct drm_atomic_state *state) return 0; } +static void +skl_copy_wm_for_pipe(struct skl_wm_values *dst, + struct skl_wm_values *src, + enum pipe pipe) +{ + dst->wm_linetime[pipe] = src->wm_linetime[pipe]; + memcpy(dst->plane[pipe], src->plane[pipe], + sizeof(dst->plane[pipe])); + memcpy(dst->plane_trans[pipe], src->plane_trans[pipe], + sizeof(dst->plane_trans[pipe])); + + dst->ddb.pipe[pipe] = src->ddb.pipe[pipe]; + memcpy(dst->ddb.y_plane[pipe], src->ddb.y_plane[pipe], + sizeof(dst->ddb.y_plane[pipe])); + memcpy(dst->ddb.plane[pipe], src->ddb.plane[pipe], + sizeof(dst->ddb.plane[pipe])); +} + static int skl_compute_wm(struct drm_atomic_state *state) { @@ -4176,8 +4194,10 @@ static void skl_update_wm(struct drm_crtc *crtc) struct drm_device *dev = crtc->dev; struct drm_i915_private *dev_priv = to_i915(dev); struct skl_wm_values *results = &dev_priv->wm.skl_results; + struct skl_wm_values *hw_vals = &dev_priv->wm.skl_hw; struct intel_crtc_state *cstate = to_intel_crtc_state(crtc->state); struct skl_pipe_wm *pipe_wm = &cstate->wm.skl.optimal; + int pipe; if ((results->dirty_pipes & drm_crtc_mask(crtc)) == 0) return; @@ -4189,8 +4209,12 @@ static void skl_update_wm(struct drm_crtc *crtc) skl_write_wm_values(dev_priv, results); skl_flush_wm_values(dev_priv, results); - /* store the new configuration */ - dev_priv->wm.skl_hw = *results; + /* + * Store the new configuration (but only for the pipes that have + * changed; the other values weren't recomputed). + */ + for_each_pipe_masked(dev_priv, pipe, results->dirty_pipes) + skl_copy_wm_for_pipe(hw_vals, results, pipe); mutex_unlock(&dev_priv->wm.wm_mutex); } -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Lyude Subject: [PATCH v12 3/7] drm/i915/gen9: Only copy WM results for changed pipes to skl_hw Date: Wed, 17 Aug 2016 15:55:55 -0400 Message-ID: <1471463761-26796-4-git-send-email-cpaul@redhat.com> References: <1471463761-26796-1-git-send-email-cpaul@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1471463761-26796-1-git-send-email-cpaul@redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: intel-gfx@lists.freedesktop.org, =?UTF-8?q?Ville=20Syrj=C3=A4l=C3=A4?= , Maarten Lankhorst , Matt Roper Cc: David Airlie , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, Hans de Goede , stable@vger.kernel.org, Daniel Vetter List-Id: dri-devel@lists.freedesktop.org RnJvbTogTWF0dCBSb3BlciA8bWF0dGhldy5kLnJvcGVyQGludGVsLmNvbT4KCldoZW4gd2Ugd3Jp dGUgd2F0ZXJtYXJrIHZhbHVlcyB0byB0aGUgaGFyZHdhcmUsIHRob3NlIHZhbHVlcyBhcmUgc3Rv cmVkCmluIGRldl9wcml2LT53bS5za2xfaHcuICBIb3dldmVyIHdpdGggcmVjZW50IHdhdGVybWFy ayBjaGFuZ2VzLCB0aGUKcmVzdWx0cyBzdHJ1Y3R1cmUgd2UncmUgY29weWluZyBmcm9tIG9ubHkg Y29udGFpbnMgdmFsaWQgd2F0ZXJtYXJrIGFuZApEREIgdmFsdWVzIGZvciB0aGUgcGlwZXMgdGhh dCBhcmUgYWN0dWFsbHkgY2hhbmdpbmc7IHRoZSB2YWx1ZXMgZm9yCm90aGVyIHBpcGVzIHJlbWFp biAwLiAgVGh1cyBhIGJsaW5kIGNvcHkgb2YgdGhlIGVudGlyZSBza2xfd21fdmFsdWVzCnN0cnVj dHVyZSB3aWxsIGNsb2JiZXIgdGhlIHZhbHVlcyBmb3IgdW5jaGFuZ2VkIHBpcGVzLi4ud2UgbmVl ZCB0byBiZQptb3JlIHNlbGVjdGl2ZSBhbmQgb25seSBjb3B5IG92ZXIgdGhlIHZhbHVlcyBmb3Ig dGhlIGNoYW5naW5nIHBpcGVzLgoKVGhpcyBtaXN0YWtlIHdhcyBoaWRkZW4gdW50aWwgcmVjZW50 bHkgZHVlIHRvIGFub3RoZXIgYnVnIHRoYXQgY2F1c2VkIHVzCnRvIGVycm9uZW91c2x5IHJlLWNh bGN1bGF0ZSB3YXRlcm1hcmtzIGZvciBhbGwgYWN0aXZlIHBpcGVzIHJhdGhlciB0aGFuCmNoYW5n aW5nIHBpcGVzLiAgT25seSB3aGVuIHRoYXQgYnVnIHdhcyBmaXhlZCB3YXMgdGhlIGltcGFjdCBv ZiB0aGlzIGJ1ZwpkaXNjb3ZlcmVkIChlLmcuLCBtb2Rlc2V0cyBmYWlsaW5nIHdpdGggIlJlcXVl c3RlZCBkaXNwbGF5IGNvbmZpZ3VyYXRpb24KZXhjZWVkcyBzeXN0ZW0gd2F0ZXJtYXJrIGxpbWl0 YXRpb25zIiBtZXNzYWdlcyBhbmQgbGVhdmluZyB3YXRlcm1hcmtzCm5vbi1mdW5jdGlvbmFsLCBl dmVuIG9uZXMgaW5pdGlhdGVkIGJ5IGludGVsX2ZiZGV2X3Jlc3RvcmVfbW9kZSkuCgpDaGFuZ2Vz IHNpbmNlIHYxOgogLSBBZGQgYSBmdW5jdGlvbiBmb3IgY29weWluZyBhIHBpcGUncyB3bSB2YWx1 ZXMKICAgKHNrbF9jb3B5X3dtX2Zvcl9waXBlKCkpIHNvIHdlIGNhbiByZXVzZSB0aGlzIGxhdGVy CgpGaXhlczogNzM0ZmEwMWYzYTE3ICgiZHJtL2k5MTUvZ2VuOTogQ2FsY3VsYXRlIHdhdGVybWFy a3MgZHVyaW5nIGF0b21pYyAnY2hlY2snICh2MikiKQpGaXhlczogOWI2MTMwMjI3NDk1ICgiZHJt L2k5MTUvZ2VuOTogUmUtYWxsb2NhdGUgRERCIG9ubHkgZm9yIGNoYW5nZWQgcGlwZXMiKQpTaWdu ZWQtb2ZmLWJ5OiBNYXR0IFJvcGVyIDxtYXR0aGV3LmQucm9wZXJAaW50ZWwuY29tPgpTaWduZWQt b2ZmLWJ5OiBMeXVkZSA8Y3BhdWxAcmVkaGF0LmNvbT4KUmV2aWV3ZWQtYnk6IE1hdHQgUm9wZXIg PG1hdHRoZXcuZC5yb3BlckBpbnRlbC5jb20+CkNjOiBzdGFibGVAdmdlci5rZXJuZWwub3JnCkNj OiBNYWFydGVuIExhbmtob3JzdCA8bWFhcnRlbi5sYW5raG9yc3RAbGludXguaW50ZWwuY29tPgpD YzogVmlsbGUgU3lyasOkbMOkIDx2aWxsZS5zeXJqYWxhQGxpbnV4LmludGVsLmNvbT4KQ2M6IERh bmllbCBWZXR0ZXIgPGRhbmllbC52ZXR0ZXJAaW50ZWwuY29tPgpDYzogUmFkaGFrcmlzaG5hIFNy aXBhZGEgPHJhZGhha3Jpc2huYS5zcmlwYWRhQGludGVsLmNvbT4KQ2M6IEhhbnMgZGUgR29lZGUg PGhkZWdvZWRlQHJlZGhhdC5jb20+Ci0tLQogZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcG0u YyB8IDI4ICsrKysrKysrKysrKysrKysrKysrKysrKysrLS0KIDEgZmlsZSBjaGFuZ2VkLCAyNiBp bnNlcnRpb25zKCspLCAyIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2ludGVsX3BtLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9wbS5jCmluZGV4 IGZlZDJiYWU4Li41YzljZjY4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRl bF9wbS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3BtLmMKQEAgLTQxMDQsNiAr NDEwNCwyNCBAQCBza2xfY29tcHV0ZV9kZGIoc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRl KQogCXJldHVybiAwOwogfQogCitzdGF0aWMgdm9pZAorc2tsX2NvcHlfd21fZm9yX3BpcGUoc3Ry dWN0IHNrbF93bV92YWx1ZXMgKmRzdCwKKwkJICAgICBzdHJ1Y3Qgc2tsX3dtX3ZhbHVlcyAqc3Jj LAorCQkgICAgIGVudW0gcGlwZSBwaXBlKQoreworCWRzdC0+d21fbGluZXRpbWVbcGlwZV0gPSBz cmMtPndtX2xpbmV0aW1lW3BpcGVdOworCW1lbWNweShkc3QtPnBsYW5lW3BpcGVdLCBzcmMtPnBs YW5lW3BpcGVdLAorCSAgICAgICBzaXplb2YoZHN0LT5wbGFuZVtwaXBlXSkpOworCW1lbWNweShk c3QtPnBsYW5lX3RyYW5zW3BpcGVdLCBzcmMtPnBsYW5lX3RyYW5zW3BpcGVdLAorCSAgICAgICBz aXplb2YoZHN0LT5wbGFuZV90cmFuc1twaXBlXSkpOworCisJZHN0LT5kZGIucGlwZVtwaXBlXSA9 IHNyYy0+ZGRiLnBpcGVbcGlwZV07CisJbWVtY3B5KGRzdC0+ZGRiLnlfcGxhbmVbcGlwZV0sIHNy Yy0+ZGRiLnlfcGxhbmVbcGlwZV0sCisJICAgICAgIHNpemVvZihkc3QtPmRkYi55X3BsYW5lW3Bp cGVdKSk7CisJbWVtY3B5KGRzdC0+ZGRiLnBsYW5lW3BpcGVdLCBzcmMtPmRkYi5wbGFuZVtwaXBl XSwKKwkgICAgICAgc2l6ZW9mKGRzdC0+ZGRiLnBsYW5lW3BpcGVdKSk7Cit9CisKIHN0YXRpYyBp bnQKIHNrbF9jb21wdXRlX3dtKHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZSkKIHsKQEAg LTQxNzYsOCArNDE5NCwxMCBAQCBzdGF0aWMgdm9pZCBza2xfdXBkYXRlX3dtKHN0cnVjdCBkcm1f Y3J0YyAqY3J0YykKIAlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gY3J0Yy0+ZGV2OwogCXN0cnVj dCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IHRvX2k5MTUoZGV2KTsKIAlzdHJ1Y3Qgc2ts X3dtX3ZhbHVlcyAqcmVzdWx0cyA9ICZkZXZfcHJpdi0+d20uc2tsX3Jlc3VsdHM7CisJc3RydWN0 IHNrbF93bV92YWx1ZXMgKmh3X3ZhbHMgPSAmZGV2X3ByaXYtPndtLnNrbF9odzsKIAlzdHJ1Y3Qg aW50ZWxfY3J0Y19zdGF0ZSAqY3N0YXRlID0gdG9faW50ZWxfY3J0Y19zdGF0ZShjcnRjLT5zdGF0 ZSk7CiAJc3RydWN0IHNrbF9waXBlX3dtICpwaXBlX3dtID0gJmNzdGF0ZS0+d20uc2tsLm9wdGlt YWw7CisJaW50IHBpcGU7CiAKIAlpZiAoKHJlc3VsdHMtPmRpcnR5X3BpcGVzICYgZHJtX2NydGNf bWFzayhjcnRjKSkgPT0gMCkKIAkJcmV0dXJuOwpAQCAtNDE4OSw4ICs0MjA5LDEyIEBAIHN0YXRp YyB2b2lkIHNrbF91cGRhdGVfd20oc3RydWN0IGRybV9jcnRjICpjcnRjKQogCXNrbF93cml0ZV93 bV92YWx1ZXMoZGV2X3ByaXYsIHJlc3VsdHMpOwogCXNrbF9mbHVzaF93bV92YWx1ZXMoZGV2X3By aXYsIHJlc3VsdHMpOwogCi0JLyogc3RvcmUgdGhlIG5ldyBjb25maWd1cmF0aW9uICovCi0JZGV2 X3ByaXYtPndtLnNrbF9odyA9ICpyZXN1bHRzOworCS8qCisJICogU3RvcmUgdGhlIG5ldyBjb25m aWd1cmF0aW9uIChidXQgb25seSBmb3IgdGhlIHBpcGVzIHRoYXQgaGF2ZQorCSAqIGNoYW5nZWQ7 IHRoZSBvdGhlciB2YWx1ZXMgd2VyZW4ndCByZWNvbXB1dGVkKS4KKwkgKi8KKwlmb3JfZWFjaF9w aXBlX21hc2tlZChkZXZfcHJpdiwgcGlwZSwgcmVzdWx0cy0+ZGlydHlfcGlwZXMpCisJCXNrbF9j b3B5X3dtX2Zvcl9waXBlKGh3X3ZhbHMsIHJlc3VsdHMsIHBpcGUpOwogCiAJbXV0ZXhfdW5sb2Nr KCZkZXZfcHJpdi0+d20ud21fbXV0ZXgpOwogfQotLSAKMi43LjQKCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkludGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50 ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9y Zy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo=