From mboxrd@z Thu Jan 1 00:00:00 1970 From: Lyude Subject: [PATCH v6 1/6] drm/i915/skl: Add support for the SAGV, fix underrun hangs Date: Tue, 2 Aug 2016 18:37:32 -0400 Message-ID: <1470177458-31984-2-git-send-email-cpaul@redhat.com> References: <1470177458-31984-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: <1470177458-31984-1-git-send-email-cpaul@redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: intel-gfx@lists.freedesktop.org, =?UTF-8?q?Ville=20Syrj=C3=A4l=C3=A4?= , Maarten Lankhorst , Matt Roper Cc: Daniel Vetter , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, stable@vger.kernel.org, Daniel Vetter , Lyude List-Id: dri-devel@lists.freedesktop.org U2luY2UgdGhlIHdhdGVybWFyayBjYWxjdWxhdGlvbnMgZm9yIFNreWxha2UgYXJlIHN0aWxsIGJy b2tlbiwgd2UncmUgYXB0CnRvIGhpdHRpbmcgdW5kZXJydW5zIHZlcnkgZWFzaWx5IHVuZGVyIG11 bHRpLW1vbml0b3IgY29uZmlndXJhdGlvbnMuCldoaWxlIGl0IHdvdWxkIGJlIGxvdmVseSBpZiB0 aGlzIHdhcyBmaXhlZCwgaXQncyBub3QuIEFub3RoZXIgcHJvYmxlbQp0aGF0J3MgYmVlbiBjb21p bmcgZnJvbSB0aGlzIGhvd2V2ZXIsIGlzIHRoZSBteXN0ZXJpb3VzIGlzc3VlIG9mCnVuZGVycnVu cyBjYXVzaW5nIGZ1bGwgc3lzdGVtIGhhbmdzLiBBbiBlYXN5IHdheSB0byByZXByb2R1Y2UgdGhp cyB3aXRoCmEgc2t5bGFrZSBzeXN0ZW06CgotIEdldCBhIGxhcHRvcCB3aXRoIGEgc2t5bGFrZSBH UFUsIGFuZCBob29rIHVwIHR3byBleHRlcm5hbCBtb25pdG9ycyB0bwogIGl0Ci0gTW92ZSB0aGUg Y3Vyc29yIGZyb20gdGhlIGJ1aWx0LWluIExDRCB0byBvbmUgb2YgdGhlIGV4dGVybmFsIGRpc3Bs YXlzCiAgYXMgcXVpY2tseSBhcyB5b3UgY2FuCi0gWW91J2xsIGdldCBhIGZldyBwaXBlIHVuZGVy cnVucywgYW5kIGV2ZW50dWFsbHkgdGhlIGVudGlyZSBzeXN0ZW0gd2lsbAogIGp1c3QgZnJlZXpl LgoKQWZ0ZXIgZG9pbmcgYSBsb3Qgb2YgaW52ZXN0aWdhdGlvbiBhbmQgcmVhZGluZyB0aHJvdWdo IHRoZSBic3BlYywgSQpmb3VuZCB0aGUgZXhpc3RlbmNlIG9mIHRoZSBTQUdWLCB3aGljaCBpcyBy ZXNwb25zaWJsZSBmb3IgYWRqdXN0aW5nIHRoZQpzeXN0ZW0gYWdlbnQgdm9sdGFnZSBhbmQgY2xv Y2sgZnJlcXVlbmNpZXMgZGVwZW5kaW5nIG9uIGhvdyBtdWNoIHBvd2VyCndlIG5lZWQuIEFjY29y ZGluZyB0byB0aGUgYnNwZWM6CgoiVGhlIGRpc3BsYXkgZW5naW5lIGFjY2VzcyB0byBzeXN0ZW0g bWVtb3J5IGlzIGJsb2NrZWQgZHVyaW5nIHRoZQogYWRqdXN0bWVudCB0aW1lLiBTQUdWIGRlZmF1 bHRzIHRvIGVuYWJsZWQuIFNvZnR3YXJlIG11c3QgdXNlIHRoZQogR1QtZHJpdmVyIHBjb2RlIG1h aWxib3ggdG8gZGlzYWJsZSBTQUdWIHdoZW4gdGhlIGRpc3BsYXkgZW5naW5lIGlzIG5vdAogYWJs ZSB0byB0b2xlcmF0ZSB0aGUgYmxvY2tpbmcgdGltZS4iCgpUaGUgcmVzdCBvZiB0aGUgYnNwZWMg Z29lcyBvbiB0byBleHBsYWluIHRoYXQgc29mdHdhcmUgY2FuIHNpbXBseSBsZWF2ZQp0aGUgU0FH ViBlbmFibGVkLCBhbmQgZGlzYWJsZSBpdCB3aGVuIHdlIHVzZSBpbnRlcmxhY2VkIHBpcGVzL2hh dmUgbW9yZQp0aGVuIG9uZSBwaXBlIGFjdGl2ZS4KClN1cmUgZW5vdWdoLCB3aXRoIHRoaXMgcGF0 Y2hzZXQgdGhlIHN5c3RlbSBoYW5ncyByZXN1bHRpbmcgZnJvbSBwaXBlCnVuZGVycnVucyBvbiBT a3lsYWtlIGhhdmUgY29tcGxldGVseSB2YW5pc2hlZCBvbiBteSBUNDYwcy4gQWRkaXRpb25hbGx5 LAp0aGUgYnNwZWMgbWVudGlvbnMgdHVybmluZyBvZmYgdGhlIFNBR1YJd2l0aCBtb3JlIHRoZW4g b25lIHBpcGUgZW5hYmxlZAphcyBhIHdvcmthcm91bmQgZm9yIGRpc3BsYXkgdW5kZXJydW5zLiBX aGlsZSB0aGlzIHBhdGNoIGRvZXNuJ3QgZW50aXJlbHkKZml4IHRoYXQsIGl0IGxvb2tzIGxpa2Ug aXQgZG9lcyBpbXByb3ZlIHRoZSBzaXR1YXRpb24gYSBsaXR0bGUgYml0IHNvCml0J3MgbGlrZWx5 IHRoaXMgaXMgZ29pbmcgdG8gYmUgcmVxdWlyZWQgdG8gbWFrZSB3YXRlcm1hcmtzIG9uIFNreWxh a2UKZnVsbHkgZnVuY3Rpb25hbC4KCkNoYW5nZXMgc2luY2UgdjU6CiAtIERvbid0IHVzZSBpc19w b3dlcl9vZl8yLiBNYWtlcyB0aGluZ3MgY29uZnVzaW5nCiAtIERvbid0IHVzZSB0aGUgb2xkIHN0 YXRlIHRvIGZpZ3VyZSBvdXQgd2hldGhlciBvciBub3QgdG8KICAgZW5hYmxlL2Rpc2FibGUgdGhl IHNhZ3YsIHVzZSB0aGUgbmV3IG9uZQogLSBTcGxpdCB0aGUgbG9vcCBpbiBza2xfZGlzYWJsZV9z YWd2IGludG8gaXQncyBvd24gZnVuY3Rpb24KIC0gTW92ZSBza2xfc2Fndl9lbmFibGUvZGlzYWJs ZSgpIGNhbGxzIGludG8gaW50ZWxfYXRvbWljX2NvbW1pdF90YWlsKCkKQ2hhbmdlcyBzaW5jZSB2 NDoKIC0gVXNlIGlzX3Bvd2VyX29mXzIgYWdhaW5zdCBhY3RpdmVfY3J0Y3MgdG8gY2hlY2sgd2hl dGhlciB3ZSBoYXZlID4gMQogICBwaXBlIGVuYWJsZWQKIC0gRml4IHNrbF9zYWd2X2dldF9od19z dGF0ZSgpOiAodGVtcCAmIDB4MSkgaW5kaWNhdGVzIGRpc2FibGVkLCAweDAKICAgZW5hYmxlZAog LSBDYWxsIHNrbF9zYWd2X2VuYWJsZS9kaXNhYmxlKCkgZnJvbSBwcmUvcG9zdC1wbGFuZSB1cGRh dGVzCkNoYW5nZXMgc2luY2UgdjM6CiAtIFVzZSB0aW1lX2JlZm9yZSgpIHRvIGNvbXBhcmUgdGlt ZW91dCB0byBqaWZmaWVzCkNoYW5nZXMgc2luY2UgdjI6CiAtIFJlYWxseSBhcHBseSBtaW5vciBz dHlsZSBuaXRwaWNrcyB0byBwYXRjaCB0aGlzIHRpbWUKQ2hhbmdlcyBzaW5jZSB2MToKIC0gQWRk ZWQgY29tbWVudHMgYWJvdXQgdGhpcyBwcm9iYWJseSBiZWluZyBvbmUgb2YgdGhlIHJlcXVpcmVt ZW50cyB0bwogICBmaXhpbmcgU2t5bGFrZSdzIHdhdGVybWFyayBpc3N1ZXMKIC0gTWlub3Igc3R5 bGUgbml0cGlja3MgZnJvbSBNYXR0IFJvcGVyCiAtIERpc2FibGUgdGhlc2UgZnVuY3Rpb25zIG9u IEJyb3h0b24sIHNpbmNlIGl0IGRvZXNuJ3QgaGF2ZSBhbiBTQUdWCgpSZXZpZXdlZC1ieTogTWF0 dCBSb3BlciA8bWF0dGhldy5kLnJvcGVyQGludGVsLmNvbT4KU2lnbmVkLW9mZi1ieTogTHl1ZGUg PGNwYXVsQHJlZGhhdC5jb20+CkNjOiBEYW5pZWwgVmV0dGVyIDxkYW5pZWwudmV0dGVyQGZmd2xs LmNoPgpDYzogVmlsbGUgU3lyasOkbMOkIDx2aWxsZS5zeXJqYWxhQGxpbnV4LmludGVsLmNvbT4K Q2M6IHN0YWJsZUB2Z2VyLmtlcm5lbC5vcmcKLS0tCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1 X2Rydi5oICAgICAgfCAgIDIgKwogZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9yZWcuaCAgICAg IHwgICA1ICsrCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMgfCAgMTEgKysr KwogZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmggICAgIHwgICAyICsKIGRyaXZlcnMv Z3B1L2RybS9pOTE1L2ludGVsX3BtLmMgICAgICB8IDExMiArKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKwogNSBmaWxlcyBjaGFuZ2VkLCAxMzIgaW5zZXJ0aW9ucygrKQoKZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmggYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pOTE1X2Rydi5oCmluZGV4IDY1YWRhNWQuLjg3MDE4ZDMgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkx NV9kcnYuaApAQCAtMTk2Miw2ICsxOTYyLDggQEAgc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgewog CXN0cnVjdCBpOTE1X3N1c3BlbmRfc2F2ZWRfcmVnaXN0ZXJzIHJlZ2ZpbGU7CiAJc3RydWN0IHZs dl9zMGl4X3N0YXRlIHZsdl9zMGl4X3N0YXRlOwogCisJYm9vbCBza2xfc2Fndl9lbmFibGVkOwor CiAJc3RydWN0IHsKIAkJLyoKIAkJICogUmF3IHdhdGVybWFyayBsYXRlbmN5IHZhbHVlczoKZGlm ZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfcmVnLmggYi9kcml2ZXJzL2dwdS9k cm0vaTkxNS9pOTE1X3JlZy5oCmluZGV4IDJmOTNkNGEuLjVmYjFjNjMgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfcmVnLmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUv aTkxNV9yZWcuaApAQCAtNzE3MCw2ICs3MTcwLDExIEBAIGVudW0gewogI2RlZmluZSAgIEhTV19Q Q09ERV9ERV9XUklURV9GUkVRX1JFUQkJMHgxNwogI2RlZmluZSAgIERJU1BMQVlfSVBTX0NPTlRS T0wJCQkweDE5CiAjZGVmaW5lCSAgSFNXX1BDT0RFX0RZTkFNSUNfRFVUWV9DWUNMRV9DT05UUk9M CTB4MUEKKyNkZWZpbmUgICBHRU45X1BDT0RFX1NBR1ZfQ09OVFJPTAkJMHgyMQorI2RlZmluZSAg ICAgR0VOOV9TQUdWX0RJU0FCTEUJCQkweDAKKyNkZWZpbmUgICAgIEdFTjlfU0FHVl9MT1dfRlJF UQkJCTB4MQorI2RlZmluZSAgICAgR0VOOV9TQUdWX0hJR0hfRlJFUQkJCTB4MgorI2RlZmluZSAg ICAgR0VOOV9TQUdWX0RZTkFNSUNfRlJFUSAgICAgICAgICAgICAgMHgzCiAjZGVmaW5lIEdFTjZf UENPREVfREFUQQkJCQlfTU1JTygweDEzODEyOCkKICNkZWZpbmUgICBHRU42X1BDT0RFX0ZSRVFf SUFfUkFUSU9fU0hJRlQJOAogI2RlZmluZSAgIEdFTjZfUENPREVfRlJFUV9SSU5HX1JBVElPX1NI SUZUCTE2CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMg Yi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMKaW5kZXggYThlOGNjOC4uMDAx Yzg4NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jCisr KyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYwpAQCAtMTM2OTIsNiArMTM2 OTIsMTQgQEAgc3RhdGljIHZvaWQgaW50ZWxfYXRvbWljX2NvbW1pdF90YWlsKHN0cnVjdCBkcm1f YXRvbWljX3N0YXRlICpzdGF0ZSkKIAkJICAgICBpbnRlbF9zdGF0ZS0+Y2RjbGtfcGxsX3ZjbyAh PSBkZXZfcHJpdi0+Y2RjbGtfcGxsLnZjbykpCiAJCQlkZXZfcHJpdi0+ZGlzcGxheS5tb2Rlc2V0 X2NvbW1pdF9jZGNsayhzdGF0ZSk7CiAKKwkJLyoKKwkJICogU0tMIHdvcmthcm91bmQ6IGJzcGVj IHJlY29tbWVuZHMgd2UgZGlzYWJsZSB0aGUgU0FHViB3aGVuIHdlCisJCSAqIGhhdmUgbW9yZSB0 aGVuIG9uZSBwaXBlIGVuYWJsZWQKKwkJICovCisJCWlmIChJU19TS1lMQUtFKGRldl9wcml2KSAm JgorCQkgICAgaHdlaWdodDMyKGludGVsX3N0YXRlLT5hY3RpdmVfY3J0Y3MpID4gMSkKKwkJCXNr bF9kaXNhYmxlX3NhZ3YoZGV2X3ByaXYpOworCiAJCWludGVsX21vZGVzZXRfdmVyaWZ5X2Rpc2Fi bGVkKGRldik7CiAJfQogCkBAIC0xMzc2NSw2ICsxMzc3Myw5IEBAIHN0YXRpYyB2b2lkIGludGVs X2F0b21pY19jb21taXRfdGFpbChzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUpCiAJCWlu dGVsX21vZGVzZXRfdmVyaWZ5X2NydGMoY3J0Yywgb2xkX2NydGNfc3RhdGUsIGNydGMtPnN0YXRl KTsKIAl9CiAKKwlpZiAoaHdlaWdodDMyKGludGVsX3N0YXRlLT5hY3RpdmVfY3J0Y3MpIDw9IDEp CisJCXNrbF9lbmFibGVfc2FndihkZXZfcHJpdik7CisKIAlkcm1fYXRvbWljX2hlbHBlcl9jb21t aXRfaHdfZG9uZShzdGF0ZSk7CiAKIAlpZiAoaW50ZWxfc3RhdGUtPm1vZGVzZXQpCmRpZmYgLS1n aXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaCBiL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2ludGVsX2Rydi5oCmluZGV4IDUwY2RjODkuLjZiMDUzMmEgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rydi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2lu dGVsX2Rydi5oCkBAIC0xNzA5LDYgKzE3MDksOCBAQCB2b2lkIGlsa193bV9nZXRfaHdfc3RhdGUo c3RydWN0IGRybV9kZXZpY2UgKmRldik7CiB2b2lkIHNrbF93bV9nZXRfaHdfc3RhdGUoc3RydWN0 IGRybV9kZXZpY2UgKmRldik7CiB2b2lkIHNrbF9kZGJfZ2V0X2h3X3N0YXRlKHN0cnVjdCBkcm1f aTkxNV9wcml2YXRlICpkZXZfcHJpdiwKIAkJCSAgc3RydWN0IHNrbF9kZGJfYWxsb2NhdGlvbiAq ZGRiIC8qIG91dCAqLyk7CitpbnQgc2tsX2VuYWJsZV9zYWd2KHN0cnVjdCBkcm1faTkxNV9wcml2 YXRlICpkZXZfcHJpdik7CitpbnQgc2tsX2Rpc2FibGVfc2FndihzdHJ1Y3QgZHJtX2k5MTVfcHJp dmF0ZSAqZGV2X3ByaXYpOwogdWludDMyX3QgaWxrX3BpcGVfcGl4ZWxfcmF0ZShjb25zdCBzdHJ1 Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqcGlwZV9jb25maWcpOwogYm9vbCBpbGtfZGlzYWJsZV9scF93 bShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KTsKIGludCBzYW5pdGl6ZV9yYzZfb3B0aW9uKHN0cnVj dCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiwgaW50IGVuYWJsZV9yYzYpOwpkaWZmIC0tZ2l0 IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcG0uYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2ludGVsX3BtLmMKaW5kZXggZjYxMGI3MS4uNjg3MjFhNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9n cHUvZHJtL2k5MTUvaW50ZWxfcG0uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9w bS5jCkBAIC0yODg0LDYgKzI4ODQsMTE2IEBAIHNrbF93bV9wbGFuZV9pZChjb25zdCBzdHJ1Y3Qg aW50ZWxfcGxhbmUgKnBsYW5lKQogfQogCiBzdGF0aWMgdm9pZAorc2tsX3NhZ3ZfZ2V0X2h3X3N0 YXRlKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdikKK3sKKwl1MzIgdGVtcDsKKwlp bnQgcmV0OworCisJaWYgKElTX0JST1hUT04oZGV2X3ByaXYpKQorCQlyZXR1cm47CisKKwltdXRl eF9sb2NrKCZkZXZfcHJpdi0+cnBzLmh3X2xvY2spOworCXJldCA9IHNhbmR5YnJpZGdlX3Bjb2Rl X3JlYWQoZGV2X3ByaXYsIEdFTjlfUENPREVfU0FHVl9DT05UUk9MLCAmdGVtcCk7CisJbXV0ZXhf dW5sb2NrKCZkZXZfcHJpdi0+cnBzLmh3X2xvY2spOworCisJaWYgKCFyZXQpIHsKKwkJZGV2X3By aXYtPnNrbF9zYWd2X2VuYWJsZWQgPSAhKHRlbXAgJiAweDEpOworCX0gZWxzZSB7CisJCS8qCisJ CSAqIElmIGZvciBzb21lIHJlYXNvbiB3ZSBjYW4ndCBhY2Nlc3MgdGhlIFNBR1Ygc3RhdGUsIGZv bGxvdworCQkgKiB0aGUgYnNwZWMgYW5kIGFzc3VtZSBpdCdzIGVuYWJsZWQKKwkJICovCisJCURS TV9FUlJPUigiRmFpbGVkIHRvIGdldCBTQUdWIHN0YXRlLCBhc3N1bWluZyBlbmFibGVkXG4iKTsK KwkJZGV2X3ByaXYtPnNrbF9zYWd2X2VuYWJsZWQgPSB0cnVlOworCX0KK30KKworLyoKKyAqIFNB R1YgZHluYW1pY2FsbHkgYWRqdXN0cyB0aGUgc3lzdGVtIGFnZW50IHZvbHRhZ2UgYW5kIGNsb2Nr IGZyZXF1ZW5jaWVzCisgKiBkZXBlbmRpbmcgb24gcG93ZXIgYW5kIHBlcmZvcm1hbmNlIHJlcXVp cmVtZW50cy4gVGhlIGRpc3BsYXkgZW5naW5lIGFjY2VzcworICogdG8gc3lzdGVtIG1lbW9yeSBp cyBibG9ja2VkIGR1cmluZyB0aGUgYWRqdXN0bWVudCB0aW1lLiBIYXZpbmcgdGhpcyBlbmFibGVk CisgKiBpbiBtdWx0aS1waXBlIGNvbmZpZ3VyYXRpb25zIGNhbiBjYXVzZSBpc3N1ZXMgKHN1Y2gg YXMgdW5kZXJydW5zIGNhdXNpbmcKKyAqIGZ1bGwgc3lzdGVtIGhhbmdzKSwgYW5kIHRoZSBic3Bl YyBhbHNvIHN1Z2dlc3RzIHRoYXQgc29mdHdhcmUgZGlzYWJsZSBpdAorICogd2hlbiBtb3JlIHRo ZW4gb25lIHBpcGUgaXMgZW5hYmxlZC4KKyAqLworaW50Citza2xfZW5hYmxlX3NhZ3Yoc3RydWN0 IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2KQoreworCWludCByZXQ7CisKKwlpZiAoSVNfQlJP WFRPTihkZXZfcHJpdikpCisJCXJldHVybiAwOworCWlmIChkZXZfcHJpdi0+c2tsX3NhZ3ZfZW5h YmxlZCkKKwkJcmV0dXJuIDA7CisKKwltdXRleF9sb2NrKCZkZXZfcHJpdi0+cnBzLmh3X2xvY2sp OworCURSTV9ERUJVR19LTVMoIkVuYWJsaW5nIHRoZSBTQUdWXG4iKTsKKworCXJldCA9IHNhbmR5 YnJpZGdlX3Bjb2RlX3dyaXRlKGRldl9wcml2LCBHRU45X1BDT0RFX1NBR1ZfQ09OVFJPTCwKKwkJ CQkgICAgICBHRU45X1NBR1ZfRFlOQU1JQ19GUkVRKTsKKwlpZiAoIXJldCkKKwkJZGV2X3ByaXYt PnNrbF9zYWd2X2VuYWJsZWQgPSB0cnVlOworCWVsc2UKKwkJRFJNX0VSUk9SKCJGYWlsZWQgdG8g ZW5hYmxlIHRoZSBTQUdWXG4iKTsKKworCS8qIFdlIGRvbid0IG5lZWQgdG8gd2FpdCBmb3IgU0FH ViB3aGVuIGVuYWJsaW5nICovCisJbXV0ZXhfdW5sb2NrKCZkZXZfcHJpdi0+cnBzLmh3X2xvY2sp OworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQKK3NrbF9kb19zYWd2X2Rpc2FibGUoc3Ry dWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2KQoreworCWludCByZXQ7CisJdWludDMyX3Qg dGVtcDsKKworCXJldCA9IHNhbmR5YnJpZGdlX3Bjb2RlX3dyaXRlKGRldl9wcml2LCBHRU45X1BD T0RFX1NBR1ZfQ09OVFJPTCwKKwkJCQkgICAgICBHRU45X1NBR1ZfRElTQUJMRSk7CisJaWYgKHJl dCkgeworCQlEUk1fRVJST1IoIkZhaWxlZCB0byBkaXNhYmxlIHRoZSBTQUdWXG4iKTsKKwkJcmV0 dXJuIHJldDsKKwl9CisKKwlyZXQgPSBzYW5keWJyaWRnZV9wY29kZV9yZWFkKGRldl9wcml2LCBH RU45X1BDT0RFX1NBR1ZfQ09OVFJPTCwKKwkJCQkgICAgICZ0ZW1wKTsKKwlpZiAocmV0KSB7CisJ CURSTV9FUlJPUigiRmFpbGVkIHRvIGNoZWNrIHRoZSBzdGF0dXMgb2YgdGhlIFNBR1ZcbiIpOwor CQlyZXR1cm4gcmV0OworCX0KKworCXJldHVybiB0ZW1wICYgMHgxOworfQorCitpbnQKK3NrbF9k aXNhYmxlX3NhZ3Yoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2KQoreworCWludCBy ZXQsIHJlc3VsdDsKKworCWlmIChJU19CUk9YVE9OKGRldl9wcml2KSkKKwkJcmV0dXJuIDA7CisJ aWYgKCFkZXZfcHJpdi0+c2tsX3NhZ3ZfZW5hYmxlZCkKKwkJcmV0dXJuIDA7CisKKwltdXRleF9s b2NrKCZkZXZfcHJpdi0+cnBzLmh3X2xvY2spOworCURSTV9ERUJVR19LTVMoIkRpc2FibGluZyB0 aGUgU0FHVlxuIik7CisKKwkvKiBic3BlYyBzYXlzIHRvIGtlZXAgcmV0cnlpbmcgZm9yIGF0IGxl YXN0IDEgbXMgKi8KKwlyZXQgPSB3YWl0X2ZvcihyZXN1bHQgPSBza2xfZG9fc2Fndl9kaXNhYmxl KGRldl9wcml2KSwgMSk7CisJbXV0ZXhfdW5sb2NrKCZkZXZfcHJpdi0+cnBzLmh3X2xvY2spOwor CisJaWYgKHJldCA9PSAtRVRJTUVET1VUKQorCQlEUk1fRVJST1IoIlJlcXVlc3QgdG8gZGlzYWJs ZSBTQUdWIHRpbWVkIG91dFxuIik7CisJZWxzZSB7CisJCWlmIChyZXN1bHQgPT0gMSkKKwkJCWRl dl9wcml2LT5za2xfc2Fndl9lbmFibGVkID0gZmFsc2U7CisKKwkJcmV0ID0gcmVzdWx0OworCX0K KworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyB2b2lkCiBza2xfZGRiX2dldF9waXBlX2FsbG9j YXRpb25fbGltaXRzKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCiAJCQkJICAgY29uc3Qgc3RydWN0 IGludGVsX2NydGNfc3RhdGUgKmNzdGF0ZSwKIAkJCQkgICBzdHJ1Y3Qgc2tsX2RkYl9lbnRyeSAq YWxsb2MsIC8qIG91dCAqLwpAQCAtNDIzNiw2ICs0MzQ2LDggQEAgdm9pZCBza2xfd21fZ2V0X2h3 X3N0YXRlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCiAJCS8qIEVhc3kvY29tbW9uIGNhc2U7IGp1 c3Qgc2FuaXRpemUgRERCIG5vdyBpZiBldmVyeXRoaW5nIG9mZiAqLwogCQltZW1zZXQoZGRiLCAw LCBzaXplb2YoKmRkYikpOwogCX0KKworCXNrbF9zYWd2X2dldF9od19zdGF0ZShkZXZfcHJpdik7 CiB9CiAKIHN0YXRpYyB2b2lkIGlsa19waXBlX3dtX2dldF9od19zdGF0ZShzdHJ1Y3QgZHJtX2Ny dGMgKmNydGMpCi0tIAoyLjcuNAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRl c2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8v ZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755952AbcHBWjn (ORCPT ); Tue, 2 Aug 2016 18:39:43 -0400 Received: from mx1.redhat.com ([209.132.183.28]:50214 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754135AbcHBWji (ORCPT ); Tue, 2 Aug 2016 18:39:38 -0400 From: Lyude To: intel-gfx@lists.freedesktop.org, =?UTF-8?q?Ville=20Syrj=C3=A4l=C3=A4?= , Maarten Lankhorst , Matt Roper Cc: Lyude , Daniel Vetter , stable@vger.kernel.org, Daniel Vetter , Jani Nikula , David Airlie , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Subject: [PATCH v6 1/6] drm/i915/skl: Add support for the SAGV, fix underrun hangs Date: Tue, 2 Aug 2016 18:37:32 -0400 Message-Id: <1470177458-31984-2-git-send-email-cpaul@redhat.com> In-Reply-To: <1470177458-31984-1-git-send-email-cpaul@redhat.com> References: <1470177458-31984-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.28]); Tue, 02 Aug 2016 22:38:10 +0000 (UTC) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Since the watermark calculations for Skylake are still broken, we're apt to hitting underruns very easily under multi-monitor configurations. While it would be lovely if this was fixed, it's not. Another problem that's been coming from this however, is the mysterious issue of underruns causing full system hangs. An easy way to reproduce this with a skylake system: - Get a laptop with a skylake GPU, and hook up two external monitors to it - Move the cursor from the built-in LCD to one of the external displays as quickly as you can - You'll get a few pipe underruns, and eventually the entire system will just freeze. After doing a lot of investigation and reading through the bspec, I found the existence of the SAGV, which is responsible for adjusting the system agent voltage and clock frequencies depending on how much power we need. According to the bspec: "The display engine access to system memory is blocked during the adjustment time. SAGV defaults to enabled. Software must use the GT-driver pcode mailbox to disable SAGV when the display engine is not able to tolerate the blocking time." The rest of the bspec goes on to explain that software can simply leave the SAGV enabled, and disable it when we use interlaced pipes/have more then one pipe active. Sure enough, with this patchset the system hangs resulting from pipe underruns on Skylake have completely vanished on my T460s. Additionally, the bspec mentions turning off the SAGV with more then one pipe enabled as a workaround for display underruns. While this patch doesn't entirely fix that, it looks like it does improve the situation a little bit so it's likely this is going to be required to make watermarks on Skylake fully functional. Changes since v5: - Don't use is_power_of_2. Makes things confusing - Don't use the old state to figure out whether or not to enable/disable the sagv, use the new one - Split the loop in skl_disable_sagv into it's own function - Move skl_sagv_enable/disable() calls into intel_atomic_commit_tail() Changes since v4: - Use is_power_of_2 against active_crtcs to check whether we have > 1 pipe enabled - Fix skl_sagv_get_hw_state(): (temp & 0x1) indicates disabled, 0x0 enabled - Call skl_sagv_enable/disable() from pre/post-plane updates Changes since v3: - Use time_before() to compare timeout to jiffies Changes since v2: - Really apply minor style nitpicks to patch this time Changes since v1: - Added comments about this probably being one of the requirements to fixing Skylake's watermark issues - Minor style nitpicks from Matt Roper - Disable these functions on Broxton, since it doesn't have an SAGV Reviewed-by: Matt Roper Signed-off-by: Lyude Cc: Daniel Vetter Cc: Ville Syrjälä Cc: stable@vger.kernel.org --- drivers/gpu/drm/i915/i915_drv.h | 2 + drivers/gpu/drm/i915/i915_reg.h | 5 ++ drivers/gpu/drm/i915/intel_display.c | 11 ++++ drivers/gpu/drm/i915/intel_drv.h | 2 + drivers/gpu/drm/i915/intel_pm.c | 112 +++++++++++++++++++++++++++++++++++ 5 files changed, 132 insertions(+) diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h index 65ada5d..87018d3 100644 --- a/drivers/gpu/drm/i915/i915_drv.h +++ b/drivers/gpu/drm/i915/i915_drv.h @@ -1962,6 +1962,8 @@ struct drm_i915_private { struct i915_suspend_saved_registers regfile; struct vlv_s0ix_state vlv_s0ix_state; + bool skl_sagv_enabled; + struct { /* * Raw watermark latency values: diff --git a/drivers/gpu/drm/i915/i915_reg.h b/drivers/gpu/drm/i915/i915_reg.h index 2f93d4a..5fb1c63 100644 --- a/drivers/gpu/drm/i915/i915_reg.h +++ b/drivers/gpu/drm/i915/i915_reg.h @@ -7170,6 +7170,11 @@ enum { #define HSW_PCODE_DE_WRITE_FREQ_REQ 0x17 #define DISPLAY_IPS_CONTROL 0x19 #define HSW_PCODE_DYNAMIC_DUTY_CYCLE_CONTROL 0x1A +#define GEN9_PCODE_SAGV_CONTROL 0x21 +#define GEN9_SAGV_DISABLE 0x0 +#define GEN9_SAGV_LOW_FREQ 0x1 +#define GEN9_SAGV_HIGH_FREQ 0x2 +#define GEN9_SAGV_DYNAMIC_FREQ 0x3 #define GEN6_PCODE_DATA _MMIO(0x138128) #define GEN6_PCODE_FREQ_IA_RATIO_SHIFT 8 #define GEN6_PCODE_FREQ_RING_RATIO_SHIFT 16 diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c index a8e8cc8..001c885 100644 --- a/drivers/gpu/drm/i915/intel_display.c +++ b/drivers/gpu/drm/i915/intel_display.c @@ -13692,6 +13692,14 @@ static void intel_atomic_commit_tail(struct drm_atomic_state *state) intel_state->cdclk_pll_vco != dev_priv->cdclk_pll.vco)) dev_priv->display.modeset_commit_cdclk(state); + /* + * SKL workaround: bspec recommends we disable the SAGV when we + * have more then one pipe enabled + */ + if (IS_SKYLAKE(dev_priv) && + hweight32(intel_state->active_crtcs) > 1) + skl_disable_sagv(dev_priv); + intel_modeset_verify_disabled(dev); } @@ -13765,6 +13773,9 @@ static void intel_atomic_commit_tail(struct drm_atomic_state *state) intel_modeset_verify_crtc(crtc, old_crtc_state, crtc->state); } + if (hweight32(intel_state->active_crtcs) <= 1) + skl_enable_sagv(dev_priv); + drm_atomic_helper_commit_hw_done(state); if (intel_state->modeset) diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h index 50cdc89..6b0532a 100644 --- a/drivers/gpu/drm/i915/intel_drv.h +++ b/drivers/gpu/drm/i915/intel_drv.h @@ -1709,6 +1709,8 @@ void ilk_wm_get_hw_state(struct drm_device *dev); void skl_wm_get_hw_state(struct drm_device *dev); void skl_ddb_get_hw_state(struct drm_i915_private *dev_priv, struct skl_ddb_allocation *ddb /* out */); +int skl_enable_sagv(struct drm_i915_private *dev_priv); +int skl_disable_sagv(struct drm_i915_private *dev_priv); uint32_t ilk_pipe_pixel_rate(const struct intel_crtc_state *pipe_config); bool ilk_disable_lp_wm(struct drm_device *dev); int sanitize_rc6_option(struct drm_i915_private *dev_priv, int enable_rc6); diff --git a/drivers/gpu/drm/i915/intel_pm.c b/drivers/gpu/drm/i915/intel_pm.c index f610b71..68721a5 100644 --- a/drivers/gpu/drm/i915/intel_pm.c +++ b/drivers/gpu/drm/i915/intel_pm.c @@ -2884,6 +2884,116 @@ skl_wm_plane_id(const struct intel_plane *plane) } static void +skl_sagv_get_hw_state(struct drm_i915_private *dev_priv) +{ + u32 temp; + int ret; + + if (IS_BROXTON(dev_priv)) + return; + + mutex_lock(&dev_priv->rps.hw_lock); + ret = sandybridge_pcode_read(dev_priv, GEN9_PCODE_SAGV_CONTROL, &temp); + mutex_unlock(&dev_priv->rps.hw_lock); + + if (!ret) { + dev_priv->skl_sagv_enabled = !(temp & 0x1); + } else { + /* + * If for some reason we can't access the SAGV state, follow + * the bspec and assume it's enabled + */ + DRM_ERROR("Failed to get SAGV state, assuming enabled\n"); + dev_priv->skl_sagv_enabled = true; + } +} + +/* + * SAGV dynamically adjusts the system agent voltage and clock frequencies + * depending on power and performance requirements. The display engine access + * to system memory is blocked during the adjustment time. Having this enabled + * in multi-pipe configurations can cause issues (such as underruns causing + * full system hangs), and the bspec also suggests that software disable it + * when more then one pipe is enabled. + */ +int +skl_enable_sagv(struct drm_i915_private *dev_priv) +{ + int ret; + + if (IS_BROXTON(dev_priv)) + return 0; + if (dev_priv->skl_sagv_enabled) + return 0; + + mutex_lock(&dev_priv->rps.hw_lock); + DRM_DEBUG_KMS("Enabling the SAGV\n"); + + ret = sandybridge_pcode_write(dev_priv, GEN9_PCODE_SAGV_CONTROL, + GEN9_SAGV_DYNAMIC_FREQ); + if (!ret) + dev_priv->skl_sagv_enabled = true; + else + DRM_ERROR("Failed to enable the SAGV\n"); + + /* We don't need to wait for SAGV when enabling */ + mutex_unlock(&dev_priv->rps.hw_lock); + return ret; +} + +static int +skl_do_sagv_disable(struct drm_i915_private *dev_priv) +{ + int ret; + uint32_t temp; + + ret = sandybridge_pcode_write(dev_priv, GEN9_PCODE_SAGV_CONTROL, + GEN9_SAGV_DISABLE); + if (ret) { + DRM_ERROR("Failed to disable the SAGV\n"); + return ret; + } + + ret = sandybridge_pcode_read(dev_priv, GEN9_PCODE_SAGV_CONTROL, + &temp); + if (ret) { + DRM_ERROR("Failed to check the status of the SAGV\n"); + return ret; + } + + return temp & 0x1; +} + +int +skl_disable_sagv(struct drm_i915_private *dev_priv) +{ + int ret, result; + + if (IS_BROXTON(dev_priv)) + return 0; + if (!dev_priv->skl_sagv_enabled) + return 0; + + mutex_lock(&dev_priv->rps.hw_lock); + DRM_DEBUG_KMS("Disabling the SAGV\n"); + + /* bspec says to keep retrying for at least 1 ms */ + ret = wait_for(result = skl_do_sagv_disable(dev_priv), 1); + mutex_unlock(&dev_priv->rps.hw_lock); + + if (ret == -ETIMEDOUT) + DRM_ERROR("Request to disable SAGV timed out\n"); + else { + if (result == 1) + dev_priv->skl_sagv_enabled = false; + + ret = result; + } + + return ret; +} + +static void skl_ddb_get_pipe_allocation_limits(struct drm_device *dev, const struct intel_crtc_state *cstate, struct skl_ddb_entry *alloc, /* out */ @@ -4236,6 +4346,8 @@ void skl_wm_get_hw_state(struct drm_device *dev) /* Easy/common case; just sanitize DDB now if everything off */ memset(ddb, 0, sizeof(*ddb)); } + + skl_sagv_get_hw_state(dev_priv); } static void ilk_pipe_wm_get_hw_state(struct drm_crtc *crtc) -- 2.7.4