From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jani Nikula Subject: Re: [PATCH v3 1/2 RESEND] drm/dp_helper: add workarounds from intel_dp_dpcd_read_wake() Date: Thu, 24 Mar 2016 11:37:35 +0200 Message-ID: <87mvpodxnk.fsf@intel.com> References: <1458761417-12165-1-git-send-email-cpaul@redhat.com> <1458761593-13561-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: <1458761593-13561-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, dri-devel@lists.freedesktop.org Cc: Lyude , arthur.j.runyan@intel.com, open list List-Id: dri-devel@lists.freedesktop.org T24gV2VkLCAyMyBNYXIgMjAxNiwgTHl1ZGUgPGNwYXVsQHJlZGhhdC5jb20+IHdyb3RlOgo+IFNv bWUgc2lua3MgbmVlZCBzb21lIHRpbWUgZHVyaW5nIHRoZSBwcm9jZXNzIG9mIHJlc3VtaW5nIHRo ZSBzeXN0ZW0gZnJvbQo+IHNsZWVwIGJlZm9yZSB0aGV5J3JlIHJlYWR5IHRvIGhhbmRsZSB0cmFu c2FjdGlvbnMuIFdoaWxlIGl0IHdvdWxkIGJlCj4gbmljZSBpZiB0aGV5IHJlc3BvbmRlZCB3aXRo IE5BQ0tzIGluIHRoZXNlIHNjZW5hcmlvcywgdGhpcyBpc24ndCBhbHdheXMKPiB0aGUgY2FzZSBh cyBhIGZldyBzaW5rcyB3aWxsIGp1c3QgdGltZW91dCBvbiBhbGwgb2YgdGhlIHRyYW5zYWN0aW9u cwo+IHRoZXkgcmVjZWl2ZS4KPgo+IFRoaXMgcGF0Y2ggd2FzIG9yaWdpbmFsbHkgaW50ZW5kZWQg dG8gYmUgYSB3b3JrYXJvdW5kIGZvciBhIHZlcnkKPiBteXN0ZXJpb3VzIGJ1ZyBvbiB0aGUgVDU2 MCwgd2hlcmUgYW55IG1vbml0b3JzIGNvbm5lY3RlZCB0byB0aGUgZG9jawo+IHdvdWxkIGZhaWwg dG8gdHVybiBiYWNrIG9uIGFmdGVyIHJlc3VtZS4gV2hlbiByZXN1bWluZyB0aGUgbGFwdG9wLCBp dAo+IGFwcGVhcnMgdGhhdCB0aGVyZSdzIGEgc2hvcnQgcGVyaW9kIG9mIHRpbWUgd2hlcmUgd2Un cmUgdW5hYmxlIHRvCj4gY29tcGxldGUgYW55IGF1eCB0cmFuc2FjdGlvbnMsIGFzIHRoZXkgYWxs IGltbWVkaWF0ZWx5IHRpbWVvdXQuIFRoZSBvbmx5Cj4gbWFjaGluZSBJJ20gYWJsZSB0byByZXBy b2R1Y2UgdGhpcyBvbiBpcyB0aGUgVDU2MCBhcyBvdGhlciBwcm9kdWN0aW9uCj4gU2t5bGFrZSBt b2RlbHMgc2VlbSB0byBiZSBmaW5lLiBUaGUgcGVyaW9kIGR1cmluZyB3aGljaCBBVVggdHJhbnNh Y3Rpb25zCj4gZmFpbCBhcHBlYXJzIHRvIGJlIGFyb3VuZCAyMm1zIGxvbmcuIEFGQUlLLCB0aGUg ZG9jayBmb3IgdGhlIFQ1NjAgbmV2ZXIKPiBhY3R1YWxseSB0dXJucyBvZmYsIHRoZSBvbmx5IGRp ZmZlcmVuY2UgaXMgdGhhdCBpdCdzIGluIFNTVCBtb2RlIGF0IHRoZQo+IHN0YXJ0IG9mIHRoZSBy ZXN1bWUgcHJvY2Vzcywgc28gaXQncyB1bmNsZWFyIGFzIHRvIHdoeSBpdCB3b3VsZCBuZWVkIHNv Cj4gbXVjaCB0aW1lIHRvIGNvbWUgYmFjayB1cC4KPgo+IFRoZXJlJ3MgYmVlbiBhIGRpc2N1c3Np b24gb24gdGhpcyBpc3N1ZSBnb2luZyBvbiBmb3IgYSB3aGlsZSBvbiB0aGUKPiBpbnRlbC1nZngg bWFpbGluZyBsaXN0IGFib3V0IHRoaXMgdGhhdCBoYXMsIGluIGFkZGl0aW9uIHRvIGluY2x1ZGlu Zwo+IGRldmVsb3BlcnMgZnJvbSBJbnRlbCwgYWxzbyBoYWQgdGhlIGNvcnJlc3BvbmRlbmNlIG9m IG9uZSBvZiB0aGUKPiBoYXJkd2FyZSBlbmdpbmVlcnMgZm9yIEludGVsOgo+Cj4gaHR0cDovL3d3 dy5zcGluaWNzLm5ldC9saXN0cy9pbnRlbC1nZngvbXNnODg4MzEuaHRtbAo+IGh0dHA6Ly93d3cu c3Bpbmljcy5uZXQvbGlzdHMvaW50ZWwtZ2Z4L21zZzg4NDEwLmh0bWwKPgo+IFdlJ3ZlIGFscmVh ZHkgbG9va2VkIGludG8gYSBjb3VwbGUgb2YgcG9zc2libGUgZXhwbGFuYXRpb25zIGZvciB0aGUK PiBwcm9ibGVtOgo+Cj4gLSBDYWxsaW5nIGludGVsX2RwX21zdF9yZXN1bWUoKSBiZWZvcmUgcmln aHQgZml4Lgo+ICAgaW50ZWxfcnVudGltZV9wbV9lbmFibGVfaW50ZXJydXB0cygpLiBUaGlzIHdh cyB0aGUgZmlyc3QgZml4IEkgdHJpZWQsCj4gICBhbmQgd2hpbGUgaXQgd29ya2VkIGl0IGRlZmlu aXRlbHkgd2Fzbid0IHRoZSByaWdodCBmaXguIFRoaXMgd29ya2VkCj4gICBiZWNhdXNlIERQIGF1 eCB0cmFuc2FjdGlvbnMgZG9uJ3QgYWN0dWFsbHkgcmVxdWlyZSBpbnRlcnJ1cHRzIHRvIHdvcms6 Cj4KPiAJc3RhdGljIHVpbnQzMl90Cj4gCWludGVsX2RwX2F1eF93YWl0X2RvbmUoc3RydWN0IGlu dGVsX2RwICppbnRlbF9kcCwgYm9vbCBoYXNfYXV4X2lycSkKPiAJewo+IAkJc3RydWN0IGludGVs X2RpZ2l0YWxfcG9ydCAqaW50ZWxfZGlnX3BvcnQgPSBkcF90b19kaWdfcG9ydChpbnRlbF9kcCk7 Cj4gCQlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gaW50ZWxfZGlnX3BvcnQtPmJhc2UuYmFzZS5k ZXY7Cj4gCQlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2 YXRlOwo+IAkJaTkxNV9yZWdfdCBjaF9jdGwgPSBpbnRlbF9kcC0+YXV4X2NoX2N0bF9yZWc7Cj4g CQl1aW50MzJfdCBzdGF0dXM7Cj4gCQlib29sIGRvbmU7Cj4KPiAJI2RlZmluZSBDICgoKHN0YXR1 cyA9IEk5MTVfUkVBRF9OT1RSQUNFKGNoX2N0bCkpICYgRFBfQVVYX0NIX0NUTF9TRU5EX0JVU1kp ID09IDApCj4gCQlpZiAoaGFzX2F1eF9pcnEpCj4gCQkJZG9uZSA9IHdhaXRfZXZlbnRfdGltZW91 dChkZXZfcHJpdi0+Z21idXNfd2FpdF9xdWV1ZSwgQywKPiAJCQkJCQkgIG1zZWNzX3RvX2ppZmZp ZXNfdGltZW91dCgxMCkpOwo+IAkJZWxzZQo+IAkJCWRvbmUgPSB3YWl0X2Zvcl9hdG9taWMoQywg MTApID09IDA7Cj4gCQlpZiAoIWRvbmUpCj4gCQkJRFJNX0VSUk9SKCJkcCBhdXggaHcgZGlkIG5v dCBzaWduYWwgdGltZW91dCAoaGFzIGlycTogJWkpIVxuIiwKPiAJCQkJICBoYXNfYXV4X2lycSk7 Cj4gCSN1bmRlZiBDCj4KPiAJCXJldHVybiBzdGF0dXM7Cj4gCX0KPgo+ICAgV2hlbiB0aGVyZSdz IG5vIGludGVycnVwdHMgZW5hYmxlZCwgd2UgZW5kIHVwIHRpbWluZyBvdXQgb24gdGhlCj4gICB3 YWl0X2V2ZW50X3RpbWVvdXQoKSBjYWxsLCB3aGljaCBjYXVzZXMgdXMgdG8gY2hlY2sgdGhlIERQ IHN0YXR1cwo+ICAgcmVnaXN0ZXIgb25jZSB0byBzZWUgaWYgdGhlIHRyYW5zYWN0aW9uIHdhcyBz dWNjZXNzZnVsIG9yIG5vdC4gU2luY2UKPiAgIHRoaXMgYWRkcyBhIDEwbXMgZGVsYXkgdG8gZWFj aCBhdXggdHJhbnNhY3Rpb24sIGl0IGVuZHMgdXAgYWRkaW5nIGEKPiAgIGxvbmcgZW5vdWdoIGRl bGF5IHRvIHRoZSByZXN1bWUgcHJvY2VzcyBmb3IgYXV4IHRyYW5zYWN0aW9ucyB0byBiZWNvbWUK PiAgIGZ1bmN0aW9uYWwgYWdhaW4uIFRoaXMgZ2F2ZSB1cyB0aGUgaWxsdXNpb24gdGhhdCBlbmFi bGluZyBpbnRlcnJ1cHRzCj4gICBoYWQgc29tZXRoaW5nIHRvIGRvIHdpdGggbWFraW5nIHRoaW5n cyB3b3JrIGFnYWluLCBhbmQgcHV0IG1lIG9uIHRoZQo+ICAgd3JvbmcgdHJhY2sgZm9yIGEgd2hp bGUuCj4KPiAtIEludGVycnVwdHMgb2NjdXJyaW5nIHdoZW4gd2UgdHJ5IHRvIHBlcmZvcm0gdGhl IGF1eCB0cmFuc2FjdGlvbnMKPiAgIHJlcXVpcmVkIHRvIHB1dCB0aGUgZG9jayBiYWNrIGludG8g TVNUIG1vZGUuIFRoaXMgaXNuJ3QgdGhlIHByb2JsZW0sCj4gICBhcyB0aGUgb25seSBpbnRlcnJ1 cHRzIEkndmUgb2JzZXJ2ZWQgdGhhdCBjb21lIGR1cmluZyB0aGlzIHRpbWVvdXQKPiAgIHBlcmlv ZCBhcmUgZnJvbSB0aGUgc25kX2hkYV9pbnRlbCBkcml2ZXIsIGFuZCBkaXNhYmxpbmcgdGhhdCBk cml2ZXIKPiAgIGRvZXNuJ3QgYXBwZWFyIHRvIGNoYW5nZSB0aGUgYmVoYXZpb3IgYXQgYWxsLgo+ Cj4gLSBTa3lsYWtlJ3MgUFNSIGJsb2NrIGNhdXNpbmcgaXNzdWVzIGJ5IHBlcmZvcm1pbmcgYXV4 IHRyYW5zYWN0aW9ucwo+ICAgd2hpbGUgd2UgdHJ5IHRvIGJyaW5nIHRoZSBkb2NrIG91dCBvZiBN U1QgbW9kZS4gRGlzYWJsaW5nIFBTUiB0aHJvdWdoCj4gICBpOTE1J3MgY29tbWFuZCBsaW5lIG9w dGlvbnMgZG9lc24ndCBzZWVtIHRvIGNoYW5nZSB0aGUgYmVoYXZpb3IKPiAgIGVpdGhlciwgbm9y IGRvZXMgcHJldmVudGluZyB0aGUgRE1DIGZpcm13YXJlIGZyb20gYmVpbmcgbG9hZGVkLgo+Cj4g U2luY2UgdGhpcyBpbnZlc3RpZ2F0aW9uIHdlbnQgb24gZm9yIGFib3V0IDIgd2Vla3MsIHdlIGRl Y2lkZWQgaXQgd291bGQKPiBiZSBiZXR0ZXIgZm9yIHRoZSB0aW1lIGJlaW5nIHRvIGp1c3Qgd29y a2Fyb3VuZCB0aGlzIGlzc3VlIHVudGlsIHdlIGZpbmQKPiBhIGJldHRlciBmaXguIFRoaXMgcGF0 Y2ggYWRkcyBzb21lIGJlaGF2aW9yIHdlIHdhbnQgaW4KPiBkcm1fZHBfZHBjZF9hY2Nlc3MoKSBh bnl3YXksIHNpbmNlIERQIGF1eCB0cmFuc2FjdGlvbnMgYXJlbid0IGV4YWN0bHkKPiByb2J1c3Qg YW5kIHRoaXMgd2lsbCBwcm9iYWJseSBmaXggcXVpdGUgYSBmZXcgb3RoZXIgaXNzdWVzIHdpdGgg RFAgTVNUCj4gaGFyZHdhcmUgbm90IHJlc3BvbmRpbmcgaW4gdGltZS4gUGx1cywgdGhpcyBpcyBz b21ldGhpbmcgd2UgYWxyZWFkeSBkbwo+IGluIHRoZSBpOTE1IGRyaXZlciB3aXRoIGludGVsX2Rw X2RwY2RfcmVhZF93YWtlKCksIGV4Y2VwdCB0aGF0IHRoYXQKPiBmdW5jdGlvbiBpcyBzb21ld2hh dCBvZiBhIGhhY2sgYW5kIERSTSBoZWxwZXJzIGNhbid0IG1ha2UgdXNlIG9mIGl0Lgo+Cj4gCQkJ ICAgIENoYW5nZXMgc2luY2UgdjIKPiAtIFJld29ya2VkIHRoZSBwYXRjaCBhZ2FpbiB0byBpbmNv cnBvcmF0ZSBhbGwgb2YgdGhlIGJlaGF2aW9yIG9mCj4gICBpbnRlbF9kcF9kcGNkX3JlYWRfd2Fr ZSgpIGludG8gZHJtX2RwX2RwY2RfcmVhZCgpIGFuZAo+ICAgZHJtX2RwX2RwY2RfYWNjZXNzKCkK Pgo+IAkJCSAgICBDaGFuZ2VzIHNpbmNlIHYxCj4KPiAtIFBhdGNoIGhhcyBiZWVuIHJld29ya2Vk IHRvIHRha2UgdGhlIHJldHJ5IGxvZ2ljIG91dCBvZgo+ICAgaW50ZWxfZHBfbXN0X3Jlc3VtZSgp IGFuZCBpbnRvIGRybV9kcF9kcGNkX2FjY2VzcygpLCBiYXNlZCBvZmYgYQo+ICAgc3VnZ2VzdGlv biBmcm9tIERhbmllbCBWZXR0ZXIKPgo+IC0gQ29tbWl0IG1lc3NhZ2UgaXMgbXVjaCBsb25nZXIg YW5kIGdpdmVzIGEgYmV0dGVyIGRlc2NyaXB0aW9uIG9mIHRoZQo+ICAgaXNzdWUgdGhpcyB3YXMg b3JpZ2luYWxseSBpbnRlbmRlZCB0byB3b3JrYXJvdW5kLgo+Cj4gU2lnbmVkLW9mZi1ieTogTHl1 ZGUgPGNwYXVsQHJlZGhhdC5jb20+CgpXZSd2ZSBoYWQgYSBsb3Qgb2YgaXNzdWVzIHdpdGggZHAg YXV4IGluIHRoZSBwYXN0LCBhbmQgd2UndmUgc2xvd2x5IGFuZAppdGVyYXRpdmVseSBpbXByb3Zl ZCBvdmVyIHRpbWUuIEluIHRoYXQgbGlnaHQsIEkgYW0gc3Ryb25nbHkgb3Bwb3NlZCB0bwpkb2lu ZyBhcyBtYW55IGNoYW5nZXMgaW4gb25lIGdvIGFzIHRoaXMgcGF0Y2ggZG9lcy4KCklmIHdlIGdv dCBhIGJpc2VjdCByZXN1bHQgb24gdGhpcywgaXQgd291bGQgYmUgaGFyZCB0byBkZWNpZGUgd2hh dCBpdApyZWFsbHkgd2FzLiBXZSBtaWdodCBoYXZlIHRvIHJldmVydCBpdCBhbGwgZXZlbiBpZiBz b21lIHBhcnRzIG9mIGl0IHdlcmUKZ29vZC4KCkknbGwgaWRlbnRpZnkgc29tZSBvZiB0aGUgY2hh bmdlcyBiZWxvdyB0aGF0IEkgdGhpbmsgbXVzdCBiZSBzZXBhcmF0ZWQKdG8gZGlzdGluY3QgY2hh bmdlcy4gKFRoZSBudW1iZXJzIGRvbid0IG5lY2Vzc2FyaWx5IHJlZmxlY3QgdGhlIG9yZGVyIGlu CndoaWNoIHRoZSBjaGFuZ2VzIHNob3VsZCBiZSBkb25lLikKCj4gLS0tCj4gTGVmdCBzb21lIHJl YmFzZSBkaXRyaXR1cyBpbiB0aGUgcGF0Y2ggYWZ0ZXIgc2VuZGluZyBpdCBieSBhY2NpZGVudCwg d2hvb3BzCj4KPiAgZHJpdmVycy9ncHUvZHJtL2RybV9kcF9oZWxwZXIuYyB8IDQ3ICsrKysrKysr KysrKysrKysrKysrKy0tLS0tLS0tLS0tLS0tLS0tLS0tCj4gIDEgZmlsZSBjaGFuZ2VkLCAyNCBp bnNlcnRpb25zKCspLCAyMyBkZWxldGlvbnMoLSkKPgo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0vZHJtX2RwX2hlbHBlci5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9kcF9oZWxwZXIuYwo+ IGluZGV4IDk1MzVjNWIuLjliMzQyNmMgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2Ry bV9kcF9oZWxwZXIuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fZHBfaGVscGVyLmMKPiBA QCAtMTU5LDcgKzE1OSw3IEBAIGludCBkcm1fZHBfYndfY29kZV90b19saW5rX3JhdGUodTggbGlu a19idykKPiAgfQo+ICBFWFBPUlRfU1lNQk9MKGRybV9kcF9id19jb2RlX3RvX2xpbmtfcmF0ZSk7 Cj4gIAo+IC0jZGVmaW5lIEFVWF9SRVRSWV9JTlRFUlZBTCA1MDAgLyogdXMgKi8KPiArI2RlZmlu ZSBBVVhfUkVUUllfSU5URVJWQUwgMTAwMCAvKiB1cyAqLwoKQ2hhbmdlICMxLiBJbmNyZWFzaW5n IHRoZSByZXRyeSBpbnRlcnZhbC4KCj4gIAo+ICAvKioKPiAgICogRE9DOiBkcCBoZWxwZXJzCj4g QEAgLTE3Nyw4ICsxNzcsOCBAQCBzdGF0aWMgaW50IGRybV9kcF9kcGNkX2FjY2VzcyhzdHJ1Y3Qg ZHJtX2RwX2F1eCAqYXV4LCB1OCByZXF1ZXN0LAo+ICAJCQkgICAgICB1bnNpZ25lZCBpbnQgb2Zm c2V0LCB2b2lkICpidWZmZXIsIHNpemVfdCBzaXplKQo+ICB7Cj4gIAlzdHJ1Y3QgZHJtX2RwX2F1 eF9tc2cgbXNnOwo+IC0JdW5zaWduZWQgaW50IHJldHJ5Owo+IC0JaW50IGVycjsKPiArCXVuc2ln bmVkIGludCByZXRyeSwgbmF0aXZlX3JlcGx5Owo+ICsJaW50IHJldCA9IDA7Cj4gIAo+ICAJbWVt c2V0KCZtc2csIDAsIHNpemVvZihtc2cpKTsKPiAgCW1zZy5hZGRyZXNzID0gb2Zmc2V0Owo+IEBA IC0xOTMsMzUgKzE5MywyOSBAQCBzdGF0aWMgaW50IGRybV9kcF9kcGNkX2FjY2VzcyhzdHJ1Y3Qg ZHJtX2RwX2F1eCAqYXV4LCB1OCByZXF1ZXN0LAo+ICAJICogc3VmZmljaWVudCwgYnVtcCB0byAz MiB3aGljaCBtYWtlcyBEZWxsIDRrIG1vbml0b3JzIGhhcHBpZXIuCj4gIAkgKi8KPiAgCWZvciAo cmV0cnkgPSAwOyByZXRyeSA8IDMyOyByZXRyeSsrKSB7Cj4gKwkJaWYgKHJldCAhPSAwICYmIHJl dCAhPSAtRVRJTUVET1VUKSB7Cj4gKwkJCXVzbGVlcF9yYW5nZShBVVhfUkVUUllfSU5URVJWQUws Cj4gKwkJCQkgICAgIEFVWF9SRVRSWV9JTlRFUlZBTCArIDEwMCk7CgpDaGFuZ2UgIzIuIENoYW5n aW5nIHRoZSBjb25kaXRpb25zIG9uIHdoZW4gdG8gc2xlZXAgYmV0d2VlbiByZXRyaWVzLgoKPiAr CQl9Cj4gIAo+ICAJCW11dGV4X2xvY2soJmF1eC0+aHdfbXV0ZXgpOwo+IC0JCWVyciA9IGF1eC0+ dHJhbnNmZXIoYXV4LCAmbXNnKTsKPiArCQlyZXQgPSBhdXgtPnRyYW5zZmVyKGF1eCwgJm1zZyk7 Cj4gIAkJbXV0ZXhfdW5sb2NrKCZhdXgtPmh3X211dGV4KTsKPiAtCQlpZiAoZXJyIDwgMCkgewo+ IC0JCQlpZiAoZXJyID09IC1FQlVTWSkKPiAtCQkJCWNvbnRpbnVlOwoKQ2hhbmdlICMzYS4gQ2hh bmdpbmcgd2hpY2ggZXJyb3JzIGxlYWQgdG8gcmV0cmllcy4KCj4gLQo+IC0JCQlyZXR1cm4gZXJy Owo+IC0JCX0KPiAtCj4gLQo+IC0JCXN3aXRjaCAobXNnLnJlcGx5ICYgRFBfQVVYX05BVElWRV9S RVBMWV9NQVNLKSB7Cj4gLQkJY2FzZSBEUF9BVVhfTkFUSVZFX1JFUExZX0FDSzoKPiAtCQkJaWYg KGVyciA8IHNpemUpCj4gLQkJCQlyZXR1cm4gLUVQUk9UTzsKPiAtCQkJcmV0dXJuIGVycjsKPiAg Cj4gLQkJY2FzZSBEUF9BVVhfTkFUSVZFX1JFUExZX05BQ0s6Cj4gLQkJCXJldHVybiAtRUlPOwoK Q2hhbmdlICMzYi4gQ2hhbmdpbmcgd2hpY2ggZXJyb3JzIGxlYWQgdG8gcmV0cmllcy4KCj4gKwkJ aWYgKHJldCA+IDApIHsKPiArCQkJbmF0aXZlX3JlcGx5ID0gbXNnLnJlcGx5ICYgRFBfQVVYX05B VElWRV9SRVBMWV9NQVNLOwo+ICsJCQlpZiAobmF0aXZlX3JlcGx5ID09IERQX0FVWF9OQVRJVkVf UkVQTFlfQUNLKSB7Cj4gKwkJCQlpZiAocmV0ID09IHNpemUpCj4gKwkJCQkJcmV0dXJuIHJldDsK PiAgCj4gLQkJY2FzZSBEUF9BVVhfTkFUSVZFX1JFUExZX0RFRkVSOgo+IC0JCQl1c2xlZXBfcmFu Z2UoQVVYX1JFVFJZX0lOVEVSVkFMLCBBVVhfUkVUUllfSU5URVJWQUwgKyAxMDApOwo+IC0JCQli cmVhazsKPiArCQkJCXJldCA9IC1FUFJPVE87Cj4gKwkJCX0gZWxzZQo+ICsJCQkJcmV0ID0gLUVJ TzsKPiAgCQl9Cj4gIAl9Cj4gIAo+ICAJRFJNX0RFQlVHX0tNUygidG9vIG1hbnkgcmV0cmllcywg Z2l2aW5nIHVwXG4iKTsKPiAtCXJldHVybiAtRUlPOwo+ICsJcmV0dXJuIHJldDsKCkNoYW5nZSAj NC4gUHJvcGFnYXRpbmcgZXJyb3JzIGZyb20gdGhlIGxhc3QgcmV0cnkuIChUaGUgZXJyb3IgZnJv bSB0aGUKbGFzdCByZXRyeSBtaWdodCBub3QgZXZlbiBiZSByZXByZXNlbnRhdGl2ZSBvZiB3aGF0 IHJlYWxseSB3ZW50IGRvd24uKQoKPiAgfQo+ICAKPiAgLyoqCj4gQEAgLTI0MSw2ICsyMzUsMTMg QEAgc3RhdGljIGludCBkcm1fZHBfZHBjZF9hY2Nlc3Moc3RydWN0IGRybV9kcF9hdXggKmF1eCwg dTggcmVxdWVzdCwKPiAgc3NpemVfdCBkcm1fZHBfZHBjZF9yZWFkKHN0cnVjdCBkcm1fZHBfYXV4 ICphdXgsIHVuc2lnbmVkIGludCBvZmZzZXQsCj4gIAkJCSB2b2lkICpidWZmZXIsIHNpemVfdCBz aXplKQo+ICB7Cj4gKwkvKgo+ICsJICogU29tZXRpbWVzIHdlIGp1c3QgZ2V0IHRoZSBzYW1lIGlu Y29ycmVjdCBieXRlIHJlcGVhdGVkIG92ZXIgdGhlCj4gKwkgKiBlbnRpcmUgYnVmZmVyLiBEb2lu ZyBvbmUgdGhyb3cgYXdheSByZWFkIGluaXRpYWxseSBzZWVtcyB0byAic29sdmUiCj4gKwkgKiBp dC4KPiArCSAqLwo+ICsJZHJtX2RwX2RwY2RfYWNjZXNzKGF1eCwgRFBfQVVYX05BVElWRV9SRUFE LCBEUF9EUENEX1JFViwgYnVmZmVyLCAxKTsKPiArCgpDaGFuZ2UgIzUuIERvaW5nIGEgZHVtbXkg cmVhZCB0byBlbnN1cmUgdGhlIHNpbmsgaXMgYXdha2UuCgoKQlIsCkphbmkuCgo+ICAJcmV0dXJu IGRybV9kcF9kcGNkX2FjY2VzcyhhdXgsIERQX0FVWF9OQVRJVkVfUkVBRCwgb2Zmc2V0LCBidWZm ZXIsCj4gIAkJCQkgIHNpemUpOwo+ICB9CgotLSAKSmFuaSBOaWt1bGEsIEludGVsIE9wZW4gU291 cmNlIFRlY2hub2xvZ3kgQ2VudGVyCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVk ZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZv L2RyaS1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932179AbcCXJiE (ORCPT ); Thu, 24 Mar 2016 05:38:04 -0400 Received: from mga11.intel.com ([192.55.52.93]:25831 "EHLO mga11.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752485AbcCXJh7 (ORCPT ); Thu, 24 Mar 2016 05:37:59 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.24,384,1455004800"; d="scan'208";a="944055647" From: Jani Nikula To: Lyude , intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Cc: arthur.j.runyan@intel.com, Ville =?utf-8?B?U3lyasOkbMOk?= , Lyude , David Airlie , open list Subject: Re: [PATCH v3 1/2 RESEND] drm/dp_helper: add workarounds from intel_dp_dpcd_read_wake() In-Reply-To: <1458761593-13561-1-git-send-email-cpaul@redhat.com> Organization: Intel Finland Oy - BIC 0357606-4 - Westendinkatu 7, 02160 Espoo References: <1458761417-12165-1-git-send-email-cpaul@redhat.com> <1458761593-13561-1-git-send-email-cpaul@redhat.com> User-Agent: Notmuch/0.21+80~g3ff6f8b (http://notmuchmail.org) Emacs/24.4.1 (x86_64-pc-linux-gnu) Date: Thu, 24 Mar 2016 11:37:35 +0200 Message-ID: <87mvpodxnk.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 Wed, 23 Mar 2016, Lyude wrote: > Some sinks need some time during the process of resuming the system from > sleep before they're ready to handle transactions. While it would be > nice if they responded with NACKs in these scenarios, this isn't always > the case as a few sinks will just timeout on all of the transactions > they receive. > > This patch was originally intended to be a workaround for a very > mysterious bug on the T560, where any monitors connected to the dock > would fail to turn back on after resume. When resuming the laptop, it > appears that there's a short period of time where we're unable to > complete any aux transactions, as they all immediately timeout. The only > machine I'm able to reproduce this on is the T560 as other production > Skylake models seem to be fine. The period during which AUX transactions > fail appears to be around 22ms long. AFAIK, the dock for the T560 never > actually turns off, the only difference is that it's in SST mode at the > start of the resume process, so it's unclear as to why it would need so > much time to come back up. > > There's been a discussion on this issue going on for a while on the > intel-gfx mailing list about this that has, in addition to including > developers from Intel, also had the correspondence of one of the > hardware engineers for Intel: > > http://www.spinics.net/lists/intel-gfx/msg88831.html > http://www.spinics.net/lists/intel-gfx/msg88410.html > > We've already looked into a couple of possible explanations for the > problem: > > - Calling intel_dp_mst_resume() before right fix. > intel_runtime_pm_enable_interrupts(). This was the first fix I tried, > and while it worked it definitely wasn't the right fix. This worked > because DP aux transactions don't actually require interrupts to work: > > static uint32_t > intel_dp_aux_wait_done(struct intel_dp *intel_dp, bool has_aux_irq) > { > struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp); > struct drm_device *dev = intel_dig_port->base.base.dev; > struct drm_i915_private *dev_priv = dev->dev_private; > i915_reg_t ch_ctl = intel_dp->aux_ch_ctl_reg; > uint32_t status; > bool done; > > #define C (((status = I915_READ_NOTRACE(ch_ctl)) & DP_AUX_CH_CTL_SEND_BUSY) == 0) > if (has_aux_irq) > done = wait_event_timeout(dev_priv->gmbus_wait_queue, C, > msecs_to_jiffies_timeout(10)); > else > done = wait_for_atomic(C, 10) == 0; > if (!done) > DRM_ERROR("dp aux hw did not signal timeout (has irq: %i)!\n", > has_aux_irq); > #undef C > > return status; > } > > When there's no interrupts enabled, we end up timing out on the > wait_event_timeout() call, which causes us to check the DP status > register once to see if the transaction was successful or not. Since > this adds a 10ms delay to each aux transaction, it ends up adding a > long enough delay to the resume process for aux transactions to become > functional again. This gave us the illusion that enabling interrupts > had something to do with making things work again, and put me on the > wrong track for a while. > > - Interrupts occurring when we try to perform the aux transactions > required to put the dock back into MST mode. This isn't the problem, > as the only interrupts I've observed that come during this timeout > period are from the snd_hda_intel driver, and disabling that driver > doesn't appear to change the behavior at all. > > - Skylake's PSR block causing issues by performing aux transactions > while we try to bring the dock out of MST mode. Disabling PSR through > i915's command line options doesn't seem to change the behavior > either, nor does preventing the DMC firmware from being loaded. > > Since this investigation went on for about 2 weeks, we decided it would > be better for the time being to just workaround this issue until we find > a better fix. This patch adds some behavior we want in > drm_dp_dpcd_access() anyway, since DP aux transactions aren't exactly > robust and this will probably fix quite a few other issues with DP MST > hardware not responding in time. Plus, this is something we already do > in the i915 driver with intel_dp_dpcd_read_wake(), except that that > function is somewhat of a hack and DRM helpers can't make use of it. > > Changes since v2 > - Reworked the patch again to incorporate all of the behavior of > intel_dp_dpcd_read_wake() into drm_dp_dpcd_read() and > drm_dp_dpcd_access() > > Changes since v1 > > - Patch has been reworked to take the retry logic out of > intel_dp_mst_resume() and into drm_dp_dpcd_access(), based off a > suggestion from Daniel Vetter > > - Commit message is much longer and gives a better description of the > issue this was originally intended to workaround. > > Signed-off-by: Lyude We've had a lot of issues with dp aux in the past, and we've slowly and iteratively improved over time. In that light, I am strongly opposed to doing as many changes in one go as this patch does. If we got a bisect result on this, it would be hard to decide what it really was. We might have to revert it all even if some parts of it were good. I'll identify some of the changes below that I think must be separated to distinct changes. (The numbers don't necessarily reflect the order in which the changes should be done.) > --- > Left some rebase ditritus in the patch after sending it by accident, whoops > > drivers/gpu/drm/drm_dp_helper.c | 47 +++++++++++++++++++++-------------------- > 1 file changed, 24 insertions(+), 23 deletions(-) > > diff --git a/drivers/gpu/drm/drm_dp_helper.c b/drivers/gpu/drm/drm_dp_helper.c > index 9535c5b..9b3426c 100644 > --- a/drivers/gpu/drm/drm_dp_helper.c > +++ b/drivers/gpu/drm/drm_dp_helper.c > @@ -159,7 +159,7 @@ int drm_dp_bw_code_to_link_rate(u8 link_bw) > } > EXPORT_SYMBOL(drm_dp_bw_code_to_link_rate); > > -#define AUX_RETRY_INTERVAL 500 /* us */ > +#define AUX_RETRY_INTERVAL 1000 /* us */ Change #1. Increasing the retry interval. > > /** > * DOC: dp helpers > @@ -177,8 +177,8 @@ static int drm_dp_dpcd_access(struct drm_dp_aux *aux, u8 request, > unsigned int offset, void *buffer, size_t size) > { > struct drm_dp_aux_msg msg; > - unsigned int retry; > - int err; > + unsigned int retry, native_reply; > + int ret = 0; > > memset(&msg, 0, sizeof(msg)); > msg.address = offset; > @@ -193,35 +193,29 @@ static int drm_dp_dpcd_access(struct drm_dp_aux *aux, u8 request, > * sufficient, bump to 32 which makes Dell 4k monitors happier. > */ > for (retry = 0; retry < 32; retry++) { > + if (ret != 0 && ret != -ETIMEDOUT) { > + usleep_range(AUX_RETRY_INTERVAL, > + AUX_RETRY_INTERVAL + 100); Change #2. Changing the conditions on when to sleep between retries. > + } > > mutex_lock(&aux->hw_mutex); > - err = aux->transfer(aux, &msg); > + ret = aux->transfer(aux, &msg); > mutex_unlock(&aux->hw_mutex); > - if (err < 0) { > - if (err == -EBUSY) > - continue; Change #3a. Changing which errors lead to retries. > - > - return err; > - } > - > - > - switch (msg.reply & DP_AUX_NATIVE_REPLY_MASK) { > - case DP_AUX_NATIVE_REPLY_ACK: > - if (err < size) > - return -EPROTO; > - return err; > > - case DP_AUX_NATIVE_REPLY_NACK: > - return -EIO; Change #3b. Changing which errors lead to retries. > + if (ret > 0) { > + native_reply = msg.reply & DP_AUX_NATIVE_REPLY_MASK; > + if (native_reply == DP_AUX_NATIVE_REPLY_ACK) { > + if (ret == size) > + return ret; > > - case DP_AUX_NATIVE_REPLY_DEFER: > - usleep_range(AUX_RETRY_INTERVAL, AUX_RETRY_INTERVAL + 100); > - break; > + ret = -EPROTO; > + } else > + ret = -EIO; > } > } > > DRM_DEBUG_KMS("too many retries, giving up\n"); > - return -EIO; > + return ret; Change #4. Propagating errors from the last retry. (The error from the last retry might not even be representative of what really went down.) > } > > /** > @@ -241,6 +235,13 @@ static int drm_dp_dpcd_access(struct drm_dp_aux *aux, u8 request, > ssize_t drm_dp_dpcd_read(struct drm_dp_aux *aux, unsigned int offset, > void *buffer, size_t size) > { > + /* > + * Sometimes we just get the same incorrect byte repeated over the > + * entire buffer. Doing one throw away read initially seems to "solve" > + * it. > + */ > + drm_dp_dpcd_access(aux, DP_AUX_NATIVE_READ, DP_DPCD_REV, buffer, 1); > + Change #5. Doing a dummy read to ensure the sink is awake. BR, Jani. > return drm_dp_dpcd_access(aux, DP_AUX_NATIVE_READ, offset, buffer, > size); > } -- Jani Nikula, Intel Open Source Technology Center