From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= Subject: Re: [PATCH v2 1/4] drm: Add helper for DP++ adaptors Date: Tue, 3 May 2016 20:38:59 +0300 Message-ID: <20160503173859.GJ4329@intel.com> References: <1462216105-20881-1-git-send-email-ville.syrjala@linux.intel.com> <1462216105-20881-2-git-send-email-ville.syrjala@linux.intel.com> <5728D2DA.2020201@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <5728D2DA.2020201@intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: "Sharma, Shashank" Cc: Paulo Zanoni , Daniel Vetter , intel-gfx@lists.freedesktop.org, Tore Anderson , stable@vger.kernel.org, dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org T24gVHVlLCBNYXkgMDMsIDIwMTYgYXQgMTA6MDM6MzBQTSArMDUzMCwgU2hhcm1hLCBTaGFzaGFu ayB3cm90ZToKPiAKPiAKPiBPbiA1LzMvMjAxNiAxMjozOCBBTSwgdmlsbGUuc3lyamFsYUBsaW51 eC5pbnRlbC5jb20gd3JvdGU6Cj4gPiBGcm9tOiBWaWxsZSBTeXJqw6Rsw6QgPHZpbGxlLnN5cmph bGFAbGludXguaW50ZWwuY29tPgo+ID4KPiA+IEFkZCBhIGhlbHBlciB3aGljaCBhaWRzIGluIHRo ZSBpZGVudGlmaWNhdGlvbiBvZiBEUCBkdWFsIG1vZGUKPiA+IChha2EuIERQKyspIGFkYXB0b3Jz LiBUaGVyZSBhcmUgc2V2ZXJhbCB0eXBlcyBvZiBhZGFwdG9ycwo+ID4gc3BlY2lmaWVkOiB0eXBl IDEgRFZJLCB0eXBlIDEgSERNSSwgdHlwZSAyIERWSSwgdHlwZSAyIEhETUkKPiA+Cj4gPiBUeXBl IDEgYWRhcHRvcnMgaGF2ZSBhIG1heCBUTURTIGNsb2NrIGxpbWl0IG9mIDE2NU1IeiwgdHlwZSAy IGFkYXB0b3JzCj4gPiBtYXkgZ28gYXMgaGlnaCBhcyAzMDBNSHogYW5kIHRoZXkgcHJvdmlkZSBh IHJlZ2lzdGVyIGluZm9ybWluZyB0aGUKPiA+IHNvdXJjZSBkZXZpY2Ugd2hhdCB0aGUgYWN0dWFs IGxpbWl0IGlzLiBTdXBwb3NlZGx5IGFsc28gdHlwZSAxIGFkYXB0b3JzCj4gPiBtYXkgb3B0aW9u YWxseSBpbXBsZW1lbnQgdGhpcyByZWdpc3Rlci4gVGhpcyBUTURTIGNsb2NrIGxpbWl0IGlzIHRo ZQo+ID4gbWFpbiByZWFzb24gd2h5IHdlIG5lZWQgdG8gaWRlbnRpZnkgdGhlc2UgYWRhcHRvcnMu Cj4gPgo+ID4gVHlwZSAxIGFkYXB0b3JzIHByb3ZpZGUgYWNjZXNzIHRvIHRoZWlyIGludGVybmFs IHJlZ2lzdGVycyBhbmQgdGhlIHNpbmsKPiA+IEREQyBidXMgdGhyb3VnaCBJMkMuIFR5cGUgMiBh ZGFwdG9ycyBwcm92aWRlIHRoaXMgYWNjZXNzIGJvdGggdmlhIEkyQwo+ID4gYW5kIEkyQy1vdmVy LUFVWC4gQSB0eXBlIDIgc291cmNlIGRldmljZSBtYXkgY2hvb3NlIHRvIGltcGxlbWVudCBlaXRo ZXIKPiA+IG9mIHRoZXNlIG1ldGhvZHMuIElmIGEgc291cmNlIGRldmljZSBpbXBsZW1lbnRzIHRo ZSBJMkMtb3Zlci1BVVgKPiA+IG1ldGhvZCwgdGhlbiB0aGUgZHJpdmVyIHdpbGwgb2J2aW91c2x5 IG5lZWQgc3BlY2lmaWMgc3VwcG9ydCBmb3Igc3VjaAo+ID4gYWRhcHRvcnMgc2luY2UgdGhlIHBv cnQgaXMgZHJpdmVuIGxpa2UgYW4gSERNSSBwb3J0LCBidXQgRERDCj4gPiBjb21tdW5pY2F0aW9u IGhhcHBlcyBvdmVyIHRoZSBBVVggY2hhbm5lbC4KPiA+Cj4gPiBUaGlzIGhlbHBlciBzaG91bGQg YmUgZW5vdWdoIHRvIGlkZW50aWZ5IHRoZSBhZGFwdG9yIHR5cGUgKHNvbWUKPiA+IHR5cGUgMSBE VkkgYWRhcHRvcnMgbWF5IGJlIGEgc2xpZ2h0IGV4Y2VwdGlvbikgYW5kIHRoZSBtYXhpbXVtIFRN RFMKPiA+IGNsb2NrIGxpbWl0LiBBbm90aGVyIGZlYXR1cmUgdGhhdCBtYXkgYmUgYXZhaWxhYmxl IGlzIGNvbnRyb2wgb3Zlcgo+ID4gdGhlIFRNRFMgb3V0cHV0IGJ1ZmZlcnMgb24gdGhlIGFkYXB0 b3IsIHBvc3NpYmx5IGFsbG93aW5nIGZvciBzb21lCj4gPiBwb3dlciBzYXZpbmcgd2hlbiB0aGUg VE1EUyBsaW5rIGlzIGRvd24uCj4gPgo+ID4gT3RoZXIgdXNlciBjb250cm9sbGFibGUgZmVhdHVy ZXMgdGhhdCBtYXkgYmUgYXZhaWxhYmxlIGluIHRoZSBhZGFwdG9ycwo+ID4gYXJlIGRvd25zdHJl YW0gaTJjIGJ1cyBzcGVlZCBjb250cm9sIHdoZW4gdXNpbmcgaTJjLW92ZXItYXV4LCBhbmQKPiA+ IHNvbWUgY29udHJvbCBvdmVyIHRoZSBDRUMgcGluLiBJIGNob3NlIG5vdCB0byBwcm92aWRlIGFu eSBoZWxwZXIKPiA+IGZ1bmN0aW9ucyBmb3IgdGhvc2Ugc2luY2UgSSBoYXZlIG5vIHVzZSBmb3Ig dGhlbSBpbiBpOTE1IGF0IHRoaXMgdGltZS4KPiA+IFRoZSByZXN0IG9mIHRoZSByZWdpc3RlcnMg aW4gdGhlIGFkYXB0b3IgYXJlIG1vc3RseSBqdXN0IGluZm9ybWF0aW9uLAo+ID4gZWcuIElFRUUg T1VJLCBoYXJkd2FyZSBhbmQgZmlybXdhcmUgcmV2aXNpb24sIGV0Yy4KPiA+Cj4gPiB2MjogUGFz cyBhZGFwdG9yIHR5cGUgdG8gaGVscGVyIGZ1bmN0aW9ucyB0byBlYXNlIGRyaXZlciBpbXBsZW1l bnRhdGlvbgo+ID4gICAgICBGaXggYSBidW5jaCBvZiB0eXBvZXMgKFBhdWxvKQo+ID4gICAgICBB ZGQgRFJNX0RQX0RVQUxfTU9ERV9VTktOT1dOIGZvciB0aGUgY2FzZSB3aGVyZSB3ZSBkb24ndCAo eWV0KSBrbm93Cj4gPiAgICAgIHRoZSB0eXBlIChQYXVsbykKPiA+ICAgICAgUmVqZWN0IDB4MDAg YW5kIDB4ZmYgRFBfRFVBTF9NT0RFX01BWF9UTURTX0NMT0NLIHZhbHVlcyAoUGF1bG8pCj4gPiAg ICAgIEFkanVzdCBkcm1fZHBfZHVhbF9tb2RlX2RldGVjdCgpIHR5cGUyIHZzLiB0eXBlMSBkZXRl Y3Rpb24gdG8KPiA+ICAgICAgZWFzZSBmdXR1cmUgTFNQQ09OIGVuYWJsaW5nCj4gPiAgICAgIFJl bW92ZSB0aGUgdW51c2VkIERQX0RVQUxfTU9ERV9MQVNUX1JFU0VSVkVEIGRlZmluZQo+ID4KPiA+ IENjOiBzdGFibGVAdmdlci5rZXJuZWwub3JnCj4gPiBDYzogVG9yZSBBbmRlcnNvbiA8dG9yZUBm dWQubm8+Cj4gPiBDYzogUGF1bG8gWmFub25pIDxwYXVsby5yLnphbm9uaUBpbnRlbC5jb20+Cj4g PiBDYzogU2hhc2hhbmsgU2hhcm1hIDxzaGFzaGFuay5zaGFybWFAaW50ZWwuY29tPgo+ID4gQ2M6 IERhbmllbCBWZXR0ZXIgPGRhbmllbC52ZXR0ZXJAZmZ3bGwuY2g+Cj4gPiBTaWduZWQtb2ZmLWJ5 OiBWaWxsZSBTeXJqw6Rsw6QgPHZpbGxlLnN5cmphbGFAbGludXguaW50ZWwuY29tPgo+ID4gLS0t Cj4gPiAgIGRyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZSAgICAgICAgICAgICAgICAgIHwgICAyICst Cj4gPiAgIGRyaXZlcnMvZ3B1L2RybS9kcm1fZHBfZHVhbF9tb2RlX2hlbHBlci5jIHwgMzU2ICsr KysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ID4gICBpbmNsdWRlL2RybS9kcm1fZHBfZHVh bF9tb2RlX2hlbHBlci5oICAgICB8ICA4MyArKysrKysrCj4gPiAgIDMgZmlsZXMgY2hhbmdlZCwg NDQwIGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKPiA+ICAgY3JlYXRlIG1vZGUgMTAwNjQ0 IGRyaXZlcnMvZ3B1L2RybS9kcm1fZHBfZHVhbF9tb2RlX2hlbHBlci5jCj4gPiAgIGNyZWF0ZSBt b2RlIDEwMDY0NCBpbmNsdWRlL2RybS9kcm1fZHBfZHVhbF9tb2RlX2hlbHBlci5oCj4gPgo+ID4g ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZSBiL2RyaXZlcnMvZ3B1L2RybS9N YWtlZmlsZQo+ID4gaW5kZXggMWEyNmI0ZWIxY2UwLi4yOWYyZWU5Yjk1MzQgMTAwNjQ0Cj4gPiAt LS0gYS9kcml2ZXJzL2dwdS9kcm0vTWFrZWZpbGUKPiA+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9N YWtlZmlsZQo+ID4gQEAgLTIzLDcgKzIzLDcgQEAgZHJtLSQoQ09ORklHX0FHUCkgKz0gZHJtX2Fn cHN1cHBvcnQubwo+ID4KPiA+ICAgZHJtX2ttc19oZWxwZXIteSA6PSBkcm1fY3J0Y19oZWxwZXIu byBkcm1fZHBfaGVscGVyLm8gZHJtX3Byb2JlX2hlbHBlci5vIFwKPiA+ICAgCQlkcm1fcGxhbmVf aGVscGVyLm8gZHJtX2RwX21zdF90b3BvbG9neS5vIGRybV9hdG9taWNfaGVscGVyLm8gXAo+ID4g LQkJZHJtX2ttc19oZWxwZXJfY29tbW9uLm8KPiA+ICsJCWRybV9rbXNfaGVscGVyX2NvbW1vbi5v IGRybV9kcF9kdWFsX21vZGVfaGVscGVyLm8KPiA+Cj4gPiAgIGRybV9rbXNfaGVscGVyLSQoQ09O RklHX0RSTV9MT0FEX0VESURfRklSTVdBUkUpICs9IGRybV9lZGlkX2xvYWQubwo+ID4gICBkcm1f a21zX2hlbHBlci0kKENPTkZJR19EUk1fRkJERVZfRU1VTEFUSU9OKSArPSBkcm1fZmJfaGVscGVy Lm8KPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2RwX2R1YWxfbW9kZV9oZWxw ZXIuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fZHBfZHVhbF9tb2RlX2hlbHBlci5jCj4gPiBuZXcg ZmlsZSBtb2RlIDEwMDY0NAo+ID4gaW5kZXggMDAwMDAwMDAwMDAwLi45NDljMGZiZWI1NDIKPiA+ IC0tLSAvZGV2L251bGwKPiA+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fZHBfZHVhbF9tb2Rl X2hlbHBlci5jCj4gPiBAQCAtMCwwICsxLDM1NiBAQAo+ID4gKy8qCj4gPiArICogQ29weXJpZ2h0 IMKpIDIwMTYgSW50ZWwgQ29ycG9yYXRpb24KPiA+ICsgKgo+ID4gKyAqIFBlcm1pc3Npb24gaXMg aGVyZWJ5IGdyYW50ZWQsIGZyZWUgb2YgY2hhcmdlLCB0byBhbnkgcGVyc29uIG9idGFpbmluZyBh Cj4gPiArICogY29weSBvZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRvY3VtZW50YXRp b24gZmlsZXMgKHRoZSAiU29mdHdhcmUiKSwKPiA+ICsgKiB0byBkZWFsIGluIHRoZSBTb2Z0d2Fy ZSB3aXRob3V0IHJlc3RyaWN0aW9uLCBpbmNsdWRpbmcgd2l0aG91dCBsaW1pdGF0aW9uCj4gPiAr ICogdGhlIHJpZ2h0cyB0byB1c2UsIGNvcHksIG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3Ry aWJ1dGUsIHN1YmxpY2Vuc2UsCj4gPiArICogYW5kL29yIHNlbGwgY29waWVzIG9mIHRoZSBTb2Z0 d2FyZSwgYW5kIHRvIHBlcm1pdCBwZXJzb25zIHRvIHdob20gdGhlCj4gPiArICogU29mdHdhcmUg aXMgZnVybmlzaGVkIHRvIGRvIHNvLCBzdWJqZWN0IHRvIHRoZSBmb2xsb3dpbmcgY29uZGl0aW9u czoKPiA+ICsgKgo+ID4gKyAqIFRoZSBhYm92ZSBjb3B5cmlnaHQgbm90aWNlIGFuZCB0aGlzIHBl cm1pc3Npb24gbm90aWNlIHNoYWxsIGJlIGluY2x1ZGVkIGluCj4gPiArICogYWxsIGNvcGllcyBv ciBzdWJzdGFudGlhbCBwb3J0aW9ucyBvZiB0aGUgU29mdHdhcmUuCj4gPiArICoKPiA+ICsgKiBU SEUgU09GVFdBUkUgSVMgUFJPVklERUQgIkFTIElTIiwgV0lUSE9VVCBXQVJSQU5UWSBPRiBBTlkg S0lORCwgRVhQUkVTUyBPUgo+ID4gKyAqIElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlU RUQgVE8gVEhFIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZLAo+ID4gKyAqIEZJVE5FU1Mg Rk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFORCBOT05JTkZSSU5HRU1FTlQuICBJTiBOTyBFVkVO VCBTSEFMTAo+ID4gKyAqIFRIRSBDT1BZUklHSFQgSE9MREVSKFMpIE9SIEFVVEhPUihTKSBCRSBM SUFCTEUgRk9SIEFOWSBDTEFJTSwgREFNQUdFUyBPUgo+ID4gKyAqIE9USEVSIExJQUJJTElUWSwg V0hFVEhFUiBJTiBBTiBBQ1RJT04gT0YgQ09OVFJBQ1QsIFRPUlQgT1IgT1RIRVJXSVNFLAo+ID4g KyAqIEFSSVNJTkcgRlJPTSwgT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdB UkUgT1IgVEhFIFVTRSBPUgo+ID4gKyAqIE9USEVSIERFQUxJTkdTIElOIFRIRSBTT0ZUV0FSRS4K PiA+ICsgKi8KPiA+ICsKPiA+ICsjaW5jbHVkZSA8bGludXgvZXJybm8uaD4KPiA+ICsjaW5jbHVk ZSA8bGludXgvZXhwb3J0Lmg+Cj4gPiArI2luY2x1ZGUgPGxpbnV4L2kyYy5oPgo+ID4gKyNpbmNs dWRlIDxsaW51eC9zbGFiLmg+Cj4gPiArI2luY2x1ZGUgPGxpbnV4L3N0cmluZy5oPgo+ID4gKyNp bmNsdWRlIDxkcm0vZHJtX2RwX2R1YWxfbW9kZV9oZWxwZXIuaD4KPiA+ICsjaW5jbHVkZSA8ZHJt L2RybVAuaD4KPiA+ICsKPiA+ICsvKioKPiA+ICsgKiBET0M6IERQIGR1YWwgbW9kZSAoYWthLiBE UCsrKSBhZGFwdG9yIGhlbHBlcnMKPiA+ICsgKgo+ID4gKyAqIEhlbHBlciBmdW5jdGlvbnMgdG8g ZGVhbCB3aXRoIERQIGR1YWwgbW9kZSBhZGFwdG9ycy4KPiA+ICsgKgo+ID4gKyAqIFR5cGUgMToK PiA+ICsgKiBBZGFwdG9yIHJlZ2lzdGVycyAoaWYgYW55KSBhbmQgdGhlIHNpbmsgRERDIGJ1cyBt YXkgYmUgYWNjZXNzZWQgdmlhIEkyQy4KPiA+ICsgKgo+ID4gKyAqIFR5cGUgMjoKPiA+ICsgKiBB ZGFwdG9yIHJlZ2lzdGVycyBhbmQgc2luayBEREMgYnVzIGNhbiBiZSBhY2Nlc3NlZCBlaXRoZXIg dmlhIEkyQyBvcgo+ID4gKyAqIEkyQy1vdmVyLUFVWC4gU291cmNlIGRldmljZXMgbWF5IGNob29z ZSB0byBpbXBsZW1lbnQgZWl0aGVyIG9mIHRoZXNlCj4gPiArICogYWNjZXNzIG1ldGhvZHMuCj4g PiArICovCj4gPiArCj4gPiArI2RlZmluZSBEUF9EVUFMX01PREVfU0xBVkVfQUREUkVTUyAweDQw Cj4gPiArCj4gPiArLyoqCj4gPiArICogZHJtX2RwX2R1YWxfbW9kZV9yZWFkIC0gUmVhZCBmcm9t IHRoZSBEUCBkdWFsIG1vZGUgYWRhcHRvciByZWdpc3RlcihzKQo+ID4gKyAqIGFkYXB0ZXI6IEky QyBhZGFwdGVyIGZvciB0aGUgRERDIGJ1cwo+ID4gKyAqIG9mZnNldDogcmVnaXN0ZXIgb2Zmc2V0 Cj4gPiArICogYnVmZmVyOiBidWZmZXIgZm9yIHJldHVybiBkYXRhCj4gPiArICogc2l6ZTogc2l6 byBvZiB0aGUgYnVmZmVyCj4gPiArICoKPiA+ICsgKiBSZWFkcyBAc2l6ZSBieXRlcyBmcm9tIHRo ZSBEUCBkdWFsIG1vZGUgYWRhcHRvciByZWdpc3RlcnMKPiA+ICsgKiBzdGFydGluZyBhdCBAb2Zm c2V0Lgo+ID4gKyAqCj4gPiArICogUmV0dXJuczoKPiA+ICsgKiAwIG9uIHN1Y2Nlc3MsIG5lZ2F0 aXZlIGVycm9yIGNvZGUgb24gZmFpbHVyZQo+ID4gKyAqLwo+ID4gK3NzaXplX3QgZHJtX2RwX2R1 YWxfbW9kZV9yZWFkKHN0cnVjdCBpMmNfYWRhcHRlciAqYWRhcHRlciwKPiA+ICsJCQkgICAgICB1 OCBvZmZzZXQsIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpCj4gPiArewo+ID4gKwlzdHJ1Y3Qg aTJjX21zZyBtc2dzW10gPSB7Cj4gPiArCQl7Cj4gPiArCQkJLmFkZHIgPSBEUF9EVUFMX01PREVf U0xBVkVfQUREUkVTUywKPiA+ICsJCQkuZmxhZ3MgPSAwLAo+ID4gKwkJCS5sZW4gPSAxLAo+ID4g KwkJCS5idWYgPSAmb2Zmc2V0LAo+ID4gKwkJfSwKPiA+ICsJCXsKPiA+ICsJCQkuYWRkciA9IERQ X0RVQUxfTU9ERV9TTEFWRV9BRERSRVNTLAo+ID4gKwkJCS5mbGFncyA9IEkyQ19NX1JELAo+ID4g KwkJCS5sZW4gPSBzaXplLAo+ID4gKwkJCS5idWYgPSBidWZmZXIsCj4gPiArCQl9LAo+ID4gKwl9 Owo+ID4gKwlpbnQgcmV0Owo+ID4gKwo+ID4gKwlyZXQgPSBpMmNfdHJhbnNmZXIoYWRhcHRlciwg bXNncywgQVJSQVlfU0laRShtc2dzKSk7Cj4gPiArCWlmIChyZXQgPCAwKQo+ID4gKwkJcmV0dXJu IHJldDsKPiA+ICsJaWYgKHJldCAhPSBBUlJBWV9TSVpFKG1zZ3MpKQo+ID4gKwkJcmV0dXJuIC1F UFJPVE87Cj4gPiArCj4gPiArCXJldHVybiAwOwo+ID4gK30KPiA+ICsKPiA+ICsvKioKPiA+ICsg KiBkcm1fZHBfZHVhbF9tb2RlX3dyaXRlIC0gV3JpdGUgdG8gdGhlIERQIGR1YWwgbW9kZSBhZGFw dG9yIHJlZ2lzdGVyKHMpCj4gPiArICogYWRhcHRlcjogSTJDIGFkYXB0ZXIgZm9yIHRoZSBEREMg YnVzCj4gPiArICogb2Zmc2V0OiByZWdpc3RlciBvZmZzZXQKPiA+ICsgKiBidWZmZXI6IGJ1ZmZl ciBmb3Igd3JpdGUgZGF0YQo+ID4gKyAqIHNpemU6IHNpem8gb2YgdGhlIGJ1ZmZlcgo+ID4gKyAq Cj4gPiArICogV3JpdGVzIEBzaXplIGJ5dGVzIHRvIHRoZSBEUCBkdWFsIG1vZGUgYWRhcHRvciBy ZWdpc3RlcnMKPiA+ICsgKiBzdGFydGluZyBhdCBAb2Zmc2V0Lgo+ID4gKyAqCj4gPiArICogUmV0 dXJuczoKPiA+ICsgKiAwIG9uIHN1Y2Nlc3MsIG5lZ2F0aXZlIGVycm9yIGNvZGUgb24gZmFpbHVy ZQo+ID4gKyAqLwo+ID4gK3NzaXplX3QgZHJtX2RwX2R1YWxfbW9kZV93cml0ZShzdHJ1Y3QgaTJj X2FkYXB0ZXIgKmFkYXB0ZXIsCj4gPiArCQkJICAgICAgIHU4IG9mZnNldCwgY29uc3Qgdm9pZCAq YnVmZmVyLCBzaXplX3Qgc2l6ZSkKPiA+ICt7Cj4gPiArCXN0cnVjdCBpMmNfbXNnIG1zZyA9IHsK PiA+ICsJCS5hZGRyID0gRFBfRFVBTF9NT0RFX1NMQVZFX0FERFJFU1MsCj4gPiArCQkuZmxhZ3Mg PSAwLAo+ID4gKwkJLmxlbiA9IDEgKyBzaXplLAo+ID4gKwkJLmJ1ZiA9IE5VTEwsCj4gPiArCX07 Cj4gPiArCXZvaWQgKmRhdGE7Cj4gPiArCWludCByZXQ7Cj4gPiArCj4gPiArCWRhdGEgPSBrbWFs bG9jKG1zZy5sZW4sIEdGUF9URU1QT1JBUlkpOwo+ID4gKwlpZiAoIWRhdGEpCj4gPiArCQlyZXR1 cm4gLUVOT01FTTsKPiA+ICsKPiA+ICsJbXNnLmJ1ZiA9IGRhdGE7Cj4gPiArCj4gPiArCW1lbWNw eShkYXRhLCAmb2Zmc2V0LCAxKTsKPiA+ICsJbWVtY3B5KGRhdGEgKyAxLCBidWZmZXIsIHNpemUp Owo+ID4gKwo+ID4gKwlyZXQgPSBpMmNfdHJhbnNmZXIoYWRhcHRlciwgJm1zZywgMSk7Cj4gPiAr Cj4gPiArCWtmcmVlKGRhdGEpOwo+ID4gKwo+ID4gKwlpZiAocmV0IDwgMCkKPiA+ICsJCXJldHVy biByZXQ7Cj4gPiArCWlmIChyZXQgIT0gMSkKPiA+ICsJCXJldHVybiAtRVBST1RPOwo+ID4gKwo+ ID4gKwlyZXR1cm4gMDsKPiA+ICt9Cj4gPiArRVhQT1JUX1NZTUJPTChkcm1fZHBfZHVhbF9tb2Rl X3dyaXRlKTsKPiA+ICsKPiA+ICtzdGF0aWMgYm9vbCBpc19oZG1pX2FkYXB0b3IoY29uc3QgY2hh ciBoZG1pX2lkW0RQX0RVQUxfTU9ERV9IRE1JX0lEX0xFTl0pCj4gPiArewo+ID4gKwlzdGF0aWMg Y29uc3QgY2hhciBkcF9kdWFsX21vZGVfaGRtaV9pZFtEUF9EVUFMX01PREVfSERNSV9JRF9MRU5d ID0KPiA+ICsJCSJEUC1IRE1JIEFEQVBUT1JceDA0IjsKPiA+ICsKPiA+ICsJcmV0dXJuIG1lbWNt cChoZG1pX2lkLCBkcF9kdWFsX21vZGVfaGRtaV9pZCwKPiA+ICsJCSAgICAgIHNpemVvZihkcF9k dWFsX21vZGVfaGRtaV9pZCkpID09IDA7Cj4gPiArfQo+ID4gKwo+ID4gK3N0YXRpYyBib29sIGlz X3R5cGUyX2FkYXB0b3IodWludDhfdCBhZGFwdG9yX2lkKQo+ID4gK3sKPiA+ICsJcmV0dXJuIGFk YXB0b3JfaWQgPT0gKERQX0RVQUxfTU9ERV9UWVBFX1RZUEUyIHwKPiA+ICsJCQkgICAgICBEUF9E VUFMX01PREVfUkVWX1RZUEUyKTsKPiA+ICt9Cj4gPiArCj4gPiArLyoqCj4gPiArICogZHJtX2Rw X2R1YWxfbW9kZV9kZXRlY3QgLSBJZGVudGlmeSB0aGUgRFAgZHVhbCBtb2RlIGFkYXB0b3IKPiA+ ICsgKiBhZGFwdGVyOiBJMkMgYWRhcHRlciBmb3IgdGhlIEREQyBidXMKPiA+ICsgKgo+ID4gKyAq IEF0dGVtcHQgdG8gaWRlbnRpZnkgdGhlIHR5cGUgb2YgdGhlIERQIGR1YWwgbW9kZSBhZGFwdG9y IHVzZWQuCj4gPiArICoKPiA+ICsgKiBOb3RlIHRoYXQgd2hlbiB0aGUgYW5zd2VyIGlzIEBEUk1f RFBfRFVBTF9NT0RFX05PTkUgaXQncyBub3QKPiA+ICsgKiBjZXJ0YWluIHdoZXRoZXIgd2UncmUg ZGVhbGluZyB3aXRoIGEgbmF0aXZlIEhETUkgcG9ydCBvcgo+ID4gKyAqIGEgdHlwZSAxIERWSSBk dWFsIG1vZGUgYWRhcHRvci4gVGhlIGRyaXZlciB3aWxsIGhhdmUgdG8gdXNlCj4gPiArICogc29t ZSBvdGhlciBoYXJkd2FyZS9kcml2ZXIgc3BlY2lmaWMgbWVjaGFuaXNtIHRvIG1ha2UgdGhhdAo+ ID4gKyAqIGRpc3RpbmN0aW9uLgo+ID4gKyAqCj4gPiArICogUmV0dXJuczoKPiA+ICsgKiBUaGUg dHlwZSBvZiB0aGUgRFAgZHVhbCBtb2RlIGFkYXB0b3IgdXNlZAo+ID4gKyAqLwo+ID4gK2VudW0g ZHJtX2RwX2R1YWxfbW9kZV90eXBlIGRybV9kcF9kdWFsX21vZGVfZGV0ZWN0KHN0cnVjdCBpMmNf YWRhcHRlciAqYWRhcHRlcikKPiA+ICt7Cj4gPiArCWNoYXIgaGRtaV9pZFtEUF9EVUFMX01PREVf SERNSV9JRF9MRU5dID0ge307Cj4gPiArCXVpbnQ4X3QgYWRhcHRvcl9pZCA9IDB4MDA7Cj4gPiAr CXNzaXplX3QgcmV0Owo+ID4gKwo+ID4gKwkvKgo+ID4gKwkgKiBMZXQncyBzZWUgaWYgdGhlIGFk YXB0b3IgaXMgdGhlcmUgdGhlIGJ5IHJlYWRpbmcgdGhlCj4gPiArCSAqIEhETUkgSUQgcmVnaXN0 ZXJzLgo+ID4gKwkgKgo+ID4gKwkgKiBOb3RlIHRoYXQgdHlwZSAxIERWSSBhZGFwdG9ycyBhcmUg bm90IHJlcXVpcmVkIHRvIGltcGxlbW50Cj4gPiArCSAqIGFueSByZWdpc3RlcnMsIGFuZCB0aGF0 IHByZXNlbnRzIGEgcHJvYmxlbSBmb3IgZGV0ZWN0aW9uLgo+ID4gKwkgKiBJZiB0aGUgaTJjIHRy YW5zZmVyIGlzIG5hY2tlZCwgd2UgbWF5IG9yIG1heSBub3QgYmUgZGVhbGluZwo+ID4gKwkgKiB3 aXRoIGEgdHlwZSAxIERWSSBhZGFwdG9yLiBTb21lIG90aGVyIG1lY2hhbmlzbSBvZiBkZXRlY3Rp bmcKPiA+ICsJICogdGhlIHByZXNlbmNlIG9mIHRoZSBhZGFwdG9yIGlzIHJlcXVpcmVkLiBPbmUg d2F5IHdvdWxkIGJlCj4gPiArCSAqIHRvIGNoZWNrIHRoZSBzdGF0ZSBvZiB0aGUgQ09ORklHMSBw aW4sIEFub3RoZXIgbWV0aG9kIHdvdWxkCj4gPiArCSAqIHNpbXBseSByZXF1aXJlIHRoZSBkcml2 ZXIgdG8ga25vdyB3aGV0aGVyIHRoZSBwb3J0IGlzIGEgRFArKwo+ID4gKwkgKiBwb3J0IG9yIGEg bmF0aXZlIEhETUkgcG9ydC4gQm90aCBvZiB0aGVzZSBtZXRob2RzIGFyZSBlbnRpcmVseQo+ID4g KwkgKiBoYXJkd2FyZS9kcml2ZXIgc3BlY2lmaWMgc28gd2UgY2FuJ3QgZGVhbCB3aXRoIHRoZW0g aGVyZS4KPiA+ICsJICovCj4gPiArCXJldCA9IGRybV9kcF9kdWFsX21vZGVfcmVhZChhZGFwdGVy LCBEUF9EVUFMX01PREVfSERNSV9JRCwKPiA+ICsJCQkJICAgIGhkbWlfaWQsIHNpemVvZihoZG1p X2lkKSk7Cj4gPiArCWlmIChyZXQpCj4gPiArCQlyZXR1cm4gRFJNX0RQX0RVQUxfTU9ERV9VTktO T1dOOwo+ID4gKwo+ID4gKwkvKgo+ID4gKwkgKiBTaWdoLiBTb21lIChtYXliZSBhbGw/KSB0eXBl IDEgYWRhcHRvcnMgYXJlIGJyb2tlbiBhbmQgYWNrCj4gPiArCSAqIHRoZSBvZmZzZXQgYnV0IGln bm9yZSBpdCwgYW5kIGluc3RlYWQgdGhleSBqdXN0IGFsd2F5cyByZXR1cm4KPiA+ICsJICogZGF0 YSBmcm9tIHRoZSBzdGFydCBvZiB0aGUgSERNSSBJRCBidWZmZXIuIFNvIGZvciBhIGJyb2tlbgo+ ID4gKwkgKiB0eXBlIDEgSERNSSBhZGFwdG9yIGEgc2luZ2xlIGJ5dGUgcmVhZCB3aWxsIGFsd2F5 cyBnaXZlIHVzCj4gPiArCSAqIDB4NDQsIGFuZCBmb3IgYSB0eXBlIDEgRFZJIGFkYXB0b3IgaXQg c2hvdWxkIGdpdmUgMHgwMAo+ID4gKwkgKiAoYXNzdW1pbmcgaXQgaW1wbGVtZW50cyBhbnkgcmVn aXN0ZXJzKS4gRm9ydHVuYXRlbHkgbmVpdGhlcgo+ID4gKwkgKiBvZiB0aG9zZSB2YWx1ZXMgd2ls bCBtYXRjaCB0aGUgdHlwZSAyIHNpZ25hdHVyZSBvZiB0aGUKPiA+ICsJICogRFBfRFVBTF9NT0RF X0FEQVBUT1JfSUQgcmVnaXN0ZXIgc28gd2UgY2FuIHByb2NlZWQgd2l0aAo+ID4gKwkgKiB0aGUg dHlwZSAyIGFkYXB0b3IgZGV0ZWN0aW9uIHNhZmVseSBldmVuIGluIHRoZSBwcmVzZW5jZQo+ID4g KwkgKiBvZiBicm9rZW4gdHlwZSAxIGFkYXB0b3JzLgo+ID4gKwkgKi8KPiA+ICsJcmV0ID0gZHJt X2RwX2R1YWxfbW9kZV9yZWFkKGFkYXB0ZXIsIERQX0RVQUxfTU9ERV9BREFQVE9SX0lELAo+ID4g KwkJCQkgICAgJmFkYXB0b3JfaWQsIHNpemVvZihhZGFwdG9yX2lkKSk7Cj4gY2FuIHdlIHJlYWQg YWxsIDE2IGJ5dGVzIGluIGEgc2luZ2xlIHJlYWQsIGFuZCB0aGVuIHNwbGl0IHRoZSBjaGFyYWN0 ZXJzIAo+IGludG8gZG9uZ2xlX3NpZ25hdHVyZSBhbmQgYWRhcHRvcl9pZCA/CgpJIHRoaW5rIFBh dWxvIHN1Z2dlc3RlZCB0aGUgc2FtZSB0aGluZyBtb3JlIG9yIGxlc3MuIEhtbS4gTGV0IG1lIHRo aW5rLgpJJ20gbm90IHN1cmUgd2Ugd2FudCB0byBkbyB0aGF0IGJlY2F1c2UgSUlSQyB0aGUgc3Bl YyBzYXlzIHRoYXQgdHlwZSAxCkhETUkgYWRhcHRvcnMgYXJlbid0IHJlcXVpcmVkIHRvIHN1cHBv cnQgYW55IHJlZ2lzdGVycyBiZXlvbmQgdGhlIEhETUkKSUQsIHNvIEknbSBub3Qgc3VyZSBzb21l IG9mIHRoZW0gbWlnaHQgbm90IHJldHVybiBhbiBlcnJvciBpZiB3ZSB0cnkgdG8KcmVhZCBtb3Jl IHRoYW4gdGhhdCwgYW5kIHRoYXQgY291bGQgdGhlbiBjYXVzZSB0aGUgSERNSSBJRCByZWFkIGZh aWwgYXMKd2VsbCBldmVuIGlmIGl0J3MgaW5kZWVkIHByZXNlbnQuIEkgZG9uJ3QgdGhpbmsgYW55 IG9mIHRoZSBhZGFwdG9ycyBJCnRlc3RlZCBiZWhhdmVkIHRoYXQgd2F5LCBidXQgSSBkb24ndCBo YXZlIHRoYXQgbWFueSBvZiB0aGVtIGhlcmUuCgpJdCdzIGEgYml0IG9mIGEgc2hhbWUgdGhlIGky YyBzdWJzeXN0ZW0gZG9lc24ndCByZXBvcnQgdGhlIG51bWJlciBvZiAKYnl0ZXMgc3VjY2VzZnVs bHkgdHJhbnNmZXJyZWQuIEl0IGp1c3QgcmV0dXJucyB0aGUgbnVtYmVyIG9mIG1lc3NhZ2VzCnN1 Y2Nlc2Z1bGx5IHRyYW5zZmVycmVkLiBBbmQgaWYgYSBtZXNzYWdlIGlzIG9ubHkgcGFydGlhbGx5 CnRyYW5zZmVycmVkLCBJIHRoaW5rIHdlJ2QganVzdCBnZXQgYSBuZWdhdGl2ZSBlcnJvciBjb2Rl IGJhY2suCgo+ID4gKwlpZiAocmV0ID09IDApIHsKPiA+ICsJCWlmIChpc190eXBlMl9hZGFwdG9y KGFkYXB0b3JfaWQpICYmIGlzX2hkbWlfYWRhcHRvcihoZG1pX2lkKSkKPiA+ICsJCQlyZXR1cm4g RFJNX0RQX0RVQUxfTU9ERV9UWVBFMl9IRE1JOwo+ID4gKwkJZWxzZSBpZiAoaXNfdHlwZTJfYWRh cHRvcihhZGFwdG9yX2lkKSkKPiA+ICsJCQlyZXR1cm4gRFJNX0RQX0RVQUxfTU9ERV9UWVBFMl9E Vkk7Cj4gCWNhbiB3ZSBzYXZlIG9uZSBpZiwgb3IgaXRzIHRvbyBsYXRlIGZvciBtZSB0byB3b3Jr IDopID8KPiAJCWlzX3R5cGUyX2FkYXB0b3IoKSB7Cj4gCQkJaXNfaGRtaV9hZGFwdG9yKCkKPiAJ CQkJcmV0dXJuIHR5cGUyX2hkbWk7Cj4gCQkJZWxzZQo+IAkJCQlyZXR1cm4gdHlwZTJfZHZpCj4g CQl9CgpJIHdhbnRlZCB0byBhdm9pZCBuZXN0aW5nIHRvbyBkZWVwbHkgaGVyZS4gQnV0IHRoZSBs aW5lIGVuZGVkIHVwIHF1aXRlCmxvbmcgYW55d2F5LCBzbyBJIGd1ZXNzIHRoZSBleHRyYSBpbmRl bnQgd291bGRuJ3QgcmVhbGx5IGxvb2sgYW55CndvcnNlIHRoYW4gdGhpcy4KCj4gPiArCX0KPiA+ ICsKPiA+ICsJaWYgKGlzX2hkbWlfYWRhcHRvcihoZG1pX2lkKSkKPiA+ICsJCXJldHVybiBEUk1f RFBfRFVBTF9NT0RFX1RZUEUxX0hETUk7Cj4gPiArCWVsc2UKPiA+ICsJCXJldHVybiBEUk1fRFBf RFVBTF9NT0RFX1RZUEUxX0RWSTsKPiA+ICt9Cj4gPiArRVhQT1JUX1NZTUJPTChkcm1fZHBfZHVh bF9tb2RlX2RldGVjdCk7Cj4gPiArCj4gPiArLyoqCj4gPiArICogZHJtX2RwX2R1YWxfbW9kZV9t YXhfdG1kc19jbG9jayAtIE1heCBUTURTIGNsb2NrIGZvciBEUCBkdWFsIG1vZGUgYWRhcHRvcgo+ ID4gKyAqIHR5cGU6IERQIGR1YWwgbW9kZSBhZGFwdG9yIHR5cGUKPiA+ICsgKiBhZGFwdGVyOiBJ MkMgYWRhcHRlciBmb3IgdGhlIEREQyBidXMKPiA+ICsgKgo+ID4gKyAqIERldGVybWluZSB0aGUg bWF4IFRNRFMgY2xvY2sgdGhlIGFkYXB0b3Igc3VwcG9ydHMgYmFzZWQgb24gdGhlCj4gPiArICog dHlwZSBvZiB0aGUgZHVhbCBtb2RlIGFkYXB0b3IgYW5kIHRoZSBEUF9EVUFMX01PREVfTUFYX1RN RFNfQ0xPQ0sKPiA+ICsgKiByZWdpc3RlciAob24gdHlwZTIgYWRhcHRvcnMpLiBBcyBzb21lIHR5 cGUgMSBhZGFwdG9ycyBoYXZlCj4gPiArICogcHJvYmxlbXMgd2l0aCByZWdpc3RlcnMgKHNlZSBj b21tZW50cyBpbiBkcm1fZHBfZHVhbF9tb2RlX2RldGVjdCgpKQo+ID4gKyAqIHdlIGRvbid0IHJl YWQgdGhlIHJlZ2lzdGVyIG9uIHRob3NlLCBpbnN0ZWFkIHdlIHNpbXBseSBhc3N1bWUKPiA+ICsg KiBhIDE2NSBNSHogbGltaXQgYmFzZWQgb24gdGhlIHNwZWNpZmljYXRpb24uCj4gPiArICoKPiA+ ICsgKiBSZXR1cm5zOgo+ID4gKyAqIE1heGltdW0gc3VwcG9ydGVkIFRNRFMgY2xvY2sgcmF0ZSBm b3IgdGhlIERQIGR1YWwgbW9kZSBhZGFwdG9yIGluIGtIei4KPiA+ICsgKi8KPiA+ICtpbnQgZHJt X2RwX2R1YWxfbW9kZV9tYXhfdG1kc19jbG9jayhlbnVtIGRybV9kcF9kdWFsX21vZGVfdHlwZSB0 eXBlLAo+ID4gKwkJCQkgICAgc3RydWN0IGkyY19hZGFwdGVyICphZGFwdGVyKQo+ID4gK3sKPiA+ ICsJdWludDhfdCBtYXhfdG1kc19jbG9jazsKPiA+ICsJc3NpemVfdCByZXQ7Cj4gPiArCj4gPiAr CS8qIG5hdGl2ZSBIRE1JIHNvIG5vIGxpbWl0ICovCj4gPiArCWlmICh0eXBlID09IERSTV9EUF9E VUFMX01PREVfTk9ORSkKPiA+ICsJCXJldHVybiAwOwo+ID4gKwo+ID4gKwkvKgo+ID4gKwkgKiBU eXBlIDEgYWRhcHRvcnMgYXJlIGxpbWl0ZWQgdG8gMTY1TUh6Cj4gPiArCSAqIFR5cGUgMiBhZGFw dG9ycyBjYW4gdGVsbHMgdXMgdGhlaXIgbGltaXQKPiA+ICsJICovCj4gPiArCWlmICh0eXBlIDwg RFJNX0RQX0RVQUxfTU9ERV9UWVBFMl9EVkkpCj4gPiArCQlyZXR1cm4gMTY1MDAwOwo+ID4gKwo+ ID4gKwlyZXQgPSBkcm1fZHBfZHVhbF9tb2RlX3JlYWQoYWRhcHRlciwgRFBfRFVBTF9NT0RFX01B WF9UTURTX0NMT0NLLAo+ID4gKwkJCQkgICAgJm1heF90bWRzX2Nsb2NrLCBzaXplb2YobWF4X3Rt ZHNfY2xvY2spKTsKPiA+ICsJaWYgKHJldCB8fCBtYXhfdG1kc19jbG9jayA9PSAweDAwIHx8IG1h eF90bWRzX2Nsb2NrID09IDB4ZmYpCj4gPiArCQlyZXR1cm4gMTY1MDAwOwo+ID4gKwo+ID4gKwly ZXR1cm4gbWF4X3RtZHNfY2xvY2sgKiA1MDAwIC8gMjsKPiA+ICt9Cj4gPiArRVhQT1JUX1NZTUJP TChkcm1fZHBfZHVhbF9tb2RlX21heF90bWRzX2Nsb2NrKTsKPiA+ICsKPiA+ICsvKioKPiA+ICsg KiBkcm1fZHBfZHVhbF9tb2RlX2dldF90bWRzX291dHB1dCAtIEdldCB0aGUgc3RhdGUgb2YgdGhl IFRNRFMgb3V0cHV0IGJ1ZmZlcnMgaW4gdGhlIERQIGR1YWwgbW9kZSBhZGFwdG9yCj4gPiArICog dHlwZTogRFAgZHVhbCBtb2RlIGFkYXB0b3IgdHlwZQo+ID4gKyAqIGFkYXB0ZXI6IEkyQyBhZGFw dGVyIGZvciB0aGUgRERDIGJ1cwo+ID4gKyAqIGVuYWJsZWQ6IGN1cnJlbnQgc3RhdGUgb2YgdGhl IFRNRFMgb3V0cHV0IGJ1ZmZlcnMKPiA+ICsgKgo+ID4gKyAqIEdldCB0aGUgc3RhdGUgb2YgdGhl IFRNRFMgb3V0cHV0IGJ1ZmZlcnMgaW4gdGhlIGFkYXB0b3IuIEZvcgo+ID4gKyAqIHR5cGUyIGFk YXB0b3JzIHRoaXMgaXMgcXVlcmllZCBmcm9tIHRoZSBEUF9EVUFMX01PREVfVE1EU19PRU4KPiA+ ICsgKiByZWdpc3Rlci4gQXMgc29tZSB0eXBlIDEgYWRhcHRvcnMgaGF2ZSBwcm9ibGVtcyB3aXRo IHJlZ2lzdGVycwo+ID4gKyAqIChzZWUgY29tbWVudHMgaW4gZHJtX2RwX2R1YWxfbW9kZV9kZXRl Y3QoKSkgd2UgZG9uJ3QgcmVhZCB0aGUKPiA+ICsgKiByZWdpc3RlciBvbiB0aG9zZSwgaW5zdGVh ZCB3ZSBzaW1wbHkgYXNzdW1lIHRoYXQgdGhlIGJ1ZmZlcnMKPiA+ICsgKiBhcmUgYWx3YXlzIGVu YWJsZWQuCj4gPiArICoKPiA+ICsgKiBSZXR1cm5zOgo+ID4gKyAqIDAgb24gc3VjY2VzcywgbmVn YXRpdmUgZXJyb3IgY29kZSBvbiBmYWlsdXJlCj4gPiArICovCj4gPiAraW50IGRybV9kcF9kdWFs X21vZGVfZ2V0X3RtZHNfb3V0cHV0KGVudW0gZHJtX2RwX2R1YWxfbW9kZV90eXBlIHR5cGUsCj4g PiArCQkJCSAgICAgc3RydWN0IGkyY19hZGFwdGVyICphZGFwdGVyLAo+ID4gKwkJCQkgICAgIGJv b2wgKmVuYWJsZWQpCj4gPiArewo+ID4gKwl1aW50OF90IHRtZHNfb2VuOwo+ID4gKwlzc2l6ZV90 IHJldDsKPiA+ICsKPiA+ICsJaWYgKHR5cGUgPCBEUk1fRFBfRFVBTF9NT0RFX1RZUEUyX0RWSSkg ewo+ID4gKwkJKmVuYWJsZWQgPSB0cnVlOwo+ID4gKwkJcmV0dXJuIDA7Cj4gPiArCX0KPiA+ICsK PiA+ICsJcmV0ID0gZHJtX2RwX2R1YWxfbW9kZV9yZWFkKGFkYXB0ZXIsIERQX0RVQUxfTU9ERV9U TURTX09FTiwKPiA+ICsJCQkJICAgICZ0bWRzX29lbiwgc2l6ZW9mKHRtZHNfb2VuKSk7Cj4gPiAr CWlmIChyZXQpCj4gZGVidWcgbWVzc2FnZSBoZXJlIG1pZ2h0IGhlbHAgaW4gZmFpbHVyZSBjYXNl cy4KClN1cmUsIEkgY2FuIGFkZCBpdC4KCj4gPiArCQlyZXR1cm4gcmV0Owo+ID4gKwo+ID4gKwkq ZW5hYmxlZCA9ICEodG1kc19vZW4gJiBEUF9EVUFMX01PREVfVE1EU19ESVNBQkxFKTsKPiA+ICsK PiA+ICsJcmV0dXJuIDA7Cj4gPiArfQo+ID4gK0VYUE9SVF9TWU1CT0woZHJtX2RwX2R1YWxfbW9k ZV9nZXRfdG1kc19vdXRwdXQpOwo+ID4gKwo+ID4gKy8qKgo+ID4gKyAqIGRybV9kcF9kdWFsX21v ZGVfc2V0X3RtZHNfb3V0cHV0IC0gRW5hYmxlL2Rpc2FibGUgVE1EUyBvdXRwdXQgYnVmZmVycyBp biB0aGUgRFAgZHVhbCBtb2RlIGFkYXB0b3IKPiA+ICsgKiB0eXBlOiBEUCBkdWFsIG1vZGUgYWRh cHRvciB0eXBlCj4gPiArICogYWRhcHRlcjogSTJDIGFkYXB0ZXIgZm9yIHRoZSBEREMgYnVzCj4g PiArICogZW5hYmxlOiBlbmFibGUgKGFzIG9wcG9zZWQgdG8gZGlzYWJsZSkgdGhlIFRNRFMgb3V0 cHV0IGJ1ZmZlcnMKPiA+ICsgKgo+ID4gKyAqIFNldCB0aGUgc3RhdGUgb2YgdGhlIFRNRFMgb3V0 cHV0IGJ1ZmZlcnMgaW4gdGhlIGFkYXB0b3IuIEZvcgo+ID4gKyAqIHR5cGUyIHRoaXMgaXMgc2V0 IHZpYSB0aGUgRFBfRFVBTF9NT0RFX1RNRFNfT0VOIHJlZ2lzdGVyLiBBcwo+ID4gKyAqIHNvbWUg dHlwZSAxIGFkYXB0b3JzIGhhdmUgcHJvYmxlbXMgd2l0aCByZWdpc3RlcnMgKHNlZSBjb21tZW50 cwo+ID4gKyAqIGluIGRybV9kcF9kdWFsX21vZGVfZGV0ZWN0KCkpIHdlIGF2b2lkIHRvdWNoaW5n IHRoZSByZWdpc3RlciwKPiA+ICsgKiBtYWtpbmcgdGhpcyBmdW5jdGlvbiBhIG5vLW9wIG9uIHR5 cGUgMSBhZGFwdG9ycy4KPiA+ICsgKgo+ID4gKyAqIFJldHVybnM6Cj4gPiArICogMCBvbiBzdWNj ZXNzLCBuZWdhdGl2ZSBlcnJvciBjb2RlIG9uIGZhaWx1cmUKPiA+ICsgKi8KPiA+ICtpbnQgZHJt X2RwX2R1YWxfbW9kZV9zZXRfdG1kc19vdXRwdXQoZW51bSBkcm1fZHBfZHVhbF9tb2RlX3R5cGUg dHlwZSwKPiA+ICsJCQkJICAgICBzdHJ1Y3QgaTJjX2FkYXB0ZXIgKmFkYXB0ZXIsIGJvb2wgZW5h YmxlKQo+ID4gK3sKPiA+ICsJdWludDhfdCB0bWRzX29lbiA9IGVuYWJsZSA/IDAgOiBEUF9EVUFM X01PREVfVE1EU19ESVNBQkxFOwo+ID4gKwlzc2l6ZV90IHJldDsKPiA+ICsKPiA+ICsJaWYgKHR5 cGUgPCBEUk1fRFBfRFVBTF9NT0RFX1RZUEUyX0RWSSkKPiA+ICsJCXJldHVybiAwOwo+ID4gKwo+ ID4gKwlyZXQgPSBkcm1fZHBfZHVhbF9tb2RlX3dyaXRlKGFkYXB0ZXIsIERQX0RVQUxfTU9ERV9U TURTX09FTiwKPiA+ICsJCQkJICAgICAmdG1kc19vZW4sIHNpemVvZih0bWRzX29lbikpOwo+ID4g KwlpZiAocmV0KQo+IGRlYnVnIG1lc3NhZ2UgaGVyZSBtaWdodCBoZWxwIGluIGZhaWx1cmUgY2Fz ZXMuCgpjYW4gZG8uCgo+ID4gKwkJcmV0dXJuIHJldDsKPiA+ICsKPiA+ICsJcmV0dXJuIDA7Cj4g PiArfQo+ID4gK0VYUE9SVF9TWU1CT0woZHJtX2RwX2R1YWxfbW9kZV9zZXRfdG1kc19vdXRwdXQp Owo+ID4gKwo+ID4gKy8qKgo+ID4gKyAqIGRybV9kcF9nZXRfZHVhbF9tb2RlX3R5cGVfbmFtZSAt IEdldCB0aGUgbmFtZSBvZiB0aGUgRFAgZHVhbCBtb2RlIGFkYXB0b3IgdHlwZSBhcyBhIHN0cmlu Zwo+ID4gKyAqIHR5cGU6IERQIGR1YWwgbW9kZSBhZGFwdG9yIHR5cGUKPiA+ICsgKgo+ID4gKyAq IFJldHVybnM6Cj4gPiArICogU3RyaW5nIHJlcHJlc2VudGF0aW9uIG9mIHRoZSBEUCBkdWFsIG1v ZGUgYWRhcHRvciB0eXBlCj4gPiArICovCj4gPiArY29uc3QgY2hhciAqZHJtX2RwX2dldF9kdWFs X21vZGVfdHlwZV9uYW1lKGVudW0gZHJtX2RwX2R1YWxfbW9kZV90eXBlIHR5cGUpCj4gPiArewo+ ID4gKwlzd2l0Y2ggKHR5cGUpIHsKPiA+ICsJY2FzZSBEUk1fRFBfRFVBTF9NT0RFX05PTkU6Cj4g PiArCQlyZXR1cm4gIm5vbmUiOwo+ID4gKwljYXNlIERSTV9EUF9EVUFMX01PREVfVFlQRTFfRFZJ Ogo+ID4gKwkJcmV0dXJuICJ0eXBlIDEgRFZJIjsKPiA+ICsJY2FzZSBEUk1fRFBfRFVBTF9NT0RF X1RZUEUxX0hETUk6Cj4gPiArCQlyZXR1cm4gInR5cGUgMSBIRE1JIjsKPiA+ICsJY2FzZSBEUk1f RFBfRFVBTF9NT0RFX1RZUEUyX0RWSToKPiA+ICsJCXJldHVybiAidHlwZSAyIERWSSI7Cj4gPiAr CWNhc2UgRFJNX0RQX0RVQUxfTU9ERV9UWVBFMl9IRE1JOgo+ID4gKwkJcmV0dXJuICJ0eXBlIDIg SERNSSI7Cj4gPiArCWRlZmF1bHQ6Cj4gPiArCQlXQVJOX09OKHR5cGUgIT0gRFJNX0RQX0RVQUxf TU9ERV9VTktOT1dOKTsKPiBkbyB3ZSBuZWVkIGEgd2FybmluZyBoZXJlLCBvciBhIERSTV9FUlJP UiBzaG91bGQgd29yayA/Cj4gSSBhbSBhZnJhaWQgd2Ugd2lsbCBzaG93IGEgYmFjay10cmFjZSBm b3IgYWxsIG5vbi1jb21wbGlhbnQgYWRhcHRlcnMuCgpJZiBzb21lb25lIHBhc3NlcyBpbiBhbiBp bnZhbGlkIHR5cGUsIHRoYXQncyBhIGJ1ZyBpbiB0aGUgY2FsbGVyLiBTbwp0aGlzIHNob3VsZCBu ZXZlciBoYXBwZW4uCgo+ID4gKwkJcmV0dXJuICJ1bmtub3duIjsKPiA+ICsJfQo+ID4gK30KPiA+ ICtFWFBPUlRfU1lNQk9MKGRybV9kcF9nZXRfZHVhbF9tb2RlX3R5cGVfbmFtZSk7Cj4gPiBkaWZm IC0tZ2l0IGEvaW5jbHVkZS9kcm0vZHJtX2RwX2R1YWxfbW9kZV9oZWxwZXIuaCBiL2luY2x1ZGUv ZHJtL2RybV9kcF9kdWFsX21vZGVfaGVscGVyLmgKPiA+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4g PiBpbmRleCAwMDAwMDAwMDAwMDAuLmI0NjAzYjlmYzAzZAo+ID4gLS0tIC9kZXYvbnVsbAo+ID4g KysrIGIvaW5jbHVkZS9kcm0vZHJtX2RwX2R1YWxfbW9kZV9oZWxwZXIuaAo+ID4gQEAgLTAsMCAr MSw4MyBAQAo+ID4gKy8qCj4gPiArICogQ29weXJpZ2h0IMKpIDIwMTYgSW50ZWwgQ29ycG9yYXRp b24KPiA+ICsgKgo+ID4gKyAqIFBlcm1pc3Npb24gaXMgaGVyZWJ5IGdyYW50ZWQsIGZyZWUgb2Yg Y2hhcmdlLCB0byBhbnkgcGVyc29uIG9idGFpbmluZyBhCj4gPiArICogY29weSBvZiB0aGlzIHNv ZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRvY3VtZW50YXRpb24gZmlsZXMgKHRoZSAiU29mdHdhcmUi KSwKPiA+ICsgKiB0byBkZWFsIGluIHRoZSBTb2Z0d2FyZSB3aXRob3V0IHJlc3RyaWN0aW9uLCBp bmNsdWRpbmcgd2l0aG91dCBsaW1pdGF0aW9uCj4gPiArICogdGhlIHJpZ2h0cyB0byB1c2UsIGNv cHksIG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1dGUsIHN1YmxpY2Vuc2UsCj4gPiAr ICogYW5kL29yIHNlbGwgY29waWVzIG9mIHRoZSBTb2Z0d2FyZSwgYW5kIHRvIHBlcm1pdCBwZXJz b25zIHRvIHdob20gdGhlCj4gPiArICogU29mdHdhcmUgaXMgZnVybmlzaGVkIHRvIGRvIHNvLCBz dWJqZWN0IHRvIHRoZSBmb2xsb3dpbmcgY29uZGl0aW9uczoKPiA+ICsgKgo+ID4gKyAqIFRoZSBh Ym92ZSBjb3B5cmlnaHQgbm90aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNlIHNoYWxsIGJl IGluY2x1ZGVkIGluCj4gPiArICogYWxsIGNvcGllcyBvciBzdWJzdGFudGlhbCBwb3J0aW9ucyBv ZiB0aGUgU29mdHdhcmUuCj4gPiArICoKPiA+ICsgKiBUSEUgU09GVFdBUkUgSVMgUFJPVklERUQg IkFTIElTIiwgV0lUSE9VVCBXQVJSQU5UWSBPRiBBTlkgS0lORCwgRVhQUkVTUyBPUgo+ID4gKyAq IElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMgT0Yg TUVSQ0hBTlRBQklMSVRZLAo+ID4gKyAqIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NF IEFORCBOT05JTkZSSU5HRU1FTlQuICBJTiBOTyBFVkVOVCBTSEFMTAo+ID4gKyAqIFRIRSBDT1BZ UklHSFQgSE9MREVSKFMpIE9SIEFVVEhPUihTKSBCRSBMSUFCTEUgRk9SIEFOWSBDTEFJTSwgREFN QUdFUyBPUgo+ID4gKyAqIE9USEVSIExJQUJJTElUWSwgV0hFVEhFUiBJTiBBTiBBQ1RJT04gT0Yg Q09OVFJBQ1QsIFRPUlQgT1IgT1RIRVJXSVNFLAo+ID4gKyAqIEFSSVNJTkcgRlJPTSwgT1VUIE9G IE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUgo+ID4gKyAq IE9USEVSIERFQUxJTkdTIElOIFRIRSBTT0ZUV0FSRS4KPiA+ICsgKi8KPiA+ICsKPiA+ICsjaWZu ZGVmIERSTV9EUF9EVUFMX01PREVfSEVMUEVSX0gKPiA+ICsjZGVmaW5lIERSTV9EUF9EVUFMX01P REVfSEVMUEVSX0gKPiA+ICsKPiA+ICsjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KPiA+ICsKPiA+ ICsvKgo+ID4gKyAqIE9wdGlvbmFsIGZvciB0eXBlIDEgRFZJIGFkYXB0b3JzCj4gPiArICogTWFu ZGF0b3J5IGZvciB0eXBlIDEgSERNSSBhbmQgdHlwZSAyIGFkYXRvcnMKPiA+ICsgKi8KPiA+ICsj ZGVmaW5lIERQX0RVQUxfTU9ERV9IRE1JX0lEIDB4MDAgLyogMDAtMGYgKi8KPiA+ICsjZGVmaW5l ICBEUF9EVUFMX01PREVfSERNSV9JRF9MRU4gMTYKPiA+ICsvKgo+ID4gKyAqIE9wdGlvbmFsIGZv ciB0eXBlIDEgYWRhcHRvcnMKPiA+ICsgKiBNYW5kYXRvcnkgZm9yIHR5cGUgMiBhZGF0b3JzCj4g PiArICovCj4gPiArI2RlZmluZSBEUF9EVUFMX01PREVfQURBUFRPUl9JRCAweDEwCj4gPiArI2Rl ZmluZSAgRFBfRFVBTF9NT0RFX1JFVl9NQVNLIDB4MDcKPiA+ICsjZGVmaW5lICBEUF9EVUFMX01P REVfUkVWX1RZUEUyIDB4MDAKPiA+ICsjZGVmaW5lICBEUF9EVUFMX01PREVfVFlQRV9NQVNLIDB4 ZjAKPiA+ICsjZGVmaW5lICBEUF9EVUFMX01PREVfVFlQRV9UWVBFMiAweGEwCj4gPiArI2RlZmlu ZSBEUF9EVUFMX01PREVfSUVFRV9PVUkgMHgxMSAvKiAxMS0xMyovCj4gPiArI2RlZmluZSAgRFBf RFVBTF9JRUVFX09VSV9MRU4gMwo+ID4gKyNkZWZpbmUgRFBfRFVBTF9ERVZJQ0VfSUQgMHgxNCAv KiAxNC0xOSAqLwo+ID4gKyNkZWZpbmUgIERQX0RVQUxfREVWSUNFX0lEX0xFTiA2Cj4gPiArI2Rl ZmluZSBEUF9EVUFMX01PREVfSEFSRFdBUkVfUkVWIDB4MWEKPiA+ICsjZGVmaW5lIERQX0RVQUxf TU9ERV9GSVJNV0FSRV9NQUpPUl9SRVYgMHgxYgo+ID4gKyNkZWZpbmUgRFBfRFVBTF9NT0RFX0ZJ Uk1XQVJFX01JTk9SX1JFViAweDFjCj4gPiArI2RlZmluZSBEUF9EVUFMX01PREVfTUFYX1RNRFNf Q0xPQ0sgMHgxZAo+ID4gKyNkZWZpbmUgRFBfRFVBTF9NT0RFX0kyQ19TUEVFRF9DQVAgMHgxZQo+ ID4gKyNkZWZpbmUgRFBfRFVBTF9NT0RFX1RNRFNfT0VOIDB4MjAKPiA+ICsjZGVmaW5lICBEUF9E VUFMX01PREVfVE1EU19ESVNBQkxFIDB4MDEKPiA+ICsjZGVmaW5lIERQX0RVQUxfTU9ERV9IRE1J X1BJTl9DVFJMIDB4MjEKPiA+ICsjZGVmaW5lICBEUF9EVUFMX01PREVfQ0VDX0VOQUJMRSAweDAx Cj4gPiArI2RlZmluZSBEUF9EVUFMX01PREVfSTJDX1NQRUVEX0NUUkwgMHgyMgo+ID4gKwo+ID4g K3N0cnVjdCBpMmNfYWRhcHRlcjsKPiA+ICsKPiA+ICtzc2l6ZV90IGRybV9kcF9kdWFsX21vZGVf cmVhZChzdHJ1Y3QgaTJjX2FkYXB0ZXIgKmFkYXB0ZXIsCj4gPiArCQkJICAgICAgdTggb2Zmc2V0 LCB2b2lkICpidWZmZXIsIHNpemVfdCBzaXplKTsKPiA+ICtzc2l6ZV90IGRybV9kcF9kdWFsX21v ZGVfd3JpdGUoc3RydWN0IGkyY19hZGFwdGVyICphZGFwdGVyLAo+ID4gKwkJCSAgICAgICB1OCBv ZmZzZXQsIGNvbnN0IHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpOwo+ID4gKwo+ID4gK2VudW0g ZHJtX2RwX2R1YWxfbW9kZV90eXBlIHsKPiA+ICsJRFJNX0RQX0RVQUxfTU9ERV9OT05FLAo+IHdo YXQgZG9lcyBkdWFsIG1vZGUgbm9uZSBpbmRpY2F0ZSAoY29uc2lkZXJpbmcgd2UgaGF2ZSBhbiB1 bmtub3duIGNhc2UgCj4gYmVsb3cpID8KCkl0IG1lYW4gd2Uga25vdyB0aGF0IHRoZXJlIGlzIG5v IGR1YWwgbW9kZSBhZGFwdG9yLCBtZWFuaW5nIHdlJ3JlCmRlYWxpbmcgd2l0aCBhIG5hdGl2ZSBI RE1JIHBvcnQuIE9yaWdpbmFsbHkgSSBoYWQganVzdCB0aGUgTk9ORSwgYnV0ClBhdWxvIHJlcXVl c3RlZCB0aGF0IHdlIG1ha2UgdGhlIFVOS05PV04gY2FzZSBtb3JlIGV4cGxpY2l0IHNvIEkgc3Bs aXQKaXQgaW50byB0d28uIEl0J3MgYWx3YXlzIHRoZSBkcml2ZXIncyByZXNwb25zaWJpbGl0eSB0 byByZWZpbmUgdGhlCmRldGVjdGlvbiByZXN1bHQgdG8gTk9ORSBvciBUWVBFMV9EVkkgaWYgZHJt X2RwX2R1YWxfbW9kZV9kZXRlY3QoKQpyZXR1cm5zIFVOS05PV04uCgo+IFJlZ2FyZHMKPiBTaGFz aGFuawo+ID4gKwlEUk1fRFBfRFVBTF9NT0RFX1VOS05PV04sCj4gPiArCURSTV9EUF9EVUFMX01P REVfVFlQRTFfRFZJLAo+ID4gKwlEUk1fRFBfRFVBTF9NT0RFX1RZUEUxX0hETUksCj4gPiArCURS TV9EUF9EVUFMX01PREVfVFlQRTJfRFZJLAo+ID4gKwlEUk1fRFBfRFVBTF9NT0RFX1RZUEUyX0hE TUksCj4gPiArfTsKPiA+ICsKPiA+ICtlbnVtIGRybV9kcF9kdWFsX21vZGVfdHlwZSBkcm1fZHBf ZHVhbF9tb2RlX2RldGVjdChzdHJ1Y3QgaTJjX2FkYXB0ZXIgKmFkYXB0ZXIpOwo+ID4gK2ludCBk cm1fZHBfZHVhbF9tb2RlX21heF90bWRzX2Nsb2NrKGVudW0gZHJtX2RwX2R1YWxfbW9kZV90eXBl IHR5cGUsCj4gPiArCQkJCSAgICBzdHJ1Y3QgaTJjX2FkYXB0ZXIgKmFkYXB0ZXIpOwo+ID4gK2lu dCBkcm1fZHBfZHVhbF9tb2RlX2dldF90bWRzX291dHB1dChlbnVtIGRybV9kcF9kdWFsX21vZGVf dHlwZSB0eXBlLAo+ID4gKwkJCQkgICAgIHN0cnVjdCBpMmNfYWRhcHRlciAqYWRhcHRlciwgYm9v bCAqZW5hYmxlZCk7Cj4gPiAraW50IGRybV9kcF9kdWFsX21vZGVfc2V0X3RtZHNfb3V0cHV0KGVu dW0gZHJtX2RwX2R1YWxfbW9kZV90eXBlIHR5cGUsCj4gPiArCQkJCSAgICAgc3RydWN0IGkyY19h ZGFwdGVyICphZGFwdGVyLCBib29sIGVuYWJsZSk7Cj4gPiArY29uc3QgY2hhciAqZHJtX2RwX2dl dF9kdWFsX21vZGVfdHlwZV9uYW1lKGVudW0gZHJtX2RwX2R1YWxfbW9kZV90eXBlIHR5cGUpOwo+ ID4gKwo+ID4gKyNlbmRpZgo+ID4KCi0tIApWaWxsZSBTeXJqw6Rsw6QKSW50ZWwgT1RDCl9fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWls aW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZy ZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga09.intel.com ([134.134.136.24]:44759 "EHLO mga09.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S934181AbcECRjF (ORCPT ); Tue, 3 May 2016 13:39:05 -0400 Date: Tue, 3 May 2016 20:38:59 +0300 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= To: "Sharma, Shashank" Cc: dri-devel@lists.freedesktop.org, intel-gfx@lists.freedesktop.org, stable@vger.kernel.org, Tore Anderson , Paulo Zanoni , Daniel Vetter Subject: Re: [PATCH v2 1/4] drm: Add helper for DP++ adaptors Message-ID: <20160503173859.GJ4329@intel.com> References: <1462216105-20881-1-git-send-email-ville.syrjala@linux.intel.com> <1462216105-20881-2-git-send-email-ville.syrjala@linux.intel.com> <5728D2DA.2020201@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <5728D2DA.2020201@intel.com> Sender: stable-owner@vger.kernel.org List-ID: On Tue, May 03, 2016 at 10:03:30PM +0530, Sharma, Shashank wrote: > > > On 5/3/2016 12:38 AM, ville.syrjala@linux.intel.com wrote: > > From: Ville Syrj�l� > > > > Add a helper which aids in the identification of DP dual mode > > (aka. DP++) adaptors. There are several types of adaptors > > specified: type 1 DVI, type 1 HDMI, type 2 DVI, type 2 HDMI > > > > Type 1 adaptors have a max TMDS clock limit of 165MHz, type 2 adaptors > > may go as high as 300MHz and they provide a register informing the > > source device what the actual limit is. Supposedly also type 1 adaptors > > may optionally implement this register. This TMDS clock limit is the > > main reason why we need to identify these adaptors. > > > > Type 1 adaptors provide access to their internal registers and the sink > > DDC bus through I2C. Type 2 adaptors provide this access both via I2C > > and I2C-over-AUX. A type 2 source device may choose to implement either > > of these methods. If a source device implements the I2C-over-AUX > > method, then the driver will obviously need specific support for such > > adaptors since the port is driven like an HDMI port, but DDC > > communication happes over the AUX channel. > > > > This helper should be enough to identify the adaptor type (some > > type 1 DVI adaptors may be a slight exception) and the maximum TMDS > > clock limit. Another feature that may be available is control over > > the TMDS output buffers on the adaptor, possibly allowing for some > > power saving when the TMDS link is down. > > > > Other user controllable features that may be available in the adaptors > > are downstream i2c bus speed control when using i2c-over-aux, and > > some control over the CEC pin. I chose not to provide any helper > > functions for those since I have no use for them in i915 at this time. > > The rest of the registers in the adaptor are mostly just information, > > eg. IEEE OUI, hardware and firmware revision, etc. > > > > v2: Pass adaptor type to helper functions to ease driver implementation > > Fix a bunch of typoes (Paulo) > > Add DRM_DP_DUAL_MODE_UNKNOWN for the case where we don't (yet) know > > the type (Paulo) > > Reject 0x00 and 0xff DP_DUAL_MODE_MAX_TMDS_CLOCK values (Paulo) > > Adjust drm_dp_dual_mode_detect() type2 vs. type1 detection to > > ease future LSPCON enabling > > Remove the unused DP_DUAL_MODE_LAST_RESERVED define > > > > Cc: stable@vger.kernel.org > > Cc: Tore Anderson > > Cc: Paulo Zanoni > > Cc: Shashank Sharma > > Cc: Daniel Vetter > > Signed-off-by: Ville Syrj�l� > > --- > > drivers/gpu/drm/Makefile | 2 +- > > drivers/gpu/drm/drm_dp_dual_mode_helper.c | 356 ++++++++++++++++++++++++++++++ > > include/drm/drm_dp_dual_mode_helper.h | 83 +++++++ > > 3 files changed, 440 insertions(+), 1 deletion(-) > > create mode 100644 drivers/gpu/drm/drm_dp_dual_mode_helper.c > > create mode 100644 include/drm/drm_dp_dual_mode_helper.h > > > > diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile > > index 1a26b4eb1ce0..29f2ee9b9534 100644 > > --- a/drivers/gpu/drm/Makefile > > +++ b/drivers/gpu/drm/Makefile > > @@ -23,7 +23,7 @@ drm-$(CONFIG_AGP) += drm_agpsupport.o > > > > drm_kms_helper-y := drm_crtc_helper.o drm_dp_helper.o drm_probe_helper.o \ > > drm_plane_helper.o drm_dp_mst_topology.o drm_atomic_helper.o \ > > - drm_kms_helper_common.o > > + drm_kms_helper_common.o drm_dp_dual_mode_helper.o > > > > drm_kms_helper-$(CONFIG_DRM_LOAD_EDID_FIRMWARE) += drm_edid_load.o > > drm_kms_helper-$(CONFIG_DRM_FBDEV_EMULATION) += drm_fb_helper.o > > diff --git a/drivers/gpu/drm/drm_dp_dual_mode_helper.c b/drivers/gpu/drm/drm_dp_dual_mode_helper.c > > new file mode 100644 > > index 000000000000..949c0fbeb542 > > --- /dev/null > > +++ b/drivers/gpu/drm/drm_dp_dual_mode_helper.c > > @@ -0,0 +1,356 @@ > > +/* > > + * Copyright � 2016 Intel Corporation > > + * > > + * Permission is hereby granted, free of charge, to any person obtaining a > > + * copy of this software and associated documentation files (the "Software"), > > + * to deal in the Software without restriction, including without limitation > > + * the rights to use, copy, modify, merge, publish, distribute, sublicense, > > + * and/or sell copies of the Software, and to permit persons to whom the > > + * Software is furnished to do so, subject to the following conditions: > > + * > > + * The above copyright notice and this permission notice shall be included in > > + * all copies or substantial portions of the Software. > > + * > > + * 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 COPYRIGHT HOLDER(S) OR AUTHOR(S) 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 > > +#include > > +#include > > + > > +/** > > + * DOC: DP dual mode (aka. DP++) adaptor helpers > > + * > > + * Helper functions to deal with DP dual mode adaptors. > > + * > > + * Type 1: > > + * Adaptor registers (if any) and the sink DDC bus may be accessed via I2C. > > + * > > + * Type 2: > > + * Adaptor registers and sink DDC bus can be accessed either via I2C or > > + * I2C-over-AUX. Source devices may choose to implement either of these > > + * access methods. > > + */ > > + > > +#define DP_DUAL_MODE_SLAVE_ADDRESS 0x40 > > + > > +/** > > + * drm_dp_dual_mode_read - Read from the DP dual mode adaptor register(s) > > + * adapter: I2C adapter for the DDC bus > > + * offset: register offset > > + * buffer: buffer for return data > > + * size: sizo of the buffer > > + * > > + * Reads @size bytes from the DP dual mode adaptor registers > > + * starting at @offset. > > + * > > + * Returns: > > + * 0 on success, negative error code on failure > > + */ > > +ssize_t drm_dp_dual_mode_read(struct i2c_adapter *adapter, > > + u8 offset, void *buffer, size_t size) > > +{ > > + struct i2c_msg msgs[] = { > > + { > > + .addr = DP_DUAL_MODE_SLAVE_ADDRESS, > > + .flags = 0, > > + .len = 1, > > + .buf = &offset, > > + }, > > + { > > + .addr = DP_DUAL_MODE_SLAVE_ADDRESS, > > + .flags = I2C_M_RD, > > + .len = size, > > + .buf = buffer, > > + }, > > + }; > > + int ret; > > + > > + ret = i2c_transfer(adapter, msgs, ARRAY_SIZE(msgs)); > > + if (ret < 0) > > + return ret; > > + if (ret != ARRAY_SIZE(msgs)) > > + return -EPROTO; > > + > > + return 0; > > +} > > + > > +/** > > + * drm_dp_dual_mode_write - Write to the DP dual mode adaptor register(s) > > + * adapter: I2C adapter for the DDC bus > > + * offset: register offset > > + * buffer: buffer for write data > > + * size: sizo of the buffer > > + * > > + * Writes @size bytes to the DP dual mode adaptor registers > > + * starting at @offset. > > + * > > + * Returns: > > + * 0 on success, negative error code on failure > > + */ > > +ssize_t drm_dp_dual_mode_write(struct i2c_adapter *adapter, > > + u8 offset, const void *buffer, size_t size) > > +{ > > + struct i2c_msg msg = { > > + .addr = DP_DUAL_MODE_SLAVE_ADDRESS, > > + .flags = 0, > > + .len = 1 + size, > > + .buf = NULL, > > + }; > > + void *data; > > + int ret; > > + > > + data = kmalloc(msg.len, GFP_TEMPORARY); > > + if (!data) > > + return -ENOMEM; > > + > > + msg.buf = data; > > + > > + memcpy(data, &offset, 1); > > + memcpy(data + 1, buffer, size); > > + > > + ret = i2c_transfer(adapter, &msg, 1); > > + > > + kfree(data); > > + > > + if (ret < 0) > > + return ret; > > + if (ret != 1) > > + return -EPROTO; > > + > > + return 0; > > +} > > +EXPORT_SYMBOL(drm_dp_dual_mode_write); > > + > > +static bool is_hdmi_adaptor(const char hdmi_id[DP_DUAL_MODE_HDMI_ID_LEN]) > > +{ > > + static const char dp_dual_mode_hdmi_id[DP_DUAL_MODE_HDMI_ID_LEN] = > > + "DP-HDMI ADAPTOR\x04"; > > + > > + return memcmp(hdmi_id, dp_dual_mode_hdmi_id, > > + sizeof(dp_dual_mode_hdmi_id)) == 0; > > +} > > + > > +static bool is_type2_adaptor(uint8_t adaptor_id) > > +{ > > + return adaptor_id == (DP_DUAL_MODE_TYPE_TYPE2 | > > + DP_DUAL_MODE_REV_TYPE2); > > +} > > + > > +/** > > + * drm_dp_dual_mode_detect - Identify the DP dual mode adaptor > > + * adapter: I2C adapter for the DDC bus > > + * > > + * Attempt to identify the type of the DP dual mode adaptor used. > > + * > > + * Note that when the answer is @DRM_DP_DUAL_MODE_NONE it's not > > + * certain whether we're dealing with a native HDMI port or > > + * a type 1 DVI dual mode adaptor. The driver will have to use > > + * some other hardware/driver specific mechanism to make that > > + * distinction. > > + * > > + * Returns: > > + * The type of the DP dual mode adaptor used > > + */ > > +enum drm_dp_dual_mode_type drm_dp_dual_mode_detect(struct i2c_adapter *adapter) > > +{ > > + char hdmi_id[DP_DUAL_MODE_HDMI_ID_LEN] = {}; > > + uint8_t adaptor_id = 0x00; > > + ssize_t ret; > > + > > + /* > > + * Let's see if the adaptor is there the by reading the > > + * HDMI ID registers. > > + * > > + * Note that type 1 DVI adaptors are not required to implemnt > > + * any registers, and that presents a problem for detection. > > + * If the i2c transfer is nacked, we may or may not be dealing > > + * with a type 1 DVI adaptor. Some other mechanism of detecting > > + * the presence of the adaptor is required. One way would be > > + * to check the state of the CONFIG1 pin, Another method would > > + * simply require the driver to know whether the port is a DP++ > > + * port or a native HDMI port. Both of these methods are entirely > > + * hardware/driver specific so we can't deal with them here. > > + */ > > + ret = drm_dp_dual_mode_read(adapter, DP_DUAL_MODE_HDMI_ID, > > + hdmi_id, sizeof(hdmi_id)); > > + if (ret) > > + return DRM_DP_DUAL_MODE_UNKNOWN; > > + > > + /* > > + * Sigh. Some (maybe all?) type 1 adaptors are broken and ack > > + * the offset but ignore it, and instead they just always return > > + * data from the start of the HDMI ID buffer. So for a broken > > + * type 1 HDMI adaptor a single byte read will always give us > > + * 0x44, and for a type 1 DVI adaptor it should give 0x00 > > + * (assuming it implements any registers). Fortunately neither > > + * of those values will match the type 2 signature of the > > + * DP_DUAL_MODE_ADAPTOR_ID register so we can proceed with > > + * the type 2 adaptor detection safely even in the presence > > + * of broken type 1 adaptors. > > + */ > > + ret = drm_dp_dual_mode_read(adapter, DP_DUAL_MODE_ADAPTOR_ID, > > + &adaptor_id, sizeof(adaptor_id)); > can we read all 16 bytes in a single read, and then split the characters > into dongle_signature and adaptor_id ? I think Paulo suggested the same thing more or less. Hmm. Let me think. I'm not sure we want to do that because IIRC the spec says that type 1 HDMI adaptors aren't required to support any registers beyond the HDMI ID, so I'm not sure some of them might not return an error if we try to read more than that, and that could then cause the HDMI ID read fail as well even if it's indeed present. I don't think any of the adaptors I tested behaved that way, but I don't have that many of them here. It's a bit of a shame the i2c subsystem doesn't report the number of bytes succesfully transferred. It just returns the number of messages succesfully transferred. And if a message is only partially transferred, I think we'd just get a negative error code back. > > + if (ret == 0) { > > + if (is_type2_adaptor(adaptor_id) && is_hdmi_adaptor(hdmi_id)) > > + return DRM_DP_DUAL_MODE_TYPE2_HDMI; > > + else if (is_type2_adaptor(adaptor_id)) > > + return DRM_DP_DUAL_MODE_TYPE2_DVI; > can we save one if, or its too late for me to work :) ? > is_type2_adaptor() { > is_hdmi_adaptor() > return type2_hdmi; > else > return type2_dvi > } I wanted to avoid nesting too deeply here. But the line ended up quite long anyway, so I guess the extra indent wouldn't really look any worse than this. > > + } > > + > > + if (is_hdmi_adaptor(hdmi_id)) > > + return DRM_DP_DUAL_MODE_TYPE1_HDMI; > > + else > > + return DRM_DP_DUAL_MODE_TYPE1_DVI; > > +} > > +EXPORT_SYMBOL(drm_dp_dual_mode_detect); > > + > > +/** > > + * drm_dp_dual_mode_max_tmds_clock - Max TMDS clock for DP dual mode adaptor > > + * type: DP dual mode adaptor type > > + * adapter: I2C adapter for the DDC bus > > + * > > + * Determine the max TMDS clock the adaptor supports based on the > > + * type of the dual mode adaptor and the DP_DUAL_MODE_MAX_TMDS_CLOCK > > + * register (on type2 adaptors). As some type 1 adaptors have > > + * problems with registers (see comments in drm_dp_dual_mode_detect()) > > + * we don't read the register on those, instead we simply assume > > + * a 165 MHz limit based on the specification. > > + * > > + * Returns: > > + * Maximum supported TMDS clock rate for the DP dual mode adaptor in kHz. > > + */ > > +int drm_dp_dual_mode_max_tmds_clock(enum drm_dp_dual_mode_type type, > > + struct i2c_adapter *adapter) > > +{ > > + uint8_t max_tmds_clock; > > + ssize_t ret; > > + > > + /* native HDMI so no limit */ > > + if (type == DRM_DP_DUAL_MODE_NONE) > > + return 0; > > + > > + /* > > + * Type 1 adaptors are limited to 165MHz > > + * Type 2 adaptors can tells us their limit > > + */ > > + if (type < DRM_DP_DUAL_MODE_TYPE2_DVI) > > + return 165000; > > + > > + ret = drm_dp_dual_mode_read(adapter, DP_DUAL_MODE_MAX_TMDS_CLOCK, > > + &max_tmds_clock, sizeof(max_tmds_clock)); > > + if (ret || max_tmds_clock == 0x00 || max_tmds_clock == 0xff) > > + return 165000; > > + > > + return max_tmds_clock * 5000 / 2; > > +} > > +EXPORT_SYMBOL(drm_dp_dual_mode_max_tmds_clock); > > + > > +/** > > + * drm_dp_dual_mode_get_tmds_output - Get the state of the TMDS output buffers in the DP dual mode adaptor > > + * type: DP dual mode adaptor type > > + * adapter: I2C adapter for the DDC bus > > + * enabled: current state of the TMDS output buffers > > + * > > + * Get the state of the TMDS output buffers in the adaptor. For > > + * type2 adaptors this is queried from the DP_DUAL_MODE_TMDS_OEN > > + * register. As some type 1 adaptors have problems with registers > > + * (see comments in drm_dp_dual_mode_detect()) we don't read the > > + * register on those, instead we simply assume that the buffers > > + * are always enabled. > > + * > > + * Returns: > > + * 0 on success, negative error code on failure > > + */ > > +int drm_dp_dual_mode_get_tmds_output(enum drm_dp_dual_mode_type type, > > + struct i2c_adapter *adapter, > > + bool *enabled) > > +{ > > + uint8_t tmds_oen; > > + ssize_t ret; > > + > > + if (type < DRM_DP_DUAL_MODE_TYPE2_DVI) { > > + *enabled = true; > > + return 0; > > + } > > + > > + ret = drm_dp_dual_mode_read(adapter, DP_DUAL_MODE_TMDS_OEN, > > + &tmds_oen, sizeof(tmds_oen)); > > + if (ret) > debug message here might help in failure cases. Sure, I can add it. > > + return ret; > > + > > + *enabled = !(tmds_oen & DP_DUAL_MODE_TMDS_DISABLE); > > + > > + return 0; > > +} > > +EXPORT_SYMBOL(drm_dp_dual_mode_get_tmds_output); > > + > > +/** > > + * drm_dp_dual_mode_set_tmds_output - Enable/disable TMDS output buffers in the DP dual mode adaptor > > + * type: DP dual mode adaptor type > > + * adapter: I2C adapter for the DDC bus > > + * enable: enable (as opposed to disable) the TMDS output buffers > > + * > > + * Set the state of the TMDS output buffers in the adaptor. For > > + * type2 this is set via the DP_DUAL_MODE_TMDS_OEN register. As > > + * some type 1 adaptors have problems with registers (see comments > > + * in drm_dp_dual_mode_detect()) we avoid touching the register, > > + * making this function a no-op on type 1 adaptors. > > + * > > + * Returns: > > + * 0 on success, negative error code on failure > > + */ > > +int drm_dp_dual_mode_set_tmds_output(enum drm_dp_dual_mode_type type, > > + struct i2c_adapter *adapter, bool enable) > > +{ > > + uint8_t tmds_oen = enable ? 0 : DP_DUAL_MODE_TMDS_DISABLE; > > + ssize_t ret; > > + > > + if (type < DRM_DP_DUAL_MODE_TYPE2_DVI) > > + return 0; > > + > > + ret = drm_dp_dual_mode_write(adapter, DP_DUAL_MODE_TMDS_OEN, > > + &tmds_oen, sizeof(tmds_oen)); > > + if (ret) > debug message here might help in failure cases. can do. > > + return ret; > > + > > + return 0; > > +} > > +EXPORT_SYMBOL(drm_dp_dual_mode_set_tmds_output); > > + > > +/** > > + * drm_dp_get_dual_mode_type_name - Get the name of the DP dual mode adaptor type as a string > > + * type: DP dual mode adaptor type > > + * > > + * Returns: > > + * String representation of the DP dual mode adaptor type > > + */ > > +const char *drm_dp_get_dual_mode_type_name(enum drm_dp_dual_mode_type type) > > +{ > > + switch (type) { > > + case DRM_DP_DUAL_MODE_NONE: > > + return "none"; > > + case DRM_DP_DUAL_MODE_TYPE1_DVI: > > + return "type 1 DVI"; > > + case DRM_DP_DUAL_MODE_TYPE1_HDMI: > > + return "type 1 HDMI"; > > + case DRM_DP_DUAL_MODE_TYPE2_DVI: > > + return "type 2 DVI"; > > + case DRM_DP_DUAL_MODE_TYPE2_HDMI: > > + return "type 2 HDMI"; > > + default: > > + WARN_ON(type != DRM_DP_DUAL_MODE_UNKNOWN); > do we need a warning here, or a DRM_ERROR should work ? > I am afraid we will show a back-trace for all non-compliant adapters. If someone passes in an invalid type, that's a bug in the caller. So this should never happen. > > + return "unknown"; > > + } > > +} > > +EXPORT_SYMBOL(drm_dp_get_dual_mode_type_name); > > diff --git a/include/drm/drm_dp_dual_mode_helper.h b/include/drm/drm_dp_dual_mode_helper.h > > new file mode 100644 > > index 000000000000..b4603b9fc03d > > --- /dev/null > > +++ b/include/drm/drm_dp_dual_mode_helper.h > > @@ -0,0 +1,83 @@ > > +/* > > + * Copyright � 2016 Intel Corporation > > + * > > + * Permission is hereby granted, free of charge, to any person obtaining a > > + * copy of this software and associated documentation files (the "Software"), > > + * to deal in the Software without restriction, including without limitation > > + * the rights to use, copy, modify, merge, publish, distribute, sublicense, > > + * and/or sell copies of the Software, and to permit persons to whom the > > + * Software is furnished to do so, subject to the following conditions: > > + * > > + * The above copyright notice and this permission notice shall be included in > > + * all copies or substantial portions of the Software. > > + * > > + * 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 COPYRIGHT HOLDER(S) OR AUTHOR(S) 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. > > + */ > > + > > +#ifndef DRM_DP_DUAL_MODE_HELPER_H > > +#define DRM_DP_DUAL_MODE_HELPER_H > > + > > +#include > > + > > +/* > > + * Optional for type 1 DVI adaptors > > + * Mandatory for type 1 HDMI and type 2 adators > > + */ > > +#define DP_DUAL_MODE_HDMI_ID 0x00 /* 00-0f */ > > +#define DP_DUAL_MODE_HDMI_ID_LEN 16 > > +/* > > + * Optional for type 1 adaptors > > + * Mandatory for type 2 adators > > + */ > > +#define DP_DUAL_MODE_ADAPTOR_ID 0x10 > > +#define DP_DUAL_MODE_REV_MASK 0x07 > > +#define DP_DUAL_MODE_REV_TYPE2 0x00 > > +#define DP_DUAL_MODE_TYPE_MASK 0xf0 > > +#define DP_DUAL_MODE_TYPE_TYPE2 0xa0 > > +#define DP_DUAL_MODE_IEEE_OUI 0x11 /* 11-13*/ > > +#define DP_DUAL_IEEE_OUI_LEN 3 > > +#define DP_DUAL_DEVICE_ID 0x14 /* 14-19 */ > > +#define DP_DUAL_DEVICE_ID_LEN 6 > > +#define DP_DUAL_MODE_HARDWARE_REV 0x1a > > +#define DP_DUAL_MODE_FIRMWARE_MAJOR_REV 0x1b > > +#define DP_DUAL_MODE_FIRMWARE_MINOR_REV 0x1c > > +#define DP_DUAL_MODE_MAX_TMDS_CLOCK 0x1d > > +#define DP_DUAL_MODE_I2C_SPEED_CAP 0x1e > > +#define DP_DUAL_MODE_TMDS_OEN 0x20 > > +#define DP_DUAL_MODE_TMDS_DISABLE 0x01 > > +#define DP_DUAL_MODE_HDMI_PIN_CTRL 0x21 > > +#define DP_DUAL_MODE_CEC_ENABLE 0x01 > > +#define DP_DUAL_MODE_I2C_SPEED_CTRL 0x22 > > + > > +struct i2c_adapter; > > + > > +ssize_t drm_dp_dual_mode_read(struct i2c_adapter *adapter, > > + u8 offset, void *buffer, size_t size); > > +ssize_t drm_dp_dual_mode_write(struct i2c_adapter *adapter, > > + u8 offset, const void *buffer, size_t size); > > + > > +enum drm_dp_dual_mode_type { > > + DRM_DP_DUAL_MODE_NONE, > what does dual mode none indicate (considering we have an unknown case > below) ? It mean we know that there is no dual mode adaptor, meaning we're dealing with a native HDMI port. Originally I had just the NONE, but Paulo requested that we make the UNKNOWN case more explicit so I split it into two. It's always the driver's responsibility to refine the detection result to NONE or TYPE1_DVI if drm_dp_dual_mode_detect() returns UNKNOWN. > Regards > Shashank > > + DRM_DP_DUAL_MODE_UNKNOWN, > > + DRM_DP_DUAL_MODE_TYPE1_DVI, > > + DRM_DP_DUAL_MODE_TYPE1_HDMI, > > + DRM_DP_DUAL_MODE_TYPE2_DVI, > > + DRM_DP_DUAL_MODE_TYPE2_HDMI, > > +}; > > + > > +enum drm_dp_dual_mode_type drm_dp_dual_mode_detect(struct i2c_adapter *adapter); > > +int drm_dp_dual_mode_max_tmds_clock(enum drm_dp_dual_mode_type type, > > + struct i2c_adapter *adapter); > > +int drm_dp_dual_mode_get_tmds_output(enum drm_dp_dual_mode_type type, > > + struct i2c_adapter *adapter, bool *enabled); > > +int drm_dp_dual_mode_set_tmds_output(enum drm_dp_dual_mode_type type, > > + struct i2c_adapter *adapter, bool enable); > > +const char *drm_dp_get_dual_mode_type_name(enum drm_dp_dual_mode_type type); > > + > > +#endif > > -- Ville Syrj�l� Intel OTC