From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= Subject: Re: [PATCHv3 1/3] drm: add support for DisplayPort CEC-Tunneling-over-AUX Date: Wed, 13 Sep 2017 13:56:04 +0300 Message-ID: <20170913105604.GF4914@intel.com> References: <20170911112547.7133-1-hverkuil@xs4all.nl> <20170911112547.7133-2-hverkuil@xs4all.nl> <20170912173935.GB4914@intel.com> <1757067a-d0dc-cbe6-0cb3-084d0bb5fc97@xs4all.nl> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by gabe.freedesktop.org (Postfix) with ESMTPS id A562A6E0BB for ; Wed, 13 Sep 2017 10:56:08 +0000 (UTC) Content-Disposition: inline In-Reply-To: <1757067a-d0dc-cbe6-0cb3-084d0bb5fc97@xs4all.nl> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Hans Verkuil Cc: Daniel Vetter , dri-devel@lists.freedesktop.org, Hans Verkuil , linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org T24gV2VkLCBTZXAgMTMsIDIwMTcgYXQgMTA6NTE6MDJBTSArMDIwMCwgSGFucyBWZXJrdWlsIHdy b3RlOgo+IE9uIDA5LzEyLzIwMTcgMDc6MzkgUE0sIFZpbGxlIFN5cmrDpGzDpCB3cm90ZToKPiA+ IE9uIE1vbiwgU2VwIDExLCAyMDE3IGF0IDAxOjI1OjQ1UE0gKzAyMDAsIEhhbnMgVmVya3VpbCB3 cm90ZToKPiA+PiBGcm9tOiBIYW5zIFZlcmt1aWwgPGhhbnMudmVya3VpbEBjaXNjby5jb20+Cj4g Pj4KPiA+PiBUaGlzIGFkZHMgc3VwcG9ydCBmb3IgdGhlIERpc3BsYXlQb3J0IENFQy1UdW5uZWxp bmctb3Zlci1BVVgKPiA+PiBmZWF0dXJlIHRoYXQgaXMgcGFydCBvZiB0aGUgRGlzcGxheVBvcnQg MS4zIHN0YW5kYXJkLgo+ID4+Cj4gPj4gVW5mb3J0dW5hdGVseSwgbm90IGFsbCBEaXNwbGF5UG9y dC9VU0ItQyB0byBIRE1JIGFkYXB0ZXJzIHdpdGggYQo+ID4+IGNoaXAgdGhhdCBoYXMgdGhpcyBj YXBhYmlsaXR5IGFjdHVhbGx5IGhvb2sgdXAgdGhlIENFQyBwaW4sIHNvCj4gPj4gZXZlbiB0aG91 Z2ggYSBDRUMgZGV2aWNlIGlzIGNyZWF0ZWQsIGl0IG1heSBub3QgYWN0dWFsbHkgd29yay4KPiA+ Pgo+ID4+IFNpZ25lZC1vZmYtYnk6IEhhbnMgVmVya3VpbCA8aGFucy52ZXJrdWlsQGNpc2NvLmNv bT4KPiA+PiBUZXN0ZWQtYnk6IENhcmxvcyBTYW50YSA8Y2FybG9zLnNhbnRhQGludGVsLmNvbT4K PiA+PiAtLS0KPiA+PiAgZHJpdmVycy9ncHUvZHJtL0tjb25maWcgICAgICB8ICAxMCArKwo+ID4+ ICBkcml2ZXJzL2dwdS9kcm0vTWFrZWZpbGUgICAgIHwgICAxICsKPiA+PiAgZHJpdmVycy9ncHUv ZHJtL2RybV9kcF9jZWMuYyB8IDMwMSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrCj4gPj4gIGluY2x1ZGUvZHJtL2RybV9kcF9oZWxwZXIuaCAgfCAgMjQgKysrKwo+ ID4+ICA0IGZpbGVzIGNoYW5nZWQsIDMzNiBpbnNlcnRpb25zKCspCj4gPj4gIGNyZWF0ZSBtb2Rl IDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0vZHJtX2RwX2NlYy5jCj4gPj4KPiA+PiBkaWZmIC0tZ2l0 IGEvZHJpdmVycy9ncHUvZHJtL0tjb25maWcgYi9kcml2ZXJzL2dwdS9kcm0vS2NvbmZpZwo+ID4+ IGluZGV4IDgzY2IyYTg4YzIwNC4uMWYyNzA4ZGY1YzRlIDEwMDY0NAo+ID4+IC0tLSBhL2RyaXZl cnMvZ3B1L2RybS9LY29uZmlnCj4gPj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL0tjb25maWcKPiA+ PiBAQCAtMTIwLDYgKzEyMCwxNiBAQCBjb25maWcgRFJNX0xPQURfRURJRF9GSVJNV0FSRQo+ID4+ ICAJICBkZWZhdWx0IGNhc2UgaXMgTi4gRGV0YWlscyBhbmQgaW5zdHJ1Y3Rpb25zIGhvdyB0byBi dWlsZCB5b3VyIG93bgo+ID4+ICAJICBFRElEIGRhdGEgYXJlIGdpdmVuIGluIERvY3VtZW50YXRp b24vRURJRC9IT1dUTy50eHQuCj4gPj4gIAo+ID4+ICtjb25maWcgRFJNX0RQX0NFQwo+ID4+ICsJ Ym9vbCAiRW5hYmxlIERpc3BsYXlQb3J0IENFQy1UdW5uZWxpbmctb3Zlci1BVVggSERNSSBzdXBw b3J0Igo+ID4+ICsJc2VsZWN0IENFQ19DT1JFCj4gPj4gKwloZWxwCj4gPj4gKwkgIENob29zZSB0 aGlzIG9wdGlvbiBpZiB5b3Ugd2FudCB0byBlbmFibGUgSERNSSBDRUMgc3VwcG9ydCBmb3IKPiA+ PiArCSAgRGlzcGxheVBvcnQvVVNCLUMgdG8gSERNSSBhZGFwdGVycy4KPiA+PiArCj4gPj4gKwkg IE5vdGU6IG5vdCBhbGwgYWRhcHRlcnMgc3VwcG9ydCB0aGlzIGZlYXR1cmUsIGFuZCBldmVuIGZv ciB0aG9zZQo+ID4+ICsJICB0aGF0IGRvIHN1cHBvcnQgdGhpcyB0aGV5IG9mdGVuIGRvIG5vdCBo b29rIHVwIHRoZSBDRUMgcGluLgo+ID4+ICsKPiA+PiAgY29uZmlnIERSTV9UVE0KPiA+PiAgCXRy aXN0YXRlCj4gPj4gIAlkZXBlbmRzIG9uIERSTSAmJiBNTVUKPiA+PiBkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL01ha2VmaWxlIGIvZHJpdmVycy9ncHUvZHJtL01ha2VmaWxlCj4gPj4gaW5k ZXggMjRhMDY2ZTE4NDFjLi5jNjU1MmM2MjA0OWUgMTAwNjQ0Cj4gPj4gLS0tIGEvZHJpdmVycy9n cHUvZHJtL01ha2VmaWxlCj4gPj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL01ha2VmaWxlCj4gPj4g QEAgLTQwLDYgKzQwLDcgQEAgZHJtX2ttc19oZWxwZXItJChDT05GSUdfRFJNX0xPQURfRURJRF9G SVJNV0FSRSkgKz0gZHJtX2VkaWRfbG9hZC5vCj4gPj4gIGRybV9rbXNfaGVscGVyLSQoQ09ORklH X0RSTV9GQkRFVl9FTVVMQVRJT04pICs9IGRybV9mYl9oZWxwZXIubwo+ID4+ICBkcm1fa21zX2hl bHBlci0kKENPTkZJR19EUk1fS01TX0NNQV9IRUxQRVIpICs9IGRybV9mYl9jbWFfaGVscGVyLm8K PiA+PiAgZHJtX2ttc19oZWxwZXItJChDT05GSUdfRFJNX0RQX0FVWF9DSEFSREVWKSArPSBkcm1f ZHBfYXV4X2Rldi5vCj4gPj4gK2RybV9rbXNfaGVscGVyLSQoQ09ORklHX0RSTV9EUF9DRUMpICs9 IGRybV9kcF9jZWMubwo+ID4+ICAKPiA+PiAgb2JqLSQoQ09ORklHX0RSTV9LTVNfSEVMUEVSKSAr PSBkcm1fa21zX2hlbHBlci5vCj4gPj4gIG9iai0kKENPTkZJR19EUk1fREVCVUdfTU1fU0VMRlRF U1QpICs9IHNlbGZ0ZXN0cy8KPiA+PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2RybV9k cF9jZWMuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fZHBfY2VjLmMKPiA+PiBuZXcgZmlsZSBtb2Rl IDEwMDY0NAo+ID4+IGluZGV4IDAwMDAwMDAwMDAwMC4uYjgzMWJiNzJjOTMyCj4gPj4gLS0tIC9k ZXYvbnVsbAo+ID4+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fZHBfY2VjLmMKPiA+PiBAQCAt MCwwICsxLDMwMSBAQAo+ID4+ICsvKgo+ID4+ICsgKiBEaXNwbGF5UG9ydCBDRUMtVHVubmVsaW5n LW92ZXItQVVYIHN1cHBvcnQKPiA+PiArICoKPiA+PiArICogQ29weXJpZ2h0IDIwMTcgQ2lzY28g U3lzdGVtcywgSW5jLiBhbmQvb3IgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQu Cj4gPj4gKyAqCj4gPj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgbWF5 IHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Cj4gPj4gKyAqIGl0IHVuZGVyIHRoZSB0ZXJt cyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Cj4gPj4g KyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IHZlcnNpb24gMiBvZiB0aGUgTGljZW5z ZS4KPiA+PiArICoKPiA+PiArICogVEhFIFNPRlRXQVJFIElTIFBST1ZJREVEICJBUyBJUyIsIFdJ VEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsCj4gPj4gKyAqIEVYUFJFU1MgT1IgSU1QTElFRCwg SU5DTFVESU5HIEJVVCBOT1QgTElNSVRFRCBUTyBUSEUgV0FSUkFOVElFUyBPRgo+ID4+ICsgKiBN RVJDSEFOVEFCSUxJVFksIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFORAo+ID4+ ICsgKiBOT05JTkZSSU5HRU1FTlQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBBVVRIT1JTIE9SIENP UFlSSUdIVCBIT0xERVJTCj4gPj4gKyAqIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VT IE9SIE9USEVSIExJQUJJTElUWSwgV0hFVEhFUiBJTiBBTgo+ID4+ICsgKiBBQ1RJT04gT0YgQ09O VFJBQ1QsIFRPUlQgT1IgT1RIRVJXSVNFLCBBUklTSU5HIEZST00sIE9VVCBPRiBPUiBJTgo+ID4+ ICsgKiBDT05ORUNUSU9OIFdJVEggVEhFIFNPRlRXQVJFIE9SIFRIRSBVU0UgT1IgT1RIRVIgREVB TElOR1MgSU4gVEhFCj4gPj4gKyAqIFNPRlRXQVJFLgo+ID4+ICsgKi8KPiA+PiArCj4gPj4gKyNp bmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KPiA+PiArI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgo+ ID4+ICsjaW5jbHVkZSA8bGludXgvc2xhYi5oPgo+ID4+ICsjaW5jbHVkZSA8ZHJtL2RybV9kcF9o ZWxwZXIuaD4KPiA+PiArI2luY2x1ZGUgPG1lZGlhL2NlYy5oPgo+ID4+ICsKPiA+PiArLyoKPiA+ PiArICogVW5mb3J0dW5hdGVseSBpdCB0dXJucyBvdXQgdGhhdCB3ZSBoYXZlIGEgY2hpY2tlbi1h bmQtZWdnIHNpdHVhdGlvbgo+ID4+ICsgKiBoZXJlLiBRdWl0ZSBhIGZldyBhY3RpdmUgKG1pbmkt KURQLXRvLUhETUkgb3IgVVNCLUMtdG8tSERNSSBhZGFwdGVycwo+ID4+ICsgKiBoYXZlIGEgY29u dmVydGVyIGNoaXAgdGhhdCBzdXBwb3J0cyBDRUMtVHVubmVsaW5nLW92ZXItQVVYICh1c3VhbGx5 IHRoZQo+ID4+ICsgKiBQYXJhZGUgUFMxNzYpLCBidXQgdGhleSBkbyBub3Qgd2lyZSB1cCB0aGUg Q0VDIHBpbiwgdGh1cyBtYWtpbmcgQ0VDCj4gPj4gKyAqIHVzZWxlc3MuCj4gPj4gKyAqCj4gPj4g KyAqIFNhZGx5IHRoZXJlIGlzIG5vIHdheSBmb3IgdGhpcyBkcml2ZXIgdG8ga25vdyB0aGlzLiBX aGF0IGhhcHBlbnMgaXMKPiA+PiArICogdGhhdCBhIC9kZXYvY2VjWCBkZXZpY2UgaXMgY3JlYXRl ZCB0aGF0IGlzIGlzb2xhdGVkIGFuZCB1bmFibGUgdG8gc2VlCj4gPj4gKyAqIGFueSBvZiB0aGUg b3RoZXIgQ0VDIGRldmljZXMuIFF1aXRlIGxpdGVyYWxseSB0aGUgQ0VDIHdpcmUgaXMgY3V0Cj4g Pj4gKyAqIChvciBpbiB0aGlzIGNhc2UsIG5ldmVyIGNvbm5lY3RlZCBpbiB0aGUgZmlyc3QgcGxh Y2UpLgo+ID4+ICsgKgo+ID4+ICsgKiBJIHN1c3BlY3QgdGhhdCB0aGUgcmVhc29uIHNvIGZldyBh ZGFwdGVycyBzdXBwb3J0IHRoaXMgaXMgdGhhdCB0aGlzCj4gPj4gKyAqIHR1bm5lbGluZyBwcm90 b2NvbCB3YXMgbmV2ZXIgc3VwcG9ydGVkIGJ5IGFueSBPUy4gU28gdGhlcmUgd2FzIG5vCj4gPj4g KyAqIGVhc3kgd2F5IG9mIHRlc3RpbmcgaXQsIGFuZCBubyBpbmNlbnRpdmUgdG8gY29ycmVjdGx5 IHdpcmUgdXAgdGhlCj4gPj4gKyAqIENFQyBwaW4uCj4gPj4gKyAqCj4gPj4gKyAqIEhvcGVmdWxs eSBieSBjcmVhdGluZyB0aGlzIGRyaXZlciBpdCB3aWxsIGJlIGVhc2llciBmb3IgdmVuZG9ycyB0 bwo+ID4+ICsgKiBmaW5hbGx5IGZpeCB0aGVpciBhZGFwdGVycyBhbmQgdGVzdCB0aGUgQ0VDIGZ1 bmN0aW9uYWxpdHkuCj4gPj4gKyAqCj4gPj4gKyAqIEkga2VlcCBhIGxpc3Qgb2Yga25vd24gd29y a2luZyBhZGFwdGVycyBoZXJlOgo+ID4+ICsgKgo+ID4+ICsgKiBodHRwczovL2h2ZXJrdWlsLmhv bWUueHM0YWxsLm5sL2NlYy1zdGF0dXMudHh0Cj4gPj4gKyAqCj4gPj4gKyAqIFBsZWFzZSBtYWls IG1lIChodmVya3VpbEB4czRhbGwubmwpIGlmIHlvdSBmaW5kIGFuIGFkYXB0ZXIgdGhhdCB3b3Jr cwo+ID4+ICsgKiBhbmQgaXMgbm90IHlldCBsaXN0ZWQgdGhlcmUuCj4gPj4gKyAqLwo+ID4+ICsK PiA+PiArLyoqCj4gPj4gKyAqIERPQzogZHAgY2VjIGhlbHBlcnMKPiA+PiArICoKPiA+PiArICog VGhlc2UgZnVuY3Rpb25zIHRha2UgY2FyZSBvZiBzdXBwb3J0aW5nIHRoZSBDRUMtVHVubmVsaW5n LW92ZXItQVVYCj4gPj4gKyAqIGZlYXR1cmUgb2YgRGlzcGxheVBvcnQtdG8tSERNSSBhZGFwdGVy cy4KPiA+PiArICovCj4gPj4gKwo+ID4+ICtzdGF0aWMgaW50IGRybV9kcF9jZWNfYWRhcF9lbmFi bGUoc3RydWN0IGNlY19hZGFwdGVyICphZGFwLCBib29sIGVuYWJsZSkKPiA+PiArewo+ID4+ICsJ c3RydWN0IGRybV9kcF9hdXggKmF1eCA9IGNlY19nZXRfZHJ2ZGF0YShhZGFwKTsKPiA+PiArCXUz MiB2YWwgPSBlbmFibGUgPyBEUF9DRUNfVFVOTkVMSU5HX0VOQUJMRSA6IDA7Cj4gPj4gKwlzc2l6 ZV90IGVyciA9IDA7Cj4gPj4gKwo+ID4+ICsJZXJyID0gZHJtX2RwX2RwY2Rfd3JpdGViKGF1eCwg RFBfQ0VDX1RVTk5FTElOR19DT05UUk9MLCB2YWwpOwo+ID4+ICsJcmV0dXJuIChlbmFibGUgJiYg ZXJyIDwgMCkgPyBlcnIgOiAwOwo+ID4+ICt9Cj4gPj4gKwo+ID4+ICtzdGF0aWMgaW50IGRybV9k cF9jZWNfYWRhcF9sb2dfYWRkcihzdHJ1Y3QgY2VjX2FkYXB0ZXIgKmFkYXAsIHU4IGFkZHIpCj4g Pj4gK3sKPiA+PiArCXN0cnVjdCBkcm1fZHBfYXV4ICphdXggPSBjZWNfZ2V0X2RydmRhdGEoYWRh cCk7Cj4gPj4gKwkvKiBCaXQgMTUgKGxvZ2ljYWwgYWRkcmVzcyAxNSkgc2hvdWxkIGFsd2F5cyBi ZSBzZXQgKi8KPiA+PiArCXUxNiBsYV9tYXNrID0gMSA8PCBDRUNfTE9HX0FERFJfQlJPQURDQVNU Owo+ID4+ICsJdTggbWFza1syXTsKPiA+PiArCXNzaXplX3QgZXJyOwo+ID4+ICsKPiA+PiArCWlm IChhZGRyICE9IENFQ19MT0dfQUREUl9JTlZBTElEKQo+ID4+ICsJCWxhX21hc2sgfD0gYWRhcC0+ bG9nX2FkZHJzLmxvZ19hZGRyX21hc2sgfCAoMSA8PCBhZGRyKTsKPiA+PiArCW1hc2tbMF0gPSBs YV9tYXNrICYgMHhmZjsKPiA+PiArCW1hc2tbMV0gPSBsYV9tYXNrID4+IDg7Cj4gPj4gKwllcnIg PSBkcm1fZHBfZHBjZF93cml0ZShhdXgsIERQX0NFQ19MT0dJQ0FMX0FERFJFU1NfTUFTSywgbWFz aywgMik7Cj4gPj4gKwlyZXR1cm4gKGFkZHIgIT0gQ0VDX0xPR19BRERSX0lOVkFMSUQgJiYgZXJy IDwgMCkgPyBlcnIgOiAwOwo+ID4+ICt9Cj4gPj4gKwo+ID4+ICtzdGF0aWMgaW50IGRybV9kcF9j ZWNfYWRhcF90cmFuc21pdChzdHJ1Y3QgY2VjX2FkYXB0ZXIgKmFkYXAsIHU4IGF0dGVtcHRzLAo+ ID4+ICsJCQkJICAgIHUzMiBzaWduYWxfZnJlZV90aW1lLCBzdHJ1Y3QgY2VjX21zZyAqbXNnKQo+ ID4+ICt7Cj4gPj4gKwlzdHJ1Y3QgZHJtX2RwX2F1eCAqYXV4ID0gY2VjX2dldF9kcnZkYXRhKGFk YXApOwo+ID4+ICsJdW5zaWduZWQgaW50IHJldHJpZXMgPSBtaW4oNSwgYXR0ZW1wdHMgLSAxKTsK PiA+PiArCXNzaXplX3QgZXJyOwo+ID4+ICsKPiA+PiArCWVyciA9IGRybV9kcF9kcGNkX3dyaXRl KGF1eCwgRFBfQ0VDX1RYX01FU1NBR0VfQlVGRkVSLAo+ID4+ICsJCQkJbXNnLT5tc2csIG1zZy0+ bGVuKTsKPiA+PiArCWlmIChlcnIgPCAwKQo+ID4+ICsJCXJldHVybiBlcnI7Cj4gPiAKPiA+IFdo YXQgaGFwcGVucyBpZiB3ZSBtYW5hZ2VkIHRvIHdyaXRlIHRoZSBkYXRhIG9ubHkgcGFydGlhbGx5 Pwo+ID4gCj4gPiBMb29raW5nIGF0IG91ciBjb2RlLCBJICp0aGluayogd2UgY2FuJ3QgYWN0YWxs eSByZXR1cm4gMCBldmVyLCBzbyB0aGUgCj4gPiBfd3JpdGViKCkgdmFyaWFudCBzZWVtIHNhZmUg d2l0aCB0aGUgPDAgY2hlY2tzLiBCdXQgdGhlIGZ1bGwgX3dyaXRlKCkKPiA+IGNvdWxkIGNlcnRh aW5seSByZXR1cm4gc29tZXRoaW5nIGJldHdlZW4gMSBhbmQgdGhlIHRvdGFsIHNpemUuCj4gCj4g Tm90IGFjY29yZGluZyB0byB0aGUgZHJtX2RwX2RwY2Rfd3JpdGUoKSBkb2N1bWVudGF0aW9uOgo+ IAo+ICJJZiBub3QgYWxsIGJ5dGVzIHdlcmUgdHJhbnNmZXJyZWQsIHRoaXMgZnVuY3Rpb24gcmV0 dXJucyAtRVBST1RPLiIKPiAKPiBMb29raW5nIGF0IHRoZSBpbXBsZW1lbnRhdGlvbiwgdGhhdCBp cyBleGFjdGx5IHdoYXQgaGFwcGVucy4KCkhtbS4gSW5kZWVkLiBUaGUgZG9jdW1lbnRhdGlvbiBz dXJlIGlzIGNvbmZ1c2luZyBiZWNhdXNlIGl0IHN0YXJ0cyBieQpzYXlpbmcgIlJldHVybnMgdGhl IG51bWJlciBvZiBieXRlcyB0cmFuc2ZlcnJlZCBvbiBzdWNjZXNzLCBvciBhCm5lZ2F0aXZlIGVy cm9yIGNvZGUgb24gZmFpbHVyZS4iLCBhbmQgb25seSBsYXRlciBpdCBzZWVtcyB0byBjbGFyaWZ5 CnRoYXQgYSBub3QgYmVpbmcgYWJsZSB0byB0cmFuc2ZlciBhbGwgdGhlIGJ5dGVzIGlzIGNvbnNp ZGVyZWQgYW4gZXJyb3IuCldlIG1pZ2h0IHdhbnQgdG8gcmV3b3JkIHRoYXQgc29tZWhvdyBiZWNh dXNlIEknbSBzdXJlbHkgbm90IHRoZSBvbmx5Cm9uZSB0aGF0J3MgY29uZnVzZWQgYnkgdGhpcy4K CkFsc28gbWFraW5nIHNvbWV0aGluZyBsb29rIGxpa2UgcmVhZCgyKS93cml0ZSgyKSBhbmQgdGhl biBub3QgZm9sbG93aW5nCnRoZSBzYW1lIGNvbnZlbnRpb25zIGlzIHJhdGhlciBiYWQgSU1PLiBX ZSBzaG91bGQgcHJvYmFibHkganVzdCBjaGFuZ2UKdGhlc2UgdG8gcmV0dXJuIDAvLWVycm5vLCBv ciB3ZSBzaG91bGQgcmVhbGx5IHN0YXJ0IGZvbGxvd2luZyB0aGUKY29tbW9uIGNvbnZlbnRpb24g Zm9yIHJlYWQvd3JpdGUuIE5vdCBxdWl0ZSBzdXJlIHdoaWNoIGlzIGJldHRlciByZWFsbHkuClRo ZSAwLy1lcnJubyB0aGluZyBpcyBlYXNpZXIgdG8gdXNlIGNlcnRhaW5seSwgYnV0IGZvciBqdXN0 IGR1bXBpbmcgb3V0CnRoZSBlbnRpcmUgRFBDRCBzaG9ydCByZWFkcyBtaWdodCBiZSBuaWNlIGZv ciB0aGUgY2FzZXMgd2hlcmUgc29tZQpyYW5kb20gcGllY2VzIG9mIERQQ0QgY2FuJ3QgYmUgc3Vj Y2VzZnVsbHkgcmVhZC4gQnV0IEkgZ3Vlc3MgdGhlCjAvLWVycm5vIHdvdWxkIGJlIHRoZSBzYWZl ciBvcHRpb24gc2luY2UgaXQgd291bGRuJ3QgYWN0dWFsbHkgY2hhbmdlCnRoZSBpbXBsZW1lbnRh dGlvbi4KCj4gCj4gPiAKPiA+PiArCj4gPj4gKwllcnIgPSBkcm1fZHBfZHBjZF93cml0ZWIoYXV4 LCBEUF9DRUNfVFhfTUVTU0FHRV9JTkZPLAo+ID4+ICsJCQkJIChtc2ctPmxlbiAtIDEpIHwgKHJl dHJpZXMgPDwgNCkgfAo+ID4+ICsJCQkJIERQX0NFQ19UWF9NRVNTQUdFX1NFTkQpOwo+ID4+ICsJ cmV0dXJuIGVyciA8IDAgPyBlcnIgOiAwOwo+ID4+ICt9Cj4gPj4gKwo+ID4+ICtzdGF0aWMgaW50 IGRybV9kcF9jZWNfYWRhcF9tb25pdG9yX2FsbF9lbmFibGUoc3RydWN0IGNlY19hZGFwdGVyICph ZGFwLAo+ID4+ICsJCQkJCSAgICAgIGJvb2wgZW5hYmxlKQo+ID4+ICt7Cj4gPj4gKwlzdHJ1Y3Qg ZHJtX2RwX2F1eCAqYXV4ID0gY2VjX2dldF9kcnZkYXRhKGFkYXApOwo+ID4+ICsJc3NpemVfdCBl cnI7Cj4gPj4gKwl1OCB2YWw7Cj4gPj4gKwo+ID4+ICsJaWYgKCEoYWRhcC0+Y2FwYWJpbGl0aWVz ICYgQ0VDX0NBUF9NT05JVE9SX0FMTCkpCj4gPj4gKwkJcmV0dXJuIDA7Cj4gPj4gKwo+ID4+ICsJ ZXJyID0gZHJtX2RwX2RwY2RfcmVhZGIoYXV4LCBEUF9DRUNfVFVOTkVMSU5HX0NPTlRST0wsICZ2 YWwpOwo+ID4+ICsJaWYgKGVyciA+PSAwKSB7Cj4gPj4gKwkJaWYgKGVuYWJsZSkKPiA+PiArCQkJ dmFsIHw9IERQX0NFQ19TTk9PUElOR19FTkFCTEU7Cj4gPj4gKwkJZWxzZQo+ID4+ICsJCQl2YWwg Jj0gfkRQX0NFQ19TTk9PUElOR19FTkFCTEU7Cj4gPj4gKwkJZXJyID0gZHJtX2RwX2RwY2Rfd3Jp dGViKGF1eCwgRFBfQ0VDX1RVTk5FTElOR19DT05UUk9MLCB2YWwpOwo+ID4+ICsJfQo+ID4+ICsJ cmV0dXJuIChlbmFibGUgJiYgZXJyIDwgMCkgPyBlcnIgOiAwOwo+ID4+ICt9Cj4gPj4gKwo+ID4+ ICtzdGF0aWMgdm9pZCBkcm1fZHBfY2VjX2FkYXBfc3RhdHVzKHN0cnVjdCBjZWNfYWRhcHRlciAq YWRhcCwKPiA+PiArCQkJCSAgIHN0cnVjdCBzZXFfZmlsZSAqZmlsZSkKPiA+PiArewo+ID4+ICsJ c3RydWN0IGRybV9kcF9hdXggKmF1eCA9IGNlY19nZXRfZHJ2ZGF0YShhZGFwKTsKPiA+PiArCXU4 IGJ1ZltEUF9BVVhfTUFYX1BBWUxPQURfQllURVNdOwo+ID4+ICsJdTggaHdfcmV2Owo+ID4+ICsK PiA+PiArCWlmIChkcm1fZHBfZHBjZF9yZWFkKGF1eCwgRFBfQlJBTkNIX09VSSwKPiA+PiArCQkJ ICAgICBidWYsIHNpemVvZihidWYpKSAhPSBzaXplb2YoYnVmKSkKPiA+PiArCQlyZXR1cm47Cj4g Pj4gKwlod19yZXYgPSBidWZbOV07Cj4gPj4gKwlidWZbOV0gPSAwOwo+ID4+ICsJc2VxX3ByaW50 ZihmaWxlLCAiT1VJOiAlMDJ4LSUwMngtJTAyeFxuIiwKPiA+PiArCQkgICBidWZbMF0sIGJ1Zlsx XSwgYnVmWzJdKTsKPiA+PiArCXNlcV9wcmludGYoZmlsZSwgIklEOiAlc1xuIiwgYnVmICsgMyk7 Cj4gPj4gKwlzZXFfcHJpbnRmKGZpbGUsICJIVyBSZXY6ICVkLiVkXG4iLCBod19yZXYgPj4gNCwg aHdfcmV2ICYgMHhmKTsKPiA+PiArCS8qCj4gPj4gKwkgKiBTaG93IHRoaXMgYm90aCBpbiBkZWNp bWFsIGFuZCBoZXg6IGF0IGxlYXN0IG9uZSB2ZW5kb3IKPiA+PiArCSAqIGFsd2F5cyByZXBvcnRz IHRoaXMgaW4gaGV4Lgo+ID4+ICsJICovCj4gPj4gKwlzZXFfcHJpbnRmKGZpbGUsICJGVy9TVyBS ZXY6ICVkLiVkICgweCUwMnguMHglMDJ4KVxuIiwKPiA+PiArCQkgICBidWZbMTBdLCBidWZbMTFd LCBidWZbMTBdLCBidWZbMTFdKTsKPiA+IAo+ID4gSSBiZWxpZXZlIHN0cnVjdCBkcm1fZHBfZHBj ZF9pZGVudCBwcm92aWRlcyBhIHNsaWdodGx5IGVhc2llciB3YXkgdG8KPiA+IHBhcnNlIHRoZXNl IHJlZ2lzdGVycy4KPiAKPiBJJ2xsIHRha2UgYSBsb29rIGF0IHRoYXQuCj4gCj4gPiAKPiA+PiAr fQo+ID4+ICsKPiA+PiArc3RhdGljIGNvbnN0IHN0cnVjdCBjZWNfYWRhcF9vcHMgZHJtX2RwX2Nl Y19hZGFwX29wcyA9IHsKPiA+PiArCS5hZGFwX2VuYWJsZSA9IGRybV9kcF9jZWNfYWRhcF9lbmFi bGUsCj4gPj4gKwkuYWRhcF9sb2dfYWRkciA9IGRybV9kcF9jZWNfYWRhcF9sb2dfYWRkciwKPiA+ PiArCS5hZGFwX3RyYW5zbWl0ID0gZHJtX2RwX2NlY19hZGFwX3RyYW5zbWl0LAo+ID4+ICsJLmFk YXBfbW9uaXRvcl9hbGxfZW5hYmxlID0gZHJtX2RwX2NlY19hZGFwX21vbml0b3JfYWxsX2VuYWJs ZSwKPiA+PiArCS5hZGFwX3N0YXR1cyA9IGRybV9kcF9jZWNfYWRhcF9zdGF0dXMsCj4gPj4gK307 Cj4gPj4gKwo+ID4+ICtzdGF0aWMgaW50IGRybV9kcF9jZWNfcmVjZWl2ZWQoc3RydWN0IGRybV9k cF9hdXggKmF1eCkKPiA+PiArewo+ID4+ICsJc3RydWN0IGNlY19hZGFwdGVyICphZGFwID0gYXV4 LT5jZWNfYWRhcDsKPiA+PiArCXN0cnVjdCBjZWNfbXNnIG1zZzsKPiA+PiArCXU4IHJ4X21zZ19p bmZvOwo+ID4+ICsJc3NpemVfdCBlcnI7Cj4gPj4gKwo+ID4+ICsJZXJyID0gZHJtX2RwX2RwY2Rf cmVhZGIoYXV4LCBEUF9DRUNfUlhfTUVTU0FHRV9JTkZPLCAmcnhfbXNnX2luZm8pOwo+ID4+ICsJ aWYgKGVyciA8IDApCj4gPj4gKwkJcmV0dXJuIGVycjsKPiA+PiArCWlmICghKHJ4X21zZ19pbmZv ICYgRFBfQ0VDX1JYX01FU1NBR0VfRU5ERUQpKQo+ID4+ICsJCXJldHVybiAwOwo+ID4+ICsJbXNn LmxlbiA9IChyeF9tc2dfaW5mbyAmIERQX0NFQ19SWF9NRVNTQUdFX0xFTl9NQVNLKSArIDE7Cj4g Pj4gKwllcnIgPSBkcm1fZHBfZHBjZF9yZWFkKGF1eCwgRFBfQ0VDX1JYX01FU1NBR0VfQlVGRkVS LCBtc2cubXNnLCBtc2cubGVuKTsKPiA+PiArCWlmIChlcnIgPCAwKQo+ID4+ICsJCXJldHVybiBl cnI7Cj4gPj4gKwljZWNfcmVjZWl2ZWRfbXNnKGFkYXAsICZtc2cpOwo+ID4+ICsJcmV0dXJuIDA7 Cj4gPiAKPiA+IG5pdDogVGhlIGNvZGUgaW4gZ2VuZXJhbCBmZWVscyBhIGJpdCBjcm93ZGVkLiBD b3VsZCB1c2UgYSBmZXcgbW9yZQo+ID4gZW1wdHkgbGluZXMgSU1PLgo+IAo+IFdpbGwgZG8uCj4g Cj4gPiAKPiA+PiArfQo+ID4+ICsKPiA+PiArc3RhdGljIGludCBkcm1fZHBfY2VjX2hhbmRsZV9p cnEoc3RydWN0IGRybV9kcF9hdXggKmF1eCkKPiA+PiArewo+ID4+ICsJc3RydWN0IGNlY19hZGFw dGVyICphZGFwID0gYXV4LT5jZWNfYWRhcDsKPiA+PiArCXU4IGZsYWdzOwo+ID4+ICsJc3NpemVf dCBlcnI7Cj4gPj4gKwo+ID4+ICsJZXJyID0gZHJtX2RwX2RwY2RfcmVhZGIoYXV4LCBEUF9DRUNf VFVOTkVMSU5HX0lSUV9GTEFHUywgJmZsYWdzKTsKPiA+PiArCWlmIChlcnIgPCAwKQo+ID4+ICsJ CXJldHVybiBlcnI7Cj4gPj4gKwo+ID4+ICsJaWYgKGZsYWdzICYgRFBfQ0VDX1JYX01FU1NBR0Vf SU5GT19WQUxJRCkKPiA+PiArCQlkcm1fZHBfY2VjX3JlY2VpdmVkKGF1eCk7Cj4gPj4gKwo+ID4+ ICsJaWYgKGZsYWdzICYgRFBfQ0VDX1RYX01FU1NBR0VfU0VOVCkKPiA+PiArCQljZWNfdHJhbnNt aXRfYXR0ZW1wdF9kb25lKGFkYXAsIENFQ19UWF9TVEFUVVNfT0spOwo+ID4+ICsJZWxzZSBpZiAo ZmxhZ3MgJiBEUF9DRUNfVFhfTElORV9FUlJPUikKPiA+PiArCQljZWNfdHJhbnNtaXRfYXR0ZW1w dF9kb25lKGFkYXAsIENFQ19UWF9TVEFUVVNfRVJST1IgfAo+ID4+ICsJCQkJCQlDRUNfVFhfU1RB VFVTX01BWF9SRVRSSUVTKTsKPiA+PiArCWVsc2UgaWYgKGZsYWdzICYKPiA+PiArCQkgKERQX0NF Q19UWF9BRERSRVNTX05BQ0tfRVJST1IgfCBEUF9DRUNfVFhfREFUQV9OQUNLX0VSUk9SKSkKPiA+ PiArCQljZWNfdHJhbnNtaXRfYXR0ZW1wdF9kb25lKGFkYXAsIENFQ19UWF9TVEFUVVNfTkFDSyB8 Cj4gPj4gKwkJCQkJCUNFQ19UWF9TVEFUVVNfTUFYX1JFVFJJRVMpOwo+ID4+ICsJZHJtX2RwX2Rw Y2Rfd3JpdGViKGF1eCwgRFBfQ0VDX1RVTk5FTElOR19JUlFfRkxBR1MsIGZsYWdzKTsKPiA+PiAr CXJldHVybiAwOwo+ID4+ICt9Cj4gPj4gKwo+ID4+ICsvKioKPiA+PiArICogZHJtX2RwX2NlY19p cnEoKSAtIGhhbmRsZSBDRUMgaW50ZXJydXB0LCBpZiBhbnkKPiA+PiArICogQGF1eDogRGlzcGxh eVBvcnQgQVVYIGNoYW5uZWwKPiA+PiArICoKPiA+PiArICogU2hvdWxkIGJlIGNhbGxlZCB3aGVu IGhhbmRsaW5nIGFuIElSUV9IUEQgcmVxdWVzdC4gSWYgQ0VDLXR1bm5lbGluZy1vdmVyLUFVWAo+ ID4+ICsgKiBpcyBwcmVzZW50LCB0aGVuIGl0IHdpbGwgY2hlY2sgZm9yIGEgQ0VDX0lSUSBhbmQg aGFuZGxlIGl0IGFjY29yZGluZ2x5Lgo+ID4+ICsgKgo+ID4+ICsgKiBSZXR1cm5zIHRydWUgaWYg YW4gaW50ZXJydXB0IHdhcyBoYW5kbGVkIHN1Y2Nlc3NmdWxseSBvciBmYWxzZSBvdGhlcndpc2Uu Cj4gPj4gKyAqLwo+ID4+ICtib29sIGRybV9kcF9jZWNfaXJxKHN0cnVjdCBkcm1fZHBfYXV4ICph dXgpCj4gPj4gK3sKPiA+PiArCWJvb2wgaGFuZGxlZCA9IGZhbHNlOwo+ID4+ICsJaW50IGF0dGVt cHRzOwo+ID4+ICsKPiA+PiArCWlmICghYXV4LT5jZWNfYWRhcCkKPiA+PiArCQlyZXR1cm4gZmFs c2U7Cj4gPj4gKwo+ID4+ICsJZm9yIChhdHRlbXB0cyA9IDA7IGF0dGVtcHRzIDwgNDsgYXR0ZW1w dHMrKykgewo+ID4gCj4gPiBXaGF0J3MgdGhlIGRlYWwgd2l0aCB0aGlzIGxvb3A/Cj4gCj4gSXQg d2FzIGNvcGllZCBmcm9tIHdoYXQgaW50ZWxfZHBfY2hlY2tfbXN0X3N0YXR1cygpIGRvZXMuCj4g Cj4gSG93ZXZlciwgSSB0aGluayBpdCBjYW4gYmUgcmVtb3ZlZCBzaW5jZSBkcm1fZHBfZHBjZF9h Y2Nlc3MgYWxyZWFkeSByZXRyaWVzCj4gZm9yIHVwIHRvIDMyIHRpbWVzLgo+IAo+IERvZXMgdGhh dCBtYWtlIHNlbnNlPwoKWWVhaCwgYmV0dGVyIHRvIG5vdCBhZGQgc29tZXRoaW5nIGlmIHdlIGRv bid0IGhhdmUgYSBnb29kIHJlYXNvbiBmb3IKaXQuIEl0J3MganVzdCBnb2luZyBtYWtlIGxpZmUg aGFyZCB3aGVuL2lmIHdoZW4vaWYgd2Ugd2FudCB0byByZWZhY3Rvcgp0aGUgc2luayBpcnEgaGFu ZGxpbmcuCgo+IAo+ID4gCj4gPj4gKwkJdTggY2VjX2lycTsKPiA+PiArCQlpbnQgcmV0Owo+ID4+ ICsKPiA+PiArCQlyZXQgPSBkcm1fZHBfZHBjZF9yZWFkYihhdXgsIERQX0RFVklDRV9TRVJWSUNF X0lSUV9WRUNUT1JfRVNJMSwKPiA+PiArCQkJCQkmY2VjX2lycSk7Cj4gPiAKPiA+IEkgYmVsaWV2 ZSBFU0kgb25seSBleGlzdHMgZm9yIERQQ0QgMS4yKy4gQXJlIHdlIHByb3RlY3RlZCBmcm9tIHJl YWNoaW5nCj4gPiB0aGlzIG9uIGVhcmxpZXIgZGV2aWNlcz8gSG1tLiBJIGd1ZXNzIHRoZSBjZWNf YWRhcCBjaGVjayBzaG91bGQgcHJvdGVjdCB1cy4KPiA+IAo+ID4gU3VwcG9zZWRseSBEUENEIHNo b3VsZCBqdXN0IHJldHVybiB6ZXJvZXMgZm9yIG5vbmV4aXN0aW5nIHJlZ2lzdGVycywgYnV0Cj4g PiBJJ3ZlIHNlZW4gYXQgbGVhc3Qgb25lIGRldmljZSB0aGF0IGZhaWxlZCBvbiB0aGF0IGZyb250 LiBJbiB0aGF0Cj4gPiBwYXJ0aWN1bGFyIGNhc2UgdGhlcmUgd2VyZSBqdXN0IGEgaGFuZGZ1bCBv ZiBieXRlcyBpbiB0aGUgZW50aXJlIERQQ0QKPiA+IGFkZHJlc3Mgc3BhY2UgdGhhdCBjb3VsZG4n dCBiZSByZWFkIHN1Y2Nlc2Z1bGx5Lgo+IAo+IEknbSBub3Qgc3VyZSBpZiBJIGNhbiBkbyBhbnl0 aGluZyB0byBtYWtlIHRoaXMgbW9yZSByb2J1c3QuIElmIHlvdSBoYXZlCj4gYW55IHN1Z2dlc3Rp b25zLCB0aGVuIEknbSBoYXBweSB0byB0cnkgYW5kIGltcGxlbWVudCB0aG9zZS4KCk5haC4gSSB0 aGluayBsb29rcyBmaW5lIGFzIGlzLgoKPiAKPiA+IAo+ID4gSSBkb24ndCBlbnRpcmVseSBsaWtl IHRoaXMgZnVuY3Rpb24gZG9pbmcgaXJxIHJlYWQvYWNrIHBhcnQuIFRoZXJlCj4gPiByZWFsbHkg c2hvdWxkIGJlIHNvbWUga2luZCBvZiBjZW50cmFsIHNpbmsgaXJxIGRpc3BhdGNoIHRoaW5neSwg YnV0Cj4gPiBzaW5jZSB3ZSBkb24ndCBoYXZlIHRoYXQgY3VycmVudGx5IEkgdGhpbmsgdGhpcyBp cyBhbiBPSyBhcHByb2FjaC4KPiA+IEF0IHNvbWUgcG9pbnQgSSBkaWQgc3RhcnQgb24gdHJ5aW5n IHRvIGNsZWFuIHVwIHRoZSBzaW5rIGlycSBoYW5kbGluZwo+ID4gbWVzcywgYnV0IEkgZGlkbid0 IGdldCB2ZXJ5IGZhciB3aXRoIGl0IGJlZm9yZSBJIGhhZCB0byBtb3ZlIG9uIHRvCj4gPiBzb21l dGhpbmcgZWxzZS4KPiA+IAo+ID4+ICsJCWlmIChyZXQgPCAwIHx8ICEoY2VjX2lycSAmIERQX0NF Q19JUlEpKQo+ID4+ICsJCQlicmVhazsKPiA+PiArCj4gPj4gKwkJaWYgKCFkcm1fZHBfY2VjX2hh bmRsZV9pcnEoYXV4KSkKPiA+PiArCQkJaGFuZGxlZCA9IHRydWU7Cj4gPj4gKwo+ID4+ICsJCXJl dCA9IGRybV9kcF9kcGNkX3dyaXRlYihhdXgsIERQX0RFVklDRV9TRVJWSUNFX0lSUV9WRUNUT1Jf RVNJMSwKPiA+PiArCQkJCQkgRFBfQ0VDX0lSUSk7Cj4gPj4gKwkJaWYgKHJldCA8IDApCj4gPj4g KwkJCWJyZWFrOwo+ID4+ICsJfQo+ID4+ICsJcmV0dXJuIGhhbmRsZWQ7Cj4gPj4gK30KPiA+PiAr RVhQT1JUX1NZTUJPTChkcm1fZHBfY2VjX2lycSk7Cj4gPj4gKwo+ID4+ICsvKioKPiA+PiArICog ZHJtX2RwX2NlY19jb25maWd1cmVfYWRhcHRlcigpIC0gY29uZmlndXJlIHRoZSBDRUMgYWRhcHRl cgo+ID4+ICsgKiBAYXV4OiBEaXNwbGF5UG9ydCBBVVggY2hhbm5lbAo+ID4+ICsgKiBAbmFtZTog bmFtZSBvZiB0aGUgQ0VDIGRldmljZQo+ID4+ICsgKiBAcGFyZW50OiBwYXJlbnQgZGV2aWNlCj4g Pj4gKyAqCj4gPj4gKyAqIENoZWNrcyBpZiB0aGlzIGlzIGEgRGlzcGxheVBvcnQtdG8tSERNSSBh ZGFwdGVyIHRoYXQgc3VwcG9ydHMKPiA+PiArICogQ0VDLXR1bm5lbGluZy1vdmVyLUFVWCwgYW5k IGlmIHNvIGl0IGNyZWF0ZXMgYSBDRUMgZGV2aWNlLgo+ID4+ICsgKgo+ID4+ICsgKiBJZiBhIENF QyBkZXZpY2Ugd2FzIGFscmVhZHkgY3JlYXRlZCwgdGhlbiBjaGVjayBpZiB0aGUgY2FwYWJpbGl0 aWVzCj4gPj4gKyAqIGhhdmUgY2hhbmdlZC4gSWYgbm90LCB0aGVuIGRvIG5vdGhpbmcuIE90aGVy d2lzZSBkZXN0cm95IHRoZSBvbGQKPiA+PiArICogQ0VDIGRldmljZSBhbmQgY3JlYXRlIGEgbmV3 IENFQyBkZXZpY2UuCj4gPj4gKyAqCj4gPj4gKyAqIFRoaXMgY2FuIGhhcHBlbiB3aGVuIG9uZSBE UC10by1IRE1JIGFkYXB0ZXIgaXMgZGlzY29ubmVjdGVkIGFuZAo+ID4+ICsgKiByZXBsYWNlZCBi eSBhbm90aGVyIGFkYXB0ZXIgd2l0aCBkaWZmZXJlbnQgQ0VDIGNhcGFiaWxpdGllcy4KPiA+PiAr ICoKPiA+PiArICogUmV0dXJucyAwIG9uIHN1Y2Nlc3Mgb3IgYSBuZWdhdGl2ZSBlcnJvciBjb2Rl IG9uIGZhaWx1cmUuCj4gPj4gKyAqLwo+ID4+ICtpbnQgZHJtX2RwX2NlY19jb25maWd1cmVfYWRh cHRlcihzdHJ1Y3QgZHJtX2RwX2F1eCAqYXV4LCBjb25zdCBjaGFyICpuYW1lLAo+ID4+ICsJCQkJ IHN0cnVjdCBkZXZpY2UgKnBhcmVudCkKPiA+PiArewo+ID4+ICsJdTMyIGNlY19jYXBzID0gQ0VD X0NBUF9ERUZBVUxUUyB8IENFQ19DQVBfTkVFRFNfSFBEOwo+ID4+ICsJdW5zaWduZWQgaW50IG51 bV9sYXMgPSAxOwo+ID4+ICsJaW50IGVycjsKPiA+PiArCXU4IGNhcDsKPiA+PiArCj4gPj4gKwlp ZiAoZHJtX2RwX2RwY2RfcmVhZGIoYXV4LCBEUF9DRUNfVFVOTkVMSU5HX0NBUEFCSUxJVFksICZj YXApICE9IDEgfHwKPiA+PiArCSAgICAhKGNhcCAmIERQX0NFQ19UVU5ORUxJTkdfQ0FQQUJMRSkp IHsKPiA+PiArCQljZWNfdW5yZWdpc3Rlcl9hZGFwdGVyKGF1eC0+Y2VjX2FkYXApOwo+ID4+ICsJ CWF1eC0+Y2VjX2FkYXAgPSBOVUxMOwo+ID4+ICsJCXJldHVybiAtRU5PREVWOwo+ID4+ICsJfQo+ ID4+ICsKPiA+PiArCWlmIChjYXAgJiBEUF9DRUNfU05PT1BJTkdfQ0FQQUJMRSkKPiA+PiArCQlj ZWNfY2FwcyB8PSBDRUNfQ0FQX01PTklUT1JfQUxMOwo+ID4+ICsJaWYgKGNhcCAmIERQX0NFQ19N VUxUSVBMRV9MQV9DQVBBQkxFKQo+ID4+ICsJCW51bV9sYXMgPSBDRUNfTUFYX0xPR19BRERSUzsK PiA+PiArCj4gPj4gKwlpZiAoYXV4LT5jZWNfYWRhcCkgewo+ID4+ICsJCWlmIChhdXgtPmNlY19h ZGFwLT5jYXBhYmlsaXRpZXMgPT0gY2VjX2NhcHMgJiYKPiA+PiArCQkgICAgYXV4LT5jZWNfYWRh cC0+YXZhaWxhYmxlX2xvZ19hZGRycyA9PSBudW1fbGFzKQo+ID4+ICsJCQlyZXR1cm4gMDsKPiA+ PiArCQljZWNfdW5yZWdpc3Rlcl9hZGFwdGVyKGF1eC0+Y2VjX2FkYXApOwo+ID4+ICsJfQo+ID4+ ICsKPiA+PiArCWF1eC0+Y2VjX2FkYXAgPSBjZWNfYWxsb2NhdGVfYWRhcHRlcigmZHJtX2RwX2Nl Y19hZGFwX29wcywKPiA+PiArCQkJIGF1eCwgbmFtZSwgY2VjX2NhcHMsIG51bV9sYXMpOwo+ID4+ ICsJaWYgKElTX0VSUihhdXgtPmNlY19hZGFwKSkgewo+ID4+ICsJCWVyciA9IFBUUl9FUlIoYXV4 LT5jZWNfYWRhcCk7Cj4gPj4gKwkJYXV4LT5jZWNfYWRhcCA9IE5VTEw7Cj4gPj4gKwkJcmV0dXJu IGVycjsKPiA+PiArCX0KPiA+PiArCWVyciA9IGNlY19yZWdpc3Rlcl9hZGFwdGVyKGF1eC0+Y2Vj X2FkYXAsIHBhcmVudCk7Cj4gPj4gKwlpZiAoZXJyKSB7Cj4gPj4gKwkJY2VjX2RlbGV0ZV9hZGFw dGVyKGF1eC0+Y2VjX2FkYXApOwo+ID4+ICsJCWF1eC0+Y2VjX2FkYXAgPSBOVUxMOwo+ID4+ICsJ fQo+ID4+ICsJcmV0dXJuIGVycjsKPiA+PiArfQo+ID4+ICtFWFBPUlRfU1lNQk9MKGRybV9kcF9j ZWNfY29uZmlndXJlX2FkYXB0ZXIpOwo+ID4+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2RybS9kcm1f ZHBfaGVscGVyLmggYi9pbmNsdWRlL2RybS9kcm1fZHBfaGVscGVyLmgKPiA+PiBpbmRleCBiMTc0 NzZhNjkwOWMuLjBlMjM2ZGQ0MGI0MiAxMDA2NDQKPiA+PiAtLS0gYS9pbmNsdWRlL2RybS9kcm1f ZHBfaGVscGVyLmgKPiA+PiArKysgYi9pbmNsdWRlL2RybS9kcm1fZHBfaGVscGVyLmgKPiA+PiBA QCAtOTUyLDYgKzk1Miw4IEBAIHN0cnVjdCBkcm1fZHBfYXV4X21zZyB7Cj4gPj4gIAlzaXplX3Qg c2l6ZTsKPiA+PiAgfTsKPiA+PiAgCj4gPj4gK3N0cnVjdCBjZWNfYWRhcHRlcjsKPiA+PiArCj4g Pj4gIC8qKgo+ID4+ICAgKiBzdHJ1Y3QgZHJtX2RwX2F1eCAtIERpc3BsYXlQb3J0IEFVWCBjaGFu bmVsCj4gPj4gICAqIEBuYW1lOiB1c2VyLXZpc2libGUgbmFtZSBvZiB0aGlzIEFVWCBjaGFubmVs IGFuZCB0aGUgSTJDLW92ZXItQVVYIGFkYXB0ZXIKPiA+PiBAQCAtMTAxMCw2ICsxMDEyLDEwIEBA IHN0cnVjdCBkcm1fZHBfYXV4IHsKPiA+PiAgCSAqIEBpMmNfZGVmZXJfY291bnQ6IENvdW50cyBJ MkMgREVGRVJzLCB1c2VkIGZvciBEUCB2YWxpZGF0aW9uLgo+ID4+ICAJICovCj4gPj4gIAl1bnNp Z25lZCBpMmNfZGVmZXJfY291bnQ7Cj4gPj4gKwkvKioKPiA+PiArCSAqIEBjZWNfYWRhcDogdGhl IENFQyBhZGFwdGVyIGZvciBDRUMtVHVubmVsaW5nLW92ZXItQVVYIHN1cHBvcnQuCj4gPj4gKwkg Ki8KPiA+PiArCXN0cnVjdCBjZWNfYWRhcHRlciAqY2VjX2FkYXA7Cj4gPj4gIH07Cj4gPj4gIAo+ ID4+ICBzc2l6ZV90IGRybV9kcF9kcGNkX3JlYWQoc3RydWN0IGRybV9kcF9hdXggKmF1eCwgdW5z aWduZWQgaW50IG9mZnNldCwKPiA+PiBAQCAtMTEzMiw0ICsxMTM4LDIyIEBAIGRybV9kcF9oYXNf cXVpcmsoY29uc3Qgc3RydWN0IGRybV9kcF9kZXNjICpkZXNjLCBlbnVtIGRybV9kcF9xdWlyayBx dWlyaykKPiA+PiAgCXJldHVybiBkZXNjLT5xdWlya3MgJiBCSVQocXVpcmspOwo+ID4+ICB9Cj4g Pj4gIAo+ID4+ICsjaWZkZWYgQ09ORklHX0RSTV9EUF9DRUMKPiA+PiArYm9vbCBkcm1fZHBfY2Vj X2lycShzdHJ1Y3QgZHJtX2RwX2F1eCAqYXV4KTsKPiA+PiAraW50IGRybV9kcF9jZWNfY29uZmln dXJlX2FkYXB0ZXIoc3RydWN0IGRybV9kcF9hdXggKmF1eCwgY29uc3QgY2hhciAqbmFtZSwKPiA+ PiArCQkJCSBzdHJ1Y3QgZGV2aWNlICpwYXJlbnQpOwo+ID4+ICsjZWxzZQo+ID4+ICtzdGF0aWMg aW5saW5lIGJvb2wgZHJtX2RwX2NlY19pcnEoc3RydWN0IGRybV9kcF9hdXggKmF1eCkKPiA+PiAr ewo+ID4+ICsJcmV0dXJuIGZhbHNlOwo+ID4+ICt9Cj4gPj4gKwo+ID4+ICtzdGF0aWMgaW5saW5l IGludCBkcm1fZHBfY2VjX2NvbmZpZ3VyZV9hZGFwdGVyKHN0cnVjdCBkcm1fZHBfYXV4ICphdXgs Cj4gPj4gKwkJCQkJICAgICAgIGNvbnN0IGNoYXIgKm5hbWUsCj4gPj4gKwkJCQkJICAgICAgIHN0 cnVjdCBkZXZpY2UgKnBhcmVudCkKPiA+PiArewo+ID4+ICsJcmV0dXJuIC1FTk9ERVY7Cj4gPj4g K30KPiA+PiArI2VuZGlmCj4gPj4gKwo+ID4+ICAjZW5kaWYgLyogX0RSTV9EUF9IRUxQRVJfSF8g Ki8KPiA+PiAtLSAKPiA+PiAyLjE0LjEKPiA+IAo+IAo+IFJlZ2FyZHMsCj4gCj4gCUhhbnMKCi0t IApWaWxsZSBTeXJqw6Rsw6QKSW50ZWwgT1RDCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3Rz LmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xp c3RpbmZvL2RyaS1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mga11.intel.com ([192.55.52.93]:32543 "EHLO mga11.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752227AbdIMK4J (ORCPT ); Wed, 13 Sep 2017 06:56:09 -0400 Date: Wed, 13 Sep 2017 13:56:04 +0300 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= To: Hans Verkuil Cc: linux-media@vger.kernel.org, Daniel Vetter , dri-devel@lists.freedesktop.org, Sean Paul , Imre Deak , Hans Verkuil Subject: Re: [PATCHv3 1/3] drm: add support for DisplayPort CEC-Tunneling-over-AUX Message-ID: <20170913105604.GF4914@intel.com> References: <20170911112547.7133-1-hverkuil@xs4all.nl> <20170911112547.7133-2-hverkuil@xs4all.nl> <20170912173935.GB4914@intel.com> <1757067a-d0dc-cbe6-0cb3-084d0bb5fc97@xs4all.nl> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <1757067a-d0dc-cbe6-0cb3-084d0bb5fc97@xs4all.nl> Sender: linux-media-owner@vger.kernel.org List-ID: On Wed, Sep 13, 2017 at 10:51:02AM +0200, Hans Verkuil wrote: > On 09/12/2017 07:39 PM, Ville Syrjälä wrote: > > On Mon, Sep 11, 2017 at 01:25:45PM +0200, Hans Verkuil wrote: > >> From: Hans Verkuil > >> > >> This adds support for the DisplayPort CEC-Tunneling-over-AUX > >> feature that is part of the DisplayPort 1.3 standard. > >> > >> Unfortunately, not all DisplayPort/USB-C to HDMI adapters with a > >> chip that has this capability actually hook up the CEC pin, so > >> even though a CEC device is created, it may not actually work. > >> > >> Signed-off-by: Hans Verkuil > >> Tested-by: Carlos Santa > >> --- > >> drivers/gpu/drm/Kconfig | 10 ++ > >> drivers/gpu/drm/Makefile | 1 + > >> drivers/gpu/drm/drm_dp_cec.c | 301 +++++++++++++++++++++++++++++++++++++++++++ > >> include/drm/drm_dp_helper.h | 24 ++++ > >> 4 files changed, 336 insertions(+) > >> create mode 100644 drivers/gpu/drm/drm_dp_cec.c > >> > >> diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig > >> index 83cb2a88c204..1f2708df5c4e 100644 > >> --- a/drivers/gpu/drm/Kconfig > >> +++ b/drivers/gpu/drm/Kconfig > >> @@ -120,6 +120,16 @@ config DRM_LOAD_EDID_FIRMWARE > >> default case is N. Details and instructions how to build your own > >> EDID data are given in Documentation/EDID/HOWTO.txt. > >> > >> +config DRM_DP_CEC > >> + bool "Enable DisplayPort CEC-Tunneling-over-AUX HDMI support" > >> + select CEC_CORE > >> + help > >> + Choose this option if you want to enable HDMI CEC support for > >> + DisplayPort/USB-C to HDMI adapters. > >> + > >> + Note: not all adapters support this feature, and even for those > >> + that do support this they often do not hook up the CEC pin. > >> + > >> config DRM_TTM > >> tristate > >> depends on DRM && MMU > >> diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile > >> index 24a066e1841c..c6552c62049e 100644 > >> --- a/drivers/gpu/drm/Makefile > >> +++ b/drivers/gpu/drm/Makefile > >> @@ -40,6 +40,7 @@ drm_kms_helper-$(CONFIG_DRM_LOAD_EDID_FIRMWARE) += drm_edid_load.o > >> drm_kms_helper-$(CONFIG_DRM_FBDEV_EMULATION) += drm_fb_helper.o > >> drm_kms_helper-$(CONFIG_DRM_KMS_CMA_HELPER) += drm_fb_cma_helper.o > >> drm_kms_helper-$(CONFIG_DRM_DP_AUX_CHARDEV) += drm_dp_aux_dev.o > >> +drm_kms_helper-$(CONFIG_DRM_DP_CEC) += drm_dp_cec.o > >> > >> obj-$(CONFIG_DRM_KMS_HELPER) += drm_kms_helper.o > >> obj-$(CONFIG_DRM_DEBUG_MM_SELFTEST) += selftests/ > >> diff --git a/drivers/gpu/drm/drm_dp_cec.c b/drivers/gpu/drm/drm_dp_cec.c > >> new file mode 100644 > >> index 000000000000..b831bb72c932 > >> --- /dev/null > >> +++ b/drivers/gpu/drm/drm_dp_cec.c > >> @@ -0,0 +1,301 @@ > >> +/* > >> + * DisplayPort CEC-Tunneling-over-AUX support > >> + * > >> + * Copyright 2017 Cisco Systems, Inc. and/or its affiliates. All rights reserved. > >> + * > >> + * This program is free software; you may redistribute it and/or modify > >> + * it under the terms of the GNU General Public License as published by > >> + * the Free Software Foundation; version 2 of the License. > >> + * > >> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, > >> + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF > >> + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND > >> + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS > >> + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN > >> + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN > >> + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE > >> + * SOFTWARE. > >> + */ > >> + > >> +#include > >> +#include > >> +#include > >> +#include > >> +#include > >> + > >> +/* > >> + * Unfortunately it turns out that we have a chicken-and-egg situation > >> + * here. Quite a few active (mini-)DP-to-HDMI or USB-C-to-HDMI adapters > >> + * have a converter chip that supports CEC-Tunneling-over-AUX (usually the > >> + * Parade PS176), but they do not wire up the CEC pin, thus making CEC > >> + * useless. > >> + * > >> + * Sadly there is no way for this driver to know this. What happens is > >> + * that a /dev/cecX device is created that is isolated and unable to see > >> + * any of the other CEC devices. Quite literally the CEC wire is cut > >> + * (or in this case, never connected in the first place). > >> + * > >> + * I suspect that the reason so few adapters support this is that this > >> + * tunneling protocol was never supported by any OS. So there was no > >> + * easy way of testing it, and no incentive to correctly wire up the > >> + * CEC pin. > >> + * > >> + * Hopefully by creating this driver it will be easier for vendors to > >> + * finally fix their adapters and test the CEC functionality. > >> + * > >> + * I keep a list of known working adapters here: > >> + * > >> + * https://hverkuil.home.xs4all.nl/cec-status.txt > >> + * > >> + * Please mail me (hverkuil@xs4all.nl) if you find an adapter that works > >> + * and is not yet listed there. > >> + */ > >> + > >> +/** > >> + * DOC: dp cec helpers > >> + * > >> + * These functions take care of supporting the CEC-Tunneling-over-AUX > >> + * feature of DisplayPort-to-HDMI adapters. > >> + */ > >> + > >> +static int drm_dp_cec_adap_enable(struct cec_adapter *adap, bool enable) > >> +{ > >> + struct drm_dp_aux *aux = cec_get_drvdata(adap); > >> + u32 val = enable ? DP_CEC_TUNNELING_ENABLE : 0; > >> + ssize_t err = 0; > >> + > >> + err = drm_dp_dpcd_writeb(aux, DP_CEC_TUNNELING_CONTROL, val); > >> + return (enable && err < 0) ? err : 0; > >> +} > >> + > >> +static int drm_dp_cec_adap_log_addr(struct cec_adapter *adap, u8 addr) > >> +{ > >> + struct drm_dp_aux *aux = cec_get_drvdata(adap); > >> + /* Bit 15 (logical address 15) should always be set */ > >> + u16 la_mask = 1 << CEC_LOG_ADDR_BROADCAST; > >> + u8 mask[2]; > >> + ssize_t err; > >> + > >> + if (addr != CEC_LOG_ADDR_INVALID) > >> + la_mask |= adap->log_addrs.log_addr_mask | (1 << addr); > >> + mask[0] = la_mask & 0xff; > >> + mask[1] = la_mask >> 8; > >> + err = drm_dp_dpcd_write(aux, DP_CEC_LOGICAL_ADDRESS_MASK, mask, 2); > >> + return (addr != CEC_LOG_ADDR_INVALID && err < 0) ? err : 0; > >> +} > >> + > >> +static int drm_dp_cec_adap_transmit(struct cec_adapter *adap, u8 attempts, > >> + u32 signal_free_time, struct cec_msg *msg) > >> +{ > >> + struct drm_dp_aux *aux = cec_get_drvdata(adap); > >> + unsigned int retries = min(5, attempts - 1); > >> + ssize_t err; > >> + > >> + err = drm_dp_dpcd_write(aux, DP_CEC_TX_MESSAGE_BUFFER, > >> + msg->msg, msg->len); > >> + if (err < 0) > >> + return err; > > > > What happens if we managed to write the data only partially? > > > > Looking at our code, I *think* we can't actally return 0 ever, so the > > _writeb() variant seem safe with the <0 checks. But the full _write() > > could certainly return something between 1 and the total size. > > Not according to the drm_dp_dpcd_write() documentation: > > "If not all bytes were transferred, this function returns -EPROTO." > > Looking at the implementation, that is exactly what happens. Hmm. Indeed. The documentation sure is confusing because it starts by saying "Returns the number of bytes transferred on success, or a negative error code on failure.", and only later it seems to clarify that a not being able to transfer all the bytes is considered an error. We might want to reword that somehow because I'm surely not the only one that's confused by this. Also making something look like read(2)/write(2) and then not following the same conventions is rather bad IMO. We should probably just change these to return 0/-errno, or we should really start following the common convention for read/write. Not quite sure which is better really. The 0/-errno thing is easier to use certainly, but for just dumping out the entire DPCD short reads might be nice for the cases where some random pieces of DPCD can't be succesfully read. But I guess the 0/-errno would be the safer option since it wouldn't actually change the implementation. > > > > >> + > >> + err = drm_dp_dpcd_writeb(aux, DP_CEC_TX_MESSAGE_INFO, > >> + (msg->len - 1) | (retries << 4) | > >> + DP_CEC_TX_MESSAGE_SEND); > >> + return err < 0 ? err : 0; > >> +} > >> + > >> +static int drm_dp_cec_adap_monitor_all_enable(struct cec_adapter *adap, > >> + bool enable) > >> +{ > >> + struct drm_dp_aux *aux = cec_get_drvdata(adap); > >> + ssize_t err; > >> + u8 val; > >> + > >> + if (!(adap->capabilities & CEC_CAP_MONITOR_ALL)) > >> + return 0; > >> + > >> + err = drm_dp_dpcd_readb(aux, DP_CEC_TUNNELING_CONTROL, &val); > >> + if (err >= 0) { > >> + if (enable) > >> + val |= DP_CEC_SNOOPING_ENABLE; > >> + else > >> + val &= ~DP_CEC_SNOOPING_ENABLE; > >> + err = drm_dp_dpcd_writeb(aux, DP_CEC_TUNNELING_CONTROL, val); > >> + } > >> + return (enable && err < 0) ? err : 0; > >> +} > >> + > >> +static void drm_dp_cec_adap_status(struct cec_adapter *adap, > >> + struct seq_file *file) > >> +{ > >> + struct drm_dp_aux *aux = cec_get_drvdata(adap); > >> + u8 buf[DP_AUX_MAX_PAYLOAD_BYTES]; > >> + u8 hw_rev; > >> + > >> + if (drm_dp_dpcd_read(aux, DP_BRANCH_OUI, > >> + buf, sizeof(buf)) != sizeof(buf)) > >> + return; > >> + hw_rev = buf[9]; > >> + buf[9] = 0; > >> + seq_printf(file, "OUI: %02x-%02x-%02x\n", > >> + buf[0], buf[1], buf[2]); > >> + seq_printf(file, "ID: %s\n", buf + 3); > >> + seq_printf(file, "HW Rev: %d.%d\n", hw_rev >> 4, hw_rev & 0xf); > >> + /* > >> + * Show this both in decimal and hex: at least one vendor > >> + * always reports this in hex. > >> + */ > >> + seq_printf(file, "FW/SW Rev: %d.%d (0x%02x.0x%02x)\n", > >> + buf[10], buf[11], buf[10], buf[11]); > > > > I believe struct drm_dp_dpcd_ident provides a slightly easier way to > > parse these registers. > > I'll take a look at that. > > > > >> +} > >> + > >> +static const struct cec_adap_ops drm_dp_cec_adap_ops = { > >> + .adap_enable = drm_dp_cec_adap_enable, > >> + .adap_log_addr = drm_dp_cec_adap_log_addr, > >> + .adap_transmit = drm_dp_cec_adap_transmit, > >> + .adap_monitor_all_enable = drm_dp_cec_adap_monitor_all_enable, > >> + .adap_status = drm_dp_cec_adap_status, > >> +}; > >> + > >> +static int drm_dp_cec_received(struct drm_dp_aux *aux) > >> +{ > >> + struct cec_adapter *adap = aux->cec_adap; > >> + struct cec_msg msg; > >> + u8 rx_msg_info; > >> + ssize_t err; > >> + > >> + err = drm_dp_dpcd_readb(aux, DP_CEC_RX_MESSAGE_INFO, &rx_msg_info); > >> + if (err < 0) > >> + return err; > >> + if (!(rx_msg_info & DP_CEC_RX_MESSAGE_ENDED)) > >> + return 0; > >> + msg.len = (rx_msg_info & DP_CEC_RX_MESSAGE_LEN_MASK) + 1; > >> + err = drm_dp_dpcd_read(aux, DP_CEC_RX_MESSAGE_BUFFER, msg.msg, msg.len); > >> + if (err < 0) > >> + return err; > >> + cec_received_msg(adap, &msg); > >> + return 0; > > > > nit: The code in general feels a bit crowded. Could use a few more > > empty lines IMO. > > Will do. > > > > >> +} > >> + > >> +static int drm_dp_cec_handle_irq(struct drm_dp_aux *aux) > >> +{ > >> + struct cec_adapter *adap = aux->cec_adap; > >> + u8 flags; > >> + ssize_t err; > >> + > >> + err = drm_dp_dpcd_readb(aux, DP_CEC_TUNNELING_IRQ_FLAGS, &flags); > >> + if (err < 0) > >> + return err; > >> + > >> + if (flags & DP_CEC_RX_MESSAGE_INFO_VALID) > >> + drm_dp_cec_received(aux); > >> + > >> + if (flags & DP_CEC_TX_MESSAGE_SENT) > >> + cec_transmit_attempt_done(adap, CEC_TX_STATUS_OK); > >> + else if (flags & DP_CEC_TX_LINE_ERROR) > >> + cec_transmit_attempt_done(adap, CEC_TX_STATUS_ERROR | > >> + CEC_TX_STATUS_MAX_RETRIES); > >> + else if (flags & > >> + (DP_CEC_TX_ADDRESS_NACK_ERROR | DP_CEC_TX_DATA_NACK_ERROR)) > >> + cec_transmit_attempt_done(adap, CEC_TX_STATUS_NACK | > >> + CEC_TX_STATUS_MAX_RETRIES); > >> + drm_dp_dpcd_writeb(aux, DP_CEC_TUNNELING_IRQ_FLAGS, flags); > >> + return 0; > >> +} > >> + > >> +/** > >> + * drm_dp_cec_irq() - handle CEC interrupt, if any > >> + * @aux: DisplayPort AUX channel > >> + * > >> + * Should be called when handling an IRQ_HPD request. If CEC-tunneling-over-AUX > >> + * is present, then it will check for a CEC_IRQ and handle it accordingly. > >> + * > >> + * Returns true if an interrupt was handled successfully or false otherwise. > >> + */ > >> +bool drm_dp_cec_irq(struct drm_dp_aux *aux) > >> +{ > >> + bool handled = false; > >> + int attempts; > >> + > >> + if (!aux->cec_adap) > >> + return false; > >> + > >> + for (attempts = 0; attempts < 4; attempts++) { > > > > What's the deal with this loop? > > It was copied from what intel_dp_check_mst_status() does. > > However, I think it can be removed since drm_dp_dpcd_access already retries > for up to 32 times. > > Does that make sense? Yeah, better to not add something if we don't have a good reason for it. It's just going make life hard when/if when/if we want to refactor the sink irq handling. > > > > >> + u8 cec_irq; > >> + int ret; > >> + > >> + ret = drm_dp_dpcd_readb(aux, DP_DEVICE_SERVICE_IRQ_VECTOR_ESI1, > >> + &cec_irq); > > > > I believe ESI only exists for DPCD 1.2+. Are we protected from reaching > > this on earlier devices? Hmm. I guess the cec_adap check should protect us. > > > > Supposedly DPCD should just return zeroes for nonexisting registers, but > > I've seen at least one device that failed on that front. In that > > particular case there were just a handful of bytes in the entire DPCD > > address space that couldn't be read succesfully. > > I'm not sure if I can do anything to make this more robust. If you have > any suggestions, then I'm happy to try and implement those. Nah. I think looks fine as is. > > > > > I don't entirely like this function doing irq read/ack part. There > > really should be some kind of central sink irq dispatch thingy, but > > since we don't have that currently I think this is an OK approach. > > At some point I did start on trying to clean up the sink irq handling > > mess, but I didn't get very far with it before I had to move on to > > something else. > > > >> + if (ret < 0 || !(cec_irq & DP_CEC_IRQ)) > >> + break; > >> + > >> + if (!drm_dp_cec_handle_irq(aux)) > >> + handled = true; > >> + > >> + ret = drm_dp_dpcd_writeb(aux, DP_DEVICE_SERVICE_IRQ_VECTOR_ESI1, > >> + DP_CEC_IRQ); > >> + if (ret < 0) > >> + break; > >> + } > >> + return handled; > >> +} > >> +EXPORT_SYMBOL(drm_dp_cec_irq); > >> + > >> +/** > >> + * drm_dp_cec_configure_adapter() - configure the CEC adapter > >> + * @aux: DisplayPort AUX channel > >> + * @name: name of the CEC device > >> + * @parent: parent device > >> + * > >> + * Checks if this is a DisplayPort-to-HDMI adapter that supports > >> + * CEC-tunneling-over-AUX, and if so it creates a CEC device. > >> + * > >> + * If a CEC device was already created, then check if the capabilities > >> + * have changed. If not, then do nothing. Otherwise destroy the old > >> + * CEC device and create a new CEC device. > >> + * > >> + * This can happen when one DP-to-HDMI adapter is disconnected and > >> + * replaced by another adapter with different CEC capabilities. > >> + * > >> + * Returns 0 on success or a negative error code on failure. > >> + */ > >> +int drm_dp_cec_configure_adapter(struct drm_dp_aux *aux, const char *name, > >> + struct device *parent) > >> +{ > >> + u32 cec_caps = CEC_CAP_DEFAULTS | CEC_CAP_NEEDS_HPD; > >> + unsigned int num_las = 1; > >> + int err; > >> + u8 cap; > >> + > >> + if (drm_dp_dpcd_readb(aux, DP_CEC_TUNNELING_CAPABILITY, &cap) != 1 || > >> + !(cap & DP_CEC_TUNNELING_CAPABLE)) { > >> + cec_unregister_adapter(aux->cec_adap); > >> + aux->cec_adap = NULL; > >> + return -ENODEV; > >> + } > >> + > >> + if (cap & DP_CEC_SNOOPING_CAPABLE) > >> + cec_caps |= CEC_CAP_MONITOR_ALL; > >> + if (cap & DP_CEC_MULTIPLE_LA_CAPABLE) > >> + num_las = CEC_MAX_LOG_ADDRS; > >> + > >> + if (aux->cec_adap) { > >> + if (aux->cec_adap->capabilities == cec_caps && > >> + aux->cec_adap->available_log_addrs == num_las) > >> + return 0; > >> + cec_unregister_adapter(aux->cec_adap); > >> + } > >> + > >> + aux->cec_adap = cec_allocate_adapter(&drm_dp_cec_adap_ops, > >> + aux, name, cec_caps, num_las); > >> + if (IS_ERR(aux->cec_adap)) { > >> + err = PTR_ERR(aux->cec_adap); > >> + aux->cec_adap = NULL; > >> + return err; > >> + } > >> + err = cec_register_adapter(aux->cec_adap, parent); > >> + if (err) { > >> + cec_delete_adapter(aux->cec_adap); > >> + aux->cec_adap = NULL; > >> + } > >> + return err; > >> +} > >> +EXPORT_SYMBOL(drm_dp_cec_configure_adapter); > >> diff --git a/include/drm/drm_dp_helper.h b/include/drm/drm_dp_helper.h > >> index b17476a6909c..0e236dd40b42 100644 > >> --- a/include/drm/drm_dp_helper.h > >> +++ b/include/drm/drm_dp_helper.h > >> @@ -952,6 +952,8 @@ struct drm_dp_aux_msg { > >> size_t size; > >> }; > >> > >> +struct cec_adapter; > >> + > >> /** > >> * struct drm_dp_aux - DisplayPort AUX channel > >> * @name: user-visible name of this AUX channel and the I2C-over-AUX adapter > >> @@ -1010,6 +1012,10 @@ struct drm_dp_aux { > >> * @i2c_defer_count: Counts I2C DEFERs, used for DP validation. > >> */ > >> unsigned i2c_defer_count; > >> + /** > >> + * @cec_adap: the CEC adapter for CEC-Tunneling-over-AUX support. > >> + */ > >> + struct cec_adapter *cec_adap; > >> }; > >> > >> ssize_t drm_dp_dpcd_read(struct drm_dp_aux *aux, unsigned int offset, > >> @@ -1132,4 +1138,22 @@ drm_dp_has_quirk(const struct drm_dp_desc *desc, enum drm_dp_quirk quirk) > >> return desc->quirks & BIT(quirk); > >> } > >> > >> +#ifdef CONFIG_DRM_DP_CEC > >> +bool drm_dp_cec_irq(struct drm_dp_aux *aux); > >> +int drm_dp_cec_configure_adapter(struct drm_dp_aux *aux, const char *name, > >> + struct device *parent); > >> +#else > >> +static inline bool drm_dp_cec_irq(struct drm_dp_aux *aux) > >> +{ > >> + return false; > >> +} > >> + > >> +static inline int drm_dp_cec_configure_adapter(struct drm_dp_aux *aux, > >> + const char *name, > >> + struct device *parent) > >> +{ > >> + return -ENODEV; > >> +} > >> +#endif > >> + > >> #endif /* _DRM_DP_HELPER_H_ */ > >> -- > >> 2.14.1 > > > > Regards, > > Hans -- Ville Syrjälä Intel OTC