From mboxrd@z Thu Jan 1 00:00:00 1970 From: Yakir Yang Subject: Re: [PATCH] drm/bridge: analogix_dp: Remove duplicated code Date: Fri, 5 Aug 2016 16:23:06 +0800 Message-ID: <57A44CEA.9070505@rock-chips.com> References: <1470291789-23402-1-git-send-email-tomeu.vizoso@collabora.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: Received: from lucky1.263xmail.com (lucky1.263xmail.com [211.157.147.131]) by gabe.freedesktop.org (Postfix) with ESMTPS id BD1126E524 for ; Fri, 5 Aug 2016 08:23:19 +0000 (UTC) In-Reply-To: <1470291789-23402-1-git-send-email-tomeu.vizoso@collabora.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Tomeu Vizoso , linux-kernel@vger.kernel.org Cc: Javier Martinez Canillas , dri-devel@lists.freedesktop.org, Mika Kahola , Daniel Vetter List-Id: dri-devel@lists.freedesktop.org VG9tZXUsCgpvX08KCklnbm9yZSBteSBwcmV2aW91cyBlbWFpbCwgc2VlbXMgSSBtYWtlIGEgbWlz dGFrZW4gYWJvdXQgdGhlIGVtYWlsIApmb3JtYXQsIGFuZCBtZXNzIHVwIHRoZSBwYXRjaCBmb3Jt YXQuCgpJIGhhdmUgbW92ZSBteSBwcmV2aW91cyBjb21tZW50cyB0byB0aGlzIG9uZSA6LSkKCk9u IDA4LzA0LzIwMTYgMDI6MjMgUE0sIFRvbWV1IFZpem9zbyB3cm90ZToKPiBSZW1vdmUgY29kZSBm b3IgcmVhZGluZyB0aGUgRURJRCBhbmQgRFBDRCBmaWVsZHMgYW5kIHVzZSB0aGUgaGVscGVycwo+ IGluc3RlYWQuCj4KPiBCZXNpZGVzIHRoZSBvYnZpb3VzIGNvZGUgcmVkdWN0aW9uLCBvdGhlciBo ZWxwZXJzIGFyZSBiZWluZyBhZGRlZCB0byB0aGUKPiBjb3JlIHRoYXQgY291bGQgYmUgdXNlZCBp biB0aGlzIGRyaXZlciBhbmQgd2lsbCBiZSBnb29kIHRvIGJlIGFibGUgdG8KPiB1c2UgdGhlbSBp bnN0ZWFkIG9mIGR1cGxpY2F0aW5nIHRoZW0uCj4KPiBTaWduZWQtb2ZmLWJ5OiBUb21ldSBWaXpv c28gPHRvbWV1LnZpem9zb0Bjb2xsYWJvcmEuY29tPgo+IENjOiBKYXZpZXIgTWFydGluZXogQ2Fu aWxsYXMgPGphdmllckBvc2cuc2Ftc3VuZy5jb20+Cj4gQ2M6IE1pa2EgS2Fob2xhIDxtaWthLmth aG9sYUBpbnRlbC5jb20+Cj4gQ2M6IFlha2lyIFlhbmcgPHlra0Byb2NrLWNoaXBzLmNvbT4KPiBD YzogRGFuaWVsIFZldHRlciA8ZGFuaWVsLnZldHRlckBpbnRlbC5jb20+Cj4gLS0tCj4gICBkcml2 ZXJzL2dwdS9kcm0vYnJpZGdlL2FuYWxvZ2l4L2FuYWxvZ2l4X2RwX2NvcmUuYyB8IDM5MCArKysr KysrKysrKy0tLS0tLS0tLS0KPiAgIGRyaXZlcnMvZ3B1L2RybS9icmlkZ2UvYW5hbG9naXgvYW5h bG9naXhfZHBfY29yZS5oIHwgIDM5ICstLQo+ICAgZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9hbmFs b2dpeC9hbmFsb2dpeF9kcF9yZWcuYyAgfCAzMjQgLS0tLS0tLS0tLS0tLS0tLS0KPiAgIDMgZmls ZXMgY2hhbmdlZCwgMjAxIGluc2VydGlvbnMoKyksIDU1MiBkZWxldGlvbnMoLSkKPgo+IGRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYnJpZGdlL2FuYWxvZ2l4L2FuYWxvZ2l4X2RwX2NvcmUu YyBiL2RyaXZlcnMvZ3B1L2RybS9icmlkZ2UvYW5hbG9naXgvYW5hbG9naXhfZHBfY29yZS5jCj4g aW5kZXggMzI3MTVkYWY3M2NiLi5jODFjYjM3ZTU2YjYgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9n cHUvZHJtL2JyaWRnZS9hbmFsb2dpeC9hbmFsb2dpeF9kcF9jb3JlLmMKPiArKysgYi9kcml2ZXJz L2dwdS9kcm0vYnJpZGdlL2FuYWxvZ2l4L2FuYWxvZ2l4X2RwX2NvcmUuYwo+IEBAIC0zMSw2ICsz MSw3IEBACj4gICAjaW5jbHVkZSA8ZHJtL2JyaWRnZS9hbmFsb2dpeF9kcC5oPgo+ICAgCj4gICAj aW5jbHVkZSAiYW5hbG9naXhfZHBfY29yZS5oIgo+ICsjaW5jbHVkZSAiYW5hbG9naXhfZHBfcmVn LmgiCj4gICAKPiAgICNkZWZpbmUgdG9fZHAobm0pCWNvbnRhaW5lcl9vZihubSwgc3RydWN0IGFu YWxvZ2l4X2RwX2RldmljZSwgbm0pCj4gICAKPiBAQCAtOTcsMTUwICs5OCwyMSBAQCBzdGF0aWMg aW50IGFuYWxvZ2l4X2RwX2RldGVjdF9ocGQoc3RydWN0IGFuYWxvZ2l4X2RwX2RldmljZSAqZHAp Cj4gICAJcmV0dXJuIDA7Cj4gICB9Cj4gICAKPiAtc3RhdGljIHVuc2lnbmVkIGNoYXIgYW5hbG9n aXhfZHBfY2FsY19lZGlkX2NoZWNrX3N1bSh1bnNpZ25lZCBjaGFyICplZGlkX2RhdGEpCj4gLXsK PiAtCWludCBpOwo+IC0JdW5zaWduZWQgY2hhciBzdW0gPSAwOwo+IC0KPiAtCWZvciAoaSA9IDA7 IGkgPCBFRElEX0JMT0NLX0xFTkdUSDsgaSsrKQo+IC0JCXN1bSA9IHN1bSArIGVkaWRfZGF0YVtp XTsKPiAtCj4gLQlyZXR1cm4gc3VtOwo+IC19Cj4gLQo+IC1zdGF0aWMgaW50IGFuYWxvZ2l4X2Rw X3JlYWRfZWRpZChzdHJ1Y3QgYW5hbG9naXhfZHBfZGV2aWNlICpkcCkKPiAtewo+IC0JdW5zaWdu ZWQgY2hhciAqZWRpZCA9IGRwLT5lZGlkOwo+IC0JdW5zaWduZWQgaW50IGV4dGVuZF9ibG9jayA9 IDA7Cj4gLQl1bnNpZ25lZCBjaGFyIHN1bTsKPiAtCXVuc2lnbmVkIGNoYXIgdGVzdF92ZWN0b3I7 Cj4gLQlpbnQgcmV0dmFsOwo+IC0KPiAtCS8qCj4gLQkgKiBFRElEIGRldmljZSBhZGRyZXNzIGlz IDB4NTAuCj4gLQkgKiBIb3dldmVyLCBpZiBuZWNlc3NhcnksIHlvdSBtdXN0IGhhdmUgc2V0IHVw cGVyIGFkZHJlc3MKPiAtCSAqIGludG8gRS1FRElEIGluIEkyQyBkZXZpY2UsIDB4MzAuCj4gLQkg Ki8KPiAtCj4gLQkvKiBSZWFkIEV4dGVuc2lvbiBGbGFnLCBOdW1iZXIgb2YgMTI4LWJ5dGUgRURJ RCBleHRlbnNpb24gYmxvY2tzICovCj4gLQlyZXR2YWwgPSBhbmFsb2dpeF9kcF9yZWFkX2J5dGVf ZnJvbV9pMmMoZHAsIEkyQ19FRElEX0RFVklDRV9BRERSLAo+IC0JCQkJCQlFRElEX0VYVEVOU0lP Tl9GTEFHLAo+IC0JCQkJCQkmZXh0ZW5kX2Jsb2NrKTsKPiAtCWlmIChyZXR2YWwpCj4gLQkJcmV0 dXJuIHJldHZhbDsKPiAtCj4gLQlpZiAoZXh0ZW5kX2Jsb2NrID4gMCkgewo+IC0JCWRldl9kYmco ZHAtPmRldiwgIkVESUQgZGF0YSBpbmNsdWRlcyBhIHNpbmdsZSBleHRlbnNpb24hXG4iKTsKPiAt Cj4gLQkJLyogUmVhZCBFRElEIGRhdGEgKi8KPiAtCQlyZXR2YWwgPSBhbmFsb2dpeF9kcF9yZWFk X2J5dGVzX2Zyb21faTJjKGRwLAo+IC0JCQkJCQlJMkNfRURJRF9ERVZJQ0VfQUREUiwKPiAtCQkJ CQkJRURJRF9IRUFERVJfUEFUVEVSTiwKPiAtCQkJCQkJRURJRF9CTE9DS19MRU5HVEgsCj4gLQkJ CQkJCSZlZGlkW0VESURfSEVBREVSX1BBVFRFUk5dKTsKPiAtCQlpZiAocmV0dmFsICE9IDApIHsK PiAtCQkJZGV2X2VycihkcC0+ZGV2LCAiRURJRCBSZWFkIGZhaWxlZCFcbiIpOwo+IC0JCQlyZXR1 cm4gLUVJTzsKPiAtCQl9Cj4gLQkJc3VtID0gYW5hbG9naXhfZHBfY2FsY19lZGlkX2NoZWNrX3N1 bShlZGlkKTsKPiAtCQlpZiAoc3VtICE9IDApIHsKPiAtCQkJZGV2X2VycihkcC0+ZGV2LCAiRURJ RCBiYWQgY2hlY2tzdW0hXG4iKTsKPiAtCQkJcmV0dXJuIC1FSU87Cj4gLQkJfQo+IC0KPiAtCQkv KiBSZWFkIGFkZGl0aW9uYWwgRURJRCBkYXRhICovCj4gLQkJcmV0dmFsID0gYW5hbG9naXhfZHBf cmVhZF9ieXRlc19mcm9tX2kyYyhkcCwKPiAtCQkJCUkyQ19FRElEX0RFVklDRV9BRERSLAo+IC0J CQkJRURJRF9CTE9DS19MRU5HVEgsCj4gLQkJCQlFRElEX0JMT0NLX0xFTkdUSCwKPiAtCQkJCSZl ZGlkW0VESURfQkxPQ0tfTEVOR1RIXSk7Cj4gLQkJaWYgKHJldHZhbCAhPSAwKSB7Cj4gLQkJCWRl dl9lcnIoZHAtPmRldiwgIkVESUQgUmVhZCBmYWlsZWQhXG4iKTsKPiAtCQkJcmV0dXJuIC1FSU87 Cj4gLQkJfQo+IC0JCXN1bSA9IGFuYWxvZ2l4X2RwX2NhbGNfZWRpZF9jaGVja19zdW0oJmVkaWRb RURJRF9CTE9DS19MRU5HVEhdKTsKPiAtCQlpZiAoc3VtICE9IDApIHsKPiAtCQkJZGV2X2Vycihk cC0+ZGV2LCAiRURJRCBiYWQgY2hlY2tzdW0hXG4iKTsKPiAtCQkJcmV0dXJuIC1FSU87Cj4gLQkJ fQo+IC0KPiAtCQlhbmFsb2dpeF9kcF9yZWFkX2J5dGVfZnJvbV9kcGNkKGRwLCBEUF9URVNUX1JF UVVFU1QsCj4gLQkJCQkJCSZ0ZXN0X3ZlY3Rvcik7Cj4gLQkJaWYgKHRlc3RfdmVjdG9yICYgRFBf VEVTVF9MSU5LX0VESURfUkVBRCkgewo+IC0JCQlhbmFsb2dpeF9kcF93cml0ZV9ieXRlX3RvX2Rw Y2QoZHAsCj4gLQkJCQlEUF9URVNUX0VESURfQ0hFQ0tTVU0sCj4gLQkJCQllZGlkW0VESURfQkxP Q0tfTEVOR1RIICsgRURJRF9DSEVDS1NVTV0pOwo+IC0JCQlhbmFsb2dpeF9kcF93cml0ZV9ieXRl X3RvX2RwY2QoZHAsCj4gLQkJCQlEUF9URVNUX1JFU1BPTlNFLAo+IC0JCQkJRFBfVEVTVF9FRElE X0NIRUNLU1VNX1dSSVRFKTsKPiAtCQl9Cj4gLQl9IGVsc2Ugewo+IC0JCWRldl9pbmZvKGRwLT5k ZXYsICJFRElEIGRhdGEgZG9lcyBub3QgaW5jbHVkZSBhbnkgZXh0ZW5zaW9ucy5cbiIpOwo+IC0K PiAtCQkvKiBSZWFkIEVESUQgZGF0YSAqLwo+IC0JCXJldHZhbCA9IGFuYWxvZ2l4X2RwX3JlYWRf Ynl0ZXNfZnJvbV9pMmMoZHAsCj4gLQkJCQlJMkNfRURJRF9ERVZJQ0VfQUREUiwgRURJRF9IRUFE RVJfUEFUVEVSTiwKPiAtCQkJCUVESURfQkxPQ0tfTEVOR1RILCAmZWRpZFtFRElEX0hFQURFUl9Q QVRURVJOXSk7Cj4gLQkJaWYgKHJldHZhbCAhPSAwKSB7Cj4gLQkJCWRldl9lcnIoZHAtPmRldiwg IkVESUQgUmVhZCBmYWlsZWQhXG4iKTsKPiAtCQkJcmV0dXJuIC1FSU87Cj4gLQkJfQo+IC0JCXN1 bSA9IGFuYWxvZ2l4X2RwX2NhbGNfZWRpZF9jaGVja19zdW0oZWRpZCk7Cj4gLQkJaWYgKHN1bSAh PSAwKSB7Cj4gLQkJCWRldl9lcnIoZHAtPmRldiwgIkVESUQgYmFkIGNoZWNrc3VtIVxuIik7Cj4g LQkJCXJldHVybiAtRUlPOwo+IC0JCX0KPiAtCj4gLQkJYW5hbG9naXhfZHBfcmVhZF9ieXRlX2Zy b21fZHBjZChkcCwgRFBfVEVTVF9SRVFVRVNULAo+IC0JCQkJCQkmdGVzdF92ZWN0b3IpOwo+IC0J CWlmICh0ZXN0X3ZlY3RvciAmIERQX1RFU1RfTElOS19FRElEX1JFQUQpIHsKPiAtCQkJYW5hbG9n aXhfZHBfd3JpdGVfYnl0ZV90b19kcGNkKGRwLAo+IC0JCQkJRFBfVEVTVF9FRElEX0NIRUNLU1VN LCBlZGlkW0VESURfQ0hFQ0tTVU1dKTsKPiAtCQkJYW5hbG9naXhfZHBfd3JpdGVfYnl0ZV90b19k cGNkKGRwLAo+IC0JCQkJRFBfVEVTVF9SRVNQT05TRSwgRFBfVEVTVF9FRElEX0NIRUNLU1VNX1dS SVRFKTsKPiAtCQl9Cj4gLQl9Cj4gLQo+IC0JZGV2X2RiZyhkcC0+ZGV2LCAiRURJRCBSZWFkIHN1 Y2Nlc3MhXG4iKTsKPiAtCXJldHVybiAwOwo+IC19Cj4gLQo+IC1zdGF0aWMgaW50IGFuYWxvZ2l4 X2RwX2hhbmRsZV9lZGlkKHN0cnVjdCBhbmFsb2dpeF9kcF9kZXZpY2UgKmRwKQo+IC17Cj4gLQl1 OCBidWZbMTJdOwo+IC0JaW50IGk7Cj4gLQlpbnQgcmV0dmFsOwo+IC0KPiAtCS8qIFJlYWQgRFBD RCBEUF9EUENEX1JFVn5SRUNFSVZFX1BPUlQxX0NBUF8xICovCj4gLQlyZXR2YWwgPSBhbmFsb2dp eF9kcF9yZWFkX2J5dGVzX2Zyb21fZHBjZChkcCwgRFBfRFBDRF9SRVYsIDEyLCBidWYpOwo+IC0J aWYgKHJldHZhbCkKPiAtCQlyZXR1cm4gcmV0dmFsOwo+IC0KPiAtCS8qIFJlYWQgRURJRCAqLwo+ IC0JZm9yIChpID0gMDsgaSA8IDM7IGkrKykgewo+IC0JCXJldHZhbCA9IGFuYWxvZ2l4X2RwX3Jl YWRfZWRpZChkcCk7Cj4gLQkJaWYgKCFyZXR2YWwpCj4gLQkJCWJyZWFrOwo+IC0JfQo+IC0KPiAt CXJldHVybiByZXR2YWw7Cj4gLX0KPiAtCj4gICBzdGF0aWMgdm9pZAo+ICAgYW5hbG9naXhfZHBf ZW5hYmxlX3J4X3RvX2VuaGFuY2VkX21vZGUoc3RydWN0IGFuYWxvZ2l4X2RwX2RldmljZSAqZHAs Cj4gICAJCQkJICAgICAgIGJvb2wgZW5hYmxlKQo+ICAgewo+ICAgCXU4IGRhdGE7Cj4gICAKPiAt CWFuYWxvZ2l4X2RwX3JlYWRfYnl0ZV9mcm9tX2RwY2QoZHAsIERQX0xBTkVfQ09VTlRfU0VULCAm ZGF0YSk7Cj4gKwlkcm1fZHBfZHBjZF9yZWFkYigmZHAtPmF1eCwgRFBfTEFORV9DT1VOVF9TRVQs ICZkYXRhKTsKPiAgIAo+ICAgCWlmIChlbmFibGUpCj4gLQkJYW5hbG9naXhfZHBfd3JpdGVfYnl0 ZV90b19kcGNkKGRwLCBEUF9MQU5FX0NPVU5UX1NFVCwKPiAtCQkJCQkgICAgICAgRFBfTEFORV9D T1VOVF9FTkhBTkNFRF9GUkFNRV9FTiB8Cj4gLQkJCQkJICAgICAgIERQQ0RfTEFORV9DT1VOVF9T RVQoZGF0YSkpOwo+ICsJCWRybV9kcF9kcGNkX3dyaXRlYigmZHAtPmF1eCwgRFBfTEFORV9DT1VO VF9TRVQsCj4gKwkJCQkgICBEUF9MQU5FX0NPVU5UX0VOSEFOQ0VEX0ZSQU1FX0VOIHwKPiArCQkJ CQlEUENEX0xBTkVfQ09VTlRfU0VUKGRhdGEpKTsKPiAgIAllbHNlCj4gLQkJYW5hbG9naXhfZHBf d3JpdGVfYnl0ZV90b19kcGNkKGRwLCBEUF9MQU5FX0NPVU5UX1NFVCwKPiAtCQkJCQkgICAgICAg RFBDRF9MQU5FX0NPVU5UX1NFVChkYXRhKSk7Cj4gKwkJZHJtX2RwX2RwY2Rfd3JpdGViKCZkcC0+ YXV4LCBEUF9MQU5FX0NPVU5UX1NFVCwKPiArCQkJCSAgIERQQ0RfTEFORV9DT1VOVF9TRVQoZGF0 YSkpOwo+ICAgfQo+ICAgCj4gICBzdGF0aWMgaW50IGFuYWxvZ2l4X2RwX2lzX2VuaGFuY2VkX21v ZGVfYXZhaWxhYmxlKHN0cnVjdCBhbmFsb2dpeF9kcF9kZXZpY2UgKmRwKQo+IEBAIC0yNDgsNyAr MTIwLDcgQEAgc3RhdGljIGludCBhbmFsb2dpeF9kcF9pc19lbmhhbmNlZF9tb2RlX2F2YWlsYWJs ZShzdHJ1Y3QgYW5hbG9naXhfZHBfZGV2aWNlICpkcCkKPiAgIAl1OCBkYXRhOwo+ICAgCWludCBy ZXR2YWw7Cj4gICAKPiAtCWFuYWxvZ2l4X2RwX3JlYWRfYnl0ZV9mcm9tX2RwY2QoZHAsIERQX01B WF9MQU5FX0NPVU5ULCAmZGF0YSk7Cj4gKwlkcm1fZHBfZHBjZF9yZWFkYigmZHAtPmF1eCwgRFBf TUFYX0xBTkVfQ09VTlQsICZkYXRhKTsKPiAgIAlyZXR2YWwgPSBEUENEX0VOSEFOQ0VEX0ZSQU1F X0NBUChkYXRhKTsKPiAgIAo+ICAgCXJldHVybiByZXR2YWw7Cj4gQEAgLTI2Nyw4ICsxMzksOCBA QCBzdGF0aWMgdm9pZCBhbmFsb2dpeF9kcF90cmFpbmluZ19wYXR0ZXJuX2RpcyhzdHJ1Y3QgYW5h bG9naXhfZHBfZGV2aWNlICpkcCkKPiAgIHsKPiAgIAlhbmFsb2dpeF9kcF9zZXRfdHJhaW5pbmdf cGF0dGVybihkcCwgRFBfTk9ORSk7Cj4gICAKPiAtCWFuYWxvZ2l4X2RwX3dyaXRlX2J5dGVfdG9f ZHBjZChkcCwgRFBfVFJBSU5JTkdfUEFUVEVSTl9TRVQsCj4gLQkJCQkgICAgICAgRFBfVFJBSU5J TkdfUEFUVEVSTl9ESVNBQkxFKTsKPiArCWRybV9kcF9kcGNkX3dyaXRlYigmZHAtPmF1eCwgRFBf VFJBSU5JTkdfUEFUVEVSTl9TRVQsCj4gKwkJCSAgIERQX1RSQUlOSU5HX1BBVFRFUk5fRElTQUJM RSk7Cj4gICB9Cj4gICAKPiAgIHN0YXRpYyB2b2lkCj4gQEAgLTMxMyw4ICsxODUsOCBAQCBzdGF0 aWMgaW50IGFuYWxvZ2l4X2RwX2xpbmtfc3RhcnQoc3RydWN0IGFuYWxvZ2l4X2RwX2RldmljZSAq ZHApCj4gICAJLyogU2V0dXAgUlggY29uZmlndXJhdGlvbiAqLwo+ICAgCWJ1ZlswXSA9IGRwLT5s aW5rX3RyYWluLmxpbmtfcmF0ZTsKPiAgIAlidWZbMV0gPSBkcC0+bGlua190cmFpbi5sYW5lX2Nv dW50Owo+IC0JcmV0dmFsID0gYW5hbG9naXhfZHBfd3JpdGVfYnl0ZXNfdG9fZHBjZChkcCwgRFBf TElOS19CV19TRVQsIDIsIGJ1Zik7Cj4gLQlpZiAocmV0dmFsKQo+ICsJcmV0dmFsID0gZHJtX2Rw X2RwY2Rfd3JpdGUoJmRwLT5hdXgsIERQX0xJTktfQldfU0VULCBidWYsIDIpOwo+ICsJaWYgKHJl dHZhbCA8IDApCj4gICAJCXJldHVybiByZXR2YWw7Cj4gICAKPiAgIAkvKiBTZXQgVFggcHJlLWVt cGhhc2lzIHRvIG1pbmltdW0gKi8KPiBAQCAtMzM4LDIwICsyMTAsMjIgQEAgc3RhdGljIGludCBh bmFsb2dpeF9kcF9saW5rX3N0YXJ0KHN0cnVjdCBhbmFsb2dpeF9kcF9kZXZpY2UgKmRwKQo+ICAg CWFuYWxvZ2l4X2RwX3NldF90cmFpbmluZ19wYXR0ZXJuKGRwLCBUUkFJTklOR19QVE4xKTsKPiAg IAo+ICAgCS8qIFNldCBSWCB0cmFpbmluZyBwYXR0ZXJuICovCj4gLQlyZXR2YWwgPSBhbmFsb2dp eF9kcF93cml0ZV9ieXRlX3RvX2RwY2QoZHAsCj4gLQkJCURQX1RSQUlOSU5HX1BBVFRFUk5fU0VU LAo+IC0JCQlEUF9MSU5LX1NDUkFNQkxJTkdfRElTQUJMRSB8IERQX1RSQUlOSU5HX1BBVFRFUk5f MSk7Cj4gLQlpZiAocmV0dmFsKQo+ICsJcmV0dmFsID0gZHJtX2RwX2RwY2Rfd3JpdGViKCZkcC0+ YXV4LCBEUF9UUkFJTklOR19QQVRURVJOX1NFVCwKPiArCQkJCSAgICBEUF9MSU5LX1NDUkFNQkxJ TkdfRElTQUJMRSB8Cj4gKwkJCQkJRFBfVFJBSU5JTkdfUEFUVEVSTl8xKTsKCidEUF9UUkFJTklO R19QQVRURVJOXzEnICBuZWVkIGFsaWduIHdpdGggJ0RQX0xJTktfU0NSQU1CTElOR19ESVNBQkxF JwoKPiArCWlmIChyZXR2YWwgPCAwKQo+ICAgCQlyZXR1cm4gcmV0dmFsOwo+ICAgCj4gICAJZm9y IChsYW5lID0gMDsgbGFuZSA8IGxhbmVfY291bnQ7IGxhbmUrKykKPiAgIAkJYnVmW2xhbmVdID0g RFBfVFJBSU5fUFJFX0VNUEhfTEVWRUxfMCB8Cj4gICAJCQkgICAgRFBfVFJBSU5fVk9MVEFHRV9T V0lOR19MRVZFTF8wOwo+ICAgCj4gLQlyZXR2YWwgPSBhbmFsb2dpeF9kcF93cml0ZV9ieXRlc190 b19kcGNkKGRwLCBEUF9UUkFJTklOR19MQU5FMF9TRVQsCj4gLQkJCQkJCSBsYW5lX2NvdW50LCBi dWYpOwo+ICsJcmV0dmFsID0gZHJtX2RwX2RwY2Rfd3JpdGUoJmRwLT5hdXgsIERQX1RSQUlOSU5H X0xBTkUwX1NFVCwgYnVmLAo+ICsJCQkJICAgbGFuZV9jb3VudCk7Cj4gKwlpZiAocmV0dmFsIDwg MCkKPiArCQlyZXR1cm4gcmV0dmFsOwo+ICAgCj4gLQlyZXR1cm4gcmV0dmFsOwo+ICsJcmV0dXJu IDA7Cj4gICB9Cj4gICAKPiAgIHN0YXRpYyB1bnNpZ25lZCBjaGFyIGFuYWxvZ2l4X2RwX2dldF9s YW5lX3N0YXR1cyh1OCBsaW5rX3N0YXR1c1syXSwgaW50IGxhbmUpCj4gQEAgLTUwMywyNSArMzc3 LDIzIEBAIHN0YXRpYyBpbnQgYW5hbG9naXhfZHBfcHJvY2Vzc19jbG9ja19yZWNvdmVyeShzdHJ1 Y3QgYW5hbG9naXhfZHBfZGV2aWNlICpkcCkKPiAgIAo+ICAgCWxhbmVfY291bnQgPSBkcC0+bGlu a190cmFpbi5sYW5lX2NvdW50Owo+ICAgCj4gLQlyZXR2YWwgPSAgYW5hbG9naXhfZHBfcmVhZF9i eXRlc19mcm9tX2RwY2QoZHAsCj4gLQkJCURQX0xBTkUwXzFfU1RBVFVTLCAyLCBsaW5rX3N0YXR1 cyk7Cj4gLQlpZiAocmV0dmFsKQo+ICsJcmV0dmFsID0gZHJtX2RwX2RwY2RfcmVhZCgmZHAtPmF1 eCwgRFBfTEFORTBfMV9TVEFUVVMsIGxpbmtfc3RhdHVzLCAyKTsKPiArCWlmIChyZXR2YWwgPCAw KQo+ICAgCQlyZXR1cm4gcmV0dmFsOwo+ICAgCj4gLQlyZXR2YWwgPSAgYW5hbG9naXhfZHBfcmVh ZF9ieXRlc19mcm9tX2RwY2QoZHAsCj4gLQkJCURQX0FESlVTVF9SRVFVRVNUX0xBTkUwXzEsIDIs IGFkanVzdF9yZXF1ZXN0KTsKPiAtCWlmIChyZXR2YWwpCj4gKwlyZXR2YWwgPSBkcm1fZHBfZHBj ZF9yZWFkKCZkcC0+YXV4LCBEUF9BREpVU1RfUkVRVUVTVF9MQU5FMF8xLAo+ICsJCQkJICBhZGp1 c3RfcmVxdWVzdCwgMik7Cj4gKwlpZiAocmV0dmFsIDwgMCkKPiAgIAkJcmV0dXJuIHJldHZhbDsK PiAgIAo+ICAgCWlmIChhbmFsb2dpeF9kcF9jbG9ja19yZWNvdmVyeV9vayhsaW5rX3N0YXR1cywg bGFuZV9jb3VudCkgPT0gMCkgewo+ICAgCQkvKiBzZXQgdHJhaW5pbmcgcGF0dGVybiAyIGZvciBF USAqLwo+ICAgCQlhbmFsb2dpeF9kcF9zZXRfdHJhaW5pbmdfcGF0dGVybihkcCwgVFJBSU5JTkdf UFROMik7Cj4gICAKPiAtCQlyZXR2YWwgPSBhbmFsb2dpeF9kcF93cml0ZV9ieXRlX3RvX2RwY2Qo ZHAsCj4gLQkJCQlEUF9UUkFJTklOR19QQVRURVJOX1NFVCwKPiAtCQkJCURQX0xJTktfU0NSQU1C TElOR19ESVNBQkxFIHwKPiAtCQkJCURQX1RSQUlOSU5HX1BBVFRFUk5fMik7Cj4gLQkJaWYgKHJl dHZhbCkKPiArCQlyZXR2YWwgPSBkcm1fZHBfZHBjZF93cml0ZWIoJmRwLT5hdXgsIERQX1RSQUlO SU5HX1BBVFRFUk5fU0VULAo+ICsJCQkJCSAgICBEUF9MSU5LX1NDUkFNQkxJTkdfRElTQUJMRSB8 Cj4gKwkJCQkJCURQX1RSQUlOSU5HX1BBVFRFUk5fMik7CgonRFBfVFJBSU5JTkdfUEFUVEVSTl8y JyAgbmVlZCBhbGlnbiB3aXRoICdEUF9MSU5LX1NDUkFNQkxJTkdfRElTQUJMRScKCj4gKwkJaWYg KHJldHZhbCA8IDApCj4gICAJCQlyZXR1cm4gcmV0dmFsOwo+ICAgCj4gICAJCWRldl9pbmZvKGRw LT5kZXYsICJMaW5rIFRyYWluaW5nIENsb2NrIFJlY292ZXJ5IHN1Y2Nlc3NcbiIpOwo+IEBAIC01 NTksMTMgKzQzMSwxMiBAQCBzdGF0aWMgaW50IGFuYWxvZ2l4X2RwX3Byb2Nlc3NfY2xvY2tfcmVj b3Zlcnkoc3RydWN0IGFuYWxvZ2l4X2RwX2RldmljZSAqZHApCj4gICAJCWFuYWxvZ2l4X2RwX3Nl dF9sYW5lX2xpbmtfdHJhaW5pbmcoZHAsCj4gICAJCQlkcC0+bGlua190cmFpbi50cmFpbmluZ19s YW5lW2xhbmVdLCBsYW5lKTsKPiAgIAo+IC0JcmV0dmFsID0gYW5hbG9naXhfZHBfd3JpdGVfYnl0 ZXNfdG9fZHBjZChkcCwKPiAtCQkJRFBfVFJBSU5JTkdfTEFORTBfU0VULCBsYW5lX2NvdW50LAo+ IC0JCQlkcC0+bGlua190cmFpbi50cmFpbmluZ19sYW5lKTsKPiAtCWlmIChyZXR2YWwpCj4gKwly ZXR2YWwgPSBkcm1fZHBfZHBjZF93cml0ZSgmZHAtPmF1eCwgRFBfVFJBSU5JTkdfTEFORTBfU0VU LAo+ICsJCQkJICAgZHAtPmxpbmtfdHJhaW4udHJhaW5pbmdfbGFuZSwgbGFuZV9jb3VudCk7Cj4g KwlpZiAocmV0dmFsIDwgMCkKPiAgIAkJcmV0dXJuIHJldHZhbDsKPiAgIAo+IC0JcmV0dXJuIHJl dHZhbDsKPiArCXJldHVybiAwOwo+ICAgfQo+ICAgCj4gICBzdGF0aWMgaW50IGFuYWxvZ2l4X2Rw X3Byb2Nlc3NfZXF1YWxpemVyX3RyYWluaW5nKHN0cnVjdCBhbmFsb2dpeF9kcF9kZXZpY2UgKmRw KQo+IEBAIC01NzgsOSArNDQ5LDggQEAgc3RhdGljIGludCBhbmFsb2dpeF9kcF9wcm9jZXNzX2Vx dWFsaXplcl90cmFpbmluZyhzdHJ1Y3QgYW5hbG9naXhfZHBfZGV2aWNlICpkcCkKPiAgIAo+ICAg CWxhbmVfY291bnQgPSBkcC0+bGlua190cmFpbi5sYW5lX2NvdW50Owo+ICAgCj4gLQlyZXR2YWwg PSBhbmFsb2dpeF9kcF9yZWFkX2J5dGVzX2Zyb21fZHBjZChkcCwKPiAtCQkJRFBfTEFORTBfMV9T VEFUVVMsIDIsIGxpbmtfc3RhdHVzKTsKPiAtCWlmIChyZXR2YWwpCj4gKwlyZXR2YWwgPSBkcm1f ZHBfZHBjZF9yZWFkKCZkcC0+YXV4LCBEUF9MQU5FMF8xX1NUQVRVUywgbGlua19zdGF0dXMsIDIp Owo+ICsJaWYgKHJldHZhbCA8IDApCj4gICAJCXJldHVybiByZXR2YWw7Cj4gICAKPiAgIAlpZiAo YW5hbG9naXhfZHBfY2xvY2tfcmVjb3Zlcnlfb2sobGlua19zdGF0dXMsIGxhbmVfY291bnQpKSB7 Cj4gQEAgLTU4OCwxNCArNDU4LDEzIEBAIHN0YXRpYyBpbnQgYW5hbG9naXhfZHBfcHJvY2Vzc19l cXVhbGl6ZXJfdHJhaW5pbmcoc3RydWN0IGFuYWxvZ2l4X2RwX2RldmljZSAqZHApCj4gICAJCXJl dHVybiAtRUlPOwo+ICAgCX0KPiAgIAo+IC0JcmV0dmFsID0gYW5hbG9naXhfZHBfcmVhZF9ieXRl c19mcm9tX2RwY2QoZHAsCj4gLQkJCURQX0FESlVTVF9SRVFVRVNUX0xBTkUwXzEsIDIsIGFkanVz dF9yZXF1ZXN0KTsKPiAtCWlmIChyZXR2YWwpCj4gKwlyZXR2YWwgPSBkcm1fZHBfZHBjZF9yZWFk KCZkcC0+YXV4LCBEUF9BREpVU1RfUkVRVUVTVF9MQU5FMF8xLCBhZGp1c3RfcmVxdWVzdCwgMik7 Cj4gKwlpZiAocmV0dmFsIDwgMCkKPiAgIAkJcmV0dXJuIHJldHZhbDsKPiAgIAo+IC0JcmV0dmFs ID0gYW5hbG9naXhfZHBfcmVhZF9ieXRlX2Zyb21fZHBjZChkcCwKPiAtCQkJRFBfTEFORV9BTElH Tl9TVEFUVVNfVVBEQVRFRCwgJmxpbmtfYWxpZ24pOwo+IC0JaWYgKHJldHZhbCkKPiArCXJldHZh bCA9IGRybV9kcF9kcGNkX3JlYWRiKCZkcC0+YXV4LCBEUF9MQU5FX0FMSUdOX1NUQVRVU19VUERB VEVELAo+ICsJCQkJICAgJmxpbmtfYWxpZ24pOwo+ICsJaWYgKHJldHZhbCA8IDApCj4gICAJCXJl dHVybiByZXR2YWw7Cj4gICAKPiAgIAlhbmFsb2dpeF9kcF9nZXRfYWRqdXN0X3RyYWluaW5nX2xh bmUoZHAsIGFkanVzdF9yZXF1ZXN0KTsKPiBAQCAtNjM2LDEwICs1MDUsMTIgQEAgc3RhdGljIGlu dCBhbmFsb2dpeF9kcF9wcm9jZXNzX2VxdWFsaXplcl90cmFpbmluZyhzdHJ1Y3QgYW5hbG9naXhf ZHBfZGV2aWNlICpkcCkKPiAgIAkJYW5hbG9naXhfZHBfc2V0X2xhbmVfbGlua190cmFpbmluZyhk cCwKPiAgIAkJCWRwLT5saW5rX3RyYWluLnRyYWluaW5nX2xhbmVbbGFuZV0sIGxhbmUpOwo+ICAg Cj4gLQlyZXR2YWwgPSBhbmFsb2dpeF9kcF93cml0ZV9ieXRlc190b19kcGNkKGRwLCBEUF9UUkFJ TklOR19MQU5FMF9TRVQsCj4gLQkJCWxhbmVfY291bnQsIGRwLT5saW5rX3RyYWluLnRyYWluaW5n X2xhbmUpOwo+ICsJcmV0dmFsID0gZHJtX2RwX2RwY2Rfd3JpdGUoJmRwLT5hdXgsIERQX1RSQUlO SU5HX0xBTkUwX1NFVCwKPiArCQkJCSAgIGRwLT5saW5rX3RyYWluLnRyYWluaW5nX2xhbmUsIGxh bmVfY291bnQpOwo+ICsJaWYgKHJldHZhbCA8IDApCj4gKwkJcmV0dXJuIHJldHZhbDsKPiAgIAo+ IC0JcmV0dXJuIHJldHZhbDsKPiArCXJldHVybiAwOwo+ICAgfQo+ICAgCj4gICBzdGF0aWMgdm9p ZCBhbmFsb2dpeF9kcF9nZXRfbWF4X3J4X2JhbmR3aWR0aChzdHJ1Y3QgYW5hbG9naXhfZHBfZGV2 aWNlICpkcCwKPiBAQCAtNjUzLDcgKzUyNCw3IEBAIHN0YXRpYyB2b2lkIGFuYWxvZ2l4X2RwX2dl dF9tYXhfcnhfYmFuZHdpZHRoKHN0cnVjdCBhbmFsb2dpeF9kcF9kZXZpY2UgKmRwLAo+ICAgCSAq IEZvciBEUCByZXYuMS4yLCBNYXhpbXVtIGxpbmsgcmF0ZSBvZiBNYWluIExpbmsgbGFuZXMKPiAg IAkgKiAweDA2ID0gMS42MiBHYnBzLCAweDBhID0gMi43IEdicHMsIDB4MTQgPSA1LjRHYnBzCj4g ICAJICovCj4gLQlhbmFsb2dpeF9kcF9yZWFkX2J5dGVfZnJvbV9kcGNkKGRwLCBEUF9NQVhfTElO S19SQVRFLCAmZGF0YSk7Cj4gKwlkcm1fZHBfZHBjZF9yZWFkYigmZHAtPmF1eCwgRFBfTUFYX0xJ TktfUkFURSwgJmRhdGEpOwo+ICAgCSpiYW5kd2lkdGggPSBkYXRhOwo+ICAgfQo+ICAgCj4gQEAg LTY2Niw3ICs1MzcsNyBAQCBzdGF0aWMgdm9pZCBhbmFsb2dpeF9kcF9nZXRfbWF4X3J4X2xhbmVf Y291bnQoc3RydWN0IGFuYWxvZ2l4X2RwX2RldmljZSAqZHAsCj4gICAJICogRm9yIERQIHJldi4x LjEsIE1heGltdW0gbnVtYmVyIG9mIE1haW4gTGluayBsYW5lcwo+ICAgCSAqIDB4MDEgPSAxIGxh bmUsIDB4MDIgPSAyIGxhbmVzLCAweDA0ID0gNCBsYW5lcwo+ICAgCSAqLwo+IC0JYW5hbG9naXhf ZHBfcmVhZF9ieXRlX2Zyb21fZHBjZChkcCwgRFBfTUFYX0xBTkVfQ09VTlQsICZkYXRhKTsKPiAr CWRybV9kcF9kcGNkX3JlYWRiKCZkcC0+YXV4LCBEUF9NQVhfTEFORV9DT1VOVCwgJmRhdGEpOwo+ ICAgCSpsYW5lX2NvdW50ID0gRFBDRF9NQVhfTEFORV9DT1VOVChkYXRhKTsKPiAgIH0KPiAgIAo+ IEBAIC04MzUsMTkgKzcwNiwxNSBAQCBzdGF0aWMgdm9pZCBhbmFsb2dpeF9kcF9lbmFibGVfc2Ny YW1ibGUoc3RydWN0IGFuYWxvZ2l4X2RwX2RldmljZSAqZHAsCj4gICAJaWYgKGVuYWJsZSkgewo+ ICAgCQlhbmFsb2dpeF9kcF9lbmFibGVfc2NyYW1ibGluZyhkcCk7Cj4gICAKPiAtCQlhbmFsb2dp eF9kcF9yZWFkX2J5dGVfZnJvbV9kcGNkKGRwLCBEUF9UUkFJTklOR19QQVRURVJOX1NFVCwKPiAt CQkJCQkJJmRhdGEpOwo+IC0JCWFuYWxvZ2l4X2RwX3dyaXRlX2J5dGVfdG9fZHBjZChkcCwKPiAt CQkJRFBfVFJBSU5JTkdfUEFUVEVSTl9TRVQsCj4gLQkJCSh1OCkoZGF0YSAmIH5EUF9MSU5LX1ND UkFNQkxJTkdfRElTQUJMRSkpOwo+ICsJCWRybV9kcF9kcGNkX3JlYWRiKCZkcC0+YXV4LCBEUF9U UkFJTklOR19QQVRURVJOX1NFVCwgJmRhdGEpOwo+ICsJCWRybV9kcF9kcGNkX3dyaXRlYigmZHAt PmF1eCwgRFBfVFJBSU5JTkdfUEFUVEVSTl9TRVQsCj4gKwkJCQkgICAodTgpKGRhdGEgJiB+RFBf TElOS19TQ1JBTUJMSU5HX0RJU0FCTEUpKTsKPiAgIAl9IGVsc2Ugewo+ICAgCQlhbmFsb2dpeF9k cF9kaXNhYmxlX3NjcmFtYmxpbmcoZHApOwo+ICAgCj4gLQkJYW5hbG9naXhfZHBfcmVhZF9ieXRl X2Zyb21fZHBjZChkcCwgRFBfVFJBSU5JTkdfUEFUVEVSTl9TRVQsCj4gLQkJCQkJCSZkYXRhKTsK PiAtCQlhbmFsb2dpeF9kcF93cml0ZV9ieXRlX3RvX2RwY2QoZHAsCj4gLQkJCURQX1RSQUlOSU5H X1BBVFRFUk5fU0VULAo+IC0JCQkodTgpKGRhdGEgfCBEUF9MSU5LX1NDUkFNQkxJTkdfRElTQUJM RSkpOwo+ICsJCWRybV9kcF9kcGNkX3JlYWRiKCZkcC0+YXV4LCBEUF9UUkFJTklOR19QQVRURVJO X1NFVCwgJmRhdGEpOwo+ICsJCWRybV9kcF9kcGNkX3dyaXRlYigmZHAtPmF1eCwgRFBfVFJBSU5J TkdfUEFUVEVSTl9TRVQsCj4gKwkJCQkgICAodTgpKGRhdGEgfCBEUF9MSU5LX1NDUkFNQkxJTkdf RElTQUJMRSkpOwo+ICAgCX0KPiAgIH0KPiAgIAo+IEBAIC05MjYsMTIgKzc5MywxMSBAQCBzdGF0 aWMgdm9pZCBhbmFsb2dpeF9kcF9jb21taXQoc3RydWN0IGFuYWxvZ2l4X2RwX2RldmljZSAqZHAp Cj4gICBpbnQgYW5hbG9naXhfZHBfZ2V0X21vZGVzKHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25u ZWN0b3IpCj4gICB7Cj4gICAJc3RydWN0IGFuYWxvZ2l4X2RwX2RldmljZSAqZHAgPSB0b19kcChj b25uZWN0b3IpOwo+IC0Jc3RydWN0IGVkaWQgKmVkaWQgPSAoc3RydWN0IGVkaWQgKilkcC0+ZWRp ZDsKPiAgIAlpbnQgbnVtX21vZGVzID0gMDsKPiAgIAo+IC0JaWYgKGFuYWxvZ2l4X2RwX2hhbmRs ZV9lZGlkKGRwKSA9PSAwKSB7Cj4gLQkJZHJtX21vZGVfY29ubmVjdG9yX3VwZGF0ZV9lZGlkX3By b3BlcnR5KCZkcC0+Y29ubmVjdG9yLCBlZGlkKTsKPiAtCQludW1fbW9kZXMgKz0gZHJtX2FkZF9l ZGlkX21vZGVzKCZkcC0+Y29ubmVjdG9yLCBlZGlkKTsKPiArCWlmICgoZHAtPmVkaWQgPSBkcm1f Z2V0X2VkaWQoY29ubmVjdG9yLCAmZHAtPmF1eC5kZGMpKSkgewo+ICsJCWRybV9tb2RlX2Nvbm5l Y3Rvcl91cGRhdGVfZWRpZF9wcm9wZXJ0eSgmZHAtPmNvbm5lY3RvciwgZHAtPmVkaWQpOwo+ICsJ CW51bV9tb2RlcyArPSBkcm1fYWRkX2VkaWRfbW9kZXMoJmRwLT5jb25uZWN0b3IsIGRwLT5lZGlk KTsKPiAgIAl9CgpZb3UgY291bGQgcmVtb3ZlIHRoZSAnLT5lZGlkJyB2YXJpYWJsZSBmcm9tIHN0 cnVjdCBhbmFsb2dpeF9kcF9kZXZpY2UsIApjYXVzZSB3ZSBkb24ndCBuZWVkIHRoaXMgaW5mb3Jt YXRpb24gYXQgb3RoZXIgcGxhY2VzLiBZb3UgbmVlZCB0byBmcmVlIAp0aGUgZWRpZCBhZnRlciBw YXJzZWQgaXQsIGNhdXNlIGVhY2ggdGltZSB3aGVuIHlvdSBjYWxsIGRybV9nZXRfZWRpZCgpIApo ZWxwZXIsIGl0IHdvdWxkIG1hbGxvYyBhIG5ldyBzcGFjZSBmb3IgJ2VkaWQnLiBCZXNpZGVzIEkg d291bGQgcHJlZmVyIAptb3ZlIHRoZSBzdGF0ZW1lbnQgb3V0IG9mIHRoZSBjb25kaXRpb24uCgoJ c3RydWN0IGVkaWQgKmVkaWQ7CgoJZWRpZCA9IGRybV9nZXRfZWRpZChjb25uZWN0b3IsICZkcC0+ YXV4LmRkYyk7CglpZiAoZWRpZCkgewoJCWRybV9tb2RlX2Nvbm5lY3Rvcl91cGRhdGVfZWRpZF9w cm9wZXJ0eSgmZHAtPmNvbm5lY3RvciwgZHAtPmVkaWQpOwoJCW51bV9tb2RlcyArPSBkcm1fYWRk X2VkaWRfbW9kZXMoJmRwLT5jb25uZWN0b3IsIGRwLT5lZGlkKTsKCQlrZnJlZShlZGlkKTsKCX0K Cj4gICAKPiAgIAlpZiAoZHAtPnBsYXRfZGF0YS0+cGFuZWwpCj4gQEAgLTk4NCw2ICs4NTAsMTM4 IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9mdW5jcyBhbmFsb2dpeF9kcF9j b25uZWN0b3JfZnVuY3MgPSB7Cj4gICAJLmF0b21pY19kZXN0cm95X3N0YXRlID0gZHJtX2F0b21p Y19oZWxwZXJfY29ubmVjdG9yX2Rlc3Ryb3lfc3RhdGUsCj4gICB9Owo+ICAgCj4gK3N0YXRpYyBz c2l6ZV90IGFuYWxvZ2l4X2RwYXV4X3RyYW5zZmVyKHN0cnVjdCBkcm1fZHBfYXV4ICphdXgsCj4g KwkJCQkgICAgICAgc3RydWN0IGRybV9kcF9hdXhfbXNnICptc2cpCj4gK3sKPiArCXN0cnVjdCBh bmFsb2dpeF9kcF9kZXZpY2UgKmRwID0gdG9fZHAoYXV4KTsKPiArCXUzMiByZWc7Cj4gKwl1OCAq YnVmZmVyID0gbXNnLT5idWZmZXI7Cj4gKwlpbnQgdGltZW91dF9sb29wID0gMDsKPiArCXVuc2ln bmVkIGludCBpOwo+ICsJaW50IHJldHZhbCA9IDA7Cj4gKwo+ICsJLyogQnVmZmVyIHNpemUgb2Yg QVVYIENIIGlzIDE2IGJ5dGVzICovCj4gKwlpZiAoV0FSTl9PTihtc2ctPnNpemUgPiAxNikpCj4g KwkJcmV0dXJuIC1FMkJJRzsKPiArCj4gKwkvKiBDbGVhciBBVVggQ0ggZGF0YSBidWZmZXIgKi8K PiArCXJlZyA9IEJVRl9DTFI7Cj4gKwl3cml0ZWwocmVnLCBkcC0+cmVnX2Jhc2UgKyBBTkFMT0dJ WF9EUF9CVUZGRVJfREFUQV9DVEwpOwo+ICsKPiArCXN3aXRjaCAobXNnLT5yZXF1ZXN0ICYgfkRQ X0FVWF9JMkNfTU9UKSB7Cj4gKwljYXNlIERQX0FVWF9JMkNfV1JJVEU6Cj4gKwkJcmVnID0gQVVY X1RYX0NPTU1fV1JJVEUgfCBBVVhfVFhfQ09NTV9JMkNfVFJBTlNBQ1RJT047Cj4gKwkJaWYgKG1z Zy0+cmVxdWVzdCAmIERQX0FVWF9JMkNfTU9UKQo+ICsJCQlyZWcgfD0gQVVYX1RYX0NPTU1fTU9U Owo+ICsKPiArCQlicmVhazsKPiArCj4gKwljYXNlIERQX0FVWF9JMkNfUkVBRDoKPiArCQlyZWcg PSBBVVhfVFhfQ09NTV9SRUFEIHwgQVVYX1RYX0NPTU1fSTJDX1RSQU5TQUNUSU9OOwo+ICsJCWlm IChtc2ctPnJlcXVlc3QgJiBEUF9BVVhfSTJDX01PVCkKPiArCQkJcmVnIHw9IEFVWF9UWF9DT01N X01PVDsKPiArCj4gKwkJYnJlYWs7Cj4gKwo+ICsJY2FzZSBEUF9BVVhfTkFUSVZFX1dSSVRFOgo+ ICsJCXJlZyA9IEFVWF9UWF9DT01NX1dSSVRFIHwgQVVYX1RYX0NPTU1fRFBfVFJBTlNBQ1RJT047 Cj4gKwkJYnJlYWs7Cj4gKwo+ICsJY2FzZSBEUF9BVVhfTkFUSVZFX1JFQUQ6Cj4gKwkJcmVnID0g QVVYX1RYX0NPTU1fUkVBRCB8IEFVWF9UWF9DT01NX0RQX1RSQU5TQUNUSU9OOwo+ICsJCWJyZWFr Owo+ICsKPiArCWRlZmF1bHQ6Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwl9Cj4gKwo+ICsJcmVn IHw9IEFVWF9MRU5HVEgobXNnLT5zaXplKTsKPiArCXdyaXRlbChyZWcsIGRwLT5yZWdfYmFzZSAr IEFOQUxPR0lYX0RQX0FVWF9DSF9DVExfMSk7Cj4gKwo+ICsJLyogU2VsZWN0IERQQ0QgZGV2aWNl IGFkZHJlc3MgKi8KPiArCXJlZyA9IEFVWF9BRERSXzdfMChtc2ctPmFkZHJlc3MpOwo+ICsJd3Jp dGVsKHJlZywgZHAtPnJlZ19iYXNlICsgQU5BTE9HSVhfRFBfQVVYX0FERFJfN18wKTsKPiArCXJl ZyA9IEFVWF9BRERSXzE1XzgobXNnLT5hZGRyZXNzKTsKPiArCXdyaXRlbChyZWcsIGRwLT5yZWdf YmFzZSArIEFOQUxPR0lYX0RQX0FVWF9BRERSXzE1XzgpOwo+ICsJcmVnID0gQVVYX0FERFJfMTlf MTYobXNnLT5hZGRyZXNzKTsKPiArCXdyaXRlbChyZWcsIGRwLT5yZWdfYmFzZSArIEFOQUxPR0lY X0RQX0FVWF9BRERSXzE5XzE2KTsKPiArCj4gKwlpZiAoKG1zZy0+cmVxdWVzdCAmIERQX0FVWF9J MkNfUkVBRCkgPT0gMCkgewo+ICsJCWZvciAoaSA9IDA7IGkgPCBtc2ctPnNpemU7IGkrKykgewo+ ICsJCQlyZWcgPSBidWZmZXJbaV07Cj4gKwkJCXdyaXRlbChyZWcsIGRwLT5yZWdfYmFzZSArIEFO QUxPR0lYX0RQX0JVRl9EQVRBXzAgKwo+ICsJCQkgICAgICAgNCAqIGkpOwo+ICsJCQlyZXR2YWwr KzsKPiArCQl9Cj4gKwl9Cj4gKwo+ICsJLyogRW5hYmxlIEFVWCBDSCBvcGVyYXRpb24gKi8KPiAr CXJlZyA9IDA7Cj4gKwo+ICsJLyogWmVyby1zaXplZCBtZXNzYWdlcyBzcGVjaWZ5IGFkZHJlc3Mt b25seSB0cmFuc2FjdGlvbnMuICovCj4gKwlpZiAobXNnLT5zaXplIDwgMSkKPiArCQlyZWcgfD0g QUREUl9PTkxZOwo+ICsKPiArCXJlZyB8PSBBVVhfRU47Cj4gKwl3cml0ZWwocmVnLCBkcC0+cmVn X2Jhc2UgKyBBTkFMT0dJWF9EUF9BVVhfQ0hfQ1RMXzIpOwo+ICsKPiArCS8qIElzIEFVWCBDSCBj b21tYW5kIHJlcGx5IHJlY2VpdmVkPyAqLwo+ICsJLyogVE9ETzogV2FpdCBmb3IgYW4gaW50ZXJy dXB0IGluc3RlYWQgb2YgbG9vcGluZz8gKi8KPiArCXJlZyA9IHJlYWRsKGRwLT5yZWdfYmFzZSAr IEFOQUxPR0lYX0RQX0lOVF9TVEEpOwo+ICsJd2hpbGUgKCEocmVnICYgUlBMWV9SRUNFSVYpKSB7 Cj4gKwkJdGltZW91dF9sb29wKys7Cj4gKwkJaWYgKERQX1RJTUVPVVRfTE9PUF9DT1VOVCA8IHRp bWVvdXRfbG9vcCkgewo+ICsJCQlkZXZfZXJyKGRwLT5kZXYsICJBVVggQ0ggY29tbWFuZCByZXBs eSBmYWlsZWQhXG4iKTsKPiArCQkJcmV0dXJuIC1FVElNRURPVVQ7Cj4gKwkJfQo+ICsJCXJlZyA9 IHJlYWRsKGRwLT5yZWdfYmFzZSArIEFOQUxPR0lYX0RQX0lOVF9TVEEpOwo+ICsJCXVzbGVlcF9y YW5nZSgxMCwgMTEpOwo+ICsJfQo+ICsKPiArCS8qIENsZWFyIGludGVycnVwdCBzb3VyY2UgZm9y IEFVWCBDSCBjb21tYW5kIHJlcGx5ICovCj4gKwl3cml0ZWwoUlBMWV9SRUNFSVYsIGRwLT5yZWdf YmFzZSArIEFOQUxPR0lYX0RQX0lOVF9TVEEpOwo+ICsKPiArCS8qIENsZWFyIGludGVycnVwdCBz b3VyY2UgZm9yIEFVWCBDSCBhY2Nlc3MgZXJyb3IgKi8KPiArCXJlZyA9IHJlYWRsKGRwLT5yZWdf YmFzZSArIEFOQUxPR0lYX0RQX0lOVF9TVEEpOwo+ICsJaWYgKHJlZyAmIEFVWF9FUlIpIHsKPiAr CQl3cml0ZWwoQVVYX0VSUiwgZHAtPnJlZ19iYXNlICsgQU5BTE9HSVhfRFBfSU5UX1NUQSk7Cj4g KwkJcmV0dXJuIC1FUkVNT1RFSU87Cj4gKwl9Cj4gKwo+ICsJLyogQ2hlY2sgQVVYIENIIGVycm9y IGFjY2VzcyBzdGF0dXMgKi8KPiArCXJlZyA9IHJlYWRsKGRwLT5yZWdfYmFzZSArIEFOQUxPR0lY X0RQX0FVWF9DSF9TVEEpOwo+ICsJaWYgKChyZWcgJiBBVVhfU1RBVFVTX01BU0spICE9IDApIHsK PiArCQlkZXZfZXJyKGRwLT5kZXYsICJBVVggQ0ggZXJyb3IgaGFwcGVuczogJWRcblxuIiwKPiAr CQkJcmVnICYgQVVYX1NUQVRVU19NQVNLKTsKPiArCQlyZXR1cm4gLUVSRU1PVEVJTzsKPiArCX0K PiArCj4gKwlpZiAobXNnLT5yZXF1ZXN0ICYgRFBfQVVYX0kyQ19SRUFEKSB7Cj4gKwkJZm9yIChp ID0gMDsgaSA8IG1zZy0+c2l6ZTsgaSsrKSB7Cj4gKwkJCXJlZyA9IHJlYWRsKGRwLT5yZWdfYmFz ZSArIEFOQUxPR0lYX0RQX0JVRl9EQVRBXzAgKwo+ICsJCQkJICAgIDQgKiBpKTsKPiArCQkJYnVm ZmVyW2ldID0gKHVuc2lnbmVkIGNoYXIpcmVnOwo+ICsJCQlyZXR2YWwrKzsKPiArCQl9Cj4gKwl9 Cj4gKwo+ICsJLyogQ2hlY2sgaWYgUnggc2VuZHMgZGVmZXIgKi8KPiArCXJlZyA9IHJlYWRsKGRw LT5yZWdfYmFzZSArIEFOQUxPR0lYX0RQX0FVWF9SWF9DT01NKTsKPiArCWlmIChyZWcgPT0gQVVY X1JYX0NPTU1fQVVYX0RFRkVSKQo+ICsJCW1zZy0+cmVwbHkgPSBEUF9BVVhfTkFUSVZFX1JFUExZ X0RFRkVSOwo+ICsJZWxzZSBpZiAocmVnID09IEFVWF9SWF9DT01NX0kyQ19ERUZFUikKPiArCQlt c2ctPnJlcGx5ID0gRFBfQVVYX0kyQ19SRVBMWV9ERUZFUjsKPiArCWVsc2UgaWYgKChtc2ctPnJl cXVlc3QgJiB+RFBfQVVYX0kyQ19NT1QpID09IERQX0FVWF9JMkNfV1JJVEUgfHwKPiArCQkgKG1z Zy0+cmVxdWVzdCAmIH5EUF9BVVhfSTJDX01PVCkgPT0gRFBfQVVYX0kyQ19SRUFEKQo+ICsJCW1z Zy0+cmVwbHkgPSBEUF9BVVhfSTJDX1JFUExZX0FDSzsKPiArCWVsc2UgaWYgKChtc2ctPnJlcXVl c3QgJiB+RFBfQVVYX0kyQ19NT1QpID09IERQX0FVWF9OQVRJVkVfV1JJVEUgfHwKPiArCQkgKG1z Zy0+cmVxdWVzdCAmIH5EUF9BVVhfSTJDX01PVCkgPT0gRFBfQVVYX05BVElWRV9SRUFEKQo+ICsJ CW1zZy0+cmVwbHkgPSBEUF9BVVhfTkFUSVZFX1JFUExZX0FDSzsKPiArCj4gKwlyZXR1cm4gcmV0 dmFsOwo+ICt9Cj4gKwoKV291bGQgeW91IGxpa2UgdG8gbW92ZSB0aGlzIGZ1bmN0aW9uIHRvICdh bmFsb2dpeF9kcF9yZWcuYycgPwoKPiArCj4gICBzdGF0aWMgaW50IGFuYWxvZ2l4X2RwX2JyaWRn ZV9hdHRhY2goc3RydWN0IGRybV9icmlkZ2UgKmJyaWRnZSkKPiAgIHsKPiAgIAlzdHJ1Y3QgYW5h bG9naXhfZHBfZGV2aWNlICpkcCA9IGJyaWRnZS0+ZHJpdmVyX3ByaXZhdGU7Cj4gQEAgLTEzNTUs NiArMTM1MywxNCBAQCBpbnQgYW5hbG9naXhfZHBfYmluZChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0 cnVjdCBkcm1fZGV2aWNlICpkcm1fZGV2LAo+ICAgCWRwLT5kcm1fZGV2ID0gZHJtX2RldjsKPiAg IAlkcC0+ZW5jb2RlciA9IGRwLT5wbGF0X2RhdGEtPmVuY29kZXI7Cj4gICAKPiArCWRwLT5hdXgu bmFtZSA9ICJEUC1BVVgiOwo+ICsJZHAtPmF1eC50cmFuc2ZlciA9IGFuYWxvZ2l4X2RwYXV4X3Ry YW5zZmVyOwo+ICsJZHAtPmF1eC5kZXYgPSAmcGRldi0+ZGV2Owo+ICsKPiArCXJldCA9IGRybV9k cF9hdXhfcmVnaXN0ZXIoJmRwLT5hdXgpOwo+ICsJaWYgKHJldCkKPiArCQlnb3RvIGVycl9kaXNh YmxlX3BtX3J1bnRpbWU7Cj4gKwo+ICAgCXJldCA9IGFuYWxvZ2l4X2RwX2NyZWF0ZV9icmlkZ2Uo ZHJtX2RldiwgZHApOwo+ICAgCWlmIChyZXQpIHsKPiAgIAkJRFJNX0VSUk9SKCJmYWlsZWQgdG8g Y3JlYXRlIGJyaWRnZSAoJWQpXG4iLCByZXQpOwo+IEBAIC0xMzg0LDYgKzEzOTAsOCBAQCB2b2lk IGFuYWxvZ2l4X2RwX3VuYmluZChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2UgKm1h c3RlciwKPiAgIAl9Cj4gICAKPiAgIAlwbV9ydW50aW1lX2Rpc2FibGUoZGV2KTsKPiArCj4gKwlr ZnJlZShkcC0+ZWRpZCk7CgpDb3VsZCByZW1vdmUgdGhpcyBmcmVlIGNvZGUuCgoKVGhhbmtzLAot IFlha2lyCgo+ICAgfQo+ICAgRVhQT1JUX1NZTUJPTF9HUEwoYW5hbG9naXhfZHBfdW5iaW5kKTsK PiAgIAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYnJpZGdlL2FuYWxvZ2l4L2FuYWxv Z2l4X2RwX2NvcmUuaCBiL2RyaXZlcnMvZ3B1L2RybS9icmlkZ2UvYW5hbG9naXgvYW5hbG9naXhf ZHBfY29yZS5oCj4gaW5kZXggYjQ1NjM4MDQzZWM0Li4yN2ViMjdhNzE4MDIgMTAwNjQ0Cj4gLS0t IGEvZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9hbmFsb2dpeC9hbmFsb2dpeF9kcF9jb3JlLmgKPiAr KysgYi9kcml2ZXJzL2dwdS9kcm0vYnJpZGdlL2FuYWxvZ2l4L2FuYWxvZ2l4X2RwX2NvcmUuaAo+ IEBAIC0yMCwxNSArMjAsNiBAQAo+ICAgI2RlZmluZSBNQVhfQ1JfTE9PUCA1Cj4gICAjZGVmaW5l IE1BWF9FUV9MT09QIDUKPiAgIAo+IC0vKiBJMkMgRURJRCBDaGlwIElELCBTbGF2ZSBBZGRyZXNz ICovCj4gLSNkZWZpbmUgSTJDX0VESURfREVWSUNFX0FERFIJCQkweDUwCj4gLSNkZWZpbmUgSTJD X0VfRURJRF9ERVZJQ0VfQUREUgkJCTB4MzAKPiAtCj4gLSNkZWZpbmUgRURJRF9CTE9DS19MRU5H VEgJCQkweDgwCj4gLSNkZWZpbmUgRURJRF9IRUFERVJfUEFUVEVSTgkJCTB4MDAKPiAtI2RlZmlu ZSBFRElEX0VYVEVOU0lPTl9GTEFHCQkJMHg3ZQo+IC0jZGVmaW5lIEVESURfQ0hFQ0tTVU0JCQkJ MHg3Zgo+IC0KPiAgIC8qIERQX01BWF9MQU5FX0NPVU5UICovCj4gICAjZGVmaW5lIERQQ0RfRU5I QU5DRURfRlJBTUVfQ0FQKHgpCQkoKCh4KSA+PiA3KSAmIDB4MSkKPiAgICNkZWZpbmUgRFBDRF9N QVhfTEFORV9DT1VOVCh4KQkJCSgoeCkgJiAweDFmKQo+IEBAIC0xNjYsNiArMTU3LDcgQEAgc3Ry dWN0IGFuYWxvZ2l4X2RwX2RldmljZSB7Cj4gICAJc3RydWN0IGRybV9kZXZpY2UJKmRybV9kZXY7 Cj4gICAJc3RydWN0IGRybV9jb25uZWN0b3IJY29ubmVjdG9yOwo+ICAgCXN0cnVjdCBkcm1fYnJp ZGdlCSpicmlkZ2U7Cj4gKwlzdHJ1Y3QgZHJtX2RwX2F1eCAgICAgICBhdXg7Cj4gICAJc3RydWN0 IGNsawkJKmNsb2NrOwo+ICAgCXVuc2lnbmVkIGludAkJaXJxOwo+ICAgCXZvaWQgX19pb21lbQkJ KnJlZ19iYXNlOwo+IEBAIC0xNzYsNyArMTY4LDcgQEAgc3RydWN0IGFuYWxvZ2l4X2RwX2Rldmlj ZSB7Cj4gICAJaW50CQkJZHBtc19tb2RlOwo+ICAgCWludAkJCWhwZF9ncGlvOwo+ICAgCWJvb2wg ICAgICAgICAgICAgICAgICAgIGZvcmNlX2hwZDsKPiAtCXVuc2lnbmVkIGNoYXIgICAgICAgICAg IGVkaWRbRURJRF9CTE9DS19MRU5HVEggKiAyXTsKPiArCXN0cnVjdCBlZGlkCQkqZWRpZDsKPiAg IAo+ICAgCXN0cnVjdCBhbmFsb2dpeF9kcF9wbGF0X2RhdGEgKnBsYXRfZGF0YTsKPiAgIH07Cj4g QEAgLTIwNiwzMyArMTk4LDYgQEAgdm9pZCBhbmFsb2dpeF9kcF9yZXNldF9hdXgoc3RydWN0IGFu YWxvZ2l4X2RwX2RldmljZSAqZHApOwo+ICAgdm9pZCBhbmFsb2dpeF9kcF9pbml0X2F1eChzdHJ1 Y3QgYW5hbG9naXhfZHBfZGV2aWNlICpkcCk7Cj4gICBpbnQgYW5hbG9naXhfZHBfZ2V0X3BsdWdf aW5fc3RhdHVzKHN0cnVjdCBhbmFsb2dpeF9kcF9kZXZpY2UgKmRwKTsKPiAgIHZvaWQgYW5hbG9n aXhfZHBfZW5hYmxlX3N3X2Z1bmN0aW9uKHN0cnVjdCBhbmFsb2dpeF9kcF9kZXZpY2UgKmRwKTsK PiAtaW50IGFuYWxvZ2l4X2RwX3N0YXJ0X2F1eF90cmFuc2FjdGlvbihzdHJ1Y3QgYW5hbG9naXhf ZHBfZGV2aWNlICpkcCk7Cj4gLWludCBhbmFsb2dpeF9kcF93cml0ZV9ieXRlX3RvX2RwY2Qoc3Ry dWN0IGFuYWxvZ2l4X2RwX2RldmljZSAqZHAsCj4gLQkJCQkgICB1bnNpZ25lZCBpbnQgcmVnX2Fk ZHIsCj4gLQkJCQkgICB1bnNpZ25lZCBjaGFyIGRhdGEpOwo+IC1pbnQgYW5hbG9naXhfZHBfcmVh ZF9ieXRlX2Zyb21fZHBjZChzdHJ1Y3QgYW5hbG9naXhfZHBfZGV2aWNlICpkcCwKPiAtCQkJCSAg ICB1bnNpZ25lZCBpbnQgcmVnX2FkZHIsCj4gLQkJCQkgICAgdW5zaWduZWQgY2hhciAqZGF0YSk7 Cj4gLWludCBhbmFsb2dpeF9kcF93cml0ZV9ieXRlc190b19kcGNkKHN0cnVjdCBhbmFsb2dpeF9k cF9kZXZpY2UgKmRwLAo+IC0JCQkJICAgIHVuc2lnbmVkIGludCByZWdfYWRkciwKPiAtCQkJCSAg ICB1bnNpZ25lZCBpbnQgY291bnQsCj4gLQkJCQkgICAgdW5zaWduZWQgY2hhciBkYXRhW10pOwo+ IC1pbnQgYW5hbG9naXhfZHBfcmVhZF9ieXRlc19mcm9tX2RwY2Qoc3RydWN0IGFuYWxvZ2l4X2Rw X2RldmljZSAqZHAsCj4gLQkJCQkgICAgIHVuc2lnbmVkIGludCByZWdfYWRkciwKPiAtCQkJCSAg ICAgdW5zaWduZWQgaW50IGNvdW50LAo+IC0JCQkJICAgICB1bnNpZ25lZCBjaGFyIGRhdGFbXSk7 Cj4gLWludCBhbmFsb2dpeF9kcF9zZWxlY3RfaTJjX2RldmljZShzdHJ1Y3QgYW5hbG9naXhfZHBf ZGV2aWNlICpkcCwKPiAtCQkJCSAgdW5zaWduZWQgaW50IGRldmljZV9hZGRyLAo+IC0JCQkJICB1 bnNpZ25lZCBpbnQgcmVnX2FkZHIpOwo+IC1pbnQgYW5hbG9naXhfZHBfcmVhZF9ieXRlX2Zyb21f aTJjKHN0cnVjdCBhbmFsb2dpeF9kcF9kZXZpY2UgKmRwLAo+IC0JCQkJICAgdW5zaWduZWQgaW50 IGRldmljZV9hZGRyLAo+IC0JCQkJICAgdW5zaWduZWQgaW50IHJlZ19hZGRyLAo+IC0JCQkJICAg dW5zaWduZWQgaW50ICpkYXRhKTsKPiAtaW50IGFuYWxvZ2l4X2RwX3JlYWRfYnl0ZXNfZnJvbV9p MmMoc3RydWN0IGFuYWxvZ2l4X2RwX2RldmljZSAqZHAsCj4gLQkJCQkgICAgdW5zaWduZWQgaW50 IGRldmljZV9hZGRyLAo+IC0JCQkJICAgIHVuc2lnbmVkIGludCByZWdfYWRkciwKPiAtCQkJCSAg ICB1bnNpZ25lZCBpbnQgY291bnQsCj4gLQkJCQkgICAgdW5zaWduZWQgY2hhciBlZGlkW10pOwo+ ICAgdm9pZCBhbmFsb2dpeF9kcF9zZXRfbGlua19iYW5kd2lkdGgoc3RydWN0IGFuYWxvZ2l4X2Rw X2RldmljZSAqZHAsIHUzMiBid3R5cGUpOwo+ICAgdm9pZCBhbmFsb2dpeF9kcF9nZXRfbGlua19i YW5kd2lkdGgoc3RydWN0IGFuYWxvZ2l4X2RwX2RldmljZSAqZHAsIHUzMiAqYnd0eXBlKTsKPiAg IHZvaWQgYW5hbG9naXhfZHBfc2V0X2xhbmVfY291bnQoc3RydWN0IGFuYWxvZ2l4X2RwX2Rldmlj ZSAqZHAsIHUzMiBjb3VudCk7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9icmlkZ2Uv YW5hbG9naXgvYW5hbG9naXhfZHBfcmVnLmMgYi9kcml2ZXJzL2dwdS9kcm0vYnJpZGdlL2FuYWxv Z2l4L2FuYWxvZ2l4X2RwX3JlZy5jCj4gaW5kZXggNDgwMzBmMGNmNDk3Li5lYWM2MWFhNDIyNGYg MTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9hbmFsb2dpeC9hbmFsb2dpeF9k cF9yZWcuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9icmlkZ2UvYW5hbG9naXgvYW5hbG9naXhf ZHBfcmVnLmMKPiBAQCAtNTg1LDMzMCArNTg1LDYgQEAgaW50IGFuYWxvZ2l4X2RwX3dyaXRlX2J5 dGVfdG9fZHBjZChzdHJ1Y3QgYW5hbG9naXhfZHBfZGV2aWNlICpkcCwKPiAgIAlyZXR1cm4gcmV0 dmFsOwo+ICAgfQo+ICAgCj4gLWludCBhbmFsb2dpeF9kcF9yZWFkX2J5dGVfZnJvbV9kcGNkKHN0 cnVjdCBhbmFsb2dpeF9kcF9kZXZpY2UgKmRwLAo+IC0JCQkJICAgIHVuc2lnbmVkIGludCByZWdf YWRkciwKPiAtCQkJCSAgICB1bnNpZ25lZCBjaGFyICpkYXRhKQo+IC17Cj4gLQl1MzIgcmVnOwo+ IC0JaW50IGk7Cj4gLQlpbnQgcmV0dmFsOwo+IC0KPiAtCWZvciAoaSA9IDA7IGkgPCAzOyBpKysp IHsKPiAtCQkvKiBDbGVhciBBVVggQ0ggZGF0YSBidWZmZXIgKi8KPiAtCQlyZWcgPSBCVUZfQ0xS Owo+IC0JCXdyaXRlbChyZWcsIGRwLT5yZWdfYmFzZSArIEFOQUxPR0lYX0RQX0JVRkZFUl9EQVRB X0NUTCk7Cj4gLQo+IC0JCS8qIFNlbGVjdCBEUENEIGRldmljZSBhZGRyZXNzICovCj4gLQkJcmVn ID0gQVVYX0FERFJfN18wKHJlZ19hZGRyKTsKPiAtCQl3cml0ZWwocmVnLCBkcC0+cmVnX2Jhc2Ug KyBBTkFMT0dJWF9EUF9BVVhfQUREUl83XzApOwo+IC0JCXJlZyA9IEFVWF9BRERSXzE1XzgocmVn X2FkZHIpOwo+IC0JCXdyaXRlbChyZWcsIGRwLT5yZWdfYmFzZSArIEFOQUxPR0lYX0RQX0FVWF9B RERSXzE1XzgpOwo+IC0JCXJlZyA9IEFVWF9BRERSXzE5XzE2KHJlZ19hZGRyKTsKPiAtCQl3cml0 ZWwocmVnLCBkcC0+cmVnX2Jhc2UgKyBBTkFMT0dJWF9EUF9BVVhfQUREUl8xOV8xNik7Cj4gLQo+ IC0JCS8qCj4gLQkJICogU2V0IERpc3BsYXlQb3J0IHRyYW5zYWN0aW9uIGFuZCByZWFkIDEgYnl0 ZQo+IC0JCSAqIElmIGJpdCAzIGlzIDEsIERpc3BsYXlQb3J0IHRyYW5zYWN0aW9uLgo+IC0JCSAq IElmIEJpdCAzIGlzIDAsIEkyQyB0cmFuc2FjdGlvbi4KPiAtCQkgKi8KPiAtCQlyZWcgPSBBVVhf VFhfQ09NTV9EUF9UUkFOU0FDVElPTiB8IEFVWF9UWF9DT01NX1JFQUQ7Cj4gLQkJd3JpdGVsKHJl ZywgZHAtPnJlZ19iYXNlICsgQU5BTE9HSVhfRFBfQVVYX0NIX0NUTF8xKTsKPiAtCj4gLQkJLyog U3RhcnQgQVVYIHRyYW5zYWN0aW9uICovCj4gLQkJcmV0dmFsID0gYW5hbG9naXhfZHBfc3RhcnRf YXV4X3RyYW5zYWN0aW9uKGRwKTsKPiAtCQlpZiAocmV0dmFsID09IDApCj4gLQkJCWJyZWFrOwo+ IC0KPiAtCQlkZXZfZGJnKGRwLT5kZXYsICIlczogQXV4IFRyYW5zYWN0aW9uIGZhaWwhXG4iLCBf X2Z1bmNfXyk7Cj4gLQl9Cj4gLQo+IC0JLyogUmVhZCBkYXRhIGJ1ZmZlciAqLwo+IC0JcmVnID0g cmVhZGwoZHAtPnJlZ19iYXNlICsgQU5BTE9HSVhfRFBfQlVGX0RBVEFfMCk7Cj4gLQkqZGF0YSA9 ICh1bnNpZ25lZCBjaGFyKShyZWcgJiAweGZmKTsKPiAtCj4gLQlyZXR1cm4gcmV0dmFsOwo+IC19 Cj4gLQo+IC1pbnQgYW5hbG9naXhfZHBfd3JpdGVfYnl0ZXNfdG9fZHBjZChzdHJ1Y3QgYW5hbG9n aXhfZHBfZGV2aWNlICpkcCwKPiAtCQkJCSAgICB1bnNpZ25lZCBpbnQgcmVnX2FkZHIsCj4gLQkJ CQkgICAgdW5zaWduZWQgaW50IGNvdW50LAo+IC0JCQkJICAgIHVuc2lnbmVkIGNoYXIgZGF0YVtd KQo+IC17Cj4gLQl1MzIgcmVnOwo+IC0JdW5zaWduZWQgaW50IHN0YXJ0X29mZnNldDsKPiAtCXVu c2lnbmVkIGludCBjdXJfZGF0YV9jb3VudDsKPiAtCXVuc2lnbmVkIGludCBjdXJfZGF0YV9pZHg7 Cj4gLQlpbnQgaTsKPiAtCWludCByZXR2YWwgPSAwOwo+IC0KPiAtCS8qIENsZWFyIEFVWCBDSCBk YXRhIGJ1ZmZlciAqLwo+IC0JcmVnID0gQlVGX0NMUjsKPiAtCXdyaXRlbChyZWcsIGRwLT5yZWdf YmFzZSArIEFOQUxPR0lYX0RQX0JVRkZFUl9EQVRBX0NUTCk7Cj4gLQo+IC0Jc3RhcnRfb2Zmc2V0 ID0gMDsKPiAtCXdoaWxlIChzdGFydF9vZmZzZXQgPCBjb3VudCkgewo+IC0JCS8qIEJ1ZmZlciBz aXplIG9mIEFVWCBDSCBpcyAxNiAqIDRieXRlcyAqLwo+IC0JCWlmICgoY291bnQgLSBzdGFydF9v ZmZzZXQpID4gMTYpCj4gLQkJCWN1cl9kYXRhX2NvdW50ID0gMTY7Cj4gLQkJZWxzZQo+IC0JCQlj dXJfZGF0YV9jb3VudCA9IGNvdW50IC0gc3RhcnRfb2Zmc2V0Owo+IC0KPiAtCQlmb3IgKGkgPSAw OyBpIDwgMzsgaSsrKSB7Cj4gLQkJCS8qIFNlbGVjdCBEUENEIGRldmljZSBhZGRyZXNzICovCj4g LQkJCXJlZyA9IEFVWF9BRERSXzdfMChyZWdfYWRkciArIHN0YXJ0X29mZnNldCk7Cj4gLQkJCXdy aXRlbChyZWcsIGRwLT5yZWdfYmFzZSArIEFOQUxPR0lYX0RQX0FVWF9BRERSXzdfMCk7Cj4gLQkJ CXJlZyA9IEFVWF9BRERSXzE1XzgocmVnX2FkZHIgKyBzdGFydF9vZmZzZXQpOwo+IC0JCQl3cml0 ZWwocmVnLCBkcC0+cmVnX2Jhc2UgKyBBTkFMT0dJWF9EUF9BVVhfQUREUl8xNV84KTsKPiAtCQkJ cmVnID0gQVVYX0FERFJfMTlfMTYocmVnX2FkZHIgKyBzdGFydF9vZmZzZXQpOwo+IC0JCQl3cml0 ZWwocmVnLCBkcC0+cmVnX2Jhc2UgKyBBTkFMT0dJWF9EUF9BVVhfQUREUl8xOV8xNik7Cj4gLQo+ IC0JCQlmb3IgKGN1cl9kYXRhX2lkeCA9IDA7IGN1cl9kYXRhX2lkeCA8IGN1cl9kYXRhX2NvdW50 Owo+IC0JCQkgICAgIGN1cl9kYXRhX2lkeCsrKSB7Cj4gLQkJCQlyZWcgPSBkYXRhW3N0YXJ0X29m ZnNldCArIGN1cl9kYXRhX2lkeF07Cj4gLQkJCQl3cml0ZWwocmVnLCBkcC0+cmVnX2Jhc2UgKwo+ IC0JCQkJICAgICAgIEFOQUxPR0lYX0RQX0JVRl9EQVRBXzAgKwo+IC0JCQkJICAgICAgIDQgKiBj dXJfZGF0YV9pZHgpOwo+IC0JCQl9Cj4gLQo+IC0JCQkvKgo+IC0JCQkgKiBTZXQgRGlzcGxheVBv cnQgdHJhbnNhY3Rpb24gYW5kIHdyaXRlCj4gLQkJCSAqIElmIGJpdCAzIGlzIDEsIERpc3BsYXlQ b3J0IHRyYW5zYWN0aW9uLgo+IC0JCQkgKiBJZiBCaXQgMyBpcyAwLCBJMkMgdHJhbnNhY3Rpb24u Cj4gLQkJCSAqLwo+IC0JCQlyZWcgPSBBVVhfTEVOR1RIKGN1cl9kYXRhX2NvdW50KSB8Cj4gLQkJ CQlBVVhfVFhfQ09NTV9EUF9UUkFOU0FDVElPTiB8IEFVWF9UWF9DT01NX1dSSVRFOwo+IC0JCQl3 cml0ZWwocmVnLCBkcC0+cmVnX2Jhc2UgKyBBTkFMT0dJWF9EUF9BVVhfQ0hfQ1RMXzEpOwo+IC0K PiAtCQkJLyogU3RhcnQgQVVYIHRyYW5zYWN0aW9uICovCj4gLQkJCXJldHZhbCA9IGFuYWxvZ2l4 X2RwX3N0YXJ0X2F1eF90cmFuc2FjdGlvbihkcCk7Cj4gLQkJCWlmIChyZXR2YWwgPT0gMCkKPiAt CQkJCWJyZWFrOwo+IC0KPiAtCQkJZGV2X2RiZyhkcC0+ZGV2LCAiJXM6IEF1eCBUcmFuc2FjdGlv biBmYWlsIVxuIiwKPiAtCQkJCV9fZnVuY19fKTsKPiAtCQl9Cj4gLQo+IC0JCXN0YXJ0X29mZnNl dCArPSBjdXJfZGF0YV9jb3VudDsKPiAtCX0KPiAtCj4gLQlyZXR1cm4gcmV0dmFsOwo+IC19Cj4g LQo+IC1pbnQgYW5hbG9naXhfZHBfcmVhZF9ieXRlc19mcm9tX2RwY2Qoc3RydWN0IGFuYWxvZ2l4 X2RwX2RldmljZSAqZHAsCj4gLQkJCQkgICAgIHVuc2lnbmVkIGludCByZWdfYWRkciwKPiAtCQkJ CSAgICAgdW5zaWduZWQgaW50IGNvdW50LAo+IC0JCQkJICAgICB1bnNpZ25lZCBjaGFyIGRhdGFb XSkKPiAtewo+IC0JdTMyIHJlZzsKPiAtCXVuc2lnbmVkIGludCBzdGFydF9vZmZzZXQ7Cj4gLQl1 bnNpZ25lZCBpbnQgY3VyX2RhdGFfY291bnQ7Cj4gLQl1bnNpZ25lZCBpbnQgY3VyX2RhdGFfaWR4 Owo+IC0JaW50IGk7Cj4gLQlpbnQgcmV0dmFsID0gMDsKPiAtCj4gLQkvKiBDbGVhciBBVVggQ0gg ZGF0YSBidWZmZXIgKi8KPiAtCXJlZyA9IEJVRl9DTFI7Cj4gLQl3cml0ZWwocmVnLCBkcC0+cmVn X2Jhc2UgKyBBTkFMT0dJWF9EUF9CVUZGRVJfREFUQV9DVEwpOwo+IC0KPiAtCXN0YXJ0X29mZnNl dCA9IDA7Cj4gLQl3aGlsZSAoc3RhcnRfb2Zmc2V0IDwgY291bnQpIHsKPiAtCQkvKiBCdWZmZXIg c2l6ZSBvZiBBVVggQ0ggaXMgMTYgKiA0Ynl0ZXMgKi8KPiAtCQlpZiAoKGNvdW50IC0gc3RhcnRf b2Zmc2V0KSA+IDE2KQo+IC0JCQljdXJfZGF0YV9jb3VudCA9IDE2Owo+IC0JCWVsc2UKPiAtCQkJ Y3VyX2RhdGFfY291bnQgPSBjb3VudCAtIHN0YXJ0X29mZnNldDsKPiAtCj4gLQkJLyogQVVYIENI IFJlcXVlc3QgVHJhbnNhY3Rpb24gcHJvY2VzcyAqLwo+IC0JCWZvciAoaSA9IDA7IGkgPCAzOyBp KyspIHsKPiAtCQkJLyogU2VsZWN0IERQQ0QgZGV2aWNlIGFkZHJlc3MgKi8KPiAtCQkJcmVnID0g QVVYX0FERFJfN18wKHJlZ19hZGRyICsgc3RhcnRfb2Zmc2V0KTsKPiAtCQkJd3JpdGVsKHJlZywg ZHAtPnJlZ19iYXNlICsgQU5BTE9HSVhfRFBfQVVYX0FERFJfN18wKTsKPiAtCQkJcmVnID0gQVVY X0FERFJfMTVfOChyZWdfYWRkciArIHN0YXJ0X29mZnNldCk7Cj4gLQkJCXdyaXRlbChyZWcsIGRw LT5yZWdfYmFzZSArIEFOQUxPR0lYX0RQX0FVWF9BRERSXzE1XzgpOwo+IC0JCQlyZWcgPSBBVVhf QUREUl8xOV8xNihyZWdfYWRkciArIHN0YXJ0X29mZnNldCk7Cj4gLQkJCXdyaXRlbChyZWcsIGRw LT5yZWdfYmFzZSArIEFOQUxPR0lYX0RQX0FVWF9BRERSXzE5XzE2KTsKPiAtCj4gLQkJCS8qCj4g LQkJCSAqIFNldCBEaXNwbGF5UG9ydCB0cmFuc2FjdGlvbiBhbmQgcmVhZAo+IC0JCQkgKiBJZiBi aXQgMyBpcyAxLCBEaXNwbGF5UG9ydCB0cmFuc2FjdGlvbi4KPiAtCQkJICogSWYgQml0IDMgaXMg MCwgSTJDIHRyYW5zYWN0aW9uLgo+IC0JCQkgKi8KPiAtCQkJcmVnID0gQVVYX0xFTkdUSChjdXJf ZGF0YV9jb3VudCkgfAo+IC0JCQkJQVVYX1RYX0NPTU1fRFBfVFJBTlNBQ1RJT04gfCBBVVhfVFhf Q09NTV9SRUFEOwo+IC0JCQl3cml0ZWwocmVnLCBkcC0+cmVnX2Jhc2UgKyBBTkFMT0dJWF9EUF9B VVhfQ0hfQ1RMXzEpOwo+IC0KPiAtCQkJLyogU3RhcnQgQVVYIHRyYW5zYWN0aW9uICovCj4gLQkJ CXJldHZhbCA9IGFuYWxvZ2l4X2RwX3N0YXJ0X2F1eF90cmFuc2FjdGlvbihkcCk7Cj4gLQkJCWlm IChyZXR2YWwgPT0gMCkKPiAtCQkJCWJyZWFrOwo+IC0KPiAtCQkJZGV2X2RiZyhkcC0+ZGV2LCAi JXM6IEF1eCBUcmFuc2FjdGlvbiBmYWlsIVxuIiwKPiAtCQkJCV9fZnVuY19fKTsKPiAtCQl9Cj4g LQo+IC0JCWZvciAoY3VyX2RhdGFfaWR4ID0gMDsgY3VyX2RhdGFfaWR4IDwgY3VyX2RhdGFfY291 bnQ7Cj4gLQkJICAgIGN1cl9kYXRhX2lkeCsrKSB7Cj4gLQkJCXJlZyA9IHJlYWRsKGRwLT5yZWdf YmFzZSArIEFOQUxPR0lYX0RQX0JVRl9EQVRBXzAKPiAtCQkJCQkJICsgNCAqIGN1cl9kYXRhX2lk eCk7Cj4gLQkJCWRhdGFbc3RhcnRfb2Zmc2V0ICsgY3VyX2RhdGFfaWR4XSA9Cj4gLQkJCQkodW5z aWduZWQgY2hhcilyZWc7Cj4gLQkJfQo+IC0KPiAtCQlzdGFydF9vZmZzZXQgKz0gY3VyX2RhdGFf Y291bnQ7Cj4gLQl9Cj4gLQo+IC0JcmV0dXJuIHJldHZhbDsKPiAtfQo+IC0KPiAtaW50IGFuYWxv Z2l4X2RwX3NlbGVjdF9pMmNfZGV2aWNlKHN0cnVjdCBhbmFsb2dpeF9kcF9kZXZpY2UgKmRwLAo+ IC0JCQkJICB1bnNpZ25lZCBpbnQgZGV2aWNlX2FkZHIsCj4gLQkJCQkgIHVuc2lnbmVkIGludCBy ZWdfYWRkcikKPiAtewo+IC0JdTMyIHJlZzsKPiAtCWludCByZXR2YWw7Cj4gLQo+IC0JLyogU2V0 IEVESUQgZGV2aWNlIGFkZHJlc3MgKi8KPiAtCXJlZyA9IGRldmljZV9hZGRyOwo+IC0Jd3JpdGVs KHJlZywgZHAtPnJlZ19iYXNlICsgQU5BTE9HSVhfRFBfQVVYX0FERFJfN18wKTsKPiAtCXdyaXRl bCgweDAsIGRwLT5yZWdfYmFzZSArIEFOQUxPR0lYX0RQX0FVWF9BRERSXzE1XzgpOwo+IC0Jd3Jp dGVsKDB4MCwgZHAtPnJlZ19iYXNlICsgQU5BTE9HSVhfRFBfQVVYX0FERFJfMTlfMTYpOwo+IC0K PiAtCS8qIFNldCBvZmZzZXQgZnJvbSBiYXNlIGFkZHJlc3Mgb2YgRURJRCBkZXZpY2UgKi8KPiAt CXdyaXRlbChyZWdfYWRkciwgZHAtPnJlZ19iYXNlICsgQU5BTE9HSVhfRFBfQlVGX0RBVEFfMCk7 Cj4gLQo+IC0JLyoKPiAtCSAqIFNldCBJMkMgdHJhbnNhY3Rpb24gYW5kIHdyaXRlIGFkZHJlc3MK PiAtCSAqIElmIGJpdCAzIGlzIDEsIERpc3BsYXlQb3J0IHRyYW5zYWN0aW9uLgo+IC0JICogSWYg Qml0IDMgaXMgMCwgSTJDIHRyYW5zYWN0aW9uLgo+IC0JICovCj4gLQlyZWcgPSBBVVhfVFhfQ09N TV9JMkNfVFJBTlNBQ1RJT04gfCBBVVhfVFhfQ09NTV9NT1QgfAo+IC0JCUFVWF9UWF9DT01NX1dS SVRFOwo+IC0Jd3JpdGVsKHJlZywgZHAtPnJlZ19iYXNlICsgQU5BTE9HSVhfRFBfQVVYX0NIX0NU TF8xKTsKPiAtCj4gLQkvKiBTdGFydCBBVVggdHJhbnNhY3Rpb24gKi8KPiAtCXJldHZhbCA9IGFu YWxvZ2l4X2RwX3N0YXJ0X2F1eF90cmFuc2FjdGlvbihkcCk7Cj4gLQlpZiAocmV0dmFsICE9IDAp Cj4gLQkJZGV2X2RiZyhkcC0+ZGV2LCAiJXM6IEF1eCBUcmFuc2FjdGlvbiBmYWlsIVxuIiwgX19m dW5jX18pOwo+IC0KPiAtCXJldHVybiByZXR2YWw7Cj4gLX0KPiAtCj4gLWludCBhbmFsb2dpeF9k cF9yZWFkX2J5dGVfZnJvbV9pMmMoc3RydWN0IGFuYWxvZ2l4X2RwX2RldmljZSAqZHAsCj4gLQkJ CQkgICB1bnNpZ25lZCBpbnQgZGV2aWNlX2FkZHIsCj4gLQkJCQkgICB1bnNpZ25lZCBpbnQgcmVn X2FkZHIsCj4gLQkJCQkgICB1bnNpZ25lZCBpbnQgKmRhdGEpCj4gLXsKPiAtCXUzMiByZWc7Cj4g LQlpbnQgaTsKPiAtCWludCByZXR2YWw7Cj4gLQo+IC0JZm9yIChpID0gMDsgaSA8IDM7IGkrKykg ewo+IC0JCS8qIENsZWFyIEFVWCBDSCBkYXRhIGJ1ZmZlciAqLwo+IC0JCXJlZyA9IEJVRl9DTFI7 Cj4gLQkJd3JpdGVsKHJlZywgZHAtPnJlZ19iYXNlICsgQU5BTE9HSVhfRFBfQlVGRkVSX0RBVEFf Q1RMKTsKPiAtCj4gLQkJLyogU2VsZWN0IEVESUQgZGV2aWNlICovCj4gLQkJcmV0dmFsID0gYW5h bG9naXhfZHBfc2VsZWN0X2kyY19kZXZpY2UoZHAsIGRldmljZV9hZGRyLAo+IC0JCQkJCQkgICAg ICAgcmVnX2FkZHIpOwo+IC0JCWlmIChyZXR2YWwgIT0gMCkKPiAtCQkJY29udGludWU7Cj4gLQo+ IC0JCS8qCj4gLQkJICogU2V0IEkyQyB0cmFuc2FjdGlvbiBhbmQgcmVhZCBkYXRhCj4gLQkJICog SWYgYml0IDMgaXMgMSwgRGlzcGxheVBvcnQgdHJhbnNhY3Rpb24uCj4gLQkJICogSWYgQml0IDMg aXMgMCwgSTJDIHRyYW5zYWN0aW9uLgo+IC0JCSAqLwo+IC0JCXJlZyA9IEFVWF9UWF9DT01NX0ky Q19UUkFOU0FDVElPTiB8Cj4gLQkJCUFVWF9UWF9DT01NX1JFQUQ7Cj4gLQkJd3JpdGVsKHJlZywg ZHAtPnJlZ19iYXNlICsgQU5BTE9HSVhfRFBfQVVYX0NIX0NUTF8xKTsKPiAtCj4gLQkJLyogU3Rh cnQgQVVYIHRyYW5zYWN0aW9uICovCj4gLQkJcmV0dmFsID0gYW5hbG9naXhfZHBfc3RhcnRfYXV4 X3RyYW5zYWN0aW9uKGRwKTsKPiAtCQlpZiAocmV0dmFsID09IDApCj4gLQkJCWJyZWFrOwo+IC0K PiAtCQlkZXZfZGJnKGRwLT5kZXYsICIlczogQXV4IFRyYW5zYWN0aW9uIGZhaWwhXG4iLCBfX2Z1 bmNfXyk7Cj4gLQl9Cj4gLQo+IC0JLyogUmVhZCBkYXRhICovCj4gLQlpZiAocmV0dmFsID09IDAp Cj4gLQkJKmRhdGEgPSByZWFkbChkcC0+cmVnX2Jhc2UgKyBBTkFMT0dJWF9EUF9CVUZfREFUQV8w KTsKPiAtCj4gLQlyZXR1cm4gcmV0dmFsOwo+IC19Cj4gLQo+IC1pbnQgYW5hbG9naXhfZHBfcmVh ZF9ieXRlc19mcm9tX2kyYyhzdHJ1Y3QgYW5hbG9naXhfZHBfZGV2aWNlICpkcCwKPiAtCQkJCSAg ICB1bnNpZ25lZCBpbnQgZGV2aWNlX2FkZHIsCj4gLQkJCQkgICAgdW5zaWduZWQgaW50IHJlZ19h ZGRyLAo+IC0JCQkJICAgIHVuc2lnbmVkIGludCBjb3VudCwKPiAtCQkJCSAgICB1bnNpZ25lZCBj aGFyIGVkaWRbXSkKPiAtewo+IC0JdTMyIHJlZzsKPiAtCXVuc2lnbmVkIGludCBpLCBqOwo+IC0J dW5zaWduZWQgaW50IGN1cl9kYXRhX2lkeDsKPiAtCXVuc2lnbmVkIGludCBkZWZlciA9IDA7Cj4g LQlpbnQgcmV0dmFsID0gMDsKPiAtCj4gLQlmb3IgKGkgPSAwOyBpIDwgY291bnQ7IGkgKz0gMTYp IHsKPiAtCQlmb3IgKGogPSAwOyBqIDwgMzsgaisrKSB7Cj4gLQkJCS8qIENsZWFyIEFVWCBDSCBk YXRhIGJ1ZmZlciAqLwo+IC0JCQlyZWcgPSBCVUZfQ0xSOwo+IC0JCQl3cml0ZWwocmVnLCBkcC0+ cmVnX2Jhc2UgKyBBTkFMT0dJWF9EUF9CVUZGRVJfREFUQV9DVEwpOwo+IC0KPiAtCQkJLyogU2V0 IG5vcm1hbCBBVVggQ0ggY29tbWFuZCAqLwo+IC0JCQlyZWcgPSByZWFkbChkcC0+cmVnX2Jhc2Ug KyBBTkFMT0dJWF9EUF9BVVhfQ0hfQ1RMXzIpOwo+IC0JCQlyZWcgJj0gfkFERFJfT05MWTsKPiAt CQkJd3JpdGVsKHJlZywgZHAtPnJlZ19iYXNlICsgQU5BTE9HSVhfRFBfQVVYX0NIX0NUTF8yKTsK PiAtCj4gLQkJCS8qCj4gLQkJCSAqIElmIFJ4IHNlbmRzIGRlZmVyLCBUeCBzZW5kcyBvbmx5IHJl YWRzCj4gLQkJCSAqIHJlcXVlc3Qgd2l0aG91dCBzZW5kaW5nIGFkZHJlc3MKPiAtCQkJICovCj4g LQkJCWlmICghZGVmZXIpCj4gLQkJCQlyZXR2YWwgPSBhbmFsb2dpeF9kcF9zZWxlY3RfaTJjX2Rl dmljZShkcCwKPiAtCQkJCQkJZGV2aWNlX2FkZHIsIHJlZ19hZGRyICsgaSk7Cj4gLQkJCWVsc2UK PiAtCQkJCWRlZmVyID0gMDsKPiAtCj4gLQkJCWlmIChyZXR2YWwgPT0gMCkgewo+IC0JCQkJLyoK PiAtCQkJCSAqIFNldCBJMkMgdHJhbnNhY3Rpb24gYW5kIHdyaXRlIGRhdGEKPiAtCQkJCSAqIElm IGJpdCAzIGlzIDEsIERpc3BsYXlQb3J0IHRyYW5zYWN0aW9uLgo+IC0JCQkJICogSWYgQml0IDMg aXMgMCwgSTJDIHRyYW5zYWN0aW9uLgo+IC0JCQkJICovCj4gLQkJCQlyZWcgPSBBVVhfTEVOR1RI KDE2KSB8Cj4gLQkJCQkJQVVYX1RYX0NPTU1fSTJDX1RSQU5TQUNUSU9OIHwKPiAtCQkJCQlBVVhf VFhfQ09NTV9SRUFEOwo+IC0JCQkJd3JpdGVsKHJlZywgZHAtPnJlZ19iYXNlICsKPiAtCQkJCQlB TkFMT0dJWF9EUF9BVVhfQ0hfQ1RMXzEpOwo+IC0KPiAtCQkJCS8qIFN0YXJ0IEFVWCB0cmFuc2Fj dGlvbiAqLwo+IC0JCQkJcmV0dmFsID0gYW5hbG9naXhfZHBfc3RhcnRfYXV4X3RyYW5zYWN0aW9u KGRwKTsKPiAtCQkJCWlmIChyZXR2YWwgPT0gMCkKPiAtCQkJCQlicmVhazsKPiAtCj4gLQkJCQlk ZXZfZGJnKGRwLT5kZXYsICIlczogQXV4IFRyYW5zYWN0aW9uIGZhaWwhXG4iLAo+IC0JCQkJCV9f ZnVuY19fKTsKPiAtCQkJfQo+IC0JCQkvKiBDaGVjayBpZiBSeCBzZW5kcyBkZWZlciAqLwo+IC0J CQlyZWcgPSByZWFkbChkcC0+cmVnX2Jhc2UgKyBBTkFMT0dJWF9EUF9BVVhfUlhfQ09NTSk7Cj4g LQkJCWlmIChyZWcgPT0gQVVYX1JYX0NPTU1fQVVYX0RFRkVSIHx8Cj4gLQkJCSAgICByZWcgPT0g QVVYX1JYX0NPTU1fSTJDX0RFRkVSKSB7Cj4gLQkJCQlkZXZfZXJyKGRwLT5kZXYsICJEZWZlcjog JWRcblxuIiwgcmVnKTsKPiAtCQkJCWRlZmVyID0gMTsKPiAtCQkJfQo+IC0JCX0KPiAtCj4gLQkJ Zm9yIChjdXJfZGF0YV9pZHggPSAwOyBjdXJfZGF0YV9pZHggPCAxNjsgY3VyX2RhdGFfaWR4Kysp IHsKPiAtCQkJcmVnID0gcmVhZGwoZHAtPnJlZ19iYXNlICsgQU5BTE9HSVhfRFBfQlVGX0RBVEFf MAo+IC0JCQkJCQkgKyA0ICogY3VyX2RhdGFfaWR4KTsKPiAtCQkJZWRpZFtpICsgY3VyX2RhdGFf aWR4XSA9ICh1bnNpZ25lZCBjaGFyKXJlZzsKPiAtCQl9Cj4gLQl9Cj4gLQo+IC0JcmV0dXJuIHJl dHZhbDsKPiAtfQo+IC0KPiAgIHZvaWQgYW5hbG9naXhfZHBfc2V0X2xpbmtfYmFuZHdpZHRoKHN0 cnVjdCBhbmFsb2dpeF9kcF9kZXZpY2UgKmRwLCB1MzIgYnd0eXBlKQo+ICAgewo+ICAgCXUzMiBy ZWc7CgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJp LWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBz Oi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1030328AbcHEIX3 (ORCPT ); Fri, 5 Aug 2016 04:23:29 -0400 Received: from lucky1.263xmail.com ([211.157.147.131]:42201 "EHLO lucky1.263xmail.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1756024AbcHEIXX (ORCPT ); Fri, 5 Aug 2016 04:23:23 -0400 X-263anti-spam: KSV:0;BIG:0;ABS:1;DNS:0;ATT:0;SPF:S; X-MAIL-GRAY: 1 X-MAIL-DELIVERY: 0 X-KSVirus-check: 0 X-ABS-CHECKED: 1 X-SKE-CHECKED: 1 X-ADDR-CHECKED: 0 X-RL-SENDER: ykk@rock-chips.com X-FST-TO: dri-devel@lists.freedesktop.org X-SENDER-IP: 103.29.142.67 X-LOGIN-NAME: ykk@rock-chips.com X-UNIQUE-TAG: X-ATTACHMENT-NUM: 0 X-DNS-TYPE: 0 Subject: Re: [PATCH] drm/bridge: analogix_dp: Remove duplicated code To: Tomeu Vizoso , linux-kernel@vger.kernel.org References: <1470291789-23402-1-git-send-email-tomeu.vizoso@collabora.com> Cc: Javier Martinez Canillas , Mika Kahola , Daniel Vetter , David Airlie , dri-devel@lists.freedesktop.org From: Yakir Yang Message-ID: <57A44CEA.9070505@rock-chips.com> Date: Fri, 5 Aug 2016 16:23:06 +0800 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:38.0) Gecko/20100101 Thunderbird/38.8.0 MIME-Version: 1.0 In-Reply-To: <1470291789-23402-1-git-send-email-tomeu.vizoso@collabora.com> Content-Type: text/plain; charset=windows-1252; format=flowed Content-Transfer-Encoding: 7bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Tomeu, o_O Ignore my previous email, seems I make a mistaken about the email format, and mess up the patch format. I have move my previous comments to this one :-) On 08/04/2016 02:23 PM, Tomeu Vizoso wrote: > Remove code for reading the EDID and DPCD fields and use the helpers > instead. > > Besides the obvious code reduction, other helpers are being added to the > core that could be used in this driver and will be good to be able to > use them instead of duplicating them. > > Signed-off-by: Tomeu Vizoso > Cc: Javier Martinez Canillas > Cc: Mika Kahola > Cc: Yakir Yang > Cc: Daniel Vetter > --- > drivers/gpu/drm/bridge/analogix/analogix_dp_core.c | 390 +++++++++++---------- > drivers/gpu/drm/bridge/analogix/analogix_dp_core.h | 39 +-- > drivers/gpu/drm/bridge/analogix/analogix_dp_reg.c | 324 ----------------- > 3 files changed, 201 insertions(+), 552 deletions(-) > > diff --git a/drivers/gpu/drm/bridge/analogix/analogix_dp_core.c b/drivers/gpu/drm/bridge/analogix/analogix_dp_core.c > index 32715daf73cb..c81cb37e56b6 100644 > --- a/drivers/gpu/drm/bridge/analogix/analogix_dp_core.c > +++ b/drivers/gpu/drm/bridge/analogix/analogix_dp_core.c > @@ -31,6 +31,7 @@ > #include > > #include "analogix_dp_core.h" > +#include "analogix_dp_reg.h" > > #define to_dp(nm) container_of(nm, struct analogix_dp_device, nm) > > @@ -97,150 +98,21 @@ static int analogix_dp_detect_hpd(struct analogix_dp_device *dp) > return 0; > } > > -static unsigned char analogix_dp_calc_edid_check_sum(unsigned char *edid_data) > -{ > - int i; > - unsigned char sum = 0; > - > - for (i = 0; i < EDID_BLOCK_LENGTH; i++) > - sum = sum + edid_data[i]; > - > - return sum; > -} > - > -static int analogix_dp_read_edid(struct analogix_dp_device *dp) > -{ > - unsigned char *edid = dp->edid; > - unsigned int extend_block = 0; > - unsigned char sum; > - unsigned char test_vector; > - int retval; > - > - /* > - * EDID device address is 0x50. > - * However, if necessary, you must have set upper address > - * into E-EDID in I2C device, 0x30. > - */ > - > - /* Read Extension Flag, Number of 128-byte EDID extension blocks */ > - retval = analogix_dp_read_byte_from_i2c(dp, I2C_EDID_DEVICE_ADDR, > - EDID_EXTENSION_FLAG, > - &extend_block); > - if (retval) > - return retval; > - > - if (extend_block > 0) { > - dev_dbg(dp->dev, "EDID data includes a single extension!\n"); > - > - /* Read EDID data */ > - retval = analogix_dp_read_bytes_from_i2c(dp, > - I2C_EDID_DEVICE_ADDR, > - EDID_HEADER_PATTERN, > - EDID_BLOCK_LENGTH, > - &edid[EDID_HEADER_PATTERN]); > - if (retval != 0) { > - dev_err(dp->dev, "EDID Read failed!\n"); > - return -EIO; > - } > - sum = analogix_dp_calc_edid_check_sum(edid); > - if (sum != 0) { > - dev_err(dp->dev, "EDID bad checksum!\n"); > - return -EIO; > - } > - > - /* Read additional EDID data */ > - retval = analogix_dp_read_bytes_from_i2c(dp, > - I2C_EDID_DEVICE_ADDR, > - EDID_BLOCK_LENGTH, > - EDID_BLOCK_LENGTH, > - &edid[EDID_BLOCK_LENGTH]); > - if (retval != 0) { > - dev_err(dp->dev, "EDID Read failed!\n"); > - return -EIO; > - } > - sum = analogix_dp_calc_edid_check_sum(&edid[EDID_BLOCK_LENGTH]); > - if (sum != 0) { > - dev_err(dp->dev, "EDID bad checksum!\n"); > - return -EIO; > - } > - > - analogix_dp_read_byte_from_dpcd(dp, DP_TEST_REQUEST, > - &test_vector); > - if (test_vector & DP_TEST_LINK_EDID_READ) { > - analogix_dp_write_byte_to_dpcd(dp, > - DP_TEST_EDID_CHECKSUM, > - edid[EDID_BLOCK_LENGTH + EDID_CHECKSUM]); > - analogix_dp_write_byte_to_dpcd(dp, > - DP_TEST_RESPONSE, > - DP_TEST_EDID_CHECKSUM_WRITE); > - } > - } else { > - dev_info(dp->dev, "EDID data does not include any extensions.\n"); > - > - /* Read EDID data */ > - retval = analogix_dp_read_bytes_from_i2c(dp, > - I2C_EDID_DEVICE_ADDR, EDID_HEADER_PATTERN, > - EDID_BLOCK_LENGTH, &edid[EDID_HEADER_PATTERN]); > - if (retval != 0) { > - dev_err(dp->dev, "EDID Read failed!\n"); > - return -EIO; > - } > - sum = analogix_dp_calc_edid_check_sum(edid); > - if (sum != 0) { > - dev_err(dp->dev, "EDID bad checksum!\n"); > - return -EIO; > - } > - > - analogix_dp_read_byte_from_dpcd(dp, DP_TEST_REQUEST, > - &test_vector); > - if (test_vector & DP_TEST_LINK_EDID_READ) { > - analogix_dp_write_byte_to_dpcd(dp, > - DP_TEST_EDID_CHECKSUM, edid[EDID_CHECKSUM]); > - analogix_dp_write_byte_to_dpcd(dp, > - DP_TEST_RESPONSE, DP_TEST_EDID_CHECKSUM_WRITE); > - } > - } > - > - dev_dbg(dp->dev, "EDID Read success!\n"); > - return 0; > -} > - > -static int analogix_dp_handle_edid(struct analogix_dp_device *dp) > -{ > - u8 buf[12]; > - int i; > - int retval; > - > - /* Read DPCD DP_DPCD_REV~RECEIVE_PORT1_CAP_1 */ > - retval = analogix_dp_read_bytes_from_dpcd(dp, DP_DPCD_REV, 12, buf); > - if (retval) > - return retval; > - > - /* Read EDID */ > - for (i = 0; i < 3; i++) { > - retval = analogix_dp_read_edid(dp); > - if (!retval) > - break; > - } > - > - return retval; > -} > - > static void > analogix_dp_enable_rx_to_enhanced_mode(struct analogix_dp_device *dp, > bool enable) > { > u8 data; > > - analogix_dp_read_byte_from_dpcd(dp, DP_LANE_COUNT_SET, &data); > + drm_dp_dpcd_readb(&dp->aux, DP_LANE_COUNT_SET, &data); > > if (enable) > - analogix_dp_write_byte_to_dpcd(dp, DP_LANE_COUNT_SET, > - DP_LANE_COUNT_ENHANCED_FRAME_EN | > - DPCD_LANE_COUNT_SET(data)); > + drm_dp_dpcd_writeb(&dp->aux, DP_LANE_COUNT_SET, > + DP_LANE_COUNT_ENHANCED_FRAME_EN | > + DPCD_LANE_COUNT_SET(data)); > else > - analogix_dp_write_byte_to_dpcd(dp, DP_LANE_COUNT_SET, > - DPCD_LANE_COUNT_SET(data)); > + drm_dp_dpcd_writeb(&dp->aux, DP_LANE_COUNT_SET, > + DPCD_LANE_COUNT_SET(data)); > } > > static int analogix_dp_is_enhanced_mode_available(struct analogix_dp_device *dp) > @@ -248,7 +120,7 @@ static int analogix_dp_is_enhanced_mode_available(struct analogix_dp_device *dp) > u8 data; > int retval; > > - analogix_dp_read_byte_from_dpcd(dp, DP_MAX_LANE_COUNT, &data); > + drm_dp_dpcd_readb(&dp->aux, DP_MAX_LANE_COUNT, &data); > retval = DPCD_ENHANCED_FRAME_CAP(data); > > return retval; > @@ -267,8 +139,8 @@ static void analogix_dp_training_pattern_dis(struct analogix_dp_device *dp) > { > analogix_dp_set_training_pattern(dp, DP_NONE); > > - analogix_dp_write_byte_to_dpcd(dp, DP_TRAINING_PATTERN_SET, > - DP_TRAINING_PATTERN_DISABLE); > + drm_dp_dpcd_writeb(&dp->aux, DP_TRAINING_PATTERN_SET, > + DP_TRAINING_PATTERN_DISABLE); > } > > static void > @@ -313,8 +185,8 @@ static int analogix_dp_link_start(struct analogix_dp_device *dp) > /* Setup RX configuration */ > buf[0] = dp->link_train.link_rate; > buf[1] = dp->link_train.lane_count; > - retval = analogix_dp_write_bytes_to_dpcd(dp, DP_LINK_BW_SET, 2, buf); > - if (retval) > + retval = drm_dp_dpcd_write(&dp->aux, DP_LINK_BW_SET, buf, 2); > + if (retval < 0) > return retval; > > /* Set TX pre-emphasis to minimum */ > @@ -338,20 +210,22 @@ static int analogix_dp_link_start(struct analogix_dp_device *dp) > analogix_dp_set_training_pattern(dp, TRAINING_PTN1); > > /* Set RX training pattern */ > - retval = analogix_dp_write_byte_to_dpcd(dp, > - DP_TRAINING_PATTERN_SET, > - DP_LINK_SCRAMBLING_DISABLE | DP_TRAINING_PATTERN_1); > - if (retval) > + retval = drm_dp_dpcd_writeb(&dp->aux, DP_TRAINING_PATTERN_SET, > + DP_LINK_SCRAMBLING_DISABLE | > + DP_TRAINING_PATTERN_1); 'DP_TRAINING_PATTERN_1' need align with 'DP_LINK_SCRAMBLING_DISABLE' > + if (retval < 0) > return retval; > > for (lane = 0; lane < lane_count; lane++) > buf[lane] = DP_TRAIN_PRE_EMPH_LEVEL_0 | > DP_TRAIN_VOLTAGE_SWING_LEVEL_0; > > - retval = analogix_dp_write_bytes_to_dpcd(dp, DP_TRAINING_LANE0_SET, > - lane_count, buf); > + retval = drm_dp_dpcd_write(&dp->aux, DP_TRAINING_LANE0_SET, buf, > + lane_count); > + if (retval < 0) > + return retval; > > - return retval; > + return 0; > } > > static unsigned char analogix_dp_get_lane_status(u8 link_status[2], int lane) > @@ -503,25 +377,23 @@ static int analogix_dp_process_clock_recovery(struct analogix_dp_device *dp) > > lane_count = dp->link_train.lane_count; > > - retval = analogix_dp_read_bytes_from_dpcd(dp, > - DP_LANE0_1_STATUS, 2, link_status); > - if (retval) > + retval = drm_dp_dpcd_read(&dp->aux, DP_LANE0_1_STATUS, link_status, 2); > + if (retval < 0) > return retval; > > - retval = analogix_dp_read_bytes_from_dpcd(dp, > - DP_ADJUST_REQUEST_LANE0_1, 2, adjust_request); > - if (retval) > + retval = drm_dp_dpcd_read(&dp->aux, DP_ADJUST_REQUEST_LANE0_1, > + adjust_request, 2); > + if (retval < 0) > return retval; > > if (analogix_dp_clock_recovery_ok(link_status, lane_count) == 0) { > /* set training pattern 2 for EQ */ > analogix_dp_set_training_pattern(dp, TRAINING_PTN2); > > - retval = analogix_dp_write_byte_to_dpcd(dp, > - DP_TRAINING_PATTERN_SET, > - DP_LINK_SCRAMBLING_DISABLE | > - DP_TRAINING_PATTERN_2); > - if (retval) > + retval = drm_dp_dpcd_writeb(&dp->aux, DP_TRAINING_PATTERN_SET, > + DP_LINK_SCRAMBLING_DISABLE | > + DP_TRAINING_PATTERN_2); 'DP_TRAINING_PATTERN_2' need align with 'DP_LINK_SCRAMBLING_DISABLE' > + if (retval < 0) > return retval; > > dev_info(dp->dev, "Link Training Clock Recovery success\n"); > @@ -559,13 +431,12 @@ static int analogix_dp_process_clock_recovery(struct analogix_dp_device *dp) > analogix_dp_set_lane_link_training(dp, > dp->link_train.training_lane[lane], lane); > > - retval = analogix_dp_write_bytes_to_dpcd(dp, > - DP_TRAINING_LANE0_SET, lane_count, > - dp->link_train.training_lane); > - if (retval) > + retval = drm_dp_dpcd_write(&dp->aux, DP_TRAINING_LANE0_SET, > + dp->link_train.training_lane, lane_count); > + if (retval < 0) > return retval; > > - return retval; > + return 0; > } > > static int analogix_dp_process_equalizer_training(struct analogix_dp_device *dp) > @@ -578,9 +449,8 @@ static int analogix_dp_process_equalizer_training(struct analogix_dp_device *dp) > > lane_count = dp->link_train.lane_count; > > - retval = analogix_dp_read_bytes_from_dpcd(dp, > - DP_LANE0_1_STATUS, 2, link_status); > - if (retval) > + retval = drm_dp_dpcd_read(&dp->aux, DP_LANE0_1_STATUS, link_status, 2); > + if (retval < 0) > return retval; > > if (analogix_dp_clock_recovery_ok(link_status, lane_count)) { > @@ -588,14 +458,13 @@ static int analogix_dp_process_equalizer_training(struct analogix_dp_device *dp) > return -EIO; > } > > - retval = analogix_dp_read_bytes_from_dpcd(dp, > - DP_ADJUST_REQUEST_LANE0_1, 2, adjust_request); > - if (retval) > + retval = drm_dp_dpcd_read(&dp->aux, DP_ADJUST_REQUEST_LANE0_1, adjust_request, 2); > + if (retval < 0) > return retval; > > - retval = analogix_dp_read_byte_from_dpcd(dp, > - DP_LANE_ALIGN_STATUS_UPDATED, &link_align); > - if (retval) > + retval = drm_dp_dpcd_readb(&dp->aux, DP_LANE_ALIGN_STATUS_UPDATED, > + &link_align); > + if (retval < 0) > return retval; > > analogix_dp_get_adjust_training_lane(dp, adjust_request); > @@ -636,10 +505,12 @@ static int analogix_dp_process_equalizer_training(struct analogix_dp_device *dp) > analogix_dp_set_lane_link_training(dp, > dp->link_train.training_lane[lane], lane); > > - retval = analogix_dp_write_bytes_to_dpcd(dp, DP_TRAINING_LANE0_SET, > - lane_count, dp->link_train.training_lane); > + retval = drm_dp_dpcd_write(&dp->aux, DP_TRAINING_LANE0_SET, > + dp->link_train.training_lane, lane_count); > + if (retval < 0) > + return retval; > > - return retval; > + return 0; > } > > static void analogix_dp_get_max_rx_bandwidth(struct analogix_dp_device *dp, > @@ -653,7 +524,7 @@ static void analogix_dp_get_max_rx_bandwidth(struct analogix_dp_device *dp, > * For DP rev.1.2, Maximum link rate of Main Link lanes > * 0x06 = 1.62 Gbps, 0x0a = 2.7 Gbps, 0x14 = 5.4Gbps > */ > - analogix_dp_read_byte_from_dpcd(dp, DP_MAX_LINK_RATE, &data); > + drm_dp_dpcd_readb(&dp->aux, DP_MAX_LINK_RATE, &data); > *bandwidth = data; > } > > @@ -666,7 +537,7 @@ static void analogix_dp_get_max_rx_lane_count(struct analogix_dp_device *dp, > * For DP rev.1.1, Maximum number of Main Link lanes > * 0x01 = 1 lane, 0x02 = 2 lanes, 0x04 = 4 lanes > */ > - analogix_dp_read_byte_from_dpcd(dp, DP_MAX_LANE_COUNT, &data); > + drm_dp_dpcd_readb(&dp->aux, DP_MAX_LANE_COUNT, &data); > *lane_count = DPCD_MAX_LANE_COUNT(data); > } > > @@ -835,19 +706,15 @@ static void analogix_dp_enable_scramble(struct analogix_dp_device *dp, > if (enable) { > analogix_dp_enable_scrambling(dp); > > - analogix_dp_read_byte_from_dpcd(dp, DP_TRAINING_PATTERN_SET, > - &data); > - analogix_dp_write_byte_to_dpcd(dp, > - DP_TRAINING_PATTERN_SET, > - (u8)(data & ~DP_LINK_SCRAMBLING_DISABLE)); > + drm_dp_dpcd_readb(&dp->aux, DP_TRAINING_PATTERN_SET, &data); > + drm_dp_dpcd_writeb(&dp->aux, DP_TRAINING_PATTERN_SET, > + (u8)(data & ~DP_LINK_SCRAMBLING_DISABLE)); > } else { > analogix_dp_disable_scrambling(dp); > > - analogix_dp_read_byte_from_dpcd(dp, DP_TRAINING_PATTERN_SET, > - &data); > - analogix_dp_write_byte_to_dpcd(dp, > - DP_TRAINING_PATTERN_SET, > - (u8)(data | DP_LINK_SCRAMBLING_DISABLE)); > + drm_dp_dpcd_readb(&dp->aux, DP_TRAINING_PATTERN_SET, &data); > + drm_dp_dpcd_writeb(&dp->aux, DP_TRAINING_PATTERN_SET, > + (u8)(data | DP_LINK_SCRAMBLING_DISABLE)); > } > } > > @@ -926,12 +793,11 @@ static void analogix_dp_commit(struct analogix_dp_device *dp) > int analogix_dp_get_modes(struct drm_connector *connector) > { > struct analogix_dp_device *dp = to_dp(connector); > - struct edid *edid = (struct edid *)dp->edid; > int num_modes = 0; > > - if (analogix_dp_handle_edid(dp) == 0) { > - drm_mode_connector_update_edid_property(&dp->connector, edid); > - num_modes += drm_add_edid_modes(&dp->connector, edid); > + if ((dp->edid = drm_get_edid(connector, &dp->aux.ddc))) { > + drm_mode_connector_update_edid_property(&dp->connector, dp->edid); > + num_modes += drm_add_edid_modes(&dp->connector, dp->edid); > } You could remove the '->edid' variable from struct analogix_dp_device, cause we don't need this information at other places. You need to free the edid after parsed it, cause each time when you call drm_get_edid() helper, it would malloc a new space for 'edid'. Besides I would prefer move the statement out of the condition. struct edid *edid; edid = drm_get_edid(connector, &dp->aux.ddc); if (edid) { drm_mode_connector_update_edid_property(&dp->connector, dp->edid); num_modes += drm_add_edid_modes(&dp->connector, dp->edid); kfree(edid); } > > if (dp->plat_data->panel) > @@ -984,6 +850,138 @@ static const struct drm_connector_funcs analogix_dp_connector_funcs = { > .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, > }; > > +static ssize_t analogix_dpaux_transfer(struct drm_dp_aux *aux, > + struct drm_dp_aux_msg *msg) > +{ > + struct analogix_dp_device *dp = to_dp(aux); > + u32 reg; > + u8 *buffer = msg->buffer; > + int timeout_loop = 0; > + unsigned int i; > + int retval = 0; > + > + /* Buffer size of AUX CH is 16 bytes */ > + if (WARN_ON(msg->size > 16)) > + return -E2BIG; > + > + /* Clear AUX CH data buffer */ > + reg = BUF_CLR; > + writel(reg, dp->reg_base + ANALOGIX_DP_BUFFER_DATA_CTL); > + > + switch (msg->request & ~DP_AUX_I2C_MOT) { > + case DP_AUX_I2C_WRITE: > + reg = AUX_TX_COMM_WRITE | AUX_TX_COMM_I2C_TRANSACTION; > + if (msg->request & DP_AUX_I2C_MOT) > + reg |= AUX_TX_COMM_MOT; > + > + break; > + > + case DP_AUX_I2C_READ: > + reg = AUX_TX_COMM_READ | AUX_TX_COMM_I2C_TRANSACTION; > + if (msg->request & DP_AUX_I2C_MOT) > + reg |= AUX_TX_COMM_MOT; > + > + break; > + > + case DP_AUX_NATIVE_WRITE: > + reg = AUX_TX_COMM_WRITE | AUX_TX_COMM_DP_TRANSACTION; > + break; > + > + case DP_AUX_NATIVE_READ: > + reg = AUX_TX_COMM_READ | AUX_TX_COMM_DP_TRANSACTION; > + break; > + > + default: > + return -EINVAL; > + } > + > + reg |= AUX_LENGTH(msg->size); > + writel(reg, dp->reg_base + ANALOGIX_DP_AUX_CH_CTL_1); > + > + /* Select DPCD device address */ > + reg = AUX_ADDR_7_0(msg->address); > + writel(reg, dp->reg_base + ANALOGIX_DP_AUX_ADDR_7_0); > + reg = AUX_ADDR_15_8(msg->address); > + writel(reg, dp->reg_base + ANALOGIX_DP_AUX_ADDR_15_8); > + reg = AUX_ADDR_19_16(msg->address); > + writel(reg, dp->reg_base + ANALOGIX_DP_AUX_ADDR_19_16); > + > + if ((msg->request & DP_AUX_I2C_READ) == 0) { > + for (i = 0; i < msg->size; i++) { > + reg = buffer[i]; > + writel(reg, dp->reg_base + ANALOGIX_DP_BUF_DATA_0 + > + 4 * i); > + retval++; > + } > + } > + > + /* Enable AUX CH operation */ > + reg = 0; > + > + /* Zero-sized messages specify address-only transactions. */ > + if (msg->size < 1) > + reg |= ADDR_ONLY; > + > + reg |= AUX_EN; > + writel(reg, dp->reg_base + ANALOGIX_DP_AUX_CH_CTL_2); > + > + /* Is AUX CH command reply received? */ > + /* TODO: Wait for an interrupt instead of looping? */ > + reg = readl(dp->reg_base + ANALOGIX_DP_INT_STA); > + while (!(reg & RPLY_RECEIV)) { > + timeout_loop++; > + if (DP_TIMEOUT_LOOP_COUNT < timeout_loop) { > + dev_err(dp->dev, "AUX CH command reply failed!\n"); > + return -ETIMEDOUT; > + } > + reg = readl(dp->reg_base + ANALOGIX_DP_INT_STA); > + usleep_range(10, 11); > + } > + > + /* Clear interrupt source for AUX CH command reply */ > + writel(RPLY_RECEIV, dp->reg_base + ANALOGIX_DP_INT_STA); > + > + /* Clear interrupt source for AUX CH access error */ > + reg = readl(dp->reg_base + ANALOGIX_DP_INT_STA); > + if (reg & AUX_ERR) { > + writel(AUX_ERR, dp->reg_base + ANALOGIX_DP_INT_STA); > + return -EREMOTEIO; > + } > + > + /* Check AUX CH error access status */ > + reg = readl(dp->reg_base + ANALOGIX_DP_AUX_CH_STA); > + if ((reg & AUX_STATUS_MASK) != 0) { > + dev_err(dp->dev, "AUX CH error happens: %d\n\n", > + reg & AUX_STATUS_MASK); > + return -EREMOTEIO; > + } > + > + if (msg->request & DP_AUX_I2C_READ) { > + for (i = 0; i < msg->size; i++) { > + reg = readl(dp->reg_base + ANALOGIX_DP_BUF_DATA_0 + > + 4 * i); > + buffer[i] = (unsigned char)reg; > + retval++; > + } > + } > + > + /* Check if Rx sends defer */ > + reg = readl(dp->reg_base + ANALOGIX_DP_AUX_RX_COMM); > + if (reg == AUX_RX_COMM_AUX_DEFER) > + msg->reply = DP_AUX_NATIVE_REPLY_DEFER; > + else if (reg == AUX_RX_COMM_I2C_DEFER) > + msg->reply = DP_AUX_I2C_REPLY_DEFER; > + else if ((msg->request & ~DP_AUX_I2C_MOT) == DP_AUX_I2C_WRITE || > + (msg->request & ~DP_AUX_I2C_MOT) == DP_AUX_I2C_READ) > + msg->reply = DP_AUX_I2C_REPLY_ACK; > + else if ((msg->request & ~DP_AUX_I2C_MOT) == DP_AUX_NATIVE_WRITE || > + (msg->request & ~DP_AUX_I2C_MOT) == DP_AUX_NATIVE_READ) > + msg->reply = DP_AUX_NATIVE_REPLY_ACK; > + > + return retval; > +} > + Would you like to move this function to 'analogix_dp_reg.c' ? > + > static int analogix_dp_bridge_attach(struct drm_bridge *bridge) > { > struct analogix_dp_device *dp = bridge->driver_private; > @@ -1355,6 +1353,14 @@ int analogix_dp_bind(struct device *dev, struct drm_device *drm_dev, > dp->drm_dev = drm_dev; > dp->encoder = dp->plat_data->encoder; > > + dp->aux.name = "DP-AUX"; > + dp->aux.transfer = analogix_dpaux_transfer; > + dp->aux.dev = &pdev->dev; > + > + ret = drm_dp_aux_register(&dp->aux); > + if (ret) > + goto err_disable_pm_runtime; > + > ret = analogix_dp_create_bridge(drm_dev, dp); > if (ret) { > DRM_ERROR("failed to create bridge (%d)\n", ret); > @@ -1384,6 +1390,8 @@ void analogix_dp_unbind(struct device *dev, struct device *master, > } > > pm_runtime_disable(dev); > + > + kfree(dp->edid); Could remove this free code. Thanks, - Yakir > } > EXPORT_SYMBOL_GPL(analogix_dp_unbind); > > diff --git a/drivers/gpu/drm/bridge/analogix/analogix_dp_core.h b/drivers/gpu/drm/bridge/analogix/analogix_dp_core.h > index b45638043ec4..27eb27a71802 100644 > --- a/drivers/gpu/drm/bridge/analogix/analogix_dp_core.h > +++ b/drivers/gpu/drm/bridge/analogix/analogix_dp_core.h > @@ -20,15 +20,6 @@ > #define MAX_CR_LOOP 5 > #define MAX_EQ_LOOP 5 > > -/* I2C EDID Chip ID, Slave Address */ > -#define I2C_EDID_DEVICE_ADDR 0x50 > -#define I2C_E_EDID_DEVICE_ADDR 0x30 > - > -#define EDID_BLOCK_LENGTH 0x80 > -#define EDID_HEADER_PATTERN 0x00 > -#define EDID_EXTENSION_FLAG 0x7e > -#define EDID_CHECKSUM 0x7f > - > /* DP_MAX_LANE_COUNT */ > #define DPCD_ENHANCED_FRAME_CAP(x) (((x) >> 7) & 0x1) > #define DPCD_MAX_LANE_COUNT(x) ((x) & 0x1f) > @@ -166,6 +157,7 @@ struct analogix_dp_device { > struct drm_device *drm_dev; > struct drm_connector connector; > struct drm_bridge *bridge; > + struct drm_dp_aux aux; > struct clk *clock; > unsigned int irq; > void __iomem *reg_base; > @@ -176,7 +168,7 @@ struct analogix_dp_device { > int dpms_mode; > int hpd_gpio; > bool force_hpd; > - unsigned char edid[EDID_BLOCK_LENGTH * 2]; > + struct edid *edid; > > struct analogix_dp_plat_data *plat_data; > }; > @@ -206,33 +198,6 @@ void analogix_dp_reset_aux(struct analogix_dp_device *dp); > void analogix_dp_init_aux(struct analogix_dp_device *dp); > int analogix_dp_get_plug_in_status(struct analogix_dp_device *dp); > void analogix_dp_enable_sw_function(struct analogix_dp_device *dp); > -int analogix_dp_start_aux_transaction(struct analogix_dp_device *dp); > -int analogix_dp_write_byte_to_dpcd(struct analogix_dp_device *dp, > - unsigned int reg_addr, > - unsigned char data); > -int analogix_dp_read_byte_from_dpcd(struct analogix_dp_device *dp, > - unsigned int reg_addr, > - unsigned char *data); > -int analogix_dp_write_bytes_to_dpcd(struct analogix_dp_device *dp, > - unsigned int reg_addr, > - unsigned int count, > - unsigned char data[]); > -int analogix_dp_read_bytes_from_dpcd(struct analogix_dp_device *dp, > - unsigned int reg_addr, > - unsigned int count, > - unsigned char data[]); > -int analogix_dp_select_i2c_device(struct analogix_dp_device *dp, > - unsigned int device_addr, > - unsigned int reg_addr); > -int analogix_dp_read_byte_from_i2c(struct analogix_dp_device *dp, > - unsigned int device_addr, > - unsigned int reg_addr, > - unsigned int *data); > -int analogix_dp_read_bytes_from_i2c(struct analogix_dp_device *dp, > - unsigned int device_addr, > - unsigned int reg_addr, > - unsigned int count, > - unsigned char edid[]); > void analogix_dp_set_link_bandwidth(struct analogix_dp_device *dp, u32 bwtype); > void analogix_dp_get_link_bandwidth(struct analogix_dp_device *dp, u32 *bwtype); > void analogix_dp_set_lane_count(struct analogix_dp_device *dp, u32 count); > diff --git a/drivers/gpu/drm/bridge/analogix/analogix_dp_reg.c b/drivers/gpu/drm/bridge/analogix/analogix_dp_reg.c > index 48030f0cf497..eac61aa4224f 100644 > --- a/drivers/gpu/drm/bridge/analogix/analogix_dp_reg.c > +++ b/drivers/gpu/drm/bridge/analogix/analogix_dp_reg.c > @@ -585,330 +585,6 @@ int analogix_dp_write_byte_to_dpcd(struct analogix_dp_device *dp, > return retval; > } > > -int analogix_dp_read_byte_from_dpcd(struct analogix_dp_device *dp, > - unsigned int reg_addr, > - unsigned char *data) > -{ > - u32 reg; > - int i; > - int retval; > - > - for (i = 0; i < 3; i++) { > - /* Clear AUX CH data buffer */ > - reg = BUF_CLR; > - writel(reg, dp->reg_base + ANALOGIX_DP_BUFFER_DATA_CTL); > - > - /* Select DPCD device address */ > - reg = AUX_ADDR_7_0(reg_addr); > - writel(reg, dp->reg_base + ANALOGIX_DP_AUX_ADDR_7_0); > - reg = AUX_ADDR_15_8(reg_addr); > - writel(reg, dp->reg_base + ANALOGIX_DP_AUX_ADDR_15_8); > - reg = AUX_ADDR_19_16(reg_addr); > - writel(reg, dp->reg_base + ANALOGIX_DP_AUX_ADDR_19_16); > - > - /* > - * Set DisplayPort transaction and read 1 byte > - * If bit 3 is 1, DisplayPort transaction. > - * If Bit 3 is 0, I2C transaction. > - */ > - reg = AUX_TX_COMM_DP_TRANSACTION | AUX_TX_COMM_READ; > - writel(reg, dp->reg_base + ANALOGIX_DP_AUX_CH_CTL_1); > - > - /* Start AUX transaction */ > - retval = analogix_dp_start_aux_transaction(dp); > - if (retval == 0) > - break; > - > - dev_dbg(dp->dev, "%s: Aux Transaction fail!\n", __func__); > - } > - > - /* Read data buffer */ > - reg = readl(dp->reg_base + ANALOGIX_DP_BUF_DATA_0); > - *data = (unsigned char)(reg & 0xff); > - > - return retval; > -} > - > -int analogix_dp_write_bytes_to_dpcd(struct analogix_dp_device *dp, > - unsigned int reg_addr, > - unsigned int count, > - unsigned char data[]) > -{ > - u32 reg; > - unsigned int start_offset; > - unsigned int cur_data_count; > - unsigned int cur_data_idx; > - int i; > - int retval = 0; > - > - /* Clear AUX CH data buffer */ > - reg = BUF_CLR; > - writel(reg, dp->reg_base + ANALOGIX_DP_BUFFER_DATA_CTL); > - > - start_offset = 0; > - while (start_offset < count) { > - /* Buffer size of AUX CH is 16 * 4bytes */ > - if ((count - start_offset) > 16) > - cur_data_count = 16; > - else > - cur_data_count = count - start_offset; > - > - for (i = 0; i < 3; i++) { > - /* Select DPCD device address */ > - reg = AUX_ADDR_7_0(reg_addr + start_offset); > - writel(reg, dp->reg_base + ANALOGIX_DP_AUX_ADDR_7_0); > - reg = AUX_ADDR_15_8(reg_addr + start_offset); > - writel(reg, dp->reg_base + ANALOGIX_DP_AUX_ADDR_15_8); > - reg = AUX_ADDR_19_16(reg_addr + start_offset); > - writel(reg, dp->reg_base + ANALOGIX_DP_AUX_ADDR_19_16); > - > - for (cur_data_idx = 0; cur_data_idx < cur_data_count; > - cur_data_idx++) { > - reg = data[start_offset + cur_data_idx]; > - writel(reg, dp->reg_base + > - ANALOGIX_DP_BUF_DATA_0 + > - 4 * cur_data_idx); > - } > - > - /* > - * Set DisplayPort transaction and write > - * If bit 3 is 1, DisplayPort transaction. > - * If Bit 3 is 0, I2C transaction. > - */ > - reg = AUX_LENGTH(cur_data_count) | > - AUX_TX_COMM_DP_TRANSACTION | AUX_TX_COMM_WRITE; > - writel(reg, dp->reg_base + ANALOGIX_DP_AUX_CH_CTL_1); > - > - /* Start AUX transaction */ > - retval = analogix_dp_start_aux_transaction(dp); > - if (retval == 0) > - break; > - > - dev_dbg(dp->dev, "%s: Aux Transaction fail!\n", > - __func__); > - } > - > - start_offset += cur_data_count; > - } > - > - return retval; > -} > - > -int analogix_dp_read_bytes_from_dpcd(struct analogix_dp_device *dp, > - unsigned int reg_addr, > - unsigned int count, > - unsigned char data[]) > -{ > - u32 reg; > - unsigned int start_offset; > - unsigned int cur_data_count; > - unsigned int cur_data_idx; > - int i; > - int retval = 0; > - > - /* Clear AUX CH data buffer */ > - reg = BUF_CLR; > - writel(reg, dp->reg_base + ANALOGIX_DP_BUFFER_DATA_CTL); > - > - start_offset = 0; > - while (start_offset < count) { > - /* Buffer size of AUX CH is 16 * 4bytes */ > - if ((count - start_offset) > 16) > - cur_data_count = 16; > - else > - cur_data_count = count - start_offset; > - > - /* AUX CH Request Transaction process */ > - for (i = 0; i < 3; i++) { > - /* Select DPCD device address */ > - reg = AUX_ADDR_7_0(reg_addr + start_offset); > - writel(reg, dp->reg_base + ANALOGIX_DP_AUX_ADDR_7_0); > - reg = AUX_ADDR_15_8(reg_addr + start_offset); > - writel(reg, dp->reg_base + ANALOGIX_DP_AUX_ADDR_15_8); > - reg = AUX_ADDR_19_16(reg_addr + start_offset); > - writel(reg, dp->reg_base + ANALOGIX_DP_AUX_ADDR_19_16); > - > - /* > - * Set DisplayPort transaction and read > - * If bit 3 is 1, DisplayPort transaction. > - * If Bit 3 is 0, I2C transaction. > - */ > - reg = AUX_LENGTH(cur_data_count) | > - AUX_TX_COMM_DP_TRANSACTION | AUX_TX_COMM_READ; > - writel(reg, dp->reg_base + ANALOGIX_DP_AUX_CH_CTL_1); > - > - /* Start AUX transaction */ > - retval = analogix_dp_start_aux_transaction(dp); > - if (retval == 0) > - break; > - > - dev_dbg(dp->dev, "%s: Aux Transaction fail!\n", > - __func__); > - } > - > - for (cur_data_idx = 0; cur_data_idx < cur_data_count; > - cur_data_idx++) { > - reg = readl(dp->reg_base + ANALOGIX_DP_BUF_DATA_0 > - + 4 * cur_data_idx); > - data[start_offset + cur_data_idx] = > - (unsigned char)reg; > - } > - > - start_offset += cur_data_count; > - } > - > - return retval; > -} > - > -int analogix_dp_select_i2c_device(struct analogix_dp_device *dp, > - unsigned int device_addr, > - unsigned int reg_addr) > -{ > - u32 reg; > - int retval; > - > - /* Set EDID device address */ > - reg = device_addr; > - writel(reg, dp->reg_base + ANALOGIX_DP_AUX_ADDR_7_0); > - writel(0x0, dp->reg_base + ANALOGIX_DP_AUX_ADDR_15_8); > - writel(0x0, dp->reg_base + ANALOGIX_DP_AUX_ADDR_19_16); > - > - /* Set offset from base address of EDID device */ > - writel(reg_addr, dp->reg_base + ANALOGIX_DP_BUF_DATA_0); > - > - /* > - * Set I2C transaction and write address > - * If bit 3 is 1, DisplayPort transaction. > - * If Bit 3 is 0, I2C transaction. > - */ > - reg = AUX_TX_COMM_I2C_TRANSACTION | AUX_TX_COMM_MOT | > - AUX_TX_COMM_WRITE; > - writel(reg, dp->reg_base + ANALOGIX_DP_AUX_CH_CTL_1); > - > - /* Start AUX transaction */ > - retval = analogix_dp_start_aux_transaction(dp); > - if (retval != 0) > - dev_dbg(dp->dev, "%s: Aux Transaction fail!\n", __func__); > - > - return retval; > -} > - > -int analogix_dp_read_byte_from_i2c(struct analogix_dp_device *dp, > - unsigned int device_addr, > - unsigned int reg_addr, > - unsigned int *data) > -{ > - u32 reg; > - int i; > - int retval; > - > - for (i = 0; i < 3; i++) { > - /* Clear AUX CH data buffer */ > - reg = BUF_CLR; > - writel(reg, dp->reg_base + ANALOGIX_DP_BUFFER_DATA_CTL); > - > - /* Select EDID device */ > - retval = analogix_dp_select_i2c_device(dp, device_addr, > - reg_addr); > - if (retval != 0) > - continue; > - > - /* > - * Set I2C transaction and read data > - * If bit 3 is 1, DisplayPort transaction. > - * If Bit 3 is 0, I2C transaction. > - */ > - reg = AUX_TX_COMM_I2C_TRANSACTION | > - AUX_TX_COMM_READ; > - writel(reg, dp->reg_base + ANALOGIX_DP_AUX_CH_CTL_1); > - > - /* Start AUX transaction */ > - retval = analogix_dp_start_aux_transaction(dp); > - if (retval == 0) > - break; > - > - dev_dbg(dp->dev, "%s: Aux Transaction fail!\n", __func__); > - } > - > - /* Read data */ > - if (retval == 0) > - *data = readl(dp->reg_base + ANALOGIX_DP_BUF_DATA_0); > - > - return retval; > -} > - > -int analogix_dp_read_bytes_from_i2c(struct analogix_dp_device *dp, > - unsigned int device_addr, > - unsigned int reg_addr, > - unsigned int count, > - unsigned char edid[]) > -{ > - u32 reg; > - unsigned int i, j; > - unsigned int cur_data_idx; > - unsigned int defer = 0; > - int retval = 0; > - > - for (i = 0; i < count; i += 16) { > - for (j = 0; j < 3; j++) { > - /* Clear AUX CH data buffer */ > - reg = BUF_CLR; > - writel(reg, dp->reg_base + ANALOGIX_DP_BUFFER_DATA_CTL); > - > - /* Set normal AUX CH command */ > - reg = readl(dp->reg_base + ANALOGIX_DP_AUX_CH_CTL_2); > - reg &= ~ADDR_ONLY; > - writel(reg, dp->reg_base + ANALOGIX_DP_AUX_CH_CTL_2); > - > - /* > - * If Rx sends defer, Tx sends only reads > - * request without sending address > - */ > - if (!defer) > - retval = analogix_dp_select_i2c_device(dp, > - device_addr, reg_addr + i); > - else > - defer = 0; > - > - if (retval == 0) { > - /* > - * Set I2C transaction and write data > - * If bit 3 is 1, DisplayPort transaction. > - * If Bit 3 is 0, I2C transaction. > - */ > - reg = AUX_LENGTH(16) | > - AUX_TX_COMM_I2C_TRANSACTION | > - AUX_TX_COMM_READ; > - writel(reg, dp->reg_base + > - ANALOGIX_DP_AUX_CH_CTL_1); > - > - /* Start AUX transaction */ > - retval = analogix_dp_start_aux_transaction(dp); > - if (retval == 0) > - break; > - > - dev_dbg(dp->dev, "%s: Aux Transaction fail!\n", > - __func__); > - } > - /* Check if Rx sends defer */ > - reg = readl(dp->reg_base + ANALOGIX_DP_AUX_RX_COMM); > - if (reg == AUX_RX_COMM_AUX_DEFER || > - reg == AUX_RX_COMM_I2C_DEFER) { > - dev_err(dp->dev, "Defer: %d\n\n", reg); > - defer = 1; > - } > - } > - > - for (cur_data_idx = 0; cur_data_idx < 16; cur_data_idx++) { > - reg = readl(dp->reg_base + ANALOGIX_DP_BUF_DATA_0 > - + 4 * cur_data_idx); > - edid[i + cur_data_idx] = (unsigned char)reg; > - } > - } > - > - return retval; > -} > - > void analogix_dp_set_link_bandwidth(struct analogix_dp_device *dp, u32 bwtype) > { > u32 reg;