From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jani Nikula Subject: Re: [Intel-gfx] [PATCH v2 1/4] drm: Add helper for DP++ adaptors Date: Tue, 03 May 2016 10:46:26 +0300 Message-ID: <87lh3rfust.fsf@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> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1462216105-20881-2-git-send-email-ville.syrjala@linux.intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: ville.syrjala@linux.intel.com, dri-devel@lists.freedesktop.org Cc: Daniel Vetter , intel-gfx@lists.freedesktop.org, Tore Anderson , Paulo Zanoni , stable@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org T24gTW9uLCAwMiBNYXkgMjAxNiwgdmlsbGUuc3lyamFsYUBsaW51eC5pbnRlbC5jb20gd3JvdGU6 Cj4gRnJvbTogVmlsbGUgU3lyasOkbMOkIDx2aWxsZS5zeXJqYWxhQGxpbnV4LmludGVsLmNvbT4K Pgo+IEFkZCBhIGhlbHBlciB3aGljaCBhaWRzIGluIHRoZSBpZGVudGlmaWNhdGlvbiBvZiBEUCBk dWFsIG1vZGUKPiAoYWthLiBEUCsrKSBhZGFwdG9ycy4gVGhlcmUgYXJlIHNldmVyYWwgdHlwZXMg b2YgYWRhcHRvcnMKPiBzcGVjaWZpZWQ6IHR5cGUgMSBEVkksIHR5cGUgMSBIRE1JLCB0eXBlIDIg RFZJLCB0eXBlIDIgSERNSQo+Cj4gVHlwZSAxIGFkYXB0b3JzIGhhdmUgYSBtYXggVE1EUyBjbG9j ayBsaW1pdCBvZiAxNjVNSHosIHR5cGUgMiBhZGFwdG9ycwo+IG1heSBnbyBhcyBoaWdoIGFzIDMw ME1IeiBhbmQgdGhleSBwcm92aWRlIGEgcmVnaXN0ZXIgaW5mb3JtaW5nIHRoZQo+IHNvdXJjZSBk ZXZpY2Ugd2hhdCB0aGUgYWN0dWFsIGxpbWl0IGlzLiBTdXBwb3NlZGx5IGFsc28gdHlwZSAxIGFk YXB0b3JzCj4gbWF5IG9wdGlvbmFsbHkgaW1wbGVtZW50IHRoaXMgcmVnaXN0ZXIuIFRoaXMgVE1E UyBjbG9jayBsaW1pdCBpcyB0aGUKPiBtYWluIHJlYXNvbiB3aHkgd2UgbmVlZCB0byBpZGVudGlm eSB0aGVzZSBhZGFwdG9ycy4KPgo+IFR5cGUgMSBhZGFwdG9ycyBwcm92aWRlIGFjY2VzcyB0byB0 aGVpciBpbnRlcm5hbCByZWdpc3RlcnMgYW5kIHRoZSBzaW5rCj4gRERDIGJ1cyB0aHJvdWdoIEky Qy4gVHlwZSAyIGFkYXB0b3JzIHByb3ZpZGUgdGhpcyBhY2Nlc3MgYm90aCB2aWEgSTJDCj4gYW5k IEkyQy1vdmVyLUFVWC4gQSB0eXBlIDIgc291cmNlIGRldmljZSBtYXkgY2hvb3NlIHRvIGltcGxl bWVudCBlaXRoZXIKPiBvZiB0aGVzZSBtZXRob2RzLiBJZiBhIHNvdXJjZSBkZXZpY2UgaW1wbGVt ZW50cyB0aGUgSTJDLW92ZXItQVVYCj4gbWV0aG9kLCB0aGVuIHRoZSBkcml2ZXIgd2lsbCBvYnZp b3VzbHkgbmVlZCBzcGVjaWZpYyBzdXBwb3J0IGZvciBzdWNoCj4gYWRhcHRvcnMgc2luY2UgdGhl IHBvcnQgaXMgZHJpdmVuIGxpa2UgYW4gSERNSSBwb3J0LCBidXQgRERDCj4gY29tbXVuaWNhdGlv biBoYXBwZXMgb3ZlciB0aGUgQVVYIGNoYW5uZWwuCj4KPiBUaGlzIGhlbHBlciBzaG91bGQgYmUg ZW5vdWdoIHRvIGlkZW50aWZ5IHRoZSBhZGFwdG9yIHR5cGUgKHNvbWUKPiB0eXBlIDEgRFZJIGFk YXB0b3JzIG1heSBiZSBhIHNsaWdodCBleGNlcHRpb24pIGFuZCB0aGUgbWF4aW11bSBUTURTCj4g Y2xvY2sgbGltaXQuIEFub3RoZXIgZmVhdHVyZSB0aGF0IG1heSBiZSBhdmFpbGFibGUgaXMgY29u dHJvbCBvdmVyCj4gdGhlIFRNRFMgb3V0cHV0IGJ1ZmZlcnMgb24gdGhlIGFkYXB0b3IsIHBvc3Np Ymx5IGFsbG93aW5nIGZvciBzb21lCj4gcG93ZXIgc2F2aW5nIHdoZW4gdGhlIFRNRFMgbGluayBp cyBkb3duLgo+Cj4gT3RoZXIgdXNlciBjb250cm9sbGFibGUgZmVhdHVyZXMgdGhhdCBtYXkgYmUg YXZhaWxhYmxlIGluIHRoZSBhZGFwdG9ycwo+IGFyZSBkb3duc3RyZWFtIGkyYyBidXMgc3BlZWQg Y29udHJvbCB3aGVuIHVzaW5nIGkyYy1vdmVyLWF1eCwgYW5kCj4gc29tZSBjb250cm9sIG92ZXIg dGhlIENFQyBwaW4uIEkgY2hvc2Ugbm90IHRvIHByb3ZpZGUgYW55IGhlbHBlcgo+IGZ1bmN0aW9u cyBmb3IgdGhvc2Ugc2luY2UgSSBoYXZlIG5vIHVzZSBmb3IgdGhlbSBpbiBpOTE1IGF0IHRoaXMg dGltZS4KPiBUaGUgcmVzdCBvZiB0aGUgcmVnaXN0ZXJzIGluIHRoZSBhZGFwdG9yIGFyZSBtb3N0 bHkganVzdCBpbmZvcm1hdGlvbiwKPiBlZy4gSUVFRSBPVUksIGhhcmR3YXJlIGFuZCBmaXJtd2Fy ZSByZXZpc2lvbiwgZXRjLgo+Cj4gdjI6IFBhc3MgYWRhcHRvciB0eXBlIHRvIGhlbHBlciBmdW5j dGlvbnMgdG8gZWFzZSBkcml2ZXIgaW1wbGVtZW50YXRpb24KPiAgICAgRml4IGEgYnVuY2ggb2Yg dHlwb2VzIChQYXVsbykKPiAgICAgQWRkIERSTV9EUF9EVUFMX01PREVfVU5LTk9XTiBmb3IgdGhl IGNhc2Ugd2hlcmUgd2UgZG9uJ3QgKHlldCkga25vdwo+ICAgICB0aGUgdHlwZSAoUGF1bG8pCj4g ICAgIFJlamVjdCAweDAwIGFuZCAweGZmIERQX0RVQUxfTU9ERV9NQVhfVE1EU19DTE9DSyB2YWx1 ZXMgKFBhdWxvKQo+ICAgICBBZGp1c3QgZHJtX2RwX2R1YWxfbW9kZV9kZXRlY3QoKSB0eXBlMiB2 cy4gdHlwZTEgZGV0ZWN0aW9uIHRvCj4gICAgIGVhc2UgZnV0dXJlIExTUENPTiBlbmFibGluZwo+ ICAgICBSZW1vdmUgdGhlIHVudXNlZCBEUF9EVUFMX01PREVfTEFTVF9SRVNFUlZFRCBkZWZpbmUK Pgo+IENjOiBzdGFibGVAdmdlci5rZXJuZWwub3JnCj4gQ2M6IFRvcmUgQW5kZXJzb24gPHRvcmVA ZnVkLm5vPgo+IENjOiBQYXVsbyBaYW5vbmkgPHBhdWxvLnIuemFub25pQGludGVsLmNvbT4KPiBD YzogU2hhc2hhbmsgU2hhcm1hIDxzaGFzaGFuay5zaGFybWFAaW50ZWwuY29tPgo+IENjOiBEYW5p ZWwgVmV0dGVyIDxkYW5pZWwudmV0dGVyQGZmd2xsLmNoPgo+IFNpZ25lZC1vZmYtYnk6IFZpbGxl IFN5cmrDpGzDpCA8dmlsbGUuc3lyamFsYUBsaW51eC5pbnRlbC5jb20+Cj4gLS0tCj4gIGRyaXZl cnMvZ3B1L2RybS9NYWtlZmlsZSAgICAgICAgICAgICAgICAgIHwgICAyICstCj4gIGRyaXZlcnMv Z3B1L2RybS9kcm1fZHBfZHVhbF9tb2RlX2hlbHBlci5jIHwgMzU2ICsrKysrKysrKysrKysrKysr KysrKysrKysrKysrKwo+ICBpbmNsdWRlL2RybS9kcm1fZHBfZHVhbF9tb2RlX2hlbHBlci5oICAg ICB8ICA4MyArKysrKysrCj4gIDMgZmlsZXMgY2hhbmdlZCwgNDQwIGluc2VydGlvbnMoKyksIDEg ZGVsZXRpb24oLSkKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS9kcm1fZHBf ZHVhbF9tb2RlX2hlbHBlci5jCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBpbmNsdWRlL2RybS9kcm1f ZHBfZHVhbF9tb2RlX2hlbHBlci5oCj4KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL01h a2VmaWxlIGIvZHJpdmVycy9ncHUvZHJtL01ha2VmaWxlCj4gaW5kZXggMWEyNmI0ZWIxY2UwLi4y OWYyZWU5Yjk1MzQgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL01ha2VmaWxlCj4gKysr IGIvZHJpdmVycy9ncHUvZHJtL01ha2VmaWxlCj4gQEAgLTIzLDcgKzIzLDcgQEAgZHJtLSQoQ09O RklHX0FHUCkgKz0gZHJtX2FncHN1cHBvcnQubwo+ICAKPiAgZHJtX2ttc19oZWxwZXIteSA6PSBk cm1fY3J0Y19oZWxwZXIubyBkcm1fZHBfaGVscGVyLm8gZHJtX3Byb2JlX2hlbHBlci5vIFwKPiAg CQlkcm1fcGxhbmVfaGVscGVyLm8gZHJtX2RwX21zdF90b3BvbG9neS5vIGRybV9hdG9taWNfaGVs cGVyLm8gXAo+IC0JCWRybV9rbXNfaGVscGVyX2NvbW1vbi5vCj4gKwkJZHJtX2ttc19oZWxwZXJf Y29tbW9uLm8gZHJtX2RwX2R1YWxfbW9kZV9oZWxwZXIubwo+ICAKPiAgZHJtX2ttc19oZWxwZXIt JChDT05GSUdfRFJNX0xPQURfRURJRF9GSVJNV0FSRSkgKz0gZHJtX2VkaWRfbG9hZC5vCj4gIGRy bV9rbXNfaGVscGVyLSQoQ09ORklHX0RSTV9GQkRFVl9FTVVMQVRJT04pICs9IGRybV9mYl9oZWxw ZXIubwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2RwX2R1YWxfbW9kZV9oZWxw ZXIuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fZHBfZHVhbF9tb2RlX2hlbHBlci5jCj4gbmV3IGZp bGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAuLjk0OWMwZmJlYjU0Mgo+IC0tLSAv ZGV2L251bGwKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2RwX2R1YWxfbW9kZV9oZWxwZXIu Ywo+IEBAIC0wLDAgKzEsMzU2IEBACj4gKy8qCj4gKyAqIENvcHlyaWdodCDCqSAyMDE2IEludGVs IENvcnBvcmF0aW9uCj4gKyAqCj4gKyAqIFBlcm1pc3Npb24gaXMgaGVyZWJ5IGdyYW50ZWQsIGZy ZWUgb2YgY2hhcmdlLCB0byBhbnkgcGVyc29uIG9idGFpbmluZyBhCj4gKyAqIGNvcHkgb2YgdGhp cyBzb2Z0d2FyZSBhbmQgYXNzb2NpYXRlZCBkb2N1bWVudGF0aW9uIGZpbGVzICh0aGUgIlNvZnR3 YXJlIiksCj4gKyAqIHRvIGRlYWwgaW4gdGhlIFNvZnR3YXJlIHdpdGhvdXQgcmVzdHJpY3Rpb24s IGluY2x1ZGluZyB3aXRob3V0IGxpbWl0YXRpb24KPiArICogdGhlIHJpZ2h0cyB0byB1c2UsIGNv cHksIG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1dGUsIHN1YmxpY2Vuc2UsCj4gKyAq IGFuZC9vciBzZWxsIGNvcGllcyBvZiB0aGUgU29mdHdhcmUsIGFuZCB0byBwZXJtaXQgcGVyc29u cyB0byB3aG9tIHRoZQo+ICsgKiBTb2Z0d2FyZSBpcyBmdXJuaXNoZWQgdG8gZG8gc28sIHN1Ympl Y3QgdG8gdGhlIGZvbGxvd2luZyBjb25kaXRpb25zOgo+ICsgKgo+ICsgKiBUaGUgYWJvdmUgY29w eXJpZ2h0IG5vdGljZSBhbmQgdGhpcyBwZXJtaXNzaW9uIG5vdGljZSBzaGFsbCBiZSBpbmNsdWRl ZCBpbgo+ICsgKiBhbGwgY29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRpb25zIG9mIHRoZSBTb2Z0 d2FyZS4KPiArICoKPiArICogVEhFIFNPRlRXQVJFIElTIFBST1ZJREVEICJBUyBJUyIsIFdJVEhP VVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsIEVYUFJFU1MgT1IKPiArICogSU1QTElFRCwgSU5DTFVE SU5HIEJVVCBOT1QgTElNSVRFRCBUTyBUSEUgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFks Cj4gKyAqIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFORCBOT05JTkZSSU5HRU1F TlQuICBJTiBOTyBFVkVOVCBTSEFMTAo+ICsgKiBUSEUgQ09QWVJJR0hUIEhPTERFUihTKSBPUiBB VVRIT1IoUykgQkUgTElBQkxFIEZPUiBBTlkgQ0xBSU0sIERBTUFHRVMgT1IKPiArICogT1RIRVIg TElBQklMSVRZLCBXSEVUSEVSIElOIEFOIEFDVElPTiBPRiBDT05UUkFDVCwgVE9SVCBPUiBPVEhF UldJU0UsCj4gKyAqIEFSSVNJTkcgRlJPTSwgT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBU SEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUgo+ICsgKiBPVEhFUiBERUFMSU5HUyBJTiBUSEUgU09G VFdBUkUuCj4gKyAqLwo+ICsKPiArI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+Cj4gKyNpbmNsdWRl IDxsaW51eC9leHBvcnQuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2kyYy5oPgo+ICsjaW5jbHVkZSA8 bGludXgvc2xhYi5oPgo+ICsjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+Cj4gKyNpbmNsdWRlIDxk cm0vZHJtX2RwX2R1YWxfbW9kZV9oZWxwZXIuaD4KPiArI2luY2x1ZGUgPGRybS9kcm1QLmg+Cj4g Kwo+ICsvKioKPiArICogRE9DOiBEUCBkdWFsIG1vZGUgKGFrYS4gRFArKykgYWRhcHRvciBoZWxw ZXJzCj4gKyAqCj4gKyAqIEhlbHBlciBmdW5jdGlvbnMgdG8gZGVhbCB3aXRoIERQIGR1YWwgbW9k ZSBhZGFwdG9ycy4KPiArICoKPiArICogVHlwZSAxOgo+ICsgKiBBZGFwdG9yIHJlZ2lzdGVycyAo aWYgYW55KSBhbmQgdGhlIHNpbmsgRERDIGJ1cyBtYXkgYmUgYWNjZXNzZWQgdmlhIEkyQy4KPiAr ICoKPiArICogVHlwZSAyOgo+ICsgKiBBZGFwdG9yIHJlZ2lzdGVycyBhbmQgc2luayBEREMgYnVz IGNhbiBiZSBhY2Nlc3NlZCBlaXRoZXIgdmlhIEkyQyBvcgo+ICsgKiBJMkMtb3Zlci1BVVguIFNv dXJjZSBkZXZpY2VzIG1heSBjaG9vc2UgdG8gaW1wbGVtZW50IGVpdGhlciBvZiB0aGVzZQo+ICsg KiBhY2Nlc3MgbWV0aG9kcy4KPiArICovCj4gKwo+ICsjZGVmaW5lIERQX0RVQUxfTU9ERV9TTEFW RV9BRERSRVNTIDB4NDAKPiArCj4gKy8qKgo+ICsgKiBkcm1fZHBfZHVhbF9tb2RlX3JlYWQgLSBS ZWFkIGZyb20gdGhlIERQIGR1YWwgbW9kZSBhZGFwdG9yIHJlZ2lzdGVyKHMpCj4gKyAqIGFkYXB0 ZXI6IEkyQyBhZGFwdGVyIGZvciB0aGUgRERDIGJ1cwo+ICsgKiBvZmZzZXQ6IHJlZ2lzdGVyIG9m ZnNldAo+ICsgKiBidWZmZXI6IGJ1ZmZlciBmb3IgcmV0dXJuIGRhdGEKPiArICogc2l6ZTogc2l6 byBvZiB0aGUgYnVmZmVyCgpUaGUgcGFyYW1ldGVycyBuZWVkIHRvIGJlIHByZWZpeGVkIHdpdGgg QCBpbiBrZXJuZWwtZG9jLiBTYW1lIGFjcm9zcyB0aGUKcGF0Y2ggc2VyaWVzLgoKQlIsCkphbmku CgoKPiArICoKPiArICogUmVhZHMgQHNpemUgYnl0ZXMgZnJvbSB0aGUgRFAgZHVhbCBtb2RlIGFk YXB0b3IgcmVnaXN0ZXJzCj4gKyAqIHN0YXJ0aW5nIGF0IEBvZmZzZXQuCj4gKyAqCj4gKyAqIFJl dHVybnM6Cj4gKyAqIDAgb24gc3VjY2VzcywgbmVnYXRpdmUgZXJyb3IgY29kZSBvbiBmYWlsdXJl Cj4gKyAqLwo+ICtzc2l6ZV90IGRybV9kcF9kdWFsX21vZGVfcmVhZChzdHJ1Y3QgaTJjX2FkYXB0 ZXIgKmFkYXB0ZXIsCj4gKwkJCSAgICAgIHU4IG9mZnNldCwgdm9pZCAqYnVmZmVyLCBzaXplX3Qg c2l6ZSkKPiArewo+ICsJc3RydWN0IGkyY19tc2cgbXNnc1tdID0gewo+ICsJCXsKPiArCQkJLmFk ZHIgPSBEUF9EVUFMX01PREVfU0xBVkVfQUREUkVTUywKPiArCQkJLmZsYWdzID0gMCwKPiArCQkJ LmxlbiA9IDEsCj4gKwkJCS5idWYgPSAmb2Zmc2V0LAo+ICsJCX0sCj4gKwkJewo+ICsJCQkuYWRk ciA9IERQX0RVQUxfTU9ERV9TTEFWRV9BRERSRVNTLAo+ICsJCQkuZmxhZ3MgPSBJMkNfTV9SRCwK PiArCQkJLmxlbiA9IHNpemUsCj4gKwkJCS5idWYgPSBidWZmZXIsCj4gKwkJfSwKPiArCX07Cj4g KwlpbnQgcmV0Owo+ICsKPiArCXJldCA9IGkyY190cmFuc2ZlcihhZGFwdGVyLCBtc2dzLCBBUlJB WV9TSVpFKG1zZ3MpKTsKPiArCWlmIChyZXQgPCAwKQo+ICsJCXJldHVybiByZXQ7Cj4gKwlpZiAo cmV0ICE9IEFSUkFZX1NJWkUobXNncykpCj4gKwkJcmV0dXJuIC1FUFJPVE87Cj4gKwo+ICsJcmV0 dXJuIDA7Cj4gK30KPiArCj4gKy8qKgo+ICsgKiBkcm1fZHBfZHVhbF9tb2RlX3dyaXRlIC0gV3Jp dGUgdG8gdGhlIERQIGR1YWwgbW9kZSBhZGFwdG9yIHJlZ2lzdGVyKHMpCj4gKyAqIGFkYXB0ZXI6 IEkyQyBhZGFwdGVyIGZvciB0aGUgRERDIGJ1cwo+ICsgKiBvZmZzZXQ6IHJlZ2lzdGVyIG9mZnNl dAo+ICsgKiBidWZmZXI6IGJ1ZmZlciBmb3Igd3JpdGUgZGF0YQo+ICsgKiBzaXplOiBzaXpvIG9m IHRoZSBidWZmZXIKPiArICoKPiArICogV3JpdGVzIEBzaXplIGJ5dGVzIHRvIHRoZSBEUCBkdWFs IG1vZGUgYWRhcHRvciByZWdpc3RlcnMKPiArICogc3RhcnRpbmcgYXQgQG9mZnNldC4KPiArICoK PiArICogUmV0dXJuczoKPiArICogMCBvbiBzdWNjZXNzLCBuZWdhdGl2ZSBlcnJvciBjb2RlIG9u IGZhaWx1cmUKPiArICovCj4gK3NzaXplX3QgZHJtX2RwX2R1YWxfbW9kZV93cml0ZShzdHJ1Y3Qg aTJjX2FkYXB0ZXIgKmFkYXB0ZXIsCj4gKwkJCSAgICAgICB1OCBvZmZzZXQsIGNvbnN0IHZvaWQg KmJ1ZmZlciwgc2l6ZV90IHNpemUpCj4gK3sKPiArCXN0cnVjdCBpMmNfbXNnIG1zZyA9IHsKPiAr CQkuYWRkciA9IERQX0RVQUxfTU9ERV9TTEFWRV9BRERSRVNTLAo+ICsJCS5mbGFncyA9IDAsCj4g KwkJLmxlbiA9IDEgKyBzaXplLAo+ICsJCS5idWYgPSBOVUxMLAo+ICsJfTsKPiArCXZvaWQgKmRh dGE7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCWRhdGEgPSBrbWFsbG9jKG1zZy5sZW4sIEdGUF9URU1Q T1JBUlkpOwo+ICsJaWYgKCFkYXRhKQo+ICsJCXJldHVybiAtRU5PTUVNOwo+ICsKPiArCW1zZy5i dWYgPSBkYXRhOwo+ICsKPiArCW1lbWNweShkYXRhLCAmb2Zmc2V0LCAxKTsKPiArCW1lbWNweShk YXRhICsgMSwgYnVmZmVyLCBzaXplKTsKPiArCj4gKwlyZXQgPSBpMmNfdHJhbnNmZXIoYWRhcHRl ciwgJm1zZywgMSk7Cj4gKwo+ICsJa2ZyZWUoZGF0YSk7Cj4gKwo+ICsJaWYgKHJldCA8IDApCj4g KwkJcmV0dXJuIHJldDsKPiArCWlmIChyZXQgIT0gMSkKPiArCQlyZXR1cm4gLUVQUk9UTzsKPiAr Cj4gKwlyZXR1cm4gMDsKPiArfQo+ICtFWFBPUlRfU1lNQk9MKGRybV9kcF9kdWFsX21vZGVfd3Jp dGUpOwo+ICsKPiArc3RhdGljIGJvb2wgaXNfaGRtaV9hZGFwdG9yKGNvbnN0IGNoYXIgaGRtaV9p ZFtEUF9EVUFMX01PREVfSERNSV9JRF9MRU5dKQo+ICt7Cj4gKwlzdGF0aWMgY29uc3QgY2hhciBk cF9kdWFsX21vZGVfaGRtaV9pZFtEUF9EVUFMX01PREVfSERNSV9JRF9MRU5dID0KPiArCQkiRFAt SERNSSBBREFQVE9SXHgwNCI7Cj4gKwo+ICsJcmV0dXJuIG1lbWNtcChoZG1pX2lkLCBkcF9kdWFs X21vZGVfaGRtaV9pZCwKPiArCQkgICAgICBzaXplb2YoZHBfZHVhbF9tb2RlX2hkbWlfaWQpKSA9 PSAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgYm9vbCBpc190eXBlMl9hZGFwdG9yKHVpbnQ4X3QgYWRh cHRvcl9pZCkKPiArewo+ICsJcmV0dXJuIGFkYXB0b3JfaWQgPT0gKERQX0RVQUxfTU9ERV9UWVBF X1RZUEUyIHwKPiArCQkJICAgICAgRFBfRFVBTF9NT0RFX1JFVl9UWVBFMik7Cj4gK30KPiArCj4g Ky8qKgo+ICsgKiBkcm1fZHBfZHVhbF9tb2RlX2RldGVjdCAtIElkZW50aWZ5IHRoZSBEUCBkdWFs IG1vZGUgYWRhcHRvcgo+ICsgKiBhZGFwdGVyOiBJMkMgYWRhcHRlciBmb3IgdGhlIEREQyBidXMK PiArICoKPiArICogQXR0ZW1wdCB0byBpZGVudGlmeSB0aGUgdHlwZSBvZiB0aGUgRFAgZHVhbCBt b2RlIGFkYXB0b3IgdXNlZC4KPiArICoKPiArICogTm90ZSB0aGF0IHdoZW4gdGhlIGFuc3dlciBp cyBARFJNX0RQX0RVQUxfTU9ERV9OT05FIGl0J3Mgbm90Cj4gKyAqIGNlcnRhaW4gd2hldGhlciB3 ZSdyZSBkZWFsaW5nIHdpdGggYSBuYXRpdmUgSERNSSBwb3J0IG9yCj4gKyAqIGEgdHlwZSAxIERW SSBkdWFsIG1vZGUgYWRhcHRvci4gVGhlIGRyaXZlciB3aWxsIGhhdmUgdG8gdXNlCj4gKyAqIHNv bWUgb3RoZXIgaGFyZHdhcmUvZHJpdmVyIHNwZWNpZmljIG1lY2hhbmlzbSB0byBtYWtlIHRoYXQK PiArICogZGlzdGluY3Rpb24uCj4gKyAqCj4gKyAqIFJldHVybnM6Cj4gKyAqIFRoZSB0eXBlIG9m IHRoZSBEUCBkdWFsIG1vZGUgYWRhcHRvciB1c2VkCj4gKyAqLwo+ICtlbnVtIGRybV9kcF9kdWFs X21vZGVfdHlwZSBkcm1fZHBfZHVhbF9tb2RlX2RldGVjdChzdHJ1Y3QgaTJjX2FkYXB0ZXIgKmFk YXB0ZXIpCj4gK3sKPiArCWNoYXIgaGRtaV9pZFtEUF9EVUFMX01PREVfSERNSV9JRF9MRU5dID0g e307Cj4gKwl1aW50OF90IGFkYXB0b3JfaWQgPSAweDAwOwo+ICsJc3NpemVfdCByZXQ7Cj4gKwo+ ICsJLyoKPiArCSAqIExldCdzIHNlZSBpZiB0aGUgYWRhcHRvciBpcyB0aGVyZSB0aGUgYnkgcmVh ZGluZyB0aGUKPiArCSAqIEhETUkgSUQgcmVnaXN0ZXJzLgo+ICsJICoKPiArCSAqIE5vdGUgdGhh dCB0eXBlIDEgRFZJIGFkYXB0b3JzIGFyZSBub3QgcmVxdWlyZWQgdG8gaW1wbGVtbnQKPiArCSAq IGFueSByZWdpc3RlcnMsIGFuZCB0aGF0IHByZXNlbnRzIGEgcHJvYmxlbSBmb3IgZGV0ZWN0aW9u Lgo+ICsJICogSWYgdGhlIGkyYyB0cmFuc2ZlciBpcyBuYWNrZWQsIHdlIG1heSBvciBtYXkgbm90 IGJlIGRlYWxpbmcKPiArCSAqIHdpdGggYSB0eXBlIDEgRFZJIGFkYXB0b3IuIFNvbWUgb3RoZXIg bWVjaGFuaXNtIG9mIGRldGVjdGluZwo+ICsJICogdGhlIHByZXNlbmNlIG9mIHRoZSBhZGFwdG9y IGlzIHJlcXVpcmVkLiBPbmUgd2F5IHdvdWxkIGJlCj4gKwkgKiB0byBjaGVjayB0aGUgc3RhdGUg b2YgdGhlIENPTkZJRzEgcGluLCBBbm90aGVyIG1ldGhvZCB3b3VsZAo+ICsJICogc2ltcGx5IHJl cXVpcmUgdGhlIGRyaXZlciB0byBrbm93IHdoZXRoZXIgdGhlIHBvcnQgaXMgYSBEUCsrCj4gKwkg KiBwb3J0IG9yIGEgbmF0aXZlIEhETUkgcG9ydC4gQm90aCBvZiB0aGVzZSBtZXRob2RzIGFyZSBl bnRpcmVseQo+ICsJICogaGFyZHdhcmUvZHJpdmVyIHNwZWNpZmljIHNvIHdlIGNhbid0IGRlYWwg d2l0aCB0aGVtIGhlcmUuCj4gKwkgKi8KPiArCXJldCA9IGRybV9kcF9kdWFsX21vZGVfcmVhZChh ZGFwdGVyLCBEUF9EVUFMX01PREVfSERNSV9JRCwKPiArCQkJCSAgICBoZG1pX2lkLCBzaXplb2Yo aGRtaV9pZCkpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gRFJNX0RQX0RVQUxfTU9ERV9VTktO T1dOOwo+ICsKPiArCS8qCj4gKwkgKiBTaWdoLiBTb21lIChtYXliZSBhbGw/KSB0eXBlIDEgYWRh cHRvcnMgYXJlIGJyb2tlbiBhbmQgYWNrCj4gKwkgKiB0aGUgb2Zmc2V0IGJ1dCBpZ25vcmUgaXQs IGFuZCBpbnN0ZWFkIHRoZXkganVzdCBhbHdheXMgcmV0dXJuCj4gKwkgKiBkYXRhIGZyb20gdGhl IHN0YXJ0IG9mIHRoZSBIRE1JIElEIGJ1ZmZlci4gU28gZm9yIGEgYnJva2VuCj4gKwkgKiB0eXBl IDEgSERNSSBhZGFwdG9yIGEgc2luZ2xlIGJ5dGUgcmVhZCB3aWxsIGFsd2F5cyBnaXZlIHVzCj4g KwkgKiAweDQ0LCBhbmQgZm9yIGEgdHlwZSAxIERWSSBhZGFwdG9yIGl0IHNob3VsZCBnaXZlIDB4 MDAKPiArCSAqIChhc3N1bWluZyBpdCBpbXBsZW1lbnRzIGFueSByZWdpc3RlcnMpLiBGb3J0dW5h dGVseSBuZWl0aGVyCj4gKwkgKiBvZiB0aG9zZSB2YWx1ZXMgd2lsbCBtYXRjaCB0aGUgdHlwZSAy IHNpZ25hdHVyZSBvZiB0aGUKPiArCSAqIERQX0RVQUxfTU9ERV9BREFQVE9SX0lEIHJlZ2lzdGVy IHNvIHdlIGNhbiBwcm9jZWVkIHdpdGgKPiArCSAqIHRoZSB0eXBlIDIgYWRhcHRvciBkZXRlY3Rp b24gc2FmZWx5IGV2ZW4gaW4gdGhlIHByZXNlbmNlCj4gKwkgKiBvZiBicm9rZW4gdHlwZSAxIGFk YXB0b3JzLgo+ICsJICovCj4gKwlyZXQgPSBkcm1fZHBfZHVhbF9tb2RlX3JlYWQoYWRhcHRlciwg RFBfRFVBTF9NT0RFX0FEQVBUT1JfSUQsCj4gKwkJCQkgICAgJmFkYXB0b3JfaWQsIHNpemVvZihh ZGFwdG9yX2lkKSk7Cj4gKwlpZiAocmV0ID09IDApIHsKPiArCQlpZiAoaXNfdHlwZTJfYWRhcHRv cihhZGFwdG9yX2lkKSAmJiBpc19oZG1pX2FkYXB0b3IoaGRtaV9pZCkpCj4gKwkJCXJldHVybiBE Uk1fRFBfRFVBTF9NT0RFX1RZUEUyX0hETUk7Cj4gKwkJZWxzZSBpZiAoaXNfdHlwZTJfYWRhcHRv cihhZGFwdG9yX2lkKSkKPiArCQkJcmV0dXJuIERSTV9EUF9EVUFMX01PREVfVFlQRTJfRFZJOwo+ ICsJfQo+ICsKPiArCWlmIChpc19oZG1pX2FkYXB0b3IoaGRtaV9pZCkpCj4gKwkJcmV0dXJuIERS TV9EUF9EVUFMX01PREVfVFlQRTFfSERNSTsKPiArCWVsc2UKPiArCQlyZXR1cm4gRFJNX0RQX0RV QUxfTU9ERV9UWVBFMV9EVkk7Cj4gK30KPiArRVhQT1JUX1NZTUJPTChkcm1fZHBfZHVhbF9tb2Rl X2RldGVjdCk7Cj4gKwo+ICsvKioKPiArICogZHJtX2RwX2R1YWxfbW9kZV9tYXhfdG1kc19jbG9j ayAtIE1heCBUTURTIGNsb2NrIGZvciBEUCBkdWFsIG1vZGUgYWRhcHRvcgo+ICsgKiB0eXBlOiBE UCBkdWFsIG1vZGUgYWRhcHRvciB0eXBlCj4gKyAqIGFkYXB0ZXI6IEkyQyBhZGFwdGVyIGZvciB0 aGUgRERDIGJ1cwo+ICsgKgo+ICsgKiBEZXRlcm1pbmUgdGhlIG1heCBUTURTIGNsb2NrIHRoZSBh ZGFwdG9yIHN1cHBvcnRzIGJhc2VkIG9uIHRoZQo+ICsgKiB0eXBlIG9mIHRoZSBkdWFsIG1vZGUg YWRhcHRvciBhbmQgdGhlIERQX0RVQUxfTU9ERV9NQVhfVE1EU19DTE9DSwo+ICsgKiByZWdpc3Rl ciAob24gdHlwZTIgYWRhcHRvcnMpLiBBcyBzb21lIHR5cGUgMSBhZGFwdG9ycyBoYXZlCj4gKyAq IHByb2JsZW1zIHdpdGggcmVnaXN0ZXJzIChzZWUgY29tbWVudHMgaW4gZHJtX2RwX2R1YWxfbW9k ZV9kZXRlY3QoKSkKPiArICogd2UgZG9uJ3QgcmVhZCB0aGUgcmVnaXN0ZXIgb24gdGhvc2UsIGlu c3RlYWQgd2Ugc2ltcGx5IGFzc3VtZQo+ICsgKiBhIDE2NSBNSHogbGltaXQgYmFzZWQgb24gdGhl IHNwZWNpZmljYXRpb24uCj4gKyAqCj4gKyAqIFJldHVybnM6Cj4gKyAqIE1heGltdW0gc3VwcG9y dGVkIFRNRFMgY2xvY2sgcmF0ZSBmb3IgdGhlIERQIGR1YWwgbW9kZSBhZGFwdG9yIGluIGtIei4K PiArICovCj4gK2ludCBkcm1fZHBfZHVhbF9tb2RlX21heF90bWRzX2Nsb2NrKGVudW0gZHJtX2Rw X2R1YWxfbW9kZV90eXBlIHR5cGUsCj4gKwkJCQkgICAgc3RydWN0IGkyY19hZGFwdGVyICphZGFw dGVyKQo+ICt7Cj4gKwl1aW50OF90IG1heF90bWRzX2Nsb2NrOwo+ICsJc3NpemVfdCByZXQ7Cj4g Kwo+ICsJLyogbmF0aXZlIEhETUkgc28gbm8gbGltaXQgKi8KPiArCWlmICh0eXBlID09IERSTV9E UF9EVUFMX01PREVfTk9ORSkKPiArCQlyZXR1cm4gMDsKPiArCj4gKwkvKgo+ICsJICogVHlwZSAx IGFkYXB0b3JzIGFyZSBsaW1pdGVkIHRvIDE2NU1Iego+ICsJICogVHlwZSAyIGFkYXB0b3JzIGNh biB0ZWxscyB1cyB0aGVpciBsaW1pdAo+ICsJICovCj4gKwlpZiAodHlwZSA8IERSTV9EUF9EVUFM X01PREVfVFlQRTJfRFZJKQo+ICsJCXJldHVybiAxNjUwMDA7Cj4gKwo+ICsJcmV0ID0gZHJtX2Rw X2R1YWxfbW9kZV9yZWFkKGFkYXB0ZXIsIERQX0RVQUxfTU9ERV9NQVhfVE1EU19DTE9DSywKPiAr CQkJCSAgICAmbWF4X3RtZHNfY2xvY2ssIHNpemVvZihtYXhfdG1kc19jbG9jaykpOwo+ICsJaWYg KHJldCB8fCBtYXhfdG1kc19jbG9jayA9PSAweDAwIHx8IG1heF90bWRzX2Nsb2NrID09IDB4ZmYp Cj4gKwkJcmV0dXJuIDE2NTAwMDsKPiArCj4gKwlyZXR1cm4gbWF4X3RtZHNfY2xvY2sgKiA1MDAw IC8gMjsKPiArfQo+ICtFWFBPUlRfU1lNQk9MKGRybV9kcF9kdWFsX21vZGVfbWF4X3RtZHNfY2xv Y2spOwo+ICsKPiArLyoqCj4gKyAqIGRybV9kcF9kdWFsX21vZGVfZ2V0X3RtZHNfb3V0cHV0IC0g R2V0IHRoZSBzdGF0ZSBvZiB0aGUgVE1EUyBvdXRwdXQgYnVmZmVycyBpbiB0aGUgRFAgZHVhbCBt b2RlIGFkYXB0b3IKPiArICogdHlwZTogRFAgZHVhbCBtb2RlIGFkYXB0b3IgdHlwZQo+ICsgKiBh ZGFwdGVyOiBJMkMgYWRhcHRlciBmb3IgdGhlIEREQyBidXMKPiArICogZW5hYmxlZDogY3VycmVu dCBzdGF0ZSBvZiB0aGUgVE1EUyBvdXRwdXQgYnVmZmVycwo+ICsgKgo+ICsgKiBHZXQgdGhlIHN0 YXRlIG9mIHRoZSBUTURTIG91dHB1dCBidWZmZXJzIGluIHRoZSBhZGFwdG9yLiBGb3IKPiArICog dHlwZTIgYWRhcHRvcnMgdGhpcyBpcyBxdWVyaWVkIGZyb20gdGhlIERQX0RVQUxfTU9ERV9UTURT X09FTgo+ICsgKiByZWdpc3Rlci4gQXMgc29tZSB0eXBlIDEgYWRhcHRvcnMgaGF2ZSBwcm9ibGVt cyB3aXRoIHJlZ2lzdGVycwo+ICsgKiAoc2VlIGNvbW1lbnRzIGluIGRybV9kcF9kdWFsX21vZGVf ZGV0ZWN0KCkpIHdlIGRvbid0IHJlYWQgdGhlCj4gKyAqIHJlZ2lzdGVyIG9uIHRob3NlLCBpbnN0 ZWFkIHdlIHNpbXBseSBhc3N1bWUgdGhhdCB0aGUgYnVmZmVycwo+ICsgKiBhcmUgYWx3YXlzIGVu YWJsZWQuCj4gKyAqCj4gKyAqIFJldHVybnM6Cj4gKyAqIDAgb24gc3VjY2VzcywgbmVnYXRpdmUg ZXJyb3IgY29kZSBvbiBmYWlsdXJlCj4gKyAqLwo+ICtpbnQgZHJtX2RwX2R1YWxfbW9kZV9nZXRf dG1kc19vdXRwdXQoZW51bSBkcm1fZHBfZHVhbF9tb2RlX3R5cGUgdHlwZSwKPiArCQkJCSAgICAg c3RydWN0IGkyY19hZGFwdGVyICphZGFwdGVyLAo+ICsJCQkJICAgICBib29sICplbmFibGVkKQo+ ICt7Cj4gKwl1aW50OF90IHRtZHNfb2VuOwo+ICsJc3NpemVfdCByZXQ7Cj4gKwo+ICsJaWYgKHR5 cGUgPCBEUk1fRFBfRFVBTF9NT0RFX1RZUEUyX0RWSSkgewo+ICsJCSplbmFibGVkID0gdHJ1ZTsK PiArCQlyZXR1cm4gMDsKPiArCX0KPiArCj4gKwlyZXQgPSBkcm1fZHBfZHVhbF9tb2RlX3JlYWQo YWRhcHRlciwgRFBfRFVBTF9NT0RFX1RNRFNfT0VOLAo+ICsJCQkJICAgICZ0bWRzX29lbiwgc2l6 ZW9mKHRtZHNfb2VuKSk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJKmVu YWJsZWQgPSAhKHRtZHNfb2VuICYgRFBfRFVBTF9NT0RFX1RNRFNfRElTQUJMRSk7Cj4gKwo+ICsJ cmV0dXJuIDA7Cj4gK30KPiArRVhQT1JUX1NZTUJPTChkcm1fZHBfZHVhbF9tb2RlX2dldF90bWRz X291dHB1dCk7Cj4gKwo+ICsvKioKPiArICogZHJtX2RwX2R1YWxfbW9kZV9zZXRfdG1kc19vdXRw dXQgLSBFbmFibGUvZGlzYWJsZSBUTURTIG91dHB1dCBidWZmZXJzIGluIHRoZSBEUCBkdWFsIG1v ZGUgYWRhcHRvcgo+ICsgKiB0eXBlOiBEUCBkdWFsIG1vZGUgYWRhcHRvciB0eXBlCj4gKyAqIGFk YXB0ZXI6IEkyQyBhZGFwdGVyIGZvciB0aGUgRERDIGJ1cwo+ICsgKiBlbmFibGU6IGVuYWJsZSAo YXMgb3Bwb3NlZCB0byBkaXNhYmxlKSB0aGUgVE1EUyBvdXRwdXQgYnVmZmVycwo+ICsgKgo+ICsg KiBTZXQgdGhlIHN0YXRlIG9mIHRoZSBUTURTIG91dHB1dCBidWZmZXJzIGluIHRoZSBhZGFwdG9y LiBGb3IKPiArICogdHlwZTIgdGhpcyBpcyBzZXQgdmlhIHRoZSBEUF9EVUFMX01PREVfVE1EU19P RU4gcmVnaXN0ZXIuIEFzCj4gKyAqIHNvbWUgdHlwZSAxIGFkYXB0b3JzIGhhdmUgcHJvYmxlbXMg d2l0aCByZWdpc3RlcnMgKHNlZSBjb21tZW50cwo+ICsgKiBpbiBkcm1fZHBfZHVhbF9tb2RlX2Rl dGVjdCgpKSB3ZSBhdm9pZCB0b3VjaGluZyB0aGUgcmVnaXN0ZXIsCj4gKyAqIG1ha2luZyB0aGlz IGZ1bmN0aW9uIGEgbm8tb3Agb24gdHlwZSAxIGFkYXB0b3JzLgo+ICsgKgo+ICsgKiBSZXR1cm5z Ogo+ICsgKiAwIG9uIHN1Y2Nlc3MsIG5lZ2F0aXZlIGVycm9yIGNvZGUgb24gZmFpbHVyZQo+ICsg Ki8KPiAraW50IGRybV9kcF9kdWFsX21vZGVfc2V0X3RtZHNfb3V0cHV0KGVudW0gZHJtX2RwX2R1 YWxfbW9kZV90eXBlIHR5cGUsCj4gKwkJCQkgICAgIHN0cnVjdCBpMmNfYWRhcHRlciAqYWRhcHRl ciwgYm9vbCBlbmFibGUpCj4gK3sKPiArCXVpbnQ4X3QgdG1kc19vZW4gPSBlbmFibGUgPyAwIDog RFBfRFVBTF9NT0RFX1RNRFNfRElTQUJMRTsKPiArCXNzaXplX3QgcmV0Owo+ICsKPiArCWlmICh0 eXBlIDwgRFJNX0RQX0RVQUxfTU9ERV9UWVBFMl9EVkkpCj4gKwkJcmV0dXJuIDA7Cj4gKwo+ICsJ cmV0ID0gZHJtX2RwX2R1YWxfbW9kZV93cml0ZShhZGFwdGVyLCBEUF9EVUFMX01PREVfVE1EU19P RU4sCj4gKwkJCQkgICAgICZ0bWRzX29lbiwgc2l6ZW9mKHRtZHNfb2VuKSk7Cj4gKwlpZiAocmV0 KQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArRVhQT1JUX1NZTUJP TChkcm1fZHBfZHVhbF9tb2RlX3NldF90bWRzX291dHB1dCk7Cj4gKwo+ICsvKioKPiArICogZHJt X2RwX2dldF9kdWFsX21vZGVfdHlwZV9uYW1lIC0gR2V0IHRoZSBuYW1lIG9mIHRoZSBEUCBkdWFs IG1vZGUgYWRhcHRvciB0eXBlIGFzIGEgc3RyaW5nCj4gKyAqIHR5cGU6IERQIGR1YWwgbW9kZSBh ZGFwdG9yIHR5cGUKPiArICoKPiArICogUmV0dXJuczoKPiArICogU3RyaW5nIHJlcHJlc2VudGF0 aW9uIG9mIHRoZSBEUCBkdWFsIG1vZGUgYWRhcHRvciB0eXBlCj4gKyAqLwo+ICtjb25zdCBjaGFy ICpkcm1fZHBfZ2V0X2R1YWxfbW9kZV90eXBlX25hbWUoZW51bSBkcm1fZHBfZHVhbF9tb2RlX3R5 cGUgdHlwZSkKPiArewo+ICsJc3dpdGNoICh0eXBlKSB7Cj4gKwljYXNlIERSTV9EUF9EVUFMX01P REVfTk9ORToKPiArCQlyZXR1cm4gIm5vbmUiOwo+ICsJY2FzZSBEUk1fRFBfRFVBTF9NT0RFX1RZ UEUxX0RWSToKPiArCQlyZXR1cm4gInR5cGUgMSBEVkkiOwo+ICsJY2FzZSBEUk1fRFBfRFVBTF9N T0RFX1RZUEUxX0hETUk6Cj4gKwkJcmV0dXJuICJ0eXBlIDEgSERNSSI7Cj4gKwljYXNlIERSTV9E UF9EVUFMX01PREVfVFlQRTJfRFZJOgo+ICsJCXJldHVybiAidHlwZSAyIERWSSI7Cj4gKwljYXNl IERSTV9EUF9EVUFMX01PREVfVFlQRTJfSERNSToKPiArCQlyZXR1cm4gInR5cGUgMiBIRE1JIjsK PiArCWRlZmF1bHQ6Cj4gKwkJV0FSTl9PTih0eXBlICE9IERSTV9EUF9EVUFMX01PREVfVU5LTk9X Tik7Cj4gKwkJcmV0dXJuICJ1bmtub3duIjsKPiArCX0KPiArfQo+ICtFWFBPUlRfU1lNQk9MKGRy bV9kcF9nZXRfZHVhbF9tb2RlX3R5cGVfbmFtZSk7Cj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvZHJt L2RybV9kcF9kdWFsX21vZGVfaGVscGVyLmggYi9pbmNsdWRlL2RybS9kcm1fZHBfZHVhbF9tb2Rl X2hlbHBlci5oCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAuLmI0 NjAzYjlmYzAzZAo+IC0tLSAvZGV2L251bGwKPiArKysgYi9pbmNsdWRlL2RybS9kcm1fZHBfZHVh bF9tb2RlX2hlbHBlci5oCj4gQEAgLTAsMCArMSw4MyBAQAo+ICsvKgo+ICsgKiBDb3B5cmlnaHQg wqkgMjAxNiBJbnRlbCBDb3Jwb3JhdGlvbgo+ICsgKgo+ICsgKiBQZXJtaXNzaW9uIGlzIGhlcmVi eSBncmFudGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNvbiBvYnRhaW5pbmcgYQo+ICsg KiBjb3B5IG9mIHRoaXMgc29mdHdhcmUgYW5kIGFzc29jaWF0ZWQgZG9jdW1lbnRhdGlvbiBmaWxl cyAodGhlICJTb2Z0d2FyZSIpLAo+ICsgKiB0byBkZWFsIGluIHRoZSBTb2Z0d2FyZSB3aXRob3V0 IHJlc3RyaWN0aW9uLCBpbmNsdWRpbmcgd2l0aG91dCBsaW1pdGF0aW9uCj4gKyAqIHRoZSByaWdo dHMgdG8gdXNlLCBjb3B5LCBtb2RpZnksIG1lcmdlLCBwdWJsaXNoLCBkaXN0cmlidXRlLCBzdWJs aWNlbnNlLAo+ICsgKiBhbmQvb3Igc2VsbCBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQgdG8g cGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0aGUKPiArICogU29mdHdhcmUgaXMgZnVybmlzaGVkIHRv IGRvIHNvLCBzdWJqZWN0IHRvIHRoZSBmb2xsb3dpbmcgY29uZGl0aW9uczoKPiArICoKPiArICog VGhlIGFib3ZlIGNvcHlyaWdodCBub3RpY2UgYW5kIHRoaXMgcGVybWlzc2lvbiBub3RpY2Ugc2hh bGwgYmUgaW5jbHVkZWQgaW4KPiArICogYWxsIGNvcGllcyBvciBzdWJzdGFudGlhbCBwb3J0aW9u cyBvZiB0aGUgU29mdHdhcmUuCj4gKyAqCj4gKyAqIFRIRSBTT0ZUV0FSRSBJUyBQUk9WSURFRCAi QVMgSVMiLCBXSVRIT1VUIFdBUlJBTlRZIE9GIEFOWSBLSU5ELCBFWFBSRVNTIE9SCj4gKyAqIElN UExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMgT0YgTUVS Q0hBTlRBQklMSVRZLAo+ICsgKiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBTkQg Tk9OSU5GUklOR0VNRU5ULiAgSU4gTk8gRVZFTlQgU0hBTEwKPiArICogVEhFIENPUFlSSUdIVCBI T0xERVIoUykgT1IgQVVUSE9SKFMpIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9S Cj4gKyAqIE9USEVSIExJQUJJTElUWSwgV0hFVEhFUiBJTiBBTiBBQ1RJT04gT0YgQ09OVFJBQ1Qs IFRPUlQgT1IgT1RIRVJXSVNFLAo+ICsgKiBBUklTSU5HIEZST00sIE9VVCBPRiBPUiBJTiBDT05O RUNUSU9OIFdJVEggVEhFIFNPRlRXQVJFIE9SIFRIRSBVU0UgT1IKPiArICogT1RIRVIgREVBTElO R1MgSU4gVEhFIFNPRlRXQVJFLgo+ICsgKi8KPiArCj4gKyNpZm5kZWYgRFJNX0RQX0RVQUxfTU9E RV9IRUxQRVJfSAo+ICsjZGVmaW5lIERSTV9EUF9EVUFMX01PREVfSEVMUEVSX0gKPiArCj4gKyNp bmNsdWRlIDxsaW51eC90eXBlcy5oPgo+ICsKPiArLyoKPiArICogT3B0aW9uYWwgZm9yIHR5cGUg MSBEVkkgYWRhcHRvcnMKPiArICogTWFuZGF0b3J5IGZvciB0eXBlIDEgSERNSSBhbmQgdHlwZSAy IGFkYXRvcnMKPiArICovCj4gKyNkZWZpbmUgRFBfRFVBTF9NT0RFX0hETUlfSUQgMHgwMCAvKiAw MC0wZiAqLwo+ICsjZGVmaW5lICBEUF9EVUFMX01PREVfSERNSV9JRF9MRU4gMTYKPiArLyoKPiAr ICogT3B0aW9uYWwgZm9yIHR5cGUgMSBhZGFwdG9ycwo+ICsgKiBNYW5kYXRvcnkgZm9yIHR5cGUg MiBhZGF0b3JzCj4gKyAqLwo+ICsjZGVmaW5lIERQX0RVQUxfTU9ERV9BREFQVE9SX0lEIDB4MTAK PiArI2RlZmluZSAgRFBfRFVBTF9NT0RFX1JFVl9NQVNLIDB4MDcKPiArI2RlZmluZSAgRFBfRFVB TF9NT0RFX1JFVl9UWVBFMiAweDAwCj4gKyNkZWZpbmUgIERQX0RVQUxfTU9ERV9UWVBFX01BU0sg MHhmMAo+ICsjZGVmaW5lICBEUF9EVUFMX01PREVfVFlQRV9UWVBFMiAweGEwCj4gKyNkZWZpbmUg RFBfRFVBTF9NT0RFX0lFRUVfT1VJIDB4MTEgLyogMTEtMTMqLwo+ICsjZGVmaW5lICBEUF9EVUFM X0lFRUVfT1VJX0xFTiAzCj4gKyNkZWZpbmUgRFBfRFVBTF9ERVZJQ0VfSUQgMHgxNCAvKiAxNC0x OSAqLwo+ICsjZGVmaW5lICBEUF9EVUFMX0RFVklDRV9JRF9MRU4gNgo+ICsjZGVmaW5lIERQX0RV QUxfTU9ERV9IQVJEV0FSRV9SRVYgMHgxYQo+ICsjZGVmaW5lIERQX0RVQUxfTU9ERV9GSVJNV0FS RV9NQUpPUl9SRVYgMHgxYgo+ICsjZGVmaW5lIERQX0RVQUxfTU9ERV9GSVJNV0FSRV9NSU5PUl9S RVYgMHgxYwo+ICsjZGVmaW5lIERQX0RVQUxfTU9ERV9NQVhfVE1EU19DTE9DSyAweDFkCj4gKyNk ZWZpbmUgRFBfRFVBTF9NT0RFX0kyQ19TUEVFRF9DQVAgMHgxZQo+ICsjZGVmaW5lIERQX0RVQUxf TU9ERV9UTURTX09FTiAweDIwCj4gKyNkZWZpbmUgIERQX0RVQUxfTU9ERV9UTURTX0RJU0FCTEUg MHgwMQo+ICsjZGVmaW5lIERQX0RVQUxfTU9ERV9IRE1JX1BJTl9DVFJMIDB4MjEKPiArI2RlZmlu ZSAgRFBfRFVBTF9NT0RFX0NFQ19FTkFCTEUgMHgwMQo+ICsjZGVmaW5lIERQX0RVQUxfTU9ERV9J MkNfU1BFRURfQ1RSTCAweDIyCj4gKwo+ICtzdHJ1Y3QgaTJjX2FkYXB0ZXI7Cj4gKwo+ICtzc2l6 ZV90IGRybV9kcF9kdWFsX21vZGVfcmVhZChzdHJ1Y3QgaTJjX2FkYXB0ZXIgKmFkYXB0ZXIsCj4g KwkJCSAgICAgIHU4IG9mZnNldCwgdm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSk7Cj4gK3NzaXpl X3QgZHJtX2RwX2R1YWxfbW9kZV93cml0ZShzdHJ1Y3QgaTJjX2FkYXB0ZXIgKmFkYXB0ZXIsCj4g KwkJCSAgICAgICB1OCBvZmZzZXQsIGNvbnN0IHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpOwo+ ICsKPiArZW51bSBkcm1fZHBfZHVhbF9tb2RlX3R5cGUgewo+ICsJRFJNX0RQX0RVQUxfTU9ERV9O T05FLAo+ICsJRFJNX0RQX0RVQUxfTU9ERV9VTktOT1dOLAo+ICsJRFJNX0RQX0RVQUxfTU9ERV9U WVBFMV9EVkksCj4gKwlEUk1fRFBfRFVBTF9NT0RFX1RZUEUxX0hETUksCj4gKwlEUk1fRFBfRFVB TF9NT0RFX1RZUEUyX0RWSSwKPiArCURSTV9EUF9EVUFMX01PREVfVFlQRTJfSERNSSwKPiArfTsK PiArCj4gK2VudW0gZHJtX2RwX2R1YWxfbW9kZV90eXBlIGRybV9kcF9kdWFsX21vZGVfZGV0ZWN0 KHN0cnVjdCBpMmNfYWRhcHRlciAqYWRhcHRlcik7Cj4gK2ludCBkcm1fZHBfZHVhbF9tb2RlX21h eF90bWRzX2Nsb2NrKGVudW0gZHJtX2RwX2R1YWxfbW9kZV90eXBlIHR5cGUsCj4gKwkJCQkgICAg c3RydWN0IGkyY19hZGFwdGVyICphZGFwdGVyKTsKPiAraW50IGRybV9kcF9kdWFsX21vZGVfZ2V0 X3RtZHNfb3V0cHV0KGVudW0gZHJtX2RwX2R1YWxfbW9kZV90eXBlIHR5cGUsCj4gKwkJCQkgICAg IHN0cnVjdCBpMmNfYWRhcHRlciAqYWRhcHRlciwgYm9vbCAqZW5hYmxlZCk7Cj4gK2ludCBkcm1f ZHBfZHVhbF9tb2RlX3NldF90bWRzX291dHB1dChlbnVtIGRybV9kcF9kdWFsX21vZGVfdHlwZSB0 eXBlLAo+ICsJCQkJICAgICBzdHJ1Y3QgaTJjX2FkYXB0ZXIgKmFkYXB0ZXIsIGJvb2wgZW5hYmxl KTsKPiArY29uc3QgY2hhciAqZHJtX2RwX2dldF9kdWFsX21vZGVfdHlwZV9uYW1lKGVudW0gZHJt X2RwX2R1YWxfbW9kZV90eXBlIHR5cGUpOwo+ICsKPiArI2VuZGlmCgotLSAKSmFuaSBOaWt1bGEs IEludGVsIE9wZW4gU291cmNlIFRlY2hub2xvZ3kgQ2VudGVyCl9fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRl dmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9t YWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga11.intel.com ([192.55.52.93]:44071 "EHLO mga11.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750773AbcECHqr convert rfc822-to-8bit (ORCPT ); Tue, 3 May 2016 03:46:47 -0400 From: Jani Nikula To: ville.syrjala@linux.intel.com, dri-devel@lists.freedesktop.org Cc: Paulo Zanoni , Daniel Vetter , intel-gfx@lists.freedesktop.org, Tore Anderson , stable@vger.kernel.org Subject: Re: [Intel-gfx] [PATCH v2 1/4] drm: Add helper for DP++ adaptors In-Reply-To: <1462216105-20881-2-git-send-email-ville.syrjala@linux.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> Date: Tue, 03 May 2016 10:46:26 +0300 Message-ID: <87lh3rfust.fsf@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8BIT Sender: stable-owner@vger.kernel.org List-ID: On Mon, 02 May 2016, 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 The parameters need to be prefixed with @ in kernel-doc. Same across the patch series. BR, Jani. > + * > + * 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)); > + 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; > + } > + > + 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) > + 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) > + 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); > + 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, > + 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 -- Jani Nikula, Intel Open Source Technology Center