From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Vetter Subject: Re: [PATCH v3 3/3] drm/i915: Use new CRC debugfs API Date: Wed, 3 Aug 2016 10:01:12 +0200 Message-ID: <20160803080112.GI6232@phenom.ffwll.local> References: <1469196645-3061-1-git-send-email-tomeu.vizoso@collabora.com> <1469196645-3061-4-git-send-email-tomeu.vizoso@collabora.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <1469196645-3061-4-git-send-email-tomeu.vizoso@collabora.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: Tomeu Vizoso Cc: Daniel Vetter , intel-gfx@lists.freedesktop.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, Emil Velikov List-Id: dri-devel@lists.freedesktop.org T24gRnJpLCBKdWwgMjIsIDIwMTYgYXQgMDQ6MTA6NDVQTSArMDIwMCwgVG9tZXUgVml6b3NvIHdy b3RlOgo+IFRoZSBjb3JlIHByb3ZpZGVzIG5vdyBhbiBBQkkgdG8gdXNlcnNwYWNlIGZvciBnZW5l cmF0aW9uIG9mIGZyYW1lIENSQ3MsCj4gc28gaW1wbGVtZW50IHRoZSAtPnNldF9jcmNfc291cmNl KCkgY2FsbGJhY2sgYW5kIHJldXNlIGFzIG11Y2ggY29kZSBhcwo+IHBvc3NpYmxlIHdpdGggdGhl IHByZXZpb3VzIEFCSSBpbXBsZW1lbnRhdGlvbi4KPiAKPiB2MjoKPiAgICAgLSBMZWF2ZSB0aGUg bGVnYWN5IGltcGxlbWVudGF0aW9uIGluIHBsYWNlIGFzIHRoZSBBQkkgaW1wbGVtZW50YXRpb24K PiAgICAgICBpbiB0aGUgY29yZSBpcyBpbmNvbXBhdGlibGUgd2l0aCBpdC4KPiB2MzoKPiAgICAg LSBVc2UgdGhlICJjb29rZWQiIHZibGFuayBjb3VudGVyIHNvIHdlIGhhdmUgYSB3aG9sZSAzMiBi aXRzLgoKVGhpcyBzaG91bGQgYmUgYSBzZXBhcmF0ZSBwYXRjaC4KCj4gICAgIC0gTWFrZSBzdXJl IHdlIGRvbid0IG1lc3Mgd2l0aCB0aGUgc3RhdGUgb2YgdGhlIGxlZ2FjeSBDUkMgY2FwdHVyZQo+ ICAgICAgIEFCSSBpbXBsZW1lbnRhdGlvbi4KCkhtLCBhcyBmb3Iga2VlcGluZyB0aGUgbGVnYWN5 IGRlYnVnZnMgaW50ZXJmYWNlIGFsaXZlIEkgdGhpbmsgaXQnZCBiZSBuaWNlCmlmIHdlIGNhbiBp bXBsZW1lbnQgdGhlIG9sZCBvbmUgaW50ZXJuYWwgd2l0aCB0aGUgbmV3IG9uZS4gSS5lLiBjYWxs IHRoZQpzZXRfY3JjX3NvdXJjIGZ1bmN0aW9uIChhZnRlciBtaW5pbWFsIHBhcnNpbmcpLCB1c2Ug dGhlIHNhbWUgcmluZ2J1ZmZlcgphbmQgcmV3b3JrIHRoZSByZWFkIGZ1bmN0aW9uIHRvIHVzZSB0 aGUgc2FtZSByaW5nYnVmZmVyLiBPciBtYXliZSB0aGF0J3MKbm90IHdvcnRoIGl0IHNpbmNlIHRo ZSBwbGFuIGlzIHRvIG51a2UgYWxsIHRoYXQgY29kZSBhbnl3YXkgYWZ0ZXIgYSBmZXcKbW9udGhz PwotRGFuaWVsCgo+IAo+IFNpZ25lZC1vZmYtYnk6IFRvbWV1IFZpem9zbyA8dG9tZXUudml6b3Nv QGNvbGxhYm9yYS5jb20+Cgo+IC0tLQo+IAo+ICBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2ly cS5jICAgICAgIHwgIDY5ICsrKysrKysrKysrKy0tLS0tLS0KPiAgZHJpdmVycy9ncHUvZHJtL2k5 MTUvaW50ZWxfZGlzcGxheS5jICB8ICAgMSArCj4gIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVs X2Rydi5oICAgICAgfCAgIDIgKwo+ICBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9waXBlX2Ny Yy5jIHwgMTI0ICsrKysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tLS0KPiAgNCBmaWxlcyBj aGFuZ2VkLCAxMzMgaW5zZXJ0aW9ucygrKSwgNjMgZGVsZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfaXJxLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkx NS9pOTE1X2lycS5jCj4gaW5kZXggYjc3ZDgwOGI3MWNkLi5mMjcyNjE3MWY3YzggMTAwNjQ0Cj4g LS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9pcnEuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2k5MTVfaXJxLmMKPiBAQCAtMTQ5Miw0MSArMTQ5Miw1OCBAQCBzdGF0aWMgdm9p ZCBkaXNwbGF5X3BpcGVfY3JjX2lycV9oYW5kbGVyKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpk ZXZfcHJpdiwKPiAgewo+ICAJc3RydWN0IGludGVsX3BpcGVfY3JjICpwaXBlX2NyYyA9ICZkZXZf cHJpdi0+cGlwZV9jcmNbcGlwZV07Cj4gIAlzdHJ1Y3QgaW50ZWxfcGlwZV9jcmNfZW50cnkgKmVu dHJ5Owo+IC0JaW50IGhlYWQsIHRhaWw7Cj4gKwlzdHJ1Y3QgZHJtX2NydGMgKmNydGMgPSBpbnRl bF9nZXRfY3J0Y19mb3JfcGlwZSgmZGV2X3ByaXYtPmRybSwgcGlwZSk7Cj4gKwlzdHJ1Y3QgZHJt X2RyaXZlciAqZHJpdmVyID0gZGV2X3ByaXYtPmRybS5kcml2ZXI7Cj4gKwl1aW50MzJfdCBjcmNz WzVdOwo+ICsJaW50IGhlYWQsIHRhaWwsIHJldDsKPiAgCj4gIAlzcGluX2xvY2soJnBpcGVfY3Jj LT5sb2NrKTsKPiArCWlmIChwaXBlX2NyYy0+c291cmNlKSB7Cj4gKwkJaWYgKCFwaXBlX2NyYy0+ ZW50cmllcykgewo+ICsJCQlzcGluX3VubG9jaygmcGlwZV9jcmMtPmxvY2spOwo+ICsJCQlEUk1f REVCVUdfS01TKCJzcHVyaW91cyBpbnRlcnJ1cHRcbiIpOwo+ICsJCQlyZXR1cm47Cj4gKwkJfQo+ ICAKPiAtCWlmICghcGlwZV9jcmMtPmVudHJpZXMpIHsKPiAtCQlzcGluX3VubG9jaygmcGlwZV9j cmMtPmxvY2spOwo+IC0JCURSTV9ERUJVR19LTVMoInNwdXJpb3VzIGludGVycnVwdFxuIik7Cj4g LQkJcmV0dXJuOwo+IC0JfQo+IC0KPiAtCWhlYWQgPSBwaXBlX2NyYy0+aGVhZDsKPiAtCXRhaWwg PSBwaXBlX2NyYy0+dGFpbDsKPiArCQloZWFkID0gcGlwZV9jcmMtPmhlYWQ7Cj4gKwkJdGFpbCA9 IHBpcGVfY3JjLT50YWlsOwo+ICAKPiAtCWlmIChDSVJDX1NQQUNFKGhlYWQsIHRhaWwsIElOVEVM X1BJUEVfQ1JDX0VOVFJJRVNfTlIpIDwgMSkgewo+IC0JCXNwaW5fdW5sb2NrKCZwaXBlX2NyYy0+ bG9jayk7Cj4gLQkJRFJNX0VSUk9SKCJDUkMgYnVmZmVyIG92ZXJmbG93aW5nXG4iKTsKPiAtCQly ZXR1cm47Cj4gLQl9Cj4gKwkJaWYgKENJUkNfU1BBQ0UoaGVhZCwgdGFpbCwgSU5URUxfUElQRV9D UkNfRU5UUklFU19OUikgPCAxKSB7Cj4gKwkJCXNwaW5fdW5sb2NrKCZwaXBlX2NyYy0+bG9jayk7 Cj4gKwkJCURSTV9FUlJPUigiQ1JDIGJ1ZmZlciBvdmVyZmxvd2luZ1xuIik7Cj4gKwkJCXJldHVy bjsKPiArCQl9Cj4gIAo+IC0JZW50cnkgPSAmcGlwZV9jcmMtPmVudHJpZXNbaGVhZF07Cj4gKwkJ ZW50cnkgPSAmcGlwZV9jcmMtPmVudHJpZXNbaGVhZF07Cj4gIAo+IC0JZW50cnktPmZyYW1lID0g ZGV2X3ByaXYtPmRybS5kcml2ZXItPmdldF92YmxhbmtfY291bnRlcigmZGV2X3ByaXYtPmRybSwK PiAtCQkJCQkJCQkgcGlwZSk7Cj4gLQllbnRyeS0+Y3JjWzBdID0gY3JjMDsKPiAtCWVudHJ5LT5j cmNbMV0gPSBjcmMxOwo+IC0JZW50cnktPmNyY1syXSA9IGNyYzI7Cj4gLQllbnRyeS0+Y3JjWzNd ID0gY3JjMzsKPiAtCWVudHJ5LT5jcmNbNF0gPSBjcmM0Owo+ICsJCWVudHJ5LT5mcmFtZSA9IGRy aXZlci0+Z2V0X3ZibGFua19jb3VudGVyKCZkZXZfcHJpdi0+ZHJtLCBwaXBlKTsKPiArCQllbnRy eS0+Y3JjWzBdID0gY3JjMDsKPiArCQllbnRyeS0+Y3JjWzFdID0gY3JjMTsKPiArCQllbnRyeS0+ Y3JjWzJdID0gY3JjMjsKPiArCQllbnRyeS0+Y3JjWzNdID0gY3JjMzsKPiArCQllbnRyeS0+Y3Jj WzRdID0gY3JjNDsKPiAgCj4gLQloZWFkID0gKGhlYWQgKyAxKSAmIChJTlRFTF9QSVBFX0NSQ19F TlRSSUVTX05SIC0gMSk7Cj4gLQlwaXBlX2NyYy0+aGVhZCA9IGhlYWQ7Cj4gKwkJaGVhZCA9ICho ZWFkICsgMSkgJiAoSU5URUxfUElQRV9DUkNfRU5UUklFU19OUiAtIDEpOwo+ICsJCXBpcGVfY3Jj LT5oZWFkID0gaGVhZDsKPiAgCj4gLQlzcGluX3VubG9jaygmcGlwZV9jcmMtPmxvY2spOwo+ICsJ CXNwaW5fdW5sb2NrKCZwaXBlX2NyYy0+bG9jayk7Cj4gIAo+IC0Jd2FrZV91cF9pbnRlcnJ1cHRp YmxlKCZwaXBlX2NyYy0+d3EpOwo+ICsJCXdha2VfdXBfaW50ZXJydXB0aWJsZSgmcGlwZV9jcmMt PndxKTsKPiArCX0gZWxzZSB7Cj4gKwkJc3Bpbl91bmxvY2soJnBpcGVfY3JjLT5sb2NrKTsKPiAr CQlzcGluX2xvY2soJmNydGMtPmNyYy5sb2NrKTsKPiArCQljcmNzWzBdID0gY3JjMDsKPiArCQlj cmNzWzFdID0gY3JjMTsKPiArCQljcmNzWzJdID0gY3JjMjsKPiArCQljcmNzWzNdID0gY3JjMzsK PiArCQljcmNzWzRdID0gY3JjNDsKPiArCQlyZXQgPSBkcm1fY3J0Y19hZGRfY3JjX2VudHJ5KGNy dGMsIHRydWUsCj4gKwkJCQkJICAgICBkcm1fYWNjdXJhdGVfdmJsYW5rX2NvdW50KGNydGMpLAo+ ICsJCQkJCSAgICAgY3Jjcyk7Cj4gKwkJc3Bpbl91bmxvY2soJmNydGMtPmNyYy5sb2NrKTsKPiAr CQlpZiAoIXJldCkKPiArCQkJd2FrZV91cF9pbnRlcnJ1cHRpYmxlKCZjcnRjLT5jcmMud3EpOwo+ ICsJfQo+ICB9Cj4gICNlbHNlCj4gIHN0YXRpYyBpbmxpbmUgdm9pZAo+IGRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkx NS9pbnRlbF9kaXNwbGF5LmMKPiBpbmRleCAxMTFiMzUwZDFkN2UuLmQ5MWEyZjc3OWZiMSAxMDA2 NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMKPiArKysgYi9k cml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMKPiBAQCAtMTQwMTksNiArMTQwMTks NyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGRybV9jcnRjX2Z1bmNzIGludGVsX2NydGNfZnVuY3Mg PSB7Cj4gIAkucGFnZV9mbGlwID0gaW50ZWxfY3J0Y19wYWdlX2ZsaXAsCj4gIAkuYXRvbWljX2R1 cGxpY2F0ZV9zdGF0ZSA9IGludGVsX2NydGNfZHVwbGljYXRlX3N0YXRlLAo+ICAJLmF0b21pY19k ZXN0cm95X3N0YXRlID0gaW50ZWxfY3J0Y19kZXN0cm95X3N0YXRlLAo+ICsJLnNldF9jcmNfc291 cmNlID0gaW50ZWxfY3J0Y19zZXRfY3JjX3NvdXJjZSwKPiAgfTsKPiAgCj4gIC8qKgo+IGRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaCBiL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2ludGVsX2Rydi5oCj4gaW5kZXggNWQwNmNiMjQyNWExLi40MzAyY2YyY2ZiMDQgMTAw NjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmgKPiArKysgYi9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaAo+IEBAIC0xNzgyLDYgKzE3ODIsOCBAQCB2b2lk IGludGVsX2NvbG9yX2xvYWRfbHV0cyhzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgKmNydGNfc3RhdGUp Owo+ICAvKiBpbnRlbF9waXBlX2NyYy5jICovCj4gIGludCBpbnRlbF9waXBlX2NyY19jcmVhdGUo c3RydWN0IGRybV9taW5vciAqbWlub3IpOwo+ICB2b2lkIGludGVsX3BpcGVfY3JjX2NsZWFudXAo c3RydWN0IGRybV9taW5vciAqbWlub3IpOwo+ICtpbnQgaW50ZWxfY3J0Y19zZXRfY3JjX3NvdXJj ZShzdHJ1Y3QgZHJtX2NydGMgKmNydGMsIGNvbnN0IGNoYXIgKnNvdXJjZV9uYW1lLAo+ICsJCQkg ICAgICBzaXplX3QgKnZhbHVlc19jbnQpOwo+ICBleHRlcm4gY29uc3Qgc3RydWN0IGZpbGVfb3Bl cmF0aW9ucyBpOTE1X2Rpc3BsYXlfY3JjX2N0bF9mb3BzOwo+ICAKPiAgI2VuZGlmIC8qIF9fSU5U RUxfRFJWX0hfXyAqLwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9w aXBlX2NyYy5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcGlwZV9jcmMuYwo+IGluZGV4 IDRlNmMyOGNlOGVjZi4uZDJmMDZhMWE5MTlhIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2ludGVsX3BpcGVfY3JjLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRl bF9waXBlX2NyYy5jCj4gQEAgLTYyNCwxNSArNjI0LDYyIEBAIHN0YXRpYyBpbnQgaXZiX3BpcGVf Y3JjX2N0bF9yZWcoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKPiAgCXJldHVybiAwOwo+ICB9Cj4g IAo+ICtzdGF0aWMgaW50IGRvX3NldF9jcmNfc291cmNlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYs IGVudW0gcGlwZSBwaXBlLAo+ICsJCQkgICAgIGVudW0gaW50ZWxfcGlwZV9jcmNfc291cmNlIHNv dXJjZSkKPiArewo+ICsJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2ID0gZGV2LT5k ZXZfcHJpdmF0ZTsKPiArCXN0cnVjdCBpbnRlbF9jcnRjICpjcnRjID0gdG9faW50ZWxfY3J0Yyhp bnRlbF9nZXRfY3J0Y19mb3JfcGlwZShkZXYsCj4gKwkJCQkJCQkJCXBpcGUpKTsKPiArCXUzMiB2 YWwgPSAwOyAvKiBzaHV0IHVwIGdjYyAqLwo+ICsJaW50IHJldDsKPiArCj4gKwlpZiAoSVNfR0VO MihkZXYpKQo+ICsJCXJldCA9IGk4eHhfcGlwZV9jcmNfY3RsX3JlZygmc291cmNlLCAmdmFsKTsK PiArCWVsc2UgaWYgKElOVEVMX0lORk8oZGV2KS0+Z2VuIDwgNSkKPiArCQlyZXQgPSBpOXh4X3Bp cGVfY3JjX2N0bF9yZWcoZGV2LCBwaXBlLCAmc291cmNlLCAmdmFsKTsKPiArCWVsc2UgaWYgKElT X1ZBTExFWVZJRVcoZGV2KSB8fCBJU19DSEVSUllWSUVXKGRldikpCj4gKwkJcmV0ID0gdmx2X3Bp cGVfY3JjX2N0bF9yZWcoZGV2LCBwaXBlLCAmc291cmNlLCAmdmFsKTsKPiArCWVsc2UgaWYgKElT X0dFTjUoZGV2KSB8fCBJU19HRU42KGRldikpCj4gKwkJcmV0ID0gaWxrX3BpcGVfY3JjX2N0bF9y ZWcoJnNvdXJjZSwgJnZhbCk7Cj4gKwllbHNlCj4gKwkJcmV0ID0gaXZiX3BpcGVfY3JjX2N0bF9y ZWcoZGV2LCBwaXBlLCAmc291cmNlLCAmdmFsKTsKPiArCj4gKwlpZiAocmV0KQo+ICsJCXJldHVy biByZXQ7Cj4gKwo+ICsJaWYgKHNvdXJjZSkgewo+ICsJCS8qCj4gKwkJICogV2hlbiBJUFMgZ2V0 cyBlbmFibGVkLCB0aGUgcGlwZSBDUkMgY2hhbmdlcy4gU2luY2UgSVBTIGdldHMKPiArCQkgKiBl bmFibGVkIGFuZCBkaXNhYmxlZCBkeW5hbWljYWxseSBiYXNlZCBvbiBwYWNrYWdlIEMgc3RhdGVz LAo+ICsJCSAqIHVzZXIgc3BhY2UgY2FuJ3QgbWFrZSByZWxpYWJsZSB1c2Ugb2YgdGhlIENSQ3Ms IHNvIGxldCdzIGp1c3QKPiArCQkgKiBjb21wbGV0ZWx5IGRpc2FibGUgaXQuCj4gKwkJICovCj4g KwkJaHN3X2Rpc2FibGVfaXBzKGNydGMpOwo+ICsJfQo+ICsKPiArCUk5MTVfV1JJVEUoUElQRV9D UkNfQ1RMKHBpcGUpLCB2YWwpOwo+ICsJUE9TVElOR19SRUFEKFBJUEVfQ1JDX0NUTChwaXBlKSk7 Cj4gKwo+ICsJaWYgKHNvdXJjZSA9PSBJTlRFTF9QSVBFX0NSQ19TT1VSQ0VfTk9ORSkgewo+ICsJ CWlmIChJU19HNFgoZGV2KSkKPiArCQkJZzR4X3VuZG9fcGlwZV9zY3JhbWJsZV9yZXNldChkZXYs IHBpcGUpOwo+ICsJCWVsc2UgaWYgKElTX1ZBTExFWVZJRVcoZGV2KSB8fCBJU19DSEVSUllWSUVX KGRldikpCj4gKwkJCXZsdl91bmRvX3BpcGVfc2NyYW1ibGVfcmVzZXQoZGV2LCBwaXBlKTsKPiAr CQllbHNlIGlmIChJU19IQVNXRUxMKGRldikgJiYgcGlwZSA9PSBQSVBFX0EpCj4gKwkJCWhzd190 cmFuc19lZHBfcGlwZV9BX2NyY193YShkZXYsIGZhbHNlKTsKPiArCj4gKwkJaHN3X2VuYWJsZV9p cHMoY3J0Yyk7Cj4gKwl9Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gIHN0YXRpYyBpbnQg cGlwZV9jcmNfc2V0X3NvdXJjZShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBlbnVtIHBpcGUgcGlw ZSwKPiAgCQkJICAgICAgIGVudW0gaW50ZWxfcGlwZV9jcmNfc291cmNlIHNvdXJjZSkKPiAgewo+ ICAJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsK PiAgCXN0cnVjdCBpbnRlbF9waXBlX2NyYyAqcGlwZV9jcmMgPSAmZGV2X3ByaXYtPnBpcGVfY3Jj W3BpcGVdOwo+IC0Jc3RydWN0IGludGVsX2NydGMgKmNydGMgPSB0b19pbnRlbF9jcnRjKGludGVs X2dldF9jcnRjX2Zvcl9waXBlKGRldiwKPiAtCQkJCQkJCQkJcGlwZSkpOwo+ICAJZW51bSBpbnRl bF9kaXNwbGF5X3Bvd2VyX2RvbWFpbiBwb3dlcl9kb21haW47Cj4gLQl1MzIgdmFsID0gMDsgLyog c2h1dCB1cCBnY2MgKi8KPiAgCWludCByZXQ7Cj4gIAo+ICAJaWYgKHBpcGVfY3JjLT5zb3VyY2Ug PT0gc291cmNlKQo+IEBAIC02NDgsMjAgKzY5NSw2IEBAIHN0YXRpYyBpbnQgcGlwZV9jcmNfc2V0 X3NvdXJjZShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBlbnVtIHBpcGUgcGlwZSwKPiAgCQlyZXR1 cm4gLUVJTzsKPiAgCX0KPiAgCj4gLQlpZiAoSVNfR0VOMihkZXYpKQo+IC0JCXJldCA9IGk4eHhf cGlwZV9jcmNfY3RsX3JlZygmc291cmNlLCAmdmFsKTsKPiAtCWVsc2UgaWYgKElOVEVMX0lORk8o ZGV2KS0+Z2VuIDwgNSkKPiAtCQlyZXQgPSBpOXh4X3BpcGVfY3JjX2N0bF9yZWcoZGV2LCBwaXBl LCAmc291cmNlLCAmdmFsKTsKPiAtCWVsc2UgaWYgKElTX1ZBTExFWVZJRVcoZGV2KSB8fCBJU19D SEVSUllWSUVXKGRldikpCj4gLQkJcmV0ID0gdmx2X3BpcGVfY3JjX2N0bF9yZWcoZGV2LCBwaXBl LCAmc291cmNlLCAmdmFsKTsKPiAtCWVsc2UgaWYgKElTX0dFTjUoZGV2KSB8fCBJU19HRU42KGRl dikpCj4gLQkJcmV0ID0gaWxrX3BpcGVfY3JjX2N0bF9yZWcoJnNvdXJjZSwgJnZhbCk7Cj4gLQll bHNlCj4gLQkJcmV0ID0gaXZiX3BpcGVfY3JjX2N0bF9yZWcoZGV2LCBwaXBlLCAmc291cmNlLCAm dmFsKTsKPiAtCj4gLQlpZiAocmV0ICE9IDApCj4gLQkJZ290byBvdXQ7Cj4gLQo+ICAJLyogbm9u ZSAtPiByZWFsIHNvdXJjZSB0cmFuc2l0aW9uICovCj4gIAlpZiAoc291cmNlKSB7Cj4gIAkJc3Ry dWN0IGludGVsX3BpcGVfY3JjX2VudHJ5ICplbnRyaWVzOwo+IEBAIC02NzcsMTQgKzcxMCw2IEBA IHN0YXRpYyBpbnQgcGlwZV9jcmNfc2V0X3NvdXJjZShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBl bnVtIHBpcGUgcGlwZSwKPiAgCQkJZ290byBvdXQ7Cj4gIAkJfQo+ICAKPiAtCQkvKgo+IC0JCSAq IFdoZW4gSVBTIGdldHMgZW5hYmxlZCwgdGhlIHBpcGUgQ1JDIGNoYW5nZXMuIFNpbmNlIElQUyBn ZXRzCj4gLQkJICogZW5hYmxlZCBhbmQgZGlzYWJsZWQgZHluYW1pY2FsbHkgYmFzZWQgb24gcGFj a2FnZSBDIHN0YXRlcywKPiAtCQkgKiB1c2VyIHNwYWNlIGNhbid0IG1ha2UgcmVsaWFibGUgdXNl IG9mIHRoZSBDUkNzLCBzbyBsZXQncyBqdXN0Cj4gLQkJICogY29tcGxldGVseSBkaXNhYmxlIGl0 Lgo+IC0JCSAqLwo+IC0JCWhzd19kaXNhYmxlX2lwcyhjcnRjKTsKPiAtCj4gIAkJc3Bpbl9sb2Nr X2lycSgmcGlwZV9jcmMtPmxvY2spOwo+ICAJCWtmcmVlKHBpcGVfY3JjLT5lbnRyaWVzKTsKPiAg CQlwaXBlX2NyYy0+ZW50cmllcyA9IGVudHJpZXM7Cj4gQEAgLTY5MywxMCArNzE4LDExIEBAIHN0 YXRpYyBpbnQgcGlwZV9jcmNfc2V0X3NvdXJjZShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBlbnVt IHBpcGUgcGlwZSwKPiAgCQlzcGluX3VubG9ja19pcnEoJnBpcGVfY3JjLT5sb2NrKTsKPiAgCX0K PiAgCj4gLQlwaXBlX2NyYy0+c291cmNlID0gc291cmNlOwo+ICsJcmV0ID0gZG9fc2V0X2NyY19z b3VyY2UoZGV2LCBwaXBlLCBzb3VyY2UpOwo+ICsJaWYgKHJldCkKPiArCQlnb3RvIG91dDsKPiAg Cj4gLQlJOTE1X1dSSVRFKFBJUEVfQ1JDX0NUTChwaXBlKSwgdmFsKTsKPiAtCVBPU1RJTkdfUkVB RChQSVBFX0NSQ19DVEwocGlwZSkpOwo+ICsJcGlwZV9jcmMtPnNvdXJjZSA9IHNvdXJjZTsKPiAg Cj4gIAkvKiByZWFsIHNvdXJjZSAtPiBub25lIHRyYW5zaXRpb24gKi8KPiAgCWlmIChzb3VyY2Ug PT0gSU5URUxfUElQRV9DUkNfU09VUkNFX05PTkUpIHsKPiBAQCAtNzIwLDE1ICs3NDYsNiBAQCBz dGF0aWMgaW50IHBpcGVfY3JjX3NldF9zb3VyY2Uoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgZW51 bSBwaXBlIHBpcGUsCj4gIAkJc3Bpbl91bmxvY2tfaXJxKCZwaXBlX2NyYy0+bG9jayk7Cj4gIAo+ ICAJCWtmcmVlKGVudHJpZXMpOwo+IC0KPiAtCQlpZiAoSVNfRzRYKGRldikpCj4gLQkJCWc0eF91 bmRvX3BpcGVfc2NyYW1ibGVfcmVzZXQoZGV2LCBwaXBlKTsKPiAtCQllbHNlIGlmIChJU19WQUxM RVlWSUVXKGRldikgfHwgSVNfQ0hFUlJZVklFVyhkZXYpKQo+IC0JCQl2bHZfdW5kb19waXBlX3Nj cmFtYmxlX3Jlc2V0KGRldiwgcGlwZSk7Cj4gLQkJZWxzZSBpZiAoSVNfSEFTV0VMTChkZXYpICYm IHBpcGUgPT0gUElQRV9BKQo+IC0JCQloc3dfdHJhbnNfZWRwX3BpcGVfQV9jcmNfd2EoZGV2LCBm YWxzZSk7Cj4gLQo+IC0JCWhzd19lbmFibGVfaXBzKGNydGMpOwo+ICAJfQo+ICAKPiAgCXJldCA9 IDA7Cj4gQEAgLTgyMSw2ICs4MzgsMTEgQEAgZGlzcGxheV9jcmNfY3RsX3BhcnNlX3NvdXJjZShj b25zdCBjaGFyICpidWYsIGVudW0gaW50ZWxfcGlwZV9jcmNfc291cmNlICpzKQo+ICB7Cj4gIAlp bnQgaTsKPiAgCj4gKwlpZiAoIWJ1Zikgewo+ICsJCSpzID0gSU5URUxfUElQRV9DUkNfU09VUkNF X05PTkU7Cj4gKwkJcmV0dXJuIDA7Cj4gKwl9Cj4gKwo+ICAJZm9yIChpID0gMDsgaSA8IEFSUkFZ X1NJWkUocGlwZV9jcmNfc291cmNlcyk7IGkrKykKPiAgCQlpZiAoIXN0cmNtcChidWYsIHBpcGVf Y3JjX3NvdXJjZXNbaV0pKSB7Cj4gIAkJCSpzID0gaTsKPiBAQCAtOTQ5LDMgKzk3MSwzMSBAQCB2 b2lkIGludGVsX3BpcGVfY3JjX2NsZWFudXAoc3RydWN0IGRybV9taW5vciAqbWlub3IpCj4gIAkJ ZHJtX2RlYnVnZnNfcmVtb3ZlX2ZpbGVzKGluZm9fbGlzdCwgMSwgbWlub3IpOwo+ICAJfQo+ICB9 Cj4gKwo+ICtpbnQgaW50ZWxfY3J0Y19zZXRfY3JjX3NvdXJjZShzdHJ1Y3QgZHJtX2NydGMgKmNy dGMsIGNvbnN0IGNoYXIgKnNvdXJjZV9uYW1lLAo+ICsJCQkgICAgICBzaXplX3QgKnZhbHVlc19j bnQpCj4gK3sKPiArCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IGNydGMtPmRl di0+ZGV2X3ByaXZhdGU7Cj4gKwllbnVtIGludGVsX2Rpc3BsYXlfcG93ZXJfZG9tYWluIHBvd2Vy X2RvbWFpbjsKPiArCWVudW0gaW50ZWxfcGlwZV9jcmNfc291cmNlIHNvdXJjZTsKPiArCWludCBy ZXQ7Cj4gKwo+ICsJaWYgKGRpc3BsYXlfY3JjX2N0bF9wYXJzZV9zb3VyY2Uoc291cmNlX25hbWUs ICZzb3VyY2UpIDwgMCkgewo+ICsJCURSTV9ERUJVR19EUklWRVIoInVua25vd24gc291cmNlICVz XG4iLCBzb3VyY2VfbmFtZSk7Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwl9Cj4gKwo+ICsJcG93 ZXJfZG9tYWluID0gUE9XRVJfRE9NQUlOX1BJUEUoY3J0Yy0+aW5kZXgpOwo+ICsJaWYgKCFpbnRl bF9kaXNwbGF5X3Bvd2VyX2dldF9pZl9lbmFibGVkKGRldl9wcml2LCBwb3dlcl9kb21haW4pKSB7 Cj4gKwkJRFJNX0RFQlVHX0tNUygiVHJ5aW5nIHRvIGNhcHR1cmUgQ1JDIHdoaWxlIHBpcGUgaXMg b2ZmXG4iKTsKPiArCQlyZXR1cm4gLUVJTzsKPiArCX0KPiArCj4gKwlyZXQgPSBkb19zZXRfY3Jj X3NvdXJjZShjcnRjLT5kZXYsIGNydGMtPmluZGV4LCBzb3VyY2UpOwo+ICsKPiArCWludGVsX2Rp c3BsYXlfcG93ZXJfcHV0KGRldl9wcml2LCBwb3dlcl9kb21haW4pOwo+ICsKPiArCSp2YWx1ZXNf Y250ID0gNTsKPiArCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gLS0gCj4gMi41LjUKPiAKPiBfX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwo+IGRyaS1kZXZlbCBt YWlsaW5nIGxpc3QKPiBkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCj4gaHR0cHM6Ly9s aXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwKCi0tIApEYW5p ZWwgVmV0dGVyClNvZnR3YXJlIEVuZ2luZWVyLCBJbnRlbCBDb3Jwb3JhdGlvbgpodHRwOi8vYmxv Zy5mZndsbC5jaApfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f XwpJbnRlbC1nZnggbWFpbGluZyBsaXN0CkludGVsLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcK aHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZngK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1756492AbcHCICt (ORCPT ); Wed, 3 Aug 2016 04:02:49 -0400 Received: from mail-wm0-f68.google.com ([74.125.82.68]:33824 "EHLO mail-wm0-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755280AbcHCICe (ORCPT ); Wed, 3 Aug 2016 04:02:34 -0400 Date: Wed, 3 Aug 2016 10:01:12 +0200 From: Daniel Vetter To: Tomeu Vizoso Cc: linux-kernel@vger.kernel.org, intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org, Daniel Vetter , Emil Velikov Subject: Re: [PATCH v3 3/3] drm/i915: Use new CRC debugfs API Message-ID: <20160803080112.GI6232@phenom.ffwll.local> Mail-Followup-To: Tomeu Vizoso , linux-kernel@vger.kernel.org, intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org, Daniel Vetter , Emil Velikov References: <1469196645-3061-1-git-send-email-tomeu.vizoso@collabora.com> <1469196645-3061-4-git-send-email-tomeu.vizoso@collabora.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <1469196645-3061-4-git-send-email-tomeu.vizoso@collabora.com> X-Operating-System: Linux phenom 4.6.0-1-amd64 User-Agent: Mutt/1.6.0 (2016-04-01) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Fri, Jul 22, 2016 at 04:10:45PM +0200, Tomeu Vizoso wrote: > The core provides now an ABI to userspace for generation of frame CRCs, > so implement the ->set_crc_source() callback and reuse as much code as > possible with the previous ABI implementation. > > v2: > - Leave the legacy implementation in place as the ABI implementation > in the core is incompatible with it. > v3: > - Use the "cooked" vblank counter so we have a whole 32 bits. This should be a separate patch. > - Make sure we don't mess with the state of the legacy CRC capture > ABI implementation. Hm, as for keeping the legacy debugfs interface alive I think it'd be nice if we can implement the old one internal with the new one. I.e. call the set_crc_sourc function (after minimal parsing), use the same ringbuffer and rework the read function to use the same ringbuffer. Or maybe that's not worth it since the plan is to nuke all that code anyway after a few months? -Daniel > > Signed-off-by: Tomeu Vizoso > --- > > drivers/gpu/drm/i915/i915_irq.c | 69 ++++++++++++------- > drivers/gpu/drm/i915/intel_display.c | 1 + > drivers/gpu/drm/i915/intel_drv.h | 2 + > drivers/gpu/drm/i915/intel_pipe_crc.c | 124 ++++++++++++++++++++++++---------- > 4 files changed, 133 insertions(+), 63 deletions(-) > > diff --git a/drivers/gpu/drm/i915/i915_irq.c b/drivers/gpu/drm/i915/i915_irq.c > index b77d808b71cd..f2726171f7c8 100644 > --- a/drivers/gpu/drm/i915/i915_irq.c > +++ b/drivers/gpu/drm/i915/i915_irq.c > @@ -1492,41 +1492,58 @@ static void display_pipe_crc_irq_handler(struct drm_i915_private *dev_priv, > { > struct intel_pipe_crc *pipe_crc = &dev_priv->pipe_crc[pipe]; > struct intel_pipe_crc_entry *entry; > - int head, tail; > + struct drm_crtc *crtc = intel_get_crtc_for_pipe(&dev_priv->drm, pipe); > + struct drm_driver *driver = dev_priv->drm.driver; > + uint32_t crcs[5]; > + int head, tail, ret; > > spin_lock(&pipe_crc->lock); > + if (pipe_crc->source) { > + if (!pipe_crc->entries) { > + spin_unlock(&pipe_crc->lock); > + DRM_DEBUG_KMS("spurious interrupt\n"); > + return; > + } > > - if (!pipe_crc->entries) { > - spin_unlock(&pipe_crc->lock); > - DRM_DEBUG_KMS("spurious interrupt\n"); > - return; > - } > - > - head = pipe_crc->head; > - tail = pipe_crc->tail; > + head = pipe_crc->head; > + tail = pipe_crc->tail; > > - if (CIRC_SPACE(head, tail, INTEL_PIPE_CRC_ENTRIES_NR) < 1) { > - spin_unlock(&pipe_crc->lock); > - DRM_ERROR("CRC buffer overflowing\n"); > - return; > - } > + if (CIRC_SPACE(head, tail, INTEL_PIPE_CRC_ENTRIES_NR) < 1) { > + spin_unlock(&pipe_crc->lock); > + DRM_ERROR("CRC buffer overflowing\n"); > + return; > + } > > - entry = &pipe_crc->entries[head]; > + entry = &pipe_crc->entries[head]; > > - entry->frame = dev_priv->drm.driver->get_vblank_counter(&dev_priv->drm, > - pipe); > - entry->crc[0] = crc0; > - entry->crc[1] = crc1; > - entry->crc[2] = crc2; > - entry->crc[3] = crc3; > - entry->crc[4] = crc4; > + entry->frame = driver->get_vblank_counter(&dev_priv->drm, pipe); > + entry->crc[0] = crc0; > + entry->crc[1] = crc1; > + entry->crc[2] = crc2; > + entry->crc[3] = crc3; > + entry->crc[4] = crc4; > > - head = (head + 1) & (INTEL_PIPE_CRC_ENTRIES_NR - 1); > - pipe_crc->head = head; > + head = (head + 1) & (INTEL_PIPE_CRC_ENTRIES_NR - 1); > + pipe_crc->head = head; > > - spin_unlock(&pipe_crc->lock); > + spin_unlock(&pipe_crc->lock); > > - wake_up_interruptible(&pipe_crc->wq); > + wake_up_interruptible(&pipe_crc->wq); > + } else { > + spin_unlock(&pipe_crc->lock); > + spin_lock(&crtc->crc.lock); > + crcs[0] = crc0; > + crcs[1] = crc1; > + crcs[2] = crc2; > + crcs[3] = crc3; > + crcs[4] = crc4; > + ret = drm_crtc_add_crc_entry(crtc, true, > + drm_accurate_vblank_count(crtc), > + crcs); > + spin_unlock(&crtc->crc.lock); > + if (!ret) > + wake_up_interruptible(&crtc->crc.wq); > + } > } > #else > static inline void > diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c > index 111b350d1d7e..d91a2f779fb1 100644 > --- a/drivers/gpu/drm/i915/intel_display.c > +++ b/drivers/gpu/drm/i915/intel_display.c > @@ -14019,6 +14019,7 @@ static const struct drm_crtc_funcs intel_crtc_funcs = { > .page_flip = intel_crtc_page_flip, > .atomic_duplicate_state = intel_crtc_duplicate_state, > .atomic_destroy_state = intel_crtc_destroy_state, > + .set_crc_source = intel_crtc_set_crc_source, > }; > > /** > diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h > index 5d06cb2425a1..4302cf2cfb04 100644 > --- a/drivers/gpu/drm/i915/intel_drv.h > +++ b/drivers/gpu/drm/i915/intel_drv.h > @@ -1782,6 +1782,8 @@ void intel_color_load_luts(struct drm_crtc_state *crtc_state); > /* intel_pipe_crc.c */ > int intel_pipe_crc_create(struct drm_minor *minor); > void intel_pipe_crc_cleanup(struct drm_minor *minor); > +int intel_crtc_set_crc_source(struct drm_crtc *crtc, const char *source_name, > + size_t *values_cnt); > extern const struct file_operations i915_display_crc_ctl_fops; > > #endif /* __INTEL_DRV_H__ */ > diff --git a/drivers/gpu/drm/i915/intel_pipe_crc.c b/drivers/gpu/drm/i915/intel_pipe_crc.c > index 4e6c28ce8ecf..d2f06a1a919a 100644 > --- a/drivers/gpu/drm/i915/intel_pipe_crc.c > +++ b/drivers/gpu/drm/i915/intel_pipe_crc.c > @@ -624,15 +624,62 @@ static int ivb_pipe_crc_ctl_reg(struct drm_device *dev, > return 0; > } > > +static int do_set_crc_source(struct drm_device *dev, enum pipe pipe, > + enum intel_pipe_crc_source source) > +{ > + struct drm_i915_private *dev_priv = dev->dev_private; > + struct intel_crtc *crtc = to_intel_crtc(intel_get_crtc_for_pipe(dev, > + pipe)); > + u32 val = 0; /* shut up gcc */ > + int ret; > + > + if (IS_GEN2(dev)) > + ret = i8xx_pipe_crc_ctl_reg(&source, &val); > + else if (INTEL_INFO(dev)->gen < 5) > + ret = i9xx_pipe_crc_ctl_reg(dev, pipe, &source, &val); > + else if (IS_VALLEYVIEW(dev) || IS_CHERRYVIEW(dev)) > + ret = vlv_pipe_crc_ctl_reg(dev, pipe, &source, &val); > + else if (IS_GEN5(dev) || IS_GEN6(dev)) > + ret = ilk_pipe_crc_ctl_reg(&source, &val); > + else > + ret = ivb_pipe_crc_ctl_reg(dev, pipe, &source, &val); > + > + if (ret) > + return ret; > + > + if (source) { > + /* > + * When IPS gets enabled, the pipe CRC changes. Since IPS gets > + * enabled and disabled dynamically based on package C states, > + * user space can't make reliable use of the CRCs, so let's just > + * completely disable it. > + */ > + hsw_disable_ips(crtc); > + } > + > + I915_WRITE(PIPE_CRC_CTL(pipe), val); > + POSTING_READ(PIPE_CRC_CTL(pipe)); > + > + if (source == INTEL_PIPE_CRC_SOURCE_NONE) { > + if (IS_G4X(dev)) > + g4x_undo_pipe_scramble_reset(dev, pipe); > + else if (IS_VALLEYVIEW(dev) || IS_CHERRYVIEW(dev)) > + vlv_undo_pipe_scramble_reset(dev, pipe); > + else if (IS_HASWELL(dev) && pipe == PIPE_A) > + hsw_trans_edp_pipe_A_crc_wa(dev, false); > + > + hsw_enable_ips(crtc); > + } > + > + return 0; > +} > + > static int pipe_crc_set_source(struct drm_device *dev, enum pipe pipe, > enum intel_pipe_crc_source source) > { > struct drm_i915_private *dev_priv = dev->dev_private; > struct intel_pipe_crc *pipe_crc = &dev_priv->pipe_crc[pipe]; > - struct intel_crtc *crtc = to_intel_crtc(intel_get_crtc_for_pipe(dev, > - pipe)); > enum intel_display_power_domain power_domain; > - u32 val = 0; /* shut up gcc */ > int ret; > > if (pipe_crc->source == source) > @@ -648,20 +695,6 @@ static int pipe_crc_set_source(struct drm_device *dev, enum pipe pipe, > return -EIO; > } > > - if (IS_GEN2(dev)) > - ret = i8xx_pipe_crc_ctl_reg(&source, &val); > - else if (INTEL_INFO(dev)->gen < 5) > - ret = i9xx_pipe_crc_ctl_reg(dev, pipe, &source, &val); > - else if (IS_VALLEYVIEW(dev) || IS_CHERRYVIEW(dev)) > - ret = vlv_pipe_crc_ctl_reg(dev, pipe, &source, &val); > - else if (IS_GEN5(dev) || IS_GEN6(dev)) > - ret = ilk_pipe_crc_ctl_reg(&source, &val); > - else > - ret = ivb_pipe_crc_ctl_reg(dev, pipe, &source, &val); > - > - if (ret != 0) > - goto out; > - > /* none -> real source transition */ > if (source) { > struct intel_pipe_crc_entry *entries; > @@ -677,14 +710,6 @@ static int pipe_crc_set_source(struct drm_device *dev, enum pipe pipe, > goto out; > } > > - /* > - * When IPS gets enabled, the pipe CRC changes. Since IPS gets > - * enabled and disabled dynamically based on package C states, > - * user space can't make reliable use of the CRCs, so let's just > - * completely disable it. > - */ > - hsw_disable_ips(crtc); > - > spin_lock_irq(&pipe_crc->lock); > kfree(pipe_crc->entries); > pipe_crc->entries = entries; > @@ -693,10 +718,11 @@ static int pipe_crc_set_source(struct drm_device *dev, enum pipe pipe, > spin_unlock_irq(&pipe_crc->lock); > } > > - pipe_crc->source = source; > + ret = do_set_crc_source(dev, pipe, source); > + if (ret) > + goto out; > > - I915_WRITE(PIPE_CRC_CTL(pipe), val); > - POSTING_READ(PIPE_CRC_CTL(pipe)); > + pipe_crc->source = source; > > /* real source -> none transition */ > if (source == INTEL_PIPE_CRC_SOURCE_NONE) { > @@ -720,15 +746,6 @@ static int pipe_crc_set_source(struct drm_device *dev, enum pipe pipe, > spin_unlock_irq(&pipe_crc->lock); > > kfree(entries); > - > - if (IS_G4X(dev)) > - g4x_undo_pipe_scramble_reset(dev, pipe); > - else if (IS_VALLEYVIEW(dev) || IS_CHERRYVIEW(dev)) > - vlv_undo_pipe_scramble_reset(dev, pipe); > - else if (IS_HASWELL(dev) && pipe == PIPE_A) > - hsw_trans_edp_pipe_A_crc_wa(dev, false); > - > - hsw_enable_ips(crtc); > } > > ret = 0; > @@ -821,6 +838,11 @@ display_crc_ctl_parse_source(const char *buf, enum intel_pipe_crc_source *s) > { > int i; > > + if (!buf) { > + *s = INTEL_PIPE_CRC_SOURCE_NONE; > + return 0; > + } > + > for (i = 0; i < ARRAY_SIZE(pipe_crc_sources); i++) > if (!strcmp(buf, pipe_crc_sources[i])) { > *s = i; > @@ -949,3 +971,31 @@ void intel_pipe_crc_cleanup(struct drm_minor *minor) > drm_debugfs_remove_files(info_list, 1, minor); > } > } > + > +int intel_crtc_set_crc_source(struct drm_crtc *crtc, const char *source_name, > + size_t *values_cnt) > +{ > + struct drm_i915_private *dev_priv = crtc->dev->dev_private; > + enum intel_display_power_domain power_domain; > + enum intel_pipe_crc_source source; > + int ret; > + > + if (display_crc_ctl_parse_source(source_name, &source) < 0) { > + DRM_DEBUG_DRIVER("unknown source %s\n", source_name); > + return -EINVAL; > + } > + > + power_domain = POWER_DOMAIN_PIPE(crtc->index); > + if (!intel_display_power_get_if_enabled(dev_priv, power_domain)) { > + DRM_DEBUG_KMS("Trying to capture CRC while pipe is off\n"); > + return -EIO; > + } > + > + ret = do_set_crc_source(crtc->dev, crtc->index, source); > + > + intel_display_power_put(dev_priv, power_domain); > + > + *values_cnt = 5; > + > + return ret; > +} > -- > 2.5.5 > > _______________________________________________ > dri-devel mailing list > dri-devel@lists.freedesktop.org > https://lists.freedesktop.org/mailman/listinfo/dri-devel -- Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch