From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jani Nikula Subject: Re: [PATCH v2] drm/i915/debugfs: Add i915_hpd_storm_ctl Date: Thu, 09 Feb 2017 13:59:25 +0200 Message-ID: <871sv7tw0y.fsf@intel.com> References: <20170209043933.11107-1-lyude@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20170209043933.11107-1-lyude@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 Cc: Lyude , David Airlie , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, Daniel Vetter List-Id: dri-devel@lists.freedesktop.org T24gVGh1LCAwOSBGZWIgMjAxNywgTHl1ZGUgPGx5dWRlQHJlZGhhdC5jb20+IHdyb3RlOgo+IFRo aXMgYWRkcyBhIGZpbGUgaW4gaTkxNSdzIGRlYnVnZnMgZGlyZWN0b3J5IHRoYXQgYWxsb3dzIHVz ZXJzcGFjZSB0bwo+IG1hbnVhbGx5IGNvbnRyb2wgSFBEIHN0b3JtIGRldGVjdGlvbi4gVGhpcyBp cyBtYWlubHkgZm9yIGhvdHBsdWdnaW5nCj4gdGVzdHMsIHdoZXJlIHdlIG1pZ2h0IHdhbnQgdG8g dGVzdCBIUEQgc3Rvcm0gZnVuY3Rpb25hbGl0eSBvciBkaXNhYmxlCj4gc3Rvcm0gZGV0ZWN0aW9u IHRvIHNwZWVkIHVwIGhvdHBsdWdnaW5nIHRlc3RzIHdpdGhvdXQgYnJlYWtpbmcgYW55dGhpbmcu Cj4KPiBDaGFuZ2VzIHNpbmNlIHYxOgo+IC0gTWFrZSBIUEQgc3Rvcm0gaW50ZXJ2YWwgY29uZmln dXJhYmxlCj4gLSBNaXNjIGNvZGUgY2xlYW51cAo+Cj4gU2lnbmVkLW9mZi1ieTogTHl1ZGUgPGx5 dWRlQHJlZGhhdC5jb20+Cj4gQ2M6IEphbmkgTmlrdWxhIDxqYW5pLm5pa3VsYUBsaW51eC5pbnRl bC5jb20+Cj4gQ2M6IFRvbWV1IFZpem9zbyA8dG9tZXVAdG9tZXV2aXpvc28ubmV0PgoKQWNrZWQt Ynk6IEphbmkgTmlrdWxhIDxqYW5pLm5pa3VsYUBpbnRlbC5jb20+CgoKPiAtLS0KPiAgZHJpdmVy cy9ncHUvZHJtL2k5MTUvaTkxNV9kZWJ1Z2ZzLmMgIHwgNzggKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKystCj4gIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmMgICAgICB8 ICAxICsKPiAgZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaCAgICAgIHwgIDQgKysKPiAg ZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9pcnEuYyAgICAgIHwgIDIgKwo+ICBkcml2ZXJzL2dw dS9kcm0vaTkxNS9pbnRlbF9ob3RwbHVnLmMgfCAxNSArKysrLS0tCj4gIDUgZmlsZXMgY2hhbmdl ZCwgOTQgaW5zZXJ0aW9ucygrKSwgNiBkZWxldGlvbnMoLSkKPgo+IGRpZmYgLS1naXQgYS9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2RlYnVnZnMuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5 MTVfZGVidWdmcy5jCj4gaW5kZXggMWNjYzI5Ny4uYjU1NTQ3ZCAxMDA2NDQKPiAtLS0gYS9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2RlYnVnZnMuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2k5MTVfZGVidWdmcy5jCj4gQEAgLTQ2NDEsNiArNDY0MSw4MSBAQCBzdGF0aWMgaW50IGk5 MTVfZm9yY2V3YWtlX2NyZWF0ZShzdHJ1Y3QgZGVudHJ5ICpyb290LCBzdHJ1Y3QgZHJtX21pbm9y ICptaW5vcikKPiAgCXJldHVybiBkcm1fYWRkX2Zha2VfaW5mb19ub2RlKG1pbm9yLCBlbnQsICZp OTE1X2ZvcmNld2FrZV9mb3BzKTsKPiAgfQo+ICAKPiArc3RhdGljIGludCBpOTE1X2hwZF9zdG9y bV9jdGxfc2hvdyhzdHJ1Y3Qgc2VxX2ZpbGUgKm0sIHZvaWQgKmRhdGEpCj4gK3sKPiArCXN0cnVj dCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IG0tPnByaXZhdGU7Cj4gKwlzdHJ1Y3QgaTkx NV9ob3RwbHVnICpob3RwbHVnID0gJmRldl9wcml2LT5ob3RwbHVnOwo+ICsKPiArCXNlcV9wcmlu dGYobSwgIlRocmVzaG9sZDogJWRcbiIsIGhvdHBsdWctPmhwZF9zdG9ybV90aHJlc2hvbGQpOwo+ ICsJc2VxX3ByaW50ZihtLCAiRGV0ZWN0ZWQ6ICVzXG4iLAo+ICsJCSAgIHllc25vKGRlbGF5ZWRf d29ya19wZW5kaW5nKCZob3RwbHVnLT5yZWVuYWJsZV93b3JrKSkpOwo+ICsKPiArCXJldHVybiAw Owo+ICt9Cj4gKwo+ICtzdGF0aWMgc3NpemVfdCBpOTE1X2hwZF9zdG9ybV9jdGxfd3JpdGUoc3Ry dWN0IGZpbGUgKmZpbGUsCj4gKwkJCQkJY29uc3QgY2hhciBfX3VzZXIgKnVidWYsIHNpemVfdCBs ZW4sCj4gKwkJCQkJbG9mZl90ICpvZmZwKQo+ICt7Cj4gKwlzdHJ1Y3Qgc2VxX2ZpbGUgKm0gPSBm aWxlLT5wcml2YXRlX2RhdGE7Cj4gKwlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYg PSBtLT5wcml2YXRlOwo+ICsJc3RydWN0IGk5MTVfaG90cGx1ZyAqaG90cGx1ZyA9ICZkZXZfcHJp di0+aG90cGx1ZzsKPiArCXVuc2lnbmVkIGludCBuZXdfdGhyZXNob2xkOwo+ICsJaW50IGk7Cj4g KwljaGFyICpuZXdsaW5lOwo+ICsJY2hhciB0bXBbMTZdOwo+ICsKPiArCWlmIChsZW4gPj0gc2l6 ZW9mKHRtcCkpCj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJaWYgKGNvcHlfZnJvbV91c2Vy KHRtcCwgdWJ1ZiwgbGVuKSkKPiArCQlyZXR1cm4gLUVGQVVMVDsKPiArCj4gKwl0bXBbbGVuXSA9 ICdcMCc7Cj4gKwo+ICsJLyogU3RyaXAgbmV3bGluZSwgaWYgYW55ICovCj4gKwluZXdsaW5lID0g c3RyY2hyKHRtcCwgJ1xuJyk7Cj4gKwlpZiAobmV3bGluZSkKPiArCQkqbmV3bGluZSA9ICdcMCc7 Cj4gKwo+ICsJaWYgKHN0cmNtcCh0bXAsICJyZXNldCIpID09IDApCj4gKwkJbmV3X3RocmVzaG9s ZCA9IEhQRF9TVE9STV9ERUZBVUxUX1RIUkVTSE9MRDsKPiArCWVsc2UgaWYgKGtzdHJ0b3VpbnQo dG1wLCAxMCwgJm5ld190aHJlc2hvbGQpICE9IDApCj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwo+ ICsJaWYgKG5ld190aHJlc2hvbGQgPiAwKQo+ICsJCURSTV9ERUJVR19LTVMoIlNldHRpbmcgSFBE IHN0b3JtIGRldGVjdGlvbiB0aHJlc2hvbGQgdG8gJWRcbiIsCj4gKwkJCSAgICAgIG5ld190aHJl c2hvbGQpOwo+ICsJZWxzZQo+ICsJCURSTV9ERUJVR19LTVMoIkRpc2FibGluZyBIUEQgc3Rvcm0g ZGV0ZWN0aW9uXG4iKTsKPiArCj4gKwlzcGluX2xvY2tfaXJxKCZkZXZfcHJpdi0+aXJxX2xvY2sp Owo+ICsJaG90cGx1Zy0+aHBkX3N0b3JtX3RocmVzaG9sZCA9IG5ld190aHJlc2hvbGQ7Cj4gKwkv KiBSZXNldCB0aGUgSFBEIHN0b3JtIHN0YXRzIHNvIHdlIGRvbid0IGFjY2lkZW50YWxseSB0cmln Z2VyIGEgc3Rvcm0gKi8KPiArCWZvcl9lYWNoX2hwZF9waW4oaSkKPiArCQlob3RwbHVnLT5zdGF0 c1tpXS5jb3VudCA9IDA7Cj4gKwlzcGluX3VubG9ja19pcnEoJmRldl9wcml2LT5pcnFfbG9jayk7 Cj4gKwo+ICsJLyogUmUtZW5hYmxlIGhwZCBpbW1lZGlhdGVseSBpZiB3ZSB3ZXJlIGluIGFuIGly cSBzdG9ybSAqLwo+ICsJZmx1c2hfZGVsYXllZF93b3JrKCZkZXZfcHJpdi0+aG90cGx1Zy5yZWVu YWJsZV93b3JrKTsKPiArCj4gKwlyZXR1cm4gbGVuOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGk5 MTVfaHBkX3N0b3JtX2N0bF9vcGVuKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpm aWxlKQo+ICt7Cj4gKwlyZXR1cm4gc2luZ2xlX29wZW4oZmlsZSwgaTkxNV9ocGRfc3Rvcm1fY3Rs X3Nob3csIGlub2RlLT5pX3ByaXZhdGUpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0 IGZpbGVfb3BlcmF0aW9ucyBpOTE1X2hwZF9zdG9ybV9jdGxfZm9wcyA9IHsKPiArCS5vd25lciA9 IFRISVNfTU9EVUxFLAo+ICsJLm9wZW4gPSBpOTE1X2hwZF9zdG9ybV9jdGxfb3BlbiwKPiArCS5y ZWFkID0gc2VxX3JlYWQsCj4gKwkubGxzZWVrID0gc2VxX2xzZWVrLAo+ICsJLnJlbGVhc2UgPSBz aW5nbGVfcmVsZWFzZSwKPiArCS53cml0ZSA9IGk5MTVfaHBkX3N0b3JtX2N0bF93cml0ZQo+ICt9 Owo+ICsKPiAgc3RhdGljIGludCBpOTE1X2RlYnVnZnNfY3JlYXRlKHN0cnVjdCBkZW50cnkgKnJv b3QsCj4gIAkJCSAgICAgICBzdHJ1Y3QgZHJtX21pbm9yICptaW5vciwKPiAgCQkJICAgICAgIGNv bnN0IGNoYXIgKm5hbWUsCj4gQEAgLTQ3MzQsNyArNDgwOSw4IEBAIHN0YXRpYyBjb25zdCBzdHJ1 Y3QgaTkxNV9kZWJ1Z2ZzX2ZpbGVzIHsKPiAgCXsiaTkxNV9kcF90ZXN0X2RhdGEiLCAmaTkxNV9k aXNwbGF5cG9ydF90ZXN0X2RhdGFfZm9wc30sCj4gIAl7Imk5MTVfZHBfdGVzdF90eXBlIiwgJmk5 MTVfZGlzcGxheXBvcnRfdGVzdF90eXBlX2ZvcHN9LAo+ICAJeyJpOTE1X2RwX3Rlc3RfYWN0aXZl IiwgJmk5MTVfZGlzcGxheXBvcnRfdGVzdF9hY3RpdmVfZm9wc30sCj4gLQl7Imk5MTVfZ3VjX2xv Z19jb250cm9sIiwgJmk5MTVfZ3VjX2xvZ19jb250cm9sX2ZvcHN9Cj4gKwl7Imk5MTVfZ3VjX2xv Z19jb250cm9sIiwgJmk5MTVfZ3VjX2xvZ19jb250cm9sX2ZvcHN9LAo+ICsJeyJpOTE1X2hwZF9z dG9ybV9jdGwiLCAmaTkxNV9ocGRfc3Rvcm1fY3RsX2ZvcHN9Cj4gIH07Cj4gIAo+ICBpbnQgaTkx NV9kZWJ1Z2ZzX3JlZ2lzdGVyKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdikKPiBk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuYyBiL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2k5MTVfZHJ2LmMKPiBpbmRleCBkNDhjMDJhNy4uZjIzYjU2OCAxMDA2NDQKPiAt LS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5jCj4gKysrIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaTkxNV9kcnYuYwo+IEBAIC04MjcsNiArODI3LDcgQEAgc3RhdGljIGludCBpOTE1 X2RyaXZlcl9pbml0X2Vhcmx5KHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiwKPiAg CXNwaW5fbG9ja19pbml0KCZkZXZfcHJpdi0+Z3B1X2Vycm9yLmxvY2spOwo+ICAJbXV0ZXhfaW5p dCgmZGV2X3ByaXYtPmJhY2tsaWdodF9sb2NrKTsKPiAgCXNwaW5fbG9ja19pbml0KCZkZXZfcHJp di0+dW5jb3JlLmxvY2spOwo+ICsKPiAgCXNwaW5fbG9ja19pbml0KCZkZXZfcHJpdi0+bW0ub2Jq ZWN0X3N0YXRfbG9jayk7Cj4gIAlzcGluX2xvY2tfaW5pdCgmZGV2X3ByaXYtPm1taW9fZmxpcF9s b2NrKTsKPiAgCXNwaW5fbG9ja19pbml0KCZkZXZfcHJpdi0+d20uZHNwYXJiX2xvY2spOwo+IGRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaTkxNV9kcnYuaAo+IGluZGV4IDYwNGIyMGYuLjJiN2IzMTcgMTAwNjQ0Cj4gLS0t IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaAo+ICsrKyBiL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2k5MTVfZHJ2LmgKPiBAQCAtMzg0LDYgKzM4NCw4IEBAIGVudW0gaHBkX3BpbiB7Cj4g ICNkZWZpbmUgZm9yX2VhY2hfaHBkX3BpbihfX3BpbikgXAo+ICAJZm9yICgoX19waW4pID0gKEhQ RF9OT05FICsgMSk7IChfX3BpbikgPCBIUERfTlVNX1BJTlM7IChfX3BpbikrKykKPiAgCj4gKyNk ZWZpbmUgSFBEX1NUT1JNX0RFRkFVTFRfVEhSRVNIT0xEIDUKPiArCj4gIHN0cnVjdCBpOTE1X2hv dHBsdWcgewo+ICAJc3RydWN0IHdvcmtfc3RydWN0IGhvdHBsdWdfd29yazsKPiAgCj4gQEAgLTQw Nyw2ICs0MDksOCBAQCBzdHJ1Y3QgaTkxNV9ob3RwbHVnIHsKPiAgCXN0cnVjdCB3b3JrX3N0cnVj dCBwb2xsX2luaXRfd29yazsKPiAgCWJvb2wgcG9sbF9lbmFibGVkOwo+ICAKPiArCXVuc2lnbmVk IGludCBocGRfc3Rvcm1fdGhyZXNob2xkOwo+ICsKPiAgCS8qCj4gIAkgKiBpZiB3ZSBnZXQgYSBI UEQgaXJxIGZyb20gRFAgYW5kIGEgSFBEIGlycSBmcm9tIG5vbi1EUAo+ICAJICogdGhlIG5vbi1E UCBIUEQgY291bGQgYmxvY2sgdGhlIHdvcmtxdWV1ZSBvbiBhIG1vZGUgY29uZmlnCj4gZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfaXJxLmMgYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pOTE1X2lycS5jCj4gaW5kZXggOWViNGM5Yy4uMjdjMTMxOTMgMTAwNjQ0Cj4gLS0tIGEv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9pcnEuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2k5MTVfaXJxLmMKPiBAQCAtNDI3Nyw2ICs0Mjc3LDggQEAgdm9pZCBpbnRlbF9pcnFfaW5p dChzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYpCj4gIAlpZiAoIUlTX0dFTjIoZGV2 X3ByaXYpKQo+ICAJCWRldi0+dmJsYW5rX2Rpc2FibGVfaW1tZWRpYXRlID0gdHJ1ZTsKPiAgCj4g KwlkZXZfcHJpdi0+aG90cGx1Zy5ocGRfc3Rvcm1fdGhyZXNob2xkID0gSFBEX1NUT1JNX0RFRkFV TFRfVEhSRVNIT0xEOwo+ICsKPiAgCWRldi0+ZHJpdmVyLT5nZXRfdmJsYW5rX3RpbWVzdGFtcCA9 IGk5MTVfZ2V0X3ZibGFua190aW1lc3RhbXA7Cj4gIAlkZXYtPmRyaXZlci0+Z2V0X3NjYW5vdXRf cG9zaXRpb24gPSBpOTE1X2dldF9jcnRjX3NjYW5vdXRwb3M7Cj4gIAo+IGRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9ob3RwbHVnLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkx NS9pbnRlbF9ob3RwbHVnLmMKPiBpbmRleCBiNjJlM2Y4Li42YTljMTY1IDEwMDY0NAo+IC0tLSBh L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2hvdHBsdWcuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2ludGVsX2hvdHBsdWcuYwo+IEBAIC0xMDAsNyArMTAwLDYgQEAgYm9vbCBpbnRl bF9ocGRfcGluX3RvX3BvcnQoZW51bSBocGRfcGluIHBpbiwgZW51bSBwb3J0ICpwb3J0KQo+ICB9 Cj4gIAo+ICAjZGVmaW5lIEhQRF9TVE9STV9ERVRFQ1RfUEVSSU9ECQkxMDAwCj4gLSNkZWZpbmUg SFBEX1NUT1JNX1RIUkVTSE9MRAkJNQo+ICAjZGVmaW5lIEhQRF9TVE9STV9SRUVOQUJMRV9ERUxB WQkoMiAqIDYwICogMTAwMCkKPiAgCj4gIC8qKgo+IEBAIC0xMTIsOSArMTExLDEzIEBAIGJvb2wg aW50ZWxfaHBkX3Bpbl90b19wb3J0KGVudW0gaHBkX3BpbiBwaW4sIGVudW0gcG9ydCAqcG9ydCkK PiAgICogc3Rvcm1zLiBPbmx5IHRoZSBwaW4gc3BlY2lmaWMgc3RhdHMgYW5kIHN0YXRlIGFyZSBj aGFuZ2VkLCB0aGUgY2FsbGVyIGlzCj4gICAqIHJlc3BvbnNpYmxlIGZvciBmdXJ0aGVyIGFjdGlv bi4KPiAgICoKPiAtICogQEhQRF9TVE9STV9USFJFU0hPTEQgaXJxcyBhcmUgYWxsb3dlZCB3aXRo aW4gQEhQRF9TVE9STV9ERVRFQ1RfUEVSSU9EIG1zLAo+IC0gKiBvdGhlcndpc2UgaXQncyBjb25z aWRlcmVkIGFuIGlycSBzdG9ybSwgYW5kIHRoZSBpcnEgc3RhdGUgaXMgc2V0IHRvCj4gLSAqIEBI UERfTUFSS19ESVNBQkxFRC4KPiArICogVGhlIG51bWJlciBvZiBpcnFzIHRoYXQgYXJlIGFsbG93 ZWQgd2l0aGluIEBIUERfU1RPUk1fREVURUNUX1BFUklPRCBpcwo+ICsgKiBzdG9yZWQgaW4gQGRl dl9wcml2LT5ob3RwbHVnLmhwZF9zdG9ybV90aHJlc2hvbGQgd2hpY2ggZGVmYXVsdHMgdG8KPiAr ICogQEhQRF9TVE9STV9ERUZBVUxUX1RIUkVTSE9MRC4gSWYgdGhpcyB0aHJlc2hvbGQgaXMgZXhj ZWVkZWQsIGl0J3MKPiArICogY29uc2lkZXJlZCBhbiBpcnEgc3Rvcm0gYW5kIHRoZSBpcnEgc3Rh dGUgaXMgc2V0IHRvIEBIUERfTUFSS19ESVNBQkxFRC4KPiArICoKPiArICogVGhlIEhQRCB0aHJl c2hvbGQgY2FuIGJlIGNvbnRyb2xsZWQgdGhyb3VnaCBpOTE1X2hwZF9zdG9ybV9jdGwgaW4gZGVi dWdmcywKPiArICogYW5kIHNob3VsZCBvbmx5IGJlIGFkanVzdGVkIGZvciBhdXRvbWF0ZWQgaG90 cGx1ZyB0ZXN0aW5nLgo+ICAgKgo+ICAgKiBSZXR1cm4gdHJ1ZSBpZiBhbiBpcnEgc3Rvcm0gd2Fz IGRldGVjdGVkIG9uIEBwaW4uCj4gICAqLwo+IEBAIC0xMjMsMTMgKzEyNiwxNSBAQCBzdGF0aWMg Ym9vbCBpbnRlbF9ocGRfaXJxX3N0b3JtX2RldGVjdChzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAq ZGV2X3ByaXYsCj4gIHsKPiAgCXVuc2lnbmVkIGxvbmcgc3RhcnQgPSBkZXZfcHJpdi0+aG90cGx1 Zy5zdGF0c1twaW5dLmxhc3RfamlmZmllczsKPiAgCXVuc2lnbmVkIGxvbmcgZW5kID0gc3RhcnQg KyBtc2Vjc190b19qaWZmaWVzKEhQRF9TVE9STV9ERVRFQ1RfUEVSSU9EKTsKPiArCWNvbnN0IGlu dCB0aHJlc2hvbGQgPSBkZXZfcHJpdi0+aG90cGx1Zy5ocGRfc3Rvcm1fdGhyZXNob2xkOwo+ICAJ Ym9vbCBzdG9ybSA9IGZhbHNlOwo+ICAKPiAgCWlmICghdGltZV9pbl9yYW5nZShqaWZmaWVzLCBz dGFydCwgZW5kKSkgewo+ICAJCWRldl9wcml2LT5ob3RwbHVnLnN0YXRzW3Bpbl0ubGFzdF9qaWZm aWVzID0gamlmZmllczsKPiAgCQlkZXZfcHJpdi0+aG90cGx1Zy5zdGF0c1twaW5dLmNvdW50ID0g MDsKPiAgCQlEUk1fREVCVUdfS01TKCJSZWNlaXZlZCBIUEQgaW50ZXJydXB0IG9uIFBJTiAlZCAt IGNudDogMFxuIiwgcGluKTsKPiAtCX0gZWxzZSBpZiAoZGV2X3ByaXYtPmhvdHBsdWcuc3RhdHNb cGluXS5jb3VudCA+IEhQRF9TVE9STV9USFJFU0hPTEQpIHsKPiArCX0gZWxzZSBpZiAoZGV2X3By aXYtPmhvdHBsdWcuc3RhdHNbcGluXS5jb3VudCA+IHRocmVzaG9sZCAmJgo+ICsJCSAgIHRocmVz aG9sZCkgewo+ICAJCWRldl9wcml2LT5ob3RwbHVnLnN0YXRzW3Bpbl0uc3RhdGUgPSBIUERfTUFS S19ESVNBQkxFRDsKPiAgCQlEUk1fREVCVUdfS01TKCJIUEQgaW50ZXJydXB0IHN0b3JtIGRldGVj dGVkIG9uIFBJTiAlZFxuIiwgcGluKTsKPiAgCQlzdG9ybSA9IHRydWU7CgotLSAKSmFuaSBOaWt1 bGEsIEludGVsIE9wZW4gU291cmNlIFRlY2hub2xvZ3kgQ2VudGVyCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkludGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50 ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9y Zy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751578AbdBIL7b (ORCPT ); Thu, 9 Feb 2017 06:59:31 -0500 Received: from mga03.intel.com ([134.134.136.65]:41731 "EHLO mga03.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751463AbdBIL7a (ORCPT ); Thu, 9 Feb 2017 06:59:30 -0500 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.35,349,1484035200"; d="scan'208";a="818854170" From: Jani Nikula To: Lyude , intel-gfx@lists.freedesktop.org Cc: Lyude , Tomeu Vizoso , Daniel Vetter , David Airlie , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Subject: Re: [PATCH v2] drm/i915/debugfs: Add i915_hpd_storm_ctl In-Reply-To: <20170209043933.11107-1-lyude@redhat.com> Organization: Intel Finland Oy - BIC 0357606-4 - Westendinkatu 7, 02160 Espoo References: <20170209043933.11107-1-lyude@redhat.com> Date: Thu, 09 Feb 2017 13:59:25 +0200 Message-ID: <871sv7tw0y.fsf@intel.com> MIME-Version: 1.0 Content-Type: text/plain Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Thu, 09 Feb 2017, Lyude wrote: > This adds a file in i915's debugfs directory that allows userspace to > manually control HPD storm detection. This is mainly for hotplugging > tests, where we might want to test HPD storm functionality or disable > storm detection to speed up hotplugging tests without breaking anything. > > Changes since v1: > - Make HPD storm interval configurable > - Misc code cleanup > > Signed-off-by: Lyude > Cc: Jani Nikula > Cc: Tomeu Vizoso Acked-by: Jani Nikula > --- > drivers/gpu/drm/i915/i915_debugfs.c | 78 +++++++++++++++++++++++++++++++++++- > drivers/gpu/drm/i915/i915_drv.c | 1 + > drivers/gpu/drm/i915/i915_drv.h | 4 ++ > drivers/gpu/drm/i915/i915_irq.c | 2 + > drivers/gpu/drm/i915/intel_hotplug.c | 15 ++++--- > 5 files changed, 94 insertions(+), 6 deletions(-) > > diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c > index 1ccc297..b55547d 100644 > --- a/drivers/gpu/drm/i915/i915_debugfs.c > +++ b/drivers/gpu/drm/i915/i915_debugfs.c > @@ -4641,6 +4641,81 @@ static int i915_forcewake_create(struct dentry *root, struct drm_minor *minor) > return drm_add_fake_info_node(minor, ent, &i915_forcewake_fops); > } > > +static int i915_hpd_storm_ctl_show(struct seq_file *m, void *data) > +{ > + struct drm_i915_private *dev_priv = m->private; > + struct i915_hotplug *hotplug = &dev_priv->hotplug; > + > + seq_printf(m, "Threshold: %d\n", hotplug->hpd_storm_threshold); > + seq_printf(m, "Detected: %s\n", > + yesno(delayed_work_pending(&hotplug->reenable_work))); > + > + return 0; > +} > + > +static ssize_t i915_hpd_storm_ctl_write(struct file *file, > + const char __user *ubuf, size_t len, > + loff_t *offp) > +{ > + struct seq_file *m = file->private_data; > + struct drm_i915_private *dev_priv = m->private; > + struct i915_hotplug *hotplug = &dev_priv->hotplug; > + unsigned int new_threshold; > + int i; > + char *newline; > + char tmp[16]; > + > + if (len >= sizeof(tmp)) > + return -EINVAL; > + > + if (copy_from_user(tmp, ubuf, len)) > + return -EFAULT; > + > + tmp[len] = '\0'; > + > + /* Strip newline, if any */ > + newline = strchr(tmp, '\n'); > + if (newline) > + *newline = '\0'; > + > + if (strcmp(tmp, "reset") == 0) > + new_threshold = HPD_STORM_DEFAULT_THRESHOLD; > + else if (kstrtouint(tmp, 10, &new_threshold) != 0) > + return -EINVAL; > + > + if (new_threshold > 0) > + DRM_DEBUG_KMS("Setting HPD storm detection threshold to %d\n", > + new_threshold); > + else > + DRM_DEBUG_KMS("Disabling HPD storm detection\n"); > + > + spin_lock_irq(&dev_priv->irq_lock); > + hotplug->hpd_storm_threshold = new_threshold; > + /* Reset the HPD storm stats so we don't accidentally trigger a storm */ > + for_each_hpd_pin(i) > + hotplug->stats[i].count = 0; > + spin_unlock_irq(&dev_priv->irq_lock); > + > + /* Re-enable hpd immediately if we were in an irq storm */ > + flush_delayed_work(&dev_priv->hotplug.reenable_work); > + > + return len; > +} > + > +static int i915_hpd_storm_ctl_open(struct inode *inode, struct file *file) > +{ > + return single_open(file, i915_hpd_storm_ctl_show, inode->i_private); > +} > + > +static const struct file_operations i915_hpd_storm_ctl_fops = { > + .owner = THIS_MODULE, > + .open = i915_hpd_storm_ctl_open, > + .read = seq_read, > + .llseek = seq_lseek, > + .release = single_release, > + .write = i915_hpd_storm_ctl_write > +}; > + > static int i915_debugfs_create(struct dentry *root, > struct drm_minor *minor, > const char *name, > @@ -4734,7 +4809,8 @@ static const struct i915_debugfs_files { > {"i915_dp_test_data", &i915_displayport_test_data_fops}, > {"i915_dp_test_type", &i915_displayport_test_type_fops}, > {"i915_dp_test_active", &i915_displayport_test_active_fops}, > - {"i915_guc_log_control", &i915_guc_log_control_fops} > + {"i915_guc_log_control", &i915_guc_log_control_fops}, > + {"i915_hpd_storm_ctl", &i915_hpd_storm_ctl_fops} > }; > > int i915_debugfs_register(struct drm_i915_private *dev_priv) > diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c > index d48c02a7..f23b568 100644 > --- a/drivers/gpu/drm/i915/i915_drv.c > +++ b/drivers/gpu/drm/i915/i915_drv.c > @@ -827,6 +827,7 @@ static int i915_driver_init_early(struct drm_i915_private *dev_priv, > spin_lock_init(&dev_priv->gpu_error.lock); > mutex_init(&dev_priv->backlight_lock); > spin_lock_init(&dev_priv->uncore.lock); > + > spin_lock_init(&dev_priv->mm.object_stat_lock); > spin_lock_init(&dev_priv->mmio_flip_lock); > spin_lock_init(&dev_priv->wm.dsparb_lock); > diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h > index 604b20f..2b7b317 100644 > --- a/drivers/gpu/drm/i915/i915_drv.h > +++ b/drivers/gpu/drm/i915/i915_drv.h > @@ -384,6 +384,8 @@ enum hpd_pin { > #define for_each_hpd_pin(__pin) \ > for ((__pin) = (HPD_NONE + 1); (__pin) < HPD_NUM_PINS; (__pin)++) > > +#define HPD_STORM_DEFAULT_THRESHOLD 5 > + > struct i915_hotplug { > struct work_struct hotplug_work; > > @@ -407,6 +409,8 @@ struct i915_hotplug { > struct work_struct poll_init_work; > bool poll_enabled; > > + unsigned int hpd_storm_threshold; > + > /* > * if we get a HPD irq from DP and a HPD irq from non-DP > * the non-DP HPD could block the workqueue on a mode config > diff --git a/drivers/gpu/drm/i915/i915_irq.c b/drivers/gpu/drm/i915/i915_irq.c > index 9eb4c9c..27c13193 100644 > --- a/drivers/gpu/drm/i915/i915_irq.c > +++ b/drivers/gpu/drm/i915/i915_irq.c > @@ -4277,6 +4277,8 @@ void intel_irq_init(struct drm_i915_private *dev_priv) > if (!IS_GEN2(dev_priv)) > dev->vblank_disable_immediate = true; > > + dev_priv->hotplug.hpd_storm_threshold = HPD_STORM_DEFAULT_THRESHOLD; > + > dev->driver->get_vblank_timestamp = i915_get_vblank_timestamp; > dev->driver->get_scanout_position = i915_get_crtc_scanoutpos; > > diff --git a/drivers/gpu/drm/i915/intel_hotplug.c b/drivers/gpu/drm/i915/intel_hotplug.c > index b62e3f8..6a9c165 100644 > --- a/drivers/gpu/drm/i915/intel_hotplug.c > +++ b/drivers/gpu/drm/i915/intel_hotplug.c > @@ -100,7 +100,6 @@ bool intel_hpd_pin_to_port(enum hpd_pin pin, enum port *port) > } > > #define HPD_STORM_DETECT_PERIOD 1000 > -#define HPD_STORM_THRESHOLD 5 > #define HPD_STORM_REENABLE_DELAY (2 * 60 * 1000) > > /** > @@ -112,9 +111,13 @@ bool intel_hpd_pin_to_port(enum hpd_pin pin, enum port *port) > * storms. Only the pin specific stats and state are changed, the caller is > * responsible for further action. > * > - * @HPD_STORM_THRESHOLD irqs are allowed within @HPD_STORM_DETECT_PERIOD ms, > - * otherwise it's considered an irq storm, and the irq state is set to > - * @HPD_MARK_DISABLED. > + * The number of irqs that are allowed within @HPD_STORM_DETECT_PERIOD is > + * stored in @dev_priv->hotplug.hpd_storm_threshold which defaults to > + * @HPD_STORM_DEFAULT_THRESHOLD. If this threshold is exceeded, it's > + * considered an irq storm and the irq state is set to @HPD_MARK_DISABLED. > + * > + * The HPD threshold can be controlled through i915_hpd_storm_ctl in debugfs, > + * and should only be adjusted for automated hotplug testing. > * > * Return true if an irq storm was detected on @pin. > */ > @@ -123,13 +126,15 @@ static bool intel_hpd_irq_storm_detect(struct drm_i915_private *dev_priv, > { > unsigned long start = dev_priv->hotplug.stats[pin].last_jiffies; > unsigned long end = start + msecs_to_jiffies(HPD_STORM_DETECT_PERIOD); > + const int threshold = dev_priv->hotplug.hpd_storm_threshold; > bool storm = false; > > if (!time_in_range(jiffies, start, end)) { > dev_priv->hotplug.stats[pin].last_jiffies = jiffies; > dev_priv->hotplug.stats[pin].count = 0; > DRM_DEBUG_KMS("Received HPD interrupt on PIN %d - cnt: 0\n", pin); > - } else if (dev_priv->hotplug.stats[pin].count > HPD_STORM_THRESHOLD) { > + } else if (dev_priv->hotplug.stats[pin].count > threshold && > + threshold) { > dev_priv->hotplug.stats[pin].state = HPD_MARK_DISABLED; > DRM_DEBUG_KMS("HPD interrupt storm detected on PIN %d\n", pin); > storm = true; -- Jani Nikula, Intel Open Source Technology Center